No OneTemporary
Actions

Size

7 MB

Referenced Files

None

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/cddl/share/zfs/compatibility.d/Makefile b/cddl/share/zfs/compatibility.d/Makefile
	index 8bc18bcd6391..255f4a3542b3 100644
	--- a/cddl/share/zfs/compatibility.d/Makefile
	+++ b/cddl/share/zfs/compatibility.d/Makefile
	@@ -1,49 +1,53 @@
	# $FreeBSD$

	ZFSTOP= ${SRCTOP}/sys/contrib/openzfs

	.PATH: ${ZFSTOP}/cmd/zpool/compatibility.d

	FILES= \
	compat-2018 \
	compat-2019 \
	compat-2020 \
	compat-2021 \
	freebsd-11.0 \
	freebsd-11.2 \
	freebsd-11.3 \
	freenas-9.10.2 \
	grub2 \
	openzfsonosx-1.7.0 \
	openzfsonosx-1.8.1 \
	openzfsonosx-1.9.3 \
	openzfs-2.0-freebsd \
	openzfs-2.0-linux \
	+ openzfs-2.1-freebsd \
	+ openzfs-2.1-linux \
	+ zol-0.6.1 \
	+ zol-0.6.4 \
	zol-0.6.5 \
	zol-0.7 \
	zol-0.8

	FILESDIR= ${SHAREDIR}/zfs/compatibility.d

	LINKS= \
	${FILESDIR}/compat-2018 ${FILESDIR}/2018 \
	${FILESDIR}/compat-2019 ${FILESDIR}/2019 \
	${FILESDIR}/compat-2020 ${FILESDIR}/2020 \
	${FILESDIR}/compat-2021 ${FILESDIR}/2021 \
	${FILESDIR}/freebsd-11.0 ${FILESDIR}/freebsd-11.1 \
	${FILESDIR}/freebsd-11.0 ${FILESDIR}/freenas-11.0 \
	${FILESDIR}/freebsd-11.2 ${FILESDIR}/freenas-11.2 \
	${FILESDIR}/freebsd-11.3 ${FILESDIR}/freebsd-11.4 \
	${FILESDIR}/freebsd-11.3 ${FILESDIR}/freebsd-12.0 \
	${FILESDIR}/freebsd-11.3 ${FILESDIR}/freebsd-12.1 \
	${FILESDIR}/freebsd-11.3 ${FILESDIR}/freebsd-12.2 \
	${FILESDIR}/freebsd-11.3 ${FILESDIR}/freenas-11.3 \
	${FILESDIR}/freenas-11.0 ${FILESDIR}/freenas-11.1 \
	${FILESDIR}/openzfsonosx-1.9.3 ${FILESDIR}/openzfsonosx-1.9.4 \
	${FILESDIR}/openzfs-2.0-freebsd ${FILESDIR}/truenas-12.0 \
	${FILESDIR}/zol-0.7 ${FILESDIR}/ubuntu-18.04 \
	${FILESDIR}/zol-0.8 ${FILESDIR}/ubuntu-20.04

	LINKMODE= ${NOBINMODE}

	.include <bsd.prog.mk>
	diff --git a/sys/contrib/openzfs/.github/workflows/zfs-tests-functional.yml b/sys/contrib/openzfs/.github/workflows/zfs-tests-functional.yml
	index 631f174b74fd..79973123fd41 100644
	--- a/sys/contrib/openzfs/.github/workflows/zfs-tests-functional.yml
	+++ b/sys/contrib/openzfs/.github/workflows/zfs-tests-functional.yml
	@@ -1,64 +1,70 @@
	name: zfs-tests-functional

	on:
	push:
	pull_request:

	jobs:
	tests-functional-ubuntu:
	strategy:
	fail-fast: false
	matrix:
	os: [18.04, 20.04]
	runs-on: ubuntu-${{ matrix.os }}
	steps:
	- uses: actions/checkout@v2
	with:
	ref: ${{ github.event.pull_request.head.sha }}
	- name: Install dependencies
	run: \|
	sudo apt-get update
	sudo apt-get install --yes -qq build-essential autoconf libtool gdb lcov \
	git alien fakeroot wget curl bc fio acl \
	sysstat mdadm lsscsi parted gdebi attr dbench watchdog ksh \
	nfs-kernel-server samba rng-tools xz-utils \
	zlib1g-dev uuid-dev libblkid-dev libselinux-dev \
	xfslibs-dev libattr1-dev libacl1-dev libudev-dev libdevmapper-dev \
	libssl-dev libffi-dev libaio-dev libelf-dev libmount-dev \
	libpam0g-dev pamtester python-dev python-setuptools python-cffi \
	python3 python3-dev python3-setuptools python3-cffi
	- name: Autogen.sh
	run: \|
	sh autogen.sh
	- name: Configure
	run: \|
	./configure --enable-debug --enable-debuginfo
	- name: Make
	run: \|
	make --no-print-directory -s pkg-utils pkg-kmod
	- name: Install
	run: \|
	sudo dpkg -i *.deb
	# Update order of directories to search for modules, otherwise
	# Ubuntu will load kernel-shipped ones.
	sudo sed -i.bak 's/updates/extra updates/' /etc/depmod.d/ubuntu.conf
	sudo depmod
	sudo modprobe zfs
	+ # Workaround to provide additional free space for testing.
	+ # https://github.com/actions/virtual-environments/issues/2840
	+ sudo rm -rf /usr/share/dotnet
	+ sudo rm -rf /opt/ghc
	+ sudo rm -rf "/usr/local/share/boost"
	+ sudo rm -rf "$AGENT_TOOLSDIRECTORY"
	- name: Tests
	run: \|
	/usr/share/zfs/zfs-tests.sh -v -s 3G
	- name: Prepare artifacts
	if: failure()
	run: \|
	RESULTS_PATH=$(readlink -f /var/tmp/test_results/current)
	sudo dmesg > $RESULTS_PATH/dmesg
	sudo cp /var/log/syslog $RESULTS_PATH/
	sudo chmod +r $RESULTS_PATH/*
	# Replace ':' in dir names, actions/upload-artifact doesn't support it
	for f in $(find $RESULTS_PATH -name ':'); do mv "$f" "${f//:/__}"; done
	- uses: actions/upload-artifact@v2
	if: failure()
	with:
	name: Test logs Ubuntu-${{ matrix.os }}
	path: /var/tmp/test_results/20*/
	if-no-files-found: ignore
	diff --git a/sys/contrib/openzfs/.github/workflows/zfs-tests-sanity.yml b/sys/contrib/openzfs/.github/workflows/zfs-tests-sanity.yml
	index e03399757575..df089c81f4ce 100644
	--- a/sys/contrib/openzfs/.github/workflows/zfs-tests-sanity.yml
	+++ b/sys/contrib/openzfs/.github/workflows/zfs-tests-sanity.yml
	@@ -1,60 +1,66 @@
	name: zfs-tests-sanity

	on:
	push:
	pull_request:

	jobs:
	tests:
	runs-on: ubuntu-latest
	steps:
	- uses: actions/checkout@v2
	with:
	ref: ${{ github.event.pull_request.head.sha }}
	- name: Install dependencies
	run: \|
	sudo apt-get update
	sudo apt-get install --yes -qq build-essential autoconf libtool gdb lcov \
	git alien fakeroot wget curl bc fio acl \
	sysstat mdadm lsscsi parted gdebi attr dbench watchdog ksh \
	nfs-kernel-server samba rng-tools xz-utils \
	zlib1g-dev uuid-dev libblkid-dev libselinux-dev \
	xfslibs-dev libattr1-dev libacl1-dev libudev-dev libdevmapper-dev \
	libssl-dev libffi-dev libaio-dev libelf-dev libmount-dev \
	libpam0g-dev pamtester python-dev python-setuptools python-cffi \
	python3 python3-dev python3-setuptools python3-cffi
	- name: Autogen.sh
	run: \|
	sh autogen.sh
	- name: Configure
	run: \|
	./configure --enable-debug --enable-debuginfo
	- name: Make
	run: \|
	make --no-print-directory -s pkg-utils pkg-kmod
	- name: Install
	run: \|
	sudo dpkg -i *.deb
	# Update order of directories to search for modules, otherwise
	# Ubuntu will load kernel-shipped ones.
	sudo sed -i.bak 's/updates/extra updates/' /etc/depmod.d/ubuntu.conf
	sudo depmod
	sudo modprobe zfs
	+ # Workaround to provide additional free space for testing.
	+ # https://github.com/actions/virtual-environments/issues/2840
	+ sudo rm -rf /usr/share/dotnet
	+ sudo rm -rf /opt/ghc
	+ sudo rm -rf "/usr/local/share/boost"
	+ sudo rm -rf "$AGENT_TOOLSDIRECTORY"
	- name: Tests
	run: \|
	/usr/share/zfs/zfs-tests.sh -v -s 3G -r sanity
	- name: Prepare artifacts
	if: failure()
	run: \|
	RESULTS_PATH=$(readlink -f /var/tmp/test_results/current)
	sudo dmesg > $RESULTS_PATH/dmesg
	sudo cp /var/log/syslog $RESULTS_PATH/
	sudo chmod +r $RESULTS_PATH/*
	# Replace ':' in dir names, actions/upload-artifact doesn't support it
	for f in $(find $RESULTS_PATH -name ':'); do mv "$f" "${f//:/__}"; done
	- uses: actions/upload-artifact@v2
	if: failure()
	with:
	name: Test logs
	path: /var/tmp/test_results/20*/
	if-no-files-found: ignore
	diff --git a/sys/contrib/openzfs/.gitmodules b/sys/contrib/openzfs/.gitmodules
	index d400f10a7e63..9eaa2b0495dc 100644
	--- a/sys/contrib/openzfs/.gitmodules
	+++ b/sys/contrib/openzfs/.gitmodules
	@@ -1,3 +1,3 @@
	[submodule "scripts/zfs-images"]
	path = scripts/zfs-images
	- url = https://github.com/zfsonlinux/zfs-images
	+ url = https://github.com/openzfs/zfs-images
	diff --git a/sys/contrib/openzfs/META b/sys/contrib/openzfs/META
	index 480849288719..9181ce7bd4a2 100644
	--- a/sys/contrib/openzfs/META
	+++ b/sys/contrib/openzfs/META
	@@ -1,10 +1,10 @@
	Meta: 1
	Name: zfs
	Branch: 1.0
	Version: 2.1.0
	-Release: rc1
	+Release: rc6
	Release-Tags: relext
	License: CDDL
	Author: OpenZFS
	-Linux-Maximum: 5.11
	+Linux-Maximum: 5.12
	Linux-Minimum: 3.10
	diff --git a/sys/contrib/openzfs/Makefile.am b/sys/contrib/openzfs/Makefile.am
	index b7cc4ce85655..c44d64df0187 100644
	--- a/sys/contrib/openzfs/Makefile.am
	+++ b/sys/contrib/openzfs/Makefile.am
	@@ -1,263 +1,261 @@
	ACLOCAL_AMFLAGS = -I config

	SUBDIRS = include
	if BUILD_LINUX
	SUBDIRS += rpm
	endif

	if CONFIG_USER
	SUBDIRS += etc man scripts lib tests cmd contrib
	if BUILD_LINUX
	SUBDIRS += udev
	endif
	endif
	if CONFIG_KERNEL
	SUBDIRS += module

	extradir = $(prefix)/src/zfs-$(VERSION)
	extra_HEADERS = zfs.release.in zfs_config.h.in

	if BUILD_LINUX
	kerneldir = $(prefix)/src/zfs-$(VERSION)/$(LINUX_VERSION)
	nodist_kernel_HEADERS = zfs.release zfs_config.h module/$(LINUX_SYMBOLS)
	endif
	endif

	AUTOMAKE_OPTIONS = foreign
	EXTRA_DIST = autogen.sh copy-builtin
	EXTRA_DIST += config/config.awk config/rpm.am config/deb.am config/tgz.am
	-EXTRA_DIST += META AUTHORS COPYRIGHT LICENSE NEWS NOTICE README.md
	-EXTRA_DIST += CODE_OF_CONDUCT.md
	+EXTRA_DIST += AUTHORS CODE_OF_CONDUCT.md COPYRIGHT LICENSE META NEWS NOTICE
	+EXTRA_DIST += README.md RELEASES.md
	EXTRA_DIST += module/lua/README.zfs module/os/linux/spl/README.md

	# Include all the extra licensing information for modules
	EXTRA_DIST += module/icp/algs/skein/THIRDPARTYLICENSE
	EXTRA_DIST += module/icp/algs/skein/THIRDPARTYLICENSE.descrip
	EXTRA_DIST += module/icp/asm-x86_64/aes/THIRDPARTYLICENSE.gladman
	EXTRA_DIST += module/icp/asm-x86_64/aes/THIRDPARTYLICENSE.gladman.descrip
	EXTRA_DIST += module/icp/asm-x86_64/aes/THIRDPARTYLICENSE.openssl
	EXTRA_DIST += module/icp/asm-x86_64/aes/THIRDPARTYLICENSE.openssl.descrip
	EXTRA_DIST += module/icp/asm-x86_64/modes/THIRDPARTYLICENSE.cryptogams
	EXTRA_DIST += module/icp/asm-x86_64/modes/THIRDPARTYLICENSE.cryptogams.descrip
	EXTRA_DIST += module/icp/asm-x86_64/modes/THIRDPARTYLICENSE.openssl
	EXTRA_DIST += module/icp/asm-x86_64/modes/THIRDPARTYLICENSE.openssl.descrip
	EXTRA_DIST += module/os/linux/spl/THIRDPARTYLICENSE.gplv2
	EXTRA_DIST += module/os/linux/spl/THIRDPARTYLICENSE.gplv2.descrip
	EXTRA_DIST += module/zfs/THIRDPARTYLICENSE.cityhash
	EXTRA_DIST += module/zfs/THIRDPARTYLICENSE.cityhash.descrip

	@CODE_COVERAGE_RULES@

	GITREV = include/zfs_gitrev.h

	PHONY = gitrev
	gitrev:
	$(AM_V_GEN)$(top_srcdir)/scripts/make_gitrev.sh $(GITREV)

	all: gitrev

	# Double-colon rules are allowed; there are multiple independent definitions.
	maintainer-clean-local::
	-$(RM) $(GITREV)

	distclean-local::
	-$(RM) -R autom4te*.cache build
	-find . \( -name SCCS -o -name BitKeeper -o -name .svn -o -name CVS \
	-o -name .pc -o -name .hg -o -name .git \) -prune -o \
	\( -name '.orig' -o -name '.rej' -o -name '*~' \
	-o -name '.bak' -o -name '##' -o -name '.*.orig' \
	-o -name '..rej' -o -size 0 -o -name '%' -o -name '.*.cmd' \
	-o -name 'core' -o -name 'Makefile' -o -name 'Module.symvers' \
	-o -name '.order' -o -name '.markers' -o -name '*.gcda' \
	-o -name '*.gcno' \) \
	-type f -print \| xargs $(RM)

	all-local:
	-[ -x ${top_builddir}/scripts/zfs-tests.sh ] && \
	${top_builddir}/scripts/zfs-tests.sh -c

	dist-hook:
	$(AM_V_GEN)$(top_srcdir)/scripts/make_gitrev.sh -D $(distdir) $(GITREV)
	$(SED) ${ac_inplace} -e 's/Release:[[:print:]]*/Release: $(RELEASE)/' \
	$(distdir)/META

	if BUILD_LINUX
	# For compatibility, create a matching spl-x.y.z directly which contains
	# symlinks to the updated header and object file locations. These
	# compatibility links will be removed in the next major release.
	if CONFIG_KERNEL
	install-data-hook:
	rm -rf $(DESTDIR)$(prefix)/src/spl-$(VERSION) && \
	mkdir $(DESTDIR)$(prefix)/src/spl-$(VERSION) && \
	cd $(DESTDIR)$(prefix)/src/spl-$(VERSION) && \
	ln -s ../zfs-$(VERSION)/include/spl include && \
	ln -s ../zfs-$(VERSION)/$(LINUX_VERSION) $(LINUX_VERSION) && \
	ln -s ../zfs-$(VERSION)/zfs_config.h.in spl_config.h.in && \
	ln -s ../zfs-$(VERSION)/zfs.release.in spl.release.in && \
	cd $(DESTDIR)$(prefix)/src/zfs-$(VERSION)/$(LINUX_VERSION) && \
	ln -fs zfs_config.h spl_config.h && \
	ln -fs zfs.release spl.release
	endif
	endif

	PHONY += codecheck
	codecheck: cstyle shellcheck checkbashisms flake8 mancheck testscheck vcscheck

	PHONY += checkstyle
	checkstyle: codecheck commitcheck

	PHONY += commitcheck
	commitcheck:
	@if git rev-parse --git-dir > /dev/null 2>&1; then \
	${top_srcdir}/scripts/commitcheck.sh; \
	fi

	PHONY += cstyle
	cstyle:
	@find ${top_srcdir} -name build -prune \
	-o -type f -name '*.[hc]' \
	! -name 'zfs_config.' ! -name '.mod.c' \
	! -name 'opt_global.h' ! -name '_if.h' \
	! -path './module/zstd/lib/*' \
	-exec ${top_srcdir}/scripts/cstyle.pl -cpP {} \+

	filter_executable = -exec test -x '{}' \; -print

	PHONY += shellcheck
	shellcheck:
	@if type shellcheck > /dev/null 2>&1; then \
	shellcheck --exclude=SC1090 --exclude=SC1117 --format=gcc \
	$$(find ${top_srcdir}/scripts/*.sh -type f) \
	$$(find ${top_srcdir}/cmd/zed/zed.d/*.sh -type f) \
	$$(find ${top_srcdir}/cmd/zpool/zpool.d/* \
	-type f ${filter_executable}); \
	else \
	echo "skipping shellcheck because shellcheck is not installed"; \
	fi

	PHONY += checkabi storeabi
	checkabi: lib
	$(MAKE) -C lib checkabi

	storeabi: lib
	$(MAKE) -C lib storeabi

	PHONY += checkbashisms
	checkbashisms:
	@if type checkbashisms > /dev/null 2>&1; then \
	checkbashisms -n -p -x \
	$$(find ${top_srcdir} \
	-name '.git' -prune \
	-o -name 'build' -prune \
	-o -name 'tests' -prune \
	-o -name 'config' -prune \
	-o -name 'zed-functions.sh*' -prune \
	-o -name 'zfs-import*' -prune \
	-o -name 'zfs-mount*' -prune \
	-o -name 'zfs-zed*' -prune \
	-o -name 'smart' -prune \
	-o -name 'paxcheck.sh' -prune \
	-o -name 'make_gitrev.sh' -prune \
	-o -name '90zfs' -prune \
	-o -type f ! -name 'config*' \
	! -name 'libtool' \
	- -exec sh -c 'awk "NR==1 && /\#\!.bin\/sh./ {print FILENAME;}" "{}"' \;); \
	+ -exec sh -c 'awk "NR==1 && /#!.bin\/sh./ {print FILENAME;}" "{}"' \;); \
	else \
	echo "skipping checkbashisms because checkbashisms is not installed"; \
	fi

	PHONY += mancheck
	mancheck:
	@if type mandoc > /dev/null 2>&1; then \
	- find ${top_srcdir}/man/man8 -type f -name 'zfs.8' \
	- -o -name 'zpool.8' -o -name 'zdb.8' \
	- -o -name 'zgenhostid.8' \| \
	- xargs mandoc -Tlint -Werror; \
	+ find ${top_srcdir}/man/man8 -type f -name '[1-9]' \
	+ -exec mandoc -Tlint -Werror {} \+; \
	else \
	echo "skipping mancheck because mandoc is not installed"; \
	fi

	if BUILD_LINUX
	stat_fmt = -c '%A %n'
	else
	stat_fmt = -f '%Sp %N'
	endif

	PHONY += testscheck
	testscheck:
	@find ${top_srcdir}/tests/zfs-tests -type f \
	$ -name '*.ksh' -not ${filter_executable} $ -o \
	$ -name '*.kshlib' ${filter_executable} $ -o \
	$ -name '*.shlib' ${filter_executable} $ -o \
	$ -name '*.cfg' ${filter_executable} $ \| \
	xargs -r stat ${stat_fmt} \| \
	awk '{c++; print} END {if(c>0) exit 1}'

	PHONY += vcscheck
	vcscheck:
	@if git rev-parse --git-dir > /dev/null 2>&1; then \
	git ls-files . --exclude-standard --others \| \
	awk '{c++; print} END {if(c>0) exit 1}' ; \
	fi

	PHONY += lint
	lint: cppcheck paxcheck

	CPPCHECKDIRS = cmd lib module
	PHONY += cppcheck
	cppcheck: $(CPPCHECKDIRS)
	@if test -n "$(CPPCHECK)"; then \
	set -e ; for dir in $(CPPCHECKDIRS) ; do \
	$(MAKE) -C $$dir cppcheck ; \
	done \
	else \
	echo "skipping cppcheck because cppcheck is not installed"; \
	fi

	PHONY += paxcheck
	paxcheck:
	@if type scanelf > /dev/null 2>&1; then \
	${top_srcdir}/scripts/paxcheck.sh ${top_builddir}; \
	else \
	echo "skipping paxcheck because scanelf is not installed"; \
	fi

	PHONY += flake8
	flake8:
	@if type flake8 > /dev/null 2>&1; then \
	flake8 ${top_srcdir}; \
	else \
	echo "skipping flake8 because flake8 is not installed"; \
	fi

	PHONY += ctags
	ctags:
	$(RM) tags
	find $(top_srcdir) -name '.?*' -prune \
	-o -type f -name '*.[hcS]' -print \| xargs ctags -a

	PHONY += etags
	etags:
	$(RM) TAGS
	find $(top_srcdir) -name '.?*' -prune \
	-o -type f -name '*.[hcS]' -print \| xargs etags -a

	PHONY += cscopelist
	cscopelist:
	find $(top_srcdir) -name '.?*' -prune \
	-o -type f -name '*.[hc]' -print >cscope.files

	PHONY += tags
	tags: ctags etags

	PHONY += pkg pkg-dkms pkg-kmod pkg-utils
	pkg: @DEFAULT_PACKAGE@
	pkg-dkms: @DEFAULT_PACKAGE@-dkms
	pkg-kmod: @DEFAULT_PACKAGE@-kmod
	pkg-utils: @DEFAULT_PACKAGE@-utils

	include config/rpm.am
	include config/deb.am
	include config/tgz.am

	.PHONY: $(PHONY)
	diff --git a/sys/contrib/openzfs/RELEASES.md b/sys/contrib/openzfs/RELEASES.md
	new file mode 100644
	index 000000000000..55bfdb80ef6e
	--- /dev/null
	+++ b/sys/contrib/openzfs/RELEASES.md
	@@ -0,0 +1,37 @@
	+OpenZFS uses the MAJOR.MINOR.PATCH versioning scheme described here:
	+
	+ * MAJOR - Incremented at the discretion of the OpenZFS developers to indicate
	+ a particularly noteworthy feature or change. An increase in MAJOR number
	+ does not indicate any incompatible on-disk format change. The ability
	+ to import a ZFS pool is controlled by the feature flags enabled on the
	+ pool and the feature flags supported by the installed OpenZFS version.
	+ Increasing the MAJOR version is expected to be an infrequent occurrence.
	+
	+ * MINOR - Incremented to indicate new functionality such as a new feature
	+ flag, pool/dataset property, zfs/zpool sub-command, new user/kernel
	+ interface, etc. MINOR releases may introduce incompatible changes to the
	+ user space library APIs (libzfs.so). Existing user/kernel interfaces are
	+ considered to be stable to maximize compatibility between OpenZFS releases.
	+ Additions to the user/kernel interface are backwards compatible.
	+
	+ * PATCH - Incremented when applying documentation updates, important bug
	+ fixes, minor performance improvements, and kernel compatibility patches.
	+ The user space library APIs and user/kernel interface are considered to
	+ be stable. PATCH releases for a MAJOR.MINOR are published as needed.
	+
	+Two release branches are maintained for OpenZFS, they are:
	+
	+ * OpenZFS LTS - A designated MAJOR.MINOR release with periodic PATCH
	+ releases that incorporate important changes backported from newer OpenZFS
	+ releases. This branch is intended for use in environments using an
	+ LTS, enterprise, or similarly managed kernel (RHEL, Ubuntu LTS, Debian).
	+ Minor changes to support these distribution kernels will be applied as
	+ needed. New kernel versions released after the OpenZFS LTS release are
	+ not supported. LTS releases will receive patches for at least 2 years.
	+ The current LTS release is OpenZFS 2.1.
	+
	+ * OpenZFS current - Tracks the newest MAJOR.MINOR release. This branch
	+ includes support for the latest OpenZFS features and recently releases
	+ kernels. When a new MINOR release is tagged the previous MINOR release
	+ will no longer be maintained (unless it is an LTS release). New MINOR
	+ releases are planned to occur roughly annually.
	diff --git a/sys/contrib/openzfs/cmd/arc_summary/arc_summary2 b/sys/contrib/openzfs/cmd/arc_summary/arc_summary2
	index 75b5697526f7..3302a802d146 100755
	--- a/sys/contrib/openzfs/cmd/arc_summary/arc_summary2
	+++ b/sys/contrib/openzfs/cmd/arc_summary/arc_summary2
	@@ -1,1185 +1,1180 @@
	#!/usr/bin/env python2
	#
	# $Id: arc_summary.pl,v 388:e27800740aa2 2011-07-08 02:53:29Z jhell $
	#
	# Copyright (c) 2008 Ben Rockwood <benr@cuddletech.com>,
	# Copyright (c) 2010 Martin Matuska <mm@FreeBSD.org>,
	# Copyright (c) 2010-2011 Jason J. Hellenthal <jhell@DataIX.net>,
	# 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 AUTHOR 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 AUTHOR 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.
	#
	# If you are having troubles when using this script from cron(8) please try
	# adjusting your PATH before reporting problems.
	#
	# Note some of this code uses older code (eg getopt instead of argparse,
	# subprocess.Popen() instead of subprocess.run()) because we need to support
	# some very old versions of Python.
	#

	"""Print statistics on the ZFS Adjustable Replacement Cache (ARC)

	Provides basic information on the ARC, its efficiency, the L2ARC (if present),
	the Data Management Unit (DMU), Virtual Devices (VDEVs), and tunables. See the
	in-source documentation and code at
	https://github.com/openzfs/zfs/blob/master/module/zfs/arc.c for details.
	"""

	import getopt
	import os
	import sys
	import time
	import errno

	from subprocess import Popen, PIPE
	from decimal import Decimal as D


	if sys.platform.startswith('freebsd'):
	# Requires py27-sysctl on FreeBSD
	import sysctl

	def is_value(ctl):
	return ctl.type != sysctl.CTLTYPE_NODE

	def load_kstats(namespace):
	"""Collect information on a specific subsystem of the ARC"""

	base = 'kstat.zfs.misc.%s.' % namespace
	fmt = lambda kstat: (kstat.name, D(kstat.value))
	kstats = sysctl.filter(base)
	return [fmt(kstat) for kstat in kstats if is_value(kstat)]

	def load_tunables():
	ctls = sysctl.filter('vfs.zfs')
	return dict((ctl.name, ctl.value) for ctl in ctls if is_value(ctl))

	elif sys.platform.startswith('linux'):

	def load_kstats(namespace):
	"""Collect information on a specific subsystem of the ARC"""

	kstat = 'kstat.zfs.misc.%s.%%s' % namespace
	path = '/proc/spl/kstat/zfs/%s' % namespace
	with open(path) as f:
	entries = [line.strip().split() for line in f][2:] # Skip header
	return [(kstat % name, D(value)) for name, _, value in entries]

	def load_tunables():
	basepath = '/sys/module/zfs/parameters'
	tunables = {}
	for name in os.listdir(basepath):
	if not name:
	continue
	path = '%s/%s' % (basepath, name)
	with open(path) as f:
	value = f.read()
	tunables[name] = value.strip()
	return tunables


	show_tunable_descriptions = False
	alternate_tunable_layout = False


	-def handle_Exception(ex_cls, ex, tb):
	- if ex is IOError:
	- if ex.errno == errno.EPIPE:
	- sys.exit()
	-
	- if ex is KeyboardInterrupt:
	- sys.exit()
	-
	-
	-sys.excepthook = handle_Exception
	-
	-
	def get_Kstat():
	"""Collect information on the ZFS subsystem from the /proc virtual
	file system. The name "kstat" is a holdover from the Solaris utility
	of the same name.
	"""

	Kstat = {}
	Kstat.update(load_kstats('arcstats'))
	Kstat.update(load_kstats('zfetchstats'))
	Kstat.update(load_kstats('vdev_cache_stats'))
	return Kstat


	def fBytes(b=0):
	"""Return human-readable representation of a byte value in
	powers of 2 (eg "KiB" for "kibibytes", etc) to two decimal
	points. Values smaller than one KiB are returned without
	decimal points.
	"""

	prefixes = [
	[2**80, "YiB"], # yobibytes (yotta)
	[2**70, "ZiB"], # zebibytes (zetta)
	[2**60, "EiB"], # exbibytes (exa)
	[2**50, "PiB"], # pebibytes (peta)
	[2**40, "TiB"], # tebibytes (tera)
	[2**30, "GiB"], # gibibytes (giga)
	[2**20, "MiB"], # mebibytes (mega)
	[2**10, "KiB"]] # kibibytes (kilo)

	if b >= 2**10:

	for limit, unit in prefixes:

	if b >= limit:
	value = b / limit
	break

	result = "%0.2f\t%s" % (value, unit)

	else:

	result = "%d\tBytes" % b

	return result


	def fHits(hits=0):
	"""Create a human-readable representation of the number of hits.
	The single-letter symbols used are SI to avoid the confusion caused
	by the different "short scale" and "long scale" representations in
	English, which use the same words for different values. See
	https://en.wikipedia.org/wiki/Names_of_large_numbers and
	https://physics.nist.gov/cuu/Units/prefixes.html
	"""

	numbers = [
	[10**24, 'Y'], # yotta (septillion)
	[10**21, 'Z'], # zetta (sextillion)
	[10**18, 'E'], # exa (quintrillion)
	[10**15, 'P'], # peta (quadrillion)
	[10**12, 'T'], # tera (trillion)
	[10**9, 'G'], # giga (billion)
	[10**6, 'M'], # mega (million)
	[10**3, 'k']] # kilo (thousand)

	if hits >= 1000:

	for limit, symbol in numbers:

	if hits >= limit:
	value = hits/limit
	break

	result = "%0.2f%s" % (value, symbol)

	else:

	result = "%d" % hits

	return result


	def fPerc(lVal=0, rVal=0, Decimal=2):
	"""Calculate percentage value and return in human-readable format"""

	if rVal > 0:
	return str("%0." + str(Decimal) + "f") % (100 * (lVal / rVal)) + "%"
	else:
	return str("%0." + str(Decimal) + "f") % 100 + "%"


	def get_arc_summary(Kstat):
	"""Collect general data on the ARC"""

	output = {}
	memory_throttle_count = Kstat[
	"kstat.zfs.misc.arcstats.memory_throttle_count"
	]

	if memory_throttle_count > 0:
	output['health'] = 'THROTTLED'
	else:
	output['health'] = 'HEALTHY'

	output['memory_throttle_count'] = fHits(memory_throttle_count)

	# ARC Misc.
	deleted = Kstat["kstat.zfs.misc.arcstats.deleted"]
	mutex_miss = Kstat["kstat.zfs.misc.arcstats.mutex_miss"]
	evict_skip = Kstat["kstat.zfs.misc.arcstats.evict_skip"]
	evict_l2_cached = Kstat["kstat.zfs.misc.arcstats.evict_l2_cached"]
	evict_l2_eligible = Kstat["kstat.zfs.misc.arcstats.evict_l2_eligible"]
	evict_l2_eligible_mfu = Kstat["kstat.zfs.misc.arcstats.evict_l2_eligible_mfu"]
	evict_l2_eligible_mru = Kstat["kstat.zfs.misc.arcstats.evict_l2_eligible_mru"]
	evict_l2_ineligible = Kstat["kstat.zfs.misc.arcstats.evict_l2_ineligible"]
	evict_l2_skip = Kstat["kstat.zfs.misc.arcstats.evict_l2_skip"]

	# ARC Misc.
	output["arc_misc"] = {}
	output["arc_misc"]["deleted"] = fHits(deleted)
	output["arc_misc"]["mutex_miss"] = fHits(mutex_miss)
	output["arc_misc"]["evict_skips"] = fHits(evict_skip)
	output["arc_misc"]["evict_l2_skip"] = fHits(evict_l2_skip)
	output["arc_misc"]["evict_l2_cached"] = fBytes(evict_l2_cached)
	output["arc_misc"]["evict_l2_eligible"] = fBytes(evict_l2_eligible)
	output["arc_misc"]["evict_l2_eligible_mfu"] = {
	'per': fPerc(evict_l2_eligible_mfu, evict_l2_eligible),
	'num': fBytes(evict_l2_eligible_mfu),
	}
	output["arc_misc"]["evict_l2_eligible_mru"] = {
	'per': fPerc(evict_l2_eligible_mru, evict_l2_eligible),
	'num': fBytes(evict_l2_eligible_mru),
	}
	output["arc_misc"]["evict_l2_ineligible"] = fBytes(evict_l2_ineligible)

	# ARC Sizing
	arc_size = Kstat["kstat.zfs.misc.arcstats.size"]
	mru_size = Kstat["kstat.zfs.misc.arcstats.mru_size"]
	mfu_size = Kstat["kstat.zfs.misc.arcstats.mfu_size"]
	meta_limit = Kstat["kstat.zfs.misc.arcstats.arc_meta_limit"]
	meta_size = Kstat["kstat.zfs.misc.arcstats.arc_meta_used"]
	dnode_limit = Kstat["kstat.zfs.misc.arcstats.arc_dnode_limit"]
	dnode_size = Kstat["kstat.zfs.misc.arcstats.dnode_size"]
	target_max_size = Kstat["kstat.zfs.misc.arcstats.c_max"]
	target_min_size = Kstat["kstat.zfs.misc.arcstats.c_min"]
	target_size = Kstat["kstat.zfs.misc.arcstats.c"]

	target_size_ratio = (target_max_size / target_min_size)

	# ARC Sizing
	output['arc_sizing'] = {}
	output['arc_sizing']['arc_size'] = {
	'per': fPerc(arc_size, target_max_size),
	'num': fBytes(arc_size),
	}
	output['arc_sizing']['target_max_size'] = {
	'ratio': target_size_ratio,
	'num': fBytes(target_max_size),
	}
	output['arc_sizing']['target_min_size'] = {
	'per': fPerc(target_min_size, target_max_size),
	'num': fBytes(target_min_size),
	}
	output['arc_sizing']['target_size'] = {
	'per': fPerc(target_size, target_max_size),
	'num': fBytes(target_size),
	}
	output['arc_sizing']['meta_limit'] = {
	'per': fPerc(meta_limit, target_max_size),
	'num': fBytes(meta_limit),
	}
	output['arc_sizing']['meta_size'] = {
	'per': fPerc(meta_size, meta_limit),
	'num': fBytes(meta_size),
	}
	output['arc_sizing']['dnode_limit'] = {
	'per': fPerc(dnode_limit, meta_limit),
	'num': fBytes(dnode_limit),
	}
	output['arc_sizing']['dnode_size'] = {
	'per': fPerc(dnode_size, dnode_limit),
	'num': fBytes(dnode_size),
	}

	# ARC Hash Breakdown
	output['arc_hash_break'] = {}
	output['arc_hash_break']['hash_chain_max'] = Kstat[
	"kstat.zfs.misc.arcstats.hash_chain_max"
	]
	output['arc_hash_break']['hash_chains'] = Kstat[
	"kstat.zfs.misc.arcstats.hash_chains"
	]
	output['arc_hash_break']['hash_collisions'] = Kstat[
	"kstat.zfs.misc.arcstats.hash_collisions"
	]
	output['arc_hash_break']['hash_elements'] = Kstat[
	"kstat.zfs.misc.arcstats.hash_elements"
	]
	output['arc_hash_break']['hash_elements_max'] = Kstat[
	"kstat.zfs.misc.arcstats.hash_elements_max"
	]

	output['arc_size_break'] = {}
	output['arc_size_break']['recently_used_cache_size'] = {
	'per': fPerc(mru_size, mru_size + mfu_size),
	'num': fBytes(mru_size),
	}
	output['arc_size_break']['frequently_used_cache_size'] = {
	'per': fPerc(mfu_size, mru_size + mfu_size),
	'num': fBytes(mfu_size),
	}

	# ARC Hash Breakdown
	hash_chain_max = Kstat["kstat.zfs.misc.arcstats.hash_chain_max"]
	hash_chains = Kstat["kstat.zfs.misc.arcstats.hash_chains"]
	hash_collisions = Kstat["kstat.zfs.misc.arcstats.hash_collisions"]
	hash_elements = Kstat["kstat.zfs.misc.arcstats.hash_elements"]
	hash_elements_max = Kstat["kstat.zfs.misc.arcstats.hash_elements_max"]

	output['arc_hash_break'] = {}
	output['arc_hash_break']['elements_max'] = fHits(hash_elements_max)
	output['arc_hash_break']['elements_current'] = {
	'per': fPerc(hash_elements, hash_elements_max),
	'num': fHits(hash_elements),
	}
	output['arc_hash_break']['collisions'] = fHits(hash_collisions)
	output['arc_hash_break']['chain_max'] = fHits(hash_chain_max)
	output['arc_hash_break']['chains'] = fHits(hash_chains)

	return output


	def _arc_summary(Kstat):
	"""Print information on the ARC"""

	# ARC Sizing
	arc = get_arc_summary(Kstat)

	sys.stdout.write("ARC Summary: (%s)\n" % arc['health'])

	sys.stdout.write("\tMemory Throttle Count:\t\t\t%s\n" %
	arc['memory_throttle_count'])
	sys.stdout.write("\n")

	# ARC Misc.
	sys.stdout.write("ARC Misc:\n")
	sys.stdout.write("\tDeleted:\t\t\t\t%s\n" % arc['arc_misc']['deleted'])
	sys.stdout.write("\tMutex Misses:\t\t\t\t%s\n" %
	arc['arc_misc']['mutex_miss'])
	sys.stdout.write("\tEviction Skips:\t\t\t\t%s\n" %
	arc['arc_misc']['evict_skips'])
	sys.stdout.write("\tEviction Skips Due to L2 Writes:\t%s\n" %
	arc['arc_misc']['evict_l2_skip'])
	sys.stdout.write("\tL2 Cached Evictions:\t\t\t%s\n" %
	arc['arc_misc']['evict_l2_cached'])
	sys.stdout.write("\tL2 Eligible Evictions:\t\t\t%s\n" %
	arc['arc_misc']['evict_l2_eligible'])
	sys.stdout.write("\tL2 Eligible MFU Evictions:\t%s\t%s\n" % (
	arc['arc_misc']['evict_l2_eligible_mfu']['per'],
	arc['arc_misc']['evict_l2_eligible_mfu']['num'],
	)
	)
	sys.stdout.write("\tL2 Eligible MRU Evictions:\t%s\t%s\n" % (
	arc['arc_misc']['evict_l2_eligible_mru']['per'],
	arc['arc_misc']['evict_l2_eligible_mru']['num'],
	)
	)
	sys.stdout.write("\tL2 Ineligible Evictions:\t\t%s\n" %
	arc['arc_misc']['evict_l2_ineligible'])
	sys.stdout.write("\n")

	# ARC Sizing
	sys.stdout.write("ARC Size:\t\t\t\t%s\t%s\n" % (
	arc['arc_sizing']['arc_size']['per'],
	arc['arc_sizing']['arc_size']['num']
	)
	)
	sys.stdout.write("\tTarget Size: (Adaptive)\t\t%s\t%s\n" % (
	arc['arc_sizing']['target_size']['per'],
	arc['arc_sizing']['target_size']['num'],
	)
	)

	sys.stdout.write("\tMin Size (Hard Limit):\t\t%s\t%s\n" % (
	arc['arc_sizing']['target_min_size']['per'],
	arc['arc_sizing']['target_min_size']['num'],
	)
	)

	sys.stdout.write("\tMax Size (High Water):\t\t%d:1\t%s\n" % (
	arc['arc_sizing']['target_max_size']['ratio'],
	arc['arc_sizing']['target_max_size']['num'],
	)
	)

	sys.stdout.write("\nARC Size Breakdown:\n")
	sys.stdout.write("\tRecently Used Cache Size:\t%s\t%s\n" % (
	arc['arc_size_break']['recently_used_cache_size']['per'],
	arc['arc_size_break']['recently_used_cache_size']['num'],
	)
	)
	sys.stdout.write("\tFrequently Used Cache Size:\t%s\t%s\n" % (
	arc['arc_size_break']['frequently_used_cache_size']['per'],
	arc['arc_size_break']['frequently_used_cache_size']['num'],
	)
	)
	sys.stdout.write("\tMetadata Size (Hard Limit):\t%s\t%s\n" % (
	arc['arc_sizing']['meta_limit']['per'],
	arc['arc_sizing']['meta_limit']['num'],
	)
	)
	sys.stdout.write("\tMetadata Size:\t\t\t%s\t%s\n" % (
	arc['arc_sizing']['meta_size']['per'],
	arc['arc_sizing']['meta_size']['num'],
	)
	)
	sys.stdout.write("\tDnode Size (Hard Limit):\t%s\t%s\n" % (
	arc['arc_sizing']['dnode_limit']['per'],
	arc['arc_sizing']['dnode_limit']['num'],
	)
	)
	sys.stdout.write("\tDnode Size:\t\t\t%s\t%s\n" % (
	arc['arc_sizing']['dnode_size']['per'],
	arc['arc_sizing']['dnode_size']['num'],
	)
	)

	sys.stdout.write("\n")

	# ARC Hash Breakdown
	sys.stdout.write("ARC Hash Breakdown:\n")
	sys.stdout.write("\tElements Max:\t\t\t\t%s\n" %
	arc['arc_hash_break']['elements_max'])
	sys.stdout.write("\tElements Current:\t\t%s\t%s\n" % (
	arc['arc_hash_break']['elements_current']['per'],
	arc['arc_hash_break']['elements_current']['num'],
	)
	)
	sys.stdout.write("\tCollisions:\t\t\t\t%s\n" %
	arc['arc_hash_break']['collisions'])
	sys.stdout.write("\tChain Max:\t\t\t\t%s\n" %
	arc['arc_hash_break']['chain_max'])
	sys.stdout.write("\tChains:\t\t\t\t\t%s\n" %
	arc['arc_hash_break']['chains'])


	def get_arc_efficiency(Kstat):
	"""Collect information on the efficiency of the ARC"""

	output = {}

	arc_hits = Kstat["kstat.zfs.misc.arcstats.hits"]
	arc_misses = Kstat["kstat.zfs.misc.arcstats.misses"]
	demand_data_hits = Kstat["kstat.zfs.misc.arcstats.demand_data_hits"]
	demand_data_misses = Kstat["kstat.zfs.misc.arcstats.demand_data_misses"]
	demand_metadata_hits = Kstat[
	"kstat.zfs.misc.arcstats.demand_metadata_hits"
	]
	demand_metadata_misses = Kstat[
	"kstat.zfs.misc.arcstats.demand_metadata_misses"
	]
	mfu_ghost_hits = Kstat["kstat.zfs.misc.arcstats.mfu_ghost_hits"]
	mfu_hits = Kstat["kstat.zfs.misc.arcstats.mfu_hits"]
	mru_ghost_hits = Kstat["kstat.zfs.misc.arcstats.mru_ghost_hits"]
	mru_hits = Kstat["kstat.zfs.misc.arcstats.mru_hits"]
	prefetch_data_hits = Kstat["kstat.zfs.misc.arcstats.prefetch_data_hits"]
	prefetch_data_misses = Kstat[
	"kstat.zfs.misc.arcstats.prefetch_data_misses"
	]
	prefetch_metadata_hits = Kstat[
	"kstat.zfs.misc.arcstats.prefetch_metadata_hits"
	]
	prefetch_metadata_misses = Kstat[
	"kstat.zfs.misc.arcstats.prefetch_metadata_misses"
	]

	anon_hits = arc_hits - (
	mfu_hits + mru_hits + mfu_ghost_hits + mru_ghost_hits
	)
	arc_accesses_total = (arc_hits + arc_misses)
	demand_data_total = (demand_data_hits + demand_data_misses)
	prefetch_data_total = (prefetch_data_hits + prefetch_data_misses)
	real_hits = (mfu_hits + mru_hits)

	output["total_accesses"] = fHits(arc_accesses_total)
	output["cache_hit_ratio"] = {
	'per': fPerc(arc_hits, arc_accesses_total),
	'num': fHits(arc_hits),
	}
	output["cache_miss_ratio"] = {
	'per': fPerc(arc_misses, arc_accesses_total),
	'num': fHits(arc_misses),
	}
	output["actual_hit_ratio"] = {
	'per': fPerc(real_hits, arc_accesses_total),
	'num': fHits(real_hits),
	}
	output["data_demand_efficiency"] = {
	'per': fPerc(demand_data_hits, demand_data_total),
	'num': fHits(demand_data_total),
	}

	if prefetch_data_total > 0:
	output["data_prefetch_efficiency"] = {
	'per': fPerc(prefetch_data_hits, prefetch_data_total),
	'num': fHits(prefetch_data_total),
	}

	if anon_hits > 0:
	output["cache_hits_by_cache_list"] = {}
	output["cache_hits_by_cache_list"]["anonymously_used"] = {
	'per': fPerc(anon_hits, arc_hits),
	'num': fHits(anon_hits),
	}

	output["most_recently_used"] = {
	'per': fPerc(mru_hits, arc_hits),
	'num': fHits(mru_hits),
	}
	output["most_frequently_used"] = {
	'per': fPerc(mfu_hits, arc_hits),
	'num': fHits(mfu_hits),
	}
	output["most_recently_used_ghost"] = {
	'per': fPerc(mru_ghost_hits, arc_hits),
	'num': fHits(mru_ghost_hits),
	}
	output["most_frequently_used_ghost"] = {
	'per': fPerc(mfu_ghost_hits, arc_hits),
	'num': fHits(mfu_ghost_hits),
	}

	output["cache_hits_by_data_type"] = {}
	output["cache_hits_by_data_type"]["demand_data"] = {
	'per': fPerc(demand_data_hits, arc_hits),
	'num': fHits(demand_data_hits),
	}
	output["cache_hits_by_data_type"]["prefetch_data"] = {
	'per': fPerc(prefetch_data_hits, arc_hits),
	'num': fHits(prefetch_data_hits),
	}
	output["cache_hits_by_data_type"]["demand_metadata"] = {
	'per': fPerc(demand_metadata_hits, arc_hits),
	'num': fHits(demand_metadata_hits),
	}
	output["cache_hits_by_data_type"]["prefetch_metadata"] = {
	'per': fPerc(prefetch_metadata_hits, arc_hits),
	'num': fHits(prefetch_metadata_hits),
	}

	output["cache_misses_by_data_type"] = {}
	output["cache_misses_by_data_type"]["demand_data"] = {
	'per': fPerc(demand_data_misses, arc_misses),
	'num': fHits(demand_data_misses),
	}
	output["cache_misses_by_data_type"]["prefetch_data"] = {
	'per': fPerc(prefetch_data_misses, arc_misses),
	'num': fHits(prefetch_data_misses),
	}
	output["cache_misses_by_data_type"]["demand_metadata"] = {
	'per': fPerc(demand_metadata_misses, arc_misses),
	'num': fHits(demand_metadata_misses),
	}
	output["cache_misses_by_data_type"]["prefetch_metadata"] = {
	'per': fPerc(prefetch_metadata_misses, arc_misses),
	'num': fHits(prefetch_metadata_misses),
	}

	return output


	def _arc_efficiency(Kstat):
	"""Print information on the efficiency of the ARC"""

	arc = get_arc_efficiency(Kstat)

	sys.stdout.write("ARC Total accesses:\t\t\t\t\t%s\n" %
	arc['total_accesses'])
	sys.stdout.write("\tCache Hit Ratio:\t\t%s\t%s\n" % (
	arc['cache_hit_ratio']['per'],
	arc['cache_hit_ratio']['num'],
	)
	)
	sys.stdout.write("\tCache Miss Ratio:\t\t%s\t%s\n" % (
	arc['cache_miss_ratio']['per'],
	arc['cache_miss_ratio']['num'],
	)
	)

	sys.stdout.write("\tActual Hit Ratio:\t\t%s\t%s\n" % (
	arc['actual_hit_ratio']['per'],
	arc['actual_hit_ratio']['num'],
	)
	)

	sys.stdout.write("\n")
	sys.stdout.write("\tData Demand Efficiency:\t\t%s\t%s\n" % (
	arc['data_demand_efficiency']['per'],
	arc['data_demand_efficiency']['num'],
	)
	)

	if 'data_prefetch_efficiency' in arc:
	sys.stdout.write("\tData Prefetch Efficiency:\t%s\t%s\n" % (
	arc['data_prefetch_efficiency']['per'],
	arc['data_prefetch_efficiency']['num'],
	)
	)
	sys.stdout.write("\n")

	sys.stdout.write("\tCACHE HITS BY CACHE LIST:\n")
	if 'cache_hits_by_cache_list' in arc:
	sys.stdout.write("\t Anonymously Used:\t\t%s\t%s\n" % (
	arc['cache_hits_by_cache_list']['anonymously_used']['per'],
	arc['cache_hits_by_cache_list']['anonymously_used']['num'],
	)
	)
	sys.stdout.write("\t Most Recently Used:\t\t%s\t%s\n" % (
	arc['most_recently_used']['per'],
	arc['most_recently_used']['num'],
	)
	)
	sys.stdout.write("\t Most Frequently Used:\t\t%s\t%s\n" % (
	arc['most_frequently_used']['per'],
	arc['most_frequently_used']['num'],
	)
	)
	sys.stdout.write("\t Most Recently Used Ghost:\t%s\t%s\n" % (
	arc['most_recently_used_ghost']['per'],
	arc['most_recently_used_ghost']['num'],
	)
	)
	sys.stdout.write("\t Most Frequently Used Ghost:\t%s\t%s\n" % (
	arc['most_frequently_used_ghost']['per'],
	arc['most_frequently_used_ghost']['num'],
	)
	)

	sys.stdout.write("\n\tCACHE HITS BY DATA TYPE:\n")
	sys.stdout.write("\t Demand Data:\t\t\t%s\t%s\n" % (
	arc["cache_hits_by_data_type"]['demand_data']['per'],
	arc["cache_hits_by_data_type"]['demand_data']['num'],
	)
	)
	sys.stdout.write("\t Prefetch Data:\t\t%s\t%s\n" % (
	arc["cache_hits_by_data_type"]['prefetch_data']['per'],
	arc["cache_hits_by_data_type"]['prefetch_data']['num'],
	)
	)
	sys.stdout.write("\t Demand Metadata:\t\t%s\t%s\n" % (
	arc["cache_hits_by_data_type"]['demand_metadata']['per'],
	arc["cache_hits_by_data_type"]['demand_metadata']['num'],
	)
	)
	sys.stdout.write("\t Prefetch Metadata:\t\t%s\t%s\n" % (
	arc["cache_hits_by_data_type"]['prefetch_metadata']['per'],
	arc["cache_hits_by_data_type"]['prefetch_metadata']['num'],
	)
	)

	sys.stdout.write("\n\tCACHE MISSES BY DATA TYPE:\n")
	sys.stdout.write("\t Demand Data:\t\t\t%s\t%s\n" % (
	arc["cache_misses_by_data_type"]['demand_data']['per'],
	arc["cache_misses_by_data_type"]['demand_data']['num'],
	)
	)
	sys.stdout.write("\t Prefetch Data:\t\t%s\t%s\n" % (
	arc["cache_misses_by_data_type"]['prefetch_data']['per'],
	arc["cache_misses_by_data_type"]['prefetch_data']['num'],
	)
	)
	sys.stdout.write("\t Demand Metadata:\t\t%s\t%s\n" % (
	arc["cache_misses_by_data_type"]['demand_metadata']['per'],
	arc["cache_misses_by_data_type"]['demand_metadata']['num'],
	)
	)
	sys.stdout.write("\t Prefetch Metadata:\t\t%s\t%s\n" % (
	arc["cache_misses_by_data_type"]['prefetch_metadata']['per'],
	arc["cache_misses_by_data_type"]['prefetch_metadata']['num'],
	)
	)


	def get_l2arc_summary(Kstat):
	"""Collection information on the L2ARC"""

	output = {}

	l2_abort_lowmem = Kstat["kstat.zfs.misc.arcstats.l2_abort_lowmem"]
	l2_cksum_bad = Kstat["kstat.zfs.misc.arcstats.l2_cksum_bad"]
	l2_evict_lock_retry = Kstat["kstat.zfs.misc.arcstats.l2_evict_lock_retry"]
	l2_evict_reading = Kstat["kstat.zfs.misc.arcstats.l2_evict_reading"]
	l2_feeds = Kstat["kstat.zfs.misc.arcstats.l2_feeds"]
	l2_free_on_write = Kstat["kstat.zfs.misc.arcstats.l2_free_on_write"]
	l2_hdr_size = Kstat["kstat.zfs.misc.arcstats.l2_hdr_size"]
	l2_hits = Kstat["kstat.zfs.misc.arcstats.l2_hits"]
	l2_io_error = Kstat["kstat.zfs.misc.arcstats.l2_io_error"]
	l2_misses = Kstat["kstat.zfs.misc.arcstats.l2_misses"]
	l2_rw_clash = Kstat["kstat.zfs.misc.arcstats.l2_rw_clash"]
	l2_size = Kstat["kstat.zfs.misc.arcstats.l2_size"]
	l2_asize = Kstat["kstat.zfs.misc.arcstats.l2_asize"]
	l2_writes_done = Kstat["kstat.zfs.misc.arcstats.l2_writes_done"]
	l2_writes_error = Kstat["kstat.zfs.misc.arcstats.l2_writes_error"]
	l2_writes_sent = Kstat["kstat.zfs.misc.arcstats.l2_writes_sent"]
	l2_mfu_asize = Kstat["kstat.zfs.misc.arcstats.l2_mfu_asize"]
	l2_mru_asize = Kstat["kstat.zfs.misc.arcstats.l2_mru_asize"]
	l2_prefetch_asize = Kstat["kstat.zfs.misc.arcstats.l2_prefetch_asize"]
	l2_bufc_data_asize = Kstat["kstat.zfs.misc.arcstats.l2_bufc_data_asize"]
	l2_bufc_metadata_asize = Kstat["kstat.zfs.misc.arcstats.l2_bufc_metadata_asize"]

	l2_access_total = (l2_hits + l2_misses)
	output['l2_health_count'] = (l2_writes_error + l2_cksum_bad + l2_io_error)

	output['l2_access_total'] = l2_access_total
	output['l2_size'] = l2_size
	output['l2_asize'] = l2_asize

	if l2_size > 0 and l2_access_total > 0:

	if output['l2_health_count'] > 0:
	output["health"] = "DEGRADED"
	else:
	output["health"] = "HEALTHY"

	output["low_memory_aborts"] = fHits(l2_abort_lowmem)
	output["free_on_write"] = fHits(l2_free_on_write)
	output["rw_clashes"] = fHits(l2_rw_clash)
	output["bad_checksums"] = fHits(l2_cksum_bad)
	output["io_errors"] = fHits(l2_io_error)

	output["l2_arc_size"] = {}
	output["l2_arc_size"]["adaptive"] = fBytes(l2_size)
	output["l2_arc_size"]["actual"] = {
	'per': fPerc(l2_asize, l2_size),
	'num': fBytes(l2_asize)
	}
	output["l2_arc_size"]["head_size"] = {
	'per': fPerc(l2_hdr_size, l2_size),
	'num': fBytes(l2_hdr_size),
	}
	output["l2_arc_size"]["mfu_asize"] = {
	'per': fPerc(l2_mfu_asize, l2_asize),
	'num': fBytes(l2_mfu_asize),
	}
	output["l2_arc_size"]["mru_asize"] = {
	'per': fPerc(l2_mru_asize, l2_asize),
	'num': fBytes(l2_mru_asize),
	}
	output["l2_arc_size"]["prefetch_asize"] = {
	'per': fPerc(l2_prefetch_asize, l2_asize),
	'num': fBytes(l2_prefetch_asize),
	}
	output["l2_arc_size"]["bufc_data_asize"] = {
	'per': fPerc(l2_bufc_data_asize, l2_asize),
	'num': fBytes(l2_bufc_data_asize),
	}
	output["l2_arc_size"]["bufc_metadata_asize"] = {
	'per': fPerc(l2_bufc_metadata_asize, l2_asize),
	'num': fBytes(l2_bufc_metadata_asize),
	}

	output["l2_arc_evicts"] = {}
	output["l2_arc_evicts"]['lock_retries'] = fHits(l2_evict_lock_retry)
	output["l2_arc_evicts"]['reading'] = fHits(l2_evict_reading)

	output['l2_arc_breakdown'] = {}
	output['l2_arc_breakdown']['value'] = fHits(l2_access_total)
	output['l2_arc_breakdown']['hit_ratio'] = {
	'per': fPerc(l2_hits, l2_access_total),
	'num': fHits(l2_hits),
	}
	output['l2_arc_breakdown']['miss_ratio'] = {
	'per': fPerc(l2_misses, l2_access_total),
	'num': fHits(l2_misses),
	}
	output['l2_arc_breakdown']['feeds'] = fHits(l2_feeds)

	output['l2_arc_buffer'] = {}

	output['l2_arc_writes'] = {}
	output['l2_writes_done'] = l2_writes_done
	output['l2_writes_sent'] = l2_writes_sent
	if l2_writes_done != l2_writes_sent:
	output['l2_arc_writes']['writes_sent'] = {
	'value': "FAULTED",
	'num': fHits(l2_writes_sent),
	}
	output['l2_arc_writes']['done_ratio'] = {
	'per': fPerc(l2_writes_done, l2_writes_sent),
	'num': fHits(l2_writes_done),
	}
	output['l2_arc_writes']['error_ratio'] = {
	'per': fPerc(l2_writes_error, l2_writes_sent),
	'num': fHits(l2_writes_error),
	}
	else:
	output['l2_arc_writes']['writes_sent'] = {
	'per': fPerc(100),
	'num': fHits(l2_writes_sent),
	}

	return output


	def _l2arc_summary(Kstat):
	"""Print information on the L2ARC"""

	arc = get_l2arc_summary(Kstat)

	if arc['l2_size'] > 0 and arc['l2_access_total'] > 0:
	sys.stdout.write("L2 ARC Summary: ")
	if arc['l2_health_count'] > 0:
	sys.stdout.write("(DEGRADED)\n")
	else:
	sys.stdout.write("(HEALTHY)\n")
	sys.stdout.write("\tLow Memory Aborts:\t\t\t%s\n" %
	arc['low_memory_aborts'])
	sys.stdout.write("\tFree on Write:\t\t\t\t%s\n" % arc['free_on_write'])
	sys.stdout.write("\tR/W Clashes:\t\t\t\t%s\n" % arc['rw_clashes'])
	sys.stdout.write("\tBad Checksums:\t\t\t\t%s\n" % arc['bad_checksums'])
	sys.stdout.write("\tIO Errors:\t\t\t\t%s\n" % arc['io_errors'])
	sys.stdout.write("\n")

	sys.stdout.write("L2 ARC Size: (Adaptive)\t\t\t\t%s\n" %
	arc["l2_arc_size"]["adaptive"])
	sys.stdout.write("\tCompressed:\t\t\t%s\t%s\n" % (
	arc["l2_arc_size"]["actual"]["per"],
	arc["l2_arc_size"]["actual"]["num"],
	)
	)
	sys.stdout.write("\tHeader Size:\t\t\t%s\t%s\n" % (
	arc["l2_arc_size"]["head_size"]["per"],
	arc["l2_arc_size"]["head_size"]["num"],
	)
	)
	sys.stdout.write("\tMFU Alloc. Size:\t\t%s\t%s\n" % (
	arc["l2_arc_size"]["mfu_asize"]["per"],
	arc["l2_arc_size"]["mfu_asize"]["num"],
	)
	)
	sys.stdout.write("\tMRU Alloc. Size:\t\t%s\t%s\n" % (
	arc["l2_arc_size"]["mru_asize"]["per"],
	arc["l2_arc_size"]["mru_asize"]["num"],
	)
	)
	sys.stdout.write("\tPrefetch Alloc. Size:\t\t%s\t%s\n" % (
	arc["l2_arc_size"]["prefetch_asize"]["per"],
	arc["l2_arc_size"]["prefetch_asize"]["num"],
	)
	)
	sys.stdout.write("\tData (buf content) Alloc. Size:\t%s\t%s\n" % (
	arc["l2_arc_size"]["bufc_data_asize"]["per"],
	arc["l2_arc_size"]["bufc_data_asize"]["num"],
	)
	)
	sys.stdout.write("\tMetadata (buf content) Size:\t%s\t%s\n" % (
	arc["l2_arc_size"]["bufc_metadata_asize"]["per"],
	arc["l2_arc_size"]["bufc_metadata_asize"]["num"],
	)
	)
	sys.stdout.write("\n")

	if arc["l2_arc_evicts"]['lock_retries'] != '0' or \
	arc["l2_arc_evicts"]["reading"] != '0':
	sys.stdout.write("L2 ARC Evictions:\n")
	sys.stdout.write("\tLock Retries:\t\t\t\t%s\n" %
	arc["l2_arc_evicts"]['lock_retries'])
	sys.stdout.write("\tUpon Reading:\t\t\t\t%s\n" %
	arc["l2_arc_evicts"]["reading"])
	sys.stdout.write("\n")

	sys.stdout.write("L2 ARC Breakdown:\t\t\t\t%s\n" %
	arc['l2_arc_breakdown']['value'])
	sys.stdout.write("\tHit Ratio:\t\t\t%s\t%s\n" % (
	arc['l2_arc_breakdown']['hit_ratio']['per'],
	arc['l2_arc_breakdown']['hit_ratio']['num'],
	)
	)

	sys.stdout.write("\tMiss Ratio:\t\t\t%s\t%s\n" % (
	arc['l2_arc_breakdown']['miss_ratio']['per'],
	arc['l2_arc_breakdown']['miss_ratio']['num'],
	)
	)

	sys.stdout.write("\tFeeds:\t\t\t\t\t%s\n" %
	arc['l2_arc_breakdown']['feeds'])
	sys.stdout.write("\n")

	sys.stdout.write("L2 ARC Writes:\n")
	if arc['l2_writes_done'] != arc['l2_writes_sent']:
	sys.stdout.write("\tWrites Sent: (%s)\t\t\t\t%s\n" % (
	arc['l2_arc_writes']['writes_sent']['value'],
	arc['l2_arc_writes']['writes_sent']['num'],
	)
	)
	sys.stdout.write("\t Done Ratio:\t\t\t%s\t%s\n" % (
	arc['l2_arc_writes']['done_ratio']['per'],
	arc['l2_arc_writes']['done_ratio']['num'],
	)
	)
	sys.stdout.write("\t Error Ratio:\t\t\t%s\t%s\n" % (
	arc['l2_arc_writes']['error_ratio']['per'],
	arc['l2_arc_writes']['error_ratio']['num'],
	)
	)
	else:
	sys.stdout.write("\tWrites Sent:\t\t\t%s\t%s\n" % (
	arc['l2_arc_writes']['writes_sent']['per'],
	arc['l2_arc_writes']['writes_sent']['num'],
	)
	)


	def get_dmu_summary(Kstat):
	"""Collect information on the DMU"""

	output = {}

	zfetch_hits = Kstat["kstat.zfs.misc.zfetchstats.hits"]
	zfetch_misses = Kstat["kstat.zfs.misc.zfetchstats.misses"]

	zfetch_access_total = (zfetch_hits + zfetch_misses)
	output['zfetch_access_total'] = zfetch_access_total

	if zfetch_access_total > 0:
	output['dmu'] = {}
	output['dmu']['efficiency'] = {}
	output['dmu']['efficiency']['value'] = fHits(zfetch_access_total)
	output['dmu']['efficiency']['hit_ratio'] = {
	'per': fPerc(zfetch_hits, zfetch_access_total),
	'num': fHits(zfetch_hits),
	}
	output['dmu']['efficiency']['miss_ratio'] = {
	'per': fPerc(zfetch_misses, zfetch_access_total),
	'num': fHits(zfetch_misses),
	}

	return output


	def _dmu_summary(Kstat):
	"""Print information on the DMU"""

	arc = get_dmu_summary(Kstat)

	if arc['zfetch_access_total'] > 0:
	sys.stdout.write("DMU Prefetch Efficiency:\t\t\t\t\t%s\n" %
	arc['dmu']['efficiency']['value'])
	sys.stdout.write("\tHit Ratio:\t\t\t%s\t%s\n" % (
	arc['dmu']['efficiency']['hit_ratio']['per'],
	arc['dmu']['efficiency']['hit_ratio']['num'],
	)
	)
	sys.stdout.write("\tMiss Ratio:\t\t\t%s\t%s\n" % (
	arc['dmu']['efficiency']['miss_ratio']['per'],
	arc['dmu']['efficiency']['miss_ratio']['num'],
	)
	)

	sys.stdout.write("\n")


	def get_vdev_summary(Kstat):
	"""Collect information on the VDEVs"""

	output = {}

	vdev_cache_delegations = \
	Kstat["kstat.zfs.misc.vdev_cache_stats.delegations"]
	vdev_cache_misses = Kstat["kstat.zfs.misc.vdev_cache_stats.misses"]
	vdev_cache_hits = Kstat["kstat.zfs.misc.vdev_cache_stats.hits"]
	vdev_cache_total = (vdev_cache_misses + vdev_cache_hits +
	vdev_cache_delegations)

	output['vdev_cache_total'] = vdev_cache_total

	if vdev_cache_total > 0:
	output['summary'] = fHits(vdev_cache_total)
	output['hit_ratio'] = {
	'per': fPerc(vdev_cache_hits, vdev_cache_total),
	'num': fHits(vdev_cache_hits),
	}
	output['miss_ratio'] = {
	'per': fPerc(vdev_cache_misses, vdev_cache_total),
	'num': fHits(vdev_cache_misses),
	}
	output['delegations'] = {
	'per': fPerc(vdev_cache_delegations, vdev_cache_total),
	'num': fHits(vdev_cache_delegations),
	}

	return output


	def _vdev_summary(Kstat):
	"""Print information on the VDEVs"""

	arc = get_vdev_summary(Kstat)

	if arc['vdev_cache_total'] > 0:
	sys.stdout.write("VDEV Cache Summary:\t\t\t\t%s\n" % arc['summary'])
	sys.stdout.write("\tHit Ratio:\t\t\t%s\t%s\n" % (
	arc['hit_ratio']['per'],
	arc['hit_ratio']['num'],
	))
	sys.stdout.write("\tMiss Ratio:\t\t\t%s\t%s\n" % (
	arc['miss_ratio']['per'],
	arc['miss_ratio']['num'],
	))
	sys.stdout.write("\tDelegations:\t\t\t%s\t%s\n" % (
	arc['delegations']['per'],
	arc['delegations']['num'],
	))


	def _tunable_summary(Kstat):
	"""Print information on tunables, including descriptions if requested"""

	global show_tunable_descriptions
	global alternate_tunable_layout

	tunables = load_tunables()
	descriptions = {}

	if show_tunable_descriptions:

	command = ["/sbin/modinfo", "zfs", "-0"]

	try:
	p = Popen(command, stdin=PIPE, stdout=PIPE,
	stderr=PIPE, shell=False, close_fds=True)
	p.wait()

	# By default, Python 2 returns a string as the first element of the
	# tuple from p.communicate(), while Python 3 returns bytes which
	# must be decoded first. The better way to do this would be with
	# subprocess.run() or at least .check_output(), but this fails on
	# CentOS 6 because of its old version of Python 2
	desc = bytes.decode(p.communicate()[0])
	description_list = desc.strip().split('\0')

	if p.returncode == 0:
	for tunable in description_list:
	if tunable[0:5] == 'parm:':
	tunable = tunable[5:].strip()
	name, description = tunable.split(':', 1)
	if not description:
	description = "Description unavailable"
	descriptions[name] = description
	else:
	sys.stderr.write("%s: '%s' exited with code %i\n" %
	(sys.argv[0], command[0], p.returncode))
	sys.stderr.write("Tunable descriptions will be disabled.\n")
	except OSError as e:
	sys.stderr.write("%s: Cannot run '%s': %s\n" %
	(sys.argv[0], command[0], e.strerror))
	sys.stderr.write("Tunable descriptions will be disabled.\n")

	sys.stdout.write("ZFS Tunables:\n")

	if alternate_tunable_layout:
	fmt = "\t%s=%s\n"
	else:
	fmt = "\t%-50s%s\n"

	for name in sorted(tunables.keys()):
	if show_tunable_descriptions and name in descriptions:
	sys.stdout.write("\t# %s\n" % descriptions[name])

	sys.stdout.write(fmt % (name, tunables[name]))


	unSub = [
	_arc_summary,
	_arc_efficiency,
	_l2arc_summary,
	_dmu_summary,
	_vdev_summary,
	_tunable_summary
	]


	def zfs_header():
	"""Print title string with date"""

	daydate = time.strftime('%a %b %d %H:%M:%S %Y')

	sys.stdout.write('\n'+'-'*72+'\n')
	sys.stdout.write('ZFS Subsystem Report\t\t\t\t%s' % daydate)
	sys.stdout.write('\n')


	def usage():
	"""Print usage information"""

	sys.stdout.write("Usage: arc_summary [-h] [-a] [-d] [-p PAGE]\n\n")
	sys.stdout.write("\t -h, --help : "
	"Print this help message and exit\n")
	sys.stdout.write("\t -a, --alternate : "
	"Show an alternate sysctl layout\n")
	sys.stdout.write("\t -d, --description : "
	"Show the sysctl descriptions\n")
	sys.stdout.write("\t -p PAGE, --page=PAGE : "
	"Select a single output page to display,\n")
	sys.stdout.write("\t "
	"should be an integer between 1 and " +
	str(len(unSub)) + "\n\n")
	sys.stdout.write("Examples:\n")
	sys.stdout.write("\tarc_summary -a\n")
	sys.stdout.write("\tarc_summary -p 4\n")
	sys.stdout.write("\tarc_summary -ad\n")
	sys.stdout.write("\tarc_summary --page=2\n")


	def main():
	"""Main function"""

	global show_tunable_descriptions
	global alternate_tunable_layout

	try:
	- opts, args = getopt.getopt(
	- sys.argv[1:],
	- "adp:h", ["alternate", "description", "page=", "help"]
	- )
	- except getopt.error as e:
	- sys.stderr.write("Error: %s\n" % e.msg)
	- usage()
	- sys.exit(1)
	-
	- args = {}
	- for opt, arg in opts:
	- if opt in ('-a', '--alternate'):
	- args['a'] = True
	- if opt in ('-d', '--description'):
	- args['d'] = True
	- if opt in ('-p', '--page'):
	- args['p'] = arg
	- if opt in ('-h', '--help'):
	- usage()
	- sys.exit(0)
	-
	- Kstat = get_Kstat()
	-
	- alternate_tunable_layout = 'a' in args
	- show_tunable_descriptions = 'd' in args
	-
	- pages = []
	-
	- if 'p' in args:
	try:
	- pages.append(unSub[int(args['p']) - 1])
	- except IndexError:
	- sys.stderr.write('the argument to -p must be between 1 and ' +
	- str(len(unSub)) + '\n')
	+ opts, args = getopt.getopt(
	+ sys.argv[1:],
	+ "adp:h", ["alternate", "description", "page=", "help"]
	+ )
	+ except getopt.error as e:
	+ sys.stderr.write("Error: %s\n" % e.msg)
	+ usage()
	sys.exit(1)
	- else:
	- pages = unSub

	- zfs_header()
	- for page in pages:
	- page(Kstat)
	- sys.stdout.write("\n")
	+ args = {}
	+ for opt, arg in opts:
	+ if opt in ('-a', '--alternate'):
	+ args['a'] = True
	+ if opt in ('-d', '--description'):
	+ args['d'] = True
	+ if opt in ('-p', '--page'):
	+ args['p'] = arg
	+ if opt in ('-h', '--help'):
	+ usage()
	+ sys.exit(0)
	+
	+ Kstat = get_Kstat()
	+
	+ alternate_tunable_layout = 'a' in args
	+ show_tunable_descriptions = 'd' in args
	+
	+ pages = []
	+
	+ if 'p' in args:
	+ try:
	+ pages.append(unSub[int(args['p']) - 1])
	+ except IndexError:
	+ sys.stderr.write('the argument to -p must be between 1 and ' +
	+ str(len(unSub)) + '\n')
	+ sys.exit(1)
	+ else:
	+ pages = unSub
	+
	+ zfs_header()
	+ for page in pages:
	+ page(Kstat)
	+ sys.stdout.write("\n")
	+ except IOError as ex:
	+ if (ex.errno == errno.EPIPE):
	+ sys.exit(0)
	+ raise
	+ except KeyboardInterrupt:
	+ sys.exit(0)


	if __name__ == '__main__':
	main()
	diff --git a/sys/contrib/openzfs/cmd/arc_summary/arc_summary3 b/sys/contrib/openzfs/cmd/arc_summary/arc_summary3
	index 96f7990e1726..d5b5489992e7 100755
	--- a/sys/contrib/openzfs/cmd/arc_summary/arc_summary3
	+++ b/sys/contrib/openzfs/cmd/arc_summary/arc_summary3
	@@ -1,966 +1,980 @@
	#!/usr/bin/env python3
	#
	# Copyright (c) 2008 Ben Rockwood <benr@cuddletech.com>,
	# Copyright (c) 2010 Martin Matuska <mm@FreeBSD.org>,
	# Copyright (c) 2010-2011 Jason J. Hellenthal <jhell@DataIX.net>,
	# Copyright (c) 2017 Scot W. Stevenson <scot.stevenson@gmail.com>
	# 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 AUTHOR 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 AUTHOR 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.
	"""Print statistics on the ZFS ARC Cache and other information

	Provides basic information on the ARC, its efficiency, the L2ARC (if present),
	the Data Management Unit (DMU), Virtual Devices (VDEVs), and tunables. See
	the in-source documentation and code at
	https://github.com/openzfs/zfs/blob/master/module/zfs/arc.c for details.
	The original introduction to arc_summary can be found at
	http://cuddletech.com/?p=454
	"""

	import argparse
	import os
	import subprocess
	import sys
	import time

	+# We can't use env -S portably, and we need python3 -u to handle pipes in
	+# the shell abruptly closing the way we want to, so...
	+import io
	+if isinstance(sys.__stderr__.buffer, io.BufferedWriter):
	+ os.execv(sys.executable, [sys.executable, "-u"] + sys.argv)
	+
	DESCRIPTION = 'Print ARC and other statistics for OpenZFS'
	INDENT = ' '*8
	LINE_LENGTH = 72
	DATE_FORMAT = '%a %b %d %H:%M:%S %Y'
	TITLE = 'ZFS Subsystem Report'

	SECTIONS = 'arc archits dmu l2arc spl tunables vdev zil'.split()
	SECTION_HELP = 'print info from one section ('+' '.join(SECTIONS)+')'

	# Tunables and SPL are handled separately because they come from
	# different sources
	SECTION_PATHS = {'arc': 'arcstats',
	'dmu': 'dmu_tx',
	'l2arc': 'arcstats', # L2ARC stuff lives in arcstats
	'vdev': 'vdev_cache_stats',
	'zfetch': 'zfetchstats',
	'zil': 'zil'}

	parser = argparse.ArgumentParser(description=DESCRIPTION)
	parser.add_argument('-a', '--alternate', action='store_true', default=False,
	help='use alternate formatting for tunables and SPL',
	dest='alt')
	parser.add_argument('-d', '--description', action='store_true', default=False,
	help='print descriptions with tunables and SPL',
	dest='desc')
	parser.add_argument('-g', '--graph', action='store_true', default=False,
	help='print graph on ARC use and exit', dest='graph')
	parser.add_argument('-p', '--page', type=int, dest='page',
	help='print page by number (DEPRECATED, use "-s")')
	parser.add_argument('-r', '--raw', action='store_true', default=False,
	help='dump all available data with minimal formatting',
	dest='raw')
	parser.add_argument('-s', '--section', dest='section', help=SECTION_HELP)
	ARGS = parser.parse_args()


	if sys.platform.startswith('freebsd'):
	# Requires py36-sysctl on FreeBSD
	import sysctl

	VDEV_CACHE_SIZE = 'vdev.cache_size'

	def is_value(ctl):
	return ctl.type != sysctl.CTLTYPE_NODE

	def namefmt(ctl, base='vfs.zfs.'):
	# base is removed from the name
	cut = len(base)
	return ctl.name[cut:]

	def load_kstats(section):
	base = 'kstat.zfs.misc.{section}.'.format(section=section)
	fmt = lambda kstat: '{name} : {value}'.format(name=namefmt(kstat, base),
	value=kstat.value)
	kstats = sysctl.filter(base)
	return [fmt(kstat) for kstat in kstats if is_value(kstat)]

	def get_params(base):
	ctls = sysctl.filter(base)
	return {namefmt(ctl): str(ctl.value) for ctl in ctls if is_value(ctl)}

	def get_tunable_params():
	return get_params('vfs.zfs')

	def get_vdev_params():
	return get_params('vfs.zfs.vdev')

	def get_version_impl(request):
	# FreeBSD reports versions for zpl and spa instead of zfs and spl.
	name = {'zfs': 'zpl',
	'spl': 'spa'}[request]
	mib = 'vfs.zfs.version.{}'.format(name)
	version = sysctl.filter(mib)[0].value
	return '{} version {}'.format(name, version)

	def get_descriptions(_request):
	ctls = sysctl.filter('vfs.zfs')
	return {namefmt(ctl): ctl.description for ctl in ctls if is_value(ctl)}


	elif sys.platform.startswith('linux'):
	KSTAT_PATH = '/proc/spl/kstat/zfs'
	SPL_PATH = '/sys/module/spl/parameters'
	TUNABLES_PATH = '/sys/module/zfs/parameters'

	VDEV_CACHE_SIZE = 'zfs_vdev_cache_size'

	def load_kstats(section):
	path = os.path.join(KSTAT_PATH, section)
	with open(path) as f:
	return list(f)[2:] # Get rid of header

	def get_params(basepath):
	"""Collect information on the Solaris Porting Layer (SPL) or the
	tunables, depending on the PATH given. Does not check if PATH is
	legal.
	"""
	result = {}
	for name in os.listdir(basepath):
	path = os.path.join(basepath, name)
	with open(path) as f:
	value = f.read()
	result[name] = value.strip()
	return result

	def get_spl_params():
	return get_params(SPL_PATH)

	def get_tunable_params():
	return get_params(TUNABLES_PATH)

	def get_vdev_params():
	return get_params(TUNABLES_PATH)

	def get_version_impl(request):
	# The original arc_summary called /sbin/modinfo/{spl,zfs} to get
	# the version information. We switch to /sys/module/{spl,zfs}/version
	# to make sure we get what is really loaded in the kernel
	- command = ["cat", "/sys/module/{0}/version".format(request)]
	- req = request.upper()
	-
	- # The recommended way to do this is with subprocess.run(). However,
	- # some installed versions of Python are < 3.5, so we offer them
	- # the option of doing it the old way (for now)
	- if 'run' in dir(subprocess):
	- info = subprocess.run(command, stdout=subprocess.PIPE,
	- universal_newlines=True)
	- version = info.stdout.strip()
	- else:
	- info = subprocess.check_output(command, universal_newlines=True)
	- version = info.strip()
	-
	- return version
	+ try:
	+ with open("/sys/module/{}/version".format(request)) as f:
	+ return f.read().strip()
	+ except:
	+ return "(unknown)"

	def get_descriptions(request):
	"""Get the descriptions of the Solaris Porting Layer (SPL) or the
	tunables, return with minimal formatting.
	"""

	if request not in ('spl', 'zfs'):
	print('ERROR: description of "{0}" requested)'.format(request))
	sys.exit(1)

	descs = {}
	target_prefix = 'parm:'

	# We would prefer to do this with /sys/modules -- see the discussion at
	# get_version() -- but there isn't a way to get the descriptions from
	# there, so we fall back on modinfo
	command = ["/sbin/modinfo", request, "-0"]

	# The recommended way to do this is with subprocess.run(). However,
	# some installed versions of Python are < 3.5, so we offer them
	# the option of doing it the old way (for now)
	info = ''

	try:

	if 'run' in dir(subprocess):
	info = subprocess.run(command, stdout=subprocess.PIPE,
	universal_newlines=True)
	raw_output = info.stdout.split('\0')
	else:
	info = subprocess.check_output(command,
	universal_newlines=True)
	raw_output = info.split('\0')

	except subprocess.CalledProcessError:
	print("Error: Descriptions not available",
	"(can't access kernel module)")
	sys.exit(1)

	for line in raw_output:

	if not line.startswith(target_prefix):
	continue

	line = line[len(target_prefix):].strip()
	name, raw_desc = line.split(':', 1)
	desc = raw_desc.rsplit('(', 1)[0]

	if desc == '':
	desc = '(No description found)'

	descs[name.strip()] = desc.strip()

	return descs

	+def handle_unraisableException(exc_type, exc_value=None, exc_traceback=None,
	+ err_msg=None, object=None):
	+ handle_Exception(exc_type, object, exc_traceback)
	+
	+def handle_Exception(ex_cls, ex, tb):
	+ if ex_cls is KeyboardInterrupt:
	+ sys.exit()
	+
	+ if ex_cls is BrokenPipeError:
	+ # It turns out that while sys.exit() triggers an exception
	+ # not handled message on Python 3.8+, os._exit() does not.
	+ os._exit(0)
	+ raise ex
	+
	+if hasattr(sys,'unraisablehook'): # Python 3.8+
	+ sys.unraisablehook = handle_unraisableException
	+sys.excepthook = handle_Exception
	+

	def cleanup_line(single_line):
	"""Format a raw line of data from /proc and isolate the name value
	part, returning a tuple with each. Currently, this gets rid of the
	middle '4'. For example "arc_no_grow 4 0" returns the tuple
	("arc_no_grow", "0").
	"""
	name, _, value = single_line.split()

	return name, value


	def draw_graph(kstats_dict):
	"""Draw a primitive graph representing the basic information on the
	ARC -- its size and the proportion used by MFU and MRU -- and quit.
	We use max size of the ARC to calculate how full it is. This is a
	very rough representation.
	"""

	arc_stats = isolate_section('arcstats', kstats_dict)

	GRAPH_INDENT = ' '*4
	GRAPH_WIDTH = 60
	arc_size = f_bytes(arc_stats['size'])
	arc_perc = f_perc(arc_stats['size'], arc_stats['c_max'])
	mfu_size = f_bytes(arc_stats['mfu_size'])
	mru_size = f_bytes(arc_stats['mru_size'])
	meta_limit = f_bytes(arc_stats['arc_meta_limit'])
	meta_size = f_bytes(arc_stats['arc_meta_used'])
	dnode_limit = f_bytes(arc_stats['arc_dnode_limit'])
	dnode_size = f_bytes(arc_stats['dnode_size'])

	info_form = ('ARC: {0} ({1}) MFU: {2} MRU: {3} META: {4} ({5}) '
	'DNODE {6} ({7})')
	info_line = info_form.format(arc_size, arc_perc, mfu_size, mru_size,
	meta_size, meta_limit, dnode_size,
	dnode_limit)
	info_spc = ' '*int((GRAPH_WIDTH-len(info_line))/2)
	info_line = GRAPH_INDENT+info_spc+info_line

	graph_line = GRAPH_INDENT+'+'+('-'*(GRAPH_WIDTH-2))+'+'

	mfu_perc = float(int(arc_stats['mfu_size'])/int(arc_stats['c_max']))
	mru_perc = float(int(arc_stats['mru_size'])/int(arc_stats['c_max']))
	arc_perc = float(int(arc_stats['size'])/int(arc_stats['c_max']))
	total_ticks = float(arc_perc)*GRAPH_WIDTH
	mfu_ticks = mfu_perc*GRAPH_WIDTH
	mru_ticks = mru_perc*GRAPH_WIDTH
	other_ticks = total_ticks-(mfu_ticks+mru_ticks)

	core_form = 'F'int(mfu_ticks)+'R'int(mru_ticks)+'O'*int(other_ticks)
	core_spc = ' '*(GRAPH_WIDTH-(2+len(core_form)))
	core_line = GRAPH_INDENT+'\|'+core_form+core_spc+'\|'

	for line in ('', info_line, graph_line, core_line, graph_line, ''):
	print(line)


	def f_bytes(byte_string):
	"""Return human-readable representation of a byte value in
	powers of 2 (eg "KiB" for "kibibytes", etc) to two decimal
	points. Values smaller than one KiB are returned without
	decimal points. Note "bytes" is a reserved keyword.
	"""

	prefixes = ([2**80, "YiB"], # yobibytes (yotta)
	[2**70, "ZiB"], # zebibytes (zetta)
	[2**60, "EiB"], # exbibytes (exa)
	[2**50, "PiB"], # pebibytes (peta)
	[2**40, "TiB"], # tebibytes (tera)
	[2**30, "GiB"], # gibibytes (giga)
	[2**20, "MiB"], # mebibytes (mega)
	[2**10, "KiB"]) # kibibytes (kilo)

	bites = int(byte_string)

	if bites >= 2**10:
	for limit, unit in prefixes:

	if bites >= limit:
	value = bites / limit
	break

	result = '{0:.1f} {1}'.format(value, unit)
	else:
	result = '{0} Bytes'.format(bites)

	return result


	def f_hits(hits_string):
	"""Create a human-readable representation of the number of hits.
	The single-letter symbols used are SI to avoid the confusion caused
	by the different "short scale" and "long scale" representations in
	English, which use the same words for different values. See
	https://en.wikipedia.org/wiki/Names_of_large_numbers and:
	https://physics.nist.gov/cuu/Units/prefixes.html
	"""

	numbers = ([10**24, 'Y'], # yotta (septillion)
	[10**21, 'Z'], # zetta (sextillion)
	[10**18, 'E'], # exa (quintrillion)
	[10**15, 'P'], # peta (quadrillion)
	[10**12, 'T'], # tera (trillion)
	[10**9, 'G'], # giga (billion)
	[10**6, 'M'], # mega (million)
	[10**3, 'k']) # kilo (thousand)

	hits = int(hits_string)

	if hits >= 1000:
	for limit, symbol in numbers:

	if hits >= limit:
	value = hits/limit
	break

	result = "%0.1f%s" % (value, symbol)
	else:
	result = "%d" % hits

	return result


	def f_perc(value1, value2):
	"""Calculate percentage and return in human-readable form. If
	rounding produces the result '0.0' though the first number is
	not zero, include a 'less-than' symbol to avoid confusion.
	Division by zero is handled by returning 'n/a'; no error
	is called.
	"""

	v1 = float(value1)
	v2 = float(value2)

	try:
	perc = 100 * v1/v2
	except ZeroDivisionError:
	result = 'n/a'
	else:
	result = '{0:0.1f} %'.format(perc)

	if result == '0.0 %' and v1 > 0:
	result = '< 0.1 %'

	return result


	def format_raw_line(name, value):
	"""For the --raw option for the tunable and SPL outputs, decide on the
	correct formatting based on the --alternate flag.
	"""

	if ARGS.alt:
	result = '{0}{1}={2}'.format(INDENT, name, value)
	else:
	# Right-align the value within the line length if it fits,
	# otherwise just separate it from the name by a single space.
	fit = LINE_LENGTH - len(INDENT) - len(name)
	overflow = len(value) + 1
	w = max(fit, overflow)
	result = '{0}{1}{2:>{w}}'.format(INDENT, name, value, w=w)

	return result


	def get_kstats():
	"""Collect information on the ZFS subsystem. The step does not perform any
	further processing, giving us the option to only work on what is actually
	needed. The name "kstat" is a holdover from the Solaris utility of the same
	name.
	"""

	result = {}

	for section in SECTION_PATHS.values():
	if section not in result:
	result[section] = load_kstats(section)

	return result


	def get_version(request):
	"""Get the version number of ZFS or SPL on this machine for header.
	Returns an error string, but does not raise an error, if we can't
	get the ZFS/SPL version.
	"""

	if request not in ('spl', 'zfs'):
	error_msg = '(ERROR: "{0}" requested)'.format(request)
	return error_msg

	return get_version_impl(request)


	def print_header():
	"""Print the initial heading with date and time as well as info on the
	kernel and ZFS versions. This is not called for the graph.
	"""

	# datetime is now recommended over time but we keep the exact formatting
	# from the older version of arc_summary in case there are scripts
	# that expect it in this way
	daydate = time.strftime(DATE_FORMAT)
	spc_date = LINE_LENGTH-len(daydate)
	sys_version = os.uname()

	sys_msg = sys_version.sysname+' '+sys_version.release
	zfs = get_version('zfs')
	spc_zfs = LINE_LENGTH-len(zfs)

	machine_msg = 'Machine: '+sys_version.nodename+' ('+sys_version.machine+')'
	spl = get_version('spl')
	spc_spl = LINE_LENGTH-len(spl)

	print('\n'+('-'*LINE_LENGTH))
	print('{0:<{spc}}{1}'.format(TITLE, daydate, spc=spc_date))
	print('{0:<{spc}}{1}'.format(sys_msg, zfs, spc=spc_zfs))
	print('{0:<{spc}}{1}\n'.format(machine_msg, spl, spc=spc_spl))


	def print_raw(kstats_dict):
	"""Print all available data from the system in a minimally sorted format.
	This can be used as a source to be piped through 'grep'.
	"""

	sections = sorted(kstats_dict.keys())

	for section in sections:

	print('\n{0}:'.format(section.upper()))
	lines = sorted(kstats_dict[section])

	for line in lines:
	name, value = cleanup_line(line)
	print(format_raw_line(name, value))

	# Tunables and SPL must be handled separately because they come from a
	# different source and have descriptions the user might request
	print()
	section_spl()
	section_tunables()


	def isolate_section(section_name, kstats_dict):
	"""From the complete information on all sections, retrieve only those
	for one section.
	"""

	try:
	section_data = kstats_dict[section_name]
	except KeyError:
	print('ERROR: Data on {0} not available'.format(section_data))
	sys.exit(1)

	section_dict = dict(cleanup_line(l) for l in section_data)

	return section_dict


	# Formatted output helper functions


	def prt_1(text, value):
	"""Print text and one value, no indent"""
	spc = ' '*(LINE_LENGTH-(len(text)+len(value)))
	print('{0}{spc}{1}'.format(text, value, spc=spc))


	def prt_i1(text, value):
	"""Print text and one value, with indent"""
	spc = ' '*(LINE_LENGTH-(len(INDENT)+len(text)+len(value)))
	print(INDENT+'{0}{spc}{1}'.format(text, value, spc=spc))


	def prt_2(text, value1, value2):
	"""Print text and two values, no indent"""
	values = '{0:>9} {1:>9}'.format(value1, value2)
	spc = ' '*(LINE_LENGTH-(len(text)+len(values)+2))
	print('{0}{spc} {1}'.format(text, values, spc=spc))


	def prt_i2(text, value1, value2):
	"""Print text and two values, with indent"""
	values = '{0:>9} {1:>9}'.format(value1, value2)
	spc = ' '*(LINE_LENGTH-(len(INDENT)+len(text)+len(values)+2))
	print(INDENT+'{0}{spc} {1}'.format(text, values, spc=spc))


	# The section output concentrates on important parameters instead of
	# being exhaustive (that is what the --raw parameter is for)


	def section_arc(kstats_dict):
	"""Give basic information on the ARC, MRU and MFU. This is the first
	and most used section.
	"""

	arc_stats = isolate_section('arcstats', kstats_dict)

	throttle = arc_stats['memory_throttle_count']

	if throttle == '0':
	health = 'HEALTHY'
	else:
	health = 'THROTTLED'

	prt_1('ARC status:', health)
	prt_i1('Memory throttle count:', throttle)
	print()

	arc_size = arc_stats['size']
	arc_target_size = arc_stats['c']
	arc_max = arc_stats['c_max']
	arc_min = arc_stats['c_min']
	mfu_size = arc_stats['mfu_size']
	mru_size = arc_stats['mru_size']
	meta_limit = arc_stats['arc_meta_limit']
	meta_size = arc_stats['arc_meta_used']
	dnode_limit = arc_stats['arc_dnode_limit']
	dnode_size = arc_stats['dnode_size']
	target_size_ratio = '{0}:1'.format(int(arc_max) // int(arc_min))

	prt_2('ARC size (current):',
	f_perc(arc_size, arc_max), f_bytes(arc_size))
	prt_i2('Target size (adaptive):',
	f_perc(arc_target_size, arc_max), f_bytes(arc_target_size))
	prt_i2('Min size (hard limit):',
	f_perc(arc_min, arc_max), f_bytes(arc_min))
	prt_i2('Max size (high water):',
	target_size_ratio, f_bytes(arc_max))
	caches_size = int(mfu_size)+int(mru_size)
	prt_i2('Most Frequently Used (MFU) cache size:',
	f_perc(mfu_size, caches_size), f_bytes(mfu_size))
	prt_i2('Most Recently Used (MRU) cache size:',
	f_perc(mru_size, caches_size), f_bytes(mru_size))
	prt_i2('Metadata cache size (hard limit):',
	f_perc(meta_limit, arc_max), f_bytes(meta_limit))
	prt_i2('Metadata cache size (current):',
	f_perc(meta_size, meta_limit), f_bytes(meta_size))
	prt_i2('Dnode cache size (hard limit):',
	f_perc(dnode_limit, meta_limit), f_bytes(dnode_limit))
	prt_i2('Dnode cache size (current):',
	f_perc(dnode_size, dnode_limit), f_bytes(dnode_size))
	print()

	print('ARC hash breakdown:')
	prt_i1('Elements max:', f_hits(arc_stats['hash_elements_max']))
	prt_i2('Elements current:',
	f_perc(arc_stats['hash_elements'], arc_stats['hash_elements_max']),
	f_hits(arc_stats['hash_elements']))
	prt_i1('Collisions:', f_hits(arc_stats['hash_collisions']))

	prt_i1('Chain max:', f_hits(arc_stats['hash_chain_max']))
	prt_i1('Chains:', f_hits(arc_stats['hash_chains']))
	print()

	print('ARC misc:')
	prt_i1('Deleted:', f_hits(arc_stats['deleted']))
	prt_i1('Mutex misses:', f_hits(arc_stats['mutex_miss']))
	prt_i1('Eviction skips:', f_hits(arc_stats['evict_skip']))
	prt_i1('Eviction skips due to L2 writes:',
	f_hits(arc_stats['evict_l2_skip']))
	prt_i1('L2 cached evictions:', f_bytes(arc_stats['evict_l2_cached']))
	prt_i1('L2 eligible evictions:', f_bytes(arc_stats['evict_l2_eligible']))
	prt_i2('L2 eligible MFU evictions:',
	f_perc(arc_stats['evict_l2_eligible_mfu'],
	arc_stats['evict_l2_eligible']),
	f_bytes(arc_stats['evict_l2_eligible_mfu']))
	prt_i2('L2 eligible MRU evictions:',
	f_perc(arc_stats['evict_l2_eligible_mru'],
	arc_stats['evict_l2_eligible']),
	f_bytes(arc_stats['evict_l2_eligible_mru']))
	prt_i1('L2 ineligible evictions:',
	f_bytes(arc_stats['evict_l2_ineligible']))
	print()


	def section_archits(kstats_dict):
	"""Print information on how the caches are accessed ("arc hits").
	"""

	arc_stats = isolate_section('arcstats', kstats_dict)
	all_accesses = int(arc_stats['hits'])+int(arc_stats['misses'])
	actual_hits = int(arc_stats['mfu_hits'])+int(arc_stats['mru_hits'])

	prt_1('ARC total accesses (hits + misses):', f_hits(all_accesses))
	ta_todo = (('Cache hit ratio:', arc_stats['hits']),
	('Cache miss ratio:', arc_stats['misses']),
	('Actual hit ratio (MFU + MRU hits):', actual_hits))

	for title, value in ta_todo:
	prt_i2(title, f_perc(value, all_accesses), f_hits(value))

	dd_total = int(arc_stats['demand_data_hits']) +\
	int(arc_stats['demand_data_misses'])
	prt_i2('Data demand efficiency:',
	f_perc(arc_stats['demand_data_hits'], dd_total),
	f_hits(dd_total))

	dp_total = int(arc_stats['prefetch_data_hits']) +\
	int(arc_stats['prefetch_data_misses'])
	prt_i2('Data prefetch efficiency:',
	f_perc(arc_stats['prefetch_data_hits'], dp_total),
	f_hits(dp_total))

	known_hits = int(arc_stats['mfu_hits']) +\
	int(arc_stats['mru_hits']) +\
	int(arc_stats['mfu_ghost_hits']) +\
	int(arc_stats['mru_ghost_hits'])

	anon_hits = int(arc_stats['hits'])-known_hits

	print()
	print('Cache hits by cache type:')
	cl_todo = (('Most frequently used (MFU):', arc_stats['mfu_hits']),
	('Most recently used (MRU):', arc_stats['mru_hits']),
	('Most frequently used (MFU) ghost:',
	arc_stats['mfu_ghost_hits']),
	('Most recently used (MRU) ghost:',
	arc_stats['mru_ghost_hits']))

	for title, value in cl_todo:
	prt_i2(title, f_perc(value, arc_stats['hits']), f_hits(value))

	# For some reason, anon_hits can turn negative, which is weird. Until we
	# have figured out why this happens, we just hide the problem, following
	# the behavior of the original arc_summary.
	if anon_hits >= 0:
	prt_i2('Anonymously used:',
	f_perc(anon_hits, arc_stats['hits']), f_hits(anon_hits))

	print()
	print('Cache hits by data type:')
	dt_todo = (('Demand data:', arc_stats['demand_data_hits']),
	('Demand prefetch data:', arc_stats['prefetch_data_hits']),
	('Demand metadata:', arc_stats['demand_metadata_hits']),
	('Demand prefetch metadata:',
	arc_stats['prefetch_metadata_hits']))

	for title, value in dt_todo:
	prt_i2(title, f_perc(value, arc_stats['hits']), f_hits(value))

	print()
	print('Cache misses by data type:')
	dm_todo = (('Demand data:', arc_stats['demand_data_misses']),
	('Demand prefetch data:',
	arc_stats['prefetch_data_misses']),
	('Demand metadata:', arc_stats['demand_metadata_misses']),
	('Demand prefetch metadata:',
	arc_stats['prefetch_metadata_misses']))

	for title, value in dm_todo:
	prt_i2(title, f_perc(value, arc_stats['misses']), f_hits(value))

	print()


	def section_dmu(kstats_dict):
	"""Collect information on the DMU"""

	zfetch_stats = isolate_section('zfetchstats', kstats_dict)

	zfetch_access_total = int(zfetch_stats['hits'])+int(zfetch_stats['misses'])

	prt_1('DMU prefetch efficiency:', f_hits(zfetch_access_total))
	prt_i2('Hit ratio:', f_perc(zfetch_stats['hits'], zfetch_access_total),
	f_hits(zfetch_stats['hits']))
	prt_i2('Miss ratio:', f_perc(zfetch_stats['misses'], zfetch_access_total),
	f_hits(zfetch_stats['misses']))
	print()


	def section_l2arc(kstats_dict):
	"""Collect information on L2ARC device if present. If not, tell user
	that we're skipping the section.
	"""

	# The L2ARC statistics live in the same section as the normal ARC stuff
	arc_stats = isolate_section('arcstats', kstats_dict)

	if arc_stats['l2_size'] == '0':
	print('L2ARC not detected, skipping section\n')
	return

	l2_errors = int(arc_stats['l2_writes_error']) +\
	int(arc_stats['l2_cksum_bad']) +\
	int(arc_stats['l2_io_error'])

	l2_access_total = int(arc_stats['l2_hits'])+int(arc_stats['l2_misses'])
	health = 'HEALTHY'

	if l2_errors > 0:
	health = 'DEGRADED'

	prt_1('L2ARC status:', health)

	l2_todo = (('Low memory aborts:', 'l2_abort_lowmem'),
	('Free on write:', 'l2_free_on_write'),
	('R/W clashes:', 'l2_rw_clash'),
	('Bad checksums:', 'l2_cksum_bad'),
	('I/O errors:', 'l2_io_error'))

	for title, value in l2_todo:
	prt_i1(title, f_hits(arc_stats[value]))

	print()
	prt_1('L2ARC size (adaptive):', f_bytes(arc_stats['l2_size']))
	prt_i2('Compressed:', f_perc(arc_stats['l2_asize'], arc_stats['l2_size']),
	f_bytes(arc_stats['l2_asize']))
	prt_i2('Header size:',
	f_perc(arc_stats['l2_hdr_size'], arc_stats['l2_size']),
	f_bytes(arc_stats['l2_hdr_size']))
	prt_i2('MFU allocated size:',
	f_perc(arc_stats['l2_mfu_asize'], arc_stats['l2_asize']),
	f_bytes(arc_stats['l2_mfu_asize']))
	prt_i2('MRU allocated size:',
	f_perc(arc_stats['l2_mru_asize'], arc_stats['l2_asize']),
	f_bytes(arc_stats['l2_mru_asize']))
	prt_i2('Prefetch allocated size:',
	f_perc(arc_stats['l2_prefetch_asize'], arc_stats['l2_asize']),
	f_bytes(arc_stats['l2_prefetch_asize']))
	prt_i2('Data (buffer content) allocated size:',
	f_perc(arc_stats['l2_bufc_data_asize'], arc_stats['l2_asize']),
	f_bytes(arc_stats['l2_bufc_data_asize']))
	prt_i2('Metadata (buffer content) allocated size:',
	f_perc(arc_stats['l2_bufc_metadata_asize'], arc_stats['l2_asize']),
	f_bytes(arc_stats['l2_bufc_metadata_asize']))

	print()
	prt_1('L2ARC breakdown:', f_hits(l2_access_total))
	prt_i2('Hit ratio:',
	f_perc(arc_stats['l2_hits'], l2_access_total),
	f_hits(arc_stats['l2_hits']))
	prt_i2('Miss ratio:',
	f_perc(arc_stats['l2_misses'], l2_access_total),
	f_hits(arc_stats['l2_misses']))
	prt_i1('Feeds:', f_hits(arc_stats['l2_feeds']))

	print()
	print('L2ARC writes:')

	if arc_stats['l2_writes_done'] != arc_stats['l2_writes_sent']:
	prt_i2('Writes sent:', 'FAULTED', f_hits(arc_stats['l2_writes_sent']))
	prt_i2('Done ratio:',
	f_perc(arc_stats['l2_writes_done'],
	arc_stats['l2_writes_sent']),
	f_hits(arc_stats['l2_writes_done']))
	prt_i2('Error ratio:',
	f_perc(arc_stats['l2_writes_error'],
	arc_stats['l2_writes_sent']),
	f_hits(arc_stats['l2_writes_error']))
	else:
	prt_i2('Writes sent:', '100 %', f_hits(arc_stats['l2_writes_sent']))

	print()
	print('L2ARC evicts:')
	prt_i1('Lock retries:', f_hits(arc_stats['l2_evict_lock_retry']))
	prt_i1('Upon reading:', f_hits(arc_stats['l2_evict_reading']))
	print()


	def section_spl(*_):
	"""Print the SPL parameters, if requested with alternative format
	and/or descriptions. This does not use kstats.
	"""

	if sys.platform.startswith('freebsd'):
	# No SPL support in FreeBSD
	return

	spls = get_spl_params()
	keylist = sorted(spls.keys())
	print('Solaris Porting Layer (SPL):')

	if ARGS.desc:
	descriptions = get_descriptions('spl')

	for key in keylist:
	value = spls[key]

	if ARGS.desc:
	try:
	print(INDENT+'#', descriptions[key])
	except KeyError:
	print(INDENT+'# (No description found)') # paranoid

	print(format_raw_line(key, value))

	print()


	def section_tunables(*_):
	"""Print the tunables, if requested with alternative format and/or
	descriptions. This does not use kstasts.
	"""

	tunables = get_tunable_params()
	keylist = sorted(tunables.keys())
	print('Tunables:')

	if ARGS.desc:
	descriptions = get_descriptions('zfs')

	for key in keylist:
	value = tunables[key]

	if ARGS.desc:
	try:
	print(INDENT+'#', descriptions[key])
	except KeyError:
	print(INDENT+'# (No description found)') # paranoid

	print(format_raw_line(key, value))

	print()


	def section_vdev(kstats_dict):
	"""Collect information on VDEV caches"""

	# Currently [Nov 2017] the VDEV cache is disabled, because it is actually
	# harmful. When this is the case, we just skip the whole entry. See
	# https://github.com/openzfs/zfs/blob/master/module/zfs/vdev_cache.c
	# for details
	tunables = get_vdev_params()

	if tunables[VDEV_CACHE_SIZE] == '0':
	print('VDEV cache disabled, skipping section\n')
	return

	vdev_stats = isolate_section('vdev_cache_stats', kstats_dict)

	vdev_cache_total = int(vdev_stats['hits']) +\
	int(vdev_stats['misses']) +\
	int(vdev_stats['delegations'])

	prt_1('VDEV cache summary:', f_hits(vdev_cache_total))
	prt_i2('Hit ratio:', f_perc(vdev_stats['hits'], vdev_cache_total),
	f_hits(vdev_stats['hits']))
	prt_i2('Miss ratio:', f_perc(vdev_stats['misses'], vdev_cache_total),
	f_hits(vdev_stats['misses']))
	prt_i2('Delegations:', f_perc(vdev_stats['delegations'], vdev_cache_total),
	f_hits(vdev_stats['delegations']))
	print()


	def section_zil(kstats_dict):
	"""Collect information on the ZFS Intent Log. Some of the information
	taken from https://github.com/openzfs/zfs/blob/master/include/sys/zil.h
	"""

	zil_stats = isolate_section('zil', kstats_dict)

	prt_1('ZIL committed transactions:',
	f_hits(zil_stats['zil_itx_count']))
	prt_i1('Commit requests:', f_hits(zil_stats['zil_commit_count']))
	prt_i1('Flushes to stable storage:',
	f_hits(zil_stats['zil_commit_writer_count']))
	prt_i2('Transactions to SLOG storage pool:',
	f_bytes(zil_stats['zil_itx_metaslab_slog_bytes']),
	f_hits(zil_stats['zil_itx_metaslab_slog_count']))
	prt_i2('Transactions to non-SLOG storage pool:',
	f_bytes(zil_stats['zil_itx_metaslab_normal_bytes']),
	f_hits(zil_stats['zil_itx_metaslab_normal_count']))
	print()


	section_calls = {'arc': section_arc,
	'archits': section_archits,
	'dmu': section_dmu,
	'l2arc': section_l2arc,
	'spl': section_spl,
	'tunables': section_tunables,
	'vdev': section_vdev,
	'zil': section_zil}


	def main():
	"""Run program. The options to draw a graph and to print all data raw are
	treated separately because they come with their own call.
	"""

	kstats = get_kstats()

	if ARGS.graph:
	draw_graph(kstats)
	sys.exit(0)

	print_header()

	if ARGS.raw:
	print_raw(kstats)

	elif ARGS.section:

	try:
	section_calls[ARGS.section](kstats)
	except KeyError:
	print('Error: Section "{0}" unknown'.format(ARGS.section))
	sys.exit(1)

	elif ARGS.page:
	print('WARNING: Pages are deprecated, please use "--section"\n')

	pages_to_calls = {1: 'arc',
	2: 'archits',
	3: 'l2arc',
	4: 'dmu',
	5: 'vdev',
	6: 'tunables'}

	try:
	call = pages_to_calls[ARGS.page]
	except KeyError:
	print('Error: Page "{0}" not supported'.format(ARGS.page))
	sys.exit(1)
	else:
	section_calls[call](kstats)

	else:
	# If no parameters were given, we print all sections. We might want to
	# change the sequence by hand
	calls = sorted(section_calls.keys())

	for section in calls:
	section_calls[section](kstats)

	sys.exit(0)


	if __name__ == '__main__':
	main()
	diff --git a/sys/contrib/openzfs/cmd/fsck_zfs/.gitignore b/sys/contrib/openzfs/cmd/fsck_zfs/.gitignore
	new file mode 100644
	index 000000000000..0edf0309e94a
	--- /dev/null
	+++ b/sys/contrib/openzfs/cmd/fsck_zfs/.gitignore
	@@ -0,0 +1 @@
	+/fsck.zfs
	diff --git a/sys/contrib/openzfs/cmd/fsck_zfs/Makefile.am b/sys/contrib/openzfs/cmd/fsck_zfs/Makefile.am
	index 2380f56fa4d4..67583ac75924 100644
	--- a/sys/contrib/openzfs/cmd/fsck_zfs/Makefile.am
	+++ b/sys/contrib/openzfs/cmd/fsck_zfs/Makefile.am
	@@ -1 +1,5 @@
	+include $(top_srcdir)/config/Substfiles.am
	+
	dist_sbin_SCRIPTS = fsck.zfs
	+
	+SUBSTFILES += $(dist_sbin_SCRIPTS)
	diff --git a/sys/contrib/openzfs/cmd/fsck_zfs/fsck.zfs b/sys/contrib/openzfs/cmd/fsck_zfs/fsck.zfs
	deleted file mode 100755
	index 129a7f39c388..000000000000
	--- a/sys/contrib/openzfs/cmd/fsck_zfs/fsck.zfs
	+++ /dev/null
	@@ -1,9 +0,0 @@
	-#!/bin/sh
	-#
	-# fsck.zfs: A fsck helper to accommodate distributions that expect
	-# to be able to execute a fsck on all filesystem types. Currently
	-# this script does nothing but it could be extended to act as a
	-# compatibility wrapper for 'zpool scrub'.
	-#
	-
	-exit 0
	diff --git a/sys/contrib/openzfs/cmd/fsck_zfs/fsck.zfs.in b/sys/contrib/openzfs/cmd/fsck_zfs/fsck.zfs.in
	new file mode 100755
	index 000000000000..32c8043e68fb
	--- /dev/null
	+++ b/sys/contrib/openzfs/cmd/fsck_zfs/fsck.zfs.in
	@@ -0,0 +1,44 @@
	+#!/bin/sh
	+#
	+# fsck.zfs: A fsck helper to accommodate distributions that expect
	+# to be able to execute a fsck on all filesystem types.
	+#
	+# This script simply bubbles up some already-known-about errors,
	+# see fsck.zfs(8)
	+#
	+
	+if [ "$#" = "0" ]; then
	+ echo "Usage: $0 [options] dataset…" >&2
	+ exit 16
	+fi
	+
	+ret=0
	+for dataset in "$@"; do
	+ case "$dataset" in
	+ -*)
	+ continue
	+ ;;
	+ *)
	+ ;;
	+ esac
	+
	+ pool="${dataset%%/*}"
	+
	+ case "$(@sbindir@/zpool list -Ho health "$pool")" in
	+ DEGRADED)
	+ ret=$(( $ret \| 4 ))
	+ ;;
	+ FAULTED)
	+ awk '!/^([[:space:]]#.)?$/ && $1 == "'"$dataset"'" && $3 == "zfs" {exit 1}' /etc/fstab \|\| \
	+ ret=$(( $ret \| 8 ))
	+ ;;
	+ "")
	+ # Pool not found, error printed by zpool(8)
	+ ret=$(( $ret \| 8 ))
	+ ;;
	+ *)
	+ ;;
	+ esac
	+done
	+
	+exit "$ret"
	diff --git a/sys/contrib/openzfs/cmd/mount_zfs/mount_zfs.c b/sys/contrib/openzfs/cmd/mount_zfs/mount_zfs.c
	index 5196c3e5cb5f..b9be69d1fb02 100644
	--- a/sys/contrib/openzfs/cmd/mount_zfs/mount_zfs.c
	+++ b/sys/contrib/openzfs/cmd/mount_zfs/mount_zfs.c
	@@ -1,387 +1,388 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2011 Lawrence Livermore National Security, LLC.
	*/

	#include <libintl.h>
	#include <unistd.h>
	#include <sys/file.h>
	#include <sys/mount.h>
	#include <sys/mntent.h>
	#include <sys/stat.h>
	#include <libzfs.h>
	#include <libzutil.h>
	#include <locale.h>
	#include <getopt.h>
	#include <fcntl.h>
	#include <errno.h>

	#define ZS_COMMENT 0x00000000 /* comment */
	#define ZS_ZFSUTIL 0x00000001 /* caller is zfs(8) */

	libzfs_handle_t *g_zfs;

	/*
	* Opportunistically convert a target string into a pool name. If the
	* string does not represent a block device with a valid zfs label
	* then it is passed through without modification.
	*/
	static void
	parse_dataset(const char target, char *dataset)
	{
	/*
	* Prior to util-linux 2.36.2, if a file or directory in the
	* current working directory was named 'dataset' then mount(8)
	* would prepend the current working directory to the dataset.
	* Check for it and strip the prepended path when it is added.
	*/
	char cwd[PATH_MAX];
	if (getcwd(cwd, PATH_MAX) == NULL) {
	perror("getcwd");
	return;
	}
	int len = strlen(cwd);
	if (strncmp(cwd, target, len) == 0)
	target += len;

	/* Assume pool/dataset is more likely */
	strlcpy(*dataset, target, PATH_MAX);

	int fd = open(target, O_RDONLY \| O_CLOEXEC);
	if (fd < 0)
	return;

	nvlist_t *cfg = NULL;
	if (zpool_read_label(fd, &cfg, NULL) == 0) {
	char *nm = NULL;
	if (!nvlist_lookup_string(cfg, ZPOOL_CONFIG_POOL_NAME, &nm))
	strlcpy(*dataset, nm, PATH_MAX);
	nvlist_free(cfg);
	}

	if (close(fd))
	perror("close");
	}

	/*
	* Update the mtab_* code to use the libmount library when it is commonly
	* available otherwise fallback to legacy mode. The mount(8) utility will
	* manage the lock file for us to prevent racing updates to /etc/mtab.
	*/
	static int
	mtab_is_writeable(void)
	{
	struct stat st;
	int error, fd;

	error = lstat("/etc/mtab", &st);
	if (error \|\| S_ISLNK(st.st_mode))
	return (0);

	fd = open("/etc/mtab", O_RDWR \| O_CREAT, 0644);
	if (fd < 0)
	return (0);

	close(fd);
	return (1);
	}

	static int
	mtab_update(char dataset, char mntpoint, char type, char mntopts)
	{
	struct mntent mnt;
	FILE *fp;
	int error;

	mnt.mnt_fsname = dataset;
	mnt.mnt_dir = mntpoint;
	mnt.mnt_type = type;
	mnt.mnt_opts = mntopts ? mntopts : "";
	mnt.mnt_freq = 0;
	mnt.mnt_passno = 0;

	fp = setmntent("/etc/mtab", "a+");
	if (!fp) {
	(void) fprintf(stderr, gettext(
	"filesystem '%s' was mounted, but /etc/mtab "
	"could not be opened due to error: %s\n"),
	dataset, strerror(errno));
	return (MOUNT_FILEIO);
	}

	error = addmntent(fp, &mnt);
	if (error) {
	(void) fprintf(stderr, gettext(
	"filesystem '%s' was mounted, but /etc/mtab "
	"could not be updated due to error: %s\n"),
	dataset, strerror(errno));
	return (MOUNT_FILEIO);
	}

	(void) endmntent(fp);

	return (MOUNT_SUCCESS);
	}

	int
	main(int argc, char **argv)
	{
	zfs_handle_t *zhp;
	char prop[ZFS_MAXPROPLEN];
	uint64_t zfs_version = 0;
	char mntopts[MNT_LINE_MAX] = { '\0' };
	char badopt[MNT_LINE_MAX] = { '\0' };
	char mtabopt[MNT_LINE_MAX] = { '\0' };
	char mntpoint[PATH_MAX];
	char dataset[PATH_MAX], *pdataset = dataset;
	unsigned long mntflags = 0, zfsflags = 0, remount = 0;
	int sloppy = 0, fake = 0, verbose = 0, nomtab = 0, zfsutil = 0;
	int error, c;

	(void) setlocale(LC_ALL, "");
	(void) setlocale(LC_NUMERIC, "C");
	(void) textdomain(TEXT_DOMAIN);

	opterr = 0;

	/* check options */
	while ((c = getopt_long(argc, argv, "sfnvo:h?", 0, 0)) != -1) {
	switch (c) {
	case 's':
	sloppy = 1;
	break;
	case 'f':
	fake = 1;
	break;
	case 'n':
	nomtab = 1;
	break;
	case 'v':
	verbose++;
	break;
	case 'o':
	(void) strlcpy(mntopts, optarg, sizeof (mntopts));
	break;
	case 'h':
	case '?':
	- (void) fprintf(stderr, gettext("Invalid option '%c'\n"),
	- optopt);
	+ if (optopt)
	+ (void) fprintf(stderr,
	+ gettext("Invalid option '%c'\n"), optopt);
	(void) fprintf(stderr, gettext("Usage: mount.zfs "
	- "[-sfnv] [-o options] <dataset> <mountpoint>\n"));
	+ "[-sfnvh] [-o options] <dataset> <mountpoint>\n"));
	return (MOUNT_USAGE);
	}
	}

	argc -= optind;
	argv += optind;

	/* check that we only have two arguments */
	if (argc != 2) {
	if (argc == 0)
	(void) fprintf(stderr, gettext("missing dataset "
	"argument\n"));
	else if (argc == 1)
	(void) fprintf(stderr,
	gettext("missing mountpoint argument\n"));
	else
	(void) fprintf(stderr, gettext("too many arguments\n"));
	(void) fprintf(stderr, "usage: mount <dataset> <mountpoint>\n");
	return (MOUNT_USAGE);
	}

	parse_dataset(argv[0], &pdataset);

	/* canonicalize the mount point */
	if (realpath(argv[1], mntpoint) == NULL) {
	(void) fprintf(stderr, gettext("filesystem '%s' cannot be "
	"mounted at '%s' due to canonicalization error: %s\n"),
	dataset, argv[1], strerror(errno));
	return (MOUNT_SYSERR);
	}

	/* validate mount options and set mntflags */
	error = zfs_parse_mount_options(mntopts, &mntflags, &zfsflags, sloppy,
	badopt, mtabopt);
	if (error) {
	switch (error) {
	case ENOMEM:
	(void) fprintf(stderr, gettext("filesystem '%s' "
	"cannot be mounted due to a memory allocation "
	"failure.\n"), dataset);
	return (MOUNT_SYSERR);
	case ENOENT:
	(void) fprintf(stderr, gettext("filesystem '%s' "
	"cannot be mounted due to invalid option "
	"'%s'.\n"), dataset, badopt);
	(void) fprintf(stderr, gettext("Use the '-s' option "
	"to ignore the bad mount option.\n"));
	return (MOUNT_USAGE);
	default:
	(void) fprintf(stderr, gettext("filesystem '%s' "
	"cannot be mounted due to internal error %d.\n"),
	dataset, error);
	return (MOUNT_SOFTWARE);
	}
	}

	if (verbose)
	(void) fprintf(stdout, gettext("mount.zfs:\n"
	" dataset: \"%s\"\n mountpoint: \"%s\"\n"
	" mountflags: 0x%lx\n zfsflags: 0x%lx\n"
	" mountopts: \"%s\"\n mtabopts: \"%s\"\n"),
	dataset, mntpoint, mntflags, zfsflags, mntopts, mtabopt);

	if (mntflags & MS_REMOUNT) {
	nomtab = 1;
	remount = 1;
	}

	if (zfsflags & ZS_ZFSUTIL)
	zfsutil = 1;

	if ((g_zfs = libzfs_init()) == NULL) {
	(void) fprintf(stderr, "%s\n", libzfs_error_init(errno));
	return (MOUNT_SYSERR);
	}

	/* try to open the dataset to access the mount point */
	if ((zhp = zfs_open(g_zfs, dataset,
	ZFS_TYPE_FILESYSTEM \| ZFS_TYPE_SNAPSHOT)) == NULL) {
	(void) fprintf(stderr, gettext("filesystem '%s' cannot be "
	"mounted, unable to open the dataset\n"), dataset);
	libzfs_fini(g_zfs);
	return (MOUNT_USAGE);
	}

	zfs_adjust_mount_options(zhp, mntpoint, mntopts, mtabopt);

	/* treat all snapshots as legacy mount points */
	if (zfs_get_type(zhp) == ZFS_TYPE_SNAPSHOT)
	(void) strlcpy(prop, ZFS_MOUNTPOINT_LEGACY, ZFS_MAXPROPLEN);
	else
	(void) zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, prop,
	sizeof (prop), NULL, NULL, 0, B_FALSE);

	/*
	* Fetch the max supported zfs version in case we get ENOTSUP
	* back from the mount command, since we need the zfs handle
	* to do so.
	*/
	zfs_version = zfs_prop_get_int(zhp, ZFS_PROP_VERSION);
	if (zfs_version == 0) {
	fprintf(stderr, gettext("unable to fetch "
	"ZFS version for filesystem '%s'\n"), dataset);
	return (MOUNT_SYSERR);
	}

	zfs_close(zhp);
	libzfs_fini(g_zfs);

	/*
	* Legacy mount points may only be mounted using 'mount', never using
	* 'zfs mount'. However, since 'zfs mount' actually invokes 'mount'
	* we differentiate the two cases using the 'zfsutil' mount option.
	* This mount option should only be supplied by the 'zfs mount' util.
	*
	* The only exception to the above rule is '-o remount' which is
	* always allowed for non-legacy datasets. This is done because when
	* using zfs as your root file system both rc.sysinit/umountroot and
	* systemd depend on 'mount -o remount <mountpoint>' to work.
	*/
	if (zfsutil && (strcmp(prop, ZFS_MOUNTPOINT_LEGACY) == 0)) {
	(void) fprintf(stderr, gettext(
	"filesystem '%s' cannot be mounted using 'zfs mount'.\n"
	"Use 'zfs set mountpoint=%s' or 'mount -t zfs %s %s'.\n"
	"See zfs(8) for more information.\n"),
	dataset, mntpoint, dataset, mntpoint);
	return (MOUNT_USAGE);
	}

	if (!zfsutil && !(remount \|\| fake) &&
	strcmp(prop, ZFS_MOUNTPOINT_LEGACY)) {
	(void) fprintf(stderr, gettext(
	"filesystem '%s' cannot be mounted using 'mount'.\n"
	"Use 'zfs set mountpoint=%s' or 'zfs mount %s'.\n"
	"See zfs(8) for more information.\n"),
	dataset, "legacy", dataset);
	return (MOUNT_USAGE);
	}

	if (!fake) {
	error = mount(dataset, mntpoint, MNTTYPE_ZFS,
	mntflags, mntopts);
	}

	if (error) {
	switch (errno) {
	case ENOENT:
	(void) fprintf(stderr, gettext("mount point "
	"'%s' does not exist\n"), mntpoint);
	return (MOUNT_SYSERR);
	case EBUSY:
	(void) fprintf(stderr, gettext("filesystem "
	"'%s' is already mounted\n"), dataset);
	return (MOUNT_BUSY);
	case ENOTSUP:
	if (zfs_version > ZPL_VERSION) {
	(void) fprintf(stderr,
	gettext("filesystem '%s' (v%d) is not "
	"supported by this implementation of "
	"ZFS (max v%d).\n"), dataset,
	(int)zfs_version, (int)ZPL_VERSION);
	} else {
	(void) fprintf(stderr,
	gettext("filesystem '%s' mount "
	"failed for unknown reason.\n"), dataset);
	}
	return (MOUNT_SYSERR);
	#ifdef MS_MANDLOCK
	case EPERM:
	if (mntflags & MS_MANDLOCK) {
	(void) fprintf(stderr, gettext("filesystem "
	"'%s' has the 'nbmand=on' property set, "
	"this mount\noption may be disabled in "
	"your kernel. Use 'zfs set nbmand=off'\n"
	"to disable this option and try to "
	"mount the filesystem again.\n"), dataset);
	return (MOUNT_SYSERR);
	}
	/* fallthru */
	#endif
	default:
	(void) fprintf(stderr, gettext("filesystem "
	"'%s' can not be mounted: %s\n"), dataset,
	strerror(errno));
	return (MOUNT_USAGE);
	}
	}

	if (!nomtab && mtab_is_writeable()) {
	error = mtab_update(dataset, mntpoint, MNTTYPE_ZFS, mtabopt);
	if (error)
	return (error);
	}

	return (MOUNT_SUCCESS);
	}
	diff --git a/sys/contrib/openzfs/cmd/vdev_id/vdev_id b/sys/contrib/openzfs/cmd/vdev_id/vdev_id
	index d8918da1078c..d349ba43ca90 100755
	--- a/sys/contrib/openzfs/cmd/vdev_id/vdev_id
	+++ b/sys/contrib/openzfs/cmd/vdev_id/vdev_id
	@@ -1,787 +1,788 @@
	#!/bin/sh
	#
	# vdev_id: udev helper to generate user-friendly names for JBOD disks
	#
	# This script parses the file /etc/zfs/vdev_id.conf to map a
	# physical path in a storage topology to a channel name. The
	# channel name is combined with a disk enclosure slot number to
	# create an alias that reflects the physical location of the drive.
	# This is particularly helpful when it comes to tasks like replacing
	# failed drives. Slot numbers may also be re-mapped in case the
	# default numbering is unsatisfactory. The drive aliases will be
	# created as symbolic links in /dev/disk/by-vdev.
	#
	# The currently supported topologies are sas_direct and sas_switch.
	# A multipath mode is supported in which dm-mpath devices are
	# handled by examining the first-listed running component disk. In
	# multipath mode the configuration file should contain a channel
	# definition with the same name for each path to a given enclosure.
	#
	# The alias keyword provides a simple way to map already-existing
	# device symlinks to more convenient names. It is suitable for
	# small, static configurations or for sites that have some automated
	# way to generate the mapping file.
	#
	#
	# Some example configuration files are given below.

	# #
	# # Example vdev_id.conf - sas_direct.
	# #
	#
	# multipath no
	# topology sas_direct
	# phys_per_port 4
	# slot bay
	#
	# # PCI_ID HBA PORT CHANNEL NAME
	# channel 85:00.0 1 A
	# channel 85:00.0 0 B
	# channel 86:00.0 1 C
	# channel 86:00.0 0 D
	#
	# # Custom mapping for Channel A
	#
	# # Linux Mapped
	# # Slot Slot Channel
	# slot 1 7 A
	# slot 2 10 A
	# slot 3 3 A
	# slot 4 6 A
	#
	# # Default mapping for B, C, and D
	# slot 1 4
	# slot 2 2
	# slot 3 1
	# slot 4 3

	# #
	# # Example vdev_id.conf - sas_switch
	# #
	#
	# topology sas_switch
	#
	# # SWITCH PORT CHANNEL NAME
	# channel 1 A
	# channel 2 B
	# channel 3 C
	# channel 4 D

	# #
	# # Example vdev_id.conf - multipath
	# #
	#
	# multipath yes
	#
	# # PCI_ID HBA PORT CHANNEL NAME
	# channel 85:00.0 1 A
	# channel 85:00.0 0 B
	# channel 86:00.0 1 A
	# channel 86:00.0 0 B

	# #
	# # Example vdev_id.conf - multipath / multijbod-daisychaining
	# #
	#
	# multipath yes
	# multijbod yes
	#
	# # PCI_ID HBA PORT CHANNEL NAME
	# channel 85:00.0 1 A
	# channel 85:00.0 0 B
	# channel 86:00.0 1 A
	# channel 86:00.0 0 B

	# #
	# # Example vdev_id.conf - multipath / mixed
	# #
	#
	# multipath yes
	# slot mix
	#
	# # PCI_ID HBA PORT CHANNEL NAME
	# channel 85:00.0 3 A
	# channel 85:00.0 2 B
	# channel 86:00.0 3 A
	# channel 86:00.0 2 B
	# channel af:00.0 0 C
	# channel af:00.0 1 C

	# #
	# # Example vdev_id.conf - alias
	# #
	#
	# # by-vdev
	# # name fully qualified or base name of device link
	# alias d1 /dev/disk/by-id/wwn-0x5000c5002de3b9ca
	# alias d2 wwn-0x5000c5002def789e

	PATH=/bin:/sbin:/usr/bin:/usr/sbin
	CONFIG=/etc/zfs/vdev_id.conf
	PHYS_PER_PORT=
	DEV=
	TOPOLOGY=
	BAY=
	ENCL_ID=""
	UNIQ_ENCL_ID=""

	usage() {
	cat << EOF
	Usage: vdev_id [-h]
	vdev_id <-d device> [-c config_file] [-p phys_per_port]
	[-g sas_direct\|sas_switch\|scsi] [-m]

	-c specify name of an alternative config file [default=$CONFIG]
	-d specify basename of device (i.e. sda)
	-e Create enclose device symlinks only (/dev/by-enclosure)
	-g Storage network topology [default="$TOPOLOGY"]
	-m Run in multipath mode
	-j Run in multijbod mode
	-p number of phy's per switch port [default=$PHYS_PER_PORT]
	-h show this summary
	EOF
	exit 0
	}

	map_slot() {
	LINUX_SLOT=$1
	CHANNEL=$2

	- MAPPED_SLOT=$(awk '$1 == "slot" && $2 == "${LINUX_SLOT}" && \
	- $4 ~ /^${CHANNEL}$\|^$/ { print $3; exit}' $CONFIG)
	+ MAPPED_SLOT=$(awk -v linux_slot="$LINUX_SLOT" -v channel="$CHANNEL" \
	+ '$1 == "slot" && $2 == linux_slot && \
	+ ($4 ~ "^"channel"$" \|\| $4 ~ /^$/) { print $3; exit}' $CONFIG)
	if [ -z "$MAPPED_SLOT" ] ; then
	MAPPED_SLOT=$LINUX_SLOT
	fi
	printf "%d" "${MAPPED_SLOT}"
	}

	map_channel() {
	MAPPED_CHAN=
	PCI_ID=$1
	PORT=$2

	case $TOPOLOGY in
	"sas_switch")
	MAPPED_CHAN=$(awk -v port="$PORT" \
	- '$1 == "channel" && $2 == ${PORT} \
	+ '$1 == "channel" && $2 == port \
	{ print $3; exit }' $CONFIG)
	;;
	"sas_direct"\|"scsi")
	MAPPED_CHAN=$(awk -v pciID="$PCI_ID" -v port="$PORT" \
	'$1 == "channel" && $2 == pciID && $3 == port \
	{print $4}' $CONFIG)
	;;
	esac
	printf "%s" "${MAPPED_CHAN}"
	}

	get_encl_id() {
	set -- $(echo $1)
	count=$#

	i=1
	while [ $i -le $count ] ; do
	d=$(eval echo '$'{$i})
	id=$(cat "/sys/class/enclosure/${d}/id")
	ENCL_ID="${ENCL_ID} $id"
	i=$((i + 1))
	done
	}

	get_uniq_encl_id() {
	for uuid in ${ENCL_ID}; do
	found=0

	for count in ${UNIQ_ENCL_ID}; do
	if [ $count = $uuid ]; then
	found=1
	break
	fi
	done

	if [ $found -eq 0 ]; then
	UNIQ_ENCL_ID="${UNIQ_ENCL_ID} $uuid"
	fi
	done
	}

	# map_jbod explainer: The bsg driver knows the difference between a SAS
	# expander and fanout expander. Use hostX instance along with top-level
	# (whole enclosure) expander instances in /sys/class/enclosure and
	# matching a field in an array of expanders, using the index of the
	# matched array field as the enclosure instance, thereby making jbod IDs
	# dynamic. Avoids reliance on high overhead userspace commands like
	# multipath and lsscsi and instead uses existing sysfs data. $HOSTCHAN
	# variable derived from devpath gymnastics in sas_handler() function.
	map_jbod() {
	DEVEXP=$(ls -l "/sys/block/$DEV/device/" \| grep enclos \| awk -F/ '{print $(NF-1) }')
	DEV=$1

	# Use "set --" to create index values (Arrays)
	set -- $(ls -l /sys/class/enclosure \| grep -v "^total" \| awk '{print $9}')
	# Get count of total elements
	JBOD_COUNT=$#
	JBOD_ITEM=$*

	# Build JBODs (enclosure) id from sys/class/enclosure/<dev>/id
	get_encl_id "$JBOD_ITEM"
	# Different expander instances for each paths.
	# Filter out and keep only unique id.
	get_uniq_encl_id

	# Identify final 'mapped jbod'
	j=0
	for count in ${UNIQ_ENCL_ID}; do
	i=1
	j=$((j + 1))
	while [ $i -le $JBOD_COUNT ] ; do
	d=$(eval echo '$'{$i})
	id=$(cat "/sys/class/enclosure/${d}/id")
	if [ "$d" = "$DEVEXP" ] && [ $id = $count ] ; then
	MAPPED_JBOD=$j
	break
	fi
	i=$((i + 1))
	done
	done

	printf "%d" "${MAPPED_JBOD}"
	}

	sas_handler() {
	if [ -z "$PHYS_PER_PORT" ] ; then
	PHYS_PER_PORT=$(awk '$1 == "phys_per_port" \
	{print $2; exit}' $CONFIG)
	fi
	PHYS_PER_PORT=${PHYS_PER_PORT:-4}

	if ! echo "$PHYS_PER_PORT" \| grep -q -E '^[0-9]+$' ; then
	echo "Error: phys_per_port value $PHYS_PER_PORT is non-numeric"
	exit 1
	fi

	if [ -z "$MULTIPATH_MODE" ] ; then
	MULTIPATH_MODE=$(awk '$1 == "multipath" \
	{print $2; exit}' $CONFIG)
	fi

	if [ -z "$MULTIJBOD_MODE" ] ; then
	MULTIJBOD_MODE=$(awk '$1 == "multijbod" \
	{print $2; exit}' $CONFIG)
	fi

	# Use first running component device if we're handling a dm-mpath device
	if [ "$MULTIPATH_MODE" = "yes" ] ; then
	# If udev didn't tell us the UUID via DM_NAME, check /dev/mapper
	if [ -z "$DM_NAME" ] ; then
	DM_NAME=$(ls -l --full-time /dev/mapper \|
	grep "$DEV"$ \| awk '{print $9}')
	fi

	# For raw disks udev exports DEVTYPE=partition when
	# handling partitions, and the rules can be written to
	# take advantage of this to append a -part suffix. For
	# dm devices we get DEVTYPE=disk even for partitions so
	# we have to append the -part suffix directly in the
	# helper.
	if [ "$DEVTYPE" != "partition" ] ; then
	# Match p[number], remove the 'p' and prepend "-part"
	PART=$(echo "$DM_NAME" \|
	awk 'match($0,/p[0-9]+$/) {print "-part"substr($0,RSTART+1,RLENGTH-1)}')
	fi

	# Strip off partition information.
	DM_NAME=$(echo "$DM_NAME" \| sed 's/p[0-9][0-9]*$//')
	if [ -z "$DM_NAME" ] ; then
	return
	fi

	# Utilize DM device name to gather subordinate block devices
	# using sysfs to avoid userspace utilities

	# If our DEVNAME is something like /dev/dm-177, then we may be
	# able to get our DMDEV from it.
	DMDEV=$(echo $DEVNAME \| sed 's;/dev/;;g')
	if [ ! -e /sys/block/$DMDEV/slaves/* ] ; then
	# It's not there, try looking in /dev/mapper
	DMDEV=$(ls -l --full-time /dev/mapper \| grep $DM_NAME \|
	awk '{gsub("../", " "); print $NF}')
	fi

	# Use sysfs pointers in /sys/block/dm-X/slaves because using
	# userspace tools creates lots of overhead and should be avoided
	# whenever possible. Use awk to isolate lowest instance of
	# sd device member in dm device group regardless of string
	# length.
	DEV=$(ls "/sys/block/$DMDEV/slaves" \| awk '
	{ len=sprintf ("%20s",length($0)); gsub(/ /,0,str); a[NR]=len "_" $0; }
	END {
	asort(a)
	print substr(a[1],22)
	}')

	if [ -z "$DEV" ] ; then
	return
	fi
	fi

	if echo "$DEV" \| grep -q ^/devices/ ; then
	sys_path=$DEV
	else
	sys_path=$(udevadm info -q path -p "/sys/block/$DEV" 2>/dev/null)
	fi

	# Use positional parameters as an ad-hoc array
	set -- $(echo "$sys_path" \| tr / ' ')
	num_dirs=$#
	scsi_host_dir="/sys"

	# Get path up to /sys/.../hostX
	i=1

	while [ $i -le "$num_dirs" ] ; do
	d=$(eval echo '$'{$i})
	scsi_host_dir="$scsi_host_dir/$d"
	echo "$d" \| grep -q -E '^host[0-9]+$' && break
	i=$((i + 1))
	done

	# Lets grab the SAS host channel number and save it for JBOD sorting later
	HOSTCHAN=$(echo "$d" \| awk -F/ '{ gsub("host","",$NF); print $NF}')

	if [ $i = "$num_dirs" ] ; then
	return
	fi

	PCI_ID=$(eval echo '$'{$((i -1))} \| awk -F: '{print $2":"$3}')

	# In sas_switch mode, the directory four levels beneath
	# /sys/.../hostX contains symlinks to phy devices that reveal
	# the switch port number. In sas_direct mode, the phy links one
	# directory down reveal the HBA port.
	port_dir=$scsi_host_dir

	case $TOPOLOGY in
	"sas_switch") j=$((i + 4)) ;;
	"sas_direct") j=$((i + 1)) ;;
	esac

	i=$((i + 1))

	while [ $i -le $j ] ; do
	port_dir="$port_dir/$(eval echo '$'{$i})"
	i=$((i + 1))
	done

	PHY=$(ls -d "$port_dir"/phy* 2>/dev/null \| head -1 \| awk -F: '{print $NF}')
	if [ -z "$PHY" ] ; then
	PHY=0
	fi
	PORT=$((PHY / PHYS_PER_PORT))

	# Look in /sys/.../sas_device/end_device-X for the bay_identifier
	# attribute.
	end_device_dir=$port_dir

	while [ $i -lt "$num_dirs" ] ; do
	d=$(eval echo '$'{$i})
	end_device_dir="$end_device_dir/$d"
	if echo "$d" \| grep -q '^end_device' ; then
	end_device_dir="$end_device_dir/sas_device/$d"
	break
	fi
	i=$((i + 1))
	done

	# Add 'mix' slot type for environments where dm-multipath devices
	# include end-devices connected via SAS expanders or direct connection
	# to SAS HBA. A mixed connectivity environment such as pool devices
	# contained in a SAS JBOD and spare drives or log devices directly
	# connected in a server backplane without expanders in the I/O path.
	SLOT=

	case $BAY in
	"bay")
	SLOT=$(cat "$end_device_dir/bay_identifier" 2>/dev/null)
	;;
	"mix")
	if [ $(cat "$end_device_dir/bay_identifier" 2>/dev/null) ] ; then
	SLOT=$(cat "$end_device_dir/bay_identifier" 2>/dev/null)
	else
	SLOT=$(cat "$end_device_dir/phy_identifier" 2>/dev/null)
	fi
	;;
	"phy")
	SLOT=$(cat "$end_device_dir/phy_identifier" 2>/dev/null)
	;;
	"port")
	d=$(eval echo '$'{$i})
	SLOT=$(echo "$d" \| sed -e 's/^.*://')
	;;
	"id")
	i=$((i + 1))
	d=$(eval echo '$'{$i})
	SLOT=$(echo "$d" \| sed -e 's/^.*://')
	;;
	"lun")
	i=$((i + 2))
	d=$(eval echo '$'{$i})
	SLOT=$(echo "$d" \| sed -e 's/^.*://')
	;;
	"ses")
	# look for this SAS path in all SCSI Enclosure Services
	# (SES) enclosures
	sas_address=$(cat "$end_device_dir/sas_address" 2>/dev/null)
	enclosures=$(lsscsi -g \| \
	sed -n -e '/enclosu/s/^.* $[^ ][^ ]$ $/\1/p')
	for enclosure in $enclosures; do
	set -- $(sg_ses -p aes "$enclosure" \| \
	awk "/device slot number:/{slot=\$12} \
	/SAS address: $sas_address/\
	{print slot}")
	SLOT=$1
	if [ -n "$SLOT" ] ; then
	break
	fi
	done
	;;
	esac
	if [ -z "$SLOT" ] ; then
	return
	fi

	if [ "$MULTIJBOD_MODE" = "yes" ] ; then
	CHAN=$(map_channel "$PCI_ID" "$PORT")
	SLOT=$(map_slot "$SLOT" "$CHAN")
	JBOD=$(map_jbod "$DEV")

	if [ -z "$CHAN" ] ; then
	return
	fi
	echo "${CHAN}"-"${JBOD}"-"${SLOT}${PART}"
	else
	CHAN=$(map_channel "$PCI_ID" "$PORT")
	SLOT=$(map_slot "$SLOT" "$CHAN")

	if [ -z "$CHAN" ] ; then
	return
	fi
	echo "${CHAN}${SLOT}${PART}"
	fi
	}

	scsi_handler() {
	if [ -z "$FIRST_BAY_NUMBER" ] ; then
	FIRST_BAY_NUMBER=$(awk '$1 == "first_bay_number" \
	{print $2; exit}' $CONFIG)
	fi
	FIRST_BAY_NUMBER=${FIRST_BAY_NUMBER:-0}

	if [ -z "$PHYS_PER_PORT" ] ; then
	PHYS_PER_PORT=$(awk '$1 == "phys_per_port" \
	{print $2; exit}' $CONFIG)
	fi
	PHYS_PER_PORT=${PHYS_PER_PORT:-4}

	if ! echo "$PHYS_PER_PORT" \| grep -q -E '^[0-9]+$' ; then
	echo "Error: phys_per_port value $PHYS_PER_PORT is non-numeric"
	exit 1
	fi

	if [ -z "$MULTIPATH_MODE" ] ; then
	MULTIPATH_MODE=$(awk '$1 == "multipath" \
	{print $2; exit}' $CONFIG)
	fi

	# Use first running component device if we're handling a dm-mpath device
	if [ "$MULTIPATH_MODE" = "yes" ] ; then
	# If udev didn't tell us the UUID via DM_NAME, check /dev/mapper
	if [ -z "$DM_NAME" ] ; then
	DM_NAME=$(ls -l --full-time /dev/mapper \|
	grep "$DEV"$ \| awk '{print $9}')
	fi

	# For raw disks udev exports DEVTYPE=partition when
	# handling partitions, and the rules can be written to
	# take advantage of this to append a -part suffix. For
	# dm devices we get DEVTYPE=disk even for partitions so
	# we have to append the -part suffix directly in the
	# helper.
	if [ "$DEVTYPE" != "partition" ] ; then
	# Match p[number], remove the 'p' and prepend "-part"
	PART=$(echo "$DM_NAME" \|
	awk 'match($0,/p[0-9]+$/) {print "-part"substr($0,RSTART+1,RLENGTH-1)}')
	fi

	# Strip off partition information.
	DM_NAME=$(echo "$DM_NAME" \| sed 's/p[0-9][0-9]*$//')
	if [ -z "$DM_NAME" ] ; then
	return
	fi

	# Get the raw scsi device name from multipath -ll. Strip off
	# leading pipe symbols to make field numbering consistent.
	DEV=$(multipath -ll "$DM_NAME" \|
	awk '/running/{gsub("^[\|]"," "); print $3 ; exit}')
	if [ -z "$DEV" ] ; then
	return
	fi
	fi

	if echo "$DEV" \| grep -q ^/devices/ ; then
	sys_path=$DEV
	else
	sys_path=$(udevadm info -q path -p "/sys/block/$DEV" 2>/dev/null)
	fi

	# expect sys_path like this, for example:
	# /devices/pci0000:00/0000:00:0b.0/0000:09:00.0/0000:0a:05.0/0000:0c:00.0/host3/target3:1:0/3:1:0:21/block/sdv

	# Use positional parameters as an ad-hoc array
	set -- $(echo "$sys_path" \| tr / ' ')
	num_dirs=$#
	scsi_host_dir="/sys"

	# Get path up to /sys/.../hostX
	i=1

	while [ $i -le "$num_dirs" ] ; do
	d=$(eval echo '$'{$i})
	scsi_host_dir="$scsi_host_dir/$d"

	echo "$d" \| grep -q -E '^host[0-9]+$' && break
	i=$((i + 1))
	done

	if [ $i = "$num_dirs" ] ; then
	return
	fi

	PCI_ID=$(eval echo '$'{$((i -1))} \| awk -F: '{print $2":"$3}')

	# In scsi mode, the directory two levels beneath
	# /sys/.../hostX reveals the port and slot.
	port_dir=$scsi_host_dir
	j=$((i + 2))

	i=$((i + 1))
	while [ $i -le $j ] ; do
	port_dir="$port_dir/$(eval echo '$'{$i})"
	i=$((i + 1))
	done

	set -- $(echo "$port_dir" \| sed -e 's/^.:$[^:]$:$[^:]*$$/\1 \2/')
	PORT=$1
	SLOT=$(($2 + FIRST_BAY_NUMBER))

	if [ -z "$SLOT" ] ; then
	return
	fi

	CHAN=$(map_channel "$PCI_ID" "$PORT")
	SLOT=$(map_slot "$SLOT" "$CHAN")

	if [ -z "$CHAN" ] ; then
	return
	fi
	echo "${CHAN}${SLOT}${PART}"
	}

	# Figure out the name for the enclosure symlink
	enclosure_handler () {
	# We get all the info we need from udev's DEVPATH variable:
	#
	# DEVPATH=/sys/devices/pci0000:00/0000:00:03.0/0000:05:00.0/host0/subsystem/devices/0:0:0:0/scsi_generic/sg0

	# Get the enclosure ID ("0:0:0:0")
	ENC=$(basename $(readlink -m "/sys/$DEVPATH/../.."))
	if [ ! -d "/sys/class/enclosure/$ENC" ] ; then
	# Not an enclosure, bail out
	return
	fi

	# Get the long sysfs device path to our enclosure. Looks like:
	# /devices/pci0000:00/0000:00:03.0/0000:05:00.0/host0/port-0:0/ ... /enclosure/0:0:0:0

	ENC_DEVICE=$(readlink "/sys/class/enclosure/$ENC")

	# Grab the full path to the hosts port dir:
	# /devices/pci0000:00/0000:00:03.0/0000:05:00.0/host0/port-0:0
	PORT_DIR=$(echo "$ENC_DEVICE" \| grep -Eo '.+host[0-9]+/port-[0-9]+:[0-9]+')

	# Get the port number
	PORT_ID=$(echo "$PORT_DIR" \| grep -Eo "[0-9]+$")

	# The PCI directory is two directories up from the port directory
	# /sys/devices/pci0000:00/0000:00:03.0/0000:05:00.0
	PCI_ID_LONG=$(basename $(readlink -m "/sys/$PORT_DIR/../.."))

	# Strip down the PCI address from 0000:05:00.0 to 05:00.0
	PCI_ID=$(echo "$PCI_ID_LONG" \| sed -r 's/^[0-9]+://g')

	# Name our device according to vdev_id.conf (like "L0" or "U1").
	NAME=$(awk '/channel/{if ($1 == "channel" && $2 == "$PCI_ID" && \
	$3 == "$PORT_ID") {print ${4}int(count[$4])}; count[$4]++}' $CONFIG)

	echo "${NAME}"
	}

	alias_handler () {
	# Special handling is needed to correctly append a -part suffix
	# to partitions of device mapper devices. The DEVTYPE attribute
	# is normally set to "disk" instead of "partition" in this case,
	# so the udev rules won't handle that for us as they do for
	# "plain" block devices.
	#
	# For example, we may have the following links for a device and its
	# partitions,
	#
	# /dev/disk/by-id/dm-name-isw_dibgbfcije_ARRAY0 -> ../../dm-0
	# /dev/disk/by-id/dm-name-isw_dibgbfcije_ARRAY0p1 -> ../../dm-1
	# /dev/disk/by-id/dm-name-isw_dibgbfcije_ARRAY0p2 -> ../../dm-3
	#
	# and the following alias in vdev_id.conf.
	#
	# alias A0 dm-name-isw_dibgbfcije_ARRAY0
	#
	# The desired outcome is for the following links to be created
	# without having explicitly defined aliases for the partitions.
	#
	# /dev/disk/by-vdev/A0 -> ../../dm-0
	# /dev/disk/by-vdev/A0-part1 -> ../../dm-1
	# /dev/disk/by-vdev/A0-part2 -> ../../dm-3
	#
	# Warning: The following grep pattern will misidentify whole-disk
	# devices whose names end with 'p' followed by a string of
	# digits as partitions, causing alias creation to fail. This
	# ambiguity seems unavoidable, so devices using this facility
	# must not use such names.
	DM_PART=
	if echo "$DM_NAME" \| grep -q -E 'p[0-9][0-9]*$' ; then
	if [ "$DEVTYPE" != "partition" ] ; then
	# Match p[number], remove the 'p' and prepend "-part"
	DM_PART=$(echo "$DM_NAME" \|
	awk 'match($0,/p[0-9]+$/) {print "-part"substr($0,RSTART+1,RLENGTH-1)}')
	fi
	fi

	# DEVLINKS attribute must have been populated by already-run udev rules.
	for link in $DEVLINKS ; do
	# Remove partition information to match key of top-level device.
	if [ -n "$DM_PART" ] ; then
	link=$(echo "$link" \| sed 's/p[0-9][0-9]*$//')
	fi
	# Check both the fully qualified and the base name of link.
	for l in $link $(basename "$link") ; do
	if [ ! -z "$l" ]; then
	alias=$(awk -v var="$l" '($1 == "alias") && \
	($3 == var) \
	{ print $2; exit }' $CONFIG)
	if [ -n "$alias" ] ; then
	echo "${alias}${DM_PART}"
	return
	fi
	fi
	done
	done
	}

	# main
	while getopts 'c:d:eg:jmp:h' OPTION; do
	case ${OPTION} in
	c)
	CONFIG=${OPTARG}
	;;
	d)
	DEV=${OPTARG}
	;;
	e)
	# When udev sees a scsi_generic device, it calls this script with -e to
	# create the enclosure device symlinks only. We also need
	# "enclosure_symlinks yes" set in vdev_id.config to actually create the
	# symlink.
	ENCLOSURE_MODE=$(awk '{if ($1 == "enclosure_symlinks") \
	print $2}' "$CONFIG")

	if [ "$ENCLOSURE_MODE" != "yes" ] ; then
	exit 0
	fi
	;;
	g)
	TOPOLOGY=$OPTARG
	;;
	p)
	PHYS_PER_PORT=${OPTARG}
	;;
	j)
	MULTIJBOD_MODE=yes
	;;
	m)
	MULTIPATH_MODE=yes
	;;
	h)
	usage
	;;
	esac
	done

	if [ ! -r "$CONFIG" ] ; then
	echo "Error: Config file \"$CONFIG\" not found"
	exit 0
	fi

	if [ -z "$DEV" ] && [ -z "$ENCLOSURE_MODE" ] ; then
	echo "Error: missing required option -d"
	exit 1
	fi

	if [ -z "$TOPOLOGY" ] ; then
	TOPOLOGY=$(awk '($1 == "topology") {print $2; exit}' "$CONFIG")
	fi

	if [ -z "$BAY" ] ; then
	BAY=$(awk '($1 == "slot") {print $2; exit}' "$CONFIG")
	fi

	TOPOLOGY=${TOPOLOGY:-sas_direct}

	# Should we create /dev/by-enclosure symlinks?
	if [ "$ENCLOSURE_MODE" = "yes" ] && [ "$TOPOLOGY" = "sas_direct" ] ; then
	ID_ENCLOSURE=$(enclosure_handler)
	if [ -z "$ID_ENCLOSURE" ] ; then
	exit 0
	fi

	# Just create the symlinks to the enclosure devices and then exit.
	ENCLOSURE_PREFIX=$(awk '/enclosure_symlinks_prefix/{print $2}' "$CONFIG")
	if [ -z "$ENCLOSURE_PREFIX" ] ; then
	ENCLOSURE_PREFIX="enc"
	fi
	echo "ID_ENCLOSURE=$ID_ENCLOSURE"
	echo "ID_ENCLOSURE_PATH=by-enclosure/$ENCLOSURE_PREFIX-$ID_ENCLOSURE"
	exit 0
	fi

	# First check if an alias was defined for this device.
	ID_VDEV=$(alias_handler)

	if [ -z "$ID_VDEV" ] ; then
	BAY=${BAY:-bay}
	case $TOPOLOGY in
	sas_direct\|sas_switch)
	ID_VDEV=$(sas_handler)
	;;
	scsi)
	ID_VDEV=$(scsi_handler)
	;;
	*)
	echo "Error: unknown topology $TOPOLOGY"
	exit 1
	;;
	esac
	fi

	if [ -n "$ID_VDEV" ] ; then
	echo "ID_VDEV=${ID_VDEV}"
	echo "ID_VDEV_PATH=disk/by-vdev/${ID_VDEV}"
	fi
	diff --git a/sys/contrib/openzfs/cmd/zdb/zdb.c b/sys/contrib/openzfs/cmd/zdb/zdb.c
	index f7a6e17d70e8..84ae606b999f 100644
	--- a/sys/contrib/openzfs/cmd/zdb/zdb.c
	+++ b/sys/contrib/openzfs/cmd/zdb/zdb.c
	@@ -1,8743 +1,8744 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2011, 2019 by Delphix. All rights reserved.
	* Copyright (c) 2014 Integros [integros.com]
	* Copyright 2016 Nexenta Systems, Inc.
	* Copyright (c) 2017, 2018 Lawrence Livermore National Security, LLC.
	* Copyright (c) 2015, 2017, Intel Corporation.
	* Copyright (c) 2020 Datto Inc.
	* Copyright (c) 2020, The FreeBSD Foundation [1]
	*
	* [1] Portions of this software were developed by Allan Jude
	* under sponsorship from the FreeBSD Foundation.
	* Copyright (c) 2021 Allan Jude
	*/

	#include <stdio.h>
	#include <unistd.h>
	#include <stdlib.h>
	#include <ctype.h>
	#include <sys/zfs_context.h>
	#include <sys/spa.h>
	#include <sys/spa_impl.h>
	#include <sys/dmu.h>
	#include <sys/zap.h>
	#include <sys/fs/zfs.h>
	#include <sys/zfs_znode.h>
	#include <sys/zfs_sa.h>
	#include <sys/sa.h>
	#include <sys/sa_impl.h>
	#include <sys/vdev.h>
	#include <sys/vdev_impl.h>
	#include <sys/metaslab_impl.h>
	#include <sys/dmu_objset.h>
	#include <sys/dsl_dir.h>
	#include <sys/dsl_dataset.h>
	#include <sys/dsl_pool.h>
	#include <sys/dsl_bookmark.h>
	#include <sys/dbuf.h>
	#include <sys/zil.h>
	#include <sys/zil_impl.h>
	#include <sys/stat.h>
	#include <sys/resource.h>
	#include <sys/dmu_send.h>
	#include <sys/dmu_traverse.h>
	#include <sys/zio_checksum.h>
	#include <sys/zio_compress.h>
	#include <sys/zfs_fuid.h>
	#include <sys/arc.h>
	#include <sys/arc_impl.h>
	#include <sys/ddt.h>
	#include <sys/zfeature.h>
	#include <sys/abd.h>
	#include <sys/blkptr.h>
	#include <sys/dsl_crypt.h>
	#include <sys/dsl_scan.h>
	#include <sys/btree.h>
	#include <zfs_comutil.h>
	#include <sys/zstd/zstd.h>

	#include <libnvpair.h>
	#include <libzutil.h>

	#include "zdb.h"

	#define ZDB_COMPRESS_NAME(idx) ((idx) < ZIO_COMPRESS_FUNCTIONS ? \
	zio_compress_table[(idx)].ci_name : "UNKNOWN")
	#define ZDB_CHECKSUM_NAME(idx) ((idx) < ZIO_CHECKSUM_FUNCTIONS ? \
	zio_checksum_table[(idx)].ci_name : "UNKNOWN")
	#define ZDB_OT_TYPE(idx) ((idx) < DMU_OT_NUMTYPES ? (idx) : \
	(idx) == DMU_OTN_ZAP_DATA \|\| (idx) == DMU_OTN_ZAP_METADATA ? \
	DMU_OT_ZAP_OTHER : \
	(idx) == DMU_OTN_UINT64_DATA \|\| (idx) == DMU_OTN_UINT64_METADATA ? \
	DMU_OT_UINT64_OTHER : DMU_OT_NUMTYPES)

	static char *
	zdb_ot_name(dmu_object_type_t type)
	{
	if (type < DMU_OT_NUMTYPES)
	return (dmu_ot[type].ot_name);
	else if ((type & DMU_OT_NEWTYPE) &&
	((type & DMU_OT_BYTESWAP_MASK) < DMU_BSWAP_NUMFUNCS))
	return (dmu_ot_byteswap[type & DMU_OT_BYTESWAP_MASK].ob_name);
	else
	return ("UNKNOWN");
	}

	extern int reference_tracking_enable;
	extern int zfs_recover;
	extern unsigned long zfs_arc_meta_min, zfs_arc_meta_limit;
	extern int zfs_vdev_async_read_max_active;
	extern boolean_t spa_load_verify_dryrun;
	extern int zfs_reconstruct_indirect_combinations_max;
	extern int zfs_btree_verify_intensity;

	static const char cmdname[] = "zdb";
	uint8_t dump_opt[256];

	typedef void object_viewer_t(objset_t , uint64_t, void data, size_t size);

	uint64_t *zopt_metaslab = NULL;
	static unsigned zopt_metaslab_args = 0;

	typedef struct zopt_object_range {
	uint64_t zor_obj_start;
	uint64_t zor_obj_end;
	uint64_t zor_flags;
	} zopt_object_range_t;
	zopt_object_range_t *zopt_object_ranges = NULL;
	static unsigned zopt_object_args = 0;

	static int flagbits[256];

	#define ZOR_FLAG_PLAIN_FILE 0x0001
	#define ZOR_FLAG_DIRECTORY 0x0002
	#define ZOR_FLAG_SPACE_MAP 0x0004
	#define ZOR_FLAG_ZAP 0x0008
	#define ZOR_FLAG_ALL_TYPES -1
	#define ZOR_SUPPORTED_FLAGS (ZOR_FLAG_PLAIN_FILE \| \
	ZOR_FLAG_DIRECTORY \| \
	ZOR_FLAG_SPACE_MAP \| \
	ZOR_FLAG_ZAP)

	#define ZDB_FLAG_CHECKSUM 0x0001
	#define ZDB_FLAG_DECOMPRESS 0x0002
	#define ZDB_FLAG_BSWAP 0x0004
	#define ZDB_FLAG_GBH 0x0008
	#define ZDB_FLAG_INDIRECT 0x0010
	#define ZDB_FLAG_RAW 0x0020
	#define ZDB_FLAG_PRINT_BLKPTR 0x0040
	#define ZDB_FLAG_VERBOSE 0x0080

	uint64_t max_inflight_bytes = 256 * 1024 * 1024; /* 256MB */
	static int leaked_objects = 0;
	static range_tree_t *mos_refd_objs;

	static void snprintf_blkptr_compact(char , size_t, const blkptr_t ,
	boolean_t);
	static void mos_obj_refd(uint64_t);
	static void mos_obj_refd_multiple(uint64_t);
	static int dump_bpobj_cb(void arg, const blkptr_t bp, boolean_t free,
	dmu_tx_t *tx);

	typedef struct sublivelist_verify {
	/* all ALLOC'd blkptr_t in one sub-livelist */
	zfs_btree_t sv_all_allocs;

	/* all FREE'd blkptr_t in one sub-livelist */
	zfs_btree_t sv_all_frees;

	/* FREE's that haven't yet matched to an ALLOC, in one sub-livelist */
	zfs_btree_t sv_pair;

	/* ALLOC's without a matching FREE, accumulates across sub-livelists */
	zfs_btree_t sv_leftover;
	} sublivelist_verify_t;

	static int
	livelist_compare(const void larg, const void rarg)
	{
	const blkptr_t *l = larg;
	const blkptr_t *r = rarg;

	/* Sort them according to dva[0] */
	uint64_t l_dva0_vdev, r_dva0_vdev;
	l_dva0_vdev = DVA_GET_VDEV(&l->blk_dva[0]);
	r_dva0_vdev = DVA_GET_VDEV(&r->blk_dva[0]);
	if (l_dva0_vdev < r_dva0_vdev)
	return (-1);
	else if (l_dva0_vdev > r_dva0_vdev)
	return (+1);

	/* if vdevs are equal, sort by offsets. */
	uint64_t l_dva0_offset;
	uint64_t r_dva0_offset;
	l_dva0_offset = DVA_GET_OFFSET(&l->blk_dva[0]);
	r_dva0_offset = DVA_GET_OFFSET(&r->blk_dva[0]);
	if (l_dva0_offset < r_dva0_offset) {
	return (-1);
	} else if (l_dva0_offset > r_dva0_offset) {
	return (+1);
	}

	/*
	* Since we're storing blkptrs without cancelling FREE/ALLOC pairs,
	* it's possible the offsets are equal. In that case, sort by txg
	*/
	if (l->blk_birth < r->blk_birth) {
	return (-1);
	} else if (l->blk_birth > r->blk_birth) {
	return (+1);
	}
	return (0);
	}

	typedef struct sublivelist_verify_block {
	dva_t svb_dva;

	/*
	* We need this to check if the block marked as allocated
	* in the livelist was freed (and potentially reallocated)
	* in the metaslab spacemaps at a later TXG.
	*/
	uint64_t svb_allocated_txg;
	} sublivelist_verify_block_t;

	static void zdb_print_blkptr(const blkptr_t *bp, int flags);

	static int
	sublivelist_verify_blkptr(void arg, const blkptr_t bp, boolean_t free,
	dmu_tx_t *tx)
	{
	ASSERT3P(tx, ==, NULL);
	struct sublivelist_verify *sv = arg;
	char blkbuf[BP_SPRINTF_LEN];
	zfs_btree_index_t where;
	if (free) {
	zfs_btree_add(&sv->sv_pair, bp);
	/* Check if the FREE is a duplicate */
	if (zfs_btree_find(&sv->sv_all_frees, bp, &where) != NULL) {
	snprintf_blkptr_compact(blkbuf, sizeof (blkbuf), bp,
	free);
	(void) printf("\tERROR: Duplicate FREE: %s\n", blkbuf);
	} else {
	zfs_btree_add_idx(&sv->sv_all_frees, bp, &where);
	}
	} else {
	/* Check if the ALLOC has been freed */
	if (zfs_btree_find(&sv->sv_pair, bp, &where) != NULL) {
	zfs_btree_remove_idx(&sv->sv_pair, &where);
	} else {
	for (int i = 0; i < SPA_DVAS_PER_BP; i++) {
	if (DVA_IS_EMPTY(&bp->blk_dva[i]))
	break;
	sublivelist_verify_block_t svb = {
	.svb_dva = bp->blk_dva[i],
	.svb_allocated_txg = bp->blk_birth
	};

	if (zfs_btree_find(&sv->sv_leftover, &svb,
	&where) == NULL) {
	zfs_btree_add_idx(&sv->sv_leftover,
	&svb, &where);
	}
	}
	}
	/* Check if the ALLOC is a duplicate */
	if (zfs_btree_find(&sv->sv_all_allocs, bp, &where) != NULL) {
	snprintf_blkptr_compact(blkbuf, sizeof (blkbuf), bp,
	free);
	(void) printf("\tERROR: Duplicate ALLOC: %s\n", blkbuf);
	} else {
	zfs_btree_add_idx(&sv->sv_all_allocs, bp, &where);
	}
	}
	return (0);
	}

	static int
	sublivelist_verify_func(void args, dsl_deadlist_entry_t dle)
	{
	int err;
	char blkbuf[BP_SPRINTF_LEN];
	struct sublivelist_verify *sv = args;

	zfs_btree_create(&sv->sv_all_allocs, livelist_compare,
	sizeof (blkptr_t));

	zfs_btree_create(&sv->sv_all_frees, livelist_compare,
	sizeof (blkptr_t));

	zfs_btree_create(&sv->sv_pair, livelist_compare,
	sizeof (blkptr_t));

	err = bpobj_iterate_nofree(&dle->dle_bpobj, sublivelist_verify_blkptr,
	sv, NULL);

	zfs_btree_clear(&sv->sv_all_allocs);
	zfs_btree_destroy(&sv->sv_all_allocs);

	zfs_btree_clear(&sv->sv_all_frees);
	zfs_btree_destroy(&sv->sv_all_frees);

	blkptr_t *e;
	zfs_btree_index_t *cookie = NULL;
	while ((e = zfs_btree_destroy_nodes(&sv->sv_pair, &cookie)) != NULL) {
	snprintf_blkptr_compact(blkbuf, sizeof (blkbuf), e, B_TRUE);
	(void) printf("\tERROR: Unmatched FREE: %s\n", blkbuf);
	}
	zfs_btree_destroy(&sv->sv_pair);

	return (err);
	}

	static int
	livelist_block_compare(const void larg, const void rarg)
	{
	const sublivelist_verify_block_t *l = larg;
	const sublivelist_verify_block_t *r = rarg;

	if (DVA_GET_VDEV(&l->svb_dva) < DVA_GET_VDEV(&r->svb_dva))
	return (-1);
	else if (DVA_GET_VDEV(&l->svb_dva) > DVA_GET_VDEV(&r->svb_dva))
	return (+1);

	if (DVA_GET_OFFSET(&l->svb_dva) < DVA_GET_OFFSET(&r->svb_dva))
	return (-1);
	else if (DVA_GET_OFFSET(&l->svb_dva) > DVA_GET_OFFSET(&r->svb_dva))
	return (+1);

	if (DVA_GET_ASIZE(&l->svb_dva) < DVA_GET_ASIZE(&r->svb_dva))
	return (-1);
	else if (DVA_GET_ASIZE(&l->svb_dva) > DVA_GET_ASIZE(&r->svb_dva))
	return (+1);

	return (0);
	}

	/*
	* Check for errors in a livelist while tracking all unfreed ALLOCs in the
	* sublivelist_verify_t: sv->sv_leftover
	*/
	static void
	livelist_verify(dsl_deadlist_t dl, void arg)
	{
	sublivelist_verify_t *sv = arg;
	dsl_deadlist_iterate(dl, sublivelist_verify_func, sv);
	}

	/*
	* Check for errors in the livelist entry and discard the intermediary
	* data structures
	*/
	/* ARGSUSED */
	static int
	sublivelist_verify_lightweight(void args, dsl_deadlist_entry_t dle)
	{
	sublivelist_verify_t sv;
	zfs_btree_create(&sv.sv_leftover, livelist_block_compare,
	sizeof (sublivelist_verify_block_t));
	int err = sublivelist_verify_func(&sv, dle);
	zfs_btree_clear(&sv.sv_leftover);
	zfs_btree_destroy(&sv.sv_leftover);
	return (err);
	}

	typedef struct metaslab_verify {
	/*
	* Tree containing all the leftover ALLOCs from the livelists
	* that are part of this metaslab.
	*/
	zfs_btree_t mv_livelist_allocs;

	/*
	* Metaslab information.
	*/
	uint64_t mv_vdid;
	uint64_t mv_msid;
	uint64_t mv_start;
	uint64_t mv_end;

	/*
	* What's currently allocated for this metaslab.
	*/
	range_tree_t *mv_allocated;
	} metaslab_verify_t;

	typedef void ll_iter_t(dsl_deadlist_t ll, void arg);

	typedef int (zdb_log_sm_cb_t)(spa_t spa, space_map_entry_t *sme, uint64_t txg,
	void *arg);

	typedef struct unflushed_iter_cb_arg {
	spa_t *uic_spa;
	uint64_t uic_txg;
	void *uic_arg;
	zdb_log_sm_cb_t uic_cb;
	} unflushed_iter_cb_arg_t;

	static int
	iterate_through_spacemap_logs_cb(space_map_entry_t sme, void arg)
	{
	unflushed_iter_cb_arg_t *uic = arg;
	return (uic->uic_cb(uic->uic_spa, sme, uic->uic_txg, uic->uic_arg));
	}

	static void
	iterate_through_spacemap_logs(spa_t spa, zdb_log_sm_cb_t cb, void arg)
	{
	if (!spa_feature_is_active(spa, SPA_FEATURE_LOG_SPACEMAP))
	return;

	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
	for (spa_log_sm_t *sls = avl_first(&spa->spa_sm_logs_by_txg);
	sls; sls = AVL_NEXT(&spa->spa_sm_logs_by_txg, sls)) {
	space_map_t *sm = NULL;
	VERIFY0(space_map_open(&sm, spa_meta_objset(spa),
	sls->sls_sm_obj, 0, UINT64_MAX, SPA_MINBLOCKSHIFT));

	unflushed_iter_cb_arg_t uic = {
	.uic_spa = spa,
	.uic_txg = sls->sls_txg,
	.uic_arg = arg,
	.uic_cb = cb
	};
	VERIFY0(space_map_iterate(sm, space_map_length(sm),
	iterate_through_spacemap_logs_cb, &uic));
	space_map_close(sm);
	}
	spa_config_exit(spa, SCL_CONFIG, FTAG);
	}

	static void
	verify_livelist_allocs(metaslab_verify_t *mv, uint64_t txg,
	uint64_t offset, uint64_t size)
	{
	sublivelist_verify_block_t svb;
	DVA_SET_VDEV(&svb.svb_dva, mv->mv_vdid);
	DVA_SET_OFFSET(&svb.svb_dva, offset);
	DVA_SET_ASIZE(&svb.svb_dva, size);
	zfs_btree_index_t where;
	uint64_t end_offset = offset + size;

	/*
	* Look for an exact match for spacemap entry in the livelist entries.
	* Then, look for other livelist entries that fall within the range
	* of the spacemap entry as it may have been condensed
	*/
	sublivelist_verify_block_t *found =
	zfs_btree_find(&mv->mv_livelist_allocs, &svb, &where);
	if (found == NULL) {
	found = zfs_btree_next(&mv->mv_livelist_allocs, &where, &where);
	}
	for (; found != NULL && DVA_GET_VDEV(&found->svb_dva) == mv->mv_vdid &&
	DVA_GET_OFFSET(&found->svb_dva) < end_offset;
	found = zfs_btree_next(&mv->mv_livelist_allocs, &where, &where)) {
	if (found->svb_allocated_txg <= txg) {
	(void) printf("ERROR: Livelist ALLOC [%llx:%llx] "
	"from TXG %llx FREED at TXG %llx\n",
	(u_longlong_t)DVA_GET_OFFSET(&found->svb_dva),
	(u_longlong_t)DVA_GET_ASIZE(&found->svb_dva),
	(u_longlong_t)found->svb_allocated_txg,
	(u_longlong_t)txg);
	}
	}
	}

	static int
	metaslab_spacemap_validation_cb(space_map_entry_t sme, void arg)
	{
	metaslab_verify_t *mv = arg;
	uint64_t offset = sme->sme_offset;
	uint64_t size = sme->sme_run;
	uint64_t txg = sme->sme_txg;

	if (sme->sme_type == SM_ALLOC) {
	if (range_tree_contains(mv->mv_allocated,
	offset, size)) {
	(void) printf("ERROR: DOUBLE ALLOC: "
	"%llu [%llx:%llx] "
	"%llu:%llu LOG_SM\n",
	(u_longlong_t)txg, (u_longlong_t)offset,
	(u_longlong_t)size, (u_longlong_t)mv->mv_vdid,
	(u_longlong_t)mv->mv_msid);
	} else {
	range_tree_add(mv->mv_allocated,
	offset, size);
	}
	} else {
	if (!range_tree_contains(mv->mv_allocated,
	offset, size)) {
	(void) printf("ERROR: DOUBLE FREE: "
	"%llu [%llx:%llx] "
	"%llu:%llu LOG_SM\n",
	(u_longlong_t)txg, (u_longlong_t)offset,
	(u_longlong_t)size, (u_longlong_t)mv->mv_vdid,
	(u_longlong_t)mv->mv_msid);
	} else {
	range_tree_remove(mv->mv_allocated,
	offset, size);
	}
	}

	if (sme->sme_type != SM_ALLOC) {
	/*
	* If something is freed in the spacemap, verify that
	* it is not listed as allocated in the livelist.
	*/
	verify_livelist_allocs(mv, txg, offset, size);
	}
	return (0);
	}

	static int
	spacemap_check_sm_log_cb(spa_t spa, space_map_entry_t sme,
	uint64_t txg, void *arg)
	{
	metaslab_verify_t *mv = arg;
	uint64_t offset = sme->sme_offset;
	uint64_t vdev_id = sme->sme_vdev;

	vdev_t *vd = vdev_lookup_top(spa, vdev_id);

	/* skip indirect vdevs */
	if (!vdev_is_concrete(vd))
	return (0);

	if (vdev_id != mv->mv_vdid)
	return (0);

	metaslab_t *ms = vd->vdev_ms[offset >> vd->vdev_ms_shift];
	if (ms->ms_id != mv->mv_msid)
	return (0);

	if (txg < metaslab_unflushed_txg(ms))
	return (0);


	ASSERT3U(txg, ==, sme->sme_txg);
	return (metaslab_spacemap_validation_cb(sme, mv));
	}

	static void
	spacemap_check_sm_log(spa_t spa, metaslab_verify_t mv)
	{
	iterate_through_spacemap_logs(spa, spacemap_check_sm_log_cb, mv);
	}

	static void
	spacemap_check_ms_sm(space_map_t sm, metaslab_verify_t mv)
	{
	if (sm == NULL)
	return;

	VERIFY0(space_map_iterate(sm, space_map_length(sm),
	metaslab_spacemap_validation_cb, mv));
	}

	static void iterate_deleted_livelists(spa_t spa, ll_iter_t func, void arg);

	/*
	* Transfer blocks from sv_leftover tree to the mv_livelist_allocs if
	* they are part of that metaslab (mv_msid).
	*/
	static void
	mv_populate_livelist_allocs(metaslab_verify_t mv, sublivelist_verify_t sv)
	{
	zfs_btree_index_t where;
	sublivelist_verify_block_t *svb;
	ASSERT3U(zfs_btree_numnodes(&mv->mv_livelist_allocs), ==, 0);
	for (svb = zfs_btree_first(&sv->sv_leftover, &where);
	svb != NULL;
	svb = zfs_btree_next(&sv->sv_leftover, &where, &where)) {
	if (DVA_GET_VDEV(&svb->svb_dva) != mv->mv_vdid)
	continue;

	if (DVA_GET_OFFSET(&svb->svb_dva) < mv->mv_start &&
	(DVA_GET_OFFSET(&svb->svb_dva) +
	DVA_GET_ASIZE(&svb->svb_dva)) > mv->mv_start) {
	(void) printf("ERROR: Found block that crosses "
	"metaslab boundary: <%llu:%llx:%llx>\n",
	(u_longlong_t)DVA_GET_VDEV(&svb->svb_dva),
	(u_longlong_t)DVA_GET_OFFSET(&svb->svb_dva),
	(u_longlong_t)DVA_GET_ASIZE(&svb->svb_dva));
	continue;
	}

	if (DVA_GET_OFFSET(&svb->svb_dva) < mv->mv_start)
	continue;

	if (DVA_GET_OFFSET(&svb->svb_dva) >= mv->mv_end)
	continue;

	if ((DVA_GET_OFFSET(&svb->svb_dva) +
	DVA_GET_ASIZE(&svb->svb_dva)) > mv->mv_end) {
	(void) printf("ERROR: Found block that crosses "
	"metaslab boundary: <%llu:%llx:%llx>\n",
	(u_longlong_t)DVA_GET_VDEV(&svb->svb_dva),
	(u_longlong_t)DVA_GET_OFFSET(&svb->svb_dva),
	(u_longlong_t)DVA_GET_ASIZE(&svb->svb_dva));
	continue;
	}

	zfs_btree_add(&mv->mv_livelist_allocs, svb);
	}

	for (svb = zfs_btree_first(&mv->mv_livelist_allocs, &where);
	svb != NULL;
	svb = zfs_btree_next(&mv->mv_livelist_allocs, &where, &where)) {
	zfs_btree_remove(&sv->sv_leftover, svb);
	}
	}

	/*
	* [Livelist Check]
	* Iterate through all the sublivelists and:
	* - report leftover frees
	* - report double ALLOCs/FREEs
	* - record leftover ALLOCs together with their TXG [see Cross Check]
	*
	* [Spacemap Check]
	* for each metaslab:
	* - iterate over spacemap and then the metaslab's entries in the
	* spacemap log, then report any double FREEs and ALLOCs (do not
	* blow up).
	*
	* [Cross Check]
	* After finishing the Livelist Check phase and while being in the
	* Spacemap Check phase, we find all the recorded leftover ALLOCs
	* of the livelist check that are part of the metaslab that we are
	* currently looking at in the Spacemap Check. We report any entries
	* that are marked as ALLOCs in the livelists but have been actually
	* freed (and potentially allocated again) after their TXG stamp in
	* the spacemaps. Also report any ALLOCs from the livelists that
	* belong to indirect vdevs (e.g. their vdev completed removal).
	*
	* Note that this will miss Log Spacemap entries that cancelled each other
	* out before being flushed to the metaslab, so we are not guaranteed
	* to match all erroneous ALLOCs.
	*/
	static void
	livelist_metaslab_validate(spa_t *spa)
	{
	(void) printf("Verifying deleted livelist entries\n");

	sublivelist_verify_t sv;
	zfs_btree_create(&sv.sv_leftover, livelist_block_compare,
	sizeof (sublivelist_verify_block_t));
	iterate_deleted_livelists(spa, livelist_verify, &sv);

	(void) printf("Verifying metaslab entries\n");
	vdev_t *rvd = spa->spa_root_vdev;
	for (uint64_t c = 0; c < rvd->vdev_children; c++) {
	vdev_t *vd = rvd->vdev_child[c];

	if (!vdev_is_concrete(vd))
	continue;

	for (uint64_t mid = 0; mid < vd->vdev_ms_count; mid++) {
	metaslab_t *m = vd->vdev_ms[mid];

	(void) fprintf(stderr,
	"\rverifying concrete vdev %llu, "
	"metaslab %llu of %llu ...",
	(longlong_t)vd->vdev_id,
	(longlong_t)mid,
	(longlong_t)vd->vdev_ms_count);

	uint64_t shift, start;
	range_seg_type_t type =
	metaslab_calculate_range_tree_type(vd, m,
	&start, &shift);
	metaslab_verify_t mv;
	mv.mv_allocated = range_tree_create(NULL,
	type, NULL, start, shift);
	mv.mv_vdid = vd->vdev_id;
	mv.mv_msid = m->ms_id;
	mv.mv_start = m->ms_start;
	mv.mv_end = m->ms_start + m->ms_size;
	zfs_btree_create(&mv.mv_livelist_allocs,
	livelist_block_compare,
	sizeof (sublivelist_verify_block_t));

	mv_populate_livelist_allocs(&mv, &sv);

	spacemap_check_ms_sm(m->ms_sm, &mv);
	spacemap_check_sm_log(spa, &mv);

	range_tree_vacate(mv.mv_allocated, NULL, NULL);
	range_tree_destroy(mv.mv_allocated);
	zfs_btree_clear(&mv.mv_livelist_allocs);
	zfs_btree_destroy(&mv.mv_livelist_allocs);
	}
	}
	(void) fprintf(stderr, "\n");

	/*
	* If there are any segments in the leftover tree after we walked
	* through all the metaslabs in the concrete vdevs then this means
	* that we have segments in the livelists that belong to indirect
	* vdevs and are marked as allocated.
	*/
	if (zfs_btree_numnodes(&sv.sv_leftover) == 0) {
	zfs_btree_destroy(&sv.sv_leftover);
	return;
	}
	(void) printf("ERROR: Found livelist blocks marked as allocated "
	"for indirect vdevs:\n");

	zfs_btree_index_t *where = NULL;
	sublivelist_verify_block_t *svb;
	while ((svb = zfs_btree_destroy_nodes(&sv.sv_leftover, &where)) !=
	NULL) {
	int vdev_id = DVA_GET_VDEV(&svb->svb_dva);
	ASSERT3U(vdev_id, <, rvd->vdev_children);
	vdev_t *vd = rvd->vdev_child[vdev_id];
	ASSERT(!vdev_is_concrete(vd));
	(void) printf("<%d:%llx:%llx> TXG %llx\n",
	vdev_id, (u_longlong_t)DVA_GET_OFFSET(&svb->svb_dva),
	(u_longlong_t)DVA_GET_ASIZE(&svb->svb_dva),
	(u_longlong_t)svb->svb_allocated_txg);
	}
	(void) printf("\n");
	zfs_btree_destroy(&sv.sv_leftover);
	}

	/*
	* These libumem hooks provide a reasonable set of defaults for the allocator's
	* debugging facilities.
	*/
	const char *
	_umem_debug_init(void)
	{
	return ("default,verbose"); /* $UMEM_DEBUG setting */
	}

	const char *
	_umem_logging_init(void)
	{
	return ("fail,contents"); /* $UMEM_LOGGING setting */
	}

	static void
	usage(void)
	{
	(void) fprintf(stderr,
	"Usage:\t%s [-AbcdDFGhikLMPsvXy] [-e [-V] [-p <path> ...]] "
	"[-I <inflight I/Os>]\n"
	"\t\t[-o <var>=<value>]... [-t <txg>] [-U <cache>] [-x <dumpdir>]\n"
	"\t\t[<poolname>[/<dataset \| objset id>] [<object \| range> ...]]\n"
	"\t%s [-AdiPv] [-e [-V] [-p <path> ...]] [-U <cache>]\n"
	"\t\t[<poolname>[/<dataset \| objset id>] [<object \| range> ...]\n"
	"\t%s [-v] <bookmark>\n"
	"\t%s -C [-A] [-U <cache>]\n"
	"\t%s -l [-Aqu] <device>\n"
	"\t%s -m [-AFLPX] [-e [-V] [-p <path> ...]] [-t <txg>] "
	"[-U <cache>]\n\t\t<poolname> [<vdev> [<metaslab> ...]]\n"
	"\t%s -O <dataset> <path>\n"
	"\t%s -r <dataset> <path> <destination>\n"
	"\t%s -R [-A] [-e [-V] [-p <path> ...]] [-U <cache>]\n"
	"\t\t<poolname> <vdev>:<offset>:<size>[:<flags>]\n"
	"\t%s -E [-A] word0:word1:...:word15\n"
	"\t%s -S [-AP] [-e [-V] [-p <path> ...]] [-U <cache>] "
	"<poolname>\n\n",
	cmdname, cmdname, cmdname, cmdname, cmdname, cmdname, cmdname,
	cmdname, cmdname, cmdname, cmdname);

	(void) fprintf(stderr, " Dataset name must include at least one "
	"separator character '/' or '@'\n");
	(void) fprintf(stderr, " If dataset name is specified, only that "
	"dataset is dumped\n");
	(void) fprintf(stderr, " If object numbers or object number "
	"ranges are specified, only those\n"
	" objects or ranges are dumped.\n\n");
	(void) fprintf(stderr,
	" Object ranges take the form <start>:<end>[:<flags>]\n"
	" start Starting object number\n"
	" end Ending object number, or -1 for no upper bound\n"
	" flags Optional flags to select object types:\n"
	" A All objects (this is the default)\n"
	" d ZFS directories\n"
	" f ZFS files \n"
	" m SPA space maps\n"
	" z ZAPs\n"
	" - Negate effect of next flag\n\n");
	(void) fprintf(stderr, " Options to control amount of output:\n");
	(void) fprintf(stderr, " -b block statistics\n");
	(void) fprintf(stderr, " -c checksum all metadata (twice for "
	"all data) blocks\n");
	(void) fprintf(stderr, " -C config (or cachefile if alone)\n");
	(void) fprintf(stderr, " -d dataset(s)\n");
	(void) fprintf(stderr, " -D dedup statistics\n");
	(void) fprintf(stderr, " -E decode and display block from an "
	"embedded block pointer\n");
	(void) fprintf(stderr, " -h pool history\n");
	(void) fprintf(stderr, " -i intent logs\n");
	(void) fprintf(stderr, " -l read label contents\n");
	(void) fprintf(stderr, " -k examine the checkpointed state "
	"of the pool\n");
	(void) fprintf(stderr, " -L disable leak tracking (do not "
	"load spacemaps)\n");
	(void) fprintf(stderr, " -m metaslabs\n");
	(void) fprintf(stderr, " -M metaslab groups\n");
	(void) fprintf(stderr, " -O perform object lookups by path\n");
	(void) fprintf(stderr, " -r copy an object by path to file\n");
	(void) fprintf(stderr, " -R read and display block from a "
	"device\n");
	(void) fprintf(stderr, " -s report stats on zdb's I/O\n");
	(void) fprintf(stderr, " -S simulate dedup to measure effect\n");
	(void) fprintf(stderr, " -v verbose (applies to all "
	"others)\n");
	(void) fprintf(stderr, " -y perform livelist and metaslab "
	"validation on any livelists being deleted\n\n");
	(void) fprintf(stderr, " Below options are intended for use "
	"with other options:\n");
	(void) fprintf(stderr, " -A ignore assertions (-A), enable "
	"panic recovery (-AA) or both (-AAA)\n");
	(void) fprintf(stderr, " -e pool is exported/destroyed/"
	"has altroot/not in a cachefile\n");
	(void) fprintf(stderr, " -F attempt automatic rewind within "
	"safe range of transaction groups\n");
	(void) fprintf(stderr, " -G dump zfs_dbgmsg buffer before "
	"exiting\n");
	(void) fprintf(stderr, " -I <number of inflight I/Os> -- "
	"specify the maximum number of\n "
	"checksumming I/Os [default is 200]\n");
	(void) fprintf(stderr, " -o <variable>=<value> set global "
	"variable to an unsigned 32-bit integer\n");
	(void) fprintf(stderr, " -p <path> -- use one or more with "
	"-e to specify path to vdev dir\n");
	(void) fprintf(stderr, " -P print numbers in parseable form\n");
	(void) fprintf(stderr, " -q don't print label contents\n");
	(void) fprintf(stderr, " -t <txg> -- highest txg to use when "
	"searching for uberblocks\n");
	(void) fprintf(stderr, " -u uberblock\n");
	(void) fprintf(stderr, " -U <cachefile_path> -- use alternate "
	"cachefile\n");
	(void) fprintf(stderr, " -V do verbatim import\n");
	(void) fprintf(stderr, " -x <dumpdir> -- "
	"dump all read blocks into specified directory\n");
	(void) fprintf(stderr, " -X attempt extreme rewind (does not "
	"work with dataset)\n");
	(void) fprintf(stderr, " -Y attempt all reconstruction "
	"combinations for split blocks\n");
	(void) fprintf(stderr, " -Z show ZSTD headers \n");
	(void) fprintf(stderr, "Specify an option more than once (e.g. -bb) "
	"to make only that option verbose\n");
	(void) fprintf(stderr, "Default is to dump everything non-verbosely\n");
	exit(1);
	}

	static void
	dump_debug_buffer(void)
	{
	if (dump_opt['G']) {
	(void) printf("\n");
	(void) fflush(stdout);
	zfs_dbgmsg_print("zdb");
	}
	}

	/*
	* Called for usage errors that are discovered after a call to spa_open(),
	* dmu_bonus_hold(), or pool_match(). abort() is called for other errors.
	*/

	static void
	fatal(const char *fmt, ...)
	{
	va_list ap;

	va_start(ap, fmt);
	(void) fprintf(stderr, "%s: ", cmdname);
	(void) vfprintf(stderr, fmt, ap);
	va_end(ap);
	(void) fprintf(stderr, "\n");

	dump_debug_buffer();

	exit(1);
	}

	/* ARGSUSED */
	static void
	dump_packed_nvlist(objset_t os, uint64_t object, void data, size_t size)
	{
	nvlist_t *nv;
	size_t nvsize = (uint64_t )data;
	char *packed = umem_alloc(nvsize, UMEM_NOFAIL);

	VERIFY(0 == dmu_read(os, object, 0, nvsize, packed, DMU_READ_PREFETCH));

	VERIFY(nvlist_unpack(packed, nvsize, &nv, 0) == 0);

	umem_free(packed, nvsize);

	dump_nvlist(nv, 8);

	nvlist_free(nv);
	}

	/* ARGSUSED */
	static void
	dump_history_offsets(objset_t os, uint64_t object, void data, size_t size)
	{
	spa_history_phys_t *shp = data;

	if (shp == NULL)
	return;

	(void) printf("\t\tpool_create_len = %llu\n",
	(u_longlong_t)shp->sh_pool_create_len);
	(void) printf("\t\tphys_max_off = %llu\n",
	(u_longlong_t)shp->sh_phys_max_off);
	(void) printf("\t\tbof = %llu\n",
	(u_longlong_t)shp->sh_bof);
	(void) printf("\t\teof = %llu\n",
	(u_longlong_t)shp->sh_eof);
	(void) printf("\t\trecords_lost = %llu\n",
	(u_longlong_t)shp->sh_records_lost);
	}

	static void
	zdb_nicenum(uint64_t num, char *buf, size_t buflen)
	{
	if (dump_opt['P'])
	(void) snprintf(buf, buflen, "%llu", (longlong_t)num);
	else
	nicenum(num, buf, sizeof (buf));
	}

	static const char histo_stars[] = "****************************************";
	static const uint64_t histo_width = sizeof (histo_stars) - 1;

	static void
	dump_histogram(const uint64_t *histo, int size, int offset)
	{
	int i;
	int minidx = size - 1;
	int maxidx = 0;
	uint64_t max = 0;

	for (i = 0; i < size; i++) {
	if (histo[i] > max)
	max = histo[i];
	if (histo[i] > 0 && i > maxidx)
	maxidx = i;
	if (histo[i] > 0 && i < minidx)
	minidx = i;
	}

	if (max < histo_width)
	max = histo_width;

	for (i = minidx; i <= maxidx; i++) {
	(void) printf("\t\t\t%3u: %6llu %s\n",
	i + offset, (u_longlong_t)histo[i],
	&histo_stars[(max - histo[i]) * histo_width / max]);
	}
	}

	static void
	dump_zap_stats(objset_t *os, uint64_t object)
	{
	int error;
	zap_stats_t zs;

	error = zap_get_stats(os, object, &zs);
	if (error)
	return;

	if (zs.zs_ptrtbl_len == 0) {
	ASSERT(zs.zs_num_blocks == 1);
	(void) printf("\tmicrozap: %llu bytes, %llu entries\n",
	(u_longlong_t)zs.zs_blocksize,
	(u_longlong_t)zs.zs_num_entries);
	return;
	}

	(void) printf("\tFat ZAP stats:\n");

	(void) printf("\t\tPointer table:\n");
	(void) printf("\t\t\t%llu elements\n",
	(u_longlong_t)zs.zs_ptrtbl_len);
	(void) printf("\t\t\tzt_blk: %llu\n",
	(u_longlong_t)zs.zs_ptrtbl_zt_blk);
	(void) printf("\t\t\tzt_numblks: %llu\n",
	(u_longlong_t)zs.zs_ptrtbl_zt_numblks);
	(void) printf("\t\t\tzt_shift: %llu\n",
	(u_longlong_t)zs.zs_ptrtbl_zt_shift);
	(void) printf("\t\t\tzt_blks_copied: %llu\n",
	(u_longlong_t)zs.zs_ptrtbl_blks_copied);
	(void) printf("\t\t\tzt_nextblk: %llu\n",
	(u_longlong_t)zs.zs_ptrtbl_nextblk);

	(void) printf("\t\tZAP entries: %llu\n",
	(u_longlong_t)zs.zs_num_entries);
	(void) printf("\t\tLeaf blocks: %llu\n",
	(u_longlong_t)zs.zs_num_leafs);
	(void) printf("\t\tTotal blocks: %llu\n",
	(u_longlong_t)zs.zs_num_blocks);
	(void) printf("\t\tzap_block_type: 0x%llx\n",
	(u_longlong_t)zs.zs_block_type);
	(void) printf("\t\tzap_magic: 0x%llx\n",
	(u_longlong_t)zs.zs_magic);
	(void) printf("\t\tzap_salt: 0x%llx\n",
	(u_longlong_t)zs.zs_salt);

	(void) printf("\t\tLeafs with 2^n pointers:\n");
	dump_histogram(zs.zs_leafs_with_2n_pointers, ZAP_HISTOGRAM_SIZE, 0);

	(void) printf("\t\tBlocks with n*5 entries:\n");
	dump_histogram(zs.zs_blocks_with_n5_entries, ZAP_HISTOGRAM_SIZE, 0);

	(void) printf("\t\tBlocks n/10 full:\n");
	dump_histogram(zs.zs_blocks_n_tenths_full, ZAP_HISTOGRAM_SIZE, 0);

	(void) printf("\t\tEntries with n chunks:\n");
	dump_histogram(zs.zs_entries_using_n_chunks, ZAP_HISTOGRAM_SIZE, 0);

	(void) printf("\t\tBuckets with n entries:\n");
	dump_histogram(zs.zs_buckets_with_n_entries, ZAP_HISTOGRAM_SIZE, 0);
	}

	/ARGSUSED/
	static void
	dump_none(objset_t os, uint64_t object, void data, size_t size)
	{
	}

	/ARGSUSED/
	static void
	dump_unknown(objset_t os, uint64_t object, void data, size_t size)
	{
	(void) printf("\tUNKNOWN OBJECT TYPE\n");
	}

	/ARGSUSED/
	static void
	dump_uint8(objset_t os, uint64_t object, void data, size_t size)
	{
	}

	/ARGSUSED/
	static void
	dump_uint64(objset_t os, uint64_t object, void data, size_t size)
	{
	uint64_t *arr;
	uint64_t oursize;
	if (dump_opt['d'] < 6)
	return;

	if (data == NULL) {
	dmu_object_info_t doi;

	VERIFY0(dmu_object_info(os, object, &doi));
	size = doi.doi_max_offset;
	/*
	* We cap the size at 1 mebibyte here to prevent
	* allocation failures and nigh-infinite printing if the
	* object is extremely large.
	*/
	oursize = MIN(size, 1 << 20);
	arr = kmem_alloc(oursize, KM_SLEEP);

	int err = dmu_read(os, object, 0, oursize, arr, 0);
	if (err != 0) {
	(void) printf("got error %u from dmu_read\n", err);
	kmem_free(arr, oursize);
	return;
	}
	} else {
	/*
	* Even though the allocation is already done in this code path,
	* we still cap the size to prevent excessive printing.
	*/
	oursize = MIN(size, 1 << 20);
	arr = data;
	}

	if (size == 0) {
	(void) printf("\t\t[]\n");
	return;
	}

	(void) printf("\t\t[%0llx", (u_longlong_t)arr[0]);
	for (size_t i = 1; i * sizeof (uint64_t) < oursize; i++) {
	if (i % 4 != 0)
	(void) printf(", %0llx", (u_longlong_t)arr[i]);
	else
	(void) printf(",\n\t\t%0llx", (u_longlong_t)arr[i]);
	}
	if (oursize != size)
	(void) printf(", ... ");
	(void) printf("]\n");

	if (data == NULL)
	kmem_free(arr, oursize);
	}

	/ARGSUSED/
	static void
	dump_zap(objset_t os, uint64_t object, void data, size_t size)
	{
	zap_cursor_t zc;
	zap_attribute_t attr;
	void *prop;
	unsigned i;

	dump_zap_stats(os, object);
	(void) printf("\n");

	for (zap_cursor_init(&zc, os, object);
	zap_cursor_retrieve(&zc, &attr) == 0;
	zap_cursor_advance(&zc)) {
	(void) printf("\t\t%s = ", attr.za_name);
	if (attr.za_num_integers == 0) {
	(void) printf("\n");
	continue;
	}
	prop = umem_zalloc(attr.za_num_integers *
	attr.za_integer_length, UMEM_NOFAIL);
	(void) zap_lookup(os, object, attr.za_name,
	attr.za_integer_length, attr.za_num_integers, prop);
	if (attr.za_integer_length == 1) {
	if (strcmp(attr.za_name,
	DSL_CRYPTO_KEY_MASTER_KEY) == 0 \|\|
	strcmp(attr.za_name,
	DSL_CRYPTO_KEY_HMAC_KEY) == 0 \|\|
	strcmp(attr.za_name, DSL_CRYPTO_KEY_IV) == 0 \|\|
	strcmp(attr.za_name, DSL_CRYPTO_KEY_MAC) == 0 \|\|
	strcmp(attr.za_name, DMU_POOL_CHECKSUM_SALT) == 0) {
	uint8_t *u8 = prop;

	for (i = 0; i < attr.za_num_integers; i++) {
	(void) printf("%02x", u8[i]);
	}
	} else {
	(void) printf("%s", (char *)prop);
	}
	} else {
	for (i = 0; i < attr.za_num_integers; i++) {
	switch (attr.za_integer_length) {
	case 2:
	(void) printf("%u ",
	((uint16_t *)prop)[i]);
	break;
	case 4:
	(void) printf("%u ",
	((uint32_t *)prop)[i]);
	break;
	case 8:
	(void) printf("%lld ",
	(u_longlong_t)((int64_t *)prop)[i]);
	break;
	}
	}
	}
	(void) printf("\n");
	umem_free(prop, attr.za_num_integers * attr.za_integer_length);
	}
	zap_cursor_fini(&zc);
	}

	static void
	dump_bpobj(objset_t os, uint64_t object, void data, size_t size)
	{
	bpobj_phys_t *bpop = data;
	uint64_t i;
	char bytes[32], comp[32], uncomp[32];

	/* make sure the output won't get truncated */
	CTASSERT(sizeof (bytes) >= NN_NUMBUF_SZ);
	CTASSERT(sizeof (comp) >= NN_NUMBUF_SZ);
	CTASSERT(sizeof (uncomp) >= NN_NUMBUF_SZ);

	if (bpop == NULL)
	return;

	zdb_nicenum(bpop->bpo_bytes, bytes, sizeof (bytes));
	zdb_nicenum(bpop->bpo_comp, comp, sizeof (comp));
	zdb_nicenum(bpop->bpo_uncomp, uncomp, sizeof (uncomp));

	(void) printf("\t\tnum_blkptrs = %llu\n",
	(u_longlong_t)bpop->bpo_num_blkptrs);
	(void) printf("\t\tbytes = %s\n", bytes);
	if (size >= BPOBJ_SIZE_V1) {
	(void) printf("\t\tcomp = %s\n", comp);
	(void) printf("\t\tuncomp = %s\n", uncomp);
	}
	if (size >= BPOBJ_SIZE_V2) {
	(void) printf("\t\tsubobjs = %llu\n",
	(u_longlong_t)bpop->bpo_subobjs);
	(void) printf("\t\tnum_subobjs = %llu\n",
	(u_longlong_t)bpop->bpo_num_subobjs);
	}
	if (size >= sizeof (*bpop)) {
	(void) printf("\t\tnum_freed = %llu\n",
	(u_longlong_t)bpop->bpo_num_freed);
	}

	if (dump_opt['d'] < 5)
	return;

	for (i = 0; i < bpop->bpo_num_blkptrs; i++) {
	char blkbuf[BP_SPRINTF_LEN];
	blkptr_t bp;

	int err = dmu_read(os, object,
	i * sizeof (bp), sizeof (bp), &bp, 0);
	if (err != 0) {
	(void) printf("got error %u from dmu_read\n", err);
	break;
	}
	snprintf_blkptr_compact(blkbuf, sizeof (blkbuf), &bp,
	BP_GET_FREE(&bp));
	(void) printf("\t%s\n", blkbuf);
	}
	}

	/* ARGSUSED */
	static void
	dump_bpobj_subobjs(objset_t os, uint64_t object, void data, size_t size)
	{
	dmu_object_info_t doi;
	int64_t i;

	VERIFY0(dmu_object_info(os, object, &doi));
	uint64_t *subobjs = kmem_alloc(doi.doi_max_offset, KM_SLEEP);

	int err = dmu_read(os, object, 0, doi.doi_max_offset, subobjs, 0);
	if (err != 0) {
	(void) printf("got error %u from dmu_read\n", err);
	kmem_free(subobjs, doi.doi_max_offset);
	return;
	}

	int64_t last_nonzero = -1;
	for (i = 0; i < doi.doi_max_offset / 8; i++) {
	if (subobjs[i] != 0)
	last_nonzero = i;
	}

	for (i = 0; i <= last_nonzero; i++) {
	(void) printf("\t%llu\n", (u_longlong_t)subobjs[i]);
	}
	kmem_free(subobjs, doi.doi_max_offset);
	}

	/ARGSUSED/
	static void
	dump_ddt_zap(objset_t os, uint64_t object, void data, size_t size)
	{
	dump_zap_stats(os, object);
	/* contents are printed elsewhere, properly decoded */
	}

	/ARGSUSED/
	static void
	dump_sa_attrs(objset_t os, uint64_t object, void data, size_t size)
	{
	zap_cursor_t zc;
	zap_attribute_t attr;

	dump_zap_stats(os, object);
	(void) printf("\n");

	for (zap_cursor_init(&zc, os, object);
	zap_cursor_retrieve(&zc, &attr) == 0;
	zap_cursor_advance(&zc)) {
	(void) printf("\t\t%s = ", attr.za_name);
	if (attr.za_num_integers == 0) {
	(void) printf("\n");
	continue;
	}
	(void) printf(" %llx : [%d:%d:%d]\n",
	(u_longlong_t)attr.za_first_integer,
	(int)ATTR_LENGTH(attr.za_first_integer),
	(int)ATTR_BSWAP(attr.za_first_integer),
	(int)ATTR_NUM(attr.za_first_integer));
	}
	zap_cursor_fini(&zc);
	}

	/ARGSUSED/
	static void
	dump_sa_layouts(objset_t os, uint64_t object, void data, size_t size)
	{
	zap_cursor_t zc;
	zap_attribute_t attr;
	uint16_t *layout_attrs;
	unsigned i;

	dump_zap_stats(os, object);
	(void) printf("\n");

	for (zap_cursor_init(&zc, os, object);
	zap_cursor_retrieve(&zc, &attr) == 0;
	zap_cursor_advance(&zc)) {
	(void) printf("\t\t%s = [", attr.za_name);
	if (attr.za_num_integers == 0) {
	(void) printf("\n");
	continue;
	}

	VERIFY(attr.za_integer_length == 2);
	layout_attrs = umem_zalloc(attr.za_num_integers *
	attr.za_integer_length, UMEM_NOFAIL);

	VERIFY(zap_lookup(os, object, attr.za_name,
	attr.za_integer_length,
	attr.za_num_integers, layout_attrs) == 0);

	for (i = 0; i != attr.za_num_integers; i++)
	(void) printf(" %d ", (int)layout_attrs[i]);
	(void) printf("]\n");
	umem_free(layout_attrs,
	attr.za_num_integers * attr.za_integer_length);
	}
	zap_cursor_fini(&zc);
	}

	/ARGSUSED/
	static void
	dump_zpldir(objset_t os, uint64_t object, void data, size_t size)
	{
	zap_cursor_t zc;
	zap_attribute_t attr;
	const char *typenames[] = {
	/* 0 */ "not specified",
	/* 1 */ "FIFO",
	/* 2 */ "Character Device",
	/* 3 */ "3 (invalid)",
	/* 4 */ "Directory",
	/* 5 */ "5 (invalid)",
	/* 6 */ "Block Device",
	/* 7 */ "7 (invalid)",
	/* 8 */ "Regular File",
	/* 9 */ "9 (invalid)",
	/* 10 */ "Symbolic Link",
	/* 11 */ "11 (invalid)",
	/* 12 */ "Socket",
	/* 13 */ "Door",
	/* 14 */ "Event Port",
	/* 15 */ "15 (invalid)",
	};

	dump_zap_stats(os, object);
	(void) printf("\n");

	for (zap_cursor_init(&zc, os, object);
	zap_cursor_retrieve(&zc, &attr) == 0;
	zap_cursor_advance(&zc)) {
	(void) printf("\t\t%s = %lld (type: %s)\n",
	attr.za_name, ZFS_DIRENT_OBJ(attr.za_first_integer),
	typenames[ZFS_DIRENT_TYPE(attr.za_first_integer)]);
	}
	zap_cursor_fini(&zc);
	}

	static int
	get_dtl_refcount(vdev_t *vd)
	{
	int refcount = 0;

	if (vd->vdev_ops->vdev_op_leaf) {
	space_map_t *sm = vd->vdev_dtl_sm;

	if (sm != NULL &&
	sm->sm_dbuf->db_size == sizeof (space_map_phys_t))
	return (1);
	return (0);
	}

	for (unsigned c = 0; c < vd->vdev_children; c++)
	refcount += get_dtl_refcount(vd->vdev_child[c]);
	return (refcount);
	}

	static int
	get_metaslab_refcount(vdev_t *vd)
	{
	int refcount = 0;

	if (vd->vdev_top == vd) {
	for (uint64_t m = 0; m < vd->vdev_ms_count; m++) {
	space_map_t *sm = vd->vdev_ms[m]->ms_sm;

	if (sm != NULL &&
	sm->sm_dbuf->db_size == sizeof (space_map_phys_t))
	refcount++;
	}
	}
	for (unsigned c = 0; c < vd->vdev_children; c++)
	refcount += get_metaslab_refcount(vd->vdev_child[c]);

	return (refcount);
	}

	static int
	get_obsolete_refcount(vdev_t *vd)
	{
	uint64_t obsolete_sm_object;
	int refcount = 0;

	VERIFY0(vdev_obsolete_sm_object(vd, &obsolete_sm_object));
	if (vd->vdev_top == vd && obsolete_sm_object != 0) {
	dmu_object_info_t doi;
	VERIFY0(dmu_object_info(vd->vdev_spa->spa_meta_objset,
	obsolete_sm_object, &doi));
	if (doi.doi_bonus_size == sizeof (space_map_phys_t)) {
	refcount++;
	}
	} else {
	ASSERT3P(vd->vdev_obsolete_sm, ==, NULL);
	ASSERT3U(obsolete_sm_object, ==, 0);
	}
	for (unsigned c = 0; c < vd->vdev_children; c++) {
	refcount += get_obsolete_refcount(vd->vdev_child[c]);
	}

	return (refcount);
	}

	static int
	get_prev_obsolete_spacemap_refcount(spa_t *spa)
	{
	uint64_t prev_obj =
	spa->spa_condensing_indirect_phys.scip_prev_obsolete_sm_object;
	if (prev_obj != 0) {
	dmu_object_info_t doi;
	VERIFY0(dmu_object_info(spa->spa_meta_objset, prev_obj, &doi));
	if (doi.doi_bonus_size == sizeof (space_map_phys_t)) {
	return (1);
	}
	}
	return (0);
	}

	static int
	get_checkpoint_refcount(vdev_t *vd)
	{
	int refcount = 0;

	if (vd->vdev_top == vd && vd->vdev_top_zap != 0 &&
	zap_contains(spa_meta_objset(vd->vdev_spa),
	vd->vdev_top_zap, VDEV_TOP_ZAP_POOL_CHECKPOINT_SM) == 0)
	refcount++;

	for (uint64_t c = 0; c < vd->vdev_children; c++)
	refcount += get_checkpoint_refcount(vd->vdev_child[c]);

	return (refcount);
	}

	static int
	get_log_spacemap_refcount(spa_t *spa)
	{
	return (avl_numnodes(&spa->spa_sm_logs_by_txg));
	}

	static int
	verify_spacemap_refcounts(spa_t *spa)
	{
	uint64_t expected_refcount = 0;
	uint64_t actual_refcount;

	(void) feature_get_refcount(spa,
	&spa_feature_table[SPA_FEATURE_SPACEMAP_HISTOGRAM],
	&expected_refcount);
	actual_refcount = get_dtl_refcount(spa->spa_root_vdev);
	actual_refcount += get_metaslab_refcount(spa->spa_root_vdev);
	actual_refcount += get_obsolete_refcount(spa->spa_root_vdev);
	actual_refcount += get_prev_obsolete_spacemap_refcount(spa);
	actual_refcount += get_checkpoint_refcount(spa->spa_root_vdev);
	actual_refcount += get_log_spacemap_refcount(spa);

	if (expected_refcount != actual_refcount) {
	(void) printf("space map refcount mismatch: expected %lld != "
	"actual %lld\n",
	(longlong_t)expected_refcount,
	(longlong_t)actual_refcount);
	return (2);
	}
	return (0);
	}

	static void
	dump_spacemap(objset_t os, space_map_t sm)
	{
	const char *ddata[] = { "ALLOC", "FREE", "CONDENSE", "INVALID",
	"INVALID", "INVALID", "INVALID", "INVALID" };

	if (sm == NULL)
	return;

	(void) printf("space map object %llu:\n",
	(longlong_t)sm->sm_object);
	(void) printf(" smp_length = 0x%llx\n",
	(longlong_t)sm->sm_phys->smp_length);
	(void) printf(" smp_alloc = 0x%llx\n",
	(longlong_t)sm->sm_phys->smp_alloc);

	if (dump_opt['d'] < 6 && dump_opt['m'] < 4)
	return;

	/*
	* Print out the freelist entries in both encoded and decoded form.
	*/
	uint8_t mapshift = sm->sm_shift;
	int64_t alloc = 0;
	uint64_t word, entry_id = 0;
	for (uint64_t offset = 0; offset < space_map_length(sm);
	offset += sizeof (word)) {

	VERIFY0(dmu_read(os, space_map_object(sm), offset,
	sizeof (word), &word, DMU_READ_PREFETCH));

	if (sm_entry_is_debug(word)) {
	uint64_t de_txg = SM_DEBUG_TXG_DECODE(word);
	uint64_t de_sync_pass = SM_DEBUG_SYNCPASS_DECODE(word);
	if (de_txg == 0) {
	(void) printf(
	"\t [%6llu] PADDING\n",
	(u_longlong_t)entry_id);
	} else {
	(void) printf(
	"\t [%6llu] %s: txg %llu pass %llu\n",
	(u_longlong_t)entry_id,
	ddata[SM_DEBUG_ACTION_DECODE(word)],
	(u_longlong_t)de_txg,
	(u_longlong_t)de_sync_pass);
	}
	entry_id++;
	continue;
	}

	uint8_t words;
	char entry_type;
	uint64_t entry_off, entry_run, entry_vdev = SM_NO_VDEVID;

	if (sm_entry_is_single_word(word)) {
	entry_type = (SM_TYPE_DECODE(word) == SM_ALLOC) ?
	'A' : 'F';
	entry_off = (SM_OFFSET_DECODE(word) << mapshift) +
	sm->sm_start;
	entry_run = SM_RUN_DECODE(word) << mapshift;
	words = 1;
	} else {
	/* it is a two-word entry so we read another word */
	ASSERT(sm_entry_is_double_word(word));

	uint64_t extra_word;
	offset += sizeof (extra_word);
	VERIFY0(dmu_read(os, space_map_object(sm), offset,
	sizeof (extra_word), &extra_word,
	DMU_READ_PREFETCH));

	ASSERT3U(offset, <=, space_map_length(sm));

	entry_run = SM2_RUN_DECODE(word) << mapshift;
	entry_vdev = SM2_VDEV_DECODE(word);
	entry_type = (SM2_TYPE_DECODE(extra_word) == SM_ALLOC) ?
	'A' : 'F';
	entry_off = (SM2_OFFSET_DECODE(extra_word) <<
	mapshift) + sm->sm_start;
	words = 2;
	}

	(void) printf("\t [%6llu] %c range:"
	" %010llx-%010llx size: %06llx vdev: %06llu words: %u\n",
	(u_longlong_t)entry_id,
	entry_type, (u_longlong_t)entry_off,
	(u_longlong_t)(entry_off + entry_run),
	(u_longlong_t)entry_run,
	(u_longlong_t)entry_vdev, words);

	if (entry_type == 'A')
	alloc += entry_run;
	else
	alloc -= entry_run;
	entry_id++;
	}
	if (alloc != space_map_allocated(sm)) {
	(void) printf("space_map_object alloc (%lld) INCONSISTENT "
	"with space map summary (%lld)\n",
	(longlong_t)space_map_allocated(sm), (longlong_t)alloc);
	}
	}

	static void
	dump_metaslab_stats(metaslab_t *msp)
	{
	char maxbuf[32];
	range_tree_t *rt = msp->ms_allocatable;
	zfs_btree_t *t = &msp->ms_allocatable_by_size;
	int free_pct = range_tree_space(rt) * 100 / msp->ms_size;

	/* max sure nicenum has enough space */
	CTASSERT(sizeof (maxbuf) >= NN_NUMBUF_SZ);

	zdb_nicenum(metaslab_largest_allocatable(msp), maxbuf, sizeof (maxbuf));

	(void) printf("\t %25s %10lu %7s %6s %4s %4d%%\n",
	"segments", zfs_btree_numnodes(t), "maxsize", maxbuf,
	"freepct", free_pct);
	(void) printf("\tIn-memory histogram:\n");
	dump_histogram(rt->rt_histogram, RANGE_TREE_HISTOGRAM_SIZE, 0);
	}

	static void
	dump_metaslab(metaslab_t *msp)
	{
	vdev_t *vd = msp->ms_group->mg_vd;
	spa_t *spa = vd->vdev_spa;
	space_map_t *sm = msp->ms_sm;
	char freebuf[32];

	zdb_nicenum(msp->ms_size - space_map_allocated(sm), freebuf,
	sizeof (freebuf));

	(void) printf(
	"\tmetaslab %6llu offset %12llx spacemap %6llu free %5s\n",
	(u_longlong_t)msp->ms_id, (u_longlong_t)msp->ms_start,
	(u_longlong_t)space_map_object(sm), freebuf);

	if (dump_opt['m'] > 2 && !dump_opt['L']) {
	mutex_enter(&msp->ms_lock);
	VERIFY0(metaslab_load(msp));
	range_tree_stat_verify(msp->ms_allocatable);
	dump_metaslab_stats(msp);
	metaslab_unload(msp);
	mutex_exit(&msp->ms_lock);
	}

	if (dump_opt['m'] > 1 && sm != NULL &&
	spa_feature_is_active(spa, SPA_FEATURE_SPACEMAP_HISTOGRAM)) {
	/*
	* The space map histogram represents free space in chunks
	* of sm_shift (i.e. bucket 0 refers to 2^sm_shift).
	*/
	(void) printf("\tOn-disk histogram:\t\tfragmentation %llu\n",
	(u_longlong_t)msp->ms_fragmentation);
	dump_histogram(sm->sm_phys->smp_histogram,
	SPACE_MAP_HISTOGRAM_SIZE, sm->sm_shift);
	}

	if (vd->vdev_ops == &vdev_draid_ops)
	ASSERT3U(msp->ms_size, <=, 1ULL << vd->vdev_ms_shift);
	else
	ASSERT3U(msp->ms_size, ==, 1ULL << vd->vdev_ms_shift);

	dump_spacemap(spa->spa_meta_objset, msp->ms_sm);

	if (spa_feature_is_active(spa, SPA_FEATURE_LOG_SPACEMAP)) {
	(void) printf("\tFlush data:\n\tunflushed txg=%llu\n\n",
	(u_longlong_t)metaslab_unflushed_txg(msp));
	}
	}

	static void
	print_vdev_metaslab_header(vdev_t *vd)
	{
	vdev_alloc_bias_t alloc_bias = vd->vdev_alloc_bias;
	const char *bias_str = "";
	if (alloc_bias == VDEV_BIAS_LOG \|\| vd->vdev_islog) {
	bias_str = VDEV_ALLOC_BIAS_LOG;
	} else if (alloc_bias == VDEV_BIAS_SPECIAL) {
	bias_str = VDEV_ALLOC_BIAS_SPECIAL;
	} else if (alloc_bias == VDEV_BIAS_DEDUP) {
	bias_str = VDEV_ALLOC_BIAS_DEDUP;
	}

	uint64_t ms_flush_data_obj = 0;
	if (vd->vdev_top_zap != 0) {
	int error = zap_lookup(spa_meta_objset(vd->vdev_spa),
	vd->vdev_top_zap, VDEV_TOP_ZAP_MS_UNFLUSHED_PHYS_TXGS,
	sizeof (uint64_t), 1, &ms_flush_data_obj);
	if (error != ENOENT) {
	ASSERT0(error);
	}
	}

	(void) printf("\tvdev %10llu %s",
	(u_longlong_t)vd->vdev_id, bias_str);

	if (ms_flush_data_obj != 0) {
	(void) printf(" ms_unflushed_phys object %llu",
	(u_longlong_t)ms_flush_data_obj);
	}

	(void) printf("\n\t%-10s%5llu %-19s %-15s %-12s\n",
	"metaslabs", (u_longlong_t)vd->vdev_ms_count,
	"offset", "spacemap", "free");
	(void) printf("\t%15s %19s %15s %12s\n",
	"---------------", "-------------------",
	"---------------", "------------");
	}

	static void
	dump_metaslab_groups(spa_t *spa)
	{
	vdev_t *rvd = spa->spa_root_vdev;
	metaslab_class_t *mc = spa_normal_class(spa);
	uint64_t fragmentation;

	metaslab_class_histogram_verify(mc);

	for (unsigned c = 0; c < rvd->vdev_children; c++) {
	vdev_t *tvd = rvd->vdev_child[c];
	metaslab_group_t *mg = tvd->vdev_mg;

	if (mg == NULL \|\| mg->mg_class != mc)
	continue;

	metaslab_group_histogram_verify(mg);
	mg->mg_fragmentation = metaslab_group_fragmentation(mg);

	(void) printf("\tvdev %10llu\t\tmetaslabs%5llu\t\t"
	"fragmentation",
	(u_longlong_t)tvd->vdev_id,
	(u_longlong_t)tvd->vdev_ms_count);
	if (mg->mg_fragmentation == ZFS_FRAG_INVALID) {
	(void) printf("%3s\n", "-");
	} else {
	(void) printf("%3llu%%\n",
	(u_longlong_t)mg->mg_fragmentation);
	}
	dump_histogram(mg->mg_histogram, RANGE_TREE_HISTOGRAM_SIZE, 0);
	}

	(void) printf("\tpool %s\tfragmentation", spa_name(spa));
	fragmentation = metaslab_class_fragmentation(mc);
	if (fragmentation == ZFS_FRAG_INVALID)
	(void) printf("\t%3s\n", "-");
	else
	(void) printf("\t%3llu%%\n", (u_longlong_t)fragmentation);
	dump_histogram(mc->mc_histogram, RANGE_TREE_HISTOGRAM_SIZE, 0);
	}

	static void
	print_vdev_indirect(vdev_t *vd)
	{
	vdev_indirect_config_t *vic = &vd->vdev_indirect_config;
	vdev_indirect_mapping_t *vim = vd->vdev_indirect_mapping;
	vdev_indirect_births_t *vib = vd->vdev_indirect_births;

	if (vim == NULL) {
	ASSERT3P(vib, ==, NULL);
	return;
	}

	ASSERT3U(vdev_indirect_mapping_object(vim), ==,
	vic->vic_mapping_object);
	ASSERT3U(vdev_indirect_births_object(vib), ==,
	vic->vic_births_object);

	(void) printf("indirect births obj %llu:\n",
	(longlong_t)vic->vic_births_object);
	(void) printf(" vib_count = %llu\n",
	(longlong_t)vdev_indirect_births_count(vib));
	for (uint64_t i = 0; i < vdev_indirect_births_count(vib); i++) {
	vdev_indirect_birth_entry_phys_t *cur_vibe =
	&vib->vib_entries[i];
	(void) printf("\toffset %llx -> txg %llu\n",
	(longlong_t)cur_vibe->vibe_offset,
	(longlong_t)cur_vibe->vibe_phys_birth_txg);
	}
	(void) printf("\n");

	(void) printf("indirect mapping obj %llu:\n",
	(longlong_t)vic->vic_mapping_object);
	(void) printf(" vim_max_offset = 0x%llx\n",
	(longlong_t)vdev_indirect_mapping_max_offset(vim));
	(void) printf(" vim_bytes_mapped = 0x%llx\n",
	(longlong_t)vdev_indirect_mapping_bytes_mapped(vim));
	(void) printf(" vim_count = %llu\n",
	(longlong_t)vdev_indirect_mapping_num_entries(vim));

	if (dump_opt['d'] <= 5 && dump_opt['m'] <= 3)
	return;

	uint32_t *counts = vdev_indirect_mapping_load_obsolete_counts(vim);

	for (uint64_t i = 0; i < vdev_indirect_mapping_num_entries(vim); i++) {
	vdev_indirect_mapping_entry_phys_t *vimep =
	&vim->vim_entries[i];
	(void) printf("\t<%llx:%llx:%llx> -> "
	"<%llx:%llx:%llx> (%x obsolete)\n",
	(longlong_t)vd->vdev_id,
	(longlong_t)DVA_MAPPING_GET_SRC_OFFSET(vimep),
	(longlong_t)DVA_GET_ASIZE(&vimep->vimep_dst),
	(longlong_t)DVA_GET_VDEV(&vimep->vimep_dst),
	(longlong_t)DVA_GET_OFFSET(&vimep->vimep_dst),
	(longlong_t)DVA_GET_ASIZE(&vimep->vimep_dst),
	counts[i]);
	}
	(void) printf("\n");

	uint64_t obsolete_sm_object;
	VERIFY0(vdev_obsolete_sm_object(vd, &obsolete_sm_object));
	if (obsolete_sm_object != 0) {
	objset_t *mos = vd->vdev_spa->spa_meta_objset;
	(void) printf("obsolete space map object %llu:\n",
	(u_longlong_t)obsolete_sm_object);
	ASSERT(vd->vdev_obsolete_sm != NULL);
	ASSERT3U(space_map_object(vd->vdev_obsolete_sm), ==,
	obsolete_sm_object);
	dump_spacemap(mos, vd->vdev_obsolete_sm);
	(void) printf("\n");
	}
	}

	static void
	dump_metaslabs(spa_t *spa)
	{
	vdev_t vd, rvd = spa->spa_root_vdev;
	uint64_t m, c = 0, children = rvd->vdev_children;

	(void) printf("\nMetaslabs:\n");

	if (!dump_opt['d'] && zopt_metaslab_args > 0) {
	c = zopt_metaslab[0];

	if (c >= children)
	(void) fatal("bad vdev id: %llu", (u_longlong_t)c);

	if (zopt_metaslab_args > 1) {
	vd = rvd->vdev_child[c];
	print_vdev_metaslab_header(vd);

	for (m = 1; m < zopt_metaslab_args; m++) {
	if (zopt_metaslab[m] < vd->vdev_ms_count)
	dump_metaslab(
	vd->vdev_ms[zopt_metaslab[m]]);
	else
	(void) fprintf(stderr, "bad metaslab "
	"number %llu\n",
	(u_longlong_t)zopt_metaslab[m]);
	}
	(void) printf("\n");
	return;
	}
	children = c + 1;
	}
	for (; c < children; c++) {
	vd = rvd->vdev_child[c];
	print_vdev_metaslab_header(vd);

	print_vdev_indirect(vd);

	for (m = 0; m < vd->vdev_ms_count; m++)
	dump_metaslab(vd->vdev_ms[m]);
	(void) printf("\n");
	}
	}

	static void
	dump_log_spacemaps(spa_t *spa)
	{
	if (!spa_feature_is_active(spa, SPA_FEATURE_LOG_SPACEMAP))
	return;

	(void) printf("\nLog Space Maps in Pool:\n");
	for (spa_log_sm_t *sls = avl_first(&spa->spa_sm_logs_by_txg);
	sls; sls = AVL_NEXT(&spa->spa_sm_logs_by_txg, sls)) {
	space_map_t *sm = NULL;
	VERIFY0(space_map_open(&sm, spa_meta_objset(spa),
	sls->sls_sm_obj, 0, UINT64_MAX, SPA_MINBLOCKSHIFT));

	(void) printf("Log Spacemap object %llu txg %llu\n",
	(u_longlong_t)sls->sls_sm_obj, (u_longlong_t)sls->sls_txg);
	dump_spacemap(spa->spa_meta_objset, sm);
	space_map_close(sm);
	}
	(void) printf("\n");
	}

	static void
	dump_dde(const ddt_t ddt, const ddt_entry_t dde, uint64_t index)
	{
	const ddt_phys_t *ddp = dde->dde_phys;
	const ddt_key_t *ddk = &dde->dde_key;
	const char *types[4] = { "ditto", "single", "double", "triple" };
	char blkbuf[BP_SPRINTF_LEN];
	blkptr_t blk;
	int p;

	for (p = 0; p < DDT_PHYS_TYPES; p++, ddp++) {
	if (ddp->ddp_phys_birth == 0)
	continue;
	ddt_bp_create(ddt->ddt_checksum, ddk, ddp, &blk);
	snprintf_blkptr(blkbuf, sizeof (blkbuf), &blk);
	(void) printf("index %llx refcnt %llu %s %s\n",
	(u_longlong_t)index, (u_longlong_t)ddp->ddp_refcnt,
	types[p], blkbuf);
	}
	}

	static void
	dump_dedup_ratio(const ddt_stat_t *dds)
	{
	double rL, rP, rD, D, dedup, compress, copies;

	if (dds->dds_blocks == 0)
	return;

	rL = (double)dds->dds_ref_lsize;
	rP = (double)dds->dds_ref_psize;
	rD = (double)dds->dds_ref_dsize;
	D = (double)dds->dds_dsize;

	dedup = rD / D;
	compress = rL / rP;
	copies = rD / rP;

	(void) printf("dedup = %.2f, compress = %.2f, copies = %.2f, "
	"dedup * compress / copies = %.2f\n\n",
	dedup, compress, copies, dedup * compress / copies);
	}

	static void
	dump_ddt(ddt_t *ddt, enum ddt_type type, enum ddt_class class)
	{
	char name[DDT_NAMELEN];
	ddt_entry_t dde;
	uint64_t walk = 0;
	dmu_object_info_t doi;
	uint64_t count, dspace, mspace;
	int error;

	error = ddt_object_info(ddt, type, class, &doi);

	if (error == ENOENT)
	return;
	ASSERT(error == 0);

	error = ddt_object_count(ddt, type, class, &count);
	ASSERT(error == 0);
	if (count == 0)
	return;

	dspace = doi.doi_physical_blocks_512 << 9;
	mspace = doi.doi_fill_count * doi.doi_data_block_size;

	ddt_object_name(ddt, type, class, name);

	(void) printf("%s: %llu entries, size %llu on disk, %llu in core\n",
	name,
	(u_longlong_t)count,
	(u_longlong_t)(dspace / count),
	(u_longlong_t)(mspace / count));

	if (dump_opt['D'] < 3)
	return;

	zpool_dump_ddt(NULL, &ddt->ddt_histogram[type][class]);

	if (dump_opt['D'] < 4)
	return;

	if (dump_opt['D'] < 5 && class == DDT_CLASS_UNIQUE)
	return;

	(void) printf("%s contents:\n\n", name);

	while ((error = ddt_object_walk(ddt, type, class, &walk, &dde)) == 0)
	dump_dde(ddt, &dde, walk);

	ASSERT3U(error, ==, ENOENT);

	(void) printf("\n");
	}

	static void
	dump_all_ddts(spa_t *spa)
	{
	ddt_histogram_t ddh_total;
	ddt_stat_t dds_total;

	bzero(&ddh_total, sizeof (ddh_total));
	bzero(&dds_total, sizeof (dds_total));

	for (enum zio_checksum c = 0; c < ZIO_CHECKSUM_FUNCTIONS; c++) {
	ddt_t *ddt = spa->spa_ddt[c];
	for (enum ddt_type type = 0; type < DDT_TYPES; type++) {
	for (enum ddt_class class = 0; class < DDT_CLASSES;
	class++) {
	dump_ddt(ddt, type, class);
	}
	}
	}

	ddt_get_dedup_stats(spa, &dds_total);

	if (dds_total.dds_blocks == 0) {
	(void) printf("All DDTs are empty\n");
	return;
	}

	(void) printf("\n");

	if (dump_opt['D'] > 1) {
	(void) printf("DDT histogram (aggregated over all DDTs):\n");
	ddt_get_dedup_histogram(spa, &ddh_total);
	zpool_dump_ddt(&dds_total, &ddh_total);
	}

	dump_dedup_ratio(&dds_total);
	}

	static void
	dump_dtl_seg(void *arg, uint64_t start, uint64_t size)
	{
	char *prefix = arg;

	(void) printf("%s [%llu,%llu) length %llu\n",
	prefix,
	(u_longlong_t)start,
	(u_longlong_t)(start + size),
	(u_longlong_t)(size));
	}

	static void
	dump_dtl(vdev_t *vd, int indent)
	{
	spa_t *spa = vd->vdev_spa;
	boolean_t required;
	const char *name[DTL_TYPES] = { "missing", "partial", "scrub",
	"outage" };
	char prefix[256];

	spa_vdev_state_enter(spa, SCL_NONE);
	required = vdev_dtl_required(vd);
	(void) spa_vdev_state_exit(spa, NULL, 0);

	if (indent == 0)
	(void) printf("\nDirty time logs:\n\n");

	(void) printf("\t%*s%s [%s]\n", indent, "",
	vd->vdev_path ? vd->vdev_path :
	vd->vdev_parent ? vd->vdev_ops->vdev_op_type : spa_name(spa),
	required ? "DTL-required" : "DTL-expendable");

	for (int t = 0; t < DTL_TYPES; t++) {
	range_tree_t *rt = vd->vdev_dtl[t];
	if (range_tree_space(rt) == 0)
	continue;
	(void) snprintf(prefix, sizeof (prefix), "\t%*s%s",
	indent + 2, "", name[t]);
	range_tree_walk(rt, dump_dtl_seg, prefix);
	if (dump_opt['d'] > 5 && vd->vdev_children == 0)
	dump_spacemap(spa->spa_meta_objset,
	vd->vdev_dtl_sm);
	}

	for (unsigned c = 0; c < vd->vdev_children; c++)
	dump_dtl(vd->vdev_child[c], indent + 4);
	}

	static void
	dump_history(spa_t *spa)
	{
	nvlist_t **events = NULL;
	char *buf;
	uint64_t resid, len, off = 0;
	uint_t num = 0;
	int error;
	time_t tsec;
	struct tm t;
	char tbuf[30];
	char internalstr[MAXPATHLEN];

	if ((buf = malloc(SPA_OLD_MAXBLOCKSIZE)) == NULL) {
	(void) fprintf(stderr, "%s: unable to allocate I/O buffer\n",
	__func__);
	return;
	}

	do {
	len = SPA_OLD_MAXBLOCKSIZE;

	if ((error = spa_history_get(spa, &off, &len, buf)) != 0) {
	(void) fprintf(stderr, "Unable to read history: "
	"error %d\n", error);
	free(buf);
	return;
	}

	if (zpool_history_unpack(buf, len, &resid, &events, &num) != 0)
	break;

	off -= resid;
	} while (len != 0);

	(void) printf("\nHistory:\n");
	for (unsigned i = 0; i < num; i++) {
	uint64_t time, txg, ievent;
	char cmd, intstr;
	boolean_t printed = B_FALSE;

	if (nvlist_lookup_uint64(events[i], ZPOOL_HIST_TIME,
	&time) != 0)
	goto next;
	if (nvlist_lookup_string(events[i], ZPOOL_HIST_CMD,
	&cmd) != 0) {
	if (nvlist_lookup_uint64(events[i],
	ZPOOL_HIST_INT_EVENT, &ievent) != 0)
	goto next;
	verify(nvlist_lookup_uint64(events[i],
	ZPOOL_HIST_TXG, &txg) == 0);
	verify(nvlist_lookup_string(events[i],
	ZPOOL_HIST_INT_STR, &intstr) == 0);
	if (ievent >= ZFS_NUM_LEGACY_HISTORY_EVENTS)
	goto next;

	(void) snprintf(internalstr,
	sizeof (internalstr),
	"[internal %s txg:%lld] %s",
	zfs_history_event_names[ievent],
	(longlong_t)txg, intstr);
	cmd = internalstr;
	}
	tsec = time;
	(void) localtime_r(&tsec, &t);
	(void) strftime(tbuf, sizeof (tbuf), "%F.%T", &t);
	(void) printf("%s %s\n", tbuf, cmd);
	printed = B_TRUE;

	next:
	if (dump_opt['h'] > 1) {
	if (!printed)
	(void) printf("unrecognized record:\n");
	dump_nvlist(events[i], 2);
	}
	}
	free(buf);
	}

	/ARGSUSED/
	static void
	dump_dnode(objset_t os, uint64_t object, void data, size_t size)
	{
	}

	static uint64_t
	blkid2offset(const dnode_phys_t dnp, const blkptr_t bp,
	const zbookmark_phys_t *zb)
	{
	if (dnp == NULL) {
	ASSERT(zb->zb_level < 0);
	if (zb->zb_object == 0)
	return (zb->zb_blkid);
	return (zb->zb_blkid * BP_GET_LSIZE(bp));
	}

	ASSERT(zb->zb_level >= 0);

	return ((zb->zb_blkid <<
	(zb->zb_level * (dnp->dn_indblkshift - SPA_BLKPTRSHIFT))) *
	dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT);
	}

	static void
	snprintf_zstd_header(spa_t spa, char blkbuf, size_t buflen,
	const blkptr_t *bp)
	{
	abd_t *pabd;
	void *buf;
	zio_t *zio;
	zfs_zstdhdr_t zstd_hdr;
	int error;

	if (BP_GET_COMPRESS(bp) != ZIO_COMPRESS_ZSTD)
	return;

	if (BP_IS_HOLE(bp))
	return;

	if (BP_IS_EMBEDDED(bp)) {
	buf = malloc(SPA_MAXBLOCKSIZE);
	if (buf == NULL) {
	(void) fprintf(stderr, "out of memory\n");
	exit(1);
	}
	decode_embedded_bp_compressed(bp, buf);
	memcpy(&zstd_hdr, buf, sizeof (zstd_hdr));
	free(buf);
	zstd_hdr.c_len = BE_32(zstd_hdr.c_len);
	zstd_hdr.raw_version_level = BE_32(zstd_hdr.raw_version_level);
	(void) snprintf(blkbuf + strlen(blkbuf),
	buflen - strlen(blkbuf),
	" ZSTD:size=%u:version=%u:level=%u:EMBEDDED",
	zstd_hdr.c_len, zstd_hdr.version, zstd_hdr.level);
	return;
	}

	pabd = abd_alloc_for_io(SPA_MAXBLOCKSIZE, B_FALSE);
	zio = zio_root(spa, NULL, NULL, 0);

	/* Decrypt but don't decompress so we can read the compression header */
	zio_nowait(zio_read(zio, spa, bp, pabd, BP_GET_PSIZE(bp), NULL, NULL,
	ZIO_PRIORITY_SYNC_READ, ZIO_FLAG_CANFAIL \| ZIO_FLAG_RAW_COMPRESS,
	NULL));
	error = zio_wait(zio);
	if (error) {
	(void) fprintf(stderr, "read failed: %d\n", error);
	return;
	}
	buf = abd_borrow_buf_copy(pabd, BP_GET_LSIZE(bp));
	memcpy(&zstd_hdr, buf, sizeof (zstd_hdr));
	zstd_hdr.c_len = BE_32(zstd_hdr.c_len);
	zstd_hdr.raw_version_level = BE_32(zstd_hdr.raw_version_level);

	(void) snprintf(blkbuf + strlen(blkbuf),
	buflen - strlen(blkbuf),
	" ZSTD:size=%u:version=%u:level=%u:NORMAL",
	zstd_hdr.c_len, zstd_hdr.version, zstd_hdr.level);

	abd_return_buf_copy(pabd, buf, BP_GET_LSIZE(bp));
	}

	static void
	snprintf_blkptr_compact(char blkbuf, size_t buflen, const blkptr_t bp,
	boolean_t bp_freed)
	{
	const dva_t *dva = bp->blk_dva;
	int ndvas = dump_opt['d'] > 5 ? BP_GET_NDVAS(bp) : 1;
	int i;

	if (dump_opt['b'] >= 6) {
	snprintf_blkptr(blkbuf, buflen, bp);
	if (bp_freed) {
	(void) snprintf(blkbuf + strlen(blkbuf),
	buflen - strlen(blkbuf), " %s", "FREE");
	}
	return;
	}

	if (BP_IS_EMBEDDED(bp)) {
	(void) sprintf(blkbuf,
	"EMBEDDED et=%u %llxL/%llxP B=%llu",
	(int)BPE_GET_ETYPE(bp),
	(u_longlong_t)BPE_GET_LSIZE(bp),
	(u_longlong_t)BPE_GET_PSIZE(bp),
	(u_longlong_t)bp->blk_birth);
	return;
	}

	blkbuf[0] = '\0';

	for (i = 0; i < ndvas; i++)
	(void) snprintf(blkbuf + strlen(blkbuf),
	buflen - strlen(blkbuf), "%llu:%llx:%llx ",
	(u_longlong_t)DVA_GET_VDEV(&dva[i]),
	(u_longlong_t)DVA_GET_OFFSET(&dva[i]),
	(u_longlong_t)DVA_GET_ASIZE(&dva[i]));

	if (BP_IS_HOLE(bp)) {
	(void) snprintf(blkbuf + strlen(blkbuf),
	buflen - strlen(blkbuf),
	"%llxL B=%llu",
	(u_longlong_t)BP_GET_LSIZE(bp),
	(u_longlong_t)bp->blk_birth);
	} else {
	(void) snprintf(blkbuf + strlen(blkbuf),
	buflen - strlen(blkbuf),
	"%llxL/%llxP F=%llu B=%llu/%llu",
	(u_longlong_t)BP_GET_LSIZE(bp),
	(u_longlong_t)BP_GET_PSIZE(bp),
	(u_longlong_t)BP_GET_FILL(bp),
	(u_longlong_t)bp->blk_birth,
	(u_longlong_t)BP_PHYSICAL_BIRTH(bp));
	if (bp_freed)
	(void) snprintf(blkbuf + strlen(blkbuf),
	buflen - strlen(blkbuf), " %s", "FREE");
	(void) snprintf(blkbuf + strlen(blkbuf),
	buflen - strlen(blkbuf), " cksum=%llx:%llx:%llx:%llx",
	(u_longlong_t)bp->blk_cksum.zc_word[0],
	(u_longlong_t)bp->blk_cksum.zc_word[1],
	(u_longlong_t)bp->blk_cksum.zc_word[2],
	(u_longlong_t)bp->blk_cksum.zc_word[3]);
	}
	}

	static void
	print_indirect(spa_t spa, blkptr_t bp, const zbookmark_phys_t *zb,
	const dnode_phys_t *dnp)
	{
	char blkbuf[BP_SPRINTF_LEN];
	int l;

	if (!BP_IS_EMBEDDED(bp)) {
	ASSERT3U(BP_GET_TYPE(bp), ==, dnp->dn_type);
	ASSERT3U(BP_GET_LEVEL(bp), ==, zb->zb_level);
	}

	(void) printf("%16llx ", (u_longlong_t)blkid2offset(dnp, bp, zb));

	ASSERT(zb->zb_level >= 0);

	for (l = dnp->dn_nlevels - 1; l >= -1; l--) {
	if (l == zb->zb_level) {
	(void) printf("L%llx", (u_longlong_t)zb->zb_level);
	} else {
	(void) printf(" ");
	}
	}

	snprintf_blkptr_compact(blkbuf, sizeof (blkbuf), bp, B_FALSE);
	if (dump_opt['Z'] && BP_GET_COMPRESS(bp) == ZIO_COMPRESS_ZSTD)
	snprintf_zstd_header(spa, blkbuf, sizeof (blkbuf), bp);
	(void) printf("%s\n", blkbuf);
	}

	static int
	visit_indirect(spa_t spa, const dnode_phys_t dnp,
	blkptr_t bp, const zbookmark_phys_t zb)
	{
	int err = 0;

	if (bp->blk_birth == 0)
	return (0);

	print_indirect(spa, bp, zb, dnp);

	if (BP_GET_LEVEL(bp) > 0 && !BP_IS_HOLE(bp)) {
	arc_flags_t flags = ARC_FLAG_WAIT;
	int i;
	blkptr_t *cbp;
	int epb = BP_GET_LSIZE(bp) >> SPA_BLKPTRSHIFT;
	arc_buf_t *buf;
	uint64_t fill = 0;
	ASSERT(!BP_IS_REDACTED(bp));

	err = arc_read(NULL, spa, bp, arc_getbuf_func, &buf,
	ZIO_PRIORITY_ASYNC_READ, ZIO_FLAG_CANFAIL, &flags, zb);
	if (err)
	return (err);
	ASSERT(buf->b_data);

	/* recursively visit blocks below this */
	cbp = buf->b_data;
	for (i = 0; i < epb; i++, cbp++) {
	zbookmark_phys_t czb;

	SET_BOOKMARK(&czb, zb->zb_objset, zb->zb_object,
	zb->zb_level - 1,
	zb->zb_blkid * epb + i);
	err = visit_indirect(spa, dnp, cbp, &czb);
	if (err)
	break;
	fill += BP_GET_FILL(cbp);
	}
	if (!err)
	ASSERT3U(fill, ==, BP_GET_FILL(bp));
	arc_buf_destroy(buf, &buf);
	}

	return (err);
	}

	/ARGSUSED/
	static void
	dump_indirect(dnode_t *dn)
	{
	dnode_phys_t *dnp = dn->dn_phys;
	int j;
	zbookmark_phys_t czb;

	(void) printf("Indirect blocks:\n");

	SET_BOOKMARK(&czb, dmu_objset_id(dn->dn_objset),
	dn->dn_object, dnp->dn_nlevels - 1, 0);
	for (j = 0; j < dnp->dn_nblkptr; j++) {
	czb.zb_blkid = j;
	(void) visit_indirect(dmu_objset_spa(dn->dn_objset), dnp,
	&dnp->dn_blkptr[j], &czb);
	}

	(void) printf("\n");
	}

	/ARGSUSED/
	static void
	dump_dsl_dir(objset_t os, uint64_t object, void data, size_t size)
	{
	dsl_dir_phys_t *dd = data;
	time_t crtime;
	char nice[32];

	/* make sure nicenum has enough space */
	CTASSERT(sizeof (nice) >= NN_NUMBUF_SZ);

	if (dd == NULL)
	return;

	ASSERT3U(size, >=, sizeof (dsl_dir_phys_t));

	crtime = dd->dd_creation_time;
	(void) printf("\t\tcreation_time = %s", ctime(&crtime));
	(void) printf("\t\thead_dataset_obj = %llu\n",
	(u_longlong_t)dd->dd_head_dataset_obj);
	(void) printf("\t\tparent_dir_obj = %llu\n",
	(u_longlong_t)dd->dd_parent_obj);
	(void) printf("\t\torigin_obj = %llu\n",
	(u_longlong_t)dd->dd_origin_obj);
	(void) printf("\t\tchild_dir_zapobj = %llu\n",
	(u_longlong_t)dd->dd_child_dir_zapobj);
	zdb_nicenum(dd->dd_used_bytes, nice, sizeof (nice));
	(void) printf("\t\tused_bytes = %s\n", nice);
	zdb_nicenum(dd->dd_compressed_bytes, nice, sizeof (nice));
	(void) printf("\t\tcompressed_bytes = %s\n", nice);
	zdb_nicenum(dd->dd_uncompressed_bytes, nice, sizeof (nice));
	(void) printf("\t\tuncompressed_bytes = %s\n", nice);
	zdb_nicenum(dd->dd_quota, nice, sizeof (nice));
	(void) printf("\t\tquota = %s\n", nice);
	zdb_nicenum(dd->dd_reserved, nice, sizeof (nice));
	(void) printf("\t\treserved = %s\n", nice);
	(void) printf("\t\tprops_zapobj = %llu\n",
	(u_longlong_t)dd->dd_props_zapobj);
	(void) printf("\t\tdeleg_zapobj = %llu\n",
	(u_longlong_t)dd->dd_deleg_zapobj);
	(void) printf("\t\tflags = %llx\n",
	(u_longlong_t)dd->dd_flags);

	#define DO(which) \
	zdb_nicenum(dd->dd_used_breakdown[DD_USED_ ## which], nice, \
	sizeof (nice)); \
	(void) printf("\t\tused_breakdown[" #which "] = %s\n", nice)
	DO(HEAD);
	DO(SNAP);
	DO(CHILD);
	DO(CHILD_RSRV);
	DO(REFRSRV);
	#undef DO
	(void) printf("\t\tclones = %llu\n",
	(u_longlong_t)dd->dd_clones);
	}

	/ARGSUSED/
	static void
	dump_dsl_dataset(objset_t os, uint64_t object, void data, size_t size)
	{
	dsl_dataset_phys_t *ds = data;
	time_t crtime;
	char used[32], compressed[32], uncompressed[32], unique[32];
	char blkbuf[BP_SPRINTF_LEN];

	/* make sure nicenum has enough space */
	CTASSERT(sizeof (used) >= NN_NUMBUF_SZ);
	CTASSERT(sizeof (compressed) >= NN_NUMBUF_SZ);
	CTASSERT(sizeof (uncompressed) >= NN_NUMBUF_SZ);
	CTASSERT(sizeof (unique) >= NN_NUMBUF_SZ);

	if (ds == NULL)
	return;

	ASSERT(size == sizeof (*ds));
	crtime = ds->ds_creation_time;
	zdb_nicenum(ds->ds_referenced_bytes, used, sizeof (used));
	zdb_nicenum(ds->ds_compressed_bytes, compressed, sizeof (compressed));
	zdb_nicenum(ds->ds_uncompressed_bytes, uncompressed,
	sizeof (uncompressed));
	zdb_nicenum(ds->ds_unique_bytes, unique, sizeof (unique));
	snprintf_blkptr(blkbuf, sizeof (blkbuf), &ds->ds_bp);

	(void) printf("\t\tdir_obj = %llu\n",
	(u_longlong_t)ds->ds_dir_obj);
	(void) printf("\t\tprev_snap_obj = %llu\n",
	(u_longlong_t)ds->ds_prev_snap_obj);
	(void) printf("\t\tprev_snap_txg = %llu\n",
	(u_longlong_t)ds->ds_prev_snap_txg);
	(void) printf("\t\tnext_snap_obj = %llu\n",
	(u_longlong_t)ds->ds_next_snap_obj);
	(void) printf("\t\tsnapnames_zapobj = %llu\n",
	(u_longlong_t)ds->ds_snapnames_zapobj);
	(void) printf("\t\tnum_children = %llu\n",
	(u_longlong_t)ds->ds_num_children);
	(void) printf("\t\tuserrefs_obj = %llu\n",
	(u_longlong_t)ds->ds_userrefs_obj);
	(void) printf("\t\tcreation_time = %s", ctime(&crtime));
	(void) printf("\t\tcreation_txg = %llu\n",
	(u_longlong_t)ds->ds_creation_txg);
	(void) printf("\t\tdeadlist_obj = %llu\n",
	(u_longlong_t)ds->ds_deadlist_obj);
	(void) printf("\t\tused_bytes = %s\n", used);
	(void) printf("\t\tcompressed_bytes = %s\n", compressed);
	(void) printf("\t\tuncompressed_bytes = %s\n", uncompressed);
	(void) printf("\t\tunique = %s\n", unique);
	(void) printf("\t\tfsid_guid = %llu\n",
	(u_longlong_t)ds->ds_fsid_guid);
	(void) printf("\t\tguid = %llu\n",
	(u_longlong_t)ds->ds_guid);
	(void) printf("\t\tflags = %llx\n",
	(u_longlong_t)ds->ds_flags);
	(void) printf("\t\tnext_clones_obj = %llu\n",
	(u_longlong_t)ds->ds_next_clones_obj);
	(void) printf("\t\tprops_obj = %llu\n",
	(u_longlong_t)ds->ds_props_obj);
	(void) printf("\t\tbp = %s\n", blkbuf);
	}

	/* ARGSUSED */
	static int
	dump_bptree_cb(void arg, const blkptr_t bp, dmu_tx_t *tx)
	{
	char blkbuf[BP_SPRINTF_LEN];

	if (bp->blk_birth != 0) {
	snprintf_blkptr(blkbuf, sizeof (blkbuf), bp);
	(void) printf("\t%s\n", blkbuf);
	}
	return (0);
	}

	static void
	dump_bptree(objset_t os, uint64_t obj, const char name)
	{
	char bytes[32];
	bptree_phys_t *bt;
	dmu_buf_t *db;

	/* make sure nicenum has enough space */
	CTASSERT(sizeof (bytes) >= NN_NUMBUF_SZ);

	if (dump_opt['d'] < 3)
	return;

	VERIFY3U(0, ==, dmu_bonus_hold(os, obj, FTAG, &db));
	bt = db->db_data;
	zdb_nicenum(bt->bt_bytes, bytes, sizeof (bytes));
	(void) printf("\n %s: %llu datasets, %s\n",
	name, (unsigned long long)(bt->bt_end - bt->bt_begin), bytes);
	dmu_buf_rele(db, FTAG);

	if (dump_opt['d'] < 5)
	return;

	(void) printf("\n");

	(void) bptree_iterate(os, obj, B_FALSE, dump_bptree_cb, NULL, NULL);
	}

	/* ARGSUSED */
	static int
	dump_bpobj_cb(void arg, const blkptr_t bp, boolean_t bp_freed, dmu_tx_t *tx)
	{
	char blkbuf[BP_SPRINTF_LEN];

	ASSERT(bp->blk_birth != 0);
	snprintf_blkptr_compact(blkbuf, sizeof (blkbuf), bp, bp_freed);
	(void) printf("\t%s\n", blkbuf);
	return (0);
	}

	static void
	dump_full_bpobj(bpobj_t bpo, const char name, int indent)
	{
	char bytes[32];
	char comp[32];
	char uncomp[32];
	uint64_t i;

	/* make sure nicenum has enough space */
	CTASSERT(sizeof (bytes) >= NN_NUMBUF_SZ);
	CTASSERT(sizeof (comp) >= NN_NUMBUF_SZ);
	CTASSERT(sizeof (uncomp) >= NN_NUMBUF_SZ);

	if (dump_opt['d'] < 3)
	return;

	zdb_nicenum(bpo->bpo_phys->bpo_bytes, bytes, sizeof (bytes));
	if (bpo->bpo_havesubobj && bpo->bpo_phys->bpo_subobjs != 0) {
	zdb_nicenum(bpo->bpo_phys->bpo_comp, comp, sizeof (comp));
	zdb_nicenum(bpo->bpo_phys->bpo_uncomp, uncomp, sizeof (uncomp));
	if (bpo->bpo_havefreed) {
	(void) printf(" %*s: object %llu, %llu local "
	"blkptrs, %llu freed, %llu subobjs in object %llu, "
	"%s (%s/%s comp)\n",
	indent * 8, name,
	(u_longlong_t)bpo->bpo_object,
	(u_longlong_t)bpo->bpo_phys->bpo_num_blkptrs,
	(u_longlong_t)bpo->bpo_phys->bpo_num_freed,
	(u_longlong_t)bpo->bpo_phys->bpo_num_subobjs,
	(u_longlong_t)bpo->bpo_phys->bpo_subobjs,
	bytes, comp, uncomp);
	} else {
	(void) printf(" %*s: object %llu, %llu local "
	"blkptrs, %llu subobjs in object %llu, "
	"%s (%s/%s comp)\n",
	indent * 8, name,
	(u_longlong_t)bpo->bpo_object,
	(u_longlong_t)bpo->bpo_phys->bpo_num_blkptrs,
	(u_longlong_t)bpo->bpo_phys->bpo_num_subobjs,
	(u_longlong_t)bpo->bpo_phys->bpo_subobjs,
	bytes, comp, uncomp);
	}

	for (i = 0; i < bpo->bpo_phys->bpo_num_subobjs; i++) {
	uint64_t subobj;
	bpobj_t subbpo;
	int error;
	VERIFY0(dmu_read(bpo->bpo_os,
	bpo->bpo_phys->bpo_subobjs,
	i * sizeof (subobj), sizeof (subobj), &subobj, 0));
	error = bpobj_open(&subbpo, bpo->bpo_os, subobj);
	if (error != 0) {
	(void) printf("ERROR %u while trying to open "
	"subobj id %llu\n",
	error, (u_longlong_t)subobj);
	continue;
	}
	dump_full_bpobj(&subbpo, "subobj", indent + 1);
	bpobj_close(&subbpo);
	}
	} else {
	if (bpo->bpo_havefreed) {
	(void) printf(" %*s: object %llu, %llu blkptrs, "
	"%llu freed, %s\n",
	indent * 8, name,
	(u_longlong_t)bpo->bpo_object,
	(u_longlong_t)bpo->bpo_phys->bpo_num_blkptrs,
	(u_longlong_t)bpo->bpo_phys->bpo_num_freed,
	bytes);
	} else {
	(void) printf(" %*s: object %llu, %llu blkptrs, "
	"%s\n",
	indent * 8, name,
	(u_longlong_t)bpo->bpo_object,
	(u_longlong_t)bpo->bpo_phys->bpo_num_blkptrs,
	bytes);
	}
	}

	if (dump_opt['d'] < 5)
	return;


	if (indent == 0) {
	(void) bpobj_iterate_nofree(bpo, dump_bpobj_cb, NULL, NULL);
	(void) printf("\n");
	}
	}

	static int
	dump_bookmark(dsl_pool_t dp, char name, boolean_t print_redact,
	boolean_t print_list)
	{
	int err = 0;
	zfs_bookmark_phys_t prop;
	objset_t *mos = dp->dp_spa->spa_meta_objset;
	err = dsl_bookmark_lookup(dp, name, NULL, &prop);

	if (err != 0) {
	return (err);
	}

	(void) printf("\t#%s: ", strchr(name, '#') + 1);
	(void) printf("{guid: %llx creation_txg: %llu creation_time: "
	"%llu redaction_obj: %llu}\n", (u_longlong_t)prop.zbm_guid,
	(u_longlong_t)prop.zbm_creation_txg,
	(u_longlong_t)prop.zbm_creation_time,
	(u_longlong_t)prop.zbm_redaction_obj);

	IMPLY(print_list, print_redact);
	if (!print_redact \|\| prop.zbm_redaction_obj == 0)
	return (0);

	redaction_list_t *rl;
	VERIFY0(dsl_redaction_list_hold_obj(dp,
	prop.zbm_redaction_obj, FTAG, &rl));

	redaction_list_phys_t *rlp = rl->rl_phys;
	(void) printf("\tRedacted:\n\t\tProgress: ");
	if (rlp->rlp_last_object != UINT64_MAX \|\|
	rlp->rlp_last_blkid != UINT64_MAX) {
	(void) printf("%llu %llu (incomplete)\n",
	(u_longlong_t)rlp->rlp_last_object,
	(u_longlong_t)rlp->rlp_last_blkid);
	} else {
	(void) printf("complete\n");
	}
	(void) printf("\t\tSnapshots: [");
	for (unsigned int i = 0; i < rlp->rlp_num_snaps; i++) {
	if (i > 0)
	(void) printf(", ");
	(void) printf("%0llu",
	(u_longlong_t)rlp->rlp_snaps[i]);
	}
	(void) printf("]\n\t\tLength: %llu\n",
	(u_longlong_t)rlp->rlp_num_entries);

	if (!print_list) {
	dsl_redaction_list_rele(rl, FTAG);
	return (0);
	}

	if (rlp->rlp_num_entries == 0) {
	dsl_redaction_list_rele(rl, FTAG);
	(void) printf("\t\tRedaction List: []\n\n");
	return (0);
	}

	redact_block_phys_t *rbp_buf;
	uint64_t size;
	dmu_object_info_t doi;

	VERIFY0(dmu_object_info(mos, prop.zbm_redaction_obj, &doi));
	size = doi.doi_max_offset;
	rbp_buf = kmem_alloc(size, KM_SLEEP);

	err = dmu_read(mos, prop.zbm_redaction_obj, 0, size,
	rbp_buf, 0);
	if (err != 0) {
	dsl_redaction_list_rele(rl, FTAG);
	kmem_free(rbp_buf, size);
	return (err);
	}

	(void) printf("\t\tRedaction List: [{object: %llx, offset: "
	"%llx, blksz: %x, count: %llx}",
	(u_longlong_t)rbp_buf[0].rbp_object,
	(u_longlong_t)rbp_buf[0].rbp_blkid,
	(uint_t)(redact_block_get_size(&rbp_buf[0])),
	(u_longlong_t)redact_block_get_count(&rbp_buf[0]));

	for (size_t i = 1; i < rlp->rlp_num_entries; i++) {
	(void) printf(",\n\t\t{object: %llx, offset: %llx, "
	"blksz: %x, count: %llx}",
	(u_longlong_t)rbp_buf[i].rbp_object,
	(u_longlong_t)rbp_buf[i].rbp_blkid,
	(uint_t)(redact_block_get_size(&rbp_buf[i])),
	(u_longlong_t)redact_block_get_count(&rbp_buf[i]));
	}
	dsl_redaction_list_rele(rl, FTAG);
	kmem_free(rbp_buf, size);
	(void) printf("]\n\n");
	return (0);
	}

	static void
	dump_bookmarks(objset_t *os, int verbosity)
	{
	zap_cursor_t zc;
	zap_attribute_t attr;
	dsl_dataset_t *ds = dmu_objset_ds(os);
	dsl_pool_t *dp = spa_get_dsl(os->os_spa);
	objset_t *mos = os->os_spa->spa_meta_objset;
	if (verbosity < 4)
	return;
	dsl_pool_config_enter(dp, FTAG);

	for (zap_cursor_init(&zc, mos, ds->ds_bookmarks_obj);
	zap_cursor_retrieve(&zc, &attr) == 0;
	zap_cursor_advance(&zc)) {
	char osname[ZFS_MAX_DATASET_NAME_LEN];
	char buf[ZFS_MAX_DATASET_NAME_LEN];
	dmu_objset_name(os, osname);
	VERIFY3S(0, <=, snprintf(buf, sizeof (buf), "%s#%s", osname,
	attr.za_name));
	(void) dump_bookmark(dp, buf, verbosity >= 5, verbosity >= 6);
	}
	zap_cursor_fini(&zc);
	dsl_pool_config_exit(dp, FTAG);
	}

	static void
	bpobj_count_refd(bpobj_t *bpo)
	{
	mos_obj_refd(bpo->bpo_object);

	if (bpo->bpo_havesubobj && bpo->bpo_phys->bpo_subobjs != 0) {
	mos_obj_refd(bpo->bpo_phys->bpo_subobjs);
	for (uint64_t i = 0; i < bpo->bpo_phys->bpo_num_subobjs; i++) {
	uint64_t subobj;
	bpobj_t subbpo;
	int error;
	VERIFY0(dmu_read(bpo->bpo_os,
	bpo->bpo_phys->bpo_subobjs,
	i * sizeof (subobj), sizeof (subobj), &subobj, 0));
	error = bpobj_open(&subbpo, bpo->bpo_os, subobj);
	if (error != 0) {
	(void) printf("ERROR %u while trying to open "
	"subobj id %llu\n",
	error, (u_longlong_t)subobj);
	continue;
	}
	bpobj_count_refd(&subbpo);
	bpobj_close(&subbpo);
	}
	}
	}

	static int
	dsl_deadlist_entry_count_refd(void arg, dsl_deadlist_entry_t dle)
	{
	spa_t *spa = arg;
	uint64_t empty_bpobj = spa->spa_dsl_pool->dp_empty_bpobj;
	if (dle->dle_bpobj.bpo_object != empty_bpobj)
	bpobj_count_refd(&dle->dle_bpobj);
	return (0);
	}

	static int
	dsl_deadlist_entry_dump(void arg, dsl_deadlist_entry_t dle)
	{
	ASSERT(arg == NULL);
	if (dump_opt['d'] >= 5) {
	char buf[128];
	(void) snprintf(buf, sizeof (buf),
	"mintxg %llu -> obj %llu",
	(longlong_t)dle->dle_mintxg,
	(longlong_t)dle->dle_bpobj.bpo_object);

	dump_full_bpobj(&dle->dle_bpobj, buf, 0);
	} else {
	(void) printf("mintxg %llu -> obj %llu\n",
	(longlong_t)dle->dle_mintxg,
	(longlong_t)dle->dle_bpobj.bpo_object);
	}
	return (0);
	}

	static void
	dump_blkptr_list(dsl_deadlist_t dl, char name)
	{
	char bytes[32];
	char comp[32];
	char uncomp[32];
	char entries[32];
	spa_t *spa = dmu_objset_spa(dl->dl_os);
	uint64_t empty_bpobj = spa->spa_dsl_pool->dp_empty_bpobj;

	if (dl->dl_oldfmt) {
	if (dl->dl_bpobj.bpo_object != empty_bpobj)
	bpobj_count_refd(&dl->dl_bpobj);
	} else {
	mos_obj_refd(dl->dl_object);
	dsl_deadlist_iterate(dl, dsl_deadlist_entry_count_refd, spa);
	}

	/* make sure nicenum has enough space */
	CTASSERT(sizeof (bytes) >= NN_NUMBUF_SZ);
	CTASSERT(sizeof (comp) >= NN_NUMBUF_SZ);
	CTASSERT(sizeof (uncomp) >= NN_NUMBUF_SZ);
	CTASSERT(sizeof (entries) >= NN_NUMBUF_SZ);

	if (dump_opt['d'] < 3)
	return;

	if (dl->dl_oldfmt) {
	dump_full_bpobj(&dl->dl_bpobj, "old-format deadlist", 0);
	return;
	}

	zdb_nicenum(dl->dl_phys->dl_used, bytes, sizeof (bytes));
	zdb_nicenum(dl->dl_phys->dl_comp, comp, sizeof (comp));
	zdb_nicenum(dl->dl_phys->dl_uncomp, uncomp, sizeof (uncomp));
	zdb_nicenum(avl_numnodes(&dl->dl_tree), entries, sizeof (entries));
	(void) printf("\n %s: %s (%s/%s comp), %s entries\n",
	name, bytes, comp, uncomp, entries);

	if (dump_opt['d'] < 4)
	return;

	(void) printf("\n");

	dsl_deadlist_iterate(dl, dsl_deadlist_entry_dump, NULL);
	}

	static int
	verify_dd_livelist(objset_t *os)
	{
	uint64_t ll_used, used, ll_comp, comp, ll_uncomp, uncomp;
	dsl_pool_t *dp = spa_get_dsl(os->os_spa);
	dsl_dir_t *dd = os->os_dsl_dataset->ds_dir;

	ASSERT(!dmu_objset_is_snapshot(os));
	if (!dsl_deadlist_is_open(&dd->dd_livelist))
	return (0);

	/* Iterate through the livelist to check for duplicates */
	dsl_deadlist_iterate(&dd->dd_livelist, sublivelist_verify_lightweight,
	NULL);

	dsl_pool_config_enter(dp, FTAG);
	dsl_deadlist_space(&dd->dd_livelist, &ll_used,
	&ll_comp, &ll_uncomp);

	dsl_dataset_t *origin_ds;
	ASSERT(dsl_pool_config_held(dp));
	VERIFY0(dsl_dataset_hold_obj(dp,
	dsl_dir_phys(dd)->dd_origin_obj, FTAG, &origin_ds));
	VERIFY0(dsl_dataset_space_written(origin_ds, os->os_dsl_dataset,
	&used, &comp, &uncomp));
	dsl_dataset_rele(origin_ds, FTAG);
	dsl_pool_config_exit(dp, FTAG);
	/*
	* It's possible that the dataset's uncomp space is larger than the
	* livelist's because livelists do not track embedded block pointers
	*/
	if (used != ll_used \|\| comp != ll_comp \|\| uncomp < ll_uncomp) {
	char nice_used[32], nice_comp[32], nice_uncomp[32];
	(void) printf("Discrepancy in space accounting:\n");
	zdb_nicenum(used, nice_used, sizeof (nice_used));
	zdb_nicenum(comp, nice_comp, sizeof (nice_comp));
	zdb_nicenum(uncomp, nice_uncomp, sizeof (nice_uncomp));
	(void) printf("dir: used %s, comp %s, uncomp %s\n",
	nice_used, nice_comp, nice_uncomp);
	zdb_nicenum(ll_used, nice_used, sizeof (nice_used));
	zdb_nicenum(ll_comp, nice_comp, sizeof (nice_comp));
	zdb_nicenum(ll_uncomp, nice_uncomp, sizeof (nice_uncomp));
	(void) printf("livelist: used %s, comp %s, uncomp %s\n",
	nice_used, nice_comp, nice_uncomp);
	return (1);
	}
	return (0);
	}

	static avl_tree_t idx_tree;
	static avl_tree_t domain_tree;
	static boolean_t fuid_table_loaded;
	static objset_t *sa_os = NULL;
	static sa_attr_type_t *sa_attr_table = NULL;

	static int
	open_objset(const char path, void tag, objset_t **osp)
	{
	int err;
	uint64_t sa_attrs = 0;
	uint64_t version = 0;

	VERIFY3P(sa_os, ==, NULL);
	/*
	* We can't own an objset if it's redacted. Therefore, we do this
	* dance: hold the objset, then acquire a long hold on its dataset, then
	* release the pool (which is held as part of holding the objset).
	*/
	err = dmu_objset_hold(path, tag, osp);
	if (err != 0) {
	(void) fprintf(stderr, "failed to hold dataset '%s': %s\n",
	path, strerror(err));
	return (err);
	}
	dsl_dataset_long_hold(dmu_objset_ds(*osp), tag);
	dsl_pool_rele(dmu_objset_pool(*osp), tag);

	if (dmu_objset_type(osp) == DMU_OST_ZFS && !(osp)->os_encrypted) {
	(void) zap_lookup(*osp, MASTER_NODE_OBJ, ZPL_VERSION_STR,
	8, 1, &version);
	if (version >= ZPL_VERSION_SA) {
	(void) zap_lookup(*osp, MASTER_NODE_OBJ, ZFS_SA_ATTRS,
	8, 1, &sa_attrs);
	}
	err = sa_setup(*osp, sa_attrs, zfs_attr_table, ZPL_END,
	&sa_attr_table);
	if (err != 0) {
	(void) fprintf(stderr, "sa_setup failed: %s\n",
	strerror(err));
	dsl_dataset_long_rele(dmu_objset_ds(*osp), tag);
	dsl_dataset_rele(dmu_objset_ds(*osp), tag);
	*osp = NULL;
	}
	}
	sa_os = *osp;

	return (0);
	}

	static void
	close_objset(objset_t os, void tag)
	{
	VERIFY3P(os, ==, sa_os);
	if (os->os_sa != NULL)
	sa_tear_down(os);
	dsl_dataset_long_rele(dmu_objset_ds(os), tag);
	dsl_dataset_rele(dmu_objset_ds(os), tag);
	sa_attr_table = NULL;
	sa_os = NULL;
	}

	static void
	fuid_table_destroy(void)
	{
	if (fuid_table_loaded) {
	zfs_fuid_table_destroy(&idx_tree, &domain_tree);
	fuid_table_loaded = B_FALSE;
	}
	}

	/*
	* print uid or gid information.
	* For normal POSIX id just the id is printed in decimal format.
	* For CIFS files with FUID the fuid is printed in hex followed by
	* the domain-rid string.
	*/
	static void
	print_idstr(uint64_t id, const char *id_type)
	{
	if (FUID_INDEX(id)) {
	char *domain;

	domain = zfs_fuid_idx_domain(&idx_tree, FUID_INDEX(id));
	(void) printf("\t%s %llx [%s-%d]\n", id_type,
	(u_longlong_t)id, domain, (int)FUID_RID(id));
	} else {
	(void) printf("\t%s %llu\n", id_type, (u_longlong_t)id);
	}

	}

	static void
	dump_uidgid(objset_t *os, uint64_t uid, uint64_t gid)
	{
	uint32_t uid_idx, gid_idx;

	uid_idx = FUID_INDEX(uid);
	gid_idx = FUID_INDEX(gid);

	/* Load domain table, if not already loaded */
	if (!fuid_table_loaded && (uid_idx \|\| gid_idx)) {
	uint64_t fuid_obj;

	/* first find the fuid object. It lives in the master node */
	VERIFY(zap_lookup(os, MASTER_NODE_OBJ, ZFS_FUID_TABLES,
	8, 1, &fuid_obj) == 0);
	zfs_fuid_avl_tree_create(&idx_tree, &domain_tree);
	(void) zfs_fuid_table_load(os, fuid_obj,
	&idx_tree, &domain_tree);
	fuid_table_loaded = B_TRUE;
	}

	print_idstr(uid, "uid");
	print_idstr(gid, "gid");
	}

	static void
	dump_znode_sa_xattr(sa_handle_t *hdl)
	{
	nvlist_t *sa_xattr;
	nvpair_t *elem = NULL;
	int sa_xattr_size = 0;
	int sa_xattr_entries = 0;
	int error;
	char *sa_xattr_packed;

	error = sa_size(hdl, sa_attr_table[ZPL_DXATTR], &sa_xattr_size);
	if (error \|\| sa_xattr_size == 0)
	return;

	sa_xattr_packed = malloc(sa_xattr_size);
	if (sa_xattr_packed == NULL)
	return;

	error = sa_lookup(hdl, sa_attr_table[ZPL_DXATTR],
	sa_xattr_packed, sa_xattr_size);
	if (error) {
	free(sa_xattr_packed);
	return;
	}

	error = nvlist_unpack(sa_xattr_packed, sa_xattr_size, &sa_xattr, 0);
	if (error) {
	free(sa_xattr_packed);
	return;
	}

	while ((elem = nvlist_next_nvpair(sa_xattr, elem)) != NULL)
	sa_xattr_entries++;

	(void) printf("\tSA xattrs: %d bytes, %d entries\n\n",
	sa_xattr_size, sa_xattr_entries);
	while ((elem = nvlist_next_nvpair(sa_xattr, elem)) != NULL) {
	uchar_t *value;
	uint_t cnt, idx;

	(void) printf("\t\t%s = ", nvpair_name(elem));
	nvpair_value_byte_array(elem, &value, &cnt);
	for (idx = 0; idx < cnt; ++idx) {
	if (isprint(value[idx]))
	(void) putchar(value[idx]);
	else
	(void) printf("\\%3.3o", value[idx]);
	}
	(void) putchar('\n');
	}

	nvlist_free(sa_xattr);
	free(sa_xattr_packed);
	}

	static void
	dump_znode_symlink(sa_handle_t *hdl)
	{
	int sa_symlink_size = 0;
	char linktarget[MAXPATHLEN];
	linktarget[0] = '\0';
	int error;

	error = sa_size(hdl, sa_attr_table[ZPL_SYMLINK], &sa_symlink_size);
	if (error \|\| sa_symlink_size == 0) {
	return;
	}
	if (sa_lookup(hdl, sa_attr_table[ZPL_SYMLINK],
	&linktarget, sa_symlink_size) == 0)
	(void) printf("\ttarget %s\n", linktarget);
	}

	/ARGSUSED/
	static void
	dump_znode(objset_t os, uint64_t object, void data, size_t size)
	{
	char path[MAXPATHLEN * 2]; /* allow for xattr and failure prefix */
	sa_handle_t *hdl;
	uint64_t xattr, rdev, gen;
	uint64_t uid, gid, mode, fsize, parent, links;
	uint64_t pflags;
	uint64_t acctm[2], modtm[2], chgtm[2], crtm[2];
	time_t z_crtime, z_atime, z_mtime, z_ctime;
	sa_bulk_attr_t bulk[12];
	int idx = 0;
	int error;

	VERIFY3P(os, ==, sa_os);
	if (sa_handle_get(os, object, NULL, SA_HDL_PRIVATE, &hdl)) {
	(void) printf("Failed to get handle for SA znode\n");
	return;
	}

	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_UID], NULL, &uid, 8);
	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_GID], NULL, &gid, 8);
	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_LINKS], NULL,
	&links, 8);
	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_GEN], NULL, &gen, 8);
	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_MODE], NULL,
	&mode, 8);
	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_PARENT],
	NULL, &parent, 8);
	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_SIZE], NULL,
	&fsize, 8);
	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_ATIME], NULL,
	acctm, 16);
	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_MTIME], NULL,
	modtm, 16);
	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_CRTIME], NULL,
	crtm, 16);
	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_CTIME], NULL,
	chgtm, 16);
	SA_ADD_BULK_ATTR(bulk, idx, sa_attr_table[ZPL_FLAGS], NULL,
	&pflags, 8);

	if (sa_bulk_lookup(hdl, bulk, idx)) {
	(void) sa_handle_destroy(hdl);
	return;
	}

	z_crtime = (time_t)crtm[0];
	z_atime = (time_t)acctm[0];
	z_mtime = (time_t)modtm[0];
	z_ctime = (time_t)chgtm[0];

	if (dump_opt['d'] > 4) {
	error = zfs_obj_to_path(os, object, path, sizeof (path));
	if (error == ESTALE) {
	(void) snprintf(path, sizeof (path), "on delete queue");
	} else if (error != 0) {
	leaked_objects++;
	(void) snprintf(path, sizeof (path),
	"path not found, possibly leaked");
	}
	(void) printf("\tpath %s\n", path);
	}

	if (S_ISLNK(mode))
	dump_znode_symlink(hdl);
	dump_uidgid(os, uid, gid);
	(void) printf("\tatime %s", ctime(&z_atime));
	(void) printf("\tmtime %s", ctime(&z_mtime));
	(void) printf("\tctime %s", ctime(&z_ctime));
	(void) printf("\tcrtime %s", ctime(&z_crtime));
	(void) printf("\tgen %llu\n", (u_longlong_t)gen);
	(void) printf("\tmode %llo\n", (u_longlong_t)mode);
	(void) printf("\tsize %llu\n", (u_longlong_t)fsize);
	(void) printf("\tparent %llu\n", (u_longlong_t)parent);
	(void) printf("\tlinks %llu\n", (u_longlong_t)links);
	(void) printf("\tpflags %llx\n", (u_longlong_t)pflags);
	if (dmu_objset_projectquota_enabled(os) && (pflags & ZFS_PROJID)) {
	uint64_t projid;

	if (sa_lookup(hdl, sa_attr_table[ZPL_PROJID], &projid,
	sizeof (uint64_t)) == 0)
	(void) printf("\tprojid %llu\n", (u_longlong_t)projid);
	}
	if (sa_lookup(hdl, sa_attr_table[ZPL_XATTR], &xattr,
	sizeof (uint64_t)) == 0)
	(void) printf("\txattr %llu\n", (u_longlong_t)xattr);
	if (sa_lookup(hdl, sa_attr_table[ZPL_RDEV], &rdev,
	sizeof (uint64_t)) == 0)
	(void) printf("\trdev 0x%016llx\n", (u_longlong_t)rdev);
	dump_znode_sa_xattr(hdl);
	sa_handle_destroy(hdl);
	}

	/ARGSUSED/
	static void
	dump_acl(objset_t os, uint64_t object, void data, size_t size)
	{
	}

	/ARGSUSED/
	static void
	dump_dmu_objset(objset_t os, uint64_t object, void data, size_t size)
	{
	}

	static object_viewer_t *object_viewer[DMU_OT_NUMTYPES + 1] = {
	dump_none, /* unallocated */
	dump_zap, /* object directory */
	dump_uint64, /* object array */
	dump_none, /* packed nvlist */
	dump_packed_nvlist, /* packed nvlist size */
	dump_none, /* bpobj */
	dump_bpobj, /* bpobj header */
	dump_none, /* SPA space map header */
	dump_none, /* SPA space map */
	dump_none, /* ZIL intent log */
	dump_dnode, /* DMU dnode */
	dump_dmu_objset, /* DMU objset */
	dump_dsl_dir, /* DSL directory */
	dump_zap, /* DSL directory child map */
	dump_zap, /* DSL dataset snap map */
	dump_zap, /* DSL props */
	dump_dsl_dataset, /* DSL dataset */
	dump_znode, /* ZFS znode */
	dump_acl, /* ZFS V0 ACL */
	dump_uint8, /* ZFS plain file */
	dump_zpldir, /* ZFS directory */
	dump_zap, /* ZFS master node */
	dump_zap, /* ZFS delete queue */
	dump_uint8, /* zvol object */
	dump_zap, /* zvol prop */
	dump_uint8, /* other uint8[] */
	dump_uint64, /* other uint64[] */
	dump_zap, /* other ZAP */
	dump_zap, /* persistent error log */
	dump_uint8, /* SPA history */
	dump_history_offsets, /* SPA history offsets */
	dump_zap, /* Pool properties */
	dump_zap, /* DSL permissions */
	dump_acl, /* ZFS ACL */
	dump_uint8, /* ZFS SYSACL */
	dump_none, /* FUID nvlist */
	dump_packed_nvlist, /* FUID nvlist size */
	dump_zap, /* DSL dataset next clones */
	dump_zap, /* DSL scrub queue */
	dump_zap, /* ZFS user/group/project used */
	dump_zap, /* ZFS user/group/project quota */
	dump_zap, /* snapshot refcount tags */
	dump_ddt_zap, /* DDT ZAP object */
	dump_zap, /* DDT statistics */
	dump_znode, /* SA object */
	dump_zap, /* SA Master Node */
	dump_sa_attrs, /* SA attribute registration */
	dump_sa_layouts, /* SA attribute layouts */
	dump_zap, /* DSL scrub translations */
	dump_none, /* fake dedup BP */
	dump_zap, /* deadlist */
	dump_none, /* deadlist hdr */
	dump_zap, /* dsl clones */
	dump_bpobj_subobjs, /* bpobj subobjs */
	dump_unknown, /* Unknown type, must be last */
	};

	static boolean_t
	match_object_type(dmu_object_type_t obj_type, uint64_t flags)
	{
	boolean_t match = B_TRUE;

	switch (obj_type) {
	case DMU_OT_DIRECTORY_CONTENTS:
	if (!(flags & ZOR_FLAG_DIRECTORY))
	match = B_FALSE;
	break;
	case DMU_OT_PLAIN_FILE_CONTENTS:
	if (!(flags & ZOR_FLAG_PLAIN_FILE))
	match = B_FALSE;
	break;
	case DMU_OT_SPACE_MAP:
	if (!(flags & ZOR_FLAG_SPACE_MAP))
	match = B_FALSE;
	break;
	default:
	if (strcmp(zdb_ot_name(obj_type), "zap") == 0) {
	if (!(flags & ZOR_FLAG_ZAP))
	match = B_FALSE;
	break;
	}

	/*
	* If all bits except some of the supported flags are
	* set, the user combined the all-types flag (A) with
	* a negated flag to exclude some types (e.g. A-f to
	* show all object types except plain files).
	*/
	if ((flags \| ZOR_SUPPORTED_FLAGS) != ZOR_FLAG_ALL_TYPES)
	match = B_FALSE;

	break;
	}

	return (match);
	}

	static void
	dump_object(objset_t *os, uint64_t object, int verbosity,
	boolean_t print_header, uint64_t dnode_slots_used, uint64_t flags)
	{
	dmu_buf_t *db = NULL;
	dmu_object_info_t doi;
	dnode_t *dn;
	boolean_t dnode_held = B_FALSE;
	void *bonus = NULL;
	size_t bsize = 0;
	char iblk[32], dblk[32], lsize[32], asize[32], fill[32], dnsize[32];
	char bonus_size[32];
	char aux[50];
	int error;

	/* make sure nicenum has enough space */
	CTASSERT(sizeof (iblk) >= NN_NUMBUF_SZ);
	CTASSERT(sizeof (dblk) >= NN_NUMBUF_SZ);
	CTASSERT(sizeof (lsize) >= NN_NUMBUF_SZ);
	CTASSERT(sizeof (asize) >= NN_NUMBUF_SZ);
	CTASSERT(sizeof (bonus_size) >= NN_NUMBUF_SZ);

	if (*print_header) {
	(void) printf("\n%10s %3s %5s %5s %5s %6s %5s %6s %s\n",
	"Object", "lvl", "iblk", "dblk", "dsize", "dnsize",
	"lsize", "%full", "type");
	*print_header = 0;
	}

	if (object == 0) {
	dn = DMU_META_DNODE(os);
	dmu_object_info_from_dnode(dn, &doi);
	} else {
	/*
	* Encrypted datasets will have sensitive bonus buffers
	* encrypted. Therefore we cannot hold the bonus buffer and
	* must hold the dnode itself instead.
	*/
	error = dmu_object_info(os, object, &doi);
	if (error)
	fatal("dmu_object_info() failed, errno %u", error);

	if (os->os_encrypted &&
	DMU_OT_IS_ENCRYPTED(doi.doi_bonus_type)) {
	error = dnode_hold(os, object, FTAG, &dn);
	if (error)
	fatal("dnode_hold() failed, errno %u", error);
	dnode_held = B_TRUE;
	} else {
	error = dmu_bonus_hold(os, object, FTAG, &db);
	if (error)
	fatal("dmu_bonus_hold(%llu) failed, errno %u",
	object, error);
	bonus = db->db_data;
	bsize = db->db_size;
	dn = DB_DNODE((dmu_buf_impl_t *)db);
	}
	}

	/*
	* Default to showing all object types if no flags were specified.
	*/
	if (flags != 0 && flags != ZOR_FLAG_ALL_TYPES &&
	!match_object_type(doi.doi_type, flags))
	goto out;

	if (dnode_slots_used)
	*dnode_slots_used = doi.doi_dnodesize / DNODE_MIN_SIZE;

	zdb_nicenum(doi.doi_metadata_block_size, iblk, sizeof (iblk));
	zdb_nicenum(doi.doi_data_block_size, dblk, sizeof (dblk));
	zdb_nicenum(doi.doi_max_offset, lsize, sizeof (lsize));
	zdb_nicenum(doi.doi_physical_blocks_512 << 9, asize, sizeof (asize));
	zdb_nicenum(doi.doi_bonus_size, bonus_size, sizeof (bonus_size));
	zdb_nicenum(doi.doi_dnodesize, dnsize, sizeof (dnsize));
	(void) sprintf(fill, "%6.2f", 100.0 * doi.doi_fill_count *
	doi.doi_data_block_size / (object == 0 ? DNODES_PER_BLOCK : 1) /
	doi.doi_max_offset);

	aux[0] = '\0';

	if (doi.doi_checksum != ZIO_CHECKSUM_INHERIT \|\| verbosity >= 6) {
	(void) snprintf(aux + strlen(aux), sizeof (aux) - strlen(aux),
	" (K=%s)", ZDB_CHECKSUM_NAME(doi.doi_checksum));
	}

	if (doi.doi_compress == ZIO_COMPRESS_INHERIT &&
	ZIO_COMPRESS_HASLEVEL(os->os_compress) && verbosity >= 6) {
	const char *compname = NULL;
	if (zfs_prop_index_to_string(ZFS_PROP_COMPRESSION,
	ZIO_COMPRESS_RAW(os->os_compress, os->os_complevel),
	&compname) == 0) {
	(void) snprintf(aux + strlen(aux),
	sizeof (aux) - strlen(aux), " (Z=inherit=%s)",
	compname);
	} else {
	(void) snprintf(aux + strlen(aux),
	sizeof (aux) - strlen(aux),
	" (Z=inherit=%s-unknown)",
	ZDB_COMPRESS_NAME(os->os_compress));
	}
	} else if (doi.doi_compress == ZIO_COMPRESS_INHERIT && verbosity >= 6) {
	(void) snprintf(aux + strlen(aux), sizeof (aux) - strlen(aux),
	" (Z=inherit=%s)", ZDB_COMPRESS_NAME(os->os_compress));
	} else if (doi.doi_compress != ZIO_COMPRESS_INHERIT \|\| verbosity >= 6) {
	(void) snprintf(aux + strlen(aux), sizeof (aux) - strlen(aux),
	" (Z=%s)", ZDB_COMPRESS_NAME(doi.doi_compress));
	}

	(void) printf("%10lld %3u %5s %5s %5s %6s %5s %6s %s%s\n",
	(u_longlong_t)object, doi.doi_indirection, iblk, dblk,
	asize, dnsize, lsize, fill, zdb_ot_name(doi.doi_type), aux);

	if (doi.doi_bonus_type != DMU_OT_NONE && verbosity > 3) {
	(void) printf("%10s %3s %5s %5s %5s %5s %5s %6s %s\n",
	"", "", "", "", "", "", bonus_size, "bonus",
	zdb_ot_name(doi.doi_bonus_type));
	}

	if (verbosity >= 4) {
	(void) printf("\tdnode flags: %s%s%s%s\n",
	(dn->dn_phys->dn_flags & DNODE_FLAG_USED_BYTES) ?
	"USED_BYTES " : "",
	(dn->dn_phys->dn_flags & DNODE_FLAG_USERUSED_ACCOUNTED) ?
	"USERUSED_ACCOUNTED " : "",
	(dn->dn_phys->dn_flags & DNODE_FLAG_USEROBJUSED_ACCOUNTED) ?
	"USEROBJUSED_ACCOUNTED " : "",
	(dn->dn_phys->dn_flags & DNODE_FLAG_SPILL_BLKPTR) ?
	"SPILL_BLKPTR" : "");
	(void) printf("\tdnode maxblkid: %llu\n",
	(longlong_t)dn->dn_phys->dn_maxblkid);

	if (!dnode_held) {
	object_viewer[ZDB_OT_TYPE(doi.doi_bonus_type)](os,
	object, bonus, bsize);
	} else {
	(void) printf("\t\t(bonus encrypted)\n");
	}

	if (!os->os_encrypted \|\| !DMU_OT_IS_ENCRYPTED(doi.doi_type)) {
	object_viewer[ZDB_OT_TYPE(doi.doi_type)](os, object,
	NULL, 0);
	} else {
	(void) printf("\t\t(object encrypted)\n");
	}

	*print_header = B_TRUE;
	}

	if (verbosity >= 5)
	dump_indirect(dn);

	if (verbosity >= 5) {
	/*
	* Report the list of segments that comprise the object.
	*/
	uint64_t start = 0;
	uint64_t end;
	uint64_t blkfill = 1;
	int minlvl = 1;

	if (dn->dn_type == DMU_OT_DNODE) {
	minlvl = 0;
	blkfill = DNODES_PER_BLOCK;
	}

	for (;;) {
	char segsize[32];
	/* make sure nicenum has enough space */
	CTASSERT(sizeof (segsize) >= NN_NUMBUF_SZ);
	error = dnode_next_offset(dn,
	0, &start, minlvl, blkfill, 0);
	if (error)
	break;
	end = start;
	error = dnode_next_offset(dn,
	DNODE_FIND_HOLE, &end, minlvl, blkfill, 0);
	zdb_nicenum(end - start, segsize, sizeof (segsize));
	(void) printf("\t\tsegment [%016llx, %016llx)"
	" size %5s\n", (u_longlong_t)start,
	(u_longlong_t)end, segsize);
	if (error)
	break;
	start = end;
	}
	}

	out:
	if (db != NULL)
	dmu_buf_rele(db, FTAG);
	if (dnode_held)
	dnode_rele(dn, FTAG);
	}

	static void
	count_dir_mos_objects(dsl_dir_t *dd)
	{
	mos_obj_refd(dd->dd_object);
	mos_obj_refd(dsl_dir_phys(dd)->dd_child_dir_zapobj);
	mos_obj_refd(dsl_dir_phys(dd)->dd_deleg_zapobj);
	mos_obj_refd(dsl_dir_phys(dd)->dd_props_zapobj);
	mos_obj_refd(dsl_dir_phys(dd)->dd_clones);

	/*
	* The dd_crypto_obj can be referenced by multiple dsl_dir's.
	* Ignore the references after the first one.
	*/
	mos_obj_refd_multiple(dd->dd_crypto_obj);
	}

	static void
	count_ds_mos_objects(dsl_dataset_t *ds)
	{
	mos_obj_refd(ds->ds_object);
	mos_obj_refd(dsl_dataset_phys(ds)->ds_next_clones_obj);
	mos_obj_refd(dsl_dataset_phys(ds)->ds_props_obj);
	mos_obj_refd(dsl_dataset_phys(ds)->ds_userrefs_obj);
	mos_obj_refd(dsl_dataset_phys(ds)->ds_snapnames_zapobj);
	mos_obj_refd(ds->ds_bookmarks_obj);

	if (!dsl_dataset_is_snapshot(ds)) {
	count_dir_mos_objects(ds->ds_dir);
	}
	}

	static const char *objset_types[DMU_OST_NUMTYPES] = {
	"NONE", "META", "ZPL", "ZVOL", "OTHER", "ANY" };

	/*
	* Parse a string denoting a range of object IDs of the form
	* <start>[:<end>[:flags]], and store the results in zor.
	* Return 0 on success. On error, return 1 and update the msg
	* pointer to point to a descriptive error message.
	*/
	static int
	parse_object_range(char range, zopt_object_range_t zor, char **msg)
	{
	uint64_t flags = 0;
	char p, s, dup, flagstr;
	size_t len;
	int i;
	int rc = 0;

	if (strchr(range, ':') == NULL) {
	zor->zor_obj_start = strtoull(range, &p, 0);
	if (*p != '\0') {
	*msg = "Invalid characters in object ID";
	rc = 1;
	}
	zor->zor_obj_end = zor->zor_obj_start;
	return (rc);
	}

	if (strchr(range, ':') == range) {
	*msg = "Invalid leading colon";
	rc = 1;
	return (rc);
	}

	len = strlen(range);
	if (range[len - 1] == ':') {
	*msg = "Invalid trailing colon";
	rc = 1;
	return (rc);
	}

	dup = strdup(range);
	s = strtok(dup, ":");
	zor->zor_obj_start = strtoull(s, &p, 0);

	if (*p != '\0') {
	*msg = "Invalid characters in start object ID";
	rc = 1;
	goto out;
	}

	s = strtok(NULL, ":");
	zor->zor_obj_end = strtoull(s, &p, 0);

	if (*p != '\0') {
	*msg = "Invalid characters in end object ID";
	rc = 1;
	goto out;
	}

	if (zor->zor_obj_start > zor->zor_obj_end) {
	*msg = "Start object ID may not exceed end object ID";
	rc = 1;
	goto out;
	}

	s = strtok(NULL, ":");
	if (s == NULL) {
	zor->zor_flags = ZOR_FLAG_ALL_TYPES;
	goto out;
	} else if (strtok(NULL, ":") != NULL) {
	*msg = "Invalid colon-delimited field after flags";
	rc = 1;
	goto out;
	}

	flagstr = s;
	for (i = 0; flagstr[i]; i++) {
	int bit;
	boolean_t negation = (flagstr[i] == '-');

	if (negation) {
	i++;
	if (flagstr[i] == '\0') {
	*msg = "Invalid trailing negation operator";
	rc = 1;
	goto out;
	}
	}
	bit = flagbits[(uchar_t)flagstr[i]];
	if (bit == 0) {
	*msg = "Invalid flag";
	rc = 1;
	goto out;
	}
	if (negation)
	flags &= ~bit;
	else
	flags \|= bit;
	}
	zor->zor_flags = flags;

	out:
	free(dup);
	return (rc);
	}

	static void
	dump_objset(objset_t *os)
	{
	dmu_objset_stats_t dds = { 0 };
	uint64_t object, object_count;
	uint64_t refdbytes, usedobjs, scratch;
	char numbuf[32];
	char blkbuf[BP_SPRINTF_LEN + 20];
	char osname[ZFS_MAX_DATASET_NAME_LEN];
	const char *type = "UNKNOWN";
	int verbosity = dump_opt['d'];
	boolean_t print_header;
	unsigned i;
	int error;
	uint64_t total_slots_used = 0;
	uint64_t max_slot_used = 0;
	uint64_t dnode_slots;
	uint64_t obj_start;
	uint64_t obj_end;
	uint64_t flags;

	/* make sure nicenum has enough space */
	CTASSERT(sizeof (numbuf) >= NN_NUMBUF_SZ);

	dsl_pool_config_enter(dmu_objset_pool(os), FTAG);
	dmu_objset_fast_stat(os, &dds);
	dsl_pool_config_exit(dmu_objset_pool(os), FTAG);

	print_header = B_TRUE;

	if (dds.dds_type < DMU_OST_NUMTYPES)
	type = objset_types[dds.dds_type];

	if (dds.dds_type == DMU_OST_META) {
	dds.dds_creation_txg = TXG_INITIAL;
	usedobjs = BP_GET_FILL(os->os_rootbp);
	refdbytes = dsl_dir_phys(os->os_spa->spa_dsl_pool->dp_mos_dir)->
	dd_used_bytes;
	} else {
	dmu_objset_space(os, &refdbytes, &scratch, &usedobjs, &scratch);
	}

	ASSERT3U(usedobjs, ==, BP_GET_FILL(os->os_rootbp));

	zdb_nicenum(refdbytes, numbuf, sizeof (numbuf));

	if (verbosity >= 4) {
	(void) snprintf(blkbuf, sizeof (blkbuf), ", rootbp ");
	(void) snprintf_blkptr(blkbuf + strlen(blkbuf),
	sizeof (blkbuf) - strlen(blkbuf), os->os_rootbp);
	} else {
	blkbuf[0] = '\0';
	}

	dmu_objset_name(os, osname);

	(void) printf("Dataset %s [%s], ID %llu, cr_txg %llu, "
	"%s, %llu objects%s%s\n",
	osname, type, (u_longlong_t)dmu_objset_id(os),
	(u_longlong_t)dds.dds_creation_txg,
	numbuf, (u_longlong_t)usedobjs, blkbuf,
	(dds.dds_inconsistent) ? " (inconsistent)" : "");

	for (i = 0; i < zopt_object_args; i++) {
	obj_start = zopt_object_ranges[i].zor_obj_start;
	obj_end = zopt_object_ranges[i].zor_obj_end;
	flags = zopt_object_ranges[i].zor_flags;

	object = obj_start;
	if (object == 0 \|\| obj_start == obj_end)
	dump_object(os, object, verbosity, &print_header, NULL,
	flags);
	else
	object--;

	while ((dmu_object_next(os, &object, B_FALSE, 0) == 0) &&
	object <= obj_end) {
	dump_object(os, object, verbosity, &print_header, NULL,
	flags);
	}
	}

	if (zopt_object_args > 0) {
	(void) printf("\n");
	return;
	}

	if (dump_opt['i'] != 0 \|\| verbosity >= 2)
	dump_intent_log(dmu_objset_zil(os));

	if (dmu_objset_ds(os) != NULL) {
	dsl_dataset_t *ds = dmu_objset_ds(os);
	dump_blkptr_list(&ds->ds_deadlist, "Deadlist");
	if (dsl_deadlist_is_open(&ds->ds_dir->dd_livelist) &&
	!dmu_objset_is_snapshot(os)) {
	dump_blkptr_list(&ds->ds_dir->dd_livelist, "Livelist");
	if (verify_dd_livelist(os) != 0)
	fatal("livelist is incorrect");
	}

	if (dsl_dataset_remap_deadlist_exists(ds)) {
	(void) printf("ds_remap_deadlist:\n");
	dump_blkptr_list(&ds->ds_remap_deadlist, "Deadlist");
	}
	count_ds_mos_objects(ds);
	}

	if (dmu_objset_ds(os) != NULL)
	dump_bookmarks(os, verbosity);

	if (verbosity < 2)
	return;

	if (BP_IS_HOLE(os->os_rootbp))
	return;

	dump_object(os, 0, verbosity, &print_header, NULL, 0);
	object_count = 0;
	if (DMU_USERUSED_DNODE(os) != NULL &&
	DMU_USERUSED_DNODE(os)->dn_type != 0) {
	dump_object(os, DMU_USERUSED_OBJECT, verbosity, &print_header,
	NULL, 0);
	dump_object(os, DMU_GROUPUSED_OBJECT, verbosity, &print_header,
	NULL, 0);
	}

	if (DMU_PROJECTUSED_DNODE(os) != NULL &&
	DMU_PROJECTUSED_DNODE(os)->dn_type != 0)
	dump_object(os, DMU_PROJECTUSED_OBJECT, verbosity,
	&print_header, NULL, 0);

	object = 0;
	while ((error = dmu_object_next(os, &object, B_FALSE, 0)) == 0) {
	dump_object(os, object, verbosity, &print_header, &dnode_slots,
	0);
	object_count++;
	total_slots_used += dnode_slots;
	max_slot_used = object + dnode_slots - 1;
	}

	(void) printf("\n");

	(void) printf(" Dnode slots:\n");
	(void) printf("\tTotal used: %10llu\n",
	(u_longlong_t)total_slots_used);
	(void) printf("\tMax used: %10llu\n",
	(u_longlong_t)max_slot_used);
	(void) printf("\tPercent empty: %10lf\n",
	(double)(max_slot_used - total_slots_used)*100 /
	(double)max_slot_used);
	(void) printf("\n");

	if (error != ESRCH) {
	(void) fprintf(stderr, "dmu_object_next() = %d\n", error);
	abort();
	}

	ASSERT3U(object_count, ==, usedobjs);

	if (leaked_objects != 0) {
	(void) printf("%d potentially leaked objects detected\n",
	leaked_objects);
	leaked_objects = 0;
	}
	}

	static void
	dump_uberblock(uberblock_t ub, const char header, const char *footer)
	{
	time_t timestamp = ub->ub_timestamp;

	(void) printf("%s", header ? header : "");
	(void) printf("\tmagic = %016llx\n", (u_longlong_t)ub->ub_magic);
	(void) printf("\tversion = %llu\n", (u_longlong_t)ub->ub_version);
	(void) printf("\ttxg = %llu\n", (u_longlong_t)ub->ub_txg);
	(void) printf("\tguid_sum = %llu\n", (u_longlong_t)ub->ub_guid_sum);
	(void) printf("\ttimestamp = %llu UTC = %s",
	(u_longlong_t)ub->ub_timestamp, asctime(localtime(&timestamp)));

	(void) printf("\tmmp_magic = %016llx\n",
	(u_longlong_t)ub->ub_mmp_magic);
	if (MMP_VALID(ub)) {
	(void) printf("\tmmp_delay = %0llu\n",
	(u_longlong_t)ub->ub_mmp_delay);
	if (MMP_SEQ_VALID(ub))
	(void) printf("\tmmp_seq = %u\n",
	(unsigned int) MMP_SEQ(ub));
	if (MMP_FAIL_INT_VALID(ub))
	(void) printf("\tmmp_fail = %u\n",
	(unsigned int) MMP_FAIL_INT(ub));
	if (MMP_INTERVAL_VALID(ub))
	(void) printf("\tmmp_write = %u\n",
	(unsigned int) MMP_INTERVAL(ub));
	/* After MMP_* to make summarize_uberblock_mmp cleaner */
	(void) printf("\tmmp_valid = %x\n",
	(unsigned int) ub->ub_mmp_config & 0xFF);
	}

	if (dump_opt['u'] >= 4) {
	char blkbuf[BP_SPRINTF_LEN];
	snprintf_blkptr(blkbuf, sizeof (blkbuf), &ub->ub_rootbp);
	(void) printf("\trootbp = %s\n", blkbuf);
	}
	(void) printf("\tcheckpoint_txg = %llu\n",
	(u_longlong_t)ub->ub_checkpoint_txg);
	(void) printf("%s", footer ? footer : "");
	}

	static void
	dump_config(spa_t *spa)
	{
	dmu_buf_t *db;
	size_t nvsize = 0;
	int error = 0;


	error = dmu_bonus_hold(spa->spa_meta_objset,
	spa->spa_config_object, FTAG, &db);

	if (error == 0) {
	nvsize = (uint64_t )db->db_data;
	dmu_buf_rele(db, FTAG);

	(void) printf("\nMOS Configuration:\n");
	dump_packed_nvlist(spa->spa_meta_objset,
	spa->spa_config_object, (void *)&nvsize, 1);
	} else {
	(void) fprintf(stderr, "dmu_bonus_hold(%llu) failed, errno %d",
	(u_longlong_t)spa->spa_config_object, error);
	}
	}

	static void
	dump_cachefile(const char *cachefile)
	{
	int fd;
	struct stat64 statbuf;
	char *buf;
	nvlist_t *config;

	if ((fd = open64(cachefile, O_RDONLY)) < 0) {
	(void) printf("cannot open '%s': %s\n", cachefile,
	strerror(errno));
	exit(1);
	}

	if (fstat64(fd, &statbuf) != 0) {
	(void) printf("failed to stat '%s': %s\n", cachefile,
	strerror(errno));
	exit(1);
	}

	if ((buf = malloc(statbuf.st_size)) == NULL) {
	(void) fprintf(stderr, "failed to allocate %llu bytes\n",
	(u_longlong_t)statbuf.st_size);
	exit(1);
	}

	if (read(fd, buf, statbuf.st_size) != statbuf.st_size) {
	(void) fprintf(stderr, "failed to read %llu bytes\n",
	(u_longlong_t)statbuf.st_size);
	exit(1);
	}

	(void) close(fd);

	if (nvlist_unpack(buf, statbuf.st_size, &config, 0) != 0) {
	(void) fprintf(stderr, "failed to unpack nvlist\n");
	exit(1);
	}

	free(buf);

	dump_nvlist(config, 0);

	nvlist_free(config);
	}

	/*
	* ZFS label nvlist stats
	*/
	typedef struct zdb_nvl_stats {
	int zns_list_count;
	int zns_leaf_count;
	size_t zns_leaf_largest;
	size_t zns_leaf_total;
	nvlist_t *zns_string;
	nvlist_t *zns_uint64;
	nvlist_t *zns_boolean;
	} zdb_nvl_stats_t;

	static void
	collect_nvlist_stats(nvlist_t nvl, zdb_nvl_stats_t stats)
	{
	nvlist_t list, *array;
	nvpair_t *nvp = NULL;
	char *name;
	uint_t i, items;

	stats->zns_list_count++;

	while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
	name = nvpair_name(nvp);

	switch (nvpair_type(nvp)) {
	case DATA_TYPE_STRING:
	fnvlist_add_string(stats->zns_string, name,
	fnvpair_value_string(nvp));
	break;
	case DATA_TYPE_UINT64:
	fnvlist_add_uint64(stats->zns_uint64, name,
	fnvpair_value_uint64(nvp));
	break;
	case DATA_TYPE_BOOLEAN:
	fnvlist_add_boolean(stats->zns_boolean, name);
	break;
	case DATA_TYPE_NVLIST:
	if (nvpair_value_nvlist(nvp, &list) == 0)
	collect_nvlist_stats(list, stats);
	break;
	case DATA_TYPE_NVLIST_ARRAY:
	if (nvpair_value_nvlist_array(nvp, &array, &items) != 0)
	break;

	for (i = 0; i < items; i++) {
	collect_nvlist_stats(array[i], stats);

	/* collect stats on leaf vdev */
	if (strcmp(name, "children") == 0) {
	size_t size;

	(void) nvlist_size(array[i], &size,
	NV_ENCODE_XDR);
	stats->zns_leaf_total += size;
	if (size > stats->zns_leaf_largest)
	stats->zns_leaf_largest = size;
	stats->zns_leaf_count++;
	}
	}
	break;
	default:
	(void) printf("skip type %d!\n", (int)nvpair_type(nvp));
	}
	}
	}

	static void
	dump_nvlist_stats(nvlist_t *nvl, size_t cap)
	{
	zdb_nvl_stats_t stats = { 0 };
	size_t size, sum = 0, total;
	size_t noise;

	/* requires nvlist with non-unique names for stat collection */
	VERIFY0(nvlist_alloc(&stats.zns_string, 0, 0));
	VERIFY0(nvlist_alloc(&stats.zns_uint64, 0, 0));
	VERIFY0(nvlist_alloc(&stats.zns_boolean, 0, 0));
	VERIFY0(nvlist_size(stats.zns_boolean, &noise, NV_ENCODE_XDR));

	(void) printf("\n\nZFS Label NVList Config Stats:\n");

	VERIFY0(nvlist_size(nvl, &total, NV_ENCODE_XDR));
	(void) printf(" %d bytes used, %d bytes free (using %4.1f%%)\n\n",
	(int)total, (int)(cap - total), 100.0 * total / cap);

	collect_nvlist_stats(nvl, &stats);

	VERIFY0(nvlist_size(stats.zns_uint64, &size, NV_ENCODE_XDR));
	size -= noise;
	sum += size;
	(void) printf("%12s %4d %6d bytes (%5.2f%%)\n", "integers:",
	(int)fnvlist_num_pairs(stats.zns_uint64),
	(int)size, 100.0 * size / total);

	VERIFY0(nvlist_size(stats.zns_string, &size, NV_ENCODE_XDR));
	size -= noise;
	sum += size;
	(void) printf("%12s %4d %6d bytes (%5.2f%%)\n", "strings:",
	(int)fnvlist_num_pairs(stats.zns_string),
	(int)size, 100.0 * size / total);

	VERIFY0(nvlist_size(stats.zns_boolean, &size, NV_ENCODE_XDR));
	size -= noise;
	sum += size;
	(void) printf("%12s %4d %6d bytes (%5.2f%%)\n", "booleans:",
	(int)fnvlist_num_pairs(stats.zns_boolean),
	(int)size, 100.0 * size / total);

	size = total - sum; /* treat remainder as nvlist overhead */
	(void) printf("%12s %4d %6d bytes (%5.2f%%)\n\n", "nvlists:",
	stats.zns_list_count, (int)size, 100.0 * size / total);

	if (stats.zns_leaf_count > 0) {
	size_t average = stats.zns_leaf_total / stats.zns_leaf_count;

	(void) printf("%12s %4d %6d bytes average\n", "leaf vdevs:",
	stats.zns_leaf_count, (int)average);
	(void) printf("%24d bytes largest\n",
	(int)stats.zns_leaf_largest);

	if (dump_opt['l'] >= 3 && average > 0)
	(void) printf(" space for %d additional leaf vdevs\n",
	(int)((cap - total) / average));
	}
	(void) printf("\n");

	nvlist_free(stats.zns_string);
	nvlist_free(stats.zns_uint64);
	nvlist_free(stats.zns_boolean);
	}

	typedef struct cksum_record {
	zio_cksum_t cksum;
	boolean_t labels[VDEV_LABELS];
	avl_node_t link;
	} cksum_record_t;

	static int
	cksum_record_compare(const void x1, const void x2)
	{
	const cksum_record_t l = (cksum_record_t )x1;
	const cksum_record_t r = (cksum_record_t )x2;
	int arraysize = ARRAY_SIZE(l->cksum.zc_word);
	int difference;

	for (int i = 0; i < arraysize; i++) {
	difference = TREE_CMP(l->cksum.zc_word[i], r->cksum.zc_word[i]);
	if (difference)
	break;
	}

	return (difference);
	}

	static cksum_record_t *
	cksum_record_alloc(zio_cksum_t *cksum, int l)
	{
	cksum_record_t *rec;

	rec = umem_zalloc(sizeof (*rec), UMEM_NOFAIL);
	rec->cksum = *cksum;
	rec->labels[l] = B_TRUE;

	return (rec);
	}

	static cksum_record_t *
	cksum_record_lookup(avl_tree_t tree, zio_cksum_t cksum)
	{
	cksum_record_t lookup = { .cksum = *cksum };
	avl_index_t where;

	return (avl_find(tree, &lookup, &where));
	}

	static cksum_record_t *
	cksum_record_insert(avl_tree_t tree, zio_cksum_t cksum, int l)
	{
	cksum_record_t *rec;

	rec = cksum_record_lookup(tree, cksum);
	if (rec) {
	rec->labels[l] = B_TRUE;
	} else {
	rec = cksum_record_alloc(cksum, l);
	avl_add(tree, rec);
	}

	return (rec);
	}

	static int
	first_label(cksum_record_t *rec)
	{
	for (int i = 0; i < VDEV_LABELS; i++)
	if (rec->labels[i])
	return (i);

	return (-1);
	}

	static void
	print_label_numbers(char prefix, cksum_record_t rec)
	{
	printf("%s", prefix);
	for (int i = 0; i < VDEV_LABELS; i++)
	if (rec->labels[i] == B_TRUE)
	printf("%d ", i);
	printf("\n");
	}

	#define MAX_UBERBLOCK_COUNT (VDEV_UBERBLOCK_RING >> UBERBLOCK_SHIFT)

	typedef struct zdb_label {
	vdev_label_t label;
	nvlist_t *config_nv;
	cksum_record_t *config;
	cksum_record_t *uberblocks[MAX_UBERBLOCK_COUNT];
	boolean_t header_printed;
	boolean_t read_failed;
	} zdb_label_t;

	static void
	print_label_header(zdb_label_t *label, int l)
	{

	if (dump_opt['q'])
	return;

	if (label->header_printed == B_TRUE)
	return;

	(void) printf("------------------------------------\n");
	(void) printf("LABEL %d\n", l);
	(void) printf("------------------------------------\n");

	label->header_printed = B_TRUE;
	}

	static void
	print_l2arc_header(void)
	{
	(void) printf("------------------------------------\n");
	(void) printf("L2ARC device header\n");
	(void) printf("------------------------------------\n");
	}

	static void
	print_l2arc_log_blocks(void)
	{
	(void) printf("------------------------------------\n");
	(void) printf("L2ARC device log blocks\n");
	(void) printf("------------------------------------\n");
	}

	static void
	dump_l2arc_log_entries(uint64_t log_entries,
	l2arc_log_ent_phys_t *le, uint64_t i)
	{
	for (int j = 0; j < log_entries; j++) {
	dva_t dva = le[j].le_dva;
	(void) printf("lb[%4llu]\tle[%4d]\tDVA asize: %llu, "
	"vdev: %llu, offset: %llu\n",
	(u_longlong_t)i, j + 1,
	(u_longlong_t)DVA_GET_ASIZE(&dva),
	(u_longlong_t)DVA_GET_VDEV(&dva),
	(u_longlong_t)DVA_GET_OFFSET(&dva));
	(void) printf("\|\t\t\t\tbirth: %llu\n",
	(u_longlong_t)le[j].le_birth);
	(void) printf("\|\t\t\t\tlsize: %llu\n",
	(u_longlong_t)L2BLK_GET_LSIZE((&le[j])->le_prop));
	(void) printf("\|\t\t\t\tpsize: %llu\n",
	(u_longlong_t)L2BLK_GET_PSIZE((&le[j])->le_prop));
	(void) printf("\|\t\t\t\tcompr: %llu\n",
	(u_longlong_t)L2BLK_GET_COMPRESS((&le[j])->le_prop));
	(void) printf("\|\t\t\t\tcomplevel: %llu\n",
	(u_longlong_t)(&le[j])->le_complevel);
	(void) printf("\|\t\t\t\ttype: %llu\n",
	(u_longlong_t)L2BLK_GET_TYPE((&le[j])->le_prop));
	(void) printf("\|\t\t\t\tprotected: %llu\n",
	(u_longlong_t)L2BLK_GET_PROTECTED((&le[j])->le_prop));
	(void) printf("\|\t\t\t\tprefetch: %llu\n",
	(u_longlong_t)L2BLK_GET_PREFETCH((&le[j])->le_prop));
	(void) printf("\|\t\t\t\taddress: %llu\n",
	(u_longlong_t)le[j].le_daddr);
	(void) printf("\|\t\t\t\tARC state: %llu\n",
	(u_longlong_t)L2BLK_GET_STATE((&le[j])->le_prop));
	(void) printf("\|\n");
	}
	(void) printf("\n");
	}

	static void
	dump_l2arc_log_blkptr(l2arc_log_blkptr_t lbps)
	{
	(void) printf("\|\t\tdaddr: %llu\n", (u_longlong_t)lbps.lbp_daddr);
	(void) printf("\|\t\tpayload_asize: %llu\n",
	(u_longlong_t)lbps.lbp_payload_asize);
	(void) printf("\|\t\tpayload_start: %llu\n",
	(u_longlong_t)lbps.lbp_payload_start);
	(void) printf("\|\t\tlsize: %llu\n",
	(u_longlong_t)L2BLK_GET_LSIZE((&lbps)->lbp_prop));
	(void) printf("\|\t\tasize: %llu\n",
	(u_longlong_t)L2BLK_GET_PSIZE((&lbps)->lbp_prop));
	(void) printf("\|\t\tcompralgo: %llu\n",
	(u_longlong_t)L2BLK_GET_COMPRESS((&lbps)->lbp_prop));
	(void) printf("\|\t\tcksumalgo: %llu\n",
	(u_longlong_t)L2BLK_GET_CHECKSUM((&lbps)->lbp_prop));
	(void) printf("\|\n\n");
	}

	static void
	dump_l2arc_log_blocks(int fd, l2arc_dev_hdr_phys_t l2dhdr,
	l2arc_dev_hdr_phys_t *rebuild)
	{
	l2arc_log_blk_phys_t this_lb;
	uint64_t asize;
	l2arc_log_blkptr_t lbps[2];
	abd_t *abd;
	zio_cksum_t cksum;
	int failed = 0;
	l2arc_dev_t dev;

	if (!dump_opt['q'])
	print_l2arc_log_blocks();
	bcopy((&l2dhdr)->dh_start_lbps, lbps, sizeof (lbps));

	dev.l2ad_evict = l2dhdr.dh_evict;
	dev.l2ad_start = l2dhdr.dh_start;
	dev.l2ad_end = l2dhdr.dh_end;

	if (l2dhdr.dh_start_lbps[0].lbp_daddr == 0) {
	/* no log blocks to read */
	if (!dump_opt['q']) {
	(void) printf("No log blocks to read\n");
	(void) printf("\n");
	}
	return;
	} else {
	dev.l2ad_hand = lbps[0].lbp_daddr +
	L2BLK_GET_PSIZE((&lbps[0])->lbp_prop);
	}

	dev.l2ad_first = !!(l2dhdr.dh_flags & L2ARC_DEV_HDR_EVICT_FIRST);

	for (;;) {
	if (!l2arc_log_blkptr_valid(&dev, &lbps[0]))
	break;

	/* L2BLK_GET_PSIZE returns aligned size for log blocks */
	asize = L2BLK_GET_PSIZE((&lbps[0])->lbp_prop);
	if (pread64(fd, &this_lb, asize, lbps[0].lbp_daddr) != asize) {
	if (!dump_opt['q']) {
	(void) printf("Error while reading next log "
	"block\n\n");
	}
	break;
	}

	fletcher_4_native_varsize(&this_lb, asize, &cksum);
	if (!ZIO_CHECKSUM_EQUAL(cksum, lbps[0].lbp_cksum)) {
	failed++;
	if (!dump_opt['q']) {
	(void) printf("Invalid cksum\n");
	dump_l2arc_log_blkptr(lbps[0]);
	}
	break;
	}

	switch (L2BLK_GET_COMPRESS((&lbps[0])->lbp_prop)) {
	case ZIO_COMPRESS_OFF:
	break;
	default:
	abd = abd_alloc_for_io(asize, B_TRUE);
	abd_copy_from_buf_off(abd, &this_lb, 0, asize);
	zio_decompress_data(L2BLK_GET_COMPRESS(
	(&lbps[0])->lbp_prop), abd, &this_lb,
	asize, sizeof (this_lb), NULL);
	abd_free(abd);
	break;
	}

	if (this_lb.lb_magic == BSWAP_64(L2ARC_LOG_BLK_MAGIC))
	byteswap_uint64_array(&this_lb, sizeof (this_lb));
	if (this_lb.lb_magic != L2ARC_LOG_BLK_MAGIC) {
	if (!dump_opt['q'])
	(void) printf("Invalid log block magic\n\n");
	break;
	}

	rebuild->dh_lb_count++;
	rebuild->dh_lb_asize += asize;
	if (dump_opt['l'] > 1 && !dump_opt['q']) {
	(void) printf("lb[%4llu]\tmagic: %llu\n",
	(u_longlong_t)rebuild->dh_lb_count,
	(u_longlong_t)this_lb.lb_magic);
	dump_l2arc_log_blkptr(lbps[0]);
	}

	if (dump_opt['l'] > 2 && !dump_opt['q'])
	dump_l2arc_log_entries(l2dhdr.dh_log_entries,
	this_lb.lb_entries,
	rebuild->dh_lb_count);

	if (l2arc_range_check_overlap(lbps[1].lbp_payload_start,
	lbps[0].lbp_payload_start, dev.l2ad_evict) &&
	!dev.l2ad_first)
	break;

	lbps[0] = lbps[1];
	lbps[1] = this_lb.lb_prev_lbp;
	}

	if (!dump_opt['q']) {
	(void) printf("log_blk_count:\t %llu with valid cksum\n",
	(u_longlong_t)rebuild->dh_lb_count);
	(void) printf("\t\t %d with invalid cksum\n", failed);
	(void) printf("log_blk_asize:\t %llu\n\n",
	(u_longlong_t)rebuild->dh_lb_asize);
	}
	}

	static int
	dump_l2arc_header(int fd)
	{
	l2arc_dev_hdr_phys_t l2dhdr, rebuild;
	int error = B_FALSE;

	bzero(&l2dhdr, sizeof (l2dhdr));
	bzero(&rebuild, sizeof (rebuild));

	if (pread64(fd, &l2dhdr, sizeof (l2dhdr),
	VDEV_LABEL_START_SIZE) != sizeof (l2dhdr)) {
	error = B_TRUE;
	} else {
	if (l2dhdr.dh_magic == BSWAP_64(L2ARC_DEV_HDR_MAGIC))
	byteswap_uint64_array(&l2dhdr, sizeof (l2dhdr));

	if (l2dhdr.dh_magic != L2ARC_DEV_HDR_MAGIC)
	error = B_TRUE;
	}

	if (error) {
	(void) printf("L2ARC device header not found\n\n");
	/* Do not return an error here for backward compatibility */
	return (0);
	} else if (!dump_opt['q']) {
	print_l2arc_header();

	(void) printf(" magic: %llu\n",
	(u_longlong_t)l2dhdr.dh_magic);
	(void) printf(" version: %llu\n",
	(u_longlong_t)l2dhdr.dh_version);
	(void) printf(" pool_guid: %llu\n",
	(u_longlong_t)l2dhdr.dh_spa_guid);
	(void) printf(" flags: %llu\n",
	(u_longlong_t)l2dhdr.dh_flags);
	(void) printf(" start_lbps[0]: %llu\n",
	(u_longlong_t)
	l2dhdr.dh_start_lbps[0].lbp_daddr);
	(void) printf(" start_lbps[1]: %llu\n",
	(u_longlong_t)
	l2dhdr.dh_start_lbps[1].lbp_daddr);
	(void) printf(" log_blk_ent: %llu\n",
	(u_longlong_t)l2dhdr.dh_log_entries);
	(void) printf(" start: %llu\n",
	(u_longlong_t)l2dhdr.dh_start);
	(void) printf(" end: %llu\n",
	(u_longlong_t)l2dhdr.dh_end);
	(void) printf(" evict: %llu\n",
	(u_longlong_t)l2dhdr.dh_evict);
	(void) printf(" lb_asize_refcount: %llu\n",
	(u_longlong_t)l2dhdr.dh_lb_asize);
	(void) printf(" lb_count_refcount: %llu\n",
	(u_longlong_t)l2dhdr.dh_lb_count);
	(void) printf(" trim_action_time: %llu\n",
	(u_longlong_t)l2dhdr.dh_trim_action_time);
	(void) printf(" trim_state: %llu\n\n",
	(u_longlong_t)l2dhdr.dh_trim_state);
	}

	dump_l2arc_log_blocks(fd, l2dhdr, &rebuild);
	/*
	* The total aligned size of log blocks and the number of log blocks
	* reported in the header of the device may be less than what zdb
	* reports by dump_l2arc_log_blocks() which emulates l2arc_rebuild().
	* This happens because dump_l2arc_log_blocks() lacks the memory
	* pressure valve that l2arc_rebuild() has. Thus, if we are on a system
	* with low memory, l2arc_rebuild will exit prematurely and dh_lb_asize
	* and dh_lb_count will be lower to begin with than what exists on the
	* device. This is normal and zdb should not exit with an error. The
	* opposite case should never happen though, the values reported in the
	* header should never be higher than what dump_l2arc_log_blocks() and
	* l2arc_rebuild() report. If this happens there is a leak in the
	* accounting of log blocks.
	*/
	if (l2dhdr.dh_lb_asize > rebuild.dh_lb_asize \|\|
	l2dhdr.dh_lb_count > rebuild.dh_lb_count)
	return (1);

	return (0);
	}

	static void
	dump_config_from_label(zdb_label_t *label, size_t buflen, int l)
	{
	if (dump_opt['q'])
	return;

	if ((dump_opt['l'] < 3) && (first_label(label->config) != l))
	return;

	print_label_header(label, l);
	dump_nvlist(label->config_nv, 4);
	print_label_numbers(" labels = ", label->config);

	if (dump_opt['l'] >= 2)
	dump_nvlist_stats(label->config_nv, buflen);
	}

	#define ZDB_MAX_UB_HEADER_SIZE 32

	static void
	dump_label_uberblocks(zdb_label_t *label, uint64_t ashift, int label_num)
	{

	vdev_t vd;
	char header[ZDB_MAX_UB_HEADER_SIZE];

	vd.vdev_ashift = ashift;
	vd.vdev_top = &vd;

	for (int i = 0; i < VDEV_UBERBLOCK_COUNT(&vd); i++) {
	uint64_t uoff = VDEV_UBERBLOCK_OFFSET(&vd, i);
	uberblock_t ub = (void )((char *)&label->label + uoff);
	cksum_record_t *rec = label->uberblocks[i];

	if (rec == NULL) {
	if (dump_opt['u'] >= 2) {
	print_label_header(label, label_num);
	(void) printf(" Uberblock[%d] invalid\n", i);
	}
	continue;
	}

	if ((dump_opt['u'] < 3) && (first_label(rec) != label_num))
	continue;

	if ((dump_opt['u'] < 4) &&
	(ub->ub_mmp_magic == MMP_MAGIC) && ub->ub_mmp_delay &&
	(i >= VDEV_UBERBLOCK_COUNT(&vd) - MMP_BLOCKS_PER_LABEL))
	continue;

	print_label_header(label, label_num);
	(void) snprintf(header, ZDB_MAX_UB_HEADER_SIZE,
	" Uberblock[%d]\n", i);
	dump_uberblock(ub, header, "");
	print_label_numbers(" labels = ", rec);
	}
	}

	static char curpath[PATH_MAX];

	/*
	* Iterate through the path components, recursively passing
	* current one's obj and remaining path until we find the obj
	* for the last one.
	*/
	static int
	dump_path_impl(objset_t os, uint64_t obj, char name, uint64_t *retobj)
	{
	int err;
	boolean_t header = B_TRUE;
	uint64_t child_obj;
	char *s;
	dmu_buf_t *db;
	dmu_object_info_t doi;

	if ((s = strchr(name, '/')) != NULL)
	*s = '\0';
	err = zap_lookup(os, obj, name, 8, 1, &child_obj);

	(void) strlcat(curpath, name, sizeof (curpath));

	if (err != 0) {
	(void) fprintf(stderr, "failed to lookup %s: %s\n",
	curpath, strerror(err));
	return (err);
	}

	child_obj = ZFS_DIRENT_OBJ(child_obj);
	err = sa_buf_hold(os, child_obj, FTAG, &db);
	if (err != 0) {
	(void) fprintf(stderr,
	"failed to get SA dbuf for obj %llu: %s\n",
	(u_longlong_t)child_obj, strerror(err));
	return (EINVAL);
	}
	dmu_object_info_from_db(db, &doi);
	sa_buf_rele(db, FTAG);

	if (doi.doi_bonus_type != DMU_OT_SA &&
	doi.doi_bonus_type != DMU_OT_ZNODE) {
	(void) fprintf(stderr, "invalid bonus type %d for obj %llu\n",
	doi.doi_bonus_type, (u_longlong_t)child_obj);
	return (EINVAL);
	}

	if (dump_opt['v'] > 6) {
	(void) printf("obj=%llu %s type=%d bonustype=%d\n",
	(u_longlong_t)child_obj, curpath, doi.doi_type,
	doi.doi_bonus_type);
	}

	(void) strlcat(curpath, "/", sizeof (curpath));

	switch (doi.doi_type) {
	case DMU_OT_DIRECTORY_CONTENTS:
	if (s != NULL && *(s + 1) != '\0')
	return (dump_path_impl(os, child_obj, s + 1, retobj));
	/FALLTHROUGH/
	case DMU_OT_PLAIN_FILE_CONTENTS:
	if (retobj != NULL) {
	*retobj = child_obj;
	} else {
	dump_object(os, child_obj, dump_opt['v'], &header,
	NULL, 0);
	}
	return (0);
	default:
	(void) fprintf(stderr, "object %llu has non-file/directory "
	"type %d\n", (u_longlong_t)obj, doi.doi_type);
	break;
	}

	return (EINVAL);
	}

	/*
	* Dump the blocks for the object specified by path inside the dataset.
	*/
	static int
	dump_path(char ds, char path, uint64_t *retobj)
	{
	int err;
	objset_t *os;
	uint64_t root_obj;

	err = open_objset(ds, FTAG, &os);
	if (err != 0)
	return (err);

	err = zap_lookup(os, MASTER_NODE_OBJ, ZFS_ROOT_OBJ, 8, 1, &root_obj);
	if (err != 0) {
	(void) fprintf(stderr, "can't lookup root znode: %s\n",
	strerror(err));
	close_objset(os, FTAG);
	return (EINVAL);
	}

	(void) snprintf(curpath, sizeof (curpath), "dataset=%s path=/", ds);

	err = dump_path_impl(os, root_obj, path, retobj);

	close_objset(os, FTAG);
	return (err);
	}

	static int
	zdb_copy_object(objset_t os, uint64_t srcobj, char destfile)
	{
	int err = 0;
	uint64_t size, readsize, oursize, offset;
	ssize_t writesize;
	sa_handle_t *hdl;

	(void) printf("Copying object %" PRIu64 " to file %s\n", srcobj,
	destfile);

	VERIFY3P(os, ==, sa_os);
	if ((err = sa_handle_get(os, srcobj, NULL, SA_HDL_PRIVATE, &hdl))) {
	(void) printf("Failed to get handle for SA znode\n");
	return (err);
	}
	if ((err = sa_lookup(hdl, sa_attr_table[ZPL_SIZE], &size, 8))) {
	(void) sa_handle_destroy(hdl);
	return (err);
	}
	(void) sa_handle_destroy(hdl);

	(void) printf("Object %" PRIu64 " is %" PRIu64 " bytes\n", srcobj,
	size);
	if (size == 0) {
	return (EINVAL);
	}

	int fd = open(destfile, O_WRONLY \| O_CREAT \| O_TRUNC, 0644);
	/*
	* We cap the size at 1 mebibyte here to prevent
	* allocation failures and nigh-infinite printing if the
	* object is extremely large.
	*/
	oursize = MIN(size, 1 << 20);
	offset = 0;
	char *buf = kmem_alloc(oursize, KM_NOSLEEP);
	if (buf == NULL) {
	return (ENOMEM);
	}

	while (offset < size) {
	readsize = MIN(size - offset, 1 << 20);
	err = dmu_read(os, srcobj, offset, readsize, buf, 0);
	if (err != 0) {
	(void) printf("got error %u from dmu_read\n", err);
	kmem_free(buf, oursize);
	return (err);
	}
	if (dump_opt['v'] > 3) {
	(void) printf("Read offset=%" PRIu64 " size=%" PRIu64
	" error=%d\n", offset, readsize, err);
	}

	writesize = write(fd, buf, readsize);
	if (writesize < 0) {
	err = errno;
	break;
	} else if (writesize != readsize) {
	/* Incomplete write */
	(void) fprintf(stderr, "Short write, only wrote %llu of"
	" %" PRIu64 " bytes, exiting...\n",
	(u_longlong_t)writesize, readsize);
	break;
	}

	offset += readsize;
	}

	(void) close(fd);

	if (buf != NULL)
	kmem_free(buf, oursize);

	return (err);
	}

	static int
	dump_label(const char *dev)
	{
	char path[MAXPATHLEN];
	zdb_label_t labels[VDEV_LABELS];
	uint64_t psize, ashift, l2cache;
	struct stat64 statbuf;
	boolean_t config_found = B_FALSE;
	boolean_t error = B_FALSE;
	boolean_t read_l2arc_header = B_FALSE;
	avl_tree_t config_tree;
	avl_tree_t uberblock_tree;
	void node, cookie;
	int fd;

	bzero(labels, sizeof (labels));

	/*
	* Check if we were given absolute path and use it as is.
	* Otherwise if the provided vdev name doesn't point to a file,
	* try prepending expected disk paths and partition numbers.
	*/
	(void) strlcpy(path, dev, sizeof (path));
	if (dev[0] != '/' && stat64(path, &statbuf) != 0) {
	int error;

	error = zfs_resolve_shortname(dev, path, MAXPATHLEN);
	if (error == 0 && zfs_dev_is_whole_disk(path)) {
	if (zfs_append_partition(path, MAXPATHLEN) == -1)
	error = ENOENT;
	}

	if (error \|\| (stat64(path, &statbuf) != 0)) {
	(void) printf("failed to find device %s, try "
	"specifying absolute path instead\n", dev);
	return (1);
	}
	}

	if ((fd = open64(path, O_RDONLY)) < 0) {
	(void) printf("cannot open '%s': %s\n", path, strerror(errno));
	exit(1);
	}

	if (fstat64_blk(fd, &statbuf) != 0) {
	(void) printf("failed to stat '%s': %s\n", path,
	strerror(errno));
	(void) close(fd);
	exit(1);
	}

	if (S_ISBLK(statbuf.st_mode) && zfs_dev_flush(fd) != 0)
	(void) printf("failed to invalidate cache '%s' : %s\n", path,
	strerror(errno));

	avl_create(&config_tree, cksum_record_compare,
	sizeof (cksum_record_t), offsetof(cksum_record_t, link));
	avl_create(&uberblock_tree, cksum_record_compare,
	sizeof (cksum_record_t), offsetof(cksum_record_t, link));

	psize = statbuf.st_size;
	psize = P2ALIGN(psize, (uint64_t)sizeof (vdev_label_t));
	ashift = SPA_MINBLOCKSHIFT;

	/*
	* 1. Read the label from disk
	* 2. Unpack the configuration and insert in config tree.
	* 3. Traverse all uberblocks and insert in uberblock tree.
	*/
	for (int l = 0; l < VDEV_LABELS; l++) {
	zdb_label_t *label = &labels[l];
	char *buf = label->label.vl_vdev_phys.vp_nvlist;
	size_t buflen = sizeof (label->label.vl_vdev_phys.vp_nvlist);
	nvlist_t *config;
	cksum_record_t *rec;
	zio_cksum_t cksum;
	vdev_t vd;

	if (pread64(fd, &label->label, sizeof (label->label),
	vdev_label_offset(psize, l, 0)) != sizeof (label->label)) {
	if (!dump_opt['q'])
	(void) printf("failed to read label %d\n", l);
	label->read_failed = B_TRUE;
	error = B_TRUE;
	continue;
	}

	label->read_failed = B_FALSE;

	if (nvlist_unpack(buf, buflen, &config, 0) == 0) {
	nvlist_t *vdev_tree = NULL;
	size_t size;

	if ((nvlist_lookup_nvlist(config,
	ZPOOL_CONFIG_VDEV_TREE, &vdev_tree) != 0) \|\|
	(nvlist_lookup_uint64(vdev_tree,
	ZPOOL_CONFIG_ASHIFT, &ashift) != 0))
	ashift = SPA_MINBLOCKSHIFT;

	if (nvlist_size(config, &size, NV_ENCODE_XDR) != 0)
	size = buflen;

	/* If the device is a cache device clear the header. */
	if (!read_l2arc_header) {
	if (nvlist_lookup_uint64(config,
	ZPOOL_CONFIG_POOL_STATE, &l2cache) == 0 &&
	l2cache == POOL_STATE_L2CACHE) {
	read_l2arc_header = B_TRUE;
	}
	}

	fletcher_4_native_varsize(buf, size, &cksum);
	rec = cksum_record_insert(&config_tree, &cksum, l);

	label->config = rec;
	label->config_nv = config;
	config_found = B_TRUE;
	} else {
	error = B_TRUE;
	}

	vd.vdev_ashift = ashift;
	vd.vdev_top = &vd;

	for (int i = 0; i < VDEV_UBERBLOCK_COUNT(&vd); i++) {
	uint64_t uoff = VDEV_UBERBLOCK_OFFSET(&vd, i);
	uberblock_t ub = (void )((char *)label + uoff);

	if (uberblock_verify(ub))
	continue;

	fletcher_4_native_varsize(ub, sizeof (*ub), &cksum);
	rec = cksum_record_insert(&uberblock_tree, &cksum, l);

	label->uberblocks[i] = rec;
	}
	}

	/*
	* Dump the label and uberblocks.
	*/
	for (int l = 0; l < VDEV_LABELS; l++) {
	zdb_label_t *label = &labels[l];
	size_t buflen = sizeof (label->label.vl_vdev_phys.vp_nvlist);

	if (label->read_failed == B_TRUE)
	continue;

	if (label->config_nv) {
	dump_config_from_label(label, buflen, l);
	} else {
	if (!dump_opt['q'])
	(void) printf("failed to unpack label %d\n", l);
	}

	if (dump_opt['u'])
	dump_label_uberblocks(label, ashift, l);

	nvlist_free(label->config_nv);
	}

	/*
	* Dump the L2ARC header, if existent.
	*/
	if (read_l2arc_header)
	error \|= dump_l2arc_header(fd);

	cookie = NULL;
	while ((node = avl_destroy_nodes(&config_tree, &cookie)) != NULL)
	umem_free(node, sizeof (cksum_record_t));

	cookie = NULL;
	while ((node = avl_destroy_nodes(&uberblock_tree, &cookie)) != NULL)
	umem_free(node, sizeof (cksum_record_t));

	avl_destroy(&config_tree);
	avl_destroy(&uberblock_tree);

	(void) close(fd);

	return (config_found == B_FALSE ? 2 :
	(error == B_TRUE ? 1 : 0));
	}

	static uint64_t dataset_feature_count[SPA_FEATURES];
	static uint64_t global_feature_count[SPA_FEATURES];
	static uint64_t remap_deadlist_count = 0;

	/ARGSUSED/
	static int
	dump_one_objset(const char dsname, void arg)
	{
	int error;
	objset_t *os;
	spa_feature_t f;

	error = open_objset(dsname, FTAG, &os);
	if (error != 0)
	return (0);

	for (f = 0; f < SPA_FEATURES; f++) {
	if (!dsl_dataset_feature_is_active(dmu_objset_ds(os), f))
	continue;
	ASSERT(spa_feature_table[f].fi_flags &
	ZFEATURE_FLAG_PER_DATASET);
	dataset_feature_count[f]++;
	}

	if (dsl_dataset_remap_deadlist_exists(dmu_objset_ds(os))) {
	remap_deadlist_count++;
	}

	for (dsl_bookmark_node_t *dbn =
	avl_first(&dmu_objset_ds(os)->ds_bookmarks); dbn != NULL;
	dbn = AVL_NEXT(&dmu_objset_ds(os)->ds_bookmarks, dbn)) {
	mos_obj_refd(dbn->dbn_phys.zbm_redaction_obj);
	if (dbn->dbn_phys.zbm_redaction_obj != 0)
	global_feature_count[SPA_FEATURE_REDACTION_BOOKMARKS]++;
	if (dbn->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN)
	global_feature_count[SPA_FEATURE_BOOKMARK_WRITTEN]++;
	}

	if (dsl_deadlist_is_open(&dmu_objset_ds(os)->ds_dir->dd_livelist) &&
	!dmu_objset_is_snapshot(os)) {
	global_feature_count[SPA_FEATURE_LIVELIST]++;
	}

	dump_objset(os);
	close_objset(os, FTAG);
	fuid_table_destroy();
	return (0);
	}

	/*
	* Block statistics.
	*/
	#define PSIZE_HISTO_SIZE (SPA_OLD_MAXBLOCKSIZE / SPA_MINBLOCKSIZE + 2)
	typedef struct zdb_blkstats {
	uint64_t zb_asize;
	uint64_t zb_lsize;
	uint64_t zb_psize;
	uint64_t zb_count;
	uint64_t zb_gangs;
	uint64_t zb_ditto_samevdev;
	uint64_t zb_ditto_same_ms;
	uint64_t zb_psize_histogram[PSIZE_HISTO_SIZE];
	} zdb_blkstats_t;

	/*
	* Extended object types to report deferred frees and dedup auto-ditto blocks.
	*/
	#define ZDB_OT_DEFERRED (DMU_OT_NUMTYPES + 0)
	#define ZDB_OT_DITTO (DMU_OT_NUMTYPES + 1)
	#define ZDB_OT_OTHER (DMU_OT_NUMTYPES + 2)
	#define ZDB_OT_TOTAL (DMU_OT_NUMTYPES + 3)

	static const char *zdb_ot_extname[] = {
	"deferred free",
	"dedup ditto",
	"other",
	"Total",
	};

	#define ZB_TOTAL DN_MAX_LEVELS
	#define SPA_MAX_FOR_16M (SPA_MAXBLOCKSHIFT+1)

	typedef struct zdb_cb {
	zdb_blkstats_t zcb_type[ZB_TOTAL + 1][ZDB_OT_TOTAL + 1];
	uint64_t zcb_removing_size;
	uint64_t zcb_checkpoint_size;
	uint64_t zcb_dedup_asize;
	uint64_t zcb_dedup_blocks;
	uint64_t zcb_psize_count[SPA_MAX_FOR_16M];
	uint64_t zcb_lsize_count[SPA_MAX_FOR_16M];
	uint64_t zcb_asize_count[SPA_MAX_FOR_16M];
	uint64_t zcb_psize_len[SPA_MAX_FOR_16M];
	uint64_t zcb_lsize_len[SPA_MAX_FOR_16M];
	uint64_t zcb_asize_len[SPA_MAX_FOR_16M];
	uint64_t zcb_psize_total;
	uint64_t zcb_lsize_total;
	uint64_t zcb_asize_total;
	uint64_t zcb_embedded_blocks[NUM_BP_EMBEDDED_TYPES];
	uint64_t zcb_embedded_histogram[NUM_BP_EMBEDDED_TYPES]
	[BPE_PAYLOAD_SIZE + 1];
	uint64_t zcb_start;
	hrtime_t zcb_lastprint;
	uint64_t zcb_totalasize;
	uint64_t zcb_errors[256];
	int zcb_readfails;
	int zcb_haderrors;
	spa_t *zcb_spa;
	uint32_t **zcb_vd_obsolete_counts;
	} zdb_cb_t;

	/* test if two DVA offsets from same vdev are within the same metaslab */
	static boolean_t
	same_metaslab(spa_t *spa, uint64_t vdev, uint64_t off1, uint64_t off2)
	{
	vdev_t *vd = vdev_lookup_top(spa, vdev);
	uint64_t ms_shift = vd->vdev_ms_shift;

	return ((off1 >> ms_shift) == (off2 >> ms_shift));
	}

	/*
	* Used to simplify reporting of the histogram data.
	*/
	typedef struct one_histo {
	char *name;
	uint64_t *count;
	uint64_t *len;
	uint64_t cumulative;
	} one_histo_t;

	/*
	* The number of separate histograms processed for psize, lsize and asize.
	*/
	#define NUM_HISTO 3

	/*
	* This routine will create a fixed column size output of three different
	* histograms showing by blocksize of 512 - 2^ SPA_MAX_FOR_16M
	* the count, length and cumulative length of the psize, lsize and
	* asize blocks.
	*
	* All three types of blocks are listed on a single line
	*
	* By default the table is printed in nicenumber format (e.g. 123K) but
	* if the '-P' parameter is specified then the full raw number (parseable)
	* is printed out.
	*/
	static void
	dump_size_histograms(zdb_cb_t *zcb)
	{
	/*
	* A temporary buffer that allows us to convert a number into
	* a string using zdb_nicenumber to allow either raw or human
	* readable numbers to be output.
	*/
	char numbuf[32];

	/*
	* Define titles which are used in the headers of the tables
	* printed by this routine.
	*/
	const char blocksize_title1[] = "block";
	const char blocksize_title2[] = "size";
	const char count_title[] = "Count";
	const char length_title[] = "Size";
	const char cumulative_title[] = "Cum.";

	/*
	* Setup the histogram arrays (psize, lsize, and asize).
	*/
	one_histo_t parm_histo[NUM_HISTO];

	parm_histo[0].name = "psize";
	parm_histo[0].count = zcb->zcb_psize_count;
	parm_histo[0].len = zcb->zcb_psize_len;
	parm_histo[0].cumulative = 0;

	parm_histo[1].name = "lsize";
	parm_histo[1].count = zcb->zcb_lsize_count;
	parm_histo[1].len = zcb->zcb_lsize_len;
	parm_histo[1].cumulative = 0;

	parm_histo[2].name = "asize";
	parm_histo[2].count = zcb->zcb_asize_count;
	parm_histo[2].len = zcb->zcb_asize_len;
	parm_histo[2].cumulative = 0;


	(void) printf("\nBlock Size Histogram\n");
	/*
	* Print the first line titles
	*/
	if (dump_opt['P'])
	(void) printf("\n%s\t", blocksize_title1);
	else
	(void) printf("\n%7s ", blocksize_title1);

	for (int j = 0; j < NUM_HISTO; j++) {
	if (dump_opt['P']) {
	if (j < NUM_HISTO - 1) {
	(void) printf("%s\t\t\t", parm_histo[j].name);
	} else {
	/* Don't print trailing spaces */
	(void) printf(" %s", parm_histo[j].name);
	}
	} else {
	if (j < NUM_HISTO - 1) {
	/* Left aligned strings in the output */
	(void) printf("%-7s ",
	parm_histo[j].name);
	} else {
	/* Don't print trailing spaces */
	(void) printf("%s", parm_histo[j].name);
	}
	}
	}
	(void) printf("\n");

	/*
	* Print the second line titles
	*/
	if (dump_opt['P']) {
	(void) printf("%s\t", blocksize_title2);
	} else {
	(void) printf("%7s ", blocksize_title2);
	}

	for (int i = 0; i < NUM_HISTO; i++) {
	if (dump_opt['P']) {
	(void) printf("%s\t%s\t%s\t",
	count_title, length_title, cumulative_title);
	} else {
	(void) printf("%7s%7s%7s",
	count_title, length_title, cumulative_title);
	}
	}
	(void) printf("\n");

	/*
	* Print the rows
	*/
	for (int i = SPA_MINBLOCKSHIFT; i < SPA_MAX_FOR_16M; i++) {

	/*
	* Print the first column showing the blocksize
	*/
	zdb_nicenum((1ULL << i), numbuf, sizeof (numbuf));

	if (dump_opt['P']) {
	printf("%s", numbuf);
	} else {
	printf("%7s:", numbuf);
	}

	/*
	* Print the remaining set of 3 columns per size:
	* for psize, lsize and asize
	*/
	for (int j = 0; j < NUM_HISTO; j++) {
	parm_histo[j].cumulative += parm_histo[j].len[i];

	zdb_nicenum(parm_histo[j].count[i],
	numbuf, sizeof (numbuf));
	if (dump_opt['P'])
	(void) printf("\t%s", numbuf);
	else
	(void) printf("%7s", numbuf);

	zdb_nicenum(parm_histo[j].len[i],
	numbuf, sizeof (numbuf));
	if (dump_opt['P'])
	(void) printf("\t%s", numbuf);
	else
	(void) printf("%7s", numbuf);

	zdb_nicenum(parm_histo[j].cumulative,
	numbuf, sizeof (numbuf));
	if (dump_opt['P'])
	(void) printf("\t%s", numbuf);
	else
	(void) printf("%7s", numbuf);
	}
	(void) printf("\n");
	}
	}

	static void
	zdb_count_block(zdb_cb_t zcb, zilog_t zilog, const blkptr_t *bp,
	dmu_object_type_t type)
	{
	uint64_t refcnt = 0;
	int i;

	ASSERT(type < ZDB_OT_TOTAL);

	if (zilog && zil_bp_tree_add(zilog, bp) != 0)
	return;

	spa_config_enter(zcb->zcb_spa, SCL_CONFIG, FTAG, RW_READER);

	for (i = 0; i < 4; i++) {
	int l = (i < 2) ? BP_GET_LEVEL(bp) : ZB_TOTAL;
	int t = (i & 1) ? type : ZDB_OT_TOTAL;
	int equal;
	zdb_blkstats_t *zb = &zcb->zcb_type[l][t];

	zb->zb_asize += BP_GET_ASIZE(bp);
	zb->zb_lsize += BP_GET_LSIZE(bp);
	zb->zb_psize += BP_GET_PSIZE(bp);
	zb->zb_count++;

	/*
	* The histogram is only big enough to record blocks up to
	* SPA_OLD_MAXBLOCKSIZE; larger blocks go into the last,
	* "other", bucket.
	*/
	unsigned idx = BP_GET_PSIZE(bp) >> SPA_MINBLOCKSHIFT;
	idx = MIN(idx, SPA_OLD_MAXBLOCKSIZE / SPA_MINBLOCKSIZE + 1);
	zb->zb_psize_histogram[idx]++;

	zb->zb_gangs += BP_COUNT_GANG(bp);

	switch (BP_GET_NDVAS(bp)) {
	case 2:
	if (DVA_GET_VDEV(&bp->blk_dva[0]) ==
	DVA_GET_VDEV(&bp->blk_dva[1])) {
	zb->zb_ditto_samevdev++;

	if (same_metaslab(zcb->zcb_spa,
	DVA_GET_VDEV(&bp->blk_dva[0]),
	DVA_GET_OFFSET(&bp->blk_dva[0]),
	DVA_GET_OFFSET(&bp->blk_dva[1])))
	zb->zb_ditto_same_ms++;
	}
	break;
	case 3:
	equal = (DVA_GET_VDEV(&bp->blk_dva[0]) ==
	DVA_GET_VDEV(&bp->blk_dva[1])) +
	(DVA_GET_VDEV(&bp->blk_dva[0]) ==
	DVA_GET_VDEV(&bp->blk_dva[2])) +
	(DVA_GET_VDEV(&bp->blk_dva[1]) ==
	DVA_GET_VDEV(&bp->blk_dva[2]));
	if (equal != 0) {
	zb->zb_ditto_samevdev++;

	if (DVA_GET_VDEV(&bp->blk_dva[0]) ==
	DVA_GET_VDEV(&bp->blk_dva[1]) &&
	same_metaslab(zcb->zcb_spa,
	DVA_GET_VDEV(&bp->blk_dva[0]),
	DVA_GET_OFFSET(&bp->blk_dva[0]),
	DVA_GET_OFFSET(&bp->blk_dva[1])))
	zb->zb_ditto_same_ms++;
	else if (DVA_GET_VDEV(&bp->blk_dva[0]) ==
	DVA_GET_VDEV(&bp->blk_dva[2]) &&
	same_metaslab(zcb->zcb_spa,
	DVA_GET_VDEV(&bp->blk_dva[0]),
	DVA_GET_OFFSET(&bp->blk_dva[0]),
	DVA_GET_OFFSET(&bp->blk_dva[2])))
	zb->zb_ditto_same_ms++;
	else if (DVA_GET_VDEV(&bp->blk_dva[1]) ==
	DVA_GET_VDEV(&bp->blk_dva[2]) &&
	same_metaslab(zcb->zcb_spa,
	DVA_GET_VDEV(&bp->blk_dva[1]),
	DVA_GET_OFFSET(&bp->blk_dva[1]),
	DVA_GET_OFFSET(&bp->blk_dva[2])))
	zb->zb_ditto_same_ms++;
	}
	break;
	}
	}

	spa_config_exit(zcb->zcb_spa, SCL_CONFIG, FTAG);

	if (BP_IS_EMBEDDED(bp)) {
	zcb->zcb_embedded_blocks[BPE_GET_ETYPE(bp)]++;
	zcb->zcb_embedded_histogram[BPE_GET_ETYPE(bp)]
	[BPE_GET_PSIZE(bp)]++;
	return;
	}
	/*
	* The binning histogram bins by powers of two up to
	* SPA_MAXBLOCKSIZE rather than creating bins for
	* every possible blocksize found in the pool.
	*/
	int bin = highbit64(BP_GET_PSIZE(bp)) - 1;

	zcb->zcb_psize_count[bin]++;
	zcb->zcb_psize_len[bin] += BP_GET_PSIZE(bp);
	zcb->zcb_psize_total += BP_GET_PSIZE(bp);

	bin = highbit64(BP_GET_LSIZE(bp)) - 1;

	zcb->zcb_lsize_count[bin]++;
	zcb->zcb_lsize_len[bin] += BP_GET_LSIZE(bp);
	zcb->zcb_lsize_total += BP_GET_LSIZE(bp);

	bin = highbit64(BP_GET_ASIZE(bp)) - 1;

	zcb->zcb_asize_count[bin]++;
	zcb->zcb_asize_len[bin] += BP_GET_ASIZE(bp);
	zcb->zcb_asize_total += BP_GET_ASIZE(bp);

	if (dump_opt['L'])
	return;

	if (BP_GET_DEDUP(bp)) {
	ddt_t *ddt;
	ddt_entry_t *dde;

	ddt = ddt_select(zcb->zcb_spa, bp);
	ddt_enter(ddt);
	dde = ddt_lookup(ddt, bp, B_FALSE);

	if (dde == NULL) {
	refcnt = 0;
	} else {
	ddt_phys_t *ddp = ddt_phys_select(dde, bp);
	ddt_phys_decref(ddp);
	refcnt = ddp->ddp_refcnt;
	if (ddt_phys_total_refcnt(dde) == 0)
	ddt_remove(ddt, dde);
	}
	ddt_exit(ddt);
	}

	VERIFY3U(zio_wait(zio_claim(NULL, zcb->zcb_spa,
	refcnt ? 0 : spa_min_claim_txg(zcb->zcb_spa),
	bp, NULL, NULL, ZIO_FLAG_CANFAIL)), ==, 0);
	}

	static void
	zdb_blkptr_done(zio_t *zio)
	{
	spa_t *spa = zio->io_spa;
	blkptr_t *bp = zio->io_bp;
	int ioerr = zio->io_error;
	zdb_cb_t *zcb = zio->io_private;
	zbookmark_phys_t *zb = &zio->io_bookmark;

	mutex_enter(&spa->spa_scrub_lock);
	spa->spa_load_verify_bytes -= BP_GET_PSIZE(bp);
	cv_broadcast(&spa->spa_scrub_io_cv);

	if (ioerr && !(zio->io_flags & ZIO_FLAG_SPECULATIVE)) {
	char blkbuf[BP_SPRINTF_LEN];

	zcb->zcb_haderrors = 1;
	zcb->zcb_errors[ioerr]++;

	if (dump_opt['b'] >= 2)
	snprintf_blkptr(blkbuf, sizeof (blkbuf), bp);
	else
	blkbuf[0] = '\0';

	(void) printf("zdb_blkptr_cb: "
	"Got error %d reading "
	"<%llu, %llu, %lld, %llx> %s -- skipping\n",
	ioerr,
	(u_longlong_t)zb->zb_objset,
	(u_longlong_t)zb->zb_object,
	(u_longlong_t)zb->zb_level,
	(u_longlong_t)zb->zb_blkid,
	blkbuf);
	}
	mutex_exit(&spa->spa_scrub_lock);

	abd_free(zio->io_abd);
	}

	static int
	zdb_blkptr_cb(spa_t spa, zilog_t zilog, const blkptr_t *bp,
	const zbookmark_phys_t zb, const dnode_phys_t dnp, void *arg)
	{
	zdb_cb_t *zcb = arg;
	dmu_object_type_t type;
	boolean_t is_metadata;

	if (zb->zb_level == ZB_DNODE_LEVEL)
	return (0);

	if (dump_opt['b'] >= 5 && bp->blk_birth > 0) {
	char blkbuf[BP_SPRINTF_LEN];
	snprintf_blkptr(blkbuf, sizeof (blkbuf), bp);
	(void) printf("objset %llu object %llu "
	"level %lld offset 0x%llx %s\n",
	(u_longlong_t)zb->zb_objset,
	(u_longlong_t)zb->zb_object,
	(longlong_t)zb->zb_level,
	(u_longlong_t)blkid2offset(dnp, bp, zb),
	blkbuf);
	}

	if (BP_IS_HOLE(bp) \|\| BP_IS_REDACTED(bp))
	return (0);

	type = BP_GET_TYPE(bp);

	zdb_count_block(zcb, zilog, bp,
	(type & DMU_OT_NEWTYPE) ? ZDB_OT_OTHER : type);

	is_metadata = (BP_GET_LEVEL(bp) != 0 \|\| DMU_OT_IS_METADATA(type));

	if (!BP_IS_EMBEDDED(bp) &&
	(dump_opt['c'] > 1 \|\| (dump_opt['c'] && is_metadata))) {
	size_t size = BP_GET_PSIZE(bp);
	abd_t *abd = abd_alloc(size, B_FALSE);
	int flags = ZIO_FLAG_CANFAIL \| ZIO_FLAG_SCRUB \| ZIO_FLAG_RAW;

	/* If it's an intent log block, failure is expected. */
	if (zb->zb_level == ZB_ZIL_LEVEL)
	flags \|= ZIO_FLAG_SPECULATIVE;

	mutex_enter(&spa->spa_scrub_lock);
	while (spa->spa_load_verify_bytes > max_inflight_bytes)
	cv_wait(&spa->spa_scrub_io_cv, &spa->spa_scrub_lock);
	spa->spa_load_verify_bytes += size;
	mutex_exit(&spa->spa_scrub_lock);

	zio_nowait(zio_read(NULL, spa, bp, abd, size,
	zdb_blkptr_done, zcb, ZIO_PRIORITY_ASYNC_READ, flags, zb));
	}

	zcb->zcb_readfails = 0;

	/* only call gethrtime() every 100 blocks */
	static int iters;
	if (++iters > 100)
	iters = 0;
	else
	return (0);

	if (dump_opt['b'] < 5 && gethrtime() > zcb->zcb_lastprint + NANOSEC) {
	uint64_t now = gethrtime();
	char buf[10];
	uint64_t bytes = zcb->zcb_type[ZB_TOTAL][ZDB_OT_TOTAL].zb_asize;
	int kb_per_sec =
	1 + bytes / (1 + ((now - zcb->zcb_start) / 1000 / 1000));
	int sec_remaining =
	(zcb->zcb_totalasize - bytes) / 1024 / kb_per_sec;

	/* make sure nicenum has enough space */
	CTASSERT(sizeof (buf) >= NN_NUMBUF_SZ);

	zfs_nicebytes(bytes, buf, sizeof (buf));
	(void) fprintf(stderr,
	"\r%5s completed (%4dMB/s) "
	"estimated time remaining: %uhr %02umin %02usec ",
	buf, kb_per_sec / 1024,
	sec_remaining / 60 / 60,
	sec_remaining / 60 % 60,
	sec_remaining % 60);

	zcb->zcb_lastprint = now;
	}

	return (0);
	}

	static void
	zdb_leak(void *arg, uint64_t start, uint64_t size)
	{
	vdev_t *vd = arg;

	(void) printf("leaked space: vdev %llu, offset 0x%llx, size %llu\n",
	(u_longlong_t)vd->vdev_id, (u_longlong_t)start, (u_longlong_t)size);
	}

	static metaslab_ops_t zdb_metaslab_ops = {
	NULL /* alloc */
	};

	/* ARGSUSED */
	static int
	load_unflushed_svr_segs_cb(spa_t spa, space_map_entry_t sme,
	uint64_t txg, void *arg)
	{
	spa_vdev_removal_t *svr = arg;

	uint64_t offset = sme->sme_offset;
	uint64_t size = sme->sme_run;

	/* skip vdevs we don't care about */
	if (sme->sme_vdev != svr->svr_vdev_id)
	return (0);

	vdev_t *vd = vdev_lookup_top(spa, sme->sme_vdev);
	metaslab_t *ms = vd->vdev_ms[offset >> vd->vdev_ms_shift];
	ASSERT(sme->sme_type == SM_ALLOC \|\| sme->sme_type == SM_FREE);

	if (txg < metaslab_unflushed_txg(ms))
	return (0);

	if (sme->sme_type == SM_ALLOC)
	range_tree_add(svr->svr_allocd_segs, offset, size);
	else
	range_tree_remove(svr->svr_allocd_segs, offset, size);

	return (0);
	}

	/* ARGSUSED */
	static void
	claim_segment_impl_cb(uint64_t inner_offset, vdev_t *vd, uint64_t offset,
	uint64_t size, void *arg)
	{
	/*
	* This callback was called through a remap from
	* a device being removed. Therefore, the vdev that
	* this callback is applied to is a concrete
	* vdev.
	*/
	ASSERT(vdev_is_concrete(vd));

	VERIFY0(metaslab_claim_impl(vd, offset, size,
	spa_min_claim_txg(vd->vdev_spa)));
	}

	static void
	claim_segment_cb(void *arg, uint64_t offset, uint64_t size)
	{
	vdev_t *vd = arg;

	vdev_indirect_ops.vdev_op_remap(vd, offset, size,
	claim_segment_impl_cb, NULL);
	}

	/*
	* After accounting for all allocated blocks that are directly referenced,
	* we might have missed a reference to a block from a partially complete
	* (and thus unused) indirect mapping object. We perform a secondary pass
	* through the metaslabs we have already mapped and claim the destination
	* blocks.
	*/
	static void
	zdb_claim_removing(spa_t spa, zdb_cb_t zcb)
	{
	if (dump_opt['L'])
	return;

	if (spa->spa_vdev_removal == NULL)
	return;

	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);

	spa_vdev_removal_t *svr = spa->spa_vdev_removal;
	vdev_t *vd = vdev_lookup_top(spa, svr->svr_vdev_id);
	vdev_indirect_mapping_t *vim = vd->vdev_indirect_mapping;

	ASSERT0(range_tree_space(svr->svr_allocd_segs));

	range_tree_t *allocs = range_tree_create(NULL, RANGE_SEG64, NULL, 0, 0);
	for (uint64_t msi = 0; msi < vd->vdev_ms_count; msi++) {
	metaslab_t *msp = vd->vdev_ms[msi];

	ASSERT0(range_tree_space(allocs));
	if (msp->ms_sm != NULL)
	VERIFY0(space_map_load(msp->ms_sm, allocs, SM_ALLOC));
	range_tree_vacate(allocs, range_tree_add, svr->svr_allocd_segs);
	}
	range_tree_destroy(allocs);

	iterate_through_spacemap_logs(spa, load_unflushed_svr_segs_cb, svr);

	/*
	* Clear everything past what has been synced,
	* because we have not allocated mappings for
	* it yet.
	*/
	range_tree_clear(svr->svr_allocd_segs,
	vdev_indirect_mapping_max_offset(vim),
	vd->vdev_asize - vdev_indirect_mapping_max_offset(vim));

	zcb->zcb_removing_size += range_tree_space(svr->svr_allocd_segs);
	range_tree_vacate(svr->svr_allocd_segs, claim_segment_cb, vd);

	spa_config_exit(spa, SCL_CONFIG, FTAG);
	}

	/* ARGSUSED */
	static int
	increment_indirect_mapping_cb(void arg, const blkptr_t bp, boolean_t bp_freed,
	dmu_tx_t *tx)
	{
	zdb_cb_t *zcb = arg;
	spa_t *spa = zcb->zcb_spa;
	vdev_t *vd;
	const dva_t *dva = &bp->blk_dva[0];

	ASSERT(!bp_freed);
	ASSERT(!dump_opt['L']);
	ASSERT3U(BP_GET_NDVAS(bp), ==, 1);

	spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER);
	vd = vdev_lookup_top(zcb->zcb_spa, DVA_GET_VDEV(dva));
	ASSERT3P(vd, !=, NULL);
	spa_config_exit(spa, SCL_VDEV, FTAG);

	ASSERT(vd->vdev_indirect_config.vic_mapping_object != 0);
	ASSERT3P(zcb->zcb_vd_obsolete_counts[vd->vdev_id], !=, NULL);

	vdev_indirect_mapping_increment_obsolete_count(
	vd->vdev_indirect_mapping,
	DVA_GET_OFFSET(dva), DVA_GET_ASIZE(dva),
	zcb->zcb_vd_obsolete_counts[vd->vdev_id]);

	return (0);
	}

	static uint32_t *
	zdb_load_obsolete_counts(vdev_t *vd)
	{
	vdev_indirect_mapping_t *vim = vd->vdev_indirect_mapping;
	spa_t *spa = vd->vdev_spa;
	spa_condensing_indirect_phys_t *scip =
	&spa->spa_condensing_indirect_phys;
	uint64_t obsolete_sm_object;
	uint32_t *counts;

	VERIFY0(vdev_obsolete_sm_object(vd, &obsolete_sm_object));
	EQUIV(obsolete_sm_object != 0, vd->vdev_obsolete_sm != NULL);
	counts = vdev_indirect_mapping_load_obsolete_counts(vim);
	if (vd->vdev_obsolete_sm != NULL) {
	vdev_indirect_mapping_load_obsolete_spacemap(vim, counts,
	vd->vdev_obsolete_sm);
	}
	if (scip->scip_vdev == vd->vdev_id &&
	scip->scip_prev_obsolete_sm_object != 0) {
	space_map_t *prev_obsolete_sm = NULL;
	VERIFY0(space_map_open(&prev_obsolete_sm, spa->spa_meta_objset,
	scip->scip_prev_obsolete_sm_object, 0, vd->vdev_asize, 0));
	vdev_indirect_mapping_load_obsolete_spacemap(vim, counts,
	prev_obsolete_sm);
	space_map_close(prev_obsolete_sm);
	}
	return (counts);
	}

	static void
	zdb_ddt_leak_init(spa_t spa, zdb_cb_t zcb)
	{
	ddt_bookmark_t ddb;
	ddt_entry_t dde;
	int error;
	int p;

	ASSERT(!dump_opt['L']);

	bzero(&ddb, sizeof (ddb));
	while ((error = ddt_walk(spa, &ddb, &dde)) == 0) {
	blkptr_t blk;
	ddt_phys_t *ddp = dde.dde_phys;

	if (ddb.ddb_class == DDT_CLASS_UNIQUE)
	return;

	ASSERT(ddt_phys_total_refcnt(&dde) > 1);

	for (p = 0; p < DDT_PHYS_TYPES; p++, ddp++) {
	if (ddp->ddp_phys_birth == 0)
	continue;
	ddt_bp_create(ddb.ddb_checksum,
	&dde.dde_key, ddp, &blk);
	if (p == DDT_PHYS_DITTO) {
	zdb_count_block(zcb, NULL, &blk, ZDB_OT_DITTO);
	} else {
	zcb->zcb_dedup_asize +=
	BP_GET_ASIZE(&blk) * (ddp->ddp_refcnt - 1);
	zcb->zcb_dedup_blocks++;
	}
	}
	ddt_t *ddt = spa->spa_ddt[ddb.ddb_checksum];
	ddt_enter(ddt);
	VERIFY(ddt_lookup(ddt, &blk, B_TRUE) != NULL);
	ddt_exit(ddt);
	}

	ASSERT(error == ENOENT);
	}

	typedef struct checkpoint_sm_exclude_entry_arg {
	vdev_t *cseea_vd;
	uint64_t cseea_checkpoint_size;
	} checkpoint_sm_exclude_entry_arg_t;

	static int
	checkpoint_sm_exclude_entry_cb(space_map_entry_t sme, void arg)
	{
	checkpoint_sm_exclude_entry_arg_t *cseea = arg;
	vdev_t *vd = cseea->cseea_vd;
	metaslab_t *ms = vd->vdev_ms[sme->sme_offset >> vd->vdev_ms_shift];
	uint64_t end = sme->sme_offset + sme->sme_run;

	ASSERT(sme->sme_type == SM_FREE);

	/*
	* Since the vdev_checkpoint_sm exists in the vdev level
	* and the ms_sm space maps exist in the metaslab level,
	* an entry in the checkpoint space map could theoretically
	* cross the boundaries of the metaslab that it belongs.
	*
	* In reality, because of the way that we populate and
	* manipulate the checkpoint's space maps currently,
	* there shouldn't be any entries that cross metaslabs.
	* Hence the assertion below.
	*
	* That said, there is no fundamental requirement that
	* the checkpoint's space map entries should not cross
	* metaslab boundaries. So if needed we could add code
	* that handles metaslab-crossing segments in the future.
	*/
	VERIFY3U(sme->sme_offset, >=, ms->ms_start);
	VERIFY3U(end, <=, ms->ms_start + ms->ms_size);

	/*
	* By removing the entry from the allocated segments we
	* also verify that the entry is there to begin with.
	*/
	mutex_enter(&ms->ms_lock);
	range_tree_remove(ms->ms_allocatable, sme->sme_offset, sme->sme_run);
	mutex_exit(&ms->ms_lock);

	cseea->cseea_checkpoint_size += sme->sme_run;
	return (0);
	}

	static void
	zdb_leak_init_vdev_exclude_checkpoint(vdev_t vd, zdb_cb_t zcb)
	{
	spa_t *spa = vd->vdev_spa;
	space_map_t *checkpoint_sm = NULL;
	uint64_t checkpoint_sm_obj;

	/*
	* If there is no vdev_top_zap, we are in a pool whose
	* version predates the pool checkpoint feature.
	*/
	if (vd->vdev_top_zap == 0)
	return;

	/*
	* If there is no reference of the vdev_checkpoint_sm in
	* the vdev_top_zap, then one of the following scenarios
	* is true:
	*
	* 1] There is no checkpoint
	* 2] There is a checkpoint, but no checkpointed blocks
	* have been freed yet
	* 3] The current vdev is indirect
	*
	* In these cases we return immediately.
	*/
	if (zap_contains(spa_meta_objset(spa), vd->vdev_top_zap,
	VDEV_TOP_ZAP_POOL_CHECKPOINT_SM) != 0)
	return;

	VERIFY0(zap_lookup(spa_meta_objset(spa), vd->vdev_top_zap,
	VDEV_TOP_ZAP_POOL_CHECKPOINT_SM, sizeof (uint64_t), 1,
	&checkpoint_sm_obj));

	checkpoint_sm_exclude_entry_arg_t cseea;
	cseea.cseea_vd = vd;
	cseea.cseea_checkpoint_size = 0;

	VERIFY0(space_map_open(&checkpoint_sm, spa_meta_objset(spa),
	checkpoint_sm_obj, 0, vd->vdev_asize, vd->vdev_ashift));

	VERIFY0(space_map_iterate(checkpoint_sm,
	space_map_length(checkpoint_sm),
	checkpoint_sm_exclude_entry_cb, &cseea));
	space_map_close(checkpoint_sm);

	zcb->zcb_checkpoint_size += cseea.cseea_checkpoint_size;
	}

	static void
	zdb_leak_init_exclude_checkpoint(spa_t spa, zdb_cb_t zcb)
	{
	ASSERT(!dump_opt['L']);

	vdev_t *rvd = spa->spa_root_vdev;
	for (uint64_t c = 0; c < rvd->vdev_children; c++) {
	ASSERT3U(c, ==, rvd->vdev_child[c]->vdev_id);
	zdb_leak_init_vdev_exclude_checkpoint(rvd->vdev_child[c], zcb);
	}
	}

	static int
	count_unflushed_space_cb(spa_t spa, space_map_entry_t sme,
	uint64_t txg, void *arg)
	{
	int64_t *ualloc_space = arg;

	uint64_t offset = sme->sme_offset;
	uint64_t vdev_id = sme->sme_vdev;

	vdev_t *vd = vdev_lookup_top(spa, vdev_id);
	if (!vdev_is_concrete(vd))
	return (0);

	metaslab_t *ms = vd->vdev_ms[offset >> vd->vdev_ms_shift];
	ASSERT(sme->sme_type == SM_ALLOC \|\| sme->sme_type == SM_FREE);

	if (txg < metaslab_unflushed_txg(ms))
	return (0);

	if (sme->sme_type == SM_ALLOC)
	*ualloc_space += sme->sme_run;
	else
	*ualloc_space -= sme->sme_run;

	return (0);
	}

	static int64_t
	get_unflushed_alloc_space(spa_t *spa)
	{
	if (dump_opt['L'])
	return (0);

	int64_t ualloc_space = 0;
	iterate_through_spacemap_logs(spa, count_unflushed_space_cb,
	&ualloc_space);
	return (ualloc_space);
	}

	static int
	load_unflushed_cb(spa_t spa, space_map_entry_t sme, uint64_t txg, void *arg)
	{
	maptype_t *uic_maptype = arg;

	uint64_t offset = sme->sme_offset;
	uint64_t size = sme->sme_run;
	uint64_t vdev_id = sme->sme_vdev;

	vdev_t *vd = vdev_lookup_top(spa, vdev_id);

	/* skip indirect vdevs */
	if (!vdev_is_concrete(vd))
	return (0);

	metaslab_t *ms = vd->vdev_ms[offset >> vd->vdev_ms_shift];

	ASSERT(sme->sme_type == SM_ALLOC \|\| sme->sme_type == SM_FREE);
	ASSERT(uic_maptype == SM_ALLOC \|\| uic_maptype == SM_FREE);

	if (txg < metaslab_unflushed_txg(ms))
	return (0);

	if (*uic_maptype == sme->sme_type)
	range_tree_add(ms->ms_allocatable, offset, size);
	else
	range_tree_remove(ms->ms_allocatable, offset, size);

	return (0);
	}

	static void
	load_unflushed_to_ms_allocatables(spa_t *spa, maptype_t maptype)
	{
	iterate_through_spacemap_logs(spa, load_unflushed_cb, &maptype);
	}

	static void
	load_concrete_ms_allocatable_trees(spa_t *spa, maptype_t maptype)
	{
	vdev_t *rvd = spa->spa_root_vdev;
	for (uint64_t i = 0; i < rvd->vdev_children; i++) {
	vdev_t *vd = rvd->vdev_child[i];

	ASSERT3U(i, ==, vd->vdev_id);

	if (vd->vdev_ops == &vdev_indirect_ops)
	continue;

	for (uint64_t m = 0; m < vd->vdev_ms_count; m++) {
	metaslab_t *msp = vd->vdev_ms[m];

	(void) fprintf(stderr,
	"\rloading concrete vdev %llu, "
	"metaslab %llu of %llu ...",
	(longlong_t)vd->vdev_id,
	(longlong_t)msp->ms_id,
	(longlong_t)vd->vdev_ms_count);

	mutex_enter(&msp->ms_lock);
	range_tree_vacate(msp->ms_allocatable, NULL, NULL);

	/*
	* We don't want to spend the CPU manipulating the
	* size-ordered tree, so clear the range_tree ops.
	*/
	msp->ms_allocatable->rt_ops = NULL;

	if (msp->ms_sm != NULL) {
	VERIFY0(space_map_load(msp->ms_sm,
	msp->ms_allocatable, maptype));
	}
	if (!msp->ms_loaded)
	msp->ms_loaded = B_TRUE;
	mutex_exit(&msp->ms_lock);
	}
	}

	load_unflushed_to_ms_allocatables(spa, maptype);
	}

	/*
	* vm_idxp is an in-out parameter which (for indirect vdevs) is the
	* index in vim_entries that has the first entry in this metaslab.
	* On return, it will be set to the first entry after this metaslab.
	*/
	static void
	load_indirect_ms_allocatable_tree(vdev_t vd, metaslab_t msp,
	uint64_t *vim_idxp)
	{
	vdev_indirect_mapping_t *vim = vd->vdev_indirect_mapping;

	mutex_enter(&msp->ms_lock);
	range_tree_vacate(msp->ms_allocatable, NULL, NULL);

	/*
	* We don't want to spend the CPU manipulating the
	* size-ordered tree, so clear the range_tree ops.
	*/
	msp->ms_allocatable->rt_ops = NULL;

	for (; *vim_idxp < vdev_indirect_mapping_num_entries(vim);
	(*vim_idxp)++) {
	vdev_indirect_mapping_entry_phys_t *vimep =
	&vim->vim_entries[*vim_idxp];
	uint64_t ent_offset = DVA_MAPPING_GET_SRC_OFFSET(vimep);
	uint64_t ent_len = DVA_GET_ASIZE(&vimep->vimep_dst);
	ASSERT3U(ent_offset, >=, msp->ms_start);
	if (ent_offset >= msp->ms_start + msp->ms_size)
	break;

	/*
	* Mappings do not cross metaslab boundaries,
	* because we create them by walking the metaslabs.
	*/
	ASSERT3U(ent_offset + ent_len, <=,
	msp->ms_start + msp->ms_size);
	range_tree_add(msp->ms_allocatable, ent_offset, ent_len);
	}

	if (!msp->ms_loaded)
	msp->ms_loaded = B_TRUE;
	mutex_exit(&msp->ms_lock);
	}

	static void
	zdb_leak_init_prepare_indirect_vdevs(spa_t spa, zdb_cb_t zcb)
	{
	ASSERT(!dump_opt['L']);

	vdev_t *rvd = spa->spa_root_vdev;
	for (uint64_t c = 0; c < rvd->vdev_children; c++) {
	vdev_t *vd = rvd->vdev_child[c];

	ASSERT3U(c, ==, vd->vdev_id);

	if (vd->vdev_ops != &vdev_indirect_ops)
	continue;

	/*
	* Note: we don't check for mapping leaks on
	* removing vdevs because their ms_allocatable's
	* are used to look for leaks in allocated space.
	*/
	zcb->zcb_vd_obsolete_counts[c] = zdb_load_obsolete_counts(vd);

	/*
	* Normally, indirect vdevs don't have any
	* metaslabs. We want to set them up for
	* zio_claim().
	*/
	vdev_metaslab_group_create(vd);
	VERIFY0(vdev_metaslab_init(vd, 0));

	- vdev_indirect_mapping_t *vim = vd->vdev_indirect_mapping;
	+ vdev_indirect_mapping_t *vim __maybe_unused =
	+ vd->vdev_indirect_mapping;
	uint64_t vim_idx = 0;
	for (uint64_t m = 0; m < vd->vdev_ms_count; m++) {

	(void) fprintf(stderr,
	"\rloading indirect vdev %llu, "
	"metaslab %llu of %llu ...",
	(longlong_t)vd->vdev_id,
	(longlong_t)vd->vdev_ms[m]->ms_id,
	(longlong_t)vd->vdev_ms_count);

	load_indirect_ms_allocatable_tree(vd, vd->vdev_ms[m],
	&vim_idx);
	}
	ASSERT3U(vim_idx, ==, vdev_indirect_mapping_num_entries(vim));
	}
	}

	static void
	zdb_leak_init(spa_t spa, zdb_cb_t zcb)
	{
	zcb->zcb_spa = spa;

	if (dump_opt['L'])
	return;

	dsl_pool_t *dp = spa->spa_dsl_pool;
	vdev_t *rvd = spa->spa_root_vdev;

	/*
	* We are going to be changing the meaning of the metaslab's
	* ms_allocatable. Ensure that the allocator doesn't try to
	* use the tree.
	*/
	spa->spa_normal_class->mc_ops = &zdb_metaslab_ops;
	spa->spa_log_class->mc_ops = &zdb_metaslab_ops;
	spa->spa_embedded_log_class->mc_ops = &zdb_metaslab_ops;

	zcb->zcb_vd_obsolete_counts =
	umem_zalloc(rvd->vdev_children * sizeof (uint32_t *),
	UMEM_NOFAIL);

	/*
	* For leak detection, we overload the ms_allocatable trees
	* to contain allocated segments instead of free segments.
	* As a result, we can't use the normal metaslab_load/unload
	* interfaces.
	*/
	zdb_leak_init_prepare_indirect_vdevs(spa, zcb);
	load_concrete_ms_allocatable_trees(spa, SM_ALLOC);

	/*
	* On load_concrete_ms_allocatable_trees() we loaded all the
	* allocated entries from the ms_sm to the ms_allocatable for
	* each metaslab. If the pool has a checkpoint or is in the
	* middle of discarding a checkpoint, some of these blocks
	* may have been freed but their ms_sm may not have been
	* updated because they are referenced by the checkpoint. In
	* order to avoid false-positives during leak-detection, we
	* go through the vdev's checkpoint space map and exclude all
	* its entries from their relevant ms_allocatable.
	*
	* We also aggregate the space held by the checkpoint and add
	* it to zcb_checkpoint_size.
	*
	* Note that at this point we are also verifying that all the
	* entries on the checkpoint_sm are marked as allocated in
	* the ms_sm of their relevant metaslab.
	* [see comment in checkpoint_sm_exclude_entry_cb()]
	*/
	zdb_leak_init_exclude_checkpoint(spa, zcb);
	ASSERT3U(zcb->zcb_checkpoint_size, ==, spa_get_checkpoint_space(spa));

	/* for cleaner progress output */
	(void) fprintf(stderr, "\n");

	if (bpobj_is_open(&dp->dp_obsolete_bpobj)) {
	ASSERT(spa_feature_is_enabled(spa,
	SPA_FEATURE_DEVICE_REMOVAL));
	(void) bpobj_iterate_nofree(&dp->dp_obsolete_bpobj,
	increment_indirect_mapping_cb, zcb, NULL);
	}

	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
	zdb_ddt_leak_init(spa, zcb);
	spa_config_exit(spa, SCL_CONFIG, FTAG);
	}

	static boolean_t
	zdb_check_for_obsolete_leaks(vdev_t vd, zdb_cb_t zcb)
	{
	boolean_t leaks = B_FALSE;
	vdev_indirect_mapping_t *vim = vd->vdev_indirect_mapping;
	uint64_t total_leaked = 0;
	boolean_t are_precise = B_FALSE;

	ASSERT(vim != NULL);

	for (uint64_t i = 0; i < vdev_indirect_mapping_num_entries(vim); i++) {
	vdev_indirect_mapping_entry_phys_t *vimep =
	&vim->vim_entries[i];
	uint64_t obsolete_bytes = 0;
	uint64_t offset = DVA_MAPPING_GET_SRC_OFFSET(vimep);
	metaslab_t *msp = vd->vdev_ms[offset >> vd->vdev_ms_shift];

	/*
	* This is not very efficient but it's easy to
	* verify correctness.
	*/
	for (uint64_t inner_offset = 0;
	inner_offset < DVA_GET_ASIZE(&vimep->vimep_dst);
	inner_offset += 1 << vd->vdev_ashift) {
	if (range_tree_contains(msp->ms_allocatable,
	offset + inner_offset, 1 << vd->vdev_ashift)) {
	obsolete_bytes += 1 << vd->vdev_ashift;
	}
	}

	int64_t bytes_leaked = obsolete_bytes -
	zcb->zcb_vd_obsolete_counts[vd->vdev_id][i];
	ASSERT3U(DVA_GET_ASIZE(&vimep->vimep_dst), >=,
	zcb->zcb_vd_obsolete_counts[vd->vdev_id][i]);

	VERIFY0(vdev_obsolete_counts_are_precise(vd, &are_precise));
	if (bytes_leaked != 0 && (are_precise \|\| dump_opt['d'] >= 5)) {
	(void) printf("obsolete indirect mapping count "
	"mismatch on %llu:%llx:%llx : %llx bytes leaked\n",
	(u_longlong_t)vd->vdev_id,
	(u_longlong_t)DVA_MAPPING_GET_SRC_OFFSET(vimep),
	(u_longlong_t)DVA_GET_ASIZE(&vimep->vimep_dst),
	(u_longlong_t)bytes_leaked);
	}
	total_leaked += ABS(bytes_leaked);
	}

	VERIFY0(vdev_obsolete_counts_are_precise(vd, &are_precise));
	if (!are_precise && total_leaked > 0) {
	int pct_leaked = total_leaked * 100 /
	vdev_indirect_mapping_bytes_mapped(vim);
	(void) printf("cannot verify obsolete indirect mapping "
	"counts of vdev %llu because precise feature was not "
	"enabled when it was removed: %d%% (%llx bytes) of mapping"
	"unreferenced\n",
	(u_longlong_t)vd->vdev_id, pct_leaked,
	(u_longlong_t)total_leaked);
	} else if (total_leaked > 0) {
	(void) printf("obsolete indirect mapping count mismatch "
	"for vdev %llu -- %llx total bytes mismatched\n",
	(u_longlong_t)vd->vdev_id,
	(u_longlong_t)total_leaked);
	leaks \|= B_TRUE;
	}

	vdev_indirect_mapping_free_obsolete_counts(vim,
	zcb->zcb_vd_obsolete_counts[vd->vdev_id]);
	zcb->zcb_vd_obsolete_counts[vd->vdev_id] = NULL;

	return (leaks);
	}

	static boolean_t
	zdb_leak_fini(spa_t spa, zdb_cb_t zcb)
	{
	if (dump_opt['L'])
	return (B_FALSE);

	boolean_t leaks = B_FALSE;
	vdev_t *rvd = spa->spa_root_vdev;
	for (unsigned c = 0; c < rvd->vdev_children; c++) {
	vdev_t *vd = rvd->vdev_child[c];

	if (zcb->zcb_vd_obsolete_counts[c] != NULL) {
	leaks \|= zdb_check_for_obsolete_leaks(vd, zcb);
	}

	for (uint64_t m = 0; m < vd->vdev_ms_count; m++) {
	metaslab_t *msp = vd->vdev_ms[m];
	ASSERT3P(msp->ms_group, ==, (msp->ms_group->mg_class ==
	spa_embedded_log_class(spa)) ?
	vd->vdev_log_mg : vd->vdev_mg);

	/*
	* ms_allocatable has been overloaded
	* to contain allocated segments. Now that
	* we finished traversing all blocks, any
	* block that remains in the ms_allocatable
	* represents an allocated block that we
	* did not claim during the traversal.
	* Claimed blocks would have been removed
	* from the ms_allocatable. For indirect
	* vdevs, space remaining in the tree
	* represents parts of the mapping that are
	* not referenced, which is not a bug.
	*/
	if (vd->vdev_ops == &vdev_indirect_ops) {
	range_tree_vacate(msp->ms_allocatable,
	NULL, NULL);
	} else {
	range_tree_vacate(msp->ms_allocatable,
	zdb_leak, vd);
	}
	if (msp->ms_loaded) {
	msp->ms_loaded = B_FALSE;
	}
	}
	}

	umem_free(zcb->zcb_vd_obsolete_counts,
	rvd->vdev_children * sizeof (uint32_t *));
	zcb->zcb_vd_obsolete_counts = NULL;

	return (leaks);
	}

	/* ARGSUSED */
	static int
	count_block_cb(void arg, const blkptr_t bp, dmu_tx_t *tx)
	{
	zdb_cb_t *zcb = arg;

	if (dump_opt['b'] >= 5) {
	char blkbuf[BP_SPRINTF_LEN];
	snprintf_blkptr(blkbuf, sizeof (blkbuf), bp);
	(void) printf("[%s] %s\n",
	"deferred free", blkbuf);
	}
	zdb_count_block(zcb, NULL, bp, ZDB_OT_DEFERRED);
	return (0);
	}

	/*
	* Iterate over livelists which have been destroyed by the user but
	* are still present in the MOS, waiting to be freed
	*/
	static void
	iterate_deleted_livelists(spa_t spa, ll_iter_t func, void arg)
	{
	objset_t *mos = spa->spa_meta_objset;
	uint64_t zap_obj;
	int err = zap_lookup(mos, DMU_POOL_DIRECTORY_OBJECT,
	DMU_POOL_DELETED_CLONES, sizeof (uint64_t), 1, &zap_obj);
	if (err == ENOENT)
	return;
	ASSERT0(err);

	zap_cursor_t zc;
	zap_attribute_t attr;
	dsl_deadlist_t ll;
	/* NULL out os prior to dsl_deadlist_open in case it's garbage */
	ll.dl_os = NULL;
	for (zap_cursor_init(&zc, mos, zap_obj);
	zap_cursor_retrieve(&zc, &attr) == 0;
	(void) zap_cursor_advance(&zc)) {
	dsl_deadlist_open(&ll, mos, attr.za_first_integer);
	func(&ll, arg);
	dsl_deadlist_close(&ll);
	}
	zap_cursor_fini(&zc);
	}

	static int
	bpobj_count_block_cb(void arg, const blkptr_t bp, boolean_t bp_freed,
	dmu_tx_t *tx)
	{
	ASSERT(!bp_freed);
	return (count_block_cb(arg, bp, tx));
	}

	static int
	livelist_entry_count_blocks_cb(void args, dsl_deadlist_entry_t dle)
	{
	zdb_cb_t *zbc = args;
	bplist_t blks;
	bplist_create(&blks);
	/* determine which blocks have been alloc'd but not freed */
	VERIFY0(dsl_process_sub_livelist(&dle->dle_bpobj, &blks, NULL, NULL));
	/* count those blocks */
	(void) bplist_iterate(&blks, count_block_cb, zbc, NULL);
	bplist_destroy(&blks);
	return (0);
	}

	static void
	livelist_count_blocks(dsl_deadlist_t ll, void arg)
	{
	dsl_deadlist_iterate(ll, livelist_entry_count_blocks_cb, arg);
	}

	/*
	* Count the blocks in the livelists that have been destroyed by the user
	* but haven't yet been freed.
	*/
	static void
	deleted_livelists_count_blocks(spa_t spa, zdb_cb_t zbc)
	{
	iterate_deleted_livelists(spa, livelist_count_blocks, zbc);
	}

	static void
	dump_livelist_cb(dsl_deadlist_t ll, void arg)
	{
	ASSERT3P(arg, ==, NULL);
	global_feature_count[SPA_FEATURE_LIVELIST]++;
	dump_blkptr_list(ll, "Deleted Livelist");
	dsl_deadlist_iterate(ll, sublivelist_verify_lightweight, NULL);
	}

	/*
	* Print out, register object references to, and increment feature counts for
	* livelists that have been destroyed by the user but haven't yet been freed.
	*/
	static void
	deleted_livelists_dump_mos(spa_t *spa)
	{
	uint64_t zap_obj;
	objset_t *mos = spa->spa_meta_objset;
	int err = zap_lookup(mos, DMU_POOL_DIRECTORY_OBJECT,
	DMU_POOL_DELETED_CLONES, sizeof (uint64_t), 1, &zap_obj);
	if (err == ENOENT)
	return;
	mos_obj_refd(zap_obj);
	iterate_deleted_livelists(spa, dump_livelist_cb, NULL);
	}

	static int
	dump_block_stats(spa_t *spa)
	{
	zdb_cb_t zcb;
	zdb_blkstats_t zb, tzb;
	uint64_t norm_alloc, norm_space, total_alloc, total_found;
	int flags = TRAVERSE_PRE \| TRAVERSE_PREFETCH_METADATA \|
	TRAVERSE_NO_DECRYPT \| TRAVERSE_HARD;
	boolean_t leaks = B_FALSE;
	int e, c, err;
	bp_embedded_type_t i;

	bzero(&zcb, sizeof (zcb));
	(void) printf("\nTraversing all blocks %s%s%s%s%s...\n\n",
	(dump_opt['c'] \|\| !dump_opt['L']) ? "to verify " : "",
	(dump_opt['c'] == 1) ? "metadata " : "",
	dump_opt['c'] ? "checksums " : "",
	(dump_opt['c'] && !dump_opt['L']) ? "and verify " : "",
	!dump_opt['L'] ? "nothing leaked " : "");

	/*
	* When leak detection is enabled we load all space maps as SM_ALLOC
	* maps, then traverse the pool claiming each block we discover. If
	* the pool is perfectly consistent, the segment trees will be empty
	* when we're done. Anything left over is a leak; any block we can't
	* claim (because it's not part of any space map) is a double
	* allocation, reference to a freed block, or an unclaimed log block.
	*
	* When leak detection is disabled (-L option) we still traverse the
	* pool claiming each block we discover, but we skip opening any space
	* maps.
	*/
	bzero(&zcb, sizeof (zdb_cb_t));
	zdb_leak_init(spa, &zcb);

	/*
	* If there's a deferred-free bplist, process that first.
	*/
	(void) bpobj_iterate_nofree(&spa->spa_deferred_bpobj,
	bpobj_count_block_cb, &zcb, NULL);

	if (spa_version(spa) >= SPA_VERSION_DEADLISTS) {
	(void) bpobj_iterate_nofree(&spa->spa_dsl_pool->dp_free_bpobj,
	bpobj_count_block_cb, &zcb, NULL);
	}

	zdb_claim_removing(spa, &zcb);

	if (spa_feature_is_active(spa, SPA_FEATURE_ASYNC_DESTROY)) {
	VERIFY3U(0, ==, bptree_iterate(spa->spa_meta_objset,
	spa->spa_dsl_pool->dp_bptree_obj, B_FALSE, count_block_cb,
	&zcb, NULL));
	}

	deleted_livelists_count_blocks(spa, &zcb);

	if (dump_opt['c'] > 1)
	flags \|= TRAVERSE_PREFETCH_DATA;

	zcb.zcb_totalasize = metaslab_class_get_alloc(spa_normal_class(spa));
	zcb.zcb_totalasize += metaslab_class_get_alloc(spa_special_class(spa));
	zcb.zcb_totalasize += metaslab_class_get_alloc(spa_dedup_class(spa));
	zcb.zcb_totalasize +=
	metaslab_class_get_alloc(spa_embedded_log_class(spa));
	zcb.zcb_start = zcb.zcb_lastprint = gethrtime();
	err = traverse_pool(spa, 0, flags, zdb_blkptr_cb, &zcb);

	/*
	* If we've traversed the data blocks then we need to wait for those
	* I/Os to complete. We leverage "The Godfather" zio to wait on
	* all async I/Os to complete.
	*/
	if (dump_opt['c']) {
	for (c = 0; c < max_ncpus; c++) {
	(void) zio_wait(spa->spa_async_zio_root[c]);
	spa->spa_async_zio_root[c] = zio_root(spa, NULL, NULL,
	ZIO_FLAG_CANFAIL \| ZIO_FLAG_SPECULATIVE \|
	ZIO_FLAG_GODFATHER);
	}
	}
	ASSERT0(spa->spa_load_verify_bytes);

	/*
	* Done after zio_wait() since zcb_haderrors is modified in
	* zdb_blkptr_done()
	*/
	zcb.zcb_haderrors \|= err;

	if (zcb.zcb_haderrors) {
	(void) printf("\nError counts:\n\n");
	(void) printf("\t%5s %s\n", "errno", "count");
	for (e = 0; e < 256; e++) {
	if (zcb.zcb_errors[e] != 0) {
	(void) printf("\t%5d %llu\n",
	e, (u_longlong_t)zcb.zcb_errors[e]);
	}
	}
	}

	/*
	* Report any leaked segments.
	*/
	leaks \|= zdb_leak_fini(spa, &zcb);

	tzb = &zcb.zcb_type[ZB_TOTAL][ZDB_OT_TOTAL];

	norm_alloc = metaslab_class_get_alloc(spa_normal_class(spa));
	norm_space = metaslab_class_get_space(spa_normal_class(spa));

	total_alloc = norm_alloc +
	metaslab_class_get_alloc(spa_log_class(spa)) +
	metaslab_class_get_alloc(spa_embedded_log_class(spa)) +
	metaslab_class_get_alloc(spa_special_class(spa)) +
	metaslab_class_get_alloc(spa_dedup_class(spa)) +
	get_unflushed_alloc_space(spa);
	total_found = tzb->zb_asize - zcb.zcb_dedup_asize +
	zcb.zcb_removing_size + zcb.zcb_checkpoint_size;

	if (total_found == total_alloc && !dump_opt['L']) {
	(void) printf("\n\tNo leaks (block sum matches space"
	" maps exactly)\n");
	} else if (!dump_opt['L']) {
	(void) printf("block traversal size %llu != alloc %llu "
	"(%s %lld)\n",
	(u_longlong_t)total_found,
	(u_longlong_t)total_alloc,
	(dump_opt['L']) ? "unreachable" : "leaked",
	(longlong_t)(total_alloc - total_found));
	leaks = B_TRUE;
	}

	if (tzb->zb_count == 0)
	return (2);

	(void) printf("\n");
	(void) printf("\t%-16s %14llu\n", "bp count:",
	(u_longlong_t)tzb->zb_count);
	(void) printf("\t%-16s %14llu\n", "ganged count:",
	(longlong_t)tzb->zb_gangs);
	(void) printf("\t%-16s %14llu avg: %6llu\n", "bp logical:",
	(u_longlong_t)tzb->zb_lsize,
	(u_longlong_t)(tzb->zb_lsize / tzb->zb_count));
	(void) printf("\t%-16s %14llu avg: %6llu compression: %6.2f\n",
	"bp physical:", (u_longlong_t)tzb->zb_psize,
	(u_longlong_t)(tzb->zb_psize / tzb->zb_count),
	(double)tzb->zb_lsize / tzb->zb_psize);
	(void) printf("\t%-16s %14llu avg: %6llu compression: %6.2f\n",
	"bp allocated:", (u_longlong_t)tzb->zb_asize,
	(u_longlong_t)(tzb->zb_asize / tzb->zb_count),
	(double)tzb->zb_lsize / tzb->zb_asize);
	(void) printf("\t%-16s %14llu ref>1: %6llu deduplication: %6.2f\n",
	"bp deduped:", (u_longlong_t)zcb.zcb_dedup_asize,
	(u_longlong_t)zcb.zcb_dedup_blocks,
	(double)zcb.zcb_dedup_asize / tzb->zb_asize + 1.0);
	(void) printf("\t%-16s %14llu used: %5.2f%%\n", "Normal class:",
	(u_longlong_t)norm_alloc, 100.0 * norm_alloc / norm_space);

	if (spa_special_class(spa)->mc_allocator[0].mca_rotor != NULL) {
	uint64_t alloc = metaslab_class_get_alloc(
	spa_special_class(spa));
	uint64_t space = metaslab_class_get_space(
	spa_special_class(spa));

	(void) printf("\t%-16s %14llu used: %5.2f%%\n",
	"Special class", (u_longlong_t)alloc,
	100.0 * alloc / space);
	}

	if (spa_dedup_class(spa)->mc_allocator[0].mca_rotor != NULL) {
	uint64_t alloc = metaslab_class_get_alloc(
	spa_dedup_class(spa));
	uint64_t space = metaslab_class_get_space(
	spa_dedup_class(spa));

	(void) printf("\t%-16s %14llu used: %5.2f%%\n",
	"Dedup class", (u_longlong_t)alloc,
	100.0 * alloc / space);
	}

	if (spa_embedded_log_class(spa)->mc_allocator[0].mca_rotor != NULL) {
	uint64_t alloc = metaslab_class_get_alloc(
	spa_embedded_log_class(spa));
	uint64_t space = metaslab_class_get_space(
	spa_embedded_log_class(spa));

	(void) printf("\t%-16s %14llu used: %5.2f%%\n",
	"Embedded log class", (u_longlong_t)alloc,
	100.0 * alloc / space);
	}

	for (i = 0; i < NUM_BP_EMBEDDED_TYPES; i++) {
	if (zcb.zcb_embedded_blocks[i] == 0)
	continue;
	(void) printf("\n");
	(void) printf("\tadditional, non-pointer bps of type %u: "
	"%10llu\n",
	i, (u_longlong_t)zcb.zcb_embedded_blocks[i]);

	if (dump_opt['b'] >= 3) {
	(void) printf("\t number of (compressed) bytes: "
	"number of bps\n");
	dump_histogram(zcb.zcb_embedded_histogram[i],
	sizeof (zcb.zcb_embedded_histogram[i]) /
	sizeof (zcb.zcb_embedded_histogram[i][0]), 0);
	}
	}

	if (tzb->zb_ditto_samevdev != 0) {
	(void) printf("\tDittoed blocks on same vdev: %llu\n",
	(longlong_t)tzb->zb_ditto_samevdev);
	}
	if (tzb->zb_ditto_same_ms != 0) {
	(void) printf("\tDittoed blocks in same metaslab: %llu\n",
	(longlong_t)tzb->zb_ditto_same_ms);
	}

	for (uint64_t v = 0; v < spa->spa_root_vdev->vdev_children; v++) {
	vdev_t *vd = spa->spa_root_vdev->vdev_child[v];
	vdev_indirect_mapping_t *vim = vd->vdev_indirect_mapping;

	if (vim == NULL) {
	continue;
	}

	char mem[32];
	zdb_nicenum(vdev_indirect_mapping_num_entries(vim),
	mem, vdev_indirect_mapping_size(vim));

	(void) printf("\tindirect vdev id %llu has %llu segments "
	"(%s in memory)\n",
	(longlong_t)vd->vdev_id,
	(longlong_t)vdev_indirect_mapping_num_entries(vim), mem);
	}

	if (dump_opt['b'] >= 2) {
	int l, t, level;
	(void) printf("\nBlocks\tLSIZE\tPSIZE\tASIZE"
	"\t avg\t comp\t%%Total\tType\n");

	for (t = 0; t <= ZDB_OT_TOTAL; t++) {
	char csize[32], lsize[32], psize[32], asize[32];
	char avg[32], gang[32];
	const char *typename;

	/* make sure nicenum has enough space */
	CTASSERT(sizeof (csize) >= NN_NUMBUF_SZ);
	CTASSERT(sizeof (lsize) >= NN_NUMBUF_SZ);
	CTASSERT(sizeof (psize) >= NN_NUMBUF_SZ);
	CTASSERT(sizeof (asize) >= NN_NUMBUF_SZ);
	CTASSERT(sizeof (avg) >= NN_NUMBUF_SZ);
	CTASSERT(sizeof (gang) >= NN_NUMBUF_SZ);

	if (t < DMU_OT_NUMTYPES)
	typename = dmu_ot[t].ot_name;
	else
	typename = zdb_ot_extname[t - DMU_OT_NUMTYPES];

	if (zcb.zcb_type[ZB_TOTAL][t].zb_asize == 0) {
	(void) printf("%6s\t%5s\t%5s\t%5s"
	"\t%5s\t%5s\t%6s\t%s\n",
	"-",
	"-",
	"-",
	"-",
	"-",
	"-",
	"-",
	typename);
	continue;
	}

	for (l = ZB_TOTAL - 1; l >= -1; l--) {
	level = (l == -1 ? ZB_TOTAL : l);
	zb = &zcb.zcb_type[level][t];

	if (zb->zb_asize == 0)
	continue;

	if (dump_opt['b'] < 3 && level != ZB_TOTAL)
	continue;

	if (level == 0 && zb->zb_asize ==
	zcb.zcb_type[ZB_TOTAL][t].zb_asize)
	continue;

	zdb_nicenum(zb->zb_count, csize,
	sizeof (csize));
	zdb_nicenum(zb->zb_lsize, lsize,
	sizeof (lsize));
	zdb_nicenum(zb->zb_psize, psize,
	sizeof (psize));
	zdb_nicenum(zb->zb_asize, asize,
	sizeof (asize));
	zdb_nicenum(zb->zb_asize / zb->zb_count, avg,
	sizeof (avg));
	zdb_nicenum(zb->zb_gangs, gang, sizeof (gang));

	(void) printf("%6s\t%5s\t%5s\t%5s\t%5s"
	"\t%5.2f\t%6.2f\t",
	csize, lsize, psize, asize, avg,
	(double)zb->zb_lsize / zb->zb_psize,
	100.0 * zb->zb_asize / tzb->zb_asize);

	if (level == ZB_TOTAL)
	(void) printf("%s\n", typename);
	else
	(void) printf(" L%d %s\n",
	level, typename);

	if (dump_opt['b'] >= 3 && zb->zb_gangs > 0) {
	(void) printf("\t number of ganged "
	"blocks: %s\n", gang);
	}

	if (dump_opt['b'] >= 4) {
	(void) printf("psize "
	"(in 512-byte sectors): "
	"number of blocks\n");
	dump_histogram(zb->zb_psize_histogram,
	PSIZE_HISTO_SIZE, 0);
	}
	}
	}

	/* Output a table summarizing block sizes in the pool */
	if (dump_opt['b'] >= 2) {
	dump_size_histograms(&zcb);
	}
	}

	(void) printf("\n");

	if (leaks)
	return (2);

	if (zcb.zcb_haderrors)
	return (3);

	return (0);
	}

	typedef struct zdb_ddt_entry {
	ddt_key_t zdde_key;
	uint64_t zdde_ref_blocks;
	uint64_t zdde_ref_lsize;
	uint64_t zdde_ref_psize;
	uint64_t zdde_ref_dsize;
	avl_node_t zdde_node;
	} zdb_ddt_entry_t;

	/* ARGSUSED */
	static int
	zdb_ddt_add_cb(spa_t spa, zilog_t zilog, const blkptr_t *bp,
	const zbookmark_phys_t zb, const dnode_phys_t dnp, void *arg)
	{
	avl_tree_t *t = arg;
	avl_index_t where;
	zdb_ddt_entry_t *zdde, zdde_search;

	if (zb->zb_level == ZB_DNODE_LEVEL \|\| BP_IS_HOLE(bp) \|\|
	BP_IS_EMBEDDED(bp))
	return (0);

	if (dump_opt['S'] > 1 && zb->zb_level == ZB_ROOT_LEVEL) {
	(void) printf("traversing objset %llu, %llu objects, "
	"%lu blocks so far\n",
	(u_longlong_t)zb->zb_objset,
	(u_longlong_t)BP_GET_FILL(bp),
	avl_numnodes(t));
	}

	if (BP_IS_HOLE(bp) \|\| BP_GET_CHECKSUM(bp) == ZIO_CHECKSUM_OFF \|\|
	BP_GET_LEVEL(bp) > 0 \|\| DMU_OT_IS_METADATA(BP_GET_TYPE(bp)))
	return (0);

	ddt_key_fill(&zdde_search.zdde_key, bp);

	zdde = avl_find(t, &zdde_search, &where);

	if (zdde == NULL) {
	zdde = umem_zalloc(sizeof (*zdde), UMEM_NOFAIL);
	zdde->zdde_key = zdde_search.zdde_key;
	avl_insert(t, zdde, where);
	}

	zdde->zdde_ref_blocks += 1;
	zdde->zdde_ref_lsize += BP_GET_LSIZE(bp);
	zdde->zdde_ref_psize += BP_GET_PSIZE(bp);
	zdde->zdde_ref_dsize += bp_get_dsize_sync(spa, bp);

	return (0);
	}

	static void
	dump_simulated_ddt(spa_t *spa)
	{
	avl_tree_t t;
	void *cookie = NULL;
	zdb_ddt_entry_t *zdde;
	ddt_histogram_t ddh_total;
	ddt_stat_t dds_total;

	bzero(&ddh_total, sizeof (ddh_total));
	bzero(&dds_total, sizeof (dds_total));
	avl_create(&t, ddt_entry_compare,
	sizeof (zdb_ddt_entry_t), offsetof(zdb_ddt_entry_t, zdde_node));

	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);

	(void) traverse_pool(spa, 0, TRAVERSE_PRE \| TRAVERSE_PREFETCH_METADATA \|
	TRAVERSE_NO_DECRYPT, zdb_ddt_add_cb, &t);

	spa_config_exit(spa, SCL_CONFIG, FTAG);

	while ((zdde = avl_destroy_nodes(&t, &cookie)) != NULL) {
	ddt_stat_t dds;
	uint64_t refcnt = zdde->zdde_ref_blocks;
	ASSERT(refcnt != 0);

	dds.dds_blocks = zdde->zdde_ref_blocks / refcnt;
	dds.dds_lsize = zdde->zdde_ref_lsize / refcnt;
	dds.dds_psize = zdde->zdde_ref_psize / refcnt;
	dds.dds_dsize = zdde->zdde_ref_dsize / refcnt;

	dds.dds_ref_blocks = zdde->zdde_ref_blocks;
	dds.dds_ref_lsize = zdde->zdde_ref_lsize;
	dds.dds_ref_psize = zdde->zdde_ref_psize;
	dds.dds_ref_dsize = zdde->zdde_ref_dsize;

	ddt_stat_add(&ddh_total.ddh_stat[highbit64(refcnt) - 1],
	&dds, 0);

	umem_free(zdde, sizeof (*zdde));
	}

	avl_destroy(&t);

	ddt_histogram_stat(&dds_total, &ddh_total);

	(void) printf("Simulated DDT histogram:\n");

	zpool_dump_ddt(&dds_total, &ddh_total);

	dump_dedup_ratio(&dds_total);
	}

	static int
	verify_device_removal_feature_counts(spa_t *spa)
	{
	uint64_t dr_feature_refcount = 0;
	uint64_t oc_feature_refcount = 0;
	uint64_t indirect_vdev_count = 0;
	uint64_t precise_vdev_count = 0;
	uint64_t obsolete_counts_object_count = 0;
	uint64_t obsolete_sm_count = 0;
	uint64_t obsolete_counts_count = 0;
	uint64_t scip_count = 0;
	uint64_t obsolete_bpobj_count = 0;
	int ret = 0;

	spa_condensing_indirect_phys_t *scip =
	&spa->spa_condensing_indirect_phys;
	if (scip->scip_next_mapping_object != 0) {
	vdev_t *vd = spa->spa_root_vdev->vdev_child[scip->scip_vdev];
	ASSERT(scip->scip_prev_obsolete_sm_object != 0);
	ASSERT3P(vd->vdev_ops, ==, &vdev_indirect_ops);

	(void) printf("Condensing indirect vdev %llu: new mapping "
	"object %llu, prev obsolete sm %llu\n",
	(u_longlong_t)scip->scip_vdev,
	(u_longlong_t)scip->scip_next_mapping_object,
	(u_longlong_t)scip->scip_prev_obsolete_sm_object);
	if (scip->scip_prev_obsolete_sm_object != 0) {
	space_map_t *prev_obsolete_sm = NULL;
	VERIFY0(space_map_open(&prev_obsolete_sm,
	spa->spa_meta_objset,
	scip->scip_prev_obsolete_sm_object,
	0, vd->vdev_asize, 0));
	dump_spacemap(spa->spa_meta_objset, prev_obsolete_sm);
	(void) printf("\n");
	space_map_close(prev_obsolete_sm);
	}

	scip_count += 2;
	}

	for (uint64_t i = 0; i < spa->spa_root_vdev->vdev_children; i++) {
	vdev_t *vd = spa->spa_root_vdev->vdev_child[i];
	vdev_indirect_config_t *vic = &vd->vdev_indirect_config;

	if (vic->vic_mapping_object != 0) {
	ASSERT(vd->vdev_ops == &vdev_indirect_ops \|\|
	vd->vdev_removing);
	indirect_vdev_count++;

	if (vd->vdev_indirect_mapping->vim_havecounts) {
	obsolete_counts_count++;
	}
	}

	boolean_t are_precise;
	VERIFY0(vdev_obsolete_counts_are_precise(vd, &are_precise));
	if (are_precise) {
	ASSERT(vic->vic_mapping_object != 0);
	precise_vdev_count++;
	}

	uint64_t obsolete_sm_object;
	VERIFY0(vdev_obsolete_sm_object(vd, &obsolete_sm_object));
	if (obsolete_sm_object != 0) {
	ASSERT(vic->vic_mapping_object != 0);
	obsolete_sm_count++;
	}
	}

	(void) feature_get_refcount(spa,
	&spa_feature_table[SPA_FEATURE_DEVICE_REMOVAL],
	&dr_feature_refcount);
	(void) feature_get_refcount(spa,
	&spa_feature_table[SPA_FEATURE_OBSOLETE_COUNTS],
	&oc_feature_refcount);

	if (dr_feature_refcount != indirect_vdev_count) {
	ret = 1;
	(void) printf("Number of indirect vdevs (%llu) " \
	"does not match feature count (%llu)\n",
	(u_longlong_t)indirect_vdev_count,
	(u_longlong_t)dr_feature_refcount);
	} else {
	(void) printf("Verified device_removal feature refcount " \
	"of %llu is correct\n",
	(u_longlong_t)dr_feature_refcount);
	}

	if (zap_contains(spa_meta_objset(spa), DMU_POOL_DIRECTORY_OBJECT,
	DMU_POOL_OBSOLETE_BPOBJ) == 0) {
	obsolete_bpobj_count++;
	}


	obsolete_counts_object_count = precise_vdev_count;
	obsolete_counts_object_count += obsolete_sm_count;
	obsolete_counts_object_count += obsolete_counts_count;
	obsolete_counts_object_count += scip_count;
	obsolete_counts_object_count += obsolete_bpobj_count;
	obsolete_counts_object_count += remap_deadlist_count;

	if (oc_feature_refcount != obsolete_counts_object_count) {
	ret = 1;
	(void) printf("Number of obsolete counts objects (%llu) " \
	"does not match feature count (%llu)\n",
	(u_longlong_t)obsolete_counts_object_count,
	(u_longlong_t)oc_feature_refcount);
	(void) printf("pv:%llu os:%llu oc:%llu sc:%llu "
	"ob:%llu rd:%llu\n",
	(u_longlong_t)precise_vdev_count,
	(u_longlong_t)obsolete_sm_count,
	(u_longlong_t)obsolete_counts_count,
	(u_longlong_t)scip_count,
	(u_longlong_t)obsolete_bpobj_count,
	(u_longlong_t)remap_deadlist_count);
	} else {
	(void) printf("Verified indirect_refcount feature refcount " \
	"of %llu is correct\n",
	(u_longlong_t)oc_feature_refcount);
	}
	return (ret);
	}

	static void
	zdb_set_skip_mmp(char *target)
	{
	spa_t *spa;

	/*
	* Disable the activity check to allow examination of
	* active pools.
	*/
	mutex_enter(&spa_namespace_lock);
	if ((spa = spa_lookup(target)) != NULL) {
	spa->spa_import_flags \|= ZFS_IMPORT_SKIP_MMP;
	}
	mutex_exit(&spa_namespace_lock);
	}

	#define BOGUS_SUFFIX "_CHECKPOINTED_UNIVERSE"
	/*
	* Import the checkpointed state of the pool specified by the target
	* parameter as readonly. The function also accepts a pool config
	* as an optional parameter, else it attempts to infer the config by
	* the name of the target pool.
	*
	* Note that the checkpointed state's pool name will be the name of
	* the original pool with the above suffix appended to it. In addition,
	* if the target is not a pool name (e.g. a path to a dataset) then
	* the new_path parameter is populated with the updated path to
	* reflect the fact that we are looking into the checkpointed state.
	*
	* The function returns a newly-allocated copy of the name of the
	* pool containing the checkpointed state. When this copy is no
	* longer needed it should be freed with free(3C). Same thing
	* applies to the new_path parameter if allocated.
	*/
	static char *
	import_checkpointed_state(char target, nvlist_t cfg, char **new_path)
	{
	int error = 0;
	char poolname, bogus_name = NULL;
	boolean_t freecfg = B_FALSE;

	/* If the target is not a pool, the extract the pool name */
	char *path_start = strchr(target, '/');
	if (path_start != NULL) {
	size_t poolname_len = path_start - target;
	poolname = strndup(target, poolname_len);
	} else {
	poolname = target;
	}

	if (cfg == NULL) {
	zdb_set_skip_mmp(poolname);
	error = spa_get_stats(poolname, &cfg, NULL, 0);
	if (error != 0) {
	fatal("Tried to read config of pool \"%s\" but "
	"spa_get_stats() failed with error %d\n",
	poolname, error);
	}
	freecfg = B_TRUE;
	}

	if (asprintf(&bogus_name, "%s%s", poolname, BOGUS_SUFFIX) == -1)
	return (NULL);
	fnvlist_add_string(cfg, ZPOOL_CONFIG_POOL_NAME, bogus_name);

	error = spa_import(bogus_name, cfg, NULL,
	ZFS_IMPORT_MISSING_LOG \| ZFS_IMPORT_CHECKPOINT \|
	ZFS_IMPORT_SKIP_MMP);
	if (freecfg)
	nvlist_free(cfg);
	if (error != 0) {
	fatal("Tried to import pool \"%s\" but spa_import() failed "
	"with error %d\n", bogus_name, error);
	}

	if (new_path != NULL && path_start != NULL) {
	if (asprintf(new_path, "%s%s", bogus_name, path_start) == -1) {
	if (path_start != NULL)
	free(poolname);
	return (NULL);
	}
	}

	if (target != poolname)
	free(poolname);

	return (bogus_name);
	}

	typedef struct verify_checkpoint_sm_entry_cb_arg {
	vdev_t *vcsec_vd;

	/* the following fields are only used for printing progress */
	uint64_t vcsec_entryid;
	uint64_t vcsec_num_entries;
	} verify_checkpoint_sm_entry_cb_arg_t;

	#define ENTRIES_PER_PROGRESS_UPDATE 10000

	static int
	verify_checkpoint_sm_entry_cb(space_map_entry_t sme, void arg)
	{
	verify_checkpoint_sm_entry_cb_arg_t *vcsec = arg;
	vdev_t *vd = vcsec->vcsec_vd;
	metaslab_t *ms = vd->vdev_ms[sme->sme_offset >> vd->vdev_ms_shift];
	uint64_t end = sme->sme_offset + sme->sme_run;

	ASSERT(sme->sme_type == SM_FREE);

	if ((vcsec->vcsec_entryid % ENTRIES_PER_PROGRESS_UPDATE) == 0) {
	(void) fprintf(stderr,
	"\rverifying vdev %llu, space map entry %llu of %llu ...",
	(longlong_t)vd->vdev_id,
	(longlong_t)vcsec->vcsec_entryid,
	(longlong_t)vcsec->vcsec_num_entries);
	}
	vcsec->vcsec_entryid++;

	/*
	* See comment in checkpoint_sm_exclude_entry_cb()
	*/
	VERIFY3U(sme->sme_offset, >=, ms->ms_start);
	VERIFY3U(end, <=, ms->ms_start + ms->ms_size);

	/*
	* The entries in the vdev_checkpoint_sm should be marked as
	* allocated in the checkpointed state of the pool, therefore
	* their respective ms_allocateable trees should not contain them.
	*/
	mutex_enter(&ms->ms_lock);
	range_tree_verify_not_present(ms->ms_allocatable,
	sme->sme_offset, sme->sme_run);
	mutex_exit(&ms->ms_lock);

	return (0);
	}

	/*
	* Verify that all segments in the vdev_checkpoint_sm are allocated
	* according to the checkpoint's ms_sm (i.e. are not in the checkpoint's
	* ms_allocatable).
	*
	* Do so by comparing the checkpoint space maps (vdev_checkpoint_sm) of
	* each vdev in the current state of the pool to the metaslab space maps
	* (ms_sm) of the checkpointed state of the pool.
	*
	* Note that the function changes the state of the ms_allocatable
	* trees of the current spa_t. The entries of these ms_allocatable
	* trees are cleared out and then repopulated from with the free
	* entries of their respective ms_sm space maps.
	*/
	static void
	verify_checkpoint_vdev_spacemaps(spa_t checkpoint, spa_t current)
	{
	vdev_t *ckpoint_rvd = checkpoint->spa_root_vdev;
	vdev_t *current_rvd = current->spa_root_vdev;

	load_concrete_ms_allocatable_trees(checkpoint, SM_FREE);

	for (uint64_t c = 0; c < ckpoint_rvd->vdev_children; c++) {
	vdev_t *ckpoint_vd = ckpoint_rvd->vdev_child[c];
	vdev_t *current_vd = current_rvd->vdev_child[c];

	space_map_t *checkpoint_sm = NULL;
	uint64_t checkpoint_sm_obj;

	if (ckpoint_vd->vdev_ops == &vdev_indirect_ops) {
	/*
	* Since we don't allow device removal in a pool
	* that has a checkpoint, we expect that all removed
	* vdevs were removed from the pool before the
	* checkpoint.
	*/
	ASSERT3P(current_vd->vdev_ops, ==, &vdev_indirect_ops);
	continue;
	}

	/*
	* If the checkpoint space map doesn't exist, then nothing
	* here is checkpointed so there's nothing to verify.
	*/
	if (current_vd->vdev_top_zap == 0 \|\|
	zap_contains(spa_meta_objset(current),
	current_vd->vdev_top_zap,
	VDEV_TOP_ZAP_POOL_CHECKPOINT_SM) != 0)
	continue;

	VERIFY0(zap_lookup(spa_meta_objset(current),
	current_vd->vdev_top_zap, VDEV_TOP_ZAP_POOL_CHECKPOINT_SM,
	sizeof (uint64_t), 1, &checkpoint_sm_obj));

	VERIFY0(space_map_open(&checkpoint_sm, spa_meta_objset(current),
	checkpoint_sm_obj, 0, current_vd->vdev_asize,
	current_vd->vdev_ashift));

	verify_checkpoint_sm_entry_cb_arg_t vcsec;
	vcsec.vcsec_vd = ckpoint_vd;
	vcsec.vcsec_entryid = 0;
	vcsec.vcsec_num_entries =
	space_map_length(checkpoint_sm) / sizeof (uint64_t);
	VERIFY0(space_map_iterate(checkpoint_sm,
	space_map_length(checkpoint_sm),
	verify_checkpoint_sm_entry_cb, &vcsec));
	if (dump_opt['m'] > 3)
	dump_spacemap(current->spa_meta_objset, checkpoint_sm);
	space_map_close(checkpoint_sm);
	}

	/*
	* If we've added vdevs since we took the checkpoint, ensure
	* that their checkpoint space maps are empty.
	*/
	if (ckpoint_rvd->vdev_children < current_rvd->vdev_children) {
	for (uint64_t c = ckpoint_rvd->vdev_children;
	c < current_rvd->vdev_children; c++) {
	vdev_t *current_vd = current_rvd->vdev_child[c];
	- ASSERT3P(current_vd->vdev_checkpoint_sm, ==, NULL);
	+ VERIFY3P(current_vd->vdev_checkpoint_sm, ==, NULL);
	}
	}

	/* for cleaner progress output */
	(void) fprintf(stderr, "\n");
	}

	/*
	* Verifies that all space that's allocated in the checkpoint is
	* still allocated in the current version, by checking that everything
	* in checkpoint's ms_allocatable (which is actually allocated, not
	* allocatable/free) is not present in current's ms_allocatable.
	*
	* Note that the function changes the state of the ms_allocatable
	* trees of both spas when called. The entries of all ms_allocatable
	* trees are cleared out and then repopulated from their respective
	* ms_sm space maps. In the checkpointed state we load the allocated
	* entries, and in the current state we load the free entries.
	*/
	static void
	verify_checkpoint_ms_spacemaps(spa_t checkpoint, spa_t current)
	{
	vdev_t *ckpoint_rvd = checkpoint->spa_root_vdev;
	vdev_t *current_rvd = current->spa_root_vdev;

	load_concrete_ms_allocatable_trees(checkpoint, SM_ALLOC);
	load_concrete_ms_allocatable_trees(current, SM_FREE);

	for (uint64_t i = 0; i < ckpoint_rvd->vdev_children; i++) {
	vdev_t *ckpoint_vd = ckpoint_rvd->vdev_child[i];
	vdev_t *current_vd = current_rvd->vdev_child[i];

	if (ckpoint_vd->vdev_ops == &vdev_indirect_ops) {
	/*
	* See comment in verify_checkpoint_vdev_spacemaps()
	*/
	ASSERT3P(current_vd->vdev_ops, ==, &vdev_indirect_ops);
	continue;
	}

	for (uint64_t m = 0; m < ckpoint_vd->vdev_ms_count; m++) {
	metaslab_t *ckpoint_msp = ckpoint_vd->vdev_ms[m];
	metaslab_t *current_msp = current_vd->vdev_ms[m];

	(void) fprintf(stderr,
	"\rverifying vdev %llu of %llu, "
	"metaslab %llu of %llu ...",
	(longlong_t)current_vd->vdev_id,
	(longlong_t)current_rvd->vdev_children,
	(longlong_t)current_vd->vdev_ms[m]->ms_id,
	(longlong_t)current_vd->vdev_ms_count);

	/*
	* We walk through the ms_allocatable trees that
	* are loaded with the allocated blocks from the
	* ms_sm spacemaps of the checkpoint. For each
	* one of these ranges we ensure that none of them
	* exists in the ms_allocatable trees of the
	* current state which are loaded with the ranges
	* that are currently free.
	*
	* This way we ensure that none of the blocks that
	* are part of the checkpoint were freed by mistake.
	*/
	range_tree_walk(ckpoint_msp->ms_allocatable,
	(range_tree_func_t *)range_tree_verify_not_present,
	current_msp->ms_allocatable);
	}
	}

	/* for cleaner progress output */
	(void) fprintf(stderr, "\n");
	}

	static void
	verify_checkpoint_blocks(spa_t *spa)
	{
	ASSERT(!dump_opt['L']);

	spa_t *checkpoint_spa;
	char *checkpoint_pool;
	int error = 0;

	/*
	* We import the checkpointed state of the pool (under a different
	* name) so we can do verification on it against the current state
	* of the pool.
	*/
	checkpoint_pool = import_checkpointed_state(spa->spa_name, NULL,
	NULL);
	ASSERT(strcmp(spa->spa_name, checkpoint_pool) != 0);

	error = spa_open(checkpoint_pool, &checkpoint_spa, FTAG);
	if (error != 0) {
	fatal("Tried to open pool \"%s\" but spa_open() failed with "
	"error %d\n", checkpoint_pool, error);
	}

	/*
	* Ensure that ranges in the checkpoint space maps of each vdev
	* are allocated according to the checkpointed state's metaslab
	* space maps.
	*/
	verify_checkpoint_vdev_spacemaps(checkpoint_spa, spa);

	/*
	* Ensure that allocated ranges in the checkpoint's metaslab
	* space maps remain allocated in the metaslab space maps of
	* the current state.
	*/
	verify_checkpoint_ms_spacemaps(checkpoint_spa, spa);

	/*
	* Once we are done, we get rid of the checkpointed state.
	*/
	spa_close(checkpoint_spa, FTAG);
	free(checkpoint_pool);
	}

	static void
	dump_leftover_checkpoint_blocks(spa_t *spa)
	{
	vdev_t *rvd = spa->spa_root_vdev;

	for (uint64_t i = 0; i < rvd->vdev_children; i++) {
	vdev_t *vd = rvd->vdev_child[i];

	space_map_t *checkpoint_sm = NULL;
	uint64_t checkpoint_sm_obj;

	if (vd->vdev_top_zap == 0)
	continue;

	if (zap_contains(spa_meta_objset(spa), vd->vdev_top_zap,
	VDEV_TOP_ZAP_POOL_CHECKPOINT_SM) != 0)
	continue;

	VERIFY0(zap_lookup(spa_meta_objset(spa), vd->vdev_top_zap,
	VDEV_TOP_ZAP_POOL_CHECKPOINT_SM,
	sizeof (uint64_t), 1, &checkpoint_sm_obj));

	VERIFY0(space_map_open(&checkpoint_sm, spa_meta_objset(spa),
	checkpoint_sm_obj, 0, vd->vdev_asize, vd->vdev_ashift));
	dump_spacemap(spa->spa_meta_objset, checkpoint_sm);
	space_map_close(checkpoint_sm);
	}
	}

	static int
	verify_checkpoint(spa_t *spa)
	{
	uberblock_t checkpoint;
	int error;

	if (!spa_feature_is_active(spa, SPA_FEATURE_POOL_CHECKPOINT))
	return (0);

	error = zap_lookup(spa->spa_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
	DMU_POOL_ZPOOL_CHECKPOINT, sizeof (uint64_t),
	sizeof (uberblock_t) / sizeof (uint64_t), &checkpoint);

	if (error == ENOENT && !dump_opt['L']) {
	/*
	* If the feature is active but the uberblock is missing
	* then we must be in the middle of discarding the
	* checkpoint.
	*/
	(void) printf("\nPartially discarded checkpoint "
	"state found:\n");
	if (dump_opt['m'] > 3)
	dump_leftover_checkpoint_blocks(spa);
	return (0);
	} else if (error != 0) {
	(void) printf("lookup error %d when looking for "
	"checkpointed uberblock in MOS\n", error);
	return (error);
	}
	dump_uberblock(&checkpoint, "\nCheckpointed uberblock found:\n", "\n");

	if (checkpoint.ub_checkpoint_txg == 0) {
	(void) printf("\nub_checkpoint_txg not set in checkpointed "
	"uberblock\n");
	error = 3;
	}

	if (error == 0 && !dump_opt['L'])
	verify_checkpoint_blocks(spa);

	return (error);
	}

	/* ARGSUSED */
	static void
	mos_leaks_cb(void *arg, uint64_t start, uint64_t size)
	{
	for (uint64_t i = start; i < size; i++) {
	(void) printf("MOS object %llu referenced but not allocated\n",
	(u_longlong_t)i);
	}
	}

	static void
	mos_obj_refd(uint64_t obj)
	{
	if (obj != 0 && mos_refd_objs != NULL)
	range_tree_add(mos_refd_objs, obj, 1);
	}

	/*
	* Call on a MOS object that may already have been referenced.
	*/
	static void
	mos_obj_refd_multiple(uint64_t obj)
	{
	if (obj != 0 && mos_refd_objs != NULL &&
	!range_tree_contains(mos_refd_objs, obj, 1))
	range_tree_add(mos_refd_objs, obj, 1);
	}

	static void
	mos_leak_vdev_top_zap(vdev_t *vd)
	{
	uint64_t ms_flush_data_obj;
	int error = zap_lookup(spa_meta_objset(vd->vdev_spa),
	vd->vdev_top_zap, VDEV_TOP_ZAP_MS_UNFLUSHED_PHYS_TXGS,
	sizeof (ms_flush_data_obj), 1, &ms_flush_data_obj);
	if (error == ENOENT)
	return;
	ASSERT0(error);

	mos_obj_refd(ms_flush_data_obj);
	}

	static void
	mos_leak_vdev(vdev_t *vd)
	{
	mos_obj_refd(vd->vdev_dtl_object);
	mos_obj_refd(vd->vdev_ms_array);
	mos_obj_refd(vd->vdev_indirect_config.vic_births_object);
	mos_obj_refd(vd->vdev_indirect_config.vic_mapping_object);
	mos_obj_refd(vd->vdev_leaf_zap);
	if (vd->vdev_checkpoint_sm != NULL)
	mos_obj_refd(vd->vdev_checkpoint_sm->sm_object);
	if (vd->vdev_indirect_mapping != NULL) {
	mos_obj_refd(vd->vdev_indirect_mapping->
	vim_phys->vimp_counts_object);
	}
	if (vd->vdev_obsolete_sm != NULL)
	mos_obj_refd(vd->vdev_obsolete_sm->sm_object);

	for (uint64_t m = 0; m < vd->vdev_ms_count; m++) {
	metaslab_t *ms = vd->vdev_ms[m];
	mos_obj_refd(space_map_object(ms->ms_sm));
	}

	if (vd->vdev_top_zap != 0) {
	mos_obj_refd(vd->vdev_top_zap);
	mos_leak_vdev_top_zap(vd);
	}

	for (uint64_t c = 0; c < vd->vdev_children; c++) {
	mos_leak_vdev(vd->vdev_child[c]);
	}
	}

	static void
	mos_leak_log_spacemaps(spa_t *spa)
	{
	uint64_t spacemap_zap;
	int error = zap_lookup(spa_meta_objset(spa),
	DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_LOG_SPACEMAP_ZAP,
	sizeof (spacemap_zap), 1, &spacemap_zap);
	if (error == ENOENT)
	return;
	ASSERT0(error);

	mos_obj_refd(spacemap_zap);
	for (spa_log_sm_t *sls = avl_first(&spa->spa_sm_logs_by_txg);
	sls; sls = AVL_NEXT(&spa->spa_sm_logs_by_txg, sls))
	mos_obj_refd(sls->sls_sm_obj);
	}

	static int
	dump_mos_leaks(spa_t *spa)
	{
	int rv = 0;
	objset_t *mos = spa->spa_meta_objset;
	dsl_pool_t *dp = spa->spa_dsl_pool;

	/* Visit and mark all referenced objects in the MOS */

	mos_obj_refd(DMU_POOL_DIRECTORY_OBJECT);
	mos_obj_refd(spa->spa_pool_props_object);
	mos_obj_refd(spa->spa_config_object);
	mos_obj_refd(spa->spa_ddt_stat_object);
	mos_obj_refd(spa->spa_feat_desc_obj);
	mos_obj_refd(spa->spa_feat_enabled_txg_obj);
	mos_obj_refd(spa->spa_feat_for_read_obj);
	mos_obj_refd(spa->spa_feat_for_write_obj);
	mos_obj_refd(spa->spa_history);
	mos_obj_refd(spa->spa_errlog_last);
	mos_obj_refd(spa->spa_errlog_scrub);
	mos_obj_refd(spa->spa_all_vdev_zaps);
	mos_obj_refd(spa->spa_dsl_pool->dp_bptree_obj);
	mos_obj_refd(spa->spa_dsl_pool->dp_tmp_userrefs_obj);
	mos_obj_refd(spa->spa_dsl_pool->dp_scan->scn_phys.scn_queue_obj);
	bpobj_count_refd(&spa->spa_deferred_bpobj);
	mos_obj_refd(dp->dp_empty_bpobj);
	bpobj_count_refd(&dp->dp_obsolete_bpobj);
	bpobj_count_refd(&dp->dp_free_bpobj);
	mos_obj_refd(spa->spa_l2cache.sav_object);
	mos_obj_refd(spa->spa_spares.sav_object);

	if (spa->spa_syncing_log_sm != NULL)
	mos_obj_refd(spa->spa_syncing_log_sm->sm_object);
	mos_leak_log_spacemaps(spa);

	mos_obj_refd(spa->spa_condensing_indirect_phys.
	scip_next_mapping_object);
	mos_obj_refd(spa->spa_condensing_indirect_phys.
	scip_prev_obsolete_sm_object);
	if (spa->spa_condensing_indirect_phys.scip_next_mapping_object != 0) {
	vdev_indirect_mapping_t *vim =
	vdev_indirect_mapping_open(mos,
	spa->spa_condensing_indirect_phys.scip_next_mapping_object);
	mos_obj_refd(vim->vim_phys->vimp_counts_object);
	vdev_indirect_mapping_close(vim);
	}
	deleted_livelists_dump_mos(spa);

	if (dp->dp_origin_snap != NULL) {
	dsl_dataset_t *ds;

	dsl_pool_config_enter(dp, FTAG);
	VERIFY0(dsl_dataset_hold_obj(dp,
	dsl_dataset_phys(dp->dp_origin_snap)->ds_next_snap_obj,
	FTAG, &ds));
	count_ds_mos_objects(ds);
	dump_blkptr_list(&ds->ds_deadlist, "Deadlist");
	dsl_dataset_rele(ds, FTAG);
	dsl_pool_config_exit(dp, FTAG);

	count_ds_mos_objects(dp->dp_origin_snap);
	dump_blkptr_list(&dp->dp_origin_snap->ds_deadlist, "Deadlist");
	}
	count_dir_mos_objects(dp->dp_mos_dir);
	if (dp->dp_free_dir != NULL)
	count_dir_mos_objects(dp->dp_free_dir);
	if (dp->dp_leak_dir != NULL)
	count_dir_mos_objects(dp->dp_leak_dir);

	mos_leak_vdev(spa->spa_root_vdev);

	for (uint64_t class = 0; class < DDT_CLASSES; class++) {
	for (uint64_t type = 0; type < DDT_TYPES; type++) {
	for (uint64_t cksum = 0;
	cksum < ZIO_CHECKSUM_FUNCTIONS; cksum++) {
	ddt_t *ddt = spa->spa_ddt[cksum];
	mos_obj_refd(ddt->ddt_object[type][class]);
	}
	}
	}

	/*
	* Visit all allocated objects and make sure they are referenced.
	*/
	uint64_t object = 0;
	while (dmu_object_next(mos, &object, B_FALSE, 0) == 0) {
	if (range_tree_contains(mos_refd_objs, object, 1)) {
	range_tree_remove(mos_refd_objs, object, 1);
	} else {
	dmu_object_info_t doi;
	const char *name;
	dmu_object_info(mos, object, &doi);
	if (doi.doi_type & DMU_OT_NEWTYPE) {
	dmu_object_byteswap_t bswap =
	DMU_OT_BYTESWAP(doi.doi_type);
	name = dmu_ot_byteswap[bswap].ob_name;
	} else {
	name = dmu_ot[doi.doi_type].ot_name;
	}

	(void) printf("MOS object %llu (%s) leaked\n",
	(u_longlong_t)object, name);
	rv = 2;
	}
	}
	(void) range_tree_walk(mos_refd_objs, mos_leaks_cb, NULL);
	if (!range_tree_is_empty(mos_refd_objs))
	rv = 2;
	range_tree_vacate(mos_refd_objs, NULL, NULL);
	range_tree_destroy(mos_refd_objs);
	return (rv);
	}

	typedef struct log_sm_obsolete_stats_arg {
	uint64_t lsos_current_txg;

	uint64_t lsos_total_entries;
	uint64_t lsos_valid_entries;

	uint64_t lsos_sm_entries;
	uint64_t lsos_valid_sm_entries;
	} log_sm_obsolete_stats_arg_t;

	static int
	log_spacemap_obsolete_stats_cb(spa_t spa, space_map_entry_t sme,
	uint64_t txg, void *arg)
	{
	log_sm_obsolete_stats_arg_t *lsos = arg;

	uint64_t offset = sme->sme_offset;
	uint64_t vdev_id = sme->sme_vdev;

	if (lsos->lsos_current_txg == 0) {
	/* this is the first log */
	lsos->lsos_current_txg = txg;
	} else if (lsos->lsos_current_txg < txg) {
	/* we just changed log - print stats and reset */
	(void) printf("%-8llu valid entries out of %-8llu - txg %llu\n",
	(u_longlong_t)lsos->lsos_valid_sm_entries,
	(u_longlong_t)lsos->lsos_sm_entries,
	(u_longlong_t)lsos->lsos_current_txg);
	lsos->lsos_valid_sm_entries = 0;
	lsos->lsos_sm_entries = 0;
	lsos->lsos_current_txg = txg;
	}
	ASSERT3U(lsos->lsos_current_txg, ==, txg);

	lsos->lsos_sm_entries++;
	lsos->lsos_total_entries++;

	vdev_t *vd = vdev_lookup_top(spa, vdev_id);
	if (!vdev_is_concrete(vd))
	return (0);

	metaslab_t *ms = vd->vdev_ms[offset >> vd->vdev_ms_shift];
	ASSERT(sme->sme_type == SM_ALLOC \|\| sme->sme_type == SM_FREE);

	if (txg < metaslab_unflushed_txg(ms))
	return (0);
	lsos->lsos_valid_sm_entries++;
	lsos->lsos_valid_entries++;
	return (0);
	}

	static void
	dump_log_spacemap_obsolete_stats(spa_t *spa)
	{
	if (!spa_feature_is_active(spa, SPA_FEATURE_LOG_SPACEMAP))
	return;

	log_sm_obsolete_stats_arg_t lsos;
	bzero(&lsos, sizeof (lsos));

	(void) printf("Log Space Map Obsolete Entry Statistics:\n");

	iterate_through_spacemap_logs(spa,
	log_spacemap_obsolete_stats_cb, &lsos);

	/* print stats for latest log */
	(void) printf("%-8llu valid entries out of %-8llu - txg %llu\n",
	(u_longlong_t)lsos.lsos_valid_sm_entries,
	(u_longlong_t)lsos.lsos_sm_entries,
	(u_longlong_t)lsos.lsos_current_txg);

	(void) printf("%-8llu valid entries out of %-8llu - total\n\n",
	(u_longlong_t)lsos.lsos_valid_entries,
	(u_longlong_t)lsos.lsos_total_entries);
	}

	static void
	dump_zpool(spa_t *spa)
	{
	dsl_pool_t *dp = spa_get_dsl(spa);
	int rc = 0;

	if (dump_opt['y']) {
	livelist_metaslab_validate(spa);
	}

	if (dump_opt['S']) {
	dump_simulated_ddt(spa);
	return;
	}

	if (!dump_opt['e'] && dump_opt['C'] > 1) {
	(void) printf("\nCached configuration:\n");
	dump_nvlist(spa->spa_config, 8);
	}

	if (dump_opt['C'])
	dump_config(spa);

	if (dump_opt['u'])
	dump_uberblock(&spa->spa_uberblock, "\nUberblock:\n", "\n");

	if (dump_opt['D'])
	dump_all_ddts(spa);

	if (dump_opt['d'] > 2 \|\| dump_opt['m'])
	dump_metaslabs(spa);
	if (dump_opt['M'])
	dump_metaslab_groups(spa);
	if (dump_opt['d'] > 2 \|\| dump_opt['m']) {
	dump_log_spacemaps(spa);
	dump_log_spacemap_obsolete_stats(spa);
	}

	if (dump_opt['d'] \|\| dump_opt['i']) {
	spa_feature_t f;
	mos_refd_objs = range_tree_create(NULL, RANGE_SEG64, NULL, 0,
	0);
	dump_objset(dp->dp_meta_objset);

	if (dump_opt['d'] >= 3) {
	dsl_pool_t *dp = spa->spa_dsl_pool;
	dump_full_bpobj(&spa->spa_deferred_bpobj,
	"Deferred frees", 0);
	if (spa_version(spa) >= SPA_VERSION_DEADLISTS) {
	dump_full_bpobj(&dp->dp_free_bpobj,
	"Pool snapshot frees", 0);
	}
	if (bpobj_is_open(&dp->dp_obsolete_bpobj)) {
	ASSERT(spa_feature_is_enabled(spa,
	SPA_FEATURE_DEVICE_REMOVAL));
	dump_full_bpobj(&dp->dp_obsolete_bpobj,
	"Pool obsolete blocks", 0);
	}

	if (spa_feature_is_active(spa,
	SPA_FEATURE_ASYNC_DESTROY)) {
	dump_bptree(spa->spa_meta_objset,
	dp->dp_bptree_obj,
	"Pool dataset frees");
	}
	dump_dtl(spa->spa_root_vdev, 0);
	}

	for (spa_feature_t f = 0; f < SPA_FEATURES; f++)
	global_feature_count[f] = UINT64_MAX;
	global_feature_count[SPA_FEATURE_REDACTION_BOOKMARKS] = 0;
	global_feature_count[SPA_FEATURE_BOOKMARK_WRITTEN] = 0;
	global_feature_count[SPA_FEATURE_LIVELIST] = 0;

	(void) dmu_objset_find(spa_name(spa), dump_one_objset,
	NULL, DS_FIND_SNAPSHOTS \| DS_FIND_CHILDREN);

	if (rc == 0 && !dump_opt['L'])
	rc = dump_mos_leaks(spa);

	for (f = 0; f < SPA_FEATURES; f++) {
	uint64_t refcount;

	uint64_t *arr;
	if (!(spa_feature_table[f].fi_flags &
	ZFEATURE_FLAG_PER_DATASET)) {
	if (global_feature_count[f] == UINT64_MAX)
	continue;
	if (!spa_feature_is_enabled(spa, f)) {
	ASSERT0(global_feature_count[f]);
	continue;
	}
	arr = global_feature_count;
	} else {
	if (!spa_feature_is_enabled(spa, f)) {
	ASSERT0(dataset_feature_count[f]);
	continue;
	}
	arr = dataset_feature_count;
	}
	if (feature_get_refcount(spa, &spa_feature_table[f],
	&refcount) == ENOTSUP)
	continue;
	if (arr[f] != refcount) {
	(void) printf("%s feature refcount mismatch: "
	"%lld consumers != %lld refcount\n",
	spa_feature_table[f].fi_uname,
	(longlong_t)arr[f], (longlong_t)refcount);
	rc = 2;
	} else {
	(void) printf("Verified %s feature refcount "
	"of %llu is correct\n",
	spa_feature_table[f].fi_uname,
	(longlong_t)refcount);
	}
	}

	if (rc == 0)
	rc = verify_device_removal_feature_counts(spa);
	}

	if (rc == 0 && (dump_opt['b'] \|\| dump_opt['c']))
	rc = dump_block_stats(spa);

	if (rc == 0)
	rc = verify_spacemap_refcounts(spa);

	if (dump_opt['s'])
	show_pool_stats(spa);

	if (dump_opt['h'])
	dump_history(spa);

	if (rc == 0)
	rc = verify_checkpoint(spa);

	if (rc != 0) {
	dump_debug_buffer();
	exit(rc);
	}
	}

	#define ZDB_FLAG_CHECKSUM 0x0001
	#define ZDB_FLAG_DECOMPRESS 0x0002
	#define ZDB_FLAG_BSWAP 0x0004
	#define ZDB_FLAG_GBH 0x0008
	#define ZDB_FLAG_INDIRECT 0x0010
	#define ZDB_FLAG_RAW 0x0020
	#define ZDB_FLAG_PRINT_BLKPTR 0x0040
	#define ZDB_FLAG_VERBOSE 0x0080

	static int flagbits[256];
	static char flagbitstr[16];

	static void
	zdb_print_blkptr(const blkptr_t *bp, int flags)
	{
	char blkbuf[BP_SPRINTF_LEN];

	if (flags & ZDB_FLAG_BSWAP)
	byteswap_uint64_array((void *)bp, sizeof (blkptr_t));

	snprintf_blkptr(blkbuf, sizeof (blkbuf), bp);
	(void) printf("%s\n", blkbuf);
	}

	static void
	zdb_dump_indirect(blkptr_t *bp, int nbps, int flags)
	{
	int i;

	for (i = 0; i < nbps; i++)
	zdb_print_blkptr(&bp[i], flags);
	}

	static void
	zdb_dump_gbh(void *buf, int flags)
	{
	zdb_dump_indirect((blkptr_t *)buf, SPA_GBH_NBLKPTRS, flags);
	}

	static void
	zdb_dump_block_raw(void *buf, uint64_t size, int flags)
	{
	if (flags & ZDB_FLAG_BSWAP)
	byteswap_uint64_array(buf, size);
	VERIFY(write(fileno(stdout), buf, size) == size);
	}

	static void
	zdb_dump_block(char label, void buf, uint64_t size, int flags)
	{
	uint64_t d = (uint64_t )buf;
	unsigned nwords = size / sizeof (uint64_t);
	int do_bswap = !!(flags & ZDB_FLAG_BSWAP);
	unsigned i, j;
	const char *hdr;
	char *c;


	if (do_bswap)
	hdr = " 7 6 5 4 3 2 1 0 f e d c b a 9 8";
	else
	hdr = " 0 1 2 3 4 5 6 7 8 9 a b c d e f";

	(void) printf("\n%s\n%6s %s 0123456789abcdef\n", label, "", hdr);

	#ifdef _LITTLE_ENDIAN
	/* correct the endianness */
	do_bswap = !do_bswap;
	#endif
	for (i = 0; i < nwords; i += 2) {
	(void) printf("%06llx: %016llx %016llx ",
	(u_longlong_t)(i * sizeof (uint64_t)),
	(u_longlong_t)(do_bswap ? BSWAP_64(d[i]) : d[i]),
	(u_longlong_t)(do_bswap ? BSWAP_64(d[i + 1]) : d[i + 1]));

	c = (char *)&d[i];
	for (j = 0; j < 2 * sizeof (uint64_t); j++)
	(void) printf("%c", isprint(c[j]) ? c[j] : '.');
	(void) printf("\n");
	}
	}

	/*
	* There are two acceptable formats:
	* leaf_name - For example: c1t0d0 or /tmp/ztest.0a
	* child[.child]* - For example: 0.1.1
	*
	* The second form can be used to specify arbitrary vdevs anywhere
	* in the hierarchy. For example, in a pool with a mirror of
	* RAID-Zs, you can specify either RAID-Z vdev with 0.0 or 0.1 .
	*/
	static vdev_t *
	zdb_vdev_lookup(vdev_t vdev, const char path)
	{
	char s, p, *q;
	unsigned i;

	if (vdev == NULL)
	return (NULL);

	/* First, assume the x.x.x.x format */
	i = strtoul(path, &s, 10);
	if (s == path \|\| (s && s != '.' && s != '\0'))
	goto name;
	if (i >= vdev->vdev_children)
	return (NULL);

	vdev = vdev->vdev_child[i];
	if (s && *s == '\0')
	return (vdev);
	return (zdb_vdev_lookup(vdev, s+1));

	name:
	for (i = 0; i < vdev->vdev_children; i++) {
	vdev_t *vc = vdev->vdev_child[i];

	if (vc->vdev_path == NULL) {
	vc = zdb_vdev_lookup(vc, path);
	if (vc == NULL)
	continue;
	else
	return (vc);
	}

	p = strrchr(vc->vdev_path, '/');
	p = p ? p + 1 : vc->vdev_path;
	q = &vc->vdev_path[strlen(vc->vdev_path) - 2];

	if (strcmp(vc->vdev_path, path) == 0)
	return (vc);
	if (strcmp(p, path) == 0)
	return (vc);
	if (strcmp(q, "s0") == 0 && strncmp(p, path, q - p) == 0)
	return (vc);
	}

	return (NULL);
	}

	static int
	name_from_objset_id(spa_t spa, uint64_t objset_id, char outstr)
	{
	dsl_dataset_t *ds;

	dsl_pool_config_enter(spa->spa_dsl_pool, FTAG);
	int error = dsl_dataset_hold_obj(spa->spa_dsl_pool, objset_id,
	NULL, &ds);
	if (error != 0) {
	(void) fprintf(stderr, "failed to hold objset %llu: %s\n",
	(u_longlong_t)objset_id, strerror(error));
	dsl_pool_config_exit(spa->spa_dsl_pool, FTAG);
	return (error);
	}
	dsl_dataset_name(ds, outstr);
	dsl_dataset_rele(ds, NULL);
	dsl_pool_config_exit(spa->spa_dsl_pool, FTAG);
	return (0);
	}

	static boolean_t
	zdb_parse_block_sizes(char sizes, uint64_t lsize, uint64_t *psize)
	{
	char s0, s1;

	if (sizes == NULL)
	return (B_FALSE);

	s0 = strtok(sizes, "/");
	if (s0 == NULL)
	return (B_FALSE);
	s1 = strtok(NULL, "/");
	*lsize = strtoull(s0, NULL, 16);
	psize = s1 ? strtoull(s1, NULL, 16) : lsize;
	return (lsize >= psize && *psize > 0);
	}

	#define ZIO_COMPRESS_MASK(alg) (1ULL << (ZIO_COMPRESS_##alg))

	static boolean_t
	zdb_decompress_block(abd_t pabd, void buf, void *lbuf, uint64_t lsize,
	uint64_t psize, int flags)
	{
	boolean_t exceeded = B_FALSE;
	/*
	* We don't know how the data was compressed, so just try
	* every decompress function at every inflated blocksize.
	*/
	void *lbuf2 = umem_alloc(SPA_MAXBLOCKSIZE, UMEM_NOFAIL);
	int cfuncs[ZIO_COMPRESS_FUNCTIONS] = { 0 };
	int *cfuncp = cfuncs;
	uint64_t maxlsize = SPA_MAXBLOCKSIZE;
	uint64_t mask = ZIO_COMPRESS_MASK(ON) \| ZIO_COMPRESS_MASK(OFF) \|
	ZIO_COMPRESS_MASK(INHERIT) \| ZIO_COMPRESS_MASK(EMPTY) \|
	(getenv("ZDB_NO_ZLE") ? ZIO_COMPRESS_MASK(ZLE) : 0);
	*cfuncp++ = ZIO_COMPRESS_LZ4;
	*cfuncp++ = ZIO_COMPRESS_LZJB;
	mask \|= ZIO_COMPRESS_MASK(LZ4) \| ZIO_COMPRESS_MASK(LZJB);
	for (int c = 0; c < ZIO_COMPRESS_FUNCTIONS; c++)
	if (((1ULL << c) & mask) == 0)
	*cfuncp++ = c;

	/*
	* On the one hand, with SPA_MAXBLOCKSIZE at 16MB, this
	* could take a while and we should let the user know
	* we are not stuck. On the other hand, printing progress
	* info gets old after a while. User can specify 'v' flag
	* to see the progression.
	*/
	if (lsize == psize)
	lsize += SPA_MINBLOCKSIZE;
	else
	maxlsize = lsize;
	for (; lsize <= maxlsize; lsize += SPA_MINBLOCKSIZE) {
	for (cfuncp = cfuncs; *cfuncp; cfuncp++) {
	if (flags & ZDB_FLAG_VERBOSE) {
	(void) fprintf(stderr,
	"Trying %05llx -> %05llx (%s)\n",
	(u_longlong_t)psize,
	(u_longlong_t)lsize,
	zio_compress_table[*cfuncp].\
	ci_name);
	}

	/*
	* We randomize lbuf2, and decompress to both
	* lbuf and lbuf2. This way, we will know if
	* decompression fill exactly to lsize.
	*/
	VERIFY0(random_get_pseudo_bytes(lbuf2, lsize));

	if (zio_decompress_data(*cfuncp, pabd,
	lbuf, psize, lsize, NULL) == 0 &&
	zio_decompress_data(*cfuncp, pabd,
	lbuf2, psize, lsize, NULL) == 0 &&
	bcmp(lbuf, lbuf2, lsize) == 0)
	break;
	}
	if (*cfuncp != 0)
	break;
	}
	umem_free(lbuf2, SPA_MAXBLOCKSIZE);

	if (lsize > maxlsize) {
	exceeded = B_TRUE;
	}
	buf = lbuf;
	if (*cfuncp == ZIO_COMPRESS_ZLE) {
	printf("\nZLE decompression was selected. If you "
	"suspect the results are wrong,\ntry avoiding ZLE "
	"by setting and exporting ZDB_NO_ZLE=\"true\"\n");
	}

	return (exceeded);
	}

	/*
	* Read a block from a pool and print it out. The syntax of the
	* block descriptor is:
	*
	* pool:vdev_specifier:offset:[lsize/]psize[:flags]
	*
	* pool - The name of the pool you wish to read from
	* vdev_specifier - Which vdev (see comment for zdb_vdev_lookup)
	* offset - offset, in hex, in bytes
	* size - Amount of data to read, in hex, in bytes
	* flags - A string of characters specifying options
	* b: Decode a blkptr at given offset within block
	* c: Calculate and display checksums
	* d: Decompress data before dumping
	* e: Byteswap data before dumping
	* g: Display data as a gang block header
	* i: Display as an indirect block
	* r: Dump raw data to stdout
	* v: Verbose
	*
	*/
	static void
	zdb_read_block(char thing, spa_t spa)
	{
	blkptr_t blk, *bp = &blk;
	dva_t *dva = bp->blk_dva;
	int flags = 0;
	uint64_t offset = 0, psize = 0, lsize = 0, blkptr_offset = 0;
	zio_t *zio;
	vdev_t *vd;
	abd_t *pabd;
	void lbuf, buf;
	char s, p, dup, vdev, flagstr, sizes;
	int i, error;
	boolean_t borrowed = B_FALSE, found = B_FALSE;

	dup = strdup(thing);
	s = strtok(dup, ":");
	vdev = s ? s : "";
	s = strtok(NULL, ":");
	offset = strtoull(s ? s : "", NULL, 16);
	sizes = strtok(NULL, ":");
	s = strtok(NULL, ":");
	flagstr = strdup(s ? s : "");

	s = NULL;
	if (!zdb_parse_block_sizes(sizes, &lsize, &psize))
	s = "invalid size(s)";
	if (!IS_P2ALIGNED(psize, DEV_BSIZE) \|\| !IS_P2ALIGNED(lsize, DEV_BSIZE))
	s = "size must be a multiple of sector size";
	if (!IS_P2ALIGNED(offset, DEV_BSIZE))
	s = "offset must be a multiple of sector size";
	if (s) {
	(void) printf("Invalid block specifier: %s - %s\n", thing, s);
	goto done;
	}

	for (s = strtok(flagstr, ":"); s; s = strtok(NULL, ":")) {
	for (i = 0; i < strlen(flagstr); i++) {
	int bit = flagbits[(uchar_t)flagstr[i]];

	if (bit == 0) {
	(void) printf("***Ignoring flag: %c\n",
	(uchar_t)flagstr[i]);
	continue;
	}
	found = B_TRUE;
	flags \|= bit;

	p = &flagstr[i + 1];
	if (p != ':' && p != '\0') {
	int j = 0, nextbit = flagbits[(uchar_t)*p];
	char *end, offstr[8] = { 0 };
	if ((bit == ZDB_FLAG_PRINT_BLKPTR) &&
	(nextbit == 0)) {
	/* look ahead to isolate the offset */
	while (nextbit == 0 &&
	strchr(flagbitstr, *p) == NULL) {
	offstr[j] = *p;
	j++;
	if (i + j > strlen(flagstr))
	break;
	p++;
	nextbit = flagbits[(uchar_t)*p];
	}
	blkptr_offset = strtoull(offstr, &end,
	16);
	i += j;
	} else if (nextbit == 0) {
	(void) printf("***Ignoring flag arg:"
	" '%c'\n", (uchar_t)*p);
	}
	}
	}
	}
	if (blkptr_offset % sizeof (blkptr_t)) {
	printf("Block pointer offset 0x%llx "
	"must be divisible by 0x%x\n",
	(longlong_t)blkptr_offset, (int)sizeof (blkptr_t));
	goto done;
	}
	if (found == B_FALSE && strlen(flagstr) > 0) {
	printf("Invalid flag arg: '%s'\n", flagstr);
	goto done;
	}

	vd = zdb_vdev_lookup(spa->spa_root_vdev, vdev);
	if (vd == NULL) {
	(void) printf("***Invalid vdev: %s\n", vdev);
	free(dup);
	return;
	} else {
	if (vd->vdev_path)
	(void) fprintf(stderr, "Found vdev: %s\n",
	vd->vdev_path);
	else
	(void) fprintf(stderr, "Found vdev type: %s\n",
	vd->vdev_ops->vdev_op_type);
	}

	pabd = abd_alloc_for_io(SPA_MAXBLOCKSIZE, B_FALSE);
	lbuf = umem_alloc(SPA_MAXBLOCKSIZE, UMEM_NOFAIL);

	BP_ZERO(bp);

	DVA_SET_VDEV(&dva[0], vd->vdev_id);
	DVA_SET_OFFSET(&dva[0], offset);
	DVA_SET_GANG(&dva[0], !!(flags & ZDB_FLAG_GBH));
	DVA_SET_ASIZE(&dva[0], vdev_psize_to_asize(vd, psize));

	BP_SET_BIRTH(bp, TXG_INITIAL, TXG_INITIAL);

	BP_SET_LSIZE(bp, lsize);
	BP_SET_PSIZE(bp, psize);
	BP_SET_COMPRESS(bp, ZIO_COMPRESS_OFF);
	BP_SET_CHECKSUM(bp, ZIO_CHECKSUM_OFF);
	BP_SET_TYPE(bp, DMU_OT_NONE);
	BP_SET_LEVEL(bp, 0);
	BP_SET_DEDUP(bp, 0);
	BP_SET_BYTEORDER(bp, ZFS_HOST_BYTEORDER);

	spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
	zio = zio_root(spa, NULL, NULL, 0);

	if (vd == vd->vdev_top) {
	/*
	* Treat this as a normal block read.
	*/
	zio_nowait(zio_read(zio, spa, bp, pabd, psize, NULL, NULL,
	ZIO_PRIORITY_SYNC_READ,
	ZIO_FLAG_CANFAIL \| ZIO_FLAG_RAW, NULL));
	} else {
	/*
	* Treat this as a vdev child I/O.
	*/
	zio_nowait(zio_vdev_child_io(zio, bp, vd, offset, pabd,
	psize, ZIO_TYPE_READ, ZIO_PRIORITY_SYNC_READ,
	ZIO_FLAG_DONT_CACHE \| ZIO_FLAG_DONT_PROPAGATE \|
	ZIO_FLAG_DONT_RETRY \| ZIO_FLAG_CANFAIL \| ZIO_FLAG_RAW \|
	ZIO_FLAG_OPTIONAL, NULL, NULL));
	}

	error = zio_wait(zio);
	spa_config_exit(spa, SCL_STATE, FTAG);

	if (error) {
	(void) printf("Read of %s failed, error: %d\n", thing, error);
	goto out;
	}

	uint64_t orig_lsize = lsize;
	buf = lbuf;
	if (flags & ZDB_FLAG_DECOMPRESS) {
	boolean_t failed = zdb_decompress_block(pabd, buf, lbuf,
	lsize, psize, flags);
	if (failed) {
	(void) printf("Decompress of %s failed\n", thing);
	goto out;
	}
	} else {
	buf = abd_borrow_buf_copy(pabd, lsize);
	borrowed = B_TRUE;
	}
	/*
	* Try to detect invalid block pointer. If invalid, try
	* decompressing.
	*/
	if ((flags & ZDB_FLAG_PRINT_BLKPTR \|\| flags & ZDB_FLAG_INDIRECT) &&
	!(flags & ZDB_FLAG_DECOMPRESS)) {
	const blkptr_t b = (const blkptr_t )(void *)
	((uintptr_t)buf + (uintptr_t)blkptr_offset);
	if (zfs_blkptr_verify(spa, b, B_FALSE, BLK_VERIFY_ONLY) ==
	B_FALSE) {
	abd_return_buf_copy(pabd, buf, lsize);
	borrowed = B_FALSE;
	buf = lbuf;
	boolean_t failed = zdb_decompress_block(pabd, buf,
	lbuf, lsize, psize, flags);
	b = (const blkptr_t )(void )
	((uintptr_t)buf + (uintptr_t)blkptr_offset);
	if (failed \|\| zfs_blkptr_verify(spa, b, B_FALSE,
	BLK_VERIFY_LOG) == B_FALSE) {
	printf("invalid block pointer at this DVA\n");
	goto out;
	}
	}
	}

	if (flags & ZDB_FLAG_PRINT_BLKPTR)
	zdb_print_blkptr((blkptr_t )(void )
	((uintptr_t)buf + (uintptr_t)blkptr_offset), flags);
	else if (flags & ZDB_FLAG_RAW)
	zdb_dump_block_raw(buf, lsize, flags);
	else if (flags & ZDB_FLAG_INDIRECT)
	zdb_dump_indirect((blkptr_t *)buf,
	orig_lsize / sizeof (blkptr_t), flags);
	else if (flags & ZDB_FLAG_GBH)
	zdb_dump_gbh(buf, flags);
	else
	zdb_dump_block(thing, buf, lsize, flags);

	/*
	* If :c was specified, iterate through the checksum table to
	* calculate and display each checksum for our specified
	* DVA and length.
	*/
	if ((flags & ZDB_FLAG_CHECKSUM) && !(flags & ZDB_FLAG_RAW) &&
	!(flags & ZDB_FLAG_GBH)) {
	zio_t *czio;
	(void) printf("\n");
	for (enum zio_checksum ck = ZIO_CHECKSUM_LABEL;
	ck < ZIO_CHECKSUM_FUNCTIONS; ck++) {

	if ((zio_checksum_table[ck].ci_flags &
	ZCHECKSUM_FLAG_EMBEDDED) \|\|
	ck == ZIO_CHECKSUM_NOPARITY) {
	continue;
	}
	BP_SET_CHECKSUM(bp, ck);
	spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
	czio = zio_root(spa, NULL, NULL, ZIO_FLAG_CANFAIL);
	czio->io_bp = bp;

	if (vd == vd->vdev_top) {
	zio_nowait(zio_read(czio, spa, bp, pabd, psize,
	NULL, NULL,
	ZIO_PRIORITY_SYNC_READ,
	ZIO_FLAG_CANFAIL \| ZIO_FLAG_RAW \|
	ZIO_FLAG_DONT_RETRY, NULL));
	} else {
	zio_nowait(zio_vdev_child_io(czio, bp, vd,
	offset, pabd, psize, ZIO_TYPE_READ,
	ZIO_PRIORITY_SYNC_READ,
	ZIO_FLAG_DONT_CACHE \|
	ZIO_FLAG_DONT_PROPAGATE \|
	ZIO_FLAG_DONT_RETRY \|
	ZIO_FLAG_CANFAIL \| ZIO_FLAG_RAW \|
	ZIO_FLAG_SPECULATIVE \|
	ZIO_FLAG_OPTIONAL, NULL, NULL));
	}
	error = zio_wait(czio);
	if (error == 0 \|\| error == ECKSUM) {
	zio_t *ck_zio = zio_root(spa, NULL, NULL, 0);
	ck_zio->io_offset =
	DVA_GET_OFFSET(&bp->blk_dva[0]);
	ck_zio->io_bp = bp;
	zio_checksum_compute(ck_zio, ck, pabd, lsize);
	printf("%12s\tcksum=%llx:%llx:%llx:%llx\n",
	zio_checksum_table[ck].ci_name,
	(u_longlong_t)bp->blk_cksum.zc_word[0],
	(u_longlong_t)bp->blk_cksum.zc_word[1],
	(u_longlong_t)bp->blk_cksum.zc_word[2],
	(u_longlong_t)bp->blk_cksum.zc_word[3]);
	zio_wait(ck_zio);
	} else {
	printf("error %d reading block\n", error);
	}
	spa_config_exit(spa, SCL_STATE, FTAG);
	}
	}

	if (borrowed)
	abd_return_buf_copy(pabd, buf, lsize);

	out:
	abd_free(pabd);
	umem_free(lbuf, SPA_MAXBLOCKSIZE);
	done:
	free(flagstr);
	free(dup);
	}

	static void
	zdb_embedded_block(char *thing)
	{
	blkptr_t bp;
	unsigned long long words = (void )&bp;
	char *buf;
	int err;

	bzero(&bp, sizeof (bp));
	err = sscanf(thing, "%llx:%llx:%llx:%llx:%llx:%llx:%llx:%llx:"
	"%llx:%llx:%llx:%llx:%llx:%llx:%llx:%llx",
	words + 0, words + 1, words + 2, words + 3,
	words + 4, words + 5, words + 6, words + 7,
	words + 8, words + 9, words + 10, words + 11,
	words + 12, words + 13, words + 14, words + 15);
	if (err != 16) {
	(void) fprintf(stderr, "invalid input format\n");
	exit(1);
	}
	ASSERT3U(BPE_GET_LSIZE(&bp), <=, SPA_MAXBLOCKSIZE);
	buf = malloc(SPA_MAXBLOCKSIZE);
	if (buf == NULL) {
	(void) fprintf(stderr, "out of memory\n");
	exit(1);
	}
	err = decode_embedded_bp(&bp, buf, BPE_GET_LSIZE(&bp));
	if (err != 0) {
	(void) fprintf(stderr, "decode failed: %u\n", err);
	exit(1);
	}
	zdb_dump_block_raw(buf, BPE_GET_LSIZE(&bp), 0);
	free(buf);
	}

	int
	main(int argc, char **argv)
	{
	int c;
	struct rlimit rl = { 1024, 1024 };
	spa_t *spa = NULL;
	objset_t *os = NULL;
	int dump_all = 1;
	int verbose = 0;
	int error = 0;
	char **searchdirs = NULL;
	int nsearch = 0;
	char target, target_pool, dsname[ZFS_MAX_DATASET_NAME_LEN];
	nvlist_t *policy = NULL;
	uint64_t max_txg = UINT64_MAX;
	int64_t objset_id = -1;
	uint64_t object;
	int flags = ZFS_IMPORT_MISSING_LOG;
	int rewind = ZPOOL_NEVER_REWIND;
	char spa_config_path_env, objset_str;
	boolean_t target_is_spa = B_TRUE, dataset_lookup = B_FALSE;
	nvlist_t *cfg = NULL;

	(void) setrlimit(RLIMIT_NOFILE, &rl);
	(void) enable_extended_FILE_stdio(-1, -1);

	dprintf_setup(&argc, argv);

	/*
	* If there is an environment variable SPA_CONFIG_PATH it overrides
	* default spa_config_path setting. If -U flag is specified it will
	* override this environment variable settings once again.
	*/
	spa_config_path_env = getenv("SPA_CONFIG_PATH");
	if (spa_config_path_env != NULL)
	spa_config_path = spa_config_path_env;

	/*
	* For performance reasons, we set this tunable down. We do so before
	* the arg parsing section so that the user can override this value if
	* they choose.
	*/
	zfs_btree_verify_intensity = 3;

	while ((c = getopt(argc, argv,
	"AbcCdDeEFGhiI:klLmMo:Op:PqrRsSt:uU:vVx:XYyZ")) != -1) {
	switch (c) {
	case 'b':
	case 'c':
	case 'C':
	case 'd':
	case 'D':
	case 'E':
	case 'G':
	case 'h':
	case 'i':
	case 'l':
	case 'm':
	case 'M':
	case 'O':
	case 'r':
	case 'R':
	case 's':
	case 'S':
	case 'u':
	case 'y':
	case 'Z':
	dump_opt[c]++;
	dump_all = 0;
	break;
	case 'A':
	case 'e':
	case 'F':
	case 'k':
	case 'L':
	case 'P':
	case 'q':
	case 'X':
	dump_opt[c]++;
	break;
	case 'Y':
	zfs_reconstruct_indirect_combinations_max = INT_MAX;
	zfs_deadman_enabled = 0;
	break;
	/* NB: Sort single match options below. */
	case 'I':
	max_inflight_bytes = strtoull(optarg, NULL, 0);
	if (max_inflight_bytes == 0) {
	(void) fprintf(stderr, "maximum number "
	"of inflight bytes must be greater "
	"than 0\n");
	usage();
	}
	break;
	case 'o':
	error = set_global_var(optarg);
	if (error != 0)
	usage();
	break;
	case 'p':
	if (searchdirs == NULL) {
	searchdirs = umem_alloc(sizeof (char *),
	UMEM_NOFAIL);
	} else {
	char *tmp = umem_alloc((nsearch + 1)
	sizeof (char *), UMEM_NOFAIL);
	bcopy(searchdirs, tmp, nsearch *
	sizeof (char *));
	umem_free(searchdirs,
	nsearch * sizeof (char *));
	searchdirs = tmp;
	}
	searchdirs[nsearch++] = optarg;
	break;
	case 't':
	max_txg = strtoull(optarg, NULL, 0);
	if (max_txg < TXG_INITIAL) {
	(void) fprintf(stderr, "incorrect txg "
	"specified: %s\n", optarg);
	usage();
	}
	break;
	case 'U':
	spa_config_path = optarg;
	if (spa_config_path[0] != '/') {
	(void) fprintf(stderr,
	"cachefile must be an absolute path "
	"(i.e. start with a slash)\n");
	usage();
	}
	break;
	case 'v':
	verbose++;
	break;
	case 'V':
	flags = ZFS_IMPORT_VERBATIM;
	break;
	case 'x':
	vn_dumpdir = optarg;
	break;
	default:
	usage();
	break;
	}
	}

	if (!dump_opt['e'] && searchdirs != NULL) {
	(void) fprintf(stderr, "-p option requires use of -e\n");
	usage();
	}
	if (dump_opt['d'] \|\| dump_opt['r']) {
	/* <pool>[/<dataset \| objset id> is accepted */
	if (argv[2] && (objset_str = strchr(argv[2], '/')) != NULL &&
	objset_str++ != NULL) {
	char *endptr;
	errno = 0;
	objset_id = strtoull(objset_str, &endptr, 0);
	/* dataset 0 is the same as opening the pool */
	if (errno == 0 && endptr != objset_str &&
	objset_id != 0) {
	target_is_spa = B_FALSE;
	dataset_lookup = B_TRUE;
	} else if (objset_id != 0) {
	printf("failed to open objset %s "
	"%llu %s", objset_str,
	(u_longlong_t)objset_id,
	strerror(errno));
	exit(1);
	}
	/* normal dataset name not an objset ID */
	if (endptr == objset_str) {
	objset_id = -1;
	}
	}
	}

	#if defined(_LP64)
	/*
	* ZDB does not typically re-read blocks; therefore limit the ARC
	* to 256 MB, which can be used entirely for metadata.
	*/
	zfs_arc_min = zfs_arc_meta_min = 2ULL << SPA_MAXBLOCKSHIFT;
	zfs_arc_max = zfs_arc_meta_limit = 256 * 1024 * 1024;
	#endif

	/*
	* "zdb -c" uses checksum-verifying scrub i/os which are async reads.
	* "zdb -b" uses traversal prefetch which uses async reads.
	* For good performance, let several of them be active at once.
	*/
	zfs_vdev_async_read_max_active = 10;

	/*
	* Disable reference tracking for better performance.
	*/
	reference_tracking_enable = B_FALSE;

	/*
	* Do not fail spa_load when spa_load_verify fails. This is needed
	* to load non-idle pools.
	*/
	spa_load_verify_dryrun = B_TRUE;

	kernel_init(SPA_MODE_READ);

	if (dump_all)
	verbose = MAX(verbose, 1);

	for (c = 0; c < 256; c++) {
	if (dump_all && strchr("AeEFklLOPrRSXy", c) == NULL)
	dump_opt[c] = 1;
	if (dump_opt[c])
	dump_opt[c] += verbose;
	}

	aok = (dump_opt['A'] == 1) \|\| (dump_opt['A'] > 2);
	zfs_recover = (dump_opt['A'] > 1);

	argc -= optind;
	argv += optind;
	if (argc < 2 && dump_opt['R'])
	usage();

	if (dump_opt['E']) {
	if (argc != 1)
	usage();
	zdb_embedded_block(argv[0]);
	return (0);
	}

	if (argc < 1) {
	if (!dump_opt['e'] && dump_opt['C']) {
	dump_cachefile(spa_config_path);
	return (0);
	}
	usage();
	}

	if (dump_opt['l'])
	return (dump_label(argv[0]));

	if (dump_opt['O']) {
	if (argc != 2)
	usage();
	dump_opt['v'] = verbose + 3;
	return (dump_path(argv[0], argv[1], NULL));
	}
	if (dump_opt['r']) {
	if (argc != 3)
	usage();
	dump_opt['v'] = verbose;
	error = dump_path(argv[0], argv[1], &object);
	}

	if (dump_opt['X'] \|\| dump_opt['F'])
	rewind = ZPOOL_DO_REWIND \|
	(dump_opt['X'] ? ZPOOL_EXTREME_REWIND : 0);

	if (nvlist_alloc(&policy, NV_UNIQUE_NAME_TYPE, 0) != 0 \|\|
	nvlist_add_uint64(policy, ZPOOL_LOAD_REQUEST_TXG, max_txg) != 0 \|\|
	nvlist_add_uint32(policy, ZPOOL_LOAD_REWIND_POLICY, rewind) != 0)
	fatal("internal error: %s", strerror(ENOMEM));

	error = 0;
	target = argv[0];

	if (strpbrk(target, "/@") != NULL) {
	size_t targetlen;

	target_pool = strdup(target);
	*strpbrk(target_pool, "/@") = '\0';

	target_is_spa = B_FALSE;
	targetlen = strlen(target);
	if (targetlen && target[targetlen - 1] == '/')
	target[targetlen - 1] = '\0';
	} else {
	target_pool = target;
	}

	if (dump_opt['e']) {
	importargs_t args = { 0 };

	args.paths = nsearch;
	args.path = searchdirs;
	args.can_be_active = B_TRUE;

	error = zpool_find_config(NULL, target_pool, &cfg, &args,
	&libzpool_config_ops);

	if (error == 0) {

	if (nvlist_add_nvlist(cfg,
	ZPOOL_LOAD_POLICY, policy) != 0) {
	fatal("can't open '%s': %s",
	target, strerror(ENOMEM));
	}

	if (dump_opt['C'] > 1) {
	(void) printf("\nConfiguration for import:\n");
	dump_nvlist(cfg, 8);
	}

	/*
	* Disable the activity check to allow examination of
	* active pools.
	*/
	error = spa_import(target_pool, cfg, NULL,
	flags \| ZFS_IMPORT_SKIP_MMP);
	}
	}

	if (searchdirs != NULL) {
	umem_free(searchdirs, nsearch * sizeof (char *));
	searchdirs = NULL;
	}

	/*
	* import_checkpointed_state makes the assumption that the
	* target pool that we pass it is already part of the spa
	* namespace. Because of that we need to make sure to call
	* it always after the -e option has been processed, which
	* imports the pool to the namespace if it's not in the
	* cachefile.
	*/
	char *checkpoint_pool = NULL;
	char *checkpoint_target = NULL;
	if (dump_opt['k']) {
	checkpoint_pool = import_checkpointed_state(target, cfg,
	&checkpoint_target);

	if (checkpoint_target != NULL)
	target = checkpoint_target;
	}

	if (cfg != NULL) {
	nvlist_free(cfg);
	cfg = NULL;
	}

	if (target_pool != target)
	free(target_pool);

	if (error == 0) {
	if (dump_opt['k'] && (target_is_spa \|\| dump_opt['R'])) {
	ASSERT(checkpoint_pool != NULL);
	ASSERT(checkpoint_target == NULL);

	error = spa_open(checkpoint_pool, &spa, FTAG);
	if (error != 0) {
	fatal("Tried to open pool \"%s\" but "
	"spa_open() failed with error %d\n",
	checkpoint_pool, error);
	}

	} else if (target_is_spa \|\| dump_opt['R'] \|\| objset_id == 0) {
	zdb_set_skip_mmp(target);
	error = spa_open_rewind(target, &spa, FTAG, policy,
	NULL);
	if (error) {
	/*
	* If we're missing the log device then
	* try opening the pool after clearing the
	* log state.
	*/
	mutex_enter(&spa_namespace_lock);
	if ((spa = spa_lookup(target)) != NULL &&
	spa->spa_log_state == SPA_LOG_MISSING) {
	spa->spa_log_state = SPA_LOG_CLEAR;
	error = 0;
	}
	mutex_exit(&spa_namespace_lock);

	if (!error) {
	error = spa_open_rewind(target, &spa,
	FTAG, policy, NULL);
	}
	}
	} else if (strpbrk(target, "#") != NULL) {
	dsl_pool_t *dp;
	error = dsl_pool_hold(target, FTAG, &dp);
	if (error != 0) {
	fatal("can't dump '%s': %s", target,
	strerror(error));
	}
	error = dump_bookmark(dp, target, B_TRUE, verbose > 1);
	dsl_pool_rele(dp, FTAG);
	if (error != 0) {
	fatal("can't dump '%s': %s", target,
	strerror(error));
	}
	return (error);
	} else {
	zdb_set_skip_mmp(target);
	if (dataset_lookup == B_TRUE) {
	/*
	* Use the supplied id to get the name
	* for open_objset.
	*/
	error = spa_open(target, &spa, FTAG);
	if (error == 0) {
	error = name_from_objset_id(spa,
	objset_id, dsname);
	spa_close(spa, FTAG);
	if (error == 0)
	target = dsname;
	}
	}
	if (error == 0)
	error = open_objset(target, FTAG, &os);
	if (error == 0)
	spa = dmu_objset_spa(os);
	}
	}
	nvlist_free(policy);

	if (error)
	fatal("can't open '%s': %s", target, strerror(error));

	/*
	* Set the pool failure mode to panic in order to prevent the pool
	* from suspending. A suspended I/O will have no way to resume and
	* can prevent the zdb(8) command from terminating as expected.
	*/
	if (spa != NULL)
	spa->spa_failmode = ZIO_FAILURE_MODE_PANIC;

	argv++;
	argc--;
	if (dump_opt['r']) {
	error = zdb_copy_object(os, object, argv[1]);
	} else if (!dump_opt['R']) {
	flagbits['d'] = ZOR_FLAG_DIRECTORY;
	flagbits['f'] = ZOR_FLAG_PLAIN_FILE;
	flagbits['m'] = ZOR_FLAG_SPACE_MAP;
	flagbits['z'] = ZOR_FLAG_ZAP;
	flagbits['A'] = ZOR_FLAG_ALL_TYPES;

	if (argc > 0 && dump_opt['d']) {
	zopt_object_args = argc;
	zopt_object_ranges = calloc(zopt_object_args,
	sizeof (zopt_object_range_t));
	for (unsigned i = 0; i < zopt_object_args; i++) {
	int err;
	char *msg = NULL;

	err = parse_object_range(argv[i],
	&zopt_object_ranges[i], &msg);
	if (err != 0)
	fatal("Bad object or range: '%s': %s\n",
	argv[i], msg ? msg : "");
	}
	} else if (argc > 0 && dump_opt['m']) {
	zopt_metaslab_args = argc;
	zopt_metaslab = calloc(zopt_metaslab_args,
	sizeof (uint64_t));
	for (unsigned i = 0; i < zopt_metaslab_args; i++) {
	errno = 0;
	zopt_metaslab[i] = strtoull(argv[i], NULL, 0);
	if (zopt_metaslab[i] == 0 && errno != 0)
	fatal("bad number %s: %s", argv[i],
	strerror(errno));
	}
	}
	if (os != NULL) {
	dump_objset(os);
	} else if (zopt_object_args > 0 && !dump_opt['m']) {
	dump_objset(spa->spa_meta_objset);
	} else {
	dump_zpool(spa);
	}
	} else {
	flagbits['b'] = ZDB_FLAG_PRINT_BLKPTR;
	flagbits['c'] = ZDB_FLAG_CHECKSUM;
	flagbits['d'] = ZDB_FLAG_DECOMPRESS;
	flagbits['e'] = ZDB_FLAG_BSWAP;
	flagbits['g'] = ZDB_FLAG_GBH;
	flagbits['i'] = ZDB_FLAG_INDIRECT;
	flagbits['r'] = ZDB_FLAG_RAW;
	flagbits['v'] = ZDB_FLAG_VERBOSE;

	for (int i = 0; i < argc; i++)
	zdb_read_block(argv[i], spa);
	}

	if (dump_opt['k']) {
	free(checkpoint_pool);
	if (!target_is_spa)
	free(checkpoint_target);
	}

	if (os != NULL) {
	close_objset(os, FTAG);
	} else {
	spa_close(spa, FTAG);
	}

	fuid_table_destroy();

	dump_debug_buffer();

	kernel_fini();

	return (error);
	}
	diff --git a/sys/contrib/openzfs/cmd/zed/agents/zfs_agents.c b/sys/contrib/openzfs/cmd/zed/agents/zfs_agents.c
	index 67b7951b0e65..35dd818ff80d 100644
	--- a/sys/contrib/openzfs/cmd/zed/agents/zfs_agents.c
	+++ b/sys/contrib/openzfs/cmd/zed/agents/zfs_agents.c
	@@ -1,431 +1,432 @@
	/*
	* CDDL HEADER START
	*
	* The contents of this file are subject to the terms of the
	* Common Development and Distribution License Version 1.0 (CDDL-1.0).
	* You can obtain a copy of the license from the top-level file
	* "OPENSOLARIS.LICENSE" or at <http://opensource.org/licenses/CDDL-1.0>.
	* You may not use this file except in compliance with the license.
	*
	* CDDL HEADER END
	*/

	/*
	* Copyright (c) 2016, Intel Corporation.
	* Copyright (c) 2018, loli10K <ezomori.nozomu@gmail.com>
	* Copyright (c) 2021 Hewlett Packard Enterprise Development LP
	*/

	#include <libnvpair.h>
	#include <libzfs.h>
	#include <stddef.h>
	#include <stdlib.h>
	#include <string.h>
	#include <sys/list.h>
	#include <sys/time.h>
	#include <sys/sysevent/eventdefs.h>
	#include <sys/sysevent/dev.h>
	#include <sys/fm/protocol.h>
	#include <sys/fm/fs/zfs.h>
	#include <pthread.h>
	#include <unistd.h>

	#include "zfs_agents.h"
	#include "fmd_api.h"
	#include "../zed_log.h"

	/*
	* agent dispatch code
	*/

	static pthread_mutex_t agent_lock = PTHREAD_MUTEX_INITIALIZER;
	static pthread_cond_t agent_cond = PTHREAD_COND_INITIALIZER;
	static list_t agent_events; /* list of pending events */
	static int agent_exiting;

	typedef struct agent_event {
	char ae_class[64];
	char ae_subclass[32];
	nvlist_t *ae_nvl;
	list_node_t ae_node;
	} agent_event_t;

	pthread_t g_agents_tid;

	libzfs_handle_t *g_zfs_hdl;

	/* guid search data */
	typedef enum device_type {
	DEVICE_TYPE_L2ARC, /* l2arc device */
	DEVICE_TYPE_SPARE, /* spare device */
	DEVICE_TYPE_PRIMARY /* any primary pool storage device */
	} device_type_t;

	typedef struct guid_search {
	uint64_t gs_pool_guid;
	uint64_t gs_vdev_guid;
	char *gs_devid;
	device_type_t gs_vdev_type;
	uint64_t gs_vdev_expandtime; /* vdev expansion time */
	} guid_search_t;

	/*
	* Walks the vdev tree recursively looking for a matching devid.
	* Returns B_TRUE as soon as a matching device is found, B_FALSE otherwise.
	*/
	static boolean_t
	zfs_agent_iter_vdev(zpool_handle_t zhp, nvlist_t nvl, void *arg)
	{
	guid_search_t *gsp = arg;
	char *path = NULL;
	uint_t c, children;
	nvlist_t **child;

	/*
	* First iterate over any children.
	*/
	if (nvlist_lookup_nvlist_array(nvl, ZPOOL_CONFIG_CHILDREN,
	&child, &children) == 0) {
	for (c = 0; c < children; c++) {
	if (zfs_agent_iter_vdev(zhp, child[c], gsp)) {
	gsp->gs_vdev_type = DEVICE_TYPE_PRIMARY;
	return (B_TRUE);
	}
	}
	}
	/*
	* Iterate over any spares and cache devices
	*/
	if (nvlist_lookup_nvlist_array(nvl, ZPOOL_CONFIG_SPARES,
	&child, &children) == 0) {
	for (c = 0; c < children; c++) {
	if (zfs_agent_iter_vdev(zhp, child[c], gsp)) {
	gsp->gs_vdev_type = DEVICE_TYPE_L2ARC;
	return (B_TRUE);
	}
	}
	}
	if (nvlist_lookup_nvlist_array(nvl, ZPOOL_CONFIG_L2CACHE,
	&child, &children) == 0) {
	for (c = 0; c < children; c++) {
	if (zfs_agent_iter_vdev(zhp, child[c], gsp)) {
	gsp->gs_vdev_type = DEVICE_TYPE_SPARE;
	return (B_TRUE);
	}
	}
	}
	/*
	* On a devid match, grab the vdev guid and expansion time, if any.
	*/
	if (gsp->gs_devid != NULL &&
	(nvlist_lookup_string(nvl, ZPOOL_CONFIG_DEVID, &path) == 0) &&
	(strcmp(gsp->gs_devid, path) == 0)) {
	(void) nvlist_lookup_uint64(nvl, ZPOOL_CONFIG_GUID,
	&gsp->gs_vdev_guid);
	(void) nvlist_lookup_uint64(nvl, ZPOOL_CONFIG_EXPANSION_TIME,
	&gsp->gs_vdev_expandtime);
	return (B_TRUE);
	}

	return (B_FALSE);
	}

	static int
	zfs_agent_iter_pool(zpool_handle_t zhp, void arg)
	{
	guid_search_t *gsp = arg;
	nvlist_t config, nvl;

	/*
	* For each vdev in this pool, look for a match by devid
	*/
	if ((config = zpool_get_config(zhp, NULL)) != NULL) {
	if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
	&nvl) == 0) {
	(void) zfs_agent_iter_vdev(zhp, nvl, gsp);
	}
	}
	/*
	* if a match was found then grab the pool guid
	*/
	if (gsp->gs_vdev_guid) {
	(void) nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID,
	&gsp->gs_pool_guid);
	}

	zpool_close(zhp);
	return (gsp->gs_vdev_guid != 0);
	}

	void
	zfs_agent_post_event(const char class, const char subclass, nvlist_t *nvl)
	{
	agent_event_t *event;

	if (subclass == NULL)
	subclass = "";

	event = malloc(sizeof (agent_event_t));
	if (event == NULL \|\| nvlist_dup(nvl, &event->ae_nvl, 0) != 0) {
	if (event)
	free(event);
	return;
	}

	if (strcmp(class, "sysevent.fs.zfs.vdev_check") == 0) {
	class = EC_ZFS;
	subclass = ESC_ZFS_VDEV_CHECK;
	}

	/*
	* On Linux, we don't get the expected FM_RESOURCE_REMOVED ereport
	* from the vdev_disk layer after a hot unplug. Fortunately we do
	* get an EC_DEV_REMOVE from our disk monitor and it is a suitable
	* proxy so we remap it here for the benefit of the diagnosis engine.
	* Starting in OpenZFS 2.0, we do get FM_RESOURCE_REMOVED from the spa
	* layer. Processing multiple FM_RESOURCE_REMOVED events is not harmful.
	*/
	if ((strcmp(class, EC_DEV_REMOVE) == 0) &&
	(strcmp(subclass, ESC_DISK) == 0) &&
	(nvlist_exists(nvl, ZFS_EV_VDEV_GUID) \|\|
	nvlist_exists(nvl, DEV_IDENTIFIER))) {
	nvlist_t *payload = event->ae_nvl;
	struct timeval tv;
	int64_t tod[2];
	uint64_t pool_guid = 0, vdev_guid = 0;
	guid_search_t search = { 0 };
	device_type_t devtype = DEVICE_TYPE_PRIMARY;

	class = "resource.fs.zfs.removed";
	subclass = "";

	(void) nvlist_add_string(payload, FM_CLASS, class);
	(void) nvlist_lookup_uint64(nvl, ZFS_EV_POOL_GUID, &pool_guid);
	(void) nvlist_lookup_uint64(nvl, ZFS_EV_VDEV_GUID, &vdev_guid);

	(void) gettimeofday(&tv, NULL);
	tod[0] = tv.tv_sec;
	tod[1] = tv.tv_usec;
	(void) nvlist_add_int64_array(payload, FM_EREPORT_TIME, tod, 2);

	/*
	* For multipath, spare and l2arc devices ZFS_EV_VDEV_GUID or
	* ZFS_EV_POOL_GUID may be missing so find them.
	*/
	if (pool_guid == 0 \|\| vdev_guid == 0) {
	if ((nvlist_lookup_string(nvl, DEV_IDENTIFIER,
	&search.gs_devid) == 0) &&
	(zpool_iter(g_zfs_hdl, zfs_agent_iter_pool, &search)
	== 1)) {
	if (pool_guid == 0)
	pool_guid = search.gs_pool_guid;
	if (vdev_guid == 0)
	vdev_guid = search.gs_vdev_guid;
	devtype = search.gs_vdev_type;
	}
	}

	/*
	* We want to avoid reporting "remove" events coming from
	* libudev for VDEVs which were expanded recently (10s) and
	* avoid activating spares in response to partitions being
	* deleted and created in rapid succession.
	*/
	if (search.gs_vdev_expandtime != 0 &&
	search.gs_vdev_expandtime + 10 > tv.tv_sec) {
	zed_log_msg(LOG_INFO, "agent post event: ignoring '%s' "
	"for recently expanded device '%s'", EC_DEV_REMOVE,
	search.gs_devid);
	goto out;
	}

	(void) nvlist_add_uint64(payload,
	FM_EREPORT_PAYLOAD_ZFS_POOL_GUID, pool_guid);
	(void) nvlist_add_uint64(payload,
	FM_EREPORT_PAYLOAD_ZFS_VDEV_GUID, vdev_guid);
	switch (devtype) {
	case DEVICE_TYPE_L2ARC:
	(void) nvlist_add_string(payload,
	FM_EREPORT_PAYLOAD_ZFS_VDEV_TYPE,
	VDEV_TYPE_L2CACHE);
	break;
	case DEVICE_TYPE_SPARE:
	(void) nvlist_add_string(payload,
	FM_EREPORT_PAYLOAD_ZFS_VDEV_TYPE, VDEV_TYPE_SPARE);
	break;
	case DEVICE_TYPE_PRIMARY:
	(void) nvlist_add_string(payload,
	FM_EREPORT_PAYLOAD_ZFS_VDEV_TYPE, VDEV_TYPE_DISK);
	break;
	}

	zed_log_msg(LOG_INFO, "agent post event: mapping '%s' to '%s'",
	EC_DEV_REMOVE, class);
	}

	(void) strlcpy(event->ae_class, class, sizeof (event->ae_class));
	(void) strlcpy(event->ae_subclass, subclass,
	sizeof (event->ae_subclass));

	(void) pthread_mutex_lock(&agent_lock);
	list_insert_tail(&agent_events, event);
	(void) pthread_mutex_unlock(&agent_lock);

	out:
	(void) pthread_cond_signal(&agent_cond);
	}

	static void
	zfs_agent_dispatch(const char class, const char subclass, nvlist_t *nvl)
	{
	/*
	* The diagnosis engine subscribes to the following events.
	* On illumos these subscriptions reside in:
	* /usr/lib/fm/fmd/plugins/zfs-diagnosis.conf
	*/
	if (strstr(class, "ereport.fs.zfs.") != NULL \|\|
	strstr(class, "resource.fs.zfs.") != NULL \|\|
	strcmp(class, "sysevent.fs.zfs.vdev_remove") == 0 \|\|
	strcmp(class, "sysevent.fs.zfs.vdev_remove_dev") == 0 \|\|
	strcmp(class, "sysevent.fs.zfs.pool_destroy") == 0) {
	fmd_module_recv(fmd_module_hdl("zfs-diagnosis"), nvl, class);
	}

	/*
	* The retire agent subscribes to the following events.
	* On illumos these subscriptions reside in:
	* /usr/lib/fm/fmd/plugins/zfs-retire.conf
	*
	* NOTE: faults events come directly from our diagnosis engine
	* and will not pass through the zfs kernel module.
	*/
	if (strcmp(class, FM_LIST_SUSPECT_CLASS) == 0 \|\|
	strcmp(class, "resource.fs.zfs.removed") == 0 \|\|
	strcmp(class, "resource.fs.zfs.statechange") == 0 \|\|
	strcmp(class, "sysevent.fs.zfs.vdev_remove") == 0) {
	fmd_module_recv(fmd_module_hdl("zfs-retire"), nvl, class);
	}

	/*
	* The SLM module only consumes disk events and vdev check events
	*
	* NOTE: disk events come directly from disk monitor and will
	* not pass through the zfs kernel module.
	*/
	if (strstr(class, "EC_dev_") != NULL \|\|
	strcmp(class, EC_ZFS) == 0) {
	(void) zfs_slm_event(class, subclass, nvl);
	}
	}

	/*
	* Events are consumed and dispatched from this thread
	* An agent can also post an event so event list lock
	* is not held when calling an agent.
	* One event is consumed at a time.
	*/
	static void *
	zfs_agent_consumer_thread(void *arg)
	{
	for (;;) {
	agent_event_t *event;

	(void) pthread_mutex_lock(&agent_lock);

	/* wait for an event to show up */
	while (!agent_exiting && list_is_empty(&agent_events))
	(void) pthread_cond_wait(&agent_cond, &agent_lock);

	if (agent_exiting) {
	(void) pthread_mutex_unlock(&agent_lock);
	zed_log_msg(LOG_INFO, "zfs_agent_consumer_thread: "
	"exiting");
	return (NULL);
	}

	if ((event = (list_head(&agent_events))) != NULL) {
	list_remove(&agent_events, event);

	(void) pthread_mutex_unlock(&agent_lock);

	/* dispatch to all event subscribers */
	zfs_agent_dispatch(event->ae_class, event->ae_subclass,
	event->ae_nvl);

	nvlist_free(event->ae_nvl);
	free(event);
	continue;
	}

	(void) pthread_mutex_unlock(&agent_lock);
	}

	return (NULL);
	}

	void
	zfs_agent_init(libzfs_handle_t *zfs_hdl)
	{
	fmd_hdl_t *hdl;

	g_zfs_hdl = zfs_hdl;

	if (zfs_slm_init() != 0)
	zed_log_die("Failed to initialize zfs slm");
	zed_log_msg(LOG_INFO, "Add Agent: init");

	hdl = fmd_module_hdl("zfs-diagnosis");
	_zfs_diagnosis_init(hdl);
	if (!fmd_module_initialized(hdl))
	zed_log_die("Failed to initialize zfs diagnosis");

	hdl = fmd_module_hdl("zfs-retire");
	_zfs_retire_init(hdl);
	if (!fmd_module_initialized(hdl))
	zed_log_die("Failed to initialize zfs retire");

	list_create(&agent_events, sizeof (agent_event_t),
	offsetof(struct agent_event, ae_node));

	if (pthread_create(&g_agents_tid, NULL, zfs_agent_consumer_thread,
	NULL) != 0) {
	list_destroy(&agent_events);
	zed_log_die("Failed to initialize agents");
	}
	+ pthread_setname_np(g_agents_tid, "agents");
	}

	void
	zfs_agent_fini(void)
	{
	fmd_hdl_t *hdl;
	agent_event_t *event;

	agent_exiting = 1;
	(void) pthread_cond_signal(&agent_cond);

	/* wait for zfs_enum_pools thread to complete */
	(void) pthread_join(g_agents_tid, NULL);

	/* drain any pending events */
	while ((event = (list_head(&agent_events))) != NULL) {
	list_remove(&agent_events, event);
	nvlist_free(event->ae_nvl);
	free(event);
	}

	list_destroy(&agent_events);

	if ((hdl = fmd_module_hdl("zfs-retire")) != NULL) {
	_zfs_retire_fini(hdl);
	fmd_hdl_unregister(hdl);
	}
	if ((hdl = fmd_module_hdl("zfs-diagnosis")) != NULL) {
	_zfs_diagnosis_fini(hdl);
	fmd_hdl_unregister(hdl);
	}

	zed_log_msg(LOG_INFO, "Add Agent: fini");
	zfs_slm_fini();

	g_zfs_hdl = NULL;
	}
	diff --git a/sys/contrib/openzfs/cmd/zed/agents/zfs_mod.c b/sys/contrib/openzfs/cmd/zed/agents/zfs_mod.c
	index 4a58e1f1dbd3..b564f2b12a26 100644
	--- a/sys/contrib/openzfs/cmd/zed/agents/zfs_mod.c
	+++ b/sys/contrib/openzfs/cmd/zed/agents/zfs_mod.c
	@@ -1,962 +1,963 @@
	/*
	* 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) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2012 by Delphix. All rights reserved.
	* Copyright 2014 Nexenta Systems, Inc. All rights reserved.
	* Copyright (c) 2016, 2017, Intel Corporation.
	* Copyright (c) 2017 Open-E, Inc. All Rights Reserved.
	*/

	/*
	* ZFS syseventd module.
	*
	* file origin: openzfs/usr/src/cmd/syseventd/modules/zfs_mod/zfs_mod.c
	*
	* The purpose of this module is to identify when devices are added to the
	* system, and appropriately online or replace the affected vdevs.
	*
	* When a device is added to the system:
	*
	* 1. Search for any vdevs whose devid matches that of the newly added
	* device.
	*
	* 2. If no vdevs are found, then search for any vdevs whose udev path
	* matches that of the new device.
	*
	* 3. If no vdevs match by either method, then ignore the event.
	*
	* 4. Attempt to online the device with a flag to indicate that it should
	* be unspared when resilvering completes. If this succeeds, then the
	* same device was inserted and we should continue normally.
	*
	* 5. If the pool does not have the 'autoreplace' property set, attempt to
	* online the device again without the unspare flag, which will
	* generate a FMA fault.
	*
	* 6. If the pool has the 'autoreplace' property set, and the matching vdev
	* is a whole disk, then label the new disk and attempt a 'zpool
	* replace'.
	*
	* The module responds to EC_DEV_ADD events. The special ESC_ZFS_VDEV_CHECK
	* event indicates that a device failed to open during pool load, but the
	* autoreplace property was set. In this case, we deferred the associated
	* FMA fault until our module had a chance to process the autoreplace logic.
	* If the device could not be replaced, then the second online attempt will
	* trigger the FMA fault that we skipped earlier.
	*
	* On Linux udev provides a disk insert for both the disk and the partition.
	*/

	#include <ctype.h>
	#include <fcntl.h>
	#include <libnvpair.h>
	#include <libzfs.h>
	#include <libzutil.h>
	#include <limits.h>
	#include <stddef.h>
	#include <stdlib.h>
	#include <string.h>
	#include <syslog.h>
	#include <sys/list.h>
	#include <sys/sunddi.h>
	#include <sys/sysevent/eventdefs.h>
	#include <sys/sysevent/dev.h>
	#include <thread_pool.h>
	#include <pthread.h>
	#include <unistd.h>
	#include <errno.h>
	#include "zfs_agents.h"
	#include "../zed_log.h"

	#define DEV_BYID_PATH "/dev/disk/by-id/"
	#define DEV_BYPATH_PATH "/dev/disk/by-path/"
	#define DEV_BYVDEV_PATH "/dev/disk/by-vdev/"

	typedef void (zfs_process_func_t)(zpool_handle_t , nvlist_t *, boolean_t);

	libzfs_handle_t *g_zfshdl;
	list_t g_pool_list; /* list of unavailable pools at initialization */
	list_t g_device_list; /* list of disks with asynchronous label request */
	tpool_t *g_tpool;
	boolean_t g_enumeration_done;
	pthread_t g_zfs_tid; /* zfs_enum_pools() thread */

	typedef struct unavailpool {
	zpool_handle_t *uap_zhp;
	list_node_t uap_node;
	} unavailpool_t;

	typedef struct pendingdev {
	char pd_physpath[128];
	list_node_t pd_node;
	} pendingdev_t;

	static int
	zfs_toplevel_state(zpool_handle_t *zhp)
	{
	nvlist_t *nvroot;
	vdev_stat_t *vs;
	unsigned int c;

	verify(nvlist_lookup_nvlist(zpool_get_config(zhp, NULL),
	ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0);
	verify(nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_VDEV_STATS,
	(uint64_t **)&vs, &c) == 0);
	return (vs->vs_state);
	}

	static int
	zfs_unavail_pool(zpool_handle_t zhp, void data)
	{
	zed_log_msg(LOG_INFO, "zfs_unavail_pool: examining '%s' (state %d)",
	zpool_get_name(zhp), (int)zfs_toplevel_state(zhp));

	if (zfs_toplevel_state(zhp) < VDEV_STATE_DEGRADED) {
	unavailpool_t *uap;
	uap = malloc(sizeof (unavailpool_t));
	uap->uap_zhp = zhp;
	list_insert_tail((list_t *)data, uap);
	} else {
	zpool_close(zhp);
	}
	return (0);
	}

	/*
	* Two stage replace on Linux
	* since we get disk notifications
	* we can wait for partitioned disk slice to show up!
	*
	* First stage tags the disk, initiates async partitioning, and returns
	* Second stage finds the tag and proceeds to ZFS labeling/replace
	*
	* disk-add --> label-disk + tag-disk --> partition-add --> zpool_vdev_attach
	*
	* 1. physical match with no fs, no partition
	* tag it top, partition disk
	*
	* 2. physical match again, see partition and tag
	*
	*/

	/*
	* The device associated with the given vdev (either by devid or physical path)
	* has been added to the system. If 'isdisk' is set, then we only attempt a
	* replacement if it's a whole disk. This also implies that we should label the
	* disk first.
	*
	* First, we attempt to online the device (making sure to undo any spare
	* operation when finished). If this succeeds, then we're done. If it fails,
	* and the new state is VDEV_CANT_OPEN, it indicates that the device was opened,
	* but that the label was not what we expected. If the 'autoreplace' property
	* is enabled, then we relabel the disk (if specified), and attempt a 'zpool
	* replace'. If the online is successful, but the new state is something else
	* (REMOVED or FAULTED), it indicates that we're out of sync or in some sort of
	* race, and we should avoid attempting to relabel the disk.
	*
	* Also can arrive here from a ESC_ZFS_VDEV_CHECK event
	*/
	static void
	zfs_process_add(zpool_handle_t zhp, nvlist_t vdev, boolean_t labeled)
	{
	char *path;
	vdev_state_t newstate;
	nvlist_t nvroot, newvd;
	pendingdev_t *device;
	uint64_t wholedisk = 0ULL;
	uint64_t offline = 0ULL;
	uint64_t guid = 0ULL;
	char physpath = NULL, new_devid = NULL, *enc_sysfs_path = NULL;
	char rawpath[PATH_MAX], fullpath[PATH_MAX];
	char devpath[PATH_MAX];
	int ret;
	boolean_t is_dm = B_FALSE;
	boolean_t is_sd = B_FALSE;
	uint_t c;
	vdev_stat_t *vs;

	if (nvlist_lookup_string(vdev, ZPOOL_CONFIG_PATH, &path) != 0)
	return;

	/* Skip healthy disks */
	verify(nvlist_lookup_uint64_array(vdev, ZPOOL_CONFIG_VDEV_STATS,
	(uint64_t **)&vs, &c) == 0);
	if (vs->vs_state == VDEV_STATE_HEALTHY) {
	zed_log_msg(LOG_INFO, "%s: %s is already healthy, skip it.",
	__func__, path);
	return;
	}

	(void) nvlist_lookup_string(vdev, ZPOOL_CONFIG_PHYS_PATH, &physpath);
	(void) nvlist_lookup_string(vdev, ZPOOL_CONFIG_VDEV_ENC_SYSFS_PATH,
	&enc_sysfs_path);
	(void) nvlist_lookup_uint64(vdev, ZPOOL_CONFIG_WHOLE_DISK, &wholedisk);
	(void) nvlist_lookup_uint64(vdev, ZPOOL_CONFIG_OFFLINE, &offline);
	(void) nvlist_lookup_uint64(vdev, ZPOOL_CONFIG_GUID, &guid);

	if (offline)
	return; /* don't intervene if it was taken offline */

	is_dm = zfs_dev_is_dm(path);
	zed_log_msg(LOG_INFO, "zfs_process_add: pool '%s' vdev '%s', phys '%s'"
	" wholedisk %d, %s dm (guid %llu)", zpool_get_name(zhp), path,
	physpath ? physpath : "NULL", wholedisk, is_dm ? "is" : "not",
	(long long unsigned int)guid);

	/*
	* The VDEV guid is preferred for identification (gets passed in path)
	*/
	if (guid != 0) {
	(void) snprintf(fullpath, sizeof (fullpath), "%llu",
	(long long unsigned int)guid);
	} else {
	/*
	* otherwise use path sans partition suffix for whole disks
	*/
	(void) strlcpy(fullpath, path, sizeof (fullpath));
	if (wholedisk) {
	char *spath = zfs_strip_partition(fullpath);
	if (!spath) {
	zed_log_msg(LOG_INFO, "%s: Can't alloc",
	__func__);
	return;
	}

	(void) strlcpy(fullpath, spath, sizeof (fullpath));
	free(spath);
	}
	}

	/*
	* Attempt to online the device.
	*/
	if (zpool_vdev_online(zhp, fullpath,
	ZFS_ONLINE_CHECKREMOVE \| ZFS_ONLINE_UNSPARE, &newstate) == 0 &&
	(newstate == VDEV_STATE_HEALTHY \|\|
	newstate == VDEV_STATE_DEGRADED)) {
	zed_log_msg(LOG_INFO, " zpool_vdev_online: vdev %s is %s",
	fullpath, (newstate == VDEV_STATE_HEALTHY) ?
	"HEALTHY" : "DEGRADED");
	return;
	}

	/*
	* vdev_id alias rule for using scsi_debug devices (FMA automated
	* testing)
	*/
	if (physpath != NULL && strcmp("scsidebug", physpath) == 0)
	is_sd = B_TRUE;

	/*
	* If the pool doesn't have the autoreplace property set, then use
	* vdev online to trigger a FMA fault by posting an ereport.
	*/
	if (!zpool_get_prop_int(zhp, ZPOOL_PROP_AUTOREPLACE, NULL) \|\|
	!(wholedisk \|\| is_dm) \|\| (physpath == NULL)) {
	(void) zpool_vdev_online(zhp, fullpath, ZFS_ONLINE_FORCEFAULT,
	&newstate);
	zed_log_msg(LOG_INFO, "Pool's autoreplace is not enabled or "
	"not a whole disk for '%s'", fullpath);
	return;
	}

	/*
	* Convert physical path into its current device node. Rawpath
	* needs to be /dev/disk/by-vdev for a scsi_debug device since
	* /dev/disk/by-path will not be present.
	*/
	(void) snprintf(rawpath, sizeof (rawpath), "%s%s",
	is_sd ? DEV_BYVDEV_PATH : DEV_BYPATH_PATH, physpath);

	if (realpath(rawpath, devpath) == NULL && !is_dm) {
	zed_log_msg(LOG_INFO, " realpath: %s failed (%s)",
	rawpath, strerror(errno));

	(void) zpool_vdev_online(zhp, fullpath, ZFS_ONLINE_FORCEFAULT,
	&newstate);

	zed_log_msg(LOG_INFO, " zpool_vdev_online: %s FORCEFAULT (%s)",
	fullpath, libzfs_error_description(g_zfshdl));
	return;
	}

	/* Only autoreplace bad disks */
	if ((vs->vs_state != VDEV_STATE_DEGRADED) &&
	(vs->vs_state != VDEV_STATE_FAULTED) &&
	(vs->vs_state != VDEV_STATE_CANT_OPEN)) {
	return;
	}

	nvlist_lookup_string(vdev, "new_devid", &new_devid);

	if (is_dm) {
	/* Don't label device mapper or multipath disks. */
	} else if (!labeled) {
	/*
	* we're auto-replacing a raw disk, so label it first
	*/
	char *leafname;

	/*
	* If this is a request to label a whole disk, then attempt to
	* write out the label. Before we can label the disk, we need
	* to map the physical string that was matched on to the under
	* lying device node.
	*
	* If any part of this process fails, then do a force online
	* to trigger a ZFS fault for the device (and any hot spare
	* replacement).
	*/
	leafname = strrchr(devpath, '/') + 1;

	/*
	* If this is a request to label a whole disk, then attempt to
	* write out the label.
	*/
	if (zpool_label_disk(g_zfshdl, zhp, leafname) != 0) {
	zed_log_msg(LOG_INFO, " zpool_label_disk: could not "
	"label '%s' (%s)", leafname,
	libzfs_error_description(g_zfshdl));

	(void) zpool_vdev_online(zhp, fullpath,
	ZFS_ONLINE_FORCEFAULT, &newstate);
	return;
	}

	/*
	* The disk labeling is asynchronous on Linux. Just record
	* this label request and return as there will be another
	* disk add event for the partition after the labeling is
	* completed.
	*/
	device = malloc(sizeof (pendingdev_t));
	(void) strlcpy(device->pd_physpath, physpath,
	sizeof (device->pd_physpath));
	list_insert_tail(&g_device_list, device);

	zed_log_msg(LOG_INFO, " zpool_label_disk: async '%s' (%llu)",
	leafname, (u_longlong_t)guid);

	return; /* resumes at EC_DEV_ADD.ESC_DISK for partition */

	} else /* labeled */ {
	boolean_t found = B_FALSE;
	/*
	* match up with request above to label the disk
	*/
	for (device = list_head(&g_device_list); device != NULL;
	device = list_next(&g_device_list, device)) {
	if (strcmp(physpath, device->pd_physpath) == 0) {
	list_remove(&g_device_list, device);
	free(device);
	found = B_TRUE;
	break;
	}
	zed_log_msg(LOG_INFO, "zpool_label_disk: %s != %s",
	physpath, device->pd_physpath);
	}
	if (!found) {
	/* unexpected partition slice encountered */
	zed_log_msg(LOG_INFO, "labeled disk %s unexpected here",
	fullpath);
	(void) zpool_vdev_online(zhp, fullpath,
	ZFS_ONLINE_FORCEFAULT, &newstate);
	return;
	}

	zed_log_msg(LOG_INFO, " zpool_label_disk: resume '%s' (%llu)",
	physpath, (u_longlong_t)guid);

	(void) snprintf(devpath, sizeof (devpath), "%s%s",
	DEV_BYID_PATH, new_devid);
	}

	/*
	* Construct the root vdev to pass to zpool_vdev_attach(). While adding
	* the entire vdev structure is harmless, we construct a reduced set of
	* path/physpath/wholedisk to keep it simple.
	*/
	if (nvlist_alloc(&nvroot, NV_UNIQUE_NAME, 0) != 0) {
	zed_log_msg(LOG_WARNING, "zfs_mod: nvlist_alloc out of memory");
	return;
	}
	if (nvlist_alloc(&newvd, NV_UNIQUE_NAME, 0) != 0) {
	zed_log_msg(LOG_WARNING, "zfs_mod: nvlist_alloc out of memory");
	nvlist_free(nvroot);
	return;
	}

	if (nvlist_add_string(newvd, ZPOOL_CONFIG_TYPE, VDEV_TYPE_DISK) != 0 \|\|
	nvlist_add_string(newvd, ZPOOL_CONFIG_PATH, path) != 0 \|\|
	nvlist_add_string(newvd, ZPOOL_CONFIG_DEVID, new_devid) != 0 \|\|
	(physpath != NULL && nvlist_add_string(newvd,
	ZPOOL_CONFIG_PHYS_PATH, physpath) != 0) \|\|
	(enc_sysfs_path != NULL && nvlist_add_string(newvd,
	ZPOOL_CONFIG_VDEV_ENC_SYSFS_PATH, enc_sysfs_path) != 0) \|\|
	nvlist_add_uint64(newvd, ZPOOL_CONFIG_WHOLE_DISK, wholedisk) != 0 \|\|
	nvlist_add_string(nvroot, ZPOOL_CONFIG_TYPE, VDEV_TYPE_ROOT) != 0 \|\|
	nvlist_add_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN, &newvd,
	1) != 0) {
	zed_log_msg(LOG_WARNING, "zfs_mod: unable to add nvlist pairs");
	nvlist_free(newvd);
	nvlist_free(nvroot);
	return;
	}

	nvlist_free(newvd);

	/*
	* Wait for udev to verify the links exist, then auto-replace
	* the leaf disk at same physical location.
	*/
	if (zpool_label_disk_wait(path, 3000) != 0) {
	zed_log_msg(LOG_WARNING, "zfs_mod: expected replacement "
	"disk %s is missing", path);
	nvlist_free(nvroot);
	return;
	}

	/*
	* Prefer sequential resilvering when supported (mirrors and dRAID),
	* otherwise fallback to a traditional healing resilver.
	*/
	ret = zpool_vdev_attach(zhp, fullpath, path, nvroot, B_TRUE, B_TRUE);
	if (ret != 0) {
	ret = zpool_vdev_attach(zhp, fullpath, path, nvroot,
	B_TRUE, B_FALSE);
	}

	zed_log_msg(LOG_INFO, " zpool_vdev_replace: %s with %s (%s)",
	fullpath, path, (ret == 0) ? "no errors" :
	libzfs_error_description(g_zfshdl));

	nvlist_free(nvroot);
	}

	/*
	* Utility functions to find a vdev matching given criteria.
	*/
	typedef struct dev_data {
	const char *dd_compare;
	const char *dd_prop;
	zfs_process_func_t dd_func;
	boolean_t dd_found;
	boolean_t dd_islabeled;
	uint64_t dd_pool_guid;
	uint64_t dd_vdev_guid;
	const char *dd_new_devid;
	} dev_data_t;

	static void
	zfs_iter_vdev(zpool_handle_t zhp, nvlist_t nvl, void *data)
	{
	dev_data_t *dp = data;
	char *path = NULL;
	uint_t c, children;
	nvlist_t **child;

	/*
	* First iterate over any children.
	*/
	if (nvlist_lookup_nvlist_array(nvl, ZPOOL_CONFIG_CHILDREN,
	&child, &children) == 0) {
	for (c = 0; c < children; c++)
	zfs_iter_vdev(zhp, child[c], data);
	}

	/*
	* Iterate over any spares and cache devices
	*/
	if (nvlist_lookup_nvlist_array(nvl, ZPOOL_CONFIG_SPARES,
	&child, &children) == 0) {
	for (c = 0; c < children; c++)
	zfs_iter_vdev(zhp, child[c], data);
	}
	if (nvlist_lookup_nvlist_array(nvl, ZPOOL_CONFIG_L2CACHE,
	&child, &children) == 0) {
	for (c = 0; c < children; c++)
	zfs_iter_vdev(zhp, child[c], data);
	}

	/* once a vdev was matched and processed there is nothing left to do */
	if (dp->dd_found)
	return;

	/*
	* Match by GUID if available otherwise fallback to devid or physical
	*/
	if (dp->dd_vdev_guid != 0) {
	uint64_t guid;

	if (nvlist_lookup_uint64(nvl, ZPOOL_CONFIG_GUID,
	&guid) != 0 \|\| guid != dp->dd_vdev_guid) {
	return;
	}
	zed_log_msg(LOG_INFO, " zfs_iter_vdev: matched on %llu", guid);
	dp->dd_found = B_TRUE;

	} else if (dp->dd_compare != NULL) {
	/*
	* NOTE: On Linux there is an event for partition, so unlike
	* illumos, substring matching is not required to accommodate
	* the partition suffix. An exact match will be present in
	* the dp->dd_compare value.
	*/
	if (nvlist_lookup_string(nvl, dp->dd_prop, &path) != 0 \|\|
	strcmp(dp->dd_compare, path) != 0)
	return;

	zed_log_msg(LOG_INFO, " zfs_iter_vdev: matched %s on %s",
	dp->dd_prop, path);
	dp->dd_found = B_TRUE;

	/* pass the new devid for use by replacing code */
	if (dp->dd_new_devid != NULL) {
	(void) nvlist_add_string(nvl, "new_devid",
	dp->dd_new_devid);
	}
	}

	(dp->dd_func)(zhp, nvl, dp->dd_islabeled);
	}

	static void
	zfs_enable_ds(void *arg)
	{
	unavailpool_t pool = (unavailpool_t )arg;

	(void) zpool_enable_datasets(pool->uap_zhp, NULL, 0);
	zpool_close(pool->uap_zhp);
	free(pool);
	}

	static int
	zfs_iter_pool(zpool_handle_t zhp, void data)
	{
	nvlist_t config, nvl;
	dev_data_t *dp = data;
	uint64_t pool_guid;
	unavailpool_t *pool;

	zed_log_msg(LOG_INFO, "zfs_iter_pool: evaluating vdevs on %s (by %s)",
	zpool_get_name(zhp), dp->dd_vdev_guid ? "GUID" : dp->dd_prop);

	/*
	* For each vdev in this pool, look for a match to apply dd_func
	*/
	if ((config = zpool_get_config(zhp, NULL)) != NULL) {
	if (dp->dd_pool_guid == 0 \|\|
	(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID,
	&pool_guid) == 0 && pool_guid == dp->dd_pool_guid)) {
	(void) nvlist_lookup_nvlist(config,
	ZPOOL_CONFIG_VDEV_TREE, &nvl);
	zfs_iter_vdev(zhp, nvl, data);
	}
	}

	/*
	* if this pool was originally unavailable,
	* then enable its datasets asynchronously
	*/
	if (g_enumeration_done) {
	for (pool = list_head(&g_pool_list); pool != NULL;
	pool = list_next(&g_pool_list, pool)) {

	if (strcmp(zpool_get_name(zhp),
	zpool_get_name(pool->uap_zhp)))
	continue;
	if (zfs_toplevel_state(zhp) >= VDEV_STATE_DEGRADED) {
	list_remove(&g_pool_list, pool);
	(void) tpool_dispatch(g_tpool, zfs_enable_ds,
	pool);
	break;
	}
	}
	}

	zpool_close(zhp);
	return (dp->dd_found); /* cease iteration after a match */
	}

	/*
	* Given a physical device location, iterate over all
	* (pool, vdev) pairs which correspond to that location.
	*/
	static boolean_t
	devphys_iter(const char physical, const char devid, zfs_process_func_t func,
	boolean_t is_slice)
	{
	dev_data_t data = { 0 };

	data.dd_compare = physical;
	data.dd_func = func;
	data.dd_prop = ZPOOL_CONFIG_PHYS_PATH;
	data.dd_found = B_FALSE;
	data.dd_islabeled = is_slice;
	data.dd_new_devid = devid; /* used by auto replace code */

	(void) zpool_iter(g_zfshdl, zfs_iter_pool, &data);

	return (data.dd_found);
	}

	/*
	* Given a device identifier, find any vdevs with a matching devid.
	* On Linux we can match devid directly which is always a whole disk.
	*/
	static boolean_t
	devid_iter(const char *devid, zfs_process_func_t func, boolean_t is_slice)
	{
	dev_data_t data = { 0 };

	data.dd_compare = devid;
	data.dd_func = func;
	data.dd_prop = ZPOOL_CONFIG_DEVID;
	data.dd_found = B_FALSE;
	data.dd_islabeled = is_slice;
	data.dd_new_devid = devid;

	(void) zpool_iter(g_zfshdl, zfs_iter_pool, &data);

	return (data.dd_found);
	}

	/*
	* Handle a EC_DEV_ADD.ESC_DISK event.
	*
	* illumos
	* Expects: DEV_PHYS_PATH string in schema
	* Matches: vdev's ZPOOL_CONFIG_PHYS_PATH or ZPOOL_CONFIG_DEVID
	*
	* path: '/dev/dsk/c0t1d0s0' (persistent)
	* devid: 'id1,sd@SATA_____Hitachi_HDS72101______JP2940HZ3H74MC/a'
	* phys_path: '/pci@0,0/pci103c,1609@11/disk@1,0:a'
	*
	* linux
	* provides: DEV_PHYS_PATH and DEV_IDENTIFIER strings in schema
	* Matches: vdev's ZPOOL_CONFIG_PHYS_PATH or ZPOOL_CONFIG_DEVID
	*
	* path: '/dev/sdc1' (not persistent)
	* devid: 'ata-SAMSUNG_HD204UI_S2HGJD2Z805891-part1'
	* phys_path: 'pci-0000:04:00.0-sas-0x4433221106000000-lun-0'
	*/
	static int
	zfs_deliver_add(nvlist_t *nvl, boolean_t is_lofi)
	{
	char devpath = NULL, devid;
	boolean_t is_slice;

	/*
	* Expecting a devid string and an optional physical location
	*/
	if (nvlist_lookup_string(nvl, DEV_IDENTIFIER, &devid) != 0)
	return (-1);

	(void) nvlist_lookup_string(nvl, DEV_PHYS_PATH, &devpath);

	is_slice = (nvlist_lookup_boolean(nvl, DEV_IS_PART) == 0);

	zed_log_msg(LOG_INFO, "zfs_deliver_add: adding %s (%s) (is_slice %d)",
	devid, devpath ? devpath : "NULL", is_slice);

	/*
	* Iterate over all vdevs looking for a match in the following order:
	* 1. ZPOOL_CONFIG_DEVID (identifies the unique disk)
	* 2. ZPOOL_CONFIG_PHYS_PATH (identifies disk physical location).
	*
	* For disks, we only want to pay attention to vdevs marked as whole
	* disks or are a multipath device.
	*/
	if (!devid_iter(devid, zfs_process_add, is_slice) && devpath != NULL)
	(void) devphys_iter(devpath, devid, zfs_process_add, is_slice);

	return (0);
	}

	/*
	* Called when we receive a VDEV_CHECK event, which indicates a device could not
	* be opened during initial pool open, but the autoreplace property was set on
	* the pool. In this case, we treat it as if it were an add event.
	*/
	static int
	zfs_deliver_check(nvlist_t *nvl)
	{
	dev_data_t data = { 0 };

	if (nvlist_lookup_uint64(nvl, ZFS_EV_POOL_GUID,
	&data.dd_pool_guid) != 0 \|\|
	nvlist_lookup_uint64(nvl, ZFS_EV_VDEV_GUID,
	&data.dd_vdev_guid) != 0 \|\|
	data.dd_vdev_guid == 0)
	return (0);

	zed_log_msg(LOG_INFO, "zfs_deliver_check: pool '%llu', vdev %llu",
	data.dd_pool_guid, data.dd_vdev_guid);

	data.dd_func = zfs_process_add;

	(void) zpool_iter(g_zfshdl, zfs_iter_pool, &data);

	return (0);
	}

	static int
	zfsdle_vdev_online(zpool_handle_t zhp, void data)
	{
	char *devname = data;
	boolean_t avail_spare, l2cache;
	nvlist_t *tgt;
	int error;

	zed_log_msg(LOG_INFO, "zfsdle_vdev_online: searching for '%s' in '%s'",
	devname, zpool_get_name(zhp));

	if ((tgt = zpool_find_vdev_by_physpath(zhp, devname,
	&avail_spare, &l2cache, NULL)) != NULL) {
	char *path, fullpath[MAXPATHLEN];
	uint64_t wholedisk;

	error = nvlist_lookup_string(tgt, ZPOOL_CONFIG_PATH, &path);
	if (error) {
	zpool_close(zhp);
	return (0);
	}

	error = nvlist_lookup_uint64(tgt, ZPOOL_CONFIG_WHOLE_DISK,
	&wholedisk);
	if (error)
	wholedisk = 0;

	if (wholedisk) {
	path = strrchr(path, '/');
	if (path != NULL) {
	path = zfs_strip_partition(path + 1);
	if (path == NULL) {
	zpool_close(zhp);
	return (0);
	}
	} else {
	zpool_close(zhp);
	return (0);
	}

	(void) strlcpy(fullpath, path, sizeof (fullpath));
	free(path);

	/*
	* We need to reopen the pool associated with this
	* device so that the kernel can update the size of
	* the expanded device. When expanding there is no
	* need to restart the scrub from the beginning.
	*/
	boolean_t scrub_restart = B_FALSE;
	(void) zpool_reopen_one(zhp, &scrub_restart);
	} else {
	(void) strlcpy(fullpath, path, sizeof (fullpath));
	}

	if (zpool_get_prop_int(zhp, ZPOOL_PROP_AUTOEXPAND, NULL)) {
	vdev_state_t newstate;

	if (zpool_get_state(zhp) != POOL_STATE_UNAVAIL) {
	error = zpool_vdev_online(zhp, fullpath, 0,
	&newstate);
	zed_log_msg(LOG_INFO, "zfsdle_vdev_online: "
	"setting device '%s' to ONLINE state "
	"in pool '%s': %d", fullpath,
	zpool_get_name(zhp), error);
	}
	}
	zpool_close(zhp);
	return (1);
	}
	zpool_close(zhp);
	return (0);
	}

	/*
	* This function handles the ESC_DEV_DLE device change event. Use the
	* provided vdev guid when looking up a disk or partition, when the guid
	* is not present assume the entire disk is owned by ZFS and append the
	* expected -part1 partition information then lookup by physical path.
	*/
	static int
	zfs_deliver_dle(nvlist_t *nvl)
	{
	char *devname, name[MAXPATHLEN];
	uint64_t guid;

	if (nvlist_lookup_uint64(nvl, ZFS_EV_VDEV_GUID, &guid) == 0) {
	sprintf(name, "%llu", (u_longlong_t)guid);
	} else if (nvlist_lookup_string(nvl, DEV_PHYS_PATH, &devname) == 0) {
	strlcpy(name, devname, MAXPATHLEN);
	zfs_append_partition(name, MAXPATHLEN);
	} else {
	zed_log_msg(LOG_INFO, "zfs_deliver_dle: no guid or physpath");
	}

	if (zpool_iter(g_zfshdl, zfsdle_vdev_online, name) != 1) {
	zed_log_msg(LOG_INFO, "zfs_deliver_dle: device '%s' not "
	"found", name);
	return (1);
	}

	return (0);
	}

	/*
	* syseventd daemon module event handler
	*
	* Handles syseventd daemon zfs device related events:
	*
	* EC_DEV_ADD.ESC_DISK
	* EC_DEV_STATUS.ESC_DEV_DLE
	* EC_ZFS.ESC_ZFS_VDEV_CHECK
	*
	* Note: assumes only one thread active at a time (not thread safe)
	*/
	static int
	zfs_slm_deliver_event(const char class, const char subclass, nvlist_t *nvl)
	{
	int ret;
	boolean_t is_lofi = B_FALSE, is_check = B_FALSE, is_dle = B_FALSE;

	if (strcmp(class, EC_DEV_ADD) == 0) {
	/*
	* We're mainly interested in disk additions, but we also listen
	* for new loop devices, to allow for simplified testing.
	*/
	if (strcmp(subclass, ESC_DISK) == 0)
	is_lofi = B_FALSE;
	else if (strcmp(subclass, ESC_LOFI) == 0)
	is_lofi = B_TRUE;
	else
	return (0);

	is_check = B_FALSE;
	} else if (strcmp(class, EC_ZFS) == 0 &&
	strcmp(subclass, ESC_ZFS_VDEV_CHECK) == 0) {
	/*
	* This event signifies that a device failed to open
	* during pool load, but the 'autoreplace' property was
	* set, so we should pretend it's just been added.
	*/
	is_check = B_TRUE;
	} else if (strcmp(class, EC_DEV_STATUS) == 0 &&
	strcmp(subclass, ESC_DEV_DLE) == 0) {
	is_dle = B_TRUE;
	} else {
	return (0);
	}

	if (is_dle)
	ret = zfs_deliver_dle(nvl);
	else if (is_check)
	ret = zfs_deliver_check(nvl);
	else
	ret = zfs_deliver_add(nvl, is_lofi);

	return (ret);
	}

	/ARGSUSED/
	static void *
	zfs_enum_pools(void *arg)
	{
	(void) zpool_iter(g_zfshdl, zfs_unavail_pool, (void *)&g_pool_list);
	/*
	* Linux - instead of using a thread pool, each list entry
	* will spawn a thread when an unavailable pool transitions
	* to available. zfs_slm_fini will wait for these threads.
	*/
	g_enumeration_done = B_TRUE;
	return (NULL);
	}

	/*
	* called from zed daemon at startup
	*
	* sent messages from zevents or udev monitor
	*
	* For now, each agent has its own libzfs instance
	*/
	int
	zfs_slm_init()
	{
	if ((g_zfshdl = libzfs_init()) == NULL)
	return (-1);

	/*
	* collect a list of unavailable pools (asynchronously,
	* since this can take a while)
	*/
	list_create(&g_pool_list, sizeof (struct unavailpool),
	offsetof(struct unavailpool, uap_node));

	if (pthread_create(&g_zfs_tid, NULL, zfs_enum_pools, NULL) != 0) {
	list_destroy(&g_pool_list);
	libzfs_fini(g_zfshdl);
	return (-1);
	}

	+ pthread_setname_np(g_zfs_tid, "enum-pools");
	list_create(&g_device_list, sizeof (struct pendingdev),
	offsetof(struct pendingdev, pd_node));

	return (0);
	}

	void
	zfs_slm_fini()
	{
	unavailpool_t *pool;
	pendingdev_t *device;

	/* wait for zfs_enum_pools thread to complete */
	(void) pthread_join(g_zfs_tid, NULL);
	/* destroy the thread pool */
	if (g_tpool != NULL) {
	tpool_wait(g_tpool);
	tpool_destroy(g_tpool);
	}

	while ((pool = (list_head(&g_pool_list))) != NULL) {
	list_remove(&g_pool_list, pool);
	zpool_close(pool->uap_zhp);
	free(pool);
	}
	list_destroy(&g_pool_list);

	while ((device = (list_head(&g_device_list))) != NULL) {
	list_remove(&g_device_list, device);
	free(device);
	}
	list_destroy(&g_device_list);

	libzfs_fini(g_zfshdl);
	}

	void
	zfs_slm_event(const char class, const char subclass, nvlist_t *nvl)
	{
	zed_log_msg(LOG_INFO, "zfs_slm_event: %s.%s", class, subclass);
	(void) zfs_slm_deliver_event(class, subclass, nvl);
	}
	diff --git a/sys/contrib/openzfs/cmd/zed/zed.c b/sys/contrib/openzfs/cmd/zed/zed.c
	index 907b8af0d01f..0aa03fded468 100644
	--- a/sys/contrib/openzfs/cmd/zed/zed.c
	+++ b/sys/contrib/openzfs/cmd/zed/zed.c
	@@ -1,306 +1,308 @@
	/*
	* This file is part of the ZFS Event Daemon (ZED).
	*
	* Developed at Lawrence Livermore National Laboratory (LLNL-CODE-403049).
	* Copyright (C) 2013-2014 Lawrence Livermore National Security, LLC.
	- * Refer to the ZoL git commit log for authoritative copyright attribution.
	+ * Refer to the OpenZFS git commit log for authoritative copyright attribution.
	*
	* The contents of this file are subject to the terms of the
	* Common Development and Distribution License Version 1.0 (CDDL-1.0).
	* You can obtain a copy of the license from the top-level file
	* "OPENSOLARIS.LICENSE" or at <http://opensource.org/licenses/CDDL-1.0>.
	* You may not use this file except in compliance with the license.
	*/

	#include <errno.h>
	#include <fcntl.h>
	#include <signal.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <sys/mman.h>
	#include <sys/stat.h>
	#include <unistd.h>
	#include "zed.h"
	#include "zed_conf.h"
	#include "zed_event.h"
	#include "zed_file.h"
	#include "zed_log.h"

	static volatile sig_atomic_t _got_exit = 0;
	static volatile sig_atomic_t _got_hup = 0;

	/*
	* Signal handler for SIGINT & SIGTERM.
	*/
	static void
	_exit_handler(int signum)
	{
	_got_exit = 1;
	}

	/*
	* Signal handler for SIGHUP.
	*/
	static void
	_hup_handler(int signum)
	{
	_got_hup = 1;
	}

	/*
	* Register signal handlers.
	*/
	static void
	_setup_sig_handlers(void)
	{
	struct sigaction sa;

	if (sigemptyset(&sa.sa_mask) < 0)
	zed_log_die("Failed to initialize sigset");

	sa.sa_flags = SA_RESTART;
	- sa.sa_handler = SIG_IGN;

	+ sa.sa_handler = SIG_IGN;
	if (sigaction(SIGPIPE, &sa, NULL) < 0)
	zed_log_die("Failed to ignore SIGPIPE");

	sa.sa_handler = _exit_handler;
	if (sigaction(SIGINT, &sa, NULL) < 0)
	zed_log_die("Failed to register SIGINT handler");

	if (sigaction(SIGTERM, &sa, NULL) < 0)
	zed_log_die("Failed to register SIGTERM handler");

	sa.sa_handler = _hup_handler;
	if (sigaction(SIGHUP, &sa, NULL) < 0)
	zed_log_die("Failed to register SIGHUP handler");
	+
	+ (void) sigaddset(&sa.sa_mask, SIGCHLD);
	+ if (pthread_sigmask(SIG_BLOCK, &sa.sa_mask, NULL) < 0)
	+ zed_log_die("Failed to block SIGCHLD");
	}

	/*
	* Lock all current and future pages in the virtual memory address space.
	* Access to locked pages will never be delayed by a page fault.
	*
	* EAGAIN is tested up to max_tries in case this is a transient error.
	*
	* Note that memory locks are not inherited by a child created via fork()
	* and are automatically removed during an execve(). As such, this must
	* be called after the daemon fork()s (when running in the background).
	*/
	static void
	_lock_memory(void)
	{
	#if HAVE_MLOCKALL
	int i = 0;
	const int max_tries = 10;

	for (i = 0; i < max_tries; i++) {
	if (mlockall(MCL_CURRENT \| MCL_FUTURE) == 0) {
	zed_log_msg(LOG_INFO, "Locked all pages in memory");
	return;
	}
	if (errno != EAGAIN)
	break;
	}
	zed_log_die("Failed to lock memory pages: %s", strerror(errno));

	#else /* HAVE_MLOCKALL */
	zed_log_die("Failed to lock memory pages: mlockall() not supported");
	#endif /* HAVE_MLOCKALL */
	}

	/*
	* Start daemonization of the process including the double fork().
	*
	* The parent process will block here until _finish_daemonize() is called
	* (in the grandchild process), at which point the parent process will exit.
	* This prevents the parent process from exiting until initialization is
	* complete.
	*/
	static void
	_start_daemonize(void)
	{
	pid_t pid;
	struct sigaction sa;

	/* Create pipe for communicating with child during daemonization. */
	zed_log_pipe_open();

	/* Background process and ensure child is not process group leader. */
	pid = fork();
	if (pid < 0) {
	zed_log_die("Failed to create child process: %s",
	strerror(errno));
	} else if (pid > 0) {

	/* Close writes since parent will only read from pipe. */
	zed_log_pipe_close_writes();

	/* Wait for notification that daemonization is complete. */
	zed_log_pipe_wait();

	zed_log_pipe_close_reads();
	_exit(EXIT_SUCCESS);
	}

	/* Close reads since child will only write to pipe. */
	zed_log_pipe_close_reads();

	/* Create independent session and detach from terminal. */
	if (setsid() < 0)
	zed_log_die("Failed to create new session: %s",
	strerror(errno));

	/* Prevent child from terminating on HUP when session leader exits. */
	if (sigemptyset(&sa.sa_mask) < 0)
	zed_log_die("Failed to initialize sigset");

	sa.sa_flags = 0;
	sa.sa_handler = SIG_IGN;

	if (sigaction(SIGHUP, &sa, NULL) < 0)
	zed_log_die("Failed to ignore SIGHUP");

	/* Ensure process cannot re-acquire terminal. */
	pid = fork();
	if (pid < 0) {
	zed_log_die("Failed to create grandchild process: %s",
	strerror(errno));
	} else if (pid > 0) {
	_exit(EXIT_SUCCESS);
	}
	}

	/*
	* Finish daemonization of the process by closing stdin/stdout/stderr.
	*
	* This must be called at the end of initialization after all external
	* communication channels are established and accessible.
	*/
	static void
	_finish_daemonize(void)
	{
	int devnull;

	/* Preserve fd 0/1/2, but discard data to/from stdin/stdout/stderr. */
	devnull = open("/dev/null", O_RDWR);
	if (devnull < 0)
	zed_log_die("Failed to open /dev/null: %s", strerror(errno));

	if (dup2(devnull, STDIN_FILENO) < 0)
	zed_log_die("Failed to dup /dev/null onto stdin: %s",
	strerror(errno));

	if (dup2(devnull, STDOUT_FILENO) < 0)
	zed_log_die("Failed to dup /dev/null onto stdout: %s",
	strerror(errno));

	if (dup2(devnull, STDERR_FILENO) < 0)
	zed_log_die("Failed to dup /dev/null onto stderr: %s",
	strerror(errno));

	if ((devnull > STDERR_FILENO) && (close(devnull) < 0))
	zed_log_die("Failed to close /dev/null: %s", strerror(errno));

	/* Notify parent that daemonization is complete. */
	zed_log_pipe_close_writes();
	}

	/*
	* ZFS Event Daemon (ZED).
	*/
	int
	main(int argc, char *argv[])
	{
	- struct zed_conf *zcp;
	+ struct zed_conf zcp;
	uint64_t saved_eid;
	int64_t saved_etime[2];

	zed_log_init(argv[0]);
	zed_log_stderr_open(LOG_NOTICE);
	- zcp = zed_conf_create();
	- zed_conf_parse_opts(zcp, argc, argv);
	- if (zcp->do_verbose)
	+ zed_conf_init(&zcp);
	+ zed_conf_parse_opts(&zcp, argc, argv);
	+ if (zcp.do_verbose)
	zed_log_stderr_open(LOG_INFO);

	if (geteuid() != 0)
	zed_log_die("Must be run as root");

	- zed_conf_parse_file(zcp);
	-
	zed_file_close_from(STDERR_FILENO + 1);

	(void) umask(0);

	if (chdir("/") < 0)
	zed_log_die("Failed to change to root directory");

	- if (zed_conf_scan_dir(zcp) < 0)
	+ if (zed_conf_scan_dir(&zcp) < 0)
	exit(EXIT_FAILURE);

	- if (!zcp->do_foreground) {
	+ if (!zcp.do_foreground) {
	_start_daemonize();
	zed_log_syslog_open(LOG_DAEMON);
	}
	_setup_sig_handlers();

	- if (zcp->do_memlock)
	+ if (zcp.do_memlock)
	_lock_memory();

	- if ((zed_conf_write_pid(zcp) < 0) && (!zcp->do_force))
	+ if ((zed_conf_write_pid(&zcp) < 0) && (!zcp.do_force))
	exit(EXIT_FAILURE);

	- if (!zcp->do_foreground)
	+ if (!zcp.do_foreground)
	_finish_daemonize();

	zed_log_msg(LOG_NOTICE,
	"ZFS Event Daemon %s-%s (PID %d)",
	ZFS_META_VERSION, ZFS_META_RELEASE, (int)getpid());

	- if (zed_conf_open_state(zcp) < 0)
	+ if (zed_conf_open_state(&zcp) < 0)
	exit(EXIT_FAILURE);

	- if (zed_conf_read_state(zcp, &saved_eid, saved_etime) < 0)
	+ if (zed_conf_read_state(&zcp, &saved_eid, saved_etime) < 0)
	exit(EXIT_FAILURE);

	idle:
	/*
	* If -I is specified, attempt to open /dev/zfs repeatedly until
	* successful.
	*/
	do {
	- if (!zed_event_init(zcp))
	+ if (!zed_event_init(&zcp))
	break;
	/* Wait for some time and try again. tunable? */
	sleep(30);
	- } while (!_got_exit && zcp->do_idle);
	+ } while (!_got_exit && zcp.do_idle);

	if (_got_exit)
	goto out;

	- zed_event_seek(zcp, saved_eid, saved_etime);
	+ zed_event_seek(&zcp, saved_eid, saved_etime);

	while (!_got_exit) {
	int rv;
	if (_got_hup) {
	_got_hup = 0;
	- (void) zed_conf_scan_dir(zcp);
	+ (void) zed_conf_scan_dir(&zcp);
	}
	- rv = zed_event_service(zcp);
	+ rv = zed_event_service(&zcp);

	/* ENODEV: When kernel module is unloaded (osx) */
	if (rv == ENODEV)
	break;
	}

	zed_log_msg(LOG_NOTICE, "Exiting");
	- zed_event_fini(zcp);
	+ zed_event_fini(&zcp);

	- if (zcp->do_idle && !_got_exit)
	+ if (zcp.do_idle && !_got_exit)
	goto idle;

	out:
	- zed_conf_destroy(zcp);
	+ zed_conf_destroy(&zcp);
	zed_log_fini();
	exit(EXIT_SUCCESS);
	}
	diff --git a/sys/contrib/openzfs/cmd/zed/zed.d/data-notify.sh b/sys/contrib/openzfs/cmd/zed/zed.d/data-notify.sh
	index 639b459bdd3b..792d30a66d23 100755
	--- a/sys/contrib/openzfs/cmd/zed/zed.d/data-notify.sh
	+++ b/sys/contrib/openzfs/cmd/zed/zed.d/data-notify.sh
	@@ -1,43 +1,43 @@
	#!/bin/sh
	#
	# Send notification in response to a DATA error.
	#
	# Only one notification per ZED_NOTIFY_INTERVAL_SECS will be sent for a given
	# class/pool/[vdev] combination. This protects against spamming the recipient
	# should multiple events occur together in time for the same pool/[vdev].
	#
	# Exit codes:
	# 0: notification sent
	# 1: notification failed
	# 2: notification not configured
	# 3: notification suppressed
	# 9: internal error

	[ -f "${ZED_ZEDLET_DIR}/zed.rc" ] && . "${ZED_ZEDLET_DIR}/zed.rc"
	. "${ZED_ZEDLET_DIR}/zed-functions.sh"

	[ -n "${ZEVENT_POOL}" ] \|\| exit 9
	[ -n "${ZEVENT_SUBCLASS}" ] \|\| exit 9
	[ -n "${ZED_NOTIFY_DATA}" ] \|\| exit 3

	rate_limit_tag="${ZEVENT_POOL};${ZEVENT_VDEV_GUID:-0};${ZEVENT_SUBCLASS};notify"
	zed_rate_limit "${rate_limit_tag}" \|\| exit 3

	umask 077
	note_subject="ZFS ${ZEVENT_SUBCLASS} error for ${ZEVENT_POOL} on $(hostname)"
	-note_pathname="${TMPDIR:="/tmp"}/$(basename -- "$0").${ZEVENT_EID}.$$"
	+note_pathname="$(mktemp)"
	{
	echo "ZFS has detected a data error:"
	echo
	echo " eid: ${ZEVENT_EID}"
	echo " class: ${ZEVENT_SUBCLASS}"
	echo " host: $(hostname)"
	echo " time: ${ZEVENT_TIME_STRING}"
	echo " error: ${ZEVENT_ZIO_ERR}"
	echo " objid: ${ZEVENT_ZIO_OBJSET}:${ZEVENT_ZIO_OBJECT}"
	echo " pool: ${ZEVENT_POOL}"
	} > "${note_pathname}"

	zed_notify "${note_subject}" "${note_pathname}"; rv=$?
	rm -f "${note_pathname}"
	exit "${rv}"
	diff --git a/sys/contrib/openzfs/cmd/zed/zed.d/generic-notify.sh b/sys/contrib/openzfs/cmd/zed/zed.d/generic-notify.sh
	index e438031a088a..1db26980c1a0 100755
	--- a/sys/contrib/openzfs/cmd/zed/zed.d/generic-notify.sh
	+++ b/sys/contrib/openzfs/cmd/zed/zed.d/generic-notify.sh
	@@ -1,54 +1,54 @@
	#!/bin/sh
	#
	# Send notification in response to a given zevent.
	#
	# This is a generic script than can be symlinked to a file in the
	# enabled-zedlets directory to have a notification sent when a particular
	# class of zevents occurs. The symlink filename must begin with the zevent
	# (sub)class string (e.g., "probe_failure-notify.sh" for the "probe_failure"
	# subclass). Refer to the zed(8) manpage for details.
	#
	# Only one notification per ZED_NOTIFY_INTERVAL_SECS will be sent for a given
	# class/pool combination. This protects against spamming the recipient
	# should multiple events occur together in time for the same pool.
	#
	# Exit codes:
	# 0: notification sent
	# 1: notification failed
	# 2: notification not configured
	# 3: notification suppressed

	[ -f "${ZED_ZEDLET_DIR}/zed.rc" ] && . "${ZED_ZEDLET_DIR}/zed.rc"
	. "${ZED_ZEDLET_DIR}/zed-functions.sh"

	# Rate-limit the notification based in part on the filename.
	#
	rate_limit_tag="${ZEVENT_POOL};${ZEVENT_SUBCLASS};$(basename -- "$0")"
	rate_limit_interval="${ZED_NOTIFY_INTERVAL_SECS}"
	zed_rate_limit "${rate_limit_tag}" "${rate_limit_interval}" \|\| exit 3

	umask 077
	pool_str="${ZEVENT_POOL:+" for ${ZEVENT_POOL}"}"
	host_str=" on $(hostname)"
	note_subject="ZFS ${ZEVENT_SUBCLASS} event${pool_str}${host_str}"
	-note_pathname="${TMPDIR:="/tmp"}/$(basename -- "$0").${ZEVENT_EID}.$$"
	+note_pathname="$(mktemp)"
	{
	echo "ZFS has posted the following event:"
	echo
	echo " eid: ${ZEVENT_EID}"
	echo " class: ${ZEVENT_SUBCLASS}"
	echo " host: $(hostname)"
	echo " time: ${ZEVENT_TIME_STRING}"

	[ -n "${ZEVENT_VDEV_TYPE}" ] && echo " vtype: ${ZEVENT_VDEV_TYPE}"
	[ -n "${ZEVENT_VDEV_PATH}" ] && echo " vpath: ${ZEVENT_VDEV_PATH}"
	[ -n "${ZEVENT_VDEV_GUID}" ] && echo " vguid: ${ZEVENT_VDEV_GUID}"

	[ -n "${ZEVENT_POOL}" ] && [ -x "${ZPOOL}" ] \
	&& "${ZPOOL}" status "${ZEVENT_POOL}"

	} > "${note_pathname}"

	zed_notify "${note_subject}" "${note_pathname}"; rv=$?
	rm -f "${note_pathname}"
	exit "${rv}"
	diff --git a/sys/contrib/openzfs/cmd/zed/zed.d/history_event-zfs-list-cacher.sh.in b/sys/contrib/openzfs/cmd/zed/zed.d/history_event-zfs-list-cacher.sh.in
	index bf5a121f6a79..15f0a8ed6189 100755
	--- a/sys/contrib/openzfs/cmd/zed/zed.d/history_event-zfs-list-cacher.sh.in
	+++ b/sys/contrib/openzfs/cmd/zed/zed.d/history_event-zfs-list-cacher.sh.in
	@@ -1,85 +1,85 @@
	#!/bin/sh
	#
	# Track changes to enumerated pools for use in early-boot
	set -ef

	FSLIST_DIR="@sysconfdir@/zfs/zfs-list.cache"
	FSLIST_TMP="@runstatedir@/zfs-list.cache.new"
	FSLIST="${FSLIST_DIR}/${ZEVENT_POOL}"

	# If the pool specific cache file is not writeable, abort
	[ -w "${FSLIST}" ] \|\| exit 0

	[ -f "${ZED_ZEDLET_DIR}/zed.rc" ] && . "${ZED_ZEDLET_DIR}/zed.rc"
	. "${ZED_ZEDLET_DIR}/zed-functions.sh"

	[ "$ZEVENT_SUBCLASS" != "history_event" ] && exit 0
	-zed_check_cmd "${ZFS}" sort diff grep
	+zed_check_cmd "${ZFS}" sort diff

	# If we are acting on a snapshot, we have nothing to do
	-printf '%s' "${ZEVENT_HISTORY_DSNAME}" \| grep '@' && exit 0
	+[ "${ZEVENT_HISTORY_DSNAME%@*}" = "${ZEVENT_HISTORY_DSNAME}" ] \|\| exit 0

	# We obtain a lock on zfs-list to avoid any simultaneous writes.
	# If we run into trouble, log and drop the lock
	abort_alter() {
	zed_log_msg "Error updating zfs-list.cache!"
	zed_unlock zfs-list
	}

	finished() {
	zed_unlock zfs-list
	trap - EXIT
	exit 0
	}

	case "${ZEVENT_HISTORY_INTERNAL_NAME}" in
	create\|"finish receiving"\|import\|destroy\|rename)
	;;

	export)
	zed_lock zfs-list
	trap abort_alter EXIT
	echo > "${FSLIST}"
	finished
	;;

	set\|inherit)
	# Only act if one of the tracked properties is altered.
	case "${ZEVENT_HISTORY_INTERNAL_STR%%=*}" in
	canmount\|mountpoint\|atime\|relatime\|devices\|exec\|readonly\| \
	setuid\|nbmand\|encroot\|keylocation\|org.openzfs.systemd:requires\| \
	org.openzfs.systemd:requires-mounts-for\| \
	org.openzfs.systemd:before\|org.openzfs.systemd:after\| \
	org.openzfs.systemd:wanted-by\|org.openzfs.systemd:required-by\| \
	org.openzfs.systemd:nofail\|org.openzfs.systemd:ignore \
	) ;;
	*) exit 0 ;;
	esac
	;;

	*)
	# Ignore all other events.
	exit 0
	;;
	esac

	zed_lock zfs-list
	trap abort_alter EXIT

	PROPS="name,mountpoint,canmount,atime,relatime,devices,exec\
	,readonly,setuid,nbmand,encroot,keylocation\
	,org.openzfs.systemd:requires,org.openzfs.systemd:requires-mounts-for\
	,org.openzfs.systemd:before,org.openzfs.systemd:after\
	,org.openzfs.systemd:wanted-by,org.openzfs.systemd:required-by\
	,org.openzfs.systemd:nofail,org.openzfs.systemd:ignore"

	"${ZFS}" list -H -t filesystem -o $PROPS -r "${ZEVENT_POOL}" > "${FSLIST_TMP}"

	# Sort the output so that it is stable
	sort "${FSLIST_TMP}" -o "${FSLIST_TMP}"

	# Don't modify the file if it hasn't changed
	diff -q "${FSLIST_TMP}" "${FSLIST}" \|\| mv "${FSLIST_TMP}" "${FSLIST}"
	rm -f "${FSLIST_TMP}"

	finished
	diff --git a/sys/contrib/openzfs/cmd/zed/zed.d/scrub_finish-notify.sh b/sys/contrib/openzfs/cmd/zed/zed.d/scrub_finish-notify.sh
	index 2145a100a3fa..5c0124b8d7e7 100755
	--- a/sys/contrib/openzfs/cmd/zed/zed.d/scrub_finish-notify.sh
	+++ b/sys/contrib/openzfs/cmd/zed/zed.d/scrub_finish-notify.sh
	@@ -1,59 +1,59 @@
	#!/bin/sh
	#
	# Send notification in response to a RESILVER_FINISH or SCRUB_FINISH.
	#
	# By default, "zpool status" output will only be included for a scrub_finish
	# zevent if the pool is not healthy; to always include its output, set
	# ZED_NOTIFY_VERBOSE=1.
	#
	# Exit codes:
	# 0: notification sent
	# 1: notification failed
	# 2: notification not configured
	# 3: notification suppressed
	# 9: internal error

	[ -f "${ZED_ZEDLET_DIR}/zed.rc" ] && . "${ZED_ZEDLET_DIR}/zed.rc"
	. "${ZED_ZEDLET_DIR}/zed-functions.sh"

	[ -n "${ZEVENT_POOL}" ] \|\| exit 9
	[ -n "${ZEVENT_SUBCLASS}" ] \|\| exit 9

	if [ "${ZEVENT_SUBCLASS}" = "resilver_finish" ]; then
	action="resilver"
	elif [ "${ZEVENT_SUBCLASS}" = "scrub_finish" ]; then
	action="scrub"
	else
	zed_log_err "unsupported event class \"${ZEVENT_SUBCLASS}\""
	exit 9
	fi

	zed_check_cmd "${ZPOOL}" \|\| exit 9

	# For scrub, suppress notification if the pool is healthy
	# and verbosity is not enabled.
	#
	if [ "${ZEVENT_SUBCLASS}" = "scrub_finish" ]; then
	healthy="$("${ZPOOL}" status -x "${ZEVENT_POOL}" \
	\| grep "'${ZEVENT_POOL}' is healthy")"
	[ -n "${healthy}" ] && [ "${ZED_NOTIFY_VERBOSE}" -eq 0 ] && exit 3
	fi

	umask 077
	note_subject="ZFS ${ZEVENT_SUBCLASS} event for ${ZEVENT_POOL} on $(hostname)"
	-note_pathname="${TMPDIR:="/tmp"}/$(basename -- "$0").${ZEVENT_EID}.$$"
	+note_pathname="$(mktemp)"
	{
	echo "ZFS has finished a ${action}:"
	echo
	echo " eid: ${ZEVENT_EID}"
	echo " class: ${ZEVENT_SUBCLASS}"
	echo " host: $(hostname)"
	echo " time: ${ZEVENT_TIME_STRING}"

	"${ZPOOL}" status "${ZEVENT_POOL}"

	} > "${note_pathname}"

	zed_notify "${note_subject}" "${note_pathname}"; rv=$?
	rm -f "${note_pathname}"
	exit "${rv}"
	diff --git a/sys/contrib/openzfs/cmd/zed/zed.d/statechange-led.sh b/sys/contrib/openzfs/cmd/zed/zed.d/statechange-led.sh
	index e656e125d378..0f9da3204317 100755
	--- a/sys/contrib/openzfs/cmd/zed/zed.d/statechange-led.sh
	+++ b/sys/contrib/openzfs/cmd/zed/zed.d/statechange-led.sh
	@@ -1,177 +1,177 @@
	#!/bin/sh
	#
	-# Turn off/on the VDEV's enclosure fault LEDs when the pool's state changes.
	+# Turn off/on vdevs' enclosure fault LEDs when their pool's state changes.
	#
	-# Turn the VDEV's fault LED on if it becomes FAULTED, DEGRADED or UNAVAIL.
	-# Turn the LED off when it's back ONLINE again.
	+# Turn a vdev's fault LED on if it becomes FAULTED, DEGRADED or UNAVAIL.
	+# Turn its LED off when it's back ONLINE again.
	#
	# This script run in two basic modes:
	#
	# 1. If $ZEVENT_VDEV_ENC_SYSFS_PATH and $ZEVENT_VDEV_STATE_STR are set, then
	-# only set the LED for that particular VDEV. This is the case for statechange
	+# only set the LED for that particular vdev. This is the case for statechange
	# events and some vdev_* events.
	#
	-# 2. If those vars are not set, then check the state of all VDEVs in the pool
	+# 2. If those vars are not set, then check the state of all vdevs in the pool
	# and set the LEDs accordingly. This is the case for pool_import events.
	#
	# Note that this script requires that your enclosure be supported by the
	-# Linux SCSI enclosure services (ses) driver. The script will do nothing
	+# Linux SCSI Enclosure services (SES) driver. The script will do nothing
	# if you have no enclosure, or if your enclosure isn't supported.
	#
	# Exit codes:
	# 0: enclosure led successfully set
	# 1: enclosure leds not available
	# 2: enclosure leds administratively disabled
	# 3: The led sysfs path passed from ZFS does not exist
	# 4: $ZPOOL not set
	# 5: awk is not installed

	[ -f "${ZED_ZEDLET_DIR}/zed.rc" ] && . "${ZED_ZEDLET_DIR}/zed.rc"
	. "${ZED_ZEDLET_DIR}/zed-functions.sh"

	if [ ! -d /sys/class/enclosure ] ; then
	exit 1
	fi

	if [ "${ZED_USE_ENCLOSURE_LEDS}" != "1" ] ; then
	exit 2
	fi

	zed_check_cmd "$ZPOOL" \|\| exit 4
	zed_check_cmd awk \|\| exit 5

	# Global used in set_led debug print
	vdev=""

	# check_and_set_led (file, val)
	#
	# Read an enclosure sysfs file, and write it if it's not already set to 'val'
	#
	# Arguments
	# file: sysfs file to set (like /sys/class/enclosure/0:0:1:0/SLOT 10/fault)
	# val: value to set it to
	#
	# Return
	# 0 on success, 3 on missing sysfs path
	#
	check_and_set_led()
	{
	file="$1"
	val="$2"

	+ if [ -z "$val" ]; then
	+ return 0
	+ fi
	+
	if [ ! -e "$file" ] ; then
	return 3
	fi

	# If another process is accessing the LED when we attempt to update it,
	# the update will be lost so retry until the LED actually changes or we
	# timeout.
	- for _ in $(seq 1 5); do
	+ for _ in 1 2 3 4 5; do
	# We want to check the current state first, since writing to the
	# 'fault' entry always causes a SES command, even if the
	# current state is already what you want.
	- current=$(cat "${file}")
	+ read -r current < "${file}"

	# On some enclosures if you write 1 to fault, and read it back,
	# it will return 2. Treat all non-zero values as 1 for
	# simplicity.
	if [ "$current" != "0" ] ; then
	current=1
	fi

	if [ "$current" != "$val" ] ; then
	echo "$val" > "$file"
	zed_log_msg "vdev $vdev set '$file' LED to $val"
	else
	break
	fi
	- done
	+ done
	}

	state_to_val()
	{
	state="$1"
	- if [ "$state" = "FAULTED" ] \|\| [ "$state" = "DEGRADED" ] \|\| \
	- [ "$state" = "UNAVAIL" ] ; then
	- echo 1
	- elif [ "$state" = "ONLINE" ] ; then
	- echo 0
	- fi
	+ case "$state" in
	+ FAULTED\|DEGRADED\|UNAVAIL)
	+ echo 1
	+ ;;
	+ ONLINE)
	+ echo 0
	+ ;;
	+ esac
	}

	-# process_pool ([pool])
	+# process_pool (pool)
	#
	-# Iterate through a pool (or pools) and set the VDEV's enclosure slot LEDs to
	-# the VDEV's state.
	+# Iterate through a pool and set the vdevs' enclosure slot LEDs to
	+# those vdevs' state.
	#
	# Arguments
	-# pool: Optional pool name. If not specified, iterate though all pools.
	+# pool: Pool name.
	#
	# Return
	# 0 on success, 3 on missing sysfs path
	#
	process_pool()
	{
	pool="$1"
	- rc=0

	- # Lookup all the current LED values and paths in parallel
	- #shellcheck disable=SC2016
	- cmd='echo led_token=$(cat "$VDEV_ENC_SYSFS_PATH/fault"),"$VDEV_ENC_SYSFS_PATH",'
	- out=$($ZPOOL status -vc "$cmd" "$pool" \| grep 'led_token=')
	-
	- #shellcheck disable=SC2034
	- echo "$out" \| while read -r vdev state read write chksum therest; do
	+ # The output will be the vdevs only (from "grep '/dev/'"):
	+ #
	+ # U45 ONLINE 0 0 0 /dev/sdk 0
	+ # U46 ONLINE 0 0 0 /dev/sdm 0
	+ # U47 ONLINE 0 0 0 /dev/sdn 0
	+ # U50 ONLINE 0 0 0 /dev/sdbn 0
	+ #
	+ ZPOOL_SCRIPTS_AS_ROOT=1 $ZPOOL status -c upath,fault_led "$pool" \| grep '/dev/' \| (
	+ rc=0
	+ while read -r vdev state _ _ _ therest; do
	# Read out current LED value and path
	- tmp=$(echo "$therest" \| sed 's/^.*led_token=//g')
	- vdev_enc_sysfs_path=$(echo "$tmp" \| awk -F ',' '{print $2}')
	- current_val=$(echo "$tmp" \| awk -F ',' '{print $1}')
	+ # Get dev name (like 'sda')
	+ dev=$(basename "$(echo "$therest" \| awk '{print $(NF-1)}')")
	+ vdev_enc_sysfs_path=$(realpath "/sys/class/block/$dev/device/enclosure_device"*)
	+ current_val=$(echo "$therest" \| awk '{print $NF}')

	if [ "$current_val" != "0" ] ; then
	current_val=1
	fi

	if [ -z "$vdev_enc_sysfs_path" ] ; then
	# Skip anything with no sysfs LED entries
	continue
	fi

	if [ ! -e "$vdev_enc_sysfs_path/fault" ] ; then
	- #shellcheck disable=SC2030
	- rc=1
	+ rc=3
	zed_log_msg "vdev $vdev '$file/fault' doesn't exist"
	- continue;
	+ continue
	fi

	val=$(state_to_val "$state")

	if [ "$current_val" = "$val" ] ; then
	# LED is already set correctly
	- continue;
	+ continue
	fi

	if ! check_and_set_led "$vdev_enc_sysfs_path/fault" "$val"; then
	- rc=1
	+ rc=3
	fi
	-
	done
	-
	- #shellcheck disable=SC2031
	- if [ "$rc" = "0" ] ; then
	- return 0
	- else
	- # We didn't see a sysfs entry that we wanted to set
	- return 3
	- fi
	+ exit "$rc"; )
	}

	if [ -n "$ZEVENT_VDEV_ENC_SYSFS_PATH" ] && [ -n "$ZEVENT_VDEV_STATE_STR" ] ; then
	- # Got a statechange for an individual VDEV
	+ # Got a statechange for an individual vdev
	val=$(state_to_val "$ZEVENT_VDEV_STATE_STR")
	vdev=$(basename "$ZEVENT_VDEV_PATH")
	check_and_set_led "$ZEVENT_VDEV_ENC_SYSFS_PATH/fault" "$val"
	else
	# Process the entire pool
	poolname=$(zed_guid_to_pool "$ZEVENT_POOL_GUID")
	process_pool "$poolname"
	fi
	diff --git a/sys/contrib/openzfs/cmd/zed/zed.d/statechange-notify.sh b/sys/contrib/openzfs/cmd/zed/zed.d/statechange-notify.sh
	index f46080a03239..76f09061c5b5 100755
	--- a/sys/contrib/openzfs/cmd/zed/zed.d/statechange-notify.sh
	+++ b/sys/contrib/openzfs/cmd/zed/zed.d/statechange-notify.sh
	@@ -1,74 +1,74 @@
	#!/bin/sh
	#
	# CDDL HEADER START
	#
	# The contents of this file are subject to the terms of the
	# Common Development and Distribution License Version 1.0 (CDDL-1.0).
	# You can obtain a copy of the license from the top-level file
	# "OPENSOLARIS.LICENSE" or at <http://opensource.org/licenses/CDDL-1.0>.
	# You may not use this file except in compliance with the license.
	#
	# CDDL HEADER END
	#

	#
	# Send notification in response to a fault induced statechange
	#
	# ZEVENT_SUBCLASS: 'statechange'
	# ZEVENT_VDEV_STATE_STR: 'DEGRADED', 'FAULTED' or 'REMOVED'
	#
	# Exit codes:
	# 0: notification sent
	# 1: notification failed
	# 2: notification not configured
	# 3: statechange not relevant
	# 4: statechange string missing (unexpected)

	[ -f "${ZED_ZEDLET_DIR}/zed.rc" ] && . "${ZED_ZEDLET_DIR}/zed.rc"
	. "${ZED_ZEDLET_DIR}/zed-functions.sh"

	[ -n "${ZEVENT_VDEV_STATE_STR}" ] \|\| exit 4

	if [ "${ZEVENT_VDEV_STATE_STR}" != "FAULTED" ] \
	&& [ "${ZEVENT_VDEV_STATE_STR}" != "DEGRADED" ] \
	&& [ "${ZEVENT_VDEV_STATE_STR}" != "REMOVED" ]; then
	exit 3
	fi

	umask 077
	note_subject="ZFS device fault for pool ${ZEVENT_POOL_GUID} on $(hostname)"
	-note_pathname="${TMPDIR:="/tmp"}/$(basename -- "$0").${ZEVENT_EID}.$$"
	+note_pathname="$(mktemp)"
	{
	if [ "${ZEVENT_VDEV_STATE_STR}" = "FAULTED" ] ; then
	echo "The number of I/O errors associated with a ZFS device exceeded"
	echo "acceptable levels. ZFS has marked the device as faulted."
	elif [ "${ZEVENT_VDEV_STATE_STR}" = "DEGRADED" ] ; then
	echo "The number of checksum errors associated with a ZFS device"
	echo "exceeded acceptable levels. ZFS has marked the device as"
	echo "degraded."
	else
	echo "ZFS has detected that a device was removed."
	fi

	echo
	echo " impact: Fault tolerance of the pool may be compromised."
	echo " eid: ${ZEVENT_EID}"
	echo " class: ${ZEVENT_SUBCLASS}"
	echo " state: ${ZEVENT_VDEV_STATE_STR}"
	echo " host: $(hostname)"
	echo " time: ${ZEVENT_TIME_STRING}"

	[ -n "${ZEVENT_VDEV_TYPE}" ] && echo " vtype: ${ZEVENT_VDEV_TYPE}"
	[ -n "${ZEVENT_VDEV_PATH}" ] && echo " vpath: ${ZEVENT_VDEV_PATH}"
	[ -n "${ZEVENT_VDEV_PHYSPATH}" ] && echo " vphys: ${ZEVENT_VDEV_PHYSPATH}"
	[ -n "${ZEVENT_VDEV_GUID}" ] && echo " vguid: ${ZEVENT_VDEV_GUID}"
	[ -n "${ZEVENT_VDEV_DEVID}" ] && echo " devid: ${ZEVENT_VDEV_DEVID}"

	echo " pool: ${ZEVENT_POOL_GUID}"

	} > "${note_pathname}"

	zed_notify "${note_subject}" "${note_pathname}"; rv=$?

	rm -f "${note_pathname}"
	exit "${rv}"
	diff --git a/sys/contrib/openzfs/cmd/zed/zed.d/trim_finish-notify.sh b/sys/contrib/openzfs/cmd/zed/zed.d/trim_finish-notify.sh
	index 5075302997e3..8fdb64531d0a 100755
	--- a/sys/contrib/openzfs/cmd/zed/zed.d/trim_finish-notify.sh
	+++ b/sys/contrib/openzfs/cmd/zed/zed.d/trim_finish-notify.sh
	@@ -1,37 +1,37 @@
	#!/bin/sh
	#
	# Send notification in response to a TRIM_FINISH. The event
	# will be received for each vdev in the pool which was trimmed.
	#
	# Exit codes:
	# 0: notification sent
	# 1: notification failed
	# 2: notification not configured
	# 9: internal error

	[ -f "${ZED_ZEDLET_DIR}/zed.rc" ] && . "${ZED_ZEDLET_DIR}/zed.rc"
	. "${ZED_ZEDLET_DIR}/zed-functions.sh"

	[ -n "${ZEVENT_POOL}" ] \|\| exit 9
	[ -n "${ZEVENT_SUBCLASS}" ] \|\| exit 9

	zed_check_cmd "${ZPOOL}" \|\| exit 9

	umask 077
	note_subject="ZFS ${ZEVENT_SUBCLASS} event for ${ZEVENT_POOL} on $(hostname)"
	-note_pathname="${TMPDIR:="/tmp"}/$(basename -- "$0").${ZEVENT_EID}.$$"
	+note_pathname="$(mktemp)"
	{
	echo "ZFS has finished a trim:"
	echo
	echo " eid: ${ZEVENT_EID}"
	echo " class: ${ZEVENT_SUBCLASS}"
	echo " host: $(hostname)"
	echo " time: ${ZEVENT_TIME_STRING}"

	"${ZPOOL}" status -t "${ZEVENT_POOL}"

	} > "${note_pathname}"

	zed_notify "${note_subject}" "${note_pathname}"; rv=$?
	rm -f "${note_pathname}"
	exit "${rv}"
	diff --git a/sys/contrib/openzfs/cmd/zed/zed.d/zed-functions.sh b/sys/contrib/openzfs/cmd/zed/zed.d/zed-functions.sh
	index 44a9b8d23303..1fd3888625b2 100644
	--- a/sys/contrib/openzfs/cmd/zed/zed.d/zed-functions.sh
	+++ b/sys/contrib/openzfs/cmd/zed/zed.d/zed-functions.sh
	@@ -1,538 +1,536 @@
	#!/bin/sh
	# shellcheck disable=SC2039
	# zed-functions.sh
	#
	# ZED helper functions for use in ZEDLETs


	# Variable Defaults
	#
	: "${ZED_LOCKDIR:="/var/lock"}"
	: "${ZED_NOTIFY_INTERVAL_SECS:=3600}"
	: "${ZED_NOTIFY_VERBOSE:=0}"
	: "${ZED_RUNDIR:="/var/run"}"
	: "${ZED_SYSLOG_PRIORITY:="daemon.notice"}"
	: "${ZED_SYSLOG_TAG:="zed"}"

	ZED_FLOCK_FD=8


	# zed_check_cmd (cmd, ...)
	#
	# For each argument given, search PATH for the executable command [cmd].
	# Log a message if [cmd] is not found.
	#
	# Arguments
	# cmd: name of executable command for which to search
	#
	# Return
	# 0 if all commands are found in PATH and are executable
	# n for a count of the command executables that are not found
	#
	zed_check_cmd()
	{
	local cmd
	local rv=0

	for cmd; do
	if ! command -v "${cmd}" >/dev/null 2>&1; then
	zed_log_err "\"${cmd}\" not installed"
	rv=$((rv + 1))
	fi
	done
	return "${rv}"
	}


	# zed_log_msg (msg, ...)
	#
	# Write all argument strings to the system log.
	#
	# Globals
	# ZED_SYSLOG_PRIORITY
	# ZED_SYSLOG_TAG
	#
	# Return
	# nothing
	#
	zed_log_msg()
	{
	logger -p "${ZED_SYSLOG_PRIORITY}" -t "${ZED_SYSLOG_TAG}" -- "$@"
	}


	# zed_log_err (msg, ...)
	#
	# Write an error message to the system log. This message will contain the
	# script name, EID, and all argument strings.
	#
	# Globals
	# ZED_SYSLOG_PRIORITY
	# ZED_SYSLOG_TAG
	# ZEVENT_EID
	#
	# Return
	# nothing
	#
	zed_log_err()
	{
	logger -p "${ZED_SYSLOG_PRIORITY}" -t "${ZED_SYSLOG_TAG}" -- "error:" \
	"$(basename -- "$0"):""${ZEVENT_EID:+" eid=${ZEVENT_EID}:"}" "$@"
	}


	# zed_lock (lockfile, [fd])
	#
	# Obtain an exclusive (write) lock on [lockfile]. If the lock cannot be
	# immediately acquired, wait until it becomes available.
	#
	# Every zed_lock() must be paired with a corresponding zed_unlock().
	#
	# By default, flock-style locks associate the lockfile with file descriptor 8.
	# The bash manpage warns that file descriptors >9 should be used with care as
	# they may conflict with file descriptors used internally by the shell. File
	# descriptor 9 is reserved for zed_rate_limit(). If concurrent locks are held
	# within the same process, they must use different file descriptors (preferably
	# decrementing from 8); otherwise, obtaining a new lock with a given file
	# descriptor will release the previous lock associated with that descriptor.
	#
	# Arguments
	# lockfile: pathname of the lock file; the lock will be stored in
	# ZED_LOCKDIR unless the pathname contains a "/".
	# fd: integer for the file descriptor used by flock (OPTIONAL unless holding
	# concurrent locks)
	#
	# Globals
	# ZED_FLOCK_FD
	# ZED_LOCKDIR
	#
	# Return
	# nothing
	#
	zed_lock()
	{
	local lockfile="$1"
	local fd="${2:-${ZED_FLOCK_FD}}"
	local umask_bak
	local err

	[ -n "${lockfile}" ] \|\| return
	if ! expr "${lockfile}" : '.*/' >/dev/null 2>&1; then
	lockfile="${ZED_LOCKDIR}/${lockfile}"
	fi

	umask_bak="$(umask)"
	umask 077

	# Obtain a lock on the file bound to the given file descriptor.
	#
	eval "exec ${fd}> '${lockfile}'"
	err="$(flock --exclusive "${fd}" 2>&1)"
	# shellcheck disable=SC2181
	if [ $? -ne 0 ]; then
	zed_log_err "failed to lock \"${lockfile}\": ${err}"
	fi

	umask "${umask_bak}"
	}


	# zed_unlock (lockfile, [fd])
	#
	# Release the lock on [lockfile].
	#
	# Arguments
	# lockfile: pathname of the lock file
	# fd: integer for the file descriptor used by flock (must match the file
	# descriptor passed to the zed_lock function call)
	#
	# Globals
	# ZED_FLOCK_FD
	# ZED_LOCKDIR
	#
	# Return
	# nothing
	#
	zed_unlock()
	{
	local lockfile="$1"
	local fd="${2:-${ZED_FLOCK_FD}}"
	local err

	[ -n "${lockfile}" ] \|\| return
	if ! expr "${lockfile}" : '.*/' >/dev/null 2>&1; then
	lockfile="${ZED_LOCKDIR}/${lockfile}"
	fi

	# Release the lock and close the file descriptor.
	err="$(flock --unlock "${fd}" 2>&1)"
	# shellcheck disable=SC2181
	if [ $? -ne 0 ]; then
	zed_log_err "failed to unlock \"${lockfile}\": ${err}"
	fi
	eval "exec ${fd}>&-"
	}


	# zed_notify (subject, pathname)
	#
	# Send a notification via all available methods.
	#
	# Arguments
	# subject: notification subject
	# pathname: pathname containing the notification message (OPTIONAL)
	#
	# Return
	# 0: notification succeeded via at least one method
	# 1: notification failed
	# 2: no notification methods configured
	#
	zed_notify()
	{
	local subject="$1"
	local pathname="$2"
	local num_success=0
	local num_failure=0

	zed_notify_email "${subject}" "${pathname}"; rv=$?
	[ "${rv}" -eq 0 ] && num_success=$((num_success + 1))
	[ "${rv}" -eq 1 ] && num_failure=$((num_failure + 1))

	zed_notify_pushbullet "${subject}" "${pathname}"; rv=$?
	[ "${rv}" -eq 0 ] && num_success=$((num_success + 1))
	[ "${rv}" -eq 1 ] && num_failure=$((num_failure + 1))

	zed_notify_slack_webhook "${subject}" "${pathname}"; rv=$?
	[ "${rv}" -eq 0 ] && num_success=$((num_success + 1))
	[ "${rv}" -eq 1 ] && num_failure=$((num_failure + 1))

	[ "${num_success}" -gt 0 ] && return 0
	[ "${num_failure}" -gt 0 ] && return 1
	return 2
	}


	# zed_notify_email (subject, pathname)
	#
	# Send a notification via email to the address specified by ZED_EMAIL_ADDR.
	#
	# Requires the mail executable to be installed in the standard PATH, or
	# ZED_EMAIL_PROG to be defined with the pathname of an executable capable of
	# reading a message body from stdin.
	#
	# Command-line options to the mail executable can be specified in
	# ZED_EMAIL_OPTS. This undergoes the following keyword substitutions:
	# - @ADDRESS@ is replaced with the space-delimited recipient email address(es)
	# - @SUBJECT@ is replaced with the notification subject
	#
	# Arguments
	# subject: notification subject
	# pathname: pathname containing the notification message (OPTIONAL)
	#
	# Globals
	# ZED_EMAIL_PROG
	# ZED_EMAIL_OPTS
	# ZED_EMAIL_ADDR
	#
	# Return
	# 0: notification sent
	# 1: notification failed
	# 2: not configured
	#
	zed_notify_email()
	{
	local subject="$1"
	local pathname="${2:-"/dev/null"}"

	: "${ZED_EMAIL_PROG:="mail"}"
	: "${ZED_EMAIL_OPTS:="-s '@SUBJECT@' @ADDRESS@"}"

	# For backward compatibility with ZED_EMAIL.
	if [ -n "${ZED_EMAIL}" ] && [ -z "${ZED_EMAIL_ADDR}" ]; then
	ZED_EMAIL_ADDR="${ZED_EMAIL}"
	fi
	[ -n "${ZED_EMAIL_ADDR}" ] \|\| return 2

	zed_check_cmd "${ZED_EMAIL_PROG}" \|\| return 1

	[ -n "${subject}" ] \|\| return 1
	if [ ! -r "${pathname}" ]; then
	zed_log_err \
	"$(basename "${ZED_EMAIL_PROG}") cannot read \"${pathname}\""
	return 1
	fi

	ZED_EMAIL_OPTS="$(echo "${ZED_EMAIL_OPTS}" \
	\| sed -e "s/@ADDRESS@/${ZED_EMAIL_ADDR}/g" \
	-e "s/@SUBJECT@/${subject}/g")"

	# shellcheck disable=SC2086
	eval "${ZED_EMAIL_PROG}" ${ZED_EMAIL_OPTS} < "${pathname}" >/dev/null 2>&1
	rv=$?
	if [ "${rv}" -ne 0 ]; then
	zed_log_err "$(basename "${ZED_EMAIL_PROG}") exit=${rv}"
	return 1
	fi
	return 0
	}


	# zed_notify_pushbullet (subject, pathname)
	#
	# Send a notification via Pushbullet <https://www.pushbullet.com/>.
	# The access token (ZED_PUSHBULLET_ACCESS_TOKEN) identifies this client to the
	# Pushbullet server. The optional channel tag (ZED_PUSHBULLET_CHANNEL_TAG) is
	# for pushing to notification feeds that can be subscribed to; if a channel is
	# not defined, push notifications will instead be sent to all devices
	# associated with the account specified by the access token.
	#
	# Requires awk, curl, and sed executables to be installed in the standard PATH.
	#
	# References
	# https://docs.pushbullet.com/
	# https://www.pushbullet.com/security
	#
	# Arguments
	# subject: notification subject
	# pathname: pathname containing the notification message (OPTIONAL)
	#
	# Globals
	# ZED_PUSHBULLET_ACCESS_TOKEN
	# ZED_PUSHBULLET_CHANNEL_TAG
	#
	# Return
	# 0: notification sent
	# 1: notification failed
	# 2: not configured
	#
	zed_notify_pushbullet()
	{
	local subject="$1"
	local pathname="${2:-"/dev/null"}"
	local msg_body
	local msg_tag
	local msg_json
	local msg_out
	local msg_err
	local url="https://api.pushbullet.com/v2/pushes"

	[ -n "${ZED_PUSHBULLET_ACCESS_TOKEN}" ] \|\| return 2

	[ -n "${subject}" ] \|\| return 1
	if [ ! -r "${pathname}" ]; then
	zed_log_err "pushbullet cannot read \"${pathname}\""
	return 1
	fi

	zed_check_cmd "awk" "curl" "sed" \|\| return 1

	# Escape the following characters in the message body for JSON:
	# newline, backslash, double quote, horizontal tab, vertical tab,
	# and carriage return.
	#
	msg_body="$(awk '{ ORS="\\n" } { gsub(/\\/, "\\\\"); gsub(/"/, "\\\"");
	gsub(/\t/, "\\t"); gsub(/\f/, "\\f"); gsub(/\r/, "\\r"); print }' \
	"${pathname}")"

	# Push to a channel if one is configured.
	#
	[ -n "${ZED_PUSHBULLET_CHANNEL_TAG}" ] && msg_tag="$(printf \
	'"channel_tag": "%s", ' "${ZED_PUSHBULLET_CHANNEL_TAG}")"

	# Construct the JSON message for pushing a note.
	#
	msg_json="$(printf '{%s"type": "note", "title": "%s", "body": "%s"}' \
	"${msg_tag}" "${subject}" "${msg_body}")"

	# Send the POST request and check for errors.
	#
	msg_out="$(curl -u "${ZED_PUSHBULLET_ACCESS_TOKEN}:" -X POST "${url}" \
	--header "Content-Type: application/json" --data-binary "${msg_json}" \
	2>/dev/null)"; rv=$?
	if [ "${rv}" -ne 0 ]; then
	zed_log_err "curl exit=${rv}"
	return 1
	fi
	msg_err="$(echo "${msg_out}" \
	\| sed -n -e 's/."error" :."message" : "$[^"]$".*/\1/p')"
	if [ -n "${msg_err}" ]; then
	zed_log_err "pushbullet \"${msg_err}"\"
	return 1
	fi
	return 0
	}


	# zed_notify_slack_webhook (subject, pathname)
	#
	# Notification via Slack Webhook <https://api.slack.com/incoming-webhooks>.
	# The Webhook URL (ZED_SLACK_WEBHOOK_URL) identifies this client to the
	-# Slack channel.
	+# Slack channel.
	#
	# Requires awk, curl, and sed executables to be installed in the standard PATH.
	#
	# References
	# https://api.slack.com/incoming-webhooks
	#
	# Arguments
	# subject: notification subject
	# pathname: pathname containing the notification message (OPTIONAL)
	#
	# Globals
	# ZED_SLACK_WEBHOOK_URL
	#
	# Return
	# 0: notification sent
	# 1: notification failed
	# 2: not configured
	#
	zed_notify_slack_webhook()
	{
	[ -n "${ZED_SLACK_WEBHOOK_URL}" ] \|\| return 2

	local subject="$1"
	local pathname="${2:-"/dev/null"}"
	local msg_body
	local msg_tag
	local msg_json
	local msg_out
	local msg_err
	local url="${ZED_SLACK_WEBHOOK_URL}"

	[ -n "${subject}" ] \|\| return 1
	if [ ! -r "${pathname}" ]; then
	zed_log_err "slack webhook cannot read \"${pathname}\""
	return 1
	fi

	zed_check_cmd "awk" "curl" "sed" \|\| return 1

	# Escape the following characters in the message body for JSON:
	# newline, backslash, double quote, horizontal tab, vertical tab,
	# and carriage return.
	#
	msg_body="$(awk '{ ORS="\\n" } { gsub(/\\/, "\\\\"); gsub(/"/, "\\\"");
	gsub(/\t/, "\\t"); gsub(/\f/, "\\f"); gsub(/\r/, "\\r"); print }' \
	"${pathname}")"

	# Construct the JSON message for posting.
	#
	msg_json="$(printf '{"text": "%s\n%s"}' "${subject}" "${msg_body}" )"

	# Send the POST request and check for errors.
	#
	msg_out="$(curl -X POST "${url}" \
	--header "Content-Type: application/json" --data-binary "${msg_json}" \
	2>/dev/null)"; rv=$?
	if [ "${rv}" -ne 0 ]; then
	zed_log_err "curl exit=${rv}"
	return 1
	fi
	msg_err="$(echo "${msg_out}" \
	\| sed -n -e 's/."error" :."message" : "$[^"]$".*/\1/p')"
	if [ -n "${msg_err}" ]; then
	zed_log_err "slack webhook \"${msg_err}"\"
	return 1
	fi
	return 0
	}

	# zed_rate_limit (tag, [interval])
	#
	# Check whether an event of a given type [tag] has already occurred within the
	# last [interval] seconds.
	#
	# This function obtains a lock on the statefile using file descriptor 9.
	#
	# Arguments
	# tag: arbitrary string for grouping related events to rate-limit
	# interval: time interval in seconds (OPTIONAL)
	#
	# Globals
	# ZED_NOTIFY_INTERVAL_SECS
	# ZED_RUNDIR
	#
	# Return
	# 0 if the event should be processed
	# 1 if the event should be dropped
	#
	# State File Format
	# time;tag
	#
	zed_rate_limit()
	{
	local tag="$1"
	local interval="${2:-${ZED_NOTIFY_INTERVAL_SECS}}"
	local lockfile="zed.zedlet.state.lock"
	local lockfile_fd=9
	local statefile="${ZED_RUNDIR}/zed.zedlet.state"
	local time_now
	local time_prev
	local umask_bak
	local rv=0

	[ -n "${tag}" ] \|\| return 0

	zed_lock "${lockfile}" "${lockfile_fd}"
	time_now="$(date +%s)"
	time_prev="$(grep -E "^[0-9]+;${tag}\$" "${statefile}" 2>/dev/null \
	\| tail -1 \| cut -d\; -f1)"

	if [ -n "${time_prev}" ] \
	&& [ "$((time_now - time_prev))" -lt "${interval}" ]; then
	rv=1
	else
	umask_bak="$(umask)"
	umask 077
	grep -E -v "^[0-9]+;${tag}\$" "${statefile}" 2>/dev/null \
	> "${statefile}.$$"
	echo "${time_now};${tag}" >> "${statefile}.$$"
	mv -f "${statefile}.$$" "${statefile}"
	umask "${umask_bak}"
	fi

	zed_unlock "${lockfile}" "${lockfile_fd}"
	return "${rv}"
	}


	# zed_guid_to_pool (guid)
	#
	# Convert a pool GUID into its pool name (like "tank")
	# Arguments
	# guid: pool GUID (decimal or hex)
	#
	# Return
	# Pool name
	#
	zed_guid_to_pool()
	{
	if [ -z "$1" ] ; then
	return
	fi

	- guid=$(printf "%llu" "$1")
	- if [ -n "$guid" ] ; then
	- $ZPOOL get -H -ovalue,name guid \| awk '$1=='"$guid"' {print $2}'
	- fi
	+ guid="$(printf "%u" "$1")"
	+ $ZPOOL get -H -ovalue,name guid \| awk '$1 == '"$guid"' {print $2; exit}'
	}

	# zed_exit_if_ignoring_this_event
	#
	# Exit the script if we should ignore this event, as determined by
	# $ZED_SYSLOG_SUBCLASS_INCLUDE and $ZED_SYSLOG_SUBCLASS_EXCLUDE in zed.rc.
	# This function assumes you've imported the normal zed variables.
	zed_exit_if_ignoring_this_event()
	{
	if [ -n "${ZED_SYSLOG_SUBCLASS_INCLUDE}" ]; then
	eval "case ${ZEVENT_SUBCLASS} in
	${ZED_SYSLOG_SUBCLASS_INCLUDE});;
	*) exit 0;;
	esac"
	elif [ -n "${ZED_SYSLOG_SUBCLASS_EXCLUDE}" ]; then
	eval "case ${ZEVENT_SUBCLASS} in
	${ZED_SYSLOG_SUBCLASS_EXCLUDE}) exit 0;;
	*);;
	esac"
	fi
	}
	diff --git a/sys/contrib/openzfs/cmd/zed/zed.h b/sys/contrib/openzfs/cmd/zed/zed.h
	index be57f1136fea..94f13c2c9da7 100644
	--- a/sys/contrib/openzfs/cmd/zed/zed.h
	+++ b/sys/contrib/openzfs/cmd/zed/zed.h
	@@ -1,58 +1,43 @@
	/*
	* This file is part of the ZFS Event Daemon (ZED).
	*
	* Developed at Lawrence Livermore National Laboratory (LLNL-CODE-403049).
	* Copyright (C) 2013-2014 Lawrence Livermore National Security, LLC.
	- * Refer to the ZoL git commit log for authoritative copyright attribution.
	+ * Refer to the OpenZFS git commit log for authoritative copyright attribution.
	*
	* The contents of this file are subject to the terms of the
	* Common Development and Distribution License Version 1.0 (CDDL-1.0).
	* You can obtain a copy of the license from the top-level file
	* "OPENSOLARIS.LICENSE" or at <http://opensource.org/licenses/CDDL-1.0>.
	* You may not use this file except in compliance with the license.
	*/

	#ifndef ZED_H
	#define ZED_H

	-/*
	- * Absolute path for the default zed configuration file.
	- */
	-#define ZED_CONF_FILE SYSCONFDIR "/zfs/zed.conf"
	-
	/*
	* Absolute path for the default zed pid file.
	*/
	#define ZED_PID_FILE RUNSTATEDIR "/zed.pid"

	/*
	* Absolute path for the default zed state file.
	*/
	#define ZED_STATE_FILE RUNSTATEDIR "/zed.state"

	/*
	* Absolute path for the default zed zedlet directory.
	*/
	#define ZED_ZEDLET_DIR SYSCONFDIR "/zfs/zed.d"

	-/*
	- * Reserved for future use.
	- */
	-#define ZED_MAX_EVENTS 0
	-
	-/*
	- * Reserved for future use.
	- */
	-#define ZED_MIN_EVENTS 0
	-
	/*
	* String prefix for ZED variables passed via environment variables.
	*/
	#define ZED_VAR_PREFIX "ZED_"

	/*
	* String prefix for ZFS event names passed via environment variables.
	*/
	#define ZEVENT_VAR_PREFIX "ZEVENT_"

	#endif /* !ZED_H */
	diff --git a/sys/contrib/openzfs/cmd/zed/zed_conf.c b/sys/contrib/openzfs/cmd/zed/zed_conf.c
	index c15f01fecb41..2cf2311dbb42 100644
	--- a/sys/contrib/openzfs/cmd/zed/zed_conf.c
	+++ b/sys/contrib/openzfs/cmd/zed/zed_conf.c
	@@ -1,735 +1,705 @@
	/*
	* This file is part of the ZFS Event Daemon (ZED).
	*
	* Developed at Lawrence Livermore National Laboratory (LLNL-CODE-403049).
	* Copyright (C) 2013-2014 Lawrence Livermore National Security, LLC.
	- * Refer to the ZoL git commit log for authoritative copyright attribution.
	+ * Refer to the OpenZFS git commit log for authoritative copyright attribution.
	*
	* The contents of this file are subject to the terms of the
	* Common Development and Distribution License Version 1.0 (CDDL-1.0).
	* You can obtain a copy of the license from the top-level file
	* "OPENSOLARIS.LICENSE" or at <http://opensource.org/licenses/CDDL-1.0>.
	* You may not use this file except in compliance with the license.
	*/

	#include <assert.h>
	#include <ctype.h>
	#include <dirent.h>
	#include <errno.h>
	#include <fcntl.h>
	#include <libgen.h>
	#include <limits.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <sys/stat.h>
	#include <sys/uio.h>
	#include <unistd.h>
	#include "zed.h"
	#include "zed_conf.h"
	#include "zed_file.h"
	#include "zed_log.h"
	#include "zed_strings.h"

	/*
	- * Return a new configuration with default values.
	+ * Initialise the configuration with default values.
	*/
	-struct zed_conf *
	-zed_conf_create(void)
	+void
	+zed_conf_init(struct zed_conf *zcp)
	{
	- struct zed_conf *zcp;
	-
	- zcp = calloc(1, sizeof (*zcp));
	- if (!zcp)
	- goto nomem;
	-
	- zcp->syslog_facility = LOG_DAEMON;
	- zcp->min_events = ZED_MIN_EVENTS;
	- zcp->max_events = ZED_MAX_EVENTS;
	- zcp->pid_fd = -1;
	- zcp->zedlets = NULL; /* created via zed_conf_scan_dir() */
	- zcp->state_fd = -1; /* opened via zed_conf_open_state() */
	- zcp->zfs_hdl = NULL; /* opened via zed_event_init() */
	- zcp->zevent_fd = -1; /* opened via zed_event_init() */
	-
	- if (!(zcp->conf_file = strdup(ZED_CONF_FILE)))
	- goto nomem;
	+ memset(zcp, 0, sizeof (*zcp));

	- if (!(zcp->pid_file = strdup(ZED_PID_FILE)))
	- goto nomem;
	+ /* zcp->zfs_hdl opened in zed_event_init() */
	+ /* zcp->zedlets created in zed_conf_scan_dir() */

	- if (!(zcp->zedlet_dir = strdup(ZED_ZEDLET_DIR)))
	- goto nomem;
	+ zcp->pid_fd = -1; /* opened in zed_conf_write_pid() */
	+ zcp->state_fd = -1; /* opened in zed_conf_open_state() */
	+ zcp->zevent_fd = -1; /* opened in zed_event_init() */

	- if (!(zcp->state_file = strdup(ZED_STATE_FILE)))
	- goto nomem;
	+ zcp->max_jobs = 16;

	- return (zcp);
	-
	-nomem:
	- zed_log_die("Failed to create conf: %s", strerror(errno));
	- return (NULL);
	+ if (!(zcp->pid_file = strdup(ZED_PID_FILE)) \|\|
	+ !(zcp->zedlet_dir = strdup(ZED_ZEDLET_DIR)) \|\|
	+ !(zcp->state_file = strdup(ZED_STATE_FILE)))
	+ zed_log_die("Failed to create conf: %s", strerror(errno));
	}

	/*
	* Destroy the configuration [zcp].
	*
	* Note: zfs_hdl & zevent_fd are destroyed via zed_event_fini().
	*/
	void
	zed_conf_destroy(struct zed_conf *zcp)
	{
	- if (!zcp)
	- return;
	-
	if (zcp->state_fd >= 0) {
	if (close(zcp->state_fd) < 0)
	zed_log_msg(LOG_WARNING,
	"Failed to close state file \"%s\": %s",
	zcp->state_file, strerror(errno));
	zcp->state_fd = -1;
	}
	if (zcp->pid_file) {
	if ((unlink(zcp->pid_file) < 0) && (errno != ENOENT))
	zed_log_msg(LOG_WARNING,
	"Failed to remove PID file \"%s\": %s",
	zcp->pid_file, strerror(errno));
	}
	if (zcp->pid_fd >= 0) {
	if (close(zcp->pid_fd) < 0)
	zed_log_msg(LOG_WARNING,
	"Failed to close PID file \"%s\": %s",
	zcp->pid_file, strerror(errno));
	zcp->pid_fd = -1;
	}
	- if (zcp->conf_file) {
	- free(zcp->conf_file);
	- zcp->conf_file = NULL;
	- }
	if (zcp->pid_file) {
	free(zcp->pid_file);
	zcp->pid_file = NULL;
	}
	if (zcp->zedlet_dir) {
	free(zcp->zedlet_dir);
	zcp->zedlet_dir = NULL;
	}
	if (zcp->state_file) {
	free(zcp->state_file);
	zcp->state_file = NULL;
	}
	if (zcp->zedlets) {
	zed_strings_destroy(zcp->zedlets);
	zcp->zedlets = NULL;
	}
	- free(zcp);
	}

	/*
	* Display command-line help and exit.
	*
	* If [got_err] is 0, output to stdout and exit normally;
	* otherwise, output to stderr and exit with a failure status.
	*/
	static void
	-_zed_conf_display_help(const char *prog, int got_err)
	+_zed_conf_display_help(const char *prog, boolean_t got_err)
	{
	+ struct opt { const char o, d, *v; };
	+
	FILE *fp = got_err ? stderr : stdout;
	- int w1 = 4; /* width of leading whitespace */
	- int w2 = 8; /* width of L-justified option field */
	+
	+ struct opt *oo;
	+ struct opt iopts[] = {
	+ { .o = "-h", .d = "Display help" },
	+ { .o = "-L", .d = "Display license information" },
	+ { .o = "-V", .d = "Display version information" },
	+ {},
	+ };
	+ struct opt nopts[] = {
	+ { .o = "-v", .d = "Be verbose" },
	+ { .o = "-f", .d = "Force daemon to run" },
	+ { .o = "-F", .d = "Run daemon in the foreground" },
	+ { .o = "-I",
	+ .d = "Idle daemon until kernel module is (re)loaded" },
	+ { .o = "-M", .d = "Lock all pages in memory" },
	+ { .o = "-P", .d = "$PATH for ZED to use (only used by ZTS)" },
	+ { .o = "-Z", .d = "Zero state file" },
	+ {},
	+ };
	+ struct opt vopts[] = {
	+ { .o = "-d DIR", .d = "Read enabled ZEDLETs from DIR.",
	+ .v = ZED_ZEDLET_DIR },
	+ { .o = "-p FILE", .d = "Write daemon's PID to FILE.",
	+ .v = ZED_PID_FILE },
	+ { .o = "-s FILE", .d = "Write daemon's state to FILE.",
	+ .v = ZED_STATE_FILE },
	+ { .o = "-j JOBS", .d = "Start at most JOBS at once.",
	+ .v = "16" },
	+ {},
	+ };

	fprintf(fp, "Usage: %s [OPTION]...\n", (prog ? prog : "zed"));
	fprintf(fp, "\n");
	- fprintf(fp, "%c%s %s\n", w1, 0x20, -w2, "-h",
	- "Display help.");
	- fprintf(fp, "%c%s %s\n", w1, 0x20, -w2, "-L",
	- "Display license information.");
	- fprintf(fp, "%c%s %s\n", w1, 0x20, -w2, "-V",
	- "Display version information.");
	+ for (oo = iopts; oo->o; ++oo)
	+ fprintf(fp, " %*s %s\n", -8, oo->o, oo->d);
	fprintf(fp, "\n");
	- fprintf(fp, "%c%s %s\n", w1, 0x20, -w2, "-v",
	- "Be verbose.");
	- fprintf(fp, "%c%s %s\n", w1, 0x20, -w2, "-f",
	- "Force daemon to run.");
	- fprintf(fp, "%c%s %s\n", w1, 0x20, -w2, "-F",
	- "Run daemon in the foreground.");
	- fprintf(fp, "%c%s %s\n", w1, 0x20, -w2, "-I",
	- "Idle daemon until kernel module is (re)loaded.");
	- fprintf(fp, "%c%s %s\n", w1, 0x20, -w2, "-M",
	- "Lock all pages in memory.");
	- fprintf(fp, "%c%s %s\n", w1, 0x20, -w2, "-P",
	- "$PATH for ZED to use (only used by ZTS).");
	- fprintf(fp, "%c%s %s\n", w1, 0x20, -w2, "-Z",
	- "Zero state file.");
	+ for (oo = nopts; oo->o; ++oo)
	+ fprintf(fp, " %*s %s\n", -8, oo->o, oo->d);
	fprintf(fp, "\n");
	-#if 0
	- fprintf(fp, "%c%s %s [%s]\n", w1, 0x20, -w2, "-c FILE",
	- "Read configuration from FILE.", ZED_CONF_FILE);
	-#endif
	- fprintf(fp, "%c%s %s [%s]\n", w1, 0x20, -w2, "-d DIR",
	- "Read enabled ZEDLETs from DIR.", ZED_ZEDLET_DIR);
	- fprintf(fp, "%c%s %s [%s]\n", w1, 0x20, -w2, "-p FILE",
	- "Write daemon's PID to FILE.", ZED_PID_FILE);
	- fprintf(fp, "%c%s %s [%s]\n", w1, 0x20, -w2, "-s FILE",
	- "Write daemon's state to FILE.", ZED_STATE_FILE);
	+ for (oo = vopts; oo->o; ++oo)
	+ fprintf(fp, " %*s %s [%s]\n", -8, oo->o, oo->d, oo->v);
	fprintf(fp, "\n");

	exit(got_err ? EXIT_FAILURE : EXIT_SUCCESS);
	}

	/*
	* Display license information to stdout and exit.
	*/
	static void
	_zed_conf_display_license(void)
	{
	- const char **pp;
	- const char *text[] = {
	- "The ZFS Event Daemon (ZED) is distributed under the terms of the",
	- " Common Development and Distribution License (CDDL-1.0)",
	- " <http://opensource.org/licenses/CDDL-1.0>.",
	- "",
	+ printf(
	+ "The ZFS Event Daemon (ZED) is distributed under the terms of the\n"
	+ " Common Development and Distribution License (CDDL-1.0)\n"
	+ " <http://opensource.org/licenses/CDDL-1.0>.\n"
	+ "\n"
	"Developed at Lawrence Livermore National Laboratory"
	- " (LLNL-CODE-403049).",
	- "",
	- NULL
	- };
	-
	- for (pp = text; *pp; pp++)
	- printf("%s\n", *pp);
	+ " (LLNL-CODE-403049).\n"
	+ "\n");

	exit(EXIT_SUCCESS);
	}

	/*
	* Display version information to stdout and exit.
	*/
	static void
	_zed_conf_display_version(void)
	{
	printf("%s-%s-%s\n",
	ZFS_META_NAME, ZFS_META_VERSION, ZFS_META_RELEASE);

	exit(EXIT_SUCCESS);
	}

	/*
	* Copy the [path] string to the [resultp] ptr.
	* If [path] is not an absolute path, prefix it with the current working dir.
	* If [resultp] is non-null, free its existing string before assignment.
	*/
	static void
	_zed_conf_parse_path(char *resultp, const char path)
	{
	char buf[PATH_MAX];

	assert(resultp != NULL);
	assert(path != NULL);

	if (*resultp)
	free(*resultp);

	if (path[0] == '/') {
	*resultp = strdup(path);
	- } else if (!getcwd(buf, sizeof (buf))) {
	- zed_log_die("Failed to get current working dir: %s",
	- strerror(errno));
	- } else if (strlcat(buf, "/", sizeof (buf)) >= sizeof (buf)) {
	- zed_log_die("Failed to copy path: %s", strerror(ENAMETOOLONG));
	- } else if (strlcat(buf, path, sizeof (buf)) >= sizeof (buf)) {
	- zed_log_die("Failed to copy path: %s", strerror(ENAMETOOLONG));
	} else {
	+ if (!getcwd(buf, sizeof (buf)))
	+ zed_log_die("Failed to get current working dir: %s",
	+ strerror(errno));
	+
	+ if (strlcat(buf, "/", sizeof (buf)) >= sizeof (buf) \|\|
	+ strlcat(buf, path, sizeof (buf)) >= sizeof (buf))
	+ zed_log_die("Failed to copy path: %s",
	+ strerror(ENAMETOOLONG));
	+
	*resultp = strdup(buf);
	}
	+
	if (!*resultp)
	zed_log_die("Failed to copy path: %s", strerror(ENOMEM));
	}

	/*
	* Parse the command-line options into the configuration [zcp].
	*/
	void
	zed_conf_parse_opts(struct zed_conf zcp, int argc, char *argv)
	{
	- const char * const opts = ":hLVc:d:p:P:s:vfFMZI";
	+ const char * const opts = ":hLVd:p:P:s:vfFMZIj:";
	int opt;
	+ unsigned long raw;

	if (!zcp \|\| !argv \|\| !argv[0])
	zed_log_die("Failed to parse options: Internal error");

	opterr = 0; /* suppress default getopt err msgs */

	while ((opt = getopt(argc, argv, opts)) != -1) {
	switch (opt) {
	case 'h':
	- _zed_conf_display_help(argv[0], EXIT_SUCCESS);
	+ _zed_conf_display_help(argv[0], B_FALSE);
	break;
	case 'L':
	_zed_conf_display_license();
	break;
	case 'V':
	_zed_conf_display_version();
	break;
	- case 'c':
	- _zed_conf_parse_path(&zcp->conf_file, optarg);
	- break;
	case 'd':
	_zed_conf_parse_path(&zcp->zedlet_dir, optarg);
	break;
	case 'I':
	zcp->do_idle = 1;
	break;
	case 'p':
	_zed_conf_parse_path(&zcp->pid_file, optarg);
	break;
	case 'P':
	_zed_conf_parse_path(&zcp->path, optarg);
	break;
	case 's':
	_zed_conf_parse_path(&zcp->state_file, optarg);
	break;
	case 'v':
	zcp->do_verbose = 1;
	break;
	case 'f':
	zcp->do_force = 1;
	break;
	case 'F':
	zcp->do_foreground = 1;
	break;
	case 'M':
	zcp->do_memlock = 1;
	break;
	case 'Z':
	zcp->do_zero = 1;
	break;
	+ case 'j':
	+ errno = 0;
	+ raw = strtoul(optarg, NULL, 0);
	+ if (errno == ERANGE \|\| raw > INT16_MAX) {
	+ zed_log_die("%lu is too many jobs", raw);
	+ } if (raw == 0) {
	+ zed_log_die("0 jobs makes no sense");
	+ } else {
	+ zcp->max_jobs = raw;
	+ }
	+ break;
	case '?':
	default:
	if (optopt == '?')
	- _zed_conf_display_help(argv[0], EXIT_SUCCESS);
	+ _zed_conf_display_help(argv[0], B_FALSE);

	- fprintf(stderr, "%s: %s '-%c'\n\n", argv[0],
	- "Invalid option", optopt);
	- _zed_conf_display_help(argv[0], EXIT_FAILURE);
	+ fprintf(stderr, "%s: Invalid option '-%c'\n\n",
	+ argv[0], optopt);
	+ _zed_conf_display_help(argv[0], B_TRUE);
	break;
	}
	}
	}

	-/*
	- * Parse the configuration file into the configuration [zcp].
	- *
	- * FIXME: Not yet implemented.
	- */
	-void
	-zed_conf_parse_file(struct zed_conf *zcp)
	-{
	- if (!zcp)
	- zed_log_die("Failed to parse config: %s", strerror(EINVAL));
	-}
	-
	/*
	* Scan the [zcp] zedlet_dir for files to exec based on the event class.
	* Files must be executable by user, but not writable by group or other.
	* Dotfiles are ignored.
	*
	* Return 0 on success with an updated set of zedlets,
	* or -1 on error with errno set.
	- *
	- * FIXME: Check if zedlet_dir and all parent dirs are secure.
	*/
	int
	zed_conf_scan_dir(struct zed_conf *zcp)
	{
	zed_strings_t *zedlets;
	DIR *dirp;
	struct dirent *direntp;
	char pathname[PATH_MAX];
	struct stat st;
	int n;

	if (!zcp) {
	errno = EINVAL;
	zed_log_msg(LOG_ERR, "Failed to scan zedlet dir: %s",
	strerror(errno));
	return (-1);
	}
	zedlets = zed_strings_create();
	if (!zedlets) {
	errno = ENOMEM;
	zed_log_msg(LOG_WARNING, "Failed to scan dir \"%s\": %s",
	zcp->zedlet_dir, strerror(errno));
	return (-1);
	}
	dirp = opendir(zcp->zedlet_dir);
	if (!dirp) {
	int errno_bak = errno;
	zed_log_msg(LOG_WARNING, "Failed to open dir \"%s\": %s",
	zcp->zedlet_dir, strerror(errno));
	zed_strings_destroy(zedlets);
	errno = errno_bak;
	return (-1);
	}
	while ((direntp = readdir(dirp))) {
	if (direntp->d_name[0] == '.')
	continue;

	n = snprintf(pathname, sizeof (pathname),
	"%s/%s", zcp->zedlet_dir, direntp->d_name);
	if ((n < 0) \|\| (n >= sizeof (pathname))) {
	zed_log_msg(LOG_WARNING, "Failed to stat \"%s\": %s",
	direntp->d_name, strerror(ENAMETOOLONG));
	continue;
	}
	if (stat(pathname, &st) < 0) {
	zed_log_msg(LOG_WARNING, "Failed to stat \"%s\": %s",
	pathname, strerror(errno));
	continue;
	}
	if (!S_ISREG(st.st_mode)) {
	zed_log_msg(LOG_INFO,
	"Ignoring \"%s\": not a regular file",
	direntp->d_name);
	continue;
	}
	if ((st.st_uid != 0) && !zcp->do_force) {
	zed_log_msg(LOG_NOTICE,
	"Ignoring \"%s\": not owned by root",
	direntp->d_name);
	continue;
	}
	if (!(st.st_mode & S_IXUSR)) {
	zed_log_msg(LOG_INFO,
	"Ignoring \"%s\": not executable by user",
	direntp->d_name);
	continue;
	}
	if ((st.st_mode & S_IWGRP) && !zcp->do_force) {
	zed_log_msg(LOG_NOTICE,
	"Ignoring \"%s\": writable by group",
	direntp->d_name);
	continue;
	}
	if ((st.st_mode & S_IWOTH) && !zcp->do_force) {
	zed_log_msg(LOG_NOTICE,
	"Ignoring \"%s\": writable by other",
	direntp->d_name);
	continue;
	}
	if (zed_strings_add(zedlets, NULL, direntp->d_name) < 0) {
	zed_log_msg(LOG_WARNING,
	"Failed to register \"%s\": %s",
	direntp->d_name, strerror(errno));
	continue;
	}
	if (zcp->do_verbose)
	zed_log_msg(LOG_INFO,
	"Registered zedlet \"%s\"", direntp->d_name);
	}
	if (closedir(dirp) < 0) {
	int errno_bak = errno;
	zed_log_msg(LOG_WARNING, "Failed to close dir \"%s\": %s",
	zcp->zedlet_dir, strerror(errno));
	zed_strings_destroy(zedlets);
	errno = errno_bak;
	return (-1);
	}
	if (zcp->zedlets)
	zed_strings_destroy(zcp->zedlets);

	zcp->zedlets = zedlets;
	return (0);
	}

	/*
	* Write the PID file specified in [zcp].
	* Return 0 on success, -1 on error.
	*
	* This must be called after fork()ing to become a daemon (so the correct PID
	* is recorded), but before daemonization is complete and the parent process
	* exits (for synchronization with systemd).
	*/
	int
	zed_conf_write_pid(struct zed_conf *zcp)
	{
	- const mode_t dirmode = S_IRWXU \| S_IRGRP \| S_IXGRP \| S_IROTH \| S_IXOTH;
	- const mode_t filemode = S_IRUSR \| S_IWUSR \| S_IRGRP \| S_IROTH;
	char buf[PATH_MAX];
	int n;
	char *p;
	mode_t mask;
	int rv;

	if (!zcp \|\| !zcp->pid_file) {
	errno = EINVAL;
	zed_log_msg(LOG_ERR, "Failed to create PID file: %s",
	strerror(errno));
	return (-1);
	}
	assert(zcp->pid_fd == -1);
	/*
	* Create PID file directory if needed.
	*/
	n = strlcpy(buf, zcp->pid_file, sizeof (buf));
	if (n >= sizeof (buf)) {
	errno = ENAMETOOLONG;
	zed_log_msg(LOG_ERR, "Failed to create PID file: %s",
	strerror(errno));
	goto err;
	}
	p = strrchr(buf, '/');
	if (p)
	*p = '\0';

	- if ((mkdirp(buf, dirmode) < 0) && (errno != EEXIST)) {
	+ if ((mkdirp(buf, 0755) < 0) && (errno != EEXIST)) {
	zed_log_msg(LOG_ERR, "Failed to create directory \"%s\": %s",
	buf, strerror(errno));
	goto err;
	}
	/*
	* Obtain PID file lock.
	*/
	mask = umask(0);
	umask(mask \| 022);
	- zcp->pid_fd = open(zcp->pid_file, (O_RDWR \| O_CREAT), filemode);
	+ zcp->pid_fd = open(zcp->pid_file, O_RDWR \| O_CREAT \| O_CLOEXEC, 0644);
	umask(mask);
	if (zcp->pid_fd < 0) {
	zed_log_msg(LOG_ERR, "Failed to open PID file \"%s\": %s",
	zcp->pid_file, strerror(errno));
	goto err;
	}
	rv = zed_file_lock(zcp->pid_fd);
	if (rv < 0) {
	zed_log_msg(LOG_ERR, "Failed to lock PID file \"%s\": %s",
	zcp->pid_file, strerror(errno));
	goto err;
	} else if (rv > 0) {
	pid_t pid = zed_file_is_locked(zcp->pid_fd);
	if (pid < 0) {
	zed_log_msg(LOG_ERR,
	"Failed to test lock on PID file \"%s\"",
	zcp->pid_file);
	} else if (pid > 0) {
	zed_log_msg(LOG_ERR,
	"Found PID %d bound to PID file \"%s\"",
	pid, zcp->pid_file);
	} else {
	zed_log_msg(LOG_ERR,
	"Inconsistent lock state on PID file \"%s\"",
	zcp->pid_file);
	}
	goto err;
	}
	/*
	* Write PID file.
	*/
	n = snprintf(buf, sizeof (buf), "%d\n", (int)getpid());
	if ((n < 0) \|\| (n >= sizeof (buf))) {
	errno = ERANGE;
	zed_log_msg(LOG_ERR, "Failed to write PID file \"%s\": %s",
	zcp->pid_file, strerror(errno));
	- } else if (zed_file_write_n(zcp->pid_fd, buf, n) != n) {
	+ } else if (write(zcp->pid_fd, buf, n) != n) {
	zed_log_msg(LOG_ERR, "Failed to write PID file \"%s\": %s",
	zcp->pid_file, strerror(errno));
	} else if (fdatasync(zcp->pid_fd) < 0) {
	zed_log_msg(LOG_ERR, "Failed to sync PID file \"%s\": %s",
	zcp->pid_file, strerror(errno));
	} else {
	return (0);
	}

	err:
	if (zcp->pid_fd >= 0) {
	(void) close(zcp->pid_fd);
	zcp->pid_fd = -1;
	}
	return (-1);
	}

	/*
	* Open and lock the [zcp] state_file.
	* Return 0 on success, -1 on error.
	*
	* FIXME: Move state information into kernel.
	*/
	int
	zed_conf_open_state(struct zed_conf *zcp)
	{
	char dirbuf[PATH_MAX];
	- mode_t dirmode = S_IRWXU \| S_IRGRP \| S_IXGRP \| S_IROTH \| S_IXOTH;
	int n;
	char *p;
	int rv;

	if (!zcp \|\| !zcp->state_file) {
	errno = EINVAL;
	zed_log_msg(LOG_ERR, "Failed to open state file: %s",
	strerror(errno));
	return (-1);
	}
	n = strlcpy(dirbuf, zcp->state_file, sizeof (dirbuf));
	if (n >= sizeof (dirbuf)) {
	errno = ENAMETOOLONG;
	zed_log_msg(LOG_WARNING, "Failed to open state file: %s",
	strerror(errno));
	return (-1);
	}
	p = strrchr(dirbuf, '/');
	if (p)
	*p = '\0';

	- if ((mkdirp(dirbuf, dirmode) < 0) && (errno != EEXIST)) {
	+ if ((mkdirp(dirbuf, 0755) < 0) && (errno != EEXIST)) {
	zed_log_msg(LOG_WARNING,
	"Failed to create directory \"%s\": %s",
	dirbuf, strerror(errno));
	return (-1);
	}
	if (zcp->state_fd >= 0) {
	if (close(zcp->state_fd) < 0) {
	zed_log_msg(LOG_WARNING,
	"Failed to close state file \"%s\": %s",
	zcp->state_file, strerror(errno));
	return (-1);
	}
	}
	if (zcp->do_zero)
	(void) unlink(zcp->state_file);

	zcp->state_fd = open(zcp->state_file,
	- (O_RDWR \| O_CREAT), (S_IRUSR \| S_IWUSR \| S_IRGRP \| S_IROTH));
	+ O_RDWR \| O_CREAT \| O_CLOEXEC, 0644);
	if (zcp->state_fd < 0) {
	zed_log_msg(LOG_WARNING, "Failed to open state file \"%s\": %s",
	zcp->state_file, strerror(errno));
	return (-1);
	}
	rv = zed_file_lock(zcp->state_fd);
	if (rv < 0) {
	zed_log_msg(LOG_WARNING, "Failed to lock state file \"%s\": %s",
	zcp->state_file, strerror(errno));
	return (-1);
	}
	if (rv > 0) {
	pid_t pid = zed_file_is_locked(zcp->state_fd);
	if (pid < 0) {
	zed_log_msg(LOG_WARNING,
	"Failed to test lock on state file \"%s\"",
	zcp->state_file);
	} else if (pid > 0) {
	zed_log_msg(LOG_WARNING,
	"Found PID %d bound to state file \"%s\"",
	pid, zcp->state_file);
	} else {
	zed_log_msg(LOG_WARNING,
	"Inconsistent lock state on state file \"%s\"",
	zcp->state_file);
	}
	return (-1);
	}
	return (0);
	}

	/*
	* Read the opened [zcp] state_file to obtain the eid & etime of the last event
	* processed. Write the state from the last event to the [eidp] & [etime] args
	* passed by reference. Note that etime[] is an array of size 2.
	* Return 0 on success, -1 on error.
	*/
	int
	zed_conf_read_state(struct zed_conf zcp, uint64_t eidp, int64_t etime[])
	{
	ssize_t len;
	struct iovec iov[3];
	ssize_t n;

	if (!zcp \|\| !eidp \|\| !etime) {
	errno = EINVAL;
	zed_log_msg(LOG_ERR,
	"Failed to read state file: %s", strerror(errno));
	return (-1);
	}
	if (lseek(zcp->state_fd, 0, SEEK_SET) == (off_t)-1) {
	zed_log_msg(LOG_WARNING,
	"Failed to reposition state file offset: %s",
	strerror(errno));
	return (-1);
	}
	len = 0;
	iov[0].iov_base = eidp;
	len += iov[0].iov_len = sizeof (*eidp);
	iov[1].iov_base = &etime[0];
	len += iov[1].iov_len = sizeof (etime[0]);
	iov[2].iov_base = &etime[1];
	len += iov[2].iov_len = sizeof (etime[1]);

	n = readv(zcp->state_fd, iov, 3);
	if (n == 0) {
	*eidp = 0;
	} else if (n < 0) {
	zed_log_msg(LOG_WARNING,
	"Failed to read state file \"%s\": %s",
	zcp->state_file, strerror(errno));
	return (-1);
	} else if (n != len) {
	errno = EIO;
	zed_log_msg(LOG_WARNING,
	"Failed to read state file \"%s\": Read %d of %d bytes",
	zcp->state_file, n, len);
	return (-1);
	}
	return (0);
	}

	/*
	* Write the [eid] & [etime] of the last processed event to the opened
	* [zcp] state_file. Note that etime[] is an array of size 2.
	* Return 0 on success, -1 on error.
	*/
	int
	zed_conf_write_state(struct zed_conf *zcp, uint64_t eid, int64_t etime[])
	{
	ssize_t len;
	struct iovec iov[3];
	ssize_t n;

	if (!zcp) {
	errno = EINVAL;
	zed_log_msg(LOG_ERR,
	"Failed to write state file: %s", strerror(errno));
	return (-1);
	}
	if (lseek(zcp->state_fd, 0, SEEK_SET) == (off_t)-1) {
	zed_log_msg(LOG_WARNING,
	"Failed to reposition state file offset: %s",
	strerror(errno));
	return (-1);
	}
	len = 0;
	iov[0].iov_base = &eid;
	len += iov[0].iov_len = sizeof (eid);
	iov[1].iov_base = &etime[0];
	len += iov[1].iov_len = sizeof (etime[0]);
	iov[2].iov_base = &etime[1];
	len += iov[2].iov_len = sizeof (etime[1]);

	n = writev(zcp->state_fd, iov, 3);
	if (n < 0) {
	zed_log_msg(LOG_WARNING,
	"Failed to write state file \"%s\": %s",
	zcp->state_file, strerror(errno));
	return (-1);
	}
	if (n != len) {
	errno = EIO;
	zed_log_msg(LOG_WARNING,
	"Failed to write state file \"%s\": Wrote %d of %d bytes",
	zcp->state_file, n, len);
	return (-1);
	}
	if (fdatasync(zcp->state_fd) < 0) {
	zed_log_msg(LOG_WARNING,
	"Failed to sync state file \"%s\": %s",
	zcp->state_file, strerror(errno));
	return (-1);
	}
	return (0);
	}
	diff --git a/sys/contrib/openzfs/cmd/zed/zed_conf.h b/sys/contrib/openzfs/cmd/zed/zed_conf.h
	index f44d20382968..0b30a1503c52 100644
	--- a/sys/contrib/openzfs/cmd/zed/zed_conf.h
	+++ b/sys/contrib/openzfs/cmd/zed/zed_conf.h
	@@ -1,62 +1,58 @@
	/*
	* This file is part of the ZFS Event Daemon (ZED).
	*
	* Developed at Lawrence Livermore National Laboratory (LLNL-CODE-403049).
	* Copyright (C) 2013-2014 Lawrence Livermore National Security, LLC.
	- * Refer to the ZoL git commit log for authoritative copyright attribution.
	+ * Refer to the OpenZFS git commit log for authoritative copyright attribution.
	*
	* The contents of this file are subject to the terms of the
	* Common Development and Distribution License Version 1.0 (CDDL-1.0).
	* You can obtain a copy of the license from the top-level file
	* "OPENSOLARIS.LICENSE" or at <http://opensource.org/licenses/CDDL-1.0>.
	* You may not use this file except in compliance with the license.
	*/

	#ifndef ZED_CONF_H
	#define ZED_CONF_H

	#include <libzfs.h>
	#include <stdint.h>
	#include "zed_strings.h"

	struct zed_conf {
	- unsigned do_force:1; /* true if force enabled */
	- unsigned do_foreground:1; /* true if run in foreground */
	- unsigned do_memlock:1; /* true if locking memory */
	- unsigned do_verbose:1; /* true if verbosity enabled */
	- unsigned do_zero:1; /* true if zeroing state */
	- unsigned do_idle:1; /* true if idle enabled */
	- int syslog_facility; /* syslog facility value */
	- int min_events; /* RESERVED FOR FUTURE USE */
	- int max_events; /* RESERVED FOR FUTURE USE */
	- char conf_file; / abs path to config file */
	char pid_file; / abs path to pid file */
	- int pid_fd; /* fd to pid file for lock */
	char zedlet_dir; / abs path to zedlet dir */
	- zed_strings_t zedlets; / names of enabled zedlets */
	char state_file; / abs path to state file */
	- int state_fd; /* fd to state file */
	+
	libzfs_handle_t zfs_hdl; / handle to libzfs */
	- int zevent_fd; /* fd for access to zevents */
	+ zed_strings_t zedlets; / names of enabled zedlets */
	char path; / custom $PATH for zedlets to use */
	-};

	-struct zed_conf *zed_conf_create(void);
	+ int pid_fd; /* fd to pid file for lock */
	+ int state_fd; /* fd to state file */
	+ int zevent_fd; /* fd for access to zevents */
	+
	+ int16_t max_jobs; /* max zedlets to run at one time */
	+
	+ boolean_t do_force:1; /* true if force enabled */
	+ boolean_t do_foreground:1; /* true if run in foreground */
	+ boolean_t do_memlock:1; /* true if locking memory */
	+ boolean_t do_verbose:1; /* true if verbosity enabled */
	+ boolean_t do_zero:1; /* true if zeroing state */
	+ boolean_t do_idle:1; /* true if idle enabled */
	+};

	+void zed_conf_init(struct zed_conf *zcp);
	void zed_conf_destroy(struct zed_conf *zcp);

	void zed_conf_parse_opts(struct zed_conf zcp, int argc, char *argv);

	-void zed_conf_parse_file(struct zed_conf *zcp);
	-
	int zed_conf_scan_dir(struct zed_conf *zcp);

	int zed_conf_write_pid(struct zed_conf *zcp);

	int zed_conf_open_state(struct zed_conf *zcp);
	-
	int zed_conf_read_state(struct zed_conf zcp, uint64_t eidp, int64_t etime[]);
	-
	int zed_conf_write_state(struct zed_conf *zcp, uint64_t eid, int64_t etime[]);

	#endif /* !ZED_CONF_H */
	diff --git a/sys/contrib/openzfs/cmd/zed/zed_disk_event.c b/sys/contrib/openzfs/cmd/zed/zed_disk_event.c
	index 174d24523253..6ec566cff3ca 100644
	--- a/sys/contrib/openzfs/cmd/zed/zed_disk_event.c
	+++ b/sys/contrib/openzfs/cmd/zed/zed_disk_event.c
	@@ -1,416 +1,417 @@
	/*
	* CDDL HEADER START
	*
	* The contents of this file are subject to the terms of the
	* Common Development and Distribution License Version 1.0 (CDDL-1.0).
	* You can obtain a copy of the license from the top-level file
	* "OPENSOLARIS.LICENSE" or at <http://opensource.org/licenses/CDDL-1.0>.
	* You may not use this file except in compliance with the license.
	*
	* CDDL HEADER END
	*/

	/*
	* Copyright (c) 2016, 2017, Intel Corporation.
	*/

	#ifdef HAVE_LIBUDEV

	#include <errno.h>
	#include <fcntl.h>
	#include <libnvpair.h>
	#include <libudev.h>
	#include <libzfs.h>
	#include <libzutil.h>
	#include <pthread.h>
	#include <stdlib.h>
	#include <string.h>

	#include <sys/sysevent/eventdefs.h>
	#include <sys/sysevent/dev.h>

	#include "zed_log.h"
	#include "zed_disk_event.h"
	#include "agents/zfs_agents.h"

	/*
	* Portions of ZED need to see disk events for disks belonging to ZFS pools.
	* A libudev monitor is established to monitor block device actions and pass
	* them on to internal ZED logic modules. Initially, zfs_mod.c is the only
	* consumer and is the Linux equivalent for the illumos syseventd ZFS SLM
	* module responsible for handling disk events for ZFS.
	*/

	pthread_t g_mon_tid;
	struct udev *g_udev;
	struct udev_monitor *g_mon;


	#define DEV_BYID_PATH "/dev/disk/by-id/"

	/* 64MB is minimum usable disk for ZFS */
	#define MINIMUM_SECTORS 131072


	/*
	* Post disk event to SLM module
	*
	* occurs in the context of monitor thread
	*/
	static void
	zed_udev_event(const char class, const char subclass, nvlist_t *nvl)
	{
	char *strval;
	uint64_t numval;

	zed_log_msg(LOG_INFO, "zed_disk_event:");
	zed_log_msg(LOG_INFO, "\tclass: %s", class);
	zed_log_msg(LOG_INFO, "\tsubclass: %s", subclass);
	if (nvlist_lookup_string(nvl, DEV_NAME, &strval) == 0)
	zed_log_msg(LOG_INFO, "\t%s: %s", DEV_NAME, strval);
	if (nvlist_lookup_string(nvl, DEV_PATH, &strval) == 0)
	zed_log_msg(LOG_INFO, "\t%s: %s", DEV_PATH, strval);
	if (nvlist_lookup_string(nvl, DEV_IDENTIFIER, &strval) == 0)
	zed_log_msg(LOG_INFO, "\t%s: %s", DEV_IDENTIFIER, strval);
	if (nvlist_lookup_string(nvl, DEV_PHYS_PATH, &strval) == 0)
	zed_log_msg(LOG_INFO, "\t%s: %s", DEV_PHYS_PATH, strval);
	if (nvlist_lookup_uint64(nvl, DEV_SIZE, &numval) == 0)
	zed_log_msg(LOG_INFO, "\t%s: %llu", DEV_SIZE, numval);
	if (nvlist_lookup_uint64(nvl, ZFS_EV_POOL_GUID, &numval) == 0)
	zed_log_msg(LOG_INFO, "\t%s: %llu", ZFS_EV_POOL_GUID, numval);
	if (nvlist_lookup_uint64(nvl, ZFS_EV_VDEV_GUID, &numval) == 0)
	zed_log_msg(LOG_INFO, "\t%s: %llu", ZFS_EV_VDEV_GUID, numval);

	(void) zfs_agent_post_event(class, subclass, nvl);
	}

	/*
	* dev_event_nvlist: place event schema into an nv pair list
	*
	* NAME VALUE (example)
	* -------------- --------------------------------------------------------
	* DEV_NAME /dev/sdl
	* DEV_PATH /devices/pci0000:00/0000:00:03.0/0000:04:00.0/host0/...
	* DEV_IDENTIFIER ata-Hitachi_HTS725050A9A362_100601PCG420VLJ37DMC
	* DEV_PHYS_PATH pci-0000:04:00.0-sas-0x4433221101000000-lun-0
	* DEV_IS_PART ---
	* DEV_SIZE 500107862016
	* ZFS_EV_POOL_GUID 17523635698032189180
	* ZFS_EV_VDEV_GUID 14663607734290803088
	*/
	static nvlist_t *
	dev_event_nvlist(struct udev_device *dev)
	{
	nvlist_t *nvl;
	char strval[128];
	const char value, path;
	uint64_t guid;

	if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0)
	return (NULL);

	if (zfs_device_get_devid(dev, strval, sizeof (strval)) == 0)
	(void) nvlist_add_string(nvl, DEV_IDENTIFIER, strval);
	if (zfs_device_get_physical(dev, strval, sizeof (strval)) == 0)
	(void) nvlist_add_string(nvl, DEV_PHYS_PATH, strval);
	if ((path = udev_device_get_devnode(dev)) != NULL)
	(void) nvlist_add_string(nvl, DEV_NAME, path);
	if ((value = udev_device_get_devpath(dev)) != NULL)
	(void) nvlist_add_string(nvl, DEV_PATH, value);
	value = udev_device_get_devtype(dev);
	if ((value != NULL && strcmp("partition", value) == 0) \|\|
	(udev_device_get_property_value(dev, "ID_PART_ENTRY_NUMBER")
	!= NULL)) {
	(void) nvlist_add_boolean(nvl, DEV_IS_PART);
	}
	if ((value = udev_device_get_sysattr_value(dev, "size")) != NULL) {
	uint64_t numval = DEV_BSIZE;

	numval *= strtoull(value, NULL, 10);
	(void) nvlist_add_uint64(nvl, DEV_SIZE, numval);
	}

	/*
	* Grab the pool and vdev guids from blkid cache
	*/
	value = udev_device_get_property_value(dev, "ID_FS_UUID");
	if (value != NULL && (guid = strtoull(value, NULL, 10)) != 0)
	(void) nvlist_add_uint64(nvl, ZFS_EV_POOL_GUID, guid);

	value = udev_device_get_property_value(dev, "ID_FS_UUID_SUB");
	if (value != NULL && (guid = strtoull(value, NULL, 10)) != 0)
	(void) nvlist_add_uint64(nvl, ZFS_EV_VDEV_GUID, guid);

	/*
	* Either a vdev guid or a devid must be present for matching
	*/
	if (!nvlist_exists(nvl, DEV_IDENTIFIER) &&
	!nvlist_exists(nvl, ZFS_EV_VDEV_GUID)) {
	nvlist_free(nvl);
	return (NULL);
	}

	return (nvl);
	}

	/*
	* Listen for block device uevents
	*/
	static void *
	zed_udev_monitor(void *arg)
	{
	struct udev_monitor *mon = arg;
	char tmp, tmp2;

	zed_log_msg(LOG_INFO, "Waiting for new udev disk events...");

	while (1) {
	struct udev_device *dev;
	const char action, type, part, sectors;
	const char bus, uuid;
	const char class, subclass;
	nvlist_t *nvl;
	boolean_t is_zfs = B_FALSE;

	/* allow a cancellation while blocked (recvmsg) */
	pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);

	/* blocks at recvmsg until an event occurs */
	if ((dev = udev_monitor_receive_device(mon)) == NULL) {
	zed_log_msg(LOG_WARNING, "zed_udev_monitor: receive "
	"device error %d", errno);
	continue;
	}

	/* allow all steps to complete before a cancellation */
	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);

	/*
	* Strongly typed device is the preferred filter
	*/
	type = udev_device_get_property_value(dev, "ID_FS_TYPE");
	if (type != NULL && type[0] != '\0') {
	if (strcmp(type, "zfs_member") == 0) {
	is_zfs = B_TRUE;
	} else {
	/* not ours, so skip */
	zed_log_msg(LOG_INFO, "zed_udev_monitor: skip "
	"%s (in use by %s)",
	udev_device_get_devnode(dev), type);
	udev_device_unref(dev);
	continue;
	}
	}

	/*
	* if this is a disk and it is partitioned, then the
	* zfs label will reside in a DEVTYPE=partition and
	* we can skip passing this event
	*/
	type = udev_device_get_property_value(dev, "DEVTYPE");
	part = udev_device_get_property_value(dev,
	"ID_PART_TABLE_TYPE");
	if (type != NULL && type[0] != '\0' &&
	strcmp(type, "disk") == 0 &&
	part != NULL && part[0] != '\0') {
	/* skip and wait for partition event */
	udev_device_unref(dev);
	continue;
	}

	/*
	* ignore small partitions
	*/
	sectors = udev_device_get_property_value(dev,
	"ID_PART_ENTRY_SIZE");
	if (sectors == NULL)
	sectors = udev_device_get_sysattr_value(dev, "size");
	if (sectors != NULL &&
	strtoull(sectors, NULL, 10) < MINIMUM_SECTORS) {
	udev_device_unref(dev);
	continue;
	}

	/*
	* If the blkid probe didn't find ZFS, then a persistent
	* device id string is required in the message schema
	* for matching with vdevs. Preflight here for expected
	* udev information.
	*/
	bus = udev_device_get_property_value(dev, "ID_BUS");
	uuid = udev_device_get_property_value(dev, "DM_UUID");
	if (!is_zfs && (bus == NULL && uuid == NULL)) {
	zed_log_msg(LOG_INFO, "zed_udev_monitor: %s no devid "
	"source", udev_device_get_devnode(dev));
	udev_device_unref(dev);
	continue;
	}

	action = udev_device_get_action(dev);
	if (strcmp(action, "add") == 0) {
	class = EC_DEV_ADD;
	subclass = ESC_DISK;
	} else if (strcmp(action, "remove") == 0) {
	class = EC_DEV_REMOVE;
	subclass = ESC_DISK;
	} else if (strcmp(action, "change") == 0) {
	class = EC_DEV_STATUS;
	subclass = ESC_DEV_DLE;
	} else {
	zed_log_msg(LOG_WARNING, "zed_udev_monitor: %s unknown",
	action);
	udev_device_unref(dev);
	continue;
	}

	/*
	* Special case an EC_DEV_ADD for multipath devices
	*
	* When a multipath device is created, udev reports the
	* following:
	*
	* 1. "add" event of the dm device for the multipath device
	* (like /dev/dm-3).
	* 2. "change" event to create the actual multipath device
	* symlink (like /dev/mapper/mpatha). The event also
	* passes back the relevant DM vars we care about, like
	* DM_UUID.
	* 3. Another "change" event identical to #2 (that we ignore).
	*
	* To get the behavior we want, we treat the "change" event
	* in #2 as a "add" event; as if "/dev/mapper/mpatha" was
	* a new disk being added.
	*/
	if (strcmp(class, EC_DEV_STATUS) == 0 &&
	udev_device_get_property_value(dev, "DM_UUID") &&
	udev_device_get_property_value(dev, "MPATH_SBIN_PATH")) {
	tmp = (char *)udev_device_get_devnode(dev);
	tmp2 = zfs_get_underlying_path(tmp);
	if (tmp && tmp2 && (strcmp(tmp, tmp2) != 0)) {
	/*
	* We have a real underlying device, which
	* means that this multipath "change" event is
	* an "add" event.
	*
	* If the multipath device and the underlying
	* dev are the same name (i.e. /dev/dm-5), then
	* there is no real underlying disk for this
	* multipath device, and so this "change" event
	* really is a multipath removal.
	*/
	class = EC_DEV_ADD;
	subclass = ESC_DISK;
	} else {
	tmp = (char *)
	udev_device_get_property_value(dev,
	"DM_NR_VALID_PATHS");
	/* treat as a multipath remove */
	if (tmp != NULL && strcmp(tmp, "0") == 0) {
	class = EC_DEV_REMOVE;
	subclass = ESC_DISK;
	}
	}
	free(tmp2);
	}

	/*
	* Special case an EC_DEV_ADD for scsi_debug devices
	*
	* These devices require a udevadm trigger command after
	* creation in order to register the vdev_id scsidebug alias
	* rule (adds a persistent path (phys_path) used for fault
	* management automated tests in the ZFS test suite.
	*
	* After udevadm trigger command, event registers as a "change"
	* event but needs to instead be handled as another "add" event
	* to allow for disk labeling and partitioning to occur.
	*/
	if (strcmp(class, EC_DEV_STATUS) == 0 &&
	udev_device_get_property_value(dev, "ID_VDEV") &&
	udev_device_get_property_value(dev, "ID_MODEL")) {
	const char id_model, id_model_sd = "scsi_debug";

	id_model = udev_device_get_property_value(dev,
	"ID_MODEL");
	if (strcmp(id_model, id_model_sd) == 0) {
	class = EC_DEV_ADD;
	subclass = ESC_DISK;
	}
	}

	if ((nvl = dev_event_nvlist(dev)) != NULL) {
	zed_udev_event(class, subclass, nvl);
	nvlist_free(nvl);
	}

	udev_device_unref(dev);
	}

	return (NULL);
	}

	int
	zed_disk_event_init()
	{
	int fd, fflags;

	if ((g_udev = udev_new()) == NULL) {
	zed_log_msg(LOG_WARNING, "udev_new failed (%d)", errno);
	return (-1);
	}

	/* Set up a udev monitor for block devices */
	g_mon = udev_monitor_new_from_netlink(g_udev, "udev");
	udev_monitor_filter_add_match_subsystem_devtype(g_mon, "block", "disk");
	udev_monitor_filter_add_match_subsystem_devtype(g_mon, "block",
	"partition");
	udev_monitor_enable_receiving(g_mon);

	/* Make sure monitoring socket is blocking */
	fd = udev_monitor_get_fd(g_mon);
	if ((fflags = fcntl(fd, F_GETFL)) & O_NONBLOCK)
	(void) fcntl(fd, F_SETFL, fflags & ~O_NONBLOCK);

	/* spawn a thread to monitor events */
	if (pthread_create(&g_mon_tid, NULL, zed_udev_monitor, g_mon) != 0) {
	udev_monitor_unref(g_mon);
	udev_unref(g_udev);
	zed_log_msg(LOG_WARNING, "pthread_create failed");
	return (-1);
	}

	+ pthread_setname_np(g_mon_tid, "udev monitor");
	zed_log_msg(LOG_INFO, "zed_disk_event_init");

	return (0);
	}

	void
	zed_disk_event_fini()
	{
	/* cancel monitor thread at recvmsg() */
	(void) pthread_cancel(g_mon_tid);
	(void) pthread_join(g_mon_tid, NULL);

	/* cleanup udev resources */
	udev_monitor_unref(g_mon);
	udev_unref(g_udev);

	zed_log_msg(LOG_INFO, "zed_disk_event_fini");
	}

	#else

	#include "zed_disk_event.h"

	int
	zed_disk_event_init()
	{
	return (0);
	}

	void
	zed_disk_event_fini()
	{
	}

	#endif /* HAVE_LIBUDEV */
	diff --git a/sys/contrib/openzfs/cmd/zed/zed_event.c b/sys/contrib/openzfs/cmd/zed/zed_event.c
	index 8892087d6e62..9eaad0e92fbb 100644
	--- a/sys/contrib/openzfs/cmd/zed/zed_event.c
	+++ b/sys/contrib/openzfs/cmd/zed/zed_event.c
	@@ -1,965 +1,987 @@
	/*
	* This file is part of the ZFS Event Daemon (ZED).
	*
	* Developed at Lawrence Livermore National Laboratory (LLNL-CODE-403049).
	* Copyright (C) 2013-2014 Lawrence Livermore National Security, LLC.
	- * Refer to the ZoL git commit log for authoritative copyright attribution.
	+ * Refer to the OpenZFS git commit log for authoritative copyright attribution.
	*
	* The contents of this file are subject to the terms of the
	* Common Development and Distribution License Version 1.0 (CDDL-1.0).
	* You can obtain a copy of the license from the top-level file
	* "OPENSOLARIS.LICENSE" or at <http://opensource.org/licenses/CDDL-1.0>.
	* You may not use this file except in compliance with the license.
	*/

	#include <ctype.h>
	#include <errno.h>
	#include <fcntl.h>
	-#include <libzfs.h> /* FIXME: Replace with libzfs_core. */
	+#include <libzfs_core.h>
	#include <paths.h>
	#include <stdarg.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <sys/zfs_ioctl.h>
	#include <time.h>
	#include <unistd.h>
	#include <sys/fm/fs/zfs.h>
	#include "zed.h"
	#include "zed_conf.h"
	#include "zed_disk_event.h"
	#include "zed_event.h"
	#include "zed_exec.h"
	#include "zed_file.h"
	#include "zed_log.h"
	#include "zed_strings.h"

	#include "agents/zfs_agents.h"

	#define MAXBUF 4096

	/*
	* Open the libzfs interface.
	*/
	int
	zed_event_init(struct zed_conf *zcp)
	{
	if (!zcp)
	zed_log_die("Failed zed_event_init: %s", strerror(EINVAL));

	zcp->zfs_hdl = libzfs_init();
	if (!zcp->zfs_hdl) {
	if (zcp->do_idle)
	return (-1);
	zed_log_die("Failed to initialize libzfs");
	}

	- zcp->zevent_fd = open(ZFS_DEV, O_RDWR);
	+ zcp->zevent_fd = open(ZFS_DEV, O_RDWR \| O_CLOEXEC);
	if (zcp->zevent_fd < 0) {
	if (zcp->do_idle)
	return (-1);
	zed_log_die("Failed to open \"%s\": %s",
	ZFS_DEV, strerror(errno));
	}

	zfs_agent_init(zcp->zfs_hdl);

	if (zed_disk_event_init() != 0) {
	if (zcp->do_idle)
	return (-1);
	zed_log_die("Failed to initialize disk events");
	}

	return (0);
	}

	/*
	* Close the libzfs interface.
	*/
	void
	zed_event_fini(struct zed_conf *zcp)
	{
	if (!zcp)
	zed_log_die("Failed zed_event_fini: %s", strerror(EINVAL));

	zed_disk_event_fini();
	zfs_agent_fini();

	if (zcp->zevent_fd >= 0) {
	if (close(zcp->zevent_fd) < 0)
	zed_log_msg(LOG_WARNING, "Failed to close \"%s\": %s",
	ZFS_DEV, strerror(errno));

	zcp->zevent_fd = -1;
	}
	if (zcp->zfs_hdl) {
	libzfs_fini(zcp->zfs_hdl);
	zcp->zfs_hdl = NULL;
	}
	+
	+ zed_exec_fini();
	+}
	+
	+static void
	+_bump_event_queue_length(void)
	+{
	+ int zzlm = -1, wr;
	+ char qlen_buf[12] = {0}; /* parameter is int => max "-2147483647\n" */
	+ long int qlen;
	+
	+ zzlm = open("/sys/module/zfs/parameters/zfs_zevent_len_max", O_RDWR);
	+ if (zzlm < 0)
	+ goto done;
	+
	+ if (read(zzlm, qlen_buf, sizeof (qlen_buf)) < 0)
	+ goto done;
	+ qlen_buf[sizeof (qlen_buf) - 1] = '\0';
	+
	+ errno = 0;
	+ qlen = strtol(qlen_buf, NULL, 10);
	+ if (errno == ERANGE)
	+ goto done;
	+
	+ if (qlen <= 0)
	+ qlen = 512; /* default zfs_zevent_len_max value */
	+ else
	+ qlen *= 2;
	+
	+ if (qlen > INT_MAX)
	+ qlen = INT_MAX;
	+ wr = snprintf(qlen_buf, sizeof (qlen_buf), "%ld", qlen);
	+
	+ if (pwrite(zzlm, qlen_buf, wr, 0) < 0)
	+ goto done;
	+
	+ zed_log_msg(LOG_WARNING, "Bumping queue length to %ld", qlen);
	+
	+done:
	+ if (zzlm > -1)
	+ (void) close(zzlm);
	}

	/*
	* Seek to the event specified by [saved_eid] and [saved_etime].
	* This protects against processing a given event more than once.
	* Return 0 upon a successful seek to the specified event, or -1 otherwise.
	*
	* A zevent is considered to be uniquely specified by its (eid,time) tuple.
	* The unsigned 64b eid is set to 1 when the kernel module is loaded, and
	* incremented by 1 for each new event. Since the state file can persist
	* across a kernel module reload, the time must be checked to ensure a match.
	*/
	int
	zed_event_seek(struct zed_conf *zcp, uint64_t saved_eid, int64_t saved_etime[])
	{
	uint64_t eid;
	int found;
	nvlist_t *nvl;
	int n_dropped;
	int64_t *etime;
	uint_t nelem;
	int rv;

	if (!zcp) {
	errno = EINVAL;
	zed_log_msg(LOG_ERR, "Failed to seek zevent: %s",
	strerror(errno));
	return (-1);
	}
	eid = 0;
	found = 0;
	while ((eid < saved_eid) && !found) {
	rv = zpool_events_next(zcp->zfs_hdl, &nvl, &n_dropped,
	ZEVENT_NONBLOCK, zcp->zevent_fd);

	if ((rv != 0) \|\| !nvl)
	break;

	if (n_dropped > 0) {
	zed_log_msg(LOG_WARNING, "Missed %d events", n_dropped);
	- /*
	- * FIXME: Increase max size of event nvlist in
	- * /sys/module/zfs/parameters/zfs_zevent_len_max ?
	- */
	+ _bump_event_queue_length();
	}
	if (nvlist_lookup_uint64(nvl, "eid", &eid) != 0) {
	zed_log_msg(LOG_WARNING, "Failed to lookup zevent eid");
	} else if (nvlist_lookup_int64_array(nvl, "time",
	&etime, &nelem) != 0) {
	zed_log_msg(LOG_WARNING,
	"Failed to lookup zevent time (eid=%llu)", eid);
	} else if (nelem != 2) {
	zed_log_msg(LOG_WARNING,
	"Failed to lookup zevent time (eid=%llu, nelem=%u)",
	eid, nelem);
	} else if ((eid != saved_eid) \|\|
	(etime[0] != saved_etime[0]) \|\|
	(etime[1] != saved_etime[1])) {
	/* no-op */
	} else {
	found = 1;
	}
	free(nvl);
	}
	if (!found && (saved_eid > 0)) {
	if (zpool_events_seek(zcp->zfs_hdl, ZEVENT_SEEK_START,
	zcp->zevent_fd) < 0)
	zed_log_msg(LOG_WARNING, "Failed to seek to eid=0");
	else
	eid = 0;
	}
	zed_log_msg(LOG_NOTICE, "Processing events since eid=%llu", eid);
	return (found ? 0 : -1);
	}

	/*
	* Return non-zero if nvpair [name] should be formatted in hex; o/w, return 0.
	*/
	static int
	_zed_event_value_is_hex(const char *name)
	{
	const char *hex_suffix[] = {
	"_guid",
	"_guids",
	NULL
	};
	const char **pp;
	char *p;

	if (!name)
	return (0);

	for (pp = hex_suffix; *pp; pp++) {
	p = strstr(name, *pp);
	if (p && strlen(p) == strlen(*pp))
	return (1);
	}
	return (0);
	}

	/*
	* Add an environment variable for [eid] to the container [zsp].
	*
	* The variable name is the concatenation of [prefix] and [name] converted to
	* uppercase with non-alphanumeric characters converted to underscores;
	* [prefix] is optional, and [name] must begin with an alphabetic character.
	* If the converted variable name already exists within the container [zsp],
	* its existing value will be replaced with the new value.
	*
	* The variable value is specified by the format string [fmt].
	*
	* Returns 0 on success, and -1 on error (with errno set).
	*
	* All environment variables in [zsp] should be added through this function.
	*/
	-static int
	+static __attribute__((format(printf, 5, 6))) int
	_zed_event_add_var(uint64_t eid, zed_strings_t *zsp,
	const char prefix, const char name, const char *fmt, ...)
	{
	char keybuf[MAXBUF];
	char valbuf[MAXBUF];
	char *dstp;
	const char *srcp;
	const char *lastp;
	int n;
	int buflen;
	va_list vargs;

	assert(zsp != NULL);
	assert(fmt != NULL);

	if (!name) {
	errno = EINVAL;
	zed_log_msg(LOG_WARNING,
	"Failed to add variable for eid=%llu: Name is empty", eid);
	return (-1);
	} else if (!isalpha(name[0])) {
	errno = EINVAL;
	zed_log_msg(LOG_WARNING,
	"Failed to add variable for eid=%llu: "
	"Name \"%s\" is invalid", eid, name);
	return (-1);
	}
	/*
	* Construct the string key by converting PREFIX (if present) and NAME.
	*/
	dstp = keybuf;
	lastp = keybuf + sizeof (keybuf);
	if (prefix) {
	for (srcp = prefix; *srcp && (dstp < lastp); srcp++)
	dstp++ = isalnum(srcp) ? toupper(*srcp) : '_';
	}
	for (srcp = name; *srcp && (dstp < lastp); srcp++)
	dstp++ = isalnum(srcp) ? toupper(*srcp) : '_';

	if (dstp == lastp) {
	errno = ENAMETOOLONG;
	zed_log_msg(LOG_WARNING,
	"Failed to add variable for eid=%llu: Name too long", eid);
	return (-1);
	}
	*dstp = '\0';
	/*
	* Construct the string specified by "[PREFIX][NAME]=[FMT]".
	*/
	dstp = valbuf;
	buflen = sizeof (valbuf);
	n = strlcpy(dstp, keybuf, buflen);
	if (n >= sizeof (valbuf)) {
	errno = EMSGSIZE;
	zed_log_msg(LOG_WARNING, "Failed to add %s for eid=%llu: %s",
	keybuf, eid, "Exceeded buffer size");
	return (-1);
	}
	dstp += n;
	buflen -= n;

	*dstp++ = '=';
	buflen--;

	if (buflen <= 0) {
	errno = EMSGSIZE;
	zed_log_msg(LOG_WARNING, "Failed to add %s for eid=%llu: %s",
	keybuf, eid, "Exceeded buffer size");
	return (-1);
	}

	va_start(vargs, fmt);
	n = vsnprintf(dstp, buflen, fmt, vargs);
	va_end(vargs);

	if ((n < 0) \|\| (n >= buflen)) {
	errno = EMSGSIZE;
	zed_log_msg(LOG_WARNING, "Failed to add %s for eid=%llu: %s",
	keybuf, eid, "Exceeded buffer size");
	return (-1);
	} else if (zed_strings_add(zsp, keybuf, valbuf) < 0) {
	zed_log_msg(LOG_WARNING, "Failed to add %s for eid=%llu: %s",
	keybuf, eid, strerror(errno));
	return (-1);
	}
	return (0);
	}

	static int
	_zed_event_add_array_err(uint64_t eid, const char *name)
	{
	errno = EMSGSIZE;
	zed_log_msg(LOG_WARNING,
	"Failed to convert nvpair \"%s\" for eid=%llu: "
	"Exceeded buffer size", name, eid);
	return (-1);
	}

	static int
	_zed_event_add_int8_array(uint64_t eid, zed_strings_t *zsp,
	const char prefix, nvpair_t nvp)
	{
	char buf[MAXBUF];
	int buflen = sizeof (buf);
	const char *name;
	int8_t *i8p;
	uint_t nelem;
	uint_t i;
	char *p;
	int n;

	assert((nvp != NULL) && (nvpair_type(nvp) == DATA_TYPE_INT8_ARRAY));

	name = nvpair_name(nvp);
	(void) nvpair_value_int8_array(nvp, &i8p, &nelem);
	for (i = 0, p = buf; (i < nelem) && (buflen > 0); i++) {
	n = snprintf(p, buflen, "%d ", i8p[i]);
	if ((n < 0) \|\| (n >= buflen))
	return (_zed_event_add_array_err(eid, name));
	p += n;
	buflen -= n;
	}
	if (nelem > 0)
	*--p = '\0';

	return (_zed_event_add_var(eid, zsp, prefix, name, "%s", buf));
	}

	static int
	_zed_event_add_uint8_array(uint64_t eid, zed_strings_t *zsp,
	const char prefix, nvpair_t nvp)
	{
	char buf[MAXBUF];
	int buflen = sizeof (buf);
	const char *name;
	uint8_t *u8p;
	uint_t nelem;
	uint_t i;
	char *p;
	int n;

	assert((nvp != NULL) && (nvpair_type(nvp) == DATA_TYPE_UINT8_ARRAY));

	name = nvpair_name(nvp);
	(void) nvpair_value_uint8_array(nvp, &u8p, &nelem);
	for (i = 0, p = buf; (i < nelem) && (buflen > 0); i++) {
	n = snprintf(p, buflen, "%u ", u8p[i]);
	if ((n < 0) \|\| (n >= buflen))
	return (_zed_event_add_array_err(eid, name));
	p += n;
	buflen -= n;
	}
	if (nelem > 0)
	*--p = '\0';

	return (_zed_event_add_var(eid, zsp, prefix, name, "%s", buf));
	}

	static int
	_zed_event_add_int16_array(uint64_t eid, zed_strings_t *zsp,
	const char prefix, nvpair_t nvp)
	{
	char buf[MAXBUF];
	int buflen = sizeof (buf);
	const char *name;
	int16_t *i16p;
	uint_t nelem;
	uint_t i;
	char *p;
	int n;

	assert((nvp != NULL) && (nvpair_type(nvp) == DATA_TYPE_INT16_ARRAY));

	name = nvpair_name(nvp);
	(void) nvpair_value_int16_array(nvp, &i16p, &nelem);
	for (i = 0, p = buf; (i < nelem) && (buflen > 0); i++) {
	n = snprintf(p, buflen, "%d ", i16p[i]);
	if ((n < 0) \|\| (n >= buflen))
	return (_zed_event_add_array_err(eid, name));
	p += n;
	buflen -= n;
	}
	if (nelem > 0)
	*--p = '\0';

	return (_zed_event_add_var(eid, zsp, prefix, name, "%s", buf));
	}

	static int
	_zed_event_add_uint16_array(uint64_t eid, zed_strings_t *zsp,
	const char prefix, nvpair_t nvp)
	{
	char buf[MAXBUF];
	int buflen = sizeof (buf);
	const char *name;
	uint16_t *u16p;
	uint_t nelem;
	uint_t i;
	char *p;
	int n;

	assert((nvp != NULL) && (nvpair_type(nvp) == DATA_TYPE_UINT16_ARRAY));

	name = nvpair_name(nvp);
	(void) nvpair_value_uint16_array(nvp, &u16p, &nelem);
	for (i = 0, p = buf; (i < nelem) && (buflen > 0); i++) {
	n = snprintf(p, buflen, "%u ", u16p[i]);
	if ((n < 0) \|\| (n >= buflen))
	return (_zed_event_add_array_err(eid, name));
	p += n;
	buflen -= n;
	}
	if (nelem > 0)
	*--p = '\0';

	return (_zed_event_add_var(eid, zsp, prefix, name, "%s", buf));
	}

	static int
	_zed_event_add_int32_array(uint64_t eid, zed_strings_t *zsp,
	const char prefix, nvpair_t nvp)
	{
	char buf[MAXBUF];
	int buflen = sizeof (buf);
	const char *name;
	int32_t *i32p;
	uint_t nelem;
	uint_t i;
	char *p;
	int n;

	assert((nvp != NULL) && (nvpair_type(nvp) == DATA_TYPE_INT32_ARRAY));

	name = nvpair_name(nvp);
	(void) nvpair_value_int32_array(nvp, &i32p, &nelem);
	for (i = 0, p = buf; (i < nelem) && (buflen > 0); i++) {
	n = snprintf(p, buflen, "%d ", i32p[i]);
	if ((n < 0) \|\| (n >= buflen))
	return (_zed_event_add_array_err(eid, name));
	p += n;
	buflen -= n;
	}
	if (nelem > 0)
	*--p = '\0';

	return (_zed_event_add_var(eid, zsp, prefix, name, "%s", buf));
	}

	static int
	_zed_event_add_uint32_array(uint64_t eid, zed_strings_t *zsp,
	const char prefix, nvpair_t nvp)
	{
	char buf[MAXBUF];
	int buflen = sizeof (buf);
	const char *name;
	uint32_t *u32p;
	uint_t nelem;
	uint_t i;
	char *p;
	int n;

	assert((nvp != NULL) && (nvpair_type(nvp) == DATA_TYPE_UINT32_ARRAY));

	name = nvpair_name(nvp);
	(void) nvpair_value_uint32_array(nvp, &u32p, &nelem);
	for (i = 0, p = buf; (i < nelem) && (buflen > 0); i++) {
	n = snprintf(p, buflen, "%u ", u32p[i]);
	if ((n < 0) \|\| (n >= buflen))
	return (_zed_event_add_array_err(eid, name));
	p += n;
	buflen -= n;
	}
	if (nelem > 0)
	*--p = '\0';

	return (_zed_event_add_var(eid, zsp, prefix, name, "%s", buf));
	}

	static int
	_zed_event_add_int64_array(uint64_t eid, zed_strings_t *zsp,
	const char prefix, nvpair_t nvp)
	{
	char buf[MAXBUF];
	int buflen = sizeof (buf);
	const char *name;
	int64_t *i64p;
	uint_t nelem;
	uint_t i;
	char *p;
	int n;

	assert((nvp != NULL) && (nvpair_type(nvp) == DATA_TYPE_INT64_ARRAY));

	name = nvpair_name(nvp);
	(void) nvpair_value_int64_array(nvp, &i64p, &nelem);
	for (i = 0, p = buf; (i < nelem) && (buflen > 0); i++) {
	n = snprintf(p, buflen, "%lld ", (u_longlong_t)i64p[i]);
	if ((n < 0) \|\| (n >= buflen))
	return (_zed_event_add_array_err(eid, name));
	p += n;
	buflen -= n;
	}
	if (nelem > 0)
	*--p = '\0';

	return (_zed_event_add_var(eid, zsp, prefix, name, "%s", buf));
	}

	static int
	_zed_event_add_uint64_array(uint64_t eid, zed_strings_t *zsp,
	const char prefix, nvpair_t nvp)
	{
	char buf[MAXBUF];
	int buflen = sizeof (buf);
	const char *name;
	const char *fmt;
	uint64_t *u64p;
	uint_t nelem;
	uint_t i;
	char *p;
	int n;

	assert((nvp != NULL) && (nvpair_type(nvp) == DATA_TYPE_UINT64_ARRAY));

	name = nvpair_name(nvp);
	fmt = _zed_event_value_is_hex(name) ? "0x%.16llX " : "%llu ";
	(void) nvpair_value_uint64_array(nvp, &u64p, &nelem);
	for (i = 0, p = buf; (i < nelem) && (buflen > 0); i++) {
	n = snprintf(p, buflen, fmt, (u_longlong_t)u64p[i]);
	if ((n < 0) \|\| (n >= buflen))
	return (_zed_event_add_array_err(eid, name));
	p += n;
	buflen -= n;
	}
	if (nelem > 0)
	*--p = '\0';

	return (_zed_event_add_var(eid, zsp, prefix, name, "%s", buf));
	}

	static int
	_zed_event_add_string_array(uint64_t eid, zed_strings_t *zsp,
	const char prefix, nvpair_t nvp)
	{
	char buf[MAXBUF];
	int buflen = sizeof (buf);
	const char *name;
	char **strp;
	uint_t nelem;
	uint_t i;
	char *p;
	int n;

	assert((nvp != NULL) && (nvpair_type(nvp) == DATA_TYPE_STRING_ARRAY));

	name = nvpair_name(nvp);
	(void) nvpair_value_string_array(nvp, &strp, &nelem);
	for (i = 0, p = buf; (i < nelem) && (buflen > 0); i++) {
	n = snprintf(p, buflen, "%s ", strp[i] ? strp[i] : "<NULL>");
	if ((n < 0) \|\| (n >= buflen))
	return (_zed_event_add_array_err(eid, name));
	p += n;
	buflen -= n;
	}
	if (nelem > 0)
	*--p = '\0';

	return (_zed_event_add_var(eid, zsp, prefix, name, "%s", buf));
	}

	/*
	* Convert the nvpair [nvp] to a string which is added to the environment
	* of the child process.
	* Return 0 on success, -1 on error.
	- *
	- * FIXME: Refactor with cmd/zpool/zpool_main.c:zpool_do_events_nvprint()?
	*/
	static void
	_zed_event_add_nvpair(uint64_t eid, zed_strings_t zsp, nvpair_t nvp)
	{
	const char *name;
	data_type_t type;
	const char *prefix = ZEVENT_VAR_PREFIX;
	boolean_t b;
	double d;
	uint8_t i8;
	uint16_t i16;
	uint32_t i32;
	uint64_t i64;
	char *str;

	assert(zsp != NULL);
	assert(nvp != NULL);

	name = nvpair_name(nvp);
	type = nvpair_type(nvp);

	switch (type) {
	case DATA_TYPE_BOOLEAN:
	_zed_event_add_var(eid, zsp, prefix, name, "%s", "1");
	break;
	case DATA_TYPE_BOOLEAN_VALUE:
	(void) nvpair_value_boolean_value(nvp, &b);
	_zed_event_add_var(eid, zsp, prefix, name, "%s", b ? "1" : "0");
	break;
	case DATA_TYPE_BYTE:
	(void) nvpair_value_byte(nvp, &i8);
	_zed_event_add_var(eid, zsp, prefix, name, "%d", i8);
	break;
	case DATA_TYPE_INT8:
	(void) nvpair_value_int8(nvp, (int8_t *)&i8);
	_zed_event_add_var(eid, zsp, prefix, name, "%d", i8);
	break;
	case DATA_TYPE_UINT8:
	(void) nvpair_value_uint8(nvp, &i8);
	_zed_event_add_var(eid, zsp, prefix, name, "%u", i8);
	break;
	case DATA_TYPE_INT16:
	(void) nvpair_value_int16(nvp, (int16_t *)&i16);
	_zed_event_add_var(eid, zsp, prefix, name, "%d", i16);
	break;
	case DATA_TYPE_UINT16:
	(void) nvpair_value_uint16(nvp, &i16);
	_zed_event_add_var(eid, zsp, prefix, name, "%u", i16);
	break;
	case DATA_TYPE_INT32:
	(void) nvpair_value_int32(nvp, (int32_t *)&i32);
	_zed_event_add_var(eid, zsp, prefix, name, "%d", i32);
	break;
	case DATA_TYPE_UINT32:
	(void) nvpair_value_uint32(nvp, &i32);
	_zed_event_add_var(eid, zsp, prefix, name, "%u", i32);
	break;
	case DATA_TYPE_INT64:
	(void) nvpair_value_int64(nvp, (int64_t *)&i64);
	_zed_event_add_var(eid, zsp, prefix, name,
	"%lld", (longlong_t)i64);
	break;
	case DATA_TYPE_UINT64:
	(void) nvpair_value_uint64(nvp, &i64);
	_zed_event_add_var(eid, zsp, prefix, name,
	(_zed_event_value_is_hex(name) ? "0x%.16llX" : "%llu"),
	(u_longlong_t)i64);
	/*
	* shadow readable strings for vdev state pairs
	*/
	if (strcmp(name, FM_EREPORT_PAYLOAD_ZFS_VDEV_STATE) == 0 \|\|
	strcmp(name, FM_EREPORT_PAYLOAD_ZFS_VDEV_LASTSTATE) == 0) {
	char alt[32];

	(void) snprintf(alt, sizeof (alt), "%s_str", name);
	_zed_event_add_var(eid, zsp, prefix, alt, "%s",
	zpool_state_to_name(i64, VDEV_AUX_NONE));
	} else
	/*
	* shadow readable strings for pool state
	*/
	if (strcmp(name, FM_EREPORT_PAYLOAD_ZFS_POOL_STATE) == 0) {
	char alt[32];

	(void) snprintf(alt, sizeof (alt), "%s_str", name);
	_zed_event_add_var(eid, zsp, prefix, alt, "%s",
	zpool_pool_state_to_name(i64));
	}
	break;
	case DATA_TYPE_DOUBLE:
	(void) nvpair_value_double(nvp, &d);
	_zed_event_add_var(eid, zsp, prefix, name, "%g", d);
	break;
	case DATA_TYPE_HRTIME:
	(void) nvpair_value_hrtime(nvp, (hrtime_t *)&i64);
	_zed_event_add_var(eid, zsp, prefix, name,
	"%llu", (u_longlong_t)i64);
	break;
	- case DATA_TYPE_NVLIST:
	- _zed_event_add_var(eid, zsp, prefix, name,
	- "%s", "_NOT_IMPLEMENTED_"); /* FIXME */
	- break;
	case DATA_TYPE_STRING:
	(void) nvpair_value_string(nvp, &str);
	_zed_event_add_var(eid, zsp, prefix, name,
	"%s", (str ? str : "<NULL>"));
	break;
	- case DATA_TYPE_BOOLEAN_ARRAY:
	- _zed_event_add_var(eid, zsp, prefix, name,
	- "%s", "_NOT_IMPLEMENTED_"); /* FIXME */
	- break;
	- case DATA_TYPE_BYTE_ARRAY:
	- _zed_event_add_var(eid, zsp, prefix, name,
	- "%s", "_NOT_IMPLEMENTED_"); /* FIXME */
	- break;
	case DATA_TYPE_INT8_ARRAY:
	_zed_event_add_int8_array(eid, zsp, prefix, nvp);
	break;
	case DATA_TYPE_UINT8_ARRAY:
	_zed_event_add_uint8_array(eid, zsp, prefix, nvp);
	break;
	case DATA_TYPE_INT16_ARRAY:
	_zed_event_add_int16_array(eid, zsp, prefix, nvp);
	break;
	case DATA_TYPE_UINT16_ARRAY:
	_zed_event_add_uint16_array(eid, zsp, prefix, nvp);
	break;
	case DATA_TYPE_INT32_ARRAY:
	_zed_event_add_int32_array(eid, zsp, prefix, nvp);
	break;
	case DATA_TYPE_UINT32_ARRAY:
	_zed_event_add_uint32_array(eid, zsp, prefix, nvp);
	break;
	case DATA_TYPE_INT64_ARRAY:
	_zed_event_add_int64_array(eid, zsp, prefix, nvp);
	break;
	case DATA_TYPE_UINT64_ARRAY:
	_zed_event_add_uint64_array(eid, zsp, prefix, nvp);
	break;
	case DATA_TYPE_STRING_ARRAY:
	_zed_event_add_string_array(eid, zsp, prefix, nvp);
	break;
	+ case DATA_TYPE_NVLIST:
	+ case DATA_TYPE_BOOLEAN_ARRAY:
	+ case DATA_TYPE_BYTE_ARRAY:
	case DATA_TYPE_NVLIST_ARRAY:
	- _zed_event_add_var(eid, zsp, prefix, name,
	- "%s", "_NOT_IMPLEMENTED_"); /* FIXME */
	+ _zed_event_add_var(eid, zsp, prefix, name, "_NOT_IMPLEMENTED_");
	break;
	default:
	errno = EINVAL;
	zed_log_msg(LOG_WARNING,
	"Failed to convert nvpair \"%s\" for eid=%llu: "
	"Unrecognized type=%u", name, eid, (unsigned int) type);
	break;
	}
	}

	/*
	* Restrict various environment variables to safe and sane values
	* when constructing the environment for the child process, unless
	* we're running with a custom $PATH (like under the ZFS test suite).
	*
	* Reference: Secure Programming Cookbook by Viega & Messier, Section 1.1.
	*/
	static void
	_zed_event_add_env_restrict(uint64_t eid, zed_strings_t *zsp,
	const char *path)
	{
	const char *env_restrict[][2] = {
	{ "IFS", " \t\n" },
	{ "PATH", _PATH_STDPATH },
	{ "ZDB", SBINDIR "/zdb" },
	{ "ZED", SBINDIR "/zed" },
	{ "ZFS", SBINDIR "/zfs" },
	{ "ZINJECT", SBINDIR "/zinject" },
	{ "ZPOOL", SBINDIR "/zpool" },
	{ "ZFS_ALIAS", ZFS_META_ALIAS },
	{ "ZFS_VERSION", ZFS_META_VERSION },
	{ "ZFS_RELEASE", ZFS_META_RELEASE },
	{ NULL, NULL }
	};

	/*
	* If we have a custom $PATH, use the default ZFS binary locations
	* instead of the hard-coded ones.
	*/
	const char *env_path[][2] = {
	{ "IFS", " \t\n" },
	{ "PATH", NULL }, /* $PATH copied in later on */
	{ "ZDB", "zdb" },
	{ "ZED", "zed" },
	{ "ZFS", "zfs" },
	{ "ZINJECT", "zinject" },
	{ "ZPOOL", "zpool" },
	{ "ZFS_ALIAS", ZFS_META_ALIAS },
	{ "ZFS_VERSION", ZFS_META_VERSION },
	{ "ZFS_RELEASE", ZFS_META_RELEASE },
	{ NULL, NULL }
	};
	const char (pa)[2];

	assert(zsp != NULL);

	pa = path != NULL ? env_path : env_restrict;

	for (; (pa); pa++) {
	/* Use our custom $PATH if we have one */
	if (path != NULL && strcmp((*pa)[0], "PATH") == 0)
	(*pa)[1] = path;

	_zed_event_add_var(eid, zsp, NULL, (pa)[0], "%s", (pa)[1]);
	}
	}

	/*
	* Preserve specified variables from the parent environment
	* when constructing the environment for the child process.
	*
	* Reference: Secure Programming Cookbook by Viega & Messier, Section 1.1.
	*/
	static void
	_zed_event_add_env_preserve(uint64_t eid, zed_strings_t *zsp)
	{
	const char *env_preserve[] = {
	"TZ",
	NULL
	};
	const char **keyp;
	const char *val;

	assert(zsp != NULL);

	for (keyp = env_preserve; *keyp; keyp++) {
	if ((val = getenv(*keyp)))
	_zed_event_add_var(eid, zsp, NULL, *keyp, "%s", val);
	}
	}

	/*
	* Compute the "subclass" by removing the first 3 components of [class]
	* (which will always be of the form "*.fs.zfs"). Return a pointer inside
	* the string [class], or NULL if insufficient components exist.
	*/
	static const char *
	_zed_event_get_subclass(const char *class)
	{
	const char *p;
	int i;

	if (!class)
	return (NULL);

	p = class;
	for (i = 0; i < 3; i++) {
	p = strchr(p, '.');
	if (!p)
	break;
	p++;
	}
	return (p);
	}

	/*
	* Convert the zevent time from a 2-element array of 64b integers
	* into a more convenient form:
	* - TIME_SECS is the second component of the time.
	* - TIME_NSECS is the nanosecond component of the time.
	* - TIME_STRING is an almost-RFC3339-compliant string representation.
	*/
	static void
	_zed_event_add_time_strings(uint64_t eid, zed_strings_t *zsp, int64_t etime[])
	{
	struct tm *stp;
	char buf[32];

	assert(zsp != NULL);
	assert(etime != NULL);

	_zed_event_add_var(eid, zsp, ZEVENT_VAR_PREFIX, "TIME_SECS",
	"%lld", (long long int) etime[0]);
	_zed_event_add_var(eid, zsp, ZEVENT_VAR_PREFIX, "TIME_NSECS",
	"%lld", (long long int) etime[1]);

	if (!(stp = localtime((const time_t *) &etime[0]))) {
	zed_log_msg(LOG_WARNING, "Failed to add %s%s for eid=%llu: %s",
	ZEVENT_VAR_PREFIX, "TIME_STRING", eid, "localtime error");
	} else if (!strftime(buf, sizeof (buf), "%Y-%m-%d %H:%M:%S%z", stp)) {
	zed_log_msg(LOG_WARNING, "Failed to add %s%s for eid=%llu: %s",
	ZEVENT_VAR_PREFIX, "TIME_STRING", eid, "strftime error");
	} else {
	_zed_event_add_var(eid, zsp, ZEVENT_VAR_PREFIX, "TIME_STRING",
	"%s", buf);
	}
	}

	/*
	* Service the next zevent, blocking until one is available.
	*/
	int
	zed_event_service(struct zed_conf *zcp)
	{
	nvlist_t *nvl;
	nvpair_t *nvp;
	int n_dropped;
	zed_strings_t *zsp;
	uint64_t eid;
	int64_t *etime;
	uint_t nelem;
	char *class;
	const char *subclass;
	int rv;

	if (!zcp) {
	errno = EINVAL;
	zed_log_msg(LOG_ERR, "Failed to service zevent: %s",
	strerror(errno));
	return (EINVAL);
	}
	rv = zpool_events_next(zcp->zfs_hdl, &nvl, &n_dropped, ZEVENT_NONE,
	zcp->zevent_fd);

	if ((rv != 0) \|\| !nvl)
	return (errno);

	if (n_dropped > 0) {
	zed_log_msg(LOG_WARNING, "Missed %d events", n_dropped);
	- /*
	- * FIXME: Increase max size of event nvlist in
	- * /sys/module/zfs/parameters/zfs_zevent_len_max ?
	- */
	+ _bump_event_queue_length();
	}
	if (nvlist_lookup_uint64(nvl, "eid", &eid) != 0) {
	zed_log_msg(LOG_WARNING, "Failed to lookup zevent eid");
	} else if (nvlist_lookup_int64_array(
	nvl, "time", &etime, &nelem) != 0) {
	zed_log_msg(LOG_WARNING,
	"Failed to lookup zevent time (eid=%llu)", eid);
	} else if (nelem != 2) {
	zed_log_msg(LOG_WARNING,
	"Failed to lookup zevent time (eid=%llu, nelem=%u)",
	eid, nelem);
	} else if (nvlist_lookup_string(nvl, "class", &class) != 0) {
	zed_log_msg(LOG_WARNING,
	"Failed to lookup zevent class (eid=%llu)", eid);
	} else {
	/* let internal modules see this event first */
	zfs_agent_post_event(class, NULL, nvl);

	zsp = zed_strings_create();

	nvp = NULL;
	while ((nvp = nvlist_next_nvpair(nvl, nvp)))
	_zed_event_add_nvpair(eid, zsp, nvp);

	_zed_event_add_env_restrict(eid, zsp, zcp->path);
	_zed_event_add_env_preserve(eid, zsp);

	_zed_event_add_var(eid, zsp, ZED_VAR_PREFIX, "PID",
	"%d", (int)getpid());
	_zed_event_add_var(eid, zsp, ZED_VAR_PREFIX, "ZEDLET_DIR",
	"%s", zcp->zedlet_dir);
	subclass = _zed_event_get_subclass(class);
	_zed_event_add_var(eid, zsp, ZEVENT_VAR_PREFIX, "SUBCLASS",
	"%s", (subclass ? subclass : class));

	_zed_event_add_time_strings(eid, zsp, etime);

	- zed_exec_process(eid, class, subclass,
	- zcp->zedlet_dir, zcp->zedlets, zsp, zcp->zevent_fd);
	+ zed_exec_process(eid, class, subclass, zcp, zsp);

	zed_conf_write_state(zcp, eid, etime);

	zed_strings_destroy(zsp);
	}
	nvlist_free(nvl);
	return (0);
	}
	diff --git a/sys/contrib/openzfs/cmd/zed/zed_event.h b/sys/contrib/openzfs/cmd/zed/zed_event.h
	index 264c377ed91a..5606f14a21a0 100644
	--- a/sys/contrib/openzfs/cmd/zed/zed_event.h
	+++ b/sys/contrib/openzfs/cmd/zed/zed_event.h
	@@ -1,29 +1,29 @@
	/*
	* This file is part of the ZFS Event Daemon (ZED).
	*
	* Developed at Lawrence Livermore National Laboratory (LLNL-CODE-403049).
	* Copyright (C) 2013-2014 Lawrence Livermore National Security, LLC.
	- * Refer to the ZoL git commit log for authoritative copyright attribution.
	+ * Refer to the OpenZFS git commit log for authoritative copyright attribution.
	*
	* The contents of this file are subject to the terms of the
	* Common Development and Distribution License Version 1.0 (CDDL-1.0).
	* You can obtain a copy of the license from the top-level file
	* "OPENSOLARIS.LICENSE" or at <http://opensource.org/licenses/CDDL-1.0>.
	* You may not use this file except in compliance with the license.
	*/

	#ifndef ZED_EVENT_H
	#define ZED_EVENT_H

	#include <stdint.h>

	int zed_event_init(struct zed_conf *zcp);

	void zed_event_fini(struct zed_conf *zcp);

	int zed_event_seek(struct zed_conf *zcp, uint64_t saved_eid,
	int64_t saved_etime[]);

	int zed_event_service(struct zed_conf *zcp);

	#endif /* !ZED_EVENT_H */
	diff --git a/sys/contrib/openzfs/cmd/zed/zed_exec.c b/sys/contrib/openzfs/cmd/zed/zed_exec.c
	index e8f510213868..1eecfa0a92c4 100644
	--- a/sys/contrib/openzfs/cmd/zed/zed_exec.c
	+++ b/sys/contrib/openzfs/cmd/zed/zed_exec.c
	@@ -1,233 +1,368 @@
	/*
	* This file is part of the ZFS Event Daemon (ZED).
	*
	* Developed at Lawrence Livermore National Laboratory (LLNL-CODE-403049).
	* Copyright (C) 2013-2014 Lawrence Livermore National Security, LLC.
	- * Refer to the ZoL git commit log for authoritative copyright attribution.
	+ * Refer to the OpenZFS git commit log for authoritative copyright attribution.
	*
	* The contents of this file are subject to the terms of the
	* Common Development and Distribution License Version 1.0 (CDDL-1.0).
	* You can obtain a copy of the license from the top-level file
	* "OPENSOLARIS.LICENSE" or at <http://opensource.org/licenses/CDDL-1.0>.
	* You may not use this file except in compliance with the license.
	*/

	#include <assert.h>
	#include <ctype.h>
	#include <errno.h>
	#include <fcntl.h>
	#include <stdlib.h>
	#include <string.h>
	+#include <stddef.h>
	+#include <sys/avl.h>
	+#include <sys/resource.h>
	#include <sys/stat.h>
	#include <sys/wait.h>
	#include <time.h>
	#include <unistd.h>
	+#include <pthread.h>
	#include "zed_exec.h"
	-#include "zed_file.h"
	#include "zed_log.h"
	#include "zed_strings.h"

	#define ZEVENT_FILENO 3

	+struct launched_process_node {
	+ avl_node_t node;
	+ pid_t pid;
	+ uint64_t eid;
	+ char *name;
	+};
	+
	+static int
	+_launched_process_node_compare(const void x1, const void x2)
	+{
	+ pid_t p1;
	+ pid_t p2;
	+
	+ assert(x1 != NULL);
	+ assert(x2 != NULL);
	+
	+ p1 = ((const struct launched_process_node *) x1)->pid;
	+ p2 = ((const struct launched_process_node *) x2)->pid;
	+
	+ if (p1 < p2)
	+ return (-1);
	+ else if (p1 == p2)
	+ return (0);
	+ else
	+ return (1);
	+}
	+
	+static pthread_t _reap_children_tid = (pthread_t)-1;
	+static volatile boolean_t _reap_children_stop;
	+static avl_tree_t _launched_processes;
	+static pthread_mutex_t _launched_processes_lock = PTHREAD_MUTEX_INITIALIZER;
	+static int16_t _launched_processes_limit;
	+
	/*
	* Create an environment string array for passing to execve() using the
	* NAME=VALUE strings in container [zsp].
	* Return a newly-allocated environment, or NULL on error.
	*/
	static char **
	_zed_exec_create_env(zed_strings_t *zsp)
	{
	int num_ptrs;
	int buflen;
	char *buf;
	char **pp;
	char *p;
	const char *q;
	int i;
	int len;

	num_ptrs = zed_strings_count(zsp) + 1;
	buflen = num_ptrs * sizeof (char *);
	for (q = zed_strings_first(zsp); q; q = zed_strings_next(zsp))
	buflen += strlen(q) + 1;

	buf = calloc(1, buflen);
	if (!buf)
	return (NULL);

	pp = (char **)buf;
	p = buf + (num_ptrs * sizeof (char *));
	i = 0;
	for (q = zed_strings_first(zsp); q; q = zed_strings_next(zsp)) {
	pp[i] = p;
	len = strlen(q) + 1;
	memcpy(p, q, len);
	p += len;
	i++;
	}
	pp[i] = NULL;
	assert(buf + buflen == p);
	return ((char **)buf);
	}

	/*
	* Fork a child process to handle event [eid]. The program [prog]
	* in directory [dir] is executed with the environment [env].
	*
	* The file descriptor [zfd] is the zevent_fd used to track the
	* current cursor location within the zevent nvlist.
	*/
	static void
	_zed_exec_fork_child(uint64_t eid, const char dir, const char prog,
	- char *env[], int zfd)
	+ char *env[], int zfd, boolean_t in_foreground)
	{
	char path[PATH_MAX];
	int n;
	pid_t pid;
	int fd;
	- pid_t wpid;
	- int status;
	+ struct launched_process_node *node;
	+ sigset_t mask;
	+ struct timespec launch_timeout =
	+ { .tv_sec = 0, .tv_nsec = 200 * 1000 * 1000, };

	assert(dir != NULL);
	assert(prog != NULL);
	assert(env != NULL);
	assert(zfd >= 0);

	+ while (__atomic_load_n(&_launched_processes_limit,
	+ __ATOMIC_SEQ_CST) <= 0)
	+ (void) nanosleep(&launch_timeout, NULL);
	+
	n = snprintf(path, sizeof (path), "%s/%s", dir, prog);
	if ((n < 0) \|\| (n >= sizeof (path))) {
	zed_log_msg(LOG_WARNING,
	"Failed to fork \"%s\" for eid=%llu: %s",
	prog, eid, strerror(ENAMETOOLONG));
	return;
	}
	+ (void) pthread_mutex_lock(&_launched_processes_lock);
	pid = fork();
	if (pid < 0) {
	+ (void) pthread_mutex_unlock(&_launched_processes_lock);
	zed_log_msg(LOG_WARNING,
	"Failed to fork \"%s\" for eid=%llu: %s",
	prog, eid, strerror(errno));
	return;
	} else if (pid == 0) {
	+ (void) sigemptyset(&mask);
	+ (void) sigprocmask(SIG_SETMASK, &mask, NULL);
	+
	(void) umask(022);
	- if ((fd = open("/dev/null", O_RDWR)) != -1) {
	+ if (in_foreground && /* we're already devnulled if daemonised */
	+ (fd = open("/dev/null", O_RDWR \| O_CLOEXEC)) != -1) {
	(void) dup2(fd, STDIN_FILENO);
	(void) dup2(fd, STDOUT_FILENO);
	(void) dup2(fd, STDERR_FILENO);
	}
	(void) dup2(zfd, ZEVENT_FILENO);
	- zed_file_close_from(ZEVENT_FILENO + 1);
	execle(path, prog, NULL, env);
	_exit(127);
	}

	/* parent process */

	+ node = calloc(1, sizeof (*node));
	+ if (node) {
	+ node->pid = pid;
	+ node->eid = eid;
	+ node->name = strdup(prog);
	+
	+ avl_add(&_launched_processes, node);
	+ }
	+ (void) pthread_mutex_unlock(&_launched_processes_lock);
	+
	+ __atomic_sub_fetch(&_launched_processes_limit, 1, __ATOMIC_SEQ_CST);
	zed_log_msg(LOG_INFO, "Invoking \"%s\" eid=%llu pid=%d",
	prog, eid, pid);
	+}

	- /* FIXME: Timeout rogue child processes with sigalarm? */
	-
	- /*
	- * Wait for child process using WNOHANG to limit
	- * the time spent waiting to 10 seconds (10,000ms).
	- */
	- for (n = 0; n < 1000; n++) {
	- wpid = waitpid(pid, &status, WNOHANG);
	- if (wpid == (pid_t)-1) {
	- if (errno == EINTR)
	- continue;
	- zed_log_msg(LOG_WARNING,
	- "Failed to wait for \"%s\" eid=%llu pid=%d",
	- prog, eid, pid);
	- break;
	- } else if (wpid == 0) {
	- struct timespec t;
	-
	- /* child still running */
	- t.tv_sec = 0;
	- t.tv_nsec = 10000000; /* 10ms */
	- (void) nanosleep(&t, NULL);
	- continue;
	- }
	+static void
	+_nop(int sig)
	+{}
	+
	+static void *
	+_reap_children(void *arg)
	+{
	+ struct launched_process_node node, *pnode;
	+ pid_t pid;
	+ int status;
	+ struct rusage usage;
	+ struct sigaction sa = {};
	+
	+ (void) sigfillset(&sa.sa_mask);
	+ (void) sigdelset(&sa.sa_mask, SIGCHLD);
	+ (void) pthread_sigmask(SIG_SETMASK, &sa.sa_mask, NULL);
	+
	+ (void) sigemptyset(&sa.sa_mask);
	+ sa.sa_handler = _nop;
	+ sa.sa_flags = SA_NOCLDSTOP;
	+ (void) sigaction(SIGCHLD, &sa, NULL);

	- if (WIFEXITED(status)) {
	- zed_log_msg(LOG_INFO,
	- "Finished \"%s\" eid=%llu pid=%d exit=%d",
	- prog, eid, pid, WEXITSTATUS(status));
	- } else if (WIFSIGNALED(status)) {
	- zed_log_msg(LOG_INFO,
	- "Finished \"%s\" eid=%llu pid=%d sig=%d/%s",
	- prog, eid, pid, WTERMSIG(status),
	- strsignal(WTERMSIG(status)));
	+ for (_reap_children_stop = B_FALSE; !_reap_children_stop; ) {
	+ (void) pthread_mutex_lock(&_launched_processes_lock);
	+ pid = wait4(0, &status, WNOHANG, &usage);
	+
	+ if (pid == 0 \|\| pid == (pid_t)-1) {
	+ (void) pthread_mutex_unlock(&_launched_processes_lock);
	+ if (pid == 0 \|\| errno == ECHILD)
	+ pause();
	+ else if (errno != EINTR)
	+ zed_log_msg(LOG_WARNING,
	+ "Failed to wait for children: %s",
	+ strerror(errno));
	} else {
	- zed_log_msg(LOG_INFO,
	- "Finished \"%s\" eid=%llu pid=%d status=0x%X",
	- prog, eid, (unsigned int) status);
	+ memset(&node, 0, sizeof (node));
	+ node.pid = pid;
	+ pnode = avl_find(&_launched_processes, &node, NULL);
	+ if (pnode) {
	+ memcpy(&node, pnode, sizeof (node));
	+
	+ avl_remove(&_launched_processes, pnode);
	+ free(pnode);
	+ }
	+ (void) pthread_mutex_unlock(&_launched_processes_lock);
	+ __atomic_add_fetch(&_launched_processes_limit, 1,
	+ __ATOMIC_SEQ_CST);
	+
	+ usage.ru_utime.tv_sec += usage.ru_stime.tv_sec;
	+ usage.ru_utime.tv_usec += usage.ru_stime.tv_usec;
	+ usage.ru_utime.tv_sec +=
	+ usage.ru_utime.tv_usec / (1000 * 1000);
	+ usage.ru_utime.tv_usec %= 1000 * 1000;
	+
	+ if (WIFEXITED(status)) {
	+ zed_log_msg(LOG_INFO,
	+ "Finished \"%s\" eid=%llu pid=%d "
	+ "time=%llu.%06us exit=%d",
	+ node.name, node.eid, pid,
	+ (unsigned long long) usage.ru_utime.tv_sec,
	+ (unsigned int) usage.ru_utime.tv_usec,
	+ WEXITSTATUS(status));
	+ } else if (WIFSIGNALED(status)) {
	+ zed_log_msg(LOG_INFO,
	+ "Finished \"%s\" eid=%llu pid=%d "
	+ "time=%llu.%06us sig=%d/%s",
	+ node.name, node.eid, pid,
	+ (unsigned long long) usage.ru_utime.tv_sec,
	+ (unsigned int) usage.ru_utime.tv_usec,
	+ WTERMSIG(status),
	+ strsignal(WTERMSIG(status)));
	+ } else {
	+ zed_log_msg(LOG_INFO,
	+ "Finished \"%s\" eid=%llu pid=%d "
	+ "time=%llu.%06us status=0x%X",
	+ node.name, node.eid,
	+ (unsigned long long) usage.ru_utime.tv_sec,
	+ (unsigned int) usage.ru_utime.tv_usec,
	+ (unsigned int) status);
	+ }
	+
	+ free(node.name);
	}
	- break;
	}

	- /*
	- * kill child process after 10 seconds
	- */
	- if (wpid == 0) {
	- zed_log_msg(LOG_WARNING, "Killing hung \"%s\" pid=%d",
	- prog, pid);
	- (void) kill(pid, SIGKILL);
	- (void) waitpid(pid, &status, 0);
	+ return (NULL);
	+}
	+
	+void
	+zed_exec_fini(void)
	+{
	+ struct launched_process_node *node;
	+ void *ck = NULL;
	+
	+ if (_reap_children_tid == (pthread_t)-1)
	+ return;
	+
	+ _reap_children_stop = B_TRUE;
	+ (void) pthread_kill(_reap_children_tid, SIGCHLD);
	+ (void) pthread_join(_reap_children_tid, NULL);
	+
	+ while ((node = avl_destroy_nodes(&_launched_processes, &ck)) != NULL) {
	+ free(node->name);
	+ free(node);
	}
	+ avl_destroy(&_launched_processes);
	+
	+ (void) pthread_mutex_destroy(&_launched_processes_lock);
	+ (void) pthread_mutex_init(&_launched_processes_lock, NULL);
	+
	+ _reap_children_tid = (pthread_t)-1;
	}

	/*
	* Process the event [eid] by synchronously invoking all zedlets with a
	* matching class prefix.
	*
	- * Each executable in [zedlets] from the directory [dir] is matched against
	- * the event's [class], [subclass], and the "all" class (which matches
	- * all events). Every zedlet with a matching class prefix is invoked.
	+ * Each executable in [zcp->zedlets] from the directory [zcp->zedlet_dir]
	+ * is matched against the event's [class], [subclass], and the "all" class
	+ * (which matches all events).
	+ * Every zedlet with a matching class prefix is invoked.
	* The NAME=VALUE strings in [envs] will be passed to the zedlet as
	* environment variables.
	*
	- * The file descriptor [zfd] is the zevent_fd used to track the
	+ * The file descriptor [zcp->zevent_fd] is the zevent_fd used to track the
	* current cursor location within the zevent nvlist.
	*
	* Return 0 on success, -1 on error.
	*/
	int
	zed_exec_process(uint64_t eid, const char class, const char subclass,
	- const char dir, zed_strings_t zedlets, zed_strings_t *envs, int zfd)
	+ struct zed_conf zcp, zed_strings_t envs)
	{
	const char *class_strings[4];
	const char *allclass = "all";
	const char **csp;
	const char *z;
	char **e;
	int n;

	- if (!dir \|\| !zedlets \|\| !envs \|\| zfd < 0)
	+ if (!zcp->zedlet_dir \|\| !zcp->zedlets \|\| !envs \|\| zcp->zevent_fd < 0)
	return (-1);

	+ if (_reap_children_tid == (pthread_t)-1) {
	+ _launched_processes_limit = zcp->max_jobs;
	+
	+ if (pthread_create(&_reap_children_tid, NULL,
	+ _reap_children, NULL) != 0)
	+ return (-1);
	+ pthread_setname_np(_reap_children_tid, "reap ZEDLETs");
	+
	+ avl_create(&_launched_processes, _launched_process_node_compare,
	+ sizeof (struct launched_process_node),
	+ offsetof(struct launched_process_node, node));
	+ }
	+
	csp = class_strings;

	if (class)
	*csp++ = class;

	if (subclass)
	*csp++ = subclass;

	if (allclass)
	*csp++ = allclass;

	*csp = NULL;

	e = _zed_exec_create_env(envs);

	- for (z = zed_strings_first(zedlets); z; z = zed_strings_next(zedlets)) {
	+ for (z = zed_strings_first(zcp->zedlets); z;
	+ z = zed_strings_next(zcp->zedlets)) {
	for (csp = class_strings; *csp; csp++) {
	n = strlen(*csp);
	if ((strncmp(z, *csp, n) == 0) && !isalpha(z[n]))
	- _zed_exec_fork_child(eid, dir, z, e, zfd);
	+ _zed_exec_fork_child(eid, zcp->zedlet_dir,
	+ z, e, zcp->zevent_fd, zcp->do_foreground);
	}
	}
	free(e);
	return (0);
	}
	diff --git a/sys/contrib/openzfs/cmd/zed/zed_exec.h b/sys/contrib/openzfs/cmd/zed/zed_exec.h
	index 5eb9170abfe3..e4c8d86335b8 100644
	--- a/sys/contrib/openzfs/cmd/zed/zed_exec.h
	+++ b/sys/contrib/openzfs/cmd/zed/zed_exec.h
	@@ -1,25 +1,27 @@
	/*
	* This file is part of the ZFS Event Daemon (ZED).
	*
	* Developed at Lawrence Livermore National Laboratory (LLNL-CODE-403049).
	* Copyright (C) 2013-2014 Lawrence Livermore National Security, LLC.
	- * Refer to the ZoL git commit log for authoritative copyright attribution.
	+ * Refer to the OpenZFS git commit log for authoritative copyright attribution.
	*
	* The contents of this file are subject to the terms of the
	* Common Development and Distribution License Version 1.0 (CDDL-1.0).
	* You can obtain a copy of the license from the top-level file
	* "OPENSOLARIS.LICENSE" or at <http://opensource.org/licenses/CDDL-1.0>.
	* You may not use this file except in compliance with the license.
	*/

	#ifndef ZED_EXEC_H
	#define ZED_EXEC_H

	#include <stdint.h>
	#include "zed_strings.h"
	+#include "zed_conf.h"
	+
	+void zed_exec_fini(void);

	int zed_exec_process(uint64_t eid, const char class, const char subclass,
	- const char dir, zed_strings_t zedlets, zed_strings_t *envs,
	- int zevent_fd);
	+ struct zed_conf zcp, zed_strings_t envs);

	#endif /* !ZED_EXEC_H */
	diff --git a/sys/contrib/openzfs/cmd/zed/zed_file.c b/sys/contrib/openzfs/cmd/zed/zed_file.c
	index b51b1ca9dcf6..b62f68b2610f 100644
	--- a/sys/contrib/openzfs/cmd/zed/zed_file.c
	+++ b/sys/contrib/openzfs/cmd/zed/zed_file.c
	@@ -1,217 +1,141 @@
	/*
	* This file is part of the ZFS Event Daemon (ZED).
	*
	* Developed at Lawrence Livermore National Laboratory (LLNL-CODE-403049).
	* Copyright (C) 2013-2014 Lawrence Livermore National Security, LLC.
	- * Refer to the ZoL git commit log for authoritative copyright attribution.
	+ * Refer to the OpenZFS git commit log for authoritative copyright attribution.
	*
	* The contents of this file are subject to the terms of the
	* Common Development and Distribution License Version 1.0 (CDDL-1.0).
	* You can obtain a copy of the license from the top-level file
	* "OPENSOLARIS.LICENSE" or at <http://opensource.org/licenses/CDDL-1.0>.
	* You may not use this file except in compliance with the license.
	*/

	+#include <dirent.h>
	#include <errno.h>
	#include <fcntl.h>
	#include <limits.h>
	#include <string.h>
	-#include <sys/resource.h>
	#include <sys/stat.h>
	#include <sys/types.h>
	#include <unistd.h>
	#include "zed_file.h"
	#include "zed_log.h"

	-/*
	- * Read up to [n] bytes from [fd] into [buf].
	- * Return the number of bytes read, 0 on EOF, or -1 on error.
	- */
	-ssize_t
	-zed_file_read_n(int fd, void *buf, size_t n)
	-{
	- unsigned char *p;
	- size_t n_left;
	- ssize_t n_read;
	-
	- p = buf;
	- n_left = n;
	- while (n_left > 0) {
	- if ((n_read = read(fd, p, n_left)) < 0) {
	- if (errno == EINTR)
	- continue;
	- else
	- return (-1);
	-
	- } else if (n_read == 0) {
	- break;
	- }
	- n_left -= n_read;
	- p += n_read;
	- }
	- return (n - n_left);
	-}
	-
	-/*
	- * Write [n] bytes from [buf] out to [fd].
	- * Return the number of bytes written, or -1 on error.
	- */
	-ssize_t
	-zed_file_write_n(int fd, void *buf, size_t n)
	-{
	- const unsigned char *p;
	- size_t n_left;
	- ssize_t n_written;
	-
	- p = buf;
	- n_left = n;
	- while (n_left > 0) {
	- if ((n_written = write(fd, p, n_left)) < 0) {
	- if (errno == EINTR)
	- continue;
	- else
	- return (-1);
	-
	- }
	- n_left -= n_written;
	- p += n_written;
	- }
	- return (n);
	-}
	-
	/*
	* Set an exclusive advisory lock on the open file descriptor [fd].
	* Return 0 on success, 1 if a conflicting lock is held by another process,
	* or -1 on error (with errno set).
	*/
	int
	zed_file_lock(int fd)
	{
	struct flock lock;

	if (fd < 0) {
	errno = EBADF;
	return (-1);
	}
	lock.l_type = F_WRLCK;
	lock.l_whence = SEEK_SET;
	lock.l_start = 0;
	lock.l_len = 0;

	if (fcntl(fd, F_SETLK, &lock) < 0) {
	if ((errno == EACCES) \|\| (errno == EAGAIN))
	return (1);

	return (-1);
	}
	return (0);
	}

	/*
	* Release an advisory lock held on the open file descriptor [fd].
	* Return 0 on success, or -1 on error (with errno set).
	*/
	int
	zed_file_unlock(int fd)
	{
	struct flock lock;

	if (fd < 0) {
	errno = EBADF;
	return (-1);
	}
	lock.l_type = F_UNLCK;
	lock.l_whence = SEEK_SET;
	lock.l_start = 0;
	lock.l_len = 0;

	if (fcntl(fd, F_SETLK, &lock) < 0)
	return (-1);

	return (0);
	}

	/*
	* Test whether an exclusive advisory lock could be obtained for the open
	* file descriptor [fd].
	* Return 0 if the file is not locked, >0 for the PID of another process
	* holding a conflicting lock, or -1 on error (with errno set).
	*/
	pid_t
	zed_file_is_locked(int fd)
	{
	struct flock lock;

	if (fd < 0) {
	errno = EBADF;
	return (-1);
	}
	lock.l_type = F_WRLCK;
	lock.l_whence = SEEK_SET;
	lock.l_start = 0;
	lock.l_len = 0;

	if (fcntl(fd, F_GETLK, &lock) < 0)
	return (-1);

	if (lock.l_type == F_UNLCK)
	return (0);

	return (lock.l_pid);
	}

	+
	+#if __APPLE__
	+#define PROC_SELF_FD "/dev/fd"
	+#else /* Linux-compatible layout */
	+#define PROC_SELF_FD "/proc/self/fd"
	+#endif
	+
	/*
	* Close all open file descriptors greater than or equal to [lowfd].
	* Any errors encountered while closing file descriptors are ignored.
	*/
	void
	zed_file_close_from(int lowfd)
	{
	- const int maxfd_def = 256;
	- int errno_bak;
	- struct rlimit rl;
	- int maxfd;
	+ int errno_bak = errno;
	+ int maxfd = 0;
	int fd;
	-
	- errno_bak = errno;
	-
	- if (getrlimit(RLIMIT_NOFILE, &rl) < 0) {
	- maxfd = maxfd_def;
	- } else if (rl.rlim_max == RLIM_INFINITY) {
	- maxfd = maxfd_def;
	+ DIR *fddir;
	+ struct dirent *fdent;
	+
	+ if ((fddir = opendir(PROC_SELF_FD)) != NULL) {
	+ while ((fdent = readdir(fddir)) != NULL) {
	+ fd = atoi(fdent->d_name);
	+ if (fd > maxfd && fd != dirfd(fddir))
	+ maxfd = fd;
	+ }
	+ (void) closedir(fddir);
	} else {
	- maxfd = rl.rlim_max;
	+ maxfd = sysconf(_SC_OPEN_MAX);
	}
	for (fd = lowfd; fd < maxfd; fd++)
	(void) close(fd);

	errno = errno_bak;
	}
	-
	-/*
	- * Set the CLOEXEC flag on file descriptor [fd] so it will be automatically
	- * closed upon successful execution of one of the exec functions.
	- * Return 0 on success, or -1 on error.
	- *
	- * FIXME: No longer needed?
	- */
	-int
	-zed_file_close_on_exec(int fd)
	-{
	- int flags;
	-
	- if (fd < 0) {
	- errno = EBADF;
	- return (-1);
	- }
	- flags = fcntl(fd, F_GETFD);
	- if (flags == -1)
	- return (-1);
	-
	- flags \|= FD_CLOEXEC;
	-
	- if (fcntl(fd, F_SETFD, flags) == -1)
	- return (-1);
	-
	- return (0);
	-}
	diff --git a/sys/contrib/openzfs/cmd/zed/zed_file.h b/sys/contrib/openzfs/cmd/zed/zed_file.h
	index 7dcae83810ef..7e3a0efcaf37 100644
	--- a/sys/contrib/openzfs/cmd/zed/zed_file.h
	+++ b/sys/contrib/openzfs/cmd/zed/zed_file.h
	@@ -1,35 +1,29 @@
	/*
	* This file is part of the ZFS Event Daemon (ZED).
	*
	* Developed at Lawrence Livermore National Laboratory (LLNL-CODE-403049).
	* Copyright (C) 2013-2014 Lawrence Livermore National Security, LLC.
	- * Refer to the ZoL git commit log for authoritative copyright attribution.
	+ * Refer to the OpenZFS git commit log for authoritative copyright attribution.
	*
	* The contents of this file are subject to the terms of the
	* Common Development and Distribution License Version 1.0 (CDDL-1.0).
	* You can obtain a copy of the license from the top-level file
	* "OPENSOLARIS.LICENSE" or at <http://opensource.org/licenses/CDDL-1.0>.
	* You may not use this file except in compliance with the license.
	*/

	#ifndef ZED_FILE_H
	#define ZED_FILE_H

	#include <sys/types.h>
	#include <unistd.h>

	-ssize_t zed_file_read_n(int fd, void *buf, size_t n);
	-
	-ssize_t zed_file_write_n(int fd, void *buf, size_t n);
	-
	int zed_file_lock(int fd);

	int zed_file_unlock(int fd);

	pid_t zed_file_is_locked(int fd);

	void zed_file_close_from(int fd);

	-int zed_file_close_on_exec(int fd);
	-
	#endif /* !ZED_FILE_H */
	diff --git a/sys/contrib/openzfs/cmd/zed/zed_log.c b/sys/contrib/openzfs/cmd/zed/zed_log.c
	index 948dad52adb8..0c4ab6f47db7 100644
	--- a/sys/contrib/openzfs/cmd/zed/zed_log.c
	+++ b/sys/contrib/openzfs/cmd/zed/zed_log.c
	@@ -1,256 +1,256 @@
	/*
	* This file is part of the ZFS Event Daemon (ZED).
	*
	* Developed at Lawrence Livermore National Laboratory (LLNL-CODE-403049).
	* Copyright (C) 2013-2014 Lawrence Livermore National Security, LLC.
	- * Refer to the ZoL git commit log for authoritative copyright attribution.
	+ * Refer to the OpenZFS git commit log for authoritative copyright attribution.
	*
	* The contents of this file are subject to the terms of the
	* Common Development and Distribution License Version 1.0 (CDDL-1.0).
	* You can obtain a copy of the license from the top-level file
	* "OPENSOLARIS.LICENSE" or at <http://opensource.org/licenses/CDDL-1.0>.
	* You may not use this file except in compliance with the license.
	*/

	#include <assert.h>
	#include <errno.h>
	#include <stdarg.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <sys/types.h>
	#include <syslog.h>
	#include <unistd.h>
	#include "zed_log.h"

	#define ZED_LOG_MAX_LOG_LEN 1024

	static struct {
	unsigned do_stderr:1;
	unsigned do_syslog:1;
	const char *identity;
	int priority;
	int pipe_fd[2];
	} _ctx;

	/*
	* Initialize the logging subsystem.
	*/
	void
	zed_log_init(const char *identity)
	{
	if (identity) {
	const char *p = strrchr(identity, '/');
	_ctx.identity = (p != NULL) ? p + 1 : identity;
	} else {
	_ctx.identity = NULL;
	}
	_ctx.pipe_fd[0] = -1;
	_ctx.pipe_fd[1] = -1;
	}

	/*
	* Shutdown the logging subsystem.
	*/
	void
	zed_log_fini(void)
	{
	zed_log_stderr_close();
	zed_log_syslog_close();
	}

	/*
	* Create pipe for communicating daemonization status between the parent and
	* child processes across the double-fork().
	*/
	void
	zed_log_pipe_open(void)
	{
	if ((_ctx.pipe_fd[0] != -1) \|\| (_ctx.pipe_fd[1] != -1))
	zed_log_die("Invalid use of zed_log_pipe_open in PID %d",
	(int)getpid());

	if (pipe(_ctx.pipe_fd) < 0)
	zed_log_die("Failed to create daemonize pipe in PID %d: %s",
	(int)getpid(), strerror(errno));
	}

	/*
	* Close the read-half of the daemonize pipe.
	*
	* This should be called by the child after fork()ing from the parent since
	* the child will never read from this pipe.
	*/
	void
	zed_log_pipe_close_reads(void)
	{
	if (_ctx.pipe_fd[0] < 0)
	zed_log_die(
	"Invalid use of zed_log_pipe_close_reads in PID %d",
	(int)getpid());

	if (close(_ctx.pipe_fd[0]) < 0)
	zed_log_die(
	"Failed to close reads on daemonize pipe in PID %d: %s",
	(int)getpid(), strerror(errno));

	_ctx.pipe_fd[0] = -1;
	}

	/*
	* Close the write-half of the daemonize pipe.
	*
	* This should be called by the parent after fork()ing its child since the
	* parent will never write to this pipe.
	*
	* This should also be called by the child once initialization is complete
	* in order to signal the parent that it can safely exit.
	*/
	void
	zed_log_pipe_close_writes(void)
	{
	if (_ctx.pipe_fd[1] < 0)
	zed_log_die(
	"Invalid use of zed_log_pipe_close_writes in PID %d",
	(int)getpid());

	if (close(_ctx.pipe_fd[1]) < 0)
	zed_log_die(
	"Failed to close writes on daemonize pipe in PID %d: %s",
	(int)getpid(), strerror(errno));

	_ctx.pipe_fd[1] = -1;
	}

	/*
	* Block on reading from the daemonize pipe until signaled by the child
	* (via zed_log_pipe_close_writes()) that initialization is complete.
	*
	* This should only be called by the parent while waiting to exit after
	* fork()ing the child.
	*/
	void
	zed_log_pipe_wait(void)
	{
	ssize_t n;
	char c;

	if (_ctx.pipe_fd[0] < 0)
	zed_log_die("Invalid use of zed_log_pipe_wait in PID %d",
	(int)getpid());

	for (;;) {
	n = read(_ctx.pipe_fd[0], &c, sizeof (c));
	if (n < 0) {
	if (errno == EINTR)
	continue;
	zed_log_die(
	"Failed to read from daemonize pipe in PID %d: %s",
	(int)getpid(), strerror(errno));
	}
	if (n == 0) {
	break;
	}
	}
	}

	/*
	* Start logging messages at the syslog [priority] level or higher to stderr.
	* Refer to syslog(3) for valid priority values.
	*/
	void
	zed_log_stderr_open(int priority)
	{
	_ctx.do_stderr = 1;
	_ctx.priority = priority;
	}

	/*
	* Stop logging messages to stderr.
	*/
	void
	zed_log_stderr_close(void)
	{
	if (_ctx.do_stderr)
	_ctx.do_stderr = 0;
	}

	/*
	* Start logging messages to syslog.
	* Refer to syslog(3) for valid option/facility values.
	*/
	void
	zed_log_syslog_open(int facility)
	{
	_ctx.do_syslog = 1;
	openlog(_ctx.identity, LOG_NDELAY \| LOG_PID, facility);
	}

	/*
	* Stop logging messages to syslog.
	*/
	void
	zed_log_syslog_close(void)
	{
	if (_ctx.do_syslog) {
	_ctx.do_syslog = 0;
	closelog();
	}
	}

	/*
	* Auxiliary function to log a message to syslog and/or stderr.
	*/
	static void
	_zed_log_aux(int priority, const char *fmt, va_list vargs)
	{
	char buf[ZED_LOG_MAX_LOG_LEN];
	int n;

	if (!fmt)
	return;

	n = vsnprintf(buf, sizeof (buf), fmt, vargs);
	if ((n < 0) \|\| (n >= sizeof (buf))) {
	buf[sizeof (buf) - 2] = '+';
	buf[sizeof (buf) - 1] = '\0';
	}

	if (_ctx.do_syslog)
	syslog(priority, "%s", buf);

	if (_ctx.do_stderr && (priority <= _ctx.priority))
	fprintf(stderr, "%s\n", buf);
	}

	/*
	* Log a message at the given [priority] level specified by the printf-style
	* format string [fmt].
	*/
	void
	zed_log_msg(int priority, const char *fmt, ...)
	{
	va_list vargs;

	if (fmt) {
	va_start(vargs, fmt);
	_zed_log_aux(priority, fmt, vargs);
	va_end(vargs);
	}
	}

	/*
	* Log a fatal error message specified by the printf-style format string [fmt].
	*/
	void
	zed_log_die(const char *fmt, ...)
	{
	va_list vargs;

	if (fmt) {
	va_start(vargs, fmt);
	_zed_log_aux(LOG_ERR, fmt, vargs);
	va_end(vargs);
	}
	exit(EXIT_FAILURE);
	}
	diff --git a/sys/contrib/openzfs/cmd/zed/zed_log.h b/sys/contrib/openzfs/cmd/zed/zed_log.h
	index 0daaad11df5c..ed88ad41d7e2 100644
	--- a/sys/contrib/openzfs/cmd/zed/zed_log.h
	+++ b/sys/contrib/openzfs/cmd/zed/zed_log.h
	@@ -1,44 +1,44 @@
	/*
	* This file is part of the ZFS Event Daemon (ZED).
	*
	* Developed at Lawrence Livermore National Laboratory (LLNL-CODE-403049).
	* Copyright (C) 2013-2014 Lawrence Livermore National Security, LLC.
	- * Refer to the ZoL git commit log for authoritative copyright attribution.
	+ * Refer to the OpenZFS git commit log for authoritative copyright attribution.
	*
	* The contents of this file are subject to the terms of the
	* Common Development and Distribution License Version 1.0 (CDDL-1.0).
	* You can obtain a copy of the license from the top-level file
	* "OPENSOLARIS.LICENSE" or at <http://opensource.org/licenses/CDDL-1.0>.
	* You may not use this file except in compliance with the license.
	*/

	#ifndef ZED_LOG_H
	#define ZED_LOG_H

	#include <syslog.h>

	void zed_log_init(const char *identity);

	void zed_log_fini(void);

	void zed_log_pipe_open(void);

	void zed_log_pipe_close_reads(void);

	void zed_log_pipe_close_writes(void);

	void zed_log_pipe_wait(void);

	void zed_log_stderr_open(int priority);

	void zed_log_stderr_close(void);

	void zed_log_syslog_open(int facility);

	void zed_log_syslog_close(void);

	void zed_log_msg(int priority, const char *fmt, ...);

	void zed_log_die(const char *fmt, ...);

	#endif /* !ZED_LOG_H */
	diff --git a/sys/contrib/openzfs/cmd/zed/zed_strings.c b/sys/contrib/openzfs/cmd/zed/zed_strings.c
	index 89964317e48c..52a86e9296fe 100644
	--- a/sys/contrib/openzfs/cmd/zed/zed_strings.c
	+++ b/sys/contrib/openzfs/cmd/zed/zed_strings.c
	@@ -1,247 +1,247 @@
	/*
	* This file is part of the ZFS Event Daemon (ZED).
	*
	* Developed at Lawrence Livermore National Laboratory (LLNL-CODE-403049).
	* Copyright (C) 2013-2014 Lawrence Livermore National Security, LLC.
	- * Refer to the ZoL git commit log for authoritative copyright attribution.
	+ * Refer to the OpenZFS git commit log for authoritative copyright attribution.
	*
	* The contents of this file are subject to the terms of the
	* Common Development and Distribution License Version 1.0 (CDDL-1.0).
	* You can obtain a copy of the license from the top-level file
	* "OPENSOLARIS.LICENSE" or at <http://opensource.org/licenses/CDDL-1.0>.
	* You may not use this file except in compliance with the license.
	*/

	#include <assert.h>
	#include <errno.h>
	#include <stddef.h>
	#include <stdlib.h>
	#include <string.h>
	#include <sys/avl.h>
	#include <sys/sysmacros.h>
	#include "zed_strings.h"

	struct zed_strings {
	avl_tree_t tree;
	avl_node_t *iteratorp;
	};

	struct zed_strings_node {
	avl_node_t node;
	char *key;
	char *val;
	};

	typedef struct zed_strings_node zed_strings_node_t;

	/*
	* Compare zed_strings_node_t nodes [x1] and [x2].
	* As required for the AVL tree, return -1 for <, 0 for ==, and +1 for >.
	*/
	static int
	_zed_strings_node_compare(const void x1, const void x2)
	{
	const char *s1;
	const char *s2;
	int rv;

	assert(x1 != NULL);
	assert(x2 != NULL);

	s1 = ((const zed_strings_node_t *) x1)->key;
	assert(s1 != NULL);
	s2 = ((const zed_strings_node_t *) x2)->key;
	assert(s2 != NULL);
	rv = strcmp(s1, s2);

	if (rv < 0)
	return (-1);

	if (rv > 0)
	return (1);

	return (0);
	}

	/*
	* Return a new string container, or NULL on error.
	*/
	zed_strings_t *
	zed_strings_create(void)
	{
	zed_strings_t *zsp;

	zsp = calloc(1, sizeof (*zsp));
	if (!zsp)
	return (NULL);

	avl_create(&zsp->tree, _zed_strings_node_compare,
	sizeof (zed_strings_node_t), offsetof(zed_strings_node_t, node));

	zsp->iteratorp = NULL;
	return (zsp);
	}

	/*
	* Destroy the string node [np].
	*/
	static void
	_zed_strings_node_destroy(zed_strings_node_t *np)
	{
	if (!np)
	return;

	if (np->key) {
	if (np->key != np->val)
	free(np->key);
	np->key = NULL;
	}
	if (np->val) {
	free(np->val);
	np->val = NULL;
	}
	free(np);
	}

	/*
	* Return a new string node for storing the string [val], or NULL on error.
	* If [key] is specified, it will be used to index the node; otherwise,
	* the string [val] will be used.
	*/
	static zed_strings_node_t *
	_zed_strings_node_create(const char key, const char val)
	{
	zed_strings_node_t *np;

	assert(val != NULL);

	np = calloc(1, sizeof (*np));
	if (!np)
	return (NULL);

	np->val = strdup(val);
	if (!np->val)
	goto nomem;

	if (key) {
	np->key = strdup(key);
	if (!np->key)
	goto nomem;
	} else {
	np->key = np->val;
	}
	return (np);

	nomem:
	_zed_strings_node_destroy(np);
	return (NULL);
	}

	/*
	* Destroy the string container [zsp] and all nodes within.
	*/
	void
	zed_strings_destroy(zed_strings_t *zsp)
	{
	void *cookie;
	zed_strings_node_t *np;

	if (!zsp)
	return;

	cookie = NULL;
	while ((np = avl_destroy_nodes(&zsp->tree, &cookie)))
	_zed_strings_node_destroy(np);

	avl_destroy(&zsp->tree);
	free(zsp);
	}

	/*
	* Add a copy of the string [s] indexed by [key] to the container [zsp].
	* If [key] already exists within the container [zsp], it will be replaced
	* with the new string [s].
	* If [key] is NULL, the string [s] will be used as the key.
	* Return 0 on success, or -1 on error.
	*/
	int
	zed_strings_add(zed_strings_t zsp, const char key, const char *s)
	{
	zed_strings_node_t newp, oldp;

	if (!zsp \|\| !s) {
	errno = EINVAL;
	return (-1);
	}
	if (key == s)
	key = NULL;

	newp = _zed_strings_node_create(key, s);
	if (!newp)
	return (-1);

	oldp = avl_find(&zsp->tree, newp, NULL);
	if (oldp) {
	avl_remove(&zsp->tree, oldp);
	_zed_strings_node_destroy(oldp);
	}
	avl_add(&zsp->tree, newp);
	return (0);
	}

	/*
	* Return the first string in container [zsp].
	* Return NULL if there are no strings, or on error.
	* This can be called multiple times to re-traverse [zsp].
	* XXX: Not thread-safe.
	*/
	const char *
	zed_strings_first(zed_strings_t *zsp)
	{
	if (!zsp) {
	errno = EINVAL;
	return (NULL);
	}
	zsp->iteratorp = avl_first(&zsp->tree);
	if (!zsp->iteratorp)
	return (NULL);

	return (((zed_strings_node_t *)zsp->iteratorp)->val);

	}

	/*
	* Return the next string in container [zsp].
	* Return NULL after the last string, or on error.
	* This must be called after zed_strings_first().
	* XXX: Not thread-safe.
	*/
	const char *
	zed_strings_next(zed_strings_t *zsp)
	{
	if (!zsp) {
	errno = EINVAL;
	return (NULL);
	}
	if (!zsp->iteratorp)
	return (NULL);

	zsp->iteratorp = AVL_NEXT(&zsp->tree, zsp->iteratorp);
	if (!zsp->iteratorp)
	return (NULL);

	return (((zed_strings_node_t *)zsp->iteratorp)->val);
	}

	/*
	* Return the number of strings in container [zsp], or -1 on error.
	*/
	int
	zed_strings_count(zed_strings_t *zsp)
	{
	if (!zsp) {
	errno = EINVAL;
	return (-1);
	}
	return (avl_numnodes(&zsp->tree));
	}
	diff --git a/sys/contrib/openzfs/cmd/zed/zed_strings.h b/sys/contrib/openzfs/cmd/zed/zed_strings.h
	index 63d776f9b48f..804639592fe5 100644
	--- a/sys/contrib/openzfs/cmd/zed/zed_strings.h
	+++ b/sys/contrib/openzfs/cmd/zed/zed_strings.h
	@@ -1,27 +1,27 @@
	/*
	* This file is part of the ZFS Event Daemon (ZED).
	*
	* Developed at Lawrence Livermore National Laboratory (LLNL-CODE-403049).
	* Copyright (C) 2013-2014 Lawrence Livermore National Security, LLC.
	- * Refer to the ZoL git commit log for authoritative copyright attribution.
	+ * Refer to the OpenZFS git commit log for authoritative copyright attribution.
	*
	* The contents of this file are subject to the terms of the
	* Common Development and Distribution License Version 1.0 (CDDL-1.0).
	* You can obtain a copy of the license from the top-level file
	* "OPENSOLARIS.LICENSE" or at <http://opensource.org/licenses/CDDL-1.0>.
	* You may not use this file except in compliance with the license.
	*/

	#ifndef ZED_STRINGS_H
	#define ZED_STRINGS_H

	typedef struct zed_strings zed_strings_t;

	zed_strings_t *zed_strings_create(void);
	void zed_strings_destroy(zed_strings_t *zsp);
	int zed_strings_add(zed_strings_t zsp, const char key, const char *s);
	const char zed_strings_first(zed_strings_t zsp);
	const char zed_strings_next(zed_strings_t zsp);
	int zed_strings_count(zed_strings_t *zsp);

	#endif /* !ZED_STRINGS_H */
	diff --git a/sys/contrib/openzfs/cmd/zfs/zfs_main.c b/sys/contrib/openzfs/cmd/zfs/zfs_main.c
	index 1a5129f79493..395fc353fe1b 100644
	--- a/sys/contrib/openzfs/cmd/zfs/zfs_main.c
	+++ b/sys/contrib/openzfs/cmd/zfs/zfs_main.c
	@@ -1,8757 +1,8768 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2011, 2020 by Delphix. All rights reserved.
	* Copyright 2012 Milan Jurik. All rights reserved.
	* Copyright (c) 2012, Joyent, Inc. All rights reserved.
	* Copyright (c) 2013 Steven Hartland. All rights reserved.
	* Copyright 2016 Igor Kozhukhov <ikozhukhov@gmail.com>.
	* Copyright 2016 Nexenta Systems, Inc.
	* Copyright (c) 2019 Datto Inc.
	* Copyright (c) 2019, loli10K <ezomori.nozomu@gmail.com>
	* Copyright 2019 Joyent, Inc.
	* Copyright (c) 2019, 2020 by Christian Schwarz. All rights reserved.
	*/

	#include <assert.h>
	#include <ctype.h>
	#include <sys/debug.h>
	#include <errno.h>
	#include <getopt.h>
	#include <libgen.h>
	#include <libintl.h>
	#include <libuutil.h>
	#include <libnvpair.h>
	#include <locale.h>
	#include <stddef.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <strings.h>
	#include <unistd.h>
	#include <fcntl.h>
	#include <zone.h>
	#include <grp.h>
	#include <pwd.h>
	#include <signal.h>
	#include <sys/list.h>
	#include <sys/mkdev.h>
	#include <sys/mntent.h>
	#include <sys/mnttab.h>
	#include <sys/mount.h>
	#include <sys/stat.h>
	#include <sys/fs/zfs.h>
	#include <sys/systeminfo.h>
	#include <sys/types.h>
	#include <time.h>
	#include <sys/zfs_project.h>

	#include <libzfs.h>
	#include <libzfs_core.h>
	#include <zfs_prop.h>
	#include <zfs_deleg.h>
	#include <libzutil.h>
	#ifdef HAVE_IDMAP
	#include <aclutils.h>
	#include <directory.h>
	#endif /* HAVE_IDMAP */

	#include "zfs_iter.h"
	#include "zfs_util.h"
	#include "zfs_comutil.h"
	#include "libzfs_impl.h"
	#include "zfs_projectutil.h"

	libzfs_handle_t *g_zfs;

	static FILE *mnttab_file;
	static char history_str[HIS_MAX_RECORD_LEN];
	static boolean_t log_history = B_TRUE;

	static int zfs_do_clone(int argc, char **argv);
	static int zfs_do_create(int argc, char **argv);
	static int zfs_do_destroy(int argc, char **argv);
	static int zfs_do_get(int argc, char **argv);
	static int zfs_do_inherit(int argc, char **argv);
	static int zfs_do_list(int argc, char **argv);
	static int zfs_do_mount(int argc, char **argv);
	static int zfs_do_rename(int argc, char **argv);
	static int zfs_do_rollback(int argc, char **argv);
	static int zfs_do_set(int argc, char **argv);
	static int zfs_do_upgrade(int argc, char **argv);
	static int zfs_do_snapshot(int argc, char **argv);
	static int zfs_do_unmount(int argc, char **argv);
	static int zfs_do_share(int argc, char **argv);
	static int zfs_do_unshare(int argc, char **argv);
	static int zfs_do_send(int argc, char **argv);
	static int zfs_do_receive(int argc, char **argv);
	static int zfs_do_promote(int argc, char **argv);
	static int zfs_do_userspace(int argc, char **argv);
	static int zfs_do_allow(int argc, char **argv);
	static int zfs_do_unallow(int argc, char **argv);
	static int zfs_do_hold(int argc, char **argv);
	static int zfs_do_holds(int argc, char **argv);
	static int zfs_do_release(int argc, char **argv);
	static int zfs_do_diff(int argc, char **argv);
	static int zfs_do_bookmark(int argc, char **argv);
	static int zfs_do_channel_program(int argc, char **argv);
	static int zfs_do_load_key(int argc, char **argv);
	static int zfs_do_unload_key(int argc, char **argv);
	static int zfs_do_change_key(int argc, char **argv);
	static int zfs_do_project(int argc, char **argv);
	static int zfs_do_version(int argc, char **argv);
	static int zfs_do_redact(int argc, char **argv);
	static int zfs_do_wait(int argc, char **argv);

	#ifdef __FreeBSD__
	static int zfs_do_jail(int argc, char **argv);
	static int zfs_do_unjail(int argc, char **argv);
	#endif

	/*
	* Enable a reasonable set of defaults for libumem debugging on DEBUG builds.
	*/

	#ifdef DEBUG
	const char *
	_umem_debug_init(void)
	{
	return ("default,verbose"); /* $UMEM_DEBUG setting */
	}

	const char *
	_umem_logging_init(void)
	{
	return ("fail,contents"); /* $UMEM_LOGGING setting */
	}
	#endif

	typedef enum {
	HELP_CLONE,
	HELP_CREATE,
	HELP_DESTROY,
	HELP_GET,
	HELP_INHERIT,
	HELP_UPGRADE,
	HELP_LIST,
	HELP_MOUNT,
	HELP_PROMOTE,
	HELP_RECEIVE,
	HELP_RENAME,
	HELP_ROLLBACK,
	HELP_SEND,
	HELP_SET,
	HELP_SHARE,
	HELP_SNAPSHOT,
	HELP_UNMOUNT,
	HELP_UNSHARE,
	HELP_ALLOW,
	HELP_UNALLOW,
	HELP_USERSPACE,
	HELP_GROUPSPACE,
	HELP_PROJECTSPACE,
	HELP_PROJECT,
	HELP_HOLD,
	HELP_HOLDS,
	HELP_RELEASE,
	HELP_DIFF,
	HELP_BOOKMARK,
	HELP_CHANNEL_PROGRAM,
	HELP_LOAD_KEY,
	HELP_UNLOAD_KEY,
	HELP_CHANGE_KEY,
	HELP_VERSION,
	HELP_REDACT,
	HELP_JAIL,
	HELP_UNJAIL,
	HELP_WAIT,
	} zfs_help_t;

	typedef struct zfs_command {
	const char *name;
	int (func)(int argc, char *argv);
	zfs_help_t usage;
	} zfs_command_t;

	/*
	* Master command table. Each ZFS command has a name, associated function, and
	* usage message. The usage messages need to be internationalized, so we have
	* to have a function to return the usage message based on a command index.
	*
	* These commands are organized according to how they are displayed in the usage
	* message. An empty command (one with a NULL name) indicates an empty line in
	* the generic usage message.
	*/
	static zfs_command_t command_table[] = {
	{ "version", zfs_do_version, HELP_VERSION },
	{ NULL },
	{ "create", zfs_do_create, HELP_CREATE },
	{ "destroy", zfs_do_destroy, HELP_DESTROY },
	{ NULL },
	{ "snapshot", zfs_do_snapshot, HELP_SNAPSHOT },
	{ "rollback", zfs_do_rollback, HELP_ROLLBACK },
	{ "clone", zfs_do_clone, HELP_CLONE },
	{ "promote", zfs_do_promote, HELP_PROMOTE },
	{ "rename", zfs_do_rename, HELP_RENAME },
	{ "bookmark", zfs_do_bookmark, HELP_BOOKMARK },
	{ "program", zfs_do_channel_program, HELP_CHANNEL_PROGRAM },
	{ NULL },
	{ "list", zfs_do_list, HELP_LIST },
	{ NULL },
	{ "set", zfs_do_set, HELP_SET },
	{ "get", zfs_do_get, HELP_GET },
	{ "inherit", zfs_do_inherit, HELP_INHERIT },
	{ "upgrade", zfs_do_upgrade, HELP_UPGRADE },
	{ NULL },
	{ "userspace", zfs_do_userspace, HELP_USERSPACE },
	{ "groupspace", zfs_do_userspace, HELP_GROUPSPACE },
	{ "projectspace", zfs_do_userspace, HELP_PROJECTSPACE },
	{ NULL },
	{ "project", zfs_do_project, HELP_PROJECT },
	{ NULL },
	{ "mount", zfs_do_mount, HELP_MOUNT },
	{ "unmount", zfs_do_unmount, HELP_UNMOUNT },
	{ "share", zfs_do_share, HELP_SHARE },
	{ "unshare", zfs_do_unshare, HELP_UNSHARE },
	{ NULL },
	{ "send", zfs_do_send, HELP_SEND },
	{ "receive", zfs_do_receive, HELP_RECEIVE },
	{ NULL },
	{ "allow", zfs_do_allow, HELP_ALLOW },
	{ NULL },
	{ "unallow", zfs_do_unallow, HELP_UNALLOW },
	{ NULL },
	{ "hold", zfs_do_hold, HELP_HOLD },
	{ "holds", zfs_do_holds, HELP_HOLDS },
	{ "release", zfs_do_release, HELP_RELEASE },
	{ "diff", zfs_do_diff, HELP_DIFF },
	{ "load-key", zfs_do_load_key, HELP_LOAD_KEY },
	{ "unload-key", zfs_do_unload_key, HELP_UNLOAD_KEY },
	{ "change-key", zfs_do_change_key, HELP_CHANGE_KEY },
	{ "redact", zfs_do_redact, HELP_REDACT },
	{ "wait", zfs_do_wait, HELP_WAIT },

	#ifdef __FreeBSD__
	{ "jail", zfs_do_jail, HELP_JAIL },
	{ "unjail", zfs_do_unjail, HELP_UNJAIL },
	#endif
	};

	#define NCOMMAND (sizeof (command_table) / sizeof (command_table[0]))

	zfs_command_t *current_command;

	static const char *
	get_usage(zfs_help_t idx)
	{
	switch (idx) {
	case HELP_CLONE:
	return (gettext("\tclone [-p] [-o property=value] ... "
	"<snapshot> <filesystem\|volume>\n"));
	case HELP_CREATE:
	return (gettext("\tcreate [-Pnpuv] [-o property=value] ... "
	"<filesystem>\n"
	"\tcreate [-Pnpsv] [-b blocksize] [-o property=value] ... "
	"-V <size> <volume>\n"));
	case HELP_DESTROY:
	return (gettext("\tdestroy [-fnpRrv] <filesystem\|volume>\n"
	"\tdestroy [-dnpRrv] "
	"<filesystem\|volume>@<snap>[%<snap>][,...]\n"
	"\tdestroy <filesystem\|volume>#<bookmark>\n"));
	case HELP_GET:
	return (gettext("\tget [-rHp] [-d max] "
	"[-o \"all\" \| field[,...]]\n"
	"\t [-t type[,...]] [-s source[,...]]\n"
	"\t <\"all\" \| property[,...]> "
	"[filesystem\|volume\|snapshot\|bookmark] ...\n"));
	case HELP_INHERIT:
	return (gettext("\tinherit [-rS] <property> "
	"<filesystem\|volume\|snapshot> ...\n"));
	case HELP_UPGRADE:
	return (gettext("\tupgrade [-v]\n"
	"\tupgrade [-r] [-V version] <-a \| filesystem ...>\n"));
	case HELP_LIST:
	return (gettext("\tlist [-Hp] [-r\|-d max] [-o property[,...]] "
	"[-s property]...\n\t [-S property]... [-t type[,...]] "
	"[filesystem\|volume\|snapshot] ...\n"));
	case HELP_MOUNT:
	return (gettext("\tmount\n"
	"\tmount [-flvO] [-o opts] <-a \| filesystem>\n"));
	case HELP_PROMOTE:
	return (gettext("\tpromote <clone-filesystem>\n"));
	case HELP_RECEIVE:
	return (gettext("\treceive [-vMnsFhu] "
	"[-o <property>=<value>] ... [-x <property>] ...\n"
	"\t <filesystem\|volume\|snapshot>\n"
	"\treceive [-vMnsFhu] [-o <property>=<value>] ... "
	"[-x <property>] ... \n"
	"\t [-d \| -e] <filesystem>\n"
	"\treceive -A <filesystem\|volume>\n"));
	case HELP_RENAME:
	return (gettext("\trename [-f] <filesystem\|volume\|snapshot> "
	"<filesystem\|volume\|snapshot>\n"
	"\trename -p [-f] <filesystem\|volume> <filesystem\|volume>\n"
	"\trename -u [-f] <filesystem> <filesystem>\n"
	"\trename -r <snapshot> <snapshot>\n"));
	case HELP_ROLLBACK:
	return (gettext("\trollback [-rRf] <snapshot>\n"));
	case HELP_SEND:
	return (gettext("\tsend [-DnPpRvLecwhb] [-[i\|I] snapshot] "
	"<snapshot>\n"
	"\tsend [-nvPLecw] [-i snapshot\|bookmark] "
	"<filesystem\|volume\|snapshot>\n"
	"\tsend [-DnPpvLec] [-i bookmark\|snapshot] "
	"--redact <bookmark> <snapshot>\n"
	"\tsend [-nvPe] -t <receive_resume_token>\n"
	"\tsend [-Pnv] --saved filesystem\n"));
	case HELP_SET:
	return (gettext("\tset <property=value> ... "
	"<filesystem\|volume\|snapshot> ...\n"));
	case HELP_SHARE:
	return (gettext("\tshare [-l] <-a [nfs\|smb] \| filesystem>\n"));
	case HELP_SNAPSHOT:
	return (gettext("\tsnapshot [-r] [-o property=value] ... "
	"<filesystem\|volume>@<snap> ...\n"));
	case HELP_UNMOUNT:
	return (gettext("\tunmount [-fu] "
	"<-a \| filesystem\|mountpoint>\n"));
	case HELP_UNSHARE:
	return (gettext("\tunshare "
	"<-a [nfs\|smb] \| filesystem\|mountpoint>\n"));
	case HELP_ALLOW:
	return (gettext("\tallow <filesystem\|volume>\n"
	"\tallow [-ldug] "
	"<\"everyone\"\|user\|group>[,...] <perm\|@setname>[,...]\n"
	"\t <filesystem\|volume>\n"
	"\tallow [-ld] -e <perm\|@setname>[,...] "
	"<filesystem\|volume>\n"
	"\tallow -c <perm\|@setname>[,...] <filesystem\|volume>\n"
	"\tallow -s @setname <perm\|@setname>[,...] "
	"<filesystem\|volume>\n"));
	case HELP_UNALLOW:
	return (gettext("\tunallow [-rldug] "
	"<\"everyone\"\|user\|group>[,...]\n"
	"\t [<perm\|@setname>[,...]] <filesystem\|volume>\n"
	"\tunallow [-rld] -e [<perm\|@setname>[,...]] "
	"<filesystem\|volume>\n"
	"\tunallow [-r] -c [<perm\|@setname>[,...]] "
	"<filesystem\|volume>\n"
	"\tunallow [-r] -s @setname [<perm\|@setname>[,...]] "
	"<filesystem\|volume>\n"));
	case HELP_USERSPACE:
	return (gettext("\tuserspace [-Hinp] [-o field[,...]] "
	"[-s field] ...\n"
	"\t [-S field] ... [-t type[,...]] "
	"<filesystem\|snapshot\|path>\n"));
	case HELP_GROUPSPACE:
	return (gettext("\tgroupspace [-Hinp] [-o field[,...]] "
	"[-s field] ...\n"
	"\t [-S field] ... [-t type[,...]] "
	"<filesystem\|snapshot\|path>\n"));
	case HELP_PROJECTSPACE:
	return (gettext("\tprojectspace [-Hp] [-o field[,...]] "
	"[-s field] ... \n"
	"\t [-S field] ... <filesystem\|snapshot\|path>\n"));
	case HELP_PROJECT:
	return (gettext("\tproject [-d\|-r] <directory\|file ...>\n"
	"\tproject -c [-0] [-d\|-r] [-p id] <directory\|file ...>\n"
	"\tproject -C [-k] [-r] <directory ...>\n"
	"\tproject [-p id] [-r] [-s] <directory ...>\n"));
	case HELP_HOLD:
	return (gettext("\thold [-r] <tag> <snapshot> ...\n"));
	case HELP_HOLDS:
	return (gettext("\tholds [-rH] <snapshot> ...\n"));
	case HELP_RELEASE:
	return (gettext("\trelease [-r] <tag> <snapshot> ...\n"));
	case HELP_DIFF:
	return (gettext("\tdiff [-FHt] <snapshot> "
	"[snapshot\|filesystem]\n"));
	case HELP_BOOKMARK:
	return (gettext("\tbookmark <snapshot\|bookmark> "
	"<newbookmark>\n"));
	case HELP_CHANNEL_PROGRAM:
	return (gettext("\tprogram [-jn] [-t <instruction limit>] "
	"[-m <memory limit (b)>]\n"
	"\t <pool> <program file> [lua args...]\n"));
	case HELP_LOAD_KEY:
	return (gettext("\tload-key [-rn] [-L <keylocation>] "
	"<-a \| filesystem\|volume>\n"));
	case HELP_UNLOAD_KEY:
	return (gettext("\tunload-key [-r] "
	"<-a \| filesystem\|volume>\n"));
	case HELP_CHANGE_KEY:
	return (gettext("\tchange-key [-l] [-o keyformat=<value>]\n"
	"\t [-o keylocation=<value>] [-o pbkdf2iters=<value>]\n"
	"\t <filesystem\|volume>\n"
	"\tchange-key -i [-l] <filesystem\|volume>\n"));
	case HELP_VERSION:
	return (gettext("\tversion\n"));
	case HELP_REDACT:
	return (gettext("\tredact <snapshot> <bookmark> "
	"<redaction_snapshot> ...\n"));
	case HELP_JAIL:
	return (gettext("\tjail <jailid\|jailname> <filesystem>\n"));
	case HELP_UNJAIL:
	return (gettext("\tunjail <jailid\|jailname> <filesystem>\n"));
	case HELP_WAIT:
	return (gettext("\twait [-t <activity>] <filesystem>\n"));
	}

	abort();
	/* NOTREACHED */
	}

	void
	nomem(void)
	{
	(void) fprintf(stderr, gettext("internal error: out of memory\n"));
	exit(1);
	}

	/*
	* Utility function to guarantee malloc() success.
	*/

	void *
	safe_malloc(size_t size)
	{
	void *data;

	if ((data = calloc(1, size)) == NULL)
	nomem();

	return (data);
	}

	static void *
	safe_realloc(void *data, size_t size)
	{
	void *newp;
	if ((newp = realloc(data, size)) == NULL) {
	free(data);
	nomem();
	}

	return (newp);
	}

	static char *
	safe_strdup(char *str)
	{
	char *dupstr = strdup(str);

	if (dupstr == NULL)
	nomem();

	return (dupstr);
	}

	/*
	* Callback routine that will print out information for each of
	* the properties.
	*/
	static int
	usage_prop_cb(int prop, void *cb)
	{
	FILE *fp = cb;

	(void) fprintf(fp, "\t%-15s ", zfs_prop_to_name(prop));

	if (zfs_prop_readonly(prop))
	(void) fprintf(fp, " NO ");
	else
	(void) fprintf(fp, "YES ");

	if (zfs_prop_inheritable(prop))
	(void) fprintf(fp, " YES ");
	else
	(void) fprintf(fp, " NO ");

	if (zfs_prop_values(prop) == NULL)
	(void) fprintf(fp, "-\n");
	else
	(void) fprintf(fp, "%s\n", zfs_prop_values(prop));

	return (ZPROP_CONT);
	}

	/*
	* Display usage message. If we're inside a command, display only the usage for
	* that command. Otherwise, iterate over the entire command table and display
	* a complete usage message.
	*/
	static void
	usage(boolean_t requested)
	{
	int i;
	boolean_t show_properties = B_FALSE;
	FILE *fp = requested ? stdout : stderr;

	if (current_command == NULL) {

	(void) fprintf(fp, gettext("usage: zfs command args ...\n"));
	(void) fprintf(fp,
	gettext("where 'command' is one of the following:\n\n"));

	for (i = 0; i < NCOMMAND; i++) {
	if (command_table[i].name == NULL)
	(void) fprintf(fp, "\n");
	else
	(void) fprintf(fp, "%s",
	get_usage(command_table[i].usage));
	}

	(void) fprintf(fp, gettext("\nEach dataset is of the form: "
	"pool/[dataset/]*dataset[@name]\n"));
	} else {
	(void) fprintf(fp, gettext("usage:\n"));
	(void) fprintf(fp, "%s", get_usage(current_command->usage));
	}

	if (current_command != NULL &&
	(strcmp(current_command->name, "set") == 0 \|\|
	strcmp(current_command->name, "get") == 0 \|\|
	strcmp(current_command->name, "inherit") == 0 \|\|
	strcmp(current_command->name, "list") == 0))
	show_properties = B_TRUE;

	if (show_properties) {
	(void) fprintf(fp,
	gettext("\nThe following properties are supported:\n"));

	(void) fprintf(fp, "\n\t%-14s %s %s %s\n\n",
	"PROPERTY", "EDIT", "INHERIT", "VALUES");

	/* Iterate over all properties */
	(void) zprop_iter(usage_prop_cb, fp, B_FALSE, B_TRUE,
	ZFS_TYPE_DATASET);

	(void) fprintf(fp, "\t%-15s ", "userused@...");
	(void) fprintf(fp, " NO NO <size>\n");
	(void) fprintf(fp, "\t%-15s ", "groupused@...");
	(void) fprintf(fp, " NO NO <size>\n");
	(void) fprintf(fp, "\t%-15s ", "projectused@...");
	(void) fprintf(fp, " NO NO <size>\n");
	(void) fprintf(fp, "\t%-15s ", "userobjused@...");
	(void) fprintf(fp, " NO NO <size>\n");
	(void) fprintf(fp, "\t%-15s ", "groupobjused@...");
	(void) fprintf(fp, " NO NO <size>\n");
	(void) fprintf(fp, "\t%-15s ", "projectobjused@...");
	(void) fprintf(fp, " NO NO <size>\n");
	(void) fprintf(fp, "\t%-15s ", "userquota@...");
	(void) fprintf(fp, "YES NO <size> \| none\n");
	(void) fprintf(fp, "\t%-15s ", "groupquota@...");
	(void) fprintf(fp, "YES NO <size> \| none\n");
	(void) fprintf(fp, "\t%-15s ", "projectquota@...");
	(void) fprintf(fp, "YES NO <size> \| none\n");
	(void) fprintf(fp, "\t%-15s ", "userobjquota@...");
	(void) fprintf(fp, "YES NO <size> \| none\n");
	(void) fprintf(fp, "\t%-15s ", "groupobjquota@...");
	(void) fprintf(fp, "YES NO <size> \| none\n");
	(void) fprintf(fp, "\t%-15s ", "projectobjquota@...");
	(void) fprintf(fp, "YES NO <size> \| none\n");
	(void) fprintf(fp, "\t%-15s ", "written@<snap>");
	(void) fprintf(fp, " NO NO <size>\n");
	(void) fprintf(fp, "\t%-15s ", "written#<bookmark>");
	(void) fprintf(fp, " NO NO <size>\n");

	(void) fprintf(fp, gettext("\nSizes are specified in bytes "
	"with standard units such as K, M, G, etc.\n"));
	(void) fprintf(fp, gettext("\nUser-defined properties can "
	"be specified by using a name containing a colon (:).\n"));
	(void) fprintf(fp, gettext("\nThe {user\|group\|project}"
	"[obj]{used\|quota}@ properties must be appended with\n"
	"a user\|group\|project specifier of one of these forms:\n"
	" POSIX name (eg: \"matt\")\n"
	" POSIX id (eg: \"126829\")\n"
	" SMB name@domain (eg: \"matt@sun\")\n"
	" SMB SID (eg: \"S-1-234-567-89\")\n"));
	} else {
	(void) fprintf(fp,
	gettext("\nFor the property list, run: %s\n"),
	"zfs set\|get");
	(void) fprintf(fp,
	gettext("\nFor the delegated permission list, run: %s\n"),
	"zfs allow\|unallow");
	}

	/*
	* See comments at end of main().
	*/
	if (getenv("ZFS_ABORT") != NULL) {
	(void) printf("dumping core by request\n");
	abort();
	}

	exit(requested ? 0 : 2);
	}

	/*
	* Take a property=value argument string and add it to the given nvlist.
	* Modifies the argument inplace.
	*/
	static boolean_t
	parseprop(nvlist_t props, char propname)
	{
	char *propval;

	if ((propval = strchr(propname, '=')) == NULL) {
	(void) fprintf(stderr, gettext("missing "
	"'=' for property=value argument\n"));
	return (B_FALSE);
	}
	*propval = '\0';
	propval++;
	if (nvlist_exists(props, propname)) {
	(void) fprintf(stderr, gettext("property '%s' "
	"specified multiple times\n"), propname);
	return (B_FALSE);
	}
	if (nvlist_add_string(props, propname, propval) != 0)
	nomem();
	return (B_TRUE);
	}

	/*
	* Take a property name argument and add it to the given nvlist.
	* Modifies the argument inplace.
	*/
	static boolean_t
	parsepropname(nvlist_t props, char propname)
	{
	if (strchr(propname, '=') != NULL) {
	(void) fprintf(stderr, gettext("invalid character "
	"'=' in property argument\n"));
	return (B_FALSE);
	}
	if (nvlist_exists(props, propname)) {
	(void) fprintf(stderr, gettext("property '%s' "
	"specified multiple times\n"), propname);
	return (B_FALSE);
	}
	if (nvlist_add_boolean(props, propname) != 0)
	nomem();
	return (B_TRUE);
	}

	static int
	parse_depth(char opt, int flags)
	{
	char *tmp;
	int depth;

	depth = (int)strtol(opt, &tmp, 0);
	if (*tmp) {
	(void) fprintf(stderr,
	gettext("%s is not an integer\n"), optarg);
	usage(B_FALSE);
	}
	if (depth < 0) {
	(void) fprintf(stderr,
	gettext("Depth can not be negative.\n"));
	usage(B_FALSE);
	}
	*flags \|= (ZFS_ITER_DEPTH_LIMIT\|ZFS_ITER_RECURSE);
	return (depth);
	}

	#define PROGRESS_DELAY 2 /* seconds */

	static char *pt_reverse = "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b";
	static time_t pt_begin;
	static char *pt_header = NULL;
	static boolean_t pt_shown;

	static void
	start_progress_timer(void)
	{
	pt_begin = time(NULL) + PROGRESS_DELAY;
	pt_shown = B_FALSE;
	}

	static void
	set_progress_header(char *header)
	{
	assert(pt_header == NULL);
	pt_header = safe_strdup(header);
	if (pt_shown) {
	(void) printf("%s: ", header);
	(void) fflush(stdout);
	}
	}

	static void
	update_progress(char *update)
	{
	if (!pt_shown && time(NULL) > pt_begin) {
	int len = strlen(update);

	(void) printf("%s: %s%.s", pt_header, update, len, len,
	pt_reverse);
	(void) fflush(stdout);
	pt_shown = B_TRUE;
	} else if (pt_shown) {
	int len = strlen(update);

	(void) printf("%s%.s", update, len, len, pt_reverse);
	(void) fflush(stdout);
	}
	}

	static void
	finish_progress(char *done)
	{
	if (pt_shown) {
	(void) printf("%s\n", done);
	(void) fflush(stdout);
	}
	free(pt_header);
	pt_header = NULL;
	}

	static int
	zfs_mount_and_share(libzfs_handle_t hdl, const char dataset, zfs_type_t type)
	{
	zfs_handle_t *zhp = NULL;
	int ret = 0;

	zhp = zfs_open(hdl, dataset, type);
	if (zhp == NULL)
	return (1);

	/*
	* Volumes may neither be mounted or shared. Potentially in the
	* future filesystems detected on these volumes could be mounted.
	*/
	if (zfs_get_type(zhp) == ZFS_TYPE_VOLUME) {
	zfs_close(zhp);
	return (0);
	}

	/*
	* Mount and/or share the new filesystem as appropriate. We provide a
	* verbose error message to let the user know that their filesystem was
	* in fact created, even if we failed to mount or share it.
	*
	* If the user doesn't want the dataset automatically mounted, then
	* skip the mount/share step
	*/
	if (zfs_prop_valid_for_type(ZFS_PROP_CANMOUNT, type, B_FALSE) &&
	zfs_prop_get_int(zhp, ZFS_PROP_CANMOUNT) == ZFS_CANMOUNT_ON) {
	if (zfs_mount_delegation_check()) {
	(void) fprintf(stderr, gettext("filesystem "
	"successfully created, but it may only be "
	"mounted by root\n"));
	ret = 1;
	} else if (zfs_mount(zhp, NULL, 0) != 0) {
	(void) fprintf(stderr, gettext("filesystem "
	"successfully created, but not mounted\n"));
	ret = 1;
	} else if (zfs_share(zhp) != 0) {
	(void) fprintf(stderr, gettext("filesystem "
	"successfully created, but not shared\n"));
	ret = 1;
	}
	zfs_commit_all_shares();
	}

	zfs_close(zhp);

	return (ret);
	}

	/*
	* zfs clone [-p] [-o prop=value] ... <snap> <fs \| vol>
	*
	* Given an existing dataset, create a writable copy whose initial contents
	* are the same as the source. The newly created dataset maintains a
	* dependency on the original; the original cannot be destroyed so long as
	* the clone exists.
	*
	* The '-p' flag creates all the non-existing ancestors of the target first.
	*/
	static int
	zfs_do_clone(int argc, char **argv)
	{
	zfs_handle_t *zhp = NULL;
	boolean_t parents = B_FALSE;
	nvlist_t *props;
	int ret = 0;
	int c;

	if (nvlist_alloc(&props, NV_UNIQUE_NAME, 0) != 0)
	nomem();

	/* check options */
	while ((c = getopt(argc, argv, "o:p")) != -1) {
	switch (c) {
	case 'o':
	if (!parseprop(props, optarg)) {
	nvlist_free(props);
	return (1);
	}
	break;
	case 'p':
	parents = B_TRUE;
	break;
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	goto usage;
	}
	}

	argc -= optind;
	argv += optind;

	/* check number of arguments */
	if (argc < 1) {
	(void) fprintf(stderr, gettext("missing source dataset "
	"argument\n"));
	goto usage;
	}
	if (argc < 2) {
	(void) fprintf(stderr, gettext("missing target dataset "
	"argument\n"));
	goto usage;
	}
	if (argc > 2) {
	(void) fprintf(stderr, gettext("too many arguments\n"));
	goto usage;
	}

	/* open the source dataset */
	if ((zhp = zfs_open(g_zfs, argv[0], ZFS_TYPE_SNAPSHOT)) == NULL) {
	nvlist_free(props);
	return (1);
	}

	if (parents && zfs_name_valid(argv[1], ZFS_TYPE_FILESYSTEM \|
	ZFS_TYPE_VOLUME)) {
	/*
	* Now create the ancestors of the target dataset. If the
	* target already exists and '-p' option was used we should not
	* complain.
	*/
	if (zfs_dataset_exists(g_zfs, argv[1], ZFS_TYPE_FILESYSTEM \|
	ZFS_TYPE_VOLUME)) {
	zfs_close(zhp);
	nvlist_free(props);
	return (0);
	}
	if (zfs_create_ancestors(g_zfs, argv[1]) != 0) {
	zfs_close(zhp);
	nvlist_free(props);
	return (1);
	}
	}

	/* pass to libzfs */
	ret = zfs_clone(zhp, argv[1], props);

	/* create the mountpoint if necessary */
	if (ret == 0) {
	if (log_history) {
	(void) zpool_log_history(g_zfs, history_str);
	log_history = B_FALSE;
	}

	ret = zfs_mount_and_share(g_zfs, argv[1], ZFS_TYPE_DATASET);
	}

	zfs_close(zhp);
	nvlist_free(props);

	return (!!ret);

	usage:
	ASSERT3P(zhp, ==, NULL);
	nvlist_free(props);
	usage(B_FALSE);
	return (-1);
	}

	/*
	* Return a default volblocksize for the pool which always uses more than
	* half of the data sectors. This primarily applies to dRAID which always
	* writes full stripe widths.
	*/
	static uint64_t
	default_volblocksize(zpool_handle_t zhp, nvlist_t props)
	{
	uint64_t volblocksize, asize = SPA_MINBLOCKSIZE;
	nvlist_t tree, *vdevs;
	uint_t nvdevs;

	nvlist_t *config = zpool_get_config(zhp, NULL);

	if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, &tree) != 0 \|\|
	nvlist_lookup_nvlist_array(tree, ZPOOL_CONFIG_CHILDREN,
	&vdevs, &nvdevs) != 0) {
	return (ZVOL_DEFAULT_BLOCKSIZE);
	}

	for (int i = 0; i < nvdevs; i++) {
	nvlist_t *nv = vdevs[i];
	uint64_t ashift, ndata, nparity;

	if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_ASHIFT, &ashift) != 0)
	continue;

	if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_DRAID_NDATA,
	&ndata) == 0) {
	/* dRAID minimum allocation width */
	asize = MAX(asize, ndata * (1ULL << ashift));
	} else if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_NPARITY,
	&nparity) == 0) {
	/* raidz minimum allocation width */
	if (nparity == 1)
	asize = MAX(asize, 2 * (1ULL << ashift));
	else
	asize = MAX(asize, 4 * (1ULL << ashift));
	} else {
	/* mirror or (non-redundant) leaf vdev */
	asize = MAX(asize, 1ULL << ashift);
	}
	}

	/*
	* Calculate the target volblocksize such that more than half
	* of the asize is used. The following table is for 4k sectors.
	*
	* n asize blksz used \| n asize blksz used
	* -------------------------+---------------------------------
	* 1 4,096 8,192 100% \| 9 36,864 32,768 88%
	* 2 8,192 8,192 100% \| 10 40,960 32,768 80%
	* 3 12,288 8,192 66% \| 11 45,056 32,768 72%
	* 4 16,384 16,384 100% \| 12 49,152 32,768 66%
	* 5 20,480 16,384 80% \| 13 53,248 32,768 61%
	* 6 24,576 16,384 66% \| 14 57,344 32,768 57%
	* 7 28,672 16,384 57% \| 15 61,440 32,768 53%
	* 8 32,768 32,768 100% \| 16 65,536 65,636 100%
	*
	* This is primarily a concern for dRAID which always allocates
	* a full stripe width. For dRAID the default stripe width is
	* n=8 in which case the volblocksize is set to 32k. Ignoring
	* compression there are no unused sectors. This same reasoning
	* applies to raidz[2,3] so target 4 sectors to minimize waste.
	*/
	uint64_t tgt_volblocksize = ZVOL_DEFAULT_BLOCKSIZE;
	while (tgt_volblocksize * 2 <= asize)
	tgt_volblocksize *= 2;

	const char *prop = zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE);
	if (nvlist_lookup_uint64(props, prop, &volblocksize) == 0) {

	/* Issue a warning when a non-optimal size is requested. */
	if (volblocksize < ZVOL_DEFAULT_BLOCKSIZE) {
	(void) fprintf(stderr, gettext("Warning: "
	"volblocksize (%llu) is less than the default "
	"minimum block size (%llu).\nTo reduce wasted "
	"space a volblocksize of %llu is recommended.\n"),
	(u_longlong_t)volblocksize,
	(u_longlong_t)ZVOL_DEFAULT_BLOCKSIZE,
	(u_longlong_t)tgt_volblocksize);
	} else if (volblocksize < tgt_volblocksize) {
	(void) fprintf(stderr, gettext("Warning: "
	"volblocksize (%llu) is much less than the "
	"minimum allocation\nunit (%llu), which wastes "
	"at least %llu%% of space. To reduce wasted "
	"space,\nuse a larger volblocksize (%llu is "
	"recommended), fewer dRAID data disks\n"
	"per group, or smaller sector size (ashift).\n"),
	(u_longlong_t)volblocksize, (u_longlong_t)asize,
	(u_longlong_t)((100 * (asize - volblocksize)) /
	asize), (u_longlong_t)tgt_volblocksize);
	}
	} else {
	volblocksize = tgt_volblocksize;
	fnvlist_add_uint64(props, prop, volblocksize);
	}

	return (volblocksize);
	}

	/*
	* zfs create [-Pnpv] [-o prop=value] ... fs
	* zfs create [-Pnpsv] [-b blocksize] [-o prop=value] ... -V vol size
	*
	* Create a new dataset. This command can be used to create filesystems
	* and volumes. Snapshot creation is handled by 'zfs snapshot'.
	* For volumes, the user must specify a size to be used.
	*
	* The '-s' flag applies only to volumes, and indicates that we should not try
	* to set the reservation for this volume. By default we set a reservation
	* equal to the size for any volume. For pools with SPA_VERSION >=
	* SPA_VERSION_REFRESERVATION, we set a refreservation instead.
	*
	* The '-p' flag creates all the non-existing ancestors of the target first.
	*
	* The '-n' flag is no-op (dry run) mode. This will perform a user-space sanity
	* check of arguments and properties, but does not check for permissions,
	* available space, etc.
	*
	* The '-u' flag prevents the newly created file system from being mounted.
	*
	* The '-v' flag is for verbose output.
	*
	* The '-P' flag is used for parseable output. It implies '-v'.
	*/
	static int
	zfs_do_create(int argc, char **argv)
	{
	zfs_type_t type = ZFS_TYPE_FILESYSTEM;
	zpool_handle_t *zpool_handle = NULL;
	nvlist_t *real_props = NULL;
	uint64_t volsize = 0;
	int c;
	boolean_t noreserve = B_FALSE;
	boolean_t bflag = B_FALSE;
	boolean_t parents = B_FALSE;
	boolean_t dryrun = B_FALSE;
	boolean_t nomount = B_FALSE;
	boolean_t verbose = B_FALSE;
	boolean_t parseable = B_FALSE;
	int ret = 1;
	nvlist_t *props;
	uint64_t intval;
	char *strval;

	if (nvlist_alloc(&props, NV_UNIQUE_NAME, 0) != 0)
	nomem();

	/* check options */
	while ((c = getopt(argc, argv, ":PV:b:nso:puv")) != -1) {
	switch (c) {
	case 'V':
	type = ZFS_TYPE_VOLUME;
	if (zfs_nicestrtonum(g_zfs, optarg, &intval) != 0) {
	(void) fprintf(stderr, gettext("bad volume "
	"size '%s': %s\n"), optarg,
	libzfs_error_description(g_zfs));
	goto error;
	}

	if (nvlist_add_uint64(props,
	zfs_prop_to_name(ZFS_PROP_VOLSIZE), intval) != 0)
	nomem();
	volsize = intval;
	break;
	case 'P':
	verbose = B_TRUE;
	parseable = B_TRUE;
	break;
	case 'p':
	parents = B_TRUE;
	break;
	case 'b':
	bflag = B_TRUE;
	if (zfs_nicestrtonum(g_zfs, optarg, &intval) != 0) {
	(void) fprintf(stderr, gettext("bad volume "
	"block size '%s': %s\n"), optarg,
	libzfs_error_description(g_zfs));
	goto error;
	}

	if (nvlist_add_uint64(props,
	zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE),
	intval) != 0)
	nomem();
	break;
	case 'n':
	dryrun = B_TRUE;
	break;
	case 'o':
	if (!parseprop(props, optarg))
	goto error;
	break;
	case 's':
	noreserve = B_TRUE;
	break;
	case 'u':
	nomount = B_TRUE;
	break;
	case 'v':
	verbose = B_TRUE;
	break;
	case ':':
	(void) fprintf(stderr, gettext("missing size "
	"argument\n"));
	goto badusage;
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	goto badusage;
	}
	}

	if ((bflag \|\| noreserve) && type != ZFS_TYPE_VOLUME) {
	(void) fprintf(stderr, gettext("'-s' and '-b' can only be "
	"used when creating a volume\n"));
	goto badusage;
	}
	if (nomount && type != ZFS_TYPE_FILESYSTEM) {
	(void) fprintf(stderr, gettext("'-u' can only be "
	"used when creating a filesystem\n"));
	goto badusage;
	}

	argc -= optind;
	argv += optind;

	/* check number of arguments */
	if (argc == 0) {
	(void) fprintf(stderr, gettext("missing %s argument\n"),
	zfs_type_to_name(type));
	goto badusage;
	}
	if (argc > 1) {
	(void) fprintf(stderr, gettext("too many arguments\n"));
	goto badusage;
	}

	if (dryrun \|\| type == ZFS_TYPE_VOLUME) {
	char msg[ZFS_MAX_DATASET_NAME_LEN * 2];
	char *p;

	if ((p = strchr(argv[0], '/')) != NULL)
	*p = '\0';
	zpool_handle = zpool_open(g_zfs, argv[0]);
	if (p != NULL)
	*p = '/';
	if (zpool_handle == NULL)
	goto error;

	(void) snprintf(msg, sizeof (msg),
	dryrun ? gettext("cannot verify '%s'") :
	gettext("cannot create '%s'"), argv[0]);
	if (props && (real_props = zfs_valid_proplist(g_zfs, type,
	props, 0, NULL, zpool_handle, B_TRUE, msg)) == NULL) {
	zpool_close(zpool_handle);
	goto error;
	}
	}

	if (type == ZFS_TYPE_VOLUME) {
	const char *prop = zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE);
	uint64_t volblocksize = default_volblocksize(zpool_handle,
	real_props);

	if (volblocksize != ZVOL_DEFAULT_BLOCKSIZE &&
	nvlist_lookup_string(props, prop, &strval) != 0) {
	if (asprintf(&strval, "%llu",
	(u_longlong_t)volblocksize) == -1)
	nomem();
	nvlist_add_string(props, prop, strval);
	free(strval);
	}

	/*
	* If volsize is not a multiple of volblocksize, round it
	* up to the nearest multiple of the volblocksize.
	*/
	if (volsize % volblocksize) {
	volsize = P2ROUNDUP_TYPED(volsize, volblocksize,
	uint64_t);

	if (nvlist_add_uint64(props,
	zfs_prop_to_name(ZFS_PROP_VOLSIZE), volsize) != 0) {
	nvlist_free(props);
	nomem();
	}
	}
	}

	if (type == ZFS_TYPE_VOLUME && !noreserve) {
	uint64_t spa_version;
	zfs_prop_t resv_prop;

	spa_version = zpool_get_prop_int(zpool_handle,
	ZPOOL_PROP_VERSION, NULL);
	if (spa_version >= SPA_VERSION_REFRESERVATION)
	resv_prop = ZFS_PROP_REFRESERVATION;
	else
	resv_prop = ZFS_PROP_RESERVATION;

	volsize = zvol_volsize_to_reservation(zpool_handle, volsize,
	real_props);

	if (nvlist_lookup_string(props, zfs_prop_to_name(resv_prop),
	&strval) != 0) {
	if (nvlist_add_uint64(props,
	zfs_prop_to_name(resv_prop), volsize) != 0) {
	nvlist_free(props);
	nomem();
	}
	}
	}
	if (zpool_handle != NULL) {
	zpool_close(zpool_handle);
	nvlist_free(real_props);
	}

	if (parents && zfs_name_valid(argv[0], type)) {
	/*
	* Now create the ancestors of target dataset. If the target
	* already exists and '-p' option was used we should not
	* complain.
	*/
	if (zfs_dataset_exists(g_zfs, argv[0], type)) {
	ret = 0;
	goto error;
	}
	if (verbose) {
	(void) printf(parseable ? "create_ancestors\t%s\n" :
	dryrun ? "would create ancestors of %s\n" :
	"create ancestors of %s\n", argv[0]);
	}
	if (!dryrun) {
	if (zfs_create_ancestors(g_zfs, argv[0]) != 0) {
	goto error;
	}
	}
	}

	if (verbose) {
	nvpair_t *nvp = NULL;
	(void) printf(parseable ? "create\t%s\n" :
	dryrun ? "would create %s\n" : "create %s\n", argv[0]);
	while ((nvp = nvlist_next_nvpair(props, nvp)) != NULL) {
	uint64_t uval;
	char *sval;

	switch (nvpair_type(nvp)) {
	case DATA_TYPE_UINT64:
	VERIFY0(nvpair_value_uint64(nvp, &uval));
	(void) printf(parseable ?
	"property\t%s\t%llu\n" : "\t%s=%llu\n",
	nvpair_name(nvp), (u_longlong_t)uval);
	break;
	case DATA_TYPE_STRING:
	VERIFY0(nvpair_value_string(nvp, &sval));
	(void) printf(parseable ?
	"property\t%s\t%s\n" : "\t%s=%s\n",
	nvpair_name(nvp), sval);
	break;
	default:
	(void) fprintf(stderr, "property '%s' "
	"has illegal type %d\n",
	nvpair_name(nvp), nvpair_type(nvp));
	abort();
	}
	}
	}
	if (dryrun) {
	ret = 0;
	goto error;
	}

	/* pass to libzfs */
	if (zfs_create(g_zfs, argv[0], type, props) != 0)
	goto error;

	if (log_history) {
	(void) zpool_log_history(g_zfs, history_str);
	log_history = B_FALSE;
	}

	if (nomount) {
	ret = 0;
	goto error;
	}

	ret = zfs_mount_and_share(g_zfs, argv[0], ZFS_TYPE_DATASET);
	error:
	nvlist_free(props);
	return (ret);
	badusage:
	nvlist_free(props);
	usage(B_FALSE);
	return (2);
	}

	/*
	* zfs destroy [-rRf] <fs, vol>
	* zfs destroy [-rRd] <snap>
	*
	* -r Recursively destroy all children
	* -R Recursively destroy all dependents, including clones
	* -f Force unmounting of any dependents
	* -d If we can't destroy now, mark for deferred destruction
	*
	* Destroys the given dataset. By default, it will unmount any filesystems,
	* and refuse to destroy a dataset that has any dependents. A dependent can
	* either be a child, or a clone of a child.
	*/
	typedef struct destroy_cbdata {
	boolean_t cb_first;
	boolean_t cb_force;
	boolean_t cb_recurse;
	boolean_t cb_error;
	boolean_t cb_doclones;
	zfs_handle_t *cb_target;
	boolean_t cb_defer_destroy;
	boolean_t cb_verbose;
	boolean_t cb_parsable;
	boolean_t cb_dryrun;
	nvlist_t *cb_nvl;
	nvlist_t *cb_batchedsnaps;

	/* first snap in contiguous run */
	char *cb_firstsnap;
	/* previous snap in contiguous run */
	char *cb_prevsnap;
	int64_t cb_snapused;
	char *cb_snapspec;
	char *cb_bookmark;
	uint64_t cb_snap_count;
	} destroy_cbdata_t;

	/*
	* Check for any dependents based on the '-r' or '-R' flags.
	*/
	static int
	destroy_check_dependent(zfs_handle_t zhp, void data)
	{
	destroy_cbdata_t *cbp = data;
	const char *tname = zfs_get_name(cbp->cb_target);
	const char *name = zfs_get_name(zhp);

	if (strncmp(tname, name, strlen(tname)) == 0 &&
	(name[strlen(tname)] == '/' \|\| name[strlen(tname)] == '@')) {
	/*
	* This is a direct descendant, not a clone somewhere else in
	* the hierarchy.
	*/
	if (cbp->cb_recurse)
	goto out;

	if (cbp->cb_first) {
	(void) fprintf(stderr, gettext("cannot destroy '%s': "
	"%s has children\n"),
	zfs_get_name(cbp->cb_target),
	zfs_type_to_name(zfs_get_type(cbp->cb_target)));
	(void) fprintf(stderr, gettext("use '-r' to destroy "
	"the following datasets:\n"));
	cbp->cb_first = B_FALSE;
	cbp->cb_error = B_TRUE;
	}

	(void) fprintf(stderr, "%s\n", zfs_get_name(zhp));
	} else {
	/*
	* This is a clone. We only want to report this if the '-r'
	* wasn't specified, or the target is a snapshot.
	*/
	if (!cbp->cb_recurse &&
	zfs_get_type(cbp->cb_target) != ZFS_TYPE_SNAPSHOT)
	goto out;

	if (cbp->cb_first) {
	(void) fprintf(stderr, gettext("cannot destroy '%s': "
	"%s has dependent clones\n"),
	zfs_get_name(cbp->cb_target),
	zfs_type_to_name(zfs_get_type(cbp->cb_target)));
	(void) fprintf(stderr, gettext("use '-R' to destroy "
	"the following datasets:\n"));
	cbp->cb_first = B_FALSE;
	cbp->cb_error = B_TRUE;
	cbp->cb_dryrun = B_TRUE;
	}

	(void) fprintf(stderr, "%s\n", zfs_get_name(zhp));
	}

	out:
	zfs_close(zhp);
	return (0);
	}

	static int
	destroy_batched(destroy_cbdata_t *cb)
	{
	int error = zfs_destroy_snaps_nvl(g_zfs,
	cb->cb_batchedsnaps, B_FALSE);
	fnvlist_free(cb->cb_batchedsnaps);
	cb->cb_batchedsnaps = fnvlist_alloc();
	return (error);
	}

	static int
	destroy_callback(zfs_handle_t zhp, void data)
	{
	destroy_cbdata_t *cb = data;
	const char *name = zfs_get_name(zhp);
	int error;

	if (cb->cb_verbose) {
	if (cb->cb_parsable) {
	(void) printf("destroy\t%s\n", name);
	} else if (cb->cb_dryrun) {
	(void) printf(gettext("would destroy %s\n"),
	name);
	} else {
	(void) printf(gettext("will destroy %s\n"),
	name);
	}
	}

	/*
	* Ignore pools (which we've already flagged as an error before getting
	* here).
	*/
	if (strchr(zfs_get_name(zhp), '/') == NULL &&
	zfs_get_type(zhp) == ZFS_TYPE_FILESYSTEM) {
	zfs_close(zhp);
	return (0);
	}
	if (cb->cb_dryrun) {
	zfs_close(zhp);
	return (0);
	}

	/*
	* We batch up all contiguous snapshots (even of different
	* filesystems) and destroy them with one ioctl. We can't
	* simply do all snap deletions and then all fs deletions,
	* because we must delete a clone before its origin.
	*/
	if (zfs_get_type(zhp) == ZFS_TYPE_SNAPSHOT) {
	cb->cb_snap_count++;
	fnvlist_add_boolean(cb->cb_batchedsnaps, name);
	if (cb->cb_snap_count % 10 == 0 && cb->cb_defer_destroy)
	error = destroy_batched(cb);
	} else {
	error = destroy_batched(cb);
	if (error != 0 \|\|
	zfs_unmount(zhp, NULL, cb->cb_force ? MS_FORCE : 0) != 0 \|\|
	zfs_destroy(zhp, cb->cb_defer_destroy) != 0) {
	zfs_close(zhp);
	/*
	* When performing a recursive destroy we ignore errors
	* so that the recursive destroy could continue
	* destroying past problem datasets
	*/
	if (cb->cb_recurse) {
	cb->cb_error = B_TRUE;
	return (0);
	}
	return (-1);
	}
	}

	zfs_close(zhp);
	return (0);
	}

	static int
	destroy_print_cb(zfs_handle_t zhp, void arg)
	{
	destroy_cbdata_t *cb = arg;
	const char *name = zfs_get_name(zhp);
	int err = 0;

	if (nvlist_exists(cb->cb_nvl, name)) {
	if (cb->cb_firstsnap == NULL)
	cb->cb_firstsnap = strdup(name);
	if (cb->cb_prevsnap != NULL)
	free(cb->cb_prevsnap);
	/* this snap continues the current range */
	cb->cb_prevsnap = strdup(name);
	if (cb->cb_firstsnap == NULL \|\| cb->cb_prevsnap == NULL)
	nomem();
	if (cb->cb_verbose) {
	if (cb->cb_parsable) {
	(void) printf("destroy\t%s\n", name);
	} else if (cb->cb_dryrun) {
	(void) printf(gettext("would destroy %s\n"),
	name);
	} else {
	(void) printf(gettext("will destroy %s\n"),
	name);
	}
	}
	} else if (cb->cb_firstsnap != NULL) {
	/* end of this range */
	uint64_t used = 0;
	err = lzc_snaprange_space(cb->cb_firstsnap,
	cb->cb_prevsnap, &used);
	cb->cb_snapused += used;
	free(cb->cb_firstsnap);
	cb->cb_firstsnap = NULL;
	free(cb->cb_prevsnap);
	cb->cb_prevsnap = NULL;
	}
	zfs_close(zhp);
	return (err);
	}

	static int
	destroy_print_snapshots(zfs_handle_t fs_zhp, destroy_cbdata_t cb)
	{
	int err;
	assert(cb->cb_firstsnap == NULL);
	assert(cb->cb_prevsnap == NULL);
	err = zfs_iter_snapshots_sorted(fs_zhp, destroy_print_cb, cb, 0, 0);
	if (cb->cb_firstsnap != NULL) {
	uint64_t used = 0;
	if (err == 0) {
	err = lzc_snaprange_space(cb->cb_firstsnap,
	cb->cb_prevsnap, &used);
	}
	cb->cb_snapused += used;
	free(cb->cb_firstsnap);
	cb->cb_firstsnap = NULL;
	free(cb->cb_prevsnap);
	cb->cb_prevsnap = NULL;
	}
	return (err);
	}

	static int
	snapshot_to_nvl_cb(zfs_handle_t zhp, void arg)
	{
	destroy_cbdata_t *cb = arg;
	int err = 0;

	/* Check for clones. */
	if (!cb->cb_doclones && !cb->cb_defer_destroy) {
	cb->cb_target = zhp;
	cb->cb_first = B_TRUE;
	err = zfs_iter_dependents(zhp, B_TRUE,
	destroy_check_dependent, cb);
	}

	if (err == 0) {
	if (nvlist_add_boolean(cb->cb_nvl, zfs_get_name(zhp)))
	nomem();
	}
	zfs_close(zhp);
	return (err);
	}

	static int
	gather_snapshots(zfs_handle_t zhp, void arg)
	{
	destroy_cbdata_t *cb = arg;
	int err = 0;

	err = zfs_iter_snapspec(zhp, cb->cb_snapspec, snapshot_to_nvl_cb, cb);
	if (err == ENOENT)
	err = 0;
	if (err != 0)
	goto out;

	if (cb->cb_verbose) {
	err = destroy_print_snapshots(zhp, cb);
	if (err != 0)
	goto out;
	}

	if (cb->cb_recurse)
	err = zfs_iter_filesystems(zhp, gather_snapshots, cb);

	out:
	zfs_close(zhp);
	return (err);
	}

	static int
	destroy_clones(destroy_cbdata_t *cb)
	{
	nvpair_t *pair;
	for (pair = nvlist_next_nvpair(cb->cb_nvl, NULL);
	pair != NULL;
	pair = nvlist_next_nvpair(cb->cb_nvl, pair)) {
	zfs_handle_t *zhp = zfs_open(g_zfs, nvpair_name(pair),
	ZFS_TYPE_SNAPSHOT);
	if (zhp != NULL) {
	boolean_t defer = cb->cb_defer_destroy;
	int err;

	/*
	* We can't defer destroy non-snapshots, so set it to
	* false while destroying the clones.
	*/
	cb->cb_defer_destroy = B_FALSE;
	err = zfs_iter_dependents(zhp, B_FALSE,
	destroy_callback, cb);
	cb->cb_defer_destroy = defer;
	zfs_close(zhp);
	if (err != 0)
	return (err);
	}
	}
	return (0);
	}

	static int
	zfs_do_destroy(int argc, char **argv)
	{
	destroy_cbdata_t cb = { 0 };
	int rv = 0;
	int err = 0;
	int c;
	zfs_handle_t *zhp = NULL;
	char at, pound;
	zfs_type_t type = ZFS_TYPE_DATASET;

	/* check options */
	while ((c = getopt(argc, argv, "vpndfrR")) != -1) {
	switch (c) {
	case 'v':
	cb.cb_verbose = B_TRUE;
	break;
	case 'p':
	cb.cb_verbose = B_TRUE;
	cb.cb_parsable = B_TRUE;
	break;
	case 'n':
	cb.cb_dryrun = B_TRUE;
	break;
	case 'd':
	cb.cb_defer_destroy = B_TRUE;
	type = ZFS_TYPE_SNAPSHOT;
	break;
	case 'f':
	cb.cb_force = B_TRUE;
	break;
	case 'r':
	cb.cb_recurse = B_TRUE;
	break;
	case 'R':
	cb.cb_recurse = B_TRUE;
	cb.cb_doclones = B_TRUE;
	break;
	case '?':
	default:
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	argc -= optind;
	argv += optind;

	/* check number of arguments */
	if (argc == 0) {
	(void) fprintf(stderr, gettext("missing dataset argument\n"));
	usage(B_FALSE);
	}
	if (argc > 1) {
	(void) fprintf(stderr, gettext("too many arguments\n"));
	usage(B_FALSE);
	}

	at = strchr(argv[0], '@');
	pound = strchr(argv[0], '#');
	if (at != NULL) {

	/* Build the list of snaps to destroy in cb_nvl. */
	cb.cb_nvl = fnvlist_alloc();

	*at = '\0';
	zhp = zfs_open(g_zfs, argv[0],
	ZFS_TYPE_FILESYSTEM \| ZFS_TYPE_VOLUME);
	if (zhp == NULL) {
	nvlist_free(cb.cb_nvl);
	return (1);
	}

	cb.cb_snapspec = at + 1;
	if (gather_snapshots(zfs_handle_dup(zhp), &cb) != 0 \|\|
	cb.cb_error) {
	rv = 1;
	goto out;
	}

	if (nvlist_empty(cb.cb_nvl)) {
	(void) fprintf(stderr, gettext("could not find any "
	"snapshots to destroy; check snapshot names.\n"));
	rv = 1;
	goto out;
	}

	if (cb.cb_verbose) {
	char buf[16];
	zfs_nicebytes(cb.cb_snapused, buf, sizeof (buf));
	if (cb.cb_parsable) {
	(void) printf("reclaim\t%llu\n",
	(u_longlong_t)cb.cb_snapused);
	} else if (cb.cb_dryrun) {
	(void) printf(gettext("would reclaim %s\n"),
	buf);
	} else {
	(void) printf(gettext("will reclaim %s\n"),
	buf);
	}
	}

	if (!cb.cb_dryrun) {
	if (cb.cb_doclones) {
	cb.cb_batchedsnaps = fnvlist_alloc();
	err = destroy_clones(&cb);
	if (err == 0) {
	err = zfs_destroy_snaps_nvl(g_zfs,
	cb.cb_batchedsnaps, B_FALSE);
	}
	if (err != 0) {
	rv = 1;
	goto out;
	}
	}
	if (err == 0) {
	err = zfs_destroy_snaps_nvl(g_zfs, cb.cb_nvl,
	cb.cb_defer_destroy);
	}
	}

	if (err != 0)
	rv = 1;
	} else if (pound != NULL) {
	int err;
	nvlist_t *nvl;

	if (cb.cb_dryrun) {
	(void) fprintf(stderr,
	"dryrun is not supported with bookmark\n");
	return (-1);
	}

	if (cb.cb_defer_destroy) {
	(void) fprintf(stderr,
	"defer destroy is not supported with bookmark\n");
	return (-1);
	}

	if (cb.cb_recurse) {
	(void) fprintf(stderr,
	"recursive is not supported with bookmark\n");
	return (-1);
	}

	/*
	* Unfortunately, zfs_bookmark() doesn't honor the
	* casesensitivity setting. However, we can't simply
	* remove this check, because lzc_destroy_bookmarks()
	* ignores non-existent bookmarks, so this is necessary
	* to get a proper error message.
	*/
	if (!zfs_bookmark_exists(argv[0])) {
	(void) fprintf(stderr, gettext("bookmark '%s' "
	"does not exist.\n"), argv[0]);
	return (1);
	}

	nvl = fnvlist_alloc();
	fnvlist_add_boolean(nvl, argv[0]);

	err = lzc_destroy_bookmarks(nvl, NULL);
	if (err != 0) {
	(void) zfs_standard_error(g_zfs, err,
	"cannot destroy bookmark");
	}

	nvlist_free(nvl);

	return (err);
	} else {
	/* Open the given dataset */
	if ((zhp = zfs_open(g_zfs, argv[0], type)) == NULL)
	return (1);

	cb.cb_target = zhp;

	/*
	* Perform an explicit check for pools before going any further.
	*/
	if (!cb.cb_recurse && strchr(zfs_get_name(zhp), '/') == NULL &&
	zfs_get_type(zhp) == ZFS_TYPE_FILESYSTEM) {
	(void) fprintf(stderr, gettext("cannot destroy '%s': "
	"operation does not apply to pools\n"),
	zfs_get_name(zhp));
	(void) fprintf(stderr, gettext("use 'zfs destroy -r "
	"%s' to destroy all datasets in the pool\n"),
	zfs_get_name(zhp));
	(void) fprintf(stderr, gettext("use 'zpool destroy %s' "
	"to destroy the pool itself\n"), zfs_get_name(zhp));
	rv = 1;
	goto out;
	}

	/*
	* Check for any dependents and/or clones.
	*/
	cb.cb_first = B_TRUE;
	if (!cb.cb_doclones &&
	zfs_iter_dependents(zhp, B_TRUE, destroy_check_dependent,
	&cb) != 0) {
	rv = 1;
	goto out;
	}

	if (cb.cb_error) {
	rv = 1;
	goto out;
	}
	cb.cb_batchedsnaps = fnvlist_alloc();
	if (zfs_iter_dependents(zhp, B_FALSE, destroy_callback,
	&cb) != 0) {
	rv = 1;
	goto out;
	}

	/*
	* Do the real thing. The callback will close the
	* handle regardless of whether it succeeds or not.
	*/
	err = destroy_callback(zhp, &cb);
	zhp = NULL;
	if (err == 0) {
	err = zfs_destroy_snaps_nvl(g_zfs,
	cb.cb_batchedsnaps, cb.cb_defer_destroy);
	}
	if (err != 0 \|\| cb.cb_error == B_TRUE)
	rv = 1;
	}

	out:
	fnvlist_free(cb.cb_batchedsnaps);
	fnvlist_free(cb.cb_nvl);
	if (zhp != NULL)
	zfs_close(zhp);
	return (rv);
	}

	static boolean_t
	is_recvd_column(zprop_get_cbdata_t *cbp)
	{
	int i;
	zfs_get_column_t col;

	for (i = 0; i < ZFS_GET_NCOLS &&
	(col = cbp->cb_columns[i]) != GET_COL_NONE; i++)
	if (col == GET_COL_RECVD)
	return (B_TRUE);
	return (B_FALSE);
	}

	/*
	* zfs get [-rHp] [-o all \| field[,field]...] [-s source[,source]...]
	* < all \| property[,property]... > < fs \| snap \| vol > ...
	*
	* -r recurse over any child datasets
	* -H scripted mode. Headers are stripped, and fields are separated
	* by tabs instead of spaces.
	* -o Set of fields to display. One of "name,property,value,
	* received,source". Default is "name,property,value,source".
	* "all" is an alias for all five.
	* -s Set of sources to allow. One of
	* "local,default,inherited,received,temporary,none". Default is
	* all six.
	* -p Display values in parsable (literal) format.
	*
	* Prints properties for the given datasets. The user can control which
	* columns to display as well as which property types to allow.
	*/

	/*
	* Invoked to display the properties for a single dataset.
	*/
	static int
	get_callback(zfs_handle_t zhp, void data)
	{
	char buf[ZFS_MAXPROPLEN];
	char rbuf[ZFS_MAXPROPLEN];
	zprop_source_t sourcetype;
	char source[ZFS_MAX_DATASET_NAME_LEN];
	zprop_get_cbdata_t *cbp = data;
	nvlist_t *user_props = zfs_get_user_props(zhp);
	zprop_list_t *pl = cbp->cb_proplist;
	nvlist_t *propval;
	char *strval;
	char *sourceval;
	boolean_t received = is_recvd_column(cbp);

	for (; pl != NULL; pl = pl->pl_next) {
	char *recvdval = NULL;
	/*
	* Skip the special fake placeholder. This will also skip over
	* the name property when 'all' is specified.
	*/
	if (pl->pl_prop == ZFS_PROP_NAME &&
	pl == cbp->cb_proplist)
	continue;

	if (pl->pl_prop != ZPROP_INVAL) {
	if (zfs_prop_get(zhp, pl->pl_prop, buf,
	sizeof (buf), &sourcetype, source,
	sizeof (source),
	cbp->cb_literal) != 0) {
	if (pl->pl_all)
	continue;
	if (!zfs_prop_valid_for_type(pl->pl_prop,
	ZFS_TYPE_DATASET, B_FALSE)) {
	(void) fprintf(stderr,
	gettext("No such property '%s'\n"),
	zfs_prop_to_name(pl->pl_prop));
	continue;
	}
	sourcetype = ZPROP_SRC_NONE;
	(void) strlcpy(buf, "-", sizeof (buf));
	}

	if (received && (zfs_prop_get_recvd(zhp,
	zfs_prop_to_name(pl->pl_prop), rbuf, sizeof (rbuf),
	cbp->cb_literal) == 0))
	recvdval = rbuf;

	zprop_print_one_property(zfs_get_name(zhp), cbp,
	zfs_prop_to_name(pl->pl_prop),
	buf, sourcetype, source, recvdval);
	} else if (zfs_prop_userquota(pl->pl_user_prop)) {
	sourcetype = ZPROP_SRC_LOCAL;

	if (zfs_prop_get_userquota(zhp, pl->pl_user_prop,
	buf, sizeof (buf), cbp->cb_literal) != 0) {
	sourcetype = ZPROP_SRC_NONE;
	(void) strlcpy(buf, "-", sizeof (buf));
	}

	zprop_print_one_property(zfs_get_name(zhp), cbp,
	pl->pl_user_prop, buf, sourcetype, source, NULL);
	} else if (zfs_prop_written(pl->pl_user_prop)) {
	sourcetype = ZPROP_SRC_LOCAL;

	if (zfs_prop_get_written(zhp, pl->pl_user_prop,
	buf, sizeof (buf), cbp->cb_literal) != 0) {
	sourcetype = ZPROP_SRC_NONE;
	(void) strlcpy(buf, "-", sizeof (buf));
	}

	zprop_print_one_property(zfs_get_name(zhp), cbp,
	pl->pl_user_prop, buf, sourcetype, source, NULL);
	} else {
	if (nvlist_lookup_nvlist(user_props,
	pl->pl_user_prop, &propval) != 0) {
	if (pl->pl_all)
	continue;
	sourcetype = ZPROP_SRC_NONE;
	strval = "-";
	} else {
	verify(nvlist_lookup_string(propval,
	ZPROP_VALUE, &strval) == 0);
	verify(nvlist_lookup_string(propval,
	ZPROP_SOURCE, &sourceval) == 0);

	if (strcmp(sourceval,
	zfs_get_name(zhp)) == 0) {
	sourcetype = ZPROP_SRC_LOCAL;
	} else if (strcmp(sourceval,
	ZPROP_SOURCE_VAL_RECVD) == 0) {
	sourcetype = ZPROP_SRC_RECEIVED;
	} else {
	sourcetype = ZPROP_SRC_INHERITED;
	(void) strlcpy(source,
	sourceval, sizeof (source));
	}
	}

	if (received && (zfs_prop_get_recvd(zhp,
	pl->pl_user_prop, rbuf, sizeof (rbuf),
	cbp->cb_literal) == 0))
	recvdval = rbuf;

	zprop_print_one_property(zfs_get_name(zhp), cbp,
	pl->pl_user_prop, strval, sourcetype,
	source, recvdval);
	}
	}

	return (0);
	}

	static int
	zfs_do_get(int argc, char **argv)
	{
	zprop_get_cbdata_t cb = { 0 };
	int i, c, flags = ZFS_ITER_ARGS_CAN_BE_PATHS;
	int types = ZFS_TYPE_DATASET \| ZFS_TYPE_BOOKMARK;
	char value, fields;
	int ret = 0;
	int limit = 0;
	zprop_list_t fake_name = { 0 };

	/*
	* Set up default columns and sources.
	*/
	cb.cb_sources = ZPROP_SRC_ALL;
	cb.cb_columns[0] = GET_COL_NAME;
	cb.cb_columns[1] = GET_COL_PROPERTY;
	cb.cb_columns[2] = GET_COL_VALUE;
	cb.cb_columns[3] = GET_COL_SOURCE;
	cb.cb_type = ZFS_TYPE_DATASET;

	/* check options */
	while ((c = getopt(argc, argv, ":d:o:s:rt:Hp")) != -1) {
	switch (c) {
	case 'p':
	cb.cb_literal = B_TRUE;
	break;
	case 'd':
	limit = parse_depth(optarg, &flags);
	break;
	case 'r':
	flags \|= ZFS_ITER_RECURSE;
	break;
	case 'H':
	cb.cb_scripted = B_TRUE;
	break;
	case ':':
	(void) fprintf(stderr, gettext("missing argument for "
	"'%c' option\n"), optopt);
	usage(B_FALSE);
	break;
	case 'o':
	/*
	* Process the set of columns to display. We zero out
	* the structure to give us a blank slate.
	*/
	bzero(&cb.cb_columns, sizeof (cb.cb_columns));
	i = 0;
	while (*optarg != '\0') {
	static char *col_subopts[] =
	{ "name", "property", "value", "received",
	"source", "all", NULL };

	if (i == ZFS_GET_NCOLS) {
	(void) fprintf(stderr, gettext("too "
	"many fields given to -o "
	"option\n"));
	usage(B_FALSE);
	}

	switch (getsubopt(&optarg, col_subopts,
	&value)) {
	case 0:
	cb.cb_columns[i++] = GET_COL_NAME;
	break;
	case 1:
	cb.cb_columns[i++] = GET_COL_PROPERTY;
	break;
	case 2:
	cb.cb_columns[i++] = GET_COL_VALUE;
	break;
	case 3:
	cb.cb_columns[i++] = GET_COL_RECVD;
	flags \|= ZFS_ITER_RECVD_PROPS;
	break;
	case 4:
	cb.cb_columns[i++] = GET_COL_SOURCE;
	break;
	case 5:
	if (i > 0) {
	(void) fprintf(stderr,
	gettext("\"all\" conflicts "
	"with specific fields "
	"given to -o option\n"));
	usage(B_FALSE);
	}
	cb.cb_columns[0] = GET_COL_NAME;
	cb.cb_columns[1] = GET_COL_PROPERTY;
	cb.cb_columns[2] = GET_COL_VALUE;
	cb.cb_columns[3] = GET_COL_RECVD;
	cb.cb_columns[4] = GET_COL_SOURCE;
	flags \|= ZFS_ITER_RECVD_PROPS;
	i = ZFS_GET_NCOLS;
	break;
	default:
	(void) fprintf(stderr,
	gettext("invalid column name "
	"'%s'\n"), value);
	usage(B_FALSE);
	}
	}
	break;

	case 's':
	cb.cb_sources = 0;
	while (*optarg != '\0') {
	static char *source_subopts[] = {
	"local", "default", "inherited",
	"received", "temporary", "none",
	NULL };

	switch (getsubopt(&optarg, source_subopts,
	&value)) {
	case 0:
	cb.cb_sources \|= ZPROP_SRC_LOCAL;
	break;
	case 1:
	cb.cb_sources \|= ZPROP_SRC_DEFAULT;
	break;
	case 2:
	cb.cb_sources \|= ZPROP_SRC_INHERITED;
	break;
	case 3:
	cb.cb_sources \|= ZPROP_SRC_RECEIVED;
	break;
	case 4:
	cb.cb_sources \|= ZPROP_SRC_TEMPORARY;
	break;
	case 5:
	cb.cb_sources \|= ZPROP_SRC_NONE;
	break;
	default:
	(void) fprintf(stderr,
	gettext("invalid source "
	"'%s'\n"), value);
	usage(B_FALSE);
	}
	}
	break;

	case 't':
	types = 0;
	flags &= ~ZFS_ITER_PROP_LISTSNAPS;
	while (*optarg != '\0') {
	static char *type_subopts[] = { "filesystem",
	"volume", "snapshot", "snap", "bookmark",
	"all", NULL };

	switch (getsubopt(&optarg, type_subopts,
	&value)) {
	case 0:
	types \|= ZFS_TYPE_FILESYSTEM;
	break;
	case 1:
	types \|= ZFS_TYPE_VOLUME;
	break;
	case 2:
	case 3:
	types \|= ZFS_TYPE_SNAPSHOT;
	break;
	case 4:
	types \|= ZFS_TYPE_BOOKMARK;
	break;
	case 5:
	types = ZFS_TYPE_DATASET \|
	ZFS_TYPE_BOOKMARK;
	break;

	default:
	(void) fprintf(stderr,
	gettext("invalid type '%s'\n"),
	value);
	usage(B_FALSE);
	}
	}
	break;

	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	argc -= optind;
	argv += optind;

	if (argc < 1) {
	(void) fprintf(stderr, gettext("missing property "
	"argument\n"));
	usage(B_FALSE);
	}

	fields = argv[0];

	/*
	* Handle users who want to get all snapshots or bookmarks
	* of a dataset (ex. 'zfs get -t snapshot refer <dataset>').
	*/
	if ((types == ZFS_TYPE_SNAPSHOT \|\| types == ZFS_TYPE_BOOKMARK) &&
	argc > 1 && (flags & ZFS_ITER_RECURSE) == 0 && limit == 0) {
	flags \|= (ZFS_ITER_DEPTH_LIMIT \| ZFS_ITER_RECURSE);
	limit = 1;
	}

	if (zprop_get_list(g_zfs, fields, &cb.cb_proplist, ZFS_TYPE_DATASET)
	!= 0)
	usage(B_FALSE);

	argc--;
	argv++;

	/*
	* As part of zfs_expand_proplist(), we keep track of the maximum column
	* width for each property. For the 'NAME' (and 'SOURCE') columns, we
	* need to know the maximum name length. However, the user likely did
	* not specify 'name' as one of the properties to fetch, so we need to
	* make sure we always include at least this property for
	* print_get_headers() to work properly.
	*/
	if (cb.cb_proplist != NULL) {
	fake_name.pl_prop = ZFS_PROP_NAME;
	fake_name.pl_width = strlen(gettext("NAME"));
	fake_name.pl_next = cb.cb_proplist;
	cb.cb_proplist = &fake_name;
	}

	cb.cb_first = B_TRUE;

	/* run for each object */
	ret = zfs_for_each(argc, argv, flags, types, NULL,
	&cb.cb_proplist, limit, get_callback, &cb);

	if (cb.cb_proplist == &fake_name)
	zprop_free_list(fake_name.pl_next);
	else
	zprop_free_list(cb.cb_proplist);

	return (ret);
	}

	/*
	* inherit [-rS] <property> <fs\|vol> ...
	*
	* -r Recurse over all children
	* -S Revert to received value, if any
	*
	* For each dataset specified on the command line, inherit the given property
	* from its parent. Inheriting a property at the pool level will cause it to
	* use the default value. The '-r' flag will recurse over all children, and is
	* useful for setting a property on a hierarchy-wide basis, regardless of any
	* local modifications for each dataset.
	*/

	typedef struct inherit_cbdata {
	const char *cb_propname;
	boolean_t cb_received;
	} inherit_cbdata_t;

	static int
	inherit_recurse_cb(zfs_handle_t zhp, void data)
	{
	inherit_cbdata_t *cb = data;
	zfs_prop_t prop = zfs_name_to_prop(cb->cb_propname);

	/*
	* If we're doing it recursively, then ignore properties that
	* are not valid for this type of dataset.
	*/
	if (prop != ZPROP_INVAL &&
	!zfs_prop_valid_for_type(prop, zfs_get_type(zhp), B_FALSE))
	return (0);

	return (zfs_prop_inherit(zhp, cb->cb_propname, cb->cb_received) != 0);
	}

	static int
	inherit_cb(zfs_handle_t zhp, void data)
	{
	inherit_cbdata_t *cb = data;

	return (zfs_prop_inherit(zhp, cb->cb_propname, cb->cb_received) != 0);
	}

	static int
	zfs_do_inherit(int argc, char **argv)
	{
	int c;
	zfs_prop_t prop;
	inherit_cbdata_t cb = { 0 };
	char *propname;
	int ret = 0;
	int flags = 0;
	boolean_t received = B_FALSE;

	/* check options */
	while ((c = getopt(argc, argv, "rS")) != -1) {
	switch (c) {
	case 'r':
	flags \|= ZFS_ITER_RECURSE;
	break;
	case 'S':
	received = B_TRUE;
	break;
	case '?':
	default:
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	argc -= optind;
	argv += optind;

	/* check number of arguments */
	if (argc < 1) {
	(void) fprintf(stderr, gettext("missing property argument\n"));
	usage(B_FALSE);
	}
	if (argc < 2) {
	(void) fprintf(stderr, gettext("missing dataset argument\n"));
	usage(B_FALSE);
	}

	propname = argv[0];
	argc--;
	argv++;

	if ((prop = zfs_name_to_prop(propname)) != ZPROP_INVAL) {
	if (zfs_prop_readonly(prop)) {
	(void) fprintf(stderr, gettext(
	"%s property is read-only\n"),
	propname);
	return (1);
	}
	if (!zfs_prop_inheritable(prop) && !received) {
	(void) fprintf(stderr, gettext("'%s' property cannot "
	"be inherited\n"), propname);
	if (prop == ZFS_PROP_QUOTA \|\|
	prop == ZFS_PROP_RESERVATION \|\|
	prop == ZFS_PROP_REFQUOTA \|\|
	prop == ZFS_PROP_REFRESERVATION) {
	(void) fprintf(stderr, gettext("use 'zfs set "
	"%s=none' to clear\n"), propname);
	(void) fprintf(stderr, gettext("use 'zfs "
	"inherit -S %s' to revert to received "
	"value\n"), propname);
	}
	return (1);
	}
	if (received && (prop == ZFS_PROP_VOLSIZE \|\|
	prop == ZFS_PROP_VERSION)) {
	(void) fprintf(stderr, gettext("'%s' property cannot "
	"be reverted to a received value\n"), propname);
	return (1);
	}
	} else if (!zfs_prop_user(propname)) {
	(void) fprintf(stderr, gettext("invalid property '%s'\n"),
	propname);
	usage(B_FALSE);
	}

	cb.cb_propname = propname;
	cb.cb_received = received;

	if (flags & ZFS_ITER_RECURSE) {
	ret = zfs_for_each(argc, argv, flags, ZFS_TYPE_DATASET,
	NULL, NULL, 0, inherit_recurse_cb, &cb);
	} else {
	ret = zfs_for_each(argc, argv, flags, ZFS_TYPE_DATASET,
	NULL, NULL, 0, inherit_cb, &cb);
	}

	return (ret);
	}

	typedef struct upgrade_cbdata {
	uint64_t cb_numupgraded;
	uint64_t cb_numsamegraded;
	uint64_t cb_numfailed;
	uint64_t cb_version;
	boolean_t cb_newer;
	boolean_t cb_foundone;
	char cb_lastfs[ZFS_MAX_DATASET_NAME_LEN];
	} upgrade_cbdata_t;

	static int
	same_pool(zfs_handle_t zhp, const char name)
	{
	int len1 = strcspn(name, "/@");
	const char *zhname = zfs_get_name(zhp);
	int len2 = strcspn(zhname, "/@");

	if (len1 != len2)
	return (B_FALSE);
	return (strncmp(name, zhname, len1) == 0);
	}

	static int
	upgrade_list_callback(zfs_handle_t zhp, void data)
	{
	upgrade_cbdata_t *cb = data;
	int version = zfs_prop_get_int(zhp, ZFS_PROP_VERSION);

	/* list if it's old/new */
	if ((!cb->cb_newer && version < ZPL_VERSION) \|\|
	(cb->cb_newer && version > ZPL_VERSION)) {
	char *str;
	if (cb->cb_newer) {
	str = gettext("The following filesystems are "
	"formatted using a newer software version and\n"
	"cannot be accessed on the current system.\n\n");
	} else {
	str = gettext("The following filesystems are "
	"out of date, and can be upgraded. After being\n"
	"upgraded, these filesystems (and any 'zfs send' "
	"streams generated from\n"
	"subsequent snapshots) will no longer be "
	"accessible by older software versions.\n\n");
	}

	if (!cb->cb_foundone) {
	(void) puts(str);
	(void) printf(gettext("VER FILESYSTEM\n"));
	(void) printf(gettext("--- ------------\n"));
	cb->cb_foundone = B_TRUE;
	}

	(void) printf("%2u %s\n", version, zfs_get_name(zhp));
	}

	return (0);
	}

	static int
	upgrade_set_callback(zfs_handle_t zhp, void data)
	{
	upgrade_cbdata_t *cb = data;
	int version = zfs_prop_get_int(zhp, ZFS_PROP_VERSION);
	int needed_spa_version;
	int spa_version;

	if (zfs_spa_version(zhp, &spa_version) < 0)
	return (-1);

	needed_spa_version = zfs_spa_version_map(cb->cb_version);

	if (needed_spa_version < 0)
	return (-1);

	if (spa_version < needed_spa_version) {
	/* can't upgrade */
	(void) printf(gettext("%s: can not be "
	"upgraded; the pool version needs to first "
	"be upgraded\nto version %d\n\n"),
	zfs_get_name(zhp), needed_spa_version);
	cb->cb_numfailed++;
	return (0);
	}

	/* upgrade */
	if (version < cb->cb_version) {
	char verstr[16];
	(void) snprintf(verstr, sizeof (verstr),
	"%llu", (u_longlong_t)cb->cb_version);
	if (cb->cb_lastfs[0] && !same_pool(zhp, cb->cb_lastfs)) {
	/*
	* If they did "zfs upgrade -a", then we could
	* be doing ioctls to different pools. We need
	* to log this history once to each pool, and bypass
	* the normal history logging that happens in main().
	*/
	(void) zpool_log_history(g_zfs, history_str);
	log_history = B_FALSE;
	}
	if (zfs_prop_set(zhp, "version", verstr) == 0)
	cb->cb_numupgraded++;
	else
	cb->cb_numfailed++;
	(void) strcpy(cb->cb_lastfs, zfs_get_name(zhp));
	} else if (version > cb->cb_version) {
	/* can't downgrade */
	(void) printf(gettext("%s: can not be downgraded; "
	"it is already at version %u\n"),
	zfs_get_name(zhp), version);
	cb->cb_numfailed++;
	} else {
	cb->cb_numsamegraded++;
	}
	return (0);
	}

	/*
	* zfs upgrade
	* zfs upgrade -v
	* zfs upgrade [-r] [-V <version>] <-a \| filesystem>
	*/
	static int
	zfs_do_upgrade(int argc, char **argv)
	{
	boolean_t all = B_FALSE;
	boolean_t showversions = B_FALSE;
	int ret = 0;
	upgrade_cbdata_t cb = { 0 };
	int c;
	int flags = ZFS_ITER_ARGS_CAN_BE_PATHS;

	/* check options */
	while ((c = getopt(argc, argv, "rvV:a")) != -1) {
	switch (c) {
	case 'r':
	flags \|= ZFS_ITER_RECURSE;
	break;
	case 'v':
	showversions = B_TRUE;
	break;
	case 'V':
	if (zfs_prop_string_to_index(ZFS_PROP_VERSION,
	optarg, &cb.cb_version) != 0) {
	(void) fprintf(stderr,
	gettext("invalid version %s\n"), optarg);
	usage(B_FALSE);
	}
	break;
	case 'a':
	all = B_TRUE;
	break;
	case '?':
	default:
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	argc -= optind;
	argv += optind;

	if ((!all && !argc) && ((flags & ZFS_ITER_RECURSE) \| cb.cb_version))
	usage(B_FALSE);
	if (showversions && (flags & ZFS_ITER_RECURSE \|\| all \|\|
	cb.cb_version \|\| argc))
	usage(B_FALSE);
	if ((all \|\| argc) && (showversions))
	usage(B_FALSE);
	if (all && argc)
	usage(B_FALSE);

	if (showversions) {
	/* Show info on available versions. */
	(void) printf(gettext("The following filesystem versions are "
	"supported:\n\n"));
	(void) printf(gettext("VER DESCRIPTION\n"));
	(void) printf("--- -----------------------------------------"
	"---------------\n");
	(void) printf(gettext(" 1 Initial ZFS filesystem version\n"));
	(void) printf(gettext(" 2 Enhanced directory entries\n"));
	(void) printf(gettext(" 3 Case insensitive and filesystem "
	"user identifier (FUID)\n"));
	(void) printf(gettext(" 4 userquota, groupquota "
	"properties\n"));
	(void) printf(gettext(" 5 System attributes\n"));
	(void) printf(gettext("\nFor more information on a particular "
	"version, including supported releases,\n"));
	(void) printf("see the ZFS Administration Guide.\n\n");
	ret = 0;
	} else if (argc \|\| all) {
	/* Upgrade filesystems */
	if (cb.cb_version == 0)
	cb.cb_version = ZPL_VERSION;
	ret = zfs_for_each(argc, argv, flags, ZFS_TYPE_FILESYSTEM,
	NULL, NULL, 0, upgrade_set_callback, &cb);
	(void) printf(gettext("%llu filesystems upgraded\n"),
	(u_longlong_t)cb.cb_numupgraded);
	if (cb.cb_numsamegraded) {
	(void) printf(gettext("%llu filesystems already at "
	"this version\n"),
	(u_longlong_t)cb.cb_numsamegraded);
	}
	if (cb.cb_numfailed != 0)
	ret = 1;
	} else {
	/* List old-version filesystems */
	boolean_t found;
	(void) printf(gettext("This system is currently running "
	"ZFS filesystem version %llu.\n\n"), ZPL_VERSION);

	flags \|= ZFS_ITER_RECURSE;
	ret = zfs_for_each(0, NULL, flags, ZFS_TYPE_FILESYSTEM,
	NULL, NULL, 0, upgrade_list_callback, &cb);

	found = cb.cb_foundone;
	cb.cb_foundone = B_FALSE;
	cb.cb_newer = B_TRUE;

	ret = zfs_for_each(0, NULL, flags, ZFS_TYPE_FILESYSTEM,
	NULL, NULL, 0, upgrade_list_callback, &cb);

	if (!cb.cb_foundone && !found) {
	(void) printf(gettext("All filesystems are "
	"formatted with the current version.\n"));
	}
	}

	return (ret);
	}

	/*
	* zfs userspace [-Hinp] [-o field[,...]] [-s field [-s field]...]
	* [-S field [-S field]...] [-t type[,...]]
	* filesystem \| snapshot \| path
	* zfs groupspace [-Hinp] [-o field[,...]] [-s field [-s field]...]
	* [-S field [-S field]...] [-t type[,...]]
	* filesystem \| snapshot \| path
	* zfs projectspace [-Hp] [-o field[,...]] [-s field [-s field]...]
	* [-S field [-S field]...] filesystem \| snapshot \| path
	*
	* -H Scripted mode; elide headers and separate columns by tabs.
	* -i Translate SID to POSIX ID.
	* -n Print numeric ID instead of user/group name.
	* -o Control which fields to display.
	* -p Use exact (parsable) numeric output.
	* -s Specify sort columns, descending order.
	* -S Specify sort columns, ascending order.
	* -t Control which object types to display.
	*
	* Displays space consumed by, and quotas on, each user in the specified
	* filesystem or snapshot.
	*/

	/* us_field_types, us_field_hdr and us_field_names should be kept in sync */
	enum us_field_types {
	USFIELD_TYPE,
	USFIELD_NAME,
	USFIELD_USED,
	USFIELD_QUOTA,
	USFIELD_OBJUSED,
	USFIELD_OBJQUOTA
	};
	static char *us_field_hdr[] = { "TYPE", "NAME", "USED", "QUOTA",
	"OBJUSED", "OBJQUOTA" };
	static char *us_field_names[] = { "type", "name", "used", "quota",
	"objused", "objquota" };
	#define USFIELD_LAST (sizeof (us_field_names) / sizeof (char *))

	#define USTYPE_PSX_GRP (1 << 0)
	#define USTYPE_PSX_USR (1 << 1)
	#define USTYPE_SMB_GRP (1 << 2)
	#define USTYPE_SMB_USR (1 << 3)
	#define USTYPE_PROJ (1 << 4)
	#define USTYPE_ALL \
	(USTYPE_PSX_GRP \| USTYPE_PSX_USR \| USTYPE_SMB_GRP \| USTYPE_SMB_USR \| \
	USTYPE_PROJ)

	static int us_type_bits[] = {
	USTYPE_PSX_GRP,
	USTYPE_PSX_USR,
	USTYPE_SMB_GRP,
	USTYPE_SMB_USR,
	USTYPE_ALL
	};
	static char *us_type_names[] = { "posixgroup", "posixuser", "smbgroup",
	"smbuser", "all" };

	typedef struct us_node {
	nvlist_t *usn_nvl;
	uu_avl_node_t usn_avlnode;
	uu_list_node_t usn_listnode;
	} us_node_t;

	typedef struct us_cbdata {
	nvlist_t **cb_nvlp;
	uu_avl_pool_t *cb_avl_pool;
	uu_avl_t *cb_avl;
	boolean_t cb_numname;
	boolean_t cb_nicenum;
	boolean_t cb_sid2posix;
	zfs_userquota_prop_t cb_prop;
	zfs_sort_column_t *cb_sortcol;
	size_t cb_width[USFIELD_LAST];
	} us_cbdata_t;

	static boolean_t us_populated = B_FALSE;

	typedef struct {
	zfs_sort_column_t *si_sortcol;
	boolean_t si_numname;
	} us_sort_info_t;

	static int
	us_field_index(char *field)
	{
	int i;

	for (i = 0; i < USFIELD_LAST; i++) {
	if (strcmp(field, us_field_names[i]) == 0)
	return (i);
	}

	return (-1);
	}

	static int
	us_compare(const void larg, const void rarg, void *unused)
	{
	const us_node_t *l = larg;
	const us_node_t *r = rarg;
	us_sort_info_t si = (us_sort_info_t )unused;
	zfs_sort_column_t *sortcol = si->si_sortcol;
	boolean_t numname = si->si_numname;
	nvlist_t *lnvl = l->usn_nvl;
	nvlist_t *rnvl = r->usn_nvl;
	int rc = 0;
	boolean_t lvb, rvb;

	for (; sortcol != NULL; sortcol = sortcol->sc_next) {
	char *lvstr = "";
	char *rvstr = "";
	uint32_t lv32 = 0;
	uint32_t rv32 = 0;
	uint64_t lv64 = 0;
	uint64_t rv64 = 0;
	zfs_prop_t prop = sortcol->sc_prop;
	const char *propname = NULL;
	boolean_t reverse = sortcol->sc_reverse;

	switch (prop) {
	case ZFS_PROP_TYPE:
	propname = "type";
	(void) nvlist_lookup_uint32(lnvl, propname, &lv32);
	(void) nvlist_lookup_uint32(rnvl, propname, &rv32);
	if (rv32 != lv32)
	rc = (rv32 < lv32) ? 1 : -1;
	break;
	case ZFS_PROP_NAME:
	propname = "name";
	if (numname) {
	compare_nums:
	(void) nvlist_lookup_uint64(lnvl, propname,
	&lv64);
	(void) nvlist_lookup_uint64(rnvl, propname,
	&rv64);
	if (rv64 != lv64)
	rc = (rv64 < lv64) ? 1 : -1;
	} else {
	if ((nvlist_lookup_string(lnvl, propname,
	&lvstr) == ENOENT) \|\|
	(nvlist_lookup_string(rnvl, propname,
	&rvstr) == ENOENT)) {
	goto compare_nums;
	}
	rc = strcmp(lvstr, rvstr);
	}
	break;
	case ZFS_PROP_USED:
	case ZFS_PROP_QUOTA:
	if (!us_populated)
	break;
	if (prop == ZFS_PROP_USED)
	propname = "used";
	else
	propname = "quota";
	(void) nvlist_lookup_uint64(lnvl, propname, &lv64);
	(void) nvlist_lookup_uint64(rnvl, propname, &rv64);
	if (rv64 != lv64)
	rc = (rv64 < lv64) ? 1 : -1;
	break;

	default:
	break;
	}

	if (rc != 0) {
	if (rc < 0)
	return (reverse ? 1 : -1);
	else
	return (reverse ? -1 : 1);
	}
	}

	/*
	* If entries still seem to be the same, check if they are of the same
	* type (smbentity is added only if we are doing SID to POSIX ID
	* translation where we can have duplicate type/name combinations).
	*/
	if (nvlist_lookup_boolean_value(lnvl, "smbentity", &lvb) == 0 &&
	nvlist_lookup_boolean_value(rnvl, "smbentity", &rvb) == 0 &&
	lvb != rvb)
	return (lvb < rvb ? -1 : 1);

	return (0);
	}

	static boolean_t
	zfs_prop_is_user(unsigned p)
	{
	return (p == ZFS_PROP_USERUSED \|\| p == ZFS_PROP_USERQUOTA \|\|
	p == ZFS_PROP_USEROBJUSED \|\| p == ZFS_PROP_USEROBJQUOTA);
	}

	static boolean_t
	zfs_prop_is_group(unsigned p)
	{
	return (p == ZFS_PROP_GROUPUSED \|\| p == ZFS_PROP_GROUPQUOTA \|\|
	p == ZFS_PROP_GROUPOBJUSED \|\| p == ZFS_PROP_GROUPOBJQUOTA);
	}

	static boolean_t
	zfs_prop_is_project(unsigned p)
	{
	return (p == ZFS_PROP_PROJECTUSED \|\| p == ZFS_PROP_PROJECTQUOTA \|\|
	p == ZFS_PROP_PROJECTOBJUSED \|\| p == ZFS_PROP_PROJECTOBJQUOTA);
	}

	static inline const char *
	us_type2str(unsigned field_type)
	{
	switch (field_type) {
	case USTYPE_PSX_USR:
	return ("POSIX User");
	case USTYPE_PSX_GRP:
	return ("POSIX Group");
	case USTYPE_SMB_USR:
	return ("SMB User");
	case USTYPE_SMB_GRP:
	return ("SMB Group");
	case USTYPE_PROJ:
	return ("Project");
	default:
	return ("Undefined");
	}
	}

	static int
	userspace_cb(void arg, const char domain, uid_t rid, uint64_t space)
	{
	us_cbdata_t cb = (us_cbdata_t )arg;
	zfs_userquota_prop_t prop = cb->cb_prop;
	char *name = NULL;
	char *propname;
	char sizebuf[32];
	us_node_t *node;
	uu_avl_pool_t *avl_pool = cb->cb_avl_pool;
	uu_avl_t *avl = cb->cb_avl;
	uu_avl_index_t idx;
	nvlist_t *props;
	us_node_t *n;
	zfs_sort_column_t *sortcol = cb->cb_sortcol;
	unsigned type = 0;
	const char *typestr;
	size_t namelen;
	size_t typelen;
	size_t sizelen;
	int typeidx, nameidx, sizeidx;
	us_sort_info_t sortinfo = { sortcol, cb->cb_numname };
	boolean_t smbentity = B_FALSE;

	if (nvlist_alloc(&props, NV_UNIQUE_NAME, 0) != 0)
	nomem();
	node = safe_malloc(sizeof (us_node_t));
	uu_avl_node_init(node, &node->usn_avlnode, avl_pool);
	node->usn_nvl = props;

	if (domain != NULL && domain[0] != '\0') {
	#ifdef HAVE_IDMAP
	/* SMB */
	char sid[MAXNAMELEN + 32];
	uid_t id;
	uint64_t classes;
	int err;
	directory_error_t e;

	smbentity = B_TRUE;

	(void) snprintf(sid, sizeof (sid), "%s-%u", domain, rid);

	if (prop == ZFS_PROP_GROUPUSED \|\| prop == ZFS_PROP_GROUPQUOTA) {
	type = USTYPE_SMB_GRP;
	err = sid_to_id(sid, B_FALSE, &id);
	} else {
	type = USTYPE_SMB_USR;
	err = sid_to_id(sid, B_TRUE, &id);
	}

	if (err == 0) {
	rid = id;
	if (!cb->cb_sid2posix) {
	e = directory_name_from_sid(NULL, sid, &name,
	&classes);
	if (e != NULL)
	directory_error_free(e);
	if (name == NULL)
	name = sid;
	}
	}
	#else
	nvlist_free(props);
	free(node);

	return (-1);
	#endif /* HAVE_IDMAP */
	}

	if (cb->cb_sid2posix \|\| domain == NULL \|\| domain[0] == '\0') {
	/* POSIX or -i */
	if (zfs_prop_is_group(prop)) {
	type = USTYPE_PSX_GRP;
	if (!cb->cb_numname) {
	struct group *g;

	if ((g = getgrgid(rid)) != NULL)
	name = g->gr_name;
	}
	} else if (zfs_prop_is_user(prop)) {
	type = USTYPE_PSX_USR;
	if (!cb->cb_numname) {
	struct passwd *p;

	if ((p = getpwuid(rid)) != NULL)
	name = p->pw_name;
	}
	} else {
	type = USTYPE_PROJ;
	}
	}

	/*
	* Make sure that the type/name combination is unique when doing
	* SID to POSIX ID translation (hence changing the type from SMB to
	* POSIX).
	*/
	if (cb->cb_sid2posix &&
	nvlist_add_boolean_value(props, "smbentity", smbentity) != 0)
	nomem();

	/* Calculate/update width of TYPE field */
	typestr = us_type2str(type);
	typelen = strlen(gettext(typestr));
	typeidx = us_field_index("type");
	if (typelen > cb->cb_width[typeidx])
	cb->cb_width[typeidx] = typelen;
	if (nvlist_add_uint32(props, "type", type) != 0)
	nomem();

	/* Calculate/update width of NAME field */
	if ((cb->cb_numname && cb->cb_sid2posix) \|\| name == NULL) {
	if (nvlist_add_uint64(props, "name", rid) != 0)
	nomem();
	namelen = snprintf(NULL, 0, "%u", rid);
	} else {
	if (nvlist_add_string(props, "name", name) != 0)
	nomem();
	namelen = strlen(name);
	}
	nameidx = us_field_index("name");
	if (nameidx >= 0 && namelen > cb->cb_width[nameidx])
	cb->cb_width[nameidx] = namelen;

	/*
	* Check if this type/name combination is in the list and update it;
	* otherwise add new node to the list.
	*/
	if ((n = uu_avl_find(avl, node, &sortinfo, &idx)) == NULL) {
	uu_avl_insert(avl, node, idx);
	} else {
	nvlist_free(props);
	free(node);
	node = n;
	props = node->usn_nvl;
	}

	/* Calculate/update width of USED/QUOTA fields */
	if (cb->cb_nicenum) {
	if (prop == ZFS_PROP_USERUSED \|\| prop == ZFS_PROP_GROUPUSED \|\|
	prop == ZFS_PROP_USERQUOTA \|\| prop == ZFS_PROP_GROUPQUOTA \|\|
	prop == ZFS_PROP_PROJECTUSED \|\|
	prop == ZFS_PROP_PROJECTQUOTA) {
	zfs_nicebytes(space, sizebuf, sizeof (sizebuf));
	} else {
	zfs_nicenum(space, sizebuf, sizeof (sizebuf));
	}
	} else {
	(void) snprintf(sizebuf, sizeof (sizebuf), "%llu",
	(u_longlong_t)space);
	}
	sizelen = strlen(sizebuf);
	if (prop == ZFS_PROP_USERUSED \|\| prop == ZFS_PROP_GROUPUSED \|\|
	prop == ZFS_PROP_PROJECTUSED) {
	propname = "used";
	if (!nvlist_exists(props, "quota"))
	(void) nvlist_add_uint64(props, "quota", 0);
	} else if (prop == ZFS_PROP_USERQUOTA \|\| prop == ZFS_PROP_GROUPQUOTA \|\|
	prop == ZFS_PROP_PROJECTQUOTA) {
	propname = "quota";
	if (!nvlist_exists(props, "used"))
	(void) nvlist_add_uint64(props, "used", 0);
	} else if (prop == ZFS_PROP_USEROBJUSED \|\|
	prop == ZFS_PROP_GROUPOBJUSED \|\| prop == ZFS_PROP_PROJECTOBJUSED) {
	propname = "objused";
	if (!nvlist_exists(props, "objquota"))
	(void) nvlist_add_uint64(props, "objquota", 0);
	} else if (prop == ZFS_PROP_USEROBJQUOTA \|\|
	prop == ZFS_PROP_GROUPOBJQUOTA \|\|
	prop == ZFS_PROP_PROJECTOBJQUOTA) {
	propname = "objquota";
	if (!nvlist_exists(props, "objused"))
	(void) nvlist_add_uint64(props, "objused", 0);
	} else {
	return (-1);
	}
	sizeidx = us_field_index(propname);
	if (sizeidx >= 0 && sizelen > cb->cb_width[sizeidx])
	cb->cb_width[sizeidx] = sizelen;

	if (nvlist_add_uint64(props, propname, space) != 0)
	nomem();

	return (0);
	}

	static void
	print_us_node(boolean_t scripted, boolean_t parsable, int *fields, int types,
	size_t width, us_node_t node)
	{
	nvlist_t *nvl = node->usn_nvl;
	char valstr[MAXNAMELEN];
	boolean_t first = B_TRUE;
	int cfield = 0;
	int field;
	uint32_t ustype;

	/* Check type */
	(void) nvlist_lookup_uint32(nvl, "type", &ustype);
	if (!(ustype & types))
	return;

	while ((field = fields[cfield]) != USFIELD_LAST) {
	nvpair_t *nvp = NULL;
	data_type_t type;
	uint32_t val32;
	uint64_t val64;
	char *strval = "-";

	while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
	if (strcmp(nvpair_name(nvp),
	us_field_names[field]) == 0)
	break;
	}

	type = nvp == NULL ? DATA_TYPE_UNKNOWN : nvpair_type(nvp);
	switch (type) {
	case DATA_TYPE_UINT32:
	(void) nvpair_value_uint32(nvp, &val32);
	break;
	case DATA_TYPE_UINT64:
	(void) nvpair_value_uint64(nvp, &val64);
	break;
	case DATA_TYPE_STRING:
	(void) nvpair_value_string(nvp, &strval);
	break;
	case DATA_TYPE_UNKNOWN:
	break;
	default:
	(void) fprintf(stderr, "invalid data type\n");
	}

	switch (field) {
	case USFIELD_TYPE:
	if (type == DATA_TYPE_UINT32)
	strval = (char *)us_type2str(val32);
	break;
	case USFIELD_NAME:
	if (type == DATA_TYPE_UINT64) {
	(void) sprintf(valstr, "%llu",
	(u_longlong_t)val64);
	strval = valstr;
	}
	break;
	case USFIELD_USED:
	case USFIELD_QUOTA:
	if (type == DATA_TYPE_UINT64) {
	if (parsable) {
	(void) sprintf(valstr, "%llu",
	(u_longlong_t)val64);
	strval = valstr;
	} else if (field == USFIELD_QUOTA &&
	val64 == 0) {
	strval = "none";
	} else {
	zfs_nicebytes(val64, valstr,
	sizeof (valstr));
	strval = valstr;
	}
	}
	break;
	case USFIELD_OBJUSED:
	case USFIELD_OBJQUOTA:
	if (type == DATA_TYPE_UINT64) {
	if (parsable) {
	(void) sprintf(valstr, "%llu",
	(u_longlong_t)val64);
	strval = valstr;
	} else if (field == USFIELD_OBJQUOTA &&
	val64 == 0) {
	strval = "none";
	} else {
	zfs_nicenum(val64, valstr,
	sizeof (valstr));
	strval = valstr;
	}
	}
	break;
	}

	if (!first) {
	if (scripted)
	(void) printf("\t");
	else
	(void) printf(" ");
	}
	if (scripted)
	(void) printf("%s", strval);
	else if (field == USFIELD_TYPE \|\| field == USFIELD_NAME)
	(void) printf("%-*s", (int)width[field], strval);
	else
	(void) printf("%*s", (int)width[field], strval);

	first = B_FALSE;
	cfield++;
	}

	(void) printf("\n");
	}

	static void
	print_us(boolean_t scripted, boolean_t parsable, int *fields, int types,
	size_t width, boolean_t rmnode, uu_avl_t avl)
	{
	us_node_t *node;
	const char *col;
	int cfield = 0;
	int field;

	if (!scripted) {
	boolean_t first = B_TRUE;

	while ((field = fields[cfield]) != USFIELD_LAST) {
	col = gettext(us_field_hdr[field]);
	if (field == USFIELD_TYPE \|\| field == USFIELD_NAME) {
	(void) printf(first ? "%-s" : " %-s",
	(int)width[field], col);
	} else {
	(void) printf(first ? "%s" : " %s",
	(int)width[field], col);
	}
	first = B_FALSE;
	cfield++;
	}
	(void) printf("\n");
	}

	for (node = uu_avl_first(avl); node; node = uu_avl_next(avl, node)) {
	print_us_node(scripted, parsable, fields, types, width, node);
	if (rmnode)
	nvlist_free(node->usn_nvl);
	}
	}

	static int
	zfs_do_userspace(int argc, char **argv)
	{
	zfs_handle_t *zhp;
	zfs_userquota_prop_t p;
	uu_avl_pool_t *avl_pool;
	uu_avl_t *avl_tree;
	uu_avl_walk_t *walk;
	char *delim;
	char deffields[] = "type,name,used,quota,objused,objquota";
	char *ofield = NULL;
	char *tfield = NULL;
	int cfield = 0;
	int fields[256];
	int i;
	boolean_t scripted = B_FALSE;
	boolean_t prtnum = B_FALSE;
	boolean_t parsable = B_FALSE;
	boolean_t sid2posix = B_FALSE;
	int ret = 0;
	int c;
	zfs_sort_column_t *sortcol = NULL;
	int types = USTYPE_PSX_USR \| USTYPE_SMB_USR;
	us_cbdata_t cb;
	us_node_t *node;
	us_node_t *rmnode;
	uu_list_pool_t *listpool;
	uu_list_t *list;
	uu_avl_index_t idx = 0;
	uu_list_index_t idx2 = 0;

	if (argc < 2)
	usage(B_FALSE);

	if (strcmp(argv[0], "groupspace") == 0) {
	/* Toggle default group types */
	types = USTYPE_PSX_GRP \| USTYPE_SMB_GRP;
	} else if (strcmp(argv[0], "projectspace") == 0) {
	types = USTYPE_PROJ;
	prtnum = B_TRUE;
	}

	while ((c = getopt(argc, argv, "nHpo:s:S:t:i")) != -1) {
	switch (c) {
	case 'n':
	if (types == USTYPE_PROJ) {
	(void) fprintf(stderr,
	gettext("invalid option 'n'\n"));
	usage(B_FALSE);
	}
	prtnum = B_TRUE;
	break;
	case 'H':
	scripted = B_TRUE;
	break;
	case 'p':
	parsable = B_TRUE;
	break;
	case 'o':
	ofield = optarg;
	break;
	case 's':
	case 'S':
	if (zfs_add_sort_column(&sortcol, optarg,
	c == 's' ? B_FALSE : B_TRUE) != 0) {
	(void) fprintf(stderr,
	gettext("invalid field '%s'\n"), optarg);
	usage(B_FALSE);
	}
	break;
	case 't':
	if (types == USTYPE_PROJ) {
	(void) fprintf(stderr,
	gettext("invalid option 't'\n"));
	usage(B_FALSE);
	}
	tfield = optarg;
	break;
	case 'i':
	if (types == USTYPE_PROJ) {
	(void) fprintf(stderr,
	gettext("invalid option 'i'\n"));
	usage(B_FALSE);
	}
	sid2posix = B_TRUE;
	break;
	case ':':
	(void) fprintf(stderr, gettext("missing argument for "
	"'%c' option\n"), optopt);
	usage(B_FALSE);
	break;
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	argc -= optind;
	argv += optind;

	if (argc < 1) {
	(void) fprintf(stderr, gettext("missing dataset name\n"));
	usage(B_FALSE);
	}
	if (argc > 1) {
	(void) fprintf(stderr, gettext("too many arguments\n"));
	usage(B_FALSE);
	}

	/* Use default output fields if not specified using -o */
	if (ofield == NULL)
	ofield = deffields;
	do {
	if ((delim = strchr(ofield, ',')) != NULL)
	*delim = '\0';
	if ((fields[cfield++] = us_field_index(ofield)) == -1) {
	(void) fprintf(stderr, gettext("invalid type '%s' "
	"for -o option\n"), ofield);
	return (-1);
	}
	if (delim != NULL)
	ofield = delim + 1;
	} while (delim != NULL);
	fields[cfield] = USFIELD_LAST;

	/* Override output types (-t option) */
	if (tfield != NULL) {
	types = 0;

	do {
	boolean_t found = B_FALSE;

	if ((delim = strchr(tfield, ',')) != NULL)
	*delim = '\0';
	for (i = 0; i < sizeof (us_type_bits) / sizeof (int);
	i++) {
	if (strcmp(tfield, us_type_names[i]) == 0) {
	found = B_TRUE;
	types \|= us_type_bits[i];
	break;
	}
	}
	if (!found) {
	(void) fprintf(stderr, gettext("invalid type "
	"'%s' for -t option\n"), tfield);
	return (-1);
	}
	if (delim != NULL)
	tfield = delim + 1;
	} while (delim != NULL);
	}

	if ((zhp = zfs_path_to_zhandle(g_zfs, argv[0], ZFS_TYPE_FILESYSTEM \|
	ZFS_TYPE_SNAPSHOT)) == NULL)
	return (1);
	if (zhp->zfs_head_type != ZFS_TYPE_FILESYSTEM) {
	(void) fprintf(stderr, gettext("operation is only applicable "
	"to filesystems and their snapshots\n"));
	zfs_close(zhp);
	return (1);
	}

	if ((avl_pool = uu_avl_pool_create("us_avl_pool", sizeof (us_node_t),
	offsetof(us_node_t, usn_avlnode), us_compare, UU_DEFAULT)) == NULL)
	nomem();
	if ((avl_tree = uu_avl_create(avl_pool, NULL, UU_DEFAULT)) == NULL)
	nomem();

	/* Always add default sorting columns */
	(void) zfs_add_sort_column(&sortcol, "type", B_FALSE);
	(void) zfs_add_sort_column(&sortcol, "name", B_FALSE);

	cb.cb_sortcol = sortcol;
	cb.cb_numname = prtnum;
	cb.cb_nicenum = !parsable;
	cb.cb_avl_pool = avl_pool;
	cb.cb_avl = avl_tree;
	cb.cb_sid2posix = sid2posix;

	for (i = 0; i < USFIELD_LAST; i++)
	cb.cb_width[i] = strlen(gettext(us_field_hdr[i]));

	for (p = 0; p < ZFS_NUM_USERQUOTA_PROPS; p++) {
	if ((zfs_prop_is_user(p) &&
	!(types & (USTYPE_PSX_USR \| USTYPE_SMB_USR))) \|\|
	(zfs_prop_is_group(p) &&
	!(types & (USTYPE_PSX_GRP \| USTYPE_SMB_GRP))) \|\|
	(zfs_prop_is_project(p) && types != USTYPE_PROJ))
	continue;

	cb.cb_prop = p;
	if ((ret = zfs_userspace(zhp, p, userspace_cb, &cb)) != 0) {
	zfs_close(zhp);
	return (ret);
	}
	}
	zfs_close(zhp);

	/* Sort the list */
	if ((node = uu_avl_first(avl_tree)) == NULL)
	return (0);

	us_populated = B_TRUE;

	listpool = uu_list_pool_create("tmplist", sizeof (us_node_t),
	offsetof(us_node_t, usn_listnode), NULL, UU_DEFAULT);
	list = uu_list_create(listpool, NULL, UU_DEFAULT);
	uu_list_node_init(node, &node->usn_listnode, listpool);

	while (node != NULL) {
	rmnode = node;
	node = uu_avl_next(avl_tree, node);
	uu_avl_remove(avl_tree, rmnode);
	if (uu_list_find(list, rmnode, NULL, &idx2) == NULL)
	uu_list_insert(list, rmnode, idx2);
	}

	for (node = uu_list_first(list); node != NULL;
	node = uu_list_next(list, node)) {
	us_sort_info_t sortinfo = { sortcol, cb.cb_numname };

	if (uu_avl_find(avl_tree, node, &sortinfo, &idx) == NULL)
	uu_avl_insert(avl_tree, node, idx);
	}

	uu_list_destroy(list);
	uu_list_pool_destroy(listpool);

	/* Print and free node nvlist memory */
	print_us(scripted, parsable, fields, types, cb.cb_width, B_TRUE,
	cb.cb_avl);

	zfs_free_sort_columns(sortcol);

	/* Clean up the AVL tree */
	if ((walk = uu_avl_walk_start(cb.cb_avl, UU_WALK_ROBUST)) == NULL)
	nomem();

	while ((node = uu_avl_walk_next(walk)) != NULL) {
	uu_avl_remove(cb.cb_avl, node);
	free(node);
	}

	uu_avl_walk_end(walk);
	uu_avl_destroy(avl_tree);
	uu_avl_pool_destroy(avl_pool);

	return (ret);
	}

	/*
	* list [-Hp][-r\|-d max] [-o property[,...]] [-s property] ... [-S property]
	* [-t type[,...]] [filesystem\|volume\|snapshot] ...
	*
	* -H Scripted mode; elide headers and separate columns by tabs
	* -p Display values in parsable (literal) format.
	* -r Recurse over all children
	* -d Limit recursion by depth.
	* -o Control which fields to display.
	* -s Specify sort columns, descending order.
	* -S Specify sort columns, ascending order.
	* -t Control which object types to display.
	*
	* When given no arguments, list all filesystems in the system.
	* Otherwise, list the specified datasets, optionally recursing down them if
	* '-r' is specified.
	*/
	typedef struct list_cbdata {
	boolean_t cb_first;
	boolean_t cb_literal;
	boolean_t cb_scripted;
	zprop_list_t *cb_proplist;
	} list_cbdata_t;

	/*
	* Given a list of columns to display, output appropriate headers for each one.
	*/
	static void
	print_header(list_cbdata_t *cb)
	{
	zprop_list_t *pl = cb->cb_proplist;
	char headerbuf[ZFS_MAXPROPLEN];
	const char *header;
	int i;
	boolean_t first = B_TRUE;
	boolean_t right_justify;

	for (; pl != NULL; pl = pl->pl_next) {
	if (!first) {
	(void) printf(" ");
	} else {
	first = B_FALSE;
	}

	right_justify = B_FALSE;
	if (pl->pl_prop != ZPROP_INVAL) {
	header = zfs_prop_column_name(pl->pl_prop);
	right_justify = zfs_prop_align_right(pl->pl_prop);
	} else {
	for (i = 0; pl->pl_user_prop[i] != '\0'; i++)
	headerbuf[i] = toupper(pl->pl_user_prop[i]);
	headerbuf[i] = '\0';
	header = headerbuf;
	}

	if (pl->pl_next == NULL && !right_justify)
	(void) printf("%s", header);
	else if (right_justify)
	(void) printf("%*s", (int)pl->pl_width, header);
	else
	(void) printf("%-*s", (int)pl->pl_width, header);
	}

	(void) printf("\n");
	}

	/*
	* Given a dataset and a list of fields, print out all the properties according
	* to the described layout.
	*/
	static void
	print_dataset(zfs_handle_t zhp, list_cbdata_t cb)
	{
	zprop_list_t *pl = cb->cb_proplist;
	boolean_t first = B_TRUE;
	char property[ZFS_MAXPROPLEN];
	nvlist_t *userprops = zfs_get_user_props(zhp);
	nvlist_t *propval;
	char *propstr;
	boolean_t right_justify;

	for (; pl != NULL; pl = pl->pl_next) {
	if (!first) {
	if (cb->cb_scripted)
	(void) printf("\t");
	else
	(void) printf(" ");
	} else {
	first = B_FALSE;
	}

	if (pl->pl_prop == ZFS_PROP_NAME) {
	(void) strlcpy(property, zfs_get_name(zhp),
	sizeof (property));
	propstr = property;
	right_justify = zfs_prop_align_right(pl->pl_prop);
	} else if (pl->pl_prop != ZPROP_INVAL) {
	if (zfs_prop_get(zhp, pl->pl_prop, property,
	sizeof (property), NULL, NULL, 0,
	cb->cb_literal) != 0)
	propstr = "-";
	else
	propstr = property;
	right_justify = zfs_prop_align_right(pl->pl_prop);
	} else if (zfs_prop_userquota(pl->pl_user_prop)) {
	if (zfs_prop_get_userquota(zhp, pl->pl_user_prop,
	property, sizeof (property), cb->cb_literal) != 0)
	propstr = "-";
	else
	propstr = property;
	right_justify = B_TRUE;
	} else if (zfs_prop_written(pl->pl_user_prop)) {
	if (zfs_prop_get_written(zhp, pl->pl_user_prop,
	property, sizeof (property), cb->cb_literal) != 0)
	propstr = "-";
	else
	propstr = property;
	right_justify = B_TRUE;
	} else {
	if (nvlist_lookup_nvlist(userprops,
	pl->pl_user_prop, &propval) != 0)
	propstr = "-";
	else
	verify(nvlist_lookup_string(propval,
	ZPROP_VALUE, &propstr) == 0);
	right_justify = B_FALSE;
	}

	/*
	* If this is being called in scripted mode, or if this is the
	* last column and it is left-justified, don't include a width
	* format specifier.
	*/
	if (cb->cb_scripted \|\| (pl->pl_next == NULL && !right_justify))
	(void) printf("%s", propstr);
	else if (right_justify)
	(void) printf("%*s", (int)pl->pl_width, propstr);
	else
	(void) printf("%-*s", (int)pl->pl_width, propstr);
	}

	(void) printf("\n");
	}

	/*
	* Generic callback function to list a dataset or snapshot.
	*/
	static int
	list_callback(zfs_handle_t zhp, void data)
	{
	list_cbdata_t *cbp = data;

	if (cbp->cb_first) {
	if (!cbp->cb_scripted)
	print_header(cbp);
	cbp->cb_first = B_FALSE;
	}

	print_dataset(zhp, cbp);

	return (0);
	}

	static int
	zfs_do_list(int argc, char **argv)
	{
	int c;
	static char default_fields[] =
	"name,used,available,referenced,mountpoint";
	int types = ZFS_TYPE_DATASET;
	boolean_t types_specified = B_FALSE;
	char *fields = NULL;
	list_cbdata_t cb = { 0 };
	char *value;
	int limit = 0;
	int ret = 0;
	zfs_sort_column_t *sortcol = NULL;
	int flags = ZFS_ITER_PROP_LISTSNAPS \| ZFS_ITER_ARGS_CAN_BE_PATHS;

	/* check options */
	while ((c = getopt(argc, argv, "HS:d:o:prs:t:")) != -1) {
	switch (c) {
	case 'o':
	fields = optarg;
	break;
	case 'p':
	cb.cb_literal = B_TRUE;
	flags \|= ZFS_ITER_LITERAL_PROPS;
	break;
	case 'd':
	limit = parse_depth(optarg, &flags);
	break;
	case 'r':
	flags \|= ZFS_ITER_RECURSE;
	break;
	case 'H':
	cb.cb_scripted = B_TRUE;
	break;
	case 's':
	if (zfs_add_sort_column(&sortcol, optarg,
	B_FALSE) != 0) {
	(void) fprintf(stderr,
	gettext("invalid property '%s'\n"), optarg);
	usage(B_FALSE);
	}
	break;
	case 'S':
	if (zfs_add_sort_column(&sortcol, optarg,
	B_TRUE) != 0) {
	(void) fprintf(stderr,
	gettext("invalid property '%s'\n"), optarg);
	usage(B_FALSE);
	}
	break;
	case 't':
	types = 0;
	types_specified = B_TRUE;
	flags &= ~ZFS_ITER_PROP_LISTSNAPS;
	while (*optarg != '\0') {
	static char *type_subopts[] = { "filesystem",
	"volume", "snapshot", "snap", "bookmark",
	"all", NULL };

	switch (getsubopt(&optarg, type_subopts,
	&value)) {
	case 0:
	types \|= ZFS_TYPE_FILESYSTEM;
	break;
	case 1:
	types \|= ZFS_TYPE_VOLUME;
	break;
	case 2:
	case 3:
	types \|= ZFS_TYPE_SNAPSHOT;
	break;
	case 4:
	types \|= ZFS_TYPE_BOOKMARK;
	break;
	case 5:
	types = ZFS_TYPE_DATASET \|
	ZFS_TYPE_BOOKMARK;
	break;
	default:
	(void) fprintf(stderr,
	gettext("invalid type '%s'\n"),
	value);
	usage(B_FALSE);
	}
	}
	break;
	case ':':
	(void) fprintf(stderr, gettext("missing argument for "
	"'%c' option\n"), optopt);
	usage(B_FALSE);
	break;
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	argc -= optind;
	argv += optind;

	if (fields == NULL)
	fields = default_fields;

	/*
	* If we are only going to list snapshot names and sort by name,
	* then we can use faster version.
	*/
	if (strcmp(fields, "name") == 0 && zfs_sort_only_by_name(sortcol))
	flags \|= ZFS_ITER_SIMPLE;

	/*
	* If "-o space" and no types were specified, don't display snapshots.
	*/
	if (strcmp(fields, "space") == 0 && types_specified == B_FALSE)
	types &= ~ZFS_TYPE_SNAPSHOT;

	/*
	* Handle users who want to list all snapshots or bookmarks
	* of the current dataset (ex. 'zfs list -t snapshot <dataset>').
	*/
	if ((types == ZFS_TYPE_SNAPSHOT \|\| types == ZFS_TYPE_BOOKMARK) &&
	argc > 0 && (flags & ZFS_ITER_RECURSE) == 0 && limit == 0) {
	flags \|= (ZFS_ITER_DEPTH_LIMIT \| ZFS_ITER_RECURSE);
	limit = 1;
	}

	/*
	* If the user specifies '-o all', the zprop_get_list() doesn't
	* normally include the name of the dataset. For 'zfs list', we always
	* want this property to be first.
	*/
	if (zprop_get_list(g_zfs, fields, &cb.cb_proplist, ZFS_TYPE_DATASET)
	!= 0)
	usage(B_FALSE);

	cb.cb_first = B_TRUE;

	ret = zfs_for_each(argc, argv, flags, types, sortcol, &cb.cb_proplist,
	limit, list_callback, &cb);

	zprop_free_list(cb.cb_proplist);
	zfs_free_sort_columns(sortcol);

	if (ret == 0 && cb.cb_first && !cb.cb_scripted)
	(void) fprintf(stderr, gettext("no datasets available\n"));

	return (ret);
	}

	/*
	* zfs rename [-fu] <fs \| snap \| vol> <fs \| snap \| vol>
	* zfs rename [-f] -p <fs \| vol> <fs \| vol>
	* zfs rename [-u] -r <snap> <snap>
	*
	* Renames the given dataset to another of the same type.
	*
	* The '-p' flag creates all the non-existing ancestors of the target first.
	* The '-u' flag prevents file systems from being remounted during rename.
	*/
	/* ARGSUSED */
	static int
	zfs_do_rename(int argc, char **argv)
	{
	zfs_handle_t *zhp;
	renameflags_t flags = { 0 };
	int c;
	int ret = 0;
	int types;
	boolean_t parents = B_FALSE;

	/* check options */
	while ((c = getopt(argc, argv, "pruf")) != -1) {
	switch (c) {
	case 'p':
	parents = B_TRUE;
	break;
	case 'r':
	flags.recursive = B_TRUE;
	break;
	case 'u':
	flags.nounmount = B_TRUE;
	break;
	case 'f':
	flags.forceunmount = B_TRUE;
	break;
	case '?':
	default:
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	argc -= optind;
	argv += optind;

	/* check number of arguments */
	if (argc < 1) {
	(void) fprintf(stderr, gettext("missing source dataset "
	"argument\n"));
	usage(B_FALSE);
	}
	if (argc < 2) {
	(void) fprintf(stderr, gettext("missing target dataset "
	"argument\n"));
	usage(B_FALSE);
	}
	if (argc > 2) {
	(void) fprintf(stderr, gettext("too many arguments\n"));
	usage(B_FALSE);
	}

	if (flags.recursive && parents) {
	(void) fprintf(stderr, gettext("-p and -r options are mutually "
	"exclusive\n"));
	usage(B_FALSE);
	}

	if (flags.nounmount && parents) {
	(void) fprintf(stderr, gettext("-u and -p options are mutually "
	"exclusive\n"));
	usage(B_FALSE);
	}

	if (flags.recursive && strchr(argv[0], '@') == 0) {
	(void) fprintf(stderr, gettext("source dataset for recursive "
	"rename must be a snapshot\n"));
	usage(B_FALSE);
	}

	if (flags.nounmount)
	types = ZFS_TYPE_FILESYSTEM;
	else if (parents)
	types = ZFS_TYPE_FILESYSTEM \| ZFS_TYPE_VOLUME;
	else
	types = ZFS_TYPE_DATASET;

	if ((zhp = zfs_open(g_zfs, argv[0], types)) == NULL)
	return (1);

	/* If we were asked and the name looks good, try to create ancestors. */
	if (parents && zfs_name_valid(argv[1], zfs_get_type(zhp)) &&
	zfs_create_ancestors(g_zfs, argv[1]) != 0) {
	zfs_close(zhp);
	return (1);
	}

	ret = (zfs_rename(zhp, argv[1], flags) != 0);

	zfs_close(zhp);
	return (ret);
	}

	/*
	* zfs promote <fs>
	*
	* Promotes the given clone fs to be the parent
	*/
	/* ARGSUSED */
	static int
	zfs_do_promote(int argc, char **argv)
	{
	zfs_handle_t *zhp;
	int ret = 0;

	/* check options */
	if (argc > 1 && argv[1][0] == '-') {
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	argv[1][1]);
	usage(B_FALSE);
	}

	/* check number of arguments */
	if (argc < 2) {
	(void) fprintf(stderr, gettext("missing clone filesystem"
	" argument\n"));
	usage(B_FALSE);
	}
	if (argc > 2) {
	(void) fprintf(stderr, gettext("too many arguments\n"));
	usage(B_FALSE);
	}

	zhp = zfs_open(g_zfs, argv[1], ZFS_TYPE_FILESYSTEM \| ZFS_TYPE_VOLUME);
	if (zhp == NULL)
	return (1);

	ret = (zfs_promote(zhp) != 0);


	zfs_close(zhp);
	return (ret);
	}

	static int
	zfs_do_redact(int argc, char **argv)
	{
	char *snap = NULL;
	char *bookname = NULL;
	char **rsnaps = NULL;
	int numrsnaps = 0;
	argv++;
	argc--;
	if (argc < 3) {
	(void) fprintf(stderr, gettext("too few arguments\n"));
	usage(B_FALSE);
	}

	snap = argv[0];
	bookname = argv[1];
	rsnaps = argv + 2;
	numrsnaps = argc - 2;

	nvlist_t *rsnapnv = fnvlist_alloc();

	for (int i = 0; i < numrsnaps; i++) {
	fnvlist_add_boolean(rsnapnv, rsnaps[i]);
	}

	int err = lzc_redact(snap, bookname, rsnapnv);
	fnvlist_free(rsnapnv);

	switch (err) {
	case 0:
	break;
	case ENOENT:
	(void) fprintf(stderr,
	gettext("provided snapshot %s does not exist\n"), snap);
	break;
	case EEXIST:
	(void) fprintf(stderr, gettext("specified redaction bookmark "
	"(%s) provided already exists\n"), bookname);
	break;
	case ENAMETOOLONG:
	(void) fprintf(stderr, gettext("provided bookmark name cannot "
	"be used, final name would be too long\n"));
	break;
	case E2BIG:
	(void) fprintf(stderr, gettext("too many redaction snapshots "
	"specified\n"));
	break;
	case EINVAL:
	if (strchr(bookname, '#') != NULL)
	(void) fprintf(stderr, gettext(
	"redaction bookmark name must not contain '#'\n"));
	else
	(void) fprintf(stderr, gettext(
	"redaction snapshot must be descendent of "
	"snapshot being redacted\n"));
	break;
	case EALREADY:
	(void) fprintf(stderr, gettext("attempted to redact redacted "
	"dataset or with respect to redacted dataset\n"));
	break;
	case ENOTSUP:
	(void) fprintf(stderr, gettext("redaction bookmarks feature "
	"not enabled\n"));
	break;
	case EXDEV:
	(void) fprintf(stderr, gettext("potentially invalid redaction "
	"snapshot; full dataset names required\n"));
	break;
	default:
	(void) fprintf(stderr, gettext("internal error: %s\n"),
	strerror(errno));
	}

	return (err);
	}

	/*
	* zfs rollback [-rRf] <snapshot>
	*
	* -r Delete any intervening snapshots before doing rollback
	* -R Delete any snapshots and their clones
	* -f ignored for backwards compatibility
	*
	* Given a filesystem, rollback to a specific snapshot, discarding any changes
	* since then and making it the active dataset. If more recent snapshots exist,
	* the command will complain unless the '-r' flag is given.
	*/
	typedef struct rollback_cbdata {
	uint64_t cb_create;
	uint8_t cb_younger_ds_printed;
	boolean_t cb_first;
	int cb_doclones;
	char *cb_target;
	int cb_error;
	boolean_t cb_recurse;
	} rollback_cbdata_t;

	static int
	rollback_check_dependent(zfs_handle_t zhp, void data)
	{
	rollback_cbdata_t *cbp = data;

	if (cbp->cb_first && cbp->cb_recurse) {
	(void) fprintf(stderr, gettext("cannot rollback to "
	"'%s': clones of previous snapshots exist\n"),
	cbp->cb_target);
	(void) fprintf(stderr, gettext("use '-R' to "
	"force deletion of the following clones and "
	"dependents:\n"));
	cbp->cb_first = 0;
	cbp->cb_error = 1;
	}

	(void) fprintf(stderr, "%s\n", zfs_get_name(zhp));

	zfs_close(zhp);
	return (0);
	}


	/*
	* Report some snapshots/bookmarks more recent than the one specified.
	* Used when '-r' is not specified. We reuse this same callback for the
	* snapshot dependents - if 'cb_dependent' is set, then this is a
	* dependent and we should report it without checking the transaction group.
	*/
	static int
	rollback_check(zfs_handle_t zhp, void data)
	{
	rollback_cbdata_t *cbp = data;
	/*
	* Max number of younger snapshots and/or bookmarks to display before
	* we stop the iteration.
	*/
	const uint8_t max_younger = 32;

	if (cbp->cb_doclones) {
	zfs_close(zhp);
	return (0);
	}

	if (zfs_prop_get_int(zhp, ZFS_PROP_CREATETXG) > cbp->cb_create) {
	if (cbp->cb_first && !cbp->cb_recurse) {
	(void) fprintf(stderr, gettext("cannot "
	"rollback to '%s': more recent snapshots "
	"or bookmarks exist\n"),
	cbp->cb_target);
	(void) fprintf(stderr, gettext("use '-r' to "
	"force deletion of the following "
	"snapshots and bookmarks:\n"));
	cbp->cb_first = 0;
	cbp->cb_error = 1;
	}

	if (cbp->cb_recurse) {
	if (zfs_iter_dependents(zhp, B_TRUE,
	rollback_check_dependent, cbp) != 0) {
	zfs_close(zhp);
	return (-1);
	}
	} else {
	(void) fprintf(stderr, "%s\n",
	zfs_get_name(zhp));
	cbp->cb_younger_ds_printed++;
	}
	}
	zfs_close(zhp);

	if (cbp->cb_younger_ds_printed == max_younger) {
	/*
	* This non-recursive rollback is going to fail due to the
	* presence of snapshots and/or bookmarks that are younger than
	* the rollback target.
	* We printed some of the offending objects, now we stop
	* zfs_iter_snapshot/bookmark iteration so we can fail fast and
	* avoid iterating over the rest of the younger objects
	*/
	(void) fprintf(stderr, gettext("Output limited to %d "
	"snapshots/bookmarks\n"), max_younger);
	return (-1);
	}
	return (0);
	}

	static int
	zfs_do_rollback(int argc, char **argv)
	{
	int ret = 0;
	int c;
	boolean_t force = B_FALSE;
	rollback_cbdata_t cb = { 0 };
	zfs_handle_t zhp, snap;
	char parentname[ZFS_MAX_DATASET_NAME_LEN];
	char *delim;
	uint64_t min_txg = 0;

	/* check options */
	while ((c = getopt(argc, argv, "rRf")) != -1) {
	switch (c) {
	case 'r':
	cb.cb_recurse = 1;
	break;
	case 'R':
	cb.cb_recurse = 1;
	cb.cb_doclones = 1;
	break;
	case 'f':
	force = B_TRUE;
	break;
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	argc -= optind;
	argv += optind;

	/* check number of arguments */
	if (argc < 1) {
	(void) fprintf(stderr, gettext("missing dataset argument\n"));
	usage(B_FALSE);
	}
	if (argc > 1) {
	(void) fprintf(stderr, gettext("too many arguments\n"));
	usage(B_FALSE);
	}

	/* open the snapshot */
	if ((snap = zfs_open(g_zfs, argv[0], ZFS_TYPE_SNAPSHOT)) == NULL)
	return (1);

	/* open the parent dataset */
	(void) strlcpy(parentname, argv[0], sizeof (parentname));
	verify((delim = strrchr(parentname, '@')) != NULL);
	*delim = '\0';
	if ((zhp = zfs_open(g_zfs, parentname, ZFS_TYPE_DATASET)) == NULL) {
	zfs_close(snap);
	return (1);
	}

	/*
	* Check for more recent snapshots and/or clones based on the presence
	* of '-r' and '-R'.
	*/
	cb.cb_target = argv[0];
	cb.cb_create = zfs_prop_get_int(snap, ZFS_PROP_CREATETXG);
	cb.cb_first = B_TRUE;
	cb.cb_error = 0;

	if (cb.cb_create > 0)
	min_txg = cb.cb_create;

	if ((ret = zfs_iter_snapshots(zhp, B_FALSE, rollback_check, &cb,
	min_txg, 0)) != 0)
	goto out;
	if ((ret = zfs_iter_bookmarks(zhp, rollback_check, &cb)) != 0)
	goto out;

	if ((ret = cb.cb_error) != 0)
	goto out;

	/*
	* Rollback parent to the given snapshot.
	*/
	ret = zfs_rollback(zhp, snap, force);

	out:
	zfs_close(snap);
	zfs_close(zhp);

	if (ret == 0)
	return (0);
	else
	return (1);
	}

	/*
	* zfs set property=value ... { fs \| snap \| vol } ...
	*
	* Sets the given properties for all datasets specified on the command line.
	*/

	static int
	set_callback(zfs_handle_t zhp, void data)
	{
	nvlist_t *props = data;

	if (zfs_prop_set_list(zhp, props) != 0) {
	switch (libzfs_errno(g_zfs)) {
	case EZFS_MOUNTFAILED:
	(void) fprintf(stderr, gettext("property may be set "
	"but unable to remount filesystem\n"));
	break;
	case EZFS_SHARENFSFAILED:
	(void) fprintf(stderr, gettext("property may be set "
	"but unable to reshare filesystem\n"));
	break;
	}
	return (1);
	}
	return (0);
	}

	static int
	zfs_do_set(int argc, char **argv)
	{
	nvlist_t *props = NULL;
	int ds_start = -1; /* argv idx of first dataset arg */
	int ret = 0;
	int i;

	/* check for options */
	if (argc > 1 && argv[1][0] == '-') {
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	argv[1][1]);
	usage(B_FALSE);
	}

	/* check number of arguments */
	if (argc < 2) {
	(void) fprintf(stderr, gettext("missing arguments\n"));
	usage(B_FALSE);
	}
	if (argc < 3) {
	if (strchr(argv[1], '=') == NULL) {
	(void) fprintf(stderr, gettext("missing property=value "
	"argument(s)\n"));
	} else {
	(void) fprintf(stderr, gettext("missing dataset "
	"name(s)\n"));
	}
	usage(B_FALSE);
	}

	/* validate argument order: prop=val args followed by dataset args */
	for (i = 1; i < argc; i++) {
	if (strchr(argv[i], '=') != NULL) {
	if (ds_start > 0) {
	/* out-of-order prop=val argument */
	(void) fprintf(stderr, gettext("invalid "
	"argument order\n"));
	usage(B_FALSE);
	}
	} else if (ds_start < 0) {
	ds_start = i;
	}
	}
	if (ds_start < 0) {
	(void) fprintf(stderr, gettext("missing dataset name(s)\n"));
	usage(B_FALSE);
	}

	/* Populate a list of property settings */
	if (nvlist_alloc(&props, NV_UNIQUE_NAME, 0) != 0)
	nomem();
	for (i = 1; i < ds_start; i++) {
	if (!parseprop(props, argv[i])) {
	ret = -1;
	goto error;
	}
	}

	ret = zfs_for_each(argc - ds_start, argv + ds_start, 0,
	ZFS_TYPE_DATASET, NULL, NULL, 0, set_callback, props);

	error:
	nvlist_free(props);
	return (ret);
	}

	typedef struct snap_cbdata {
	nvlist_t *sd_nvl;
	boolean_t sd_recursive;
	const char *sd_snapname;
	} snap_cbdata_t;

	static int
	zfs_snapshot_cb(zfs_handle_t zhp, void arg)
	{
	snap_cbdata_t *sd = arg;
	char *name;
	int rv = 0;
	int error;

	if (sd->sd_recursive &&
	zfs_prop_get_int(zhp, ZFS_PROP_INCONSISTENT) != 0) {
	zfs_close(zhp);
	return (0);
	}

	error = asprintf(&name, "%s@%s", zfs_get_name(zhp), sd->sd_snapname);
	if (error == -1)
	nomem();
	fnvlist_add_boolean(sd->sd_nvl, name);
	free(name);

	if (sd->sd_recursive)
	rv = zfs_iter_filesystems(zhp, zfs_snapshot_cb, sd);
	zfs_close(zhp);
	return (rv);
	}

	/*
	* zfs snapshot [-r] [-o prop=value] ... <fs@snap>
	*
	* Creates a snapshot with the given name. While functionally equivalent to
	* 'zfs create', it is a separate command to differentiate intent.
	*/
	static int
	zfs_do_snapshot(int argc, char **argv)
	{
	int ret = 0;
	int c;
	nvlist_t *props;
	snap_cbdata_t sd = { 0 };
	boolean_t multiple_snaps = B_FALSE;

	if (nvlist_alloc(&props, NV_UNIQUE_NAME, 0) != 0)
	nomem();
	if (nvlist_alloc(&sd.sd_nvl, NV_UNIQUE_NAME, 0) != 0)
	nomem();

	/* check options */
	while ((c = getopt(argc, argv, "ro:")) != -1) {
	switch (c) {
	case 'o':
	if (!parseprop(props, optarg)) {
	nvlist_free(sd.sd_nvl);
	nvlist_free(props);
	return (1);
	}
	break;
	case 'r':
	sd.sd_recursive = B_TRUE;
	multiple_snaps = B_TRUE;
	break;
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	goto usage;
	}
	}

	argc -= optind;
	argv += optind;

	/* check number of arguments */
	if (argc < 1) {
	(void) fprintf(stderr, gettext("missing snapshot argument\n"));
	goto usage;
	}

	if (argc > 1)
	multiple_snaps = B_TRUE;
	for (; argc > 0; argc--, argv++) {
	char *atp;
	zfs_handle_t *zhp;

	atp = strchr(argv[0], '@');
	if (atp == NULL)
	goto usage;
	*atp = '\0';
	sd.sd_snapname = atp + 1;
	zhp = zfs_open(g_zfs, argv[0],
	ZFS_TYPE_FILESYSTEM \| ZFS_TYPE_VOLUME);
	if (zhp == NULL)
	goto usage;
	if (zfs_snapshot_cb(zhp, &sd) != 0)
	goto usage;
	}

	ret = zfs_snapshot_nvl(g_zfs, sd.sd_nvl, props);
	nvlist_free(sd.sd_nvl);
	nvlist_free(props);
	if (ret != 0 && multiple_snaps)
	(void) fprintf(stderr, gettext("no snapshots were created\n"));
	return (ret != 0);

	usage:
	nvlist_free(sd.sd_nvl);
	nvlist_free(props);
	usage(B_FALSE);
	return (-1);
	}


	/*
	* Send a backup stream to stdout.
	*/
	static int
	zfs_do_send(int argc, char **argv)
	{
	char *fromname = NULL;
	char *toname = NULL;
	char *resume_token = NULL;
	char *cp;
	zfs_handle_t *zhp;
	sendflags_t flags = { 0 };
	int c, err;
	nvlist_t *dbgnv = NULL;
	char *redactbook = NULL;

	struct option long_options[] = {
	{"replicate", no_argument, NULL, 'R'},
	+ {"skip-missing", no_argument, NULL, 's'},
	{"redact", required_argument, NULL, 'd'},
	{"props", no_argument, NULL, 'p'},
	{"parsable", no_argument, NULL, 'P'},
	{"dedup", no_argument, NULL, 'D'},
	{"verbose", no_argument, NULL, 'v'},
	{"dryrun", no_argument, NULL, 'n'},
	{"large-block", no_argument, NULL, 'L'},
	{"embed", no_argument, NULL, 'e'},
	{"resume", required_argument, NULL, 't'},
	{"compressed", no_argument, NULL, 'c'},
	{"raw", no_argument, NULL, 'w'},
	{"backup", no_argument, NULL, 'b'},
	{"holds", no_argument, NULL, 'h'},
	{"saved", no_argument, NULL, 'S'},
	{0, 0, 0, 0}
	};

	/* check options */
	- while ((c = getopt_long(argc, argv, ":i:I:RDpvnPLeht:cwbd:S",
	+ while ((c = getopt_long(argc, argv, ":i:I:RsDpvnPLeht:cwbd:S",
	long_options, NULL)) != -1) {
	switch (c) {
	case 'i':
	if (fromname)
	usage(B_FALSE);
	fromname = optarg;
	break;
	case 'I':
	if (fromname)
	usage(B_FALSE);
	fromname = optarg;
	flags.doall = B_TRUE;
	break;
	case 'R':
	flags.replicate = B_TRUE;
	break;
	+ case 's':
	+ flags.skipmissing = B_TRUE;
	+ break;
	case 'd':
	redactbook = optarg;
	break;
	case 'p':
	flags.props = B_TRUE;
	break;
	case 'b':
	flags.backup = B_TRUE;
	break;
	case 'h':
	flags.holds = B_TRUE;
	break;
	case 'P':
	flags.parsable = B_TRUE;
	break;
	case 'v':
	flags.verbosity++;
	flags.progress = B_TRUE;
	break;
	case 'D':
	(void) fprintf(stderr,
	gettext("WARNING: deduplicated send is no "
	"longer supported. A regular,\n"
	"non-deduplicated stream will be generated.\n\n"));
	break;
	case 'n':
	flags.dryrun = B_TRUE;
	break;
	case 'L':
	flags.largeblock = B_TRUE;
	break;
	case 'e':
	flags.embed_data = B_TRUE;
	break;
	case 't':
	resume_token = optarg;
	break;
	case 'c':
	flags.compress = B_TRUE;
	break;
	case 'w':
	flags.raw = B_TRUE;
	flags.compress = B_TRUE;
	flags.embed_data = B_TRUE;
	flags.largeblock = B_TRUE;
	break;
	case 'S':
	flags.saved = B_TRUE;
	break;
	case ':':
	/*
	* If a parameter was not passed, optopt contains the
	* value that would normally lead us into the
	* appropriate case statement. If it's > 256, then this
	* must be a longopt and we should look at argv to get
	* the string. Otherwise it's just the character, so we
	* should use it directly.
	*/
	if (optopt <= UINT8_MAX) {
	(void) fprintf(stderr,
	gettext("missing argument for '%c' "
	"option\n"), optopt);
	} else {
	(void) fprintf(stderr,
	gettext("missing argument for '%s' "
	"option\n"), argv[optind - 1]);
	}
	usage(B_FALSE);
	break;
	case '?':
	/FALLTHROUGH/
	default:
	/*
	* If an invalid flag was passed, optopt contains the
	* character if it was a short flag, or 0 if it was a
	* longopt.
	*/
	if (optopt != 0) {
	(void) fprintf(stderr,
	gettext("invalid option '%c'\n"), optopt);
	} else {
	(void) fprintf(stderr,
	gettext("invalid option '%s'\n"),
	argv[optind - 1]);

	}
	usage(B_FALSE);
	}
	}

	if (flags.parsable && flags.verbosity == 0)
	flags.verbosity = 1;

	argc -= optind;
	argv += optind;

	if (resume_token != NULL) {
	if (fromname != NULL \|\| flags.replicate \|\| flags.props \|\|
	flags.backup \|\| flags.holds \|\|
	flags.saved \|\| redactbook != NULL) {
	(void) fprintf(stderr,
	gettext("invalid flags combined with -t\n"));
	usage(B_FALSE);
	}
	if (argc > 0) {
	(void) fprintf(stderr, gettext("too many arguments\n"));
	usage(B_FALSE);
	}
	} else {
	if (argc < 1) {
	(void) fprintf(stderr,
	gettext("missing snapshot argument\n"));
	usage(B_FALSE);
	}
	if (argc > 1) {
	(void) fprintf(stderr, gettext("too many arguments\n"));
	usage(B_FALSE);
	}
	}

	if (flags.saved) {
	if (fromname != NULL \|\| flags.replicate \|\| flags.props \|\|
	flags.doall \|\| flags.backup \|\|
	flags.holds \|\| flags.largeblock \|\| flags.embed_data \|\|
	flags.compress \|\| flags.raw \|\| redactbook != NULL) {
	(void) fprintf(stderr, gettext("incompatible flags "
	"combined with saved send flag\n"));
	usage(B_FALSE);
	}
	if (strchr(argv[0], '@') != NULL) {
	(void) fprintf(stderr, gettext("saved send must "
	"specify the dataset with partially-received "
	"state\n"));
	usage(B_FALSE);
	}
	}

	if (flags.raw && redactbook != NULL) {
	(void) fprintf(stderr,
	gettext("Error: raw sends may not be redacted.\n"));
	return (1);
	}

	if (!flags.dryrun && isatty(STDOUT_FILENO)) {
	(void) fprintf(stderr,
	gettext("Error: Stream can not be written to a terminal.\n"
	"You must redirect standard output.\n"));
	return (1);
	}

	if (flags.saved) {
	zhp = zfs_open(g_zfs, argv[0], ZFS_TYPE_DATASET);
	if (zhp == NULL)
	return (1);

	err = zfs_send_saved(zhp, &flags, STDOUT_FILENO,
	resume_token);
	zfs_close(zhp);
	return (err != 0);
	} else if (resume_token != NULL) {
	return (zfs_send_resume(g_zfs, &flags, STDOUT_FILENO,
	resume_token));
	}

	+ if (flags.skipmissing && !flags.replicate) {
	+ (void) fprintf(stderr,
	+ gettext("skip-missing flag can only be used in "
	+ "conjunction with replicate\n"));
	+ usage(B_FALSE);
	+ }
	+
	/*
	* For everything except -R and -I, use the new, cleaner code path.
	*/
	if (!(flags.replicate \|\| flags.doall)) {
	char frombuf[ZFS_MAX_DATASET_NAME_LEN];

	if (fromname != NULL && (strchr(fromname, '#') == NULL &&
	strchr(fromname, '@') == NULL)) {
	/*
	* Neither bookmark or snapshot was specified. Print a
	* warning, and assume snapshot.
	*/
	(void) fprintf(stderr, "Warning: incremental source "
	"didn't specify type, assuming snapshot. Use '@' "
	"or '#' prefix to avoid ambiguity.\n");
	(void) snprintf(frombuf, sizeof (frombuf), "@%s",
	fromname);
	fromname = frombuf;
	}
	if (fromname != NULL &&
	(fromname[0] == '#' \|\| fromname[0] == '@')) {
	/*
	* Incremental source name begins with # or @.
	* Default to same fs as target.
	*/
	char tmpbuf[ZFS_MAX_DATASET_NAME_LEN];
	(void) strlcpy(tmpbuf, fromname, sizeof (tmpbuf));
	(void) strlcpy(frombuf, argv[0], sizeof (frombuf));
	cp = strchr(frombuf, '@');
	if (cp != NULL)
	*cp = '\0';
	(void) strlcat(frombuf, tmpbuf, sizeof (frombuf));
	fromname = frombuf;
	}

	zhp = zfs_open(g_zfs, argv[0], ZFS_TYPE_DATASET);
	if (zhp == NULL)
	return (1);
	err = zfs_send_one(zhp, fromname, STDOUT_FILENO, &flags,
	redactbook);
	zfs_close(zhp);
	return (err != 0);
	}

	if (fromname != NULL && strchr(fromname, '#')) {
	(void) fprintf(stderr,
	gettext("Error: multiple snapshots cannot be "
	"sent from a bookmark.\n"));
	return (1);
	}

	if (redactbook != NULL) {
	(void) fprintf(stderr, gettext("Error: multiple snapshots "
	"cannot be sent redacted.\n"));
	return (1);
	}

	if ((cp = strchr(argv[0], '@')) == NULL) {
	(void) fprintf(stderr, gettext("Error: "
	"Unsupported flag with filesystem or bookmark.\n"));
	return (1);
	}
	*cp = '\0';
	toname = cp + 1;
	zhp = zfs_open(g_zfs, argv[0], ZFS_TYPE_FILESYSTEM \| ZFS_TYPE_VOLUME);
	if (zhp == NULL)
	return (1);

	/*
	* If they specified the full path to the snapshot, chop off
	* everything except the short name of the snapshot, but special
	* case if they specify the origin.
	*/
	if (fromname && (cp = strchr(fromname, '@')) != NULL) {
	char origin[ZFS_MAX_DATASET_NAME_LEN];
	zprop_source_t src;

	(void) zfs_prop_get(zhp, ZFS_PROP_ORIGIN,
	origin, sizeof (origin), &src, NULL, 0, B_FALSE);

	if (strcmp(origin, fromname) == 0) {
	fromname = NULL;
	flags.fromorigin = B_TRUE;
	} else {
	*cp = '\0';
	if (cp != fromname && strcmp(argv[0], fromname)) {
	(void) fprintf(stderr,
	gettext("incremental source must be "
	"in same filesystem\n"));
	usage(B_FALSE);
	}
	fromname = cp + 1;
	if (strchr(fromname, '@') \|\| strchr(fromname, '/')) {
	(void) fprintf(stderr,
	gettext("invalid incremental source\n"));
	usage(B_FALSE);
	}
	}
	}

	if (flags.replicate && fromname == NULL)
	flags.doall = B_TRUE;

	err = zfs_send(zhp, fromname, toname, &flags, STDOUT_FILENO, NULL, 0,
	flags.verbosity >= 3 ? &dbgnv : NULL);

	if (flags.verbosity >= 3 && dbgnv != NULL) {
	/*
	* dump_nvlist prints to stdout, but that's been
	* redirected to a file. Make it print to stderr
	* instead.
	*/
	(void) dup2(STDERR_FILENO, STDOUT_FILENO);
	dump_nvlist(dbgnv, 0);
	nvlist_free(dbgnv);
	}
	zfs_close(zhp);

	return (err != 0);
	}

	/*
	* Restore a backup stream from stdin.
	*/
	static int
	zfs_do_receive(int argc, char **argv)
	{
	int c, err = 0;
	recvflags_t flags = { 0 };
	boolean_t abort_resumable = B_FALSE;
	nvlist_t *props;

	if (nvlist_alloc(&props, NV_UNIQUE_NAME, 0) != 0)
	nomem();

	/* check options */
	while ((c = getopt(argc, argv, ":o:x:dehMnuvFsA")) != -1) {
	switch (c) {
	case 'o':
	if (!parseprop(props, optarg)) {
	nvlist_free(props);
	usage(B_FALSE);
	}
	break;
	case 'x':
	if (!parsepropname(props, optarg)) {
	nvlist_free(props);
	usage(B_FALSE);
	}
	break;
	case 'd':
	if (flags.istail) {
	(void) fprintf(stderr, gettext("invalid option "
	"combination: -d and -e are mutually "
	"exclusive\n"));
	usage(B_FALSE);
	}
	flags.isprefix = B_TRUE;
	break;
	case 'e':
	if (flags.isprefix) {
	(void) fprintf(stderr, gettext("invalid option "
	"combination: -d and -e are mutually "
	"exclusive\n"));
	usage(B_FALSE);
	}
	flags.istail = B_TRUE;
	break;
	case 'h':
	flags.skipholds = B_TRUE;
	break;
	case 'M':
	flags.forceunmount = B_TRUE;
	break;
	case 'n':
	flags.dryrun = B_TRUE;
	break;
	case 'u':
	flags.nomount = B_TRUE;
	break;
	case 'v':
	flags.verbose = B_TRUE;
	break;
	case 's':
	flags.resumable = B_TRUE;
	break;
	case 'F':
	flags.force = B_TRUE;
	break;
	case 'A':
	abort_resumable = B_TRUE;
	break;
	case ':':
	(void) fprintf(stderr, gettext("missing argument for "
	"'%c' option\n"), optopt);
	usage(B_FALSE);
	break;
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	argc -= optind;
	argv += optind;

	/* zfs recv -e (use "tail" name) implies -d (remove dataset "head") */
	if (flags.istail)
	flags.isprefix = B_TRUE;

	/* check number of arguments */
	if (argc < 1) {
	(void) fprintf(stderr, gettext("missing snapshot argument\n"));
	usage(B_FALSE);
	}
	if (argc > 1) {
	(void) fprintf(stderr, gettext("too many arguments\n"));
	usage(B_FALSE);
	}

	if (abort_resumable) {
	if (flags.isprefix \|\| flags.istail \|\| flags.dryrun \|\|
	flags.resumable \|\| flags.nomount) {
	(void) fprintf(stderr, gettext("invalid option\n"));
	usage(B_FALSE);
	}

	char namebuf[ZFS_MAX_DATASET_NAME_LEN];
	(void) snprintf(namebuf, sizeof (namebuf),
	"%s/%%recv", argv[0]);

	if (zfs_dataset_exists(g_zfs, namebuf,
	ZFS_TYPE_FILESYSTEM \| ZFS_TYPE_VOLUME)) {
	zfs_handle_t *zhp = zfs_open(g_zfs,
	namebuf, ZFS_TYPE_FILESYSTEM \| ZFS_TYPE_VOLUME);
	if (zhp == NULL) {
	nvlist_free(props);
	return (1);
	}
	err = zfs_destroy(zhp, B_FALSE);
	zfs_close(zhp);
	} else {
	zfs_handle_t *zhp = zfs_open(g_zfs,
	argv[0], ZFS_TYPE_FILESYSTEM \| ZFS_TYPE_VOLUME);
	if (zhp == NULL)
	usage(B_FALSE);
	if (!zfs_prop_get_int(zhp, ZFS_PROP_INCONSISTENT) \|\|
	zfs_prop_get(zhp, ZFS_PROP_RECEIVE_RESUME_TOKEN,
	NULL, 0, NULL, NULL, 0, B_TRUE) == -1) {
	(void) fprintf(stderr,
	gettext("'%s' does not have any "
	"resumable receive state to abort\n"),
	argv[0]);
	nvlist_free(props);
	zfs_close(zhp);
	return (1);
	}
	err = zfs_destroy(zhp, B_FALSE);
	zfs_close(zhp);
	}
	nvlist_free(props);
	return (err != 0);
	}

	if (isatty(STDIN_FILENO)) {
	(void) fprintf(stderr,
	gettext("Error: Backup stream can not be read "
	"from a terminal.\n"
	"You must redirect standard input.\n"));
	nvlist_free(props);
	return (1);
	}
	err = zfs_receive(g_zfs, argv[0], props, &flags, STDIN_FILENO, NULL);
	nvlist_free(props);

	return (err != 0);
	}

	/*
	* allow/unallow stuff
	*/
	/* copied from zfs/sys/dsl_deleg.h */
	#define ZFS_DELEG_PERM_CREATE "create"
	#define ZFS_DELEG_PERM_DESTROY "destroy"
	#define ZFS_DELEG_PERM_SNAPSHOT "snapshot"
	#define ZFS_DELEG_PERM_ROLLBACK "rollback"
	#define ZFS_DELEG_PERM_CLONE "clone"
	#define ZFS_DELEG_PERM_PROMOTE "promote"
	#define ZFS_DELEG_PERM_RENAME "rename"
	#define ZFS_DELEG_PERM_MOUNT "mount"
	#define ZFS_DELEG_PERM_SHARE "share"
	#define ZFS_DELEG_PERM_SEND "send"
	#define ZFS_DELEG_PERM_RECEIVE "receive"
	#define ZFS_DELEG_PERM_ALLOW "allow"
	#define ZFS_DELEG_PERM_USERPROP "userprop"
	#define ZFS_DELEG_PERM_VSCAN "vscan" /* ??? */
	#define ZFS_DELEG_PERM_USERQUOTA "userquota"
	#define ZFS_DELEG_PERM_GROUPQUOTA "groupquota"
	#define ZFS_DELEG_PERM_USERUSED "userused"
	#define ZFS_DELEG_PERM_GROUPUSED "groupused"
	#define ZFS_DELEG_PERM_USEROBJQUOTA "userobjquota"
	#define ZFS_DELEG_PERM_GROUPOBJQUOTA "groupobjquota"
	#define ZFS_DELEG_PERM_USEROBJUSED "userobjused"
	#define ZFS_DELEG_PERM_GROUPOBJUSED "groupobjused"

	#define ZFS_DELEG_PERM_HOLD "hold"
	#define ZFS_DELEG_PERM_RELEASE "release"
	#define ZFS_DELEG_PERM_DIFF "diff"
	#define ZFS_DELEG_PERM_BOOKMARK "bookmark"
	#define ZFS_DELEG_PERM_LOAD_KEY "load-key"
	#define ZFS_DELEG_PERM_CHANGE_KEY "change-key"

	#define ZFS_DELEG_PERM_PROJECTUSED "projectused"
	#define ZFS_DELEG_PERM_PROJECTQUOTA "projectquota"
	#define ZFS_DELEG_PERM_PROJECTOBJUSED "projectobjused"
	#define ZFS_DELEG_PERM_PROJECTOBJQUOTA "projectobjquota"

	#define ZFS_NUM_DELEG_NOTES ZFS_DELEG_NOTE_NONE

	static zfs_deleg_perm_tab_t zfs_deleg_perm_tbl[] = {
	{ ZFS_DELEG_PERM_ALLOW, ZFS_DELEG_NOTE_ALLOW },
	{ ZFS_DELEG_PERM_CLONE, ZFS_DELEG_NOTE_CLONE },
	{ ZFS_DELEG_PERM_CREATE, ZFS_DELEG_NOTE_CREATE },
	{ ZFS_DELEG_PERM_DESTROY, ZFS_DELEG_NOTE_DESTROY },
	{ ZFS_DELEG_PERM_DIFF, ZFS_DELEG_NOTE_DIFF},
	{ ZFS_DELEG_PERM_HOLD, ZFS_DELEG_NOTE_HOLD },
	{ ZFS_DELEG_PERM_MOUNT, ZFS_DELEG_NOTE_MOUNT },
	{ ZFS_DELEG_PERM_PROMOTE, ZFS_DELEG_NOTE_PROMOTE },
	{ ZFS_DELEG_PERM_RECEIVE, ZFS_DELEG_NOTE_RECEIVE },
	{ ZFS_DELEG_PERM_RELEASE, ZFS_DELEG_NOTE_RELEASE },
	{ ZFS_DELEG_PERM_RENAME, ZFS_DELEG_NOTE_RENAME },
	{ ZFS_DELEG_PERM_ROLLBACK, ZFS_DELEG_NOTE_ROLLBACK },
	{ ZFS_DELEG_PERM_SEND, ZFS_DELEG_NOTE_SEND },
	{ ZFS_DELEG_PERM_SHARE, ZFS_DELEG_NOTE_SHARE },
	{ ZFS_DELEG_PERM_SNAPSHOT, ZFS_DELEG_NOTE_SNAPSHOT },
	{ ZFS_DELEG_PERM_BOOKMARK, ZFS_DELEG_NOTE_BOOKMARK },
	{ ZFS_DELEG_PERM_LOAD_KEY, ZFS_DELEG_NOTE_LOAD_KEY },
	{ ZFS_DELEG_PERM_CHANGE_KEY, ZFS_DELEG_NOTE_CHANGE_KEY },

	{ ZFS_DELEG_PERM_GROUPQUOTA, ZFS_DELEG_NOTE_GROUPQUOTA },
	{ ZFS_DELEG_PERM_GROUPUSED, ZFS_DELEG_NOTE_GROUPUSED },
	{ ZFS_DELEG_PERM_USERPROP, ZFS_DELEG_NOTE_USERPROP },
	{ ZFS_DELEG_PERM_USERQUOTA, ZFS_DELEG_NOTE_USERQUOTA },
	{ ZFS_DELEG_PERM_USERUSED, ZFS_DELEG_NOTE_USERUSED },
	{ ZFS_DELEG_PERM_USEROBJQUOTA, ZFS_DELEG_NOTE_USEROBJQUOTA },
	{ ZFS_DELEG_PERM_USEROBJUSED, ZFS_DELEG_NOTE_USEROBJUSED },
	{ ZFS_DELEG_PERM_GROUPOBJQUOTA, ZFS_DELEG_NOTE_GROUPOBJQUOTA },
	{ ZFS_DELEG_PERM_GROUPOBJUSED, ZFS_DELEG_NOTE_GROUPOBJUSED },
	{ ZFS_DELEG_PERM_PROJECTUSED, ZFS_DELEG_NOTE_PROJECTUSED },
	{ ZFS_DELEG_PERM_PROJECTQUOTA, ZFS_DELEG_NOTE_PROJECTQUOTA },
	{ ZFS_DELEG_PERM_PROJECTOBJUSED, ZFS_DELEG_NOTE_PROJECTOBJUSED },
	{ ZFS_DELEG_PERM_PROJECTOBJQUOTA, ZFS_DELEG_NOTE_PROJECTOBJQUOTA },
	{ NULL, ZFS_DELEG_NOTE_NONE }
	};

	/* permission structure */
	typedef struct deleg_perm {
	zfs_deleg_who_type_t dp_who_type;
	const char *dp_name;
	boolean_t dp_local;
	boolean_t dp_descend;
	} deleg_perm_t;

	/* */
	typedef struct deleg_perm_node {
	deleg_perm_t dpn_perm;

	uu_avl_node_t dpn_avl_node;
	} deleg_perm_node_t;

	typedef struct fs_perm fs_perm_t;

	/* permissions set */
	typedef struct who_perm {
	zfs_deleg_who_type_t who_type;
	const char who_name; / id */
	char who_ug_name[256]; /* user/group name */
	fs_perm_t who_fsperm; / uplink */

	uu_avl_t who_deleg_perm_avl; / permissions */
	} who_perm_t;

	/* */
	typedef struct who_perm_node {
	who_perm_t who_perm;
	uu_avl_node_t who_avl_node;
	} who_perm_node_t;

	typedef struct fs_perm_set fs_perm_set_t;
	/* fs permissions */
	struct fs_perm {
	const char *fsp_name;

	uu_avl_t fsp_sc_avl; / sets,create */
	uu_avl_t fsp_uge_avl; / user,group,everyone */

	fs_perm_set_t fsp_set; / uplink */
	};

	/* */
	typedef struct fs_perm_node {
	fs_perm_t fspn_fsperm;
	uu_avl_t *fspn_avl;

	uu_list_node_t fspn_list_node;
	} fs_perm_node_t;

	/* top level structure */
	struct fs_perm_set {
	uu_list_pool_t *fsps_list_pool;
	uu_list_t fsps_list; / list of fs_perms */

	uu_avl_pool_t *fsps_named_set_avl_pool;
	uu_avl_pool_t *fsps_who_perm_avl_pool;
	uu_avl_pool_t *fsps_deleg_perm_avl_pool;
	};

	static inline const char *
	deleg_perm_type(zfs_deleg_note_t note)
	{
	/* subcommands */
	switch (note) {
	/* SUBCOMMANDS */
	/* OTHER */
	case ZFS_DELEG_NOTE_GROUPQUOTA:
	case ZFS_DELEG_NOTE_GROUPUSED:
	case ZFS_DELEG_NOTE_USERPROP:
	case ZFS_DELEG_NOTE_USERQUOTA:
	case ZFS_DELEG_NOTE_USERUSED:
	case ZFS_DELEG_NOTE_USEROBJQUOTA:
	case ZFS_DELEG_NOTE_USEROBJUSED:
	case ZFS_DELEG_NOTE_GROUPOBJQUOTA:
	case ZFS_DELEG_NOTE_GROUPOBJUSED:
	case ZFS_DELEG_NOTE_PROJECTUSED:
	case ZFS_DELEG_NOTE_PROJECTQUOTA:
	case ZFS_DELEG_NOTE_PROJECTOBJUSED:
	case ZFS_DELEG_NOTE_PROJECTOBJQUOTA:
	/* other */
	return (gettext("other"));
	default:
	return (gettext("subcommand"));
	}
	}

	static int
	who_type2weight(zfs_deleg_who_type_t who_type)
	{
	int res;
	switch (who_type) {
	case ZFS_DELEG_NAMED_SET_SETS:
	case ZFS_DELEG_NAMED_SET:
	res = 0;
	break;
	case ZFS_DELEG_CREATE_SETS:
	case ZFS_DELEG_CREATE:
	res = 1;
	break;
	case ZFS_DELEG_USER_SETS:
	case ZFS_DELEG_USER:
	res = 2;
	break;
	case ZFS_DELEG_GROUP_SETS:
	case ZFS_DELEG_GROUP:
	res = 3;
	break;
	case ZFS_DELEG_EVERYONE_SETS:
	case ZFS_DELEG_EVERYONE:
	res = 4;
	break;
	default:
	res = -1;
	}

	return (res);
	}

	/* ARGSUSED */
	static int
	who_perm_compare(const void larg, const void rarg, void *unused)
	{
	const who_perm_node_t *l = larg;
	const who_perm_node_t *r = rarg;
	zfs_deleg_who_type_t ltype = l->who_perm.who_type;
	zfs_deleg_who_type_t rtype = r->who_perm.who_type;
	int lweight = who_type2weight(ltype);
	int rweight = who_type2weight(rtype);
	int res = lweight - rweight;
	if (res == 0)
	res = strncmp(l->who_perm.who_name, r->who_perm.who_name,
	ZFS_MAX_DELEG_NAME-1);

	if (res == 0)
	return (0);
	if (res > 0)
	return (1);
	else
	return (-1);
	}

	/* ARGSUSED */
	static int
	deleg_perm_compare(const void larg, const void rarg, void *unused)
	{
	const deleg_perm_node_t *l = larg;
	const deleg_perm_node_t *r = rarg;
	int res = strncmp(l->dpn_perm.dp_name, r->dpn_perm.dp_name,
	ZFS_MAX_DELEG_NAME-1);

	if (res == 0)
	return (0);

	if (res > 0)
	return (1);
	else
	return (-1);
	}

	static inline void
	fs_perm_set_init(fs_perm_set_t *fspset)
	{
	bzero(fspset, sizeof (fs_perm_set_t));

	if ((fspset->fsps_list_pool = uu_list_pool_create("fsps_list_pool",
	sizeof (fs_perm_node_t), offsetof(fs_perm_node_t, fspn_list_node),
	NULL, UU_DEFAULT)) == NULL)
	nomem();
	if ((fspset->fsps_list = uu_list_create(fspset->fsps_list_pool, NULL,
	UU_DEFAULT)) == NULL)
	nomem();

	if ((fspset->fsps_named_set_avl_pool = uu_avl_pool_create(
	"named_set_avl_pool", sizeof (who_perm_node_t), offsetof(
	who_perm_node_t, who_avl_node), who_perm_compare,
	UU_DEFAULT)) == NULL)
	nomem();

	if ((fspset->fsps_who_perm_avl_pool = uu_avl_pool_create(
	"who_perm_avl_pool", sizeof (who_perm_node_t), offsetof(
	who_perm_node_t, who_avl_node), who_perm_compare,
	UU_DEFAULT)) == NULL)
	nomem();

	if ((fspset->fsps_deleg_perm_avl_pool = uu_avl_pool_create(
	"deleg_perm_avl_pool", sizeof (deleg_perm_node_t), offsetof(
	deleg_perm_node_t, dpn_avl_node), deleg_perm_compare, UU_DEFAULT))
	== NULL)
	nomem();
	}

	static inline void fs_perm_fini(fs_perm_t *);
	static inline void who_perm_fini(who_perm_t *);

	static inline void
	fs_perm_set_fini(fs_perm_set_t *fspset)
	{
	fs_perm_node_t *node = uu_list_first(fspset->fsps_list);

	while (node != NULL) {
	fs_perm_node_t *next_node =
	uu_list_next(fspset->fsps_list, node);
	fs_perm_t *fsperm = &node->fspn_fsperm;
	fs_perm_fini(fsperm);
	uu_list_remove(fspset->fsps_list, node);
	free(node);
	node = next_node;
	}

	uu_avl_pool_destroy(fspset->fsps_named_set_avl_pool);
	uu_avl_pool_destroy(fspset->fsps_who_perm_avl_pool);
	uu_avl_pool_destroy(fspset->fsps_deleg_perm_avl_pool);
	}

	static inline void
	deleg_perm_init(deleg_perm_t *deleg_perm, zfs_deleg_who_type_t type,
	const char *name)
	{
	deleg_perm->dp_who_type = type;
	deleg_perm->dp_name = name;
	}

	static inline void
	who_perm_init(who_perm_t who_perm, fs_perm_t fsperm,
	zfs_deleg_who_type_t type, const char *name)
	{
	uu_avl_pool_t *pool;
	pool = fsperm->fsp_set->fsps_deleg_perm_avl_pool;

	bzero(who_perm, sizeof (who_perm_t));

	if ((who_perm->who_deleg_perm_avl = uu_avl_create(pool, NULL,
	UU_DEFAULT)) == NULL)
	nomem();

	who_perm->who_type = type;
	who_perm->who_name = name;
	who_perm->who_fsperm = fsperm;
	}

	static inline void
	who_perm_fini(who_perm_t *who_perm)
	{
	deleg_perm_node_t *node = uu_avl_first(who_perm->who_deleg_perm_avl);

	while (node != NULL) {
	deleg_perm_node_t *next_node =
	uu_avl_next(who_perm->who_deleg_perm_avl, node);

	uu_avl_remove(who_perm->who_deleg_perm_avl, node);
	free(node);
	node = next_node;
	}

	uu_avl_destroy(who_perm->who_deleg_perm_avl);
	}

	static inline void
	fs_perm_init(fs_perm_t fsperm, fs_perm_set_t fspset, const char *fsname)
	{
	uu_avl_pool_t *nset_pool = fspset->fsps_named_set_avl_pool;
	uu_avl_pool_t *who_pool = fspset->fsps_who_perm_avl_pool;

	bzero(fsperm, sizeof (fs_perm_t));

	if ((fsperm->fsp_sc_avl = uu_avl_create(nset_pool, NULL, UU_DEFAULT))
	== NULL)
	nomem();

	if ((fsperm->fsp_uge_avl = uu_avl_create(who_pool, NULL, UU_DEFAULT))
	== NULL)
	nomem();

	fsperm->fsp_set = fspset;
	fsperm->fsp_name = fsname;
	}

	static inline void
	fs_perm_fini(fs_perm_t *fsperm)
	{
	who_perm_node_t *node = uu_avl_first(fsperm->fsp_sc_avl);
	while (node != NULL) {
	who_perm_node_t *next_node = uu_avl_next(fsperm->fsp_sc_avl,
	node);
	who_perm_t *who_perm = &node->who_perm;
	who_perm_fini(who_perm);
	uu_avl_remove(fsperm->fsp_sc_avl, node);
	free(node);
	node = next_node;
	}

	node = uu_avl_first(fsperm->fsp_uge_avl);
	while (node != NULL) {
	who_perm_node_t *next_node = uu_avl_next(fsperm->fsp_uge_avl,
	node);
	who_perm_t *who_perm = &node->who_perm;
	who_perm_fini(who_perm);
	uu_avl_remove(fsperm->fsp_uge_avl, node);
	free(node);
	node = next_node;
	}

	uu_avl_destroy(fsperm->fsp_sc_avl);
	uu_avl_destroy(fsperm->fsp_uge_avl);
	}

	static void
	set_deleg_perm_node(uu_avl_t avl, deleg_perm_node_t node,
	zfs_deleg_who_type_t who_type, const char *name, char locality)
	{
	uu_avl_index_t idx = 0;

	deleg_perm_node_t *found_node = NULL;
	deleg_perm_t *deleg_perm = &node->dpn_perm;

	deleg_perm_init(deleg_perm, who_type, name);

	if ((found_node = uu_avl_find(avl, node, NULL, &idx))
	== NULL)
	uu_avl_insert(avl, node, idx);
	else {
	node = found_node;
	deleg_perm = &node->dpn_perm;
	}


	switch (locality) {
	case ZFS_DELEG_LOCAL:
	deleg_perm->dp_local = B_TRUE;
	break;
	case ZFS_DELEG_DESCENDENT:
	deleg_perm->dp_descend = B_TRUE;
	break;
	case ZFS_DELEG_NA:
	break;
	default:
	assert(B_FALSE); /* invalid locality */
	}
	}

	static inline int
	parse_who_perm(who_perm_t who_perm, nvlist_t nvl, char locality)
	{
	nvpair_t *nvp = NULL;
	fs_perm_set_t *fspset = who_perm->who_fsperm->fsp_set;
	uu_avl_t *avl = who_perm->who_deleg_perm_avl;
	zfs_deleg_who_type_t who_type = who_perm->who_type;

	while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
	const char *name = nvpair_name(nvp);
	data_type_t type = nvpair_type(nvp);
	uu_avl_pool_t *avl_pool = fspset->fsps_deleg_perm_avl_pool;
	deleg_perm_node_t *node =
	safe_malloc(sizeof (deleg_perm_node_t));

	VERIFY(type == DATA_TYPE_BOOLEAN);

	uu_avl_node_init(node, &node->dpn_avl_node, avl_pool);
	set_deleg_perm_node(avl, node, who_type, name, locality);
	}

	return (0);
	}

	static inline int
	parse_fs_perm(fs_perm_t fsperm, nvlist_t nvl)
	{
	nvpair_t *nvp = NULL;
	fs_perm_set_t *fspset = fsperm->fsp_set;

	while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
	nvlist_t *nvl2 = NULL;
	const char *name = nvpair_name(nvp);
	uu_avl_t *avl = NULL;
	uu_avl_pool_t *avl_pool = NULL;
	zfs_deleg_who_type_t perm_type = name[0];
	char perm_locality = name[1];
	const char *perm_name = name + 3;
	who_perm_t *who_perm = NULL;

	assert('$' == name[2]);

	if (nvpair_value_nvlist(nvp, &nvl2) != 0)
	return (-1);

	switch (perm_type) {
	case ZFS_DELEG_CREATE:
	case ZFS_DELEG_CREATE_SETS:
	case ZFS_DELEG_NAMED_SET:
	case ZFS_DELEG_NAMED_SET_SETS:
	avl_pool = fspset->fsps_named_set_avl_pool;
	avl = fsperm->fsp_sc_avl;
	break;
	case ZFS_DELEG_USER:
	case ZFS_DELEG_USER_SETS:
	case ZFS_DELEG_GROUP:
	case ZFS_DELEG_GROUP_SETS:
	case ZFS_DELEG_EVERYONE:
	case ZFS_DELEG_EVERYONE_SETS:
	avl_pool = fspset->fsps_who_perm_avl_pool;
	avl = fsperm->fsp_uge_avl;
	break;

	default:
	assert(!"unhandled zfs_deleg_who_type_t");
	}

	who_perm_node_t *found_node = NULL;
	who_perm_node_t *node = safe_malloc(
	sizeof (who_perm_node_t));
	who_perm = &node->who_perm;
	uu_avl_index_t idx = 0;

	uu_avl_node_init(node, &node->who_avl_node, avl_pool);
	who_perm_init(who_perm, fsperm, perm_type, perm_name);

	if ((found_node = uu_avl_find(avl, node, NULL, &idx))
	== NULL) {
	if (avl == fsperm->fsp_uge_avl) {
	uid_t rid = 0;
	struct passwd *p = NULL;
	struct group *g = NULL;
	const char *nice_name = NULL;

	switch (perm_type) {
	case ZFS_DELEG_USER_SETS:
	case ZFS_DELEG_USER:
	rid = atoi(perm_name);
	p = getpwuid(rid);
	if (p)
	nice_name = p->pw_name;
	break;
	case ZFS_DELEG_GROUP_SETS:
	case ZFS_DELEG_GROUP:
	rid = atoi(perm_name);
	g = getgrgid(rid);
	if (g)
	nice_name = g->gr_name;
	break;

	default:
	break;
	}

	if (nice_name != NULL) {
	(void) strlcpy(
	node->who_perm.who_ug_name,
	nice_name, 256);
	} else {
	/* User or group unknown */
	(void) snprintf(
	node->who_perm.who_ug_name,
	sizeof (node->who_perm.who_ug_name),
	"(unknown: %d)", rid);
	}
	}

	uu_avl_insert(avl, node, idx);
	} else {
	node = found_node;
	who_perm = &node->who_perm;
	}

	assert(who_perm != NULL);
	(void) parse_who_perm(who_perm, nvl2, perm_locality);
	}

	return (0);
	}

	static inline int
	parse_fs_perm_set(fs_perm_set_t fspset, nvlist_t nvl)
	{
	nvpair_t *nvp = NULL;
	uu_avl_index_t idx = 0;

	while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
	nvlist_t *nvl2 = NULL;
	const char *fsname = nvpair_name(nvp);
	data_type_t type = nvpair_type(nvp);
	fs_perm_t *fsperm = NULL;
	fs_perm_node_t *node = safe_malloc(sizeof (fs_perm_node_t));
	if (node == NULL)
	nomem();

	fsperm = &node->fspn_fsperm;

	VERIFY(DATA_TYPE_NVLIST == type);

	uu_list_node_init(node, &node->fspn_list_node,
	fspset->fsps_list_pool);

	idx = uu_list_numnodes(fspset->fsps_list);
	fs_perm_init(fsperm, fspset, fsname);

	if (nvpair_value_nvlist(nvp, &nvl2) != 0)
	return (-1);

	(void) parse_fs_perm(fsperm, nvl2);

	uu_list_insert(fspset->fsps_list, node, idx);
	}

	return (0);
	}

	static inline const char *
	deleg_perm_comment(zfs_deleg_note_t note)
	{
	const char *str = "";

	/* subcommands */
	switch (note) {
	/* SUBCOMMANDS */
	case ZFS_DELEG_NOTE_ALLOW:
	str = gettext("Must also have the permission that is being"
	"\n\t\t\t\tallowed");
	break;
	case ZFS_DELEG_NOTE_CLONE:
	str = gettext("Must also have the 'create' ability and 'mount'"
	"\n\t\t\t\tability in the origin file system");
	break;
	case ZFS_DELEG_NOTE_CREATE:
	str = gettext("Must also have the 'mount' ability");
	break;
	case ZFS_DELEG_NOTE_DESTROY:
	str = gettext("Must also have the 'mount' ability");
	break;
	case ZFS_DELEG_NOTE_DIFF:
	str = gettext("Allows lookup of paths within a dataset;"
	"\n\t\t\t\tgiven an object number. Ordinary users need this"
	"\n\t\t\t\tin order to use zfs diff");
	break;
	case ZFS_DELEG_NOTE_HOLD:
	str = gettext("Allows adding a user hold to a snapshot");
	break;
	case ZFS_DELEG_NOTE_MOUNT:
	str = gettext("Allows mount/umount of ZFS datasets");
	break;
	case ZFS_DELEG_NOTE_PROMOTE:
	str = gettext("Must also have the 'mount'\n\t\t\t\tand"
	" 'promote' ability in the origin file system");
	break;
	case ZFS_DELEG_NOTE_RECEIVE:
	str = gettext("Must also have the 'mount' and 'create'"
	" ability");
	break;
	case ZFS_DELEG_NOTE_RELEASE:
	str = gettext("Allows releasing a user hold which\n\t\t\t\t"
	"might destroy the snapshot");
	break;
	case ZFS_DELEG_NOTE_RENAME:
	str = gettext("Must also have the 'mount' and 'create'"
	"\n\t\t\t\tability in the new parent");
	break;
	case ZFS_DELEG_NOTE_ROLLBACK:
	str = gettext("");
	break;
	case ZFS_DELEG_NOTE_SEND:
	str = gettext("");
	break;
	case ZFS_DELEG_NOTE_SHARE:
	str = gettext("Allows sharing file systems over NFS or SMB"
	"\n\t\t\t\tprotocols");
	break;
	case ZFS_DELEG_NOTE_SNAPSHOT:
	str = gettext("");
	break;
	case ZFS_DELEG_NOTE_LOAD_KEY:
	str = gettext("Allows loading or unloading an encryption key");
	break;
	case ZFS_DELEG_NOTE_CHANGE_KEY:
	str = gettext("Allows changing or adding an encryption key");
	break;
	/*
	* case ZFS_DELEG_NOTE_VSCAN:
	* str = gettext("");
	* break;
	*/
	/* OTHER */
	case ZFS_DELEG_NOTE_GROUPQUOTA:
	str = gettext("Allows accessing any groupquota@... property");
	break;
	case ZFS_DELEG_NOTE_GROUPUSED:
	str = gettext("Allows reading any groupused@... property");
	break;
	case ZFS_DELEG_NOTE_USERPROP:
	str = gettext("Allows changing any user property");
	break;
	case ZFS_DELEG_NOTE_USERQUOTA:
	str = gettext("Allows accessing any userquota@... property");
	break;
	case ZFS_DELEG_NOTE_USERUSED:
	str = gettext("Allows reading any userused@... property");
	break;
	case ZFS_DELEG_NOTE_USEROBJQUOTA:
	str = gettext("Allows accessing any userobjquota@... property");
	break;
	case ZFS_DELEG_NOTE_GROUPOBJQUOTA:
	str = gettext("Allows accessing any \n\t\t\t\t"
	"groupobjquota@... property");
	break;
	case ZFS_DELEG_NOTE_GROUPOBJUSED:
	str = gettext("Allows reading any groupobjused@... property");
	break;
	case ZFS_DELEG_NOTE_USEROBJUSED:
	str = gettext("Allows reading any userobjused@... property");
	break;
	case ZFS_DELEG_NOTE_PROJECTQUOTA:
	str = gettext("Allows accessing any projectquota@... property");
	break;
	case ZFS_DELEG_NOTE_PROJECTOBJQUOTA:
	str = gettext("Allows accessing any \n\t\t\t\t"
	"projectobjquota@... property");
	break;
	case ZFS_DELEG_NOTE_PROJECTUSED:
	str = gettext("Allows reading any projectused@... property");
	break;
	case ZFS_DELEG_NOTE_PROJECTOBJUSED:
	str = gettext("Allows accessing any \n\t\t\t\t"
	"projectobjused@... property");
	break;
	/* other */
	default:
	str = "";
	}

	return (str);
	}

	struct allow_opts {
	boolean_t local;
	boolean_t descend;
	boolean_t user;
	boolean_t group;
	boolean_t everyone;
	boolean_t create;
	boolean_t set;
	boolean_t recursive; /* unallow only */
	boolean_t prt_usage;

	boolean_t prt_perms;
	char *who;
	char *perms;
	const char *dataset;
	};

	static inline int
	prop_cmp(const void a, const void b)
	{
	const char str1 = (const char **)a;
	const char str2 = (const char **)b;
	return (strcmp(str1, str2));
	}

	static void
	allow_usage(boolean_t un, boolean_t requested, const char *msg)
	{
	const char *opt_desc[] = {
	"-h", gettext("show this help message and exit"),
	"-l", gettext("set permission locally"),
	"-d", gettext("set permission for descents"),
	"-u", gettext("set permission for user"),
	"-g", gettext("set permission for group"),
	"-e", gettext("set permission for everyone"),
	"-c", gettext("set create time permission"),
	"-s", gettext("define permission set"),
	/* unallow only */
	"-r", gettext("remove permissions recursively"),
	};
	size_t unallow_size = sizeof (opt_desc) / sizeof (char *);
	size_t allow_size = unallow_size - 2;
	const char *props[ZFS_NUM_PROPS];
	int i;
	size_t count = 0;
	FILE *fp = requested ? stdout : stderr;
	zprop_desc_t *pdtbl = zfs_prop_get_table();
	const char *fmt = gettext("%-16s %-14s\t%s\n");

	(void) fprintf(fp, gettext("Usage: %s\n"), get_usage(un ? HELP_UNALLOW :
	HELP_ALLOW));
	(void) fprintf(fp, gettext("Options:\n"));
	for (i = 0; i < (un ? unallow_size : allow_size); i += 2) {
	const char *opt = opt_desc[i];
	const char *optdsc = opt_desc[i + 1];
	(void) fprintf(fp, gettext(" %-10s %s\n"), opt, optdsc);
	}

	(void) fprintf(fp, gettext("\nThe following permissions are "
	"supported:\n\n"));
	(void) fprintf(fp, fmt, gettext("NAME"), gettext("TYPE"),
	gettext("NOTES"));
	for (i = 0; i < ZFS_NUM_DELEG_NOTES; i++) {
	const char *perm_name = zfs_deleg_perm_tbl[i].z_perm;
	zfs_deleg_note_t perm_note = zfs_deleg_perm_tbl[i].z_note;
	const char *perm_type = deleg_perm_type(perm_note);
	const char *perm_comment = deleg_perm_comment(perm_note);
	(void) fprintf(fp, fmt, perm_name, perm_type, perm_comment);
	}

	for (i = 0; i < ZFS_NUM_PROPS; i++) {
	zprop_desc_t *pd = &pdtbl[i];
	if (pd->pd_visible != B_TRUE)
	continue;

	if (pd->pd_attr == PROP_READONLY)
	continue;

	props[count++] = pd->pd_name;
	}
	props[count] = NULL;

	qsort(props, count, sizeof (char *), prop_cmp);

	for (i = 0; i < count; i++)
	(void) fprintf(fp, fmt, props[i], gettext("property"), "");

	if (msg != NULL)
	(void) fprintf(fp, gettext("\nzfs: error: %s"), msg);

	exit(requested ? 0 : 2);
	}

	static inline const char *
	munge_args(int argc, char **argv, boolean_t un, size_t expected_argc,
	char **permsp)
	{
	if (un && argc == expected_argc - 1)
	*permsp = NULL;
	else if (argc == expected_argc)
	*permsp = argv[argc - 2];
	else
	allow_usage(un, B_FALSE,
	gettext("wrong number of parameters\n"));

	return (argv[argc - 1]);
	}

	static void
	parse_allow_args(int argc, char *argv, boolean_t un, struct allow_opts opts)
	{
	int uge_sum = opts->user + opts->group + opts->everyone;
	int csuge_sum = opts->create + opts->set + uge_sum;
	int ldcsuge_sum = csuge_sum + opts->local + opts->descend;
	int all_sum = un ? ldcsuge_sum + opts->recursive : ldcsuge_sum;

	if (uge_sum > 1)
	allow_usage(un, B_FALSE,
	gettext("-u, -g, and -e are mutually exclusive\n"));

	if (opts->prt_usage) {
	if (argc == 0 && all_sum == 0)
	allow_usage(un, B_TRUE, NULL);
	else
	usage(B_FALSE);
	}

	if (opts->set) {
	if (csuge_sum > 1)
	allow_usage(un, B_FALSE,
	gettext("invalid options combined with -s\n"));

	opts->dataset = munge_args(argc, argv, un, 3, &opts->perms);
	if (argv[0][0] != '@')
	allow_usage(un, B_FALSE,
	gettext("invalid set name: missing '@' prefix\n"));
	opts->who = argv[0];
	} else if (opts->create) {
	if (ldcsuge_sum > 1)
	allow_usage(un, B_FALSE,
	gettext("invalid options combined with -c\n"));
	opts->dataset = munge_args(argc, argv, un, 2, &opts->perms);
	} else if (opts->everyone) {
	if (csuge_sum > 1)
	allow_usage(un, B_FALSE,
	gettext("invalid options combined with -e\n"));
	opts->dataset = munge_args(argc, argv, un, 2, &opts->perms);
	} else if (uge_sum == 0 && argc > 0 && strcmp(argv[0], "everyone")
	== 0) {
	opts->everyone = B_TRUE;
	argc--;
	argv++;
	opts->dataset = munge_args(argc, argv, un, 2, &opts->perms);
	} else if (argc == 1 && !un) {
	opts->prt_perms = B_TRUE;
	opts->dataset = argv[argc-1];
	} else {
	opts->dataset = munge_args(argc, argv, un, 3, &opts->perms);
	opts->who = argv[0];
	}

	if (!opts->local && !opts->descend) {
	opts->local = B_TRUE;
	opts->descend = B_TRUE;
	}
	}

	static void
	store_allow_perm(zfs_deleg_who_type_t type, boolean_t local, boolean_t descend,
	const char who, char perms, nvlist_t *top_nvl)
	{
	int i;
	char ld[2] = { '\0', '\0' };
	char who_buf[MAXNAMELEN + 32];
	char base_type = '\0';
	char set_type = '\0';
	nvlist_t *base_nvl = NULL;
	nvlist_t *set_nvl = NULL;
	nvlist_t *nvl;

	if (nvlist_alloc(&base_nvl, NV_UNIQUE_NAME, 0) != 0)
	nomem();
	if (nvlist_alloc(&set_nvl, NV_UNIQUE_NAME, 0) != 0)
	nomem();

	switch (type) {
	case ZFS_DELEG_NAMED_SET_SETS:
	case ZFS_DELEG_NAMED_SET:
	set_type = ZFS_DELEG_NAMED_SET_SETS;
	base_type = ZFS_DELEG_NAMED_SET;
	ld[0] = ZFS_DELEG_NA;
	break;
	case ZFS_DELEG_CREATE_SETS:
	case ZFS_DELEG_CREATE:
	set_type = ZFS_DELEG_CREATE_SETS;
	base_type = ZFS_DELEG_CREATE;
	ld[0] = ZFS_DELEG_NA;
	break;
	case ZFS_DELEG_USER_SETS:
	case ZFS_DELEG_USER:
	set_type = ZFS_DELEG_USER_SETS;
	base_type = ZFS_DELEG_USER;
	if (local)
	ld[0] = ZFS_DELEG_LOCAL;
	if (descend)
	ld[1] = ZFS_DELEG_DESCENDENT;
	break;
	case ZFS_DELEG_GROUP_SETS:
	case ZFS_DELEG_GROUP:
	set_type = ZFS_DELEG_GROUP_SETS;
	base_type = ZFS_DELEG_GROUP;
	if (local)
	ld[0] = ZFS_DELEG_LOCAL;
	if (descend)
	ld[1] = ZFS_DELEG_DESCENDENT;
	break;
	case ZFS_DELEG_EVERYONE_SETS:
	case ZFS_DELEG_EVERYONE:
	set_type = ZFS_DELEG_EVERYONE_SETS;
	base_type = ZFS_DELEG_EVERYONE;
	if (local)
	ld[0] = ZFS_DELEG_LOCAL;
	if (descend)
	ld[1] = ZFS_DELEG_DESCENDENT;
	break;

	default:
	assert(set_type != '\0' && base_type != '\0');
	}

	if (perms != NULL) {
	char *curr = perms;
	char *end = curr + strlen(perms);

	while (curr < end) {
	char *delim = strchr(curr, ',');
	if (delim == NULL)
	delim = end;
	else
	*delim = '\0';

	if (curr[0] == '@')
	nvl = set_nvl;
	else
	nvl = base_nvl;

	(void) nvlist_add_boolean(nvl, curr);
	if (delim != end)
	*delim = ',';
	curr = delim + 1;
	}

	for (i = 0; i < 2; i++) {
	char locality = ld[i];
	if (locality == 0)
	continue;

	if (!nvlist_empty(base_nvl)) {
	if (who != NULL)
	(void) snprintf(who_buf,
	sizeof (who_buf), "%c%c$%s",
	base_type, locality, who);
	else
	(void) snprintf(who_buf,
	sizeof (who_buf), "%c%c$",
	base_type, locality);

	(void) nvlist_add_nvlist(top_nvl, who_buf,
	base_nvl);
	}


	if (!nvlist_empty(set_nvl)) {
	if (who != NULL)
	(void) snprintf(who_buf,
	sizeof (who_buf), "%c%c$%s",
	set_type, locality, who);
	else
	(void) snprintf(who_buf,
	sizeof (who_buf), "%c%c$",
	set_type, locality);

	(void) nvlist_add_nvlist(top_nvl, who_buf,
	set_nvl);
	}
	}
	} else {
	for (i = 0; i < 2; i++) {
	char locality = ld[i];
	if (locality == 0)
	continue;

	if (who != NULL)
	(void) snprintf(who_buf, sizeof (who_buf),
	"%c%c$%s", base_type, locality, who);
	else
	(void) snprintf(who_buf, sizeof (who_buf),
	"%c%c$", base_type, locality);
	(void) nvlist_add_boolean(top_nvl, who_buf);

	if (who != NULL)
	(void) snprintf(who_buf, sizeof (who_buf),
	"%c%c$%s", set_type, locality, who);
	else
	(void) snprintf(who_buf, sizeof (who_buf),
	"%c%c$", set_type, locality);
	(void) nvlist_add_boolean(top_nvl, who_buf);
	}
	}
	}

	static int
	construct_fsacl_list(boolean_t un, struct allow_opts opts, nvlist_t *nvlp)
	{
	if (nvlist_alloc(nvlp, NV_UNIQUE_NAME, 0) != 0)
	nomem();

	if (opts->set) {
	store_allow_perm(ZFS_DELEG_NAMED_SET, opts->local,
	opts->descend, opts->who, opts->perms, *nvlp);
	} else if (opts->create) {
	store_allow_perm(ZFS_DELEG_CREATE, opts->local,
	opts->descend, NULL, opts->perms, *nvlp);
	} else if (opts->everyone) {
	store_allow_perm(ZFS_DELEG_EVERYONE, opts->local,
	opts->descend, NULL, opts->perms, *nvlp);
	} else {
	char *curr = opts->who;
	char *end = curr + strlen(curr);

	while (curr < end) {
	const char *who;
	zfs_deleg_who_type_t who_type = ZFS_DELEG_WHO_UNKNOWN;
	char *endch;
	char *delim = strchr(curr, ',');
	char errbuf[256];
	char id[64];
	struct passwd *p = NULL;
	struct group *g = NULL;

	uid_t rid;
	if (delim == NULL)
	delim = end;
	else
	*delim = '\0';

	rid = (uid_t)strtol(curr, &endch, 0);
	if (opts->user) {
	who_type = ZFS_DELEG_USER;
	if (*endch != '\0')
	p = getpwnam(curr);
	else
	p = getpwuid(rid);

	if (p != NULL)
	rid = p->pw_uid;
	else if (*endch != '\0') {
	(void) snprintf(errbuf, 256, gettext(
	"invalid user %s\n"), curr);
	allow_usage(un, B_TRUE, errbuf);
	}
	} else if (opts->group) {
	who_type = ZFS_DELEG_GROUP;
	if (*endch != '\0')
	g = getgrnam(curr);
	else
	g = getgrgid(rid);

	if (g != NULL)
	rid = g->gr_gid;
	else if (*endch != '\0') {
	(void) snprintf(errbuf, 256, gettext(
	"invalid group %s\n"), curr);
	allow_usage(un, B_TRUE, errbuf);
	}
	} else {
	if (*endch != '\0') {
	p = getpwnam(curr);
	} else {
	p = getpwuid(rid);
	}

	if (p == NULL) {
	if (*endch != '\0') {
	g = getgrnam(curr);
	} else {
	g = getgrgid(rid);
	}
	}

	if (p != NULL) {
	who_type = ZFS_DELEG_USER;
	rid = p->pw_uid;
	} else if (g != NULL) {
	who_type = ZFS_DELEG_GROUP;
	rid = g->gr_gid;
	} else {
	(void) snprintf(errbuf, 256, gettext(
	"invalid user/group %s\n"), curr);
	allow_usage(un, B_TRUE, errbuf);
	}
	}

	(void) sprintf(id, "%u", rid);
	who = id;

	store_allow_perm(who_type, opts->local,
	opts->descend, who, opts->perms, *nvlp);
	curr = delim + 1;
	}
	}

	return (0);
	}

	static void
	print_set_creat_perms(uu_avl_t *who_avl)
	{
	const char *sc_title[] = {
	gettext("Permission sets:\n"),
	gettext("Create time permissions:\n"),
	NULL
	};
	who_perm_node_t *who_node = NULL;
	int prev_weight = -1;

	for (who_node = uu_avl_first(who_avl); who_node != NULL;
	who_node = uu_avl_next(who_avl, who_node)) {
	uu_avl_t *avl = who_node->who_perm.who_deleg_perm_avl;
	zfs_deleg_who_type_t who_type = who_node->who_perm.who_type;
	const char *who_name = who_node->who_perm.who_name;
	int weight = who_type2weight(who_type);
	boolean_t first = B_TRUE;
	deleg_perm_node_t *deleg_node;

	if (prev_weight != weight) {
	(void) printf("%s", sc_title[weight]);
	prev_weight = weight;
	}

	if (who_name == NULL \|\| strnlen(who_name, 1) == 0)
	(void) printf("\t");
	else
	(void) printf("\t%s ", who_name);

	for (deleg_node = uu_avl_first(avl); deleg_node != NULL;
	deleg_node = uu_avl_next(avl, deleg_node)) {
	if (first) {
	(void) printf("%s",
	deleg_node->dpn_perm.dp_name);
	first = B_FALSE;
	} else
	(void) printf(",%s",
	deleg_node->dpn_perm.dp_name);
	}

	(void) printf("\n");
	}
	}

	static void
	print_uge_deleg_perms(uu_avl_t *who_avl, boolean_t local, boolean_t descend,
	const char *title)
	{
	who_perm_node_t *who_node = NULL;
	boolean_t prt_title = B_TRUE;
	uu_avl_walk_t *walk;

	if ((walk = uu_avl_walk_start(who_avl, UU_WALK_ROBUST)) == NULL)
	nomem();

	while ((who_node = uu_avl_walk_next(walk)) != NULL) {
	const char *who_name = who_node->who_perm.who_name;
	const char *nice_who_name = who_node->who_perm.who_ug_name;
	uu_avl_t *avl = who_node->who_perm.who_deleg_perm_avl;
	zfs_deleg_who_type_t who_type = who_node->who_perm.who_type;
	char delim = ' ';
	deleg_perm_node_t *deleg_node;
	boolean_t prt_who = B_TRUE;

	for (deleg_node = uu_avl_first(avl);
	deleg_node != NULL;
	deleg_node = uu_avl_next(avl, deleg_node)) {
	if (local != deleg_node->dpn_perm.dp_local \|\|
	descend != deleg_node->dpn_perm.dp_descend)
	continue;

	if (prt_who) {
	const char *who = NULL;
	if (prt_title) {
	prt_title = B_FALSE;
	(void) printf("%s", title);
	}

	switch (who_type) {
	case ZFS_DELEG_USER_SETS:
	case ZFS_DELEG_USER:
	who = gettext("user");
	if (nice_who_name)
	who_name = nice_who_name;
	break;
	case ZFS_DELEG_GROUP_SETS:
	case ZFS_DELEG_GROUP:
	who = gettext("group");
	if (nice_who_name)
	who_name = nice_who_name;
	break;
	case ZFS_DELEG_EVERYONE_SETS:
	case ZFS_DELEG_EVERYONE:
	who = gettext("everyone");
	who_name = NULL;
	break;

	default:
	assert(who != NULL);
	}

	prt_who = B_FALSE;
	if (who_name == NULL)
	(void) printf("\t%s", who);
	else
	(void) printf("\t%s %s", who, who_name);
	}

	(void) printf("%c%s", delim,
	deleg_node->dpn_perm.dp_name);
	delim = ',';
	}

	if (!prt_who)
	(void) printf("\n");
	}

	uu_avl_walk_end(walk);
	}

	static void
	print_fs_perms(fs_perm_set_t *fspset)
	{
	fs_perm_node_t *node = NULL;
	char buf[MAXNAMELEN + 32];
	const char *dsname = buf;

	for (node = uu_list_first(fspset->fsps_list); node != NULL;
	node = uu_list_next(fspset->fsps_list, node)) {
	uu_avl_t *sc_avl = node->fspn_fsperm.fsp_sc_avl;
	uu_avl_t *uge_avl = node->fspn_fsperm.fsp_uge_avl;
	int left = 0;

	(void) snprintf(buf, sizeof (buf),
	gettext("---- Permissions on %s "),
	node->fspn_fsperm.fsp_name);
	(void) printf("%s", dsname);
	left = 70 - strlen(buf);
	while (left-- > 0)
	(void) printf("-");
	(void) printf("\n");

	print_set_creat_perms(sc_avl);
	print_uge_deleg_perms(uge_avl, B_TRUE, B_FALSE,
	gettext("Local permissions:\n"));
	print_uge_deleg_perms(uge_avl, B_FALSE, B_TRUE,
	gettext("Descendent permissions:\n"));
	print_uge_deleg_perms(uge_avl, B_TRUE, B_TRUE,
	gettext("Local+Descendent permissions:\n"));
	}
	}

	static fs_perm_set_t fs_perm_set = { NULL, NULL, NULL, NULL };

	struct deleg_perms {
	boolean_t un;
	nvlist_t *nvl;
	};

	static int
	set_deleg_perms(zfs_handle_t zhp, void data)
	{
	struct deleg_perms perms = (struct deleg_perms )data;
	zfs_type_t zfs_type = zfs_get_type(zhp);

	if (zfs_type != ZFS_TYPE_FILESYSTEM && zfs_type != ZFS_TYPE_VOLUME)
	return (0);

	return (zfs_set_fsacl(zhp, perms->un, perms->nvl));
	}

	static int
	zfs_do_allow_unallow_impl(int argc, char **argv, boolean_t un)
	{
	zfs_handle_t *zhp;
	nvlist_t *perm_nvl = NULL;
	nvlist_t *update_perm_nvl = NULL;
	int error = 1;
	int c;
	struct allow_opts opts = { 0 };

	const char *optstr = un ? "ldugecsrh" : "ldugecsh";

	/* check opts */
	while ((c = getopt(argc, argv, optstr)) != -1) {
	switch (c) {
	case 'l':
	opts.local = B_TRUE;
	break;
	case 'd':
	opts.descend = B_TRUE;
	break;
	case 'u':
	opts.user = B_TRUE;
	break;
	case 'g':
	opts.group = B_TRUE;
	break;
	case 'e':
	opts.everyone = B_TRUE;
	break;
	case 's':
	opts.set = B_TRUE;
	break;
	case 'c':
	opts.create = B_TRUE;
	break;
	case 'r':
	opts.recursive = B_TRUE;
	break;
	case ':':
	(void) fprintf(stderr, gettext("missing argument for "
	"'%c' option\n"), optopt);
	usage(B_FALSE);
	break;
	case 'h':
	opts.prt_usage = B_TRUE;
	break;
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	argc -= optind;
	argv += optind;

	/* check arguments */
	parse_allow_args(argc, argv, un, &opts);

	/* try to open the dataset */
	if ((zhp = zfs_open(g_zfs, opts.dataset, ZFS_TYPE_FILESYSTEM \|
	ZFS_TYPE_VOLUME)) == NULL) {
	(void) fprintf(stderr, "Failed to open dataset: %s\n",
	opts.dataset);
	return (-1);
	}

	if (zfs_get_fsacl(zhp, &perm_nvl) != 0)
	goto cleanup2;

	fs_perm_set_init(&fs_perm_set);
	if (parse_fs_perm_set(&fs_perm_set, perm_nvl) != 0) {
	(void) fprintf(stderr, "Failed to parse fsacl permissions\n");
	goto cleanup1;
	}

	if (opts.prt_perms)
	print_fs_perms(&fs_perm_set);
	else {
	(void) construct_fsacl_list(un, &opts, &update_perm_nvl);
	if (zfs_set_fsacl(zhp, un, update_perm_nvl) != 0)
	goto cleanup0;

	if (un && opts.recursive) {
	struct deleg_perms data = { un, update_perm_nvl };
	if (zfs_iter_filesystems(zhp, set_deleg_perms,
	&data) != 0)
	goto cleanup0;
	}
	}

	error = 0;

	cleanup0:
	nvlist_free(perm_nvl);
	nvlist_free(update_perm_nvl);
	cleanup1:
	fs_perm_set_fini(&fs_perm_set);
	cleanup2:
	zfs_close(zhp);

	return (error);
	}

	static int
	zfs_do_allow(int argc, char **argv)
	{
	return (zfs_do_allow_unallow_impl(argc, argv, B_FALSE));
	}

	static int
	zfs_do_unallow(int argc, char **argv)
	{
	return (zfs_do_allow_unallow_impl(argc, argv, B_TRUE));
	}

	static int
	zfs_do_hold_rele_impl(int argc, char **argv, boolean_t holding)
	{
	int errors = 0;
	int i;
	const char *tag;
	boolean_t recursive = B_FALSE;
	const char *opts = holding ? "rt" : "r";
	int c;

	/* check options */
	while ((c = getopt(argc, argv, opts)) != -1) {
	switch (c) {
	case 'r':
	recursive = B_TRUE;
	break;
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	argc -= optind;
	argv += optind;

	/* check number of arguments */
	if (argc < 2)
	usage(B_FALSE);

	tag = argv[0];
	--argc;
	++argv;

	if (holding && tag[0] == '.') {
	/* tags starting with '.' are reserved for libzfs */
	(void) fprintf(stderr, gettext("tag may not start with '.'\n"));
	usage(B_FALSE);
	}

	for (i = 0; i < argc; ++i) {
	zfs_handle_t *zhp;
	char parent[ZFS_MAX_DATASET_NAME_LEN];
	const char *delim;
	char *path = argv[i];

	delim = strchr(path, '@');
	if (delim == NULL) {
	(void) fprintf(stderr,
	gettext("'%s' is not a snapshot\n"), path);
	++errors;
	continue;
	}
	(void) strncpy(parent, path, delim - path);
	parent[delim - path] = '\0';

	zhp = zfs_open(g_zfs, parent,
	ZFS_TYPE_FILESYSTEM \| ZFS_TYPE_VOLUME);
	if (zhp == NULL) {
	++errors;
	continue;
	}
	if (holding) {
	if (zfs_hold(zhp, delim+1, tag, recursive, -1) != 0)
	++errors;
	} else {
	if (zfs_release(zhp, delim+1, tag, recursive) != 0)
	++errors;
	}
	zfs_close(zhp);
	}

	return (errors != 0);
	}

	/*
	* zfs hold [-r] [-t] <tag> <snap> ...
	*
	* -r Recursively hold
	*
	* Apply a user-hold with the given tag to the list of snapshots.
	*/
	static int
	zfs_do_hold(int argc, char **argv)
	{
	return (zfs_do_hold_rele_impl(argc, argv, B_TRUE));
	}

	/*
	* zfs release [-r] <tag> <snap> ...
	*
	* -r Recursively release
	*
	* Release a user-hold with the given tag from the list of snapshots.
	*/
	static int
	zfs_do_release(int argc, char **argv)
	{
	return (zfs_do_hold_rele_impl(argc, argv, B_FALSE));
	}

	typedef struct holds_cbdata {
	boolean_t cb_recursive;
	const char *cb_snapname;
	nvlist_t **cb_nvlp;
	size_t cb_max_namelen;
	size_t cb_max_taglen;
	} holds_cbdata_t;

	#define STRFTIME_FMT_STR "%a %b %e %H:%M %Y"
	#define DATETIME_BUF_LEN (32)
	/*
	*
	*/
	static void
	print_holds(boolean_t scripted, int nwidth, int tagwidth, nvlist_t *nvl)
	{
	int i;
	nvpair_t *nvp = NULL;
	char *hdr_cols[] = { "NAME", "TAG", "TIMESTAMP" };
	const char *col;

	if (!scripted) {
	for (i = 0; i < 3; i++) {
	col = gettext(hdr_cols[i]);
	if (i < 2)
	(void) printf("%-*s ", i ? tagwidth : nwidth,
	col);
	else
	(void) printf("%s\n", col);
	}
	}

	while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
	char *zname = nvpair_name(nvp);
	nvlist_t *nvl2;
	nvpair_t *nvp2 = NULL;
	(void) nvpair_value_nvlist(nvp, &nvl2);
	while ((nvp2 = nvlist_next_nvpair(nvl2, nvp2)) != NULL) {
	char tsbuf[DATETIME_BUF_LEN];
	char *tagname = nvpair_name(nvp2);
	uint64_t val = 0;
	time_t time;
	struct tm t;

	(void) nvpair_value_uint64(nvp2, &val);
	time = (time_t)val;
	(void) localtime_r(&time, &t);
	(void) strftime(tsbuf, DATETIME_BUF_LEN,
	gettext(STRFTIME_FMT_STR), &t);

	if (scripted) {
	(void) printf("%s\t%s\t%s\n", zname,
	tagname, tsbuf);
	} else {
	(void) printf("%-s %-s %s\n", nwidth,
	zname, tagwidth, tagname, tsbuf);
	}
	}
	}
	}

	/*
	* Generic callback function to list a dataset or snapshot.
	*/
	static int
	holds_callback(zfs_handle_t zhp, void data)
	{
	holds_cbdata_t *cbp = data;
	nvlist_t top_nvl = cbp->cb_nvlp;
	nvlist_t *nvl = NULL;
	nvpair_t *nvp = NULL;
	const char *zname = zfs_get_name(zhp);
	size_t znamelen = strlen(zname);

	if (cbp->cb_recursive) {
	const char *snapname;
	char *delim = strchr(zname, '@');
	if (delim == NULL)
	return (0);

	snapname = delim + 1;
	if (strcmp(cbp->cb_snapname, snapname))
	return (0);
	}

	if (zfs_get_holds(zhp, &nvl) != 0)
	return (-1);

	if (znamelen > cbp->cb_max_namelen)
	cbp->cb_max_namelen = znamelen;

	while ((nvp = nvlist_next_nvpair(nvl, nvp)) != NULL) {
	const char *tag = nvpair_name(nvp);
	size_t taglen = strlen(tag);
	if (taglen > cbp->cb_max_taglen)
	cbp->cb_max_taglen = taglen;
	}

	return (nvlist_add_nvlist(top_nvl, zname, nvl));
	}

	/*
	* zfs holds [-rH] <snap> ...
	*
	* -r Lists holds that are set on the named snapshots recursively.
	* -H Scripted mode; elide headers and separate columns by tabs.
	*/
	static int
	zfs_do_holds(int argc, char **argv)
	{
	int errors = 0;
	int c;
	int i;
	boolean_t scripted = B_FALSE;
	boolean_t recursive = B_FALSE;
	const char *opts = "rH";
	nvlist_t *nvl;

	int types = ZFS_TYPE_SNAPSHOT;
	holds_cbdata_t cb = { 0 };

	int limit = 0;
	int ret = 0;
	int flags = 0;

	/* check options */
	while ((c = getopt(argc, argv, opts)) != -1) {
	switch (c) {
	case 'r':
	recursive = B_TRUE;
	break;
	case 'H':
	scripted = B_TRUE;
	break;
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	if (recursive) {
	types \|= ZFS_TYPE_FILESYSTEM \| ZFS_TYPE_VOLUME;
	flags \|= ZFS_ITER_RECURSE;
	}

	argc -= optind;
	argv += optind;

	/* check number of arguments */
	if (argc < 1)
	usage(B_FALSE);

	if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0)
	nomem();

	for (i = 0; i < argc; ++i) {
	char *snapshot = argv[i];
	const char *delim;
	const char *snapname;

	delim = strchr(snapshot, '@');
	if (delim == NULL) {
	(void) fprintf(stderr,
	gettext("'%s' is not a snapshot\n"), snapshot);
	++errors;
	continue;
	}
	snapname = delim + 1;
	if (recursive)
	snapshot[delim - snapshot] = '\0';

	cb.cb_recursive = recursive;
	cb.cb_snapname = snapname;
	cb.cb_nvlp = &nvl;

	/*
	* 1. collect holds data, set format options
	*/
	ret = zfs_for_each(argc, argv, flags, types, NULL, NULL, limit,
	holds_callback, &cb);
	if (ret != 0)
	++errors;
	}

	/*
	* 2. print holds data
	*/
	print_holds(scripted, cb.cb_max_namelen, cb.cb_max_taglen, nvl);

	if (nvlist_empty(nvl))
	(void) fprintf(stderr, gettext("no datasets available\n"));

	nvlist_free(nvl);

	return (0 != errors);
	}

	#define CHECK_SPINNER 30
	#define SPINNER_TIME 3 /* seconds */
	#define MOUNT_TIME 1 /* seconds */

	typedef struct get_all_state {
	boolean_t ga_verbose;
	get_all_cb_t *ga_cbp;
	} get_all_state_t;

	static int
	get_one_dataset(zfs_handle_t zhp, void data)
	{
	static char *spin[] = { "-", "\\", "\|", "/" };
	static int spinval = 0;
	static int spincheck = 0;
	static time_t last_spin_time = (time_t)0;
	get_all_state_t *state = data;
	zfs_type_t type = zfs_get_type(zhp);

	if (state->ga_verbose) {
	if (--spincheck < 0) {
	time_t now = time(NULL);
	if (last_spin_time + SPINNER_TIME < now) {
	update_progress(spin[spinval++ % 4]);
	last_spin_time = now;
	}
	spincheck = CHECK_SPINNER;
	}
	}

	/*
	* Iterate over any nested datasets.
	*/
	if (zfs_iter_filesystems(zhp, get_one_dataset, data) != 0) {
	zfs_close(zhp);
	return (1);
	}

	/*
	* Skip any datasets whose type does not match.
	*/
	if ((type & ZFS_TYPE_FILESYSTEM) == 0) {
	zfs_close(zhp);
	return (0);
	}
	libzfs_add_handle(state->ga_cbp, zhp);
	assert(state->ga_cbp->cb_used <= state->ga_cbp->cb_alloc);

	return (0);
	}

	static void
	get_all_datasets(get_all_cb_t *cbp, boolean_t verbose)
	{
	get_all_state_t state = {
	.ga_verbose = verbose,
	.ga_cbp = cbp
	};

	if (verbose)
	set_progress_header(gettext("Reading ZFS config"));
	(void) zfs_iter_root(g_zfs, get_one_dataset, &state);

	if (verbose)
	finish_progress(gettext("done."));
	}

	/*
	* Generic callback for sharing or mounting filesystems. Because the code is so
	* similar, we have a common function with an extra parameter to determine which
	* mode we are using.
	*/
	typedef enum { OP_SHARE, OP_MOUNT } share_mount_op_t;

	typedef struct share_mount_state {
	share_mount_op_t sm_op;
	boolean_t sm_verbose;
	int sm_flags;
	char *sm_options;
	char sm_proto; / only valid for OP_SHARE */
	pthread_mutex_t sm_lock; /* protects the remaining fields */
	uint_t sm_total; /* number of filesystems to process */
	uint_t sm_done; /* number of filesystems processed */
	int sm_status; /* -1 if any of the share/mount operations failed */
	} share_mount_state_t;

	/*
	* Share or mount a dataset.
	*/
	static int
	share_mount_one(zfs_handle_t zhp, int op, int flags, char protocol,
	boolean_t explicit, const char *options)
	{
	char mountpoint[ZFS_MAXPROPLEN];
	char shareopts[ZFS_MAXPROPLEN];
	char smbshareopts[ZFS_MAXPROPLEN];
	const char *cmdname = op == OP_SHARE ? "share" : "mount";
	struct mnttab mnt;
	uint64_t zoned, canmount;
	boolean_t shared_nfs, shared_smb;

	assert(zfs_get_type(zhp) & ZFS_TYPE_FILESYSTEM);

	/*
	* Check to make sure we can mount/share this dataset. If we
	* are in the global zone and the filesystem is exported to a
	* local zone, or if we are in a local zone and the
	* filesystem is not exported, then it is an error.
	*/
	zoned = zfs_prop_get_int(zhp, ZFS_PROP_ZONED);

	if (zoned && getzoneid() == GLOBAL_ZONEID) {
	if (!explicit)
	return (0);

	(void) fprintf(stderr, gettext("cannot %s '%s': "
	"dataset is exported to a local zone\n"), cmdname,
	zfs_get_name(zhp));
	return (1);

	} else if (!zoned && getzoneid() != GLOBAL_ZONEID) {
	if (!explicit)
	return (0);

	(void) fprintf(stderr, gettext("cannot %s '%s': "
	"permission denied\n"), cmdname,
	zfs_get_name(zhp));
	return (1);
	}

	/*
	* Ignore any filesystems which don't apply to us. This
	* includes those with a legacy mountpoint, or those with
	* legacy share options.
	*/
	verify(zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mountpoint,
	sizeof (mountpoint), NULL, NULL, 0, B_FALSE) == 0);
	verify(zfs_prop_get(zhp, ZFS_PROP_SHARENFS, shareopts,
	sizeof (shareopts), NULL, NULL, 0, B_FALSE) == 0);
	verify(zfs_prop_get(zhp, ZFS_PROP_SHARESMB, smbshareopts,
	sizeof (smbshareopts), NULL, NULL, 0, B_FALSE) == 0);

	if (op == OP_SHARE && strcmp(shareopts, "off") == 0 &&
	strcmp(smbshareopts, "off") == 0) {
	if (!explicit)
	return (0);

	(void) fprintf(stderr, gettext("cannot share '%s': "
	"legacy share\n"), zfs_get_name(zhp));
	(void) fprintf(stderr, gettext("use exports(5) or "
	"smb.conf(5) to share this filesystem, or set "
	"the sharenfs or sharesmb property\n"));
	return (1);
	}

	/*
	* We cannot share or mount legacy filesystems. If the
	* shareopts is non-legacy but the mountpoint is legacy, we
	* treat it as a legacy share.
	*/
	if (strcmp(mountpoint, "legacy") == 0) {
	if (!explicit)
	return (0);

	(void) fprintf(stderr, gettext("cannot %s '%s': "
	"legacy mountpoint\n"), cmdname, zfs_get_name(zhp));
	(void) fprintf(stderr, gettext("use %s(8) to "
	"%s this filesystem\n"), cmdname, cmdname);
	return (1);
	}

	if (strcmp(mountpoint, "none") == 0) {
	if (!explicit)
	return (0);

	(void) fprintf(stderr, gettext("cannot %s '%s': no "
	"mountpoint set\n"), cmdname, zfs_get_name(zhp));
	return (1);
	}

	/*
	* canmount explicit outcome
	* on no pass through
	* on yes pass through
	* off no return 0
	* off yes display error, return 1
	* noauto no return 0
	* noauto yes pass through
	*/
	canmount = zfs_prop_get_int(zhp, ZFS_PROP_CANMOUNT);
	if (canmount == ZFS_CANMOUNT_OFF) {
	if (!explicit)
	return (0);

	(void) fprintf(stderr, gettext("cannot %s '%s': "
	"'canmount' property is set to 'off'\n"), cmdname,
	zfs_get_name(zhp));
	return (1);
	} else if (canmount == ZFS_CANMOUNT_NOAUTO && !explicit) {
	/*
	* When performing a 'zfs mount -a', we skip any mounts for
	* datasets that have 'noauto' set. Sharing a dataset with
	* 'noauto' set is only allowed if it's mounted.
	*/
	if (op == OP_MOUNT)
	return (0);
	if (op == OP_SHARE && !zfs_is_mounted(zhp, NULL)) {
	/* also purge it from existing exports */
	zfs_unshareall_bypath(zhp, mountpoint);
	return (0);
	}
	}

	/*
	* If this filesystem is encrypted and does not have
	* a loaded key, we can not mount it.
	*/
	if ((flags & MS_CRYPT) == 0 &&
	zfs_prop_get_int(zhp, ZFS_PROP_ENCRYPTION) != ZIO_CRYPT_OFF &&
	zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS) ==
	ZFS_KEYSTATUS_UNAVAILABLE) {
	if (!explicit)
	return (0);

	(void) fprintf(stderr, gettext("cannot %s '%s': "
	"encryption key not loaded\n"), cmdname, zfs_get_name(zhp));
	return (1);
	}

	/*
	* If this filesystem is inconsistent and has a receive resume
	* token, we can not mount it.
	*/
	if (zfs_prop_get_int(zhp, ZFS_PROP_INCONSISTENT) &&
	zfs_prop_get(zhp, ZFS_PROP_RECEIVE_RESUME_TOKEN,
	NULL, 0, NULL, NULL, 0, B_TRUE) == 0) {
	if (!explicit)
	return (0);

	(void) fprintf(stderr, gettext("cannot %s '%s': "
	"Contains partially-completed state from "
	"\"zfs receive -s\", which can be resumed with "
	"\"zfs send -t\"\n"),
	cmdname, zfs_get_name(zhp));
	return (1);
	}

	if (zfs_prop_get_int(zhp, ZFS_PROP_REDACTED) && !(flags & MS_FORCE)) {
	if (!explicit)
	return (0);

	(void) fprintf(stderr, gettext("cannot %s '%s': "
	"Dataset is not complete, was created by receiving "
	"a redacted zfs send stream.\n"), cmdname,
	zfs_get_name(zhp));
	return (1);
	}

	/*
	* At this point, we have verified that the mountpoint and/or
	* shareopts are appropriate for auto management. If the
	* filesystem is already mounted or shared, return (failing
	* for explicit requests); otherwise mount or share the
	* filesystem.
	*/
	switch (op) {
	case OP_SHARE:

	shared_nfs = zfs_is_shared_nfs(zhp, NULL);
	shared_smb = zfs_is_shared_smb(zhp, NULL);

	if ((shared_nfs && shared_smb) \|\|
	(shared_nfs && strcmp(shareopts, "on") == 0 &&
	strcmp(smbshareopts, "off") == 0) \|\|
	(shared_smb && strcmp(smbshareopts, "on") == 0 &&
	strcmp(shareopts, "off") == 0)) {
	if (!explicit)
	return (0);

	(void) fprintf(stderr, gettext("cannot share "
	"'%s': filesystem already shared\n"),
	zfs_get_name(zhp));
	return (1);
	}

	if (!zfs_is_mounted(zhp, NULL) &&
	zfs_mount(zhp, NULL, flags) != 0)
	return (1);

	if (protocol == NULL) {
	if (zfs_shareall(zhp) != 0)
	return (1);
	} else if (strcmp(protocol, "nfs") == 0) {
	if (zfs_share_nfs(zhp))
	return (1);
	} else if (strcmp(protocol, "smb") == 0) {
	if (zfs_share_smb(zhp))
	return (1);
	} else {
	(void) fprintf(stderr, gettext("cannot share "
	"'%s': invalid share type '%s' "
	"specified\n"),
	zfs_get_name(zhp), protocol);
	return (1);
	}

	break;

	case OP_MOUNT:
	if (options == NULL)
	mnt.mnt_mntopts = "";
	else
	mnt.mnt_mntopts = (char *)options;

	if (!hasmntopt(&mnt, MNTOPT_REMOUNT) &&
	zfs_is_mounted(zhp, NULL)) {
	if (!explicit)
	return (0);

	(void) fprintf(stderr, gettext("cannot mount "
	"'%s': filesystem already mounted\n"),
	zfs_get_name(zhp));
	return (1);
	}

	if (zfs_mount(zhp, options, flags) != 0)
	return (1);
	break;
	}

	return (0);
	}

	/*
	* Reports progress in the form "(current/total)". Not thread-safe.
	*/
	static void
	report_mount_progress(int current, int total)
	{
	static time_t last_progress_time = 0;
	time_t now = time(NULL);
	char info[32];

	/* display header if we're here for the first time */
	if (current == 1) {
	set_progress_header(gettext("Mounting ZFS filesystems"));
	} else if (current != total && last_progress_time + MOUNT_TIME >= now) {
	/* too soon to report again */
	return;
	}

	last_progress_time = now;

	(void) sprintf(info, "(%d/%d)", current, total);

	if (current == total)
	finish_progress(info);
	else
	update_progress(info);
	}

	/*
	* zfs_foreach_mountpoint() callback that mounts or shares one filesystem and
	* updates the progress meter.
	*/
	static int
	share_mount_one_cb(zfs_handle_t zhp, void arg)
	{
	share_mount_state_t *sms = arg;
	int ret;

	ret = share_mount_one(zhp, sms->sm_op, sms->sm_flags, sms->sm_proto,
	B_FALSE, sms->sm_options);

	pthread_mutex_lock(&sms->sm_lock);
	if (ret != 0)
	sms->sm_status = ret;
	sms->sm_done++;
	if (sms->sm_verbose)
	report_mount_progress(sms->sm_done, sms->sm_total);
	pthread_mutex_unlock(&sms->sm_lock);
	return (ret);
	}

	static void
	append_options(char mntopts, char newopts)
	{
	int len = strlen(mntopts);

	/* original length plus new string to append plus 1 for the comma */
	if (len + 1 + strlen(newopts) >= MNT_LINE_MAX) {
	(void) fprintf(stderr, gettext("the opts argument for "
	"'%s' option is too long (more than %d chars)\n"),
	"-o", MNT_LINE_MAX);
	usage(B_FALSE);
	}

	if (*mntopts)
	mntopts[len++] = ',';

	(void) strcpy(&mntopts[len], newopts);
	}

	static int
	share_mount(int op, int argc, char **argv)
	{
	int do_all = 0;
	boolean_t verbose = B_FALSE;
	int c, ret = 0;
	char *options = NULL;
	int flags = 0;

	/* check options */
	while ((c = getopt(argc, argv, op == OP_MOUNT ? ":alvo:Of" : "al"))
	!= -1) {
	switch (c) {
	case 'a':
	do_all = 1;
	break;
	case 'v':
	verbose = B_TRUE;
	break;
	case 'l':
	flags \|= MS_CRYPT;
	break;
	case 'o':
	if (*optarg == '\0') {
	(void) fprintf(stderr, gettext("empty mount "
	"options (-o) specified\n"));
	usage(B_FALSE);
	}

	if (options == NULL)
	options = safe_malloc(MNT_LINE_MAX + 1);

	/* option validation is done later */
	append_options(options, optarg);
	break;
	case 'O':
	flags \|= MS_OVERLAY;
	break;
	case 'f':
	flags \|= MS_FORCE;
	break;
	case ':':
	(void) fprintf(stderr, gettext("missing argument for "
	"'%c' option\n"), optopt);
	usage(B_FALSE);
	break;
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	argc -= optind;
	argv += optind;

	/* check number of arguments */
	if (do_all) {
	char *protocol = NULL;

	if (op == OP_SHARE && argc > 0) {
	if (strcmp(argv[0], "nfs") != 0 &&
	strcmp(argv[0], "smb") != 0) {
	(void) fprintf(stderr, gettext("share type "
	"must be 'nfs' or 'smb'\n"));
	usage(B_FALSE);
	}
	protocol = argv[0];
	argc--;
	argv++;
	}

	if (argc != 0) {
	(void) fprintf(stderr, gettext("too many arguments\n"));
	usage(B_FALSE);
	}

	start_progress_timer();
	get_all_cb_t cb = { 0 };
	get_all_datasets(&cb, verbose);

	if (cb.cb_used == 0) {
	if (options != NULL)
	free(options);
	return (0);
	}

	share_mount_state_t share_mount_state = { 0 };
	share_mount_state.sm_op = op;
	share_mount_state.sm_verbose = verbose;
	share_mount_state.sm_flags = flags;
	share_mount_state.sm_options = options;
	share_mount_state.sm_proto = protocol;
	share_mount_state.sm_total = cb.cb_used;
	pthread_mutex_init(&share_mount_state.sm_lock, NULL);

	/*
	* libshare isn't mt-safe, so only do the operation in parallel
	* if we're mounting. Additionally, the key-loading option must
	* be serialized so that we can prompt the user for their keys
	* in a consistent manner.
	*/
	zfs_foreach_mountpoint(g_zfs, cb.cb_handles, cb.cb_used,
	share_mount_one_cb, &share_mount_state,
	op == OP_MOUNT && !(flags & MS_CRYPT));
	zfs_commit_all_shares();

	ret = share_mount_state.sm_status;

	for (int i = 0; i < cb.cb_used; i++)
	zfs_close(cb.cb_handles[i]);
	free(cb.cb_handles);
	} else if (argc == 0) {
	struct mnttab entry;

	if ((op == OP_SHARE) \|\| (options != NULL)) {
	(void) fprintf(stderr, gettext("missing filesystem "
	"argument (specify -a for all)\n"));
	usage(B_FALSE);
	}

	/*
	* When mount is given no arguments, go through
	* /proc/self/mounts and display any active ZFS mounts.
	* We hide any snapshots, since they are controlled
	* automatically.
	*/

	/* Reopen MNTTAB to prevent reading stale data from open file */
	if (freopen(MNTTAB, "r", mnttab_file) == NULL) {
	if (options != NULL)
	free(options);
	return (ENOENT);
	}

	while (getmntent(mnttab_file, &entry) == 0) {
	if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0 \|\|
	strchr(entry.mnt_special, '@') != NULL)
	continue;

	(void) printf("%-30s %s\n", entry.mnt_special,
	entry.mnt_mountp);
	}

	} else {
	zfs_handle_t *zhp;

	if (argc > 1) {
	(void) fprintf(stderr,
	gettext("too many arguments\n"));
	usage(B_FALSE);
	}

	if ((zhp = zfs_open(g_zfs, argv[0],
	ZFS_TYPE_FILESYSTEM)) == NULL) {
	ret = 1;
	} else {
	ret = share_mount_one(zhp, op, flags, NULL, B_TRUE,
	options);
	zfs_commit_all_shares();
	zfs_close(zhp);
	}
	}

	if (options != NULL)
	free(options);

	return (ret);
	}

	/*
	* zfs mount -a [nfs]
	* zfs mount filesystem
	*
	* Mount all filesystems, or mount the given filesystem.
	*/
	static int
	zfs_do_mount(int argc, char **argv)
	{
	return (share_mount(OP_MOUNT, argc, argv));
	}

	/*
	* zfs share -a [nfs \| smb]
	* zfs share filesystem
	*
	* Share all filesystems, or share the given filesystem.
	*/
	static int
	zfs_do_share(int argc, char **argv)
	{
	return (share_mount(OP_SHARE, argc, argv));
	}

	typedef struct unshare_unmount_node {
	zfs_handle_t *un_zhp;
	char *un_mountp;
	uu_avl_node_t un_avlnode;
	} unshare_unmount_node_t;

	/* ARGSUSED */
	static int
	unshare_unmount_compare(const void larg, const void rarg, void *unused)
	{
	const unshare_unmount_node_t *l = larg;
	const unshare_unmount_node_t *r = rarg;

	return (strcmp(l->un_mountp, r->un_mountp));
	}

	/*
	* Convenience routine used by zfs_do_umount() and manual_unmount(). Given an
	* absolute path, find the entry /proc/self/mounts, verify that it's a
	* ZFS filesystem, and unmount it appropriately.
	*/
	static int
	unshare_unmount_path(int op, char *path, int flags, boolean_t is_manual)
	{
	zfs_handle_t *zhp;
	int ret = 0;
	struct stat64 statbuf;
	struct extmnttab entry;
	const char *cmdname = (op == OP_SHARE) ? "unshare" : "unmount";
	ino_t path_inode;

	/*
	* Search for the given (major,minor) pair in the mount table.
	*/

	/* Reopen MNTTAB to prevent reading stale data from open file */
	if (freopen(MNTTAB, "r", mnttab_file) == NULL)
	return (ENOENT);

	if (getextmntent(path, &entry, &statbuf) != 0) {
	if (op == OP_SHARE) {
	(void) fprintf(stderr, gettext("cannot %s '%s': not "
	"currently mounted\n"), cmdname, path);
	return (1);
	}
	(void) fprintf(stderr, gettext("warning: %s not in"
	"/proc/self/mounts\n"), path);
	if ((ret = umount2(path, flags)) != 0)
	(void) fprintf(stderr, gettext("%s: %s\n"), path,
	strerror(errno));
	return (ret != 0);
	}
	path_inode = statbuf.st_ino;

	if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0) {
	(void) fprintf(stderr, gettext("cannot %s '%s': not a ZFS "
	"filesystem\n"), cmdname, path);
	return (1);
	}

	if ((zhp = zfs_open(g_zfs, entry.mnt_special,
	ZFS_TYPE_FILESYSTEM)) == NULL)
	return (1);

	ret = 1;
	if (stat64(entry.mnt_mountp, &statbuf) != 0) {
	(void) fprintf(stderr, gettext("cannot %s '%s': %s\n"),
	cmdname, path, strerror(errno));
	goto out;
	} else if (statbuf.st_ino != path_inode) {
	(void) fprintf(stderr, gettext("cannot "
	"%s '%s': not a mountpoint\n"), cmdname, path);
	goto out;
	}

	if (op == OP_SHARE) {
	char nfs_mnt_prop[ZFS_MAXPROPLEN];
	char smbshare_prop[ZFS_MAXPROPLEN];

	verify(zfs_prop_get(zhp, ZFS_PROP_SHARENFS, nfs_mnt_prop,
	sizeof (nfs_mnt_prop), NULL, NULL, 0, B_FALSE) == 0);
	verify(zfs_prop_get(zhp, ZFS_PROP_SHARESMB, smbshare_prop,
	sizeof (smbshare_prop), NULL, NULL, 0, B_FALSE) == 0);

	if (strcmp(nfs_mnt_prop, "off") == 0 &&
	strcmp(smbshare_prop, "off") == 0) {
	(void) fprintf(stderr, gettext("cannot unshare "
	"'%s': legacy share\n"), path);
	(void) fprintf(stderr, gettext("use exportfs(8) "
	"or smbcontrol(1) to unshare this filesystem\n"));
	} else if (!zfs_is_shared(zhp)) {
	(void) fprintf(stderr, gettext("cannot unshare '%s': "
	"not currently shared\n"), path);
	} else {
	ret = zfs_unshareall_bypath(zhp, path);
	zfs_commit_all_shares();
	}
	} else {
	char mtpt_prop[ZFS_MAXPROPLEN];

	verify(zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, mtpt_prop,
	sizeof (mtpt_prop), NULL, NULL, 0, B_FALSE) == 0);

	if (is_manual) {
	ret = zfs_unmount(zhp, NULL, flags);
	} else if (strcmp(mtpt_prop, "legacy") == 0) {
	(void) fprintf(stderr, gettext("cannot unmount "
	"'%s': legacy mountpoint\n"),
	zfs_get_name(zhp));
	(void) fprintf(stderr, gettext("use umount(8) "
	"to unmount this filesystem\n"));
	} else {
	ret = zfs_unmountall(zhp, flags);
	}
	}

	out:
	zfs_close(zhp);

	return (ret != 0);
	}

	/*
	* Generic callback for unsharing or unmounting a filesystem.
	*/
	static int
	unshare_unmount(int op, int argc, char **argv)
	{
	int do_all = 0;
	int flags = 0;
	int ret = 0;
	int c;
	zfs_handle_t *zhp;
	char nfs_mnt_prop[ZFS_MAXPROPLEN];
	char sharesmb[ZFS_MAXPROPLEN];

	/* check options */
	while ((c = getopt(argc, argv, op == OP_SHARE ? ":a" : "afu")) != -1) {
	switch (c) {
	case 'a':
	do_all = 1;
	break;
	case 'f':
	flags \|= MS_FORCE;
	break;
	case 'u':
	flags \|= MS_CRYPT;
	break;
	case ':':
	(void) fprintf(stderr, gettext("missing argument for "
	"'%c' option\n"), optopt);
	usage(B_FALSE);
	break;
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	argc -= optind;
	argv += optind;

	if (do_all) {
	/*
	* We could make use of zfs_for_each() to walk all datasets in
	* the system, but this would be very inefficient, especially
	* since we would have to linearly search /proc/self/mounts for
	* each one. Instead, do one pass through /proc/self/mounts
	* looking for zfs entries and call zfs_unmount() for each one.
	*
	* Things get a little tricky if the administrator has created
	* mountpoints beneath other ZFS filesystems. In this case, we
	* have to unmount the deepest filesystems first. To accomplish
	* this, we place all the mountpoints in an AVL tree sorted by
	* the special type (dataset name), and walk the result in
	* reverse to make sure to get any snapshots first.
	*/
	struct mnttab entry;
	uu_avl_pool_t *pool;
	uu_avl_t *tree = NULL;
	unshare_unmount_node_t *node;
	uu_avl_index_t idx;
	uu_avl_walk_t *walk;
	char *protocol = NULL;

	if (op == OP_SHARE && argc > 0) {
	if (strcmp(argv[0], "nfs") != 0 &&
	strcmp(argv[0], "smb") != 0) {
	(void) fprintf(stderr, gettext("share type "
	"must be 'nfs' or 'smb'\n"));
	usage(B_FALSE);
	}
	protocol = argv[0];
	argc--;
	argv++;
	}

	if (argc != 0) {
	(void) fprintf(stderr, gettext("too many arguments\n"));
	usage(B_FALSE);
	}

	if (((pool = uu_avl_pool_create("unmount_pool",
	sizeof (unshare_unmount_node_t),
	offsetof(unshare_unmount_node_t, un_avlnode),
	unshare_unmount_compare, UU_DEFAULT)) == NULL) \|\|
	((tree = uu_avl_create(pool, NULL, UU_DEFAULT)) == NULL))
	nomem();

	/* Reopen MNTTAB to prevent reading stale data from open file */
	if (freopen(MNTTAB, "r", mnttab_file) == NULL)
	return (ENOENT);

	while (getmntent(mnttab_file, &entry) == 0) {

	/* ignore non-ZFS entries */
	if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0)
	continue;

	/* ignore snapshots */
	if (strchr(entry.mnt_special, '@') != NULL)
	continue;

	if ((zhp = zfs_open(g_zfs, entry.mnt_special,
	ZFS_TYPE_FILESYSTEM)) == NULL) {
	ret = 1;
	continue;
	}

	/*
	* Ignore datasets that are excluded/restricted by
	* parent pool name.
	*/
	if (zpool_skip_pool(zfs_get_pool_name(zhp))) {
	zfs_close(zhp);
	continue;
	}

	switch (op) {
	case OP_SHARE:
	verify(zfs_prop_get(zhp, ZFS_PROP_SHARENFS,
	nfs_mnt_prop,
	sizeof (nfs_mnt_prop),
	NULL, NULL, 0, B_FALSE) == 0);
	if (strcmp(nfs_mnt_prop, "off") != 0)
	break;
	verify(zfs_prop_get(zhp, ZFS_PROP_SHARESMB,
	nfs_mnt_prop,
	sizeof (nfs_mnt_prop),
	NULL, NULL, 0, B_FALSE) == 0);
	if (strcmp(nfs_mnt_prop, "off") == 0)
	continue;
	break;
	case OP_MOUNT:
	/* Ignore legacy mounts */
	verify(zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT,
	nfs_mnt_prop,
	sizeof (nfs_mnt_prop),
	NULL, NULL, 0, B_FALSE) == 0);
	if (strcmp(nfs_mnt_prop, "legacy") == 0)
	continue;
	/* Ignore canmount=noauto mounts */
	if (zfs_prop_get_int(zhp, ZFS_PROP_CANMOUNT) ==
	ZFS_CANMOUNT_NOAUTO)
	continue;
	default:
	break;
	}

	node = safe_malloc(sizeof (unshare_unmount_node_t));
	node->un_zhp = zhp;
	node->un_mountp = safe_strdup(entry.mnt_mountp);

	uu_avl_node_init(node, &node->un_avlnode, pool);

	if (uu_avl_find(tree, node, NULL, &idx) == NULL) {
	uu_avl_insert(tree, node, idx);
	} else {
	zfs_close(node->un_zhp);
	free(node->un_mountp);
	free(node);
	}
	}

	/*
	* Walk the AVL tree in reverse, unmounting each filesystem and
	* removing it from the AVL tree in the process.
	*/
	if ((walk = uu_avl_walk_start(tree,
	UU_WALK_REVERSE \| UU_WALK_ROBUST)) == NULL)
	nomem();

	while ((node = uu_avl_walk_next(walk)) != NULL) {
	const char *mntarg = NULL;

	uu_avl_remove(tree, node);
	switch (op) {
	case OP_SHARE:
	if (zfs_unshareall_bytype(node->un_zhp,
	node->un_mountp, protocol) != 0)
	ret = 1;
	break;

	case OP_MOUNT:
	if (zfs_unmount(node->un_zhp,
	mntarg, flags) != 0)
	ret = 1;
	break;
	}

	zfs_close(node->un_zhp);
	free(node->un_mountp);
	free(node);
	}

	if (op == OP_SHARE)
	zfs_commit_shares(protocol);

	uu_avl_walk_end(walk);
	uu_avl_destroy(tree);
	uu_avl_pool_destroy(pool);

	} else {
	if (argc != 1) {
	if (argc == 0)
	(void) fprintf(stderr,
	gettext("missing filesystem argument\n"));
	else
	(void) fprintf(stderr,
	gettext("too many arguments\n"));
	usage(B_FALSE);
	}

	/*
	* We have an argument, but it may be a full path or a ZFS
	* filesystem. Pass full paths off to unmount_path() (shared by
	* manual_unmount), otherwise open the filesystem and pass to
	* zfs_unmount().
	*/
	if (argv[0][0] == '/')
	return (unshare_unmount_path(op, argv[0],
	flags, B_FALSE));

	if ((zhp = zfs_open(g_zfs, argv[0],
	ZFS_TYPE_FILESYSTEM)) == NULL)
	return (1);

	verify(zfs_prop_get(zhp, op == OP_SHARE ?
	ZFS_PROP_SHARENFS : ZFS_PROP_MOUNTPOINT,
	nfs_mnt_prop, sizeof (nfs_mnt_prop), NULL,
	NULL, 0, B_FALSE) == 0);

	switch (op) {
	case OP_SHARE:
	verify(zfs_prop_get(zhp, ZFS_PROP_SHARENFS,
	nfs_mnt_prop,
	sizeof (nfs_mnt_prop),
	NULL, NULL, 0, B_FALSE) == 0);
	verify(zfs_prop_get(zhp, ZFS_PROP_SHARESMB,
	sharesmb, sizeof (sharesmb), NULL, NULL,
	0, B_FALSE) == 0);

	if (strcmp(nfs_mnt_prop, "off") == 0 &&
	strcmp(sharesmb, "off") == 0) {
	(void) fprintf(stderr, gettext("cannot "
	"unshare '%s': legacy share\n"),
	zfs_get_name(zhp));
	(void) fprintf(stderr, gettext("use "
	"exports(5) or smb.conf(5) to unshare "
	"this filesystem\n"));
	ret = 1;
	} else if (!zfs_is_shared(zhp)) {
	(void) fprintf(stderr, gettext("cannot "
	"unshare '%s': not currently "
	"shared\n"), zfs_get_name(zhp));
	ret = 1;
	} else if (zfs_unshareall(zhp) != 0) {
	ret = 1;
	}
	break;

	case OP_MOUNT:
	if (strcmp(nfs_mnt_prop, "legacy") == 0) {
	(void) fprintf(stderr, gettext("cannot "
	"unmount '%s': legacy "
	"mountpoint\n"), zfs_get_name(zhp));
	(void) fprintf(stderr, gettext("use "
	"umount(8) to unmount this "
	"filesystem\n"));
	ret = 1;
	} else if (!zfs_is_mounted(zhp, NULL)) {
	(void) fprintf(stderr, gettext("cannot "
	"unmount '%s': not currently "
	"mounted\n"),
	zfs_get_name(zhp));
	ret = 1;
	} else if (zfs_unmountall(zhp, flags) != 0) {
	ret = 1;
	}
	break;
	}

	zfs_close(zhp);
	}

	return (ret);
	}

	/*
	* zfs unmount [-fu] -a
	* zfs unmount [-fu] filesystem
	*
	* Unmount all filesystems, or a specific ZFS filesystem.
	*/
	static int
	zfs_do_unmount(int argc, char **argv)
	{
	return (unshare_unmount(OP_MOUNT, argc, argv));
	}

	/*
	* zfs unshare -a
	* zfs unshare filesystem
	*
	* Unshare all filesystems, or a specific ZFS filesystem.
	*/
	static int
	zfs_do_unshare(int argc, char **argv)
	{
	return (unshare_unmount(OP_SHARE, argc, argv));
	}

	static int
	find_command_idx(char command, int idx)
	{
	int i;

	for (i = 0; i < NCOMMAND; i++) {
	if (command_table[i].name == NULL)
	continue;

	if (strcmp(command, command_table[i].name) == 0) {
	*idx = i;
	return (0);
	}
	}
	return (1);
	}

	static int
	zfs_do_diff(int argc, char **argv)
	{
	zfs_handle_t *zhp;
	int flags = 0;
	char *tosnap = NULL;
	char *fromsnap = NULL;
	char atp, copy;
	int err = 0;
	int c;
	struct sigaction sa;

	while ((c = getopt(argc, argv, "FHt")) != -1) {
	switch (c) {
	case 'F':
	flags \|= ZFS_DIFF_CLASSIFY;
	break;
	case 'H':
	flags \|= ZFS_DIFF_PARSEABLE;
	break;
	case 't':
	flags \|= ZFS_DIFF_TIMESTAMP;
	break;
	default:
	(void) fprintf(stderr,
	gettext("invalid option '%c'\n"), optopt);
	usage(B_FALSE);
	}
	}

	argc -= optind;
	argv += optind;

	if (argc < 1) {
	(void) fprintf(stderr,
	gettext("must provide at least one snapshot name\n"));
	usage(B_FALSE);
	}

	if (argc > 2) {
	(void) fprintf(stderr, gettext("too many arguments\n"));
	usage(B_FALSE);
	}

	fromsnap = argv[0];
	tosnap = (argc == 2) ? argv[1] : NULL;

	copy = NULL;
	if (*fromsnap != '@')
	copy = strdup(fromsnap);
	else if (tosnap)
	copy = strdup(tosnap);
	if (copy == NULL)
	usage(B_FALSE);

	if ((atp = strchr(copy, '@')) != NULL)
	*atp = '\0';

	if ((zhp = zfs_open(g_zfs, copy, ZFS_TYPE_FILESYSTEM)) == NULL) {
	free(copy);
	return (1);
	}
	free(copy);

	/*
	* Ignore SIGPIPE so that the library can give us
	* information on any failure
	*/
	if (sigemptyset(&sa.sa_mask) == -1) {
	err = errno;
	goto out;
	}
	sa.sa_flags = 0;
	sa.sa_handler = SIG_IGN;
	if (sigaction(SIGPIPE, &sa, NULL) == -1) {
	err = errno;
	goto out;
	}

	err = zfs_show_diffs(zhp, STDOUT_FILENO, fromsnap, tosnap, flags);
	out:
	zfs_close(zhp);

	return (err != 0);
	}

	/*
	* zfs bookmark <fs@source>\|<fs#source> <fs#bookmark>
	*
	* Creates a bookmark with the given name from the source snapshot
	* or creates a copy of an existing source bookmark.
	*/
	static int
	zfs_do_bookmark(int argc, char **argv)
	{
	char source, bookname;
	char expbuf[ZFS_MAX_DATASET_NAME_LEN];
	int source_type;
	nvlist_t *nvl;
	int ret = 0;
	int c;

	/* check options */
	while ((c = getopt(argc, argv, "")) != -1) {
	switch (c) {
	case '?':
	(void) fprintf(stderr,
	gettext("invalid option '%c'\n"), optopt);
	goto usage;
	}
	}

	argc -= optind;
	argv += optind;

	/* check number of arguments */
	if (argc < 1) {
	(void) fprintf(stderr, gettext("missing source argument\n"));
	goto usage;
	}
	if (argc < 2) {
	(void) fprintf(stderr, gettext("missing bookmark argument\n"));
	goto usage;
	}

	source = argv[0];
	bookname = argv[1];

	if (strchr(source, '@') == NULL && strchr(source, '#') == NULL) {
	(void) fprintf(stderr,
	gettext("invalid source name '%s': "
	"must contain a '@' or '#'\n"), source);
	goto usage;
	}
	if (strchr(bookname, '#') == NULL) {
	(void) fprintf(stderr,
	gettext("invalid bookmark name '%s': "
	"must contain a '#'\n"), bookname);
	goto usage;
	}

	/*
	* expand source or bookname to full path:
	* one of them may be specified as short name
	*/
	{
	char **expand;
	char source_short, bookname_short;
	source_short = strpbrk(source, "@#");
	bookname_short = strpbrk(bookname, "#");
	if (source_short == source &&
	bookname_short == bookname) {
	(void) fprintf(stderr, gettext(
	"either source or bookmark must be specified as "
	"full dataset paths"));
	goto usage;
	} else if (source_short != source &&
	bookname_short != bookname) {
	expand = NULL;
	} else if (source_short != source) {
	strlcpy(expbuf, source, sizeof (expbuf));
	expand = &bookname;
	} else if (bookname_short != bookname) {
	strlcpy(expbuf, bookname, sizeof (expbuf));
	expand = &source;
	} else {
	abort();
	}
	if (expand != NULL) {
	strpbrk(expbuf, "@#") = '\0'; / dataset name in buf */
	(void) strlcat(expbuf, *expand, sizeof (expbuf));
	*expand = expbuf;
	}
	}

	/* determine source type */
	switch (*strpbrk(source, "@#")) {
	case '@': source_type = ZFS_TYPE_SNAPSHOT; break;
	case '#': source_type = ZFS_TYPE_BOOKMARK; break;
	default: abort();
	}

	/* test the source exists */
	zfs_handle_t *zhp;
	zhp = zfs_open(g_zfs, source, source_type);
	if (zhp == NULL)
	goto usage;
	zfs_close(zhp);

	nvl = fnvlist_alloc();
	fnvlist_add_string(nvl, bookname, source);
	ret = lzc_bookmark(nvl, NULL);
	fnvlist_free(nvl);

	if (ret != 0) {
	const char *err_msg = NULL;
	char errbuf[1024];

	(void) snprintf(errbuf, sizeof (errbuf),
	dgettext(TEXT_DOMAIN,
	"cannot create bookmark '%s'"), bookname);

	switch (ret) {
	case EXDEV:
	err_msg = "bookmark is in a different pool";
	break;
	case ZFS_ERR_BOOKMARK_SOURCE_NOT_ANCESTOR:
	err_msg = "source is not an ancestor of the "
	"new bookmark's dataset";
	break;
	case EEXIST:
	err_msg = "bookmark exists";
	break;
	case EINVAL:
	err_msg = "invalid argument";
	break;
	case ENOTSUP:
	err_msg = "bookmark feature not enabled";
	break;
	case ENOSPC:
	err_msg = "out of space";
	break;
	case ENOENT:
	err_msg = "dataset does not exist";
	break;
	default:
	(void) zfs_standard_error(g_zfs, ret, errbuf);
	break;
	}
	if (err_msg != NULL) {
	(void) fprintf(stderr, "%s: %s\n", errbuf,
	dgettext(TEXT_DOMAIN, err_msg));
	}
	}

	return (ret != 0);

	usage:
	usage(B_FALSE);
	return (-1);
	}

	static int
	zfs_do_channel_program(int argc, char **argv)
	{
	int ret, fd, c;
	char progbuf, filename, *poolname;
	size_t progsize, progread;
	nvlist_t *outnvl = NULL;
	uint64_t instrlimit = ZCP_DEFAULT_INSTRLIMIT;
	uint64_t memlimit = ZCP_DEFAULT_MEMLIMIT;
	boolean_t sync_flag = B_TRUE, json_output = B_FALSE;
	zpool_handle_t *zhp;

	/* check options */
	while ((c = getopt(argc, argv, "nt:m:j")) != -1) {
	switch (c) {
	case 't':
	case 'm': {
	uint64_t arg;
	char *endp;

	errno = 0;
	arg = strtoull(optarg, &endp, 0);
	if (errno != 0 \|\| *endp != '\0') {
	(void) fprintf(stderr, gettext(
	"invalid argument "
	"'%s': expected integer\n"), optarg);
	goto usage;
	}

	if (c == 't') {
	instrlimit = arg;
	} else {
	ASSERT3U(c, ==, 'm');
	memlimit = arg;
	}
	break;
	}
	case 'n': {
	sync_flag = B_FALSE;
	break;
	}
	case 'j': {
	json_output = B_TRUE;
	break;
	}
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	goto usage;
	}
	}

	argc -= optind;
	argv += optind;

	if (argc < 2) {
	(void) fprintf(stderr,
	gettext("invalid number of arguments\n"));
	goto usage;
	}

	poolname = argv[0];
	filename = argv[1];
	if (strcmp(filename, "-") == 0) {
	fd = 0;
	filename = "standard input";
	} else if ((fd = open(filename, O_RDONLY)) < 0) {
	(void) fprintf(stderr, gettext("cannot open '%s': %s\n"),
	filename, strerror(errno));
	return (1);
	}

	if ((zhp = zpool_open(g_zfs, poolname)) == NULL) {
	(void) fprintf(stderr, gettext("cannot open pool '%s'\n"),
	poolname);
	if (fd != 0)
	(void) close(fd);
	return (1);
	}
	zpool_close(zhp);

	/*
	* Read in the channel program, expanding the program buffer as
	* necessary.
	*/
	progread = 0;
	progsize = 1024;
	progbuf = safe_malloc(progsize);
	do {
	ret = read(fd, progbuf + progread, progsize - progread);
	progread += ret;
	if (progread == progsize && ret > 0) {
	progsize *= 2;
	progbuf = safe_realloc(progbuf, progsize);
	}
	} while (ret > 0);

	if (fd != 0)
	(void) close(fd);
	if (ret < 0) {
	free(progbuf);
	(void) fprintf(stderr,
	gettext("cannot read '%s': %s\n"),
	filename, strerror(errno));
	return (1);
	}
	progbuf[progread] = '\0';

	/*
	* Any remaining arguments are passed as arguments to the lua script as
	* a string array:
	* {
	* "argv" -> [ "arg 1", ... "arg n" ],
	* }
	*/
	nvlist_t *argnvl = fnvlist_alloc();
	fnvlist_add_string_array(argnvl, ZCP_ARG_CLIARGV, argv + 2, argc - 2);

	if (sync_flag) {
	ret = lzc_channel_program(poolname, progbuf,
	instrlimit, memlimit, argnvl, &outnvl);
	} else {
	ret = lzc_channel_program_nosync(poolname, progbuf,
	instrlimit, memlimit, argnvl, &outnvl);
	}

	if (ret != 0) {
	/*
	* On error, report the error message handed back by lua if one
	* exists. Otherwise, generate an appropriate error message,
	* falling back on strerror() for an unexpected return code.
	*/
	char *errstring = NULL;
	const char *msg = gettext("Channel program execution failed");
	uint64_t instructions = 0;
	if (outnvl != NULL && nvlist_exists(outnvl, ZCP_RET_ERROR)) {
	(void) nvlist_lookup_string(outnvl,
	ZCP_RET_ERROR, &errstring);
	if (errstring == NULL)
	errstring = strerror(ret);
	if (ret == ETIME) {
	(void) nvlist_lookup_uint64(outnvl,
	ZCP_ARG_INSTRLIMIT, &instructions);
	}
	} else {
	switch (ret) {
	case EINVAL:
	errstring =
	"Invalid instruction or memory limit.";
	break;
	case ENOMEM:
	errstring = "Return value too large.";
	break;
	case ENOSPC:
	errstring = "Memory limit exhausted.";
	break;
	case ETIME:
	errstring = "Timed out.";
	break;
	case EPERM:
	errstring = "Permission denied. Channel "
	"programs must be run as root.";
	break;
	default:
	(void) zfs_standard_error(g_zfs, ret, msg);
	}
	}
	if (errstring != NULL)
	(void) fprintf(stderr, "%s:\n%s\n", msg, errstring);

	if (ret == ETIME && instructions != 0)
	(void) fprintf(stderr,
	gettext("%llu Lua instructions\n"),
	(u_longlong_t)instructions);
	} else {
	if (json_output) {
	(void) nvlist_print_json(stdout, outnvl);
	} else if (nvlist_empty(outnvl)) {
	(void) fprintf(stdout, gettext("Channel program fully "
	"executed and did not produce output.\n"));
	} else {
	(void) fprintf(stdout, gettext("Channel program fully "
	"executed and produced output:\n"));
	dump_nvlist(outnvl, 4);
	}
	}

	free(progbuf);
	fnvlist_free(outnvl);
	fnvlist_free(argnvl);
	return (ret != 0);

	usage:
	usage(B_FALSE);
	return (-1);
	}


	typedef struct loadkey_cbdata {
	boolean_t cb_loadkey;
	boolean_t cb_recursive;
	boolean_t cb_noop;
	char *cb_keylocation;
	uint64_t cb_numfailed;
	uint64_t cb_numattempted;
	} loadkey_cbdata_t;

	static int
	load_key_callback(zfs_handle_t zhp, void data)
	{
	int ret;
	boolean_t is_encroot;
	loadkey_cbdata_t *cb = data;
	uint64_t keystatus = zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS);

	/*
	* If we are working recursively, we want to skip loading / unloading
	* keys for non-encryption roots and datasets whose keys are already
	* in the desired end-state.
	*/
	if (cb->cb_recursive) {
	ret = zfs_crypto_get_encryption_root(zhp, &is_encroot, NULL);
	if (ret != 0)
	return (ret);
	if (!is_encroot)
	return (0);

	if ((cb->cb_loadkey && keystatus == ZFS_KEYSTATUS_AVAILABLE) \|\|
	(!cb->cb_loadkey && keystatus == ZFS_KEYSTATUS_UNAVAILABLE))
	return (0);
	}

	cb->cb_numattempted++;

	if (cb->cb_loadkey)
	ret = zfs_crypto_load_key(zhp, cb->cb_noop, cb->cb_keylocation);
	else
	ret = zfs_crypto_unload_key(zhp);

	if (ret != 0) {
	cb->cb_numfailed++;
	return (ret);
	}

	return (0);
	}

	static int
	load_unload_keys(int argc, char **argv, boolean_t loadkey)
	{
	int c, ret = 0, flags = 0;
	boolean_t do_all = B_FALSE;
	loadkey_cbdata_t cb = { 0 };

	cb.cb_loadkey = loadkey;

	while ((c = getopt(argc, argv, "anrL:")) != -1) {
	/* noop and alternate keylocations only apply to zfs load-key */
	if (loadkey) {
	switch (c) {
	case 'n':
	cb.cb_noop = B_TRUE;
	continue;
	case 'L':
	cb.cb_keylocation = optarg;
	continue;
	default:
	break;
	}
	}

	switch (c) {
	case 'a':
	do_all = B_TRUE;
	cb.cb_recursive = B_TRUE;
	break;
	case 'r':
	flags \|= ZFS_ITER_RECURSE;
	cb.cb_recursive = B_TRUE;
	break;
	default:
	(void) fprintf(stderr,
	gettext("invalid option '%c'\n"), optopt);
	usage(B_FALSE);
	}
	}

	argc -= optind;
	argv += optind;

	if (!do_all && argc == 0) {
	(void) fprintf(stderr,
	gettext("Missing dataset argument or -a option\n"));
	usage(B_FALSE);
	}

	if (do_all && argc != 0) {
	(void) fprintf(stderr,
	gettext("Cannot specify dataset with -a option\n"));
	usage(B_FALSE);
	}

	if (cb.cb_recursive && cb.cb_keylocation != NULL &&
	strcmp(cb.cb_keylocation, "prompt") != 0) {
	(void) fprintf(stderr, gettext("alternate keylocation may only "
	"be 'prompt' with -r or -a\n"));
	usage(B_FALSE);
	}

	ret = zfs_for_each(argc, argv, flags,
	ZFS_TYPE_FILESYSTEM \| ZFS_TYPE_VOLUME, NULL, NULL, 0,
	load_key_callback, &cb);

	if (cb.cb_noop \|\| (cb.cb_recursive && cb.cb_numattempted != 0)) {
	(void) printf(gettext("%llu / %llu key(s) successfully %s\n"),
	(u_longlong_t)(cb.cb_numattempted - cb.cb_numfailed),
	(u_longlong_t)cb.cb_numattempted,
	loadkey ? (cb.cb_noop ? "verified" : "loaded") :
	"unloaded");
	}

	if (cb.cb_numfailed != 0)
	ret = -1;

	return (ret);
	}

	static int
	zfs_do_load_key(int argc, char **argv)
	{
	return (load_unload_keys(argc, argv, B_TRUE));
	}


	static int
	zfs_do_unload_key(int argc, char **argv)
	{
	return (load_unload_keys(argc, argv, B_FALSE));
	}

	static int
	zfs_do_change_key(int argc, char **argv)
	{
	int c, ret;
	uint64_t keystatus;
	boolean_t loadkey = B_FALSE, inheritkey = B_FALSE;
	zfs_handle_t *zhp = NULL;
	nvlist_t *props = fnvlist_alloc();

	while ((c = getopt(argc, argv, "lio:")) != -1) {
	switch (c) {
	case 'l':
	loadkey = B_TRUE;
	break;
	case 'i':
	inheritkey = B_TRUE;
	break;
	case 'o':
	if (!parseprop(props, optarg)) {
	nvlist_free(props);
	return (1);
	}
	break;
	default:
	(void) fprintf(stderr,
	gettext("invalid option '%c'\n"), optopt);
	usage(B_FALSE);
	}
	}

	if (inheritkey && !nvlist_empty(props)) {
	(void) fprintf(stderr,
	gettext("Properties not allowed for inheriting\n"));
	usage(B_FALSE);
	}

	argc -= optind;
	argv += optind;

	if (argc < 1) {
	(void) fprintf(stderr, gettext("Missing dataset argument\n"));
	usage(B_FALSE);
	}

	if (argc > 1) {
	(void) fprintf(stderr, gettext("Too many arguments\n"));
	usage(B_FALSE);
	}

	zhp = zfs_open(g_zfs, argv[argc - 1],
	ZFS_TYPE_FILESYSTEM \| ZFS_TYPE_VOLUME);
	if (zhp == NULL)
	usage(B_FALSE);

	if (loadkey) {
	keystatus = zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS);
	if (keystatus != ZFS_KEYSTATUS_AVAILABLE) {
	ret = zfs_crypto_load_key(zhp, B_FALSE, NULL);
	if (ret != 0) {
	nvlist_free(props);
	zfs_close(zhp);
	return (-1);
	}
	}

	/* refresh the properties so the new keystatus is visible */
	zfs_refresh_properties(zhp);
	}

	ret = zfs_crypto_rewrap(zhp, props, inheritkey);
	if (ret != 0) {
	nvlist_free(props);
	zfs_close(zhp);
	return (-1);
	}

	nvlist_free(props);
	zfs_close(zhp);
	return (0);
	}

	/*
	* 1) zfs project [-d\|-r] <file\|directory ...>
	* List project ID and inherit flag of file(s) or directories.
	* -d: List the directory itself, not its children.
	* -r: List subdirectories recursively.
	*
	* 2) zfs project -C [-k] [-r] <file\|directory ...>
	* Clear project inherit flag and/or ID on the file(s) or directories.
	* -k: Keep the project ID unchanged. If not specified, the project ID
	* will be reset as zero.
	* -r: Clear on subdirectories recursively.
	*
	* 3) zfs project -c [-0] [-d\|-r] [-p id] <file\|directory ...>
	* Check project ID and inherit flag on the file(s) or directories,
	* report the outliers.
	* -0: Print file name followed by a NUL instead of newline.
	* -d: Check the directory itself, not its children.
	* -p: Specify the referenced ID for comparing with the target file(s)
	* or directories' project IDs. If not specified, the target (top)
	* directory's project ID will be used as the referenced one.
	* -r: Check subdirectories recursively.
	*
	* 4) zfs project [-p id] [-r] [-s] <file\|directory ...>
	* Set project ID and/or inherit flag on the file(s) or directories.
	* -p: Set the project ID as the given id.
	* -r: Set on subdirectories recursively. If not specify "-p" option,
	* it will use top-level directory's project ID as the given id,
	* then set both project ID and inherit flag on all descendants
	* of the top-level directory.
	* -s: Set project inherit flag.
	*/
	static int
	zfs_do_project(int argc, char **argv)
	{
	zfs_project_control_t zpc = {
	.zpc_expected_projid = ZFS_INVALID_PROJID,
	.zpc_op = ZFS_PROJECT_OP_DEFAULT,
	.zpc_dironly = B_FALSE,
	.zpc_keep_projid = B_FALSE,
	.zpc_newline = B_TRUE,
	.zpc_recursive = B_FALSE,
	.zpc_set_flag = B_FALSE,
	};
	int ret = 0, c;

	if (argc < 2)
	usage(B_FALSE);

	while ((c = getopt(argc, argv, "0Ccdkp:rs")) != -1) {
	switch (c) {
	case '0':
	zpc.zpc_newline = B_FALSE;
	break;
	case 'C':
	if (zpc.zpc_op != ZFS_PROJECT_OP_DEFAULT) {
	(void) fprintf(stderr, gettext("cannot "
	"specify '-C' '-c' '-s' together\n"));
	usage(B_FALSE);
	}

	zpc.zpc_op = ZFS_PROJECT_OP_CLEAR;
	break;
	case 'c':
	if (zpc.zpc_op != ZFS_PROJECT_OP_DEFAULT) {
	(void) fprintf(stderr, gettext("cannot "
	"specify '-C' '-c' '-s' together\n"));
	usage(B_FALSE);
	}

	zpc.zpc_op = ZFS_PROJECT_OP_CHECK;
	break;
	case 'd':
	zpc.zpc_dironly = B_TRUE;
	/* overwrite "-r" option */
	zpc.zpc_recursive = B_FALSE;
	break;
	case 'k':
	zpc.zpc_keep_projid = B_TRUE;
	break;
	case 'p': {
	char *endptr;

	errno = 0;
	zpc.zpc_expected_projid = strtoull(optarg, &endptr, 0);
	if (errno != 0 \|\| *endptr != '\0') {
	(void) fprintf(stderr,
	gettext("project ID must be less than "
	"%u\n"), UINT32_MAX);
	usage(B_FALSE);
	}
	if (zpc.zpc_expected_projid >= UINT32_MAX) {
	(void) fprintf(stderr,
	gettext("invalid project ID\n"));
	usage(B_FALSE);
	}
	break;
	}
	case 'r':
	zpc.zpc_recursive = B_TRUE;
	/* overwrite "-d" option */
	zpc.zpc_dironly = B_FALSE;
	break;
	case 's':
	if (zpc.zpc_op != ZFS_PROJECT_OP_DEFAULT) {
	(void) fprintf(stderr, gettext("cannot "
	"specify '-C' '-c' '-s' together\n"));
	usage(B_FALSE);
	}

	zpc.zpc_set_flag = B_TRUE;
	zpc.zpc_op = ZFS_PROJECT_OP_SET;
	break;
	default:
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	if (zpc.zpc_op == ZFS_PROJECT_OP_DEFAULT) {
	if (zpc.zpc_expected_projid != ZFS_INVALID_PROJID)
	zpc.zpc_op = ZFS_PROJECT_OP_SET;
	else
	zpc.zpc_op = ZFS_PROJECT_OP_LIST;
	}

	switch (zpc.zpc_op) {
	case ZFS_PROJECT_OP_LIST:
	if (zpc.zpc_keep_projid) {
	(void) fprintf(stderr,
	gettext("'-k' is only valid together with '-C'\n"));
	usage(B_FALSE);
	}
	if (!zpc.zpc_newline) {
	(void) fprintf(stderr,
	gettext("'-0' is only valid together with '-c'\n"));
	usage(B_FALSE);
	}
	break;
	case ZFS_PROJECT_OP_CHECK:
	if (zpc.zpc_keep_projid) {
	(void) fprintf(stderr,
	gettext("'-k' is only valid together with '-C'\n"));
	usage(B_FALSE);
	}
	break;
	case ZFS_PROJECT_OP_CLEAR:
	if (zpc.zpc_dironly) {
	(void) fprintf(stderr,
	gettext("'-d' is useless together with '-C'\n"));
	usage(B_FALSE);
	}
	if (!zpc.zpc_newline) {
	(void) fprintf(stderr,
	gettext("'-0' is only valid together with '-c'\n"));
	usage(B_FALSE);
	}
	if (zpc.zpc_expected_projid != ZFS_INVALID_PROJID) {
	(void) fprintf(stderr,
	gettext("'-p' is useless together with '-C'\n"));
	usage(B_FALSE);
	}
	break;
	case ZFS_PROJECT_OP_SET:
	if (zpc.zpc_dironly) {
	(void) fprintf(stderr,
	gettext("'-d' is useless for set project ID and/or "
	"inherit flag\n"));
	usage(B_FALSE);
	}
	if (zpc.zpc_keep_projid) {
	(void) fprintf(stderr,
	gettext("'-k' is only valid together with '-C'\n"));
	usage(B_FALSE);
	}
	if (!zpc.zpc_newline) {
	(void) fprintf(stderr,
	gettext("'-0' is only valid together with '-c'\n"));
	usage(B_FALSE);
	}
	break;
	default:
	ASSERT(0);
	break;
	}

	argv += optind;
	argc -= optind;
	if (argc == 0) {
	(void) fprintf(stderr,
	gettext("missing file or directory target(s)\n"));
	usage(B_FALSE);
	}

	for (int i = 0; i < argc; i++) {
	int err;

	err = zfs_project_handle(argv[i], &zpc);
	if (err && !ret)
	ret = err;
	}

	return (ret);
	}

	static int
	zfs_do_wait(int argc, char **argv)
	{
	boolean_t enabled[ZFS_WAIT_NUM_ACTIVITIES];
	int error, i;
	int c;

	/* By default, wait for all types of activity. */
	for (i = 0; i < ZFS_WAIT_NUM_ACTIVITIES; i++)
	enabled[i] = B_TRUE;

	while ((c = getopt(argc, argv, "t:")) != -1) {
	switch (c) {
	case 't':
	{
	static char *col_subopts[] = { "deleteq", NULL };
	char *value;

	/* Reset activities array */
	bzero(&enabled, sizeof (enabled));
	while (*optarg != '\0') {
	int activity = getsubopt(&optarg, col_subopts,
	&value);

	if (activity < 0) {
	(void) fprintf(stderr,
	gettext("invalid activity '%s'\n"),
	value);
	usage(B_FALSE);
	}

	enabled[activity] = B_TRUE;
	}
	break;
	}
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	argv += optind;
	argc -= optind;
	if (argc < 1) {
	(void) fprintf(stderr, gettext("missing 'filesystem' "
	"argument\n"));
	usage(B_FALSE);
	}
	if (argc > 1) {
	(void) fprintf(stderr, gettext("too many arguments\n"));
	usage(B_FALSE);
	}

	zfs_handle_t *zhp = zfs_open(g_zfs, argv[0], ZFS_TYPE_FILESYSTEM);
	if (zhp == NULL)
	return (1);

	for (;;) {
	boolean_t missing = B_FALSE;
	boolean_t any_waited = B_FALSE;

	for (int i = 0; i < ZFS_WAIT_NUM_ACTIVITIES; i++) {
	boolean_t waited;

	if (!enabled[i])
	continue;

	error = zfs_wait_status(zhp, i, &missing, &waited);
	if (error != 0 \|\| missing)
	break;

	any_waited = (any_waited \|\| waited);
	}

	if (error != 0 \|\| missing \|\| !any_waited)
	break;
	}

	zfs_close(zhp);

	return (error);
	}

	/*
	* Display version message
	*/
	static int
	zfs_do_version(int argc, char **argv)
	{
	if (zfs_version_print() == -1)
	return (1);

	return (0);
	}

	int
	main(int argc, char **argv)
	{
	int ret = 0;
	int i = 0;
	char *cmdname;
	char **newargv;

	(void) setlocale(LC_ALL, "");
	(void) setlocale(LC_NUMERIC, "C");
	(void) textdomain(TEXT_DOMAIN);

	opterr = 0;

	/*
	* Make sure the user has specified some command.
	*/
	if (argc < 2) {
	(void) fprintf(stderr, gettext("missing command\n"));
	usage(B_FALSE);
	}

	cmdname = argv[1];

	/*
	* The 'umount' command is an alias for 'unmount'
	*/
	if (strcmp(cmdname, "umount") == 0)
	cmdname = "unmount";

	/*
	* The 'recv' command is an alias for 'receive'
	*/
	if (strcmp(cmdname, "recv") == 0)
	cmdname = "receive";

	/*
	* The 'snap' command is an alias for 'snapshot'
	*/
	if (strcmp(cmdname, "snap") == 0)
	cmdname = "snapshot";

	/*
	* Special case '-?'
	*/
	if ((strcmp(cmdname, "-?") == 0) \|\|
	(strcmp(cmdname, "--help") == 0))
	usage(B_TRUE);

	/*
	* Special case '-V\|--version'
	*/
	if ((strcmp(cmdname, "-V") == 0) \|\| (strcmp(cmdname, "--version") == 0))
	return (zfs_do_version(argc, argv));

	if ((g_zfs = libzfs_init()) == NULL) {
	(void) fprintf(stderr, "%s\n", libzfs_error_init(errno));
	return (1);
	}

	mnttab_file = g_zfs->libzfs_mnttab;

	zfs_save_arguments(argc, argv, history_str, sizeof (history_str));

	libzfs_print_on_error(g_zfs, B_TRUE);

	/*
	* Many commands modify input strings for string parsing reasons.
	* We create a copy to protect the original argv.
	*/
	newargv = malloc((argc + 1) * sizeof (newargv[0]));
	for (i = 0; i < argc; i++)
	newargv[i] = strdup(argv[i]);
	newargv[argc] = NULL;

	/*
	* Run the appropriate command.
	*/
	libzfs_mnttab_cache(g_zfs, B_TRUE);
	if (find_command_idx(cmdname, &i) == 0) {
	current_command = &command_table[i];
	ret = command_table[i].func(argc - 1, newargv + 1);
	} else if (strchr(cmdname, '=') != NULL) {
	verify(find_command_idx("set", &i) == 0);
	current_command = &command_table[i];
	ret = command_table[i].func(argc, newargv);
	} else {
	(void) fprintf(stderr, gettext("unrecognized "
	"command '%s'\n"), cmdname);
	usage(B_FALSE);
	ret = 1;
	}

	for (i = 0; i < argc; i++)
	free(newargv[i]);
	free(newargv);

	if (ret == 0 && log_history)
	(void) zpool_log_history(g_zfs, history_str);

	libzfs_fini(g_zfs);

	/*
	* The 'ZFS_ABORT' environment variable causes us to dump core on exit
	* for the purposes of running ::findleaks.
	*/
	if (getenv("ZFS_ABORT") != NULL) {
	(void) printf("dumping core by request\n");
	abort();
	}

	return (ret);
	}

	#ifdef __FreeBSD__
	#include <sys/jail.h>
	#include <jail.h>
	/*
	* Attach/detach the given dataset to/from the given jail
	*/
	/* ARGSUSED */
	static int
	zfs_do_jail_impl(int argc, char **argv, boolean_t attach)
	{
	zfs_handle_t *zhp;
	int jailid, ret;

	/* check number of arguments */
	if (argc < 3) {
	(void) fprintf(stderr, gettext("missing argument(s)\n"));
	usage(B_FALSE);
	}
	if (argc > 3) {
	(void) fprintf(stderr, gettext("too many arguments\n"));
	usage(B_FALSE);
	}

	jailid = jail_getid(argv[1]);
	if (jailid < 0) {
	(void) fprintf(stderr, gettext("invalid jail id or name\n"));
	usage(B_FALSE);
	}

	zhp = zfs_open(g_zfs, argv[2], ZFS_TYPE_FILESYSTEM);
	if (zhp == NULL)
	return (1);

	ret = (zfs_jail(zhp, jailid, attach) != 0);

	zfs_close(zhp);
	return (ret);
	}

	/*
	* zfs jail jailid filesystem
	*
	* Attach the given dataset to the given jail
	*/
	/* ARGSUSED */
	static int
	zfs_do_jail(int argc, char **argv)
	{
	return (zfs_do_jail_impl(argc, argv, B_TRUE));
	}

	/*
	* zfs unjail jailid filesystem
	*
	* Detach the given dataset from the given jail
	*/
	/* ARGSUSED */
	static int
	zfs_do_unjail(int argc, char **argv)
	{
	return (zfs_do_jail_impl(argc, argv, B_FALSE));
	}
	#endif
	diff --git a/sys/contrib/openzfs/cmd/zfs_ids_to_path/zfs_ids_to_path.c b/sys/contrib/openzfs/cmd/zfs_ids_to_path/zfs_ids_to_path.c
	index 80dd5bf2dc2e..1d3bb6b29ee1 100644
	--- a/sys/contrib/openzfs/cmd/zfs_ids_to_path/zfs_ids_to_path.c
	+++ b/sys/contrib/openzfs/cmd/zfs_ids_to_path/zfs_ids_to_path.c
	@@ -1,96 +1,96 @@
	/*
	* 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) 2019 by Delphix. All rights reserved.
	*/
	#include <libintl.h>
	#include <unistd.h>
	#include <sys/types.h>
	#include <stdint.h>
	#include <libzfs.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <errno.h>

	libzfs_handle_t *g_zfs;

	static void
	usage(int err)
	{
	- fprintf(stderr, "Usage: [-v] zfs_ids_to_path <pool> <objset id> "
	+ fprintf(stderr, "Usage: zfs_ids_to_path [-v] <pool> <objset id> "
	"<object id>\n");
	exit(err);
	}

	int
	main(int argc, char **argv)
	{
	boolean_t verbose = B_FALSE;
	int c;
	while ((c = getopt(argc, argv, "v")) != -1) {
	switch (c) {
	case 'v':
	verbose = B_TRUE;
	break;
	}
	}
	argc -= optind;
	argv += optind;

	if (argc != 3) {
	(void) fprintf(stderr, "Incorrect number of arguments: %d\n",
	argc);
	usage(1);
	}

	uint64_t objset, object;
	if (sscanf(argv[1], "%llu", (u_longlong_t *)&objset) != 1) {
	- (void) fprintf(stderr, "Invalid objset id: %s\n", argv[2]);
	+ (void) fprintf(stderr, "Invalid objset id: %s\n", argv[1]);
	usage(2);
	}
	if (sscanf(argv[2], "%llu", (u_longlong_t *)&object) != 1) {
	- (void) fprintf(stderr, "Invalid object id: %s\n", argv[3]);
	+ (void) fprintf(stderr, "Invalid object id: %s\n", argv[2]);
	usage(3);
	}
	if ((g_zfs = libzfs_init()) == NULL) {
	(void) fprintf(stderr, "%s\n", libzfs_error_init(errno));
	return (4);
	}
	zpool_handle_t *pool = zpool_open(g_zfs, argv[0]);
	if (pool == NULL) {
	- fprintf(stderr, "Could not open pool %s\n", argv[1]);
	+ fprintf(stderr, "Could not open pool %s\n", argv[0]);
	libzfs_fini(g_zfs);
	return (5);
	}

	char pathname[PATH_MAX * 2];
	if (verbose) {
	zpool_obj_to_path_ds(pool, objset, object, pathname,
	sizeof (pathname));
	} else {
	zpool_obj_to_path(pool, objset, object, pathname,
	sizeof (pathname));
	}
	printf("%s\n", pathname);
	zpool_close(pool);
	libzfs_fini(g_zfs);
	return (0);
	}
	diff --git a/sys/contrib/openzfs/cmd/zgenhostid/zgenhostid.c b/sys/contrib/openzfs/cmd/zgenhostid/zgenhostid.c
	index 50fcf05e420c..5a9bdad7c38d 100644
	--- a/sys/contrib/openzfs/cmd/zgenhostid/zgenhostid.c
	+++ b/sys/contrib/openzfs/cmd/zgenhostid/zgenhostid.c
	@@ -1,152 +1,152 @@
	/*
	* 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) 2020, Georgy Yakovlev. All rights reserved.
	*/

	#include <errno.h>
	#include <fcntl.h>
	#include <getopt.h>
	#include <inttypes.h>
	#include <limits.h>
	#include <stdint.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <sys/stat.h>
	#include <time.h>
	#include <unistd.h>

	static void usage(void);

	static void
	usage(void)
	{
	(void) fprintf(stderr,
	"usage: zgenhostid [-fh] [-o path] [value]\n\n"
	" -f\t\t force hostid file write\n"
	" -h\t\t print this usage and exit\n"
	" -o <filename>\t write hostid to this file\n\n"
	"If hostid file is not present, store a hostid in it.\n"
	"The optional value should be an 8-digit hex number between"
	" 1 and 2^32-1.\n"
	"If the value is 0 or no value is provided, a random one"
	" will be generated.\n"
	"The value must be unique among your systems.\n");
	exit(EXIT_FAILURE);
	/* NOTREACHED */
	}

	int
	main(int argc, char **argv)
	{
	/* default file path, can be optionally set by user */
	char path[PATH_MAX] = "/etc/hostid";
	/* holds converted user input or lrand48() generated value */
	unsigned long input_i = 0;

	int opt;
	int pathlen;
	int force_fwrite = 0;
	while ((opt = getopt_long(argc, argv, "fo:h?", 0, 0)) != -1) {
	switch (opt) {
	case 'f':
	force_fwrite = 1;
	break;
	case 'o':
	pathlen = snprintf(path, sizeof (path), "%s", optarg);
	if (pathlen >= sizeof (path)) {
	fprintf(stderr, "%s\n", strerror(EOVERFLOW));
	exit(EXIT_FAILURE);
	} else if (pathlen < 1) {
	fprintf(stderr, "%s\n", strerror(EINVAL));
	exit(EXIT_FAILURE);
	}
	break;
	case 'h':
	case '?':
	usage();
	}
	}

	char *in_s = argv[optind];
	if (in_s != NULL) {
	/* increment pointer by 2 if string is 0x prefixed */
	if (strncasecmp("0x", in_s, 2) == 0) {
	in_s += 2;
	}

	/* need to be exactly 8 characters */
	const char *hex = "0123456789abcdefABCDEF";
	if (strlen(in_s) != 8 \|\| strspn(in_s, hex) != 8) {
	fprintf(stderr, "%s\n", strerror(ERANGE));
	usage();
	}

	input_i = strtoul(in_s, NULL, 16);
	if (errno != 0) {
	perror("strtoul");
	exit(EXIT_FAILURE);
	}

	if (input_i > UINT32_MAX) {
	fprintf(stderr, "%s\n", strerror(ERANGE));
	usage();
	}
	}

	struct stat fstat;
	if (force_fwrite == 0 && stat(path, &fstat) == 0 &&
	S_ISREG(fstat.st_mode)) {
	fprintf(stderr, "%s: %s\n", path, strerror(EEXIST));
	exit(EXIT_FAILURE);
	}

	/*
	* generate if not provided by user
	* also handle unlikely zero return from lrand48()
	*/
	while (input_i == 0) {
	srand48(getpid() ^ time(NULL));
	input_i = lrand48();
	}

	FILE *fp = fopen(path, "wb");
	if (!fp) {
	perror("fopen");
	exit(EXIT_FAILURE);
	}

	/*
	- * we need just 4 bytes in native endianess
	+ * we need just 4 bytes in native endianness
	* not using sethostid() because it may be missing or just a stub
	*/
	uint32_t hostid = input_i;
	int written = fwrite(&hostid, 1, 4, fp);
	if (written != 4) {
	perror("fwrite");
	exit(EXIT_FAILURE);
	}

	fclose(fp);
	exit(EXIT_SUCCESS);
	}
	diff --git a/sys/contrib/openzfs/cmd/zpool/Makefile.am b/sys/contrib/openzfs/cmd/zpool/Makefile.am
	index abfa940c3d72..4446cf04a085 100644
	--- a/sys/contrib/openzfs/cmd/zpool/Makefile.am
	+++ b/sys/contrib/openzfs/cmd/zpool/Makefile.am
	@@ -1,183 +1,187 @@
	include $(top_srcdir)/config/Rules.am

	AM_CFLAGS += $(LIBBLKID_CFLAGS) $(LIBUUID_CFLAGS)

	DEFAULT_INCLUDES += -I$(srcdir)

	sbin_PROGRAMS = zpool

	zpool_SOURCES = \
	zpool_iter.c \
	zpool_main.c \
	zpool_util.c \
	zpool_util.h \
	zpool_vdev.c

	if BUILD_FREEBSD
	zpool_SOURCES += os/freebsd/zpool_vdev_os.c
	endif

	if BUILD_LINUX
	zpool_SOURCES += os/linux/zpool_vdev_os.c
	endif

	zpool_LDADD = \
	$(abs_top_builddir)/lib/libzfs/libzfs.la \
	$(abs_top_builddir)/lib/libzfs_core/libzfs_core.la \
	$(abs_top_builddir)/lib/libnvpair/libnvpair.la \
	$(abs_top_builddir)/lib/libuutil/libuutil.la

	zpool_LDADD += $(LTLIBINTL)

	if BUILD_FREEBSD
	zpool_LDADD += -lgeom
	endif
	zpool_LDADD += -lm $(LIBBLKID_LIBS) $(LIBUUID_LIBS)

	include $(top_srcdir)/config/CppCheck.am

	zpoolconfdir = $(sysconfdir)/zfs/zpool.d
	zpoolexecdir = $(zfsexecdir)/zpool.d

	EXTRA_DIST = zpool.d/README compatibility.d

	dist_zpoolexec_SCRIPTS = \
	zpool.d/dm-deps \
	zpool.d/enc \
	zpool.d/encdev \
	zpool.d/fault_led \
	zpool.d/iostat \
	zpool.d/iostat-1s \
	zpool.d/iostat-10s \
	zpool.d/label \
	zpool.d/locate_led \
	zpool.d/lsblk \
	zpool.d/media \
	zpool.d/model \
	zpool.d/serial \
	zpool.d/ses \
	zpool.d/size \
	zpool.d/slot \
	zpool.d/smart \
	zpool.d/smartx \
	zpool.d/temp \
	zpool.d/health \
	zpool.d/r_proc \
	zpool.d/w_proc \
	zpool.d/r_ucor \
	zpool.d/w_ucor \
	zpool.d/nonmed \
	zpool.d/defect \
	zpool.d/hours_on \
	zpool.d/realloc \
	zpool.d/rep_ucor \
	zpool.d/cmd_to \
	zpool.d/pend_sec \
	zpool.d/off_ucor \
	zpool.d/ata_err \
	zpool.d/nvme_err \
	zpool.d/pwr_cyc \
	zpool.d/upath \
	zpool.d/vendor \
	zpool.d/smart_test \
	zpool.d/test_type \
	zpool.d/test_status \
	zpool.d/test_progress \
	zpool.d/test_ended

	zpoolconfdefaults = \
	dm-deps \
	enc \
	encdev \
	fault_led \
	iostat \
	iostat-1s \
	iostat-10s \
	label \
	locate_led \
	lsblk \
	media \
	model \
	serial \
	ses \
	size \
	slot \
	smart \
	smartx \
	temp \
	health \
	r_proc \
	w_proc \
	r_ucor \
	w_ucor \
	nonmed \
	defect \
	hours_on \
	realloc \
	rep_ucor \
	cmd_to \
	pend_sec \
	off_ucor \
	ata_err \
	nvme_err \
	pwr_cyc \
	upath \
	vendor \
	smart_test \
	test_type \
	test_status \
	test_progress \
	test_ended

	zpoolcompatdir = $(pkgdatadir)/compatibility.d

	dist_zpoolcompat_DATA = \
	compatibility.d/compat-2018 \
	compatibility.d/compat-2019 \
	compatibility.d/compat-2020 \
	compatibility.d/compat-2021 \
	compatibility.d/freebsd-11.0 \
	compatibility.d/freebsd-11.2 \
	compatibility.d/freebsd-11.3 \
	compatibility.d/freenas-9.10.2 \
	compatibility.d/grub2 \
	compatibility.d/openzfsonosx-1.7.0 \
	compatibility.d/openzfsonosx-1.8.1 \
	compatibility.d/openzfsonosx-1.9.3 \
	compatibility.d/openzfs-2.0-freebsd \
	compatibility.d/openzfs-2.0-linux \
	+ compatibility.d/openzfs-2.1-freebsd \
	+ compatibility.d/openzfs-2.1-linux \
	+ compatibility.d/zol-0.6.1 \
	+ compatibility.d/zol-0.6.4 \
	compatibility.d/zol-0.6.5 \
	compatibility.d/zol-0.7 \
	compatibility.d/zol-0.8

	# canonical <- alias symbolic link pairs
	# eg: "2018" is a link to "compat-2018"
	zpoolcompatlinks = \
	"compat-2018 2018" \
	"compat-2019 2019" \
	"compat-2020 2020" \
	"compat-2021 2021" \
	"freebsd-11.0 freebsd-11.1" \
	"freebsd-11.0 freenas-11.0" \
	"freebsd-11.2 freenas-11.2" \
	"freebsd-11.3 freebsd-11.4" \
	"freebsd-11.3 freebsd-12.0" \
	"freebsd-11.3 freebsd-12.1" \
	"freebsd-11.3 freebsd-12.2" \
	"freebsd-11.3 freenas-11.3" \
	"freenas-11.0 freenas-11.1" \
	"openzfsonosx-1.9.3 openzfsonosx-1.9.4" \
	"openzfs-2.0-freebsd truenas-12.0" \
	"zol-0.7 ubuntu-18.04" \
	"zol-0.8 ubuntu-20.04"

	install-data-hook:
	$(MKDIR_P) "$(DESTDIR)$(zpoolconfdir)"
	for f in $(zpoolconfdefaults); do \
	test -f "$(DESTDIR)$(zpoolconfdir)/$${f}" -o \
	-L "$(DESTDIR)$(zpoolconfdir)/$${f}" \|\| \
	ln -s "$(zpoolexecdir)/$${f}" "$(DESTDIR)$(zpoolconfdir)"; \
	done
	for l in $(zpoolcompatlinks); do \
	(cd "$(DESTDIR)$(zpoolcompatdir)"; ln -sf $${l} ); \
	done
	diff --git a/sys/contrib/openzfs/cmd/zpool/compatibility.d/openzfs-2.1-freebsd b/sys/contrib/openzfs/cmd/zpool/compatibility.d/openzfs-2.1-freebsd
	new file mode 100644
	index 000000000000..9fde997e8c60
	--- /dev/null
	+++ b/sys/contrib/openzfs/cmd/zpool/compatibility.d/openzfs-2.1-freebsd
	@@ -0,0 +1,34 @@
	+# Features supported by OpenZFS 2.1 on FreeBSD
	+allocation_classes
	+async_destroy
	+bookmark_v2
	+bookmark_written
	+bookmarks
	+device_rebuild
	+device_removal
	+draid
	+embedded_data
	+empty_bpobj
	+enabled_txg
	+encryption
	+extensible_dataset
	+filesystem_limits
	+hole_birth
	+large_blocks
	+large_dnode
	+livelist
	+log_spacemap
	+lz4_compress
	+multi_vdev_crash_dump
	+obsolete_counts
	+project_quota
	+redacted_datasets
	+redaction_bookmarks
	+resilver_defer
	+sha512
	+skein
	+spacemap_histogram
	+spacemap_v2
	+userobj_accounting
	+zpool_checkpoint
	+zstd_compress
	diff --git a/sys/contrib/openzfs/cmd/zpool/compatibility.d/openzfs-2.1-linux b/sys/contrib/openzfs/cmd/zpool/compatibility.d/openzfs-2.1-linux
	new file mode 100644
	index 000000000000..c3ff176bf8f2
	--- /dev/null
	+++ b/sys/contrib/openzfs/cmd/zpool/compatibility.d/openzfs-2.1-linux
	@@ -0,0 +1,35 @@
	+# Features supported by OpenZFS 2.1 on Linux
	+allocation_classes
	+async_destroy
	+bookmark_v2
	+bookmark_written
	+bookmarks
	+device_rebuild
	+device_removal
	+draid
	+edonr
	+embedded_data
	+empty_bpobj
	+enabled_txg
	+encryption
	+extensible_dataset
	+filesystem_limits
	+hole_birth
	+large_blocks
	+large_dnode
	+livelist
	+log_spacemap
	+lz4_compress
	+multi_vdev_crash_dump
	+obsolete_counts
	+project_quota
	+redacted_datasets
	+redaction_bookmarks
	+resilver_defer
	+sha512
	+skein
	+spacemap_histogram
	+spacemap_v2
	+userobj_accounting
	+zpool_checkpoint
	+zstd_compress
	diff --git a/sys/contrib/openzfs/cmd/zpool/compatibility.d/zol-0.6.1 b/sys/contrib/openzfs/cmd/zpool/compatibility.d/zol-0.6.1
	new file mode 100644
	index 000000000000..9bc963ddccab
	--- /dev/null
	+++ b/sys/contrib/openzfs/cmd/zpool/compatibility.d/zol-0.6.1
	@@ -0,0 +1,4 @@
	+# Features supported by ZFSonLinux v0.6.1
	+async_destroy
	+empty_bpobj
	+lz4_compress
	diff --git a/sys/contrib/openzfs/cmd/zpool/compatibility.d/zol-0.6.4 b/sys/contrib/openzfs/cmd/zpool/compatibility.d/zol-0.6.4
	new file mode 100644
	index 000000000000..82a2698c8c5c
	--- /dev/null
	+++ b/sys/contrib/openzfs/cmd/zpool/compatibility.d/zol-0.6.4
	@@ -0,0 +1,10 @@
	+# Features supported by ZFSonLinux v0.6.4
	+async_destroy
	+bookmarks
	+embedded_data
	+empty_bpobj
	+enabled_txg
	+extensible_dataset
	+hole_birth
	+lz4_compress
	+spacemap_histogram
	diff --git a/sys/contrib/openzfs/cmd/zpool/zpool_iter.c b/sys/contrib/openzfs/cmd/zpool/zpool_iter.c
	index d70d266699cf..3d7a0cfc35e6 100644
	--- a/sys/contrib/openzfs/cmd/zpool/zpool_iter.c
	+++ b/sys/contrib/openzfs/cmd/zpool/zpool_iter.c
	@@ -1,763 +1,768 @@
	/*
	* 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 2007 Sun Microsystems, Inc. All rights reserved.
	* Use is subject to license terms.
	*/

	/*
	* Copyright 2016 Igor Kozhukhov <ikozhukhov@gmail.com>.
	*/

	#include <libintl.h>
	#include <libuutil.h>
	#include <stddef.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <strings.h>
	#include <thread_pool.h>

	#include <libzfs.h>
	#include <libzutil.h>
	#include <sys/zfs_context.h>
	#include <sys/wait.h>

	#include "zpool_util.h"

	/*
	* Private interface for iterating over pools specified on the command line.
	* Most consumers will call for_each_pool, but in order to support iostat, we
	* allow fined grained control through the zpool_list_t interface.
	*/

	typedef struct zpool_node {
	zpool_handle_t *zn_handle;
	uu_avl_node_t zn_avlnode;
	int zn_mark;
	} zpool_node_t;

	struct zpool_list {
	boolean_t zl_findall;
	boolean_t zl_literal;
	uu_avl_t *zl_avl;
	uu_avl_pool_t *zl_pool;
	zprop_list_t **zl_proplist;
	};

	/* ARGSUSED */
	static int
	zpool_compare(const void larg, const void rarg, void *unused)
	{
	zpool_handle_t l = ((zpool_node_t )larg)->zn_handle;
	zpool_handle_t r = ((zpool_node_t )rarg)->zn_handle;
	const char *lname = zpool_get_name(l);
	const char *rname = zpool_get_name(r);

	return (strcmp(lname, rname));
	}

	/*
	* Callback function for pool_list_get(). Adds the given pool to the AVL tree
	* of known pools.
	*/
	static int
	add_pool(zpool_handle_t zhp, void data)
	{
	zpool_list_t *zlp = data;
	zpool_node_t *node = safe_malloc(sizeof (zpool_node_t));
	uu_avl_index_t idx;

	node->zn_handle = zhp;
	uu_avl_node_init(node, &node->zn_avlnode, zlp->zl_pool);
	if (uu_avl_find(zlp->zl_avl, node, NULL, &idx) == NULL) {
	if (zlp->zl_proplist &&
	zpool_expand_proplist(zhp, zlp->zl_proplist,
	zlp->zl_literal)
	!= 0) {
	zpool_close(zhp);
	free(node);
	return (-1);
	}
	uu_avl_insert(zlp->zl_avl, node, idx);
	} else {
	zpool_close(zhp);
	free(node);
	return (-1);
	}

	return (0);
	}

	/*
	* Create a list of pools based on the given arguments. If we're given no
	* arguments, then iterate over all pools in the system and add them to the AVL
	* tree. Otherwise, add only those pool explicitly specified on the command
	* line.
	*/
	zpool_list_t *
	pool_list_get(int argc, char argv, zprop_list_t proplist,
	boolean_t literal, int *err)
	{
	zpool_list_t *zlp;

	zlp = safe_malloc(sizeof (zpool_list_t));

	zlp->zl_pool = uu_avl_pool_create("zfs_pool", sizeof (zpool_node_t),
	offsetof(zpool_node_t, zn_avlnode), zpool_compare, UU_DEFAULT);

	if (zlp->zl_pool == NULL)
	zpool_no_memory();

	if ((zlp->zl_avl = uu_avl_create(zlp->zl_pool, NULL,
	UU_DEFAULT)) == NULL)
	zpool_no_memory();

	zlp->zl_proplist = proplist;

	zlp->zl_literal = literal;

	if (argc == 0) {
	(void) zpool_iter(g_zfs, add_pool, zlp);
	zlp->zl_findall = B_TRUE;
	} else {
	int i;

	for (i = 0; i < argc; i++) {
	zpool_handle_t *zhp;

	if ((zhp = zpool_open_canfail(g_zfs, argv[i])) !=
	NULL) {
	if (add_pool(zhp, zlp) != 0)
	*err = B_TRUE;
	} else {
	*err = B_TRUE;
	}
	}
	}

	return (zlp);
	}

	/*
	* Search for any new pools, adding them to the list. We only add pools when no
	* options were given on the command line. Otherwise, we keep the list fixed as
	* those that were explicitly specified.
	*/
	void
	pool_list_update(zpool_list_t *zlp)
	{
	if (zlp->zl_findall)
	(void) zpool_iter(g_zfs, add_pool, zlp);
	}

	/*
	* Iterate over all pools in the list, executing the callback for each
	*/
	int
	pool_list_iter(zpool_list_t *zlp, int unavail, zpool_iter_f func,
	void *data)
	{
	zpool_node_t node, next_node;
	int ret = 0;

	for (node = uu_avl_first(zlp->zl_avl); node != NULL; node = next_node) {
	next_node = uu_avl_next(zlp->zl_avl, node);
	if (zpool_get_state(node->zn_handle) != POOL_STATE_UNAVAIL \|\|
	unavail)
	ret \|= func(node->zn_handle, data);
	}

	return (ret);
	}

	/*
	* Remove the given pool from the list. When running iostat, we want to remove
	* those pools that no longer exist.
	*/
	void
	pool_list_remove(zpool_list_t zlp, zpool_handle_t zhp)
	{
	zpool_node_t search, *node;

	search.zn_handle = zhp;
	if ((node = uu_avl_find(zlp->zl_avl, &search, NULL, NULL)) != NULL) {
	uu_avl_remove(zlp->zl_avl, node);
	zpool_close(node->zn_handle);
	free(node);
	}
	}

	/*
	* Free all the handles associated with this list.
	*/
	void
	pool_list_free(zpool_list_t *zlp)
	{
	uu_avl_walk_t *walk;
	zpool_node_t *node;

	if ((walk = uu_avl_walk_start(zlp->zl_avl, UU_WALK_ROBUST)) == NULL) {
	(void) fprintf(stderr,
	gettext("internal error: out of memory"));
	exit(1);
	}

	while ((node = uu_avl_walk_next(walk)) != NULL) {
	uu_avl_remove(zlp->zl_avl, node);
	zpool_close(node->zn_handle);
	free(node);
	}

	uu_avl_walk_end(walk);
	uu_avl_destroy(zlp->zl_avl);
	uu_avl_pool_destroy(zlp->zl_pool);

	free(zlp);
	}

	/*
	* Returns the number of elements in the pool list.
	*/
	int
	pool_list_count(zpool_list_t *zlp)
	{
	return (uu_avl_numnodes(zlp->zl_avl));
	}

	/*
	* High level function which iterates over all pools given on the command line,
	* using the pool_list_* interfaces.
	*/
	int
	for_each_pool(int argc, char **argv, boolean_t unavail,
	zprop_list_t *proplist, boolean_t literal, zpool_iter_f func, void data)
	{
	zpool_list_t *list;
	int ret = 0;

	if ((list = pool_list_get(argc, argv, proplist, literal, &ret)) == NULL)
	return (1);

	if (pool_list_iter(list, unavail, func, data) != 0)
	ret = 1;

	pool_list_free(list);

	return (ret);
	}

	static int
	for_each_vdev_cb(zpool_handle_t zhp, nvlist_t nv, pool_vdev_iter_f func,
	void *data)
	{
	nvlist_t **child;
	uint_t c, children;
	int ret = 0;
	int i;
	char *type;

	const char *list[] = {
	ZPOOL_CONFIG_SPARES,
	ZPOOL_CONFIG_L2CACHE,
	ZPOOL_CONFIG_CHILDREN
	};

	for (i = 0; i < ARRAY_SIZE(list); i++) {
	if (nvlist_lookup_nvlist_array(nv, list[i], &child,
	&children) == 0) {
	for (c = 0; c < children; c++) {
	uint64_t ishole = 0;

	(void) nvlist_lookup_uint64(child[c],
	ZPOOL_CONFIG_IS_HOLE, &ishole);

	if (ishole)
	continue;

	ret \|= for_each_vdev_cb(zhp, child[c], func,
	data);
	}
	}
	}

	if (nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &type) != 0)
	return (ret);

	/* Don't run our function on root vdevs */
	if (strcmp(type, VDEV_TYPE_ROOT) != 0) {
	ret \|= func(zhp, nv, data);
	}

	return (ret);
	}

	/*
	* This is the equivalent of for_each_pool() for vdevs. It iterates thorough
	* all vdevs in the pool, ignoring root vdevs and holes, calling func() on
	* each one.
	*
	* @zhp: Zpool handle
	* @func: Function to call on each vdev
	* @data: Custom data to pass to the function
	*/
	int
	for_each_vdev(zpool_handle_t zhp, pool_vdev_iter_f func, void data)
	{
	nvlist_t config, nvroot = NULL;

	if ((config = zpool_get_config(zhp, NULL)) != NULL) {
	verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
	&nvroot) == 0);
	}
	return (for_each_vdev_cb(zhp, nvroot, func, data));
	}

	/*
	* Process the vcdl->vdev_cmd_data[] array to figure out all the unique column
	* names and their widths. When this function is done, vcdl->uniq_cols,
	* vcdl->uniq_cols_cnt, and vcdl->uniq_cols_width will be filled in.
	*/
	static void
	process_unique_cmd_columns(vdev_cmd_data_list_t *vcdl)
	{
	char uniq_cols = NULL, tmp = NULL;
	int *uniq_cols_width;
	vdev_cmd_data_t *data;
	int cnt = 0;
	int k;

	/* For each vdev */
	for (int i = 0; i < vcdl->count; i++) {
	data = &vcdl->data[i];
	/* For each column the vdev reported */
	for (int j = 0; j < data->cols_cnt; j++) {
	/* Is this column in our list of unique column names? */
	for (k = 0; k < cnt; k++) {
	if (strcmp(data->cols[j], uniq_cols[k]) == 0)
	break; /* yes it is */
	}
	if (k == cnt) {
	/* No entry for column, add to list */
	tmp = realloc(uniq_cols, sizeof (uniq_cols)
	(cnt + 1));
	if (tmp == NULL)
	break; /* Nothing we can do... */
	uniq_cols = tmp;
	uniq_cols[cnt] = data->cols[j];
	cnt++;
	}
	}
	}

	/*
	* We now have a list of all the unique column names. Figure out the
	* max width of each column by looking at the column name and all its
	* values.
	*/
	uniq_cols_width = safe_malloc(sizeof (uniq_cols_width) cnt);
	for (int i = 0; i < cnt; i++) {
	/* Start off with the column title's width */
	uniq_cols_width[i] = strlen(uniq_cols[i]);
	/* For each vdev */
	for (int j = 0; j < vcdl->count; j++) {
	/* For each of the vdev's values in a column */
	data = &vcdl->data[j];
	for (k = 0; k < data->cols_cnt; k++) {
	/* Does this vdev have a value for this col? */
	if (strcmp(data->cols[k], uniq_cols[i]) == 0) {
	/* Is the value width larger? */
	uniq_cols_width[i] =
	MAX(uniq_cols_width[i],
	strlen(data->lines[k]));
	}
	}
	}
	}

	vcdl->uniq_cols = uniq_cols;
	vcdl->uniq_cols_cnt = cnt;
	vcdl->uniq_cols_width = uniq_cols_width;
	}


	/*
	* Process a line of command output
	*
	* When running 'zpool iostat\|status -c' the lines of output can either be
	* in the form of:
	*
	* column_name=value
	*
	* Or just:
	*
	* value
	*
	* Process the column_name (if any) and value.
	*
	* Returns 0 if line was processed, and there are more lines can still be
	* processed.
	*
	* Returns 1 if this was the last line to process, or error.
	*/
	static int
	vdev_process_cmd_output(vdev_cmd_data_t data, char line)
	{
	char *col = NULL;
	char *val = line;
	char *equals;
	char **tmp;

	if (line == NULL)
	return (1);

	equals = strchr(line, '=');
	if (equals != NULL) {
	/*
	* We have a 'column=value' type line. Split it into the
	* column and value strings by turning the '=' into a '\0'.
	*/
	*equals = '\0';
	col = line;
	val = equals + 1;
	} else {
	val = line;
	}

	/* Do we already have a column by this name? If so, skip it. */
	if (col != NULL) {
	for (int i = 0; i < data->cols_cnt; i++) {
	if (strcmp(col, data->cols[i]) == 0)
	return (0); /* Duplicate, skip */
	}
	}

	if (val != NULL) {
	tmp = realloc(data->lines,
	(data->lines_cnt + 1) * sizeof (*data->lines));
	if (tmp == NULL)
	return (1);

	data->lines = tmp;
	data->lines[data->lines_cnt] = strdup(val);
	data->lines_cnt++;
	}

	if (col != NULL) {
	tmp = realloc(data->cols,
	(data->cols_cnt + 1) * sizeof (*data->cols));
	if (tmp == NULL)
	return (1);

	data->cols = tmp;
	data->cols[data->cols_cnt] = strdup(col);
	data->cols_cnt++;
	}

	if (val != NULL && col == NULL)
	return (1);

	return (0);
	}

	/*
	* Run the cmd and store results in *data.
	*/
	static void
	vdev_run_cmd(vdev_cmd_data_t data, char cmd)
	{
	int rc;
	char *argv[2] = {cmd, 0};
	char *env[5] = {"PATH=/bin:/sbin:/usr/bin:/usr/sbin", NULL, NULL, NULL,
	NULL};
	char **lines = NULL;
	int lines_cnt = 0;
	int i;

	/* Setup our custom environment variables */
	rc = asprintf(&env[1], "VDEV_PATH=%s",
	data->path ? data->path : "");
	- if (rc == -1)
	+ if (rc == -1) {
	+ env[1] = NULL;
	goto out;
	+ }

	rc = asprintf(&env[2], "VDEV_UPATH=%s",
	data->upath ? data->upath : "");
	- if (rc == -1)
	+ if (rc == -1) {
	+ env[2] = NULL;
	goto out;
	+ }

	rc = asprintf(&env[3], "VDEV_ENC_SYSFS_PATH=%s",
	data->vdev_enc_sysfs_path ?
	data->vdev_enc_sysfs_path : "");
	- if (rc == -1)
	+ if (rc == -1) {
	+ env[3] = NULL;
	goto out;
	+ }

	/* Run the command */
	rc = libzfs_run_process_get_stdout_nopath(cmd, argv, env, &lines,
	&lines_cnt);
	if (rc != 0)
	goto out;

	/* Process the output we got */
	for (i = 0; i < lines_cnt; i++)
	if (vdev_process_cmd_output(data, lines[i]) != 0)
	break;

	out:
	if (lines != NULL)
	libzfs_free_str_array(lines, lines_cnt);

	/* Start with i = 1 since env[0] was statically allocated */
	for (i = 1; i < ARRAY_SIZE(env); i++)
	- if (env[i] != NULL)
	- free(env[i]);
	+ free(env[i]);
	}

	/*
	* Generate the search path for zpool iostat/status -c scripts.
	* The string returned must be freed.
	*/
	char *
	zpool_get_cmd_search_path(void)
	{
	const char *env;
	char *sp = NULL;

	env = getenv("ZPOOL_SCRIPTS_PATH");
	if (env != NULL)
	return (strdup(env));

	env = getenv("HOME");
	if (env != NULL) {
	if (asprintf(&sp, "%s/.zpool.d:%s",
	env, ZPOOL_SCRIPTS_DIR) != -1) {
	return (sp);
	}
	}

	if (asprintf(&sp, "%s", ZPOOL_SCRIPTS_DIR) != -1)
	return (sp);

	return (NULL);
	}

	/* Thread function run for each vdev */
	static void
	vdev_run_cmd_thread(void *cb_cmd_data)
	{
	vdev_cmd_data_t *data = cb_cmd_data;
	char cmd = NULL, cmddup, *cmdrest;

	cmddup = strdup(data->cmd);
	if (cmddup == NULL)
	return;

	cmdrest = cmddup;
	while ((cmd = strtok_r(cmdrest, ",", &cmdrest))) {
	char dir = NULL, sp, *sprest;
	char fullpath[MAXPATHLEN];

	if (strchr(cmd, '/') != NULL)
	continue;

	sp = zpool_get_cmd_search_path();
	if (sp == NULL)
	continue;

	sprest = sp;
	while ((dir = strtok_r(sprest, ":", &sprest))) {
	if (snprintf(fullpath, sizeof (fullpath),
	"%s/%s", dir, cmd) == -1)
	continue;

	if (access(fullpath, X_OK) == 0) {
	vdev_run_cmd(data, fullpath);
	break;
	}
	}
	free(sp);
	}
	free(cmddup);
	}

	/* For each vdev in the pool run a command */
	static int
	for_each_vdev_run_cb(zpool_handle_t zhp, nvlist_t nv, void *cb_vcdl)
	{
	vdev_cmd_data_list_t *vcdl = cb_vcdl;
	vdev_cmd_data_t *data;
	char *path = NULL;
	char *vname = NULL;
	char *vdev_enc_sysfs_path = NULL;
	int i, match = 0;

	if (nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path) != 0)
	return (1);

	nvlist_lookup_string(nv, ZPOOL_CONFIG_VDEV_ENC_SYSFS_PATH,
	&vdev_enc_sysfs_path);

	/* Spares show more than once if they're in use, so skip if exists */
	for (i = 0; i < vcdl->count; i++) {
	if ((strcmp(vcdl->data[i].path, path) == 0) &&
	(strcmp(vcdl->data[i].pool, zpool_get_name(zhp)) == 0)) {
	/* vdev already exists, skip it */
	return (0);
	}
	}

	/* Check for selected vdevs here, if any */
	for (i = 0; i < vcdl->vdev_names_count; i++) {
	vname = zpool_vdev_name(g_zfs, zhp, nv, vcdl->cb_name_flags);
	if (strcmp(vcdl->vdev_names[i], vname) == 0) {
	free(vname);
	match = 1;
	break; /* match */
	}
	free(vname);
	}

	/* If we selected vdevs, and this isn't one of them, then bail out */
	if (!match && vcdl->vdev_names_count)
	return (0);

	/*
	* Resize our array and add in the new element.
	*/
	if (!(vcdl->data = realloc(vcdl->data,
	sizeof (vcdl->data) (vcdl->count + 1))))
	return (ENOMEM); /* couldn't realloc */

	data = &vcdl->data[vcdl->count];

	data->pool = strdup(zpool_get_name(zhp));
	data->path = strdup(path);
	data->upath = zfs_get_underlying_path(path);
	data->cmd = vcdl->cmd;
	data->lines = data->cols = NULL;
	data->lines_cnt = data->cols_cnt = 0;
	if (vdev_enc_sysfs_path)
	data->vdev_enc_sysfs_path = strdup(vdev_enc_sysfs_path);
	else
	data->vdev_enc_sysfs_path = NULL;

	vcdl->count++;

	return (0);
	}

	/* Get the names and count of the vdevs */
	static int
	all_pools_for_each_vdev_gather_cb(zpool_handle_t zhp, void cb_vcdl)
	{
	return (for_each_vdev(zhp, for_each_vdev_run_cb, cb_vcdl));
	}

	/*
	* Now that vcdl is populated with our complete list of vdevs, spawn
	* off the commands.
	*/
	static void
	all_pools_for_each_vdev_run_vcdl(vdev_cmd_data_list_t *vcdl)
	{
	tpool_t *t;

	t = tpool_create(1, 5 * sysconf(_SC_NPROCESSORS_ONLN), 0, NULL);
	if (t == NULL)
	return;

	/* Spawn off the command for each vdev */
	for (int i = 0; i < vcdl->count; i++) {
	(void) tpool_dispatch(t, vdev_run_cmd_thread,
	(void *) &vcdl->data[i]);
	}

	/* Wait for threads to finish */
	tpool_wait(t);
	tpool_destroy(t);
	}

	/*
	* Run command 'cmd' on all vdevs in all pools in argv. Saves the first line of
	* output from the command in vcdk->data[].line for all vdevs. If you want
	* to run the command on only certain vdevs, fill in g_zfs, vdev_names,
	* vdev_names_count, and cb_name_flags. Otherwise leave them as zero.
	*
	* Returns a vdev_cmd_data_list_t that must be freed with
	* free_vdev_cmd_data_list();
	*/
	vdev_cmd_data_list_t *
	all_pools_for_each_vdev_run(int argc, char *argv, char cmd,
	libzfs_handle_t g_zfs, char *vdev_names, int vdev_names_count,
	int cb_name_flags)
	{
	vdev_cmd_data_list_t *vcdl;
	vcdl = safe_malloc(sizeof (vdev_cmd_data_list_t));
	vcdl->cmd = cmd;

	vcdl->vdev_names = vdev_names;
	vcdl->vdev_names_count = vdev_names_count;
	vcdl->cb_name_flags = cb_name_flags;
	vcdl->g_zfs = g_zfs;

	/* Gather our list of all vdevs in all pools */
	for_each_pool(argc, argv, B_TRUE, NULL, B_FALSE,
	all_pools_for_each_vdev_gather_cb, vcdl);

	/* Run command on all vdevs in all pools */
	all_pools_for_each_vdev_run_vcdl(vcdl);

	/*
	* vcdl->data[] now contains all the column names and values for each
	* vdev. We need to process that into a master list of unique column
	* names, and figure out the width of each column.
	*/
	process_unique_cmd_columns(vcdl);

	return (vcdl);
	}

	/*
	* Free the vdev_cmd_data_list_t created by all_pools_for_each_vdev_run()
	*/
	void
	free_vdev_cmd_data_list(vdev_cmd_data_list_t *vcdl)
	{
	free(vcdl->uniq_cols);
	free(vcdl->uniq_cols_width);

	for (int i = 0; i < vcdl->count; i++) {
	free(vcdl->data[i].path);
	free(vcdl->data[i].pool);
	free(vcdl->data[i].upath);

	for (int j = 0; j < vcdl->data[i].lines_cnt; j++)
	free(vcdl->data[i].lines[j]);

	free(vcdl->data[i].lines);

	for (int j = 0; j < vcdl->data[i].cols_cnt; j++)
	free(vcdl->data[i].cols[j]);

	free(vcdl->data[i].cols);
	free(vcdl->data[i].vdev_enc_sysfs_path);
	}
	free(vcdl->data);
	free(vcdl);
	}
	diff --git a/sys/contrib/openzfs/cmd/zpool/zpool_main.c b/sys/contrib/openzfs/cmd/zpool/zpool_main.c
	index e23604b3d81c..d7d93c4da343 100644
	--- a/sys/contrib/openzfs/cmd/zpool/zpool_main.c
	+++ b/sys/contrib/openzfs/cmd/zpool/zpool_main.c
	@@ -1,10629 +1,10745 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright 2011 Nexenta Systems, Inc. All rights reserved.
	* Copyright (c) 2011, 2020 by Delphix. All rights reserved.
	* Copyright (c) 2012 by Frederik Wessels. All rights reserved.
	* Copyright (c) 2012 by Cyril Plisko. All rights reserved.
	* Copyright (c) 2013 by Prasad Joshi (sTec). All rights reserved.
	* Copyright 2016 Igor Kozhukhov <ikozhukhov@gmail.com>.
	* Copyright (c) 2017 Datto Inc.
	* Copyright (c) 2017 Open-E, Inc. All Rights Reserved.
	* Copyright (c) 2017, Intel Corporation.
	* Copyright (c) 2019, loli10K <ezomori.nozomu@gmail.com>
	* Copyright (c) 2021, Colm Buckley <colm@tuatha.org>
	+ * Copyright [2021] Hewlett Packard Enterprise Development LP
	*/

	#include <assert.h>
	#include <ctype.h>
	#include <dirent.h>
	#include <errno.h>
	#include <fcntl.h>
	#include <getopt.h>
	#include <libgen.h>
	#include <libintl.h>
	#include <libuutil.h>
	#include <locale.h>
	#include <pthread.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <strings.h>
	#include <time.h>
	#include <unistd.h>
	#include <pwd.h>
	#include <zone.h>
	#include <sys/wait.h>
	#include <zfs_prop.h>
	#include <sys/fs/zfs.h>
	#include <sys/stat.h>
	#include <sys/systeminfo.h>
	#include <sys/fm/fs/zfs.h>
	#include <sys/fm/util.h>
	#include <sys/fm/protocol.h>
	#include <sys/zfs_ioctl.h>
	#include <sys/mount.h>
	#include <sys/sysmacros.h>

	#include <math.h>

	#include <libzfs.h>
	#include <libzutil.h>

	#include "zpool_util.h"
	#include "zfs_comutil.h"
	#include "zfeature_common.h"

	#include "statcommon.h"

	libzfs_handle_t *g_zfs;

	static int zpool_do_create(int, char **);
	static int zpool_do_destroy(int, char **);

	static int zpool_do_add(int, char **);
	static int zpool_do_remove(int, char **);
	static int zpool_do_labelclear(int, char **);

	static int zpool_do_checkpoint(int, char **);

	static int zpool_do_list(int, char **);
	static int zpool_do_iostat(int, char **);
	static int zpool_do_status(int, char **);

	static int zpool_do_online(int, char **);
	static int zpool_do_offline(int, char **);
	static int zpool_do_clear(int, char **);
	static int zpool_do_reopen(int, char **);

	static int zpool_do_reguid(int, char **);

	static int zpool_do_attach(int, char **);
	static int zpool_do_detach(int, char **);
	static int zpool_do_replace(int, char **);
	static int zpool_do_split(int, char **);

	static int zpool_do_initialize(int, char **);
	static int zpool_do_scrub(int, char **);
	static int zpool_do_resilver(int, char **);
	static int zpool_do_trim(int, char **);

	static int zpool_do_import(int, char **);
	static int zpool_do_export(int, char **);

	static int zpool_do_upgrade(int, char **);

	static int zpool_do_history(int, char **);
	static int zpool_do_events(int, char **);

	static int zpool_do_get(int, char **);
	static int zpool_do_set(int, char **);

	static int zpool_do_sync(int, char **);

	static int zpool_do_version(int, char **);

	static int zpool_do_wait(int, char **);

	static zpool_compat_status_t zpool_do_load_compat(
	const char , boolean_t );

	/*
	* These libumem hooks provide a reasonable set of defaults for the allocator's
	* debugging facilities.
	*/

	#ifdef DEBUG
	const char *
	_umem_debug_init(void)
	{
	return ("default,verbose"); /* $UMEM_DEBUG setting */
	}

	const char *
	_umem_logging_init(void)
	{
	return ("fail,contents"); /* $UMEM_LOGGING setting */
	}
	#endif

	typedef enum {
	HELP_ADD,
	HELP_ATTACH,
	HELP_CLEAR,
	HELP_CREATE,
	HELP_CHECKPOINT,
	HELP_DESTROY,
	HELP_DETACH,
	HELP_EXPORT,
	HELP_HISTORY,
	HELP_IMPORT,
	HELP_IOSTAT,
	HELP_LABELCLEAR,
	HELP_LIST,
	HELP_OFFLINE,
	HELP_ONLINE,
	HELP_REPLACE,
	HELP_REMOVE,
	HELP_INITIALIZE,
	HELP_SCRUB,
	HELP_RESILVER,
	HELP_TRIM,
	HELP_STATUS,
	HELP_UPGRADE,
	HELP_EVENTS,
	HELP_GET,
	HELP_SET,
	HELP_SPLIT,
	HELP_SYNC,
	HELP_REGUID,
	HELP_REOPEN,
	HELP_VERSION,
	HELP_WAIT
	} zpool_help_t;


	/*
	* Flags for stats to display with "zpool iostats"
	*/
	enum iostat_type {
	IOS_DEFAULT = 0,
	IOS_LATENCY = 1,
	IOS_QUEUES = 2,
	IOS_L_HISTO = 3,
	IOS_RQ_HISTO = 4,
	IOS_COUNT, /* always last element */
	};

	/* iostat_type entries as bitmasks */
	#define IOS_DEFAULT_M (1ULL << IOS_DEFAULT)
	#define IOS_LATENCY_M (1ULL << IOS_LATENCY)
	#define IOS_QUEUES_M (1ULL << IOS_QUEUES)
	#define IOS_L_HISTO_M (1ULL << IOS_L_HISTO)
	#define IOS_RQ_HISTO_M (1ULL << IOS_RQ_HISTO)

	/* Mask of all the histo bits */
	#define IOS_ANYHISTO_M (IOS_L_HISTO_M \| IOS_RQ_HISTO_M)

	/*
	* Lookup table for iostat flags to nvlist names. Basically a list
	* of all the nvlists a flag requires. Also specifies the order in
	* which data gets printed in zpool iostat.
	*/
	static const char *vsx_type_to_nvlist[IOS_COUNT][13] = {
	[IOS_L_HISTO] = {
	ZPOOL_CONFIG_VDEV_TOT_R_LAT_HISTO,
	ZPOOL_CONFIG_VDEV_TOT_W_LAT_HISTO,
	ZPOOL_CONFIG_VDEV_DISK_R_LAT_HISTO,
	ZPOOL_CONFIG_VDEV_DISK_W_LAT_HISTO,
	ZPOOL_CONFIG_VDEV_SYNC_R_LAT_HISTO,
	ZPOOL_CONFIG_VDEV_SYNC_W_LAT_HISTO,
	ZPOOL_CONFIG_VDEV_ASYNC_R_LAT_HISTO,
	ZPOOL_CONFIG_VDEV_ASYNC_W_LAT_HISTO,
	ZPOOL_CONFIG_VDEV_SCRUB_LAT_HISTO,
	ZPOOL_CONFIG_VDEV_TRIM_LAT_HISTO,
	NULL},
	[IOS_LATENCY] = {
	ZPOOL_CONFIG_VDEV_TOT_R_LAT_HISTO,
	ZPOOL_CONFIG_VDEV_TOT_W_LAT_HISTO,
	ZPOOL_CONFIG_VDEV_DISK_R_LAT_HISTO,
	ZPOOL_CONFIG_VDEV_DISK_W_LAT_HISTO,
	ZPOOL_CONFIG_VDEV_TRIM_LAT_HISTO,
	NULL},
	[IOS_QUEUES] = {
	ZPOOL_CONFIG_VDEV_SYNC_R_ACTIVE_QUEUE,
	ZPOOL_CONFIG_VDEV_SYNC_W_ACTIVE_QUEUE,
	ZPOOL_CONFIG_VDEV_ASYNC_R_ACTIVE_QUEUE,
	ZPOOL_CONFIG_VDEV_ASYNC_W_ACTIVE_QUEUE,
	ZPOOL_CONFIG_VDEV_SCRUB_ACTIVE_QUEUE,
	ZPOOL_CONFIG_VDEV_TRIM_ACTIVE_QUEUE,
	NULL},
	[IOS_RQ_HISTO] = {
	ZPOOL_CONFIG_VDEV_SYNC_IND_R_HISTO,
	ZPOOL_CONFIG_VDEV_SYNC_AGG_R_HISTO,
	ZPOOL_CONFIG_VDEV_SYNC_IND_W_HISTO,
	ZPOOL_CONFIG_VDEV_SYNC_AGG_W_HISTO,
	ZPOOL_CONFIG_VDEV_ASYNC_IND_R_HISTO,
	ZPOOL_CONFIG_VDEV_ASYNC_AGG_R_HISTO,
	ZPOOL_CONFIG_VDEV_ASYNC_IND_W_HISTO,
	ZPOOL_CONFIG_VDEV_ASYNC_AGG_W_HISTO,
	ZPOOL_CONFIG_VDEV_IND_SCRUB_HISTO,
	ZPOOL_CONFIG_VDEV_AGG_SCRUB_HISTO,
	ZPOOL_CONFIG_VDEV_IND_TRIM_HISTO,
	ZPOOL_CONFIG_VDEV_AGG_TRIM_HISTO,
	NULL},
	};


	/*
	* Given a cb->cb_flags with a histogram bit set, return the iostat_type.
	* Right now, only one histo bit is ever set at one time, so we can
	* just do a highbit64(a)
	*/
	#define IOS_HISTO_IDX(a) (highbit64(a & IOS_ANYHISTO_M) - 1)

	typedef struct zpool_command {
	const char *name;
	int (func)(int, char *);
	zpool_help_t usage;
	} zpool_command_t;

	/*
	* Master command table. Each ZFS command has a name, associated function, and
	* usage message. The usage messages need to be internationalized, so we have
	* to have a function to return the usage message based on a command index.
	*
	* These commands are organized according to how they are displayed in the usage
	* message. An empty command (one with a NULL name) indicates an empty line in
	* the generic usage message.
	*/
	static zpool_command_t command_table[] = {
	{ "version", zpool_do_version, HELP_VERSION },
	{ NULL },
	{ "create", zpool_do_create, HELP_CREATE },
	{ "destroy", zpool_do_destroy, HELP_DESTROY },
	{ NULL },
	{ "add", zpool_do_add, HELP_ADD },
	{ "remove", zpool_do_remove, HELP_REMOVE },
	{ NULL },
	{ "labelclear", zpool_do_labelclear, HELP_LABELCLEAR },
	{ NULL },
	{ "checkpoint", zpool_do_checkpoint, HELP_CHECKPOINT },
	{ NULL },
	{ "list", zpool_do_list, HELP_LIST },
	{ "iostat", zpool_do_iostat, HELP_IOSTAT },
	{ "status", zpool_do_status, HELP_STATUS },
	{ NULL },
	{ "online", zpool_do_online, HELP_ONLINE },
	{ "offline", zpool_do_offline, HELP_OFFLINE },
	{ "clear", zpool_do_clear, HELP_CLEAR },
	{ "reopen", zpool_do_reopen, HELP_REOPEN },
	{ NULL },
	{ "attach", zpool_do_attach, HELP_ATTACH },
	{ "detach", zpool_do_detach, HELP_DETACH },
	{ "replace", zpool_do_replace, HELP_REPLACE },
	{ "split", zpool_do_split, HELP_SPLIT },
	{ NULL },
	{ "initialize", zpool_do_initialize, HELP_INITIALIZE },
	{ "resilver", zpool_do_resilver, HELP_RESILVER },
	{ "scrub", zpool_do_scrub, HELP_SCRUB },
	{ "trim", zpool_do_trim, HELP_TRIM },
	{ NULL },
	{ "import", zpool_do_import, HELP_IMPORT },
	{ "export", zpool_do_export, HELP_EXPORT },
	{ "upgrade", zpool_do_upgrade, HELP_UPGRADE },
	{ "reguid", zpool_do_reguid, HELP_REGUID },
	{ NULL },
	{ "history", zpool_do_history, HELP_HISTORY },
	{ "events", zpool_do_events, HELP_EVENTS },
	{ NULL },
	{ "get", zpool_do_get, HELP_GET },
	{ "set", zpool_do_set, HELP_SET },
	{ "sync", zpool_do_sync, HELP_SYNC },
	{ NULL },
	{ "wait", zpool_do_wait, HELP_WAIT },
	};

	#define NCOMMAND (ARRAY_SIZE(command_table))

	#define VDEV_ALLOC_CLASS_LOGS "logs"

	static zpool_command_t *current_command;
	static char history_str[HIS_MAX_RECORD_LEN];
	static boolean_t log_history = B_TRUE;
	static uint_t timestamp_fmt = NODATE;

	static const char *
	get_usage(zpool_help_t idx)
	{
	switch (idx) {
	case HELP_ADD:
	return (gettext("\tadd [-fgLnP] [-o property=value] "
	"<pool> <vdev> ...\n"));
	case HELP_ATTACH:
	return (gettext("\tattach [-fsw] [-o property=value] "
	"<pool> <device> <new-device>\n"));
	case HELP_CLEAR:
	return (gettext("\tclear [-nF] <pool> [device]\n"));
	case HELP_CREATE:
	return (gettext("\tcreate [-fnd] [-o property=value] ... \n"
	"\t [-O file-system-property=value] ... \n"
	"\t [-m mountpoint] [-R root] <pool> <vdev> ...\n"));
	case HELP_CHECKPOINT:
	return (gettext("\tcheckpoint [-d [-w]] <pool> ...\n"));
	case HELP_DESTROY:
	return (gettext("\tdestroy [-f] <pool>\n"));
	case HELP_DETACH:
	return (gettext("\tdetach <pool> <device>\n"));
	case HELP_EXPORT:
	return (gettext("\texport [-af] <pool> ...\n"));
	case HELP_HISTORY:
	return (gettext("\thistory [-il] [<pool>] ...\n"));
	case HELP_IMPORT:
	return (gettext("\timport [-d dir] [-D]\n"
	"\timport [-o mntopts] [-o property=value] ... \n"
	"\t [-d dir \| -c cachefile] [-D] [-l] [-f] [-m] [-N] "
	"[-R root] [-F [-n]] -a\n"
	"\timport [-o mntopts] [-o property=value] ... \n"
	"\t [-d dir \| -c cachefile] [-D] [-l] [-f] [-m] [-N] "
	"[-R root] [-F [-n]]\n"
	"\t [--rewind-to-checkpoint] <pool \| id> [newpool]\n"));
	case HELP_IOSTAT:
	return (gettext("\tiostat [[[-c [script1,script2,...]"
	"[-lq]]\|[-rw]] [-T d \| u] [-ghHLpPvy]\n"
	"\t [[pool ...]\|[pool vdev ...]\|[vdev ...]]"
	" [[-n] interval [count]]\n"));
	case HELP_LABELCLEAR:
	return (gettext("\tlabelclear [-f] <vdev>\n"));
	case HELP_LIST:
	return (gettext("\tlist [-gHLpPv] [-o property[,...]] "
	"[-T d\|u] [pool] ... \n"
	"\t [interval [count]]\n"));
	case HELP_OFFLINE:
	return (gettext("\toffline [-f] [-t] <pool> <device> ...\n"));
	case HELP_ONLINE:
	return (gettext("\tonline [-e] <pool> <device> ...\n"));
	case HELP_REPLACE:
	return (gettext("\treplace [-fsw] [-o property=value] "
	"<pool> <device> [new-device]\n"));
	case HELP_REMOVE:
	return (gettext("\tremove [-npsw] <pool> <device> ...\n"));
	case HELP_REOPEN:
	return (gettext("\treopen [-n] <pool>\n"));
	case HELP_INITIALIZE:
	return (gettext("\tinitialize [-c \| -s] [-w] <pool> "
	"[<device> ...]\n"));
	case HELP_SCRUB:
	return (gettext("\tscrub [-s \| -p] [-w] <pool> ...\n"));
	case HELP_RESILVER:
	return (gettext("\tresilver <pool> ...\n"));
	case HELP_TRIM:
	return (gettext("\ttrim [-dw] [-r <rate>] [-c \| -s] <pool> "
	"[<device> ...]\n"));
	case HELP_STATUS:
	return (gettext("\tstatus [-c [script1,script2,...]] "
	"[-igLpPstvxD] [-T d\|u] [pool] ... \n"
	"\t [interval [count]]\n"));
	case HELP_UPGRADE:
	return (gettext("\tupgrade\n"
	"\tupgrade -v\n"
	"\tupgrade [-V version] <-a \| pool ...>\n"));
	case HELP_EVENTS:
	return (gettext("\tevents [-vHf [pool] \| -c]\n"));
	case HELP_GET:
	return (gettext("\tget [-Hp] [-o \"all\" \| field[,...]] "
	"<\"all\" \| property[,...]> <pool> ...\n"));
	case HELP_SET:
	return (gettext("\tset <property=value> <pool> \n"));
	case HELP_SPLIT:
	return (gettext("\tsplit [-gLnPl] [-R altroot] [-o mntopts]\n"
	"\t [-o property=value] <pool> <newpool> "
	"[<device> ...]\n"));
	case HELP_REGUID:
	return (gettext("\treguid <pool>\n"));
	case HELP_SYNC:
	return (gettext("\tsync [pool] ...\n"));
	case HELP_VERSION:
	return (gettext("\tversion\n"));
	case HELP_WAIT:
	return (gettext("\twait [-Hp] [-T d\|u] [-t <activity>[,...]] "
	"<pool> [interval]\n"));
	}

	abort();
	/* NOTREACHED */
	}

	static void
	zpool_collect_leaves(zpool_handle_t zhp, nvlist_t nvroot, nvlist_t *res)
	{
	uint_t children = 0;
	nvlist_t **child;
	uint_t i;

	(void) nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN,
	&child, &children);

	if (children == 0) {
	char *path = zpool_vdev_name(g_zfs, zhp, nvroot,
	VDEV_NAME_PATH);

	if (strcmp(path, VDEV_TYPE_INDIRECT) != 0 &&
	strcmp(path, VDEV_TYPE_HOLE) != 0)
	fnvlist_add_boolean(res, path);

	free(path);
	return;
	}

	for (i = 0; i < children; i++) {
	zpool_collect_leaves(zhp, child[i], res);
	}
	}

	/*
	* Callback routine that will print out a pool property value.
	*/
	static int
	print_prop_cb(int prop, void *cb)
	{
	FILE *fp = cb;

	(void) fprintf(fp, "\t%-19s ", zpool_prop_to_name(prop));

	if (zpool_prop_readonly(prop))
	(void) fprintf(fp, " NO ");
	else
	(void) fprintf(fp, " YES ");

	if (zpool_prop_values(prop) == NULL)
	(void) fprintf(fp, "-\n");
	else
	(void) fprintf(fp, "%s\n", zpool_prop_values(prop));

	return (ZPROP_CONT);
	}

	/*
	* Display usage message. If we're inside a command, display only the usage for
	* that command. Otherwise, iterate over the entire command table and display
	* a complete usage message.
	*/
	static void
	usage(boolean_t requested)
	{
	FILE *fp = requested ? stdout : stderr;

	if (current_command == NULL) {
	int i;

	(void) fprintf(fp, gettext("usage: zpool command args ...\n"));
	(void) fprintf(fp,
	gettext("where 'command' is one of the following:\n\n"));

	for (i = 0; i < NCOMMAND; i++) {
	if (command_table[i].name == NULL)
	(void) fprintf(fp, "\n");
	else
	(void) fprintf(fp, "%s",
	get_usage(command_table[i].usage));
	}
	} else {
	(void) fprintf(fp, gettext("usage:\n"));
	(void) fprintf(fp, "%s", get_usage(current_command->usage));
	}

	if (current_command != NULL &&
	((strcmp(current_command->name, "set") == 0) \|\|
	(strcmp(current_command->name, "get") == 0) \|\|
	(strcmp(current_command->name, "list") == 0))) {

	(void) fprintf(fp,
	gettext("\nthe following properties are supported:\n"));

	(void) fprintf(fp, "\n\t%-19s %s %s\n\n",
	"PROPERTY", "EDIT", "VALUES");

	/* Iterate over all properties */
	(void) zprop_iter(print_prop_cb, fp, B_FALSE, B_TRUE,
	ZFS_TYPE_POOL);

	(void) fprintf(fp, "\t%-19s ", "feature@...");
	(void) fprintf(fp, "YES disabled \| enabled \| active\n");

	(void) fprintf(fp, gettext("\nThe feature@ properties must be "
	"appended with a feature name.\nSee zpool-features(5).\n"));
	}

	/*
	* See comments at end of main().
	*/
	if (getenv("ZFS_ABORT") != NULL) {
	(void) printf("dumping core by request\n");
	abort();
	}

	exit(requested ? 0 : 2);
	}

	/*
	* zpool initialize [-c \| -s] [-w] <pool> [<vdev> ...]
	* Initialize all unused blocks in the specified vdevs, or all vdevs in the pool
	* if none specified.
	*
	* -c Cancel. Ends active initializing.
	* -s Suspend. Initializing can then be restarted with no flags.
	* -w Wait. Blocks until initializing has completed.
	*/
	int
	zpool_do_initialize(int argc, char **argv)
	{
	int c;
	char *poolname;
	zpool_handle_t *zhp;
	nvlist_t *vdevs;
	int err = 0;
	boolean_t wait = B_FALSE;

	struct option long_options[] = {
	{"cancel", no_argument, NULL, 'c'},
	{"suspend", no_argument, NULL, 's'},
	{"wait", no_argument, NULL, 'w'},
	{0, 0, 0, 0}
	};

	pool_initialize_func_t cmd_type = POOL_INITIALIZE_START;
	while ((c = getopt_long(argc, argv, "csw", long_options, NULL)) != -1) {
	switch (c) {
	case 'c':
	if (cmd_type != POOL_INITIALIZE_START &&
	cmd_type != POOL_INITIALIZE_CANCEL) {
	(void) fprintf(stderr, gettext("-c cannot be "
	"combined with other options\n"));
	usage(B_FALSE);
	}
	cmd_type = POOL_INITIALIZE_CANCEL;
	break;
	case 's':
	if (cmd_type != POOL_INITIALIZE_START &&
	cmd_type != POOL_INITIALIZE_SUSPEND) {
	(void) fprintf(stderr, gettext("-s cannot be "
	"combined with other options\n"));
	usage(B_FALSE);
	}
	cmd_type = POOL_INITIALIZE_SUSPEND;
	break;
	case 'w':
	wait = B_TRUE;
	break;
	case '?':
	if (optopt != 0) {
	(void) fprintf(stderr,
	gettext("invalid option '%c'\n"), optopt);
	} else {
	(void) fprintf(stderr,
	gettext("invalid option '%s'\n"),
	argv[optind - 1]);
	}
	usage(B_FALSE);
	}
	}

	argc -= optind;
	argv += optind;

	if (argc < 1) {
	(void) fprintf(stderr, gettext("missing pool name argument\n"));
	usage(B_FALSE);
	return (-1);
	}

	if (wait && (cmd_type != POOL_INITIALIZE_START)) {
	(void) fprintf(stderr, gettext("-w cannot be used with -c or "
	"-s\n"));
	usage(B_FALSE);
	}

	poolname = argv[0];
	zhp = zpool_open(g_zfs, poolname);
	if (zhp == NULL)
	return (-1);

	vdevs = fnvlist_alloc();
	if (argc == 1) {
	/* no individual leaf vdevs specified, so add them all */
	nvlist_t *config = zpool_get_config(zhp, NULL);
	nvlist_t *nvroot = fnvlist_lookup_nvlist(config,
	ZPOOL_CONFIG_VDEV_TREE);
	zpool_collect_leaves(zhp, nvroot, vdevs);
	} else {
	for (int i = 1; i < argc; i++) {
	fnvlist_add_boolean(vdevs, argv[i]);
	}
	}

	if (wait)
	err = zpool_initialize_wait(zhp, cmd_type, vdevs);
	else
	err = zpool_initialize(zhp, cmd_type, vdevs);

	fnvlist_free(vdevs);
	zpool_close(zhp);

	return (err);
	}

	/*
	* print a pool vdev config for dry runs
	*/
	static void
	print_vdev_tree(zpool_handle_t zhp, const char name, nvlist_t *nv, int indent,
	const char *match, int name_flags)
	{
	nvlist_t **child;
	uint_t c, children;
	char *vname;
	boolean_t printed = B_FALSE;

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
	&child, &children) != 0) {
	if (name != NULL)
	(void) printf("\t%*s%s\n", indent, "", name);
	return;
	}

	for (c = 0; c < children; c++) {
	uint64_t is_log = B_FALSE, is_hole = B_FALSE;
	char *class = "";

	(void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_HOLE,
	&is_hole);

	if (is_hole == B_TRUE) {
	continue;
	}

	(void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG,
	&is_log);
	if (is_log)
	class = VDEV_ALLOC_BIAS_LOG;
	(void) nvlist_lookup_string(child[c],
	ZPOOL_CONFIG_ALLOCATION_BIAS, &class);
	if (strcmp(match, class) != 0)
	continue;

	if (!printed && name != NULL) {
	(void) printf("\t%*s%s\n", indent, "", name);
	printed = B_TRUE;
	}
	vname = zpool_vdev_name(g_zfs, zhp, child[c], name_flags);
	print_vdev_tree(zhp, vname, child[c], indent + 2, "",
	name_flags);
	free(vname);
	}
	}

	/*
	* Print the list of l2cache devices for dry runs.
	*/
	static void
	print_cache_list(nvlist_t *nv, int indent)
	{
	nvlist_t **child;
	uint_t c, children;

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_L2CACHE,
	&child, &children) == 0 && children > 0) {
	(void) printf("\t%*s%s\n", indent, "", "cache");
	} else {
	return;
	}
	for (c = 0; c < children; c++) {
	char *vname;

	vname = zpool_vdev_name(g_zfs, NULL, child[c], 0);
	(void) printf("\t%*s%s\n", indent + 2, "", vname);
	free(vname);
	}
	}

	/*
	* Print the list of spares for dry runs.
	*/
	static void
	print_spare_list(nvlist_t *nv, int indent)
	{
	nvlist_t **child;
	uint_t c, children;

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_SPARES,
	&child, &children) == 0 && children > 0) {
	(void) printf("\t%*s%s\n", indent, "", "spares");
	} else {
	return;
	}
	for (c = 0; c < children; c++) {
	char *vname;

	vname = zpool_vdev_name(g_zfs, NULL, child[c], 0);
	(void) printf("\t%*s%s\n", indent + 2, "", vname);
	free(vname);
	}
	}

	static boolean_t
	prop_list_contains_feature(nvlist_t *proplist)
	{
	nvpair_t *nvp;
	for (nvp = nvlist_next_nvpair(proplist, NULL); NULL != nvp;
	nvp = nvlist_next_nvpair(proplist, nvp)) {
	if (zpool_prop_feature(nvpair_name(nvp)))
	return (B_TRUE);
	}
	return (B_FALSE);
	}

	/*
	* Add a property pair (name, string-value) into a property nvlist.
	*/
	static int
	add_prop_list(const char propname, char propval, nvlist_t **props,
	boolean_t poolprop)
	{
	zpool_prop_t prop = ZPOOL_PROP_INVAL;
	nvlist_t *proplist;
	const char *normnm;
	char *strval;

	if (*props == NULL &&
	nvlist_alloc(props, NV_UNIQUE_NAME, 0) != 0) {
	(void) fprintf(stderr,
	gettext("internal error: out of memory\n"));
	return (1);
	}

	proplist = *props;

	if (poolprop) {
	const char *vname = zpool_prop_to_name(ZPOOL_PROP_VERSION);
	- const char *fname =
	+ const char *cname =
	zpool_prop_to_name(ZPOOL_PROP_COMPATIBILITY);

	if ((prop = zpool_name_to_prop(propname)) == ZPOOL_PROP_INVAL &&
	!zpool_prop_feature(propname)) {
	(void) fprintf(stderr, gettext("property '%s' is "
	"not a valid pool property\n"), propname);
	return (2);
	}

	/*
	* feature@ properties and version should not be specified
	* at the same time.
	*/
	if ((prop == ZPOOL_PROP_INVAL && zpool_prop_feature(propname) &&
	nvlist_exists(proplist, vname)) \|\|
	(prop == ZPOOL_PROP_VERSION &&
	prop_list_contains_feature(proplist))) {
	(void) fprintf(stderr, gettext("'feature@' and "
	"'version' properties cannot be specified "
	"together\n"));
	return (2);
	}

	/*
	- * compatibility property and version should not be specified
	- * at the same time.
	+ * if version is specified, only "legacy" compatibility
	+ * may be requested
	*/
	if ((prop == ZPOOL_PROP_COMPATIBILITY &&
	+ strcmp(propval, ZPOOL_COMPAT_LEGACY) != 0 &&
	nvlist_exists(proplist, vname)) \|\|
	(prop == ZPOOL_PROP_VERSION &&
	- nvlist_exists(proplist, fname))) {
	- (void) fprintf(stderr, gettext("'compatibility' and "
	- "'version' properties cannot be specified "
	- "together\n"));
	+ nvlist_exists(proplist, cname) &&
	+ strcmp(fnvlist_lookup_string(proplist, cname),
	+ ZPOOL_COMPAT_LEGACY) != 0)) {
	+ (void) fprintf(stderr, gettext("when 'version' is "
	+ "specified, the 'compatibility' feature may only "
	+ "be set to '" ZPOOL_COMPAT_LEGACY "'\n"));
	return (2);
	}

	if (zpool_prop_feature(propname))
	normnm = propname;
	else
	normnm = zpool_prop_to_name(prop);
	} else {
	zfs_prop_t fsprop = zfs_name_to_prop(propname);

	if (zfs_prop_valid_for_type(fsprop, ZFS_TYPE_FILESYSTEM,
	B_FALSE)) {
	normnm = zfs_prop_to_name(fsprop);
	} else if (zfs_prop_user(propname) \|\|
	zfs_prop_userquota(propname)) {
	normnm = propname;
	} else {
	(void) fprintf(stderr, gettext("property '%s' is "
	"not a valid filesystem property\n"), propname);
	return (2);
	}
	}

	if (nvlist_lookup_string(proplist, normnm, &strval) == 0 &&
	prop != ZPOOL_PROP_CACHEFILE) {
	(void) fprintf(stderr, gettext("property '%s' "
	"specified multiple times\n"), propname);
	return (2);
	}

	if (nvlist_add_string(proplist, normnm, propval) != 0) {
	(void) fprintf(stderr, gettext("internal "
	"error: out of memory\n"));
	return (1);
	}

	return (0);
	}

	/*
	* Set a default property pair (name, string-value) in a property nvlist
	*/
	static int
	add_prop_list_default(const char propname, char propval, nvlist_t **props,
	boolean_t poolprop)
	{
	char *pval;

	if (nvlist_lookup_string(*props, propname, &pval) == 0)
	return (0);

	return (add_prop_list(propname, propval, props, B_TRUE));
	}

	/*
	* zpool add [-fgLnP] [-o property=value] <pool> <vdev> ...
	*
	* -f Force addition of devices, even if they appear in use
	* -g Display guid for individual vdev name.
	* -L Follow links when resolving vdev path name.
	* -n Do not add the devices, but display the resulting layout if
	* they were to be added.
	* -o Set property=value.
	* -P Display full path for vdev name.
	*
	* Adds the given vdevs to 'pool'. As with create, the bulk of this work is
	* handled by make_root_vdev(), which constructs the nvlist needed to pass to
	* libzfs.
	*/
	int
	zpool_do_add(int argc, char **argv)
	{
	boolean_t force = B_FALSE;
	boolean_t dryrun = B_FALSE;
	int name_flags = 0;
	int c;
	nvlist_t *nvroot;
	char *poolname;
	int ret;
	zpool_handle_t *zhp;
	nvlist_t *config;
	nvlist_t *props = NULL;
	char *propval;

	/* check options */
	while ((c = getopt(argc, argv, "fgLno:P")) != -1) {
	switch (c) {
	case 'f':
	force = B_TRUE;
	break;
	case 'g':
	name_flags \|= VDEV_NAME_GUID;
	break;
	case 'L':
	name_flags \|= VDEV_NAME_FOLLOW_LINKS;
	break;
	case 'n':
	dryrun = B_TRUE;
	break;
	case 'o':
	if ((propval = strchr(optarg, '=')) == NULL) {
	(void) fprintf(stderr, gettext("missing "
	"'=' for -o option\n"));
	usage(B_FALSE);
	}
	*propval = '\0';
	propval++;

	if ((strcmp(optarg, ZPOOL_CONFIG_ASHIFT) != 0) \|\|
	(add_prop_list(optarg, propval, &props, B_TRUE)))
	usage(B_FALSE);
	break;
	case 'P':
	name_flags \|= VDEV_NAME_PATH;
	break;
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	argc -= optind;
	argv += optind;

	/* get pool name and check number of arguments */
	if (argc < 1) {
	(void) fprintf(stderr, gettext("missing pool name argument\n"));
	usage(B_FALSE);
	}
	if (argc < 2) {
	(void) fprintf(stderr, gettext("missing vdev specification\n"));
	usage(B_FALSE);
	}

	poolname = argv[0];

	argc--;
	argv++;

	if ((zhp = zpool_open(g_zfs, poolname)) == NULL)
	return (1);

	if ((config = zpool_get_config(zhp, NULL)) == NULL) {
	(void) fprintf(stderr, gettext("pool '%s' is unavailable\n"),
	poolname);
	zpool_close(zhp);
	return (1);
	}

	/* unless manually specified use "ashift" pool property (if set) */
	if (!nvlist_exists(props, ZPOOL_CONFIG_ASHIFT)) {
	int intval;
	zprop_source_t src;
	char strval[ZPOOL_MAXPROPLEN];

	intval = zpool_get_prop_int(zhp, ZPOOL_PROP_ASHIFT, &src);
	if (src != ZPROP_SRC_DEFAULT) {
	(void) sprintf(strval, "%" PRId32, intval);
	verify(add_prop_list(ZPOOL_CONFIG_ASHIFT, strval,
	&props, B_TRUE) == 0);
	}
	}

	/* pass off to make_root_vdev for processing */
	nvroot = make_root_vdev(zhp, props, force, !force, B_FALSE, dryrun,
	argc, argv);
	if (nvroot == NULL) {
	zpool_close(zhp);
	return (1);
	}

	if (dryrun) {
	nvlist_t *poolnvroot;
	nvlist_t l2child, sparechild;
	uint_t l2children, sparechildren, c;
	char *vname;
	boolean_t hadcache = B_FALSE, hadspare = B_FALSE;

	verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
	&poolnvroot) == 0);

	(void) printf(gettext("would update '%s' to the following "
	"configuration:\n\n"), zpool_get_name(zhp));

	/* print original main pool and new tree */
	print_vdev_tree(zhp, poolname, poolnvroot, 0, "",
	name_flags \| VDEV_NAME_TYPE_ID);
	print_vdev_tree(zhp, NULL, nvroot, 0, "", name_flags);

	/* print other classes: 'dedup', 'special', and 'log' */
	if (zfs_special_devs(poolnvroot, VDEV_ALLOC_BIAS_DEDUP)) {
	print_vdev_tree(zhp, "dedup", poolnvroot, 0,
	VDEV_ALLOC_BIAS_DEDUP, name_flags);
	print_vdev_tree(zhp, NULL, nvroot, 0,
	VDEV_ALLOC_BIAS_DEDUP, name_flags);
	} else if (zfs_special_devs(nvroot, VDEV_ALLOC_BIAS_DEDUP)) {
	print_vdev_tree(zhp, "dedup", nvroot, 0,
	VDEV_ALLOC_BIAS_DEDUP, name_flags);
	}

	if (zfs_special_devs(poolnvroot, VDEV_ALLOC_BIAS_SPECIAL)) {
	print_vdev_tree(zhp, "special", poolnvroot, 0,
	VDEV_ALLOC_BIAS_SPECIAL, name_flags);
	print_vdev_tree(zhp, NULL, nvroot, 0,
	VDEV_ALLOC_BIAS_SPECIAL, name_flags);
	} else if (zfs_special_devs(nvroot, VDEV_ALLOC_BIAS_SPECIAL)) {
	print_vdev_tree(zhp, "special", nvroot, 0,
	VDEV_ALLOC_BIAS_SPECIAL, name_flags);
	}

	if (num_logs(poolnvroot) > 0) {
	print_vdev_tree(zhp, "logs", poolnvroot, 0,
	VDEV_ALLOC_BIAS_LOG, name_flags);
	print_vdev_tree(zhp, NULL, nvroot, 0,
	VDEV_ALLOC_BIAS_LOG, name_flags);
	} else if (num_logs(nvroot) > 0) {
	print_vdev_tree(zhp, "logs", nvroot, 0,
	VDEV_ALLOC_BIAS_LOG, name_flags);
	}

	/* Do the same for the caches */
	if (nvlist_lookup_nvlist_array(poolnvroot, ZPOOL_CONFIG_L2CACHE,
	&l2child, &l2children) == 0 && l2children) {
	hadcache = B_TRUE;
	(void) printf(gettext("\tcache\n"));
	for (c = 0; c < l2children; c++) {
	vname = zpool_vdev_name(g_zfs, NULL,
	l2child[c], name_flags);
	(void) printf("\t %s\n", vname);
	free(vname);
	}
	}
	if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE,
	&l2child, &l2children) == 0 && l2children) {
	if (!hadcache)
	(void) printf(gettext("\tcache\n"));
	for (c = 0; c < l2children; c++) {
	vname = zpool_vdev_name(g_zfs, NULL,
	l2child[c], name_flags);
	(void) printf("\t %s\n", vname);
	free(vname);
	}
	}
	- /* And finaly the spares */
	+ /* And finally the spares */
	if (nvlist_lookup_nvlist_array(poolnvroot, ZPOOL_CONFIG_SPARES,
	&sparechild, &sparechildren) == 0 && sparechildren > 0) {
	hadspare = B_TRUE;
	(void) printf(gettext("\tspares\n"));
	for (c = 0; c < sparechildren; c++) {
	vname = zpool_vdev_name(g_zfs, NULL,
	sparechild[c], name_flags);
	(void) printf("\t %s\n", vname);
	free(vname);
	}
	}
	if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES,
	&sparechild, &sparechildren) == 0 && sparechildren > 0) {
	if (!hadspare)
	(void) printf(gettext("\tspares\n"));
	for (c = 0; c < sparechildren; c++) {
	vname = zpool_vdev_name(g_zfs, NULL,
	sparechild[c], name_flags);
	(void) printf("\t %s\n", vname);
	free(vname);
	}
	}

	ret = 0;
	} else {
	ret = (zpool_add(zhp, nvroot) != 0);
	}

	nvlist_free(props);
	nvlist_free(nvroot);
	zpool_close(zhp);

	return (ret);
	}

	/*
	* zpool remove [-npsw] <pool> <vdev> ...
	*
	* Removes the given vdev from the pool.
	*/
	int
	zpool_do_remove(int argc, char **argv)
	{
	char *poolname;
	int i, ret = 0;
	zpool_handle_t *zhp = NULL;
	boolean_t stop = B_FALSE;
	int c;
	boolean_t noop = B_FALSE;
	boolean_t parsable = B_FALSE;
	boolean_t wait = B_FALSE;

	/* check options */
	while ((c = getopt(argc, argv, "npsw")) != -1) {
	switch (c) {
	case 'n':
	noop = B_TRUE;
	break;
	case 'p':
	parsable = B_TRUE;
	break;
	case 's':
	stop = B_TRUE;
	break;
	case 'w':
	wait = B_TRUE;
	break;
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	argc -= optind;
	argv += optind;

	/* get pool name and check number of arguments */
	if (argc < 1) {
	(void) fprintf(stderr, gettext("missing pool name argument\n"));
	usage(B_FALSE);
	}

	poolname = argv[0];

	if ((zhp = zpool_open(g_zfs, poolname)) == NULL)
	return (1);

	if (stop && noop) {
	(void) fprintf(stderr, gettext("stop request ignored\n"));
	return (0);
	}

	if (stop) {
	if (argc > 1) {
	(void) fprintf(stderr, gettext("too many arguments\n"));
	usage(B_FALSE);
	}
	if (zpool_vdev_remove_cancel(zhp) != 0)
	ret = 1;
	if (wait) {
	(void) fprintf(stderr, gettext("invalid option "
	"combination: -w cannot be used with -s\n"));
	usage(B_FALSE);
	}
	} else {
	if (argc < 2) {
	(void) fprintf(stderr, gettext("missing device\n"));
	usage(B_FALSE);
	}

	for (i = 1; i < argc; i++) {
	if (noop) {
	uint64_t size;

	if (zpool_vdev_indirect_size(zhp, argv[i],
	&size) != 0) {
	ret = 1;
	break;
	}
	if (parsable) {
	(void) printf("%s %llu\n",
	argv[i], (unsigned long long)size);
	} else {
	char valstr[32];
	zfs_nicenum(size, valstr,
	sizeof (valstr));
	(void) printf("Memory that will be "
	"used after removing %s: %s\n",
	argv[i], valstr);
	}
	} else {
	if (zpool_vdev_remove(zhp, argv[i]) != 0)
	ret = 1;
	}
	}

	if (ret == 0 && wait)
	ret = zpool_wait(zhp, ZPOOL_WAIT_REMOVE);
	}
	zpool_close(zhp);

	return (ret);
	}

	/*
	* zpool labelclear [-f] <vdev>
	*
	* -f Force clearing the label for the vdevs which are members of
	* the exported or foreign pools.
	*
	* Verifies that the vdev is not active and zeros out the label information
	* on the device.
	*/
	int
	zpool_do_labelclear(int argc, char **argv)
	{
	char vdev[MAXPATHLEN];
	char *name = NULL;
	struct stat st;
	int c, fd = -1, ret = 0;
	nvlist_t *config;
	pool_state_t state;
	boolean_t inuse = B_FALSE;
	boolean_t force = B_FALSE;

	/* check options */
	while ((c = getopt(argc, argv, "f")) != -1) {
	switch (c) {
	case 'f':
	force = B_TRUE;
	break;
	default:
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	argc -= optind;
	argv += optind;

	/* get vdev name */
	if (argc < 1) {
	(void) fprintf(stderr, gettext("missing vdev name\n"));
	usage(B_FALSE);
	}
	if (argc > 1) {
	(void) fprintf(stderr, gettext("too many arguments\n"));
	usage(B_FALSE);
	}

	/*
	* Check if we were given absolute path and use it as is.
	* Otherwise if the provided vdev name doesn't point to a file,
	* try prepending expected disk paths and partition numbers.
	*/
	(void) strlcpy(vdev, argv[0], sizeof (vdev));
	if (vdev[0] != '/' && stat(vdev, &st) != 0) {
	int error;

	error = zfs_resolve_shortname(argv[0], vdev, MAXPATHLEN);
	if (error == 0 && zfs_dev_is_whole_disk(vdev)) {
	if (zfs_append_partition(vdev, MAXPATHLEN) == -1)
	error = ENOENT;
	}

	if (error \|\| (stat(vdev, &st) != 0)) {
	(void) fprintf(stderr, gettext(
	"failed to find device %s, try specifying absolute "
	"path instead\n"), argv[0]);
	return (1);
	}
	}

	if ((fd = open(vdev, O_RDWR)) < 0) {
	(void) fprintf(stderr, gettext("failed to open %s: %s\n"),
	vdev, strerror(errno));
	return (1);
	}

	/*
	* Flush all dirty pages for the block device. This should not be
	* fatal when the device does not support BLKFLSBUF as would be the
	* case for a file vdev.
	*/
	if ((zfs_dev_flush(fd) != 0) && (errno != ENOTTY))
	(void) fprintf(stderr, gettext("failed to invalidate "
	"cache for %s: %s\n"), vdev, strerror(errno));

	if (zpool_read_label(fd, &config, NULL) != 0) {
	(void) fprintf(stderr,
	gettext("failed to read label from %s\n"), vdev);
	ret = 1;
	goto errout;
	}
	nvlist_free(config);

	ret = zpool_in_use(g_zfs, fd, &state, &name, &inuse);
	if (ret != 0) {
	(void) fprintf(stderr,
	gettext("failed to check state for %s\n"), vdev);
	ret = 1;
	goto errout;
	}

	if (!inuse)
	goto wipe_label;

	switch (state) {
	default:
	case POOL_STATE_ACTIVE:
	case POOL_STATE_SPARE:
	case POOL_STATE_L2CACHE:
	(void) fprintf(stderr, gettext(
	"%s is a member (%s) of pool \"%s\"\n"),
	vdev, zpool_pool_state_to_name(state), name);
	ret = 1;
	goto errout;

	case POOL_STATE_EXPORTED:
	if (force)
	break;
	(void) fprintf(stderr, gettext(
	"use '-f' to override the following error:\n"
	"%s is a member of exported pool \"%s\"\n"),
	vdev, name);
	ret = 1;
	goto errout;

	case POOL_STATE_POTENTIALLY_ACTIVE:
	if (force)
	break;
	(void) fprintf(stderr, gettext(
	"use '-f' to override the following error:\n"
	"%s is a member of potentially active pool \"%s\"\n"),
	vdev, name);
	ret = 1;
	goto errout;

	case POOL_STATE_DESTROYED:
	/* inuse should never be set for a destroyed pool */
	assert(0);
	break;
	}

	wipe_label:
	ret = zpool_clear_label(fd);
	if (ret != 0) {
	(void) fprintf(stderr,
	gettext("failed to clear label for %s\n"), vdev);
	}

	errout:
	free(name);
	(void) close(fd);

	return (ret);
	}

	/*
	* zpool create [-fnd] [-o property=value] ...
	* [-O file-system-property=value] ...
	* [-R root] [-m mountpoint] <pool> <dev> ...
	*
	* -f Force creation, even if devices appear in use
	* -n Do not create the pool, but display the resulting layout if it
	* were to be created.
	* -R Create a pool under an alternate root
	* -m Set default mountpoint for the root dataset. By default it's
	* '/<pool>'
	* -o Set property=value.
	* -o Set feature@feature=enabled\|disabled.
	* -d Don't automatically enable all supported pool features
	* (individual features can be enabled with -o).
	* -O Set fsproperty=value in the pool's root file system
	*
	* Creates the named pool according to the given vdev specification. The
	* bulk of the vdev processing is done in make_root_vdev() in zpool_vdev.c.
	* Once we get the nvlist back from make_root_vdev(), we either print out the
	* contents (if '-n' was specified), or pass it to libzfs to do the creation.
	*/
	int
	zpool_do_create(int argc, char **argv)
	{
	boolean_t force = B_FALSE;
	boolean_t dryrun = B_FALSE;
	boolean_t enable_pool_features = B_TRUE;

	int c;
	nvlist_t *nvroot = NULL;
	char *poolname;
	char *tname = NULL;
	int ret = 1;
	char *altroot = NULL;
	char *compat = NULL;
	char *mountpoint = NULL;
	nvlist_t *fsprops = NULL;
	nvlist_t *props = NULL;
	char *propval;

	/* check options */
	while ((c = getopt(argc, argv, ":fndR:m:o:O:t:")) != -1) {
	switch (c) {
	case 'f':
	force = B_TRUE;
	break;
	case 'n':
	dryrun = B_TRUE;
	break;
	case 'd':
	enable_pool_features = B_FALSE;
	break;
	case 'R':
	altroot = optarg;
	if (add_prop_list(zpool_prop_to_name(
	ZPOOL_PROP_ALTROOT), optarg, &props, B_TRUE))
	goto errout;
	if (add_prop_list_default(zpool_prop_to_name(
	ZPOOL_PROP_CACHEFILE), "none", &props, B_TRUE))
	goto errout;
	break;
	case 'm':
	/* Equivalent to -O mountpoint=optarg */
	mountpoint = optarg;
	break;
	case 'o':
	if ((propval = strchr(optarg, '=')) == NULL) {
	(void) fprintf(stderr, gettext("missing "
	"'=' for -o option\n"));
	goto errout;
	}
	*propval = '\0';
	propval++;

	if (add_prop_list(optarg, propval, &props, B_TRUE))
	goto errout;

	/*
	* If the user is creating a pool that doesn't support
	* feature flags, don't enable any features.
	*/
	if (zpool_name_to_prop(optarg) == ZPOOL_PROP_VERSION) {
	char *end;
	u_longlong_t ver;

	ver = strtoull(propval, &end, 10);
	if (*end == '\0' &&
	ver < SPA_VERSION_FEATURES) {
	enable_pool_features = B_FALSE;
	}
	}
	if (zpool_name_to_prop(optarg) == ZPOOL_PROP_ALTROOT)
	altroot = propval;
	if (zpool_name_to_prop(optarg) ==
	ZPOOL_PROP_COMPATIBILITY)
	compat = propval;
	break;
	case 'O':
	if ((propval = strchr(optarg, '=')) == NULL) {
	(void) fprintf(stderr, gettext("missing "
	"'=' for -O option\n"));
	goto errout;
	}
	*propval = '\0';
	propval++;

	/*
	* Mountpoints are checked and then added later.
	* Uniquely among properties, they can be specified
	* more than once, to avoid conflict with -m.
	*/
	if (0 == strcmp(optarg,
	zfs_prop_to_name(ZFS_PROP_MOUNTPOINT))) {
	mountpoint = propval;
	} else if (add_prop_list(optarg, propval, &fsprops,
	B_FALSE)) {
	goto errout;
	}
	break;
	case 't':
	/*
	* Sanity check temporary pool name.
	*/
	if (strchr(optarg, '/') != NULL) {
	(void) fprintf(stderr, gettext("cannot create "
	"'%s': invalid character '/' in temporary "
	"name\n"), optarg);
	(void) fprintf(stderr, gettext("use 'zfs "
	"create' to create a dataset\n"));
	goto errout;
	}

	if (add_prop_list(zpool_prop_to_name(
	ZPOOL_PROP_TNAME), optarg, &props, B_TRUE))
	goto errout;
	if (add_prop_list_default(zpool_prop_to_name(
	ZPOOL_PROP_CACHEFILE), "none", &props, B_TRUE))
	goto errout;
	tname = optarg;
	break;
	case ':':
	(void) fprintf(stderr, gettext("missing argument for "
	"'%c' option\n"), optopt);
	goto badusage;
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	goto badusage;
	}
	}

	argc -= optind;
	argv += optind;

	/* get pool name and check number of arguments */
	if (argc < 1) {
	(void) fprintf(stderr, gettext("missing pool name argument\n"));
	goto badusage;
	}
	if (argc < 2) {
	(void) fprintf(stderr, gettext("missing vdev specification\n"));
	goto badusage;
	}

	poolname = argv[0];

	/*
	* As a special case, check for use of '/' in the name, and direct the
	* user to use 'zfs create' instead.
	*/
	if (strchr(poolname, '/') != NULL) {
	(void) fprintf(stderr, gettext("cannot create '%s': invalid "
	"character '/' in pool name\n"), poolname);
	(void) fprintf(stderr, gettext("use 'zfs create' to "
	"create a dataset\n"));
	goto errout;
	}

	/* pass off to make_root_vdev for bulk processing */
	nvroot = make_root_vdev(NULL, props, force, !force, B_FALSE, dryrun,
	argc - 1, argv + 1);
	if (nvroot == NULL)
	goto errout;

	/* make_root_vdev() allows 0 toplevel children if there are spares */
	if (!zfs_allocatable_devs(nvroot)) {
	(void) fprintf(stderr, gettext("invalid vdev "
	"specification: at least one toplevel vdev must be "
	"specified\n"));
	goto errout;
	}

	if (altroot != NULL && altroot[0] != '/') {
	(void) fprintf(stderr, gettext("invalid alternate root '%s': "
	"must be an absolute path\n"), altroot);
	goto errout;
	}

	/*
	* Check the validity of the mountpoint and direct the user to use the
	* '-m' mountpoint option if it looks like its in use.
	*/
	if (mountpoint == NULL \|\|
	(strcmp(mountpoint, ZFS_MOUNTPOINT_LEGACY) != 0 &&
	strcmp(mountpoint, ZFS_MOUNTPOINT_NONE) != 0)) {
	char buf[MAXPATHLEN];
	DIR *dirp;

	if (mountpoint && mountpoint[0] != '/') {
	(void) fprintf(stderr, gettext("invalid mountpoint "
	"'%s': must be an absolute path, 'legacy', or "
	"'none'\n"), mountpoint);
	goto errout;
	}

	if (mountpoint == NULL) {
	if (altroot != NULL)
	(void) snprintf(buf, sizeof (buf), "%s/%s",
	altroot, poolname);
	else
	(void) snprintf(buf, sizeof (buf), "/%s",
	poolname);
	} else {
	if (altroot != NULL)
	(void) snprintf(buf, sizeof (buf), "%s%s",
	altroot, mountpoint);
	else
	(void) snprintf(buf, sizeof (buf), "%s",
	mountpoint);
	}

	if ((dirp = opendir(buf)) == NULL && errno != ENOENT) {
	(void) fprintf(stderr, gettext("mountpoint '%s' : "
	"%s\n"), buf, strerror(errno));
	(void) fprintf(stderr, gettext("use '-m' "
	"option to provide a different default\n"));
	goto errout;
	} else if (dirp) {
	int count = 0;

	while (count < 3 && readdir(dirp) != NULL)
	count++;
	(void) closedir(dirp);

	if (count > 2) {
	(void) fprintf(stderr, gettext("mountpoint "
	"'%s' exists and is not empty\n"), buf);
	(void) fprintf(stderr, gettext("use '-m' "
	"option to provide a "
	"different default\n"));
	goto errout;
	}
	}
	}

	/*
	* Now that the mountpoint's validity has been checked, ensure that
	* the property is set appropriately prior to creating the pool.
	*/
	if (mountpoint != NULL) {
	ret = add_prop_list(zfs_prop_to_name(ZFS_PROP_MOUNTPOINT),
	mountpoint, &fsprops, B_FALSE);
	if (ret != 0)
	goto errout;
	}

	ret = 1;
	if (dryrun) {
	/*
	* For a dry run invocation, print out a basic message and run
	* through all the vdevs in the list and print out in an
	* appropriate hierarchy.
	*/
	(void) printf(gettext("would create '%s' with the "
	"following layout:\n\n"), poolname);

	print_vdev_tree(NULL, poolname, nvroot, 0, "", 0);
	print_vdev_tree(NULL, "dedup", nvroot, 0,
	VDEV_ALLOC_BIAS_DEDUP, 0);
	print_vdev_tree(NULL, "special", nvroot, 0,
	VDEV_ALLOC_BIAS_SPECIAL, 0);
	print_vdev_tree(NULL, "logs", nvroot, 0,
	VDEV_ALLOC_BIAS_LOG, 0);
	print_cache_list(nvroot, 0);
	print_spare_list(nvroot, 0);

	ret = 0;
	} else {
	/*
	* Load in feature set.
	* Note: if compatibility property not given, we'll have
	* NULL, which means 'all features'.
	*/
	boolean_t requested_features[SPA_FEATURES];
	if (zpool_do_load_compat(compat, requested_features) !=
	ZPOOL_COMPATIBILITY_OK)
	goto errout;

	/*
	* props contains list of features to enable.
	* For each feature:
	* - remove it if feature@name=disabled
	* - leave it there if feature@name=enabled
	* - add it if:
	* - enable_pool_features (ie: no '-d' or '-o version')
	* - it's supported by the kernel module
	* - it's in the requested feature set
	+ * - warn if it's enabled but not in compat
	*/
	for (spa_feature_t i = 0; i < SPA_FEATURES; i++) {
	char propname[MAXPATHLEN];
	char *propval;
	zfeature_info_t *feat = &spa_feature_table[i];

	(void) snprintf(propname, sizeof (propname),
	"feature@%s", feat->fi_uname);

	if (!nvlist_lookup_string(props, propname, &propval)) {
	if (strcmp(propval, ZFS_FEATURE_DISABLED) == 0)
	(void) nvlist_remove_all(props,
	propname);
	+ if (strcmp(propval,
	+ ZFS_FEATURE_ENABLED) == 0 &&
	+ !requested_features[i])
	+ (void) fprintf(stderr, gettext(
	+ "Warning: feature \"%s\" enabled "
	+ "but is not in specified "
	+ "'compatibility' feature set.\n"),
	+ feat->fi_uname);
	} else if (
	enable_pool_features &&
	feat->fi_zfs_mod_supported &&
	requested_features[i]) {
	ret = add_prop_list(propname,
	ZFS_FEATURE_ENABLED, &props, B_TRUE);
	if (ret != 0)
	goto errout;
	}
	}

	ret = 1;
	if (zpool_create(g_zfs, poolname,
	nvroot, props, fsprops) == 0) {
	zfs_handle_t *pool = zfs_open(g_zfs,
	tname ? tname : poolname, ZFS_TYPE_FILESYSTEM);
	if (pool != NULL) {
	if (zfs_mount(pool, NULL, 0) == 0) {
	ret = zfs_shareall(pool);
	zfs_commit_all_shares();
	}
	zfs_close(pool);
	}
	} else if (libzfs_errno(g_zfs) == EZFS_INVALIDNAME) {
	(void) fprintf(stderr, gettext("pool name may have "
	"been omitted\n"));
	}
	}

	errout:
	nvlist_free(nvroot);
	nvlist_free(fsprops);
	nvlist_free(props);
	return (ret);
	badusage:
	nvlist_free(fsprops);
	nvlist_free(props);
	usage(B_FALSE);
	return (2);
	}

	/*
	* zpool destroy <pool>
	*
	* -f Forcefully unmount any datasets
	*
	* Destroy the given pool. Automatically unmounts any datasets in the pool.
	*/
	int
	zpool_do_destroy(int argc, char **argv)
	{
	boolean_t force = B_FALSE;
	int c;
	char *pool;
	zpool_handle_t *zhp;
	int ret;

	/* check options */
	while ((c = getopt(argc, argv, "f")) != -1) {
	switch (c) {
	case 'f':
	force = B_TRUE;
	break;
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	argc -= optind;
	argv += optind;

	/* check arguments */
	if (argc < 1) {
	(void) fprintf(stderr, gettext("missing pool argument\n"));
	usage(B_FALSE);
	}
	if (argc > 1) {
	(void) fprintf(stderr, gettext("too many arguments\n"));
	usage(B_FALSE);
	}

	pool = argv[0];

	if ((zhp = zpool_open_canfail(g_zfs, pool)) == NULL) {
	/*
	* As a special case, check for use of '/' in the name, and
	* direct the user to use 'zfs destroy' instead.
	*/
	if (strchr(pool, '/') != NULL)
	(void) fprintf(stderr, gettext("use 'zfs destroy' to "
	"destroy a dataset\n"));
	return (1);
	}

	if (zpool_disable_datasets(zhp, force) != 0) {
	(void) fprintf(stderr, gettext("could not destroy '%s': "
	"could not unmount datasets\n"), zpool_get_name(zhp));
	zpool_close(zhp);
	return (1);
	}

	/* The history must be logged as part of the export */
	log_history = B_FALSE;

	ret = (zpool_destroy(zhp, history_str) != 0);

	zpool_close(zhp);

	return (ret);
	}

	typedef struct export_cbdata {
	boolean_t force;
	boolean_t hardforce;
	} export_cbdata_t;

	/*
	* Export one pool
	*/
	static int
	zpool_export_one(zpool_handle_t zhp, void data)
	{
	export_cbdata_t *cb = data;

	if (zpool_disable_datasets(zhp, cb->force) != 0)
	return (1);

	/* The history must be logged as part of the export */
	log_history = B_FALSE;

	if (cb->hardforce) {
	if (zpool_export_force(zhp, history_str) != 0)
	return (1);
	} else if (zpool_export(zhp, cb->force, history_str) != 0) {
	return (1);
	}

	return (0);
	}

	/*
	* zpool export [-f] <pool> ...
	*
	* -a Export all pools
	* -f Forcefully unmount datasets
	*
	* Export the given pools. By default, the command will attempt to cleanly
	* unmount any active datasets within the pool. If the '-f' flag is specified,
	* then the datasets will be forcefully unmounted.
	*/
	int
	zpool_do_export(int argc, char **argv)
	{
	export_cbdata_t cb;
	boolean_t do_all = B_FALSE;
	boolean_t force = B_FALSE;
	boolean_t hardforce = B_FALSE;
	int c, ret;

	/* check options */
	while ((c = getopt(argc, argv, "afF")) != -1) {
	switch (c) {
	case 'a':
	do_all = B_TRUE;
	break;
	case 'f':
	force = B_TRUE;
	break;
	case 'F':
	hardforce = B_TRUE;
	break;
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	cb.force = force;
	cb.hardforce = hardforce;
	argc -= optind;
	argv += optind;

	if (do_all) {
	if (argc != 0) {
	(void) fprintf(stderr, gettext("too many arguments\n"));
	usage(B_FALSE);
	}

	return (for_each_pool(argc, argv, B_TRUE, NULL,
	B_FALSE, zpool_export_one, &cb));
	}

	/* check arguments */
	if (argc < 1) {
	(void) fprintf(stderr, gettext("missing pool argument\n"));
	usage(B_FALSE);
	}

	ret = for_each_pool(argc, argv, B_TRUE, NULL, B_FALSE, zpool_export_one,
	&cb);

	return (ret);
	}

	/*
	* Given a vdev configuration, determine the maximum width needed for the device
	* name column.
	*/
	static int
	max_width(zpool_handle_t zhp, nvlist_t nv, int depth, int max,
	int name_flags)
	{
	char *name;
	nvlist_t **child;
	uint_t c, children;
	int ret;

	name = zpool_vdev_name(g_zfs, zhp, nv, name_flags);
	if (strlen(name) + depth > max)
	max = strlen(name) + depth;

	free(name);

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_SPARES,
	&child, &children) == 0) {
	for (c = 0; c < children; c++)
	if ((ret = max_width(zhp, child[c], depth + 2,
	max, name_flags)) > max)
	max = ret;
	}

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_L2CACHE,
	&child, &children) == 0) {
	for (c = 0; c < children; c++)
	if ((ret = max_width(zhp, child[c], depth + 2,
	max, name_flags)) > max)
	max = ret;
	}

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
	&child, &children) == 0) {
	for (c = 0; c < children; c++)
	if ((ret = max_width(zhp, child[c], depth + 2,
	max, name_flags)) > max)
	max = ret;
	}

	return (max);
	}

	typedef struct spare_cbdata {
	uint64_t cb_guid;
	zpool_handle_t *cb_zhp;
	} spare_cbdata_t;

	static boolean_t
	find_vdev(nvlist_t *nv, uint64_t search)
	{
	uint64_t guid;
	nvlist_t **child;
	uint_t c, children;

	if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &guid) == 0 &&
	search == guid)
	return (B_TRUE);

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
	&child, &children) == 0) {
	for (c = 0; c < children; c++)
	if (find_vdev(child[c], search))
	return (B_TRUE);
	}

	return (B_FALSE);
	}

	static int
	find_spare(zpool_handle_t zhp, void data)
	{
	spare_cbdata_t *cbp = data;
	nvlist_t config, nvroot;

	config = zpool_get_config(zhp, NULL);
	verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
	&nvroot) == 0);

	if (find_vdev(nvroot, cbp->cb_guid)) {
	cbp->cb_zhp = zhp;
	return (1);
	}

	zpool_close(zhp);
	return (0);
	}

	typedef struct status_cbdata {
	int cb_count;
	int cb_name_flags;
	int cb_namewidth;
	boolean_t cb_allpools;
	boolean_t cb_verbose;
	boolean_t cb_literal;
	boolean_t cb_explain;
	boolean_t cb_first;
	boolean_t cb_dedup_stats;
	boolean_t cb_print_status;
	boolean_t cb_print_slow_ios;
	boolean_t cb_print_vdev_init;
	boolean_t cb_print_vdev_trim;
	vdev_cmd_data_list_t *vcdl;
	} status_cbdata_t;

	/* Return 1 if string is NULL, empty, or whitespace; return 0 otherwise. */
	static int
	is_blank_str(char *str)
	{
	while (str != NULL && *str != '\0') {
	if (!isblank(*str))
	return (0);
	str++;
	}
	return (1);
	}

	/* Print command output lines for specific vdev in a specific pool */
	static void
	zpool_print_cmd(vdev_cmd_data_list_t vcdl, const char pool, char *path)
	{
	vdev_cmd_data_t *data;
	int i, j;
	char *val;

	for (i = 0; i < vcdl->count; i++) {
	if ((strcmp(vcdl->data[i].path, path) != 0) \|\|
	(strcmp(vcdl->data[i].pool, pool) != 0)) {
	/* Not the vdev we're looking for */
	continue;
	}

	data = &vcdl->data[i];
	/* Print out all the output values for this vdev */
	for (j = 0; j < vcdl->uniq_cols_cnt; j++) {
	val = NULL;
	/* Does this vdev have values for this column? */
	for (int k = 0; k < data->cols_cnt; k++) {
	if (strcmp(data->cols[k],
	vcdl->uniq_cols[j]) == 0) {
	/* yes it does, record the value */
	val = data->lines[k];
	break;
	}
	}
	/*
	* Mark empty values with dashes to make output
	* awk-able.
	*/
	if (val == NULL \|\| is_blank_str(val))
	val = "-";

	printf("%*s", vcdl->uniq_cols_width[j], val);
	if (j < vcdl->uniq_cols_cnt - 1)
	printf(" ");
	}

	/* Print out any values that aren't in a column at the end */
	for (j = data->cols_cnt; j < data->lines_cnt; j++) {
	/* Did we have any columns? If so print a spacer. */
	if (vcdl->uniq_cols_cnt > 0)
	printf(" ");

	val = data->lines[j];
	printf("%s", val ? val : "");
	}
	break;
	}
	}

	/*
	* Print vdev initialization status for leaves
	*/
	static void
	print_status_initialize(vdev_stat_t *vs, boolean_t verbose)
	{
	if (verbose) {
	if ((vs->vs_initialize_state == VDEV_INITIALIZE_ACTIVE \|\|
	vs->vs_initialize_state == VDEV_INITIALIZE_SUSPENDED \|\|
	vs->vs_initialize_state == VDEV_INITIALIZE_COMPLETE) &&
	!vs->vs_scan_removing) {
	char zbuf[1024];
	char tbuf[256];
	struct tm zaction_ts;

	time_t t = vs->vs_initialize_action_time;
	int initialize_pct = 100;
	if (vs->vs_initialize_state !=
	VDEV_INITIALIZE_COMPLETE) {
	initialize_pct = (vs->vs_initialize_bytes_done *
	100 / (vs->vs_initialize_bytes_est + 1));
	}

	(void) localtime_r(&t, &zaction_ts);
	(void) strftime(tbuf, sizeof (tbuf), "%c", &zaction_ts);

	switch (vs->vs_initialize_state) {
	case VDEV_INITIALIZE_SUSPENDED:
	(void) snprintf(zbuf, sizeof (zbuf), ", %s %s",
	gettext("suspended, started at"), tbuf);
	break;
	case VDEV_INITIALIZE_ACTIVE:
	(void) snprintf(zbuf, sizeof (zbuf), ", %s %s",
	gettext("started at"), tbuf);
	break;
	case VDEV_INITIALIZE_COMPLETE:
	(void) snprintf(zbuf, sizeof (zbuf), ", %s %s",
	gettext("completed at"), tbuf);
	break;
	}

	(void) printf(gettext(" (%d%% initialized%s)"),
	initialize_pct, zbuf);
	} else {
	(void) printf(gettext(" (uninitialized)"));
	}
	} else if (vs->vs_initialize_state == VDEV_INITIALIZE_ACTIVE) {
	(void) printf(gettext(" (initializing)"));
	}
	}

	/*
	* Print vdev TRIM status for leaves
	*/
	static void
	print_status_trim(vdev_stat_t *vs, boolean_t verbose)
	{
	if (verbose) {
	if ((vs->vs_trim_state == VDEV_TRIM_ACTIVE \|\|
	vs->vs_trim_state == VDEV_TRIM_SUSPENDED \|\|
	vs->vs_trim_state == VDEV_TRIM_COMPLETE) &&
	!vs->vs_scan_removing) {
	char zbuf[1024];
	char tbuf[256];
	struct tm zaction_ts;

	time_t t = vs->vs_trim_action_time;
	int trim_pct = 100;
	if (vs->vs_trim_state != VDEV_TRIM_COMPLETE) {
	trim_pct = (vs->vs_trim_bytes_done *
	100 / (vs->vs_trim_bytes_est + 1));
	}

	(void) localtime_r(&t, &zaction_ts);
	(void) strftime(tbuf, sizeof (tbuf), "%c", &zaction_ts);

	switch (vs->vs_trim_state) {
	case VDEV_TRIM_SUSPENDED:
	(void) snprintf(zbuf, sizeof (zbuf), ", %s %s",
	gettext("suspended, started at"), tbuf);
	break;
	case VDEV_TRIM_ACTIVE:
	(void) snprintf(zbuf, sizeof (zbuf), ", %s %s",
	gettext("started at"), tbuf);
	break;
	case VDEV_TRIM_COMPLETE:
	(void) snprintf(zbuf, sizeof (zbuf), ", %s %s",
	gettext("completed at"), tbuf);
	break;
	}

	(void) printf(gettext(" (%d%% trimmed%s)"),
	trim_pct, zbuf);
	} else if (vs->vs_trim_notsup) {
	(void) printf(gettext(" (trim unsupported)"));
	} else {
	(void) printf(gettext(" (untrimmed)"));
	}
	} else if (vs->vs_trim_state == VDEV_TRIM_ACTIVE) {
	(void) printf(gettext(" (trimming)"));
	}
	}

	/*
	* Return the color associated with a health string. This includes returning
	* NULL for no color change.
	*/
	static char *
	health_str_to_color(const char *health)
	{
	if (strcmp(health, gettext("FAULTED")) == 0 \|\|
	strcmp(health, gettext("SUSPENDED")) == 0 \|\|
	strcmp(health, gettext("UNAVAIL")) == 0) {
	return (ANSI_RED);
	}

	if (strcmp(health, gettext("OFFLINE")) == 0 \|\|
	strcmp(health, gettext("DEGRADED")) == 0 \|\|
	strcmp(health, gettext("REMOVED")) == 0) {
	return (ANSI_YELLOW);
	}

	return (NULL);
	}

	/*
	* Print out configuration state as requested by status_callback.
	*/
	static void
	print_status_config(zpool_handle_t zhp, status_cbdata_t cb, const char *name,
	nvlist_t nv, int depth, boolean_t isspare, vdev_rebuild_stat_t vrs)
	{
	nvlist_t *child, root;
	uint_t c, i, vsc, children;
	pool_scan_stat_t *ps = NULL;
	vdev_stat_t *vs;
	char rbuf[6], wbuf[6], cbuf[6];
	char *vname;
	uint64_t notpresent;
	spare_cbdata_t spare_cb;
	const char *state;
	char *type;
	char *path = NULL;
	char rcolor = NULL, wcolor = NULL, *ccolor = NULL;

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
	&child, &children) != 0)
	children = 0;

	verify(nvlist_lookup_uint64_array(nv, ZPOOL_CONFIG_VDEV_STATS,
	(uint64_t **)&vs, &vsc) == 0);

	verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &type) == 0);

	if (strcmp(type, VDEV_TYPE_INDIRECT) == 0)
	return;

	state = zpool_state_to_name(vs->vs_state, vs->vs_aux);

	if (isspare) {
	/*
	* For hot spares, we use the terms 'INUSE' and 'AVAILABLE' for
	* online drives.
	*/
	if (vs->vs_aux == VDEV_AUX_SPARED)
	state = gettext("INUSE");
	else if (vs->vs_state == VDEV_STATE_HEALTHY)
	state = gettext("AVAIL");
	}

	printf_color(health_str_to_color(state),
	"\t%s%-s %-8s", depth, "", cb->cb_namewidth - depth,
	name, state);

	if (!isspare) {
	if (vs->vs_read_errors)
	rcolor = ANSI_RED;

	if (vs->vs_write_errors)
	wcolor = ANSI_RED;

	if (vs->vs_checksum_errors)
	ccolor = ANSI_RED;

	if (cb->cb_literal) {
	printf(" ");
	printf_color(rcolor, "%5llu",
	(u_longlong_t)vs->vs_read_errors);
	printf(" ");
	printf_color(wcolor, "%5llu",
	(u_longlong_t)vs->vs_write_errors);
	printf(" ");
	printf_color(ccolor, "%5llu",
	(u_longlong_t)vs->vs_checksum_errors);
	} else {
	zfs_nicenum(vs->vs_read_errors, rbuf, sizeof (rbuf));
	zfs_nicenum(vs->vs_write_errors, wbuf, sizeof (wbuf));
	zfs_nicenum(vs->vs_checksum_errors, cbuf,
	sizeof (cbuf));
	printf(" ");
	printf_color(rcolor, "%5s", rbuf);
	printf(" ");
	printf_color(wcolor, "%5s", wbuf);
	printf(" ");
	printf_color(ccolor, "%5s", cbuf);
	}
	if (cb->cb_print_slow_ios) {
	if (children == 0) {
	/* Only leafs vdevs have slow IOs */
	zfs_nicenum(vs->vs_slow_ios, rbuf,
	sizeof (rbuf));
	} else {
	snprintf(rbuf, sizeof (rbuf), "-");
	}

	if (cb->cb_literal)
	printf(" %5llu", (u_longlong_t)vs->vs_slow_ios);
	else
	printf(" %5s", rbuf);
	}
	}

	if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_NOT_PRESENT,
	&notpresent) == 0) {
	verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path) == 0);
	(void) printf(" %s %s", gettext("was"), path);
	} else if (vs->vs_aux != 0) {
	(void) printf(" ");
	color_start(ANSI_RED);
	switch (vs->vs_aux) {
	case VDEV_AUX_OPEN_FAILED:
	(void) printf(gettext("cannot open"));
	break;

	case VDEV_AUX_BAD_GUID_SUM:
	(void) printf(gettext("missing device"));
	break;

	case VDEV_AUX_NO_REPLICAS:
	(void) printf(gettext("insufficient replicas"));
	break;

	case VDEV_AUX_VERSION_NEWER:
	(void) printf(gettext("newer version"));
	break;

	case VDEV_AUX_UNSUP_FEAT:
	(void) printf(gettext("unsupported feature(s)"));
	break;

	case VDEV_AUX_ASHIFT_TOO_BIG:
	(void) printf(gettext("unsupported minimum blocksize"));
	break;

	case VDEV_AUX_SPARED:
	verify(nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID,
	&spare_cb.cb_guid) == 0);
	if (zpool_iter(g_zfs, find_spare, &spare_cb) == 1) {
	if (strcmp(zpool_get_name(spare_cb.cb_zhp),
	zpool_get_name(zhp)) == 0)
	(void) printf(gettext("currently in "
	"use"));
	else
	(void) printf(gettext("in use by "
	"pool '%s'"),
	zpool_get_name(spare_cb.cb_zhp));
	zpool_close(spare_cb.cb_zhp);
	} else {
	(void) printf(gettext("currently in use"));
	}
	break;

	case VDEV_AUX_ERR_EXCEEDED:
	(void) printf(gettext("too many errors"));
	break;

	case VDEV_AUX_IO_FAILURE:
	(void) printf(gettext("experienced I/O failures"));
	break;

	case VDEV_AUX_BAD_LOG:
	(void) printf(gettext("bad intent log"));
	break;

	case VDEV_AUX_EXTERNAL:
	(void) printf(gettext("external device fault"));
	break;

	case VDEV_AUX_SPLIT_POOL:
	(void) printf(gettext("split into new pool"));
	break;

	case VDEV_AUX_ACTIVE:
	(void) printf(gettext("currently in use"));
	break;

	case VDEV_AUX_CHILDREN_OFFLINE:
	(void) printf(gettext("all children offline"));
	break;

	+ case VDEV_AUX_BAD_LABEL:
	+ (void) printf(gettext("invalid label"));
	+ break;
	+
	default:
	(void) printf(gettext("corrupted data"));
	break;
	}
	color_end();
	} else if (children == 0 && !isspare &&
	getenv("ZPOOL_STATUS_NON_NATIVE_ASHIFT_IGNORE") == NULL &&
	VDEV_STAT_VALID(vs_physical_ashift, vsc) &&
	vs->vs_configured_ashift < vs->vs_physical_ashift) {
	(void) printf(
	gettext(" block size: %dB configured, %dB native"),
	1 << vs->vs_configured_ashift, 1 << vs->vs_physical_ashift);
	}

	/* The root vdev has the scrub/resilver stats */
	root = fnvlist_lookup_nvlist(zpool_get_config(zhp, NULL),
	ZPOOL_CONFIG_VDEV_TREE);
	(void) nvlist_lookup_uint64_array(root, ZPOOL_CONFIG_SCAN_STATS,
	(uint64_t **)&ps, &c);

	if (ps != NULL && ps->pss_state == DSS_SCANNING && children == 0) {
	if (vs->vs_scan_processed != 0) {
	(void) printf(gettext(" (%s)"),
	(ps->pss_func == POOL_SCAN_RESILVER) ?
	"resilvering" : "repairing");
	} else if (vs->vs_resilver_deferred) {
	(void) printf(gettext(" (awaiting resilver)"));
	}
	}

	/* The top-level vdevs have the rebuild stats */
	if (vrs != NULL && vrs->vrs_state == VDEV_REBUILD_ACTIVE &&
	children == 0) {
	if (vs->vs_rebuild_processed != 0) {
	(void) printf(gettext(" (resilvering)"));
	}
	}

	if (cb->vcdl != NULL) {
	if (nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path) == 0) {
	printf(" ");
	zpool_print_cmd(cb->vcdl, zpool_get_name(zhp), path);
	}
	}

	/* Display vdev initialization and trim status for leaves. */
	if (children == 0) {
	print_status_initialize(vs, cb->cb_print_vdev_init);
	print_status_trim(vs, cb->cb_print_vdev_trim);
	}

	(void) printf("\n");

	for (c = 0; c < children; c++) {
	uint64_t islog = B_FALSE, ishole = B_FALSE;

	/* Don't print logs or holes here */
	(void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG,
	&islog);
	(void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_HOLE,
	&ishole);
	if (islog \|\| ishole)
	continue;
	/* Only print normal classes here */
	if (nvlist_exists(child[c], ZPOOL_CONFIG_ALLOCATION_BIAS))
	continue;

	/* Provide vdev_rebuild_stats to children if available */
	if (vrs == NULL) {
	(void) nvlist_lookup_uint64_array(nv,
	ZPOOL_CONFIG_REBUILD_STATS,
	(uint64_t **)&vrs, &i);
	}

	vname = zpool_vdev_name(g_zfs, zhp, child[c],
	cb->cb_name_flags \| VDEV_NAME_TYPE_ID);
	print_status_config(zhp, cb, vname, child[c], depth + 2,
	isspare, vrs);
	free(vname);
	}
	}

	/*
	* Print the configuration of an exported pool. Iterate over all vdevs in the
	* pool, printing out the name and status for each one.
	*/
	static void
	print_import_config(status_cbdata_t cb, const char name, nvlist_t *nv,
	int depth)
	{
	nvlist_t **child;
	uint_t c, children;
	vdev_stat_t *vs;
	char type, vname;

	verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &type) == 0);
	if (strcmp(type, VDEV_TYPE_MISSING) == 0 \|\|
	strcmp(type, VDEV_TYPE_HOLE) == 0)
	return;

	verify(nvlist_lookup_uint64_array(nv, ZPOOL_CONFIG_VDEV_STATS,
	(uint64_t **)&vs, &c) == 0);

	(void) printf("\t%s%-s", depth, "", cb->cb_namewidth - depth, name);
	(void) printf(" %s", zpool_state_to_name(vs->vs_state, vs->vs_aux));

	if (vs->vs_aux != 0) {
	(void) printf(" ");

	switch (vs->vs_aux) {
	case VDEV_AUX_OPEN_FAILED:
	(void) printf(gettext("cannot open"));
	break;

	case VDEV_AUX_BAD_GUID_SUM:
	(void) printf(gettext("missing device"));
	break;

	case VDEV_AUX_NO_REPLICAS:
	(void) printf(gettext("insufficient replicas"));
	break;

	case VDEV_AUX_VERSION_NEWER:
	(void) printf(gettext("newer version"));
	break;

	case VDEV_AUX_UNSUP_FEAT:
	(void) printf(gettext("unsupported feature(s)"));
	break;

	case VDEV_AUX_ERR_EXCEEDED:
	(void) printf(gettext("too many errors"));
	break;

	case VDEV_AUX_ACTIVE:
	(void) printf(gettext("currently in use"));
	break;

	case VDEV_AUX_CHILDREN_OFFLINE:
	(void) printf(gettext("all children offline"));
	break;

	+ case VDEV_AUX_BAD_LABEL:
	+ (void) printf(gettext("invalid label"));
	+ break;
	+
	default:
	(void) printf(gettext("corrupted data"));
	break;
	}
	}
	(void) printf("\n");

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
	&child, &children) != 0)
	return;

	for (c = 0; c < children; c++) {
	uint64_t is_log = B_FALSE;

	(void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG,
	&is_log);
	if (is_log)
	continue;
	if (nvlist_exists(child[c], ZPOOL_CONFIG_ALLOCATION_BIAS))
	continue;

	vname = zpool_vdev_name(g_zfs, NULL, child[c],
	cb->cb_name_flags \| VDEV_NAME_TYPE_ID);
	print_import_config(cb, vname, child[c], depth + 2);
	free(vname);
	}

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_L2CACHE,
	&child, &children) == 0) {
	(void) printf(gettext("\tcache\n"));
	for (c = 0; c < children; c++) {
	vname = zpool_vdev_name(g_zfs, NULL, child[c],
	cb->cb_name_flags);
	(void) printf("\t %s\n", vname);
	free(vname);
	}
	}

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_SPARES,
	&child, &children) == 0) {
	(void) printf(gettext("\tspares\n"));
	for (c = 0; c < children; c++) {
	vname = zpool_vdev_name(g_zfs, NULL, child[c],
	cb->cb_name_flags);
	(void) printf("\t %s\n", vname);
	free(vname);
	}
	}
	}

	/*
	* Print specialized class vdevs.
	*
	* These are recorded as top level vdevs in the main pool child array
	* but with "is_log" set to 1 or an "alloc_bias" string. We use either
	* print_status_config() or print_import_config() to print the top level
	* class vdevs then any of their children (eg mirrored slogs) are printed
	* recursively - which works because only the top level vdev is marked.
	*/
	static void
	print_class_vdevs(zpool_handle_t zhp, status_cbdata_t cb, nvlist_t *nv,
	const char *class)
	{
	uint_t c, children;
	nvlist_t **child;
	boolean_t printed = B_FALSE;

	assert(zhp != NULL \|\| !cb->cb_verbose);

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN, &child,
	&children) != 0)
	return;

	for (c = 0; c < children; c++) {
	uint64_t is_log = B_FALSE;
	char *bias = NULL;
	char *type = NULL;

	(void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG,
	&is_log);

	if (is_log) {
	bias = VDEV_ALLOC_CLASS_LOGS;
	} else {
	(void) nvlist_lookup_string(child[c],
	ZPOOL_CONFIG_ALLOCATION_BIAS, &bias);
	(void) nvlist_lookup_string(child[c],
	ZPOOL_CONFIG_TYPE, &type);
	}

	if (bias == NULL \|\| strcmp(bias, class) != 0)
	continue;
	if (!is_log && strcmp(type, VDEV_TYPE_INDIRECT) == 0)
	continue;

	if (!printed) {
	(void) printf("\t%s\t\n", gettext(class));
	printed = B_TRUE;
	}

	char *name = zpool_vdev_name(g_zfs, zhp, child[c],
	cb->cb_name_flags \| VDEV_NAME_TYPE_ID);
	if (cb->cb_print_status)
	print_status_config(zhp, cb, name, child[c], 2,
	B_FALSE, NULL);
	else
	print_import_config(cb, name, child[c], 2);
	free(name);
	}
	}

	/*
	* Display the status for the given pool.
	*/
	static int
	show_import(nvlist_t *config, boolean_t report_error)
	{
	uint64_t pool_state;
	vdev_stat_t *vs;
	char *name;
	uint64_t guid;
	uint64_t hostid = 0;
	char *msgid;
	char *hostname = "unknown";
	nvlist_t nvroot, nvinfo;
	zpool_status_t reason;
	zpool_errata_t errata;
	const char *health;
	uint_t vsc;
	char *comment;
	status_cbdata_t cb = { 0 };

	verify(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME,
	&name) == 0);
	verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID,
	&guid) == 0);
	verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE,
	&pool_state) == 0);
	verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
	&nvroot) == 0);

	verify(nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_VDEV_STATS,
	(uint64_t **)&vs, &vsc) == 0);
	health = zpool_state_to_name(vs->vs_state, vs->vs_aux);

	reason = zpool_import_status(config, &msgid, &errata);

	/*
	* If we're importing using a cachefile, then we won't report any
	* errors unless we are in the scan phase of the import.
	*/
	if (reason != ZPOOL_STATUS_OK && !report_error)
	return (reason);

	(void) printf(gettext(" pool: %s\n"), name);
	(void) printf(gettext(" id: %llu\n"), (u_longlong_t)guid);
	(void) printf(gettext(" state: %s"), health);
	if (pool_state == POOL_STATE_DESTROYED)
	(void) printf(gettext(" (DESTROYED)"));
	(void) printf("\n");

	switch (reason) {
	case ZPOOL_STATUS_MISSING_DEV_R:
	case ZPOOL_STATUS_MISSING_DEV_NR:
	case ZPOOL_STATUS_BAD_GUID_SUM:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("One or more devices are "
	"missing from the system.\n"));
	break;

	case ZPOOL_STATUS_CORRUPT_LABEL_R:
	case ZPOOL_STATUS_CORRUPT_LABEL_NR:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("One or more devices contains"
	" corrupted data.\n"));
	break;

	case ZPOOL_STATUS_CORRUPT_DATA:
	(void) printf(
	gettext(" status: The pool data is corrupted.\n"));
	break;

	case ZPOOL_STATUS_OFFLINE_DEV:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("One or more devices "
	"are offlined.\n"));
	break;

	case ZPOOL_STATUS_CORRUPT_POOL:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("The pool metadata is "
	"corrupted.\n"));
	break;

	case ZPOOL_STATUS_VERSION_OLDER:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("The pool is formatted using "
	"a legacy on-disk version.\n"));
	break;

	case ZPOOL_STATUS_VERSION_NEWER:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("The pool is formatted using "
	"an incompatible version.\n"));
	break;

	case ZPOOL_STATUS_FEAT_DISABLED:
	printf_color(ANSI_BOLD, gettext("status: "));
	- printf_color(ANSI_YELLOW, gettext("Some supported and "
	- "requested features are not enabled on the pool.\n"));
	+ printf_color(ANSI_YELLOW, gettext("Some supported "
	+ "features are not enabled on the pool.\n\t"
	+ "(Note that they may be intentionally disabled "
	+ "if the\n\t'compatibility' property is set.)\n"));
	break;

	case ZPOOL_STATUS_COMPATIBILITY_ERR:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("Error reading or parsing "
	"the file(s) indicated by the 'compatibility'\n"
	"property.\n"));
	break;

	+ case ZPOOL_STATUS_INCOMPATIBLE_FEAT:
	+ printf_color(ANSI_BOLD, gettext("status: "));
	+ printf_color(ANSI_YELLOW, gettext("One or more features "
	+ "are enabled on the pool despite not being\n"
	+ "requested by the 'compatibility' property.\n"));
	+ break;
	+
	case ZPOOL_STATUS_UNSUP_FEAT_READ:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("The pool uses the following "
	"feature(s) not supported on this system:\n"));
	color_start(ANSI_YELLOW);
	zpool_print_unsup_feat(config);
	color_end();
	break;

	case ZPOOL_STATUS_UNSUP_FEAT_WRITE:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("The pool can only be "
	"accessed in read-only mode on this system. It\n\tcannot be"
	" accessed in read-write mode because it uses the "
	"following\n\tfeature(s) not supported on this system:\n"));
	color_start(ANSI_YELLOW);
	zpool_print_unsup_feat(config);
	color_end();
	break;

	case ZPOOL_STATUS_HOSTID_ACTIVE:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("The pool is currently "
	"imported by another system.\n"));
	break;

	case ZPOOL_STATUS_HOSTID_REQUIRED:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("The pool has the "
	"multihost property on. It cannot\n\tbe safely imported "
	"when the system hostid is not set.\n"));
	break;

	case ZPOOL_STATUS_HOSTID_MISMATCH:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("The pool was last accessed "
	"by another system.\n"));
	break;

	case ZPOOL_STATUS_FAULTED_DEV_R:
	case ZPOOL_STATUS_FAULTED_DEV_NR:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("One or more devices are "
	"faulted.\n"));
	break;

	case ZPOOL_STATUS_BAD_LOG:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("An intent log record cannot "
	"be read.\n"));
	break;

	case ZPOOL_STATUS_RESILVERING:
	case ZPOOL_STATUS_REBUILDING:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("One or more devices were "
	"being resilvered.\n"));
	break;

	case ZPOOL_STATUS_ERRATA:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("Errata #%d detected.\n"),
	errata);
	break;

	case ZPOOL_STATUS_NON_NATIVE_ASHIFT:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("One or more devices are "
	"configured to use a non-native block size.\n"
	"\tExpect reduced performance.\n"));
	break;

	default:
	/*
	* No other status can be seen when importing pools.
	*/
	assert(reason == ZPOOL_STATUS_OK);
	}

	/*
	* Print out an action according to the overall state of the pool.
	*/
	if (vs->vs_state == VDEV_STATE_HEALTHY) {
	if (reason == ZPOOL_STATUS_VERSION_OLDER \|\|
	reason == ZPOOL_STATUS_FEAT_DISABLED) {
	(void) printf(gettext(" action: The pool can be "
	"imported using its name or numeric identifier, "
	"though\n\tsome features will not be available "
	"without an explicit 'zpool upgrade'.\n"));
	} else if (reason == ZPOOL_STATUS_COMPATIBILITY_ERR) {
	(void) printf(gettext(" action: The pool can be "
	"imported using its name or numeric\n\tidentifier, "
	"though the file(s) indicated by its "
	"'compatibility'\n\tproperty cannot be parsed at "
	"this time.\n"));
	} else if (reason == ZPOOL_STATUS_HOSTID_MISMATCH) {
	(void) printf(gettext(" action: The pool can be "
	"imported using its name or numeric "
	"identifier and\n\tthe '-f' flag.\n"));
	} else if (reason == ZPOOL_STATUS_ERRATA) {
	switch (errata) {
	case ZPOOL_ERRATA_NONE:
	break;

	case ZPOOL_ERRATA_ZOL_2094_SCRUB:
	(void) printf(gettext(" action: The pool can "
	"be imported using its name or numeric "
	"identifier,\n\thowever there is a compat"
	"ibility issue which should be corrected"
	"\n\tby running 'zpool scrub'\n"));
	break;

	case ZPOOL_ERRATA_ZOL_2094_ASYNC_DESTROY:
	(void) printf(gettext(" action: The pool can"
	"not be imported with this version of ZFS "
	"due to\n\tan active asynchronous destroy. "
	"Revert to an earlier version\n\tand "
	"allow the destroy to complete before "
	"updating.\n"));
	break;

	case ZPOOL_ERRATA_ZOL_6845_ENCRYPTION:
	(void) printf(gettext(" action: Existing "
	"encrypted datasets contain an on-disk "
	"incompatibility, which\n\tneeds to be "
	"corrected. Backup these datasets to new "
	"encrypted datasets\n\tand destroy the "
	"old ones.\n"));
	break;

	case ZPOOL_ERRATA_ZOL_8308_ENCRYPTION:
	(void) printf(gettext(" action: Existing "
	"encrypted snapshots and bookmarks contain "
	"an on-disk\n\tincompatibility. This may "
	"cause on-disk corruption if they are used"
	"\n\twith 'zfs recv'. To correct the "
	"issue, enable the bookmark_v2 feature.\n\t"
	"No additional action is needed if there "
	"are no encrypted snapshots or\n\t"
	"bookmarks. If preserving the encrypted "
	"snapshots and bookmarks is\n\trequired, "
	"use a non-raw send to backup and restore "
	"them. Alternately,\n\tthey may be removed"
	" to resolve the incompatibility.\n"));
	break;
	default:
	/*
	* All errata must contain an action message.
	*/
	assert(0);
	}
	} else {
	(void) printf(gettext(" action: The pool can be "
	"imported using its name or numeric "
	"identifier.\n"));
	}
	} else if (vs->vs_state == VDEV_STATE_DEGRADED) {
	(void) printf(gettext(" action: The pool can be imported "
	"despite missing or damaged devices. The\n\tfault "
	"tolerance of the pool may be compromised if imported.\n"));
	} else {
	switch (reason) {
	case ZPOOL_STATUS_VERSION_NEWER:
	(void) printf(gettext(" action: The pool cannot be "
	"imported. Access the pool on a system running "
	"newer\n\tsoftware, or recreate the pool from "
	"backup.\n"));
	break;
	case ZPOOL_STATUS_UNSUP_FEAT_READ:
	printf_color(ANSI_BOLD, gettext("action: "));
	printf_color(ANSI_YELLOW, gettext("The pool cannot be "
	"imported. Access the pool on a system that "
	"supports\n\tthe required feature(s), or recreate "
	"the pool from backup.\n"));
	break;
	case ZPOOL_STATUS_UNSUP_FEAT_WRITE:
	printf_color(ANSI_BOLD, gettext("action: "));
	printf_color(ANSI_YELLOW, gettext("The pool cannot be "
	"imported in read-write mode. Import the pool "
	"with\n"
	"\t\"-o readonly=on\", access the pool on a system "
	"that supports the\n\trequired feature(s), or "
	"recreate the pool from backup.\n"));
	break;
	case ZPOOL_STATUS_MISSING_DEV_R:
	case ZPOOL_STATUS_MISSING_DEV_NR:
	case ZPOOL_STATUS_BAD_GUID_SUM:
	(void) printf(gettext(" action: The pool cannot be "
	"imported. Attach the missing\n\tdevices and try "
	"again.\n"));
	break;
	case ZPOOL_STATUS_HOSTID_ACTIVE:
	VERIFY0(nvlist_lookup_nvlist(config,
	ZPOOL_CONFIG_LOAD_INFO, &nvinfo));

	if (nvlist_exists(nvinfo, ZPOOL_CONFIG_MMP_HOSTNAME))
	hostname = fnvlist_lookup_string(nvinfo,
	ZPOOL_CONFIG_MMP_HOSTNAME);

	if (nvlist_exists(nvinfo, ZPOOL_CONFIG_MMP_HOSTID))
	hostid = fnvlist_lookup_uint64(nvinfo,
	ZPOOL_CONFIG_MMP_HOSTID);

	(void) printf(gettext(" action: The pool must be "
	"exported from %s (hostid=%lx)\n\tbefore it "
	"can be safely imported.\n"), hostname,
	(unsigned long) hostid);
	break;
	case ZPOOL_STATUS_HOSTID_REQUIRED:
	(void) printf(gettext(" action: Set a unique system "
	"hostid with the zgenhostid(8) command.\n"));
	break;
	default:
	(void) printf(gettext(" action: The pool cannot be "
	"imported due to damaged devices or data.\n"));
	}
	}

	/* Print the comment attached to the pool. */
	if (nvlist_lookup_string(config, ZPOOL_CONFIG_COMMENT, &comment) == 0)
	(void) printf(gettext("comment: %s\n"), comment);

	/*
	* If the state is "closed" or "can't open", and the aux state
	* is "corrupt data":
	*/
	if (((vs->vs_state == VDEV_STATE_CLOSED) \|\|
	(vs->vs_state == VDEV_STATE_CANT_OPEN)) &&
	(vs->vs_aux == VDEV_AUX_CORRUPT_DATA)) {
	if (pool_state == POOL_STATE_DESTROYED)
	(void) printf(gettext("\tThe pool was destroyed, "
	"but can be imported using the '-Df' flags.\n"));
	else if (pool_state != POOL_STATE_EXPORTED)
	(void) printf(gettext("\tThe pool may be active on "
	"another system, but can be imported using\n\t"
	"the '-f' flag.\n"));
	}

	if (msgid != NULL) {
	(void) printf(gettext(
	" see: https://openzfs.github.io/openzfs-docs/msg/%s\n"),
	msgid);
	}

	(void) printf(gettext(" config:\n\n"));

	cb.cb_namewidth = max_width(NULL, nvroot, 0, strlen(name),
	VDEV_NAME_TYPE_ID);
	if (cb.cb_namewidth < 10)
	cb.cb_namewidth = 10;

	print_import_config(&cb, name, nvroot, 0);

	print_class_vdevs(NULL, &cb, nvroot, VDEV_ALLOC_BIAS_DEDUP);
	print_class_vdevs(NULL, &cb, nvroot, VDEV_ALLOC_BIAS_SPECIAL);
	print_class_vdevs(NULL, &cb, nvroot, VDEV_ALLOC_CLASS_LOGS);

	if (reason == ZPOOL_STATUS_BAD_GUID_SUM) {
	(void) printf(gettext("\n\tAdditional devices are known to "
	"be part of this pool, though their\n\texact "
	"configuration cannot be determined.\n"));
	}
	return (0);
	}

	static boolean_t
	zfs_force_import_required(nvlist_t *config)
	{
	uint64_t state;
	uint64_t hostid = 0;
	nvlist_t *nvinfo;

	state = fnvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE);
	(void) nvlist_lookup_uint64(config, ZPOOL_CONFIG_HOSTID, &hostid);

	if (state != POOL_STATE_EXPORTED && hostid != get_system_hostid())
	return (B_TRUE);

	nvinfo = fnvlist_lookup_nvlist(config, ZPOOL_CONFIG_LOAD_INFO);
	if (nvlist_exists(nvinfo, ZPOOL_CONFIG_MMP_STATE)) {
	mmp_state_t mmp_state = fnvlist_lookup_uint64(nvinfo,
	ZPOOL_CONFIG_MMP_STATE);

	if (mmp_state != MMP_STATE_INACTIVE)
	return (B_TRUE);
	}

	return (B_FALSE);
	}

	/*
	* Perform the import for the given configuration. This passes the heavy
	* lifting off to zpool_import_props(), and then mounts the datasets contained
	* within the pool.
	*/
	static int
	do_import(nvlist_t config, const char newname, const char *mntopts,
	nvlist_t *props, int flags)
	{
	int ret = 0;
	zpool_handle_t *zhp;
	char *name;
	uint64_t version;

	name = fnvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME);
	version = fnvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION);

	if (!SPA_VERSION_IS_SUPPORTED(version)) {
	(void) fprintf(stderr, gettext("cannot import '%s': pool "
	"is formatted using an unsupported ZFS version\n"), name);
	return (1);
	} else if (zfs_force_import_required(config) &&
	!(flags & ZFS_IMPORT_ANY_HOST)) {
	mmp_state_t mmp_state = MMP_STATE_INACTIVE;
	nvlist_t *nvinfo;

	nvinfo = fnvlist_lookup_nvlist(config, ZPOOL_CONFIG_LOAD_INFO);
	if (nvlist_exists(nvinfo, ZPOOL_CONFIG_MMP_STATE))
	mmp_state = fnvlist_lookup_uint64(nvinfo,
	ZPOOL_CONFIG_MMP_STATE);

	if (mmp_state == MMP_STATE_ACTIVE) {
	char *hostname = "<unknown>";
	uint64_t hostid = 0;

	if (nvlist_exists(nvinfo, ZPOOL_CONFIG_MMP_HOSTNAME))
	hostname = fnvlist_lookup_string(nvinfo,
	ZPOOL_CONFIG_MMP_HOSTNAME);

	if (nvlist_exists(nvinfo, ZPOOL_CONFIG_MMP_HOSTID))
	hostid = fnvlist_lookup_uint64(nvinfo,
	ZPOOL_CONFIG_MMP_HOSTID);

	(void) fprintf(stderr, gettext("cannot import '%s': "
	"pool is imported on %s (hostid: "
	"0x%lx)\nExport the pool on the other system, "
	"then run 'zpool import'.\n"),
	name, hostname, (unsigned long) hostid);
	} else if (mmp_state == MMP_STATE_NO_HOSTID) {
	(void) fprintf(stderr, gettext("Cannot import '%s': "
	"pool has the multihost property on and the\n"
	"system's hostid is not set. Set a unique hostid "
	"with the zgenhostid(8) command.\n"), name);
	} else {
	char *hostname = "<unknown>";
	uint64_t timestamp = 0;
	uint64_t hostid = 0;

	if (nvlist_exists(config, ZPOOL_CONFIG_HOSTNAME))
	hostname = fnvlist_lookup_string(config,
	ZPOOL_CONFIG_HOSTNAME);

	if (nvlist_exists(config, ZPOOL_CONFIG_TIMESTAMP))
	timestamp = fnvlist_lookup_uint64(config,
	ZPOOL_CONFIG_TIMESTAMP);

	if (nvlist_exists(config, ZPOOL_CONFIG_HOSTID))
	hostid = fnvlist_lookup_uint64(config,
	ZPOOL_CONFIG_HOSTID);

	(void) fprintf(stderr, gettext("cannot import '%s': "
	"pool was previously in use from another system.\n"
	"Last accessed by %s (hostid=%lx) at %s"
	"The pool can be imported, use 'zpool import -f' "
	"to import the pool.\n"), name, hostname,
	(unsigned long)hostid, ctime((time_t *)&timestamp));
	}

	return (1);
	}

	if (zpool_import_props(g_zfs, config, newname, props, flags) != 0)
	return (1);

	if (newname != NULL)
	name = (char *)newname;

	if ((zhp = zpool_open_canfail(g_zfs, name)) == NULL)
	return (1);

	/*
	* Loading keys is best effort. We don't want to return immediately
	* if it fails but we do want to give the error to the caller.
	*/
	if (flags & ZFS_IMPORT_LOAD_KEYS) {
	ret = zfs_crypto_attempt_load_keys(g_zfs, name);
	if (ret != 0)
	ret = 1;
	}

	if (zpool_get_state(zhp) != POOL_STATE_UNAVAIL &&
	!(flags & ZFS_IMPORT_ONLY) &&
	zpool_enable_datasets(zhp, mntopts, 0) != 0) {
	zpool_close(zhp);
	return (1);
	}

	zpool_close(zhp);
	return (ret);
	}

	static int
	import_pools(nvlist_t pools, nvlist_t props, char *mntopts, int flags,
	char orig_name, char new_name,
	boolean_t do_destroyed, boolean_t pool_specified, boolean_t do_all,
	importargs_t *import)
	{
	nvlist_t *config = NULL;
	nvlist_t *found_config = NULL;
	uint64_t pool_state;

	/*
	* At this point we have a list of import candidate configs. Even if
	* we were searching by pool name or guid, we still need to
	* post-process the list to deal with pool state and possible
	* duplicate names.
	*/
	int err = 0;
	nvpair_t *elem = NULL;
	boolean_t first = B_TRUE;
	while ((elem = nvlist_next_nvpair(pools, elem)) != NULL) {

	verify(nvpair_value_nvlist(elem, &config) == 0);

	verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE,
	&pool_state) == 0);
	if (!do_destroyed && pool_state == POOL_STATE_DESTROYED)
	continue;
	if (do_destroyed && pool_state != POOL_STATE_DESTROYED)
	continue;

	verify(nvlist_add_nvlist(config, ZPOOL_LOAD_POLICY,
	import->policy) == 0);

	if (!pool_specified) {
	if (first)
	first = B_FALSE;
	else if (!do_all)
	(void) printf("\n");

	if (do_all) {
	err \|= do_import(config, NULL, mntopts,
	props, flags);
	} else {
	/*
	* If we're importing from cachefile, then
	* we don't want to report errors until we
	* are in the scan phase of the import. If
	* we get an error, then we return that error
	* to invoke the scan phase.
	*/
	if (import->cachefile && !import->scan)
	err = show_import(config, B_FALSE);
	else
	(void) show_import(config, B_TRUE);
	}
	} else if (import->poolname != NULL) {
	char *name;

	/*
	* We are searching for a pool based on name.
	*/
	verify(nvlist_lookup_string(config,
	ZPOOL_CONFIG_POOL_NAME, &name) == 0);

	if (strcmp(name, import->poolname) == 0) {
	if (found_config != NULL) {
	(void) fprintf(stderr, gettext(
	"cannot import '%s': more than "
	"one matching pool\n"),
	import->poolname);
	(void) fprintf(stderr, gettext(
	"import by numeric ID instead\n"));
	err = B_TRUE;
	}
	found_config = config;
	}
	} else {
	uint64_t guid;

	/*
	* Search for a pool by guid.
	*/
	verify(nvlist_lookup_uint64(config,
	ZPOOL_CONFIG_POOL_GUID, &guid) == 0);

	if (guid == import->guid)
	found_config = config;
	}
	}

	/*
	* If we were searching for a specific pool, verify that we found a
	* pool, and then do the import.
	*/
	if (pool_specified && err == 0) {
	if (found_config == NULL) {
	(void) fprintf(stderr, gettext("cannot import '%s': "
	"no such pool available\n"), orig_name);
	err = B_TRUE;
	} else {
	err \|= do_import(found_config, new_name,
	mntopts, props, flags);
	}
	}

	/*
	* If we were just looking for pools, report an error if none were
	* found.
	*/
	if (!pool_specified && first)
	(void) fprintf(stderr,
	gettext("no pools available to import\n"));
	return (err);
	}

	typedef struct target_exists_args {
	const char *poolname;
	uint64_t poolguid;
	} target_exists_args_t;

	static int
	name_or_guid_exists(zpool_handle_t zhp, void data)
	{
	target_exists_args_t *args = data;
	nvlist_t *config = zpool_get_config(zhp, NULL);
	int found = 0;

	if (config == NULL)
	return (0);

	if (args->poolname != NULL) {
	char *pool_name;

	verify(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME,
	&pool_name) == 0);
	if (strcmp(pool_name, args->poolname) == 0)
	found = 1;
	} else {
	uint64_t pool_guid;

	verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID,
	&pool_guid) == 0);
	if (pool_guid == args->poolguid)
	found = 1;
	}
	zpool_close(zhp);

	return (found);
	}
	/*
	* zpool checkpoint <pool>
	* checkpoint --discard <pool>
	*
	* -d Discard the checkpoint from a checkpointed
	* --discard pool.
	*
	* -w Wait for discarding a checkpoint to complete.
	* --wait
	*
	* Checkpoints the specified pool, by taking a "snapshot" of its
	* current state. A pool can only have one checkpoint at a time.
	*/
	int
	zpool_do_checkpoint(int argc, char **argv)
	{
	boolean_t discard, wait;
	char *pool;
	zpool_handle_t *zhp;
	int c, err;

	struct option long_options[] = {
	{"discard", no_argument, NULL, 'd'},
	{"wait", no_argument, NULL, 'w'},
	{0, 0, 0, 0}
	};

	discard = B_FALSE;
	wait = B_FALSE;
	while ((c = getopt_long(argc, argv, ":dw", long_options, NULL)) != -1) {
	switch (c) {
	case 'd':
	discard = B_TRUE;
	break;
	case 'w':
	wait = B_TRUE;
	break;
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	if (wait && !discard) {
	(void) fprintf(stderr, gettext("--wait only valid when "
	"--discard also specified\n"));
	usage(B_FALSE);
	}

	argc -= optind;
	argv += optind;

	if (argc < 1) {
	(void) fprintf(stderr, gettext("missing pool argument\n"));
	usage(B_FALSE);
	}

	if (argc > 1) {
	(void) fprintf(stderr, gettext("too many arguments\n"));
	usage(B_FALSE);
	}

	pool = argv[0];

	if ((zhp = zpool_open(g_zfs, pool)) == NULL) {
	/* As a special case, check for use of '/' in the name */
	if (strchr(pool, '/') != NULL)
	(void) fprintf(stderr, gettext("'zpool checkpoint' "
	"doesn't work on datasets. To save the state "
	"of a dataset from a specific point in time "
	"please use 'zfs snapshot'\n"));
	return (1);
	}

	if (discard) {
	err = (zpool_discard_checkpoint(zhp) != 0);
	if (err == 0 && wait)
	err = zpool_wait(zhp, ZPOOL_WAIT_CKPT_DISCARD);
	} else {
	err = (zpool_checkpoint(zhp) != 0);
	}

	zpool_close(zhp);

	return (err);
	}

	#define CHECKPOINT_OPT 1024

	/*
	* zpool import [-d dir] [-D]
	* import [-o mntopts] [-o prop=value] ... [-R root] [-D] [-l]
	* [-d dir \| -c cachefile \| -s] [-f] -a
	* import [-o mntopts] [-o prop=value] ... [-R root] [-D] [-l]
	* [-d dir \| -c cachefile \| -s] [-f] [-n] [-F] <pool \| id>
	* [newpool]
	*
	* -c Read pool information from a cachefile instead of searching
	* devices. If importing from a cachefile config fails, then
	* fallback to searching for devices only in the directories that
	* exist in the cachefile.
	*
	* -d Scan in a specific directory, other than /dev/. More than
	* one directory can be specified using multiple '-d' options.
	*
	* -D Scan for previously destroyed pools or import all or only
	* specified destroyed pools.
	*
	* -R Temporarily import the pool, with all mountpoints relative to
	* the given root. The pool will remain exported when the machine
	* is rebooted.
	*
	* -V Import even in the presence of faulted vdevs. This is an
	* intentionally undocumented option for testing purposes, and
	* treats the pool configuration as complete, leaving any bad
	* vdevs in the FAULTED state. In other words, it does verbatim
	* import.
	*
	* -f Force import, even if it appears that the pool is active.
	*
	* -F Attempt rewind if necessary.
	*
	* -n See if rewind would work, but don't actually rewind.
	*
	* -N Import the pool but don't mount datasets.
	*
	* -T Specify a starting txg to use for import. This option is
	* intentionally undocumented option for testing purposes.
	*
	* -a Import all pools found.
	*
	* -l Load encryption keys while importing.
	*
	* -o Set property=value and/or temporary mount options (without '=').
	*
	* -s Scan using the default search path, the libblkid cache will
	* not be consulted.
	*
	* --rewind-to-checkpoint
	* Import the pool and revert back to the checkpoint.
	*
	* The import command scans for pools to import, and import pools based on pool
	* name and GUID. The pool can also be renamed as part of the import process.
	*/
	int
	zpool_do_import(int argc, char **argv)
	{
	char **searchdirs = NULL;
	char env, envdup = NULL;
	int nsearch = 0;
	int c;
	int err = 0;
	nvlist_t *pools = NULL;
	boolean_t do_all = B_FALSE;
	boolean_t do_destroyed = B_FALSE;
	char *mntopts = NULL;
	uint64_t searchguid = 0;
	char *searchname = NULL;
	char *propval;
	nvlist_t *policy = NULL;
	nvlist_t *props = NULL;
	int flags = ZFS_IMPORT_NORMAL;
	uint32_t rewind_policy = ZPOOL_NO_REWIND;
	boolean_t dryrun = B_FALSE;
	boolean_t do_rewind = B_FALSE;
	boolean_t xtreme_rewind = B_FALSE;
	boolean_t do_scan = B_FALSE;
	boolean_t pool_exists = B_FALSE;
	boolean_t pool_specified = B_FALSE;
	uint64_t txg = -1ULL;
	char *cachefile = NULL;
	importargs_t idata = { 0 };
	char *endptr;

	struct option long_options[] = {
	{"rewind-to-checkpoint", no_argument, NULL, CHECKPOINT_OPT},
	{0, 0, 0, 0}
	};

	/* check options */
	while ((c = getopt_long(argc, argv, ":aCc:d:DEfFlmnNo:R:stT:VX",
	long_options, NULL)) != -1) {
	switch (c) {
	case 'a':
	do_all = B_TRUE;
	break;
	case 'c':
	cachefile = optarg;
	break;
	case 'd':
	if (searchdirs == NULL) {
	searchdirs = safe_malloc(sizeof (char *));
	} else {
	char *tmp = safe_malloc((nsearch + 1)
	sizeof (char *));
	bcopy(searchdirs, tmp, nsearch *
	sizeof (char *));
	free(searchdirs);
	searchdirs = tmp;
	}
	searchdirs[nsearch++] = optarg;
	break;
	case 'D':
	do_destroyed = B_TRUE;
	break;
	case 'f':
	flags \|= ZFS_IMPORT_ANY_HOST;
	break;
	case 'F':
	do_rewind = B_TRUE;
	break;
	case 'l':
	flags \|= ZFS_IMPORT_LOAD_KEYS;
	break;
	case 'm':
	flags \|= ZFS_IMPORT_MISSING_LOG;
	break;
	case 'n':
	dryrun = B_TRUE;
	break;
	case 'N':
	flags \|= ZFS_IMPORT_ONLY;
	break;
	case 'o':
	if ((propval = strchr(optarg, '=')) != NULL) {
	*propval = '\0';
	propval++;
	if (add_prop_list(optarg, propval,
	&props, B_TRUE))
	goto error;
	} else {
	mntopts = optarg;
	}
	break;
	case 'R':
	if (add_prop_list(zpool_prop_to_name(
	ZPOOL_PROP_ALTROOT), optarg, &props, B_TRUE))
	goto error;
	if (add_prop_list_default(zpool_prop_to_name(
	ZPOOL_PROP_CACHEFILE), "none", &props, B_TRUE))
	goto error;
	break;
	case 's':
	do_scan = B_TRUE;
	break;
	case 't':
	flags \|= ZFS_IMPORT_TEMP_NAME;
	if (add_prop_list_default(zpool_prop_to_name(
	ZPOOL_PROP_CACHEFILE), "none", &props, B_TRUE))
	goto error;
	break;

	case 'T':
	errno = 0;
	txg = strtoull(optarg, &endptr, 0);
	if (errno != 0 \|\| *endptr != '\0') {
	(void) fprintf(stderr,
	gettext("invalid txg value\n"));
	usage(B_FALSE);
	}
	rewind_policy = ZPOOL_DO_REWIND \| ZPOOL_EXTREME_REWIND;
	break;
	case 'V':
	flags \|= ZFS_IMPORT_VERBATIM;
	break;
	case 'X':
	xtreme_rewind = B_TRUE;
	break;
	case CHECKPOINT_OPT:
	flags \|= ZFS_IMPORT_CHECKPOINT;
	break;
	case ':':
	(void) fprintf(stderr, gettext("missing argument for "
	"'%c' option\n"), optopt);
	usage(B_FALSE);
	break;
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	argc -= optind;
	argv += optind;

	if (cachefile && nsearch != 0) {
	(void) fprintf(stderr, gettext("-c is incompatible with -d\n"));
	usage(B_FALSE);
	}

	if (cachefile && do_scan) {
	(void) fprintf(stderr, gettext("-c is incompatible with -s\n"));
	usage(B_FALSE);
	}

	if ((flags & ZFS_IMPORT_LOAD_KEYS) && (flags & ZFS_IMPORT_ONLY)) {
	(void) fprintf(stderr, gettext("-l is incompatible with -N\n"));
	usage(B_FALSE);
	}

	if ((flags & ZFS_IMPORT_LOAD_KEYS) && !do_all && argc == 0) {
	(void) fprintf(stderr, gettext("-l is only meaningful during "
	"an import\n"));
	usage(B_FALSE);
	}

	if ((dryrun \|\| xtreme_rewind) && !do_rewind) {
	(void) fprintf(stderr,
	gettext("-n or -X only meaningful with -F\n"));
	usage(B_FALSE);
	}
	if (dryrun)
	rewind_policy = ZPOOL_TRY_REWIND;
	else if (do_rewind)
	rewind_policy = ZPOOL_DO_REWIND;
	if (xtreme_rewind)
	rewind_policy \|= ZPOOL_EXTREME_REWIND;

	/* In the future, we can capture further policy and include it here */
	if (nvlist_alloc(&policy, NV_UNIQUE_NAME, 0) != 0 \|\|
	nvlist_add_uint64(policy, ZPOOL_LOAD_REQUEST_TXG, txg) != 0 \|\|
	nvlist_add_uint32(policy, ZPOOL_LOAD_REWIND_POLICY,
	rewind_policy) != 0)
	goto error;

	/* check argument count */
	if (do_all) {
	if (argc != 0) {
	(void) fprintf(stderr, gettext("too many arguments\n"));
	usage(B_FALSE);
	}
	} else {
	if (argc > 2) {
	(void) fprintf(stderr, gettext("too many arguments\n"));
	usage(B_FALSE);
	}
	}

	/*
	* Check for the effective uid. We do this explicitly here because
	* otherwise any attempt to discover pools will silently fail.
	*/
	if (argc == 0 && geteuid() != 0) {
	(void) fprintf(stderr, gettext("cannot "
	"discover pools: permission denied\n"));
	if (searchdirs != NULL)
	free(searchdirs);

	nvlist_free(props);
	nvlist_free(policy);
	return (1);
	}

	/*
	* Depending on the arguments given, we do one of the following:
	*
	* <none> Iterate through all pools and display information about
	* each one.
	*
	* -a Iterate through all pools and try to import each one.
	*
	* <id> Find the pool that corresponds to the given GUID/pool
	* name and import that one.
	*
	* -D Above options applies only to destroyed pools.
	*/
	if (argc != 0) {
	char *endptr;

	errno = 0;
	searchguid = strtoull(argv[0], &endptr, 10);
	if (errno != 0 \|\| *endptr != '\0') {
	searchname = argv[0];
	searchguid = 0;
	}
	pool_specified = B_TRUE;

	/*
	* User specified a name or guid. Ensure it's unique.
	*/
	target_exists_args_t search = {searchname, searchguid};
	pool_exists = zpool_iter(g_zfs, name_or_guid_exists, &search);
	}

	/*
	* Check the environment for the preferred search path.
	*/
	if ((searchdirs == NULL) && (env = getenv("ZPOOL_IMPORT_PATH"))) {
	char *dir;

	envdup = strdup(env);

	dir = strtok(envdup, ":");
	while (dir != NULL) {
	if (searchdirs == NULL) {
	searchdirs = safe_malloc(sizeof (char *));
	} else {
	char *tmp = safe_malloc((nsearch + 1)
	sizeof (char *));
	bcopy(searchdirs, tmp, nsearch *
	sizeof (char *));
	free(searchdirs);
	searchdirs = tmp;
	}
	searchdirs[nsearch++] = dir;
	dir = strtok(NULL, ":");
	}
	}

	idata.path = searchdirs;
	idata.paths = nsearch;
	idata.poolname = searchname;
	idata.guid = searchguid;
	idata.cachefile = cachefile;
	idata.scan = do_scan;
	idata.policy = policy;

	pools = zpool_search_import(g_zfs, &idata, &libzfs_config_ops);

	if (pools != NULL && pool_exists &&
	(argc == 1 \|\| strcmp(argv[0], argv[1]) == 0)) {
	(void) fprintf(stderr, gettext("cannot import '%s': "
	"a pool with that name already exists\n"),
	argv[0]);
	(void) fprintf(stderr, gettext("use the form '%s "
	"<pool \| id> <newpool>' to give it a new name\n"),
	"zpool import");
	err = 1;
	} else if (pools == NULL && pool_exists) {
	(void) fprintf(stderr, gettext("cannot import '%s': "
	"a pool with that name is already created/imported,\n"),
	argv[0]);
	(void) fprintf(stderr, gettext("and no additional pools "
	"with that name were found\n"));
	err = 1;
	} else if (pools == NULL) {
	if (argc != 0) {
	(void) fprintf(stderr, gettext("cannot import '%s': "
	"no such pool available\n"), argv[0]);
	}
	err = 1;
	}

	if (err == 1) {
	if (searchdirs != NULL)
	free(searchdirs);
	if (envdup != NULL)
	free(envdup);
	nvlist_free(policy);
	nvlist_free(pools);
	nvlist_free(props);
	return (1);
	}

	err = import_pools(pools, props, mntopts, flags, argv[0],
	argc == 1 ? NULL : argv[1], do_destroyed, pool_specified,
	do_all, &idata);

	/*
	* If we're using the cachefile and we failed to import, then
	* fallback to scanning the directory for pools that match
	* those in the cachefile.
	*/
	if (err != 0 && cachefile != NULL) {
	(void) printf(gettext("cachefile import failed, retrying\n"));

	/*
	* We use the scan flag to gather the directories that exist
	* in the cachefile. If we need to fallback to searching for
	* the pool config, we will only search devices in these
	* directories.
	*/
	idata.scan = B_TRUE;
	nvlist_free(pools);
	pools = zpool_search_import(g_zfs, &idata, &libzfs_config_ops);

	err = import_pools(pools, props, mntopts, flags, argv[0],
	argc == 1 ? NULL : argv[1], do_destroyed, pool_specified,
	do_all, &idata);
	}

	error:
	nvlist_free(props);
	nvlist_free(pools);
	nvlist_free(policy);
	if (searchdirs != NULL)
	free(searchdirs);
	if (envdup != NULL)
	free(envdup);

	return (err ? 1 : 0);
	}

	/*
	* zpool sync [-f] [pool] ...
	*
	* -f (undocumented) force uberblock (and config including zpool cache file)
	* update.
	*
	* Sync the specified pool(s).
	* Without arguments "zpool sync" will sync all pools.
	* This command initiates TXG sync(s) and will return after the TXG(s) commit.
	*
	*/
	static int
	zpool_do_sync(int argc, char **argv)
	{
	int ret;
	boolean_t force = B_FALSE;

	/* check options */
	while ((ret = getopt(argc, argv, "f")) != -1) {
	switch (ret) {
	case 'f':
	force = B_TRUE;
	break;
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	argc -= optind;
	argv += optind;

	/* if argc == 0 we will execute zpool_sync_one on all pools */
	ret = for_each_pool(argc, argv, B_FALSE, NULL, B_FALSE, zpool_sync_one,
	&force);

	return (ret);
	}

	typedef struct iostat_cbdata {
	uint64_t cb_flags;
	int cb_name_flags;
	int cb_namewidth;
	int cb_iteration;
	char *cb_vdev_names; / Only show these vdevs */
	unsigned int cb_vdev_names_count;
	boolean_t cb_verbose;
	boolean_t cb_literal;
	boolean_t cb_scripted;
	zpool_list_t *cb_list;
	vdev_cmd_data_list_t *vcdl;
	} iostat_cbdata_t;

	/* iostat labels */
	typedef struct name_and_columns {
	const char name; / Column name */
	unsigned int columns; /* Center name to this number of columns */
	} name_and_columns_t;

	#define IOSTAT_MAX_LABELS 13 /* Max number of labels on one line */

	static const name_and_columns_t iostat_top_labels[][IOSTAT_MAX_LABELS] =
	{
	[IOS_DEFAULT] = {{"capacity", 2}, {"operations", 2}, {"bandwidth", 2},
	{NULL}},
	[IOS_LATENCY] = {{"total_wait", 2}, {"disk_wait", 2}, {"syncq_wait", 2},
	{"asyncq_wait", 2}, {"scrub", 1}, {"trim", 1}, {NULL}},
	[IOS_QUEUES] = {{"syncq_read", 2}, {"syncq_write", 2},
	{"asyncq_read", 2}, {"asyncq_write", 2}, {"scrubq_read", 2},
	{"trimq_write", 2}, {NULL}},
	[IOS_L_HISTO] = {{"total_wait", 2}, {"disk_wait", 2}, {"syncq_wait", 2},
	{"asyncq_wait", 2}, {NULL}},
	[IOS_RQ_HISTO] = {{"sync_read", 2}, {"sync_write", 2},
	{"async_read", 2}, {"async_write", 2}, {"scrub", 2},
	{"trim", 2}, {NULL}},
	};

	/* Shorthand - if "columns" field not set, default to 1 column */
	static const name_and_columns_t iostat_bottom_labels[][IOSTAT_MAX_LABELS] =
	{
	[IOS_DEFAULT] = {{"alloc"}, {"free"}, {"read"}, {"write"}, {"read"},
	{"write"}, {NULL}},
	[IOS_LATENCY] = {{"read"}, {"write"}, {"read"}, {"write"}, {"read"},
	{"write"}, {"read"}, {"write"}, {"wait"}, {"wait"}, {NULL}},
	[IOS_QUEUES] = {{"pend"}, {"activ"}, {"pend"}, {"activ"}, {"pend"},
	{"activ"}, {"pend"}, {"activ"}, {"pend"}, {"activ"},
	{"pend"}, {"activ"}, {NULL}},
	[IOS_L_HISTO] = {{"read"}, {"write"}, {"read"}, {"write"}, {"read"},
	{"write"}, {"read"}, {"write"}, {"scrub"}, {"trim"}, {NULL}},
	[IOS_RQ_HISTO] = {{"ind"}, {"agg"}, {"ind"}, {"agg"}, {"ind"}, {"agg"},
	{"ind"}, {"agg"}, {"ind"}, {"agg"}, {"ind"}, {"agg"}, {NULL}},
	};

	static const char *histo_to_title[] = {
	[IOS_L_HISTO] = "latency",
	[IOS_RQ_HISTO] = "req_size",
	};

	/*
	* Return the number of labels in a null-terminated name_and_columns_t
	* array.
	*
	*/
	static unsigned int
	label_array_len(const name_and_columns_t *labels)
	{
	int i = 0;

	while (labels[i].name)
	i++;

	return (i);
	}

	/*
	* Return the number of strings in a null-terminated string array.
	* For example:
	*
	* const char foo[] = {"bar", "baz", NULL}
	*
	* returns 2
	*/
	static uint64_t
	str_array_len(const char *array[])
	{
	uint64_t i = 0;
	while (array[i])
	i++;

	return (i);
	}


	/*
	* Return a default column width for default/latency/queue columns. This does
	* not include histograms, which have their columns autosized.
	*/
	static unsigned int
	default_column_width(iostat_cbdata_t *cb, enum iostat_type type)
	{
	unsigned long column_width = 5; /* Normal niceprint */
	static unsigned long widths[] = {
	/*
	* Choose some sane default column sizes for printing the
	* raw numbers.
	*/
	[IOS_DEFAULT] = 15, /* 1PB capacity */
	[IOS_LATENCY] = 10, /* 1B ns = 10sec */
	[IOS_QUEUES] = 6, /* 1M queue entries */
	[IOS_L_HISTO] = 10, /* 1B ns = 10sec */
	[IOS_RQ_HISTO] = 6, /* 1M queue entries */
	};

	if (cb->cb_literal)
	column_width = widths[type];

	return (column_width);
	}

	/*
	* Print the column labels, i.e:
	*
	* capacity operations bandwidth
	* alloc free read write read write ...
	*
	* If force_column_width is set, use it for the column width. If not set, use
	* the default column width.
	*/
	static void
	print_iostat_labels(iostat_cbdata_t *cb, unsigned int force_column_width,
	const name_and_columns_t labels[][IOSTAT_MAX_LABELS])
	{
	int i, idx, s;
	int text_start, rw_column_width, spaces_to_end;
	uint64_t flags = cb->cb_flags;
	uint64_t f;
	unsigned int column_width = force_column_width;

	/* For each bit set in flags */
	for (f = flags; f; f &= ~(1ULL << idx)) {
	idx = lowbit64(f) - 1;
	if (!force_column_width)
	column_width = default_column_width(cb, idx);
	/* Print our top labels centered over "read write" label. */
	for (i = 0; i < label_array_len(labels[idx]); i++) {
	const char *name = labels[idx][i].name;
	/*
	* We treat labels[][].columns == 0 as shorthand
	* for one column. It makes writing out the label
	* tables more concise.
	*/
	unsigned int columns = MAX(1, labels[idx][i].columns);
	unsigned int slen = strlen(name);

	rw_column_width = (column_width * columns) +
	(2 * (columns - 1));

	text_start = (int)((rw_column_width) / columns -
	slen / columns);
	if (text_start < 0)
	text_start = 0;

	printf(" "); /* Two spaces between columns */

	/* Space from beginning of column to label */
	for (s = 0; s < text_start; s++)
	printf(" ");

	printf("%s", name);

	/* Print space after label to end of column */
	spaces_to_end = rw_column_width - text_start - slen;
	if (spaces_to_end < 0)
	spaces_to_end = 0;

	for (s = 0; s < spaces_to_end; s++)
	printf(" ");
	}
	}
	}


	/*
	* print_cmd_columns - Print custom column titles from -c
	*
	* If the user specified the "zpool status\|iostat -c" then print their custom
	* column titles in the header. For example, print_cmd_columns() would print
	* the " col1 col2" part of this:
	*
	* $ zpool iostat -vc 'echo col1=val1; echo col2=val2'
	* ...
	* capacity operations bandwidth
	* pool alloc free read write read write col1 col2
	* ---------- ----- ----- ----- ----- ----- ----- ---- ----
	* mypool 269K 1008M 0 0 107 946
	* mirror 269K 1008M 0 0 107 946
	* sdb - - 0 0 102 473 val1 val2
	* sdc - - 0 0 5 473 val1 val2
	* ---------- ----- ----- ----- ----- ----- ----- ---- ----
	*/
	static void
	print_cmd_columns(vdev_cmd_data_list_t *vcdl, int use_dashes)
	{
	int i, j;
	vdev_cmd_data_t *data = &vcdl->data[0];

	if (vcdl->count == 0 \|\| data == NULL)
	return;

	/*
	* Each vdev cmd should have the same column names unless the user did
	* something weird with their cmd. Just take the column names from the
	* first vdev and assume it works for all of them.
	*/
	for (i = 0; i < vcdl->uniq_cols_cnt; i++) {
	printf(" ");
	if (use_dashes) {
	for (j = 0; j < vcdl->uniq_cols_width[i]; j++)
	printf("-");
	} else {
	printf_color(ANSI_BOLD, "%*s", vcdl->uniq_cols_width[i],
	vcdl->uniq_cols[i]);
	}
	}
	}


	/*
	* Utility function to print out a line of dashes like:
	*
	* -------------------------------- ----- ----- ----- ----- -----
	*
	* ...or a dashed named-row line like:
	*
	* logs - - - - -
	*
	* @cb: iostat data
	*
	* @force_column_width If non-zero, use the value as the column width.
	* Otherwise use the default column widths.
	*
	* @name: Print a dashed named-row line starting
	* with @name. Otherwise, print a regular
	* dashed line.
	*/
	static void
	print_iostat_dashes(iostat_cbdata_t *cb, unsigned int force_column_width,
	const char *name)
	{
	int i;
	unsigned int namewidth;
	uint64_t flags = cb->cb_flags;
	uint64_t f;
	int idx;
	const name_and_columns_t *labels;
	const char *title;


	if (cb->cb_flags & IOS_ANYHISTO_M) {
	title = histo_to_title[IOS_HISTO_IDX(cb->cb_flags)];
	} else if (cb->cb_vdev_names_count) {
	title = "vdev";
	} else {
	title = "pool";
	}

	namewidth = MAX(MAX(strlen(title), cb->cb_namewidth),
	name ? strlen(name) : 0);


	if (name) {
	printf("%-*s", namewidth, name);
	} else {
	for (i = 0; i < namewidth; i++)
	(void) printf("-");
	}

	/* For each bit in flags */
	for (f = flags; f; f &= ~(1ULL << idx)) {
	unsigned int column_width;
	idx = lowbit64(f) - 1;
	if (force_column_width)
	column_width = force_column_width;
	else
	column_width = default_column_width(cb, idx);

	labels = iostat_bottom_labels[idx];
	for (i = 0; i < label_array_len(labels); i++) {
	if (name)
	printf(" %*s-", column_width - 1, " ");
	else
	printf(" %.*s", column_width,
	"--------------------");
	}
	}
	}


	static void
	print_iostat_separator_impl(iostat_cbdata_t *cb,
	unsigned int force_column_width)
	{
	print_iostat_dashes(cb, force_column_width, NULL);
	}

	static void
	print_iostat_separator(iostat_cbdata_t *cb)
	{
	print_iostat_separator_impl(cb, 0);
	}

	static void
	print_iostat_header_impl(iostat_cbdata_t *cb, unsigned int force_column_width,
	const char *histo_vdev_name)
	{
	unsigned int namewidth;
	const char *title;

	if (cb->cb_flags & IOS_ANYHISTO_M) {
	title = histo_to_title[IOS_HISTO_IDX(cb->cb_flags)];
	} else if (cb->cb_vdev_names_count) {
	title = "vdev";
	} else {
	title = "pool";
	}

	namewidth = MAX(MAX(strlen(title), cb->cb_namewidth),
	histo_vdev_name ? strlen(histo_vdev_name) : 0);

	if (histo_vdev_name)
	printf("%-*s", namewidth, histo_vdev_name);
	else
	printf("%*s", namewidth, "");


	print_iostat_labels(cb, force_column_width, iostat_top_labels);
	printf("\n");

	printf("%-*s", namewidth, title);

	print_iostat_labels(cb, force_column_width, iostat_bottom_labels);
	if (cb->vcdl != NULL)
	print_cmd_columns(cb->vcdl, 0);

	printf("\n");

	print_iostat_separator_impl(cb, force_column_width);

	if (cb->vcdl != NULL)
	print_cmd_columns(cb->vcdl, 1);

	printf("\n");
	}

	static void
	print_iostat_header(iostat_cbdata_t *cb)
	{
	print_iostat_header_impl(cb, 0, NULL);
	}


	/*
	* Display a single statistic.
	*/
	static void
	print_one_stat(uint64_t value, enum zfs_nicenum_format format,
	unsigned int column_size, boolean_t scripted)
	{
	char buf[64];

	zfs_nicenum_format(value, buf, sizeof (buf), format);

	if (scripted)
	printf("\t%s", buf);
	else
	printf(" %*s", column_size, buf);
	}

	/*
	* Calculate the default vdev stats
	*
	* Subtract oldvs from newvs, apply a scaling factor, and save the resulting
	* stats into calcvs.
	*/
	static void
	calc_default_iostats(vdev_stat_t oldvs, vdev_stat_t newvs,
	vdev_stat_t *calcvs)
	{
	int i;

	memcpy(calcvs, newvs, sizeof (*calcvs));
	for (i = 0; i < ARRAY_SIZE(calcvs->vs_ops); i++)
	calcvs->vs_ops[i] = (newvs->vs_ops[i] - oldvs->vs_ops[i]);

	for (i = 0; i < ARRAY_SIZE(calcvs->vs_bytes); i++)
	calcvs->vs_bytes[i] = (newvs->vs_bytes[i] - oldvs->vs_bytes[i]);
	}

	/*
	* Internal representation of the extended iostats data.
	*
	* The extended iostat stats are exported in nvlists as either uint64_t arrays
	* or single uint64_t's. We make both look like arrays to make them easier
	* to process. In order to make single uint64_t's look like arrays, we set
	* __data to the stat data, and then set *data = &__data with count = 1. Then,
	* we can just use *data and count.
	*/
	struct stat_array {
	uint64_t *data;
	uint_t count; /* Number of entries in data[] */
	uint64_t __data; /* Only used when data is a single uint64_t */
	};

	static uint64_t
	stat_histo_max(struct stat_array *nva, unsigned int len)
	{
	uint64_t max = 0;
	int i;
	for (i = 0; i < len; i++)
	max = MAX(max, array64_max(nva[i].data, nva[i].count));

	return (max);
	}

	/*
	* Helper function to lookup a uint64_t array or uint64_t value and store its
	* data as a stat_array. If the nvpair is a single uint64_t value, then we make
	* it look like a one element array to make it easier to process.
	*/
	static int
	nvpair64_to_stat_array(nvlist_t nvl, const char name,
	struct stat_array *nva)
	{
	nvpair_t *tmp;
	int ret;

	verify(nvlist_lookup_nvpair(nvl, name, &tmp) == 0);
	switch (nvpair_type(tmp)) {
	case DATA_TYPE_UINT64_ARRAY:
	ret = nvpair_value_uint64_array(tmp, &nva->data, &nva->count);
	break;
	case DATA_TYPE_UINT64:
	ret = nvpair_value_uint64(tmp, &nva->__data);
	nva->data = &nva->__data;
	nva->count = 1;
	break;
	default:
	/* Not a uint64_t */
	ret = EINVAL;
	break;
	}

	return (ret);
	}

	/*
	* Given a list of nvlist names, look up the extended stats in newnv and oldnv,
	* subtract them, and return the results in a newly allocated stat_array.
	* You must free the returned array after you are done with it with
	* free_calc_stats().
	*
	* Additionally, you can set "oldnv" to NULL if you simply want the newnv
	* values.
	*/
	static struct stat_array *
	calc_and_alloc_stats_ex(const char *names, unsigned int len, nvlist_t oldnv,
	nvlist_t *newnv)
	{
	nvlist_t oldnvx = NULL, newnvx;
	struct stat_array oldnva, newnva, *calcnva;
	int i, j;
	unsigned int alloc_size = (sizeof (struct stat_array)) * len;

	/* Extract our extended stats nvlist from the main list */
	verify(nvlist_lookup_nvlist(newnv, ZPOOL_CONFIG_VDEV_STATS_EX,
	&newnvx) == 0);
	if (oldnv) {
	verify(nvlist_lookup_nvlist(oldnv, ZPOOL_CONFIG_VDEV_STATS_EX,
	&oldnvx) == 0);
	}

	newnva = safe_malloc(alloc_size);
	oldnva = safe_malloc(alloc_size);
	calcnva = safe_malloc(alloc_size);

	for (j = 0; j < len; j++) {
	verify(nvpair64_to_stat_array(newnvx, names[j],
	&newnva[j]) == 0);
	calcnva[j].count = newnva[j].count;
	alloc_size = calcnva[j].count * sizeof (calcnva[j].data[0]);
	calcnva[j].data = safe_malloc(alloc_size);
	memcpy(calcnva[j].data, newnva[j].data, alloc_size);

	if (oldnvx) {
	verify(nvpair64_to_stat_array(oldnvx, names[j],
	&oldnva[j]) == 0);
	for (i = 0; i < oldnva[j].count; i++)
	calcnva[j].data[i] -= oldnva[j].data[i];
	}
	}
	free(newnva);
	free(oldnva);
	return (calcnva);
	}

	static void
	free_calc_stats(struct stat_array *nva, unsigned int len)
	{
	int i;
	for (i = 0; i < len; i++)
	free(nva[i].data);

	free(nva);
	}

	static void
	print_iostat_histo(struct stat_array *nva, unsigned int len,
	iostat_cbdata_t *cb, unsigned int column_width, unsigned int namewidth,
	double scale)
	{
	int i, j;
	char buf[6];
	uint64_t val;
	enum zfs_nicenum_format format;
	unsigned int buckets;
	unsigned int start_bucket;

	if (cb->cb_literal)
	format = ZFS_NICENUM_RAW;
	else
	format = ZFS_NICENUM_1024;

	/* All these histos are the same size, so just use nva[0].count */
	buckets = nva[0].count;

	if (cb->cb_flags & IOS_RQ_HISTO_M) {
	/* Start at 512 - req size should never be lower than this */
	start_bucket = 9;
	} else {
	start_bucket = 0;
	}

	for (j = start_bucket; j < buckets; j++) {
	/* Print histogram bucket label */
	if (cb->cb_flags & IOS_L_HISTO_M) {
	/* Ending range of this bucket */
	val = (1UL << (j + 1)) - 1;
	zfs_nicetime(val, buf, sizeof (buf));
	} else {
	/* Request size (starting range of bucket) */
	val = (1UL << j);
	zfs_nicenum(val, buf, sizeof (buf));
	}

	if (cb->cb_scripted)
	printf("%llu", (u_longlong_t)val);
	else
	printf("%-*s", namewidth, buf);

	/* Print the values on the line */
	for (i = 0; i < len; i++) {
	print_one_stat(nva[i].data[j] * scale, format,
	column_width, cb->cb_scripted);
	}
	printf("\n");
	}
	}

	static void
	print_solid_separator(unsigned int length)
	{
	while (length--)
	printf("-");
	printf("\n");
	}

	static void
	print_iostat_histos(iostat_cbdata_t cb, nvlist_t oldnv,
	nvlist_t newnv, double scale, const char name)
	{
	unsigned int column_width;
	unsigned int namewidth;
	unsigned int entire_width;
	enum iostat_type type;
	struct stat_array *nva;
	const char **names;
	unsigned int names_len;

	/* What type of histo are we? */
	type = IOS_HISTO_IDX(cb->cb_flags);

	/* Get NULL-terminated array of nvlist names for our histo */
	names = vsx_type_to_nvlist[type];
	names_len = str_array_len(names); /* num of names */

	nva = calc_and_alloc_stats_ex(names, names_len, oldnv, newnv);

	if (cb->cb_literal) {
	column_width = MAX(5,
	(unsigned int) log10(stat_histo_max(nva, names_len)) + 1);
	} else {
	column_width = 5;
	}

	namewidth = MAX(cb->cb_namewidth,
	strlen(histo_to_title[IOS_HISTO_IDX(cb->cb_flags)]));

	/*
	* Calculate the entire line width of what we're printing. The
	* +2 is for the two spaces between columns:
	*/
	/* read write */
	/* ----- ----- */
	/* \|___\| <---------- column_width */
	/* */
	/* \|__________\| <--- entire_width */
	/* */
	entire_width = namewidth + (column_width + 2) *
	label_array_len(iostat_bottom_labels[type]);

	if (cb->cb_scripted)
	printf("%s\n", name);
	else
	print_iostat_header_impl(cb, column_width, name);

	print_iostat_histo(nva, names_len, cb, column_width,
	namewidth, scale);

	free_calc_stats(nva, names_len);
	if (!cb->cb_scripted)
	print_solid_separator(entire_width);
	}

	/*
	* Calculate the average latency of a power-of-two latency histogram
	*/
	static uint64_t
	single_histo_average(uint64_t *histo, unsigned int buckets)
	{
	int i;
	uint64_t count = 0, total = 0;

	for (i = 0; i < buckets; i++) {
	/*
	* Our buckets are power-of-two latency ranges. Use the
	* midpoint latency of each bucket to calculate the average.
	* For example:
	*
	* Bucket Midpoint
	* 8ns-15ns: 12ns
	* 16ns-31ns: 24ns
	* ...
	*/
	if (histo[i] != 0) {
	total += histo[i] * (((1UL << i) + ((1UL << i)/2)));
	count += histo[i];
	}
	}

	/* Prevent divide by zero */
	return (count == 0 ? 0 : total / count);
	}

	static void
	print_iostat_queues(iostat_cbdata_t cb, nvlist_t oldnv,
	nvlist_t *newnv)
	{
	int i;
	uint64_t val;
	const char *names[] = {
	ZPOOL_CONFIG_VDEV_SYNC_R_PEND_QUEUE,
	ZPOOL_CONFIG_VDEV_SYNC_R_ACTIVE_QUEUE,
	ZPOOL_CONFIG_VDEV_SYNC_W_PEND_QUEUE,
	ZPOOL_CONFIG_VDEV_SYNC_W_ACTIVE_QUEUE,
	ZPOOL_CONFIG_VDEV_ASYNC_R_PEND_QUEUE,
	ZPOOL_CONFIG_VDEV_ASYNC_R_ACTIVE_QUEUE,
	ZPOOL_CONFIG_VDEV_ASYNC_W_PEND_QUEUE,
	ZPOOL_CONFIG_VDEV_ASYNC_W_ACTIVE_QUEUE,
	ZPOOL_CONFIG_VDEV_SCRUB_PEND_QUEUE,
	ZPOOL_CONFIG_VDEV_SCRUB_ACTIVE_QUEUE,
	ZPOOL_CONFIG_VDEV_TRIM_PEND_QUEUE,
	ZPOOL_CONFIG_VDEV_TRIM_ACTIVE_QUEUE,
	};

	struct stat_array *nva;

	unsigned int column_width = default_column_width(cb, IOS_QUEUES);
	enum zfs_nicenum_format format;

	nva = calc_and_alloc_stats_ex(names, ARRAY_SIZE(names), NULL, newnv);

	if (cb->cb_literal)
	format = ZFS_NICENUM_RAW;
	else
	format = ZFS_NICENUM_1024;

	for (i = 0; i < ARRAY_SIZE(names); i++) {
	val = nva[i].data[0];
	print_one_stat(val, format, column_width, cb->cb_scripted);
	}

	free_calc_stats(nva, ARRAY_SIZE(names));
	}

	static void
	print_iostat_latency(iostat_cbdata_t cb, nvlist_t oldnv,
	nvlist_t *newnv)
	{
	int i;
	uint64_t val;
	const char *names[] = {
	ZPOOL_CONFIG_VDEV_TOT_R_LAT_HISTO,
	ZPOOL_CONFIG_VDEV_TOT_W_LAT_HISTO,
	ZPOOL_CONFIG_VDEV_DISK_R_LAT_HISTO,
	ZPOOL_CONFIG_VDEV_DISK_W_LAT_HISTO,
	ZPOOL_CONFIG_VDEV_SYNC_R_LAT_HISTO,
	ZPOOL_CONFIG_VDEV_SYNC_W_LAT_HISTO,
	ZPOOL_CONFIG_VDEV_ASYNC_R_LAT_HISTO,
	ZPOOL_CONFIG_VDEV_ASYNC_W_LAT_HISTO,
	ZPOOL_CONFIG_VDEV_SCRUB_LAT_HISTO,
	ZPOOL_CONFIG_VDEV_TRIM_LAT_HISTO,
	};
	struct stat_array *nva;

	unsigned int column_width = default_column_width(cb, IOS_LATENCY);
	enum zfs_nicenum_format format;

	nva = calc_and_alloc_stats_ex(names, ARRAY_SIZE(names), oldnv, newnv);

	if (cb->cb_literal)
	format = ZFS_NICENUM_RAWTIME;
	else
	format = ZFS_NICENUM_TIME;

	/* Print our avg latencies on the line */
	for (i = 0; i < ARRAY_SIZE(names); i++) {
	/* Compute average latency for a latency histo */
	val = single_histo_average(nva[i].data, nva[i].count);
	print_one_stat(val, format, column_width, cb->cb_scripted);
	}
	free_calc_stats(nva, ARRAY_SIZE(names));
	}

	/*
	* Print default statistics (capacity/operations/bandwidth)
	*/
	static void
	print_iostat_default(vdev_stat_t vs, iostat_cbdata_t cb, double scale)
	{
	unsigned int column_width = default_column_width(cb, IOS_DEFAULT);
	enum zfs_nicenum_format format;
	char na; /* char to print for "not applicable" values */

	if (cb->cb_literal) {
	format = ZFS_NICENUM_RAW;
	na = '0';
	} else {
	format = ZFS_NICENUM_1024;
	na = '-';
	}

	/* only toplevel vdevs have capacity stats */
	if (vs->vs_space == 0) {
	if (cb->cb_scripted)
	printf("\t%c\t%c", na, na);
	else
	printf(" %c %c", column_width, na, column_width,
	na);
	} else {
	print_one_stat(vs->vs_alloc, format, column_width,
	cb->cb_scripted);
	print_one_stat(vs->vs_space - vs->vs_alloc, format,
	column_width, cb->cb_scripted);
	}

	print_one_stat((uint64_t)(vs->vs_ops[ZIO_TYPE_READ] * scale),
	format, column_width, cb->cb_scripted);
	print_one_stat((uint64_t)(vs->vs_ops[ZIO_TYPE_WRITE] * scale),
	format, column_width, cb->cb_scripted);
	print_one_stat((uint64_t)(vs->vs_bytes[ZIO_TYPE_READ] * scale),
	format, column_width, cb->cb_scripted);
	print_one_stat((uint64_t)(vs->vs_bytes[ZIO_TYPE_WRITE] * scale),
	format, column_width, cb->cb_scripted);
	}

	static const char *class_name[] = {
	VDEV_ALLOC_BIAS_DEDUP,
	VDEV_ALLOC_BIAS_SPECIAL,
	VDEV_ALLOC_CLASS_LOGS
	};

	/*
	* Print out all the statistics for the given vdev. This can either be the
	* toplevel configuration, or called recursively. If 'name' is NULL, then this
	* is a verbose output, and we don't want to display the toplevel pool stats.
	*
	* Returns the number of stat lines printed.
	*/
	static unsigned int
	print_vdev_stats(zpool_handle_t zhp, const char name, nvlist_t *oldnv,
	nvlist_t newnv, iostat_cbdata_t cb, int depth)
	{
	nvlist_t oldchild, newchild;
	uint_t c, children, oldchildren;
	vdev_stat_t oldvs, newvs, *calcvs;
	vdev_stat_t zerovs = { 0 };
	char *vname;
	int i;
	int ret = 0;
	uint64_t tdelta;
	double scale;

	if (strcmp(name, VDEV_TYPE_INDIRECT) == 0)
	return (ret);

	calcvs = safe_malloc(sizeof (*calcvs));

	if (oldnv != NULL) {
	verify(nvlist_lookup_uint64_array(oldnv,
	ZPOOL_CONFIG_VDEV_STATS, (uint64_t **)&oldvs, &c) == 0);
	} else {
	oldvs = &zerovs;
	}

	/* Do we only want to see a specific vdev? */
	for (i = 0; i < cb->cb_vdev_names_count; i++) {
	/* Yes we do. Is this the vdev? */
	if (strcmp(name, cb->cb_vdev_names[i]) == 0) {
	/*
	* This is our vdev. Since it is the only vdev we
	* will be displaying, make depth = 0 so that it
	* doesn't get indented.
	*/
	depth = 0;
	break;
	}
	}

	if (cb->cb_vdev_names_count && (i == cb->cb_vdev_names_count)) {
	/* Couldn't match the name */
	goto children;
	}


	verify(nvlist_lookup_uint64_array(newnv, ZPOOL_CONFIG_VDEV_STATS,
	(uint64_t **)&newvs, &c) == 0);

	/*
	* Print the vdev name unless it's is a histogram. Histograms
	* display the vdev name in the header itself.
	*/
	if (!(cb->cb_flags & IOS_ANYHISTO_M)) {
	if (cb->cb_scripted) {
	printf("%s", name);
	} else {
	if (strlen(name) + depth > cb->cb_namewidth)
	(void) printf("%*s%s", depth, "", name);
	else
	(void) printf("%s%s%s", depth, "", name,
	(int)(cb->cb_namewidth - strlen(name) -
	depth), "");
	}
	}

	/* Calculate our scaling factor */
	tdelta = newvs->vs_timestamp - oldvs->vs_timestamp;
	if ((oldvs->vs_timestamp == 0) && (cb->cb_flags & IOS_ANYHISTO_M)) {
	/*
	* If we specify printing histograms with no time interval, then
	* print the histogram numbers over the entire lifetime of the
	* vdev.
	*/
	scale = 1;
	} else {
	if (tdelta == 0)
	scale = 1.0;
	else
	scale = (double)NANOSEC / tdelta;
	}

	if (cb->cb_flags & IOS_DEFAULT_M) {
	calc_default_iostats(oldvs, newvs, calcvs);
	print_iostat_default(calcvs, cb, scale);
	}
	if (cb->cb_flags & IOS_LATENCY_M)
	print_iostat_latency(cb, oldnv, newnv);
	if (cb->cb_flags & IOS_QUEUES_M)
	print_iostat_queues(cb, oldnv, newnv);
	if (cb->cb_flags & IOS_ANYHISTO_M) {
	printf("\n");
	print_iostat_histos(cb, oldnv, newnv, scale, name);
	}

	if (cb->vcdl != NULL) {
	char *path;
	if (nvlist_lookup_string(newnv, ZPOOL_CONFIG_PATH,
	&path) == 0) {
	printf(" ");
	zpool_print_cmd(cb->vcdl, zpool_get_name(zhp), path);
	}
	}

	if (!(cb->cb_flags & IOS_ANYHISTO_M))
	printf("\n");

	ret++;

	children:

	free(calcvs);

	if (!cb->cb_verbose)
	return (ret);

	if (nvlist_lookup_nvlist_array(newnv, ZPOOL_CONFIG_CHILDREN,
	&newchild, &children) != 0)
	return (ret);

	if (oldnv) {
	if (nvlist_lookup_nvlist_array(oldnv, ZPOOL_CONFIG_CHILDREN,
	&oldchild, &oldchildren) != 0)
	return (ret);

	children = MIN(oldchildren, children);
	}

	/*
	* print normal top-level devices
	*/
	for (c = 0; c < children; c++) {
	uint64_t ishole = B_FALSE, islog = B_FALSE;

	(void) nvlist_lookup_uint64(newchild[c], ZPOOL_CONFIG_IS_HOLE,
	&ishole);

	(void) nvlist_lookup_uint64(newchild[c], ZPOOL_CONFIG_IS_LOG,
	&islog);

	if (ishole \|\| islog)
	continue;

	if (nvlist_exists(newchild[c], ZPOOL_CONFIG_ALLOCATION_BIAS))
	continue;

	vname = zpool_vdev_name(g_zfs, zhp, newchild[c],
	cb->cb_name_flags);
	ret += print_vdev_stats(zhp, vname, oldnv ? oldchild[c] : NULL,
	newchild[c], cb, depth + 2);
	free(vname);
	}

	/*
	* print all other top-level devices
	*/
	for (uint_t n = 0; n < 3; n++) {
	boolean_t printed = B_FALSE;

	for (c = 0; c < children; c++) {
	uint64_t islog = B_FALSE;
	char *bias = NULL;
	char *type = NULL;

	(void) nvlist_lookup_uint64(newchild[c],
	ZPOOL_CONFIG_IS_LOG, &islog);
	if (islog) {
	bias = VDEV_ALLOC_CLASS_LOGS;
	} else {
	(void) nvlist_lookup_string(newchild[c],
	ZPOOL_CONFIG_ALLOCATION_BIAS, &bias);
	(void) nvlist_lookup_string(newchild[c],
	ZPOOL_CONFIG_TYPE, &type);
	}
	if (bias == NULL \|\| strcmp(bias, class_name[n]) != 0)
	continue;
	if (!islog && strcmp(type, VDEV_TYPE_INDIRECT) == 0)
	continue;

	if (!printed) {
	if ((!(cb->cb_flags & IOS_ANYHISTO_M)) &&
	!cb->cb_scripted && !cb->cb_vdev_names) {
	print_iostat_dashes(cb, 0,
	class_name[n]);
	}
	printf("\n");
	printed = B_TRUE;
	}

	vname = zpool_vdev_name(g_zfs, zhp, newchild[c],
	cb->cb_name_flags);
	ret += print_vdev_stats(zhp, vname, oldnv ?
	oldchild[c] : NULL, newchild[c], cb, depth + 2);
	free(vname);
	}
	}

	/*
	* Include level 2 ARC devices in iostat output
	*/
	if (nvlist_lookup_nvlist_array(newnv, ZPOOL_CONFIG_L2CACHE,
	&newchild, &children) != 0)
	return (ret);

	if (oldnv) {
	if (nvlist_lookup_nvlist_array(oldnv, ZPOOL_CONFIG_L2CACHE,
	&oldchild, &oldchildren) != 0)
	return (ret);

	children = MIN(oldchildren, children);
	}

	if (children > 0) {
	if ((!(cb->cb_flags & IOS_ANYHISTO_M)) && !cb->cb_scripted &&
	!cb->cb_vdev_names) {
	print_iostat_dashes(cb, 0, "cache");
	}
	printf("\n");

	for (c = 0; c < children; c++) {
	vname = zpool_vdev_name(g_zfs, zhp, newchild[c],
	cb->cb_name_flags);
	ret += print_vdev_stats(zhp, vname, oldnv ? oldchild[c]
	: NULL, newchild[c], cb, depth + 2);
	free(vname);
	}
	}

	return (ret);
	}

	static int
	refresh_iostat(zpool_handle_t zhp, void data)
	{
	iostat_cbdata_t *cb = data;
	boolean_t missing;

	/*
	* If the pool has disappeared, remove it from the list and continue.
	*/
	if (zpool_refresh_stats(zhp, &missing) != 0)
	return (-1);

	if (missing)
	pool_list_remove(cb->cb_list, zhp);

	return (0);
	}

	/*
	* Callback to print out the iostats for the given pool.
	*/
	static int
	print_iostat(zpool_handle_t zhp, void data)
	{
	iostat_cbdata_t *cb = data;
	nvlist_t oldconfig, newconfig;
	nvlist_t oldnvroot, newnvroot;
	int ret;

	newconfig = zpool_get_config(zhp, &oldconfig);

	if (cb->cb_iteration == 1)
	oldconfig = NULL;

	verify(nvlist_lookup_nvlist(newconfig, ZPOOL_CONFIG_VDEV_TREE,
	&newnvroot) == 0);

	if (oldconfig == NULL)
	oldnvroot = NULL;
	else
	verify(nvlist_lookup_nvlist(oldconfig, ZPOOL_CONFIG_VDEV_TREE,
	&oldnvroot) == 0);

	ret = print_vdev_stats(zhp, zpool_get_name(zhp), oldnvroot, newnvroot,
	cb, 0);
	if ((ret != 0) && !(cb->cb_flags & IOS_ANYHISTO_M) &&
	!cb->cb_scripted && cb->cb_verbose && !cb->cb_vdev_names_count) {
	print_iostat_separator(cb);
	if (cb->vcdl != NULL) {
	print_cmd_columns(cb->vcdl, 1);
	}
	printf("\n");
	}

	return (ret);
	}

	static int
	get_columns(void)
	{
	struct winsize ws;
	int columns = 80;
	int error;

	if (isatty(STDOUT_FILENO)) {
	error = ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws);
	if (error == 0)
	columns = ws.ws_col;
	} else {
	columns = 999;
	}

	return (columns);
	}

	/*
	* Return the required length of the pool/vdev name column. The minimum
	* allowed width and output formatting flags must be provided.
	*/
	static int
	get_namewidth(zpool_handle_t *zhp, int min_width, int flags, boolean_t verbose)
	{
	nvlist_t config, nvroot;
	int width = min_width;

	if ((config = zpool_get_config(zhp, NULL)) != NULL) {
	verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
	&nvroot) == 0);
	unsigned int poolname_len = strlen(zpool_get_name(zhp));
	if (verbose == B_FALSE) {
	width = MAX(poolname_len, min_width);
	} else {
	width = MAX(poolname_len,
	max_width(zhp, nvroot, 0, min_width, flags));
	}
	}

	return (width);
	}

	/*
	* Parse the input string, get the 'interval' and 'count' value if there is one.
	*/
	static void
	get_interval_count(int argcp, char argv, float iv,
	unsigned long *cnt)
	{
	float interval = 0;
	unsigned long count = 0;
	int argc = *argcp;

	/*
	* Determine if the last argument is an integer or a pool name
	*/
	if (argc > 0 && zfs_isnumber(argv[argc - 1])) {
	char *end;

	errno = 0;
	interval = strtof(argv[argc - 1], &end);

	if (*end == '\0' && errno == 0) {
	if (interval == 0) {
	- (void) fprintf(stderr, gettext("interval "
	- "cannot be zero\n"));
	+ (void) fprintf(stderr, gettext(
	+ "interval cannot be zero\n"));
	usage(B_FALSE);
	}
	/*
	* Ignore the last parameter
	*/
	argc--;
	} else {
	/*
	* If this is not a valid number, just plow on. The
	* user will get a more informative error message later
	* on.
	*/
	interval = 0;
	}
	}

	/*
	* If the last argument is also an integer, then we have both a count
	* and an interval.
	*/
	if (argc > 0 && zfs_isnumber(argv[argc - 1])) {
	char *end;

	errno = 0;
	count = interval;
	interval = strtof(argv[argc - 1], &end);

	if (*end == '\0' && errno == 0) {
	if (interval == 0) {
	- (void) fprintf(stderr, gettext("interval "
	- "cannot be zero\n"));
	+ (void) fprintf(stderr, gettext(
	+ "interval cannot be zero\n"));
	usage(B_FALSE);
	}

	/*
	* Ignore the last parameter
	*/
	argc--;
	} else {
	interval = 0;
	}
	}

	*iv = interval;
	*cnt = count;
	*argcp = argc;
	}

	static void
	get_timestamp_arg(char c)
	{
	if (c == 'u')
	timestamp_fmt = UDATE;
	else if (c == 'd')
	timestamp_fmt = DDATE;
	else
	usage(B_FALSE);
	}

	/*
	* Return stat flags that are supported by all pools by both the module and
	* zpool iostat. "*data" should be initialized to all 0xFFs before running.
	* It will get ANDed down until only the flags that are supported on all pools
	* remain.
	*/
	static int
	get_stat_flags_cb(zpool_handle_t zhp, void data)
	{
	uint64_t *mask = data;
	nvlist_t config, nvroot, *nvx;
	uint64_t flags = 0;
	int i, j;

	config = zpool_get_config(zhp, NULL);
	verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
	&nvroot) == 0);

	/* Default stats are always supported, but for completeness.. */
	if (nvlist_exists(nvroot, ZPOOL_CONFIG_VDEV_STATS))
	flags \|= IOS_DEFAULT_M;

	/* Get our extended stats nvlist from the main list */
	if (nvlist_lookup_nvlist(nvroot, ZPOOL_CONFIG_VDEV_STATS_EX,
	&nvx) != 0) {
	/*
	* No extended stats; they're probably running an older
	* module. No big deal, we support that too.
	*/
	goto end;
	}

	/* For each extended stat, make sure all its nvpairs are supported */
	for (j = 0; j < ARRAY_SIZE(vsx_type_to_nvlist); j++) {
	if (!vsx_type_to_nvlist[j][0])
	continue;

	/* Start off by assuming the flag is supported, then check */
	flags \|= (1ULL << j);
	for (i = 0; vsx_type_to_nvlist[j][i]; i++) {
	if (!nvlist_exists(nvx, vsx_type_to_nvlist[j][i])) {
	/* flag isn't supported */
	flags = flags & ~(1ULL << j);
	break;
	}
	}
	}
	end:
	mask = mask & flags;
	return (0);
	}

	/*
	* Return a bitmask of stats that are supported on all pools by both the module
	* and zpool iostat.
	*/
	static uint64_t
	get_stat_flags(zpool_list_t *list)
	{
	uint64_t mask = -1;

	/*
	* get_stat_flags_cb() will lop off bits from "mask" until only the
	* flags that are supported on all pools remain.
	*/
	pool_list_iter(list, B_FALSE, get_stat_flags_cb, &mask);
	return (mask);
	}

	/*
	* Return 1 if cb_data->cb_vdev_names[0] is this vdev's name, 0 otherwise.
	*/
	static int
	is_vdev_cb(zpool_handle_t zhp, nvlist_t nv, void *cb_data)
	{
	iostat_cbdata_t *cb = cb_data;
	char *name = NULL;
	int ret = 0;

	name = zpool_vdev_name(g_zfs, zhp, nv, cb->cb_name_flags);

	if (strcmp(name, cb->cb_vdev_names[0]) == 0)
	ret = 1; /* match */
	free(name);

	return (ret);
	}

	/*
	* Returns 1 if cb_data->cb_vdev_names[0] is a vdev name, 0 otherwise.
	*/
	static int
	is_vdev(zpool_handle_t zhp, void cb_data)
	{
	return (for_each_vdev(zhp, is_vdev_cb, cb_data));
	}

	/*
	* Check if vdevs are in a pool
	*
	* Return 1 if all argv[] strings are vdev names in pool "pool_name". Otherwise
	* return 0. If pool_name is NULL, then search all pools.
	*/
	static int
	are_vdevs_in_pool(int argc, char *argv, char pool_name,
	iostat_cbdata_t *cb)
	{
	char **tmp_name;
	int ret = 0;
	int i;
	int pool_count = 0;

	if ((argc == 0) \|\| !*argv)
	return (0);

	if (pool_name)
	pool_count = 1;

	/* Temporarily hijack cb_vdev_names for a second... */
	tmp_name = cb->cb_vdev_names;

	/* Go though our list of prospective vdev names */
	for (i = 0; i < argc; i++) {
	cb->cb_vdev_names = argv + i;

	/* Is this name a vdev in our pools? */
	ret = for_each_pool(pool_count, &pool_name, B_TRUE, NULL,
	B_FALSE, is_vdev, cb);
	if (!ret) {
	/* No match */
	break;
	}
	}

	cb->cb_vdev_names = tmp_name;

	return (ret);
	}

	static int
	is_pool_cb(zpool_handle_t zhp, void data)
	{
	char *name = data;
	if (strcmp(name, zpool_get_name(zhp)) == 0)
	return (1);

	return (0);
	}

	/*
	* Do we have a pool named *name? If so, return 1, otherwise 0.
	*/
	static int
	is_pool(char *name)
	{
	return (for_each_pool(0, NULL, B_TRUE, NULL, B_FALSE, is_pool_cb,
	name));
	}

	/* Are all our argv[] strings pool names? If so return 1, 0 otherwise. */
	static int
	are_all_pools(int argc, char **argv)
	{
	if ((argc == 0) \|\| !*argv)
	return (0);

	while (--argc >= 0)
	if (!is_pool(argv[argc]))
	return (0);

	return (1);
	}

	/*
	* Helper function to print out vdev/pool names we can't resolve. Used for an
	* error message.
	*/
	static void
	error_list_unresolved_vdevs(int argc, char *argv, char pool_name,
	iostat_cbdata_t *cb)
	{
	int i;
	char *name;
	char *str;
	for (i = 0; i < argc; i++) {
	name = argv[i];

	if (is_pool(name))
	str = gettext("pool");
	else if (are_vdevs_in_pool(1, &name, pool_name, cb))
	str = gettext("vdev in this pool");
	else if (are_vdevs_in_pool(1, &name, NULL, cb))
	str = gettext("vdev in another pool");
	else
	str = gettext("unknown");

	fprintf(stderr, "\t%s (%s)\n", name, str);
	}
	}

	/*
	* Same as get_interval_count(), but with additional checks to not misinterpret
	* guids as interval/count values. Assumes VDEV_NAME_GUID is set in
	* cb.cb_name_flags.
	*/
	static void
	get_interval_count_filter_guids(int argc, char argv, float interval,
	unsigned long count, iostat_cbdata_t cb)
	{
	char **tmpargv = argv;
	int argc_for_interval = 0;

	/* Is the last arg an interval value? Or a guid? */
	if (argc >= 1 && !are_vdevs_in_pool(1, &argv[argc - 1], NULL, cb)) {
	/*
	* The last arg is not a guid, so it's probably an
	* interval value.
	*/
	argc_for_interval++;

	if (*argc >= 2 &&
	!are_vdevs_in_pool(1, &argv[*argc - 2], NULL, cb)) {
	/*
	* The 2nd to last arg is not a guid, so it's probably
	* an interval value.
	*/
	argc_for_interval++;
	}
	}

	/* Point to our list of possible intervals */
	tmpargv = &argv[*argc - argc_for_interval];

	argc = argc - argc_for_interval;
	get_interval_count(&argc_for_interval, tmpargv,
	interval, count);
	}

	/*
	* Floating point sleep(). Allows you to pass in a floating point value for
	* seconds.
	*/
	static void
	fsleep(float sec)
	{
	struct timespec req;
	req.tv_sec = floor(sec);
	req.tv_nsec = (sec - (float)req.tv_sec) * NANOSEC;
	nanosleep(&req, NULL);
	}

	/*
	* Terminal height, in rows. Returns -1 if stdout is not connected to a TTY or
	* if we were unable to determine its size.
	*/
	static int
	terminal_height(void)
	{
	struct winsize win;

	if (isatty(STDOUT_FILENO) == 0)
	return (-1);

	if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &win) != -1 && win.ws_row > 0)
	return (win.ws_row);

	return (-1);
	}

	/*
	* Run one of the zpool status/iostat -c scripts with the help (-h) option and
	* print the result.
	*
	* name: Short name of the script ('iostat').
	* path: Full path to the script ('/usr/local/etc/zfs/zpool.d/iostat');
	*/
	static void
	print_zpool_script_help(char name, char path)
	{
	char *argv[] = {path, "-h", NULL};
	char **lines = NULL;
	int lines_cnt = 0;
	int rc;

	rc = libzfs_run_process_get_stdout_nopath(path, argv, NULL, &lines,
	&lines_cnt);
	if (rc != 0 \|\| lines == NULL \|\| lines_cnt <= 0) {
	if (lines != NULL)
	libzfs_free_str_array(lines, lines_cnt);
	return;
	}

	for (int i = 0; i < lines_cnt; i++)
	if (!is_blank_str(lines[i]))
	printf(" %-14s %s\n", name, lines[i]);

	libzfs_free_str_array(lines, lines_cnt);
	}

	/*
	* Go though the zpool status/iostat -c scripts in the user's path, run their
	* help option (-h), and print out the results.
	*/
	static void
	print_zpool_dir_scripts(char *dirpath)
	{
	DIR *dir;
	struct dirent *ent;
	char fullpath[MAXPATHLEN];
	struct stat dir_stat;

	if ((dir = opendir(dirpath)) != NULL) {
	/* print all the files and directories within directory */
	while ((ent = readdir(dir)) != NULL) {
	sprintf(fullpath, "%s/%s", dirpath, ent->d_name);

	/* Print the scripts */
	if (stat(fullpath, &dir_stat) == 0)
	if (dir_stat.st_mode & S_IXUSR &&
	S_ISREG(dir_stat.st_mode))
	print_zpool_script_help(ent->d_name,
	fullpath);
	}
	closedir(dir);
	}
	}

	/*
	* Print out help text for all zpool status/iostat -c scripts.
	*/
	static void
	print_zpool_script_list(char *subcommand)
	{
	char dir, sp;

	printf(gettext("Available 'zpool %s -c' commands:\n"), subcommand);

	sp = zpool_get_cmd_search_path();
	if (sp == NULL)
	return;

	dir = strtok(sp, ":");
	while (dir != NULL) {
	print_zpool_dir_scripts(dir);
	dir = strtok(NULL, ":");
	}

	free(sp);
	}

	/*
	* Set the minimum pool/vdev name column width. The width must be at least 10,
	* but may be as large as the column width - 42 so it still fits on one line.
	* NOTE: 42 is the width of the default capacity/operations/bandwidth output
	*/
	static int
	get_namewidth_iostat(zpool_handle_t zhp, void data)
	{
	iostat_cbdata_t *cb = data;
	int width, available_width;

	/*
	* get_namewidth() returns the maximum width of any name in that column
	* for any pool/vdev/device line that will be output.
	*/
	width = get_namewidth(zhp, cb->cb_namewidth, cb->cb_name_flags,
	cb->cb_verbose);

	/*
	* The width we are calculating is the width of the header and also the
	* padding width for names that are less than maximum width. The stats
	* take up 42 characters, so the width available for names is:
	*/
	available_width = get_columns() - 42;

	/*
	* If the maximum width fits on a screen, then great! Make everything
	* line up by justifying all lines to the same width. If that max
	* width is larger than what's available, the name plus stats won't fit
	* on one line, and justifying to that width would cause every line to
	* wrap on the screen. We only want lines with long names to wrap.
	* Limit the padding to what won't wrap.
	*/
	if (width > available_width)
	width = available_width;

	/*
	* And regardless of whatever the screen width is (get_columns can
	* return 0 if the width is not known or less than 42 for a narrow
	* terminal) have the width be a minimum of 10.
	*/
	if (width < 10)
	width = 10;

	/* Save the calculated width */
	cb->cb_namewidth = width;

	return (0);
	}

	/*
	* zpool iostat [[-c [script1,script2,...]] [-lq]\|[-rw]] [-ghHLpPvy] [-n name]
	* [-T d\|u] [[ pool ...]\|[pool vdev ...]\|[vdev ...]]
	* [interval [count]]
	*
	* -c CMD For each vdev, run command CMD
	* -g Display guid for individual vdev name.
	* -L Follow links when resolving vdev path name.
	* -P Display full path for vdev name.
	* -v Display statistics for individual vdevs
	* -h Display help
	* -p Display values in parsable (exact) format.
	* -H Scripted mode. Don't display headers, and separate properties
	* by a single tab.
	* -l Display average latency
	* -q Display queue depths
	* -w Display latency histograms
	* -r Display request size histogram
	* -T Display a timestamp in date(1) or Unix format
	* -n Only print headers once
	*
	* This command can be tricky because we want to be able to deal with pool
	* creation/destruction as well as vdev configuration changes. The bulk of this
	* processing is handled by the pool_list_* routines in zpool_iter.c. We rely
	* on pool_list_update() to detect the addition of new pools. Configuration
	* changes are all handled within libzfs.
	*/
	int
	zpool_do_iostat(int argc, char **argv)
	{
	int c;
	int ret;
	int npools;
	float interval = 0;
	unsigned long count = 0;
	int winheight = 24;
	zpool_list_t *list;
	boolean_t verbose = B_FALSE;
	boolean_t latency = B_FALSE, l_histo = B_FALSE, rq_histo = B_FALSE;
	boolean_t queues = B_FALSE, parsable = B_FALSE, scripted = B_FALSE;
	boolean_t omit_since_boot = B_FALSE;
	boolean_t guid = B_FALSE;
	boolean_t follow_links = B_FALSE;
	boolean_t full_name = B_FALSE;
	boolean_t headers_once = B_FALSE;
	iostat_cbdata_t cb = { 0 };
	char *cmd = NULL;

	/* Used for printing error message */
	const char flag_to_arg[] = {[IOS_LATENCY] = 'l', [IOS_QUEUES] = 'q',
	[IOS_L_HISTO] = 'w', [IOS_RQ_HISTO] = 'r'};

	uint64_t unsupported_flags;

	/* check options */
	while ((c = getopt(argc, argv, "c:gLPT:vyhplqrwnH")) != -1) {
	switch (c) {
	case 'c':
	if (cmd != NULL) {
	fprintf(stderr,
	gettext("Can't set -c flag twice\n"));
	exit(1);
	}

	if (getenv("ZPOOL_SCRIPTS_ENABLED") != NULL &&
	!libzfs_envvar_is_set("ZPOOL_SCRIPTS_ENABLED")) {
	fprintf(stderr, gettext(
	"Can't run -c, disabled by "
	"ZPOOL_SCRIPTS_ENABLED.\n"));
	exit(1);
	}

	if ((getuid() <= 0 \|\| geteuid() <= 0) &&
	!libzfs_envvar_is_set("ZPOOL_SCRIPTS_AS_ROOT")) {
	fprintf(stderr, gettext(
	"Can't run -c with root privileges "
	"unless ZPOOL_SCRIPTS_AS_ROOT is set.\n"));
	exit(1);
	}
	cmd = optarg;
	verbose = B_TRUE;
	break;
	case 'g':
	guid = B_TRUE;
	break;
	case 'L':
	follow_links = B_TRUE;
	break;
	case 'P':
	full_name = B_TRUE;
	break;
	case 'T':
	get_timestamp_arg(*optarg);
	break;
	case 'v':
	verbose = B_TRUE;
	break;
	case 'p':
	parsable = B_TRUE;
	break;
	case 'l':
	latency = B_TRUE;
	break;
	case 'q':
	queues = B_TRUE;
	break;
	case 'H':
	scripted = B_TRUE;
	break;
	case 'w':
	l_histo = B_TRUE;
	break;
	case 'r':
	rq_histo = B_TRUE;
	break;
	case 'y':
	omit_since_boot = B_TRUE;
	break;
	case 'n':
	headers_once = B_TRUE;
	break;
	case 'h':
	usage(B_FALSE);
	break;
	case '?':
	if (optopt == 'c') {
	print_zpool_script_list("iostat");
	exit(0);
	} else {
	fprintf(stderr,
	gettext("invalid option '%c'\n"), optopt);
	}
	usage(B_FALSE);
	}
	}

	argc -= optind;
	argv += optind;

	cb.cb_literal = parsable;
	cb.cb_scripted = scripted;

	if (guid)
	cb.cb_name_flags \|= VDEV_NAME_GUID;
	if (follow_links)
	cb.cb_name_flags \|= VDEV_NAME_FOLLOW_LINKS;
	if (full_name)
	cb.cb_name_flags \|= VDEV_NAME_PATH;
	cb.cb_iteration = 0;
	cb.cb_namewidth = 0;
	cb.cb_verbose = verbose;

	/* Get our interval and count values (if any) */
	if (guid) {
	get_interval_count_filter_guids(&argc, argv, &interval,
	&count, &cb);
	} else {
	get_interval_count(&argc, argv, &interval, &count);
	}

	if (argc == 0) {
	/* No args, so just print the defaults. */
	} else if (are_all_pools(argc, argv)) {
	/* All the args are pool names */
	} else if (are_vdevs_in_pool(argc, argv, NULL, &cb)) {
	/* All the args are vdevs */
	cb.cb_vdev_names = argv;
	cb.cb_vdev_names_count = argc;
	argc = 0; /* No pools to process */
	} else if (are_all_pools(1, argv)) {
	/* The first arg is a pool name */
	if (are_vdevs_in_pool(argc - 1, argv + 1, argv[0], &cb)) {
	/* ...and the rest are vdev names */
	cb.cb_vdev_names = argv + 1;
	cb.cb_vdev_names_count = argc - 1;
	argc = 1; /* One pool to process */
	} else {
	fprintf(stderr, gettext("Expected either a list of "));
	fprintf(stderr, gettext("pools, or list of vdevs in"));
	fprintf(stderr, " \"%s\", ", argv[0]);
	fprintf(stderr, gettext("but got:\n"));
	error_list_unresolved_vdevs(argc - 1, argv + 1,
	argv[0], &cb);
	fprintf(stderr, "\n");
	usage(B_FALSE);
	return (1);
	}
	} else {
	/*
	* The args don't make sense. The first arg isn't a pool name,
	* nor are all the args vdevs.
	*/
	fprintf(stderr, gettext("Unable to parse pools/vdevs list.\n"));
	fprintf(stderr, "\n");
	return (1);
	}

	if (cb.cb_vdev_names_count != 0) {
	/*
	* If user specified vdevs, it implies verbose.
	*/
	cb.cb_verbose = B_TRUE;
	}

	/*
	* Construct the list of all interesting pools.
	*/
	ret = 0;
	if ((list = pool_list_get(argc, argv, NULL, parsable, &ret)) == NULL)
	return (1);

	if (pool_list_count(list) == 0 && argc != 0) {
	pool_list_free(list);
	return (1);
	}

	if (pool_list_count(list) == 0 && interval == 0) {
	pool_list_free(list);
	(void) fprintf(stderr, gettext("no pools available\n"));
	return (1);
	}

	if ((l_histo \|\| rq_histo) && (cmd != NULL \|\| latency \|\| queues)) {
	pool_list_free(list);
	(void) fprintf(stderr,
	gettext("[-r\|-w] isn't allowed with [-c\|-l\|-q]\n"));
	usage(B_FALSE);
	return (1);
	}

	if (l_histo && rq_histo) {
	pool_list_free(list);
	(void) fprintf(stderr,
	gettext("Only one of [-r\|-w] can be passed at a time\n"));
	usage(B_FALSE);
	return (1);
	}

	/*
	* Enter the main iostat loop.
	*/
	cb.cb_list = list;

	if (l_histo) {
	/*
	* Histograms tables look out of place when you try to display
	* them with the other stats, so make a rule that you can only
	* print histograms by themselves.
	*/
	cb.cb_flags = IOS_L_HISTO_M;
	} else if (rq_histo) {
	cb.cb_flags = IOS_RQ_HISTO_M;
	} else {
	cb.cb_flags = IOS_DEFAULT_M;
	if (latency)
	cb.cb_flags \|= IOS_LATENCY_M;
	if (queues)
	cb.cb_flags \|= IOS_QUEUES_M;
	}

	/*
	* See if the module supports all the stats we want to display.
	*/
	unsupported_flags = cb.cb_flags & ~get_stat_flags(list);
	if (unsupported_flags) {
	uint64_t f;
	int idx;
	fprintf(stderr,
	gettext("The loaded zfs module doesn't support:"));

	/* for each bit set in unsupported_flags */
	for (f = unsupported_flags; f; f &= ~(1ULL << idx)) {
	idx = lowbit64(f) - 1;
	fprintf(stderr, " -%c", flag_to_arg[idx]);
	}

	fprintf(stderr, ". Try running a newer module.\n");
	pool_list_free(list);

	return (1);
	}

	for (;;) {
	if ((npools = pool_list_count(list)) == 0)
	(void) fprintf(stderr, gettext("no pools available\n"));
	else {
	/*
	* If this is the first iteration and -y was supplied
	* we skip any printing.
	*/
	boolean_t skip = (omit_since_boot &&
	cb.cb_iteration == 0);

	/*
	* Refresh all statistics. This is done as an
	* explicit step before calculating the maximum name
	* width, so that any * configuration changes are
	* properly accounted for.
	*/
	(void) pool_list_iter(list, B_FALSE, refresh_iostat,
	&cb);

	/*
	* Iterate over all pools to determine the maximum width
	* for the pool / device name column across all pools.
	*/
	cb.cb_namewidth = 0;
	(void) pool_list_iter(list, B_FALSE,
	get_namewidth_iostat, &cb);

	if (timestamp_fmt != NODATE)
	print_timestamp(timestamp_fmt);

	if (cmd != NULL && cb.cb_verbose &&
	!(cb.cb_flags & IOS_ANYHISTO_M)) {
	cb.vcdl = all_pools_for_each_vdev_run(argc,
	argv, cmd, g_zfs, cb.cb_vdev_names,
	cb.cb_vdev_names_count, cb.cb_name_flags);
	} else {
	cb.vcdl = NULL;
	}


	/*
	* Check terminal size so we can print headers
	* even when terminal window has its height
	* changed.
	*/
	winheight = terminal_height();
	/*
	* Are we connected to TTY? If not, headers_once
	* should be true, to avoid breaking scripts.
	*/
	if (winheight < 0)
	headers_once = B_TRUE;

	/*
	* If it's the first time and we're not skipping it,
	* or either skip or verbose mode, print the header.
	*
	* The histogram code explicitly prints its header on
	* every vdev, so skip this for histograms.
	*/
	if (((++cb.cb_iteration == 1 && !skip) \|\|
	(skip != verbose) \|\|
	(!headers_once &&
	(cb.cb_iteration % winheight) == 0)) &&
	(!(cb.cb_flags & IOS_ANYHISTO_M)) &&
	!cb.cb_scripted)
	print_iostat_header(&cb);

	if (skip) {
	(void) fsleep(interval);
	continue;
	}

	pool_list_iter(list, B_FALSE, print_iostat, &cb);

	/*
	* If there's more than one pool, and we're not in
	* verbose mode (which prints a separator for us),
	* then print a separator.
	*
	* In addition, if we're printing specific vdevs then
	* we also want an ending separator.
	*/
	if (((npools > 1 && !verbose &&
	!(cb.cb_flags & IOS_ANYHISTO_M)) \|\|
	(!(cb.cb_flags & IOS_ANYHISTO_M) &&
	cb.cb_vdev_names_count)) &&
	!cb.cb_scripted) {
	print_iostat_separator(&cb);
	if (cb.vcdl != NULL)
	print_cmd_columns(cb.vcdl, 1);
	printf("\n");
	}

	if (cb.vcdl != NULL)
	free_vdev_cmd_data_list(cb.vcdl);

	}

	/*
	* Flush the output so that redirection to a file isn't buffered
	* indefinitely.
	*/
	(void) fflush(stdout);

	if (interval == 0)
	break;

	if (count != 0 && --count == 0)
	break;

	(void) fsleep(interval);
	}

	pool_list_free(list);

	return (ret);
	}

	typedef struct list_cbdata {
	boolean_t cb_verbose;
	int cb_name_flags;
	int cb_namewidth;
	boolean_t cb_scripted;
	zprop_list_t *cb_proplist;
	boolean_t cb_literal;
	} list_cbdata_t;


	/*
	* Given a list of columns to display, output appropriate headers for each one.
	*/
	static void
	print_header(list_cbdata_t *cb)
	{
	zprop_list_t *pl = cb->cb_proplist;
	char headerbuf[ZPOOL_MAXPROPLEN];
	const char *header;
	boolean_t first = B_TRUE;
	boolean_t right_justify;
	size_t width = 0;

	for (; pl != NULL; pl = pl->pl_next) {
	width = pl->pl_width;
	if (first && cb->cb_verbose) {
	/*
	* Reset the width to accommodate the verbose listing
	* of devices.
	*/
	width = cb->cb_namewidth;
	}

	if (!first)
	(void) printf(" ");
	else
	first = B_FALSE;

	right_justify = B_FALSE;
	if (pl->pl_prop != ZPROP_INVAL) {
	header = zpool_prop_column_name(pl->pl_prop);
	right_justify = zpool_prop_align_right(pl->pl_prop);
	} else {
	int i;

	for (i = 0; pl->pl_user_prop[i] != '\0'; i++)
	headerbuf[i] = toupper(pl->pl_user_prop[i]);
	headerbuf[i] = '\0';
	header = headerbuf;
	}

	if (pl->pl_next == NULL && !right_justify)
	(void) printf("%s", header);
	else if (right_justify)
	(void) printf("%*s", (int)width, header);
	else
	(void) printf("%-*s", (int)width, header);
	}

	(void) printf("\n");
	}

	/*
	* Given a pool and a list of properties, print out all the properties according
	* to the described layout. Used by zpool_do_list().
	*/
	static void
	print_pool(zpool_handle_t zhp, list_cbdata_t cb)
	{
	zprop_list_t *pl = cb->cb_proplist;
	boolean_t first = B_TRUE;
	char property[ZPOOL_MAXPROPLEN];
	char *propstr;
	boolean_t right_justify;
	size_t width;

	for (; pl != NULL; pl = pl->pl_next) {

	width = pl->pl_width;
	if (first && cb->cb_verbose) {
	/*
	* Reset the width to accommodate the verbose listing
	* of devices.
	*/
	width = cb->cb_namewidth;
	}

	if (!first) {
	if (cb->cb_scripted)
	(void) printf("\t");
	else
	(void) printf(" ");
	} else {
	first = B_FALSE;
	}

	right_justify = B_FALSE;
	if (pl->pl_prop != ZPROP_INVAL) {
	if (zpool_get_prop(zhp, pl->pl_prop, property,
	sizeof (property), NULL, cb->cb_literal) != 0)
	propstr = "-";
	else
	propstr = property;

	right_justify = zpool_prop_align_right(pl->pl_prop);
	} else if ((zpool_prop_feature(pl->pl_user_prop) \|\|
	zpool_prop_unsupported(pl->pl_user_prop)) &&
	zpool_prop_get_feature(zhp, pl->pl_user_prop, property,
	sizeof (property)) == 0) {
	propstr = property;
	} else {
	propstr = "-";
	}


	/*
	* If this is being called in scripted mode, or if this is the
	* last column and it is left-justified, don't include a width
	* format specifier.
	*/
	if (cb->cb_scripted \|\| (pl->pl_next == NULL && !right_justify))
	(void) printf("%s", propstr);
	else if (right_justify)
	(void) printf("%*s", (int)width, propstr);
	else
	(void) printf("%-*s", (int)width, propstr);
	}

	(void) printf("\n");
	}

	static void
	print_one_column(zpool_prop_t prop, uint64_t value, const char *str,
	boolean_t scripted, boolean_t valid, enum zfs_nicenum_format format)
	{
	char propval[64];
	boolean_t fixed;
	size_t width = zprop_width(prop, &fixed, ZFS_TYPE_POOL);

	switch (prop) {
	case ZPOOL_PROP_EXPANDSZ:
	case ZPOOL_PROP_CHECKPOINT:
	case ZPOOL_PROP_DEDUPRATIO:
	if (value == 0)
	(void) strlcpy(propval, "-", sizeof (propval));
	else
	zfs_nicenum_format(value, propval, sizeof (propval),
	format);
	break;
	case ZPOOL_PROP_FRAGMENTATION:
	if (value == ZFS_FRAG_INVALID) {
	(void) strlcpy(propval, "-", sizeof (propval));
	} else if (format == ZFS_NICENUM_RAW) {
	(void) snprintf(propval, sizeof (propval), "%llu",
	(unsigned long long)value);
	} else {
	(void) snprintf(propval, sizeof (propval), "%llu%%",
	(unsigned long long)value);
	}
	break;
	case ZPOOL_PROP_CAPACITY:
	/* capacity value is in parts-per-10,000 (aka permyriad) */
	if (format == ZFS_NICENUM_RAW)
	(void) snprintf(propval, sizeof (propval), "%llu",
	(unsigned long long)value / 100);
	else
	(void) snprintf(propval, sizeof (propval),
	value < 1000 ? "%1.2f%%" : value < 10000 ?
	"%2.1f%%" : "%3.0f%%", value / 100.0);
	break;
	case ZPOOL_PROP_HEALTH:
	width = 8;
	- snprintf(propval, sizeof (propval), "%-*s", (int)width, str);
	+ (void) strlcpy(propval, str, sizeof (propval));
	break;
	default:
	zfs_nicenum_format(value, propval, sizeof (propval), format);
	}

	if (!valid)
	(void) strlcpy(propval, "-", sizeof (propval));

	if (scripted)
	(void) printf("\t%s", propval);
	else
	(void) printf(" %*s", (int)width, propval);
	}

	/*
	* print static default line per vdev
	* not compatible with '-o' <proplist> option
	*/
	static void
	print_list_stats(zpool_handle_t zhp, const char name, nvlist_t *nv,
	list_cbdata_t *cb, int depth, boolean_t isspare)
	{
	nvlist_t **child;
	vdev_stat_t *vs;
	uint_t c, children;
	char *vname;
	boolean_t scripted = cb->cb_scripted;
	uint64_t islog = B_FALSE;
	char dashes = "%-s - - - - "
	"- - - - -\n";

	verify(nvlist_lookup_uint64_array(nv, ZPOOL_CONFIG_VDEV_STATS,
	(uint64_t **)&vs, &c) == 0);

	if (name != NULL) {
	boolean_t toplevel = (vs->vs_space != 0);
	uint64_t cap;
	enum zfs_nicenum_format format;
	const char *state;

	if (cb->cb_literal)
	format = ZFS_NICENUM_RAW;
	else
	format = ZFS_NICENUM_1024;

	if (strcmp(name, VDEV_TYPE_INDIRECT) == 0)
	return;

	if (scripted)
	(void) printf("\t%s", name);
	else if (strlen(name) + depth > cb->cb_namewidth)
	(void) printf("%*s%s", depth, "", name);
	else
	(void) printf("%s%s%s", depth, "", name,
	(int)(cb->cb_namewidth - strlen(name) - depth), "");

	/*
	* Print the properties for the individual vdevs. Some
	* properties are only applicable to toplevel vdevs. The
	* 'toplevel' boolean value is passed to the print_one_column()
	* to indicate that the value is valid.
	*/
	print_one_column(ZPOOL_PROP_SIZE, vs->vs_space, NULL, scripted,
	toplevel, format);
	print_one_column(ZPOOL_PROP_ALLOCATED, vs->vs_alloc, NULL,
	scripted, toplevel, format);
	print_one_column(ZPOOL_PROP_FREE, vs->vs_space - vs->vs_alloc,
	NULL, scripted, toplevel, format);
	print_one_column(ZPOOL_PROP_CHECKPOINT,
	vs->vs_checkpoint_space, NULL, scripted, toplevel, format);
	print_one_column(ZPOOL_PROP_EXPANDSZ, vs->vs_esize, NULL,
	scripted, B_TRUE, format);
	print_one_column(ZPOOL_PROP_FRAGMENTATION,
	vs->vs_fragmentation, NULL, scripted,
	(vs->vs_fragmentation != ZFS_FRAG_INVALID && toplevel),
	format);
	cap = (vs->vs_space == 0) ? 0 :
	(vs->vs_alloc * 10000 / vs->vs_space);
	print_one_column(ZPOOL_PROP_CAPACITY, cap, NULL,
	scripted, toplevel, format);
	print_one_column(ZPOOL_PROP_DEDUPRATIO, 0, NULL,
	scripted, toplevel, format);
	state = zpool_state_to_name(vs->vs_state, vs->vs_aux);
	if (isspare) {
	if (vs->vs_aux == VDEV_AUX_SPARED)
	state = "INUSE";
	else if (vs->vs_state == VDEV_STATE_HEALTHY)
	state = "AVAIL";
	}
	print_one_column(ZPOOL_PROP_HEALTH, 0, state, scripted,
	B_TRUE, format);
	(void) printf("\n");
	}

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
	&child, &children) != 0)
	return;

	/* list the normal vdevs first */
	for (c = 0; c < children; c++) {
	uint64_t ishole = B_FALSE;

	if (nvlist_lookup_uint64(child[c],
	ZPOOL_CONFIG_IS_HOLE, &ishole) == 0 && ishole)
	continue;

	if (nvlist_lookup_uint64(child[c],
	ZPOOL_CONFIG_IS_LOG, &islog) == 0 && islog)
	continue;

	if (nvlist_exists(child[c], ZPOOL_CONFIG_ALLOCATION_BIAS))
	continue;

	vname = zpool_vdev_name(g_zfs, zhp, child[c],
	cb->cb_name_flags);
	print_list_stats(zhp, vname, child[c], cb, depth + 2, B_FALSE);
	free(vname);
	}

	/* list the classes: 'logs', 'dedup', and 'special' */
	for (uint_t n = 0; n < 3; n++) {
	boolean_t printed = B_FALSE;

	for (c = 0; c < children; c++) {
	char *bias = NULL;
	char *type = NULL;

	if (nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG,
	&islog) == 0 && islog) {
	bias = VDEV_ALLOC_CLASS_LOGS;
	} else {
	(void) nvlist_lookup_string(child[c],
	ZPOOL_CONFIG_ALLOCATION_BIAS, &bias);
	(void) nvlist_lookup_string(child[c],
	ZPOOL_CONFIG_TYPE, &type);
	}
	if (bias == NULL \|\| strcmp(bias, class_name[n]) != 0)
	continue;
	if (!islog && strcmp(type, VDEV_TYPE_INDIRECT) == 0)
	continue;

	if (!printed) {
	/* LINTED E_SEC_PRINTF_VAR_FMT */
	(void) printf(dashes, cb->cb_namewidth,
	class_name[n]);
	printed = B_TRUE;
	}
	vname = zpool_vdev_name(g_zfs, zhp, child[c],
	cb->cb_name_flags);
	print_list_stats(zhp, vname, child[c], cb, depth + 2,
	B_FALSE);
	free(vname);
	}
	}

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_L2CACHE,
	&child, &children) == 0 && children > 0) {
	/* LINTED E_SEC_PRINTF_VAR_FMT */
	(void) printf(dashes, cb->cb_namewidth, "cache");
	for (c = 0; c < children; c++) {
	vname = zpool_vdev_name(g_zfs, zhp, child[c],
	cb->cb_name_flags);
	print_list_stats(zhp, vname, child[c], cb, depth + 2,
	B_FALSE);
	free(vname);
	}
	}

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_SPARES, &child,
	&children) == 0 && children > 0) {
	/* LINTED E_SEC_PRINTF_VAR_FMT */
	(void) printf(dashes, cb->cb_namewidth, "spare");
	for (c = 0; c < children; c++) {
	vname = zpool_vdev_name(g_zfs, zhp, child[c],
	cb->cb_name_flags);
	print_list_stats(zhp, vname, child[c], cb, depth + 2,
	B_TRUE);
	free(vname);
	}
	}
	}

	/*
	* Generic callback function to list a pool.
	*/
	static int
	list_callback(zpool_handle_t zhp, void data)
	{
	list_cbdata_t *cbp = data;

	print_pool(zhp, cbp);

	if (cbp->cb_verbose) {
	nvlist_t config, nvroot;

	config = zpool_get_config(zhp, NULL);
	verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
	&nvroot) == 0);
	print_list_stats(zhp, NULL, nvroot, cbp, 0, B_FALSE);
	}

	return (0);
	}

	/*
	* Set the minimum pool/vdev name column width. The width must be at least 9,
	* but may be as large as needed.
	*/
	static int
	get_namewidth_list(zpool_handle_t zhp, void data)
	{
	list_cbdata_t *cb = data;
	int width;

	width = get_namewidth(zhp, cb->cb_namewidth, cb->cb_name_flags,
	cb->cb_verbose);

	if (width < 9)
	width = 9;

	cb->cb_namewidth = width;

	return (0);
	}

	/*
	* zpool list [-gHLpP] [-o prop[,prop]*] [-T d\|u] [pool] ... [interval [count]]
	*
	* -g Display guid for individual vdev name.
	* -H Scripted mode. Don't display headers, and separate properties
	* by a single tab.
	* -L Follow links when resolving vdev path name.
	* -o List of properties to display. Defaults to
	* "name,size,allocated,free,expandsize,fragmentation,capacity,"
	* "dedupratio,health,altroot"
	* -p Display values in parsable (exact) format.
	* -P Display full path for vdev name.
	* -T Display a timestamp in date(1) or Unix format
	*
	* List all pools in the system, whether or not they're healthy. Output space
	* statistics for each one, as well as health status summary.
	*/
	int
	zpool_do_list(int argc, char **argv)
	{
	int c;
	int ret = 0;
	list_cbdata_t cb = { 0 };
	static char default_props[] =
	"name,size,allocated,free,checkpoint,expandsize,fragmentation,"
	"capacity,dedupratio,health,altroot";
	char *props = default_props;
	float interval = 0;
	unsigned long count = 0;
	zpool_list_t *list;
	boolean_t first = B_TRUE;

	/* check options */
	while ((c = getopt(argc, argv, ":gHLo:pPT:v")) != -1) {
	switch (c) {
	case 'g':
	cb.cb_name_flags \|= VDEV_NAME_GUID;
	break;
	case 'H':
	cb.cb_scripted = B_TRUE;
	break;
	case 'L':
	cb.cb_name_flags \|= VDEV_NAME_FOLLOW_LINKS;
	break;
	case 'o':
	props = optarg;
	break;
	case 'P':
	cb.cb_name_flags \|= VDEV_NAME_PATH;
	break;
	case 'p':
	cb.cb_literal = B_TRUE;
	break;
	case 'T':
	get_timestamp_arg(*optarg);
	break;
	case 'v':
	cb.cb_verbose = B_TRUE;
	cb.cb_namewidth = 8; /* 8 until precalc is avail */
	break;
	case ':':
	(void) fprintf(stderr, gettext("missing argument for "
	"'%c' option\n"), optopt);
	usage(B_FALSE);
	break;
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	argc -= optind;
	argv += optind;

	get_interval_count(&argc, argv, &interval, &count);

	if (zprop_get_list(g_zfs, props, &cb.cb_proplist, ZFS_TYPE_POOL) != 0)
	usage(B_FALSE);

	for (;;) {
	if ((list = pool_list_get(argc, argv, &cb.cb_proplist,
	cb.cb_literal, &ret)) == NULL)
	return (1);

	if (pool_list_count(list) == 0)
	break;

	cb.cb_namewidth = 0;
	(void) pool_list_iter(list, B_FALSE, get_namewidth_list, &cb);

	if (timestamp_fmt != NODATE)
	print_timestamp(timestamp_fmt);

	if (!cb.cb_scripted && (first \|\| cb.cb_verbose)) {
	print_header(&cb);
	first = B_FALSE;
	}
	ret = pool_list_iter(list, B_TRUE, list_callback, &cb);

	if (interval == 0)
	break;

	if (count != 0 && --count == 0)
	break;

	pool_list_free(list);
	(void) fsleep(interval);
	}

	if (argc == 0 && !cb.cb_scripted && pool_list_count(list) == 0) {
	(void) printf(gettext("no pools available\n"));
	ret = 0;
	}

	pool_list_free(list);
	zprop_free_list(cb.cb_proplist);
	return (ret);
	}

	static int
	zpool_do_attach_or_replace(int argc, char **argv, int replacing)
	{
	boolean_t force = B_FALSE;
	boolean_t rebuild = B_FALSE;
	boolean_t wait = B_FALSE;
	int c;
	nvlist_t *nvroot;
	char poolname, old_disk, *new_disk;
	zpool_handle_t *zhp;
	nvlist_t *props = NULL;
	char *propval;
	int ret;

	/* check options */
	while ((c = getopt(argc, argv, "fo:sw")) != -1) {
	switch (c) {
	case 'f':
	force = B_TRUE;
	break;
	case 'o':
	if ((propval = strchr(optarg, '=')) == NULL) {
	(void) fprintf(stderr, gettext("missing "
	"'=' for -o option\n"));
	usage(B_FALSE);
	}
	*propval = '\0';
	propval++;

	if ((strcmp(optarg, ZPOOL_CONFIG_ASHIFT) != 0) \|\|
	(add_prop_list(optarg, propval, &props, B_TRUE)))
	usage(B_FALSE);
	break;
	case 's':
	rebuild = B_TRUE;
	break;
	case 'w':
	wait = B_TRUE;
	break;
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	argc -= optind;
	argv += optind;

	/* get pool name and check number of arguments */
	if (argc < 1) {
	(void) fprintf(stderr, gettext("missing pool name argument\n"));
	usage(B_FALSE);
	}

	poolname = argv[0];

	if (argc < 2) {
	(void) fprintf(stderr,
	gettext("missing <device> specification\n"));
	usage(B_FALSE);
	}

	old_disk = argv[1];

	if (argc < 3) {
	if (!replacing) {
	(void) fprintf(stderr,
	gettext("missing <new_device> specification\n"));
	usage(B_FALSE);
	}
	new_disk = old_disk;
	argc -= 1;
	argv += 1;
	} else {
	new_disk = argv[2];
	argc -= 2;
	argv += 2;
	}

	if (argc > 1) {
	(void) fprintf(stderr, gettext("too many arguments\n"));
	usage(B_FALSE);
	}

	if ((zhp = zpool_open(g_zfs, poolname)) == NULL) {
	nvlist_free(props);
	return (1);
	}

	if (zpool_get_config(zhp, NULL) == NULL) {
	(void) fprintf(stderr, gettext("pool '%s' is unavailable\n"),
	poolname);
	zpool_close(zhp);
	nvlist_free(props);
	return (1);
	}

	/* unless manually specified use "ashift" pool property (if set) */
	if (!nvlist_exists(props, ZPOOL_CONFIG_ASHIFT)) {
	int intval;
	zprop_source_t src;
	char strval[ZPOOL_MAXPROPLEN];

	intval = zpool_get_prop_int(zhp, ZPOOL_PROP_ASHIFT, &src);
	if (src != ZPROP_SRC_DEFAULT) {
	(void) sprintf(strval, "%" PRId32, intval);
	verify(add_prop_list(ZPOOL_CONFIG_ASHIFT, strval,
	&props, B_TRUE) == 0);
	}
	}

	nvroot = make_root_vdev(zhp, props, force, B_FALSE, replacing, B_FALSE,
	argc, argv);
	if (nvroot == NULL) {
	zpool_close(zhp);
	nvlist_free(props);
	return (1);
	}

	ret = zpool_vdev_attach(zhp, old_disk, new_disk, nvroot, replacing,
	rebuild);

	if (ret == 0 && wait)
	ret = zpool_wait(zhp,
	replacing ? ZPOOL_WAIT_REPLACE : ZPOOL_WAIT_RESILVER);

	nvlist_free(props);
	nvlist_free(nvroot);
	zpool_close(zhp);

	return (ret);
	}

	/*
	* zpool replace [-fsw] [-o property=value] <pool> <device> <new_device>
	*
	* -f Force attach, even if <new_device> appears to be in use.
	* -s Use sequential instead of healing reconstruction for resilver.
	* -o Set property=value.
	* -w Wait for replacing to complete before returning
	*
	* Replace <device> with <new_device>.
	*/
	/* ARGSUSED */
	int
	zpool_do_replace(int argc, char **argv)
	{
	return (zpool_do_attach_or_replace(argc, argv, B_TRUE));
	}

	/*
	* zpool attach [-fsw] [-o property=value] <pool> <device> <new_device>
	*
	* -f Force attach, even if <new_device> appears to be in use.
	* -s Use sequential instead of healing reconstruction for resilver.
	* -o Set property=value.
	* -w Wait for resilvering to complete before returning
	*
	* Attach <new_device> to the mirror containing <device>. If <device> is not
	* part of a mirror, then <device> will be transformed into a mirror of
	* <device> and <new_device>. In either case, <new_device> will begin life
	* with a DTL of [0, now], and will immediately begin to resilver itself.
	*/
	int
	zpool_do_attach(int argc, char **argv)
	{
	return (zpool_do_attach_or_replace(argc, argv, B_FALSE));
	}

	/*
	* zpool detach [-f] <pool> <device>
	*
	* -f Force detach of <device>, even if DTLs argue against it
	* (not supported yet)
	*
	* Detach a device from a mirror. The operation will be refused if <device>
	* is the last device in the mirror, or if the DTLs indicate that this device
	* has the only valid copy of some data.
	*/
	/* ARGSUSED */
	int
	zpool_do_detach(int argc, char **argv)
	{
	int c;
	char poolname, path;
	zpool_handle_t *zhp;
	int ret;

	/* check options */
	while ((c = getopt(argc, argv, "")) != -1) {
	switch (c) {
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	argc -= optind;
	argv += optind;

	/* get pool name and check number of arguments */
	if (argc < 1) {
	(void) fprintf(stderr, gettext("missing pool name argument\n"));
	usage(B_FALSE);
	}

	if (argc < 2) {
	(void) fprintf(stderr,
	gettext("missing <device> specification\n"));
	usage(B_FALSE);
	}

	poolname = argv[0];
	path = argv[1];

	if ((zhp = zpool_open(g_zfs, poolname)) == NULL)
	return (1);

	ret = zpool_vdev_detach(zhp, path);

	zpool_close(zhp);

	return (ret);
	}

	/*
	* zpool split [-gLnP] [-o prop=val] ...
	* [-o mntopt] ...
	* [-R altroot] <pool> <newpool> [<device> ...]
	*
	* -g Display guid for individual vdev name.
	* -L Follow links when resolving vdev path name.
	* -n Do not split the pool, but display the resulting layout if
	* it were to be split.
	* -o Set property=value, or set mount options.
	* -P Display full path for vdev name.
	* -R Mount the split-off pool under an alternate root.
	* -l Load encryption keys while importing.
	*
	* Splits the named pool and gives it the new pool name. Devices to be split
	* off may be listed, provided that no more than one device is specified
	* per top-level vdev mirror. The newly split pool is left in an exported
	* state unless -R is specified.
	*
	* Restrictions: the top-level of the pool pool must only be made up of
	* mirrors; all devices in the pool must be healthy; no device may be
	* undergoing a resilvering operation.
	*/
	int
	zpool_do_split(int argc, char **argv)
	{
	char srcpool, newpool, *propval;
	char *mntopts = NULL;
	splitflags_t flags;
	int c, ret = 0;
	boolean_t loadkeys = B_FALSE;
	zpool_handle_t *zhp;
	nvlist_t config, props = NULL;

	flags.dryrun = B_FALSE;
	flags.import = B_FALSE;
	flags.name_flags = 0;

	/* check options */
	while ((c = getopt(argc, argv, ":gLR:lno:P")) != -1) {
	switch (c) {
	case 'g':
	flags.name_flags \|= VDEV_NAME_GUID;
	break;
	case 'L':
	flags.name_flags \|= VDEV_NAME_FOLLOW_LINKS;
	break;
	case 'R':
	flags.import = B_TRUE;
	if (add_prop_list(
	zpool_prop_to_name(ZPOOL_PROP_ALTROOT), optarg,
	&props, B_TRUE) != 0) {
	nvlist_free(props);
	usage(B_FALSE);
	}
	break;
	case 'l':
	loadkeys = B_TRUE;
	break;
	case 'n':
	flags.dryrun = B_TRUE;
	break;
	case 'o':
	if ((propval = strchr(optarg, '=')) != NULL) {
	*propval = '\0';
	propval++;
	if (add_prop_list(optarg, propval,
	&props, B_TRUE) != 0) {
	nvlist_free(props);
	usage(B_FALSE);
	}
	} else {
	mntopts = optarg;
	}
	break;
	case 'P':
	flags.name_flags \|= VDEV_NAME_PATH;
	break;
	case ':':
	(void) fprintf(stderr, gettext("missing argument for "
	"'%c' option\n"), optopt);
	usage(B_FALSE);
	break;
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	break;
	}
	}

	if (!flags.import && mntopts != NULL) {
	(void) fprintf(stderr, gettext("setting mntopts is only "
	"valid when importing the pool\n"));
	usage(B_FALSE);
	}

	if (!flags.import && loadkeys) {
	(void) fprintf(stderr, gettext("loading keys is only "
	"valid when importing the pool\n"));
	usage(B_FALSE);
	}

	argc -= optind;
	argv += optind;

	if (argc < 1) {
	(void) fprintf(stderr, gettext("Missing pool name\n"));
	usage(B_FALSE);
	}
	if (argc < 2) {
	(void) fprintf(stderr, gettext("Missing new pool name\n"));
	usage(B_FALSE);
	}

	srcpool = argv[0];
	newpool = argv[1];

	argc -= 2;
	argv += 2;

	if ((zhp = zpool_open(g_zfs, srcpool)) == NULL) {
	nvlist_free(props);
	return (1);
	}

	config = split_mirror_vdev(zhp, newpool, props, flags, argc, argv);
	if (config == NULL) {
	ret = 1;
	} else {
	if (flags.dryrun) {
	(void) printf(gettext("would create '%s' with the "
	"following layout:\n\n"), newpool);
	print_vdev_tree(NULL, newpool, config, 0, "",
	flags.name_flags);
	print_vdev_tree(NULL, "dedup", config, 0,
	VDEV_ALLOC_BIAS_DEDUP, 0);
	print_vdev_tree(NULL, "special", config, 0,
	VDEV_ALLOC_BIAS_SPECIAL, 0);
	}
	}

	zpool_close(zhp);

	if (ret != 0 \|\| flags.dryrun \|\| !flags.import) {
	nvlist_free(config);
	nvlist_free(props);
	return (ret);
	}

	/*
	* The split was successful. Now we need to open the new
	* pool and import it.
	*/
	if ((zhp = zpool_open_canfail(g_zfs, newpool)) == NULL) {
	nvlist_free(config);
	nvlist_free(props);
	return (1);
	}

	if (loadkeys) {
	ret = zfs_crypto_attempt_load_keys(g_zfs, newpool);
	if (ret != 0)
	ret = 1;
	}

	if (zpool_get_state(zhp) != POOL_STATE_UNAVAIL &&
	zpool_enable_datasets(zhp, mntopts, 0) != 0) {
	ret = 1;
	(void) fprintf(stderr, gettext("Split was successful, but "
	"the datasets could not all be mounted\n"));
	(void) fprintf(stderr, gettext("Try doing '%s' with a "
	"different altroot\n"), "zpool import");
	}
	zpool_close(zhp);
	nvlist_free(config);
	nvlist_free(props);

	return (ret);
	}



	/*
	* zpool online <pool> <device> ...
	*/
	int
	zpool_do_online(int argc, char **argv)
	{
	int c, i;
	char *poolname;
	zpool_handle_t *zhp;
	int ret = 0;
	vdev_state_t newstate;
	int flags = 0;

	/* check options */
	while ((c = getopt(argc, argv, "e")) != -1) {
	switch (c) {
	case 'e':
	flags \|= ZFS_ONLINE_EXPAND;
	break;
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	argc -= optind;
	argv += optind;

	/* get pool name and check number of arguments */
	if (argc < 1) {
	(void) fprintf(stderr, gettext("missing pool name\n"));
	usage(B_FALSE);
	}
	if (argc < 2) {
	(void) fprintf(stderr, gettext("missing device name\n"));
	usage(B_FALSE);
	}

	poolname = argv[0];

	if ((zhp = zpool_open(g_zfs, poolname)) == NULL)
	return (1);

	for (i = 1; i < argc; i++) {
	if (zpool_vdev_online(zhp, argv[i], flags, &newstate) == 0) {
	if (newstate != VDEV_STATE_HEALTHY) {
	(void) printf(gettext("warning: device '%s' "
	"onlined, but remains in faulted state\n"),
	argv[i]);
	if (newstate == VDEV_STATE_FAULTED)
	(void) printf(gettext("use 'zpool "
	"clear' to restore a faulted "
	"device\n"));
	else
	(void) printf(gettext("use 'zpool "
	"replace' to replace devices "
	"that are no longer present\n"));
	}
	} else {
	ret = 1;
	}
	}

	zpool_close(zhp);

	return (ret);
	}

	/*
	* zpool offline [-ft] <pool> <device> ...
	*
	* -f Force the device into a faulted state.
	*
	* -t Only take the device off-line temporarily. The offline/faulted
	* state will not be persistent across reboots.
	*/
	/* ARGSUSED */
	int
	zpool_do_offline(int argc, char **argv)
	{
	int c, i;
	char *poolname;
	zpool_handle_t *zhp;
	int ret = 0;
	boolean_t istmp = B_FALSE;
	boolean_t fault = B_FALSE;

	/* check options */
	while ((c = getopt(argc, argv, "ft")) != -1) {
	switch (c) {
	case 'f':
	fault = B_TRUE;
	break;
	case 't':
	istmp = B_TRUE;
	break;
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	argc -= optind;
	argv += optind;

	/* get pool name and check number of arguments */
	if (argc < 1) {
	(void) fprintf(stderr, gettext("missing pool name\n"));
	usage(B_FALSE);
	}
	if (argc < 2) {
	(void) fprintf(stderr, gettext("missing device name\n"));
	usage(B_FALSE);
	}

	poolname = argv[0];

	if ((zhp = zpool_open(g_zfs, poolname)) == NULL)
	return (1);

	for (i = 1; i < argc; i++) {
	if (fault) {
	uint64_t guid = zpool_vdev_path_to_guid(zhp, argv[i]);
	vdev_aux_t aux;
	if (istmp == B_FALSE) {
	/* Force the fault to persist across imports */
	aux = VDEV_AUX_EXTERNAL_PERSIST;
	} else {
	aux = VDEV_AUX_EXTERNAL;
	}

	if (guid == 0 \|\| zpool_vdev_fault(zhp, guid, aux) != 0)
	ret = 1;
	} else {
	if (zpool_vdev_offline(zhp, argv[i], istmp) != 0)
	ret = 1;
	}
	}

	zpool_close(zhp);

	return (ret);
	}

	/*
	* zpool clear <pool> [device]
	*
	* Clear all errors associated with a pool or a particular device.
	*/
	int
	zpool_do_clear(int argc, char **argv)
	{
	int c;
	int ret = 0;
	boolean_t dryrun = B_FALSE;
	boolean_t do_rewind = B_FALSE;
	boolean_t xtreme_rewind = B_FALSE;
	uint32_t rewind_policy = ZPOOL_NO_REWIND;
	nvlist_t *policy = NULL;
	zpool_handle_t *zhp;
	char pool, device;

	/* check options */
	while ((c = getopt(argc, argv, "FnX")) != -1) {
	switch (c) {
	case 'F':
	do_rewind = B_TRUE;
	break;
	case 'n':
	dryrun = B_TRUE;
	break;
	case 'X':
	xtreme_rewind = B_TRUE;
	break;
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	argc -= optind;
	argv += optind;

	if (argc < 1) {
	(void) fprintf(stderr, gettext("missing pool name\n"));
	usage(B_FALSE);
	}

	if (argc > 2) {
	(void) fprintf(stderr, gettext("too many arguments\n"));
	usage(B_FALSE);
	}

	if ((dryrun \|\| xtreme_rewind) && !do_rewind) {
	(void) fprintf(stderr,
	gettext("-n or -X only meaningful with -F\n"));
	usage(B_FALSE);
	}
	if (dryrun)
	rewind_policy = ZPOOL_TRY_REWIND;
	else if (do_rewind)
	rewind_policy = ZPOOL_DO_REWIND;
	if (xtreme_rewind)
	rewind_policy \|= ZPOOL_EXTREME_REWIND;

	/* In future, further rewind policy choices can be passed along here */
	if (nvlist_alloc(&policy, NV_UNIQUE_NAME, 0) != 0 \|\|
	nvlist_add_uint32(policy, ZPOOL_LOAD_REWIND_POLICY,
	rewind_policy) != 0) {
	return (1);
	}

	pool = argv[0];
	device = argc == 2 ? argv[1] : NULL;

	if ((zhp = zpool_open_canfail(g_zfs, pool)) == NULL) {
	nvlist_free(policy);
	return (1);
	}

	if (zpool_clear(zhp, device, policy) != 0)
	ret = 1;

	zpool_close(zhp);

	nvlist_free(policy);

	return (ret);
	}

	/*
	* zpool reguid <pool>
	*/
	int
	zpool_do_reguid(int argc, char **argv)
	{
	int c;
	char *poolname;
	zpool_handle_t *zhp;
	int ret = 0;

	/* check options */
	while ((c = getopt(argc, argv, "")) != -1) {
	switch (c) {
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	argc -= optind;
	argv += optind;

	/* get pool name and check number of arguments */
	if (argc < 1) {
	(void) fprintf(stderr, gettext("missing pool name\n"));
	usage(B_FALSE);
	}

	if (argc > 1) {
	(void) fprintf(stderr, gettext("too many arguments\n"));
	usage(B_FALSE);
	}

	poolname = argv[0];
	if ((zhp = zpool_open(g_zfs, poolname)) == NULL)
	return (1);

	ret = zpool_reguid(zhp);

	zpool_close(zhp);
	return (ret);
	}


	/*
	* zpool reopen <pool>
	*
	* Reopen the pool so that the kernel can update the sizes of all vdevs.
	*/
	int
	zpool_do_reopen(int argc, char **argv)
	{
	int c;
	int ret = 0;
	boolean_t scrub_restart = B_TRUE;

	/* check options */
	while ((c = getopt(argc, argv, "n")) != -1) {
	switch (c) {
	case 'n':
	scrub_restart = B_FALSE;
	break;
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	argc -= optind;
	argv += optind;

	/* if argc == 0 we will execute zpool_reopen_one on all pools */
	ret = for_each_pool(argc, argv, B_TRUE, NULL, B_FALSE, zpool_reopen_one,
	&scrub_restart);

	return (ret);
	}

	typedef struct scrub_cbdata {
	int cb_type;
	pool_scrub_cmd_t cb_scrub_cmd;
	} scrub_cbdata_t;

	static boolean_t
	zpool_has_checkpoint(zpool_handle_t *zhp)
	{
	nvlist_t config, nvroot;

	config = zpool_get_config(zhp, NULL);

	if (config != NULL) {
	pool_checkpoint_stat_t *pcs = NULL;
	uint_t c;

	nvroot = fnvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE);
	(void) nvlist_lookup_uint64_array(nvroot,
	ZPOOL_CONFIG_CHECKPOINT_STATS, (uint64_t **)&pcs, &c);

	if (pcs == NULL \|\| pcs->pcs_state == CS_NONE)
	return (B_FALSE);

	assert(pcs->pcs_state == CS_CHECKPOINT_EXISTS \|\|
	pcs->pcs_state == CS_CHECKPOINT_DISCARDING);
	return (B_TRUE);
	}

	return (B_FALSE);
	}

	static int
	scrub_callback(zpool_handle_t zhp, void data)
	{
	scrub_cbdata_t *cb = data;
	int err;

	/*
	* Ignore faulted pools.
	*/
	if (zpool_get_state(zhp) == POOL_STATE_UNAVAIL) {
	(void) fprintf(stderr, gettext("cannot scan '%s': pool is "
	"currently unavailable\n"), zpool_get_name(zhp));
	return (1);
	}

	err = zpool_scan(zhp, cb->cb_type, cb->cb_scrub_cmd);

	if (err == 0 && zpool_has_checkpoint(zhp) &&
	cb->cb_type == POOL_SCAN_SCRUB) {
	(void) printf(gettext("warning: will not scrub state that "
	"belongs to the checkpoint of pool '%s'\n"),
	zpool_get_name(zhp));
	}

	return (err != 0);
	}

	static int
	wait_callback(zpool_handle_t zhp, void data)
	{
	zpool_wait_activity_t *act = data;
	return (zpool_wait(zhp, *act));
	}

	/*
	* zpool scrub [-s \| -p] [-w] <pool> ...
	*
	* -s Stop. Stops any in-progress scrub.
	* -p Pause. Pause in-progress scrub.
	* -w Wait. Blocks until scrub has completed.
	*/
	int
	zpool_do_scrub(int argc, char **argv)
	{
	int c;
	scrub_cbdata_t cb;
	boolean_t wait = B_FALSE;
	int error;

	cb.cb_type = POOL_SCAN_SCRUB;
	cb.cb_scrub_cmd = POOL_SCRUB_NORMAL;

	/* check options */
	while ((c = getopt(argc, argv, "spw")) != -1) {
	switch (c) {
	case 's':
	cb.cb_type = POOL_SCAN_NONE;
	break;
	case 'p':
	cb.cb_scrub_cmd = POOL_SCRUB_PAUSE;
	break;
	case 'w':
	wait = B_TRUE;
	break;
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	if (cb.cb_type == POOL_SCAN_NONE &&
	cb.cb_scrub_cmd == POOL_SCRUB_PAUSE) {
	(void) fprintf(stderr, gettext("invalid option combination: "
	"-s and -p are mutually exclusive\n"));
	usage(B_FALSE);
	}

	if (wait && (cb.cb_type == POOL_SCAN_NONE \|\|
	cb.cb_scrub_cmd == POOL_SCRUB_PAUSE)) {
	(void) fprintf(stderr, gettext("invalid option combination: "
	"-w cannot be used with -p or -s\n"));
	usage(B_FALSE);
	}

	argc -= optind;
	argv += optind;

	if (argc < 1) {
	(void) fprintf(stderr, gettext("missing pool name argument\n"));
	usage(B_FALSE);
	}

	error = for_each_pool(argc, argv, B_TRUE, NULL, B_FALSE,
	scrub_callback, &cb);

	if (wait && !error) {
	zpool_wait_activity_t act = ZPOOL_WAIT_SCRUB;
	error = for_each_pool(argc, argv, B_TRUE, NULL, B_FALSE,
	wait_callback, &act);
	}

	return (error);
	}

	/*
	* zpool resilver <pool> ...
	*
	* Restarts any in-progress resilver
	*/
	int
	zpool_do_resilver(int argc, char **argv)
	{
	int c;
	scrub_cbdata_t cb;

	cb.cb_type = POOL_SCAN_RESILVER;
	cb.cb_scrub_cmd = POOL_SCRUB_NORMAL;

	/* check options */
	while ((c = getopt(argc, argv, "")) != -1) {
	switch (c) {
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	argc -= optind;
	argv += optind;

	if (argc < 1) {
	(void) fprintf(stderr, gettext("missing pool name argument\n"));
	usage(B_FALSE);
	}

	return (for_each_pool(argc, argv, B_TRUE, NULL, B_FALSE,
	scrub_callback, &cb));
	}

	/*
	* zpool trim [-d] [-r <rate>] [-c \| -s] <pool> [<device> ...]
	*
	* -c Cancel. Ends any in-progress trim.
	* -d Secure trim. Requires kernel and device support.
	* -r <rate> Sets the TRIM rate in bytes (per second). Supports
	* adding a multiplier suffix such as 'k' or 'm'.
	* -s Suspend. TRIM can then be restarted with no flags.
	* -w Wait. Blocks until trimming has completed.
	*/
	int
	zpool_do_trim(int argc, char **argv)
	{
	struct option long_options[] = {
	{"cancel", no_argument, NULL, 'c'},
	{"secure", no_argument, NULL, 'd'},
	{"rate", required_argument, NULL, 'r'},
	{"suspend", no_argument, NULL, 's'},
	{"wait", no_argument, NULL, 'w'},
	{0, 0, 0, 0}
	};

	pool_trim_func_t cmd_type = POOL_TRIM_START;
	uint64_t rate = 0;
	boolean_t secure = B_FALSE;
	boolean_t wait = B_FALSE;

	int c;
	while ((c = getopt_long(argc, argv, "cdr:sw", long_options, NULL))
	!= -1) {
	switch (c) {
	case 'c':
	if (cmd_type != POOL_TRIM_START &&
	cmd_type != POOL_TRIM_CANCEL) {
	(void) fprintf(stderr, gettext("-c cannot be "
	"combined with other options\n"));
	usage(B_FALSE);
	}
	cmd_type = POOL_TRIM_CANCEL;
	break;
	case 'd':
	if (cmd_type != POOL_TRIM_START) {
	(void) fprintf(stderr, gettext("-d cannot be "
	"combined with the -c or -s options\n"));
	usage(B_FALSE);
	}
	secure = B_TRUE;
	break;
	case 'r':
	if (cmd_type != POOL_TRIM_START) {
	(void) fprintf(stderr, gettext("-r cannot be "
	"combined with the -c or -s options\n"));
	usage(B_FALSE);
	}
	if (zfs_nicestrtonum(NULL, optarg, &rate) == -1) {
	(void) fprintf(stderr,
	gettext("invalid value for rate\n"));
	usage(B_FALSE);
	}
	break;
	case 's':
	if (cmd_type != POOL_TRIM_START &&
	cmd_type != POOL_TRIM_SUSPEND) {
	(void) fprintf(stderr, gettext("-s cannot be "
	"combined with other options\n"));
	usage(B_FALSE);
	}
	cmd_type = POOL_TRIM_SUSPEND;
	break;
	case 'w':
	wait = B_TRUE;
	break;
	case '?':
	if (optopt != 0) {
	(void) fprintf(stderr,
	gettext("invalid option '%c'\n"), optopt);
	} else {
	(void) fprintf(stderr,
	gettext("invalid option '%s'\n"),
	argv[optind - 1]);
	}
	usage(B_FALSE);
	}
	}

	argc -= optind;
	argv += optind;

	if (argc < 1) {
	(void) fprintf(stderr, gettext("missing pool name argument\n"));
	usage(B_FALSE);
	return (-1);
	}

	if (wait && (cmd_type != POOL_TRIM_START)) {
	(void) fprintf(stderr, gettext("-w cannot be used with -c or "
	"-s\n"));
	usage(B_FALSE);
	}

	char *poolname = argv[0];
	zpool_handle_t *zhp = zpool_open(g_zfs, poolname);
	if (zhp == NULL)
	return (-1);

	trimflags_t trim_flags = {
	.secure = secure,
	.rate = rate,
	.wait = wait,
	};

	nvlist_t *vdevs = fnvlist_alloc();
	if (argc == 1) {
	/* no individual leaf vdevs specified, so add them all */
	nvlist_t *config = zpool_get_config(zhp, NULL);
	nvlist_t *nvroot = fnvlist_lookup_nvlist(config,
	ZPOOL_CONFIG_VDEV_TREE);
	zpool_collect_leaves(zhp, nvroot, vdevs);
	trim_flags.fullpool = B_TRUE;
	} else {
	trim_flags.fullpool = B_FALSE;
	for (int i = 1; i < argc; i++) {
	fnvlist_add_boolean(vdevs, argv[i]);
	}
	}

	int error = zpool_trim(zhp, cmd_type, vdevs, &trim_flags);

	fnvlist_free(vdevs);
	zpool_close(zhp);

	return (error);
	}

	/*
	* Converts a total number of seconds to a human readable string broken
	* down in to days/hours/minutes/seconds.
	*/
	static void
	secs_to_dhms(uint64_t total, char *buf)
	{
	uint64_t days = total / 60 / 60 / 24;
	uint64_t hours = (total / 60 / 60) % 24;
	uint64_t mins = (total / 60) % 60;
	uint64_t secs = (total % 60);

	if (days > 0) {
	(void) sprintf(buf, "%llu days %02llu:%02llu:%02llu",
	(u_longlong_t)days, (u_longlong_t)hours,
	(u_longlong_t)mins, (u_longlong_t)secs);
	} else {
	(void) sprintf(buf, "%02llu:%02llu:%02llu",
	(u_longlong_t)hours, (u_longlong_t)mins,
	(u_longlong_t)secs);
	}
	}

	/*
	* Print out detailed scrub status.
	*/
	static void
	print_scan_scrub_resilver_status(pool_scan_stat_t *ps)
	{
	time_t start, end, pause;
	uint64_t pass_scanned, scanned, pass_issued, issued, total;
	uint64_t elapsed, scan_rate, issue_rate;
	double fraction_done;
	char processed_buf[7], scanned_buf[7], issued_buf[7], total_buf[7];
	char srate_buf[7], irate_buf[7], time_buf[32];

	printf(" ");
	printf_color(ANSI_BOLD, gettext("scan:"));
	printf(" ");

	/* If there's never been a scan, there's not much to say. */
	if (ps == NULL \|\| ps->pss_func == POOL_SCAN_NONE \|\|
	ps->pss_func >= POOL_SCAN_FUNCS) {
	(void) printf(gettext("none requested\n"));
	return;
	}

	start = ps->pss_start_time;
	end = ps->pss_end_time;
	pause = ps->pss_pass_scrub_pause;

	zfs_nicebytes(ps->pss_processed, processed_buf, sizeof (processed_buf));

	assert(ps->pss_func == POOL_SCAN_SCRUB \|\|
	ps->pss_func == POOL_SCAN_RESILVER);

	/* Scan is finished or canceled. */
	if (ps->pss_state == DSS_FINISHED) {
	secs_to_dhms(end - start, time_buf);

	if (ps->pss_func == POOL_SCAN_SCRUB) {
	(void) printf(gettext("scrub repaired %s "
	"in %s with %llu errors on %s"), processed_buf,
	time_buf, (u_longlong_t)ps->pss_errors,
	ctime(&end));
	} else if (ps->pss_func == POOL_SCAN_RESILVER) {
	(void) printf(gettext("resilvered %s "
	"in %s with %llu errors on %s"), processed_buf,
	time_buf, (u_longlong_t)ps->pss_errors,
	ctime(&end));
	}
	return;
	} else if (ps->pss_state == DSS_CANCELED) {
	if (ps->pss_func == POOL_SCAN_SCRUB) {
	(void) printf(gettext("scrub canceled on %s"),
	ctime(&end));
	} else if (ps->pss_func == POOL_SCAN_RESILVER) {
	(void) printf(gettext("resilver canceled on %s"),
	ctime(&end));
	}
	return;
	}

	assert(ps->pss_state == DSS_SCANNING);

	/* Scan is in progress. Resilvers can't be paused. */
	if (ps->pss_func == POOL_SCAN_SCRUB) {
	if (pause == 0) {
	(void) printf(gettext("scrub in progress since %s"),
	ctime(&start));
	} else {
	(void) printf(gettext("scrub paused since %s"),
	ctime(&pause));
	(void) printf(gettext("\tscrub started on %s"),
	ctime(&start));
	}
	} else if (ps->pss_func == POOL_SCAN_RESILVER) {
	(void) printf(gettext("resilver in progress since %s"),
	ctime(&start));
	}

	scanned = ps->pss_examined;
	pass_scanned = ps->pss_pass_exam;
	issued = ps->pss_issued;
	pass_issued = ps->pss_pass_issued;
	total = ps->pss_to_examine;

	/* we are only done with a block once we have issued the IO for it */
	fraction_done = (double)issued / total;

	/* elapsed time for this pass, rounding up to 1 if it's 0 */
	elapsed = time(NULL) - ps->pss_pass_start;
	elapsed -= ps->pss_pass_scrub_spent_paused;
	elapsed = (elapsed != 0) ? elapsed : 1;

	scan_rate = pass_scanned / elapsed;
	issue_rate = pass_issued / elapsed;
	uint64_t total_secs_left = (issue_rate != 0 && total >= issued) ?
	((total - issued) / issue_rate) : UINT64_MAX;
	secs_to_dhms(total_secs_left, time_buf);

	/* format all of the numbers we will be reporting */
	zfs_nicebytes(scanned, scanned_buf, sizeof (scanned_buf));
	zfs_nicebytes(issued, issued_buf, sizeof (issued_buf));
	zfs_nicebytes(total, total_buf, sizeof (total_buf));
	zfs_nicebytes(scan_rate, srate_buf, sizeof (srate_buf));
	zfs_nicebytes(issue_rate, irate_buf, sizeof (irate_buf));

	/* do not print estimated time if we have a paused scrub */
	if (pause == 0) {
	(void) printf(gettext("\t%s scanned at %s/s, "
	"%s issued at %s/s, %s total\n"),
	scanned_buf, srate_buf, issued_buf, irate_buf, total_buf);
	} else {
	(void) printf(gettext("\t%s scanned, %s issued, %s total\n"),
	scanned_buf, issued_buf, total_buf);
	}

	if (ps->pss_func == POOL_SCAN_RESILVER) {
	(void) printf(gettext("\t%s resilvered, %.2f%% done"),
	processed_buf, 100 * fraction_done);
	} else if (ps->pss_func == POOL_SCAN_SCRUB) {
	(void) printf(gettext("\t%s repaired, %.2f%% done"),
	processed_buf, 100 * fraction_done);
	}

	if (pause == 0) {
	if (total_secs_left != UINT64_MAX &&
	issue_rate >= 10 * 1024 * 1024) {
	(void) printf(gettext(", %s to go\n"), time_buf);
	} else {
	(void) printf(gettext(", no estimated "
	"completion time\n"));
	}
	} else {
	(void) printf(gettext("\n"));
	}
	}

	static void
	print_rebuild_status_impl(vdev_rebuild_stat_t vrs, char vdev_name)
	{
	if (vrs == NULL \|\| vrs->vrs_state == VDEV_REBUILD_NONE)
	return;

	printf(" ");
	printf_color(ANSI_BOLD, gettext("scan:"));
	printf(" ");

	uint64_t bytes_scanned = vrs->vrs_bytes_scanned;
	uint64_t bytes_issued = vrs->vrs_bytes_issued;
	uint64_t bytes_rebuilt = vrs->vrs_bytes_rebuilt;
	uint64_t bytes_est = vrs->vrs_bytes_est;
	uint64_t scan_rate = (vrs->vrs_pass_bytes_scanned /
	(vrs->vrs_pass_time_ms + 1)) * 1000;
	uint64_t issue_rate = (vrs->vrs_pass_bytes_issued /
	(vrs->vrs_pass_time_ms + 1)) * 1000;
	double scan_pct = MIN((double)bytes_scanned * 100 /
	(bytes_est + 1), 100);

	/* Format all of the numbers we will be reporting */
	char bytes_scanned_buf[7], bytes_issued_buf[7];
	char bytes_rebuilt_buf[7], bytes_est_buf[7];
	char scan_rate_buf[7], issue_rate_buf[7], time_buf[32];
	zfs_nicebytes(bytes_scanned, bytes_scanned_buf,
	sizeof (bytes_scanned_buf));
	zfs_nicebytes(bytes_issued, bytes_issued_buf,
	sizeof (bytes_issued_buf));
	zfs_nicebytes(bytes_rebuilt, bytes_rebuilt_buf,
	sizeof (bytes_rebuilt_buf));
	zfs_nicebytes(bytes_est, bytes_est_buf, sizeof (bytes_est_buf));
	zfs_nicebytes(scan_rate, scan_rate_buf, sizeof (scan_rate_buf));
	zfs_nicebytes(issue_rate, issue_rate_buf, sizeof (issue_rate_buf));

	time_t start = vrs->vrs_start_time;
	time_t end = vrs->vrs_end_time;

	/* Rebuild is finished or canceled. */
	if (vrs->vrs_state == VDEV_REBUILD_COMPLETE) {
	secs_to_dhms(vrs->vrs_scan_time_ms / 1000, time_buf);
	(void) printf(gettext("resilvered (%s) %s in %s "
	"with %llu errors on %s"), vdev_name, bytes_rebuilt_buf,
	time_buf, (u_longlong_t)vrs->vrs_errors, ctime(&end));
	return;
	} else if (vrs->vrs_state == VDEV_REBUILD_CANCELED) {
	(void) printf(gettext("resilver (%s) canceled on %s"),
	vdev_name, ctime(&end));
	return;
	} else if (vrs->vrs_state == VDEV_REBUILD_ACTIVE) {
	(void) printf(gettext("resilver (%s) in progress since %s"),
	vdev_name, ctime(&start));
	}

	assert(vrs->vrs_state == VDEV_REBUILD_ACTIVE);

	secs_to_dhms(MAX((int64_t)bytes_est - (int64_t)bytes_scanned, 0) /
	MAX(scan_rate, 1), time_buf);

	(void) printf(gettext("\t%s scanned at %s/s, %s issued %s/s, "
	"%s total\n"), bytes_scanned_buf, scan_rate_buf,
	bytes_issued_buf, issue_rate_buf, bytes_est_buf);
	(void) printf(gettext("\t%s resilvered, %.2f%% done"),
	bytes_rebuilt_buf, scan_pct);

	if (vrs->vrs_state == VDEV_REBUILD_ACTIVE) {
	if (scan_rate >= 10 * 1024 * 1024) {
	(void) printf(gettext(", %s to go\n"), time_buf);
	} else {
	(void) printf(gettext(", no estimated "
	"completion time\n"));
	}
	} else {
	(void) printf(gettext("\n"));
	}
	}

	/*
	* Print rebuild status for top-level vdevs.
	*/
	static void
	print_rebuild_status(zpool_handle_t zhp, nvlist_t nvroot)
	{
	nvlist_t **child;
	uint_t children;

	if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN,
	&child, &children) != 0)
	children = 0;

	for (uint_t c = 0; c < children; c++) {
	vdev_rebuild_stat_t *vrs;
	uint_t i;

	if (nvlist_lookup_uint64_array(child[c],
	ZPOOL_CONFIG_REBUILD_STATS, (uint64_t **)&vrs, &i) == 0) {
	char *name = zpool_vdev_name(g_zfs, zhp,
	child[c], VDEV_NAME_TYPE_ID);
	print_rebuild_status_impl(vrs, name);
	free(name);
	}
	}
	}

	/*
	* As we don't scrub checkpointed blocks, we want to warn the user that we
	* skipped scanning some blocks if a checkpoint exists or existed at any
	* time during the scan. If a sequential instead of healing reconstruction
	* was performed then the blocks were reconstructed. However, their checksums
	* have not been verified so we still print the warning.
	*/
	static void
	print_checkpoint_scan_warning(pool_scan_stat_t ps, pool_checkpoint_stat_t pcs)
	{
	if (ps == NULL \|\| pcs == NULL)
	return;

	if (pcs->pcs_state == CS_NONE \|\|
	pcs->pcs_state == CS_CHECKPOINT_DISCARDING)
	return;

	assert(pcs->pcs_state == CS_CHECKPOINT_EXISTS);

	if (ps->pss_state == DSS_NONE)
	return;

	if ((ps->pss_state == DSS_FINISHED \|\| ps->pss_state == DSS_CANCELED) &&
	ps->pss_end_time < pcs->pcs_start_time)
	return;

	if (ps->pss_state == DSS_FINISHED \|\| ps->pss_state == DSS_CANCELED) {
	(void) printf(gettext(" scan warning: skipped blocks "
	"that are only referenced by the checkpoint.\n"));
	} else {
	assert(ps->pss_state == DSS_SCANNING);
	(void) printf(gettext(" scan warning: skipping blocks "
	"that are only referenced by the checkpoint.\n"));
	}
	}

	/*
	* Returns B_TRUE if there is an active rebuild in progress. Otherwise,
	* B_FALSE is returned and 'rebuild_end_time' is set to the end time for
	* the last completed (or cancelled) rebuild.
	*/
	static boolean_t
	check_rebuilding(nvlist_t nvroot, uint64_t rebuild_end_time)
	{
	nvlist_t **child;
	uint_t children;
	boolean_t rebuilding = B_FALSE;
	uint64_t end_time = 0;

	if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN,
	&child, &children) != 0)
	children = 0;

	for (uint_t c = 0; c < children; c++) {
	vdev_rebuild_stat_t *vrs;
	uint_t i;

	if (nvlist_lookup_uint64_array(child[c],
	ZPOOL_CONFIG_REBUILD_STATS, (uint64_t **)&vrs, &i) == 0) {

	if (vrs->vrs_end_time > end_time)
	end_time = vrs->vrs_end_time;

	if (vrs->vrs_state == VDEV_REBUILD_ACTIVE) {
	rebuilding = B_TRUE;
	end_time = 0;
	break;
	}
	}
	}

	if (rebuild_end_time != NULL)
	*rebuild_end_time = end_time;

	return (rebuilding);
	}

	/*
	* Print the scan status.
	*/
	static void
	print_scan_status(zpool_handle_t zhp, nvlist_t nvroot)
	{
	uint64_t rebuild_end_time = 0, resilver_end_time = 0;
	boolean_t have_resilver = B_FALSE, have_scrub = B_FALSE;
	boolean_t active_resilver = B_FALSE;
	pool_checkpoint_stat_t *pcs = NULL;
	pool_scan_stat_t *ps = NULL;
	uint_t c;

	if (nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_SCAN_STATS,
	(uint64_t **)&ps, &c) == 0) {
	if (ps->pss_func == POOL_SCAN_RESILVER) {
	resilver_end_time = ps->pss_end_time;
	active_resilver = (ps->pss_state == DSS_SCANNING);
	}

	have_resilver = (ps->pss_func == POOL_SCAN_RESILVER);
	have_scrub = (ps->pss_func == POOL_SCAN_SCRUB);
	}

	boolean_t active_rebuild = check_rebuilding(nvroot, &rebuild_end_time);
	boolean_t have_rebuild = (active_rebuild \|\| (rebuild_end_time > 0));

	/* Always print the scrub status when available. */
	if (have_scrub)
	print_scan_scrub_resilver_status(ps);

	/*
	* When there is an active resilver or rebuild print its status.
	* Otherwise print the status of the last resilver or rebuild.
	*/
	if (active_resilver \|\| (!active_rebuild && have_resilver &&
	resilver_end_time && resilver_end_time > rebuild_end_time)) {
	print_scan_scrub_resilver_status(ps);
	} else if (active_rebuild \|\| (!active_resilver && have_rebuild &&
	rebuild_end_time && rebuild_end_time > resilver_end_time)) {
	print_rebuild_status(zhp, nvroot);
	}

	(void) nvlist_lookup_uint64_array(nvroot,
	ZPOOL_CONFIG_CHECKPOINT_STATS, (uint64_t **)&pcs, &c);
	print_checkpoint_scan_warning(ps, pcs);
	}

	/*
	* Print out detailed removal status.
	*/
	static void
	print_removal_status(zpool_handle_t zhp, pool_removal_stat_t prs)
	{
	char copied_buf[7], examined_buf[7], total_buf[7], rate_buf[7];
	time_t start, end;
	nvlist_t config, nvroot;
	nvlist_t **child;
	uint_t children;
	char *vdev_name;

	if (prs == NULL \|\| prs->prs_state == DSS_NONE)
	return;

	/*
	* Determine name of vdev.
	*/
	config = zpool_get_config(zhp, NULL);
	nvroot = fnvlist_lookup_nvlist(config,
	ZPOOL_CONFIG_VDEV_TREE);
	verify(nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN,
	&child, &children) == 0);
	assert(prs->prs_removing_vdev < children);
	vdev_name = zpool_vdev_name(g_zfs, zhp,
	child[prs->prs_removing_vdev], B_TRUE);

	printf_color(ANSI_BOLD, gettext("remove: "));

	start = prs->prs_start_time;
	end = prs->prs_end_time;
	zfs_nicenum(prs->prs_copied, copied_buf, sizeof (copied_buf));

	/*
	* Removal is finished or canceled.
	*/
	if (prs->prs_state == DSS_FINISHED) {
	uint64_t minutes_taken = (end - start) / 60;

	(void) printf(gettext("Removal of vdev %llu copied %s "
	"in %lluh%um, completed on %s"),
	(longlong_t)prs->prs_removing_vdev,
	copied_buf,
	(u_longlong_t)(minutes_taken / 60),
	(uint_t)(minutes_taken % 60),
	ctime((time_t *)&end));
	} else if (prs->prs_state == DSS_CANCELED) {
	(void) printf(gettext("Removal of %s canceled on %s"),
	vdev_name, ctime(&end));
	} else {
	uint64_t copied, total, elapsed, mins_left, hours_left;
	double fraction_done;
	uint_t rate;

	assert(prs->prs_state == DSS_SCANNING);

	/*
	* Removal is in progress.
	*/
	(void) printf(gettext(
	"Evacuation of %s in progress since %s"),
	vdev_name, ctime(&start));

	copied = prs->prs_copied > 0 ? prs->prs_copied : 1;
	total = prs->prs_to_copy;
	fraction_done = (double)copied / total;

	/* elapsed time for this pass */
	elapsed = time(NULL) - prs->prs_start_time;
	elapsed = elapsed > 0 ? elapsed : 1;
	rate = copied / elapsed;
	rate = rate > 0 ? rate : 1;
	mins_left = ((total - copied) / rate) / 60;
	hours_left = mins_left / 60;

	zfs_nicenum(copied, examined_buf, sizeof (examined_buf));
	zfs_nicenum(total, total_buf, sizeof (total_buf));
	zfs_nicenum(rate, rate_buf, sizeof (rate_buf));

	/*
	* do not print estimated time if hours_left is more than
	* 30 days
	*/
	(void) printf(gettext(
	"\t%s copied out of %s at %s/s, %.2f%% done"),
	examined_buf, total_buf, rate_buf, 100 * fraction_done);
	if (hours_left < (30 * 24)) {
	(void) printf(gettext(", %lluh%um to go\n"),
	(u_longlong_t)hours_left, (uint_t)(mins_left % 60));
	} else {
	(void) printf(gettext(
	", (copy is slow, no estimated time)\n"));
	}
	}
	free(vdev_name);

	if (prs->prs_mapping_memory > 0) {
	char mem_buf[7];
	zfs_nicenum(prs->prs_mapping_memory, mem_buf, sizeof (mem_buf));
	(void) printf(gettext(
	"\t%s memory used for removed device mappings\n"),
	mem_buf);
	}
	}

	static void
	print_checkpoint_status(pool_checkpoint_stat_t *pcs)
	{
	time_t start;
	char space_buf[7];

	if (pcs == NULL \|\| pcs->pcs_state == CS_NONE)
	return;

	(void) printf(gettext("checkpoint: "));

	start = pcs->pcs_start_time;
	zfs_nicenum(pcs->pcs_space, space_buf, sizeof (space_buf));

	if (pcs->pcs_state == CS_CHECKPOINT_EXISTS) {
	char *date = ctime(&start);

	/*
	* ctime() adds a newline at the end of the generated
	* string, thus the weird format specifier and the
	* strlen() call used to chop it off from the output.
	*/
	(void) printf(gettext("created %.*s, consumes %s\n"),
	(int)(strlen(date) - 1), date, space_buf);
	return;
	}

	assert(pcs->pcs_state == CS_CHECKPOINT_DISCARDING);

	(void) printf(gettext("discarding, %s remaining.\n"),
	space_buf);
	}

	static void
	print_error_log(zpool_handle_t *zhp)
	{
	nvlist_t *nverrlist = NULL;
	nvpair_t *elem;
	char *pathname;
	size_t len = MAXPATHLEN * 2;

	if (zpool_get_errlog(zhp, &nverrlist) != 0)
	return;

	(void) printf("errors: Permanent errors have been "
	"detected in the following files:\n\n");

	pathname = safe_malloc(len);
	elem = NULL;
	while ((elem = nvlist_next_nvpair(nverrlist, elem)) != NULL) {
	nvlist_t *nv;
	uint64_t dsobj, obj;

	verify(nvpair_value_nvlist(elem, &nv) == 0);
	verify(nvlist_lookup_uint64(nv, ZPOOL_ERR_DATASET,
	&dsobj) == 0);
	verify(nvlist_lookup_uint64(nv, ZPOOL_ERR_OBJECT,
	&obj) == 0);
	zpool_obj_to_path(zhp, dsobj, obj, pathname, len);
	(void) printf("%7s %s\n", "", pathname);
	}
	free(pathname);
	nvlist_free(nverrlist);
	}

	static void
	print_spares(zpool_handle_t zhp, status_cbdata_t cb, nvlist_t **spares,
	uint_t nspares)
	{
	uint_t i;
	char *name;

	if (nspares == 0)
	return;

	(void) printf(gettext("\tspares\n"));

	for (i = 0; i < nspares; i++) {
	name = zpool_vdev_name(g_zfs, zhp, spares[i],
	cb->cb_name_flags);
	print_status_config(zhp, cb, name, spares[i], 2, B_TRUE, NULL);
	free(name);
	}
	}

	static void
	print_l2cache(zpool_handle_t zhp, status_cbdata_t cb, nvlist_t **l2cache,
	uint_t nl2cache)
	{
	uint_t i;
	char *name;

	if (nl2cache == 0)
	return;

	(void) printf(gettext("\tcache\n"));

	for (i = 0; i < nl2cache; i++) {
	name = zpool_vdev_name(g_zfs, zhp, l2cache[i],
	cb->cb_name_flags);
	print_status_config(zhp, cb, name, l2cache[i], 2,
	B_FALSE, NULL);
	free(name);
	}
	}

	static void
	print_dedup_stats(nvlist_t *config)
	{
	ddt_histogram_t *ddh;
	ddt_stat_t *dds;
	ddt_object_t *ddo;
	uint_t c;
	char dspace[6], mspace[6];

	/*
	* If the pool was faulted then we may not have been able to
	* obtain the config. Otherwise, if we have anything in the dedup
	* table continue processing the stats.
	*/
	if (nvlist_lookup_uint64_array(config, ZPOOL_CONFIG_DDT_OBJ_STATS,
	(uint64_t **)&ddo, &c) != 0)
	return;

	(void) printf("\n");
	(void) printf(gettext(" dedup: "));
	if (ddo->ddo_count == 0) {
	(void) printf(gettext("no DDT entries\n"));
	return;
	}

	zfs_nicebytes(ddo->ddo_dspace, dspace, sizeof (dspace));
	zfs_nicebytes(ddo->ddo_mspace, mspace, sizeof (mspace));
	(void) printf("DDT entries %llu, size %s on disk, %s in core\n",
	(u_longlong_t)ddo->ddo_count,
	dspace,
	mspace);

	verify(nvlist_lookup_uint64_array(config, ZPOOL_CONFIG_DDT_STATS,
	(uint64_t **)&dds, &c) == 0);
	verify(nvlist_lookup_uint64_array(config, ZPOOL_CONFIG_DDT_HISTOGRAM,
	(uint64_t **)&ddh, &c) == 0);
	zpool_dump_ddt(dds, ddh);
	}

	/*
	* Display a summary of pool status. Displays a summary such as:
	*
	* pool: tank
	* status: DEGRADED
	* reason: One or more devices ...
	* see: https://openzfs.github.io/openzfs-docs/msg/ZFS-xxxx-01
	* config:
	* mirror DEGRADED
	* c1t0d0 OK
	* c2t0d0 UNAVAIL
	*
	* When given the '-v' option, we print out the complete config. If the '-e'
	* option is specified, then we print out error rate information as well.
	*/
	static int
	status_callback(zpool_handle_t zhp, void data)
	{
	status_cbdata_t *cbp = data;
	nvlist_t config, nvroot;
	char *msgid;
	zpool_status_t reason;
	zpool_errata_t errata;
	const char *health;
	uint_t c;
	vdev_stat_t *vs;

	config = zpool_get_config(zhp, NULL);
	reason = zpool_get_status(zhp, &msgid, &errata);

	cbp->cb_count++;

	/*
	* If we were given 'zpool status -x', only report those pools with
	* problems.
	*/
	if (cbp->cb_explain &&
	(reason == ZPOOL_STATUS_OK \|\|
	reason == ZPOOL_STATUS_VERSION_OLDER \|\|
	reason == ZPOOL_STATUS_FEAT_DISABLED \|\|
	- reason == ZPOOL_STATUS_COMPATIBILITY_ERR)) {
	+ reason == ZPOOL_STATUS_COMPATIBILITY_ERR \|\|
	+ reason == ZPOOL_STATUS_INCOMPATIBLE_FEAT)) {
	if (!cbp->cb_allpools) {
	(void) printf(gettext("pool '%s' is healthy\n"),
	zpool_get_name(zhp));
	if (cbp->cb_first)
	cbp->cb_first = B_FALSE;
	}
	return (0);
	}

	if (cbp->cb_first)
	cbp->cb_first = B_FALSE;
	else
	(void) printf("\n");

	nvroot = fnvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE);
	verify(nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_VDEV_STATS,
	(uint64_t **)&vs, &c) == 0);

	health = zpool_get_state_str(zhp);

	printf(" ");
	printf_color(ANSI_BOLD, gettext("pool:"));
	printf(" %s\n", zpool_get_name(zhp));
	printf(" ");
	printf_color(ANSI_BOLD, gettext("state: "));

	printf_color(health_str_to_color(health), "%s", health);

	printf("\n");

	switch (reason) {
	case ZPOOL_STATUS_MISSING_DEV_R:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("One or more devices could "
	"not be opened. Sufficient replicas exist for\n\tthe pool "
	"to continue functioning in a degraded state.\n"));
	printf_color(ANSI_BOLD, gettext("action: "));
	printf_color(ANSI_YELLOW, gettext("Attach the missing device "
	"and online it using 'zpool online'.\n"));
	break;

	case ZPOOL_STATUS_MISSING_DEV_NR:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("One or more devices could "
	"not be opened. There are insufficient\n\treplicas for the"
	" pool to continue functioning.\n"));
	printf_color(ANSI_BOLD, gettext("action: "));
	printf_color(ANSI_YELLOW, gettext("Attach the missing device "
	"and online it using 'zpool online'.\n"));
	break;

	case ZPOOL_STATUS_CORRUPT_LABEL_R:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("One or more devices could "
	"not be used because the label is missing or\n\tinvalid. "
	"Sufficient replicas exist for the pool to continue\n\t"
	"functioning in a degraded state.\n"));
	printf_color(ANSI_BOLD, gettext("action: "));
	printf_color(ANSI_YELLOW, gettext("Replace the device using "
	"'zpool replace'.\n"));
	break;

	case ZPOOL_STATUS_CORRUPT_LABEL_NR:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("One or more devices could "
	"not be used because the label is missing \n\tor invalid. "
	"There are insufficient replicas for the pool to "
	"continue\n\tfunctioning.\n"));
	zpool_explain_recover(zpool_get_handle(zhp),
	zpool_get_name(zhp), reason, config);
	break;

	case ZPOOL_STATUS_FAILING_DEV:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("One or more devices has "
	"experienced an unrecoverable error. An\n\tattempt was "
	"made to correct the error. Applications are "
	"unaffected.\n"));
	printf_color(ANSI_BOLD, gettext("action: "));
	printf_color(ANSI_YELLOW, gettext("Determine if the "
	"device needs to be replaced, and clear the errors\n\tusing"
	" 'zpool clear' or replace the device with 'zpool "
	"replace'.\n"));
	break;

	case ZPOOL_STATUS_OFFLINE_DEV:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("One or more devices has "
	"been taken offline by the administrator.\n\tSufficient "
	"replicas exist for the pool to continue functioning in "
	"a\n\tdegraded state.\n"));
	printf_color(ANSI_BOLD, gettext("action: "));
	printf_color(ANSI_YELLOW, gettext("Online the device "
	"using 'zpool online' or replace the device with\n\t'zpool "
	"replace'.\n"));
	break;

	case ZPOOL_STATUS_REMOVED_DEV:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("One or more devices has "
	"been removed by the administrator.\n\tSufficient "
	"replicas exist for the pool to continue functioning in "
	"a\n\tdegraded state.\n"));
	printf_color(ANSI_BOLD, gettext("action: "));
	printf_color(ANSI_YELLOW, gettext("Online the device "
	"using zpool online' or replace the device with\n\t'zpool "
	"replace'.\n"));
	break;

	case ZPOOL_STATUS_RESILVERING:
	case ZPOOL_STATUS_REBUILDING:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("One or more devices is "
	"currently being resilvered. The pool will\n\tcontinue "
	"to function, possibly in a degraded state.\n"));
	printf_color(ANSI_BOLD, gettext("action: "));
	printf_color(ANSI_YELLOW, gettext("Wait for the resilver to "
	"complete.\n"));
	break;

	case ZPOOL_STATUS_REBUILD_SCRUB:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("One or more devices have "
	"been sequentially resilvered, scrubbing\n\tthe pool "
	"is recommended.\n"));
	printf_color(ANSI_BOLD, gettext("action: "));
	printf_color(ANSI_YELLOW, gettext("Use 'zpool scrub' to "
	"verify all data checksums.\n"));
	break;

	case ZPOOL_STATUS_CORRUPT_DATA:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("One or more devices has "
	"experienced an error resulting in data\n\tcorruption. "
	"Applications may be affected.\n"));
	printf_color(ANSI_BOLD, gettext("action: "));
	printf_color(ANSI_YELLOW, gettext("Restore the file in question"
	" if possible. Otherwise restore the\n\tentire pool from "
	"backup.\n"));
	break;

	case ZPOOL_STATUS_CORRUPT_POOL:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("The pool metadata is "
	"corrupted and the pool cannot be opened.\n"));
	zpool_explain_recover(zpool_get_handle(zhp),
	zpool_get_name(zhp), reason, config);
	break;

	case ZPOOL_STATUS_VERSION_OLDER:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("The pool is formatted using "
	"a legacy on-disk format. The pool can\n\tstill be used, "
	"but some features are unavailable.\n"));
	printf_color(ANSI_BOLD, gettext("action: "));
	printf_color(ANSI_YELLOW, gettext("Upgrade the pool using "
	"'zpool upgrade'. Once this is done, the\n\tpool will no "
	"longer be accessible on software that does not support\n\t"
	"feature flags.\n"));
	break;

	case ZPOOL_STATUS_VERSION_NEWER:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("The pool has been upgraded "
	"to a newer, incompatible on-disk version.\n\tThe pool "
	"cannot be accessed on this system.\n"));
	printf_color(ANSI_BOLD, gettext("action: "));
	printf_color(ANSI_YELLOW, gettext("Access the pool from a "
	"system running more recent software, or\n\trestore the "
	"pool from backup.\n"));
	break;

	case ZPOOL_STATUS_FEAT_DISABLED:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("Some supported and "
	"requested features are not enabled on the pool.\n\t"
	"The pool can still be used, but some features are "
	"unavailable.\n"));
	printf_color(ANSI_BOLD, gettext("action: "));
	printf_color(ANSI_YELLOW, gettext("Enable all features using "
	"'zpool upgrade'. Once this is done,\n\tthe pool may no "
	"longer be accessible by software that does not support\n\t"
	"the features. See zpool-features(5) for details.\n"));
	break;

	case ZPOOL_STATUS_COMPATIBILITY_ERR:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("This pool has a "
	"compatibility list specified, but it could not be\n\t"
	"read/parsed at this time. The pool can still be used, "
	"but this\n\tshould be investigated.\n"));
	printf_color(ANSI_BOLD, gettext("action: "));
	printf_color(ANSI_YELLOW, gettext("Check the value of the "
	"'compatibility' property against the\n\t"
	"appropriate file in " ZPOOL_SYSCONF_COMPAT_D " or "
	ZPOOL_DATA_COMPAT_D ".\n"));
	break;

	+ case ZPOOL_STATUS_INCOMPATIBLE_FEAT:
	+ printf_color(ANSI_BOLD, gettext("status: "));
	+ printf_color(ANSI_YELLOW, gettext("One or more features "
	+ "are enabled on the pool despite not being\n\t"
	+ "requested by the 'compatibility' property.\n"));
	+ printf_color(ANSI_BOLD, gettext("action: "));
	+ printf_color(ANSI_YELLOW, gettext("Consider setting "
	+ "'compatibility' to an appropriate value, or\n\t"
	+ "adding needed features to the relevant file in\n\t"
	+ ZPOOL_SYSCONF_COMPAT_D " or " ZPOOL_DATA_COMPAT_D ".\n"));
	+ break;
	+
	case ZPOOL_STATUS_UNSUP_FEAT_READ:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("The pool cannot be accessed "
	"on this system because it uses the\n\tfollowing feature(s)"
	" not supported on this system:\n"));
	zpool_print_unsup_feat(config);
	(void) printf("\n");
	printf_color(ANSI_BOLD, gettext("action: "));
	printf_color(ANSI_YELLOW, gettext("Access the pool from a "
	"system that supports the required feature(s),\n\tor "
	"restore the pool from backup.\n"));
	break;

	case ZPOOL_STATUS_UNSUP_FEAT_WRITE:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("The pool can only be "
	"accessed in read-only mode on this system. It\n\tcannot be"
	" accessed in read-write mode because it uses the "
	"following\n\tfeature(s) not supported on this system:\n"));
	zpool_print_unsup_feat(config);
	(void) printf("\n");
	printf_color(ANSI_BOLD, gettext("action: "));
	printf_color(ANSI_YELLOW, gettext("The pool cannot be accessed "
	"in read-write mode. Import the pool with\n"
	"\t\"-o readonly=on\", access the pool from a system that "
	"supports the\n\trequired feature(s), or restore the "
	"pool from backup.\n"));
	break;

	case ZPOOL_STATUS_FAULTED_DEV_R:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("One or more devices are "
	"faulted in response to persistent errors.\n\tSufficient "
	"replicas exist for the pool to continue functioning "
	"in a\n\tdegraded state.\n"));
	printf_color(ANSI_BOLD, gettext("action: "));
	printf_color(ANSI_YELLOW, gettext("Replace the faulted device, "
	"or use 'zpool clear' to mark the device\n\trepaired.\n"));
	break;

	case ZPOOL_STATUS_FAULTED_DEV_NR:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("One or more devices are "
	"faulted in response to persistent errors. There are "
	"insufficient replicas for the pool to\n\tcontinue "
	"functioning.\n"));
	printf_color(ANSI_BOLD, gettext("action: "));
	printf_color(ANSI_YELLOW, gettext("Destroy and re-create the "
	"pool from a backup source. Manually marking the device\n"
	"\trepaired using 'zpool clear' may allow some data "
	"to be recovered.\n"));
	break;

	case ZPOOL_STATUS_IO_FAILURE_MMP:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("The pool is suspended "
	"because multihost writes failed or were delayed;\n\t"
	"another system could import the pool undetected.\n"));
	printf_color(ANSI_BOLD, gettext("action: "));
	printf_color(ANSI_YELLOW, gettext("Make sure the pool's devices"
	" are connected, then reboot your system and\n\timport the "
	"pool.\n"));
	break;

	case ZPOOL_STATUS_IO_FAILURE_WAIT:
	case ZPOOL_STATUS_IO_FAILURE_CONTINUE:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("One or more devices are "
	"faulted in response to IO failures.\n"));
	printf_color(ANSI_BOLD, gettext("action: "));
	printf_color(ANSI_YELLOW, gettext("Make sure the affected "
	"devices are connected, then run 'zpool clear'.\n"));
	break;

	case ZPOOL_STATUS_BAD_LOG:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("An intent log record "
	"could not be read.\n"
	"\tWaiting for administrator intervention to fix the "
	"faulted pool.\n"));
	printf_color(ANSI_BOLD, gettext("action: "));
	printf_color(ANSI_YELLOW, gettext("Either restore the affected "
	"device(s) and run 'zpool online',\n"
	"\tor ignore the intent log records by running "
	"'zpool clear'.\n"));
	break;

	case ZPOOL_STATUS_NON_NATIVE_ASHIFT:
	(void) printf(gettext("status: One or more devices are "
	"configured to use a non-native block size.\n"
	"\tExpect reduced performance.\n"));
	(void) printf(gettext("action: Replace affected devices with "
	"devices that support the\n\tconfigured block size, or "
	"migrate data to a properly configured\n\tpool.\n"));
	break;

	case ZPOOL_STATUS_HOSTID_MISMATCH:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("Mismatch between pool hostid"
	" and system hostid on imported pool.\n\tThis pool was "
	"previously imported into a system with a different "
	"hostid,\n\tand then was verbatim imported into this "
	"system.\n"));
	printf_color(ANSI_BOLD, gettext("action: "));
	printf_color(ANSI_YELLOW, gettext("Export this pool on all "
	"systems on which it is imported.\n"
	"\tThen import it to correct the mismatch.\n"));
	break;

	case ZPOOL_STATUS_ERRATA:
	printf_color(ANSI_BOLD, gettext("status: "));
	printf_color(ANSI_YELLOW, gettext("Errata #%d detected.\n"),
	errata);

	switch (errata) {
	case ZPOOL_ERRATA_NONE:
	break;

	case ZPOOL_ERRATA_ZOL_2094_SCRUB:
	printf_color(ANSI_BOLD, gettext("action: "));
	printf_color(ANSI_YELLOW, gettext("To correct the issue"
	" run 'zpool scrub'.\n"));
	break;

	case ZPOOL_ERRATA_ZOL_6845_ENCRYPTION:
	(void) printf(gettext("\tExisting encrypted datasets "
	"contain an on-disk incompatibility\n\twhich "
	"needs to be corrected.\n"));
	printf_color(ANSI_BOLD, gettext("action: "));
	printf_color(ANSI_YELLOW, gettext("To correct the issue"
	" backup existing encrypted datasets to new\n\t"
	"encrypted datasets and destroy the old ones. "
	"'zfs mount -o ro' can\n\tbe used to temporarily "
	"mount existing encrypted datasets readonly.\n"));
	break;

	case ZPOOL_ERRATA_ZOL_8308_ENCRYPTION:
	(void) printf(gettext("\tExisting encrypted snapshots "
	"and bookmarks contain an on-disk\n\tincompat"
	"ibility. This may cause on-disk corruption if "
	"they are used\n\twith 'zfs recv'.\n"));
	printf_color(ANSI_BOLD, gettext("action: "));
	printf_color(ANSI_YELLOW, gettext("To correct the"
	"issue, enable the bookmark_v2 feature. No "
	"additional\n\taction is needed if there are no "
	"encrypted snapshots or bookmarks.\n\tIf preserving"
	"the encrypted snapshots and bookmarks is required,"
	" use\n\ta non-raw send to backup and restore them."
	" Alternately, they may be\n\tremoved to resolve "
	"the incompatibility.\n"));
	break;

	default:
	/*
	* All errata which allow the pool to be imported
	* must contain an action message.
	*/
	assert(0);
	}
	break;

	default:
	/*
	* The remaining errors can't actually be generated, yet.
	*/
	assert(reason == ZPOOL_STATUS_OK);
	}

	if (msgid != NULL) {
	printf(" ");
	printf_color(ANSI_BOLD, gettext("see:"));
	printf(gettext(
	" https://openzfs.github.io/openzfs-docs/msg/%s\n"),
	msgid);
	}

	if (config != NULL) {
	uint64_t nerr;
	nvlist_t spares, l2cache;
	uint_t nspares, nl2cache;
	pool_checkpoint_stat_t *pcs = NULL;
	pool_removal_stat_t *prs = NULL;

	print_scan_status(zhp, nvroot);

	(void) nvlist_lookup_uint64_array(nvroot,
	ZPOOL_CONFIG_REMOVAL_STATS, (uint64_t **)&prs, &c);
	print_removal_status(zhp, prs);

	(void) nvlist_lookup_uint64_array(nvroot,
	ZPOOL_CONFIG_CHECKPOINT_STATS, (uint64_t **)&pcs, &c);
	print_checkpoint_status(pcs);

	cbp->cb_namewidth = max_width(zhp, nvroot, 0, 0,
	cbp->cb_name_flags \| VDEV_NAME_TYPE_ID);
	if (cbp->cb_namewidth < 10)
	cbp->cb_namewidth = 10;

	color_start(ANSI_BOLD);
	(void) printf(gettext("config:\n\n"));
	(void) printf(gettext("\t%-*s %-8s %5s %5s %5s"),
	cbp->cb_namewidth, "NAME", "STATE", "READ", "WRITE",
	"CKSUM");
	color_end();

	if (cbp->cb_print_slow_ios) {
	printf_color(ANSI_BOLD, " %5s", gettext("SLOW"));
	}

	if (cbp->vcdl != NULL)
	print_cmd_columns(cbp->vcdl, 0);

	printf("\n");

	print_status_config(zhp, cbp, zpool_get_name(zhp), nvroot, 0,
	B_FALSE, NULL);

	print_class_vdevs(zhp, cbp, nvroot, VDEV_ALLOC_BIAS_DEDUP);
	print_class_vdevs(zhp, cbp, nvroot, VDEV_ALLOC_BIAS_SPECIAL);
	print_class_vdevs(zhp, cbp, nvroot, VDEV_ALLOC_CLASS_LOGS);

	if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE,
	&l2cache, &nl2cache) == 0)
	print_l2cache(zhp, cbp, l2cache, nl2cache);

	if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES,
	&spares, &nspares) == 0)
	print_spares(zhp, cbp, spares, nspares);

	if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_ERRCOUNT,
	&nerr) == 0) {
	nvlist_t *nverrlist = NULL;

	/*
	* If the approximate error count is small, get a
	* precise count by fetching the entire log and
	* uniquifying the results.
	*/
	if (nerr > 0 && nerr < 100 && !cbp->cb_verbose &&
	zpool_get_errlog(zhp, &nverrlist) == 0) {
	nvpair_t *elem;

	elem = NULL;
	nerr = 0;
	while ((elem = nvlist_next_nvpair(nverrlist,
	elem)) != NULL) {
	nerr++;
	}
	}
	nvlist_free(nverrlist);

	(void) printf("\n");

	if (nerr == 0)
	(void) printf(gettext("errors: No known data "
	"errors\n"));
	else if (!cbp->cb_verbose)
	(void) printf(gettext("errors: %llu data "
	"errors, use '-v' for a list\n"),
	(u_longlong_t)nerr);
	else
	print_error_log(zhp);
	}

	if (cbp->cb_dedup_stats)
	print_dedup_stats(config);
	} else {
	(void) printf(gettext("config: The configuration cannot be "
	"determined.\n"));
	}

	return (0);
	}

	/*
	* zpool status [-c [script1,script2,...]] [-igLpPstvx] [-T d\|u] [pool] ...
	* [interval [count]]
	*
	* -c CMD For each vdev, run command CMD
	* -i Display vdev initialization status.
	* -g Display guid for individual vdev name.
	* -L Follow links when resolving vdev path name.
	* -p Display values in parsable (exact) format.
	* -P Display full path for vdev name.
	* -s Display slow IOs column.
	* -v Display complete error logs
	* -x Display only pools with potential problems
	* -D Display dedup status (undocumented)
	* -t Display vdev TRIM status.
	* -T Display a timestamp in date(1) or Unix format
	*
	* Describes the health status of all pools or some subset.
	*/
	int
	zpool_do_status(int argc, char **argv)
	{
	int c;
	int ret;
	float interval = 0;
	unsigned long count = 0;
	status_cbdata_t cb = { 0 };
	char *cmd = NULL;

	/* check options */
	while ((c = getopt(argc, argv, "c:igLpPsvxDtT:")) != -1) {
	switch (c) {
	case 'c':
	if (cmd != NULL) {
	fprintf(stderr,
	gettext("Can't set -c flag twice\n"));
	exit(1);
	}

	if (getenv("ZPOOL_SCRIPTS_ENABLED") != NULL &&
	!libzfs_envvar_is_set("ZPOOL_SCRIPTS_ENABLED")) {
	fprintf(stderr, gettext(
	"Can't run -c, disabled by "
	"ZPOOL_SCRIPTS_ENABLED.\n"));
	exit(1);
	}

	if ((getuid() <= 0 \|\| geteuid() <= 0) &&
	!libzfs_envvar_is_set("ZPOOL_SCRIPTS_AS_ROOT")) {
	fprintf(stderr, gettext(
	"Can't run -c with root privileges "
	"unless ZPOOL_SCRIPTS_AS_ROOT is set.\n"));
	exit(1);
	}
	cmd = optarg;
	break;
	case 'i':
	cb.cb_print_vdev_init = B_TRUE;
	break;
	case 'g':
	cb.cb_name_flags \|= VDEV_NAME_GUID;
	break;
	case 'L':
	cb.cb_name_flags \|= VDEV_NAME_FOLLOW_LINKS;
	break;
	case 'p':
	cb.cb_literal = B_TRUE;
	break;
	case 'P':
	cb.cb_name_flags \|= VDEV_NAME_PATH;
	break;
	case 's':
	cb.cb_print_slow_ios = B_TRUE;
	break;
	case 'v':
	cb.cb_verbose = B_TRUE;
	break;
	case 'x':
	cb.cb_explain = B_TRUE;
	break;
	case 'D':
	cb.cb_dedup_stats = B_TRUE;
	break;
	case 't':
	cb.cb_print_vdev_trim = B_TRUE;
	break;
	case 'T':
	get_timestamp_arg(*optarg);
	break;
	case '?':
	if (optopt == 'c') {
	print_zpool_script_list("status");
	exit(0);
	} else {
	fprintf(stderr,
	gettext("invalid option '%c'\n"), optopt);
	}
	usage(B_FALSE);
	}
	}

	argc -= optind;
	argv += optind;

	get_interval_count(&argc, argv, &interval, &count);

	if (argc == 0)
	cb.cb_allpools = B_TRUE;

	cb.cb_first = B_TRUE;
	cb.cb_print_status = B_TRUE;

	for (;;) {
	if (timestamp_fmt != NODATE)
	print_timestamp(timestamp_fmt);

	if (cmd != NULL)
	cb.vcdl = all_pools_for_each_vdev_run(argc, argv, cmd,
	NULL, NULL, 0, 0);

	ret = for_each_pool(argc, argv, B_TRUE, NULL, cb.cb_literal,
	status_callback, &cb);

	if (cb.vcdl != NULL)
	free_vdev_cmd_data_list(cb.vcdl);

	if (argc == 0 && cb.cb_count == 0)
	(void) fprintf(stderr, gettext("no pools available\n"));
	else if (cb.cb_explain && cb.cb_first && cb.cb_allpools)
	(void) printf(gettext("all pools are healthy\n"));

	if (ret != 0)
	return (ret);

	if (interval == 0)
	break;

	if (count != 0 && --count == 0)
	break;

	(void) fsleep(interval);
	}

	return (0);
	}

	typedef struct upgrade_cbdata {
	int cb_first;
	int cb_argc;
	uint64_t cb_version;
	char **cb_argv;
	} upgrade_cbdata_t;

	static int
	check_unsupp_fs(zfs_handle_t zhp, void unsupp_fs)
	{
	int zfs_version = (int)zfs_prop_get_int(zhp, ZFS_PROP_VERSION);
	int count = (int )unsupp_fs;

	if (zfs_version > ZPL_VERSION) {
	(void) printf(gettext("%s (v%d) is not supported by this "
	"implementation of ZFS.\n"),
	zfs_get_name(zhp), zfs_version);
	(*count)++;
	}

	zfs_iter_filesystems(zhp, check_unsupp_fs, unsupp_fs);

	zfs_close(zhp);

	return (0);
	}

	static int
	upgrade_version(zpool_handle_t *zhp, uint64_t version)
	{
	int ret;
	nvlist_t *config;
	uint64_t oldversion;
	int unsupp_fs = 0;

	config = zpool_get_config(zhp, NULL);
	verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION,
	&oldversion) == 0);

	+ char compat[ZFS_MAXPROPLEN];
	+ if (zpool_get_prop(zhp, ZPOOL_PROP_COMPATIBILITY, compat,
	+ ZFS_MAXPROPLEN, NULL, B_FALSE) != 0)
	+ compat[0] = '\0';
	+
	assert(SPA_VERSION_IS_SUPPORTED(oldversion));
	assert(oldversion < version);

	ret = zfs_iter_root(zpool_get_handle(zhp), check_unsupp_fs, &unsupp_fs);
	if (ret != 0)
	return (ret);

	if (unsupp_fs) {
	(void) fprintf(stderr, gettext("Upgrade not performed due "
	"to %d unsupported filesystems (max v%d).\n"),
	unsupp_fs, (int)ZPL_VERSION);
	return (1);
	}

	+ if (strcmp(compat, ZPOOL_COMPAT_LEGACY) == 0) {
	+ (void) fprintf(stderr, gettext("Upgrade not performed because "
	+ "'compatibility' property set to '"
	+ ZPOOL_COMPAT_LEGACY "'.\n"));
	+ return (1);
	+ }
	+
	ret = zpool_upgrade(zhp, version);
	if (ret != 0)
	return (ret);

	if (version >= SPA_VERSION_FEATURES) {
	(void) printf(gettext("Successfully upgraded "
	"'%s' from version %llu to feature flags.\n"),
	zpool_get_name(zhp), (u_longlong_t)oldversion);
	} else {
	(void) printf(gettext("Successfully upgraded "
	"'%s' from version %llu to version %llu.\n"),
	zpool_get_name(zhp), (u_longlong_t)oldversion,
	(u_longlong_t)version);
	}

	return (0);
	}

	static int
	upgrade_enable_all(zpool_handle_t zhp, int countp)
	{
	int i, ret, count;
	boolean_t firstff = B_TRUE;
	nvlist_t *enabled = zpool_get_features(zhp);

	char compat[ZFS_MAXPROPLEN];
	if (zpool_get_prop(zhp, ZPOOL_PROP_COMPATIBILITY, compat,
	ZFS_MAXPROPLEN, NULL, B_FALSE) != 0)
	compat[0] = '\0';

	boolean_t requested_features[SPA_FEATURES];
	if (zpool_do_load_compat(compat, requested_features) !=
	ZPOOL_COMPATIBILITY_OK)
	return (-1);

	count = 0;
	for (i = 0; i < SPA_FEATURES; i++) {
	const char *fname = spa_feature_table[i].fi_uname;
	const char *fguid = spa_feature_table[i].fi_guid;

	if (!spa_feature_table[i].fi_zfs_mod_supported)
	continue;

	if (!nvlist_exists(enabled, fguid) && requested_features[i]) {
	char *propname;
	verify(-1 != asprintf(&propname, "feature@%s", fname));
	ret = zpool_set_prop(zhp, propname,
	ZFS_FEATURE_ENABLED);
	if (ret != 0) {
	free(propname);
	return (ret);
	}
	count++;

	if (firstff) {
	(void) printf(gettext("Enabled the "
	"following features on '%s':\n"),
	zpool_get_name(zhp));
	firstff = B_FALSE;
	}
	(void) printf(gettext(" %s\n"), fname);
	free(propname);
	}
	}

	if (countp != NULL)
	*countp = count;
	return (0);
	}

	static int
	upgrade_cb(zpool_handle_t zhp, void arg)
	{
	upgrade_cbdata_t *cbp = arg;
	nvlist_t *config;
	uint64_t version;
	boolean_t printnl = B_FALSE;
	int ret;

	config = zpool_get_config(zhp, NULL);
	verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION,
	&version) == 0);

	assert(SPA_VERSION_IS_SUPPORTED(version));

	if (version < cbp->cb_version) {
	cbp->cb_first = B_FALSE;
	ret = upgrade_version(zhp, cbp->cb_version);
	if (ret != 0)
	return (ret);
	printnl = B_TRUE;

	/*
	* If they did "zpool upgrade -a", then we could
	* be doing ioctls to different pools. We need
	* to log this history once to each pool, and bypass
	* the normal history logging that happens in main().
	*/
	(void) zpool_log_history(g_zfs, history_str);
	log_history = B_FALSE;
	}

	if (cbp->cb_version >= SPA_VERSION_FEATURES) {
	int count;
	ret = upgrade_enable_all(zhp, &count);
	if (ret != 0)
	return (ret);

	if (count > 0) {
	cbp->cb_first = B_FALSE;
	printnl = B_TRUE;
	}
	}

	if (printnl) {
	(void) printf(gettext("\n"));
	}

	return (0);
	}

	static int
	upgrade_list_older_cb(zpool_handle_t zhp, void arg)
	{
	upgrade_cbdata_t *cbp = arg;
	nvlist_t *config;
	uint64_t version;

	config = zpool_get_config(zhp, NULL);
	verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION,
	&version) == 0);

	assert(SPA_VERSION_IS_SUPPORTED(version));

	if (version < SPA_VERSION_FEATURES) {
	if (cbp->cb_first) {
	(void) printf(gettext("The following pools are "
	"formatted with legacy version numbers and can\n"
	"be upgraded to use feature flags. After "
	"being upgraded, these pools\nwill no "
	"longer be accessible by software that does not "
	- "support feature\nflags.\n\n"));
	+ "support feature\nflags.\n\n"
	+ "Note that setting a pool's 'compatibility' "
	+ "feature to '" ZPOOL_COMPAT_LEGACY "' will\n"
	+ "inhibit upgrades.\n\n"));
	(void) printf(gettext("VER POOL\n"));
	(void) printf(gettext("--- ------------\n"));
	cbp->cb_first = B_FALSE;
	}

	(void) printf("%2llu %s\n", (u_longlong_t)version,
	zpool_get_name(zhp));
	}

	return (0);
	}

	static int
	upgrade_list_disabled_cb(zpool_handle_t zhp, void arg)
	{
	upgrade_cbdata_t *cbp = arg;
	nvlist_t *config;
	uint64_t version;

	config = zpool_get_config(zhp, NULL);
	verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION,
	&version) == 0);

	if (version >= SPA_VERSION_FEATURES) {
	int i;
	boolean_t poolfirst = B_TRUE;
	nvlist_t *enabled = zpool_get_features(zhp);

	for (i = 0; i < SPA_FEATURES; i++) {
	const char *fguid = spa_feature_table[i].fi_guid;
	const char *fname = spa_feature_table[i].fi_uname;

	if (!spa_feature_table[i].fi_zfs_mod_supported)
	continue;

	if (!nvlist_exists(enabled, fguid)) {
	if (cbp->cb_first) {
	(void) printf(gettext("\nSome "
	"supported features are not "
	"enabled on the following pools. "
	"Once a\nfeature is enabled the "
	"pool may become incompatible with "
	"software\nthat does not support "
	"the feature. See "
	"zpool-features(5) for "
	- "details.\n\n"));
	+ "details.\n\n"
	+ "Note that the pool "
	+ "'compatibility' feature can be "
	+ "used to inhibit\nfeature "
	+ "upgrades.\n\n"));
	(void) printf(gettext("POOL "
	"FEATURE\n"));
	(void) printf(gettext("------"
	"---------\n"));
	cbp->cb_first = B_FALSE;
	}

	if (poolfirst) {
	(void) printf(gettext("%s\n"),
	zpool_get_name(zhp));
	poolfirst = B_FALSE;
	}

	(void) printf(gettext(" %s\n"), fname);
	}
	/*
	* If they did "zpool upgrade -a", then we could
	* be doing ioctls to different pools. We need
	* to log this history once to each pool, and bypass
	* the normal history logging that happens in main().
	*/
	(void) zpool_log_history(g_zfs, history_str);
	log_history = B_FALSE;
	}
	}

	return (0);
	}

	/* ARGSUSED */
	static int
	upgrade_one(zpool_handle_t zhp, void data)
	{
	boolean_t printnl = B_FALSE;
	upgrade_cbdata_t *cbp = data;
	uint64_t cur_version;
	int ret;

	if (strcmp("log", zpool_get_name(zhp)) == 0) {
	(void) fprintf(stderr, gettext("'log' is now a reserved word\n"
	"Pool 'log' must be renamed using export and import"
	" to upgrade.\n"));
	return (1);
	}

	cur_version = zpool_get_prop_int(zhp, ZPOOL_PROP_VERSION, NULL);
	if (cur_version > cbp->cb_version) {
	(void) printf(gettext("Pool '%s' is already formatted "
	"using more current version '%llu'.\n\n"),
	zpool_get_name(zhp), (u_longlong_t)cur_version);
	return (0);
	}

	if (cbp->cb_version != SPA_VERSION && cur_version == cbp->cb_version) {
	(void) printf(gettext("Pool '%s' is already formatted "
	"using version %llu.\n\n"), zpool_get_name(zhp),
	(u_longlong_t)cbp->cb_version);
	return (0);
	}

	if (cur_version != cbp->cb_version) {
	printnl = B_TRUE;
	ret = upgrade_version(zhp, cbp->cb_version);
	if (ret != 0)
	return (ret);
	}

	if (cbp->cb_version >= SPA_VERSION_FEATURES) {
	int count = 0;
	ret = upgrade_enable_all(zhp, &count);
	if (ret != 0)
	return (ret);

	if (count != 0) {
	printnl = B_TRUE;
	} else if (cur_version == SPA_VERSION) {
	(void) printf(gettext("Pool '%s' already has all "
	"supported and requested features enabled.\n"),
	zpool_get_name(zhp));
	}
	}

	if (printnl) {
	(void) printf(gettext("\n"));
	}

	return (0);
	}

	/*
	* zpool upgrade
	* zpool upgrade -v
	* zpool upgrade [-V version] <-a \| pool ...>
	*
	* With no arguments, display downrev'd ZFS pool available for upgrade.
	* Individual pools can be upgraded by specifying the pool, and '-a' will
	* upgrade all pools.
	*/
	int
	zpool_do_upgrade(int argc, char **argv)
	{
	int c;
	upgrade_cbdata_t cb = { 0 };
	int ret = 0;
	boolean_t showversions = B_FALSE;
	boolean_t upgradeall = B_FALSE;
	char *end;


	/* check options */
	while ((c = getopt(argc, argv, ":avV:")) != -1) {
	switch (c) {
	case 'a':
	upgradeall = B_TRUE;
	break;
	case 'v':
	showversions = B_TRUE;
	break;
	case 'V':
	cb.cb_version = strtoll(optarg, &end, 10);
	if (*end != '\0' \|\|
	!SPA_VERSION_IS_SUPPORTED(cb.cb_version)) {
	(void) fprintf(stderr,
	gettext("invalid version '%s'\n"), optarg);
	usage(B_FALSE);
	}
	break;
	case ':':
	(void) fprintf(stderr, gettext("missing argument for "
	"'%c' option\n"), optopt);
	usage(B_FALSE);
	break;
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	cb.cb_argc = argc;
	cb.cb_argv = argv;
	argc -= optind;
	argv += optind;

	if (cb.cb_version == 0) {
	cb.cb_version = SPA_VERSION;
	} else if (!upgradeall && argc == 0) {
	(void) fprintf(stderr, gettext("-V option is "
	"incompatible with other arguments\n"));
	usage(B_FALSE);
	}

	if (showversions) {
	if (upgradeall \|\| argc != 0) {
	(void) fprintf(stderr, gettext("-v option is "
	"incompatible with other arguments\n"));
	usage(B_FALSE);
	}
	} else if (upgradeall) {
	if (argc != 0) {
	(void) fprintf(stderr, gettext("-a option should not "
	"be used along with a pool name\n"));
	usage(B_FALSE);
	}
	}

	(void) printf(gettext("This system supports ZFS pool feature "
	"flags.\n\n"));
	if (showversions) {
	int i;

	(void) printf(gettext("The following features are "
	"supported:\n\n"));
	(void) printf(gettext("FEAT DESCRIPTION\n"));
	(void) printf("----------------------------------------------"
	"---------------\n");
	for (i = 0; i < SPA_FEATURES; i++) {
	zfeature_info_t *fi = &spa_feature_table[i];
	if (!fi->fi_zfs_mod_supported)
	continue;
	const char *ro =
	(fi->fi_flags & ZFEATURE_FLAG_READONLY_COMPAT) ?
	" (read-only compatible)" : "";

	(void) printf("%-37s%s\n", fi->fi_uname, ro);
	(void) printf(" %s\n", fi->fi_desc);
	}
	(void) printf("\n");

	(void) printf(gettext("The following legacy versions are also "
	"supported:\n\n"));
	(void) printf(gettext("VER DESCRIPTION\n"));
	(void) printf("--- -----------------------------------------"
	"---------------\n");
	(void) printf(gettext(" 1 Initial ZFS version\n"));
	(void) printf(gettext(" 2 Ditto blocks "
	"(replicated metadata)\n"));
	(void) printf(gettext(" 3 Hot spares and double parity "
	"RAID-Z\n"));
	(void) printf(gettext(" 4 zpool history\n"));
	(void) printf(gettext(" 5 Compression using the gzip "
	"algorithm\n"));
	(void) printf(gettext(" 6 bootfs pool property\n"));
	(void) printf(gettext(" 7 Separate intent log devices\n"));
	(void) printf(gettext(" 8 Delegated administration\n"));
	(void) printf(gettext(" 9 refquota and refreservation "
	"properties\n"));
	(void) printf(gettext(" 10 Cache devices\n"));
	(void) printf(gettext(" 11 Improved scrub performance\n"));
	(void) printf(gettext(" 12 Snapshot properties\n"));
	(void) printf(gettext(" 13 snapused property\n"));
	(void) printf(gettext(" 14 passthrough-x aclinherit\n"));
	(void) printf(gettext(" 15 user/group space accounting\n"));
	(void) printf(gettext(" 16 stmf property support\n"));
	(void) printf(gettext(" 17 Triple-parity RAID-Z\n"));
	(void) printf(gettext(" 18 Snapshot user holds\n"));
	(void) printf(gettext(" 19 Log device removal\n"));
	(void) printf(gettext(" 20 Compression using zle "
	"(zero-length encoding)\n"));
	(void) printf(gettext(" 21 Deduplication\n"));
	(void) printf(gettext(" 22 Received properties\n"));
	(void) printf(gettext(" 23 Slim ZIL\n"));
	(void) printf(gettext(" 24 System attributes\n"));
	(void) printf(gettext(" 25 Improved scrub stats\n"));
	(void) printf(gettext(" 26 Improved snapshot deletion "
	"performance\n"));
	(void) printf(gettext(" 27 Improved snapshot creation "
	"performance\n"));
	(void) printf(gettext(" 28 Multiple vdev replacements\n"));
	(void) printf(gettext("\nFor more information on a particular "
	"version, including supported releases,\n"));
	(void) printf(gettext("see the ZFS Administration Guide.\n\n"));
	} else if (argc == 0 && upgradeall) {
	cb.cb_first = B_TRUE;
	ret = zpool_iter(g_zfs, upgrade_cb, &cb);
	if (ret == 0 && cb.cb_first) {
	if (cb.cb_version == SPA_VERSION) {
	(void) printf(gettext("All pools are already "
	"formatted using feature flags.\n\n"));
	(void) printf(gettext("Every feature flags "
	"pool already has all supported and "
	"requested features enabled.\n"));
	} else {
	(void) printf(gettext("All pools are already "
	"formatted with version %llu or higher.\n"),
	(u_longlong_t)cb.cb_version);
	}
	}
	} else if (argc == 0) {
	cb.cb_first = B_TRUE;
	ret = zpool_iter(g_zfs, upgrade_list_older_cb, &cb);
	assert(ret == 0);

	if (cb.cb_first) {
	(void) printf(gettext("All pools are formatted "
	"using feature flags.\n\n"));
	} else {
	(void) printf(gettext("\nUse 'zpool upgrade -v' "
	"for a list of available legacy versions.\n"));
	}

	cb.cb_first = B_TRUE;
	ret = zpool_iter(g_zfs, upgrade_list_disabled_cb, &cb);
	assert(ret == 0);

	if (cb.cb_first) {
	(void) printf(gettext("Every feature flags pool has "
	"all supported and requested features enabled.\n"));
	} else {
	(void) printf(gettext("\n"));
	}
	} else {
	ret = for_each_pool(argc, argv, B_FALSE, NULL, B_FALSE,
	upgrade_one, &cb);
	}

	return (ret);
	}

	typedef struct hist_cbdata {
	boolean_t first;
	boolean_t longfmt;
	boolean_t internal;
	} hist_cbdata_t;

	static void
	print_history_records(nvlist_t nvhis, hist_cbdata_t cb)
	{
	nvlist_t **records;
	uint_t numrecords;
	int i;

	verify(nvlist_lookup_nvlist_array(nvhis, ZPOOL_HIST_RECORD,
	&records, &numrecords) == 0);
	for (i = 0; i < numrecords; i++) {
	nvlist_t *rec = records[i];
	char tbuf[64] = "";

	if (nvlist_exists(rec, ZPOOL_HIST_TIME)) {
	time_t tsec;
	struct tm t;

	tsec = fnvlist_lookup_uint64(records[i],
	ZPOOL_HIST_TIME);
	(void) localtime_r(&tsec, &t);
	(void) strftime(tbuf, sizeof (tbuf), "%F.%T", &t);
	}

	if (nvlist_exists(rec, ZPOOL_HIST_ELAPSED_NS)) {
	uint64_t elapsed_ns = fnvlist_lookup_int64(records[i],
	ZPOOL_HIST_ELAPSED_NS);
	(void) snprintf(tbuf + strlen(tbuf),
	sizeof (tbuf) - strlen(tbuf),
	" (%lldms)", (long long)elapsed_ns / 1000 / 1000);
	}

	if (nvlist_exists(rec, ZPOOL_HIST_CMD)) {
	(void) printf("%s %s", tbuf,
	fnvlist_lookup_string(rec, ZPOOL_HIST_CMD));
	} else if (nvlist_exists(rec, ZPOOL_HIST_INT_EVENT)) {
	int ievent =
	fnvlist_lookup_uint64(rec, ZPOOL_HIST_INT_EVENT);
	if (!cb->internal)
	continue;
	if (ievent >= ZFS_NUM_LEGACY_HISTORY_EVENTS) {
	(void) printf("%s unrecognized record:\n",
	tbuf);
	dump_nvlist(rec, 4);
	continue;
	}
	(void) printf("%s [internal %s txg:%lld] %s", tbuf,
	zfs_history_event_names[ievent],
	(longlong_t)fnvlist_lookup_uint64(
	rec, ZPOOL_HIST_TXG),
	fnvlist_lookup_string(rec, ZPOOL_HIST_INT_STR));
	} else if (nvlist_exists(rec, ZPOOL_HIST_INT_NAME)) {
	if (!cb->internal)
	continue;
	(void) printf("%s [txg:%lld] %s", tbuf,
	(longlong_t)fnvlist_lookup_uint64(
	rec, ZPOOL_HIST_TXG),
	fnvlist_lookup_string(rec, ZPOOL_HIST_INT_NAME));
	if (nvlist_exists(rec, ZPOOL_HIST_DSNAME)) {
	(void) printf(" %s (%llu)",
	fnvlist_lookup_string(rec,
	ZPOOL_HIST_DSNAME),
	(u_longlong_t)fnvlist_lookup_uint64(rec,
	ZPOOL_HIST_DSID));
	}
	(void) printf(" %s", fnvlist_lookup_string(rec,
	ZPOOL_HIST_INT_STR));
	} else if (nvlist_exists(rec, ZPOOL_HIST_IOCTL)) {
	if (!cb->internal)
	continue;
	(void) printf("%s ioctl %s\n", tbuf,
	fnvlist_lookup_string(rec, ZPOOL_HIST_IOCTL));
	if (nvlist_exists(rec, ZPOOL_HIST_INPUT_NVL)) {
	(void) printf(" input:\n");
	dump_nvlist(fnvlist_lookup_nvlist(rec,
	ZPOOL_HIST_INPUT_NVL), 8);
	}
	if (nvlist_exists(rec, ZPOOL_HIST_OUTPUT_NVL)) {
	(void) printf(" output:\n");
	dump_nvlist(fnvlist_lookup_nvlist(rec,
	ZPOOL_HIST_OUTPUT_NVL), 8);
	}
	if (nvlist_exists(rec, ZPOOL_HIST_OUTPUT_SIZE)) {
	(void) printf(" output nvlist omitted; "
	"original size: %lldKB\n",
	(longlong_t)fnvlist_lookup_int64(rec,
	ZPOOL_HIST_OUTPUT_SIZE) / 1024);
	}
	if (nvlist_exists(rec, ZPOOL_HIST_ERRNO)) {
	(void) printf(" errno: %lld\n",
	(longlong_t)fnvlist_lookup_int64(rec,
	ZPOOL_HIST_ERRNO));
	}
	} else {
	if (!cb->internal)
	continue;
	(void) printf("%s unrecognized record:\n", tbuf);
	dump_nvlist(rec, 4);
	}

	if (!cb->longfmt) {
	(void) printf("\n");
	continue;
	}
	(void) printf(" [");
	if (nvlist_exists(rec, ZPOOL_HIST_WHO)) {
	uid_t who = fnvlist_lookup_uint64(rec, ZPOOL_HIST_WHO);
	struct passwd *pwd = getpwuid(who);
	(void) printf("user %d ", (int)who);
	if (pwd != NULL)
	(void) printf("(%s) ", pwd->pw_name);
	}
	if (nvlist_exists(rec, ZPOOL_HIST_HOST)) {
	(void) printf("on %s",
	fnvlist_lookup_string(rec, ZPOOL_HIST_HOST));
	}
	if (nvlist_exists(rec, ZPOOL_HIST_ZONE)) {
	(void) printf(":%s",
	fnvlist_lookup_string(rec, ZPOOL_HIST_ZONE));
	}

	(void) printf("]");
	(void) printf("\n");
	}
	}

	/*
	* Print out the command history for a specific pool.
	*/
	static int
	get_history_one(zpool_handle_t zhp, void data)
	{
	nvlist_t *nvhis;
	int ret;
	hist_cbdata_t cb = (hist_cbdata_t )data;
	uint64_t off = 0;
	boolean_t eof = B_FALSE;

	cb->first = B_FALSE;

	(void) printf(gettext("History for '%s':\n"), zpool_get_name(zhp));

	while (!eof) {
	if ((ret = zpool_get_history(zhp, &nvhis, &off, &eof)) != 0)
	return (ret);

	print_history_records(nvhis, cb);
	nvlist_free(nvhis);
	}
	(void) printf("\n");

	return (ret);
	}

	/*
	* zpool history <pool>
	*
	* Displays the history of commands that modified pools.
	*/
	int
	zpool_do_history(int argc, char **argv)
	{
	hist_cbdata_t cbdata = { 0 };
	int ret;
	int c;

	cbdata.first = B_TRUE;
	/* check options */
	while ((c = getopt(argc, argv, "li")) != -1) {
	switch (c) {
	case 'l':
	cbdata.longfmt = B_TRUE;
	break;
	case 'i':
	cbdata.internal = B_TRUE;
	break;
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}
	argc -= optind;
	argv += optind;

	ret = for_each_pool(argc, argv, B_FALSE, NULL, B_FALSE, get_history_one,
	&cbdata);

	if (argc == 0 && cbdata.first == B_TRUE) {
	(void) fprintf(stderr, gettext("no pools available\n"));
	return (0);
	}

	return (ret);
	}

	typedef struct ev_opts {
	int verbose;
	int scripted;
	int follow;
	int clear;
	char poolname[ZFS_MAX_DATASET_NAME_LEN];
	} ev_opts_t;

	static void
	zpool_do_events_short(nvlist_t nvl, ev_opts_t opts)
	{
	char ctime_str[26], str[32], *ptr;
	int64_t *tv;
	uint_t n;

	verify(nvlist_lookup_int64_array(nvl, FM_EREPORT_TIME, &tv, &n) == 0);
	memset(str, ' ', 32);
	(void) ctime_r((const time_t *)&tv[0], ctime_str);
	(void) memcpy(str, ctime_str+4, 6); /* 'Jun 30' */
	(void) memcpy(str+7, ctime_str+20, 4); /* '1993' */
	(void) memcpy(str+12, ctime_str+11, 8); /* '21:49:08' */
	(void) sprintf(str+20, ".%09lld", (longlong_t)tv[1]); /* '.123456789' */
	if (opts->scripted)
	(void) printf(gettext("%s\t"), str);
	else
	(void) printf(gettext("%s "), str);

	verify(nvlist_lookup_string(nvl, FM_CLASS, &ptr) == 0);
	(void) printf(gettext("%s\n"), ptr);
	}

	static void
	zpool_do_events_nvprint(nvlist_t *nvl, int depth)
	{
	nvpair_t *nvp;

	for (nvp = nvlist_next_nvpair(nvl, NULL);
	nvp != NULL; nvp = nvlist_next_nvpair(nvl, nvp)) {

	data_type_t type = nvpair_type(nvp);
	const char *name = nvpair_name(nvp);

	boolean_t b;
	uint8_t i8;
	uint16_t i16;
	uint32_t i32;
	uint64_t i64;
	char *str;
	nvlist_t *cnv;

	printf(gettext("%*s%s = "), depth, "", name);

	switch (type) {
	case DATA_TYPE_BOOLEAN:
	printf(gettext("%s"), "1");
	break;

	case DATA_TYPE_BOOLEAN_VALUE:
	(void) nvpair_value_boolean_value(nvp, &b);
	printf(gettext("%s"), b ? "1" : "0");
	break;

	case DATA_TYPE_BYTE:
	(void) nvpair_value_byte(nvp, &i8);
	printf(gettext("0x%x"), i8);
	break;

	case DATA_TYPE_INT8:
	(void) nvpair_value_int8(nvp, (void *)&i8);
	printf(gettext("0x%x"), i8);
	break;

	case DATA_TYPE_UINT8:
	(void) nvpair_value_uint8(nvp, &i8);
	printf(gettext("0x%x"), i8);
	break;

	case DATA_TYPE_INT16:
	(void) nvpair_value_int16(nvp, (void *)&i16);
	printf(gettext("0x%x"), i16);
	break;

	case DATA_TYPE_UINT16:
	(void) nvpair_value_uint16(nvp, &i16);
	printf(gettext("0x%x"), i16);
	break;

	case DATA_TYPE_INT32:
	(void) nvpair_value_int32(nvp, (void *)&i32);
	printf(gettext("0x%x"), i32);
	break;

	case DATA_TYPE_UINT32:
	(void) nvpair_value_uint32(nvp, &i32);
	printf(gettext("0x%x"), i32);
	break;

	case DATA_TYPE_INT64:
	(void) nvpair_value_int64(nvp, (void *)&i64);
	printf(gettext("0x%llx"), (u_longlong_t)i64);
	break;

	case DATA_TYPE_UINT64:
	(void) nvpair_value_uint64(nvp, &i64);
	/*
	* translate vdev state values to readable
	* strings to aide zpool events consumers
	*/
	if (strcmp(name,
	FM_EREPORT_PAYLOAD_ZFS_VDEV_STATE) == 0 \|\|
	strcmp(name,
	FM_EREPORT_PAYLOAD_ZFS_VDEV_LASTSTATE) == 0) {
	printf(gettext("\"%s\" (0x%llx)"),
	zpool_state_to_name(i64, VDEV_AUX_NONE),
	(u_longlong_t)i64);
	} else {
	printf(gettext("0x%llx"), (u_longlong_t)i64);
	}
	break;

	case DATA_TYPE_HRTIME:
	(void) nvpair_value_hrtime(nvp, (void *)&i64);
	printf(gettext("0x%llx"), (u_longlong_t)i64);
	break;

	case DATA_TYPE_STRING:
	(void) nvpair_value_string(nvp, &str);
	printf(gettext("\"%s\""), str ? str : "<NULL>");
	break;

	case DATA_TYPE_NVLIST:
	printf(gettext("(embedded nvlist)\n"));
	(void) nvpair_value_nvlist(nvp, &cnv);
	zpool_do_events_nvprint(cnv, depth + 8);
	printf(gettext("%*s(end %s)"), depth, "", name);
	break;

	case DATA_TYPE_NVLIST_ARRAY: {
	nvlist_t **val;
	uint_t i, nelem;

	(void) nvpair_value_nvlist_array(nvp, &val, &nelem);
	printf(gettext("(%d embedded nvlists)\n"), nelem);
	for (i = 0; i < nelem; i++) {
	printf(gettext("%*s%s[%d] = %s\n"),
	depth, "", name, i, "(embedded nvlist)");
	zpool_do_events_nvprint(val[i], depth + 8);
	printf(gettext("%*s(end %s[%i])\n"),
	depth, "", name, i);
	}
	printf(gettext("%*s(end %s)\n"), depth, "", name);
	}
	break;

	case DATA_TYPE_INT8_ARRAY: {
	int8_t *val;
	uint_t i, nelem;

	(void) nvpair_value_int8_array(nvp, &val, &nelem);
	for (i = 0; i < nelem; i++)
	printf(gettext("0x%x "), val[i]);

	break;
	}

	case DATA_TYPE_UINT8_ARRAY: {
	uint8_t *val;
	uint_t i, nelem;

	(void) nvpair_value_uint8_array(nvp, &val, &nelem);
	for (i = 0; i < nelem; i++)
	printf(gettext("0x%x "), val[i]);

	break;
	}

	case DATA_TYPE_INT16_ARRAY: {
	int16_t *val;
	uint_t i, nelem;

	(void) nvpair_value_int16_array(nvp, &val, &nelem);
	for (i = 0; i < nelem; i++)
	printf(gettext("0x%x "), val[i]);

	break;
	}

	case DATA_TYPE_UINT16_ARRAY: {
	uint16_t *val;
	uint_t i, nelem;

	(void) nvpair_value_uint16_array(nvp, &val, &nelem);
	for (i = 0; i < nelem; i++)
	printf(gettext("0x%x "), val[i]);

	break;
	}

	case DATA_TYPE_INT32_ARRAY: {
	int32_t *val;
	uint_t i, nelem;

	(void) nvpair_value_int32_array(nvp, &val, &nelem);
	for (i = 0; i < nelem; i++)
	printf(gettext("0x%x "), val[i]);

	break;
	}

	case DATA_TYPE_UINT32_ARRAY: {
	uint32_t *val;
	uint_t i, nelem;

	(void) nvpair_value_uint32_array(nvp, &val, &nelem);
	for (i = 0; i < nelem; i++)
	printf(gettext("0x%x "), val[i]);

	break;
	}

	case DATA_TYPE_INT64_ARRAY: {
	int64_t *val;
	uint_t i, nelem;

	(void) nvpair_value_int64_array(nvp, &val, &nelem);
	for (i = 0; i < nelem; i++)
	printf(gettext("0x%llx "),
	(u_longlong_t)val[i]);

	break;
	}

	case DATA_TYPE_UINT64_ARRAY: {
	uint64_t *val;
	uint_t i, nelem;

	(void) nvpair_value_uint64_array(nvp, &val, &nelem);
	for (i = 0; i < nelem; i++)
	printf(gettext("0x%llx "),
	(u_longlong_t)val[i]);

	break;
	}

	case DATA_TYPE_STRING_ARRAY: {
	char **str;
	uint_t i, nelem;

	(void) nvpair_value_string_array(nvp, &str, &nelem);
	for (i = 0; i < nelem; i++)
	printf(gettext("\"%s\" "),
	str[i] ? str[i] : "<NULL>");

	break;
	}

	case DATA_TYPE_BOOLEAN_ARRAY:
	case DATA_TYPE_BYTE_ARRAY:
	case DATA_TYPE_DOUBLE:
	case DATA_TYPE_DONTCARE:
	case DATA_TYPE_UNKNOWN:
	printf(gettext("<unknown>"));
	break;
	}

	printf(gettext("\n"));
	}
	}

	static int
	zpool_do_events_next(ev_opts_t *opts)
	{
	nvlist_t *nvl;
	int zevent_fd, ret, dropped;
	char *pool;

	zevent_fd = open(ZFS_DEV, O_RDWR);
	VERIFY(zevent_fd >= 0);

	if (!opts->scripted)
	(void) printf(gettext("%-30s %s\n"), "TIME", "CLASS");

	while (1) {
	ret = zpool_events_next(g_zfs, &nvl, &dropped,
	(opts->follow ? ZEVENT_NONE : ZEVENT_NONBLOCK), zevent_fd);
	if (ret \|\| nvl == NULL)
	break;

	if (dropped > 0)
	(void) printf(gettext("dropped %d events\n"), dropped);

	if (strlen(opts->poolname) > 0 &&
	nvlist_lookup_string(nvl, FM_FMRI_ZFS_POOL, &pool) == 0 &&
	strcmp(opts->poolname, pool) != 0)
	continue;

	zpool_do_events_short(nvl, opts);

	if (opts->verbose) {
	zpool_do_events_nvprint(nvl, 8);
	printf(gettext("\n"));
	}
	(void) fflush(stdout);

	nvlist_free(nvl);
	}

	VERIFY(0 == close(zevent_fd));

	return (ret);
	}

	static int
	zpool_do_events_clear(ev_opts_t *opts)
	{
	int count, ret;

	ret = zpool_events_clear(g_zfs, &count);
	if (!ret)
	(void) printf(gettext("cleared %d events\n"), count);

	return (ret);
	}

	/*
	* zpool events [-vHf [pool] \| -c]
	*
	* Displays events logs by ZFS.
	*/
	int
	zpool_do_events(int argc, char **argv)
	{
	ev_opts_t opts = { 0 };
	int ret;
	int c;

	/* check options */
	while ((c = getopt(argc, argv, "vHfc")) != -1) {
	switch (c) {
	case 'v':
	opts.verbose = 1;
	break;
	case 'H':
	opts.scripted = 1;
	break;
	case 'f':
	opts.follow = 1;
	break;
	case 'c':
	opts.clear = 1;
	break;
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}
	argc -= optind;
	argv += optind;

	if (argc > 1) {
	(void) fprintf(stderr, gettext("too many arguments\n"));
	usage(B_FALSE);
	} else if (argc == 1) {
	(void) strlcpy(opts.poolname, argv[0], sizeof (opts.poolname));
	if (!zfs_name_valid(opts.poolname, ZFS_TYPE_POOL)) {
	(void) fprintf(stderr,
	gettext("invalid pool name '%s'\n"), opts.poolname);
	usage(B_FALSE);
	}
	}

	if ((argc == 1 \|\| opts.verbose \|\| opts.scripted \|\| opts.follow) &&
	opts.clear) {
	(void) fprintf(stderr,
	gettext("invalid options combined with -c\n"));
	usage(B_FALSE);
	}

	if (opts.clear)
	ret = zpool_do_events_clear(&opts);
	else
	ret = zpool_do_events_next(&opts);

	return (ret);
	}

	static int
	get_callback(zpool_handle_t zhp, void data)
	{
	zprop_get_cbdata_t cbp = (zprop_get_cbdata_t )data;
	char value[MAXNAMELEN];
	zprop_source_t srctype;
	zprop_list_t *pl;

	for (pl = cbp->cb_proplist; pl != NULL; pl = pl->pl_next) {

	/*
	* Skip the special fake placeholder. This will also skip
	* over the name property when 'all' is specified.
	*/
	if (pl->pl_prop == ZPOOL_PROP_NAME &&
	pl == cbp->cb_proplist)
	continue;

	if (pl->pl_prop == ZPROP_INVAL &&
	(zpool_prop_feature(pl->pl_user_prop) \|\|
	zpool_prop_unsupported(pl->pl_user_prop))) {
	srctype = ZPROP_SRC_LOCAL;

	if (zpool_prop_get_feature(zhp, pl->pl_user_prop,
	value, sizeof (value)) == 0) {
	zprop_print_one_property(zpool_get_name(zhp),
	cbp, pl->pl_user_prop, value, srctype,
	NULL, NULL);
	}
	} else {
	if (zpool_get_prop(zhp, pl->pl_prop, value,
	sizeof (value), &srctype, cbp->cb_literal) != 0)
	continue;

	zprop_print_one_property(zpool_get_name(zhp), cbp,
	zpool_prop_to_name(pl->pl_prop), value, srctype,
	NULL, NULL);
	}
	}
	return (0);
	}

	/*
	* zpool get [-Hp] [-o "all" \| field[,...]] <"all" \| property[,...]> <pool> ...
	*
	* -H Scripted mode. Don't display headers, and separate properties
	* by a single tab.
	* -o List of columns to display. Defaults to
	* "name,property,value,source".
	* -p Display values in parsable (exact) format.
	*
	* Get properties of pools in the system. Output space statistics
	* for each one as well as other attributes.
	*/
	int
	zpool_do_get(int argc, char **argv)
	{
	zprop_get_cbdata_t cb = { 0 };
	zprop_list_t fake_name = { 0 };
	int ret;
	int c, i;
	char *value;

	cb.cb_first = B_TRUE;

	/*
	* Set up default columns and sources.
	*/
	cb.cb_sources = ZPROP_SRC_ALL;
	cb.cb_columns[0] = GET_COL_NAME;
	cb.cb_columns[1] = GET_COL_PROPERTY;
	cb.cb_columns[2] = GET_COL_VALUE;
	cb.cb_columns[3] = GET_COL_SOURCE;
	cb.cb_type = ZFS_TYPE_POOL;

	/* check options */
	while ((c = getopt(argc, argv, ":Hpo:")) != -1) {
	switch (c) {
	case 'p':
	cb.cb_literal = B_TRUE;
	break;
	case 'H':
	cb.cb_scripted = B_TRUE;
	break;
	case 'o':
	bzero(&cb.cb_columns, sizeof (cb.cb_columns));
	i = 0;
	while (*optarg != '\0') {
	static char *col_subopts[] =
	{ "name", "property", "value", "source",
	"all", NULL };

	if (i == ZFS_GET_NCOLS) {
	(void) fprintf(stderr, gettext("too "
	"many fields given to -o "
	"option\n"));
	usage(B_FALSE);
	}

	switch (getsubopt(&optarg, col_subopts,
	&value)) {
	case 0:
	cb.cb_columns[i++] = GET_COL_NAME;
	break;
	case 1:
	cb.cb_columns[i++] = GET_COL_PROPERTY;
	break;
	case 2:
	cb.cb_columns[i++] = GET_COL_VALUE;
	break;
	case 3:
	cb.cb_columns[i++] = GET_COL_SOURCE;
	break;
	case 4:
	if (i > 0) {
	(void) fprintf(stderr,
	gettext("\"all\" conflicts "
	"with specific fields "
	"given to -o option\n"));
	usage(B_FALSE);
	}
	cb.cb_columns[0] = GET_COL_NAME;
	cb.cb_columns[1] = GET_COL_PROPERTY;
	cb.cb_columns[2] = GET_COL_VALUE;
	cb.cb_columns[3] = GET_COL_SOURCE;
	i = ZFS_GET_NCOLS;
	break;
	default:
	(void) fprintf(stderr,
	gettext("invalid column name "
	"'%s'\n"), value);
	usage(B_FALSE);
	}
	}
	break;
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	argc -= optind;
	argv += optind;

	if (argc < 1) {
	(void) fprintf(stderr, gettext("missing property "
	"argument\n"));
	usage(B_FALSE);
	}

	if (zprop_get_list(g_zfs, argv[0], &cb.cb_proplist,
	ZFS_TYPE_POOL) != 0)
	usage(B_FALSE);

	argc--;
	argv++;

	if (cb.cb_proplist != NULL) {
	fake_name.pl_prop = ZPOOL_PROP_NAME;
	fake_name.pl_width = strlen(gettext("NAME"));
	fake_name.pl_next = cb.cb_proplist;
	cb.cb_proplist = &fake_name;
	}

	ret = for_each_pool(argc, argv, B_TRUE, &cb.cb_proplist, cb.cb_literal,
	get_callback, &cb);

	if (cb.cb_proplist == &fake_name)
	zprop_free_list(fake_name.pl_next);
	else
	zprop_free_list(cb.cb_proplist);

	return (ret);
	}

	typedef struct set_cbdata {
	char *cb_propname;
	char *cb_value;
	boolean_t cb_any_successful;
	} set_cbdata_t;

	static int
	set_callback(zpool_handle_t zhp, void data)
	{
	int error;
	set_cbdata_t cb = (set_cbdata_t )data;

	+ /* Check if we have out-of-bounds features */
	+ if (strcmp(cb->cb_propname, ZPOOL_CONFIG_COMPATIBILITY) == 0) {
	+ boolean_t features[SPA_FEATURES];
	+ if (zpool_do_load_compat(cb->cb_value, features) !=
	+ ZPOOL_COMPATIBILITY_OK)
	+ return (-1);
	+
	+ nvlist_t *enabled = zpool_get_features(zhp);
	+ spa_feature_t i;
	+ for (i = 0; i < SPA_FEATURES; i++) {
	+ const char *fguid = spa_feature_table[i].fi_guid;
	+ if (nvlist_exists(enabled, fguid) && !features[i])
	+ break;
	+ }
	+ if (i < SPA_FEATURES)
	+ (void) fprintf(stderr, gettext("Warning: one or "
	+ "more features already enabled on pool '%s'\n"
	+ "are not present in this compatibility set.\n"),
	+ zpool_get_name(zhp));
	+ }
	+
	+ /* if we're setting a feature, check it's in compatibility set */
	+ if (zpool_prop_feature(cb->cb_propname) &&
	+ strcmp(cb->cb_value, ZFS_FEATURE_ENABLED) == 0) {
	+ char *fname = strchr(cb->cb_propname, '@') + 1;
	+ spa_feature_t f;
	+
	+ if (zfeature_lookup_name(fname, &f) == 0) {
	+ char compat[ZFS_MAXPROPLEN];
	+ if (zpool_get_prop(zhp, ZPOOL_PROP_COMPATIBILITY,
	+ compat, ZFS_MAXPROPLEN, NULL, B_FALSE) != 0)
	+ compat[0] = '\0';
	+
	+ boolean_t features[SPA_FEATURES];
	+ if (zpool_do_load_compat(compat, features) !=
	+ ZPOOL_COMPATIBILITY_OK) {
	+ (void) fprintf(stderr, gettext("Error: "
	+ "cannot enable feature '%s' on pool '%s'\n"
	+ "because the pool's 'compatibility' "
	+ "property cannot be parsed.\n"),
	+ fname, zpool_get_name(zhp));
	+ return (-1);
	+ }
	+
	+ if (!features[f]) {
	+ (void) fprintf(stderr, gettext("Error: "
	+ "cannot enable feature '%s' on pool '%s'\n"
	+ "as it is not specified in this pool's "
	+ "current compatibility set.\n"
	+ "Consider setting 'compatibility' to a "
	+ "less restrictive set, or to 'off'.\n"),
	+ fname, zpool_get_name(zhp));
	+ return (-1);
	+ }
	+ }
	+ }
	+
	error = zpool_set_prop(zhp, cb->cb_propname, cb->cb_value);

	if (!error)
	cb->cb_any_successful = B_TRUE;

	return (error);
	}

	int
	zpool_do_set(int argc, char **argv)
	{
	set_cbdata_t cb = { 0 };
	int error;

	if (argc > 1 && argv[1][0] == '-') {
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	argv[1][1]);
	usage(B_FALSE);
	}

	if (argc < 2) {
	(void) fprintf(stderr, gettext("missing property=value "
	"argument\n"));
	usage(B_FALSE);
	}

	if (argc < 3) {
	(void) fprintf(stderr, gettext("missing pool name\n"));
	usage(B_FALSE);
	}

	if (argc > 3) {
	(void) fprintf(stderr, gettext("too many pool names\n"));
	usage(B_FALSE);
	}

	cb.cb_propname = argv[1];
	cb.cb_value = strchr(cb.cb_propname, '=');
	if (cb.cb_value == NULL) {
	(void) fprintf(stderr, gettext("missing value in "
	"property=value argument\n"));
	usage(B_FALSE);
	}

	*(cb.cb_value) = '\0';
	cb.cb_value++;

	error = for_each_pool(argc - 2, argv + 2, B_TRUE, NULL, B_FALSE,
	set_callback, &cb);

	return (error);
	}

	/* Add up the total number of bytes left to initialize/trim across all vdevs */
	static uint64_t
	vdev_activity_remaining(nvlist_t *nv, zpool_wait_activity_t activity)
	{
	uint64_t bytes_remaining;
	nvlist_t **child;
	uint_t c, children;
	vdev_stat_t *vs;

	assert(activity == ZPOOL_WAIT_INITIALIZE \|\|
	activity == ZPOOL_WAIT_TRIM);

	verify(nvlist_lookup_uint64_array(nv, ZPOOL_CONFIG_VDEV_STATS,
	(uint64_t **)&vs, &c) == 0);

	if (activity == ZPOOL_WAIT_INITIALIZE &&
	vs->vs_initialize_state == VDEV_INITIALIZE_ACTIVE)
	bytes_remaining = vs->vs_initialize_bytes_est -
	vs->vs_initialize_bytes_done;
	else if (activity == ZPOOL_WAIT_TRIM &&
	vs->vs_trim_state == VDEV_TRIM_ACTIVE)
	bytes_remaining = vs->vs_trim_bytes_est -
	vs->vs_trim_bytes_done;
	else
	bytes_remaining = 0;

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
	&child, &children) != 0)
	children = 0;

	for (c = 0; c < children; c++)
	bytes_remaining += vdev_activity_remaining(child[c], activity);

	return (bytes_remaining);
	}

	/* Add up the total number of bytes left to rebuild across top-level vdevs */
	static uint64_t
	vdev_activity_top_remaining(nvlist_t *nv)
	{
	uint64_t bytes_remaining = 0;
	nvlist_t **child;
	uint_t children;
	int error;

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
	&child, &children) != 0)
	children = 0;

	for (uint_t c = 0; c < children; c++) {
	vdev_rebuild_stat_t *vrs;
	uint_t i;

	error = nvlist_lookup_uint64_array(child[c],
	ZPOOL_CONFIG_REBUILD_STATS, (uint64_t **)&vrs, &i);
	if (error == 0) {
	if (vrs->vrs_state == VDEV_REBUILD_ACTIVE) {
	bytes_remaining += (vrs->vrs_bytes_est -
	vrs->vrs_bytes_rebuilt);
	}
	}
	}

	return (bytes_remaining);
	}

	/* Whether any vdevs are 'spare' or 'replacing' vdevs */
	static boolean_t
	vdev_any_spare_replacing(nvlist_t *nv)
	{
	nvlist_t **child;
	uint_t c, children;
	char *vdev_type;

	(void) nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &vdev_type);

	if (strcmp(vdev_type, VDEV_TYPE_REPLACING) == 0 \|\|
	strcmp(vdev_type, VDEV_TYPE_SPARE) == 0 \|\|
	strcmp(vdev_type, VDEV_TYPE_DRAID_SPARE) == 0) {
	return (B_TRUE);
	}

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
	&child, &children) != 0)
	children = 0;

	for (c = 0; c < children; c++) {
	if (vdev_any_spare_replacing(child[c]))
	return (B_TRUE);
	}

	return (B_FALSE);
	}

	typedef struct wait_data {
	char *wd_poolname;
	boolean_t wd_scripted;
	boolean_t wd_exact;
	boolean_t wd_headers_once;
	boolean_t wd_should_exit;
	/* Which activities to wait for */
	boolean_t wd_enabled[ZPOOL_WAIT_NUM_ACTIVITIES];
	float wd_interval;
	pthread_cond_t wd_cv;
	pthread_mutex_t wd_mutex;
	} wait_data_t;

	/*
	* Print to stdout a single line, containing one column for each activity that
	* we are waiting for specifying how many bytes of work are left for that
	* activity.
	*/
	static void
	print_wait_status_row(wait_data_t wd, zpool_handle_t zhp, int row)
	{
	nvlist_t config, nvroot;
	uint_t c;
	int i;
	pool_checkpoint_stat_t *pcs = NULL;
	pool_scan_stat_t *pss = NULL;
	pool_removal_stat_t *prs = NULL;
	char *headers[] = {"DISCARD", "FREE", "INITIALIZE", "REPLACE",
	"REMOVE", "RESILVER", "SCRUB", "TRIM"};
	int col_widths[ZPOOL_WAIT_NUM_ACTIVITIES];

	/* Calculate the width of each column */
	for (i = 0; i < ZPOOL_WAIT_NUM_ACTIVITIES; i++) {
	/*
	* Make sure we have enough space in the col for pretty-printed
	* numbers and for the column header, and then leave a couple
	* spaces between cols for readability.
	*/
	col_widths[i] = MAX(strlen(headers[i]), 6) + 2;
	}

	/* Print header if appropriate */
	int term_height = terminal_height();
	boolean_t reprint_header = (!wd->wd_headers_once && term_height > 0 &&
	row % (term_height-1) == 0);
	if (!wd->wd_scripted && (row == 0 \|\| reprint_header)) {
	for (i = 0; i < ZPOOL_WAIT_NUM_ACTIVITIES; i++) {
	if (wd->wd_enabled[i])
	(void) printf("%*s", col_widths[i], headers[i]);
	}
	(void) printf("\n");
	}

	/* Bytes of work remaining in each activity */
	int64_t bytes_rem[ZPOOL_WAIT_NUM_ACTIVITIES] = {0};

	bytes_rem[ZPOOL_WAIT_FREE] =
	zpool_get_prop_int(zhp, ZPOOL_PROP_FREEING, NULL);

	config = zpool_get_config(zhp, NULL);
	nvroot = fnvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE);

	(void) nvlist_lookup_uint64_array(nvroot,
	ZPOOL_CONFIG_CHECKPOINT_STATS, (uint64_t **)&pcs, &c);
	if (pcs != NULL && pcs->pcs_state == CS_CHECKPOINT_DISCARDING)
	bytes_rem[ZPOOL_WAIT_CKPT_DISCARD] = pcs->pcs_space;

	(void) nvlist_lookup_uint64_array(nvroot,
	ZPOOL_CONFIG_REMOVAL_STATS, (uint64_t **)&prs, &c);
	if (prs != NULL && prs->prs_state == DSS_SCANNING)
	bytes_rem[ZPOOL_WAIT_REMOVE] = prs->prs_to_copy -
	prs->prs_copied;

	(void) nvlist_lookup_uint64_array(nvroot,
	ZPOOL_CONFIG_SCAN_STATS, (uint64_t **)&pss, &c);
	if (pss != NULL && pss->pss_state == DSS_SCANNING &&
	pss->pss_pass_scrub_pause == 0) {
	int64_t rem = pss->pss_to_examine - pss->pss_issued;
	if (pss->pss_func == POOL_SCAN_SCRUB)
	bytes_rem[ZPOOL_WAIT_SCRUB] = rem;
	else
	bytes_rem[ZPOOL_WAIT_RESILVER] = rem;
	} else if (check_rebuilding(nvroot, NULL)) {
	bytes_rem[ZPOOL_WAIT_RESILVER] =
	vdev_activity_top_remaining(nvroot);
	}

	bytes_rem[ZPOOL_WAIT_INITIALIZE] =
	vdev_activity_remaining(nvroot, ZPOOL_WAIT_INITIALIZE);
	bytes_rem[ZPOOL_WAIT_TRIM] =
	vdev_activity_remaining(nvroot, ZPOOL_WAIT_TRIM);

	/*
	* A replace finishes after resilvering finishes, so the amount of work
	* left for a replace is the same as for resilvering.
	*
	* It isn't quite correct to say that if we have any 'spare' or
	* 'replacing' vdevs and a resilver is happening, then a replace is in
	* progress, like we do here. When a hot spare is used, the faulted vdev
	* is not removed after the hot spare is resilvered, so parent 'spare'
	* vdev is not removed either. So we could have a 'spare' vdev, but be
	* resilvering for a different reason. However, we use it as a heuristic
	* because we don't have access to the DTLs, which could tell us whether
	* or not we have really finished resilvering a hot spare.
	*/
	if (vdev_any_spare_replacing(nvroot))
	bytes_rem[ZPOOL_WAIT_REPLACE] = bytes_rem[ZPOOL_WAIT_RESILVER];

	if (timestamp_fmt != NODATE)
	print_timestamp(timestamp_fmt);

	for (i = 0; i < ZPOOL_WAIT_NUM_ACTIVITIES; i++) {
	char buf[64];
	if (!wd->wd_enabled[i])
	continue;

	if (wd->wd_exact)
	(void) snprintf(buf, sizeof (buf), "%" PRIi64,
	bytes_rem[i]);
	else
	zfs_nicenum(bytes_rem[i], buf, sizeof (buf));

	if (wd->wd_scripted)
	(void) printf(i == 0 ? "%s" : "\t%s", buf);
	else
	(void) printf(" %*s", col_widths[i] - 1, buf);
	}
	(void) printf("\n");
	(void) fflush(stdout);
	}

	static void *
	wait_status_thread(void *arg)
	{
	wait_data_t wd = (wait_data_t )arg;
	zpool_handle_t *zhp;

	if ((zhp = zpool_open(g_zfs, wd->wd_poolname)) == NULL)
	return (void *)(1);

	for (int row = 0; ; row++) {
	boolean_t missing;
	struct timespec timeout;
	int ret = 0;
	(void) clock_gettime(CLOCK_REALTIME, &timeout);

	if (zpool_refresh_stats(zhp, &missing) != 0 \|\| missing \|\|
	zpool_props_refresh(zhp) != 0) {
	zpool_close(zhp);
	return (void *)(uintptr_t)(missing ? 0 : 1);
	}

	print_wait_status_row(wd, zhp, row);

	timeout.tv_sec += floor(wd->wd_interval);
	long nanos = timeout.tv_nsec +
	(wd->wd_interval - floor(wd->wd_interval)) * NANOSEC;
	if (nanos >= NANOSEC) {
	timeout.tv_sec++;
	timeout.tv_nsec = nanos - NANOSEC;
	} else {
	timeout.tv_nsec = nanos;
	}
	pthread_mutex_lock(&wd->wd_mutex);
	if (!wd->wd_should_exit)
	ret = pthread_cond_timedwait(&wd->wd_cv, &wd->wd_mutex,
	&timeout);
	pthread_mutex_unlock(&wd->wd_mutex);
	if (ret == 0) {
	break; /* signaled by main thread */
	} else if (ret != ETIMEDOUT) {
	(void) fprintf(stderr, gettext("pthread_cond_timedwait "
	"failed: %s\n"), strerror(ret));
	zpool_close(zhp);
	return (void *)(uintptr_t)(1);
	}
	}

	zpool_close(zhp);
	return (void *)(0);
	}

	int
	zpool_do_wait(int argc, char **argv)
	{
	boolean_t verbose = B_FALSE;
	int c;
	char *value;
	int i;
	unsigned long count;
	pthread_t status_thr;
	int error = 0;
	zpool_handle_t *zhp;

	wait_data_t wd;
	wd.wd_scripted = B_FALSE;
	wd.wd_exact = B_FALSE;
	wd.wd_headers_once = B_FALSE;
	wd.wd_should_exit = B_FALSE;

	pthread_mutex_init(&wd.wd_mutex, NULL);
	pthread_cond_init(&wd.wd_cv, NULL);

	/* By default, wait for all types of activity. */
	for (i = 0; i < ZPOOL_WAIT_NUM_ACTIVITIES; i++)
	wd.wd_enabled[i] = B_TRUE;

	while ((c = getopt(argc, argv, "HpT:t:")) != -1) {
	switch (c) {
	case 'H':
	wd.wd_scripted = B_TRUE;
	break;
	case 'n':
	wd.wd_headers_once = B_TRUE;
	break;
	case 'p':
	wd.wd_exact = B_TRUE;
	break;
	case 'T':
	get_timestamp_arg(*optarg);
	break;
	case 't':
	{
	static char *col_subopts[] = { "discard", "free",
	"initialize", "replace", "remove", "resilver",
	"scrub", "trim", NULL };

	/* Reset activities array */
	bzero(&wd.wd_enabled, sizeof (wd.wd_enabled));
	while (*optarg != '\0') {
	int activity = getsubopt(&optarg, col_subopts,
	&value);

	if (activity < 0) {
	(void) fprintf(stderr,
	gettext("invalid activity '%s'\n"),
	value);
	usage(B_FALSE);
	}

	wd.wd_enabled[activity] = B_TRUE;
	}
	break;
	}
	case '?':
	(void) fprintf(stderr, gettext("invalid option '%c'\n"),
	optopt);
	usage(B_FALSE);
	}
	}

	argc -= optind;
	argv += optind;

	get_interval_count(&argc, argv, &wd.wd_interval, &count);
	if (count != 0) {
	/* This subcmd only accepts an interval, not a count */
	(void) fprintf(stderr, gettext("too many arguments\n"));
	usage(B_FALSE);
	}

	if (wd.wd_interval != 0)
	verbose = B_TRUE;

	if (argc < 1) {
	(void) fprintf(stderr, gettext("missing 'pool' argument\n"));
	usage(B_FALSE);
	}
	if (argc > 1) {
	(void) fprintf(stderr, gettext("too many arguments\n"));
	usage(B_FALSE);
	}

	wd.wd_poolname = argv[0];

	if ((zhp = zpool_open(g_zfs, wd.wd_poolname)) == NULL)
	return (1);

	if (verbose) {
	/*
	* We use a separate thread for printing status updates because
	* the main thread will call lzc_wait(), which blocks as long
	* as an activity is in progress, which can be a long time.
	*/
	if (pthread_create(&status_thr, NULL, wait_status_thread, &wd)
	!= 0) {
	(void) fprintf(stderr, gettext("failed to create status"
	"thread: %s\n"), strerror(errno));
	zpool_close(zhp);
	return (1);
	}
	}

	/*
	* Loop over all activities that we are supposed to wait for until none
	* of them are in progress. Note that this means we can end up waiting
	* for more activities to complete than just those that were in progress
	* when we began waiting; if an activity we are interested in begins
	* while we are waiting for another activity, we will wait for both to
	* complete before exiting.
	*/
	for (;;) {
	boolean_t missing = B_FALSE;
	boolean_t any_waited = B_FALSE;

	for (i = 0; i < ZPOOL_WAIT_NUM_ACTIVITIES; i++) {
	boolean_t waited;

	if (!wd.wd_enabled[i])
	continue;

	error = zpool_wait_status(zhp, i, &missing, &waited);
	if (error != 0 \|\| missing)
	break;

	any_waited = (any_waited \|\| waited);
	}

	if (error != 0 \|\| missing \|\| !any_waited)
	break;
	}

	zpool_close(zhp);

	if (verbose) {
	uintptr_t status;
	pthread_mutex_lock(&wd.wd_mutex);
	wd.wd_should_exit = B_TRUE;
	pthread_cond_signal(&wd.wd_cv);
	pthread_mutex_unlock(&wd.wd_mutex);
	(void) pthread_join(status_thr, (void *)&status);
	if (status != 0)
	error = status;
	}

	pthread_mutex_destroy(&wd.wd_mutex);
	pthread_cond_destroy(&wd.wd_cv);
	return (error);
	}

	static int
	find_command_idx(char command, int idx)
	{
	int i;

	for (i = 0; i < NCOMMAND; i++) {
	if (command_table[i].name == NULL)
	continue;

	if (strcmp(command, command_table[i].name) == 0) {
	*idx = i;
	return (0);
	}
	}
	return (1);
	}

	/*
	* Display version message
	*/
	static int
	zpool_do_version(int argc, char **argv)
	{
	if (zfs_version_print() == -1)
	return (1);

	return (0);
	}

	/*
	* Do zpool_load_compat() and print error message on failure
	*/
	static zpool_compat_status_t
	zpool_do_load_compat(const char compat, boolean_t list)
	{
	- char badword[ZFS_MAXPROPLEN];
	- char badfile[MAXPATHLEN];
	+ char report[1024];
	+
	zpool_compat_status_t ret;

	- switch (ret = zpool_load_compat(compat, list, badword, badfile)) {
	+ ret = zpool_load_compat(compat, list, report, 1024);
	+ switch (ret) {
	+
	case ZPOOL_COMPATIBILITY_OK:
	break;
	- case ZPOOL_COMPATIBILITY_READERR:
	- (void) fprintf(stderr, gettext("error reading compatibility "
	- "file '%s'\n"), badfile);
	- break;
	+
	+ case ZPOOL_COMPATIBILITY_NOFILES:
	case ZPOOL_COMPATIBILITY_BADFILE:
	- (void) fprintf(stderr, gettext("compatibility file '%s' "
	- "too large or not newline-terminated\n"), badfile);
	- break;
	- case ZPOOL_COMPATIBILITY_BADWORD:
	- (void) fprintf(stderr, gettext("unknown feature '%s' in "
	- "compatibility file '%s'\n"), badword, badfile);
	+ case ZPOOL_COMPATIBILITY_BADTOKEN:
	+ (void) fprintf(stderr, "Error: %s\n", report);
	break;
	- case ZPOOL_COMPATIBILITY_NOFILES:
	- (void) fprintf(stderr, gettext("no compatibility files "
	- "specified\n"));
	+
	+ case ZPOOL_COMPATIBILITY_WARNTOKEN:
	+ (void) fprintf(stderr, "Warning: %s\n", report);
	+ ret = ZPOOL_COMPATIBILITY_OK;
	break;
	}
	return (ret);
	}

	int
	main(int argc, char **argv)
	{
	int ret = 0;
	int i = 0;
	char *cmdname;
	char **newargv;

	(void) setlocale(LC_ALL, "");
	(void) setlocale(LC_NUMERIC, "C");
	(void) textdomain(TEXT_DOMAIN);
	srand(time(NULL));

	opterr = 0;

	/*
	* Make sure the user has specified some command.
	*/
	if (argc < 2) {
	(void) fprintf(stderr, gettext("missing command\n"));
	usage(B_FALSE);
	}

	cmdname = argv[1];

	/*
	* Special case '-?'
	*/
	if ((strcmp(cmdname, "-?") == 0) \|\| strcmp(cmdname, "--help") == 0)
	usage(B_TRUE);

	/*
	* Special case '-V\|--version'
	*/
	if ((strcmp(cmdname, "-V") == 0) \|\| (strcmp(cmdname, "--version") == 0))
	return (zpool_do_version(argc, argv));

	if ((g_zfs = libzfs_init()) == NULL) {
	(void) fprintf(stderr, "%s\n", libzfs_error_init(errno));
	return (1);
	}

	libzfs_print_on_error(g_zfs, B_TRUE);

	zfs_save_arguments(argc, argv, history_str, sizeof (history_str));

	/*
	* Many commands modify input strings for string parsing reasons.
	* We create a copy to protect the original argv.
	*/
	newargv = malloc((argc + 1) * sizeof (newargv[0]));
	for (i = 0; i < argc; i++)
	newargv[i] = strdup(argv[i]);
	newargv[argc] = NULL;

	/*
	* Run the appropriate command.
	*/
	if (find_command_idx(cmdname, &i) == 0) {
	current_command = &command_table[i];
	ret = command_table[i].func(argc - 1, newargv + 1);
	} else if (strchr(cmdname, '=')) {
	verify(find_command_idx("set", &i) == 0);
	current_command = &command_table[i];
	ret = command_table[i].func(argc, newargv);
	} else if (strcmp(cmdname, "freeze") == 0 && argc == 3) {
	/*
	* 'freeze' is a vile debugging abomination, so we treat
	* it as such.
	*/
	zfs_cmd_t zc = {"\0"};

	(void) strlcpy(zc.zc_name, argv[2], sizeof (zc.zc_name));
	ret = zfs_ioctl(g_zfs, ZFS_IOC_POOL_FREEZE, &zc);
	if (ret != 0) {
	(void) fprintf(stderr,
	gettext("failed to freeze pool: %d\n"), errno);
	ret = 1;
	}

	log_history = 0;
	} else {
	(void) fprintf(stderr, gettext("unrecognized "
	"command '%s'\n"), cmdname);
	usage(B_FALSE);
	ret = 1;
	}

	for (i = 0; i < argc; i++)
	free(newargv[i]);
	free(newargv);

	if (ret == 0 && log_history)
	(void) zpool_log_history(g_zfs, history_str);

	libzfs_fini(g_zfs);

	/*
	* The 'ZFS_ABORT' environment variable causes us to dump core on exit
	* for the purposes of running ::findleaks.
	*/
	if (getenv("ZFS_ABORT") != NULL) {
	(void) printf("dumping core by request\n");
	abort();
	}

	return (ret);
	}
	diff --git a/sys/contrib/openzfs/cmd/zpool/zpool_vdev.c b/sys/contrib/openzfs/cmd/zpool/zpool_vdev.c
	index c86081a8153a..3d83da641ecb 100644
	--- a/sys/contrib/openzfs/cmd/zpool/zpool_vdev.c
	+++ b/sys/contrib/openzfs/cmd/zpool/zpool_vdev.c
	@@ -1,1870 +1,1870 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2013, 2018 by Delphix. All rights reserved.
	* Copyright (c) 2016, 2017 Intel Corporation.
	* Copyright 2016 Igor Kozhukhov <ikozhukhov@gmail.com>.
	*/

	/*
	* Functions to convert between a list of vdevs and an nvlist representing the
	* configuration. Each entry in the list can be one of:
	*
	* Device vdevs
	* disk=(path=..., devid=...)
	* file=(path=...)
	*
	* Group vdevs
	* raidz[1\|2]=(...)
	* mirror=(...)
	*
	* Hot spares
	*
	* While the underlying implementation supports it, group vdevs cannot contain
	* other group vdevs. All userland verification of devices is contained within
	* this file. If successful, the nvlist returned can be passed directly to the
	* kernel; we've done as much verification as possible in userland.
	*
	* Hot spares are a special case, and passed down as an array of disk vdevs, at
	* the same level as the root of the vdev tree.
	*
	* The only function exported by this file is 'make_root_vdev'. The
	* function performs several passes:
	*
	* 1. Construct the vdev specification. Performs syntax validation and
	* makes sure each device is valid.
	* 2. Check for devices in use. Using libblkid to make sure that no
	* devices are also in use. Some can be overridden using the 'force'
	* flag, others cannot.
	* 3. Check for replication errors if the 'force' flag is not specified.
	* validates that the replication level is consistent across the
	* entire pool.
	* 4. Call libzfs to label any whole disks with an EFI label.
	*/

	#include <assert.h>
	#include <ctype.h>
	#include <errno.h>
	#include <fcntl.h>
	#include <libintl.h>
	#include <libnvpair.h>
	#include <libzutil.h>
	#include <limits.h>
	#include <sys/spa.h>
	#include <stdio.h>
	#include <string.h>
	#include <unistd.h>
	#include "zpool_util.h"
	#include <sys/zfs_context.h>
	#include <sys/stat.h>

	/*
	* For any given vdev specification, we can have multiple errors. The
	* vdev_error() function keeps track of whether we have seen an error yet, and
	* prints out a header if its the first error we've seen.
	*/
	boolean_t error_seen;
	boolean_t is_force;

	/PRINTFLIKE1/
	void
	vdev_error(const char *fmt, ...)
	{
	va_list ap;

	if (!error_seen) {
	(void) fprintf(stderr, gettext("invalid vdev specification\n"));
	if (!is_force)
	(void) fprintf(stderr, gettext("use '-f' to override "
	"the following errors:\n"));
	else
	(void) fprintf(stderr, gettext("the following errors "
	"must be manually repaired:\n"));
	error_seen = B_TRUE;
	}

	va_start(ap, fmt);
	(void) vfprintf(stderr, fmt, ap);
	va_end(ap);
	}

	/*
	* Check that a file is valid. All we can do in this case is check that it's
	* not in use by another pool, and not in use by swap.
	*/
	int
	check_file(const char *file, boolean_t force, boolean_t isspare)
	{
	char *name;
	int fd;
	int ret = 0;
	pool_state_t state;
	boolean_t inuse;

	if ((fd = open(file, O_RDONLY)) < 0)
	return (0);

	if (zpool_in_use(g_zfs, fd, &state, &name, &inuse) == 0 && inuse) {
	const char *desc;

	switch (state) {
	case POOL_STATE_ACTIVE:
	desc = gettext("active");
	break;

	case POOL_STATE_EXPORTED:
	desc = gettext("exported");
	break;

	case POOL_STATE_POTENTIALLY_ACTIVE:
	desc = gettext("potentially active");
	break;

	default:
	desc = gettext("unknown");
	break;
	}

	/*
	* Allow hot spares to be shared between pools.
	*/
	if (state == POOL_STATE_SPARE && isspare) {
	free(name);
	(void) close(fd);
	return (0);
	}

	if (state == POOL_STATE_ACTIVE \|\|
	state == POOL_STATE_SPARE \|\| !force) {
	switch (state) {
	case POOL_STATE_SPARE:
	vdev_error(gettext("%s is reserved as a hot "
	"spare for pool %s\n"), file, name);
	break;
	default:
	vdev_error(gettext("%s is part of %s pool "
	"'%s'\n"), file, desc, name);
	break;
	}
	ret = -1;
	}

	free(name);
	}

	(void) close(fd);
	return (ret);
	}

	/*
	* This may be a shorthand device path or it could be total gibberish.
	* Check to see if it is a known device available in zfs_vdev_paths.
	* As part of this check, see if we've been given an entire disk
	* (minus the slice number).
	*/
	static int
	is_shorthand_path(const char arg, char path, size_t path_size,
	struct stat64 statbuf, boolean_t wholedisk)
	{
	int error;

	error = zfs_resolve_shortname(arg, path, path_size);
	if (error == 0) {
	*wholedisk = zfs_dev_is_whole_disk(path);
	if (*wholedisk \|\| (stat64(path, statbuf) == 0))
	return (0);
	}

	strlcpy(path, arg, path_size);
	memset(statbuf, 0, sizeof (*statbuf));
	*wholedisk = B_FALSE;

	return (error);
	}

	/*
	* Determine if the given path is a hot spare within the given configuration.
	* If no configuration is given we rely solely on the label.
	*/
	static boolean_t
	is_spare(nvlist_t config, const char path)
	{
	int fd;
	pool_state_t state;
	char *name = NULL;
	nvlist_t *label;
	uint64_t guid, spareguid;
	nvlist_t *nvroot;
	nvlist_t **spares;
	uint_t i, nspares;
	boolean_t inuse;

	if (zpool_is_draid_spare(path))
	return (B_TRUE);

	if ((fd = open(path, O_RDONLY\|O_DIRECT)) < 0)
	return (B_FALSE);

	if (zpool_in_use(g_zfs, fd, &state, &name, &inuse) != 0 \|\|
	!inuse \|\|
	state != POOL_STATE_SPARE \|\|
	zpool_read_label(fd, &label, NULL) != 0) {
	free(name);
	(void) close(fd);
	return (B_FALSE);
	}
	free(name);
	(void) close(fd);

	if (config == NULL) {
	nvlist_free(label);
	return (B_TRUE);
	}

	verify(nvlist_lookup_uint64(label, ZPOOL_CONFIG_GUID, &guid) == 0);
	nvlist_free(label);

	verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
	&nvroot) == 0);
	if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES,
	&spares, &nspares) == 0) {
	for (i = 0; i < nspares; i++) {
	verify(nvlist_lookup_uint64(spares[i],
	ZPOOL_CONFIG_GUID, &spareguid) == 0);
	if (spareguid == guid)
	return (B_TRUE);
	}
	}

	return (B_FALSE);
	}

	/*
	* Create a leaf vdev. Determine if this is a file or a device. If it's a
	* device, fill in the device id to make a complete nvlist. Valid forms for a
	* leaf vdev are:
	*
	* /dev/xxx Complete disk path
	* /xxx Full path to file
	* xxx Shorthand for <zfs_vdev_paths>/xxx
	* draid* Virtual dRAID spare
	*/
	static nvlist_t *
	make_leaf_vdev(nvlist_t props, const char arg, boolean_t is_primary)
	{
	char path[MAXPATHLEN];
	struct stat64 statbuf;
	nvlist_t *vdev = NULL;
	char *type = NULL;
	boolean_t wholedisk = B_FALSE;
	uint64_t ashift = 0;
	int err;

	/*
	* Determine what type of vdev this is, and put the full path into
	* 'path'. We detect whether this is a device of file afterwards by
	* checking the st_mode of the file.
	*/
	if (arg[0] == '/') {
	/*
	* Complete device or file path. Exact type is determined by
	* examining the file descriptor afterwards. Symbolic links
	* are resolved to their real paths to determine whole disk
	* and S_ISBLK/S_ISREG type checks. However, we are careful
	* to store the given path as ZPOOL_CONFIG_PATH to ensure we
	* can leverage udev's persistent device labels.
	*/
	if (realpath(arg, path) == NULL) {
	(void) fprintf(stderr,
	gettext("cannot resolve path '%s'\n"), arg);
	return (NULL);
	}

	wholedisk = zfs_dev_is_whole_disk(path);
	if (!wholedisk && (stat64(path, &statbuf) != 0)) {
	(void) fprintf(stderr,
	gettext("cannot open '%s': %s\n"),
	path, strerror(errno));
	return (NULL);
	}

	/* After whole disk check restore original passed path */
	strlcpy(path, arg, sizeof (path));
	} else if (zpool_is_draid_spare(arg)) {
	if (!is_primary) {
	(void) fprintf(stderr,
	gettext("cannot open '%s': dRAID spares can only "
	"be used to replace primary vdevs\n"), arg);
	return (NULL);
	}

	wholedisk = B_TRUE;
	strlcpy(path, arg, sizeof (path));
	type = VDEV_TYPE_DRAID_SPARE;
	} else {
	err = is_shorthand_path(arg, path, sizeof (path),
	&statbuf, &wholedisk);
	if (err != 0) {
	/*
	* If we got ENOENT, then the user gave us
	* gibberish, so try to direct them with a
	* reasonable error message. Otherwise,
	* regurgitate strerror() since it's the best we
	* can do.
	*/
	if (err == ENOENT) {
	(void) fprintf(stderr,
	gettext("cannot open '%s': no such "
	"device in %s\n"), arg, DISK_ROOT);
	(void) fprintf(stderr,
	gettext("must be a full path or "
	"shorthand device name\n"));
	return (NULL);
	} else {
	(void) fprintf(stderr,
	gettext("cannot open '%s': %s\n"),
	path, strerror(errno));
	return (NULL);
	}
	}
	}

	if (type == NULL) {
	/*
	* Determine whether this is a device or a file.
	*/
	if (wholedisk \|\| S_ISBLK(statbuf.st_mode)) {
	type = VDEV_TYPE_DISK;
	} else if (S_ISREG(statbuf.st_mode)) {
	type = VDEV_TYPE_FILE;
	} else {
	fprintf(stderr, gettext("cannot use '%s': must "
	"be a block device or regular file\n"), path);
	return (NULL);
	}
	}

	/*
	* Finally, we have the complete device or file, and we know that it is
	* acceptable to use. Construct the nvlist to describe this vdev. All
	* vdevs have a 'path' element, and devices also have a 'devid' element.
	*/
	verify(nvlist_alloc(&vdev, NV_UNIQUE_NAME, 0) == 0);
	verify(nvlist_add_string(vdev, ZPOOL_CONFIG_PATH, path) == 0);
	verify(nvlist_add_string(vdev, ZPOOL_CONFIG_TYPE, type) == 0);

	if (strcmp(type, VDEV_TYPE_DISK) == 0)
	verify(nvlist_add_uint64(vdev, ZPOOL_CONFIG_WHOLE_DISK,
	(uint64_t)wholedisk) == 0);

	/*
	* Override defaults if custom properties are provided.
	*/
	if (props != NULL) {
	char *value = NULL;

	if (nvlist_lookup_string(props,
	zpool_prop_to_name(ZPOOL_PROP_ASHIFT), &value) == 0) {
	if (zfs_nicestrtonum(NULL, value, &ashift) != 0) {
	(void) fprintf(stderr,
	gettext("ashift must be a number.\n"));
	return (NULL);
	}
	if (ashift != 0 &&
	(ashift < ASHIFT_MIN \|\| ashift > ASHIFT_MAX)) {
	(void) fprintf(stderr,
	gettext("invalid 'ashift=%" PRIu64 "' "
	"property: only values between %" PRId32 " "
	"and %" PRId32 " are allowed.\n"),
	ashift, ASHIFT_MIN, ASHIFT_MAX);
	return (NULL);
	}
	}
	}

	/*
	* If the device is known to incorrectly report its physical sector
	* size explicitly provide the known correct value.
	*/
	if (ashift == 0) {
	int sector_size;

	if (check_sector_size_database(path, &sector_size) == B_TRUE)
	ashift = highbit64(sector_size) - 1;
	}

	if (ashift > 0)
	(void) nvlist_add_uint64(vdev, ZPOOL_CONFIG_ASHIFT, ashift);

	return (vdev);
	}

	/*
	* Go through and verify the replication level of the pool is consistent.
	* Performs the following checks:
	*
	* For the new spec, verifies that devices in mirrors and raidz are the
	* same size.
	*
	* If the current configuration already has inconsistent replication
	* levels, ignore any other potential problems in the new spec.
	*
	* Otherwise, make sure that the current spec (if there is one) and the new
	* spec have consistent replication levels.
	*
	* If there is no current spec (create), make sure new spec has at least
	* one general purpose vdev.
	*/
	typedef struct replication_level {
	char *zprl_type;
	uint64_t zprl_children;
	uint64_t zprl_parity;
	} replication_level_t;

	#define ZPOOL_FUZZ (16 * 1024 * 1024)

	/*
	* N.B. For the purposes of comparing replication levels dRAID can be
	- * considered functionally equivilant to raidz.
	+ * considered functionally equivalent to raidz.
	*/
	static boolean_t
	is_raidz_mirror(replication_level_t a, replication_level_t b,
	replication_level_t raidz, replication_level_t mirror)
	{
	if ((strcmp(a->zprl_type, "raidz") == 0 \|\|
	strcmp(a->zprl_type, "draid") == 0) &&
	strcmp(b->zprl_type, "mirror") == 0) {
	*raidz = a;
	*mirror = b;
	return (B_TRUE);
	}
	return (B_FALSE);
	}

	/*
	* Comparison for determining if dRAID and raidz where passed in either order.
	*/
	static boolean_t
	is_raidz_draid(replication_level_t a, replication_level_t b)
	{
	if ((strcmp(a->zprl_type, "raidz") == 0 \|\|
	strcmp(a->zprl_type, "draid") == 0) &&
	(strcmp(b->zprl_type, "raidz") == 0 \|\|
	strcmp(b->zprl_type, "draid") == 0)) {
	return (B_TRUE);
	}

	return (B_FALSE);
	}

	/*
	* Given a list of toplevel vdevs, return the current replication level. If
	* the config is inconsistent, then NULL is returned. If 'fatal' is set, then
	* an error message will be displayed for each self-inconsistent vdev.
	*/
	static replication_level_t *
	get_replication(nvlist_t *nvroot, boolean_t fatal)
	{
	nvlist_t **top;
	uint_t t, toplevels;
	nvlist_t **child;
	uint_t c, children;
	nvlist_t *nv;
	char *type;
	replication_level_t lastrep = {0};
	replication_level_t rep;
	replication_level_t *ret;
	replication_level_t raidz, mirror;
	boolean_t dontreport;

	ret = safe_malloc(sizeof (replication_level_t));

	verify(nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN,
	&top, &toplevels) == 0);

	for (t = 0; t < toplevels; t++) {
	uint64_t is_log = B_FALSE;

	nv = top[t];

	/*
	* For separate logs we ignore the top level vdev replication
	* constraints.
	*/
	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_IS_LOG, &is_log);
	if (is_log)
	continue;

	/* Ignore holes introduced by removing aux devices */
	verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &type) == 0);
	if (strcmp(type, VDEV_TYPE_HOLE) == 0)
	continue;

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
	&child, &children) != 0) {
	/*
	* This is a 'file' or 'disk' vdev.
	*/
	rep.zprl_type = type;
	rep.zprl_children = 1;
	rep.zprl_parity = 0;
	} else {
	int64_t vdev_size;

	/*
	* This is a mirror or RAID-Z vdev. Go through and make
	* sure the contents are all the same (files vs. disks),
	* keeping track of the number of elements in the
	* process.
	*
	* We also check that the size of each vdev (if it can
	* be determined) is the same.
	*/
	rep.zprl_type = type;
	rep.zprl_children = 0;

	if (strcmp(type, VDEV_TYPE_RAIDZ) == 0 \|\|
	strcmp(type, VDEV_TYPE_DRAID) == 0) {
	verify(nvlist_lookup_uint64(nv,
	ZPOOL_CONFIG_NPARITY,
	&rep.zprl_parity) == 0);
	assert(rep.zprl_parity != 0);
	} else {
	rep.zprl_parity = 0;
	}

	/*
	* The 'dontreport' variable indicates that we've
	* already reported an error for this spec, so don't
	* bother doing it again.
	*/
	type = NULL;
	dontreport = 0;
	vdev_size = -1LL;
	for (c = 0; c < children; c++) {
	nvlist_t *cnv = child[c];
	char *path;
	struct stat64 statbuf;
	int64_t size = -1LL;
	char *childtype;
	int fd, err;

	rep.zprl_children++;

	verify(nvlist_lookup_string(cnv,
	ZPOOL_CONFIG_TYPE, &childtype) == 0);

	/*
	* If this is a replacing or spare vdev, then
	* get the real first child of the vdev: do this
	* in a loop because replacing and spare vdevs
	* can be nested.
	*/
	while (strcmp(childtype,
	VDEV_TYPE_REPLACING) == 0 \|\|
	strcmp(childtype, VDEV_TYPE_SPARE) == 0) {
	nvlist_t **rchild;
	uint_t rchildren;

	verify(nvlist_lookup_nvlist_array(cnv,
	ZPOOL_CONFIG_CHILDREN, &rchild,
	&rchildren) == 0);
	assert(rchildren == 2);
	cnv = rchild[0];

	verify(nvlist_lookup_string(cnv,
	ZPOOL_CONFIG_TYPE,
	&childtype) == 0);
	}

	verify(nvlist_lookup_string(cnv,
	ZPOOL_CONFIG_PATH, &path) == 0);

	/*
	* If we have a raidz/mirror that combines disks
	* with files, report it as an error.
	*/
	if (!dontreport && type != NULL &&
	strcmp(type, childtype) != 0) {
	if (ret != NULL)
	free(ret);
	ret = NULL;
	if (fatal)
	vdev_error(gettext(
	"mismatched replication "
	"level: %s contains both "
	"files and devices\n"),
	rep.zprl_type);
	else
	return (NULL);
	dontreport = B_TRUE;
	}

	/*
	* According to stat(2), the value of 'st_size'
	* is undefined for block devices and character
	* devices. But there is no effective way to
	* determine the real size in userland.
	*
	* Instead, we'll take advantage of an
	* implementation detail of spec_size(). If the
	* device is currently open, then we (should)
	* return a valid size.
	*
	* If we still don't get a valid size (indicated
	* by a size of 0 or MAXOFFSET_T), then ignore
	* this device altogether.
	*/
	if ((fd = open(path, O_RDONLY)) >= 0) {
	err = fstat64_blk(fd, &statbuf);
	(void) close(fd);
	} else {
	err = stat64(path, &statbuf);
	}

	if (err != 0 \|\|
	statbuf.st_size == 0 \|\|
	statbuf.st_size == MAXOFFSET_T)
	continue;

	size = statbuf.st_size;

	/*
	* Also make sure that devices and
	* slices have a consistent size. If
	* they differ by a significant amount
	* (~16MB) then report an error.
	*/
	if (!dontreport &&
	(vdev_size != -1LL &&
	(llabs(size - vdev_size) >
	ZPOOL_FUZZ))) {
	if (ret != NULL)
	free(ret);
	ret = NULL;
	if (fatal)
	vdev_error(gettext(
	"%s contains devices of "
	"different sizes\n"),
	rep.zprl_type);
	else
	return (NULL);
	dontreport = B_TRUE;
	}

	type = childtype;
	vdev_size = size;
	}
	}

	/*
	* At this point, we have the replication of the last toplevel
	* vdev in 'rep'. Compare it to 'lastrep' to see if it is
	* different.
	*/
	if (lastrep.zprl_type != NULL) {
	if (is_raidz_mirror(&lastrep, &rep, &raidz, &mirror) \|\|
	is_raidz_mirror(&rep, &lastrep, &raidz, &mirror)) {
	/*
	* Accepted raidz and mirror when they can
	* handle the same number of disk failures.
	*/
	if (raidz->zprl_parity !=
	mirror->zprl_children - 1) {
	if (ret != NULL)
	free(ret);
	ret = NULL;
	if (fatal)
	vdev_error(gettext(
	"mismatched replication "
	"level: "
	"%s and %s vdevs with "
	"different redundancy, "
	"%llu vs. %llu (%llu-way) "
	"are present\n"),
	raidz->zprl_type,
	mirror->zprl_type,
	raidz->zprl_parity,
	mirror->zprl_children - 1,
	mirror->zprl_children);
	else
	return (NULL);
	}
	} else if (is_raidz_draid(&lastrep, &rep)) {
	/*
	* Accepted raidz and draid when they can
	* handle the same number of disk failures.
	*/
	if (lastrep.zprl_parity != rep.zprl_parity) {
	if (ret != NULL)
	free(ret);
	ret = NULL;
	if (fatal)
	vdev_error(gettext(
	"mismatched replication "
	"level: %s and %s vdevs "
	"with different "
	"redundancy, %llu vs. "
	"%llu are present\n"),
	lastrep.zprl_type,
	rep.zprl_type,
	lastrep.zprl_parity,
	rep.zprl_parity);
	else
	return (NULL);
	}
	} else if (strcmp(lastrep.zprl_type, rep.zprl_type) !=
	0) {
	if (ret != NULL)
	free(ret);
	ret = NULL;
	if (fatal)
	vdev_error(gettext(
	"mismatched replication level: "
	"both %s and %s vdevs are "
	"present\n"),
	lastrep.zprl_type, rep.zprl_type);
	else
	return (NULL);
	} else if (lastrep.zprl_parity != rep.zprl_parity) {
	if (ret)
	free(ret);
	ret = NULL;
	if (fatal)
	vdev_error(gettext(
	"mismatched replication level: "
	"both %llu and %llu device parity "
	"%s vdevs are present\n"),
	lastrep.zprl_parity,
	rep.zprl_parity,
	rep.zprl_type);
	else
	return (NULL);
	} else if (lastrep.zprl_children != rep.zprl_children) {
	if (ret)
	free(ret);
	ret = NULL;
	if (fatal)
	vdev_error(gettext(
	"mismatched replication level: "
	"both %llu-way and %llu-way %s "
	"vdevs are present\n"),
	lastrep.zprl_children,
	rep.zprl_children,
	rep.zprl_type);
	else
	return (NULL);
	}
	}
	lastrep = rep;
	}

	if (ret != NULL)
	*ret = rep;

	return (ret);
	}

	/*
	* Check the replication level of the vdev spec against the current pool. Calls
	* get_replication() to make sure the new spec is self-consistent. If the pool
	* has a consistent replication level, then we ignore any errors. Otherwise,
	* report any difference between the two.
	*/
	static int
	check_replication(nvlist_t config, nvlist_t newroot)
	{
	nvlist_t **child;
	uint_t children;
	replication_level_t current = NULL, new;
	replication_level_t raidz, mirror;
	int ret;

	/*
	* If we have a current pool configuration, check to see if it's
	* self-consistent. If not, simply return success.
	*/
	if (config != NULL) {
	nvlist_t *nvroot;

	verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
	&nvroot) == 0);
	if ((current = get_replication(nvroot, B_FALSE)) == NULL)
	return (0);
	}
	/*
	* for spares there may be no children, and therefore no
	* replication level to check
	*/
	if ((nvlist_lookup_nvlist_array(newroot, ZPOOL_CONFIG_CHILDREN,
	&child, &children) != 0) \|\| (children == 0)) {
	free(current);
	return (0);
	}

	/*
	* If all we have is logs then there's no replication level to check.
	*/
	if (num_logs(newroot) == children) {
	free(current);
	return (0);
	}

	/*
	* Get the replication level of the new vdev spec, reporting any
	* inconsistencies found.
	*/
	if ((new = get_replication(newroot, B_TRUE)) == NULL) {
	free(current);
	return (-1);
	}

	/*
	* Check to see if the new vdev spec matches the replication level of
	* the current pool.
	*/
	ret = 0;
	if (current != NULL) {
	if (is_raidz_mirror(current, new, &raidz, &mirror) \|\|
	is_raidz_mirror(new, current, &raidz, &mirror)) {
	if (raidz->zprl_parity != mirror->zprl_children - 1) {
	vdev_error(gettext(
	"mismatched replication level: pool and "
	"new vdev with different redundancy, %s "
	"and %s vdevs, %llu vs. %llu (%llu-way)\n"),
	raidz->zprl_type,
	mirror->zprl_type,
	raidz->zprl_parity,
	mirror->zprl_children - 1,
	mirror->zprl_children);
	ret = -1;
	}
	} else if (strcmp(current->zprl_type, new->zprl_type) != 0) {
	vdev_error(gettext(
	"mismatched replication level: pool uses %s "
	"and new vdev is %s\n"),
	current->zprl_type, new->zprl_type);
	ret = -1;
	} else if (current->zprl_parity != new->zprl_parity) {
	vdev_error(gettext(
	"mismatched replication level: pool uses %llu "
	"device parity and new vdev uses %llu\n"),
	current->zprl_parity, new->zprl_parity);
	ret = -1;
	} else if (current->zprl_children != new->zprl_children) {
	vdev_error(gettext(
	"mismatched replication level: pool uses %llu-way "
	"%s and new vdev uses %llu-way %s\n"),
	current->zprl_children, current->zprl_type,
	new->zprl_children, new->zprl_type);
	ret = -1;
	}
	}

	free(new);
	if (current != NULL)
	free(current);

	return (ret);
	}

	static int
	zero_label(char *path)
	{
	const int size = 4096;
	char buf[size];
	int err, fd;

	if ((fd = open(path, O_WRONLY\|O_EXCL)) < 0) {
	(void) fprintf(stderr, gettext("cannot open '%s': %s\n"),
	path, strerror(errno));
	return (-1);
	}

	memset(buf, 0, size);
	err = write(fd, buf, size);
	(void) fdatasync(fd);
	(void) close(fd);

	if (err == -1) {
	(void) fprintf(stderr, gettext("cannot zero first %d bytes "
	"of '%s': %s\n"), size, path, strerror(errno));
	return (-1);
	}

	if (err != size) {
	(void) fprintf(stderr, gettext("could only zero %d/%d bytes "
	"of '%s'\n"), err, size, path);
	return (-1);
	}

	return (0);
	}

	/*
	* Go through and find any whole disks in the vdev specification, labelling them
	* as appropriate. When constructing the vdev spec, we were unable to open this
	* device in order to provide a devid. Now that we have labelled the disk and
	* know that slice 0 is valid, we can construct the devid now.
	*
	* If the disk was already labeled with an EFI label, we will have gotten the
	* devid already (because we were able to open the whole disk). Otherwise, we
	* need to get the devid after we label the disk.
	*/
	static int
	make_disks(zpool_handle_t zhp, nvlist_t nv)
	{
	nvlist_t **child;
	uint_t c, children;
	char type, path;
	char devpath[MAXPATHLEN];
	char udevpath[MAXPATHLEN];
	uint64_t wholedisk;
	struct stat64 statbuf;
	int is_exclusive = 0;
	int fd;
	int ret;

	verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &type) == 0);

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
	&child, &children) != 0) {

	if (strcmp(type, VDEV_TYPE_DISK) != 0)
	return (0);

	/*
	* We have a disk device. If this is a whole disk write
	* out the efi partition table, otherwise write zero's to
	* the first 4k of the partition. This is to ensure that
	* libblkid will not misidentify the partition due to a
	* magic value left by the previous filesystem.
	*/
	verify(!nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path));
	verify(!nvlist_lookup_uint64(nv, ZPOOL_CONFIG_WHOLE_DISK,
	&wholedisk));

	if (!wholedisk) {
	/*
	* Update device id string for mpath nodes (Linux only)
	*/
	if (is_mpath_whole_disk(path))
	update_vdev_config_dev_strs(nv);

	if (!is_spare(NULL, path))
	(void) zero_label(path);
	return (0);
	}

	if (realpath(path, devpath) == NULL) {
	ret = errno;
	(void) fprintf(stderr,
	gettext("cannot resolve path '%s'\n"), path);
	return (ret);
	}

	/*
	* Remove any previously existing symlink from a udev path to
	* the device before labeling the disk. This ensures that
	* only newly created links are used. Otherwise there is a
	* window between when udev deletes and recreates the link
	* during which access attempts will fail with ENOENT.
	*/
	strlcpy(udevpath, path, MAXPATHLEN);
	(void) zfs_append_partition(udevpath, MAXPATHLEN);

	fd = open(devpath, O_RDWR\|O_EXCL);
	if (fd == -1) {
	if (errno == EBUSY)
	is_exclusive = 1;
	#ifdef __FreeBSD__
	if (errno == EPERM)
	is_exclusive = 1;
	#endif
	} else {
	(void) close(fd);
	}

	/*
	* If the partition exists, contains a valid spare label,
	* and is opened exclusively there is no need to partition
	* it. Hot spares have already been partitioned and are
	* held open exclusively by the kernel as a safety measure.
	*
	* If the provided path is for a /dev/disk/ device its
	* symbolic link will be removed, partition table created,
	* and then block until udev creates the new link.
	*/
	if (!is_exclusive && !is_spare(NULL, udevpath)) {
	char *devnode = strrchr(devpath, '/') + 1;

	ret = strncmp(udevpath, UDISK_ROOT, strlen(UDISK_ROOT));
	if (ret == 0) {
	ret = lstat64(udevpath, &statbuf);
	if (ret == 0 && S_ISLNK(statbuf.st_mode))
	(void) unlink(udevpath);
	}

	/*
	* When labeling a pool the raw device node name
	* is provided as it appears under /dev/.
	*/
	if (zpool_label_disk(g_zfs, zhp, devnode) == -1)
	return (-1);

	/*
	* Wait for udev to signal the device is available
	* by the provided path.
	*/
	ret = zpool_label_disk_wait(udevpath, DISK_LABEL_WAIT);
	if (ret) {
	(void) fprintf(stderr,
	gettext("missing link: %s was "
	"partitioned but %s is missing\n"),
	devnode, udevpath);
	return (ret);
	}

	ret = zero_label(udevpath);
	if (ret)
	return (ret);
	}

	/*
	* Update the path to refer to the partition. The presence of
	* the 'whole_disk' field indicates to the CLI that we should
	* chop off the partition number when displaying the device in
	* future output.
	*/
	verify(nvlist_add_string(nv, ZPOOL_CONFIG_PATH, udevpath) == 0);

	/*
	* Update device id strings for whole disks (Linux only)
	*/
	update_vdev_config_dev_strs(nv);

	return (0);
	}

	for (c = 0; c < children; c++)
	if ((ret = make_disks(zhp, child[c])) != 0)
	return (ret);

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_SPARES,
	&child, &children) == 0)
	for (c = 0; c < children; c++)
	if ((ret = make_disks(zhp, child[c])) != 0)
	return (ret);

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_L2CACHE,
	&child, &children) == 0)
	for (c = 0; c < children; c++)
	if ((ret = make_disks(zhp, child[c])) != 0)
	return (ret);

	return (0);
	}

	/*
	* Go through and find any devices that are in use. We rely on libdiskmgt for
	* the majority of this task.
	*/
	static boolean_t
	is_device_in_use(nvlist_t config, nvlist_t nv, boolean_t force,
	boolean_t replacing, boolean_t isspare)
	{
	nvlist_t **child;
	uint_t c, children;
	char type, path;
	int ret = 0;
	char buf[MAXPATHLEN];
	uint64_t wholedisk = B_FALSE;
	boolean_t anyinuse = B_FALSE;

	verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &type) == 0);

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
	&child, &children) != 0) {

	verify(!nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path));
	if (strcmp(type, VDEV_TYPE_DISK) == 0)
	verify(!nvlist_lookup_uint64(nv,
	ZPOOL_CONFIG_WHOLE_DISK, &wholedisk));

	/*
	* As a generic check, we look to see if this is a replace of a
	* hot spare within the same pool. If so, we allow it
	* regardless of what libblkid or zpool_in_use() says.
	*/
	if (replacing) {
	(void) strlcpy(buf, path, sizeof (buf));
	if (wholedisk) {
	ret = zfs_append_partition(buf, sizeof (buf));
	if (ret == -1)
	return (-1);
	}

	if (is_spare(config, buf))
	return (B_FALSE);
	}

	if (strcmp(type, VDEV_TYPE_DISK) == 0)
	ret = check_device(path, force, isspare, wholedisk);

	else if (strcmp(type, VDEV_TYPE_FILE) == 0)
	ret = check_file(path, force, isspare);

	return (ret != 0);
	}

	for (c = 0; c < children; c++)
	if (is_device_in_use(config, child[c], force, replacing,
	B_FALSE))
	anyinuse = B_TRUE;

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_SPARES,
	&child, &children) == 0)
	for (c = 0; c < children; c++)
	if (is_device_in_use(config, child[c], force, replacing,
	B_TRUE))
	anyinuse = B_TRUE;

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_L2CACHE,
	&child, &children) == 0)
	for (c = 0; c < children; c++)
	if (is_device_in_use(config, child[c], force, replacing,
	B_FALSE))
	anyinuse = B_TRUE;

	return (anyinuse);
	}

	/*
	* Returns the parity level extracted from a raidz or draid type.
	* If the parity cannot be determined zero is returned.
	*/
	static int
	get_parity(const char *type)
	{
	long parity = 0;
	const char *p;

	if (strncmp(type, VDEV_TYPE_RAIDZ, strlen(VDEV_TYPE_RAIDZ)) == 0) {
	p = type + strlen(VDEV_TYPE_RAIDZ);

	if (*p == '\0') {
	/* when unspecified default to single parity */
	return (1);
	} else if (*p == '0') {
	/* no zero prefixes allowed */
	return (0);
	} else {
	/* 0-3, no suffixes allowed */
	char *end;
	errno = 0;
	parity = strtol(p, &end, 10);
	if (errno != 0 \|\| *end != '\0' \|\|
	parity < 1 \|\| parity > VDEV_RAIDZ_MAXPARITY) {
	return (0);
	}
	}
	} else if (strncmp(type, VDEV_TYPE_DRAID,
	strlen(VDEV_TYPE_DRAID)) == 0) {
	p = type + strlen(VDEV_TYPE_DRAID);

	if (p == '\0' \|\| p == ':') {
	/* when unspecified default to single parity */
	return (1);
	} else if (*p == '0') {
	/* no zero prefixes allowed */
	return (0);
	} else {
	/* 0-3, allowed suffixes: '\0' or ':' */
	char *end;
	errno = 0;
	parity = strtol(p, &end, 10);
	if (errno != 0 \|\|
	parity < 1 \|\| parity > VDEV_DRAID_MAXPARITY \|\|
	(end != '\0' && end != ':')) {
	return (0);
	}
	}
	}

	return ((int)parity);
	}

	/*
	* Assign the minimum and maximum number of devices allowed for
	* the specified type. On error NULL is returned, otherwise the
	* type prefix is returned (raidz, mirror, etc).
	*/
	static const char *
	is_grouping(const char type, int mindev, int *maxdev)
	{
	int nparity;

	if (strncmp(type, VDEV_TYPE_RAIDZ, strlen(VDEV_TYPE_RAIDZ)) == 0 \|\|
	strncmp(type, VDEV_TYPE_DRAID, strlen(VDEV_TYPE_DRAID)) == 0) {
	nparity = get_parity(type);
	if (nparity == 0)
	return (NULL);
	if (mindev != NULL)
	*mindev = nparity + 1;
	if (maxdev != NULL)
	*maxdev = 255;

	if (strncmp(type, VDEV_TYPE_RAIDZ,
	strlen(VDEV_TYPE_RAIDZ)) == 0) {
	return (VDEV_TYPE_RAIDZ);
	} else {
	return (VDEV_TYPE_DRAID);
	}
	}

	if (maxdev != NULL)
	*maxdev = INT_MAX;

	if (strcmp(type, "mirror") == 0) {
	if (mindev != NULL)
	*mindev = 2;
	return (VDEV_TYPE_MIRROR);
	}

	if (strcmp(type, "spare") == 0) {
	if (mindev != NULL)
	*mindev = 1;
	return (VDEV_TYPE_SPARE);
	}

	if (strcmp(type, "log") == 0) {
	if (mindev != NULL)
	*mindev = 1;
	return (VDEV_TYPE_LOG);
	}

	if (strcmp(type, VDEV_ALLOC_BIAS_SPECIAL) == 0 \|\|
	strcmp(type, VDEV_ALLOC_BIAS_DEDUP) == 0) {
	if (mindev != NULL)
	*mindev = 1;
	return (type);
	}

	if (strcmp(type, "cache") == 0) {
	if (mindev != NULL)
	*mindev = 1;
	return (VDEV_TYPE_L2CACHE);
	}

	return (NULL);
	}

	/*
	* Extract the configuration parameters encoded in the dRAID type and
	* use them to generate a dRAID configuration. The expected format is:
	*
	* draid[<parity>][:<data><d\|D>][:<children><c\|C>][:<spares><s\|S>]
	*
	* The intent is to be able to generate a good configuration when no
	* additional information is provided. The only mandatory component
	* of the 'type' is the 'draid' prefix. If a value is not provided
	* then reasonable defaults are used. The optional components may
	* appear in any order but the d/s/c suffix is required.
	*
	* Valid inputs:
	* - data: number of data devices per group (1-255)
	* - parity: number of parity blocks per group (1-3)
	* - spares: number of distributed spare (0-100)
	* - children: total number of devices (1-255)
	*
	* Examples:
	* - zpool create tank draid <devices...>
	* - zpool create tank draid2:8d:51c:2s <devices...>
	*/
	static int
	draid_config_by_type(nvlist_t nv, const char type, uint64_t children)
	{
	uint64_t nparity = 1;
	uint64_t nspares = 0;
	uint64_t ndata = UINT64_MAX;
	uint64_t ngroups = 1;
	long value;

	if (strncmp(type, VDEV_TYPE_DRAID, strlen(VDEV_TYPE_DRAID)) != 0)
	return (EINVAL);

	nparity = (uint64_t)get_parity(type);
	if (nparity == 0)
	return (EINVAL);

	char p = (char )type;
	while ((p = strchr(p, ':')) != NULL) {
	char *end;

	p = p + 1;
	errno = 0;

	if (!isdigit(p[0])) {
	(void) fprintf(stderr, gettext("invalid dRAID "
	"syntax; expected [:<number><c\|d\|s>] not '%s'\n"),
	type);
	return (EINVAL);
	}

	/* Expected non-zero value with c/d/s suffix */
	value = strtol(p, &end, 10);
	char suffix = tolower(*end);
	if (errno != 0 \|\|
	(suffix != 'c' && suffix != 'd' && suffix != 's')) {
	(void) fprintf(stderr, gettext("invalid dRAID "
	"syntax; expected [:<number><c\|d\|s>] not '%s'\n"),
	type);
	return (EINVAL);
	}

	if (suffix == 'c') {
	if ((uint64_t)value != children) {
	fprintf(stderr,
	gettext("invalid number of dRAID children; "
	"%llu required but %llu provided\n"),
	(u_longlong_t)value,
	(u_longlong_t)children);
	return (EINVAL);
	}
	} else if (suffix == 'd') {
	ndata = (uint64_t)value;
	} else if (suffix == 's') {
	nspares = (uint64_t)value;
	} else {
	verify(0); /* Unreachable */
	}
	}

	/*
	* When a specific number of data disks is not provided limit a
	* redundancy group to 8 data disks. This value was selected to
	* provide a reasonable tradeoff between capacity and performance.
	*/
	if (ndata == UINT64_MAX) {
	if (children > nspares + nparity) {
	ndata = MIN(children - nspares - nparity, 8);
	} else {
	fprintf(stderr, gettext("request number of "
	"distributed spares %llu and parity level %llu\n"
	"leaves no disks available for data\n"),
	(u_longlong_t)nspares, (u_longlong_t)nparity);
	return (EINVAL);
	}
	}

	/* Verify the maximum allowed group size is never exceeded. */
	if (ndata == 0 \|\| (ndata + nparity > children - nspares)) {
	fprintf(stderr, gettext("requested number of dRAID data "
	"disks per group %llu is too high,\nat most %llu disks "
	"are available for data\n"), (u_longlong_t)ndata,
	(u_longlong_t)(children - nspares - nparity));
	return (EINVAL);
	}

	if (nparity == 0 \|\| nparity > VDEV_DRAID_MAXPARITY) {
	fprintf(stderr,
	gettext("invalid dRAID parity level %llu; must be "
	"between 1 and %d\n"), (u_longlong_t)nparity,
	VDEV_DRAID_MAXPARITY);
	return (EINVAL);
	}

	/*
	* Verify the requested number of spares can be satisfied.
	* An arbitrary limit of 100 distributed spares is applied.
	*/
	if (nspares > 100 \|\| nspares > (children - (ndata + nparity))) {
	fprintf(stderr,
	gettext("invalid number of dRAID spares %llu; additional "
	"disks would be required\n"), (u_longlong_t)nspares);
	return (EINVAL);
	}

	/* Verify the requested number children is sufficient. */
	if (children < (ndata + nparity + nspares)) {
	fprintf(stderr, gettext("%llu disks were provided, but at "
	"least %llu disks are required for this config\n"),
	(u_longlong_t)children,
	(u_longlong_t)(ndata + nparity + nspares));
	}

	if (children > VDEV_DRAID_MAX_CHILDREN) {
	fprintf(stderr, gettext("%llu disks were provided, but "
	"dRAID only supports up to %u disks"),
	(u_longlong_t)children, VDEV_DRAID_MAX_CHILDREN);
	}

	/*
	* Calculate the minimum number of groups required to fill a slice.
	* This is the LCM of the stripe width (ndata + nparity) and the
	* number of data drives (children - nspares).
	*/
	while (ngroups * (ndata + nparity) % (children - nspares) != 0)
	ngroups++;

	/* Store the basic dRAID configuration. */
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_NPARITY, nparity);
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_DRAID_NDATA, ndata);
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_DRAID_NSPARES, nspares);
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_DRAID_NGROUPS, ngroups);

	return (0);
	}

	/*
	* Construct a syntactically valid vdev specification,
	* and ensure that all devices and files exist and can be opened.
	* Note: we don't bother freeing anything in the error paths
	* because the program is just going to exit anyway.
	*/
	static nvlist_t *
	construct_spec(nvlist_t props, int argc, char *argv)
	{
	nvlist_t nvroot, nv, top, spares, **l2cache;
	int t, toplevels, mindev, maxdev, nspares, nlogs, nl2cache;
	const char type, fulltype;
	boolean_t is_log, is_special, is_dedup, is_spare;
	boolean_t seen_logs;

	top = NULL;
	toplevels = 0;
	spares = NULL;
	l2cache = NULL;
	nspares = 0;
	nlogs = 0;
	nl2cache = 0;
	is_log = is_special = is_dedup = is_spare = B_FALSE;
	seen_logs = B_FALSE;
	nvroot = NULL;

	while (argc > 0) {
	fulltype = argv[0];
	nv = NULL;

	/*
	* If it's a mirror, raidz, or draid the subsequent arguments
	* are its leaves -- until we encounter the next mirror,
	* raidz or draid.
	*/
	if ((type = is_grouping(fulltype, &mindev, &maxdev)) != NULL) {
	nvlist_t **child = NULL;
	int c, children = 0;

	if (strcmp(type, VDEV_TYPE_SPARE) == 0) {
	if (spares != NULL) {
	(void) fprintf(stderr,
	gettext("invalid vdev "
	"specification: 'spare' can be "
	"specified only once\n"));
	goto spec_out;
	}
	is_spare = B_TRUE;
	is_log = is_special = is_dedup = B_FALSE;
	}

	if (strcmp(type, VDEV_TYPE_LOG) == 0) {
	if (seen_logs) {
	(void) fprintf(stderr,
	gettext("invalid vdev "
	"specification: 'log' can be "
	"specified only once\n"));
	goto spec_out;
	}
	seen_logs = B_TRUE;
	is_log = B_TRUE;
	is_special = is_dedup = is_spare = B_FALSE;
	argc--;
	argv++;
	/*
	* A log is not a real grouping device.
	* We just set is_log and continue.
	*/
	continue;
	}

	if (strcmp(type, VDEV_ALLOC_BIAS_SPECIAL) == 0) {
	is_special = B_TRUE;
	is_log = is_dedup = is_spare = B_FALSE;
	argc--;
	argv++;
	continue;
	}

	if (strcmp(type, VDEV_ALLOC_BIAS_DEDUP) == 0) {
	is_dedup = B_TRUE;
	is_log = is_special = is_spare = B_FALSE;
	argc--;
	argv++;
	continue;
	}

	if (strcmp(type, VDEV_TYPE_L2CACHE) == 0) {
	if (l2cache != NULL) {
	(void) fprintf(stderr,
	gettext("invalid vdev "
	"specification: 'cache' can be "
	"specified only once\n"));
	goto spec_out;
	}
	is_log = is_special = B_FALSE;
	is_dedup = is_spare = B_FALSE;
	}

	if (is_log \|\| is_special \|\| is_dedup) {
	if (strcmp(type, VDEV_TYPE_MIRROR) != 0) {
	(void) fprintf(stderr,
	gettext("invalid vdev "
	"specification: unsupported '%s' "
	"device: %s\n"), is_log ? "log" :
	"special", type);
	goto spec_out;
	}
	nlogs++;
	}

	for (c = 1; c < argc; c++) {
	if (is_grouping(argv[c], NULL, NULL) != NULL)
	break;

	children++;
	child = realloc(child,
	children * sizeof (nvlist_t *));
	if (child == NULL)
	zpool_no_memory();
	if ((nv = make_leaf_vdev(props, argv[c],
	!(is_log \|\| is_special \|\| is_dedup \|\|
	is_spare))) == NULL) {
	for (c = 0; c < children - 1; c++)
	nvlist_free(child[c]);
	free(child);
	goto spec_out;
	}

	child[children - 1] = nv;
	}

	if (children < mindev) {
	(void) fprintf(stderr, gettext("invalid vdev "
	"specification: %s requires at least %d "
	"devices\n"), argv[0], mindev);
	for (c = 0; c < children; c++)
	nvlist_free(child[c]);
	free(child);
	goto spec_out;
	}

	if (children > maxdev) {
	(void) fprintf(stderr, gettext("invalid vdev "
	"specification: %s supports no more than "
	"%d devices\n"), argv[0], maxdev);
	for (c = 0; c < children; c++)
	nvlist_free(child[c]);
	free(child);
	goto spec_out;
	}

	argc -= c;
	argv += c;

	if (strcmp(type, VDEV_TYPE_SPARE) == 0) {
	spares = child;
	nspares = children;
	continue;
	} else if (strcmp(type, VDEV_TYPE_L2CACHE) == 0) {
	l2cache = child;
	nl2cache = children;
	continue;
	} else {
	/* create a top-level vdev with children */
	verify(nvlist_alloc(&nv, NV_UNIQUE_NAME,
	0) == 0);
	verify(nvlist_add_string(nv, ZPOOL_CONFIG_TYPE,
	type) == 0);
	verify(nvlist_add_uint64(nv,
	ZPOOL_CONFIG_IS_LOG, is_log) == 0);
	if (is_log) {
	verify(nvlist_add_string(nv,
	ZPOOL_CONFIG_ALLOCATION_BIAS,
	VDEV_ALLOC_BIAS_LOG) == 0);
	}
	if (is_special) {
	verify(nvlist_add_string(nv,
	ZPOOL_CONFIG_ALLOCATION_BIAS,
	VDEV_ALLOC_BIAS_SPECIAL) == 0);
	}
	if (is_dedup) {
	verify(nvlist_add_string(nv,
	ZPOOL_CONFIG_ALLOCATION_BIAS,
	VDEV_ALLOC_BIAS_DEDUP) == 0);
	}
	if (strcmp(type, VDEV_TYPE_RAIDZ) == 0) {
	verify(nvlist_add_uint64(nv,
	ZPOOL_CONFIG_NPARITY,
	mindev - 1) == 0);
	}
	if (strcmp(type, VDEV_TYPE_DRAID) == 0) {
	if (draid_config_by_type(nv,
	fulltype, children) != 0) {
	for (c = 0; c < children; c++)
	nvlist_free(child[c]);
	free(child);
	goto spec_out;
	}
	}
	verify(nvlist_add_nvlist_array(nv,
	ZPOOL_CONFIG_CHILDREN, child,
	children) == 0);

	for (c = 0; c < children; c++)
	nvlist_free(child[c]);
	free(child);
	}
	} else {
	/*
	* We have a device. Pass off to make_leaf_vdev() to
	* construct the appropriate nvlist describing the vdev.
	*/
	if ((nv = make_leaf_vdev(props, argv[0], !(is_log \|\|
	is_special \|\| is_dedup \|\| is_spare))) == NULL)
	goto spec_out;

	verify(nvlist_add_uint64(nv,
	ZPOOL_CONFIG_IS_LOG, is_log) == 0);
	if (is_log) {
	verify(nvlist_add_string(nv,
	ZPOOL_CONFIG_ALLOCATION_BIAS,
	VDEV_ALLOC_BIAS_LOG) == 0);
	nlogs++;
	}

	if (is_special) {
	verify(nvlist_add_string(nv,
	ZPOOL_CONFIG_ALLOCATION_BIAS,
	VDEV_ALLOC_BIAS_SPECIAL) == 0);
	}
	if (is_dedup) {
	verify(nvlist_add_string(nv,
	ZPOOL_CONFIG_ALLOCATION_BIAS,
	VDEV_ALLOC_BIAS_DEDUP) == 0);
	}
	argc--;
	argv++;
	}

	toplevels++;
	top = realloc(top, toplevels * sizeof (nvlist_t *));
	if (top == NULL)
	zpool_no_memory();
	top[toplevels - 1] = nv;
	}

	if (toplevels == 0 && nspares == 0 && nl2cache == 0) {
	(void) fprintf(stderr, gettext("invalid vdev "
	"specification: at least one toplevel vdev must be "
	"specified\n"));
	goto spec_out;
	}

	if (seen_logs && nlogs == 0) {
	(void) fprintf(stderr, gettext("invalid vdev specification: "
	"log requires at least 1 device\n"));
	goto spec_out;
	}

	/*
	* Finally, create nvroot and add all top-level vdevs to it.
	*/
	verify(nvlist_alloc(&nvroot, NV_UNIQUE_NAME, 0) == 0);
	verify(nvlist_add_string(nvroot, ZPOOL_CONFIG_TYPE,
	VDEV_TYPE_ROOT) == 0);
	verify(nvlist_add_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN,
	top, toplevels) == 0);
	if (nspares != 0)
	verify(nvlist_add_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES,
	spares, nspares) == 0);
	if (nl2cache != 0)
	verify(nvlist_add_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE,
	l2cache, nl2cache) == 0);

	spec_out:
	for (t = 0; t < toplevels; t++)
	nvlist_free(top[t]);
	for (t = 0; t < nspares; t++)
	nvlist_free(spares[t]);
	for (t = 0; t < nl2cache; t++)
	nvlist_free(l2cache[t]);

	free(spares);
	free(l2cache);
	free(top);

	return (nvroot);
	}

	nvlist_t *
	split_mirror_vdev(zpool_handle_t zhp, char newname, nvlist_t *props,
	splitflags_t flags, int argc, char **argv)
	{
	nvlist_t newroot = NULL, *child;
	uint_t c, children;

	if (argc > 0) {
	if ((newroot = construct_spec(props, argc, argv)) == NULL) {
	(void) fprintf(stderr, gettext("Unable to build a "
	"pool from the specified devices\n"));
	return (NULL);
	}

	if (!flags.dryrun && make_disks(zhp, newroot) != 0) {
	nvlist_free(newroot);
	return (NULL);
	}

	/* avoid any tricks in the spec */
	verify(nvlist_lookup_nvlist_array(newroot,
	ZPOOL_CONFIG_CHILDREN, &child, &children) == 0);
	for (c = 0; c < children; c++) {
	char *path;
	const char *type;
	int min, max;

	verify(nvlist_lookup_string(child[c],
	ZPOOL_CONFIG_PATH, &path) == 0);
	if ((type = is_grouping(path, &min, &max)) != NULL) {
	(void) fprintf(stderr, gettext("Cannot use "
	"'%s' as a device for splitting\n"), type);
	nvlist_free(newroot);
	return (NULL);
	}
	}
	}

	if (zpool_vdev_split(zhp, newname, &newroot, props, flags) != 0) {
	nvlist_free(newroot);
	return (NULL);
	}

	return (newroot);
	}

	static int
	num_normal_vdevs(nvlist_t *nvroot)
	{
	nvlist_t **top;
	uint_t t, toplevels, normal = 0;

	verify(nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN,
	&top, &toplevels) == 0);

	for (t = 0; t < toplevels; t++) {
	uint64_t log = B_FALSE;

	(void) nvlist_lookup_uint64(top[t], ZPOOL_CONFIG_IS_LOG, &log);
	if (log)
	continue;
	if (nvlist_exists(top[t], ZPOOL_CONFIG_ALLOCATION_BIAS))
	continue;

	normal++;
	}

	return (normal);
	}

	/*
	* Get and validate the contents of the given vdev specification. This ensures
	* that the nvlist returned is well-formed, that all the devices exist, and that
	* they are not currently in use by any other known consumer. The 'poolconfig'
	* parameter is the current configuration of the pool when adding devices
	* existing pool, and is used to perform additional checks, such as changing the
	* replication level of the pool. It can be 'NULL' to indicate that this is a
	* new pool. The 'force' flag controls whether devices should be forcefully
	* added, even if they appear in use.
	*/
	nvlist_t *
	make_root_vdev(zpool_handle_t zhp, nvlist_t props, int force, int check_rep,
	boolean_t replacing, boolean_t dryrun, int argc, char **argv)
	{
	nvlist_t *newroot;
	nvlist_t *poolconfig = NULL;
	is_force = force;

	/*
	* Construct the vdev specification. If this is successful, we know
	* that we have a valid specification, and that all devices can be
	* opened.
	*/
	if ((newroot = construct_spec(props, argc, argv)) == NULL)
	return (NULL);

	if (zhp && ((poolconfig = zpool_get_config(zhp, NULL)) == NULL)) {
	nvlist_free(newroot);
	return (NULL);
	}

	/*
	* Validate each device to make sure that it's not shared with another
	* subsystem. We do this even if 'force' is set, because there are some
	* uses (such as a dedicated dump device) that even '-f' cannot
	* override.
	*/
	if (is_device_in_use(poolconfig, newroot, force, replacing, B_FALSE)) {
	nvlist_free(newroot);
	return (NULL);
	}

	/*
	* Check the replication level of the given vdevs and report any errors
	* found. We include the existing pool spec, if any, as we need to
	* catch changes against the existing replication level.
	*/
	if (check_rep && check_replication(poolconfig, newroot) != 0) {
	nvlist_free(newroot);
	return (NULL);
	}

	/*
	* On pool create the new vdev spec must have one normal vdev.
	*/
	if (poolconfig == NULL && num_normal_vdevs(newroot) == 0) {
	vdev_error(gettext("at least one general top-level vdev must "
	"be specified\n"));
	nvlist_free(newroot);
	return (NULL);
	}

	/*
	* Run through the vdev specification and label any whole disks found.
	*/
	if (!dryrun && make_disks(zhp, newroot) != 0) {
	nvlist_free(newroot);
	return (NULL);
	}

	return (newroot);
	}
	diff --git a/sys/contrib/openzfs/cmd/zstreamdump/zstreamdump b/sys/contrib/openzfs/cmd/zstreamdump/zstreamdump
	index fbf02ee687f6..17f1aa4b2206 100755
	--- a/sys/contrib/openzfs/cmd/zstreamdump/zstreamdump
	+++ b/sys/contrib/openzfs/cmd/zstreamdump/zstreamdump
	@@ -1,3 +1,3 @@
	#!/bin/sh

	-zstream dump "$@"
	+exec zstream dump "$@"
	diff --git a/sys/contrib/openzfs/cmd/ztest/ztest.c b/sys/contrib/openzfs/cmd/ztest/ztest.c
	index 7193eafe3d21..24197d27b065 100644
	--- a/sys/contrib/openzfs/cmd/ztest/ztest.c
	+++ b/sys/contrib/openzfs/cmd/ztest/ztest.c
	@@ -1,8063 +1,8063 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2011, 2018 by Delphix. All rights reserved.
	* Copyright 2011 Nexenta Systems, Inc. All rights reserved.
	* Copyright (c) 2013 Steven Hartland. All rights reserved.
	* Copyright (c) 2014 Integros [integros.com]
	* Copyright 2017 Joyent, Inc.
	* Copyright (c) 2017, Intel Corporation.
	*/

	/*
	* The objective of this program is to provide a DMU/ZAP/SPA stress test
	* that runs entirely in userland, is easy to use, and easy to extend.
	*
	* The overall design of the ztest program is as follows:
	*
	* (1) For each major functional area (e.g. adding vdevs to a pool,
	* creating and destroying datasets, reading and writing objects, etc)
	* we have a simple routine to test that functionality. These
	* individual routines do not have to do anything "stressful".
	*
	* (2) We turn these simple functionality tests into a stress test by
	* running them all in parallel, with as many threads as desired,
	* and spread across as many datasets, objects, and vdevs as desired.
	*
	* (3) While all this is happening, we inject faults into the pool to
	* verify that self-healing data really works.
	*
	* (4) Every time we open a dataset, we change its checksum and compression
	* functions. Thus even individual objects vary from block to block
	* in which checksum they use and whether they're compressed.
	*
	* (5) To verify that we never lose on-disk consistency after a crash,
	* we run the entire test in a child of the main process.
	* At random times, the child self-immolates with a SIGKILL.
	* This is the software equivalent of pulling the power cord.
	* The parent then runs the test again, using the existing
	* storage pool, as many times as desired. If backwards compatibility
	* testing is enabled ztest will sometimes run the "older" version
	* of ztest after a SIGKILL.
	*
	* (6) To verify that we don't have future leaks or temporal incursions,
	* many of the functional tests record the transaction group number
	* as part of their data. When reading old data, they verify that
	* the transaction group number is less than the current, open txg.
	* If you add a new test, please do this if applicable.
	*
	* (7) Threads are created with a reduced stack size, for sanity checking.
	* Therefore, it's important not to allocate huge buffers on the stack.
	*
	* When run with no arguments, ztest runs for about five minutes and
	* produces no output if successful. To get a little bit of information,
	* specify -V. To get more information, specify -VV, and so on.
	*
	* To turn this into an overnight stress test, use -T to specify run time.
	*
	* You can ask more vdevs [-v], datasets [-d], or threads [-t]
	* to increase the pool capacity, fanout, and overall stress level.
	*
	* Use the -k option to set the desired frequency of kills.
	*
	* When ztest invokes itself it passes all relevant information through a
	* temporary file which is mmap-ed in the child process. This allows shared
	* memory to survive the exec syscall. The ztest_shared_hdr_t struct is always
	* stored at offset 0 of this file and contains information on the size and
	* number of shared structures in the file. The information stored in this file
	* must remain backwards compatible with older versions of ztest so that
	* ztest can invoke them during backwards compatibility testing (-B).
	*/

	#include <sys/zfs_context.h>
	#include <sys/spa.h>
	#include <sys/dmu.h>
	#include <sys/txg.h>
	#include <sys/dbuf.h>
	#include <sys/zap.h>
	#include <sys/dmu_objset.h>
	#include <sys/poll.h>
	#include <sys/stat.h>
	#include <sys/time.h>
	#include <sys/wait.h>
	#include <sys/mman.h>
	#include <sys/resource.h>
	#include <sys/zio.h>
	#include <sys/zil.h>
	#include <sys/zil_impl.h>
	#include <sys/vdev_draid.h>
	#include <sys/vdev_impl.h>
	#include <sys/vdev_file.h>
	#include <sys/vdev_initialize.h>
	#include <sys/vdev_raidz.h>
	#include <sys/vdev_trim.h>
	#include <sys/spa_impl.h>
	#include <sys/metaslab_impl.h>
	#include <sys/dsl_prop.h>
	#include <sys/dsl_dataset.h>
	#include <sys/dsl_destroy.h>
	#include <sys/dsl_scan.h>
	#include <sys/zio_checksum.h>
	#include <sys/zfs_refcount.h>
	#include <sys/zfeature.h>
	#include <sys/dsl_userhold.h>
	#include <sys/abd.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <unistd.h>
	#include <signal.h>
	#include <umem.h>
	#include <ctype.h>
	#include <math.h>
	#include <sys/fs/zfs.h>
	#include <zfs_fletcher.h>
	#include <libnvpair.h>
	#include <libzutil.h>
	#include <sys/crypto/icp.h>
	#if (__GLIBC__ && !__UCLIBC__)
	#include <execinfo.h> /* for backtrace() */
	#endif

	static int ztest_fd_data = -1;
	static int ztest_fd_rand = -1;

	typedef struct ztest_shared_hdr {
	uint64_t zh_hdr_size;
	uint64_t zh_opts_size;
	uint64_t zh_size;
	uint64_t zh_stats_size;
	uint64_t zh_stats_count;
	uint64_t zh_ds_size;
	uint64_t zh_ds_count;
	} ztest_shared_hdr_t;

	static ztest_shared_hdr_t *ztest_shared_hdr;

	enum ztest_class_state {
	ZTEST_VDEV_CLASS_OFF,
	ZTEST_VDEV_CLASS_ON,
	ZTEST_VDEV_CLASS_RND
	};

	#define ZO_GVARS_MAX_ARGLEN ((size_t)64)
	#define ZO_GVARS_MAX_COUNT ((size_t)10)

	typedef struct ztest_shared_opts {
	char zo_pool[ZFS_MAX_DATASET_NAME_LEN];
	char zo_dir[ZFS_MAX_DATASET_NAME_LEN];
	char zo_alt_ztest[MAXNAMELEN];
	char zo_alt_libpath[MAXNAMELEN];
	uint64_t zo_vdevs;
	uint64_t zo_vdevtime;
	size_t zo_vdev_size;
	int zo_ashift;
	int zo_mirrors;
	int zo_raid_children;
	int zo_raid_parity;
	char zo_raid_type[8];
	int zo_draid_data;
	int zo_draid_spares;
	int zo_datasets;
	int zo_threads;
	uint64_t zo_passtime;
	uint64_t zo_killrate;
	int zo_verbose;
	int zo_init;
	uint64_t zo_time;
	uint64_t zo_maxloops;
	uint64_t zo_metaslab_force_ganging;
	int zo_mmp_test;
	int zo_special_vdevs;
	int zo_dump_dbgmsg;
	int zo_gvars_count;
	char zo_gvars[ZO_GVARS_MAX_COUNT][ZO_GVARS_MAX_ARGLEN];
	} ztest_shared_opts_t;

	static const ztest_shared_opts_t ztest_opts_defaults = {
	.zo_pool = "ztest",
	.zo_dir = "/tmp",
	.zo_alt_ztest = { '\0' },
	.zo_alt_libpath = { '\0' },
	.zo_vdevs = 5,
	.zo_ashift = SPA_MINBLOCKSHIFT,
	.zo_mirrors = 2,
	.zo_raid_children = 4,
	.zo_raid_parity = 1,
	.zo_raid_type = VDEV_TYPE_RAIDZ,
	.zo_vdev_size = SPA_MINDEVSIZE * 4, /* 256m default size */
	.zo_draid_data = 4, /* data drives */
	.zo_draid_spares = 1, /* distributed spares */
	.zo_datasets = 7,
	.zo_threads = 23,
	.zo_passtime = 60, /* 60 seconds */
	.zo_killrate = 70, /* 70% kill rate */
	.zo_verbose = 0,
	.zo_mmp_test = 0,
	.zo_init = 1,
	.zo_time = 300, /* 5 minutes */
	.zo_maxloops = 50, /* max loops during spa_freeze() */
	.zo_metaslab_force_ganging = 64 << 10,
	.zo_special_vdevs = ZTEST_VDEV_CLASS_RND,
	.zo_gvars_count = 0,
	};

	extern uint64_t metaslab_force_ganging;
	extern uint64_t metaslab_df_alloc_threshold;
	extern unsigned long zfs_deadman_synctime_ms;
	extern int metaslab_preload_limit;
	extern boolean_t zfs_compressed_arc_enabled;
	extern int zfs_abd_scatter_enabled;
	extern int dmu_object_alloc_chunk_shift;
	extern boolean_t zfs_force_some_double_word_sm_entries;
	extern unsigned long zio_decompress_fail_fraction;
	extern unsigned long zfs_reconstruct_indirect_damage_fraction;


	static ztest_shared_opts_t *ztest_shared_opts;
	static ztest_shared_opts_t ztest_opts;
	static char *ztest_wkeydata = "abcdefghijklmnopqrstuvwxyz012345";

	typedef struct ztest_shared_ds {
	uint64_t zd_seq;
	} ztest_shared_ds_t;

	static ztest_shared_ds_t *ztest_shared_ds;
	#define ZTEST_GET_SHARED_DS(d) (&ztest_shared_ds[d])

	#define BT_MAGIC 0x123456789abcdefULL
	#define MAXFAULTS(zs) \
	(MAX((zs)->zs_mirrors, 1) * (ztest_opts.zo_raid_parity + 1) - 1)

	enum ztest_io_type {
	ZTEST_IO_WRITE_TAG,
	ZTEST_IO_WRITE_PATTERN,
	ZTEST_IO_WRITE_ZEROES,
	ZTEST_IO_TRUNCATE,
	ZTEST_IO_SETATTR,
	ZTEST_IO_REWRITE,
	ZTEST_IO_TYPES
	};

	typedef struct ztest_block_tag {
	uint64_t bt_magic;
	uint64_t bt_objset;
	uint64_t bt_object;
	uint64_t bt_dnodesize;
	uint64_t bt_offset;
	uint64_t bt_gen;
	uint64_t bt_txg;
	uint64_t bt_crtxg;
	} ztest_block_tag_t;

	typedef struct bufwad {
	uint64_t bw_index;
	uint64_t bw_txg;
	uint64_t bw_data;
	} bufwad_t;

	/*
	* It would be better to use a rangelock_t per object. Unfortunately
	* the rangelock_t is not a drop-in replacement for rl_t, because we
	* still need to map from object ID to rangelock_t.
	*/
	typedef enum {
	RL_READER,
	RL_WRITER,
	RL_APPEND
	} rl_type_t;

	typedef struct rll {
	void *rll_writer;
	int rll_readers;
	kmutex_t rll_lock;
	kcondvar_t rll_cv;
	} rll_t;

	typedef struct rl {
	uint64_t rl_object;
	uint64_t rl_offset;
	uint64_t rl_size;
	rll_t *rl_lock;
	} rl_t;

	#define ZTEST_RANGE_LOCKS 64
	#define ZTEST_OBJECT_LOCKS 64

	/*
	* Object descriptor. Used as a template for object lookup/create/remove.
	*/
	typedef struct ztest_od {
	uint64_t od_dir;
	uint64_t od_object;
	dmu_object_type_t od_type;
	dmu_object_type_t od_crtype;
	uint64_t od_blocksize;
	uint64_t od_crblocksize;
	uint64_t od_crdnodesize;
	uint64_t od_gen;
	uint64_t od_crgen;
	char od_name[ZFS_MAX_DATASET_NAME_LEN];
	} ztest_od_t;

	/*
	* Per-dataset state.
	*/
	typedef struct ztest_ds {
	ztest_shared_ds_t *zd_shared;
	objset_t *zd_os;
	pthread_rwlock_t zd_zilog_lock;
	zilog_t *zd_zilog;
	ztest_od_t zd_od; / debugging aid */
	char zd_name[ZFS_MAX_DATASET_NAME_LEN];
	kmutex_t zd_dirobj_lock;
	rll_t zd_object_lock[ZTEST_OBJECT_LOCKS];
	rll_t zd_range_lock[ZTEST_RANGE_LOCKS];
	} ztest_ds_t;

	/*
	* Per-iteration state.
	*/
	typedef void ztest_func_t(ztest_ds_t *zd, uint64_t id);

	typedef struct ztest_info {
	ztest_func_t zi_func; / test function */
	uint64_t zi_iters; /* iterations per execution */
	uint64_t zi_interval; / execute every <interval> seconds */
	const char zi_funcname; / name of test function */
	} ztest_info_t;

	typedef struct ztest_shared_callstate {
	uint64_t zc_count; /* per-pass count */
	uint64_t zc_time; /* per-pass time */
	uint64_t zc_next; /* next time to call this function */
	} ztest_shared_callstate_t;

	static ztest_shared_callstate_t *ztest_shared_callstate;
	#define ZTEST_GET_SHARED_CALLSTATE(c) (&ztest_shared_callstate[c])

	ztest_func_t ztest_dmu_read_write;
	ztest_func_t ztest_dmu_write_parallel;
	ztest_func_t ztest_dmu_object_alloc_free;
	ztest_func_t ztest_dmu_object_next_chunk;
	ztest_func_t ztest_dmu_commit_callbacks;
	ztest_func_t ztest_zap;
	ztest_func_t ztest_zap_parallel;
	ztest_func_t ztest_zil_commit;
	ztest_func_t ztest_zil_remount;
	ztest_func_t ztest_dmu_read_write_zcopy;
	ztest_func_t ztest_dmu_objset_create_destroy;
	ztest_func_t ztest_dmu_prealloc;
	ztest_func_t ztest_fzap;
	ztest_func_t ztest_dmu_snapshot_create_destroy;
	ztest_func_t ztest_dsl_prop_get_set;
	ztest_func_t ztest_spa_prop_get_set;
	ztest_func_t ztest_spa_create_destroy;
	ztest_func_t ztest_fault_inject;
	ztest_func_t ztest_dmu_snapshot_hold;
	ztest_func_t ztest_mmp_enable_disable;
	ztest_func_t ztest_scrub;
	ztest_func_t ztest_dsl_dataset_promote_busy;
	ztest_func_t ztest_vdev_attach_detach;
	ztest_func_t ztest_vdev_LUN_growth;
	ztest_func_t ztest_vdev_add_remove;
	ztest_func_t ztest_vdev_class_add;
	ztest_func_t ztest_vdev_aux_add_remove;
	ztest_func_t ztest_split_pool;
	ztest_func_t ztest_reguid;
	ztest_func_t ztest_spa_upgrade;
	ztest_func_t ztest_device_removal;
	ztest_func_t ztest_spa_checkpoint_create_discard;
	ztest_func_t ztest_initialize;
	ztest_func_t ztest_trim;
	ztest_func_t ztest_fletcher;
	ztest_func_t ztest_fletcher_incr;
	ztest_func_t ztest_verify_dnode_bt;

	uint64_t zopt_always = 0ULL * NANOSEC; /* all the time */
	uint64_t zopt_incessant = 1ULL * NANOSEC / 10; /* every 1/10 second */
	uint64_t zopt_often = 1ULL * NANOSEC; /* every second */
	uint64_t zopt_sometimes = 10ULL * NANOSEC; /* every 10 seconds */
	uint64_t zopt_rarely = 60ULL * NANOSEC; /* every 60 seconds */

	#define ZTI_INIT(func, iters, interval) \
	{ .zi_func = (func), \
	.zi_iters = (iters), \
	.zi_interval = (interval), \
	.zi_funcname = # func }

	ztest_info_t ztest_info[] = {
	ZTI_INIT(ztest_dmu_read_write, 1, &zopt_always),
	ZTI_INIT(ztest_dmu_write_parallel, 10, &zopt_always),
	ZTI_INIT(ztest_dmu_object_alloc_free, 1, &zopt_always),
	ZTI_INIT(ztest_dmu_object_next_chunk, 1, &zopt_sometimes),
	ZTI_INIT(ztest_dmu_commit_callbacks, 1, &zopt_always),
	ZTI_INIT(ztest_zap, 30, &zopt_always),
	ZTI_INIT(ztest_zap_parallel, 100, &zopt_always),
	ZTI_INIT(ztest_split_pool, 1, &zopt_always),
	ZTI_INIT(ztest_zil_commit, 1, &zopt_incessant),
	ZTI_INIT(ztest_zil_remount, 1, &zopt_sometimes),
	ZTI_INIT(ztest_dmu_read_write_zcopy, 1, &zopt_often),
	ZTI_INIT(ztest_dmu_objset_create_destroy, 1, &zopt_often),
	ZTI_INIT(ztest_dsl_prop_get_set, 1, &zopt_often),
	ZTI_INIT(ztest_spa_prop_get_set, 1, &zopt_sometimes),
	#if 0
	ZTI_INIT(ztest_dmu_prealloc, 1, &zopt_sometimes),
	#endif
	ZTI_INIT(ztest_fzap, 1, &zopt_sometimes),
	ZTI_INIT(ztest_dmu_snapshot_create_destroy, 1, &zopt_sometimes),
	ZTI_INIT(ztest_spa_create_destroy, 1, &zopt_sometimes),
	ZTI_INIT(ztest_fault_inject, 1, &zopt_sometimes),
	ZTI_INIT(ztest_dmu_snapshot_hold, 1, &zopt_sometimes),
	ZTI_INIT(ztest_mmp_enable_disable, 1, &zopt_sometimes),
	ZTI_INIT(ztest_reguid, 1, &zopt_rarely),
	ZTI_INIT(ztest_scrub, 1, &zopt_rarely),
	ZTI_INIT(ztest_spa_upgrade, 1, &zopt_rarely),
	ZTI_INIT(ztest_dsl_dataset_promote_busy, 1, &zopt_rarely),
	ZTI_INIT(ztest_vdev_attach_detach, 1, &zopt_sometimes),
	ZTI_INIT(ztest_vdev_LUN_growth, 1, &zopt_rarely),
	ZTI_INIT(ztest_vdev_add_remove, 1, &ztest_opts.zo_vdevtime),
	ZTI_INIT(ztest_vdev_class_add, 1, &ztest_opts.zo_vdevtime),
	ZTI_INIT(ztest_vdev_aux_add_remove, 1, &ztest_opts.zo_vdevtime),
	ZTI_INIT(ztest_device_removal, 1, &zopt_sometimes),
	ZTI_INIT(ztest_spa_checkpoint_create_discard, 1, &zopt_rarely),
	ZTI_INIT(ztest_initialize, 1, &zopt_sometimes),
	ZTI_INIT(ztest_trim, 1, &zopt_sometimes),
	ZTI_INIT(ztest_fletcher, 1, &zopt_rarely),
	ZTI_INIT(ztest_fletcher_incr, 1, &zopt_rarely),
	ZTI_INIT(ztest_verify_dnode_bt, 1, &zopt_sometimes),
	};

	#define ZTEST_FUNCS (sizeof (ztest_info) / sizeof (ztest_info_t))

	/*
	* The following struct is used to hold a list of uncalled commit callbacks.
	* The callbacks are ordered by txg number.
	*/
	typedef struct ztest_cb_list {
	kmutex_t zcl_callbacks_lock;
	list_t zcl_callbacks;
	} ztest_cb_list_t;

	/*
	* Stuff we need to share writably between parent and child.
	*/
	typedef struct ztest_shared {
	boolean_t zs_do_init;
	hrtime_t zs_proc_start;
	hrtime_t zs_proc_stop;
	hrtime_t zs_thread_start;
	hrtime_t zs_thread_stop;
	hrtime_t zs_thread_kill;
	uint64_t zs_enospc_count;
	uint64_t zs_vdev_next_leaf;
	uint64_t zs_vdev_aux;
	uint64_t zs_alloc;
	uint64_t zs_space;
	uint64_t zs_splits;
	uint64_t zs_mirrors;
	uint64_t zs_metaslab_sz;
	uint64_t zs_metaslab_df_alloc_threshold;
	uint64_t zs_guid;
	} ztest_shared_t;

	#define ID_PARALLEL -1ULL

	static char ztest_dev_template[] = "%s/%s.%llua";
	static char ztest_aux_template[] = "%s/%s.%s.%llu";
	ztest_shared_t *ztest_shared;

	static spa_t *ztest_spa = NULL;
	static ztest_ds_t *ztest_ds;

	static kmutex_t ztest_vdev_lock;
	static boolean_t ztest_device_removal_active = B_FALSE;
	static boolean_t ztest_pool_scrubbed = B_FALSE;
	static kmutex_t ztest_checkpoint_lock;

	/*
	* The ztest_name_lock protects the pool and dataset namespace used by
	* the individual tests. To modify the namespace, consumers must grab
	* this lock as writer. Grabbing the lock as reader will ensure that the
	* namespace does not change while the lock is held.
	*/
	static pthread_rwlock_t ztest_name_lock;

	static boolean_t ztest_dump_core = B_TRUE;
	static boolean_t ztest_exiting;

	/* Global commit callback list */
	static ztest_cb_list_t zcl;
	/* Commit cb delay */
	static uint64_t zc_min_txg_delay = UINT64_MAX;
	static int zc_cb_counter = 0;

	/*
	* Minimum number of commit callbacks that need to be registered for us to check
	* whether the minimum txg delay is acceptable.
	*/
	#define ZTEST_COMMIT_CB_MIN_REG 100

	/*
	* If a number of txgs equal to this threshold have been created after a commit
	* callback has been registered but not called, then we assume there is an
	* implementation bug.
	*/
	#define ZTEST_COMMIT_CB_THRESH (TXG_CONCURRENT_STATES + 1000)

	enum ztest_object {
	ZTEST_META_DNODE = 0,
	ZTEST_DIROBJ,
	ZTEST_OBJECTS
	};

	static void usage(boolean_t) __NORETURN;
	static int ztest_scrub_impl(spa_t *spa);

	/*
	* These libumem hooks provide a reasonable set of defaults for the allocator's
	* debugging facilities.
	*/
	const char *
	_umem_debug_init(void)
	{
	return ("default,verbose"); /* $UMEM_DEBUG setting */
	}

	const char *
	_umem_logging_init(void)
	{
	return ("fail,contents"); /* $UMEM_LOGGING setting */
	}

	static void
	dump_debug_buffer(void)
	{
	ssize_t ret __attribute__((unused));

	if (!ztest_opts.zo_dump_dbgmsg)
	return;

	/*
	* We use write() instead of printf() so that this function
	* is safe to call from a signal handler.
	*/
	ret = write(STDOUT_FILENO, "\n", 1);
	zfs_dbgmsg_print("ztest");
	}

	#define BACKTRACE_SZ 100

	static void sig_handler(int signo)
	{
	struct sigaction action;
	#if (__GLIBC__ && !__UCLIBC__) /* backtrace() is a GNU extension */
	int nptrs;
	void *buffer[BACKTRACE_SZ];

	nptrs = backtrace(buffer, BACKTRACE_SZ);
	backtrace_symbols_fd(buffer, nptrs, STDERR_FILENO);
	#endif
	dump_debug_buffer();

	/*
	* Restore default action and re-raise signal so SIGSEGV and
	* SIGABRT can trigger a core dump.
	*/
	action.sa_handler = SIG_DFL;
	sigemptyset(&action.sa_mask);
	action.sa_flags = 0;
	(void) sigaction(signo, &action, NULL);
	raise(signo);
	}

	#define FATAL_MSG_SZ 1024

	char *fatal_msg;

	static void
	fatal(int do_perror, char *message, ...)
	{
	va_list args;
	int save_errno = errno;
	char *buf;

	(void) fflush(stdout);
	buf = umem_alloc(FATAL_MSG_SZ, UMEM_NOFAIL);

	va_start(args, message);
	(void) sprintf(buf, "ztest: ");
	/* LINTED */
	(void) vsprintf(buf + strlen(buf), message, args);
	va_end(args);
	if (do_perror) {
	(void) snprintf(buf + strlen(buf), FATAL_MSG_SZ - strlen(buf),
	": %s", strerror(save_errno));
	}
	(void) fprintf(stderr, "%s\n", buf);
	fatal_msg = buf; /* to ease debugging */

	if (ztest_dump_core)
	abort();
	else
	dump_debug_buffer();

	exit(3);
	}

	static int
	str2shift(const char *buf)
	{
	const char *ends = "BKMGTPEZ";
	int i;

	if (buf[0] == '\0')
	return (0);
	for (i = 0; i < strlen(ends); i++) {
	if (toupper(buf[0]) == ends[i])
	break;
	}
	if (i == strlen(ends)) {
	(void) fprintf(stderr, "ztest: invalid bytes suffix: %s\n",
	buf);
	usage(B_FALSE);
	}
	if (buf[1] == '\0' \|\| (toupper(buf[1]) == 'B' && buf[2] == '\0')) {
	return (10*i);
	}
	(void) fprintf(stderr, "ztest: invalid bytes suffix: %s\n", buf);
	usage(B_FALSE);
	/* NOTREACHED */
	}

	static uint64_t
	nicenumtoull(const char *buf)
	{
	char *end;
	uint64_t val;

	val = strtoull(buf, &end, 0);
	if (end == buf) {
	(void) fprintf(stderr, "ztest: bad numeric value: %s\n", buf);
	usage(B_FALSE);
	} else if (end[0] == '.') {
	double fval = strtod(buf, &end);
	fval *= pow(2, str2shift(end));
	/*
	* UINT64_MAX is not exactly representable as a double.
	* The closest representation is UINT64_MAX + 1, so we
	* use a >= comparison instead of > for the bounds check.
	*/
	if (fval >= (double)UINT64_MAX) {
	(void) fprintf(stderr, "ztest: value too large: %s\n",
	buf);
	usage(B_FALSE);
	}
	val = (uint64_t)fval;
	} else {
	int shift = str2shift(end);
	if (shift >= 64 \|\| (val << shift) >> shift != val) {
	(void) fprintf(stderr, "ztest: value too large: %s\n",
	buf);
	usage(B_FALSE);
	}
	val <<= shift;
	}
	return (val);
	}

	static void
	usage(boolean_t requested)
	{
	const ztest_shared_opts_t *zo = &ztest_opts_defaults;

	char nice_vdev_size[NN_NUMBUF_SZ];
	char nice_force_ganging[NN_NUMBUF_SZ];
	FILE *fp = requested ? stdout : stderr;

	nicenum(zo->zo_vdev_size, nice_vdev_size, sizeof (nice_vdev_size));
	nicenum(zo->zo_metaslab_force_ganging, nice_force_ganging,
	sizeof (nice_force_ganging));

	(void) fprintf(fp, "Usage: %s\n"
	"\t[-v vdevs (default: %llu)]\n"
	"\t[-s size_of_each_vdev (default: %s)]\n"
	"\t[-a alignment_shift (default: %d)] use 0 for random\n"
	"\t[-m mirror_copies (default: %d)]\n"
	"\t[-r raidz_disks / draid_disks (default: %d)]\n"
	"\t[-R raid_parity (default: %d)]\n"
	"\t[-K raid_kind (default: random)] raidz\|draid\|random\n"
	"\t[-D draid_data (default: %d)] in config\n"
	"\t[-S draid_spares (default: %d)]\n"
	"\t[-d datasets (default: %d)]\n"
	"\t[-t threads (default: %d)]\n"
	"\t[-g gang_block_threshold (default: %s)]\n"
	"\t[-i init_count (default: %d)] initialize pool i times\n"
	"\t[-k kill_percentage (default: %llu%%)]\n"
	"\t[-p pool_name (default: %s)]\n"
	"\t[-f dir (default: %s)] file directory for vdev files\n"
	"\t[-M] Multi-host simulate pool imported on remote host\n"
	"\t[-V] verbose (use multiple times for ever more blather)\n"
	"\t[-E] use existing pool instead of creating new one\n"
	"\t[-T time (default: %llu sec)] total run time\n"
	"\t[-F freezeloops (default: %llu)] max loops in spa_freeze()\n"
	"\t[-P passtime (default: %llu sec)] time per pass\n"
	"\t[-B alt_ztest (default: <none>)] alternate ztest path\n"
	"\t[-C vdev class state (default: random)] special=on\|off\|random\n"
	"\t[-o variable=value] ... set global variable to an unsigned\n"
	"\t 32-bit integer value\n"
	"\t[-G dump zfs_dbgmsg buffer before exiting due to an error\n"
	"\t[-h] (print help)\n"
	"",
	zo->zo_pool,
	(u_longlong_t)zo->zo_vdevs, /* -v */
	nice_vdev_size, /* -s */
	zo->zo_ashift, /* -a */
	zo->zo_mirrors, /* -m */
	zo->zo_raid_children, /* -r */
	zo->zo_raid_parity, /* -R */
	zo->zo_draid_data, /* -D */
	zo->zo_draid_spares, /* -S */
	zo->zo_datasets, /* -d */
	zo->zo_threads, /* -t */
	nice_force_ganging, /* -g */
	zo->zo_init, /* -i */
	(u_longlong_t)zo->zo_killrate, /* -k */
	zo->zo_pool, /* -p */
	zo->zo_dir, /* -f */
	(u_longlong_t)zo->zo_time, /* -T */
	(u_longlong_t)zo->zo_maxloops, /* -F */
	(u_longlong_t)zo->zo_passtime);
	exit(requested ? 0 : 1);
	}

	static uint64_t
	ztest_random(uint64_t range)
	{
	uint64_t r;

	ASSERT3S(ztest_fd_rand, >=, 0);

	if (range == 0)
	return (0);

	if (read(ztest_fd_rand, &r, sizeof (r)) != sizeof (r))
	fatal(1, "short read from /dev/urandom");

	return (r % range);
	}

	static void
	ztest_parse_name_value(const char input, ztest_shared_opts_t zo)
	{
	char name[32];
	char *value;
	int state = ZTEST_VDEV_CLASS_RND;

	(void) strlcpy(name, input, sizeof (name));

	value = strchr(name, '=');
	if (value == NULL) {
	(void) fprintf(stderr, "missing value in property=value "
	"'-C' argument (%s)\n", input);
	usage(B_FALSE);
	}
	*(value) = '\0';
	value++;

	if (strcmp(value, "on") == 0) {
	state = ZTEST_VDEV_CLASS_ON;
	} else if (strcmp(value, "off") == 0) {
	state = ZTEST_VDEV_CLASS_OFF;
	} else if (strcmp(value, "random") == 0) {
	state = ZTEST_VDEV_CLASS_RND;
	} else {
	(void) fprintf(stderr, "invalid property value '%s'\n", value);
	usage(B_FALSE);
	}

	if (strcmp(name, "special") == 0) {
	zo->zo_special_vdevs = state;
	} else {
	(void) fprintf(stderr, "invalid property name '%s'\n", name);
	usage(B_FALSE);
	}
	if (zo->zo_verbose >= 3)
	(void) printf("%s vdev state is '%s'\n", name, value);
	}

	static void
	process_options(int argc, char **argv)
	{
	char *path;
	ztest_shared_opts_t *zo = &ztest_opts;

	int opt;
	uint64_t value;
	char altdir[MAXNAMELEN] = { 0 };
	char raid_kind[8] = { "random" };

	bcopy(&ztest_opts_defaults, zo, sizeof (*zo));

	while ((opt = getopt(argc, argv,
	"v:s:a:m:r:R:K:D:S:d:t:g:i:k:p:f:MVET:P:hF:B:C:o:G")) != EOF) {
	value = 0;
	switch (opt) {
	case 'v':
	case 's':
	case 'a':
	case 'm':
	case 'r':
	case 'R':
	case 'D':
	case 'S':
	case 'd':
	case 't':
	case 'g':
	case 'i':
	case 'k':
	case 'T':
	case 'P':
	case 'F':
	value = nicenumtoull(optarg);
	}
	switch (opt) {
	case 'v':
	zo->zo_vdevs = value;
	break;
	case 's':
	zo->zo_vdev_size = MAX(SPA_MINDEVSIZE, value);
	break;
	case 'a':
	zo->zo_ashift = value;
	break;
	case 'm':
	zo->zo_mirrors = value;
	break;
	case 'r':
	zo->zo_raid_children = MAX(1, value);
	break;
	case 'R':
	zo->zo_raid_parity = MIN(MAX(value, 1), 3);
	break;
	case 'K':
	(void) strlcpy(raid_kind, optarg, sizeof (raid_kind));
	break;
	case 'D':
	zo->zo_draid_data = MAX(1, value);
	break;
	case 'S':
	zo->zo_draid_spares = MAX(1, value);
	break;
	case 'd':
	zo->zo_datasets = MAX(1, value);
	break;
	case 't':
	zo->zo_threads = MAX(1, value);
	break;
	case 'g':
	zo->zo_metaslab_force_ganging =
	MAX(SPA_MINBLOCKSIZE << 1, value);
	break;
	case 'i':
	zo->zo_init = value;
	break;
	case 'k':
	zo->zo_killrate = value;
	break;
	case 'p':
	(void) strlcpy(zo->zo_pool, optarg,
	sizeof (zo->zo_pool));
	break;
	case 'f':
	path = realpath(optarg, NULL);
	if (path == NULL) {
	(void) fprintf(stderr, "error: %s: %s\n",
	optarg, strerror(errno));
	usage(B_FALSE);
	} else {
	(void) strlcpy(zo->zo_dir, path,
	sizeof (zo->zo_dir));
	free(path);
	}
	break;
	case 'M':
	zo->zo_mmp_test = 1;
	break;
	case 'V':
	zo->zo_verbose++;
	break;
	case 'E':
	zo->zo_init = 0;
	break;
	case 'T':
	zo->zo_time = value;
	break;
	case 'P':
	zo->zo_passtime = MAX(1, value);
	break;
	case 'F':
	zo->zo_maxloops = MAX(1, value);
	break;
	case 'B':
	(void) strlcpy(altdir, optarg, sizeof (altdir));
	break;
	case 'C':
	ztest_parse_name_value(optarg, zo);
	break;
	case 'o':
	if (zo->zo_gvars_count >= ZO_GVARS_MAX_COUNT) {
	(void) fprintf(stderr,
	"max global var count (%zu) exceeded\n",
	ZO_GVARS_MAX_COUNT);
	usage(B_FALSE);
	}
	char *v = zo->zo_gvars[zo->zo_gvars_count];
	if (strlcpy(v, optarg, ZO_GVARS_MAX_ARGLEN) >=
	ZO_GVARS_MAX_ARGLEN) {
	(void) fprintf(stderr,
	"global var option '%s' is too long\n",
	optarg);
	usage(B_FALSE);
	}
	zo->zo_gvars_count++;
	break;
	case 'G':
	zo->zo_dump_dbgmsg = 1;
	break;
	case 'h':
	usage(B_TRUE);
	break;
	case '?':
	default:
	usage(B_FALSE);
	break;
	}
	}

	/* When raid choice is 'random' add a draid pool 50% of the time */
	if (strcmp(raid_kind, "random") == 0) {
	(void) strlcpy(raid_kind, (ztest_random(2) == 0) ?
	"draid" : "raidz", sizeof (raid_kind));

	if (ztest_opts.zo_verbose >= 3)
	(void) printf("choosing RAID type '%s'\n", raid_kind);
	}

	if (strcmp(raid_kind, "draid") == 0) {
	uint64_t min_devsize;

	/* With fewer disk use 256M, otherwise 128M is OK */
	min_devsize = (ztest_opts.zo_raid_children < 16) ?
	(256ULL << 20) : (128ULL << 20);

	/* No top-level mirrors with dRAID for now */
	zo->zo_mirrors = 0;

	/* Use more appropriate defaults for dRAID */
	if (zo->zo_vdevs == ztest_opts_defaults.zo_vdevs)
	zo->zo_vdevs = 1;
	if (zo->zo_raid_children ==
	ztest_opts_defaults.zo_raid_children)
	zo->zo_raid_children = 16;
	if (zo->zo_ashift < 12)
	zo->zo_ashift = 12;
	if (zo->zo_vdev_size < min_devsize)
	zo->zo_vdev_size = min_devsize;

	if (zo->zo_draid_data + zo->zo_raid_parity >
	zo->zo_raid_children - zo->zo_draid_spares) {
	(void) fprintf(stderr, "error: too few draid "
	"children (%d) for stripe width (%d)\n",
	zo->zo_raid_children,
	zo->zo_draid_data + zo->zo_raid_parity);
	usage(B_FALSE);
	}

	(void) strlcpy(zo->zo_raid_type, VDEV_TYPE_DRAID,
	sizeof (zo->zo_raid_type));

	} else /* using raidz */ {
	ASSERT0(strcmp(raid_kind, "raidz"));

	zo->zo_raid_parity = MIN(zo->zo_raid_parity,
	zo->zo_raid_children - 1);
	}

	zo->zo_vdevtime =
	(zo->zo_vdevs > 0 ? zo->zo_time * NANOSEC / zo->zo_vdevs :
	UINT64_MAX >> 2);

	if (strlen(altdir) > 0) {
	char *cmd;
	char *realaltdir;
	char *bin;
	char *ztest;
	char *isa;
	int isalen;

	cmd = umem_alloc(MAXPATHLEN, UMEM_NOFAIL);
	realaltdir = umem_alloc(MAXPATHLEN, UMEM_NOFAIL);

	VERIFY3P(NULL, !=, realpath(getexecname(), cmd));
	if (0 != access(altdir, F_OK)) {
	ztest_dump_core = B_FALSE;
	fatal(B_TRUE, "invalid alternate ztest path: %s",
	altdir);
	}
	VERIFY3P(NULL, !=, realpath(altdir, realaltdir));

	/*
	* 'cmd' should be of the form "<anything>/usr/bin/<isa>/ztest".
	* We want to extract <isa> to determine if we should use
	* 32 or 64 bit binaries.
	*/
	bin = strstr(cmd, "/usr/bin/");
	ztest = strstr(bin, "/ztest");
	isa = bin + 9;
	isalen = ztest - isa;
	(void) snprintf(zo->zo_alt_ztest, sizeof (zo->zo_alt_ztest),
	"%s/usr/bin/%.*s/ztest", realaltdir, isalen, isa);
	(void) snprintf(zo->zo_alt_libpath, sizeof (zo->zo_alt_libpath),
	"%s/usr/lib/%.*s", realaltdir, isalen, isa);

	if (0 != access(zo->zo_alt_ztest, X_OK)) {
	ztest_dump_core = B_FALSE;
	fatal(B_TRUE, "invalid alternate ztest: %s",
	zo->zo_alt_ztest);
	} else if (0 != access(zo->zo_alt_libpath, X_OK)) {
	ztest_dump_core = B_FALSE;
	fatal(B_TRUE, "invalid alternate lib directory %s",
	zo->zo_alt_libpath);
	}

	umem_free(cmd, MAXPATHLEN);
	umem_free(realaltdir, MAXPATHLEN);
	}
	}

	static void
	ztest_kill(ztest_shared_t *zs)
	{
	zs->zs_alloc = metaslab_class_get_alloc(spa_normal_class(ztest_spa));
	zs->zs_space = metaslab_class_get_space(spa_normal_class(ztest_spa));

	/*
	* Before we kill off ztest, make sure that the config is updated.
	* See comment above spa_write_cachefile().
	*/
	mutex_enter(&spa_namespace_lock);
	spa_write_cachefile(ztest_spa, B_FALSE, B_FALSE);
	mutex_exit(&spa_namespace_lock);

	(void) kill(getpid(), SIGKILL);
	}

	/* ARGSUSED */
	static void
	ztest_record_enospc(const char *s)
	{
	ztest_shared->zs_enospc_count++;
	}

	static uint64_t
	ztest_get_ashift(void)
	{
	if (ztest_opts.zo_ashift == 0)
	return (SPA_MINBLOCKSHIFT + ztest_random(5));
	return (ztest_opts.zo_ashift);
	}

	static boolean_t
	ztest_is_draid_spare(const char *name)
	{
	uint64_t spare_id = 0, parity = 0, vdev_id = 0;

	if (sscanf(name, VDEV_TYPE_DRAID "%llu-%llu-%llu",
	(u_longlong_t )&parity, (u_longlong_t )&vdev_id,
	(u_longlong_t *)&spare_id) == 3) {
	return (B_TRUE);
	}

	return (B_FALSE);
	}

	static nvlist_t *
	make_vdev_file(char path, char aux, char *pool, size_t size, uint64_t ashift)
	{
	char *pathbuf;
	uint64_t vdev;
	nvlist_t *file;
	boolean_t draid_spare = B_FALSE;

	pathbuf = umem_alloc(MAXPATHLEN, UMEM_NOFAIL);

	if (ashift == 0)
	ashift = ztest_get_ashift();

	if (path == NULL) {
	path = pathbuf;

	if (aux != NULL) {
	vdev = ztest_shared->zs_vdev_aux;
	(void) snprintf(path, MAXPATHLEN,
	ztest_aux_template, ztest_opts.zo_dir,
	pool == NULL ? ztest_opts.zo_pool : pool,
	aux, vdev);
	} else {
	vdev = ztest_shared->zs_vdev_next_leaf++;
	(void) snprintf(path, MAXPATHLEN,
	ztest_dev_template, ztest_opts.zo_dir,
	pool == NULL ? ztest_opts.zo_pool : pool, vdev);
	}
	} else {
	draid_spare = ztest_is_draid_spare(path);
	}

	if (size != 0 && !draid_spare) {
	int fd = open(path, O_RDWR \| O_CREAT \| O_TRUNC, 0666);
	if (fd == -1)
	fatal(1, "can't open %s", path);
	if (ftruncate(fd, size) != 0)
	fatal(1, "can't ftruncate %s", path);
	(void) close(fd);
	}

	file = fnvlist_alloc();
	fnvlist_add_string(file, ZPOOL_CONFIG_TYPE,
	draid_spare ? VDEV_TYPE_DRAID_SPARE : VDEV_TYPE_FILE);
	fnvlist_add_string(file, ZPOOL_CONFIG_PATH, path);
	fnvlist_add_uint64(file, ZPOOL_CONFIG_ASHIFT, ashift);
	umem_free(pathbuf, MAXPATHLEN);

	return (file);
	}

	static nvlist_t *
	make_vdev_raid(char path, char aux, char *pool, size_t size,
	uint64_t ashift, int r)
	{
	nvlist_t raid, *child;
	int c;

	if (r < 2)
	return (make_vdev_file(path, aux, pool, size, ashift));
	child = umem_alloc(r * sizeof (nvlist_t *), UMEM_NOFAIL);

	for (c = 0; c < r; c++)
	child[c] = make_vdev_file(path, aux, pool, size, ashift);

	raid = fnvlist_alloc();
	fnvlist_add_string(raid, ZPOOL_CONFIG_TYPE,
	ztest_opts.zo_raid_type);
	fnvlist_add_uint64(raid, ZPOOL_CONFIG_NPARITY,
	ztest_opts.zo_raid_parity);
	fnvlist_add_nvlist_array(raid, ZPOOL_CONFIG_CHILDREN, child, r);

	if (strcmp(ztest_opts.zo_raid_type, VDEV_TYPE_DRAID) == 0) {
	uint64_t ndata = ztest_opts.zo_draid_data;
	uint64_t nparity = ztest_opts.zo_raid_parity;
	uint64_t nspares = ztest_opts.zo_draid_spares;
	uint64_t children = ztest_opts.zo_raid_children;
	uint64_t ngroups = 1;

	/*
	* Calculate the minimum number of groups required to fill a
	* slice. This is the LCM of the stripe width (data + parity)
	* and the number of data drives (children - spares).
	*/
	while (ngroups * (ndata + nparity) % (children - nspares) != 0)
	ngroups++;

	/* Store the basic dRAID configuration. */
	fnvlist_add_uint64(raid, ZPOOL_CONFIG_DRAID_NDATA, ndata);
	fnvlist_add_uint64(raid, ZPOOL_CONFIG_DRAID_NSPARES, nspares);
	fnvlist_add_uint64(raid, ZPOOL_CONFIG_DRAID_NGROUPS, ngroups);
	}

	for (c = 0; c < r; c++)
	fnvlist_free(child[c]);

	umem_free(child, r * sizeof (nvlist_t *));

	return (raid);
	}

	static nvlist_t *
	make_vdev_mirror(char path, char aux, char *pool, size_t size,
	uint64_t ashift, int r, int m)
	{
	nvlist_t mirror, *child;
	int c;

	if (m < 1)
	return (make_vdev_raid(path, aux, pool, size, ashift, r));

	child = umem_alloc(m * sizeof (nvlist_t *), UMEM_NOFAIL);

	for (c = 0; c < m; c++)
	child[c] = make_vdev_raid(path, aux, pool, size, ashift, r);

	mirror = fnvlist_alloc();
	fnvlist_add_string(mirror, ZPOOL_CONFIG_TYPE, VDEV_TYPE_MIRROR);
	fnvlist_add_nvlist_array(mirror, ZPOOL_CONFIG_CHILDREN, child, m);

	for (c = 0; c < m; c++)
	fnvlist_free(child[c]);

	umem_free(child, m * sizeof (nvlist_t *));

	return (mirror);
	}

	static nvlist_t *
	make_vdev_root(char path, char aux, char *pool, size_t size, uint64_t ashift,
	const char *class, int r, int m, int t)
	{
	nvlist_t root, *child;
	int c;
	boolean_t log;

	ASSERT3S(t, >, 0);

	log = (class != NULL && strcmp(class, "log") == 0);

	child = umem_alloc(t * sizeof (nvlist_t *), UMEM_NOFAIL);

	for (c = 0; c < t; c++) {
	child[c] = make_vdev_mirror(path, aux, pool, size, ashift,
	r, m);
	fnvlist_add_uint64(child[c], ZPOOL_CONFIG_IS_LOG, log);

	if (class != NULL && class[0] != '\0') {
	ASSERT(m > 1 \|\| log); /* expecting a mirror */
	fnvlist_add_string(child[c],
	ZPOOL_CONFIG_ALLOCATION_BIAS, class);
	}
	}

	root = fnvlist_alloc();
	fnvlist_add_string(root, ZPOOL_CONFIG_TYPE, VDEV_TYPE_ROOT);
	fnvlist_add_nvlist_array(root, aux ? aux : ZPOOL_CONFIG_CHILDREN,
	child, t);

	for (c = 0; c < t; c++)
	fnvlist_free(child[c]);

	umem_free(child, t * sizeof (nvlist_t *));

	return (root);
	}

	/*
	* Find a random spa version. Returns back a random spa version in the
	* range [initial_version, SPA_VERSION_FEATURES].
	*/
	static uint64_t
	ztest_random_spa_version(uint64_t initial_version)
	{
	uint64_t version = initial_version;

	if (version <= SPA_VERSION_BEFORE_FEATURES) {
	version = version +
	ztest_random(SPA_VERSION_BEFORE_FEATURES - version + 1);
	}

	if (version > SPA_VERSION_BEFORE_FEATURES)
	version = SPA_VERSION_FEATURES;

	ASSERT(SPA_VERSION_IS_SUPPORTED(version));
	return (version);
	}

	static int
	ztest_random_blocksize(void)
	{
	ASSERT3U(ztest_spa->spa_max_ashift, !=, 0);

	/*
	* Choose a block size >= the ashift.
	* If the SPA supports new MAXBLOCKSIZE, test up to 1MB blocks.
	*/
	int maxbs = SPA_OLD_MAXBLOCKSHIFT;
	if (spa_maxblocksize(ztest_spa) == SPA_MAXBLOCKSIZE)
	maxbs = 20;
	uint64_t block_shift =
	ztest_random(maxbs - ztest_spa->spa_max_ashift + 1);
	return (1 << (SPA_MINBLOCKSHIFT + block_shift));
	}

	static int
	ztest_random_dnodesize(void)
	{
	int slots;
	int max_slots = spa_maxdnodesize(ztest_spa) >> DNODE_SHIFT;

	if (max_slots == DNODE_MIN_SLOTS)
	return (DNODE_MIN_SIZE);

	/*
	* Weight the random distribution more heavily toward smaller
	* dnode sizes since that is more likely to reflect real-world
	* usage.
	*/
	ASSERT3U(max_slots, >, 4);
	switch (ztest_random(10)) {
	case 0:
	slots = 5 + ztest_random(max_slots - 4);
	break;
	case 1 ... 4:
	slots = 2 + ztest_random(3);
	break;
	default:
	slots = 1;
	break;
	}

	return (slots << DNODE_SHIFT);
	}

	static int
	ztest_random_ibshift(void)
	{
	return (DN_MIN_INDBLKSHIFT +
	ztest_random(DN_MAX_INDBLKSHIFT - DN_MIN_INDBLKSHIFT + 1));
	}

	static uint64_t
	ztest_random_vdev_top(spa_t *spa, boolean_t log_ok)
	{
	uint64_t top;
	vdev_t *rvd = spa->spa_root_vdev;
	vdev_t *tvd;

	ASSERT3U(spa_config_held(spa, SCL_ALL, RW_READER), !=, 0);

	do {
	top = ztest_random(rvd->vdev_children);
	tvd = rvd->vdev_child[top];
	} while (!vdev_is_concrete(tvd) \|\| (tvd->vdev_islog && !log_ok) \|\|
	tvd->vdev_mg == NULL \|\| tvd->vdev_mg->mg_class == NULL);

	return (top);
	}

	static uint64_t
	ztest_random_dsl_prop(zfs_prop_t prop)
	{
	uint64_t value;

	do {
	value = zfs_prop_random_value(prop, ztest_random(-1ULL));
	} while (prop == ZFS_PROP_CHECKSUM && value == ZIO_CHECKSUM_OFF);

	return (value);
	}

	static int
	ztest_dsl_prop_set_uint64(char *osname, zfs_prop_t prop, uint64_t value,
	boolean_t inherit)
	{
	const char *propname = zfs_prop_to_name(prop);
	const char *valname;
	char *setpoint;
	uint64_t curval;
	int error;

	error = dsl_prop_set_int(osname, propname,
	(inherit ? ZPROP_SRC_NONE : ZPROP_SRC_LOCAL), value);

	if (error == ENOSPC) {
	ztest_record_enospc(FTAG);
	return (error);
	}
	ASSERT0(error);

	setpoint = umem_alloc(MAXPATHLEN, UMEM_NOFAIL);
	VERIFY0(dsl_prop_get_integer(osname, propname, &curval, setpoint));

	if (ztest_opts.zo_verbose >= 6) {
	int err;

	err = zfs_prop_index_to_string(prop, curval, &valname);
	if (err)
	(void) printf("%s %s = %llu at '%s'\n", osname,
	propname, (unsigned long long)curval, setpoint);
	else
	(void) printf("%s %s = %s at '%s'\n",
	osname, propname, valname, setpoint);
	}
	umem_free(setpoint, MAXPATHLEN);

	return (error);
	}

	static int
	ztest_spa_prop_set_uint64(zpool_prop_t prop, uint64_t value)
	{
	spa_t *spa = ztest_spa;
	nvlist_t *props = NULL;
	int error;

	props = fnvlist_alloc();
	fnvlist_add_uint64(props, zpool_prop_to_name(prop), value);

	error = spa_prop_set(spa, props);

	fnvlist_free(props);

	if (error == ENOSPC) {
	ztest_record_enospc(FTAG);
	return (error);
	}
	ASSERT0(error);

	return (error);
	}

	static int
	ztest_dmu_objset_own(const char *name, dmu_objset_type_t type,
	boolean_t readonly, boolean_t decrypt, void tag, objset_t *osp)
	{
	int err;
	char *cp = NULL;
	char ddname[ZFS_MAX_DATASET_NAME_LEN];

	strcpy(ddname, name);
	cp = strchr(ddname, '@');
	if (cp != NULL)
	*cp = '\0';

	err = dmu_objset_own(name, type, readonly, decrypt, tag, osp);
	while (decrypt && err == EACCES) {
	dsl_crypto_params_t *dcp;
	nvlist_t *crypto_args = fnvlist_alloc();

	fnvlist_add_uint8_array(crypto_args, "wkeydata",
	(uint8_t *)ztest_wkeydata, WRAPPING_KEY_LEN);
	VERIFY0(dsl_crypto_params_create_nvlist(DCP_CMD_NONE, NULL,
	crypto_args, &dcp));
	err = spa_keystore_load_wkey(ddname, dcp, B_FALSE);
	/*
	* Note: if there was an error loading, the wkey was not
	* consumed, and needs to be freed.
	*/
	dsl_crypto_params_free(dcp, (err != 0));
	fnvlist_free(crypto_args);

	if (err == EINVAL) {
	/*
	* We couldn't load a key for this dataset so try
	* the parent. This loop will eventually hit the
	* encryption root since ztest only makes clones
	* as children of their origin datasets.
	*/
	cp = strrchr(ddname, '/');
	if (cp == NULL)
	return (err);

	*cp = '\0';
	err = EACCES;
	continue;
	} else if (err != 0) {
	break;
	}

	err = dmu_objset_own(name, type, readonly, decrypt, tag, osp);
	break;
	}

	return (err);
	}

	static void
	ztest_rll_init(rll_t *rll)
	{
	rll->rll_writer = NULL;
	rll->rll_readers = 0;
	mutex_init(&rll->rll_lock, NULL, MUTEX_DEFAULT, NULL);
	cv_init(&rll->rll_cv, NULL, CV_DEFAULT, NULL);
	}

	static void
	ztest_rll_destroy(rll_t *rll)
	{
	ASSERT3P(rll->rll_writer, ==, NULL);
	ASSERT0(rll->rll_readers);
	mutex_destroy(&rll->rll_lock);
	cv_destroy(&rll->rll_cv);
	}

	static void
	ztest_rll_lock(rll_t *rll, rl_type_t type)
	{
	mutex_enter(&rll->rll_lock);

	if (type == RL_READER) {
	while (rll->rll_writer != NULL)
	(void) cv_wait(&rll->rll_cv, &rll->rll_lock);
	rll->rll_readers++;
	} else {
	while (rll->rll_writer != NULL \|\| rll->rll_readers)
	(void) cv_wait(&rll->rll_cv, &rll->rll_lock);
	rll->rll_writer = curthread;
	}

	mutex_exit(&rll->rll_lock);
	}

	static void
	ztest_rll_unlock(rll_t *rll)
	{
	mutex_enter(&rll->rll_lock);

	if (rll->rll_writer) {
	ASSERT0(rll->rll_readers);
	rll->rll_writer = NULL;
	} else {
	ASSERT3S(rll->rll_readers, >, 0);
	ASSERT3P(rll->rll_writer, ==, NULL);
	rll->rll_readers--;
	}

	if (rll->rll_writer == NULL && rll->rll_readers == 0)
	cv_broadcast(&rll->rll_cv);

	mutex_exit(&rll->rll_lock);
	}

	static void
	ztest_object_lock(ztest_ds_t *zd, uint64_t object, rl_type_t type)
	{
	rll_t *rll = &zd->zd_object_lock[object & (ZTEST_OBJECT_LOCKS - 1)];

	ztest_rll_lock(rll, type);
	}

	static void
	ztest_object_unlock(ztest_ds_t *zd, uint64_t object)
	{
	rll_t *rll = &zd->zd_object_lock[object & (ZTEST_OBJECT_LOCKS - 1)];

	ztest_rll_unlock(rll);
	}

	static rl_t *
	ztest_range_lock(ztest_ds_t *zd, uint64_t object, uint64_t offset,
	uint64_t size, rl_type_t type)
	{
	uint64_t hash = object ^ (offset % (ZTEST_RANGE_LOCKS + 1));
	rll_t *rll = &zd->zd_range_lock[hash & (ZTEST_RANGE_LOCKS - 1)];
	rl_t *rl;

	rl = umem_alloc(sizeof (*rl), UMEM_NOFAIL);
	rl->rl_object = object;
	rl->rl_offset = offset;
	rl->rl_size = size;
	rl->rl_lock = rll;

	ztest_rll_lock(rll, type);

	return (rl);
	}

	static void
	ztest_range_unlock(rl_t *rl)
	{
	rll_t *rll = rl->rl_lock;

	ztest_rll_unlock(rll);

	umem_free(rl, sizeof (*rl));
	}

	static void
	ztest_zd_init(ztest_ds_t zd, ztest_shared_ds_t szd, objset_t *os)
	{
	zd->zd_os = os;
	zd->zd_zilog = dmu_objset_zil(os);
	zd->zd_shared = szd;
	dmu_objset_name(os, zd->zd_name);
	int l;

	if (zd->zd_shared != NULL)
	zd->zd_shared->zd_seq = 0;

	VERIFY0(pthread_rwlock_init(&zd->zd_zilog_lock, NULL));
	mutex_init(&zd->zd_dirobj_lock, NULL, MUTEX_DEFAULT, NULL);

	for (l = 0; l < ZTEST_OBJECT_LOCKS; l++)
	ztest_rll_init(&zd->zd_object_lock[l]);

	for (l = 0; l < ZTEST_RANGE_LOCKS; l++)
	ztest_rll_init(&zd->zd_range_lock[l]);
	}

	static void
	ztest_zd_fini(ztest_ds_t *zd)
	{
	int l;

	mutex_destroy(&zd->zd_dirobj_lock);
	(void) pthread_rwlock_destroy(&zd->zd_zilog_lock);

	for (l = 0; l < ZTEST_OBJECT_LOCKS; l++)
	ztest_rll_destroy(&zd->zd_object_lock[l]);

	for (l = 0; l < ZTEST_RANGE_LOCKS; l++)
	ztest_rll_destroy(&zd->zd_range_lock[l]);
	}

	#define TXG_MIGHTWAIT (ztest_random(10) == 0 ? TXG_NOWAIT : TXG_WAIT)

	static uint64_t
	ztest_tx_assign(dmu_tx_t tx, uint64_t txg_how, const char tag)
	{
	uint64_t txg;
	int error;

	/*
	* Attempt to assign tx to some transaction group.
	*/
	error = dmu_tx_assign(tx, txg_how);
	if (error) {
	if (error == ERESTART) {
	ASSERT3U(txg_how, ==, TXG_NOWAIT);
	dmu_tx_wait(tx);
	} else {
	ASSERT3U(error, ==, ENOSPC);
	ztest_record_enospc(tag);
	}
	dmu_tx_abort(tx);
	return (0);
	}
	txg = dmu_tx_get_txg(tx);
	ASSERT3U(txg, !=, 0);
	return (txg);
	}

	static void
	ztest_bt_generate(ztest_block_tag_t bt, objset_t os, uint64_t object,
	uint64_t dnodesize, uint64_t offset, uint64_t gen, uint64_t txg,
	uint64_t crtxg)
	{
	bt->bt_magic = BT_MAGIC;
	bt->bt_objset = dmu_objset_id(os);
	bt->bt_object = object;
	bt->bt_dnodesize = dnodesize;
	bt->bt_offset = offset;
	bt->bt_gen = gen;
	bt->bt_txg = txg;
	bt->bt_crtxg = crtxg;
	}

	static void
	ztest_bt_verify(ztest_block_tag_t bt, objset_t os, uint64_t object,
	uint64_t dnodesize, uint64_t offset, uint64_t gen, uint64_t txg,
	uint64_t crtxg)
	{
	ASSERT3U(bt->bt_magic, ==, BT_MAGIC);
	ASSERT3U(bt->bt_objset, ==, dmu_objset_id(os));
	ASSERT3U(bt->bt_object, ==, object);
	ASSERT3U(bt->bt_dnodesize, ==, dnodesize);
	ASSERT3U(bt->bt_offset, ==, offset);
	ASSERT3U(bt->bt_gen, <=, gen);
	ASSERT3U(bt->bt_txg, <=, txg);
	ASSERT3U(bt->bt_crtxg, ==, crtxg);
	}

	static ztest_block_tag_t *
	ztest_bt_bonus(dmu_buf_t *db)
	{
	dmu_object_info_t doi;
	ztest_block_tag_t *bt;

	dmu_object_info_from_db(db, &doi);
	ASSERT3U(doi.doi_bonus_size, <=, db->db_size);
	ASSERT3U(doi.doi_bonus_size, >=, sizeof (*bt));
	bt = (void )((char )db->db_data + doi.doi_bonus_size - sizeof (*bt));

	return (bt);
	}

	/*
	* Generate a token to fill up unused bonus buffer space. Try to make
	* it unique to the object, generation, and offset to verify that data
	* is not getting overwritten by data from other dnodes.
	*/
	#define ZTEST_BONUS_FILL_TOKEN(obj, ds, gen, offset) \
	(((ds) << 48) \| ((gen) << 32) \| ((obj) << 8) \| (offset))

	/*
	* Fill up the unused bonus buffer region before the block tag with a
	* verifiable pattern. Filling the whole bonus area with non-zero data
	* helps ensure that all dnode traversal code properly skips the
	* interior regions of large dnodes.
	*/
	static void
	ztest_fill_unused_bonus(dmu_buf_t db, void end, uint64_t obj,
	objset_t *os, uint64_t gen)
	{
	uint64_t *bonusp;

	ASSERT(IS_P2ALIGNED((char )end - (char )db->db_data, 8));

	for (bonusp = db->db_data; bonusp < (uint64_t *)end; bonusp++) {
	uint64_t token = ZTEST_BONUS_FILL_TOKEN(obj, dmu_objset_id(os),
	gen, bonusp - (uint64_t *)db->db_data);
	*bonusp = token;
	}
	}

	/*
	* Verify that the unused area of a bonus buffer is filled with the
	* expected tokens.
	*/
	static void
	ztest_verify_unused_bonus(dmu_buf_t db, void end, uint64_t obj,
	objset_t *os, uint64_t gen)
	{
	uint64_t *bonusp;

	for (bonusp = db->db_data; bonusp < (uint64_t *)end; bonusp++) {
	uint64_t token = ZTEST_BONUS_FILL_TOKEN(obj, dmu_objset_id(os),
	gen, bonusp - (uint64_t *)db->db_data);
	VERIFY3U(*bonusp, ==, token);
	}
	}

	/*
	* ZIL logging ops
	*/

	#define lrz_type lr_mode
	#define lrz_blocksize lr_uid
	#define lrz_ibshift lr_gid
	#define lrz_bonustype lr_rdev
	#define lrz_dnodesize lr_crtime[1]

	static void
	ztest_log_create(ztest_ds_t zd, dmu_tx_t tx, lr_create_t *lr)
	{
	char name = (void )(lr + 1); /* name follows lr */
	size_t namesize = strlen(name) + 1;
	itx_t *itx;

	if (zil_replaying(zd->zd_zilog, tx))
	return;

	itx = zil_itx_create(TX_CREATE, sizeof (*lr) + namesize);
	bcopy(&lr->lr_common + 1, &itx->itx_lr + 1,
	sizeof (*lr) + namesize - sizeof (lr_t));

	zil_itx_assign(zd->zd_zilog, itx, tx);
	}

	static void
	ztest_log_remove(ztest_ds_t zd, dmu_tx_t tx, lr_remove_t *lr, uint64_t object)
	{
	char name = (void )(lr + 1); /* name follows lr */
	size_t namesize = strlen(name) + 1;
	itx_t *itx;

	if (zil_replaying(zd->zd_zilog, tx))
	return;

	itx = zil_itx_create(TX_REMOVE, sizeof (*lr) + namesize);
	bcopy(&lr->lr_common + 1, &itx->itx_lr + 1,
	sizeof (*lr) + namesize - sizeof (lr_t));

	itx->itx_oid = object;
	zil_itx_assign(zd->zd_zilog, itx, tx);
	}

	static void
	ztest_log_write(ztest_ds_t zd, dmu_tx_t tx, lr_write_t *lr)
	{
	itx_t *itx;
	itx_wr_state_t write_state = ztest_random(WR_NUM_STATES);

	if (zil_replaying(zd->zd_zilog, tx))
	return;

	if (lr->lr_length > zil_max_log_data(zd->zd_zilog))
	write_state = WR_INDIRECT;

	itx = zil_itx_create(TX_WRITE,
	sizeof (*lr) + (write_state == WR_COPIED ? lr->lr_length : 0));

	if (write_state == WR_COPIED &&
	dmu_read(zd->zd_os, lr->lr_foid, lr->lr_offset, lr->lr_length,
	((lr_write_t *)&itx->itx_lr) + 1, DMU_READ_NO_PREFETCH) != 0) {
	zil_itx_destroy(itx);
	itx = zil_itx_create(TX_WRITE, sizeof (*lr));
	write_state = WR_NEED_COPY;
	}
	itx->itx_private = zd;
	itx->itx_wr_state = write_state;
	itx->itx_sync = (ztest_random(8) == 0);

	bcopy(&lr->lr_common + 1, &itx->itx_lr + 1,
	sizeof (*lr) - sizeof (lr_t));

	zil_itx_assign(zd->zd_zilog, itx, tx);
	}

	static void
	ztest_log_truncate(ztest_ds_t zd, dmu_tx_t tx, lr_truncate_t *lr)
	{
	itx_t *itx;

	if (zil_replaying(zd->zd_zilog, tx))
	return;

	itx = zil_itx_create(TX_TRUNCATE, sizeof (*lr));
	bcopy(&lr->lr_common + 1, &itx->itx_lr + 1,
	sizeof (*lr) - sizeof (lr_t));

	itx->itx_sync = B_FALSE;
	zil_itx_assign(zd->zd_zilog, itx, tx);
	}

	static void
	ztest_log_setattr(ztest_ds_t zd, dmu_tx_t tx, lr_setattr_t *lr)
	{
	itx_t *itx;

	if (zil_replaying(zd->zd_zilog, tx))
	return;

	itx = zil_itx_create(TX_SETATTR, sizeof (*lr));
	bcopy(&lr->lr_common + 1, &itx->itx_lr + 1,
	sizeof (*lr) - sizeof (lr_t));

	itx->itx_sync = B_FALSE;
	zil_itx_assign(zd->zd_zilog, itx, tx);
	}

	/*
	* ZIL replay ops
	*/
	static int
	ztest_replay_create(void arg1, void arg2, boolean_t byteswap)
	{
	ztest_ds_t *zd = arg1;
	lr_create_t *lr = arg2;
	char name = (void )(lr + 1); /* name follows lr */
	objset_t *os = zd->zd_os;
	ztest_block_tag_t *bbt;
	dmu_buf_t *db;
	dmu_tx_t *tx;
	uint64_t txg;
	int error = 0;
	int bonuslen;

	if (byteswap)
	byteswap_uint64_array(lr, sizeof (*lr));

	ASSERT3U(lr->lr_doid, ==, ZTEST_DIROBJ);
	ASSERT3S(name[0], !=, '\0');

	tx = dmu_tx_create(os);

	dmu_tx_hold_zap(tx, lr->lr_doid, B_TRUE, name);

	if (lr->lrz_type == DMU_OT_ZAP_OTHER) {
	dmu_tx_hold_zap(tx, DMU_NEW_OBJECT, B_TRUE, NULL);
	} else {
	dmu_tx_hold_bonus(tx, DMU_NEW_OBJECT);
	}

	txg = ztest_tx_assign(tx, TXG_WAIT, FTAG);
	if (txg == 0)
	return (ENOSPC);

	ASSERT3U(dmu_objset_zil(os)->zl_replay, ==, !!lr->lr_foid);
	bonuslen = DN_BONUS_SIZE(lr->lrz_dnodesize);

	if (lr->lrz_type == DMU_OT_ZAP_OTHER) {
	if (lr->lr_foid == 0) {
	lr->lr_foid = zap_create_dnsize(os,
	lr->lrz_type, lr->lrz_bonustype,
	bonuslen, lr->lrz_dnodesize, tx);
	} else {
	error = zap_create_claim_dnsize(os, lr->lr_foid,
	lr->lrz_type, lr->lrz_bonustype,
	bonuslen, lr->lrz_dnodesize, tx);
	}
	} else {
	if (lr->lr_foid == 0) {
	lr->lr_foid = dmu_object_alloc_dnsize(os,
	lr->lrz_type, 0, lr->lrz_bonustype,
	bonuslen, lr->lrz_dnodesize, tx);
	} else {
	error = dmu_object_claim_dnsize(os, lr->lr_foid,
	lr->lrz_type, 0, lr->lrz_bonustype,
	bonuslen, lr->lrz_dnodesize, tx);
	}
	}

	if (error) {
	ASSERT3U(error, ==, EEXIST);
	ASSERT(zd->zd_zilog->zl_replay);
	dmu_tx_commit(tx);
	return (error);
	}

	ASSERT3U(lr->lr_foid, !=, 0);

	if (lr->lrz_type != DMU_OT_ZAP_OTHER)
	VERIFY0(dmu_object_set_blocksize(os, lr->lr_foid,
	lr->lrz_blocksize, lr->lrz_ibshift, tx));

	VERIFY0(dmu_bonus_hold(os, lr->lr_foid, FTAG, &db));
	bbt = ztest_bt_bonus(db);
	dmu_buf_will_dirty(db, tx);
	ztest_bt_generate(bbt, os, lr->lr_foid, lr->lrz_dnodesize, -1ULL,
	lr->lr_gen, txg, txg);
	ztest_fill_unused_bonus(db, bbt, lr->lr_foid, os, lr->lr_gen);
	dmu_buf_rele(db, FTAG);

	VERIFY0(zap_add(os, lr->lr_doid, name, sizeof (uint64_t), 1,
	&lr->lr_foid, tx));

	(void) ztest_log_create(zd, tx, lr);

	dmu_tx_commit(tx);

	return (0);
	}

	static int
	ztest_replay_remove(void arg1, void arg2, boolean_t byteswap)
	{
	ztest_ds_t *zd = arg1;
	lr_remove_t *lr = arg2;
	char name = (void )(lr + 1); /* name follows lr */
	objset_t *os = zd->zd_os;
	dmu_object_info_t doi;
	dmu_tx_t *tx;
	uint64_t object, txg;

	if (byteswap)
	byteswap_uint64_array(lr, sizeof (*lr));

	ASSERT3U(lr->lr_doid, ==, ZTEST_DIROBJ);
	ASSERT3S(name[0], !=, '\0');

	VERIFY0(
	zap_lookup(os, lr->lr_doid, name, sizeof (object), 1, &object));
	ASSERT3U(object, !=, 0);

	ztest_object_lock(zd, object, RL_WRITER);

	VERIFY0(dmu_object_info(os, object, &doi));

	tx = dmu_tx_create(os);

	dmu_tx_hold_zap(tx, lr->lr_doid, B_FALSE, name);
	dmu_tx_hold_free(tx, object, 0, DMU_OBJECT_END);

	txg = ztest_tx_assign(tx, TXG_WAIT, FTAG);
	if (txg == 0) {
	ztest_object_unlock(zd, object);
	return (ENOSPC);
	}

	if (doi.doi_type == DMU_OT_ZAP_OTHER) {
	VERIFY0(zap_destroy(os, object, tx));
	} else {
	VERIFY0(dmu_object_free(os, object, tx));
	}

	VERIFY0(zap_remove(os, lr->lr_doid, name, tx));

	(void) ztest_log_remove(zd, tx, lr, object);

	dmu_tx_commit(tx);

	ztest_object_unlock(zd, object);

	return (0);
	}

	static int
	ztest_replay_write(void arg1, void arg2, boolean_t byteswap)
	{
	ztest_ds_t *zd = arg1;
	lr_write_t *lr = arg2;
	objset_t *os = zd->zd_os;
	void data = lr + 1; / data follows lr */
	uint64_t offset, length;
	ztest_block_tag_t *bt = data;
	ztest_block_tag_t *bbt;
	uint64_t gen, txg, lrtxg, crtxg;
	dmu_object_info_t doi;
	dmu_tx_t *tx;
	dmu_buf_t *db;
	arc_buf_t *abuf = NULL;
	rl_t *rl;

	if (byteswap)
	byteswap_uint64_array(lr, sizeof (*lr));

	offset = lr->lr_offset;
	length = lr->lr_length;

	/* If it's a dmu_sync() block, write the whole block */
	if (lr->lr_common.lrc_reclen == sizeof (lr_write_t)) {
	uint64_t blocksize = BP_GET_LSIZE(&lr->lr_blkptr);
	if (length < blocksize) {
	offset -= offset % blocksize;
	length = blocksize;
	}
	}

	if (bt->bt_magic == BSWAP_64(BT_MAGIC))
	byteswap_uint64_array(bt, sizeof (*bt));

	if (bt->bt_magic != BT_MAGIC)
	bt = NULL;

	ztest_object_lock(zd, lr->lr_foid, RL_READER);
	rl = ztest_range_lock(zd, lr->lr_foid, offset, length, RL_WRITER);

	VERIFY0(dmu_bonus_hold(os, lr->lr_foid, FTAG, &db));

	dmu_object_info_from_db(db, &doi);

	bbt = ztest_bt_bonus(db);
	ASSERT3U(bbt->bt_magic, ==, BT_MAGIC);
	gen = bbt->bt_gen;
	crtxg = bbt->bt_crtxg;
	lrtxg = lr->lr_common.lrc_txg;

	tx = dmu_tx_create(os);

	dmu_tx_hold_write(tx, lr->lr_foid, offset, length);

	if (ztest_random(8) == 0 && length == doi.doi_data_block_size &&
	P2PHASE(offset, length) == 0)
	abuf = dmu_request_arcbuf(db, length);

	txg = ztest_tx_assign(tx, TXG_WAIT, FTAG);
	if (txg == 0) {
	if (abuf != NULL)
	dmu_return_arcbuf(abuf);
	dmu_buf_rele(db, FTAG);
	ztest_range_unlock(rl);
	ztest_object_unlock(zd, lr->lr_foid);
	return (ENOSPC);
	}

	if (bt != NULL) {
	/*
	* Usually, verify the old data before writing new data --
	* but not always, because we also want to verify correct
	* behavior when the data was not recently read into cache.
	*/
	ASSERT0(offset % doi.doi_data_block_size);
	if (ztest_random(4) != 0) {
	int prefetch = ztest_random(2) ?
	DMU_READ_PREFETCH : DMU_READ_NO_PREFETCH;
	ztest_block_tag_t rbt;

	VERIFY(dmu_read(os, lr->lr_foid, offset,
	sizeof (rbt), &rbt, prefetch) == 0);
	if (rbt.bt_magic == BT_MAGIC) {
	ztest_bt_verify(&rbt, os, lr->lr_foid, 0,
	offset, gen, txg, crtxg);
	}
	}

	/*
	* Writes can appear to be newer than the bonus buffer because
	* the ztest_get_data() callback does a dmu_read() of the
	* open-context data, which may be different than the data
	* as it was when the write was generated.
	*/
	if (zd->zd_zilog->zl_replay) {
	ztest_bt_verify(bt, os, lr->lr_foid, 0, offset,
	MAX(gen, bt->bt_gen), MAX(txg, lrtxg),
	bt->bt_crtxg);
	}

	/*
	* Set the bt's gen/txg to the bonus buffer's gen/txg
	* so that all of the usual ASSERTs will work.
	*/
	ztest_bt_generate(bt, os, lr->lr_foid, 0, offset, gen, txg,
	crtxg);
	}

	if (abuf == NULL) {
	dmu_write(os, lr->lr_foid, offset, length, data, tx);
	} else {
	bcopy(data, abuf->b_data, length);
	dmu_assign_arcbuf_by_dbuf(db, offset, abuf, tx);
	}

	(void) ztest_log_write(zd, tx, lr);

	dmu_buf_rele(db, FTAG);

	dmu_tx_commit(tx);

	ztest_range_unlock(rl);
	ztest_object_unlock(zd, lr->lr_foid);

	return (0);
	}

	static int
	ztest_replay_truncate(void arg1, void arg2, boolean_t byteswap)
	{
	ztest_ds_t *zd = arg1;
	lr_truncate_t *lr = arg2;
	objset_t *os = zd->zd_os;
	dmu_tx_t *tx;
	uint64_t txg;
	rl_t *rl;

	if (byteswap)
	byteswap_uint64_array(lr, sizeof (*lr));

	ztest_object_lock(zd, lr->lr_foid, RL_READER);
	rl = ztest_range_lock(zd, lr->lr_foid, lr->lr_offset, lr->lr_length,
	RL_WRITER);

	tx = dmu_tx_create(os);

	dmu_tx_hold_free(tx, lr->lr_foid, lr->lr_offset, lr->lr_length);

	txg = ztest_tx_assign(tx, TXG_WAIT, FTAG);
	if (txg == 0) {
	ztest_range_unlock(rl);
	ztest_object_unlock(zd, lr->lr_foid);
	return (ENOSPC);
	}

	VERIFY0(dmu_free_range(os, lr->lr_foid, lr->lr_offset,
	lr->lr_length, tx));

	(void) ztest_log_truncate(zd, tx, lr);

	dmu_tx_commit(tx);

	ztest_range_unlock(rl);
	ztest_object_unlock(zd, lr->lr_foid);

	return (0);
	}

	static int
	ztest_replay_setattr(void arg1, void arg2, boolean_t byteswap)
	{
	ztest_ds_t *zd = arg1;
	lr_setattr_t *lr = arg2;
	objset_t *os = zd->zd_os;
	dmu_tx_t *tx;
	dmu_buf_t *db;
	ztest_block_tag_t *bbt;
	uint64_t txg, lrtxg, crtxg, dnodesize;

	if (byteswap)
	byteswap_uint64_array(lr, sizeof (*lr));

	ztest_object_lock(zd, lr->lr_foid, RL_WRITER);

	VERIFY0(dmu_bonus_hold(os, lr->lr_foid, FTAG, &db));

	tx = dmu_tx_create(os);
	dmu_tx_hold_bonus(tx, lr->lr_foid);

	txg = ztest_tx_assign(tx, TXG_WAIT, FTAG);
	if (txg == 0) {
	dmu_buf_rele(db, FTAG);
	ztest_object_unlock(zd, lr->lr_foid);
	return (ENOSPC);
	}

	bbt = ztest_bt_bonus(db);
	ASSERT3U(bbt->bt_magic, ==, BT_MAGIC);
	crtxg = bbt->bt_crtxg;
	lrtxg = lr->lr_common.lrc_txg;
	dnodesize = bbt->bt_dnodesize;

	if (zd->zd_zilog->zl_replay) {
	ASSERT3U(lr->lr_size, !=, 0);
	ASSERT3U(lr->lr_mode, !=, 0);
	ASSERT3U(lrtxg, !=, 0);
	} else {
	/*
	* Randomly change the size and increment the generation.
	*/
	lr->lr_size = (ztest_random(db->db_size / sizeof (bbt)) + 1)
	sizeof (*bbt);
	lr->lr_mode = bbt->bt_gen + 1;
	ASSERT0(lrtxg);
	}

	/*
	* Verify that the current bonus buffer is not newer than our txg.
	*/
	ztest_bt_verify(bbt, os, lr->lr_foid, dnodesize, -1ULL, lr->lr_mode,
	MAX(txg, lrtxg), crtxg);

	dmu_buf_will_dirty(db, tx);

	ASSERT3U(lr->lr_size, >=, sizeof (*bbt));
	ASSERT3U(lr->lr_size, <=, db->db_size);
	VERIFY0(dmu_set_bonus(db, lr->lr_size, tx));
	bbt = ztest_bt_bonus(db);

	ztest_bt_generate(bbt, os, lr->lr_foid, dnodesize, -1ULL, lr->lr_mode,
	txg, crtxg);
	ztest_fill_unused_bonus(db, bbt, lr->lr_foid, os, bbt->bt_gen);
	dmu_buf_rele(db, FTAG);

	(void) ztest_log_setattr(zd, tx, lr);

	dmu_tx_commit(tx);

	ztest_object_unlock(zd, lr->lr_foid);

	return (0);
	}

	zil_replay_func_t *ztest_replay_vector[TX_MAX_TYPE] = {
	NULL, /* 0 no such transaction type */
	ztest_replay_create, /* TX_CREATE */
	NULL, /* TX_MKDIR */
	NULL, /* TX_MKXATTR */
	NULL, /* TX_SYMLINK */
	ztest_replay_remove, /* TX_REMOVE */
	NULL, /* TX_RMDIR */
	NULL, /* TX_LINK */
	NULL, /* TX_RENAME */
	ztest_replay_write, /* TX_WRITE */
	ztest_replay_truncate, /* TX_TRUNCATE */
	ztest_replay_setattr, /* TX_SETATTR */
	NULL, /* TX_ACL */
	NULL, /* TX_CREATE_ACL */
	NULL, /* TX_CREATE_ATTR */
	NULL, /* TX_CREATE_ACL_ATTR */
	NULL, /* TX_MKDIR_ACL */
	NULL, /* TX_MKDIR_ATTR */
	NULL, /* TX_MKDIR_ACL_ATTR */
	NULL, /* TX_WRITE2 */
	};

	/*
	* ZIL get_data callbacks
	*/

	/* ARGSUSED */
	static void
	ztest_get_done(zgd_t *zgd, int error)
	{
	ztest_ds_t *zd = zgd->zgd_private;
	uint64_t object = ((rl_t *)zgd->zgd_lr)->rl_object;

	if (zgd->zgd_db)
	dmu_buf_rele(zgd->zgd_db, zgd);

	ztest_range_unlock((rl_t *)zgd->zgd_lr);
	ztest_object_unlock(zd, object);

	umem_free(zgd, sizeof (*zgd));
	}

	static int
	ztest_get_data(void arg, uint64_t arg2, lr_write_t lr, char *buf,
	struct lwb lwb, zio_t zio)
	{
	ztest_ds_t *zd = arg;
	objset_t *os = zd->zd_os;
	uint64_t object = lr->lr_foid;
	uint64_t offset = lr->lr_offset;
	uint64_t size = lr->lr_length;
	uint64_t txg = lr->lr_common.lrc_txg;
	uint64_t crtxg;
	dmu_object_info_t doi;
	dmu_buf_t *db;
	zgd_t *zgd;
	int error;

	ASSERT3P(lwb, !=, NULL);
	ASSERT3P(zio, !=, NULL);
	ASSERT3U(size, !=, 0);

	ztest_object_lock(zd, object, RL_READER);
	error = dmu_bonus_hold(os, object, FTAG, &db);
	if (error) {
	ztest_object_unlock(zd, object);
	return (error);
	}

	crtxg = ztest_bt_bonus(db)->bt_crtxg;

	if (crtxg == 0 \|\| crtxg > txg) {
	dmu_buf_rele(db, FTAG);
	ztest_object_unlock(zd, object);
	return (ENOENT);
	}

	dmu_object_info_from_db(db, &doi);
	dmu_buf_rele(db, FTAG);
	db = NULL;

	zgd = umem_zalloc(sizeof (*zgd), UMEM_NOFAIL);
	zgd->zgd_lwb = lwb;
	zgd->zgd_private = zd;

	if (buf != NULL) { /* immediate write */
	zgd->zgd_lr = (struct zfs_locked_range *)ztest_range_lock(zd,
	object, offset, size, RL_READER);

	error = dmu_read(os, object, offset, size, buf,
	DMU_READ_NO_PREFETCH);
	ASSERT0(error);
	} else {
	size = doi.doi_data_block_size;
	if (ISP2(size)) {
	offset = P2ALIGN(offset, size);
	} else {
	ASSERT3U(offset, <, size);
	offset = 0;
	}

	zgd->zgd_lr = (struct zfs_locked_range *)ztest_range_lock(zd,
	object, offset, size, RL_READER);

	error = dmu_buf_hold(os, object, offset, zgd, &db,
	DMU_READ_NO_PREFETCH);

	if (error == 0) {
	blkptr_t *bp = &lr->lr_blkptr;

	zgd->zgd_db = db;
	zgd->zgd_bp = bp;

	ASSERT3U(db->db_offset, ==, offset);
	ASSERT3U(db->db_size, ==, size);

	error = dmu_sync(zio, lr->lr_common.lrc_txg,
	ztest_get_done, zgd);

	if (error == 0)
	return (0);
	}
	}

	ztest_get_done(zgd, error);

	return (error);
	}

	static void *
	ztest_lr_alloc(size_t lrsize, char *name)
	{
	char *lr;
	size_t namesize = name ? strlen(name) + 1 : 0;

	lr = umem_zalloc(lrsize + namesize, UMEM_NOFAIL);

	if (name)
	bcopy(name, lr + lrsize, namesize);

	return (lr);
	}

	static void
	ztest_lr_free(void lr, size_t lrsize, char name)
	{
	size_t namesize = name ? strlen(name) + 1 : 0;

	umem_free(lr, lrsize + namesize);
	}

	/*
	* Lookup a bunch of objects. Returns the number of objects not found.
	*/
	static int
	ztest_lookup(ztest_ds_t zd, ztest_od_t od, int count)
	{
	int missing = 0;
	int error;
	int i;

	ASSERT(MUTEX_HELD(&zd->zd_dirobj_lock));

	for (i = 0; i < count; i++, od++) {
	od->od_object = 0;
	error = zap_lookup(zd->zd_os, od->od_dir, od->od_name,
	sizeof (uint64_t), 1, &od->od_object);
	if (error) {
	ASSERT3S(error, ==, ENOENT);
	ASSERT0(od->od_object);
	missing++;
	} else {
	dmu_buf_t *db;
	ztest_block_tag_t *bbt;
	dmu_object_info_t doi;

	ASSERT3U(od->od_object, !=, 0);
	ASSERT0(missing); /* there should be no gaps */

	ztest_object_lock(zd, od->od_object, RL_READER);
	VERIFY0(dmu_bonus_hold(zd->zd_os, od->od_object,
	FTAG, &db));
	dmu_object_info_from_db(db, &doi);
	bbt = ztest_bt_bonus(db);
	ASSERT3U(bbt->bt_magic, ==, BT_MAGIC);
	od->od_type = doi.doi_type;
	od->od_blocksize = doi.doi_data_block_size;
	od->od_gen = bbt->bt_gen;
	dmu_buf_rele(db, FTAG);
	ztest_object_unlock(zd, od->od_object);
	}
	}

	return (missing);
	}

	static int
	ztest_create(ztest_ds_t zd, ztest_od_t od, int count)
	{
	int missing = 0;
	int i;

	ASSERT(MUTEX_HELD(&zd->zd_dirobj_lock));

	for (i = 0; i < count; i++, od++) {
	if (missing) {
	od->od_object = 0;
	missing++;
	continue;
	}

	lr_create_t lr = ztest_lr_alloc(sizeof (lr), od->od_name);

	lr->lr_doid = od->od_dir;
	lr->lr_foid = 0; /* 0 to allocate, > 0 to claim */
	lr->lrz_type = od->od_crtype;
	lr->lrz_blocksize = od->od_crblocksize;
	lr->lrz_ibshift = ztest_random_ibshift();
	lr->lrz_bonustype = DMU_OT_UINT64_OTHER;
	lr->lrz_dnodesize = od->od_crdnodesize;
	lr->lr_gen = od->od_crgen;
	lr->lr_crtime[0] = time(NULL);

	if (ztest_replay_create(zd, lr, B_FALSE) != 0) {
	ASSERT0(missing);
	od->od_object = 0;
	missing++;
	} else {
	od->od_object = lr->lr_foid;
	od->od_type = od->od_crtype;
	od->od_blocksize = od->od_crblocksize;
	od->od_gen = od->od_crgen;
	ASSERT3U(od->od_object, !=, 0);
	}

	ztest_lr_free(lr, sizeof (*lr), od->od_name);
	}

	return (missing);
	}

	static int
	ztest_remove(ztest_ds_t zd, ztest_od_t od, int count)
	{
	int missing = 0;
	int error;
	int i;

	ASSERT(MUTEX_HELD(&zd->zd_dirobj_lock));

	od += count - 1;

	for (i = count - 1; i >= 0; i--, od--) {
	if (missing) {
	missing++;
	continue;
	}

	/*
	* No object was found.
	*/
	if (od->od_object == 0)
	continue;

	lr_remove_t lr = ztest_lr_alloc(sizeof (lr), od->od_name);

	lr->lr_doid = od->od_dir;

	if ((error = ztest_replay_remove(zd, lr, B_FALSE)) != 0) {
	ASSERT3U(error, ==, ENOSPC);
	missing++;
	} else {
	od->od_object = 0;
	}
	ztest_lr_free(lr, sizeof (*lr), od->od_name);
	}

	return (missing);
	}

	static int
	ztest_write(ztest_ds_t *zd, uint64_t object, uint64_t offset, uint64_t size,
	void *data)
	{
	lr_write_t *lr;
	int error;

	lr = ztest_lr_alloc(sizeof (*lr) + size, NULL);

	lr->lr_foid = object;
	lr->lr_offset = offset;
	lr->lr_length = size;
	lr->lr_blkoff = 0;
	BP_ZERO(&lr->lr_blkptr);

	bcopy(data, lr + 1, size);

	error = ztest_replay_write(zd, lr, B_FALSE);

	ztest_lr_free(lr, sizeof (*lr) + size, NULL);

	return (error);
	}

	static int
	ztest_truncate(ztest_ds_t *zd, uint64_t object, uint64_t offset, uint64_t size)
	{
	lr_truncate_t *lr;
	int error;

	lr = ztest_lr_alloc(sizeof (*lr), NULL);

	lr->lr_foid = object;
	lr->lr_offset = offset;
	lr->lr_length = size;

	error = ztest_replay_truncate(zd, lr, B_FALSE);

	ztest_lr_free(lr, sizeof (*lr), NULL);

	return (error);
	}

	static int
	ztest_setattr(ztest_ds_t *zd, uint64_t object)
	{
	lr_setattr_t *lr;
	int error;

	lr = ztest_lr_alloc(sizeof (*lr), NULL);

	lr->lr_foid = object;
	lr->lr_size = 0;
	lr->lr_mode = 0;

	error = ztest_replay_setattr(zd, lr, B_FALSE);

	ztest_lr_free(lr, sizeof (*lr), NULL);

	return (error);
	}

	static void
	ztest_prealloc(ztest_ds_t *zd, uint64_t object, uint64_t offset, uint64_t size)
	{
	objset_t *os = zd->zd_os;
	dmu_tx_t *tx;
	uint64_t txg;
	rl_t *rl;

	txg_wait_synced(dmu_objset_pool(os), 0);

	ztest_object_lock(zd, object, RL_READER);
	rl = ztest_range_lock(zd, object, offset, size, RL_WRITER);

	tx = dmu_tx_create(os);

	dmu_tx_hold_write(tx, object, offset, size);

	txg = ztest_tx_assign(tx, TXG_WAIT, FTAG);

	if (txg != 0) {
	dmu_prealloc(os, object, offset, size, tx);
	dmu_tx_commit(tx);
	txg_wait_synced(dmu_objset_pool(os), txg);
	} else {
	(void) dmu_free_long_range(os, object, offset, size);
	}

	ztest_range_unlock(rl);
	ztest_object_unlock(zd, object);
	}

	static void
	ztest_io(ztest_ds_t *zd, uint64_t object, uint64_t offset)
	{
	int err;
	ztest_block_tag_t wbt;
	dmu_object_info_t doi;
	enum ztest_io_type io_type;
	uint64_t blocksize;
	void *data;

	VERIFY0(dmu_object_info(zd->zd_os, object, &doi));
	blocksize = doi.doi_data_block_size;
	data = umem_alloc(blocksize, UMEM_NOFAIL);

	/*
	* Pick an i/o type at random, biased toward writing block tags.
	*/
	io_type = ztest_random(ZTEST_IO_TYPES);
	if (ztest_random(2) == 0)
	io_type = ZTEST_IO_WRITE_TAG;

	(void) pthread_rwlock_rdlock(&zd->zd_zilog_lock);

	switch (io_type) {

	case ZTEST_IO_WRITE_TAG:
	ztest_bt_generate(&wbt, zd->zd_os, object, doi.doi_dnodesize,
	offset, 0, 0, 0);
	(void) ztest_write(zd, object, offset, sizeof (wbt), &wbt);
	break;

	case ZTEST_IO_WRITE_PATTERN:
	(void) memset(data, 'a' + (object + offset) % 5, blocksize);
	if (ztest_random(2) == 0) {
	/*
	* Induce fletcher2 collisions to ensure that
	* zio_ddt_collision() detects and resolves them
	* when using fletcher2-verify for deduplication.
	*/
	((uint64_t *)data)[0] ^= 1ULL << 63;
	((uint64_t *)data)[4] ^= 1ULL << 63;
	}
	(void) ztest_write(zd, object, offset, blocksize, data);
	break;

	case ZTEST_IO_WRITE_ZEROES:
	bzero(data, blocksize);
	(void) ztest_write(zd, object, offset, blocksize, data);
	break;

	case ZTEST_IO_TRUNCATE:
	(void) ztest_truncate(zd, object, offset, blocksize);
	break;

	case ZTEST_IO_SETATTR:
	(void) ztest_setattr(zd, object);
	break;
	default:
	break;

	case ZTEST_IO_REWRITE:
	(void) pthread_rwlock_rdlock(&ztest_name_lock);
	err = ztest_dsl_prop_set_uint64(zd->zd_name,
	ZFS_PROP_CHECKSUM, spa_dedup_checksum(ztest_spa),
	B_FALSE);
	VERIFY(err == 0 \|\| err == ENOSPC);
	err = ztest_dsl_prop_set_uint64(zd->zd_name,
	ZFS_PROP_COMPRESSION,
	ztest_random_dsl_prop(ZFS_PROP_COMPRESSION),
	B_FALSE);
	VERIFY(err == 0 \|\| err == ENOSPC);
	(void) pthread_rwlock_unlock(&ztest_name_lock);

	VERIFY0(dmu_read(zd->zd_os, object, offset, blocksize, data,
	DMU_READ_NO_PREFETCH));

	(void) ztest_write(zd, object, offset, blocksize, data);
	break;
	}

	(void) pthread_rwlock_unlock(&zd->zd_zilog_lock);

	umem_free(data, blocksize);
	}

	/*
	* Initialize an object description template.
	*/
	static void
	ztest_od_init(ztest_od_t od, uint64_t id, char tag, uint64_t index,
	dmu_object_type_t type, uint64_t blocksize, uint64_t dnodesize,
	uint64_t gen)
	{
	od->od_dir = ZTEST_DIROBJ;
	od->od_object = 0;

	od->od_crtype = type;
	od->od_crblocksize = blocksize ? blocksize : ztest_random_blocksize();
	od->od_crdnodesize = dnodesize ? dnodesize : ztest_random_dnodesize();
	od->od_crgen = gen;

	od->od_type = DMU_OT_NONE;
	od->od_blocksize = 0;
	od->od_gen = 0;

	(void) snprintf(od->od_name, sizeof (od->od_name), "%s(%lld)[%llu]",
	tag, (longlong_t)id, (u_longlong_t)index);
	}

	/*
	* Lookup or create the objects for a test using the od template.
	* If the objects do not all exist, or if 'remove' is specified,
	* remove any existing objects and create new ones. Otherwise,
	* use the existing objects.
	*/
	static int
	ztest_object_init(ztest_ds_t zd, ztest_od_t od, size_t size, boolean_t remove)
	{
	int count = size / sizeof (*od);
	int rv = 0;

	mutex_enter(&zd->zd_dirobj_lock);
	if ((ztest_lookup(zd, od, count) != 0 \|\| remove) &&
	(ztest_remove(zd, od, count) != 0 \|\|
	ztest_create(zd, od, count) != 0))
	rv = -1;
	zd->zd_od = od;
	mutex_exit(&zd->zd_dirobj_lock);

	return (rv);
	}

	/* ARGSUSED */
	void
	ztest_zil_commit(ztest_ds_t *zd, uint64_t id)
	{
	zilog_t *zilog = zd->zd_zilog;

	(void) pthread_rwlock_rdlock(&zd->zd_zilog_lock);

	zil_commit(zilog, ztest_random(ZTEST_OBJECTS));

	/*
	* Remember the committed values in zd, which is in parent/child
	* shared memory. If we die, the next iteration of ztest_run()
	* will verify that the log really does contain this record.
	*/
	mutex_enter(&zilog->zl_lock);
	ASSERT3P(zd->zd_shared, !=, NULL);
	ASSERT3U(zd->zd_shared->zd_seq, <=, zilog->zl_commit_lr_seq);
	zd->zd_shared->zd_seq = zilog->zl_commit_lr_seq;
	mutex_exit(&zilog->zl_lock);

	(void) pthread_rwlock_unlock(&zd->zd_zilog_lock);
	}

	/*
	* This function is designed to simulate the operations that occur during a
	* mount/unmount operation. We hold the dataset across these operations in an
	* attempt to expose any implicit assumptions about ZIL management.
	*/
	/* ARGSUSED */
	void
	ztest_zil_remount(ztest_ds_t *zd, uint64_t id)
	{
	objset_t *os = zd->zd_os;

	/*
	* We hold the ztest_vdev_lock so we don't cause problems with
	* other threads that wish to remove a log device, such as
	* ztest_device_removal().
	*/
	mutex_enter(&ztest_vdev_lock);

	/*
	* We grab the zd_dirobj_lock to ensure that no other thread is
	* updating the zil (i.e. adding in-memory log records) and the
	* zd_zilog_lock to block any I/O.
	*/
	mutex_enter(&zd->zd_dirobj_lock);
	(void) pthread_rwlock_wrlock(&zd->zd_zilog_lock);

	/* zfsvfs_teardown() */
	zil_close(zd->zd_zilog);

	/* zfsvfs_setup() */
	VERIFY3P(zil_open(os, ztest_get_data), ==, zd->zd_zilog);
	zil_replay(os, zd, ztest_replay_vector);

	(void) pthread_rwlock_unlock(&zd->zd_zilog_lock);
	mutex_exit(&zd->zd_dirobj_lock);
	mutex_exit(&ztest_vdev_lock);
	}

	/*
	* Verify that we can't destroy an active pool, create an existing pool,
	* or create a pool with a bad vdev spec.
	*/
	/* ARGSUSED */
	void
	ztest_spa_create_destroy(ztest_ds_t *zd, uint64_t id)
	{
	ztest_shared_opts_t *zo = &ztest_opts;
	spa_t *spa;
	nvlist_t *nvroot;

	if (zo->zo_mmp_test)
	return;

	/*
	* Attempt to create using a bad file.
	*/
	nvroot = make_vdev_root("/dev/bogus", NULL, NULL, 0, 0, NULL, 0, 0, 1);
	VERIFY3U(ENOENT, ==,
	spa_create("ztest_bad_file", nvroot, NULL, NULL, NULL));
	fnvlist_free(nvroot);

	/*
	* Attempt to create using a bad mirror.
	*/
	nvroot = make_vdev_root("/dev/bogus", NULL, NULL, 0, 0, NULL, 0, 2, 1);
	VERIFY3U(ENOENT, ==,
	spa_create("ztest_bad_mirror", nvroot, NULL, NULL, NULL));
	fnvlist_free(nvroot);

	/*
	* Attempt to create an existing pool. It shouldn't matter
	* what's in the nvroot; we should fail with EEXIST.
	*/
	(void) pthread_rwlock_rdlock(&ztest_name_lock);
	nvroot = make_vdev_root("/dev/bogus", NULL, NULL, 0, 0, NULL, 0, 0, 1);
	VERIFY3U(EEXIST, ==,
	spa_create(zo->zo_pool, nvroot, NULL, NULL, NULL));
	fnvlist_free(nvroot);

	/*
	* We open a reference to the spa and then we try to export it
	* expecting one of the following errors:
	*
	* EBUSY
	* Because of the reference we just opened.
	*
	* ZFS_ERR_EXPORT_IN_PROGRESS
	* For the case that there is another ztest thread doing
	* an export concurrently.
	*/
	VERIFY0(spa_open(zo->zo_pool, &spa, FTAG));
	int error = spa_destroy(zo->zo_pool);
	if (error != EBUSY && error != ZFS_ERR_EXPORT_IN_PROGRESS) {
	fatal(0, "spa_destroy(%s) returned unexpected value %d",
	spa->spa_name, error);
	}
	spa_close(spa, FTAG);

	(void) pthread_rwlock_unlock(&ztest_name_lock);
	}

	/*
	* Start and then stop the MMP threads to ensure the startup and shutdown code
	* works properly. Actual protection and property-related code tested via ZTS.
	*/
	/* ARGSUSED */
	void
	ztest_mmp_enable_disable(ztest_ds_t *zd, uint64_t id)
	{
	ztest_shared_opts_t *zo = &ztest_opts;
	spa_t *spa = ztest_spa;

	if (zo->zo_mmp_test)
	return;

	/*
	* Since enabling MMP involves setting a property, it could not be done
	* while the pool is suspended.
	*/
	if (spa_suspended(spa))
	return;

	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
	mutex_enter(&spa->spa_props_lock);

	zfs_multihost_fail_intervals = 0;

	if (!spa_multihost(spa)) {
	spa->spa_multihost = B_TRUE;
	mmp_thread_start(spa);
	}

	mutex_exit(&spa->spa_props_lock);
	spa_config_exit(spa, SCL_CONFIG, FTAG);

	txg_wait_synced(spa_get_dsl(spa), 0);
	mmp_signal_all_threads();
	txg_wait_synced(spa_get_dsl(spa), 0);

	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
	mutex_enter(&spa->spa_props_lock);

	if (spa_multihost(spa)) {
	mmp_thread_stop(spa);
	spa->spa_multihost = B_FALSE;
	}

	mutex_exit(&spa->spa_props_lock);
	spa_config_exit(spa, SCL_CONFIG, FTAG);
	}

	/* ARGSUSED */
	void
	ztest_spa_upgrade(ztest_ds_t *zd, uint64_t id)
	{
	spa_t *spa;
	uint64_t initial_version = SPA_VERSION_INITIAL;
	uint64_t version, newversion;
	nvlist_t nvroot, props;
	char *name;

	if (ztest_opts.zo_mmp_test)
	return;

	/* dRAID added after feature flags, skip upgrade test. */
	if (strcmp(ztest_opts.zo_raid_type, VDEV_TYPE_DRAID) == 0)
	return;

	mutex_enter(&ztest_vdev_lock);
	name = kmem_asprintf("%s_upgrade", ztest_opts.zo_pool);

	/*
	* Clean up from previous runs.
	*/
	(void) spa_destroy(name);

	nvroot = make_vdev_root(NULL, NULL, name, ztest_opts.zo_vdev_size, 0,
	NULL, ztest_opts.zo_raid_children, ztest_opts.zo_mirrors, 1);

	/*
	* If we're configuring a RAIDZ device then make sure that the
	* initial version is capable of supporting that feature.
	*/
	switch (ztest_opts.zo_raid_parity) {
	case 0:
	case 1:
	initial_version = SPA_VERSION_INITIAL;
	break;
	case 2:
	initial_version = SPA_VERSION_RAIDZ2;
	break;
	case 3:
	initial_version = SPA_VERSION_RAIDZ3;
	break;
	}

	/*
	* Create a pool with a spa version that can be upgraded. Pick
	* a value between initial_version and SPA_VERSION_BEFORE_FEATURES.
	*/
	do {
	version = ztest_random_spa_version(initial_version);
	} while (version > SPA_VERSION_BEFORE_FEATURES);

	props = fnvlist_alloc();
	fnvlist_add_uint64(props,
	zpool_prop_to_name(ZPOOL_PROP_VERSION), version);
	VERIFY0(spa_create(name, nvroot, props, NULL, NULL));
	fnvlist_free(nvroot);
	fnvlist_free(props);

	VERIFY0(spa_open(name, &spa, FTAG));
	VERIFY3U(spa_version(spa), ==, version);
	newversion = ztest_random_spa_version(version + 1);

	if (ztest_opts.zo_verbose >= 4) {
	(void) printf("upgrading spa version from %llu to %llu\n",
	(u_longlong_t)version, (u_longlong_t)newversion);
	}

	spa_upgrade(spa, newversion);
	VERIFY3U(spa_version(spa), >, version);
	VERIFY3U(spa_version(spa), ==, fnvlist_lookup_uint64(spa->spa_config,
	zpool_prop_to_name(ZPOOL_PROP_VERSION)));
	spa_close(spa, FTAG);

	kmem_strfree(name);
	mutex_exit(&ztest_vdev_lock);
	}

	static void
	ztest_spa_checkpoint(spa_t *spa)
	{
	ASSERT(MUTEX_HELD(&ztest_checkpoint_lock));

	int error = spa_checkpoint(spa->spa_name);

	switch (error) {
	case 0:
	case ZFS_ERR_DEVRM_IN_PROGRESS:
	case ZFS_ERR_DISCARDING_CHECKPOINT:
	case ZFS_ERR_CHECKPOINT_EXISTS:
	break;
	case ENOSPC:
	ztest_record_enospc(FTAG);
	break;
	default:
	fatal(0, "spa_checkpoint(%s) = %d", spa->spa_name, error);
	}
	}

	static void
	ztest_spa_discard_checkpoint(spa_t *spa)
	{
	ASSERT(MUTEX_HELD(&ztest_checkpoint_lock));

	int error = spa_checkpoint_discard(spa->spa_name);

	switch (error) {
	case 0:
	case ZFS_ERR_DISCARDING_CHECKPOINT:
	case ZFS_ERR_NO_CHECKPOINT:
	break;
	default:
	fatal(0, "spa_discard_checkpoint(%s) = %d",
	spa->spa_name, error);
	}

	}

	/* ARGSUSED */
	void
	ztest_spa_checkpoint_create_discard(ztest_ds_t *zd, uint64_t id)
	{
	spa_t *spa = ztest_spa;

	mutex_enter(&ztest_checkpoint_lock);
	if (ztest_random(2) == 0) {
	ztest_spa_checkpoint(spa);
	} else {
	ztest_spa_discard_checkpoint(spa);
	}
	mutex_exit(&ztest_checkpoint_lock);
	}


	static vdev_t *
	vdev_lookup_by_path(vdev_t vd, const char path)
	{
	vdev_t *mvd;
	int c;

	if (vd->vdev_path != NULL && strcmp(path, vd->vdev_path) == 0)
	return (vd);

	for (c = 0; c < vd->vdev_children; c++)
	if ((mvd = vdev_lookup_by_path(vd->vdev_child[c], path)) !=
	NULL)
	return (mvd);

	return (NULL);
	}

	static int
	spa_num_top_vdevs(spa_t *spa)
	{
	vdev_t *rvd = spa->spa_root_vdev;
	ASSERT3U(spa_config_held(spa, SCL_VDEV, RW_READER), ==, SCL_VDEV);
	return (rvd->vdev_children);
	}

	/*
	* Verify that vdev_add() works as expected.
	*/
	/* ARGSUSED */
	void
	ztest_vdev_add_remove(ztest_ds_t *zd, uint64_t id)
	{
	ztest_shared_t *zs = ztest_shared;
	spa_t *spa = ztest_spa;
	uint64_t leaves;
	uint64_t guid;
	nvlist_t *nvroot;
	int error;

	if (ztest_opts.zo_mmp_test)
	return;

	mutex_enter(&ztest_vdev_lock);
	leaves = MAX(zs->zs_mirrors + zs->zs_splits, 1) *
	ztest_opts.zo_raid_children;

	spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER);

	ztest_shared->zs_vdev_next_leaf = spa_num_top_vdevs(spa) * leaves;

	/*
	* If we have slogs then remove them 1/4 of the time.
	*/
	if (spa_has_slogs(spa) && ztest_random(4) == 0) {
	metaslab_group_t *mg;

	/*
	* find the first real slog in log allocation class
	*/
	mg = spa_log_class(spa)->mc_allocator[0].mca_rotor;
	while (!mg->mg_vd->vdev_islog)
	mg = mg->mg_next;

	guid = mg->mg_vd->vdev_guid;

	spa_config_exit(spa, SCL_VDEV, FTAG);

	/*
	* We have to grab the zs_name_lock as writer to
	* prevent a race between removing a slog (dmu_objset_find)
	* and destroying a dataset. Removing the slog will
	* grab a reference on the dataset which may cause
	* dsl_destroy_head() to fail with EBUSY thus
	* leaving the dataset in an inconsistent state.
	*/
	pthread_rwlock_wrlock(&ztest_name_lock);
	error = spa_vdev_remove(spa, guid, B_FALSE);
	pthread_rwlock_unlock(&ztest_name_lock);

	switch (error) {
	case 0:
	case EEXIST: /* Generic zil_reset() error */
	case EBUSY: /* Replay required */
	case EACCES: /* Crypto key not loaded */
	case ZFS_ERR_CHECKPOINT_EXISTS:
	case ZFS_ERR_DISCARDING_CHECKPOINT:
	break;
	default:
	fatal(0, "spa_vdev_remove() = %d", error);
	}
	} else {
	spa_config_exit(spa, SCL_VDEV, FTAG);

	/*
	* Make 1/4 of the devices be log devices
	*/
	nvroot = make_vdev_root(NULL, NULL, NULL,
	ztest_opts.zo_vdev_size, 0, (ztest_random(4) == 0) ?
	"log" : NULL, ztest_opts.zo_raid_children, zs->zs_mirrors,
	1);

	error = spa_vdev_add(spa, nvroot);
	fnvlist_free(nvroot);

	switch (error) {
	case 0:
	break;
	case ENOSPC:
	ztest_record_enospc("spa_vdev_add");
	break;
	default:
	fatal(0, "spa_vdev_add() = %d", error);
	}
	}

	mutex_exit(&ztest_vdev_lock);
	}

	/* ARGSUSED */
	void
	ztest_vdev_class_add(ztest_ds_t *zd, uint64_t id)
	{
	ztest_shared_t *zs = ztest_shared;
	spa_t *spa = ztest_spa;
	uint64_t leaves;
	nvlist_t *nvroot;
	const char *class = (ztest_random(2) == 0) ?
	VDEV_ALLOC_BIAS_SPECIAL : VDEV_ALLOC_BIAS_DEDUP;
	int error;

	/*
	* By default add a special vdev 50% of the time
	*/
	if ((ztest_opts.zo_special_vdevs == ZTEST_VDEV_CLASS_OFF) \|\|
	(ztest_opts.zo_special_vdevs == ZTEST_VDEV_CLASS_RND &&
	ztest_random(2) == 0)) {
	return;
	}

	mutex_enter(&ztest_vdev_lock);

	/* Only test with mirrors */
	if (zs->zs_mirrors < 2) {
	mutex_exit(&ztest_vdev_lock);
	return;
	}

	/* requires feature@allocation_classes */
	if (!spa_feature_is_enabled(spa, SPA_FEATURE_ALLOCATION_CLASSES)) {
	mutex_exit(&ztest_vdev_lock);
	return;
	}

	leaves = MAX(zs->zs_mirrors + zs->zs_splits, 1) *
	ztest_opts.zo_raid_children;

	spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER);
	ztest_shared->zs_vdev_next_leaf = spa_num_top_vdevs(spa) * leaves;
	spa_config_exit(spa, SCL_VDEV, FTAG);

	nvroot = make_vdev_root(NULL, NULL, NULL, ztest_opts.zo_vdev_size, 0,
	class, ztest_opts.zo_raid_children, zs->zs_mirrors, 1);

	error = spa_vdev_add(spa, nvroot);
	fnvlist_free(nvroot);

	if (error == ENOSPC)
	ztest_record_enospc("spa_vdev_add");
	else if (error != 0)
	fatal(0, "spa_vdev_add() = %d", error);

	/*
	* 50% of the time allow small blocks in the special class
	*/
	if (error == 0 &&
	spa_special_class(spa)->mc_groups == 1 && ztest_random(2) == 0) {
	if (ztest_opts.zo_verbose >= 3)
	(void) printf("Enabling special VDEV small blocks\n");
	(void) ztest_dsl_prop_set_uint64(zd->zd_name,
	ZFS_PROP_SPECIAL_SMALL_BLOCKS, 32768, B_FALSE);
	}

	mutex_exit(&ztest_vdev_lock);

	if (ztest_opts.zo_verbose >= 3) {
	metaslab_class_t *mc;

	if (strcmp(class, VDEV_ALLOC_BIAS_SPECIAL) == 0)
	mc = spa_special_class(spa);
	else
	mc = spa_dedup_class(spa);
	(void) printf("Added a %s mirrored vdev (of %d)\n",
	class, (int)mc->mc_groups);
	}
	}

	/*
	* Verify that adding/removing aux devices (l2arc, hot spare) works as expected.
	*/
	/* ARGSUSED */
	void
	ztest_vdev_aux_add_remove(ztest_ds_t *zd, uint64_t id)
	{
	ztest_shared_t *zs = ztest_shared;
	spa_t *spa = ztest_spa;
	vdev_t *rvd = spa->spa_root_vdev;
	spa_aux_vdev_t *sav;
	char *aux;
	char *path;
	uint64_t guid = 0;
	int error, ignore_err = 0;

	if (ztest_opts.zo_mmp_test)
	return;

	path = umem_alloc(MAXPATHLEN, UMEM_NOFAIL);

	if (ztest_random(2) == 0) {
	sav = &spa->spa_spares;
	aux = ZPOOL_CONFIG_SPARES;
	} else {
	sav = &spa->spa_l2cache;
	aux = ZPOOL_CONFIG_L2CACHE;
	}

	mutex_enter(&ztest_vdev_lock);

	spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER);

	if (sav->sav_count != 0 && ztest_random(4) == 0) {
	/*
	* Pick a random device to remove.
	*/
	vdev_t *svd = sav->sav_vdevs[ztest_random(sav->sav_count)];

	/* dRAID spares cannot be removed; try anyways to see ENOTSUP */
	if (strstr(svd->vdev_path, VDEV_TYPE_DRAID) != NULL)
	ignore_err = ENOTSUP;

	guid = svd->vdev_guid;
	} else {
	/*
	* Find an unused device we can add.
	*/
	zs->zs_vdev_aux = 0;
	for (;;) {
	int c;
	(void) snprintf(path, MAXPATHLEN, ztest_aux_template,
	ztest_opts.zo_dir, ztest_opts.zo_pool, aux,
	zs->zs_vdev_aux);
	for (c = 0; c < sav->sav_count; c++)
	if (strcmp(sav->sav_vdevs[c]->vdev_path,
	path) == 0)
	break;
	if (c == sav->sav_count &&
	vdev_lookup_by_path(rvd, path) == NULL)
	break;
	zs->zs_vdev_aux++;
	}
	}

	spa_config_exit(spa, SCL_VDEV, FTAG);

	if (guid == 0) {
	/*
	* Add a new device.
	*/
	nvlist_t *nvroot = make_vdev_root(NULL, aux, NULL,
	(ztest_opts.zo_vdev_size * 5) / 4, 0, NULL, 0, 0, 1);
	error = spa_vdev_add(spa, nvroot);

	switch (error) {
	case 0:
	break;
	default:
	fatal(0, "spa_vdev_add(%p) = %d", nvroot, error);
	}
	fnvlist_free(nvroot);
	} else {
	/*
	* Remove an existing device. Sometimes, dirty its
	* vdev state first to make sure we handle removal
	* of devices that have pending state changes.
	*/
	if (ztest_random(2) == 0)
	(void) vdev_online(spa, guid, 0, NULL);

	error = spa_vdev_remove(spa, guid, B_FALSE);

	switch (error) {
	case 0:
	case EBUSY:
	case ZFS_ERR_CHECKPOINT_EXISTS:
	case ZFS_ERR_DISCARDING_CHECKPOINT:
	break;
	default:
	if (error != ignore_err)
	fatal(0, "spa_vdev_remove(%llu) = %d", guid,
	error);
	}
	}

	mutex_exit(&ztest_vdev_lock);

	umem_free(path, MAXPATHLEN);
	}

	/*
	* split a pool if it has mirror tlvdevs
	*/
	/* ARGSUSED */
	void
	ztest_split_pool(ztest_ds_t *zd, uint64_t id)
	{
	ztest_shared_t *zs = ztest_shared;
	spa_t *spa = ztest_spa;
	vdev_t *rvd = spa->spa_root_vdev;
	nvlist_t tree, child, config, split, *schild;
	uint_t c, children, schildren = 0, lastlogid = 0;
	int error = 0;

	if (ztest_opts.zo_mmp_test)
	return;

	mutex_enter(&ztest_vdev_lock);

	/* ensure we have a usable config; mirrors of raidz aren't supported */
	if (zs->zs_mirrors < 3 \|\| ztest_opts.zo_raid_children > 1) {
	mutex_exit(&ztest_vdev_lock);
	return;
	}

	/* clean up the old pool, if any */
	(void) spa_destroy("splitp");

	spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER);

	/* generate a config from the existing config */
	mutex_enter(&spa->spa_props_lock);
	tree = fnvlist_lookup_nvlist(spa->spa_config, ZPOOL_CONFIG_VDEV_TREE);
	mutex_exit(&spa->spa_props_lock);

	VERIFY0(nvlist_lookup_nvlist_array(tree, ZPOOL_CONFIG_CHILDREN,
	&child, &children));

	schild = malloc(rvd->vdev_children * sizeof (nvlist_t *));
	for (c = 0; c < children; c++) {
	vdev_t *tvd = rvd->vdev_child[c];
	nvlist_t **mchild;
	uint_t mchildren;

	if (tvd->vdev_islog \|\| tvd->vdev_ops == &vdev_hole_ops) {
	schild[schildren] = fnvlist_alloc();
	fnvlist_add_string(schild[schildren],
	ZPOOL_CONFIG_TYPE, VDEV_TYPE_HOLE);
	fnvlist_add_uint64(schild[schildren],
	ZPOOL_CONFIG_IS_HOLE, 1);
	if (lastlogid == 0)
	lastlogid = schildren;
	++schildren;
	continue;
	}
	lastlogid = 0;
	VERIFY0(nvlist_lookup_nvlist_array(child[c],
	ZPOOL_CONFIG_CHILDREN, &mchild, &mchildren));
	schild[schildren++] = fnvlist_dup(mchild[0]);
	}

	/* OK, create a config that can be used to split */
	split = fnvlist_alloc();
	fnvlist_add_string(split, ZPOOL_CONFIG_TYPE, VDEV_TYPE_ROOT);
	fnvlist_add_nvlist_array(split, ZPOOL_CONFIG_CHILDREN, schild,
	lastlogid != 0 ? lastlogid : schildren);

	config = fnvlist_alloc();
	fnvlist_add_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, split);

	for (c = 0; c < schildren; c++)
	fnvlist_free(schild[c]);
	free(schild);
	fnvlist_free(split);

	spa_config_exit(spa, SCL_VDEV, FTAG);

	(void) pthread_rwlock_wrlock(&ztest_name_lock);
	error = spa_vdev_split_mirror(spa, "splitp", config, NULL, B_FALSE);
	(void) pthread_rwlock_unlock(&ztest_name_lock);

	fnvlist_free(config);

	if (error == 0) {
	(void) printf("successful split - results:\n");
	mutex_enter(&spa_namespace_lock);
	show_pool_stats(spa);
	show_pool_stats(spa_lookup("splitp"));
	mutex_exit(&spa_namespace_lock);
	++zs->zs_splits;
	--zs->zs_mirrors;
	}
	mutex_exit(&ztest_vdev_lock);
	}

	/*
	* Verify that we can attach and detach devices.
	*/
	/* ARGSUSED */
	void
	ztest_vdev_attach_detach(ztest_ds_t *zd, uint64_t id)
	{
	ztest_shared_t *zs = ztest_shared;
	spa_t *spa = ztest_spa;
	spa_aux_vdev_t *sav = &spa->spa_spares;
	vdev_t *rvd = spa->spa_root_vdev;
	vdev_t oldvd, newvd, *pvd;
	nvlist_t *root;
	uint64_t leaves;
	uint64_t leaf, top;
	uint64_t ashift = ztest_get_ashift();
	uint64_t oldguid, pguid;
	uint64_t oldsize, newsize;
	char oldpath, newpath;
	int replacing;
	int oldvd_has_siblings = B_FALSE;
	int newvd_is_spare = B_FALSE;
	int newvd_is_dspare = B_FALSE;
	int oldvd_is_log;
	int error, expected_error;

	if (ztest_opts.zo_mmp_test)
	return;

	oldpath = umem_alloc(MAXPATHLEN, UMEM_NOFAIL);
	newpath = umem_alloc(MAXPATHLEN, UMEM_NOFAIL);

	mutex_enter(&ztest_vdev_lock);
	leaves = MAX(zs->zs_mirrors, 1) * ztest_opts.zo_raid_children;

	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);

	/*
	* If a vdev is in the process of being removed, its removal may
	* finish while we are in progress, leading to an unexpected error
	* value. Don't bother trying to attach while we are in the middle
	* of removal.
	*/
	if (ztest_device_removal_active) {
	spa_config_exit(spa, SCL_ALL, FTAG);
	goto out;
	}

	/*
	* Decide whether to do an attach or a replace.
	*/
	replacing = ztest_random(2);

	/*
	* Pick a random top-level vdev.
	*/
	top = ztest_random_vdev_top(spa, B_TRUE);

	/*
	* Pick a random leaf within it.
	*/
	leaf = ztest_random(leaves);

	/*
	* Locate this vdev.
	*/
	oldvd = rvd->vdev_child[top];

	/* pick a child from the mirror */
	if (zs->zs_mirrors >= 1) {
	ASSERT3P(oldvd->vdev_ops, ==, &vdev_mirror_ops);
	ASSERT3U(oldvd->vdev_children, >=, zs->zs_mirrors);
	oldvd = oldvd->vdev_child[leaf / ztest_opts.zo_raid_children];
	}

	/* pick a child out of the raidz group */
	if (ztest_opts.zo_raid_children > 1) {
	if (strcmp(oldvd->vdev_ops->vdev_op_type, "raidz") == 0)
	ASSERT3P(oldvd->vdev_ops, ==, &vdev_raidz_ops);
	else
	ASSERT3P(oldvd->vdev_ops, ==, &vdev_draid_ops);
	ASSERT3U(oldvd->vdev_children, ==, ztest_opts.zo_raid_children);
	oldvd = oldvd->vdev_child[leaf % ztest_opts.zo_raid_children];
	}

	/*
	* If we're already doing an attach or replace, oldvd may be a
	* mirror vdev -- in which case, pick a random child.
	*/
	while (oldvd->vdev_children != 0) {
	oldvd_has_siblings = B_TRUE;
	ASSERT3U(oldvd->vdev_children, >=, 2);
	oldvd = oldvd->vdev_child[ztest_random(oldvd->vdev_children)];
	}

	oldguid = oldvd->vdev_guid;
	oldsize = vdev_get_min_asize(oldvd);
	oldvd_is_log = oldvd->vdev_top->vdev_islog;
	(void) strcpy(oldpath, oldvd->vdev_path);
	pvd = oldvd->vdev_parent;
	pguid = pvd->vdev_guid;

	/*
	* If oldvd has siblings, then half of the time, detach it. Prior
	* to the detach the pool is scrubbed in order to prevent creating
	* unrepairable blocks as a result of the data corruption injection.
	*/
	if (oldvd_has_siblings && ztest_random(2) == 0) {
	spa_config_exit(spa, SCL_ALL, FTAG);

	error = ztest_scrub_impl(spa);
	if (error)
	goto out;

	error = spa_vdev_detach(spa, oldguid, pguid, B_FALSE);
	if (error != 0 && error != ENODEV && error != EBUSY &&
	error != ENOTSUP && error != ZFS_ERR_CHECKPOINT_EXISTS &&
	error != ZFS_ERR_DISCARDING_CHECKPOINT)
	fatal(0, "detach (%s) returned %d", oldpath, error);
	goto out;
	}

	/*
	* For the new vdev, choose with equal probability between the two
	* standard paths (ending in either 'a' or 'b') or a random hot spare.
	*/
	if (sav->sav_count != 0 && ztest_random(3) == 0) {
	newvd = sav->sav_vdevs[ztest_random(sav->sav_count)];
	newvd_is_spare = B_TRUE;

	if (newvd->vdev_ops == &vdev_draid_spare_ops)
	newvd_is_dspare = B_TRUE;

	(void) strcpy(newpath, newvd->vdev_path);
	} else {
	(void) snprintf(newpath, MAXPATHLEN, ztest_dev_template,
	ztest_opts.zo_dir, ztest_opts.zo_pool,
	top * leaves + leaf);
	if (ztest_random(2) == 0)
	newpath[strlen(newpath) - 1] = 'b';
	newvd = vdev_lookup_by_path(rvd, newpath);
	}

	if (newvd) {
	/*
	* Reopen to ensure the vdev's asize field isn't stale.
	*/
	vdev_reopen(newvd);
	newsize = vdev_get_min_asize(newvd);
	} else {
	/*
	* Make newsize a little bigger or smaller than oldsize.
	* If it's smaller, the attach should fail.
	* If it's larger, and we're doing a replace,
	* we should get dynamic LUN growth when we're done.
	*/
	newsize = 10 * oldsize / (9 + ztest_random(3));
	}

	/*
	* If pvd is not a mirror or root, the attach should fail with ENOTSUP,
	* unless it's a replace; in that case any non-replacing parent is OK.
	*
	* If newvd is already part of the pool, it should fail with EBUSY.
	*
	* If newvd is too small, it should fail with EOVERFLOW.
	*
	* If newvd is a distributed spare and it's being attached to a
	* dRAID which is not its parent it should fail with EINVAL.
	*/
	if (pvd->vdev_ops != &vdev_mirror_ops &&
	pvd->vdev_ops != &vdev_root_ops && (!replacing \|\|
	pvd->vdev_ops == &vdev_replacing_ops \|\|
	pvd->vdev_ops == &vdev_spare_ops))
	expected_error = ENOTSUP;
	else if (newvd_is_spare && (!replacing \|\| oldvd_is_log))
	expected_error = ENOTSUP;
	else if (newvd == oldvd)
	expected_error = replacing ? 0 : EBUSY;
	else if (vdev_lookup_by_path(rvd, newpath) != NULL)
	expected_error = EBUSY;
	else if (!newvd_is_dspare && newsize < oldsize)
	expected_error = EOVERFLOW;
	else if (ashift > oldvd->vdev_top->vdev_ashift)
	expected_error = EDOM;
	else if (newvd_is_dspare && pvd != vdev_draid_spare_get_parent(newvd))
	expected_error = ENOTSUP;
	else
	expected_error = 0;

	spa_config_exit(spa, SCL_ALL, FTAG);

	/*
	* Build the nvlist describing newpath.
	*/
	root = make_vdev_root(newpath, NULL, NULL, newvd == NULL ? newsize : 0,
	ashift, NULL, 0, 0, 1);

	/*
	* When supported select either a healing or sequential resilver.
	*/
	boolean_t rebuilding = B_FALSE;
	if (pvd->vdev_ops == &vdev_mirror_ops \|\|
	pvd->vdev_ops == &vdev_root_ops) {
	rebuilding = !!ztest_random(2);
	}

	error = spa_vdev_attach(spa, oldguid, root, replacing, rebuilding);

	fnvlist_free(root);

	/*
	* If our parent was the replacing vdev, but the replace completed,
	* then instead of failing with ENOTSUP we may either succeed,
	* fail with ENODEV, or fail with EOVERFLOW.
	*/
	if (expected_error == ENOTSUP &&
	(error == 0 \|\| error == ENODEV \|\| error == EOVERFLOW))
	expected_error = error;

	/*
	* If someone grew the LUN, the replacement may be too small.
	*/
	if (error == EOVERFLOW \|\| error == EBUSY)
	expected_error = error;

	if (error == ZFS_ERR_CHECKPOINT_EXISTS \|\|
	error == ZFS_ERR_DISCARDING_CHECKPOINT \|\|
	error == ZFS_ERR_RESILVER_IN_PROGRESS \|\|
	error == ZFS_ERR_REBUILD_IN_PROGRESS)
	expected_error = error;

	if (error != expected_error && expected_error != EBUSY) {
	fatal(0, "attach (%s %llu, %s %llu, %d) "
	"returned %d, expected %d",
	oldpath, oldsize, newpath,
	newsize, replacing, error, expected_error);
	}
	out:
	mutex_exit(&ztest_vdev_lock);

	umem_free(oldpath, MAXPATHLEN);
	umem_free(newpath, MAXPATHLEN);
	}

	/* ARGSUSED */
	void
	ztest_device_removal(ztest_ds_t *zd, uint64_t id)
	{
	spa_t *spa = ztest_spa;
	vdev_t *vd;
	uint64_t guid;
	int error;

	mutex_enter(&ztest_vdev_lock);

	if (ztest_device_removal_active) {
	mutex_exit(&ztest_vdev_lock);
	return;
	}

	/*
	* Remove a random top-level vdev and wait for removal to finish.
	*/
	spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER);
	vd = vdev_lookup_top(spa, ztest_random_vdev_top(spa, B_FALSE));
	guid = vd->vdev_guid;
	spa_config_exit(spa, SCL_VDEV, FTAG);

	error = spa_vdev_remove(spa, guid, B_FALSE);
	if (error == 0) {
	ztest_device_removal_active = B_TRUE;
	mutex_exit(&ztest_vdev_lock);

	/*
	* spa->spa_vdev_removal is created in a sync task that
	* is initiated via dsl_sync_task_nowait(). Since the
	* task may not run before spa_vdev_remove() returns, we
	* must wait at least 1 txg to ensure that the removal
	* struct has been created.
	*/
	txg_wait_synced(spa_get_dsl(spa), 0);

	while (spa->spa_removing_phys.sr_state == DSS_SCANNING)
	txg_wait_synced(spa_get_dsl(spa), 0);
	} else {
	mutex_exit(&ztest_vdev_lock);
	return;
	}

	/*
	* The pool needs to be scrubbed after completing device removal.
	* Failure to do so may result in checksum errors due to the
	* strategy employed by ztest_fault_inject() when selecting which
	* offset are redundant and can be damaged.
	*/
	error = spa_scan(spa, POOL_SCAN_SCRUB);
	if (error == 0) {
	while (dsl_scan_scrubbing(spa_get_dsl(spa)))
	txg_wait_synced(spa_get_dsl(spa), 0);
	}

	mutex_enter(&ztest_vdev_lock);
	ztest_device_removal_active = B_FALSE;
	mutex_exit(&ztest_vdev_lock);
	}

	/*
	* Callback function which expands the physical size of the vdev.
	*/
	static vdev_t *
	grow_vdev(vdev_t vd, void arg)
	{
	spa_t *spa __maybe_unused = vd->vdev_spa;
	size_t *newsize = arg;
	size_t fsize;
	int fd;

	ASSERT3S(spa_config_held(spa, SCL_STATE, RW_READER), ==, SCL_STATE);
	ASSERT(vd->vdev_ops->vdev_op_leaf);

	if ((fd = open(vd->vdev_path, O_RDWR)) == -1)
	return (vd);

	fsize = lseek(fd, 0, SEEK_END);
	VERIFY0(ftruncate(fd, *newsize));

	if (ztest_opts.zo_verbose >= 6) {
	(void) printf("%s grew from %lu to %lu bytes\n",
	vd->vdev_path, (ulong_t)fsize, (ulong_t)*newsize);
	}
	(void) close(fd);
	return (NULL);
	}

	/*
	* Callback function which expands a given vdev by calling vdev_online().
	*/
	/* ARGSUSED */
	static vdev_t *
	online_vdev(vdev_t vd, void arg)
	{
	spa_t *spa = vd->vdev_spa;
	vdev_t *tvd = vd->vdev_top;
	uint64_t guid = vd->vdev_guid;
	uint64_t generation = spa->spa_config_generation + 1;
	vdev_state_t newstate = VDEV_STATE_UNKNOWN;
	int error;

	ASSERT3S(spa_config_held(spa, SCL_STATE, RW_READER), ==, SCL_STATE);
	ASSERT(vd->vdev_ops->vdev_op_leaf);

	/* Calling vdev_online will initialize the new metaslabs */
	spa_config_exit(spa, SCL_STATE, spa);
	error = vdev_online(spa, guid, ZFS_ONLINE_EXPAND, &newstate);
	spa_config_enter(spa, SCL_STATE, spa, RW_READER);

	/*
	* If vdev_online returned an error or the underlying vdev_open
	* failed then we abort the expand. The only way to know that
	* vdev_open fails is by checking the returned newstate.
	*/
	if (error \|\| newstate != VDEV_STATE_HEALTHY) {
	if (ztest_opts.zo_verbose >= 5) {
	(void) printf("Unable to expand vdev, state %llu, "
	"error %d\n", (u_longlong_t)newstate, error);
	}
	return (vd);
	}
	ASSERT3U(newstate, ==, VDEV_STATE_HEALTHY);

	/*
	* Since we dropped the lock we need to ensure that we're
	* still talking to the original vdev. It's possible this
	* vdev may have been detached/replaced while we were
	* trying to online it.
	*/
	if (generation != spa->spa_config_generation) {
	if (ztest_opts.zo_verbose >= 5) {
	(void) printf("vdev configuration has changed, "
	"guid %llu, state %llu, expected gen %llu, "
	"got gen %llu\n",
	(u_longlong_t)guid,
	(u_longlong_t)tvd->vdev_state,
	(u_longlong_t)generation,
	(u_longlong_t)spa->spa_config_generation);
	}
	return (vd);
	}
	return (NULL);
	}

	/*
	* Traverse the vdev tree calling the supplied function.
	* We continue to walk the tree until we either have walked all
	* children or we receive a non-NULL return from the callback.
	* If a NULL callback is passed, then we just return back the first
	* leaf vdev we encounter.
	*/
	static vdev_t *
	vdev_walk_tree(vdev_t vd, vdev_t (func)(vdev_t , void ), void arg)
	{
	uint_t c;

	if (vd->vdev_ops->vdev_op_leaf) {
	if (func == NULL)
	return (vd);
	else
	return (func(vd, arg));
	}

	for (c = 0; c < vd->vdev_children; c++) {
	vdev_t *cvd = vd->vdev_child[c];
	if ((cvd = vdev_walk_tree(cvd, func, arg)) != NULL)
	return (cvd);
	}
	return (NULL);
	}

	/*
	* Verify that dynamic LUN growth works as expected.
	*/
	/* ARGSUSED */
	void
	ztest_vdev_LUN_growth(ztest_ds_t *zd, uint64_t id)
	{
	spa_t *spa = ztest_spa;
	vdev_t vd, tvd;
	metaslab_class_t *mc;
	metaslab_group_t *mg;
	size_t psize, newsize;
	uint64_t top;
	uint64_t old_class_space, new_class_space, old_ms_count, new_ms_count;

	mutex_enter(&ztest_checkpoint_lock);
	mutex_enter(&ztest_vdev_lock);
	spa_config_enter(spa, SCL_STATE, spa, RW_READER);

	/*
	* If there is a vdev removal in progress, it could complete while
	* we are running, in which case we would not be able to verify
	* that the metaslab_class space increased (because it decreases
	* when the device removal completes).
	*/
	if (ztest_device_removal_active) {
	spa_config_exit(spa, SCL_STATE, spa);
	mutex_exit(&ztest_vdev_lock);
	mutex_exit(&ztest_checkpoint_lock);
	return;
	}

	top = ztest_random_vdev_top(spa, B_TRUE);

	tvd = spa->spa_root_vdev->vdev_child[top];
	mg = tvd->vdev_mg;
	mc = mg->mg_class;
	old_ms_count = tvd->vdev_ms_count;
	old_class_space = metaslab_class_get_space(mc);

	/*
	* Determine the size of the first leaf vdev associated with
	* our top-level device.
	*/
	vd = vdev_walk_tree(tvd, NULL, NULL);
	ASSERT3P(vd, !=, NULL);
	ASSERT(vd->vdev_ops->vdev_op_leaf);

	psize = vd->vdev_psize;

	/*
	* We only try to expand the vdev if it's healthy, less than 4x its
	* original size, and it has a valid psize.
	*/
	if (tvd->vdev_state != VDEV_STATE_HEALTHY \|\|
	psize == 0 \|\| psize >= 4 * ztest_opts.zo_vdev_size) {
	spa_config_exit(spa, SCL_STATE, spa);
	mutex_exit(&ztest_vdev_lock);
	mutex_exit(&ztest_checkpoint_lock);
	return;
	}
	ASSERT3U(psize, >, 0);
	newsize = psize + MAX(psize / 8, SPA_MAXBLOCKSIZE);
	ASSERT3U(newsize, >, psize);

	if (ztest_opts.zo_verbose >= 6) {
	(void) printf("Expanding LUN %s from %lu to %lu\n",
	vd->vdev_path, (ulong_t)psize, (ulong_t)newsize);
	}

	/*
	* Growing the vdev is a two step process:
	* 1). expand the physical size (i.e. relabel)
	* 2). online the vdev to create the new metaslabs
	*/
	if (vdev_walk_tree(tvd, grow_vdev, &newsize) != NULL \|\|
	vdev_walk_tree(tvd, online_vdev, NULL) != NULL \|\|
	tvd->vdev_state != VDEV_STATE_HEALTHY) {
	if (ztest_opts.zo_verbose >= 5) {
	(void) printf("Could not expand LUN because "
	"the vdev configuration changed.\n");
	}
	spa_config_exit(spa, SCL_STATE, spa);
	mutex_exit(&ztest_vdev_lock);
	mutex_exit(&ztest_checkpoint_lock);
	return;
	}

	spa_config_exit(spa, SCL_STATE, spa);

	/*
	* Expanding the LUN will update the config asynchronously,
	* thus we must wait for the async thread to complete any
	* pending tasks before proceeding.
	*/
	for (;;) {
	boolean_t done;
	mutex_enter(&spa->spa_async_lock);
	done = (spa->spa_async_thread == NULL && !spa->spa_async_tasks);
	mutex_exit(&spa->spa_async_lock);
	if (done)
	break;
	txg_wait_synced(spa_get_dsl(spa), 0);
	(void) poll(NULL, 0, 100);
	}

	spa_config_enter(spa, SCL_STATE, spa, RW_READER);

	tvd = spa->spa_root_vdev->vdev_child[top];
	new_ms_count = tvd->vdev_ms_count;
	new_class_space = metaslab_class_get_space(mc);

	if (tvd->vdev_mg != mg \|\| mg->mg_class != mc) {
	if (ztest_opts.zo_verbose >= 5) {
	(void) printf("Could not verify LUN expansion due to "
	"intervening vdev offline or remove.\n");
	}
	spa_config_exit(spa, SCL_STATE, spa);
	mutex_exit(&ztest_vdev_lock);
	mutex_exit(&ztest_checkpoint_lock);
	return;
	}

	/*
	* Make sure we were able to grow the vdev.
	*/
	if (new_ms_count <= old_ms_count) {
	fatal(0, "LUN expansion failed: ms_count %llu < %llu\n",
	old_ms_count, new_ms_count);
	}

	/*
	* Make sure we were able to grow the pool.
	*/
	if (new_class_space <= old_class_space) {
	fatal(0, "LUN expansion failed: class_space %llu < %llu\n",
	old_class_space, new_class_space);
	}

	if (ztest_opts.zo_verbose >= 5) {
	char oldnumbuf[NN_NUMBUF_SZ], newnumbuf[NN_NUMBUF_SZ];

	nicenum(old_class_space, oldnumbuf, sizeof (oldnumbuf));
	nicenum(new_class_space, newnumbuf, sizeof (newnumbuf));
	(void) printf("%s grew from %s to %s\n",
	spa->spa_name, oldnumbuf, newnumbuf);
	}

	spa_config_exit(spa, SCL_STATE, spa);
	mutex_exit(&ztest_vdev_lock);
	mutex_exit(&ztest_checkpoint_lock);
	}

	/*
	* Verify that dmu_objset_{create,destroy,open,close} work as expected.
	*/
	/* ARGSUSED */
	static void
	ztest_objset_create_cb(objset_t os, void arg, cred_t cr, dmu_tx_t tx)
	{
	/*
	* Create the objects common to all ztest datasets.
	*/
	VERIFY0(zap_create_claim(os, ZTEST_DIROBJ,
	DMU_OT_ZAP_OTHER, DMU_OT_NONE, 0, tx));
	}

	static int
	ztest_dataset_create(char *dsname)
	{
	int err;
	uint64_t rand;
	dsl_crypto_params_t *dcp = NULL;

	/*
	* 50% of the time, we create encrypted datasets
	* using a random cipher suite and a hard-coded
	* wrapping key.
	*/
	rand = ztest_random(2);
	if (rand != 0) {
	nvlist_t *crypto_args = fnvlist_alloc();
	nvlist_t *props = fnvlist_alloc();

	/* slight bias towards the default cipher suite */
	rand = ztest_random(ZIO_CRYPT_FUNCTIONS);
	if (rand < ZIO_CRYPT_AES_128_CCM)
	rand = ZIO_CRYPT_ON;

	fnvlist_add_uint64(props,
	zfs_prop_to_name(ZFS_PROP_ENCRYPTION), rand);
	fnvlist_add_uint8_array(crypto_args, "wkeydata",
	(uint8_t *)ztest_wkeydata, WRAPPING_KEY_LEN);

	/*
	* These parameters aren't really used by the kernel. They
	* are simply stored so that userspace knows how to load
	* the wrapping key.
	*/
	fnvlist_add_uint64(props,
	zfs_prop_to_name(ZFS_PROP_KEYFORMAT), ZFS_KEYFORMAT_RAW);
	fnvlist_add_string(props,
	zfs_prop_to_name(ZFS_PROP_KEYLOCATION), "prompt");
	fnvlist_add_uint64(props,
	zfs_prop_to_name(ZFS_PROP_PBKDF2_SALT), 0ULL);
	fnvlist_add_uint64(props,
	zfs_prop_to_name(ZFS_PROP_PBKDF2_ITERS), 0ULL);

	VERIFY0(dsl_crypto_params_create_nvlist(DCP_CMD_NONE, props,
	crypto_args, &dcp));

	/*
	* Cycle through all available encryption implementations
	* to verify interoperability.
	*/
	VERIFY0(gcm_impl_set("cycle"));
	VERIFY0(aes_impl_set("cycle"));

	fnvlist_free(crypto_args);
	fnvlist_free(props);
	}

	err = dmu_objset_create(dsname, DMU_OST_OTHER, 0, dcp,
	ztest_objset_create_cb, NULL);
	dsl_crypto_params_free(dcp, !!err);

	rand = ztest_random(100);
	if (err \|\| rand < 80)
	return (err);

	if (ztest_opts.zo_verbose >= 5)
	(void) printf("Setting dataset %s to sync always\n", dsname);
	return (ztest_dsl_prop_set_uint64(dsname, ZFS_PROP_SYNC,
	ZFS_SYNC_ALWAYS, B_FALSE));
	}

	/* ARGSUSED */
	static int
	ztest_objset_destroy_cb(const char name, void arg)
	{
	objset_t *os;
	dmu_object_info_t doi;
	int error;

	/*
	* Verify that the dataset contains a directory object.
	*/
	VERIFY0(ztest_dmu_objset_own(name, DMU_OST_OTHER, B_TRUE,
	B_TRUE, FTAG, &os));
	error = dmu_object_info(os, ZTEST_DIROBJ, &doi);
	if (error != ENOENT) {
	/* We could have crashed in the middle of destroying it */
	ASSERT0(error);
	ASSERT3U(doi.doi_type, ==, DMU_OT_ZAP_OTHER);
	ASSERT3S(doi.doi_physical_blocks_512, >=, 0);
	}
	dmu_objset_disown(os, B_TRUE, FTAG);

	/*
	* Destroy the dataset.
	*/
	if (strchr(name, '@') != NULL) {
	VERIFY0(dsl_destroy_snapshot(name, B_TRUE));
	} else {
	error = dsl_destroy_head(name);
	if (error == ENOSPC) {
	/* There could be checkpoint or insufficient slop */
	ztest_record_enospc(FTAG);
	} else if (error != EBUSY) {
	/* There could be a hold on this dataset */
	ASSERT0(error);
	}
	}
	return (0);
	}

	static boolean_t
	ztest_snapshot_create(char *osname, uint64_t id)
	{
	char snapname[ZFS_MAX_DATASET_NAME_LEN];
	int error;

	(void) snprintf(snapname, sizeof (snapname), "%llu", (u_longlong_t)id);

	error = dmu_objset_snapshot_one(osname, snapname);
	if (error == ENOSPC) {
	ztest_record_enospc(FTAG);
	return (B_FALSE);
	}
	if (error != 0 && error != EEXIST) {
	fatal(0, "ztest_snapshot_create(%s@%s) = %d", osname,
	snapname, error);
	}
	return (B_TRUE);
	}

	static boolean_t
	ztest_snapshot_destroy(char *osname, uint64_t id)
	{
	char snapname[ZFS_MAX_DATASET_NAME_LEN];
	int error;

	(void) snprintf(snapname, sizeof (snapname), "%s@%llu", osname,
	(u_longlong_t)id);

	error = dsl_destroy_snapshot(snapname, B_FALSE);
	if (error != 0 && error != ENOENT)
	fatal(0, "ztest_snapshot_destroy(%s) = %d", snapname, error);
	return (B_TRUE);
	}

	/* ARGSUSED */
	void
	ztest_dmu_objset_create_destroy(ztest_ds_t *zd, uint64_t id)
	{
	ztest_ds_t *zdtmp;
	int iters;
	int error;
	objset_t os, os2;
	char name[ZFS_MAX_DATASET_NAME_LEN];
	zilog_t *zilog;
	int i;

	zdtmp = umem_alloc(sizeof (ztest_ds_t), UMEM_NOFAIL);

	(void) pthread_rwlock_rdlock(&ztest_name_lock);

	(void) snprintf(name, sizeof (name), "%s/temp_%llu",
	ztest_opts.zo_pool, (u_longlong_t)id);

	/*
	* If this dataset exists from a previous run, process its replay log
	* half of the time. If we don't replay it, then dsl_destroy_head()
	* (invoked from ztest_objset_destroy_cb()) should just throw it away.
	*/
	if (ztest_random(2) == 0 &&
	ztest_dmu_objset_own(name, DMU_OST_OTHER, B_FALSE,
	B_TRUE, FTAG, &os) == 0) {
	ztest_zd_init(zdtmp, NULL, os);
	zil_replay(os, zdtmp, ztest_replay_vector);
	ztest_zd_fini(zdtmp);
	dmu_objset_disown(os, B_TRUE, FTAG);
	}

	/*
	* There may be an old instance of the dataset we're about to
	* create lying around from a previous run. If so, destroy it
	* and all of its snapshots.
	*/
	(void) dmu_objset_find(name, ztest_objset_destroy_cb, NULL,
	DS_FIND_CHILDREN \| DS_FIND_SNAPSHOTS);

	/*
	* Verify that the destroyed dataset is no longer in the namespace.
	*/
	VERIFY3U(ENOENT, ==, ztest_dmu_objset_own(name, DMU_OST_OTHER, B_TRUE,
	B_TRUE, FTAG, &os));

	/*
	* Verify that we can create a new dataset.
	*/
	error = ztest_dataset_create(name);
	if (error) {
	if (error == ENOSPC) {
	ztest_record_enospc(FTAG);
	goto out;
	}
	fatal(0, "dmu_objset_create(%s) = %d", name, error);
	}

	VERIFY0(ztest_dmu_objset_own(name, DMU_OST_OTHER, B_FALSE, B_TRUE,
	FTAG, &os));

	ztest_zd_init(zdtmp, NULL, os);

	/*
	* Open the intent log for it.
	*/
	zilog = zil_open(os, ztest_get_data);

	/*
	* Put some objects in there, do a little I/O to them,
	* and randomly take a couple of snapshots along the way.
	*/
	iters = ztest_random(5);
	for (i = 0; i < iters; i++) {
	ztest_dmu_object_alloc_free(zdtmp, id);
	if (ztest_random(iters) == 0)
	(void) ztest_snapshot_create(name, i);
	}

	/*
	* Verify that we cannot create an existing dataset.
	*/
	VERIFY3U(EEXIST, ==,
	dmu_objset_create(name, DMU_OST_OTHER, 0, NULL, NULL, NULL));

	/*
	* Verify that we can hold an objset that is also owned.
	*/
	VERIFY0(dmu_objset_hold(name, FTAG, &os2));
	dmu_objset_rele(os2, FTAG);

	/*
	* Verify that we cannot own an objset that is already owned.
	*/
	VERIFY3U(EBUSY, ==, ztest_dmu_objset_own(name, DMU_OST_OTHER,
	B_FALSE, B_TRUE, FTAG, &os2));

	zil_close(zilog);
	dmu_objset_disown(os, B_TRUE, FTAG);
	ztest_zd_fini(zdtmp);
	out:
	(void) pthread_rwlock_unlock(&ztest_name_lock);

	umem_free(zdtmp, sizeof (ztest_ds_t));
	}

	/*
	* Verify that dmu_snapshot_{create,destroy,open,close} work as expected.
	*/
	void
	ztest_dmu_snapshot_create_destroy(ztest_ds_t *zd, uint64_t id)
	{
	(void) pthread_rwlock_rdlock(&ztest_name_lock);
	(void) ztest_snapshot_destroy(zd->zd_name, id);
	(void) ztest_snapshot_create(zd->zd_name, id);
	(void) pthread_rwlock_unlock(&ztest_name_lock);
	}

	/*
	* Cleanup non-standard snapshots and clones.
	*/
	static void
	ztest_dsl_dataset_cleanup(char *osname, uint64_t id)
	{
	char *snap1name;
	char *clone1name;
	char *snap2name;
	char *clone2name;
	char *snap3name;
	int error;

	snap1name = umem_alloc(ZFS_MAX_DATASET_NAME_LEN, UMEM_NOFAIL);
	clone1name = umem_alloc(ZFS_MAX_DATASET_NAME_LEN, UMEM_NOFAIL);
	snap2name = umem_alloc(ZFS_MAX_DATASET_NAME_LEN, UMEM_NOFAIL);
	clone2name = umem_alloc(ZFS_MAX_DATASET_NAME_LEN, UMEM_NOFAIL);
	snap3name = umem_alloc(ZFS_MAX_DATASET_NAME_LEN, UMEM_NOFAIL);

	(void) snprintf(snap1name, ZFS_MAX_DATASET_NAME_LEN,
	"%s@s1_%llu", osname, (u_longlong_t)id);
	(void) snprintf(clone1name, ZFS_MAX_DATASET_NAME_LEN,
	"%s/c1_%llu", osname, (u_longlong_t)id);
	(void) snprintf(snap2name, ZFS_MAX_DATASET_NAME_LEN,
	"%s@s2_%llu", clone1name, (u_longlong_t)id);
	(void) snprintf(clone2name, ZFS_MAX_DATASET_NAME_LEN,
	"%s/c2_%llu", osname, (u_longlong_t)id);
	(void) snprintf(snap3name, ZFS_MAX_DATASET_NAME_LEN,
	"%s@s3_%llu", clone1name, (u_longlong_t)id);

	error = dsl_destroy_head(clone2name);
	if (error && error != ENOENT)
	fatal(0, "dsl_destroy_head(%s) = %d", clone2name, error);
	error = dsl_destroy_snapshot(snap3name, B_FALSE);
	if (error && error != ENOENT)
	fatal(0, "dsl_destroy_snapshot(%s) = %d", snap3name, error);
	error = dsl_destroy_snapshot(snap2name, B_FALSE);
	if (error && error != ENOENT)
	fatal(0, "dsl_destroy_snapshot(%s) = %d", snap2name, error);
	error = dsl_destroy_head(clone1name);
	if (error && error != ENOENT)
	fatal(0, "dsl_destroy_head(%s) = %d", clone1name, error);
	error = dsl_destroy_snapshot(snap1name, B_FALSE);
	if (error && error != ENOENT)
	fatal(0, "dsl_destroy_snapshot(%s) = %d", snap1name, error);

	umem_free(snap1name, ZFS_MAX_DATASET_NAME_LEN);
	umem_free(clone1name, ZFS_MAX_DATASET_NAME_LEN);
	umem_free(snap2name, ZFS_MAX_DATASET_NAME_LEN);
	umem_free(clone2name, ZFS_MAX_DATASET_NAME_LEN);
	umem_free(snap3name, ZFS_MAX_DATASET_NAME_LEN);
	}

	/*
	* Verify dsl_dataset_promote handles EBUSY
	*/
	void
	ztest_dsl_dataset_promote_busy(ztest_ds_t *zd, uint64_t id)
	{
	objset_t *os;
	char *snap1name;
	char *clone1name;
	char *snap2name;
	char *clone2name;
	char *snap3name;
	char *osname = zd->zd_name;
	int error;

	snap1name = umem_alloc(ZFS_MAX_DATASET_NAME_LEN, UMEM_NOFAIL);
	clone1name = umem_alloc(ZFS_MAX_DATASET_NAME_LEN, UMEM_NOFAIL);
	snap2name = umem_alloc(ZFS_MAX_DATASET_NAME_LEN, UMEM_NOFAIL);
	clone2name = umem_alloc(ZFS_MAX_DATASET_NAME_LEN, UMEM_NOFAIL);
	snap3name = umem_alloc(ZFS_MAX_DATASET_NAME_LEN, UMEM_NOFAIL);

	(void) pthread_rwlock_rdlock(&ztest_name_lock);

	ztest_dsl_dataset_cleanup(osname, id);

	(void) snprintf(snap1name, ZFS_MAX_DATASET_NAME_LEN,
	"%s@s1_%llu", osname, (u_longlong_t)id);
	(void) snprintf(clone1name, ZFS_MAX_DATASET_NAME_LEN,
	"%s/c1_%llu", osname, (u_longlong_t)id);
	(void) snprintf(snap2name, ZFS_MAX_DATASET_NAME_LEN,
	"%s@s2_%llu", clone1name, (u_longlong_t)id);
	(void) snprintf(clone2name, ZFS_MAX_DATASET_NAME_LEN,
	"%s/c2_%llu", osname, (u_longlong_t)id);
	(void) snprintf(snap3name, ZFS_MAX_DATASET_NAME_LEN,
	"%s@s3_%llu", clone1name, (u_longlong_t)id);

	error = dmu_objset_snapshot_one(osname, strchr(snap1name, '@') + 1);
	if (error && error != EEXIST) {
	if (error == ENOSPC) {
	ztest_record_enospc(FTAG);
	goto out;
	}
	fatal(0, "dmu_take_snapshot(%s) = %d", snap1name, error);
	}

	error = dmu_objset_clone(clone1name, snap1name);
	if (error) {
	if (error == ENOSPC) {
	ztest_record_enospc(FTAG);
	goto out;
	}
	fatal(0, "dmu_objset_create(%s) = %d", clone1name, error);
	}

	error = dmu_objset_snapshot_one(clone1name, strchr(snap2name, '@') + 1);
	if (error && error != EEXIST) {
	if (error == ENOSPC) {
	ztest_record_enospc(FTAG);
	goto out;
	}
	fatal(0, "dmu_open_snapshot(%s) = %d", snap2name, error);
	}

	error = dmu_objset_snapshot_one(clone1name, strchr(snap3name, '@') + 1);
	if (error && error != EEXIST) {
	if (error == ENOSPC) {
	ztest_record_enospc(FTAG);
	goto out;
	}
	fatal(0, "dmu_open_snapshot(%s) = %d", snap3name, error);
	}

	error = dmu_objset_clone(clone2name, snap3name);
	if (error) {
	if (error == ENOSPC) {
	ztest_record_enospc(FTAG);
	goto out;
	}
	fatal(0, "dmu_objset_create(%s) = %d", clone2name, error);
	}

	error = ztest_dmu_objset_own(snap2name, DMU_OST_ANY, B_TRUE, B_TRUE,
	FTAG, &os);
	if (error)
	fatal(0, "dmu_objset_own(%s) = %d", snap2name, error);
	error = dsl_dataset_promote(clone2name, NULL);
	if (error == ENOSPC) {
	dmu_objset_disown(os, B_TRUE, FTAG);
	ztest_record_enospc(FTAG);
	goto out;
	}
	if (error != EBUSY)
	fatal(0, "dsl_dataset_promote(%s), %d, not EBUSY", clone2name,
	error);
	dmu_objset_disown(os, B_TRUE, FTAG);

	out:
	ztest_dsl_dataset_cleanup(osname, id);

	(void) pthread_rwlock_unlock(&ztest_name_lock);

	umem_free(snap1name, ZFS_MAX_DATASET_NAME_LEN);
	umem_free(clone1name, ZFS_MAX_DATASET_NAME_LEN);
	umem_free(snap2name, ZFS_MAX_DATASET_NAME_LEN);
	umem_free(clone2name, ZFS_MAX_DATASET_NAME_LEN);
	umem_free(snap3name, ZFS_MAX_DATASET_NAME_LEN);
	}

	#undef OD_ARRAY_SIZE
	#define OD_ARRAY_SIZE 4

	/*
	* Verify that dmu_object_{alloc,free} work as expected.
	*/
	void
	ztest_dmu_object_alloc_free(ztest_ds_t *zd, uint64_t id)
	{
	ztest_od_t *od;
	int batchsize;
	int size;
	int b;

	size = sizeof (ztest_od_t) * OD_ARRAY_SIZE;
	od = umem_alloc(size, UMEM_NOFAIL);
	batchsize = OD_ARRAY_SIZE;

	for (b = 0; b < batchsize; b++)
	ztest_od_init(od + b, id, FTAG, b, DMU_OT_UINT64_OTHER,
	0, 0, 0);

	/*
	* Destroy the previous batch of objects, create a new batch,
	* and do some I/O on the new objects.
	*/
	if (ztest_object_init(zd, od, size, B_TRUE) != 0)
	return;

	while (ztest_random(4 * batchsize) != 0)
	ztest_io(zd, od[ztest_random(batchsize)].od_object,
	ztest_random(ZTEST_RANGE_LOCKS) << SPA_MAXBLOCKSHIFT);

	umem_free(od, size);
	}

	/*
	* Rewind the global allocator to verify object allocation backfilling.
	*/
	void
	ztest_dmu_object_next_chunk(ztest_ds_t *zd, uint64_t id)
	{
	objset_t *os = zd->zd_os;
	int dnodes_per_chunk = 1 << dmu_object_alloc_chunk_shift;
	uint64_t object;

	/*
	* Rewind the global allocator randomly back to a lower object number
	* to force backfilling and reclamation of recently freed dnodes.
	*/
	mutex_enter(&os->os_obj_lock);
	object = ztest_random(os->os_obj_next_chunk);
	os->os_obj_next_chunk = P2ALIGN(object, dnodes_per_chunk);
	mutex_exit(&os->os_obj_lock);
	}

	#undef OD_ARRAY_SIZE
	#define OD_ARRAY_SIZE 2

	/*
	* Verify that dmu_{read,write} work as expected.
	*/
	void
	ztest_dmu_read_write(ztest_ds_t *zd, uint64_t id)
	{
	int size;
	ztest_od_t *od;

	objset_t *os = zd->zd_os;
	size = sizeof (ztest_od_t) * OD_ARRAY_SIZE;
	od = umem_alloc(size, UMEM_NOFAIL);
	dmu_tx_t *tx;
	int i, freeit, error;
	uint64_t n, s, txg;
	bufwad_t packbuf, bigbuf, pack, bigH, *bigT;
	uint64_t packobj, packoff, packsize, bigobj, bigoff, bigsize;
	uint64_t chunksize = (1000 + ztest_random(1000)) * sizeof (uint64_t);
	uint64_t regions = 997;
	uint64_t stride = 123456789ULL;
	uint64_t width = 40;
	int free_percent = 5;

	/*
	* This test uses two objects, packobj and bigobj, that are always
	* updated together (i.e. in the same tx) so that their contents are
	* in sync and can be compared. Their contents relate to each other
	* in a simple way: packobj is a dense array of 'bufwad' structures,
	* while bigobj is a sparse array of the same bufwads. Specifically,
	* for any index n, there are three bufwads that should be identical:
	*
	* packobj, at offset n * sizeof (bufwad_t)
	* bigobj, at the head of the nth chunk
	* bigobj, at the tail of the nth chunk
	*
	* The chunk size is arbitrary. It doesn't have to be a power of two,
	* and it doesn't have any relation to the object blocksize.
	* The only requirement is that it can hold at least two bufwads.
	*
	* Normally, we write the bufwad to each of these locations.
	* However, free_percent of the time we instead write zeroes to
	* packobj and perform a dmu_free_range() on bigobj. By comparing
	* bigobj to packobj, we can verify that the DMU is correctly
	* tracking which parts of an object are allocated and free,
	* and that the contents of the allocated blocks are correct.
	*/

	/*
	* Read the directory info. If it's the first time, set things up.
	*/
	ztest_od_init(od, id, FTAG, 0, DMU_OT_UINT64_OTHER, 0, 0, chunksize);
	ztest_od_init(od + 1, id, FTAG, 1, DMU_OT_UINT64_OTHER, 0, 0,
	chunksize);

	if (ztest_object_init(zd, od, size, B_FALSE) != 0) {
	umem_free(od, size);
	return;
	}

	bigobj = od[0].od_object;
	packobj = od[1].od_object;
	chunksize = od[0].od_gen;
	ASSERT3U(chunksize, ==, od[1].od_gen);

	/*
	* Prefetch a random chunk of the big object.
	* Our aim here is to get some async reads in flight
	* for blocks that we may free below; the DMU should
	* handle this race correctly.
	*/
	n = ztest_random(regions) * stride + ztest_random(width);
	s = 1 + ztest_random(2 * width - 1);
	dmu_prefetch(os, bigobj, 0, n * chunksize, s * chunksize,
	ZIO_PRIORITY_SYNC_READ);

	/*
	* Pick a random index and compute the offsets into packobj and bigobj.
	*/
	n = ztest_random(regions) * stride + ztest_random(width);
	s = 1 + ztest_random(width - 1);

	packoff = n * sizeof (bufwad_t);
	packsize = s * sizeof (bufwad_t);

	bigoff = n * chunksize;
	bigsize = s * chunksize;

	packbuf = umem_alloc(packsize, UMEM_NOFAIL);
	bigbuf = umem_alloc(bigsize, UMEM_NOFAIL);

	/*
	* free_percent of the time, free a range of bigobj rather than
	* overwriting it.
	*/
	freeit = (ztest_random(100) < free_percent);

	/*
	* Read the current contents of our objects.
	*/
	error = dmu_read(os, packobj, packoff, packsize, packbuf,
	DMU_READ_PREFETCH);
	ASSERT0(error);
	error = dmu_read(os, bigobj, bigoff, bigsize, bigbuf,
	DMU_READ_PREFETCH);
	ASSERT0(error);

	/*
	* Get a tx for the mods to both packobj and bigobj.
	*/
	tx = dmu_tx_create(os);

	dmu_tx_hold_write(tx, packobj, packoff, packsize);

	if (freeit)
	dmu_tx_hold_free(tx, bigobj, bigoff, bigsize);
	else
	dmu_tx_hold_write(tx, bigobj, bigoff, bigsize);

	/* This accounts for setting the checksum/compression. */
	dmu_tx_hold_bonus(tx, bigobj);

	txg = ztest_tx_assign(tx, TXG_MIGHTWAIT, FTAG);
	if (txg == 0) {
	umem_free(packbuf, packsize);
	umem_free(bigbuf, bigsize);
	umem_free(od, size);
	return;
	}

	enum zio_checksum cksum;
	do {
	cksum = (enum zio_checksum)
	ztest_random_dsl_prop(ZFS_PROP_CHECKSUM);
	} while (cksum >= ZIO_CHECKSUM_LEGACY_FUNCTIONS);
	dmu_object_set_checksum(os, bigobj, cksum, tx);

	enum zio_compress comp;
	do {
	comp = (enum zio_compress)
	ztest_random_dsl_prop(ZFS_PROP_COMPRESSION);
	} while (comp >= ZIO_COMPRESS_LEGACY_FUNCTIONS);
	dmu_object_set_compress(os, bigobj, comp, tx);

	/*
	* For each index from n to n + s, verify that the existing bufwad
	* in packobj matches the bufwads at the head and tail of the
	* corresponding chunk in bigobj. Then update all three bufwads
	* with the new values we want to write out.
	*/
	for (i = 0; i < s; i++) {
	/* LINTED */
	pack = (bufwad_t )((char )packbuf + i * sizeof (bufwad_t));
	/* LINTED */
	bigH = (bufwad_t )((char )bigbuf + i * chunksize);
	/* LINTED */
	bigT = (bufwad_t )((char )bigH + chunksize) - 1;

	ASSERT3U((uintptr_t)bigH - (uintptr_t)bigbuf, <, bigsize);
	ASSERT3U((uintptr_t)bigT - (uintptr_t)bigbuf, <, bigsize);

	if (pack->bw_txg > txg)
	fatal(0, "future leak: got %llx, open txg is %llx",
	pack->bw_txg, txg);

	if (pack->bw_data != 0 && pack->bw_index != n + i)
	fatal(0, "wrong index: got %llx, wanted %llx+%llx",
	pack->bw_index, n, i);

	if (bcmp(pack, bigH, sizeof (bufwad_t)) != 0)
	fatal(0, "pack/bigH mismatch in %p/%p", pack, bigH);

	if (bcmp(pack, bigT, sizeof (bufwad_t)) != 0)
	fatal(0, "pack/bigT mismatch in %p/%p", pack, bigT);

	if (freeit) {
	bzero(pack, sizeof (bufwad_t));
	} else {
	pack->bw_index = n + i;
	pack->bw_txg = txg;
	pack->bw_data = 1 + ztest_random(-2ULL);
	}
	bigH = pack;
	bigT = pack;
	}

	/*
	* We've verified all the old bufwads, and made new ones.
	* Now write them out.
	*/
	dmu_write(os, packobj, packoff, packsize, packbuf, tx);

	if (freeit) {
	if (ztest_opts.zo_verbose >= 7) {
	(void) printf("freeing offset %llx size %llx"
	" txg %llx\n",
	(u_longlong_t)bigoff,
	(u_longlong_t)bigsize,
	(u_longlong_t)txg);
	}
	VERIFY0(dmu_free_range(os, bigobj, bigoff, bigsize, tx));
	} else {
	if (ztest_opts.zo_verbose >= 7) {
	(void) printf("writing offset %llx size %llx"
	" txg %llx\n",
	(u_longlong_t)bigoff,
	(u_longlong_t)bigsize,
	(u_longlong_t)txg);
	}
	dmu_write(os, bigobj, bigoff, bigsize, bigbuf, tx);
	}

	dmu_tx_commit(tx);

	/*
	* Sanity check the stuff we just wrote.
	*/
	{
	void *packcheck = umem_alloc(packsize, UMEM_NOFAIL);
	void *bigcheck = umem_alloc(bigsize, UMEM_NOFAIL);

	VERIFY0(dmu_read(os, packobj, packoff,
	packsize, packcheck, DMU_READ_PREFETCH));
	VERIFY0(dmu_read(os, bigobj, bigoff,
	bigsize, bigcheck, DMU_READ_PREFETCH));

	ASSERT0(bcmp(packbuf, packcheck, packsize));
	ASSERT0(bcmp(bigbuf, bigcheck, bigsize));

	umem_free(packcheck, packsize);
	umem_free(bigcheck, bigsize);
	}

	umem_free(packbuf, packsize);
	umem_free(bigbuf, bigsize);
	umem_free(od, size);
	}

	static void
	compare_and_update_pbbufs(uint64_t s, bufwad_t packbuf, bufwad_t bigbuf,
	uint64_t bigsize, uint64_t n, uint64_t chunksize, uint64_t txg)
	{
	uint64_t i;
	bufwad_t *pack;
	bufwad_t *bigH;
	bufwad_t *bigT;

	/*
	* For each index from n to n + s, verify that the existing bufwad
	* in packobj matches the bufwads at the head and tail of the
	* corresponding chunk in bigobj. Then update all three bufwads
	* with the new values we want to write out.
	*/
	for (i = 0; i < s; i++) {
	/* LINTED */
	pack = (bufwad_t )((char )packbuf + i * sizeof (bufwad_t));
	/* LINTED */
	bigH = (bufwad_t )((char )bigbuf + i * chunksize);
	/* LINTED */
	bigT = (bufwad_t )((char )bigH + chunksize) - 1;

	ASSERT3U((uintptr_t)bigH - (uintptr_t)bigbuf, <, bigsize);
	ASSERT3U((uintptr_t)bigT - (uintptr_t)bigbuf, <, bigsize);

	if (pack->bw_txg > txg)
	fatal(0, "future leak: got %llx, open txg is %llx",
	pack->bw_txg, txg);

	if (pack->bw_data != 0 && pack->bw_index != n + i)
	fatal(0, "wrong index: got %llx, wanted %llx+%llx",
	pack->bw_index, n, i);

	if (bcmp(pack, bigH, sizeof (bufwad_t)) != 0)
	fatal(0, "pack/bigH mismatch in %p/%p", pack, bigH);

	if (bcmp(pack, bigT, sizeof (bufwad_t)) != 0)
	fatal(0, "pack/bigT mismatch in %p/%p", pack, bigT);

	pack->bw_index = n + i;
	pack->bw_txg = txg;
	pack->bw_data = 1 + ztest_random(-2ULL);

	bigH = pack;
	bigT = pack;
	}
	}

	#undef OD_ARRAY_SIZE
	#define OD_ARRAY_SIZE 2

	void
	ztest_dmu_read_write_zcopy(ztest_ds_t *zd, uint64_t id)
	{
	objset_t *os = zd->zd_os;
	ztest_od_t *od;
	dmu_tx_t *tx;
	uint64_t i;
	int error;
	int size;
	uint64_t n, s, txg;
	bufwad_t packbuf, bigbuf;
	uint64_t packobj, packoff, packsize, bigobj, bigoff, bigsize;
	uint64_t blocksize = ztest_random_blocksize();
	uint64_t chunksize = blocksize;
	uint64_t regions = 997;
	uint64_t stride = 123456789ULL;
	uint64_t width = 9;
	dmu_buf_t *bonus_db;
	arc_buf_t **bigbuf_arcbufs;
	dmu_object_info_t doi;

	size = sizeof (ztest_od_t) * OD_ARRAY_SIZE;
	od = umem_alloc(size, UMEM_NOFAIL);

	/*
	* This test uses two objects, packobj and bigobj, that are always
	* updated together (i.e. in the same tx) so that their contents are
	* in sync and can be compared. Their contents relate to each other
	* in a simple way: packobj is a dense array of 'bufwad' structures,
	* while bigobj is a sparse array of the same bufwads. Specifically,
	* for any index n, there are three bufwads that should be identical:
	*
	* packobj, at offset n * sizeof (bufwad_t)
	* bigobj, at the head of the nth chunk
	* bigobj, at the tail of the nth chunk
	*
	* The chunk size is set equal to bigobj block size so that
	* dmu_assign_arcbuf_by_dbuf() can be tested for object updates.
	*/

	/*
	* Read the directory info. If it's the first time, set things up.
	*/
	ztest_od_init(od, id, FTAG, 0, DMU_OT_UINT64_OTHER, blocksize, 0, 0);
	ztest_od_init(od + 1, id, FTAG, 1, DMU_OT_UINT64_OTHER, 0, 0,
	chunksize);


	if (ztest_object_init(zd, od, size, B_FALSE) != 0) {
	umem_free(od, size);
	return;
	}

	bigobj = od[0].od_object;
	packobj = od[1].od_object;
	blocksize = od[0].od_blocksize;
	chunksize = blocksize;
	ASSERT3U(chunksize, ==, od[1].od_gen);

	VERIFY0(dmu_object_info(os, bigobj, &doi));
	VERIFY(ISP2(doi.doi_data_block_size));
	VERIFY3U(chunksize, ==, doi.doi_data_block_size);
	VERIFY3U(chunksize, >=, 2 * sizeof (bufwad_t));

	/*
	* Pick a random index and compute the offsets into packobj and bigobj.
	*/
	n = ztest_random(regions) * stride + ztest_random(width);
	s = 1 + ztest_random(width - 1);

	packoff = n * sizeof (bufwad_t);
	packsize = s * sizeof (bufwad_t);

	bigoff = n * chunksize;
	bigsize = s * chunksize;

	packbuf = umem_zalloc(packsize, UMEM_NOFAIL);
	bigbuf = umem_zalloc(bigsize, UMEM_NOFAIL);

	VERIFY0(dmu_bonus_hold(os, bigobj, FTAG, &bonus_db));

	bigbuf_arcbufs = umem_zalloc(2 * s * sizeof (arc_buf_t *), UMEM_NOFAIL);

	/*
	* Iteration 0 test zcopy for DB_UNCACHED dbufs.
	* Iteration 1 test zcopy to already referenced dbufs.
	* Iteration 2 test zcopy to dirty dbuf in the same txg.
	* Iteration 3 test zcopy to dbuf dirty in previous txg.
	* Iteration 4 test zcopy when dbuf is no longer dirty.
	* Iteration 5 test zcopy when it can't be done.
	* Iteration 6 one more zcopy write.
	*/
	for (i = 0; i < 7; i++) {
	uint64_t j;
	uint64_t off;

	/*
	* In iteration 5 (i == 5) use arcbufs
	* that don't match bigobj blksz to test
	* dmu_assign_arcbuf_by_dbuf() when it can't directly
	* assign an arcbuf to a dbuf.
	*/
	for (j = 0; j < s; j++) {
	if (i != 5 \|\| chunksize < (SPA_MINBLOCKSIZE * 2)) {
	bigbuf_arcbufs[j] =
	dmu_request_arcbuf(bonus_db, chunksize);
	} else {
	bigbuf_arcbufs[2 * j] =
	dmu_request_arcbuf(bonus_db, chunksize / 2);
	bigbuf_arcbufs[2 * j + 1] =
	dmu_request_arcbuf(bonus_db, chunksize / 2);
	}
	}

	/*
	* Get a tx for the mods to both packobj and bigobj.
	*/
	tx = dmu_tx_create(os);

	dmu_tx_hold_write(tx, packobj, packoff, packsize);
	dmu_tx_hold_write(tx, bigobj, bigoff, bigsize);

	txg = ztest_tx_assign(tx, TXG_MIGHTWAIT, FTAG);
	if (txg == 0) {
	umem_free(packbuf, packsize);
	umem_free(bigbuf, bigsize);
	for (j = 0; j < s; j++) {
	if (i != 5 \|\|
	chunksize < (SPA_MINBLOCKSIZE * 2)) {
	dmu_return_arcbuf(bigbuf_arcbufs[j]);
	} else {
	dmu_return_arcbuf(
	bigbuf_arcbufs[2 * j]);
	dmu_return_arcbuf(
	bigbuf_arcbufs[2 * j + 1]);
	}
	}
	umem_free(bigbuf_arcbufs, 2 * s * sizeof (arc_buf_t *));
	umem_free(od, size);
	dmu_buf_rele(bonus_db, FTAG);
	return;
	}

	/*
	* 50% of the time don't read objects in the 1st iteration to
	* test dmu_assign_arcbuf_by_dbuf() for the case when there are
	* no existing dbufs for the specified offsets.
	*/
	if (i != 0 \|\| ztest_random(2) != 0) {
	error = dmu_read(os, packobj, packoff,
	packsize, packbuf, DMU_READ_PREFETCH);
	ASSERT0(error);
	error = dmu_read(os, bigobj, bigoff, bigsize,
	bigbuf, DMU_READ_PREFETCH);
	ASSERT0(error);
	}
	compare_and_update_pbbufs(s, packbuf, bigbuf, bigsize,
	n, chunksize, txg);

	/*
	* We've verified all the old bufwads, and made new ones.
	* Now write them out.
	*/
	dmu_write(os, packobj, packoff, packsize, packbuf, tx);
	if (ztest_opts.zo_verbose >= 7) {
	(void) printf("writing offset %llx size %llx"
	" txg %llx\n",
	(u_longlong_t)bigoff,
	(u_longlong_t)bigsize,
	(u_longlong_t)txg);
	}
	for (off = bigoff, j = 0; j < s; j++, off += chunksize) {
	dmu_buf_t *dbt;
	if (i != 5 \|\| chunksize < (SPA_MINBLOCKSIZE * 2)) {
	bcopy((caddr_t)bigbuf + (off - bigoff),
	bigbuf_arcbufs[j]->b_data, chunksize);
	} else {
	bcopy((caddr_t)bigbuf + (off - bigoff),
	bigbuf_arcbufs[2 * j]->b_data,
	chunksize / 2);
	bcopy((caddr_t)bigbuf + (off - bigoff) +
	chunksize / 2,
	bigbuf_arcbufs[2 * j + 1]->b_data,
	chunksize / 2);
	}

	if (i == 1) {
	VERIFY(dmu_buf_hold(os, bigobj, off,
	FTAG, &dbt, DMU_READ_NO_PREFETCH) == 0);
	}
	if (i != 5 \|\| chunksize < (SPA_MINBLOCKSIZE * 2)) {
	VERIFY0(dmu_assign_arcbuf_by_dbuf(bonus_db,
	off, bigbuf_arcbufs[j], tx));
	} else {
	VERIFY0(dmu_assign_arcbuf_by_dbuf(bonus_db,
	off, bigbuf_arcbufs[2 * j], tx));
	VERIFY0(dmu_assign_arcbuf_by_dbuf(bonus_db,
	off + chunksize / 2,
	bigbuf_arcbufs[2 * j + 1], tx));
	}
	if (i == 1) {
	dmu_buf_rele(dbt, FTAG);
	}
	}
	dmu_tx_commit(tx);

	/*
	* Sanity check the stuff we just wrote.
	*/
	{
	void *packcheck = umem_alloc(packsize, UMEM_NOFAIL);
	void *bigcheck = umem_alloc(bigsize, UMEM_NOFAIL);

	VERIFY0(dmu_read(os, packobj, packoff,
	packsize, packcheck, DMU_READ_PREFETCH));
	VERIFY0(dmu_read(os, bigobj, bigoff,
	bigsize, bigcheck, DMU_READ_PREFETCH));

	ASSERT0(bcmp(packbuf, packcheck, packsize));
	ASSERT0(bcmp(bigbuf, bigcheck, bigsize));

	umem_free(packcheck, packsize);
	umem_free(bigcheck, bigsize);
	}
	if (i == 2) {
	txg_wait_open(dmu_objset_pool(os), 0, B_TRUE);
	} else if (i == 3) {
	txg_wait_synced(dmu_objset_pool(os), 0);
	}
	}

	dmu_buf_rele(bonus_db, FTAG);
	umem_free(packbuf, packsize);
	umem_free(bigbuf, bigsize);
	umem_free(bigbuf_arcbufs, 2 * s * sizeof (arc_buf_t *));
	umem_free(od, size);
	}

	/* ARGSUSED */
	void
	ztest_dmu_write_parallel(ztest_ds_t *zd, uint64_t id)
	{
	ztest_od_t *od;

	od = umem_alloc(sizeof (ztest_od_t), UMEM_NOFAIL);
	uint64_t offset = (1ULL << (ztest_random(20) + 43)) +
	(ztest_random(ZTEST_RANGE_LOCKS) << SPA_MAXBLOCKSHIFT);

	/*
	* Have multiple threads write to large offsets in an object
	* to verify that parallel writes to an object -- even to the
	* same blocks within the object -- doesn't cause any trouble.
	*/
	ztest_od_init(od, ID_PARALLEL, FTAG, 0, DMU_OT_UINT64_OTHER, 0, 0, 0);

	if (ztest_object_init(zd, od, sizeof (ztest_od_t), B_FALSE) != 0)
	return;

	while (ztest_random(10) != 0)
	ztest_io(zd, od->od_object, offset);

	umem_free(od, sizeof (ztest_od_t));
	}

	void
	ztest_dmu_prealloc(ztest_ds_t *zd, uint64_t id)
	{
	ztest_od_t *od;
	uint64_t offset = (1ULL << (ztest_random(4) + SPA_MAXBLOCKSHIFT)) +
	(ztest_random(ZTEST_RANGE_LOCKS) << SPA_MAXBLOCKSHIFT);
	uint64_t count = ztest_random(20) + 1;
	uint64_t blocksize = ztest_random_blocksize();
	void *data;

	od = umem_alloc(sizeof (ztest_od_t), UMEM_NOFAIL);

	ztest_od_init(od, id, FTAG, 0, DMU_OT_UINT64_OTHER, blocksize, 0, 0);

	if (ztest_object_init(zd, od, sizeof (ztest_od_t),
	!ztest_random(2)) != 0) {
	umem_free(od, sizeof (ztest_od_t));
	return;
	}

	if (ztest_truncate(zd, od->od_object, offset, count * blocksize) != 0) {
	umem_free(od, sizeof (ztest_od_t));
	return;
	}

	ztest_prealloc(zd, od->od_object, offset, count * blocksize);

	data = umem_zalloc(blocksize, UMEM_NOFAIL);

	while (ztest_random(count) != 0) {
	uint64_t randoff = offset + (ztest_random(count) * blocksize);
	if (ztest_write(zd, od->od_object, randoff, blocksize,
	data) != 0)
	break;
	while (ztest_random(4) != 0)
	ztest_io(zd, od->od_object, randoff);
	}

	umem_free(data, blocksize);
	umem_free(od, sizeof (ztest_od_t));
	}

	/*
	* Verify that zap_{create,destroy,add,remove,update} work as expected.
	*/
	#define ZTEST_ZAP_MIN_INTS 1
	#define ZTEST_ZAP_MAX_INTS 4
	#define ZTEST_ZAP_MAX_PROPS 1000

	void
	ztest_zap(ztest_ds_t *zd, uint64_t id)
	{
	objset_t *os = zd->zd_os;
	ztest_od_t *od;
	uint64_t object;
	uint64_t txg, last_txg;
	uint64_t value[ZTEST_ZAP_MAX_INTS];
	uint64_t zl_ints, zl_intsize, prop;
	int i, ints;
	dmu_tx_t *tx;
	char propname[100], txgname[100];
	int error;
	char *hc[2] = { "s.acl.h", ".s.open.h.hyLZlg" };

	od = umem_alloc(sizeof (ztest_od_t), UMEM_NOFAIL);
	ztest_od_init(od, id, FTAG, 0, DMU_OT_ZAP_OTHER, 0, 0, 0);

	if (ztest_object_init(zd, od, sizeof (ztest_od_t),
	!ztest_random(2)) != 0)
	goto out;

	object = od->od_object;

	/*
	* Generate a known hash collision, and verify that
	* we can lookup and remove both entries.
	*/
	tx = dmu_tx_create(os);
	dmu_tx_hold_zap(tx, object, B_TRUE, NULL);
	txg = ztest_tx_assign(tx, TXG_MIGHTWAIT, FTAG);
	if (txg == 0)
	goto out;
	for (i = 0; i < 2; i++) {
	value[i] = i;
	VERIFY0(zap_add(os, object, hc[i], sizeof (uint64_t),
	1, &value[i], tx));
	}
	for (i = 0; i < 2; i++) {
	VERIFY3U(EEXIST, ==, zap_add(os, object, hc[i],
	sizeof (uint64_t), 1, &value[i], tx));
	VERIFY0(
	zap_length(os, object, hc[i], &zl_intsize, &zl_ints));
	ASSERT3U(zl_intsize, ==, sizeof (uint64_t));
	ASSERT3U(zl_ints, ==, 1);
	}
	for (i = 0; i < 2; i++) {
	VERIFY0(zap_remove(os, object, hc[i], tx));
	}
	dmu_tx_commit(tx);

	/*
	* Generate a bunch of random entries.
	*/
	ints = MAX(ZTEST_ZAP_MIN_INTS, object % ZTEST_ZAP_MAX_INTS);

	prop = ztest_random(ZTEST_ZAP_MAX_PROPS);
	(void) sprintf(propname, "prop_%llu", (u_longlong_t)prop);
	(void) sprintf(txgname, "txg_%llu", (u_longlong_t)prop);
	bzero(value, sizeof (value));
	last_txg = 0;

	/*
	* If these zap entries already exist, validate their contents.
	*/
	error = zap_length(os, object, txgname, &zl_intsize, &zl_ints);
	if (error == 0) {
	ASSERT3U(zl_intsize, ==, sizeof (uint64_t));
	ASSERT3U(zl_ints, ==, 1);

	VERIFY0(zap_lookup(os, object, txgname, zl_intsize,
	zl_ints, &last_txg));

	VERIFY0(zap_length(os, object, propname, &zl_intsize,
	&zl_ints));

	ASSERT3U(zl_intsize, ==, sizeof (uint64_t));
	ASSERT3U(zl_ints, ==, ints);

	VERIFY0(zap_lookup(os, object, propname, zl_intsize,
	zl_ints, value));

	for (i = 0; i < ints; i++) {
	ASSERT3U(value[i], ==, last_txg + object + i);
	}
	} else {
	ASSERT3U(error, ==, ENOENT);
	}

	/*
	* Atomically update two entries in our zap object.
	* The first is named txg_%llu, and contains the txg
	* in which the property was last updated. The second
	* is named prop_%llu, and the nth element of its value
	* should be txg + object + n.
	*/
	tx = dmu_tx_create(os);
	dmu_tx_hold_zap(tx, object, B_TRUE, NULL);
	txg = ztest_tx_assign(tx, TXG_MIGHTWAIT, FTAG);
	if (txg == 0)
	goto out;

	if (last_txg > txg)
	fatal(0, "zap future leak: old %llu new %llu", last_txg, txg);

	for (i = 0; i < ints; i++)
	value[i] = txg + object + i;

	VERIFY0(zap_update(os, object, txgname, sizeof (uint64_t),
	1, &txg, tx));
	VERIFY0(zap_update(os, object, propname, sizeof (uint64_t),
	ints, value, tx));

	dmu_tx_commit(tx);

	/*
	* Remove a random pair of entries.
	*/
	prop = ztest_random(ZTEST_ZAP_MAX_PROPS);
	(void) sprintf(propname, "prop_%llu", (u_longlong_t)prop);
	(void) sprintf(txgname, "txg_%llu", (u_longlong_t)prop);

	error = zap_length(os, object, txgname, &zl_intsize, &zl_ints);

	if (error == ENOENT)
	goto out;

	ASSERT0(error);

	tx = dmu_tx_create(os);
	dmu_tx_hold_zap(tx, object, B_TRUE, NULL);
	txg = ztest_tx_assign(tx, TXG_MIGHTWAIT, FTAG);
	if (txg == 0)
	goto out;
	VERIFY0(zap_remove(os, object, txgname, tx));
	VERIFY0(zap_remove(os, object, propname, tx));
	dmu_tx_commit(tx);
	out:
	umem_free(od, sizeof (ztest_od_t));
	}

	/*
	* Test case to test the upgrading of a microzap to fatzap.
	*/
	void
	ztest_fzap(ztest_ds_t *zd, uint64_t id)
	{
	objset_t *os = zd->zd_os;
	ztest_od_t *od;
	uint64_t object, txg;
	int i;

	od = umem_alloc(sizeof (ztest_od_t), UMEM_NOFAIL);
	ztest_od_init(od, id, FTAG, 0, DMU_OT_ZAP_OTHER, 0, 0, 0);

	if (ztest_object_init(zd, od, sizeof (ztest_od_t),
	!ztest_random(2)) != 0)
	goto out;
	object = od->od_object;

	/*
	* Add entries to this ZAP and make sure it spills over
	* and gets upgraded to a fatzap. Also, since we are adding
	* 2050 entries we should see ptrtbl growth and leaf-block split.
	*/
	for (i = 0; i < 2050; i++) {
	char name[ZFS_MAX_DATASET_NAME_LEN];
	uint64_t value = i;
	dmu_tx_t *tx;
	int error;

	(void) snprintf(name, sizeof (name), "fzap-%llu-%llu",
	(u_longlong_t)id, (u_longlong_t)value);

	tx = dmu_tx_create(os);
	dmu_tx_hold_zap(tx, object, B_TRUE, name);
	txg = ztest_tx_assign(tx, TXG_MIGHTWAIT, FTAG);
	if (txg == 0)
	goto out;
	error = zap_add(os, object, name, sizeof (uint64_t), 1,
	&value, tx);
	ASSERT(error == 0 \|\| error == EEXIST);
	dmu_tx_commit(tx);
	}
	out:
	umem_free(od, sizeof (ztest_od_t));
	}

	/* ARGSUSED */
	void
	ztest_zap_parallel(ztest_ds_t *zd, uint64_t id)
	{
	objset_t *os = zd->zd_os;
	ztest_od_t *od;
	uint64_t txg, object, count, wsize, wc, zl_wsize, zl_wc;
	dmu_tx_t *tx;
	int i, namelen, error;
	int micro = ztest_random(2);
	char name[20], string_value[20];
	void *data;

	od = umem_alloc(sizeof (ztest_od_t), UMEM_NOFAIL);
	ztest_od_init(od, ID_PARALLEL, FTAG, micro, DMU_OT_ZAP_OTHER, 0, 0, 0);

	if (ztest_object_init(zd, od, sizeof (ztest_od_t), B_FALSE) != 0) {
	umem_free(od, sizeof (ztest_od_t));
	return;
	}

	object = od->od_object;

	/*
	* Generate a random name of the form 'xxx.....' where each
	* x is a random printable character and the dots are dots.
	* There are 94 such characters, and the name length goes from
	* 6 to 20, so there are 94^3 * 15 = 12,458,760 possible names.
	*/
	namelen = ztest_random(sizeof (name) - 5) + 5 + 1;

	for (i = 0; i < 3; i++)
	name[i] = '!' + ztest_random('~' - '!' + 1);
	for (; i < namelen - 1; i++)
	name[i] = '.';
	name[i] = '\0';

	if ((namelen & 1) \|\| micro) {
	wsize = sizeof (txg);
	wc = 1;
	data = &txg;
	} else {
	wsize = 1;
	wc = namelen;
	data = string_value;
	}

	count = -1ULL;
	VERIFY0(zap_count(os, object, &count));
	ASSERT3S(count, !=, -1ULL);

	/*
	* Select an operation: length, lookup, add, update, remove.
	*/
	i = ztest_random(5);

	if (i >= 2) {
	tx = dmu_tx_create(os);
	dmu_tx_hold_zap(tx, object, B_TRUE, NULL);
	txg = ztest_tx_assign(tx, TXG_MIGHTWAIT, FTAG);
	if (txg == 0) {
	umem_free(od, sizeof (ztest_od_t));
	return;
	}
	bcopy(name, string_value, namelen);
	} else {
	tx = NULL;
	txg = 0;
	bzero(string_value, namelen);
	}

	switch (i) {

	case 0:
	error = zap_length(os, object, name, &zl_wsize, &zl_wc);
	if (error == 0) {
	ASSERT3U(wsize, ==, zl_wsize);
	ASSERT3U(wc, ==, zl_wc);
	} else {
	ASSERT3U(error, ==, ENOENT);
	}
	break;

	case 1:
	error = zap_lookup(os, object, name, wsize, wc, data);
	if (error == 0) {
	if (data == string_value &&
	bcmp(name, data, namelen) != 0)
	fatal(0, "name '%s' != val '%s' len %d",
	name, data, namelen);
	} else {
	ASSERT3U(error, ==, ENOENT);
	}
	break;

	case 2:
	error = zap_add(os, object, name, wsize, wc, data, tx);
	ASSERT(error == 0 \|\| error == EEXIST);
	break;

	case 3:
	VERIFY0(zap_update(os, object, name, wsize, wc, data, tx));
	break;

	case 4:
	error = zap_remove(os, object, name, tx);
	ASSERT(error == 0 \|\| error == ENOENT);
	break;
	}

	if (tx != NULL)
	dmu_tx_commit(tx);

	umem_free(od, sizeof (ztest_od_t));
	}

	/*
	* Commit callback data.
	*/
	typedef struct ztest_cb_data {
	list_node_t zcd_node;
	uint64_t zcd_txg;
	int zcd_expected_err;
	boolean_t zcd_added;
	boolean_t zcd_called;
	spa_t *zcd_spa;
	} ztest_cb_data_t;

	/* This is the actual commit callback function */
	static void
	ztest_commit_callback(void *arg, int error)
	{
	ztest_cb_data_t *data = arg;
	uint64_t synced_txg;

	VERIFY3P(data, !=, NULL);
	VERIFY3S(data->zcd_expected_err, ==, error);
	VERIFY(!data->zcd_called);

	synced_txg = spa_last_synced_txg(data->zcd_spa);
	if (data->zcd_txg > synced_txg)
	fatal(0, "commit callback of txg %" PRIu64 " called prematurely"
	", last synced txg = %" PRIu64 "\n", data->zcd_txg,
	synced_txg);

	data->zcd_called = B_TRUE;

	if (error == ECANCELED) {
	ASSERT0(data->zcd_txg);
	ASSERT(!data->zcd_added);

	/*
	* The private callback data should be destroyed here, but
	* since we are going to check the zcd_called field after
	* dmu_tx_abort(), we will destroy it there.
	*/
	return;
	}

	ASSERT(data->zcd_added);
	ASSERT3U(data->zcd_txg, !=, 0);

	(void) mutex_enter(&zcl.zcl_callbacks_lock);

	/* See if this cb was called more quickly */
	if ((synced_txg - data->zcd_txg) < zc_min_txg_delay)
	zc_min_txg_delay = synced_txg - data->zcd_txg;

	/* Remove our callback from the list */
	list_remove(&zcl.zcl_callbacks, data);

	(void) mutex_exit(&zcl.zcl_callbacks_lock);

	umem_free(data, sizeof (ztest_cb_data_t));
	}

	/* Allocate and initialize callback data structure */
	static ztest_cb_data_t *
	ztest_create_cb_data(objset_t *os, uint64_t txg)
	{
	ztest_cb_data_t *cb_data;

	cb_data = umem_zalloc(sizeof (ztest_cb_data_t), UMEM_NOFAIL);

	cb_data->zcd_txg = txg;
	cb_data->zcd_spa = dmu_objset_spa(os);
	list_link_init(&cb_data->zcd_node);

	return (cb_data);
	}

	/*
	* Commit callback test.
	*/
	void
	ztest_dmu_commit_callbacks(ztest_ds_t *zd, uint64_t id)
	{
	objset_t *os = zd->zd_os;
	ztest_od_t *od;
	dmu_tx_t *tx;
	ztest_cb_data_t cb_data[3], tmp_cb;
	uint64_t old_txg, txg;
	int i, error = 0;

	od = umem_alloc(sizeof (ztest_od_t), UMEM_NOFAIL);
	ztest_od_init(od, id, FTAG, 0, DMU_OT_UINT64_OTHER, 0, 0, 0);

	if (ztest_object_init(zd, od, sizeof (ztest_od_t), B_FALSE) != 0) {
	umem_free(od, sizeof (ztest_od_t));
	return;
	}

	tx = dmu_tx_create(os);

	cb_data[0] = ztest_create_cb_data(os, 0);
	dmu_tx_callback_register(tx, ztest_commit_callback, cb_data[0]);

	dmu_tx_hold_write(tx, od->od_object, 0, sizeof (uint64_t));

	/* Every once in a while, abort the transaction on purpose */
	if (ztest_random(100) == 0)
	error = -1;

	if (!error)
	error = dmu_tx_assign(tx, TXG_NOWAIT);

	txg = error ? 0 : dmu_tx_get_txg(tx);

	cb_data[0]->zcd_txg = txg;
	cb_data[1] = ztest_create_cb_data(os, txg);
	dmu_tx_callback_register(tx, ztest_commit_callback, cb_data[1]);

	if (error) {
	/*
	* It's not a strict requirement to call the registered
	* callbacks from inside dmu_tx_abort(), but that's what
	* it's supposed to happen in the current implementation
	* so we will check for that.
	*/
	for (i = 0; i < 2; i++) {
	cb_data[i]->zcd_expected_err = ECANCELED;
	VERIFY(!cb_data[i]->zcd_called);
	}

	dmu_tx_abort(tx);

	for (i = 0; i < 2; i++) {
	VERIFY(cb_data[i]->zcd_called);
	umem_free(cb_data[i], sizeof (ztest_cb_data_t));
	}

	umem_free(od, sizeof (ztest_od_t));
	return;
	}

	cb_data[2] = ztest_create_cb_data(os, txg);
	dmu_tx_callback_register(tx, ztest_commit_callback, cb_data[2]);

	/*
	* Read existing data to make sure there isn't a future leak.
	*/
	VERIFY0(dmu_read(os, od->od_object, 0, sizeof (uint64_t),
	&old_txg, DMU_READ_PREFETCH));

	if (old_txg > txg)
	fatal(0, "future leak: got %" PRIu64 ", open txg is %" PRIu64,
	old_txg, txg);

	dmu_write(os, od->od_object, 0, sizeof (uint64_t), &txg, tx);

	(void) mutex_enter(&zcl.zcl_callbacks_lock);

	/*
	* Since commit callbacks don't have any ordering requirement and since
	* it is theoretically possible for a commit callback to be called
	* after an arbitrary amount of time has elapsed since its txg has been
	* synced, it is difficult to reliably determine whether a commit
	* callback hasn't been called due to high load or due to a flawed
	* implementation.
	*
	* In practice, we will assume that if after a certain number of txgs a
	* commit callback hasn't been called, then most likely there's an
	* implementation bug..
	*/
	tmp_cb = list_head(&zcl.zcl_callbacks);
	if (tmp_cb != NULL &&
	tmp_cb->zcd_txg + ZTEST_COMMIT_CB_THRESH < txg) {
	fatal(0, "Commit callback threshold exceeded, oldest txg: %"
	PRIu64 ", open txg: %" PRIu64 "\n", tmp_cb->zcd_txg, txg);
	}

	/*
	* Let's find the place to insert our callbacks.
	*
	* Even though the list is ordered by txg, it is possible for the
	* insertion point to not be the end because our txg may already be
	* quiescing at this point and other callbacks in the open txg
	* (from other objsets) may have sneaked in.
	*/
	tmp_cb = list_tail(&zcl.zcl_callbacks);
	while (tmp_cb != NULL && tmp_cb->zcd_txg > txg)
	tmp_cb = list_prev(&zcl.zcl_callbacks, tmp_cb);

	/* Add the 3 callbacks to the list */
	for (i = 0; i < 3; i++) {
	if (tmp_cb == NULL)
	list_insert_head(&zcl.zcl_callbacks, cb_data[i]);
	else
	list_insert_after(&zcl.zcl_callbacks, tmp_cb,
	cb_data[i]);

	cb_data[i]->zcd_added = B_TRUE;
	VERIFY(!cb_data[i]->zcd_called);

	tmp_cb = cb_data[i];
	}

	zc_cb_counter += 3;

	(void) mutex_exit(&zcl.zcl_callbacks_lock);

	dmu_tx_commit(tx);

	umem_free(od, sizeof (ztest_od_t));
	}

	/*
	* Visit each object in the dataset. Verify that its properties
	* are consistent what was stored in the block tag when it was created,
	* and that its unused bonus buffer space has not been overwritten.
	*/
	/* ARGSUSED */
	void
	ztest_verify_dnode_bt(ztest_ds_t *zd, uint64_t id)
	{
	objset_t *os = zd->zd_os;
	uint64_t obj;
	int err = 0;

	for (obj = 0; err == 0; err = dmu_object_next(os, &obj, FALSE, 0)) {
	ztest_block_tag_t *bt = NULL;
	dmu_object_info_t doi;
	dmu_buf_t *db;

	ztest_object_lock(zd, obj, RL_READER);
	if (dmu_bonus_hold(os, obj, FTAG, &db) != 0) {
	ztest_object_unlock(zd, obj);
	continue;
	}

	dmu_object_info_from_db(db, &doi);
	if (doi.doi_bonus_size >= sizeof (*bt))
	bt = ztest_bt_bonus(db);

	if (bt && bt->bt_magic == BT_MAGIC) {
	ztest_bt_verify(bt, os, obj, doi.doi_dnodesize,
	bt->bt_offset, bt->bt_gen, bt->bt_txg,
	bt->bt_crtxg);
	ztest_verify_unused_bonus(db, bt, obj, os, bt->bt_gen);
	}

	dmu_buf_rele(db, FTAG);
	ztest_object_unlock(zd, obj);
	}
	}

	/* ARGSUSED */
	void
	ztest_dsl_prop_get_set(ztest_ds_t *zd, uint64_t id)
	{
	zfs_prop_t proplist[] = {
	ZFS_PROP_CHECKSUM,
	ZFS_PROP_COMPRESSION,
	ZFS_PROP_COPIES,
	ZFS_PROP_DEDUP
	};
	int p;

	(void) pthread_rwlock_rdlock(&ztest_name_lock);

	for (p = 0; p < sizeof (proplist) / sizeof (proplist[0]); p++)
	(void) ztest_dsl_prop_set_uint64(zd->zd_name, proplist[p],
	ztest_random_dsl_prop(proplist[p]), (int)ztest_random(2));

	VERIFY0(ztest_dsl_prop_set_uint64(zd->zd_name, ZFS_PROP_RECORDSIZE,
	ztest_random_blocksize(), (int)ztest_random(2)));

	(void) pthread_rwlock_unlock(&ztest_name_lock);
	}

	/* ARGSUSED */
	void
	ztest_spa_prop_get_set(ztest_ds_t *zd, uint64_t id)
	{
	nvlist_t *props = NULL;

	(void) pthread_rwlock_rdlock(&ztest_name_lock);

	(void) ztest_spa_prop_set_uint64(ZPOOL_PROP_AUTOTRIM, ztest_random(2));

	VERIFY0(spa_prop_get(ztest_spa, &props));

	if (ztest_opts.zo_verbose >= 6)
	dump_nvlist(props, 4);

	fnvlist_free(props);

	(void) pthread_rwlock_unlock(&ztest_name_lock);
	}

	static int
	user_release_one(const char snapname, const char holdname)
	{
	nvlist_t snaps, holds;
	int error;

	snaps = fnvlist_alloc();
	holds = fnvlist_alloc();
	fnvlist_add_boolean(holds, holdname);
	fnvlist_add_nvlist(snaps, snapname, holds);
	fnvlist_free(holds);
	error = dsl_dataset_user_release(snaps, NULL);
	fnvlist_free(snaps);
	return (error);
	}

	/*
	* Test snapshot hold/release and deferred destroy.
	*/
	void
	ztest_dmu_snapshot_hold(ztest_ds_t *zd, uint64_t id)
	{
	int error;
	objset_t *os = zd->zd_os;
	objset_t *origin;
	char snapname[100];
	char fullname[100];
	char clonename[100];
	char tag[100];
	char osname[ZFS_MAX_DATASET_NAME_LEN];
	nvlist_t *holds;

	(void) pthread_rwlock_rdlock(&ztest_name_lock);

	dmu_objset_name(os, osname);

	(void) snprintf(snapname, sizeof (snapname), "sh1_%llu",
	(u_longlong_t)id);
	(void) snprintf(fullname, sizeof (fullname), "%s@%s", osname, snapname);
	(void) snprintf(clonename, sizeof (clonename),
	"%s/ch1_%llu", osname, (u_longlong_t)id);
	(void) snprintf(tag, sizeof (tag), "tag_%llu", (u_longlong_t)id);

	/*
	* Clean up from any previous run.
	*/
	error = dsl_destroy_head(clonename);
	if (error != ENOENT)
	ASSERT0(error);
	error = user_release_one(fullname, tag);
	if (error != ESRCH && error != ENOENT)
	ASSERT0(error);
	error = dsl_destroy_snapshot(fullname, B_FALSE);
	if (error != ENOENT)
	ASSERT0(error);

	/*
	* Create snapshot, clone it, mark snap for deferred destroy,
	* destroy clone, verify snap was also destroyed.
	*/
	error = dmu_objset_snapshot_one(osname, snapname);
	if (error) {
	if (error == ENOSPC) {
	ztest_record_enospc("dmu_objset_snapshot");
	goto out;
	}
	fatal(0, "dmu_objset_snapshot(%s) = %d", fullname, error);
	}

	error = dmu_objset_clone(clonename, fullname);
	if (error) {
	if (error == ENOSPC) {
	ztest_record_enospc("dmu_objset_clone");
	goto out;
	}
	fatal(0, "dmu_objset_clone(%s) = %d", clonename, error);
	}

	error = dsl_destroy_snapshot(fullname, B_TRUE);
	if (error) {
	fatal(0, "dsl_destroy_snapshot(%s, B_TRUE) = %d",
	fullname, error);
	}

	error = dsl_destroy_head(clonename);
	if (error)
	fatal(0, "dsl_destroy_head(%s) = %d", clonename, error);

	error = dmu_objset_hold(fullname, FTAG, &origin);
	if (error != ENOENT)
	fatal(0, "dmu_objset_hold(%s) = %d", fullname, error);

	/*
	* Create snapshot, add temporary hold, verify that we can't
	* destroy a held snapshot, mark for deferred destroy,
	* release hold, verify snapshot was destroyed.
	*/
	error = dmu_objset_snapshot_one(osname, snapname);
	if (error) {
	if (error == ENOSPC) {
	ztest_record_enospc("dmu_objset_snapshot");
	goto out;
	}
	fatal(0, "dmu_objset_snapshot(%s) = %d", fullname, error);
	}

	holds = fnvlist_alloc();
	fnvlist_add_string(holds, fullname, tag);
	error = dsl_dataset_user_hold(holds, 0, NULL);
	fnvlist_free(holds);

	if (error == ENOSPC) {
	ztest_record_enospc("dsl_dataset_user_hold");
	goto out;
	} else if (error) {
	fatal(0, "dsl_dataset_user_hold(%s, %s) = %u",
	fullname, tag, error);
	}

	error = dsl_destroy_snapshot(fullname, B_FALSE);
	if (error != EBUSY) {
	fatal(0, "dsl_destroy_snapshot(%s, B_FALSE) = %d",
	fullname, error);
	}

	error = dsl_destroy_snapshot(fullname, B_TRUE);
	if (error) {
	fatal(0, "dsl_destroy_snapshot(%s, B_TRUE) = %d",
	fullname, error);
	}

	error = user_release_one(fullname, tag);
	if (error)
	fatal(0, "user_release_one(%s, %s) = %d", fullname, tag, error);

	VERIFY3U(dmu_objset_hold(fullname, FTAG, &origin), ==, ENOENT);

	out:
	(void) pthread_rwlock_unlock(&ztest_name_lock);
	}

	/*
	* Inject random faults into the on-disk data.
	*/
	/* ARGSUSED */
	void
	ztest_fault_inject(ztest_ds_t *zd, uint64_t id)
	{
	ztest_shared_t *zs = ztest_shared;
	spa_t *spa = ztest_spa;
	int fd;
	uint64_t offset;
	uint64_t leaves;
	uint64_t bad = 0x1990c0ffeedecadeull;
	uint64_t top, leaf;
	char *path0;
	char *pathrand;
	size_t fsize;
	int bshift = SPA_MAXBLOCKSHIFT + 2;
	int iters = 1000;
	int maxfaults;
	int mirror_save;
	vdev_t *vd0 = NULL;
	uint64_t guid0 = 0;
	boolean_t islog = B_FALSE;

	path0 = umem_alloc(MAXPATHLEN, UMEM_NOFAIL);
	pathrand = umem_alloc(MAXPATHLEN, UMEM_NOFAIL);

	mutex_enter(&ztest_vdev_lock);

	/*
	* Device removal is in progress, fault injection must be disabled
	* until it completes and the pool is scrubbed. The fault injection
	* strategy for damaging blocks does not take in to account evacuated
	* blocks which may have already been damaged.
	*/
	if (ztest_device_removal_active) {
	mutex_exit(&ztest_vdev_lock);
	goto out;
	}

	maxfaults = MAXFAULTS(zs);
	leaves = MAX(zs->zs_mirrors, 1) * ztest_opts.zo_raid_children;
	mirror_save = zs->zs_mirrors;
	mutex_exit(&ztest_vdev_lock);

	ASSERT3U(leaves, >=, 1);

	/*
	* While ztest is running the number of leaves will not change. This
	* is critical for the fault injection logic as it determines where
	* errors can be safely injected such that they are always repairable.
	*
	* When restarting ztest a different number of leaves may be requested
	* which will shift the regions to be damaged. This is fine as long
	* as the pool has been scrubbed prior to using the new mapping.
	* Failure to do can result in non-repairable damage being injected.
	*/
	if (ztest_pool_scrubbed == B_FALSE)
	goto out;

	/*
	* Grab the name lock as reader. There are some operations
	* which don't like to have their vdevs changed while
	* they are in progress (i.e. spa_change_guid). Those
	* operations will have grabbed the name lock as writer.
	*/
	(void) pthread_rwlock_rdlock(&ztest_name_lock);

	/*
	* We need SCL_STATE here because we're going to look at vd0->vdev_tsd.
	*/
	spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);

	if (ztest_random(2) == 0) {
	/*
	* Inject errors on a normal data device or slog device.
	*/
	top = ztest_random_vdev_top(spa, B_TRUE);
	leaf = ztest_random(leaves) + zs->zs_splits;

	/*
	* Generate paths to the first leaf in this top-level vdev,
	* and to the random leaf we selected. We'll induce transient
	* write failures and random online/offline activity on leaf 0,
	* and we'll write random garbage to the randomly chosen leaf.
	*/
	(void) snprintf(path0, MAXPATHLEN, ztest_dev_template,
	ztest_opts.zo_dir, ztest_opts.zo_pool,
	top * leaves + zs->zs_splits);
	(void) snprintf(pathrand, MAXPATHLEN, ztest_dev_template,
	ztest_opts.zo_dir, ztest_opts.zo_pool,
	top * leaves + leaf);

	vd0 = vdev_lookup_by_path(spa->spa_root_vdev, path0);
	if (vd0 != NULL && vd0->vdev_top->vdev_islog)
	islog = B_TRUE;

	/*
	* If the top-level vdev needs to be resilvered
	* then we only allow faults on the device that is
	* resilvering.
	*/
	if (vd0 != NULL && maxfaults != 1 &&
	(!vdev_resilver_needed(vd0->vdev_top, NULL, NULL) \|\|
	vd0->vdev_resilver_txg != 0)) {
	/*
	* Make vd0 explicitly claim to be unreadable,
	- * or unwriteable, or reach behind its back
	+ * or unwritable, or reach behind its back
	* and close the underlying fd. We can do this if
	* maxfaults == 0 because we'll fail and reexecute,
	* and we can do it if maxfaults >= 2 because we'll
	* have enough redundancy. If maxfaults == 1, the
	* combination of this with injection of random data
	* corruption below exceeds the pool's fault tolerance.
	*/
	vdev_file_t *vf = vd0->vdev_tsd;

	zfs_dbgmsg("injecting fault to vdev %llu; maxfaults=%d",
	(long long)vd0->vdev_id, (int)maxfaults);

	if (vf != NULL && ztest_random(3) == 0) {
	(void) close(vf->vf_file->f_fd);
	vf->vf_file->f_fd = -1;
	} else if (ztest_random(2) == 0) {
	vd0->vdev_cant_read = B_TRUE;
	} else {
	vd0->vdev_cant_write = B_TRUE;
	}
	guid0 = vd0->vdev_guid;
	}
	} else {
	/*
	* Inject errors on an l2cache device.
	*/
	spa_aux_vdev_t *sav = &spa->spa_l2cache;

	if (sav->sav_count == 0) {
	spa_config_exit(spa, SCL_STATE, FTAG);
	(void) pthread_rwlock_unlock(&ztest_name_lock);
	goto out;
	}
	vd0 = sav->sav_vdevs[ztest_random(sav->sav_count)];
	guid0 = vd0->vdev_guid;
	(void) strcpy(path0, vd0->vdev_path);
	(void) strcpy(pathrand, vd0->vdev_path);

	leaf = 0;
	leaves = 1;
	maxfaults = INT_MAX; /* no limit on cache devices */
	}

	spa_config_exit(spa, SCL_STATE, FTAG);
	(void) pthread_rwlock_unlock(&ztest_name_lock);

	/*
	* If we can tolerate two or more faults, or we're dealing
	* with a slog, randomly online/offline vd0.
	*/
	if ((maxfaults >= 2 \|\| islog) && guid0 != 0) {
	if (ztest_random(10) < 6) {
	int flags = (ztest_random(2) == 0 ?
	ZFS_OFFLINE_TEMPORARY : 0);

	/*
	* We have to grab the zs_name_lock as writer to
	* prevent a race between offlining a slog and
	* destroying a dataset. Offlining the slog will
	* grab a reference on the dataset which may cause
	* dsl_destroy_head() to fail with EBUSY thus
	* leaving the dataset in an inconsistent state.
	*/
	if (islog)
	(void) pthread_rwlock_wrlock(&ztest_name_lock);

	VERIFY3U(vdev_offline(spa, guid0, flags), !=, EBUSY);

	if (islog)
	(void) pthread_rwlock_unlock(&ztest_name_lock);
	} else {
	/*
	* Ideally we would like to be able to randomly
	* call vdev_[on\|off]line without holding locks
	* to force unpredictable failures but the side
	* effects of vdev_[on\|off]line prevent us from
	* doing so. We grab the ztest_vdev_lock here to
	* prevent a race between injection testing and
	* aux_vdev removal.
	*/
	mutex_enter(&ztest_vdev_lock);
	(void) vdev_online(spa, guid0, 0, NULL);
	mutex_exit(&ztest_vdev_lock);
	}
	}

	if (maxfaults == 0)
	goto out;

	/*
	* We have at least single-fault tolerance, so inject data corruption.
	*/
	fd = open(pathrand, O_RDWR);

	if (fd == -1) /* we hit a gap in the device namespace */
	goto out;

	fsize = lseek(fd, 0, SEEK_END);

	while (--iters != 0) {
	/*
	* The offset must be chosen carefully to ensure that
	* we do not inject a given logical block with errors
	* on two different leaf devices, because ZFS can not
	* tolerate that (if maxfaults==1).
	*
	* To achieve this we divide each leaf device into
	* chunks of size (# leaves * SPA_MAXBLOCKSIZE * 4).
	* Each chunk is further divided into error-injection
	* ranges (can accept errors) and clear ranges (we do
	* not inject errors in those). Each error-injection
	* range can accept errors only for a single leaf vdev.
	* Error-injection ranges are separated by clear ranges.
	*
	* For example, with 3 leaves, each chunk looks like:
	* 0 to 32M: injection range for leaf 0
	* 32M to 64M: clear range - no injection allowed
	* 64M to 96M: injection range for leaf 1
	* 96M to 128M: clear range - no injection allowed
	* 128M to 160M: injection range for leaf 2
	* 160M to 192M: clear range - no injection allowed
	*
	* Each clear range must be large enough such that a
	* single block cannot straddle it. This way a block
	* can't be a target in two different injection ranges
	* (on different leaf vdevs).
	*/
	offset = ztest_random(fsize / (leaves << bshift)) *
	(leaves << bshift) + (leaf << bshift) +
	(ztest_random(1ULL << (bshift - 1)) & -8ULL);

	/*
	* Only allow damage to the labels at one end of the vdev.
	*
	* If all labels are damaged, the device will be totally
	* inaccessible, which will result in loss of data,
	* because we also damage (parts of) the other side of
	* the mirror/raidz.
	*
	* Additionally, we will always have both an even and an
	* odd label, so that we can handle crashes in the
	* middle of vdev_config_sync().
	*/
	if ((leaf & 1) == 0 && offset < VDEV_LABEL_START_SIZE)
	continue;

	/*
	* The two end labels are stored at the "end" of the disk, but
	* the end of the disk (vdev_psize) is aligned to
	* sizeof (vdev_label_t).
	*/
	uint64_t psize = P2ALIGN(fsize, sizeof (vdev_label_t));
	if ((leaf & 1) == 1 &&
	offset + sizeof (bad) > psize - VDEV_LABEL_END_SIZE)
	continue;

	mutex_enter(&ztest_vdev_lock);
	if (mirror_save != zs->zs_mirrors) {
	mutex_exit(&ztest_vdev_lock);
	(void) close(fd);
	goto out;
	}

	if (pwrite(fd, &bad, sizeof (bad), offset) != sizeof (bad))
	fatal(1, "can't inject bad word at 0x%llx in %s",
	offset, pathrand);

	mutex_exit(&ztest_vdev_lock);

	if (ztest_opts.zo_verbose >= 7)
	(void) printf("injected bad word into %s,"
	" offset 0x%llx\n", pathrand, (u_longlong_t)offset);
	}

	(void) close(fd);
	out:
	umem_free(path0, MAXPATHLEN);
	umem_free(pathrand, MAXPATHLEN);
	}

	/*
	* By design ztest will never inject uncorrectable damage in to the pool.
	* Issue a scrub, wait for it to complete, and verify there is never any
	* persistent damage.
	*
	* Only after a full scrub has been completed is it safe to start injecting
	* data corruption. See the comment in zfs_fault_inject().
	*/
	static int
	ztest_scrub_impl(spa_t *spa)
	{
	int error = spa_scan(spa, POOL_SCAN_SCRUB);
	if (error)
	return (error);

	while (dsl_scan_scrubbing(spa_get_dsl(spa)))
	txg_wait_synced(spa_get_dsl(spa), 0);

	if (spa_get_errlog_size(spa) > 0)
	return (ECKSUM);

	ztest_pool_scrubbed = B_TRUE;

	return (0);
	}

	/*
	* Scrub the pool.
	*/
	/* ARGSUSED */
	void
	ztest_scrub(ztest_ds_t *zd, uint64_t id)
	{
	spa_t *spa = ztest_spa;
	int error;

	/*
	* Scrub in progress by device removal.
	*/
	if (ztest_device_removal_active)
	return;

	/*
	* Start a scrub, wait a moment, then force a restart.
	*/
	(void) spa_scan(spa, POOL_SCAN_SCRUB);
	(void) poll(NULL, 0, 100);

	error = ztest_scrub_impl(spa);
	if (error == EBUSY)
	error = 0;
	ASSERT0(error);
	}

	/*
	* Change the guid for the pool.
	*/
	/* ARGSUSED */
	void
	ztest_reguid(ztest_ds_t *zd, uint64_t id)
	{
	spa_t *spa = ztest_spa;
	uint64_t orig, load;
	int error;

	if (ztest_opts.zo_mmp_test)
	return;

	orig = spa_guid(spa);
	load = spa_load_guid(spa);

	(void) pthread_rwlock_wrlock(&ztest_name_lock);
	error = spa_change_guid(spa);
	(void) pthread_rwlock_unlock(&ztest_name_lock);

	if (error != 0)
	return;

	if (ztest_opts.zo_verbose >= 4) {
	(void) printf("Changed guid old %llu -> %llu\n",
	(u_longlong_t)orig, (u_longlong_t)spa_guid(spa));
	}

	VERIFY3U(orig, !=, spa_guid(spa));
	VERIFY3U(load, ==, spa_load_guid(spa));
	}

	void
	ztest_fletcher(ztest_ds_t *zd, uint64_t id)
	{
	hrtime_t end = gethrtime() + NANOSEC;

	while (gethrtime() <= end) {
	int run_count = 100;
	void *buf;
	struct abd abd_data, abd_meta;
	uint32_t size;
	int *ptr;
	int i;
	zio_cksum_t zc_ref;
	zio_cksum_t zc_ref_byteswap;

	size = ztest_random_blocksize();

	buf = umem_alloc(size, UMEM_NOFAIL);
	abd_data = abd_alloc(size, B_FALSE);
	abd_meta = abd_alloc(size, B_TRUE);

	for (i = 0, ptr = buf; i < size / sizeof (*ptr); i++, ptr++)
	*ptr = ztest_random(UINT_MAX);

	abd_copy_from_buf_off(abd_data, buf, 0, size);
	abd_copy_from_buf_off(abd_meta, buf, 0, size);

	VERIFY0(fletcher_4_impl_set("scalar"));
	fletcher_4_native(buf, size, NULL, &zc_ref);
	fletcher_4_byteswap(buf, size, NULL, &zc_ref_byteswap);

	VERIFY0(fletcher_4_impl_set("cycle"));
	while (run_count-- > 0) {
	zio_cksum_t zc;
	zio_cksum_t zc_byteswap;

	fletcher_4_byteswap(buf, size, NULL, &zc_byteswap);
	fletcher_4_native(buf, size, NULL, &zc);

	VERIFY0(bcmp(&zc, &zc_ref, sizeof (zc)));
	VERIFY0(bcmp(&zc_byteswap, &zc_ref_byteswap,
	sizeof (zc_byteswap)));

	/* Test ABD - data */
	abd_fletcher_4_byteswap(abd_data, size, NULL,
	&zc_byteswap);
	abd_fletcher_4_native(abd_data, size, NULL, &zc);

	VERIFY0(bcmp(&zc, &zc_ref, sizeof (zc)));
	VERIFY0(bcmp(&zc_byteswap, &zc_ref_byteswap,
	sizeof (zc_byteswap)));

	/* Test ABD - metadata */
	abd_fletcher_4_byteswap(abd_meta, size, NULL,
	&zc_byteswap);
	abd_fletcher_4_native(abd_meta, size, NULL, &zc);

	VERIFY0(bcmp(&zc, &zc_ref, sizeof (zc)));
	VERIFY0(bcmp(&zc_byteswap, &zc_ref_byteswap,
	sizeof (zc_byteswap)));

	}

	umem_free(buf, size);
	abd_free(abd_data);
	abd_free(abd_meta);
	}
	}

	void
	ztest_fletcher_incr(ztest_ds_t *zd, uint64_t id)
	{
	void *buf;
	size_t size;
	int *ptr;
	int i;
	zio_cksum_t zc_ref;
	zio_cksum_t zc_ref_bswap;

	hrtime_t end = gethrtime() + NANOSEC;

	while (gethrtime() <= end) {
	int run_count = 100;

	size = ztest_random_blocksize();
	buf = umem_alloc(size, UMEM_NOFAIL);

	for (i = 0, ptr = buf; i < size / sizeof (*ptr); i++, ptr++)
	*ptr = ztest_random(UINT_MAX);

	VERIFY0(fletcher_4_impl_set("scalar"));
	fletcher_4_native(buf, size, NULL, &zc_ref);
	fletcher_4_byteswap(buf, size, NULL, &zc_ref_bswap);

	VERIFY0(fletcher_4_impl_set("cycle"));

	while (run_count-- > 0) {
	zio_cksum_t zc;
	zio_cksum_t zc_bswap;
	size_t pos = 0;

	ZIO_SET_CHECKSUM(&zc, 0, 0, 0, 0);
	ZIO_SET_CHECKSUM(&zc_bswap, 0, 0, 0, 0);

	while (pos < size) {
	size_t inc = 64 * ztest_random(size / 67);
	/* sometimes add few bytes to test non-simd */
	if (ztest_random(100) < 10)
	inc += P2ALIGN(ztest_random(64),
	sizeof (uint32_t));

	if (inc > (size - pos))
	inc = size - pos;

	fletcher_4_incremental_native(buf + pos, inc,
	&zc);
	fletcher_4_incremental_byteswap(buf + pos, inc,
	&zc_bswap);

	pos += inc;
	}

	VERIFY3U(pos, ==, size);

	VERIFY(ZIO_CHECKSUM_EQUAL(zc, zc_ref));
	VERIFY(ZIO_CHECKSUM_EQUAL(zc_bswap, zc_ref_bswap));

	/*
	* verify if incremental on the whole buffer is
	* equivalent to non-incremental version
	*/
	ZIO_SET_CHECKSUM(&zc, 0, 0, 0, 0);
	ZIO_SET_CHECKSUM(&zc_bswap, 0, 0, 0, 0);

	fletcher_4_incremental_native(buf, size, &zc);
	fletcher_4_incremental_byteswap(buf, size, &zc_bswap);

	VERIFY(ZIO_CHECKSUM_EQUAL(zc, zc_ref));
	VERIFY(ZIO_CHECKSUM_EQUAL(zc_bswap, zc_ref_bswap));
	}

	umem_free(buf, size);
	}
	}

	static int
	ztest_set_global_vars(void)
	{
	for (size_t i = 0; i < ztest_opts.zo_gvars_count; i++) {
	char *kv = ztest_opts.zo_gvars[i];
	VERIFY3U(strlen(kv), <=, ZO_GVARS_MAX_ARGLEN);
	VERIFY3U(strlen(kv), >, 0);
	int err = set_global_var(kv);
	if (ztest_opts.zo_verbose > 0) {
	(void) printf("setting global var %s ... %s\n", kv,
	err ? "failed" : "ok");
	}
	if (err != 0) {
	(void) fprintf(stderr,
	"failed to set global var '%s'\n", kv);
	return (err);
	}
	}
	return (0);
	}

	static char **
	ztest_global_vars_to_zdb_args(void)
	{
	char *args = calloc(2ztest_opts.zo_gvars_count + 1, sizeof (char *));
	char **cur = args;
	for (size_t i = 0; i < ztest_opts.zo_gvars_count; i++) {
	char *kv = ztest_opts.zo_gvars[i];
	*cur = "-o";
	cur++;
	*cur = strdup(kv);
	cur++;
	}
	ASSERT3P(cur, ==, &args[2*ztest_opts.zo_gvars_count]);
	*cur = NULL;
	return (args);
	}

	/* The end of strings is indicated by a NULL element */
	static char *
	join_strings(char *strings, const char sep)
	{
	size_t totallen = 0;
	for (char *sp = strings; sp != NULL; sp++) {
	totallen += strlen(*sp);
	totallen += strlen(sep);
	}
	if (totallen > 0) {
	ASSERT(totallen >= strlen(sep));
	totallen -= strlen(sep);
	}

	size_t buflen = totallen + 1;
	char o = malloc(buflen); / trailing 0 byte */
	o[0] = '\0';
	for (char *sp = strings; sp != NULL; sp++) {
	size_t would;
	would = strlcat(o, *sp, buflen);
	VERIFY3U(would, <, buflen);
	if (*(sp+1) == NULL) {
	break;
	}
	would = strlcat(o, sep, buflen);
	VERIFY3U(would, <, buflen);
	}
	ASSERT3S(strlen(o), ==, totallen);
	return (o);
	}

	static int
	ztest_check_path(char *path)
	{
	struct stat s;
	/* return true on success */
	return (!stat(path, &s));
	}

	static void
	ztest_get_zdb_bin(char *bin, int len)
	{
	char *zdb_path;
	/*
	* Try to use ZDB_PATH and in-tree zdb path. If not successful, just
	* let popen to search through PATH.
	*/
	if ((zdb_path = getenv("ZDB_PATH"))) {
	strlcpy(bin, zdb_path, len); /* In env */
	if (!ztest_check_path(bin)) {
	ztest_dump_core = 0;
	fatal(1, "invalid ZDB_PATH '%s'", bin);
	}
	return;
	}

	VERIFY3P(realpath(getexecname(), bin), !=, NULL);
	if (strstr(bin, "/ztest/")) {
	strstr(bin, "/ztest/")[0] = '\0'; /* In-tree */
	strcat(bin, "/zdb/zdb");
	if (ztest_check_path(bin))
	return;
	}
	strcpy(bin, "zdb");
	}

	static vdev_t *
	ztest_random_concrete_vdev_leaf(vdev_t *vd)
	{
	if (vd == NULL)
	return (NULL);

	if (vd->vdev_children == 0)
	return (vd);

	vdev_t *eligible[vd->vdev_children];
	int eligible_idx = 0, i;
	for (i = 0; i < vd->vdev_children; i++) {
	vdev_t *cvd = vd->vdev_child[i];
	if (cvd->vdev_top->vdev_removing)
	continue;
	if (cvd->vdev_children > 0 \|\|
	(vdev_is_concrete(cvd) && !cvd->vdev_detached)) {
	eligible[eligible_idx++] = cvd;
	}
	}
	VERIFY3S(eligible_idx, >, 0);

	uint64_t child_no = ztest_random(eligible_idx);
	return (ztest_random_concrete_vdev_leaf(eligible[child_no]));
	}

	/* ARGSUSED */
	void
	ztest_initialize(ztest_ds_t *zd, uint64_t id)
	{
	spa_t *spa = ztest_spa;
	int error = 0;

	mutex_enter(&ztest_vdev_lock);

	spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER);

	/* Random leaf vdev */
	vdev_t *rand_vd = ztest_random_concrete_vdev_leaf(spa->spa_root_vdev);
	if (rand_vd == NULL) {
	spa_config_exit(spa, SCL_VDEV, FTAG);
	mutex_exit(&ztest_vdev_lock);
	return;
	}

	/*
	* The random vdev we've selected may change as soon as we
	* drop the spa_config_lock. We create local copies of things
	* we're interested in.
	*/
	uint64_t guid = rand_vd->vdev_guid;
	char *path = strdup(rand_vd->vdev_path);
	boolean_t active = rand_vd->vdev_initialize_thread != NULL;

	zfs_dbgmsg("vd %px, guid %llu", rand_vd, guid);
	spa_config_exit(spa, SCL_VDEV, FTAG);

	uint64_t cmd = ztest_random(POOL_INITIALIZE_FUNCS);

	nvlist_t *vdev_guids = fnvlist_alloc();
	nvlist_t *vdev_errlist = fnvlist_alloc();
	fnvlist_add_uint64(vdev_guids, path, guid);
	error = spa_vdev_initialize(spa, vdev_guids, cmd, vdev_errlist);
	fnvlist_free(vdev_guids);
	fnvlist_free(vdev_errlist);

	switch (cmd) {
	case POOL_INITIALIZE_CANCEL:
	if (ztest_opts.zo_verbose >= 4) {
	(void) printf("Cancel initialize %s", path);
	if (!active)
	(void) printf(" failed (no initialize active)");
	(void) printf("\n");
	}
	break;
	case POOL_INITIALIZE_START:
	if (ztest_opts.zo_verbose >= 4) {
	(void) printf("Start initialize %s", path);
	if (active && error == 0)
	(void) printf(" failed (already active)");
	else if (error != 0)
	(void) printf(" failed (error %d)", error);
	(void) printf("\n");
	}
	break;
	case POOL_INITIALIZE_SUSPEND:
	if (ztest_opts.zo_verbose >= 4) {
	(void) printf("Suspend initialize %s", path);
	if (!active)
	(void) printf(" failed (no initialize active)");
	(void) printf("\n");
	}
	break;
	}
	free(path);
	mutex_exit(&ztest_vdev_lock);
	}

	/* ARGSUSED */
	void
	ztest_trim(ztest_ds_t *zd, uint64_t id)
	{
	spa_t *spa = ztest_spa;
	int error = 0;

	mutex_enter(&ztest_vdev_lock);

	spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER);

	/* Random leaf vdev */
	vdev_t *rand_vd = ztest_random_concrete_vdev_leaf(spa->spa_root_vdev);
	if (rand_vd == NULL) {
	spa_config_exit(spa, SCL_VDEV, FTAG);
	mutex_exit(&ztest_vdev_lock);
	return;
	}

	/*
	* The random vdev we've selected may change as soon as we
	* drop the spa_config_lock. We create local copies of things
	* we're interested in.
	*/
	uint64_t guid = rand_vd->vdev_guid;
	char *path = strdup(rand_vd->vdev_path);
	boolean_t active = rand_vd->vdev_trim_thread != NULL;

	zfs_dbgmsg("vd %p, guid %llu", rand_vd, guid);
	spa_config_exit(spa, SCL_VDEV, FTAG);

	uint64_t cmd = ztest_random(POOL_TRIM_FUNCS);
	uint64_t rate = 1 << ztest_random(30);
	boolean_t partial = (ztest_random(5) > 0);
	boolean_t secure = (ztest_random(5) > 0);

	nvlist_t *vdev_guids = fnvlist_alloc();
	nvlist_t *vdev_errlist = fnvlist_alloc();
	fnvlist_add_uint64(vdev_guids, path, guid);
	error = spa_vdev_trim(spa, vdev_guids, cmd, rate, partial,
	secure, vdev_errlist);
	fnvlist_free(vdev_guids);
	fnvlist_free(vdev_errlist);

	switch (cmd) {
	case POOL_TRIM_CANCEL:
	if (ztest_opts.zo_verbose >= 4) {
	(void) printf("Cancel TRIM %s", path);
	if (!active)
	(void) printf(" failed (no TRIM active)");
	(void) printf("\n");
	}
	break;
	case POOL_TRIM_START:
	if (ztest_opts.zo_verbose >= 4) {
	(void) printf("Start TRIM %s", path);
	if (active && error == 0)
	(void) printf(" failed (already active)");
	else if (error != 0)
	(void) printf(" failed (error %d)", error);
	(void) printf("\n");
	}
	break;
	case POOL_TRIM_SUSPEND:
	if (ztest_opts.zo_verbose >= 4) {
	(void) printf("Suspend TRIM %s", path);
	if (!active)
	(void) printf(" failed (no TRIM active)");
	(void) printf("\n");
	}
	break;
	}
	free(path);
	mutex_exit(&ztest_vdev_lock);
	}

	/*
	* Verify pool integrity by running zdb.
	*/
	static void
	ztest_run_zdb(char *pool)
	{
	int status;
	char *bin;
	char *zdb;
	char *zbuf;
	const int len = MAXPATHLEN + MAXNAMELEN + 20;
	FILE *fp;

	bin = umem_alloc(len, UMEM_NOFAIL);
	zdb = umem_alloc(len, UMEM_NOFAIL);
	zbuf = umem_alloc(1024, UMEM_NOFAIL);

	ztest_get_zdb_bin(bin, len);

	char **set_gvars_args = ztest_global_vars_to_zdb_args();
	char *set_gvars_args_joined = join_strings(set_gvars_args, " ");
	free(set_gvars_args);

	size_t would = snprintf(zdb, len,
	"%s -bcc%s%s -G -d -Y -e -y %s -p %s %s",
	bin,
	ztest_opts.zo_verbose >= 3 ? "s" : "",
	ztest_opts.zo_verbose >= 4 ? "v" : "",
	set_gvars_args_joined,
	ztest_opts.zo_dir,
	pool);
	ASSERT3U(would, <, len);

	free(set_gvars_args_joined);

	if (ztest_opts.zo_verbose >= 5)
	(void) printf("Executing %s\n", strstr(zdb, "zdb "));

	fp = popen(zdb, "r");

	while (fgets(zbuf, 1024, fp) != NULL)
	if (ztest_opts.zo_verbose >= 3)
	(void) printf("%s", zbuf);

	status = pclose(fp);

	if (status == 0)
	goto out;

	ztest_dump_core = 0;
	if (WIFEXITED(status))
	fatal(0, "'%s' exit code %d", zdb, WEXITSTATUS(status));
	else
	fatal(0, "'%s' died with signal %d", zdb, WTERMSIG(status));
	out:
	umem_free(bin, len);
	umem_free(zdb, len);
	umem_free(zbuf, 1024);
	}

	static void
	ztest_walk_pool_directory(char *header)
	{
	spa_t *spa = NULL;

	if (ztest_opts.zo_verbose >= 6)
	(void) printf("%s\n", header);

	mutex_enter(&spa_namespace_lock);
	while ((spa = spa_next(spa)) != NULL)
	if (ztest_opts.zo_verbose >= 6)
	(void) printf("\t%s\n", spa_name(spa));
	mutex_exit(&spa_namespace_lock);
	}

	static void
	ztest_spa_import_export(char oldname, char newname)
	{
	nvlist_t config, newconfig;
	uint64_t pool_guid;
	spa_t *spa;
	int error;

	if (ztest_opts.zo_verbose >= 4) {
	(void) printf("import/export: old = %s, new = %s\n",
	oldname, newname);
	}

	/*
	* Clean up from previous runs.
	*/
	(void) spa_destroy(newname);

	/*
	* Get the pool's configuration and guid.
	*/
	VERIFY0(spa_open(oldname, &spa, FTAG));

	/*
	* Kick off a scrub to tickle scrub/export races.
	*/
	if (ztest_random(2) == 0)
	(void) spa_scan(spa, POOL_SCAN_SCRUB);

	pool_guid = spa_guid(spa);
	spa_close(spa, FTAG);

	ztest_walk_pool_directory("pools before export");

	/*
	* Export it.
	*/
	VERIFY0(spa_export(oldname, &config, B_FALSE, B_FALSE));

	ztest_walk_pool_directory("pools after export");

	/*
	* Try to import it.
	*/
	newconfig = spa_tryimport(config);
	ASSERT3P(newconfig, !=, NULL);
	fnvlist_free(newconfig);

	/*
	* Import it under the new name.
	*/
	error = spa_import(newname, config, NULL, 0);
	if (error != 0) {
	dump_nvlist(config, 0);
	fatal(B_FALSE, "couldn't import pool %s as %s: error %u",
	oldname, newname, error);
	}

	ztest_walk_pool_directory("pools after import");

	/*
	* Try to import it again -- should fail with EEXIST.
	*/
	VERIFY3U(EEXIST, ==, spa_import(newname, config, NULL, 0));

	/*
	* Try to import it under a different name -- should fail with EEXIST.
	*/
	VERIFY3U(EEXIST, ==, spa_import(oldname, config, NULL, 0));

	/*
	* Verify that the pool is no longer visible under the old name.
	*/
	VERIFY3U(ENOENT, ==, spa_open(oldname, &spa, FTAG));

	/*
	* Verify that we can open and close the pool using the new name.
	*/
	VERIFY0(spa_open(newname, &spa, FTAG));
	ASSERT3U(pool_guid, ==, spa_guid(spa));
	spa_close(spa, FTAG);

	fnvlist_free(config);
	}

	static void
	ztest_resume(spa_t *spa)
	{
	if (spa_suspended(spa) && ztest_opts.zo_verbose >= 6)
	(void) printf("resuming from suspended state\n");
	spa_vdev_state_enter(spa, SCL_NONE);
	vdev_clear(spa, NULL);
	(void) spa_vdev_state_exit(spa, NULL, 0);
	(void) zio_resume(spa);
	}

	static void
	ztest_resume_thread(void *arg)
	{
	spa_t *spa = arg;

	while (!ztest_exiting) {
	if (spa_suspended(spa))
	ztest_resume(spa);
	(void) poll(NULL, 0, 100);

	/*
	* Periodically change the zfs_compressed_arc_enabled setting.
	*/
	if (ztest_random(10) == 0)
	zfs_compressed_arc_enabled = ztest_random(2);

	/*
	* Periodically change the zfs_abd_scatter_enabled setting.
	*/
	if (ztest_random(10) == 0)
	zfs_abd_scatter_enabled = ztest_random(2);
	}

	thread_exit();
	}

	static void
	ztest_deadman_thread(void *arg)
	{
	ztest_shared_t *zs = arg;
	spa_t *spa = ztest_spa;
	hrtime_t delay, overdue, last_run = gethrtime();

	delay = (zs->zs_thread_stop - zs->zs_thread_start) +
	MSEC2NSEC(zfs_deadman_synctime_ms);

	while (!ztest_exiting) {
	/*
	* Wait for the delay timer while checking occasionally
	* if we should stop.
	*/
	if (gethrtime() < last_run + delay) {
	(void) poll(NULL, 0, 1000);
	continue;
	}

	/*
	* If the pool is suspended then fail immediately. Otherwise,
	* check to see if the pool is making any progress. If
	* vdev_deadman() discovers that there hasn't been any recent
	* I/Os then it will end up aborting the tests.
	*/
	if (spa_suspended(spa) \|\| spa->spa_root_vdev == NULL) {
	fatal(0, "aborting test after %llu seconds because "
	"pool has transitioned to a suspended state.",
	zfs_deadman_synctime_ms / 1000);
	}
	vdev_deadman(spa->spa_root_vdev, FTAG);

	/*
	* If the process doesn't complete within a grace period of
	* zfs_deadman_synctime_ms over the expected finish time,
	* then it may be hung and is terminated.
	*/
	overdue = zs->zs_proc_stop + MSEC2NSEC(zfs_deadman_synctime_ms);
	if (gethrtime() > overdue) {
	fatal(0, "aborting test after %llu seconds because "
	"the process is overdue for termination.",
	(gethrtime() - zs->zs_proc_start) / NANOSEC);
	}

	(void) printf("ztest has been running for %lld seconds\n",
	(gethrtime() - zs->zs_proc_start) / NANOSEC);

	last_run = gethrtime();
	delay = MSEC2NSEC(zfs_deadman_checktime_ms);
	}

	thread_exit();
	}

	static void
	ztest_execute(int test, ztest_info_t *zi, uint64_t id)
	{
	ztest_ds_t *zd = &ztest_ds[id % ztest_opts.zo_datasets];
	ztest_shared_callstate_t *zc = ZTEST_GET_SHARED_CALLSTATE(test);
	hrtime_t functime = gethrtime();
	int i;

	for (i = 0; i < zi->zi_iters; i++)
	zi->zi_func(zd, id);

	functime = gethrtime() - functime;

	atomic_add_64(&zc->zc_count, 1);
	atomic_add_64(&zc->zc_time, functime);

	if (ztest_opts.zo_verbose >= 4)
	(void) printf("%6.2f sec in %s\n",
	(double)functime / NANOSEC, zi->zi_funcname);
	}

	static void
	ztest_thread(void *arg)
	{
	int rand;
	uint64_t id = (uintptr_t)arg;
	ztest_shared_t *zs = ztest_shared;
	uint64_t call_next;
	hrtime_t now;
	ztest_info_t *zi;
	ztest_shared_callstate_t *zc;

	while ((now = gethrtime()) < zs->zs_thread_stop) {
	/*
	* See if it's time to force a crash.
	*/
	if (now > zs->zs_thread_kill)
	ztest_kill(zs);

	/*
	* If we're getting ENOSPC with some regularity, stop.
	*/
	if (zs->zs_enospc_count > 10)
	break;

	/*
	* Pick a random function to execute.
	*/
	rand = ztest_random(ZTEST_FUNCS);
	zi = &ztest_info[rand];
	zc = ZTEST_GET_SHARED_CALLSTATE(rand);
	call_next = zc->zc_next;

	if (now >= call_next &&
	atomic_cas_64(&zc->zc_next, call_next, call_next +
	ztest_random(2 * zi->zi_interval[0] + 1)) == call_next) {
	ztest_execute(rand, zi, id);
	}
	}

	thread_exit();
	}

	static void
	ztest_dataset_name(char dsname, char pool, int d)
	{
	(void) snprintf(dsname, ZFS_MAX_DATASET_NAME_LEN, "%s/ds_%d", pool, d);
	}

	static void
	ztest_dataset_destroy(int d)
	{
	char name[ZFS_MAX_DATASET_NAME_LEN];
	int t;

	ztest_dataset_name(name, ztest_opts.zo_pool, d);

	if (ztest_opts.zo_verbose >= 3)
	(void) printf("Destroying %s to free up space\n", name);

	/*
	* Cleanup any non-standard clones and snapshots. In general,
	* ztest thread t operates on dataset (t % zopt_datasets),
	* so there may be more than one thing to clean up.
	*/
	for (t = d; t < ztest_opts.zo_threads;
	t += ztest_opts.zo_datasets)
	ztest_dsl_dataset_cleanup(name, t);

	(void) dmu_objset_find(name, ztest_objset_destroy_cb, NULL,
	DS_FIND_SNAPSHOTS \| DS_FIND_CHILDREN);
	}

	static void
	ztest_dataset_dirobj_verify(ztest_ds_t *zd)
	{
	uint64_t usedobjs, dirobjs, scratch;

	/*
	* ZTEST_DIROBJ is the object directory for the entire dataset.
	* Therefore, the number of objects in use should equal the
	* number of ZTEST_DIROBJ entries, +1 for ZTEST_DIROBJ itself.
	* If not, we have an object leak.
	*
	* Note that we can only check this in ztest_dataset_open(),
	* when the open-context and syncing-context values agree.
	* That's because zap_count() returns the open-context value,
	* while dmu_objset_space() returns the rootbp fill count.
	*/
	VERIFY0(zap_count(zd->zd_os, ZTEST_DIROBJ, &dirobjs));
	dmu_objset_space(zd->zd_os, &scratch, &scratch, &usedobjs, &scratch);
	ASSERT3U(dirobjs + 1, ==, usedobjs);
	}

	static int
	ztest_dataset_open(int d)
	{
	ztest_ds_t *zd = &ztest_ds[d];
	uint64_t committed_seq = ZTEST_GET_SHARED_DS(d)->zd_seq;
	objset_t *os;
	zilog_t *zilog;
	char name[ZFS_MAX_DATASET_NAME_LEN];
	int error;

	ztest_dataset_name(name, ztest_opts.zo_pool, d);

	(void) pthread_rwlock_rdlock(&ztest_name_lock);

	error = ztest_dataset_create(name);
	if (error == ENOSPC) {
	(void) pthread_rwlock_unlock(&ztest_name_lock);
	ztest_record_enospc(FTAG);
	return (error);
	}
	ASSERT(error == 0 \|\| error == EEXIST);

	VERIFY0(ztest_dmu_objset_own(name, DMU_OST_OTHER, B_FALSE,
	B_TRUE, zd, &os));
	(void) pthread_rwlock_unlock(&ztest_name_lock);

	ztest_zd_init(zd, ZTEST_GET_SHARED_DS(d), os);

	zilog = zd->zd_zilog;

	if (zilog->zl_header->zh_claim_lr_seq != 0 &&
	zilog->zl_header->zh_claim_lr_seq < committed_seq)
	fatal(0, "missing log records: claimed %llu < committed %llu",
	zilog->zl_header->zh_claim_lr_seq, committed_seq);

	ztest_dataset_dirobj_verify(zd);

	zil_replay(os, zd, ztest_replay_vector);

	ztest_dataset_dirobj_verify(zd);

	if (ztest_opts.zo_verbose >= 6)
	(void) printf("%s replay %llu blocks, %llu records, seq %llu\n",
	zd->zd_name,
	(u_longlong_t)zilog->zl_parse_blk_count,
	(u_longlong_t)zilog->zl_parse_lr_count,
	(u_longlong_t)zilog->zl_replaying_seq);

	zilog = zil_open(os, ztest_get_data);

	if (zilog->zl_replaying_seq != 0 &&
	zilog->zl_replaying_seq < committed_seq)
	fatal(0, "missing log records: replayed %llu < committed %llu",
	zilog->zl_replaying_seq, committed_seq);

	return (0);
	}

	static void
	ztest_dataset_close(int d)
	{
	ztest_ds_t *zd = &ztest_ds[d];

	zil_close(zd->zd_zilog);
	dmu_objset_disown(zd->zd_os, B_TRUE, zd);

	ztest_zd_fini(zd);
	}

	/* ARGSUSED */
	static int
	ztest_replay_zil_cb(const char name, void arg)
	{
	objset_t *os;
	ztest_ds_t *zdtmp;

	VERIFY0(ztest_dmu_objset_own(name, DMU_OST_ANY, B_TRUE,
	B_TRUE, FTAG, &os));

	zdtmp = umem_alloc(sizeof (ztest_ds_t), UMEM_NOFAIL);

	ztest_zd_init(zdtmp, NULL, os);
	zil_replay(os, zdtmp, ztest_replay_vector);
	ztest_zd_fini(zdtmp);

	if (dmu_objset_zil(os)->zl_parse_lr_count != 0 &&
	ztest_opts.zo_verbose >= 6) {
	zilog_t *zilog = dmu_objset_zil(os);

	(void) printf("%s replay %llu blocks, %llu records, seq %llu\n",
	name,
	(u_longlong_t)zilog->zl_parse_blk_count,
	(u_longlong_t)zilog->zl_parse_lr_count,
	(u_longlong_t)zilog->zl_replaying_seq);
	}

	umem_free(zdtmp, sizeof (ztest_ds_t));

	dmu_objset_disown(os, B_TRUE, FTAG);
	return (0);
	}

	static void
	ztest_freeze(void)
	{
	ztest_ds_t *zd = &ztest_ds[0];
	spa_t *spa;
	int numloops = 0;

	if (ztest_opts.zo_verbose >= 3)
	(void) printf("testing spa_freeze()...\n");

	kernel_init(SPA_MODE_READ \| SPA_MODE_WRITE);
	VERIFY0(spa_open(ztest_opts.zo_pool, &spa, FTAG));
	VERIFY0(ztest_dataset_open(0));
	ztest_spa = spa;

	/*
	* Force the first log block to be transactionally allocated.
	* We have to do this before we freeze the pool -- otherwise
	* the log chain won't be anchored.
	*/
	while (BP_IS_HOLE(&zd->zd_zilog->zl_header->zh_log)) {
	ztest_dmu_object_alloc_free(zd, 0);
	zil_commit(zd->zd_zilog, 0);
	}

	txg_wait_synced(spa_get_dsl(spa), 0);

	/*
	* Freeze the pool. This stops spa_sync() from doing anything,
	* so that the only way to record changes from now on is the ZIL.
	*/
	spa_freeze(spa);

	/*
	* Because it is hard to predict how much space a write will actually
	* require beforehand, we leave ourselves some fudge space to write over
	* capacity.
	*/
	uint64_t capacity = metaslab_class_get_space(spa_normal_class(spa)) / 2;

	/*
	* Run tests that generate log records but don't alter the pool config
	* or depend on DSL sync tasks (snapshots, objset create/destroy, etc).
	* We do a txg_wait_synced() after each iteration to force the txg
	* to increase well beyond the last synced value in the uberblock.
	* The ZIL should be OK with that.
	*
	* Run a random number of times less than zo_maxloops and ensure we do
	* not run out of space on the pool.
	*/
	while (ztest_random(10) != 0 &&
	numloops++ < ztest_opts.zo_maxloops &&
	metaslab_class_get_alloc(spa_normal_class(spa)) < capacity) {
	ztest_od_t od;
	ztest_od_init(&od, 0, FTAG, 0, DMU_OT_UINT64_OTHER, 0, 0, 0);
	VERIFY0(ztest_object_init(zd, &od, sizeof (od), B_FALSE));
	ztest_io(zd, od.od_object,
	ztest_random(ZTEST_RANGE_LOCKS) << SPA_MAXBLOCKSHIFT);
	txg_wait_synced(spa_get_dsl(spa), 0);
	}

	/*
	* Commit all of the changes we just generated.
	*/
	zil_commit(zd->zd_zilog, 0);
	txg_wait_synced(spa_get_dsl(spa), 0);

	/*
	* Close our dataset and close the pool.
	*/
	ztest_dataset_close(0);
	spa_close(spa, FTAG);
	kernel_fini();

	/*
	* Open and close the pool and dataset to induce log replay.
	*/
	kernel_init(SPA_MODE_READ \| SPA_MODE_WRITE);
	VERIFY0(spa_open(ztest_opts.zo_pool, &spa, FTAG));
	ASSERT3U(spa_freeze_txg(spa), ==, UINT64_MAX);
	VERIFY0(ztest_dataset_open(0));
	ztest_spa = spa;
	txg_wait_synced(spa_get_dsl(spa), 0);
	ztest_dataset_close(0);
	ztest_reguid(NULL, 0);

	spa_close(spa, FTAG);
	kernel_fini();
	}

	static void
	ztest_import_impl(ztest_shared_t *zs)
	{
	importargs_t args = { 0 };
	nvlist_t *cfg = NULL;
	int nsearch = 1;
	char *searchdirs[nsearch];
	int flags = ZFS_IMPORT_MISSING_LOG;

	searchdirs[0] = ztest_opts.zo_dir;
	args.paths = nsearch;
	args.path = searchdirs;
	args.can_be_active = B_FALSE;

	VERIFY0(zpool_find_config(NULL, ztest_opts.zo_pool, &cfg, &args,
	&libzpool_config_ops));
	VERIFY0(spa_import(ztest_opts.zo_pool, cfg, NULL, flags));
	fnvlist_free(cfg);
	}

	/*
	* Import a storage pool with the given name.
	*/
	static void
	ztest_import(ztest_shared_t *zs)
	{
	spa_t *spa;

	mutex_init(&ztest_vdev_lock, NULL, MUTEX_DEFAULT, NULL);
	mutex_init(&ztest_checkpoint_lock, NULL, MUTEX_DEFAULT, NULL);
	VERIFY0(pthread_rwlock_init(&ztest_name_lock, NULL));

	kernel_init(SPA_MODE_READ \| SPA_MODE_WRITE);

	ztest_import_impl(zs);

	VERIFY0(spa_open(ztest_opts.zo_pool, &spa, FTAG));
	zs->zs_metaslab_sz =
	1ULL << spa->spa_root_vdev->vdev_child[0]->vdev_ms_shift;
	spa_close(spa, FTAG);

	kernel_fini();

	if (!ztest_opts.zo_mmp_test) {
	ztest_run_zdb(ztest_opts.zo_pool);
	ztest_freeze();
	ztest_run_zdb(ztest_opts.zo_pool);
	}

	(void) pthread_rwlock_destroy(&ztest_name_lock);
	mutex_destroy(&ztest_vdev_lock);
	mutex_destroy(&ztest_checkpoint_lock);
	}

	/*
	* Kick off threads to run tests on all datasets in parallel.
	*/
	static void
	ztest_run(ztest_shared_t *zs)
	{
	spa_t *spa;
	objset_t *os;
	kthread_t resume_thread, deadman_thread;
	kthread_t **run_threads;
	uint64_t object;
	int error;
	int t, d;

	ztest_exiting = B_FALSE;

	/*
	* Initialize parent/child shared state.
	*/
	mutex_init(&ztest_vdev_lock, NULL, MUTEX_DEFAULT, NULL);
	mutex_init(&ztest_checkpoint_lock, NULL, MUTEX_DEFAULT, NULL);
	VERIFY0(pthread_rwlock_init(&ztest_name_lock, NULL));

	zs->zs_thread_start = gethrtime();
	zs->zs_thread_stop =
	zs->zs_thread_start + ztest_opts.zo_passtime * NANOSEC;
	zs->zs_thread_stop = MIN(zs->zs_thread_stop, zs->zs_proc_stop);
	zs->zs_thread_kill = zs->zs_thread_stop;
	if (ztest_random(100) < ztest_opts.zo_killrate) {
	zs->zs_thread_kill -=
	ztest_random(ztest_opts.zo_passtime * NANOSEC);
	}

	mutex_init(&zcl.zcl_callbacks_lock, NULL, MUTEX_DEFAULT, NULL);

	list_create(&zcl.zcl_callbacks, sizeof (ztest_cb_data_t),
	offsetof(ztest_cb_data_t, zcd_node));

	/*
	* Open our pool. It may need to be imported first depending on
	* what tests were running when the previous pass was terminated.
	*/
	kernel_init(SPA_MODE_READ \| SPA_MODE_WRITE);
	error = spa_open(ztest_opts.zo_pool, &spa, FTAG);
	if (error) {
	VERIFY3S(error, ==, ENOENT);
	ztest_import_impl(zs);
	VERIFY0(spa_open(ztest_opts.zo_pool, &spa, FTAG));
	zs->zs_metaslab_sz =
	1ULL << spa->spa_root_vdev->vdev_child[0]->vdev_ms_shift;
	}

	metaslab_preload_limit = ztest_random(20) + 1;
	ztest_spa = spa;

	VERIFY0(vdev_raidz_impl_set("cycle"));

	dmu_objset_stats_t dds;
	VERIFY0(ztest_dmu_objset_own(ztest_opts.zo_pool,
	DMU_OST_ANY, B_TRUE, B_TRUE, FTAG, &os));
	dsl_pool_config_enter(dmu_objset_pool(os), FTAG);
	dmu_objset_fast_stat(os, &dds);
	dsl_pool_config_exit(dmu_objset_pool(os), FTAG);
	zs->zs_guid = dds.dds_guid;
	dmu_objset_disown(os, B_TRUE, FTAG);

	/*
	* Create a thread to periodically resume suspended I/O.
	*/
	resume_thread = thread_create(NULL, 0, ztest_resume_thread,
	spa, 0, NULL, TS_RUN \| TS_JOINABLE, defclsyspri);

	/*
	* Create a deadman thread and set to panic if we hang.
	*/
	deadman_thread = thread_create(NULL, 0, ztest_deadman_thread,
	zs, 0, NULL, TS_RUN \| TS_JOINABLE, defclsyspri);

	spa->spa_deadman_failmode = ZIO_FAILURE_MODE_PANIC;

	/*
	* Verify that we can safely inquire about any object,
	* whether it's allocated or not. To make it interesting,
	* we probe a 5-wide window around each power of two.
	* This hits all edge cases, including zero and the max.
	*/
	for (t = 0; t < 64; t++) {
	for (d = -5; d <= 5; d++) {
	error = dmu_object_info(spa->spa_meta_objset,
	(1ULL << t) + d, NULL);
	ASSERT(error == 0 \|\| error == ENOENT \|\|
	error == EINVAL);
	}
	}

	/*
	* If we got any ENOSPC errors on the previous run, destroy something.
	*/
	if (zs->zs_enospc_count != 0) {
	int d = ztest_random(ztest_opts.zo_datasets);
	ztest_dataset_destroy(d);
	}
	zs->zs_enospc_count = 0;

	/*
	* If we were in the middle of ztest_device_removal() and were killed
	* we need to ensure the removal and scrub complete before running
	* any tests that check ztest_device_removal_active. The removal will
	* be restarted automatically when the spa is opened, but we need to
	* initiate the scrub manually if it is not already in progress. Note
	* that we always run the scrub whenever an indirect vdev exists
	* because we have no way of knowing for sure if ztest_device_removal()
	* fully completed its scrub before the pool was reimported.
	*/
	if (spa->spa_removing_phys.sr_state == DSS_SCANNING \|\|
	spa->spa_removing_phys.sr_prev_indirect_vdev != -1) {
	while (spa->spa_removing_phys.sr_state == DSS_SCANNING)
	txg_wait_synced(spa_get_dsl(spa), 0);

	error = ztest_scrub_impl(spa);
	if (error == EBUSY)
	error = 0;
	ASSERT0(error);
	}

	run_threads = umem_zalloc(ztest_opts.zo_threads * sizeof (kthread_t *),
	UMEM_NOFAIL);

	if (ztest_opts.zo_verbose >= 4)
	(void) printf("starting main threads...\n");

	/*
	* Replay all logs of all datasets in the pool. This is primarily for
	* temporary datasets which wouldn't otherwise get replayed, which
	* can trigger failures when attempting to offline a SLOG in
	* ztest_fault_inject().
	*/
	(void) dmu_objset_find(ztest_opts.zo_pool, ztest_replay_zil_cb,
	NULL, DS_FIND_CHILDREN);

	/*
	* Kick off all the tests that run in parallel.
	*/
	for (t = 0; t < ztest_opts.zo_threads; t++) {
	if (t < ztest_opts.zo_datasets && ztest_dataset_open(t) != 0) {
	umem_free(run_threads, ztest_opts.zo_threads *
	sizeof (kthread_t *));
	return;
	}

	run_threads[t] = thread_create(NULL, 0, ztest_thread,
	(void *)(uintptr_t)t, 0, NULL, TS_RUN \| TS_JOINABLE,
	defclsyspri);
	}

	/*
	* Wait for all of the tests to complete.
	*/
	for (t = 0; t < ztest_opts.zo_threads; t++)
	VERIFY0(thread_join(run_threads[t]));

	/*
	* Close all datasets. This must be done after all the threads
	* are joined so we can be sure none of the datasets are in-use
	* by any of the threads.
	*/
	for (t = 0; t < ztest_opts.zo_threads; t++) {
	if (t < ztest_opts.zo_datasets)
	ztest_dataset_close(t);
	}

	txg_wait_synced(spa_get_dsl(spa), 0);

	zs->zs_alloc = metaslab_class_get_alloc(spa_normal_class(spa));
	zs->zs_space = metaslab_class_get_space(spa_normal_class(spa));

	umem_free(run_threads, ztest_opts.zo_threads * sizeof (kthread_t *));

	/* Kill the resume and deadman threads */
	ztest_exiting = B_TRUE;
	VERIFY0(thread_join(resume_thread));
	VERIFY0(thread_join(deadman_thread));
	ztest_resume(spa);

	/*
	* Right before closing the pool, kick off a bunch of async I/O;
	* spa_close() should wait for it to complete.
	*/
	for (object = 1; object < 50; object++) {
	dmu_prefetch(spa->spa_meta_objset, object, 0, 0, 1ULL << 20,
	ZIO_PRIORITY_SYNC_READ);
	}

	/* Verify that at least one commit cb was called in a timely fashion */
	if (zc_cb_counter >= ZTEST_COMMIT_CB_MIN_REG)
	VERIFY0(zc_min_txg_delay);

	spa_close(spa, FTAG);

	/*
	* Verify that we can loop over all pools.
	*/
	mutex_enter(&spa_namespace_lock);
	for (spa = spa_next(NULL); spa != NULL; spa = spa_next(spa))
	if (ztest_opts.zo_verbose > 3)
	(void) printf("spa_next: found %s\n", spa_name(spa));
	mutex_exit(&spa_namespace_lock);

	/*
	* Verify that we can export the pool and reimport it under a
	* different name.
	*/
	if ((ztest_random(2) == 0) && !ztest_opts.zo_mmp_test) {
	char name[ZFS_MAX_DATASET_NAME_LEN];
	(void) snprintf(name, sizeof (name), "%s_import",
	ztest_opts.zo_pool);
	ztest_spa_import_export(ztest_opts.zo_pool, name);
	ztest_spa_import_export(name, ztest_opts.zo_pool);
	}

	kernel_fini();

	list_destroy(&zcl.zcl_callbacks);
	mutex_destroy(&zcl.zcl_callbacks_lock);
	(void) pthread_rwlock_destroy(&ztest_name_lock);
	mutex_destroy(&ztest_vdev_lock);
	mutex_destroy(&ztest_checkpoint_lock);
	}

	static void
	print_time(hrtime_t t, char *timebuf)
	{
	hrtime_t s = t / NANOSEC;
	hrtime_t m = s / 60;
	hrtime_t h = m / 60;
	hrtime_t d = h / 24;

	s -= m * 60;
	m -= h * 60;
	h -= d * 24;

	timebuf[0] = '\0';

	if (d)
	(void) sprintf(timebuf,
	"%llud%02lluh%02llum%02llus", d, h, m, s);
	else if (h)
	(void) sprintf(timebuf, "%lluh%02llum%02llus", h, m, s);
	else if (m)
	(void) sprintf(timebuf, "%llum%02llus", m, s);
	else
	(void) sprintf(timebuf, "%llus", s);
	}

	static nvlist_t *
	make_random_props(void)
	{
	nvlist_t *props;

	props = fnvlist_alloc();

	if (ztest_random(2) == 0)
	return (props);

	fnvlist_add_uint64(props,
	zpool_prop_to_name(ZPOOL_PROP_AUTOREPLACE), 1);

	return (props);
	}

	/*
	* Create a storage pool with the given name and initial vdev size.
	* Then test spa_freeze() functionality.
	*/
	static void
	ztest_init(ztest_shared_t *zs)
	{
	spa_t *spa;
	nvlist_t nvroot, props;
	int i;

	mutex_init(&ztest_vdev_lock, NULL, MUTEX_DEFAULT, NULL);
	mutex_init(&ztest_checkpoint_lock, NULL, MUTEX_DEFAULT, NULL);
	VERIFY0(pthread_rwlock_init(&ztest_name_lock, NULL));

	kernel_init(SPA_MODE_READ \| SPA_MODE_WRITE);

	/*
	* Create the storage pool.
	*/
	(void) spa_destroy(ztest_opts.zo_pool);
	ztest_shared->zs_vdev_next_leaf = 0;
	zs->zs_splits = 0;
	zs->zs_mirrors = ztest_opts.zo_mirrors;
	nvroot = make_vdev_root(NULL, NULL, NULL, ztest_opts.zo_vdev_size, 0,
	NULL, ztest_opts.zo_raid_children, zs->zs_mirrors, 1);
	props = make_random_props();

	/*
	* We don't expect the pool to suspend unless maxfaults == 0,
	* in which case ztest_fault_inject() temporarily takes away
	* the only valid replica.
	*/
	fnvlist_add_uint64(props,
	zpool_prop_to_name(ZPOOL_PROP_FAILUREMODE),
	MAXFAULTS(zs) ? ZIO_FAILURE_MODE_PANIC : ZIO_FAILURE_MODE_WAIT);

	for (i = 0; i < SPA_FEATURES; i++) {
	char *buf;

	if (!spa_feature_table[i].fi_zfs_mod_supported)
	continue;

	/*
	* 75% chance of using the log space map feature. We want ztest
	* to exercise both the code paths that use the log space map
	* feature and the ones that don't.
	*/
	if (i == SPA_FEATURE_LOG_SPACEMAP && ztest_random(4) == 0)
	continue;

	VERIFY3S(-1, !=, asprintf(&buf, "feature@%s",
	spa_feature_table[i].fi_uname));
	fnvlist_add_uint64(props, buf, 0);
	free(buf);
	}

	VERIFY0(spa_create(ztest_opts.zo_pool, nvroot, props, NULL, NULL));
	fnvlist_free(nvroot);
	fnvlist_free(props);

	VERIFY0(spa_open(ztest_opts.zo_pool, &spa, FTAG));
	zs->zs_metaslab_sz =
	1ULL << spa->spa_root_vdev->vdev_child[0]->vdev_ms_shift;
	spa_close(spa, FTAG);

	kernel_fini();

	if (!ztest_opts.zo_mmp_test) {
	ztest_run_zdb(ztest_opts.zo_pool);
	ztest_freeze();
	ztest_run_zdb(ztest_opts.zo_pool);
	}

	(void) pthread_rwlock_destroy(&ztest_name_lock);
	mutex_destroy(&ztest_vdev_lock);
	mutex_destroy(&ztest_checkpoint_lock);
	}

	static void
	setup_data_fd(void)
	{
	static char ztest_name_data[] = "/tmp/ztest.data.XXXXXX";

	ztest_fd_data = mkstemp(ztest_name_data);
	ASSERT3S(ztest_fd_data, >=, 0);
	(void) unlink(ztest_name_data);
	}

	static int
	shared_data_size(ztest_shared_hdr_t *hdr)
	{
	int size;

	size = hdr->zh_hdr_size;
	size += hdr->zh_opts_size;
	size += hdr->zh_size;
	size += hdr->zh_stats_size * hdr->zh_stats_count;
	size += hdr->zh_ds_size * hdr->zh_ds_count;

	return (size);
	}

	static void
	setup_hdr(void)
	{
	int size;
	ztest_shared_hdr_t *hdr;

	hdr = (void )mmap(0, P2ROUNDUP(sizeof (hdr), getpagesize()),
	PROT_READ \| PROT_WRITE, MAP_SHARED, ztest_fd_data, 0);
	ASSERT3P(hdr, !=, MAP_FAILED);

	VERIFY0(ftruncate(ztest_fd_data, sizeof (ztest_shared_hdr_t)));

	hdr->zh_hdr_size = sizeof (ztest_shared_hdr_t);
	hdr->zh_opts_size = sizeof (ztest_shared_opts_t);
	hdr->zh_size = sizeof (ztest_shared_t);
	hdr->zh_stats_size = sizeof (ztest_shared_callstate_t);
	hdr->zh_stats_count = ZTEST_FUNCS;
	hdr->zh_ds_size = sizeof (ztest_shared_ds_t);
	hdr->zh_ds_count = ztest_opts.zo_datasets;

	size = shared_data_size(hdr);
	VERIFY0(ftruncate(ztest_fd_data, size));

	(void) munmap((caddr_t)hdr, P2ROUNDUP(sizeof (*hdr), getpagesize()));
	}

	static void
	setup_data(void)
	{
	int size, offset;
	ztest_shared_hdr_t *hdr;
	uint8_t *buf;

	hdr = (void )mmap(0, P2ROUNDUP(sizeof (hdr), getpagesize()),
	PROT_READ, MAP_SHARED, ztest_fd_data, 0);
	ASSERT3P(hdr, !=, MAP_FAILED);

	size = shared_data_size(hdr);

	(void) munmap((caddr_t)hdr, P2ROUNDUP(sizeof (*hdr), getpagesize()));
	hdr = ztest_shared_hdr = (void *)mmap(0, P2ROUNDUP(size, getpagesize()),
	PROT_READ \| PROT_WRITE, MAP_SHARED, ztest_fd_data, 0);
	ASSERT3P(hdr, !=, MAP_FAILED);
	buf = (uint8_t *)hdr;

	offset = hdr->zh_hdr_size;
	ztest_shared_opts = (void *)&buf[offset];
	offset += hdr->zh_opts_size;
	ztest_shared = (void *)&buf[offset];
	offset += hdr->zh_size;
	ztest_shared_callstate = (void *)&buf[offset];
	offset += hdr->zh_stats_size * hdr->zh_stats_count;
	ztest_shared_ds = (void *)&buf[offset];
	}

	static boolean_t
	exec_child(char cmd, char libpath, boolean_t ignorekill, int *statusp)
	{
	pid_t pid;
	int status;
	char *cmdbuf = NULL;

	pid = fork();

	if (cmd == NULL) {
	cmdbuf = umem_alloc(MAXPATHLEN, UMEM_NOFAIL);
	(void) strlcpy(cmdbuf, getexecname(), MAXPATHLEN);
	cmd = cmdbuf;
	}

	if (pid == -1)
	fatal(1, "fork failed");

	if (pid == 0) { /* child */
	char *emptyargv[2] = { cmd, NULL };
	char fd_data_str[12];

	struct rlimit rl = { 1024, 1024 };
	(void) setrlimit(RLIMIT_NOFILE, &rl);

	(void) close(ztest_fd_rand);
	VERIFY3S(11, >=,
	snprintf(fd_data_str, 12, "%d", ztest_fd_data));
	VERIFY0(setenv("ZTEST_FD_DATA", fd_data_str, 1));

	(void) enable_extended_FILE_stdio(-1, -1);
	if (libpath != NULL)
	VERIFY0(setenv("LD_LIBRARY_PATH", libpath, 1));
	(void) execv(cmd, emptyargv);
	ztest_dump_core = B_FALSE;
	fatal(B_TRUE, "exec failed: %s", cmd);
	}

	if (cmdbuf != NULL) {
	umem_free(cmdbuf, MAXPATHLEN);
	cmd = NULL;
	}

	while (waitpid(pid, &status, 0) != pid)
	continue;
	if (statusp != NULL)
	*statusp = status;

	if (WIFEXITED(status)) {
	if (WEXITSTATUS(status) != 0) {
	(void) fprintf(stderr, "child exited with code %d\n",
	WEXITSTATUS(status));
	exit(2);
	}
	return (B_FALSE);
	} else if (WIFSIGNALED(status)) {
	if (!ignorekill \|\| WTERMSIG(status) != SIGKILL) {
	(void) fprintf(stderr, "child died with signal %d\n",
	WTERMSIG(status));
	exit(3);
	}
	return (B_TRUE);
	} else {
	(void) fprintf(stderr, "something strange happened to child\n");
	exit(4);
	/* NOTREACHED */
	}
	}

	static void
	ztest_run_init(void)
	{
	int i;

	ztest_shared_t *zs = ztest_shared;

	/*
	* Blow away any existing copy of zpool.cache
	*/
	(void) remove(spa_config_path);

	if (ztest_opts.zo_init == 0) {
	if (ztest_opts.zo_verbose >= 1)
	(void) printf("Importing pool %s\n",
	ztest_opts.zo_pool);
	ztest_import(zs);
	return;
	}

	/*
	* Create and initialize our storage pool.
	*/
	for (i = 1; i <= ztest_opts.zo_init; i++) {
	bzero(zs, sizeof (ztest_shared_t));
	if (ztest_opts.zo_verbose >= 3 &&
	ztest_opts.zo_init != 1) {
	(void) printf("ztest_init(), pass %d\n", i);
	}
	ztest_init(zs);
	}
	}

	int
	main(int argc, char **argv)
	{
	int kills = 0;
	int iters = 0;
	int older = 0;
	int newer = 0;
	ztest_shared_t *zs;
	ztest_info_t *zi;
	ztest_shared_callstate_t *zc;
	char timebuf[100];
	char numbuf[NN_NUMBUF_SZ];
	char *cmd;
	boolean_t hasalt;
	int f, err;
	char *fd_data_str = getenv("ZTEST_FD_DATA");
	struct sigaction action;

	(void) setvbuf(stdout, NULL, _IOLBF, 0);

	dprintf_setup(&argc, argv);
	zfs_deadman_synctime_ms = 300000;
	zfs_deadman_checktime_ms = 30000;
	/*
	* As two-word space map entries may not come up often (especially
	* if pool and vdev sizes are small) we want to force at least some
	* of them so the feature get tested.
	*/
	zfs_force_some_double_word_sm_entries = B_TRUE;

	/*
	* Verify that even extensively damaged split blocks with many
	* segments can be reconstructed in a reasonable amount of time
	* when reconstruction is known to be possible.
	*
	* Note: the lower this value is, the more damage we inflict, and
	* the more time ztest spends in recovering that damage. We chose
	* to induce damage 1/100th of the time so recovery is tested but
	* not so frequently that ztest doesn't get to test other code paths.
	*/
	zfs_reconstruct_indirect_damage_fraction = 100;

	action.sa_handler = sig_handler;
	sigemptyset(&action.sa_mask);
	action.sa_flags = 0;

	if (sigaction(SIGSEGV, &action, NULL) < 0) {
	(void) fprintf(stderr, "ztest: cannot catch SIGSEGV: %s.\n",
	strerror(errno));
	exit(EXIT_FAILURE);
	}

	if (sigaction(SIGABRT, &action, NULL) < 0) {
	(void) fprintf(stderr, "ztest: cannot catch SIGABRT: %s.\n",
	strerror(errno));
	exit(EXIT_FAILURE);
	}

	/*
	* Force random_get_bytes() to use /dev/urandom in order to prevent
	* ztest from needlessly depleting the system entropy pool.
	*/
	random_path = "/dev/urandom";
	ztest_fd_rand = open(random_path, O_RDONLY);
	ASSERT3S(ztest_fd_rand, >=, 0);

	if (!fd_data_str) {
	process_options(argc, argv);

	setup_data_fd();
	setup_hdr();
	setup_data();
	bcopy(&ztest_opts, ztest_shared_opts,
	sizeof (*ztest_shared_opts));
	} else {
	ztest_fd_data = atoi(fd_data_str);
	setup_data();
	bcopy(ztest_shared_opts, &ztest_opts, sizeof (ztest_opts));
	}
	ASSERT3U(ztest_opts.zo_datasets, ==, ztest_shared_hdr->zh_ds_count);

	err = ztest_set_global_vars();
	if (err != 0 && !fd_data_str) {
	/* error message done by ztest_set_global_vars */
	exit(EXIT_FAILURE);
	} else {
	/* children should not be spawned if setting gvars fails */
	VERIFY3S(err, ==, 0);
	}

	/* Override location of zpool.cache */
	VERIFY3S(asprintf((char **)&spa_config_path, "%s/zpool.cache",
	ztest_opts.zo_dir), !=, -1);

	ztest_ds = umem_alloc(ztest_opts.zo_datasets * sizeof (ztest_ds_t),
	UMEM_NOFAIL);
	zs = ztest_shared;

	if (fd_data_str) {
	metaslab_force_ganging = ztest_opts.zo_metaslab_force_ganging;
	metaslab_df_alloc_threshold =
	zs->zs_metaslab_df_alloc_threshold;

	if (zs->zs_do_init)
	ztest_run_init();
	else
	ztest_run(zs);
	exit(0);
	}

	hasalt = (strlen(ztest_opts.zo_alt_ztest) != 0);

	if (ztest_opts.zo_verbose >= 1) {
	(void) printf("%llu vdevs, %d datasets, %d threads,"
	"%d %s disks, %llu seconds...\n\n",
	(u_longlong_t)ztest_opts.zo_vdevs,
	ztest_opts.zo_datasets,
	ztest_opts.zo_threads,
	ztest_opts.zo_raid_children,
	ztest_opts.zo_raid_type,
	(u_longlong_t)ztest_opts.zo_time);
	}

	cmd = umem_alloc(MAXNAMELEN, UMEM_NOFAIL);
	(void) strlcpy(cmd, getexecname(), MAXNAMELEN);

	zs->zs_do_init = B_TRUE;
	if (strlen(ztest_opts.zo_alt_ztest) != 0) {
	if (ztest_opts.zo_verbose >= 1) {
	(void) printf("Executing older ztest for "
	"initialization: %s\n", ztest_opts.zo_alt_ztest);
	}
	VERIFY(!exec_child(ztest_opts.zo_alt_ztest,
	ztest_opts.zo_alt_libpath, B_FALSE, NULL));
	} else {
	VERIFY(!exec_child(NULL, NULL, B_FALSE, NULL));
	}
	zs->zs_do_init = B_FALSE;

	zs->zs_proc_start = gethrtime();
	zs->zs_proc_stop = zs->zs_proc_start + ztest_opts.zo_time * NANOSEC;

	for (f = 0; f < ZTEST_FUNCS; f++) {
	zi = &ztest_info[f];
	zc = ZTEST_GET_SHARED_CALLSTATE(f);
	if (zs->zs_proc_start + zi->zi_interval[0] > zs->zs_proc_stop)
	zc->zc_next = UINT64_MAX;
	else
	zc->zc_next = zs->zs_proc_start +
	ztest_random(2 * zi->zi_interval[0] + 1);
	}

	/*
	* Run the tests in a loop. These tests include fault injection
	* to verify that self-healing data works, and forced crashes
	* to verify that we never lose on-disk consistency.
	*/
	while (gethrtime() < zs->zs_proc_stop) {
	int status;
	boolean_t killed;

	/*
	* Initialize the workload counters for each function.
	*/
	for (f = 0; f < ZTEST_FUNCS; f++) {
	zc = ZTEST_GET_SHARED_CALLSTATE(f);
	zc->zc_count = 0;
	zc->zc_time = 0;
	}

	/* Set the allocation switch size */
	zs->zs_metaslab_df_alloc_threshold =
	ztest_random(zs->zs_metaslab_sz / 4) + 1;

	if (!hasalt \|\| ztest_random(2) == 0) {
	if (hasalt && ztest_opts.zo_verbose >= 1) {
	(void) printf("Executing newer ztest: %s\n",
	cmd);
	}
	newer++;
	killed = exec_child(cmd, NULL, B_TRUE, &status);
	} else {
	if (hasalt && ztest_opts.zo_verbose >= 1) {
	(void) printf("Executing older ztest: %s\n",
	ztest_opts.zo_alt_ztest);
	}
	older++;
	killed = exec_child(ztest_opts.zo_alt_ztest,
	ztest_opts.zo_alt_libpath, B_TRUE, &status);
	}

	if (killed)
	kills++;
	iters++;

	if (ztest_opts.zo_verbose >= 1) {
	hrtime_t now = gethrtime();

	now = MIN(now, zs->zs_proc_stop);
	print_time(zs->zs_proc_stop - now, timebuf);
	nicenum(zs->zs_space, numbuf, sizeof (numbuf));

	(void) printf("Pass %3d, %8s, %3llu ENOSPC, "
	"%4.1f%% of %5s used, %3.0f%% done, %8s to go\n",
	iters,
	WIFEXITED(status) ? "Complete" : "SIGKILL",
	(u_longlong_t)zs->zs_enospc_count,
	100.0 * zs->zs_alloc / zs->zs_space,
	numbuf,
	100.0 * (now - zs->zs_proc_start) /
	(ztest_opts.zo_time * NANOSEC), timebuf);
	}

	if (ztest_opts.zo_verbose >= 2) {
	(void) printf("\nWorkload summary:\n\n");
	(void) printf("%7s %9s %s\n",
	"Calls", "Time", "Function");
	(void) printf("%7s %9s %s\n",
	"-----", "----", "--------");
	for (f = 0; f < ZTEST_FUNCS; f++) {
	zi = &ztest_info[f];
	zc = ZTEST_GET_SHARED_CALLSTATE(f);
	print_time(zc->zc_time, timebuf);
	(void) printf("%7llu %9s %s\n",
	(u_longlong_t)zc->zc_count, timebuf,
	zi->zi_funcname);
	}
	(void) printf("\n");
	}

	if (!ztest_opts.zo_mmp_test)
	ztest_run_zdb(ztest_opts.zo_pool);
	}

	if (ztest_opts.zo_verbose >= 1) {
	if (hasalt) {
	(void) printf("%d runs of older ztest: %s\n", older,
	ztest_opts.zo_alt_ztest);
	(void) printf("%d runs of newer ztest: %s\n", newer,
	cmd);
	}
	(void) printf("%d killed, %d completed, %.0f%% kill rate\n",
	kills, iters - kills, (100.0 * kills) / MAX(1, iters));
	}

	umem_free(cmd, MAXNAMELEN);

	return (0);
	}
	diff --git a/sys/contrib/openzfs/cmd/zvol_wait/zvol_wait b/sys/contrib/openzfs/cmd/zvol_wait/zvol_wait
	index 9a3948da5564..cc6ba5e62572 100755
	--- a/sys/contrib/openzfs/cmd/zvol_wait/zvol_wait
	+++ b/sys/contrib/openzfs/cmd/zvol_wait/zvol_wait
	@@ -1,116 +1,112 @@
	#!/bin/sh

	count_zvols() {
	if [ -z "$zvols" ]; then
	echo 0
	else
	echo "$zvols" \| wc -l
	fi
	}

	filter_out_zvols_with_links() {
	- while read -r zvol; do
	- if [ ! -L "/dev/zvol/$zvol" ]; then
	+ echo "$zvols" \| tr ' ' '+' \| while read -r zvol; do
	+ if ! [ -L "/dev/zvol/$zvol" ]; then
	echo "$zvol"
	fi
	- done
	+ done \| tr '+' ' '
	}

	filter_out_deleted_zvols() {
	- while read -r zvol; do
	- if zfs list "$zvol" >/dev/null 2>&1; then
	- echo "$zvol"
	- fi
	- done
	+ OIFS="$IFS"
	+ IFS="
	+"
	+ zfs list -H -o name $zvols 2>/dev/null
	+ IFS="$OIFS"
	}

	list_zvols() {
	+ read -r default_volmode < /sys/module/zfs/parameters/zvol_volmode
	zfs list -t volume -H -o \
	- name,volmode,receive_resume_token,redact_snaps \|
	- while read -r zvol_line; do
	- name=$(echo "$zvol_line" \| awk '{print $1}')
	- volmode=$(echo "$zvol_line" \| awk '{print $2}')
	- token=$(echo "$zvol_line" \| awk '{print $3}')
	- redacted=$(echo "$zvol_line" \| awk '{print $4}')
	- #
	+ name,volmode,receive_resume_token,redact_snaps \|
	+ while IFS=" " read -r name volmode token redacted; do # IFS=\t here!
	+
	# /dev links are not created for zvols with volmode = "none"
	# or for redacted zvols.
	- #
	[ "$volmode" = "none" ] && continue
	+ [ "$volmode" = "default" ] && [ "$default_volmode" = "3" ] &&
	+ continue
	[ "$redacted" = "-" ] \|\| continue
	- #
	- # We also also ignore partially received zvols if it is
	+
	+ # We also ignore partially received zvols if it is
	# not an incremental receive, as those won't even have a block
	# device minor node created yet.
	- #
	if [ "$token" != "-" ]; then
	- #
	+
	# Incremental receives create an invisible clone that
	# is not automatically displayed by zfs list.
	- #
	if ! zfs list "$name/%recv" >/dev/null 2>&1; then
	continue
	fi
	fi
	echo "$name"
	done
	}

	zvols=$(list_zvols)
	zvols_count=$(count_zvols)
	if [ "$zvols_count" -eq 0 ]; then
	echo "No zvols found, nothing to do."
	exit 0
	fi

	echo "Testing $zvols_count zvol links"

	outer_loop=0
	while [ "$outer_loop" -lt 20 ]; do
	outer_loop=$((outer_loop + 1))

	old_zvols_count=$(count_zvols)

	inner_loop=0
	while [ "$inner_loop" -lt 30 ]; do
	inner_loop=$((inner_loop + 1))

	- zvols="$(echo "$zvols" \| filter_out_zvols_with_links)"
	+ zvols="$(filter_out_zvols_with_links)"

	zvols_count=$(count_zvols)
	if [ "$zvols_count" -eq 0 ]; then
	echo "All zvol links are now present."
	exit 0
	fi
	sleep 1
	done

	echo "Still waiting on $zvols_count zvol links ..."
	#
	# Although zvols should normally not be deleted at boot time,
	# if that is the case then their links will be missing and
	# we would stall.
	#
	if [ "$old_zvols_count" -eq "$zvols_count" ]; then
	echo "No progress since last loop."
	echo "Checking if any zvols were deleted."

	- zvols=$(echo "$zvols" \| filter_out_deleted_zvols)
	+ zvols=$(filter_out_deleted_zvols)
	zvols_count=$(count_zvols)

	if [ "$old_zvols_count" -ne "$zvols_count" ]; then
	echo "$((old_zvols_count - zvols_count)) zvol(s) deleted."
	fi

	if [ "$zvols_count" -ne 0 ]; then
	echo "Remaining zvols:"
	echo "$zvols"
	else
	echo "All zvol links are now present."
	exit 0
	fi
	fi
	done

	echo "Timed out waiting on zvol links"
	exit 1
	diff --git a/sys/contrib/openzfs/config/CppCheck.am b/sys/contrib/openzfs/config/CppCheck.am
	index 13c633c60038..e53013bd01cc 100644
	--- a/sys/contrib/openzfs/config/CppCheck.am
	+++ b/sys/contrib/openzfs/config/CppCheck.am
	@@ -1,11 +1,11 @@
	#
	-# Default rules for running cppcheck against the the user space components.
	+# Default rules for running cppcheck against the user space components.
	#

	PHONY += cppcheck

	CPPCHECKFLAGS = --std=c99 --quiet --max-configs=1 --error-exitcode=2
	CPPCHECKFLAGS += --inline-suppr -U_KERNEL

	cppcheck:
	$(CPPCHECK) -j$(CPU_COUNT) $(CPPCHECKFLAGS) $(DEFAULT_INCLUDES) $(SOURCES)
	diff --git a/sys/contrib/openzfs/config/deb.am b/sys/contrib/openzfs/config/deb.am
	index 639a46efddbf..cdbdbecb356f 100644
	--- a/sys/contrib/openzfs/config/deb.am
	+++ b/sys/contrib/openzfs/config/deb.am
	@@ -1,74 +1,86 @@
	PHONY += deb-kmod deb-dkms deb-utils deb deb-local

	deb-local:
	@(if test "${HAVE_DPKGBUILD}" = "no"; then \
	echo -e "\n" \
	"*** Required util ${DPKGBUILD} missing. Please install the\n" \
	"*** package for your distribution which provides ${DPKGBUILD},\n" \
	"*** re-run configure, and try again.\n"; \
	exit 1; \
	fi; \
	if test "${HAVE_ALIEN}" = "no"; then \
	echo -e "\n" \
	"*** Required util ${ALIEN} missing. Please install the\n" \
	"*** package for your distribution which provides ${ALIEN},\n" \
	"*** re-run configure, and try again.\n"; \
	exit 1; \
	- fi)
	+ fi; \
	+ if test "${ALIEN_MAJOR}" = "8" && \
	+ test "${ALIEN_MINOR}" = "95"; then \
	+ if test "${ALIEN_POINT}" = "1" \|\| \
	+ test "${ALIEN_POINT}" = "2" \|\| \
	+ test "${ALIEN_POINT}" = "3"; then \
	+ /bin/echo -e "\n" \
	+ "*** Installed version of ${ALIEN} is known to be broken;\n" \
	+ "*** attempting to generate debs will fail! See\n" \
	+ "*** https://github.com/openzfs/zfs/issues/11650 for details.\n"; \
	+ exit 1; \
	+ fi; \
	+ fi)

	deb-kmod: deb-local rpm-kmod
	name=${PACKAGE}; \
	version=${VERSION}-${RELEASE}; \
	arch=`$(RPM) -qp $${name}-kmod-$${version}.src.rpm --qf %{arch} \| tail -1`; \
	debarch=`$(DPKG) --print-architecture`; \
	pkg1=kmod-$${name}*$${version}.$${arch}.rpm; \
	fakeroot $(ALIEN) --bump=0 --scripts --to-deb --target=$$debarch $$pkg1 \|\| exit 1; \
	$(RM) $$pkg1


	deb-dkms: deb-local rpm-dkms
	name=${PACKAGE}; \
	version=${VERSION}-${RELEASE}; \
	arch=`$(RPM) -qp $${name}-dkms-$${version}.src.rpm --qf %{arch} \| tail -1`; \
	debarch=`$(DPKG) --print-architecture`; \
	pkg1=$${name}-dkms-$${version}.$${arch}.rpm; \
	fakeroot $(ALIEN) --bump=0 --scripts --to-deb --target=$$debarch $$pkg1 \|\| exit 1; \
	$(RM) $$pkg1

	deb-utils: deb-local rpm-utils-initramfs
	name=${PACKAGE}; \
	version=${VERSION}-${RELEASE}; \
	arch=`$(RPM) -qp $${name}-$${version}.src.rpm --qf %{arch} \| tail -1`; \
	debarch=`$(DPKG) --print-architecture`; \
	pkg1=$${name}-$${version}.$${arch}.rpm; \
	pkg2=libnvpair3-$${version}.$${arch}.rpm; \
	pkg3=libuutil3-$${version}.$${arch}.rpm; \
	- pkg4=libzfs4-$${version}.$${arch}.rpm; \
	- pkg5=libzpool4-$${version}.$${arch}.rpm; \
	- pkg6=libzfs4-devel-$${version}.$${arch}.rpm; \
	+ pkg4=libzfs5-$${version}.$${arch}.rpm; \
	+ pkg5=libzpool5-$${version}.$${arch}.rpm; \
	+ pkg6=libzfs5-devel-$${version}.$${arch}.rpm; \
	pkg7=$${name}-test-$${version}.$${arch}.rpm; \
	pkg8=$${name}-dracut-$${version}.noarch.rpm; \
	pkg9=$${name}-initramfs-$${version}.$${arch}.rpm; \
	pkg10=`ls python-pyzfs-$${version} \| tail -1`; \
	## Arguments need to be passed to dh_shlibdeps. Alien provides no mechanism
	## to do this, so we install a shim onto the path which calls the real
	## dh_shlibdeps with the required arguments.
	path_prepend=`mktemp -d /tmp/intercept.XXXXXX`; \
	echo "#$(SHELL)" > $${path_prepend}/dh_shlibdeps; \
	echo "`which dh_shlibdeps` -- \
	- -xlibuutil3linux -xlibnvpair3linux -xlibzfs4linux -xlibzpool4linux" \
	+ -xlibuutil3linux -xlibnvpair3linux -xlibzfs5linux -xlibzpool5linux" \
	>> $${path_prepend}/dh_shlibdeps; \
	## These -x arguments are passed to dpkg-shlibdeps, which exclude the
	## Debianized packages from the auto-generated dependencies of the new debs,
	## which should NOT be mixed with the alien-generated debs created here
	chmod +x $${path_prepend}/dh_shlibdeps; \
	env PATH=$${path_prepend}:$${PATH} \
	fakeroot $(ALIEN) --bump=0 --scripts --to-deb --target=$$debarch \
	$$pkg1 $$pkg2 $$pkg3 $$pkg4 $$pkg5 $$pkg6 $$pkg7 \
	$$pkg8 $$pkg9 $$pkg10 \|\| exit 1; \
	$(RM) $${path_prepend}/dh_shlibdeps; \
	rmdir $${path_prepend}; \
	$(RM) $$pkg1 $$pkg2 $$pkg3 $$pkg4 $$pkg5 $$pkg6 $$pkg7 \
	$$pkg8 $$pkg9 $$pkg10;

	deb: deb-kmod deb-dkms deb-utils
	diff --git a/sys/contrib/openzfs/config/kernel-acl.m4 b/sys/contrib/openzfs/config/kernel-acl.m4
	index e02ce665323f..c6da4df24eb9 100644
	--- a/sys/contrib/openzfs/config/kernel-acl.m4
	+++ b/sys/contrib/openzfs/config/kernel-acl.m4
	@@ -1,289 +1,310 @@
	dnl #
	dnl # Check if posix_acl_release can be used from a ZFS_META_LICENSED
	dnl # module. The is_owner_or_cap macro was replaced by
	dnl # inode_owner_or_capable
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_POSIX_ACL_RELEASE], [
	ZFS_LINUX_TEST_SRC([posix_acl_release], [
	#include <linux/cred.h>
	#include <linux/fs.h>
	#include <linux/posix_acl.h>
	], [
	struct posix_acl *tmp = posix_acl_alloc(1, 0);
	posix_acl_release(tmp);
	], [], [ZFS_META_LICENSE])
	])

	AC_DEFUN([ZFS_AC_KERNEL_POSIX_ACL_RELEASE], [
	AC_MSG_CHECKING([whether posix_acl_release() is available])
	ZFS_LINUX_TEST_RESULT([posix_acl_release], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_POSIX_ACL_RELEASE, 1,
	[posix_acl_release() is available])

	AC_MSG_CHECKING([whether posix_acl_release() is GPL-only])
	ZFS_LINUX_TEST_RESULT([posix_acl_release_license], [
	AC_MSG_RESULT(no)
	],[
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_POSIX_ACL_RELEASE_GPL_ONLY, 1,
	[posix_acl_release() is GPL-only])
	])
	],[
	AC_MSG_RESULT(no)
	])
	])

	dnl #
	dnl # 3.14 API change,
	dnl # set_cached_acl() and forget_cached_acl() changed from inline to
	dnl # EXPORT_SYMBOL. In the former case, they may not be usable because of
	dnl # posix_acl_release. In the latter case, we can always use them.
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_SET_CACHED_ACL_USABLE], [
	ZFS_LINUX_TEST_SRC([set_cached_acl], [
	#include <linux/cred.h>
	#include <linux/fs.h>
	#include <linux/posix_acl.h>
	], [
	struct inode *ip = NULL;
	struct posix_acl *acl = posix_acl_alloc(1, 0);
	set_cached_acl(ip, ACL_TYPE_ACCESS, acl);
	forget_cached_acl(ip, ACL_TYPE_ACCESS);
	], [], [ZFS_META_LICENSE])
	])

	AC_DEFUN([ZFS_AC_KERNEL_SET_CACHED_ACL_USABLE], [
	AC_MSG_CHECKING([whether set_cached_acl() is usable])
	ZFS_LINUX_TEST_RESULT([set_cached_acl_license], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_SET_CACHED_ACL_USABLE, 1,
	[set_cached_acl() is usable])
	],[
	AC_MSG_RESULT(no)
	])
	])

	dnl #
	dnl # 3.1 API change,
	dnl # posix_acl_chmod() was added as the preferred interface.
	dnl #
	dnl # 3.14 API change,
	dnl # posix_acl_chmod() was changed to __posix_acl_chmod()
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_POSIX_ACL_CHMOD], [
	ZFS_LINUX_TEST_SRC([posix_acl_chmod], [
	#include <linux/fs.h>
	#include <linux/posix_acl.h>
	],[
	posix_acl_chmod(NULL, 0, 0)
	])

	ZFS_LINUX_TEST_SRC([__posix_acl_chmod], [
	#include <linux/fs.h>
	#include <linux/posix_acl.h>
	],[
	__posix_acl_chmod(NULL, 0, 0)
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_POSIX_ACL_CHMOD], [
	AC_MSG_CHECKING([whether __posix_acl_chmod exists])
	ZFS_LINUX_TEST_RESULT([__posix_acl_chmod], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE___POSIX_ACL_CHMOD, 1,
	[__posix_acl_chmod() exists])
	],[
	AC_MSG_RESULT(no)

	AC_MSG_CHECKING([whether posix_acl_chmod exists])
	ZFS_LINUX_TEST_RESULT([posix_acl_chmod], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_POSIX_ACL_CHMOD, 1,
	[posix_acl_chmod() exists])
	],[
	ZFS_LINUX_TEST_ERROR([posix_acl_chmod()])
	])
	])
	])

	dnl #
	dnl # 3.1 API change,
	dnl # posix_acl_equiv_mode now wants an umode_t instead of a mode_t
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_POSIX_ACL_EQUIV_MODE_WANTS_UMODE_T], [
	ZFS_LINUX_TEST_SRC([posix_acl_equiv_mode], [
	#include <linux/fs.h>
	#include <linux/posix_acl.h>
	],[
	umode_t tmp;
	posix_acl_equiv_mode(NULL, &tmp);
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_POSIX_ACL_EQUIV_MODE_WANTS_UMODE_T], [
	AC_MSG_CHECKING([whether posix_acl_equiv_mode() wants umode_t])
	ZFS_LINUX_TEST_RESULT([posix_acl_equiv_mode], [
	AC_MSG_RESULT(yes)
	],[
	ZFS_LINUX_TEST_ERROR([posix_acl_equiv_mode()])
	])
	])

	dnl #
	dnl # 4.8 API change,
	dnl # The function posix_acl_valid now must be passed a namespace.
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_POSIX_ACL_VALID_WITH_NS], [
	ZFS_LINUX_TEST_SRC([posix_acl_valid_with_ns], [
	#include <linux/fs.h>
	#include <linux/posix_acl.h>
	],[
	struct user_namespace *user_ns = NULL;
	const struct posix_acl *acl = NULL;
	int error;

	error = posix_acl_valid(user_ns, acl);
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_POSIX_ACL_VALID_WITH_NS], [
	AC_MSG_CHECKING([whether posix_acl_valid() wants user namespace])
	ZFS_LINUX_TEST_RESULT([posix_acl_valid_with_ns], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_POSIX_ACL_VALID_WITH_NS, 1,
	[posix_acl_valid() wants user namespace])
	],[
	AC_MSG_RESULT(no)
	])
	])

	dnl #
	dnl # 3.1 API change,
	dnl # Check if inode_operations contains the function get_acl
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_INODE_OPERATIONS_GET_ACL], [
	ZFS_LINUX_TEST_SRC([inode_operations_get_acl], [
	#include <linux/fs.h>

	struct posix_acl get_acl_fn(struct inode inode, int type)
	{ return NULL; }

	static const struct inode_operations
	iops __attribute__ ((unused)) = {
	.get_acl = get_acl_fn,
	};
	],[])
	])

	AC_DEFUN([ZFS_AC_KERNEL_INODE_OPERATIONS_GET_ACL], [
	AC_MSG_CHECKING([whether iops->get_acl() exists])
	ZFS_LINUX_TEST_RESULT([inode_operations_get_acl], [
	AC_MSG_RESULT(yes)
	],[
	ZFS_LINUX_TEST_ERROR([iops->get_acl()])
	])
	])

	dnl #
	dnl # 3.14 API change,
	dnl # Check if inode_operations contains the function set_acl
	dnl #
	+dnl # 5.12 API change,
	+dnl # set_acl() added a user_namespace* parameter first
	+dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_INODE_OPERATIONS_SET_ACL], [
	+ ZFS_LINUX_TEST_SRC([inode_operations_set_acl_userns], [
	+ #include <linux/fs.h>
	+
	+ int set_acl_fn(struct user_namespace *userns,
	+ struct inode inode, struct posix_acl acl,
	+ int type) { return 0; }
	+
	+ static const struct inode_operations
	+ iops __attribute__ ((unused)) = {
	+ .set_acl = set_acl_fn,
	+ };
	+ ],[])
	ZFS_LINUX_TEST_SRC([inode_operations_set_acl], [
	#include <linux/fs.h>

	int set_acl_fn(struct inode inode, struct posix_acl acl,
	int type) { return 0; }

	static const struct inode_operations
	iops __attribute__ ((unused)) = {
	.set_acl = set_acl_fn,
	};
	],[])
	])

	AC_DEFUN([ZFS_AC_KERNEL_INODE_OPERATIONS_SET_ACL], [
	AC_MSG_CHECKING([whether iops->set_acl() exists])
	- ZFS_LINUX_TEST_RESULT([inode_operations_set_acl], [
	+ ZFS_LINUX_TEST_RESULT([inode_operations_set_acl_userns], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_SET_ACL, 1, [iops->set_acl() exists])
	+ AC_DEFINE(HAVE_SET_ACL_USERNS, 1, [iops->set_acl() takes 4 args])
	],[
	- AC_MSG_RESULT(no)
	+ ZFS_LINUX_TEST_RESULT([inode_operations_set_acl], [
	+ AC_MSG_RESULT(yes)
	+ AC_DEFINE(HAVE_SET_ACL, 1, [iops->set_acl() exists, takes 3 args])
	+ ],[
	+ AC_MSG_RESULT(no)
	+ ])
	])
	])

	dnl #
	dnl # 4.7 API change,
	dnl # The kernel get_acl will now check cache before calling i_op->get_acl and
	dnl # do set_cached_acl after that, so i_op->get_acl don't need to do that
	dnl # anymore.
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_GET_ACL_HANDLE_CACHE], [
	ZFS_LINUX_TEST_SRC([get_acl_handle_cache], [
	#include <linux/fs.h>
	],[
	void *sentinel __attribute__ ((unused)) =
	uncached_acl_sentinel(NULL);
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_GET_ACL_HANDLE_CACHE], [
	AC_MSG_CHECKING([whether uncached_acl_sentinel() exists])
	ZFS_LINUX_TEST_RESULT([get_acl_handle_cache], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_KERNEL_GET_ACL_HANDLE_CACHE, 1,
	[uncached_acl_sentinel() exists])
	],[
	AC_MSG_RESULT(no)
	])
	])

	dnl #
	dnl # 4.16 kernel: check if struct posix_acl acl.a_refcount is a refcount_t.
	dnl # It's an atomic_t on older kernels.
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_ACL_HAS_REFCOUNT], [
	ZFS_LINUX_TEST_SRC([acl_refcount], [
	#include <linux/backing-dev.h>
	#include <linux/refcount.h>
	#include <linux/posix_acl.h>
	],[
	struct posix_acl acl;
	refcount_t *r __attribute__ ((unused)) = &acl.a_refcount;
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_ACL_HAS_REFCOUNT], [
	AC_MSG_CHECKING([whether posix_acl has refcount_t])
	ZFS_LINUX_TEST_RESULT([acl_refcount], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_ACL_REFCOUNT, 1, [posix_acl has refcount_t])
	],[
	AC_MSG_RESULT(no)
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_SRC_ACL], [
	ZFS_AC_KERNEL_SRC_POSIX_ACL_RELEASE
	ZFS_AC_KERNEL_SRC_SET_CACHED_ACL_USABLE
	ZFS_AC_KERNEL_SRC_POSIX_ACL_CHMOD
	ZFS_AC_KERNEL_SRC_POSIX_ACL_EQUIV_MODE_WANTS_UMODE_T
	ZFS_AC_KERNEL_SRC_POSIX_ACL_VALID_WITH_NS
	ZFS_AC_KERNEL_SRC_INODE_OPERATIONS_GET_ACL
	ZFS_AC_KERNEL_SRC_INODE_OPERATIONS_SET_ACL
	ZFS_AC_KERNEL_SRC_GET_ACL_HANDLE_CACHE
	ZFS_AC_KERNEL_SRC_ACL_HAS_REFCOUNT
	])

	AC_DEFUN([ZFS_AC_KERNEL_ACL], [
	ZFS_AC_KERNEL_POSIX_ACL_RELEASE
	ZFS_AC_KERNEL_SET_CACHED_ACL_USABLE
	ZFS_AC_KERNEL_POSIX_ACL_CHMOD
	ZFS_AC_KERNEL_POSIX_ACL_EQUIV_MODE_WANTS_UMODE_T
	ZFS_AC_KERNEL_POSIX_ACL_VALID_WITH_NS
	ZFS_AC_KERNEL_INODE_OPERATIONS_GET_ACL
	ZFS_AC_KERNEL_INODE_OPERATIONS_SET_ACL
	ZFS_AC_KERNEL_GET_ACL_HANDLE_CACHE
	ZFS_AC_KERNEL_ACL_HAS_REFCOUNT
	])
	diff --git a/sys/contrib/openzfs/config/kernel-bdi.m4 b/sys/contrib/openzfs/config/kernel-bdi.m4
	index 9351df71b4b8..9758863a9cbf 100644
	--- a/sys/contrib/openzfs/config/kernel-bdi.m4
	+++ b/sys/contrib/openzfs/config/kernel-bdi.m4
	@@ -1,79 +1,81 @@
	dnl #
	dnl # Check available BDI interfaces.
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_BDI], [
	ZFS_LINUX_TEST_SRC([super_setup_bdi_name], [
	#include <linux/fs.h>
	struct super_block sb;
	], [
	char *name = "bdi";
	atomic_long_t zfs_bdi_seq;
	- int error __attribute__((unused)) =
	+ int error __attribute__((unused));
	+ atomic_long_set(&zfs_bdi_seq, 0);
	+ error =
	super_setup_bdi_name(&sb, "%.28s-%ld", name,
	atomic_long_inc_return(&zfs_bdi_seq));
	])

	ZFS_LINUX_TEST_SRC([bdi_setup_and_register], [
	#include <linux/backing-dev.h>
	struct backing_dev_info bdi;
	], [
	char *name = "bdi";
	int error __attribute__((unused)) =
	bdi_setup_and_register(&bdi, name);
	])

	ZFS_LINUX_TEST_SRC([bdi_setup_and_register_3args], [
	#include <linux/backing-dev.h>
	struct backing_dev_info bdi;
	], [
	char *name = "bdi";
	unsigned int cap = BDI_CAP_MAP_COPY;
	int error __attribute__((unused)) =
	bdi_setup_and_register(&bdi, name, cap);
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BDI], [
	dnl #
	dnl # 4.12, super_setup_bdi_name() introduced.
	dnl #
	AC_MSG_CHECKING([whether super_setup_bdi_name() exists])
	ZFS_LINUX_TEST_RESULT_SYMBOL([super_setup_bdi_name],
	[super_setup_bdi_name], [fs/super.c], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_SUPER_SETUP_BDI_NAME, 1,
	[super_setup_bdi_name() exits])
	], [
	AC_MSG_RESULT(no)

	dnl #
	dnl # 4.0 - 4.11, bdi_setup_and_register() takes 2 arguments.
	dnl #
	AC_MSG_CHECKING(
	[whether bdi_setup_and_register() wants 2 args])
	ZFS_LINUX_TEST_RESULT_SYMBOL([bdi_setup_and_register],
	[bdi_setup_and_register], [mm/backing-dev.c], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_2ARGS_BDI_SETUP_AND_REGISTER, 1,
	[bdi_setup_and_register() wants 2 args])
	], [
	AC_MSG_RESULT(no)

	dnl #
	dnl # 2.6.34 - 3.19, bdi_setup_and_register()
	dnl # takes 3 arguments.
	dnl #
	AC_MSG_CHECKING(
	[whether bdi_setup_and_register() wants 3 args])
	ZFS_LINUX_TEST_RESULT_SYMBOL(
	[bdi_setup_and_register_3args],
	[bdi_setup_and_register], [mm/backing-dev.c], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_3ARGS_BDI_SETUP_AND_REGISTER, 1,
	[bdi_setup_and_register() wants 3 args])
	], [
	ZFS_LINUX_TEST_ERROR([bdi_setup])
	])
	])
	])
	])
	diff --git a/sys/contrib/openzfs/config/kernel-blk-queue.m4 b/sys/contrib/openzfs/config/kernel-blk-queue.m4
	index ff2da92e9ee1..1dced82ce686 100644
	--- a/sys/contrib/openzfs/config/kernel-blk-queue.m4
	+++ b/sys/contrib/openzfs/config/kernel-blk-queue.m4
	@@ -1,302 +1,302 @@
	dnl #
	dnl # 2.6.39 API change,
	dnl # blk_start_plug() and blk_finish_plug()
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLK_QUEUE_PLUG], [
	ZFS_LINUX_TEST_SRC([blk_plug], [
	#include <linux/blkdev.h>
	],[
	struct blk_plug plug __attribute__ ((unused));

	blk_start_plug(&plug);
	blk_finish_plug(&plug);
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BLK_QUEUE_PLUG], [
	AC_MSG_CHECKING([whether struct blk_plug is available])
	ZFS_LINUX_TEST_RESULT([blk_plug], [
	AC_MSG_RESULT(yes)
	],[
	ZFS_LINUX_TEST_ERROR([blk_plug])
	])
	])

	dnl #
	-dnl # 2.6.32 - 4.11, statically allocated bdi in request_queue
	-dnl # 4.12 - x.y, dynamically allocated bdi in request_queue
	+dnl # 2.6.32 - 4.11: statically allocated bdi in request_queue
	+dnl # 4.12: dynamically allocated bdi in request_queue
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLK_QUEUE_BDI], [
	ZFS_LINUX_TEST_SRC([blk_queue_bdi], [
	#include <linux/blkdev.h>
	],[
	struct request_queue q;
	struct backing_dev_info bdi;
	q.backing_dev_info = &bdi;
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BLK_QUEUE_BDI], [
	AC_MSG_CHECKING([whether blk_queue bdi is dynamic])
	ZFS_LINUX_TEST_RESULT([blk_queue_bdi], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_BLK_QUEUE_BDI_DYNAMIC, 1,
	[blk queue backing_dev_info is dynamic])
	],[
	AC_MSG_RESULT(no)
	])
	])

	dnl #
	-dnl # 2.6.32 - 4.x API,
	+dnl # 2.6.32 API,
	dnl # blk_queue_discard()
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLK_QUEUE_DISCARD], [
	ZFS_LINUX_TEST_SRC([blk_queue_discard], [
	#include <linux/blkdev.h>
	],[
	struct request_queue *q __attribute__ ((unused)) = NULL;
	int value __attribute__ ((unused));
	value = blk_queue_discard(q);
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BLK_QUEUE_DISCARD], [
	AC_MSG_CHECKING([whether blk_queue_discard() is available])
	ZFS_LINUX_TEST_RESULT([blk_queue_discard], [
	AC_MSG_RESULT(yes)
	],[
	ZFS_LINUX_TEST_ERROR([blk_queue_discard])
	])
	])

	dnl #
	-dnl # 4.8 - 4.x API,
	+dnl # 4.8 API,
	dnl # blk_queue_secure_erase()
	dnl #
	dnl # 2.6.36 - 4.7 API,
	dnl # blk_queue_secdiscard()
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLK_QUEUE_SECURE_ERASE], [
	ZFS_LINUX_TEST_SRC([blk_queue_secure_erase], [
	#include <linux/blkdev.h>
	],[
	struct request_queue *q __attribute__ ((unused)) = NULL;
	int value __attribute__ ((unused));
	value = blk_queue_secure_erase(q);
	])

	ZFS_LINUX_TEST_SRC([blk_queue_secdiscard], [
	#include <linux/blkdev.h>
	],[
	struct request_queue *q __attribute__ ((unused)) = NULL;
	int value __attribute__ ((unused));
	value = blk_queue_secdiscard(q);
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BLK_QUEUE_SECURE_ERASE], [
	AC_MSG_CHECKING([whether blk_queue_secure_erase() is available])
	ZFS_LINUX_TEST_RESULT([blk_queue_secure_erase], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_BLK_QUEUE_SECURE_ERASE, 1,
	[blk_queue_secure_erase() is available])
	],[
	AC_MSG_RESULT(no)

	AC_MSG_CHECKING([whether blk_queue_secdiscard() is available])
	ZFS_LINUX_TEST_RESULT([blk_queue_secdiscard], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_BLK_QUEUE_SECDISCARD, 1,
	[blk_queue_secdiscard() is available])
	],[
	ZFS_LINUX_TEST_ERROR([blk_queue_secure_erase])
	])
	])
	])

	dnl #
	dnl # 4.16 API change,
	dnl # Introduction of blk_queue_flag_set and blk_queue_flag_clear
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLK_QUEUE_FLAG_SET], [
	ZFS_LINUX_TEST_SRC([blk_queue_flag_set], [
	#include <linux/kernel.h>
	#include <linux/blkdev.h>
	],[
	struct request_queue *q = NULL;
	blk_queue_flag_set(0, q);
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BLK_QUEUE_FLAG_SET], [
	AC_MSG_CHECKING([whether blk_queue_flag_set() exists])
	ZFS_LINUX_TEST_RESULT([blk_queue_flag_set], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_BLK_QUEUE_FLAG_SET, 1,
	[blk_queue_flag_set() exists])
	],[
	AC_MSG_RESULT(no)
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLK_QUEUE_FLAG_CLEAR], [
	ZFS_LINUX_TEST_SRC([blk_queue_flag_clear], [
	#include <linux/kernel.h>
	#include <linux/blkdev.h>
	],[
	struct request_queue *q = NULL;
	blk_queue_flag_clear(0, q);
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BLK_QUEUE_FLAG_CLEAR], [
	AC_MSG_CHECKING([whether blk_queue_flag_clear() exists])
	ZFS_LINUX_TEST_RESULT([blk_queue_flag_clear], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_BLK_QUEUE_FLAG_CLEAR, 1,
	[blk_queue_flag_clear() exists])
	],[
	AC_MSG_RESULT(no)
	])
	])

	dnl #
	dnl # 2.6.36 API change,
	dnl # Added blk_queue_flush() interface, while the previous interface
	dnl # was available to all the new one is GPL-only. Thus in addition to
	dnl # detecting if this function is available we determine if it is
	dnl # GPL-only. If the GPL-only interface is there we implement our own
	dnl # compatibility function, otherwise we use the function. The hope
	dnl # is that long term this function will be opened up.
	dnl #
	dnl # 4.7 API change,
	dnl # Replace blk_queue_flush with blk_queue_write_cache
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLK_QUEUE_FLUSH], [
	ZFS_LINUX_TEST_SRC([blk_queue_flush], [
	#include <linux/blkdev.h>
	], [
	struct request_queue *q = NULL;
	(void) blk_queue_flush(q, REQ_FLUSH);
	], [$NO_UNUSED_BUT_SET_VARIABLE], [ZFS_META_LICENSE])

	ZFS_LINUX_TEST_SRC([blk_queue_write_cache], [
	#include <linux/kernel.h>
	#include <linux/blkdev.h>
	], [
	struct request_queue *q = NULL;
	blk_queue_write_cache(q, true, true);
	], [$NO_UNUSED_BUT_SET_VARIABLE], [ZFS_META_LICENSE])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BLK_QUEUE_FLUSH], [
	AC_MSG_CHECKING([whether blk_queue_flush() is available])
	ZFS_LINUX_TEST_RESULT([blk_queue_flush], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_BLK_QUEUE_FLUSH, 1,
	[blk_queue_flush() is available])

	AC_MSG_CHECKING([whether blk_queue_flush() is GPL-only])
	ZFS_LINUX_TEST_RESULT([blk_queue_flush_license], [
	AC_MSG_RESULT(no)
	],[
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_BLK_QUEUE_FLUSH_GPL_ONLY, 1,
	[blk_queue_flush() is GPL-only])
	])
	],[
	AC_MSG_RESULT(no)
	])

	dnl #
	dnl # 4.7 API change
	dnl # Replace blk_queue_flush with blk_queue_write_cache
	dnl #
	AC_MSG_CHECKING([whether blk_queue_write_cache() exists])
	ZFS_LINUX_TEST_RESULT([blk_queue_write_cache], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_BLK_QUEUE_WRITE_CACHE, 1,
	[blk_queue_write_cache() exists])

	AC_MSG_CHECKING([whether blk_queue_write_cache() is GPL-only])
	ZFS_LINUX_TEST_RESULT([blk_queue_write_cache_license], [
	AC_MSG_RESULT(no)
	],[
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_BLK_QUEUE_WRITE_CACHE_GPL_ONLY, 1,
	[blk_queue_write_cache() is GPL-only])
	])
	],[
	AC_MSG_RESULT(no)
	])
	])

	dnl #
	dnl # 2.6.34 API change
	dnl # blk_queue_max_hw_sectors() replaces blk_queue_max_sectors().
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLK_QUEUE_MAX_HW_SECTORS], [
	ZFS_LINUX_TEST_SRC([blk_queue_max_hw_sectors], [
	#include <linux/blkdev.h>
	], [
	struct request_queue *q = NULL;
	(void) blk_queue_max_hw_sectors(q, BLK_SAFE_MAX_SECTORS);
	], [$NO_UNUSED_BUT_SET_VARIABLE])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BLK_QUEUE_MAX_HW_SECTORS], [
	AC_MSG_CHECKING([whether blk_queue_max_hw_sectors() is available])
	ZFS_LINUX_TEST_RESULT([blk_queue_max_hw_sectors], [
	AC_MSG_RESULT(yes)
	],[
	ZFS_LINUX_TEST_ERROR([blk_queue_max_hw_sectors])
	])
	])

	dnl #
	dnl # 2.6.34 API change
	dnl # blk_queue_max_segments() consolidates blk_queue_max_hw_segments()
	dnl # and blk_queue_max_phys_segments().
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLK_QUEUE_MAX_SEGMENTS], [
	ZFS_LINUX_TEST_SRC([blk_queue_max_segments], [
	#include <linux/blkdev.h>
	], [
	struct request_queue *q = NULL;
	(void) blk_queue_max_segments(q, BLK_MAX_SEGMENTS);
	], [$NO_UNUSED_BUT_SET_VARIABLE])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BLK_QUEUE_MAX_SEGMENTS], [
	AC_MSG_CHECKING([whether blk_queue_max_segments() is available])
	ZFS_LINUX_TEST_RESULT([blk_queue_max_segments], [
	AC_MSG_RESULT(yes)
	], [
	ZFS_LINUX_TEST_ERROR([blk_queue_max_segments])
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLK_QUEUE], [
	ZFS_AC_KERNEL_SRC_BLK_QUEUE_PLUG
	ZFS_AC_KERNEL_SRC_BLK_QUEUE_BDI
	ZFS_AC_KERNEL_SRC_BLK_QUEUE_DISCARD
	ZFS_AC_KERNEL_SRC_BLK_QUEUE_SECURE_ERASE
	ZFS_AC_KERNEL_SRC_BLK_QUEUE_FLAG_SET
	ZFS_AC_KERNEL_SRC_BLK_QUEUE_FLAG_CLEAR
	ZFS_AC_KERNEL_SRC_BLK_QUEUE_FLUSH
	ZFS_AC_KERNEL_SRC_BLK_QUEUE_MAX_HW_SECTORS
	ZFS_AC_KERNEL_SRC_BLK_QUEUE_MAX_SEGMENTS
	])

	AC_DEFUN([ZFS_AC_KERNEL_BLK_QUEUE], [
	ZFS_AC_KERNEL_BLK_QUEUE_PLUG
	ZFS_AC_KERNEL_BLK_QUEUE_BDI
	ZFS_AC_KERNEL_BLK_QUEUE_DISCARD
	ZFS_AC_KERNEL_BLK_QUEUE_SECURE_ERASE
	ZFS_AC_KERNEL_BLK_QUEUE_FLAG_SET
	ZFS_AC_KERNEL_BLK_QUEUE_FLAG_CLEAR
	ZFS_AC_KERNEL_BLK_QUEUE_FLUSH
	ZFS_AC_KERNEL_BLK_QUEUE_MAX_HW_SECTORS
	ZFS_AC_KERNEL_BLK_QUEUE_MAX_SEGMENTS
	])
	diff --git a/sys/contrib/openzfs/config/kernel-block-device-operations.m4 b/sys/contrib/openzfs/config/kernel-block-device-operations.m4
	index 8e64ecca909b..a48618185bfb 100644
	--- a/sys/contrib/openzfs/config/kernel-block-device-operations.m4
	+++ b/sys/contrib/openzfs/config/kernel-block-device-operations.m4
	@@ -1,63 +1,95 @@
	dnl #
	dnl # 2.6.38 API change
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLOCK_DEVICE_OPERATIONS_CHECK_EVENTS], [
	ZFS_LINUX_TEST_SRC([block_device_operations_check_events], [
	#include <linux/blkdev.h>

	unsigned int blk_check_events(struct gendisk *disk,
	unsigned int clearing) { return (0); }

	static const struct block_device_operations
	bops __attribute__ ((unused)) = {
	.check_events = blk_check_events,
	};
	], [], [$NO_UNUSED_BUT_SET_VARIABLE])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BLOCK_DEVICE_OPERATIONS_CHECK_EVENTS], [
	AC_MSG_CHECKING([whether bops->check_events() exists])
	ZFS_LINUX_TEST_RESULT([block_device_operations_check_events], [
	AC_MSG_RESULT(yes)
	],[
	ZFS_LINUX_TEST_ERROR([bops->check_events()])
	])
	])

	dnl #
	dnl # 3.10.x API change
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLOCK_DEVICE_OPERATIONS_RELEASE_VOID], [
	ZFS_LINUX_TEST_SRC([block_device_operations_release_void], [
	#include <linux/blkdev.h>

	void blk_release(struct gendisk *g, fmode_t mode) { return; }

	static const struct block_device_operations
	bops __attribute__ ((unused)) = {
	.open = NULL,
	.release = blk_release,
	.ioctl = NULL,
	.compat_ioctl = NULL,
	};
	], [], [$NO_UNUSED_BUT_SET_VARIABLE])
	])

	AC_DEFUN([ZFS_AC_KERNEL_BLOCK_DEVICE_OPERATIONS_RELEASE_VOID], [
	AC_MSG_CHECKING([whether bops->release() is void])
	ZFS_LINUX_TEST_RESULT([block_device_operations_release_void], [
	AC_MSG_RESULT(yes)
	],[
	ZFS_LINUX_TEST_ERROR([bops->release()])
	])
	])

	+dnl #
	+dnl # 5.13 API change
	+dnl # block_device_operations->revalidate_disk() was removed
	+dnl #
	+AC_DEFUN([ZFS_AC_KERNEL_SRC_BLOCK_DEVICE_OPERATIONS_REVALIDATE_DISK], [
	+ ZFS_LINUX_TEST_SRC([block_device_operations_revalidate_disk], [
	+ #include <linux/blkdev.h>
	+
	+ int blk_revalidate_disk(struct gendisk *disk) {
	+ return(0);
	+ }
	+
	+ static const struct block_device_operations
	+ bops __attribute__ ((unused)) = {
	+ .revalidate_disk = blk_revalidate_disk,
	+ };
	+ ], [], [$NO_UNUSED_BUT_SET_VARIABLE])
	+])
	+
	+AC_DEFUN([ZFS_AC_KERNEL_BLOCK_DEVICE_OPERATIONS_REVALIDATE_DISK], [
	+ AC_MSG_CHECKING([whether bops->revalidate_disk() exists])
	+ ZFS_LINUX_TEST_RESULT([block_device_operations_revalidate_disk], [
	+ AC_DEFINE([HAVE_BLOCK_DEVICE_OPERATIONS_REVALIDATE_DISK], [1],
	+ [Define if revalidate_disk() in block_device_operations])
	+ AC_MSG_RESULT(yes)
	+ ],[
	+ AC_MSG_RESULT(no)
	+ ])
	+])
	+
	AC_DEFUN([ZFS_AC_KERNEL_SRC_BLOCK_DEVICE_OPERATIONS], [
	ZFS_AC_KERNEL_SRC_BLOCK_DEVICE_OPERATIONS_CHECK_EVENTS
	ZFS_AC_KERNEL_SRC_BLOCK_DEVICE_OPERATIONS_RELEASE_VOID
	+ ZFS_AC_KERNEL_SRC_BLOCK_DEVICE_OPERATIONS_REVALIDATE_DISK
	])

	AC_DEFUN([ZFS_AC_KERNEL_BLOCK_DEVICE_OPERATIONS], [
	ZFS_AC_KERNEL_BLOCK_DEVICE_OPERATIONS_CHECK_EVENTS
	ZFS_AC_KERNEL_BLOCK_DEVICE_OPERATIONS_RELEASE_VOID
	+ ZFS_AC_KERNEL_BLOCK_DEVICE_OPERATIONS_REVALIDATE_DISK
	])
	diff --git a/sys/contrib/openzfs/config/kernel-generic_fillattr.m4 b/sys/contrib/openzfs/config/kernel-generic_fillattr.m4
	index 50c8031305b3..0acd5d53103f 100644
	--- a/sys/contrib/openzfs/config/kernel-generic_fillattr.m4
	+++ b/sys/contrib/openzfs/config/kernel-generic_fillattr.m4
	@@ -1,28 +1,28 @@
	dnl #
	dnl # 5.12 API
	dnl #
	dnl # generic_fillattr in linux/fs.h now requires a struct user_namespace*
	dnl # as the first arg, to support idmapped mounts.
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_GENERIC_FILLATTR_USERNS], [
	ZFS_LINUX_TEST_SRC([generic_fillattr_userns], [
	#include <linux/fs.h>
	],[
	struct user_namespace *userns = NULL;
	struct inode *in = NULL;
	struct kstat *k = NULL;
	generic_fillattr(userns, in, k);
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_GENERIC_FILLATTR_USERNS], [
	- AC_MSG_CHECKING([whether generic_fillattr requres struct user_namespace*])
	+ AC_MSG_CHECKING([whether generic_fillattr requires struct user_namespace*])
	ZFS_LINUX_TEST_RESULT([generic_fillattr_userns], [
	AC_MSG_RESULT([yes])
	AC_DEFINE(HAVE_GENERIC_FILLATTR_USERNS, 1,
	[generic_fillattr requires struct user_namespace*])
	],[
	AC_MSG_RESULT([no])
	])
	])

	diff --git a/sys/contrib/openzfs/config/kernel-is_owner_or_cap.m4 b/sys/contrib/openzfs/config/kernel-is_owner_or_cap.m4
	index 3c3c6ad2240f..a90cf3da641d 100644
	--- a/sys/contrib/openzfs/config/kernel-is_owner_or_cap.m4
	+++ b/sys/contrib/openzfs/config/kernel-is_owner_or_cap.m4
	@@ -1,42 +1,46 @@
	dnl #
	dnl # 2.6.39 API change,
	dnl # The is_owner_or_cap() macro was renamed to inode_owner_or_capable(),
	dnl # This is used for permission checks in the xattr and file attribute call
	dnl # paths.
	dnl #
	+dnl # 5.12 API change,
	+dnl # inode_owner_or_capable() now takes struct user_namespace *
	+dnl # to support idmapped mounts
	+dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_INODE_OWNER_OR_CAPABLE], [
	ZFS_LINUX_TEST_SRC([inode_owner_or_capable], [
	#include <linux/fs.h>
	],[
	struct inode *ip = NULL;
	(void) inode_owner_or_capable(ip);
	])

	ZFS_LINUX_TEST_SRC([inode_owner_or_capable_idmapped], [
	#include <linux/fs.h>
	],[
	struct inode *ip = NULL;
	(void) inode_owner_or_capable(&init_user_ns, ip);
	])
	])

	AC_DEFUN([ZFS_AC_KERNEL_INODE_OWNER_OR_CAPABLE], [
	AC_MSG_CHECKING([whether inode_owner_or_capable() exists])
	ZFS_LINUX_TEST_RESULT([inode_owner_or_capable], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_INODE_OWNER_OR_CAPABLE, 1,
	[inode_owner_or_capable() exists])
	], [
	AC_MSG_RESULT(no)

	AC_MSG_CHECKING(
	[whether inode_owner_or_capable() takes user_ns])
	ZFS_LINUX_TEST_RESULT([inode_owner_or_capable_idmapped], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_INODE_OWNER_OR_CAPABLE_IDMAPPED, 1,
	[inode_owner_or_capable() takes user_ns])
	],[
	ZFS_LINUX_TEST_ERROR([capability])
	])
	])
	])
	diff --git a/sys/contrib/openzfs/config/kernel-rename.m4 b/sys/contrib/openzfs/config/kernel-rename.m4
	index 31d199f33bba..302db43f5748 100644
	--- a/sys/contrib/openzfs/config/kernel-rename.m4
	+++ b/sys/contrib/openzfs/config/kernel-rename.m4
	@@ -1,55 +1,56 @@
	AC_DEFUN([ZFS_AC_KERNEL_SRC_RENAME], [
	dnl #
	dnl # 4.9 API change,
	dnl # iops->rename2() merged into iops->rename(), and iops->rename() now wants
	dnl # flags.
	dnl #
	ZFS_LINUX_TEST_SRC([inode_operations_rename_flags], [
	#include <linux/fs.h>
	int rename_fn(struct inode sip, struct dentry sdp,
	struct inode tip, struct dentry tdp,
	unsigned int flags) { return 0; }

	static const struct inode_operations
	iops __attribute__ ((unused)) = {
	.rename = rename_fn,
	};
	],[])

	dnl #
	dnl # 5.12 API change,
	dnl #
	dnl # Linux 5.12 introduced passing struct user_namespace* as the first argument
	dnl # of the rename() and other inode_operations members.
	dnl #
	ZFS_LINUX_TEST_SRC([inode_operations_rename_userns], [
	#include <linux/fs.h>
	int rename_fn(struct user_namespace user_ns, struct inode sip,
	struct dentry sdp, struct inode tip, struct dentry *tdp,
	unsigned int flags) { return 0; }

	static const struct inode_operations
	iops __attribute__ ((unused)) = {
	.rename = rename_fn,
	};
	],[])
	])

	AC_DEFUN([ZFS_AC_KERNEL_RENAME], [
	AC_MSG_CHECKING([whether iops->rename() takes struct user_namespace*])
	ZFS_LINUX_TEST_RESULT([inode_operations_rename_userns], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_IOPS_RENAME_USERNS, 1,
	[iops->rename() takes struct user_namespace*])
	],[
	AC_MSG_RESULT(no)

	+ AC_MSG_CHECKING([whether iop->rename() wants flags])
	ZFS_LINUX_TEST_RESULT([inode_operations_rename_flags], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_RENAME_WANTS_FLAGS, 1,
	[iops->rename() wants flags])
	],[
	AC_MSG_RESULT(no)
	])
	])
	])
	diff --git a/sys/contrib/openzfs/config/kernel-siginfo.m4 b/sys/contrib/openzfs/config/kernel-siginfo.m4
	new file mode 100644
	index 000000000000..6ddb0dcc37d2
	--- /dev/null
	+++ b/sys/contrib/openzfs/config/kernel-siginfo.m4
	@@ -0,0 +1,21 @@
	+dnl #
	+dnl # 4.20 API change
	+dnl # Added kernel_siginfo_t
	+dnl #
	+AC_DEFUN([ZFS_AC_KERNEL_SRC_SIGINFO], [
	+ ZFS_LINUX_TEST_SRC([siginfo], [
	+ #include <linux/signal_types.h>
	+ ],[
	+ kernel_siginfo_t info __attribute__ ((unused));
	+ ])
	+])
	+
	+AC_DEFUN([ZFS_AC_KERNEL_SIGINFO], [
	+ AC_MSG_CHECKING([whether kernel_siginfo_t tyepedef exists])
	+ ZFS_LINUX_TEST_RESULT([siginfo], [
	+ AC_MSG_RESULT(yes)
	+ AC_DEFINE(HAVE_SIGINFO, 1, [kernel_siginfo_t exists])
	+ ],[
	+ AC_MSG_RESULT(no)
	+ ])
	+])
	diff --git a/sys/contrib/openzfs/config/kernel-signal-stop.m4 b/sys/contrib/openzfs/config/kernel-signal-stop.m4
	new file mode 100644
	index 000000000000..6cb86e7c4cde
	--- /dev/null
	+++ b/sys/contrib/openzfs/config/kernel-signal-stop.m4
	@@ -0,0 +1,21 @@
	+dnl #
	+dnl # 4.4 API change
	+dnl # Added kernel_signal_stop
	+dnl #
	+AC_DEFUN([ZFS_AC_KERNEL_SRC_SIGNAL_STOP], [
	+ ZFS_LINUX_TEST_SRC([signal_stop], [
	+ #include <linux/sched/signal.h>
	+ ],[
	+ kernel_signal_stop();
	+ ])
	+])
	+
	+AC_DEFUN([ZFS_AC_KERNEL_SIGNAL_STOP], [
	+ AC_MSG_CHECKING([whether signal_stop() exists])
	+ ZFS_LINUX_TEST_RESULT([signal_stop], [
	+ AC_MSG_RESULT(yes)
	+ AC_DEFINE(HAVE_SIGNAL_STOP, 1, [signal_stop() exists])
	+ ],[
	+ AC_MSG_RESULT(no)
	+ ])
	+])
	diff --git a/sys/contrib/openzfs/config/kernel-special-state.m4 b/sys/contrib/openzfs/config/kernel-special-state.m4
	new file mode 100644
	index 000000000000..aa60aabebc43
	--- /dev/null
	+++ b/sys/contrib/openzfs/config/kernel-special-state.m4
	@@ -0,0 +1,21 @@
	+dnl #
	+dnl # 4.17 API change
	+dnl # Added set_special_state() function
	+dnl #
	+AC_DEFUN([ZFS_AC_KERNEL_SRC_SET_SPECIAL_STATE], [
	+ ZFS_LINUX_TEST_SRC([set_special_state], [
	+ #include <linux/sched.h>
	+ ],[
	+ set_special_state(TASK_STOPPED);
	+ ])
	+])
	+
	+AC_DEFUN([ZFS_AC_KERNEL_SET_SPECIAL_STATE], [
	+ AC_MSG_CHECKING([whether set_special_state() exists])
	+ ZFS_LINUX_TEST_RESULT([set_special_state], [
	+ AC_MSG_RESULT(yes)
	+ AC_DEFINE(HAVE_SET_SPECIAL_STATE, 1, [set_special_state() exists])
	+ ],[
	+ AC_MSG_RESULT(no)
	+ ])
	+])
	diff --git a/sys/contrib/openzfs/config/kernel-tmpfile.m4 b/sys/contrib/openzfs/config/kernel-tmpfile.m4
	index f510bfe6ba03..45c2e6ceea52 100644
	--- a/sys/contrib/openzfs/config/kernel-tmpfile.m4
	+++ b/sys/contrib/openzfs/config/kernel-tmpfile.m4
	@@ -1,25 +1,45 @@
	dnl #
	dnl # 3.11 API change
	dnl # Add support for i_op->tmpfile
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_SRC_TMPFILE], [
	- ZFS_LINUX_TEST_SRC([inode_operations_tmpfile], [
	+ dnl #
	+ dnl # 5.11 API change
	+ dnl # add support for userns parameter to tmpfile
	+ dnl #
	+ ZFS_LINUX_TEST_SRC([inode_operations_tmpfile_userns], [
	#include <linux/fs.h>
	- int tmpfile(struct inode inode, struct dentry dentry,
	+ int tmpfile(struct user_namespace *userns,
	+ struct inode inode, struct dentry dentry,
	umode_t mode) { return 0; }
	static struct inode_operations
	iops __attribute__ ((unused)) = {
	.tmpfile = tmpfile,
	};
	],[])
	+ ZFS_LINUX_TEST_SRC([inode_operations_tmpfile], [
	+ #include <linux/fs.h>
	+ int tmpfile(struct inode inode, struct dentry dentry,
	+ umode_t mode) { return 0; }
	+ static struct inode_operations
	+ iops __attribute__ ((unused)) = {
	+ .tmpfile = tmpfile,
	+ };
	+ ],[])
	])

	AC_DEFUN([ZFS_AC_KERNEL_TMPFILE], [
	AC_MSG_CHECKING([whether i_op->tmpfile() exists])
	- ZFS_LINUX_TEST_RESULT([inode_operations_tmpfile], [
	+ ZFS_LINUX_TEST_RESULT([inode_operations_tmpfile_userns], [
	AC_MSG_RESULT(yes)
	AC_DEFINE(HAVE_TMPFILE, 1, [i_op->tmpfile() exists])
	+ AC_DEFINE(HAVE_TMPFILE_USERNS, 1, [i_op->tmpfile() has userns])
	],[
	- AC_MSG_RESULT(no)
	+ ZFS_LINUX_TEST_RESULT([inode_operations_tmpfile], [
	+ AC_MSG_RESULT(yes)
	+ AC_DEFINE(HAVE_TMPFILE, 1, [i_op->tmpfile() exists])
	+ ],[
	+ AC_MSG_RESULT(no)
	+ ])
	])
	])
	diff --git a/sys/contrib/openzfs/config/kernel.m4 b/sys/contrib/openzfs/config/kernel.m4
	index dfb6165d879d..7196e66ca28a 100644
	--- a/sys/contrib/openzfs/config/kernel.m4
	+++ b/sys/contrib/openzfs/config/kernel.m4
	@@ -1,881 +1,887 @@
	dnl #
	dnl # Default ZFS kernel configuration
	dnl #
	AC_DEFUN([ZFS_AC_CONFIG_KERNEL], [
	AM_COND_IF([BUILD_LINUX], [
	dnl # Setup the kernel build environment.
	ZFS_AC_KERNEL
	ZFS_AC_QAT

	dnl # Sanity checks for module building and CONFIG_* defines
	ZFS_AC_KERNEL_TEST_MODULE
	ZFS_AC_KERNEL_CONFIG_DEFINED

	dnl # Sequential ZFS_LINUX_TRY_COMPILE tests
	ZFS_AC_KERNEL_FPU_HEADER
	ZFS_AC_KERNEL_OBJTOOL_HEADER
	ZFS_AC_KERNEL_WAIT_QUEUE_ENTRY_T
	ZFS_AC_KERNEL_MISC_MINOR
	ZFS_AC_KERNEL_DECLARE_EVENT_CLASS

	dnl # Parallel ZFS_LINUX_TEST_SRC / ZFS_LINUX_TEST_RESULT tests
	ZFS_AC_KERNEL_TEST_SRC
	ZFS_AC_KERNEL_TEST_RESULT

	AS_IF([test "$LINUX_OBJ" != "$LINUX"], [
	KERNEL_MAKE="$KERNEL_MAKE O=$LINUX_OBJ"
	])

	AC_SUBST(KERNEL_MAKE)
	])
	])

	dnl #
	dnl # Generate and compile all of the kernel API test cases to determine
	dnl # which interfaces are available. By invoking the kernel build system
	dnl # only once the compilation can be done in parallel significantly
	dnl # speeding up the process.
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_TEST_SRC], [
	ZFS_AC_KERNEL_SRC_OBJTOOL
	ZFS_AC_KERNEL_SRC_GLOBAL_PAGE_STATE
	ZFS_AC_KERNEL_SRC_ACCESS_OK_TYPE
	ZFS_AC_KERNEL_SRC_PDE_DATA
	ZFS_AC_KERNEL_SRC_FALLOCATE
	ZFS_AC_KERNEL_SRC_2ARGS_ZLIB_DEFLATE_WORKSPACESIZE
	ZFS_AC_KERNEL_SRC_RWSEM
	ZFS_AC_KERNEL_SRC_SCHED
	ZFS_AC_KERNEL_SRC_USLEEP_RANGE
	ZFS_AC_KERNEL_SRC_KMEM_CACHE
	ZFS_AC_KERNEL_SRC_KVMALLOC
	ZFS_AC_KERNEL_SRC_VMALLOC_PAGE_KERNEL
	ZFS_AC_KERNEL_SRC_WAIT
	ZFS_AC_KERNEL_SRC_INODE_TIMES
	ZFS_AC_KERNEL_SRC_INODE_LOCK
	ZFS_AC_KERNEL_SRC_GROUP_INFO_GID
	ZFS_AC_KERNEL_SRC_RW
	ZFS_AC_KERNEL_SRC_TIMER_SETUP
	ZFS_AC_KERNEL_SRC_SUPER_USER_NS
	ZFS_AC_KERNEL_SRC_PROC_OPERATIONS
	ZFS_AC_KERNEL_SRC_BLOCK_DEVICE_OPERATIONS
	ZFS_AC_KERNEL_SRC_BIO
	ZFS_AC_KERNEL_SRC_BLKDEV
	ZFS_AC_KERNEL_SRC_BLK_QUEUE
	ZFS_AC_KERNEL_SRC_REVALIDATE_DISK
	ZFS_AC_KERNEL_SRC_GET_DISK_RO
	ZFS_AC_KERNEL_SRC_GENERIC_READLINK_GLOBAL
	ZFS_AC_KERNEL_SRC_DISCARD_GRANULARITY
	ZFS_AC_KERNEL_SRC_INODE_OWNER_OR_CAPABLE
	ZFS_AC_KERNEL_SRC_XATTR
	ZFS_AC_KERNEL_SRC_ACL
	ZFS_AC_KERNEL_SRC_INODE_GETATTR
	ZFS_AC_KERNEL_SRC_INODE_SET_FLAGS
	ZFS_AC_KERNEL_SRC_INODE_SET_IVERSION
	ZFS_AC_KERNEL_SRC_SHOW_OPTIONS
	ZFS_AC_KERNEL_SRC_FILE_INODE
	ZFS_AC_KERNEL_SRC_FILE_DENTRY
	ZFS_AC_KERNEL_SRC_FSYNC
	ZFS_AC_KERNEL_SRC_AIO_FSYNC
	ZFS_AC_KERNEL_SRC_EVICT_INODE
	ZFS_AC_KERNEL_SRC_DIRTY_INODE
	ZFS_AC_KERNEL_SRC_SHRINKER
	ZFS_AC_KERNEL_SRC_MKDIR
	ZFS_AC_KERNEL_SRC_LOOKUP_FLAGS
	ZFS_AC_KERNEL_SRC_CREATE
	ZFS_AC_KERNEL_SRC_GET_LINK
	ZFS_AC_KERNEL_SRC_PUT_LINK
	ZFS_AC_KERNEL_SRC_TMPFILE
	ZFS_AC_KERNEL_SRC_AUTOMOUNT
	ZFS_AC_KERNEL_SRC_ENCODE_FH_WITH_INODE
	ZFS_AC_KERNEL_SRC_COMMIT_METADATA
	ZFS_AC_KERNEL_SRC_CLEAR_INODE
	ZFS_AC_KERNEL_SRC_SETATTR_PREPARE
	ZFS_AC_KERNEL_SRC_INSERT_INODE_LOCKED
	ZFS_AC_KERNEL_SRC_DENTRY
	ZFS_AC_KERNEL_SRC_TRUNCATE_SETSIZE
	ZFS_AC_KERNEL_SRC_SECURITY_INODE
	ZFS_AC_KERNEL_SRC_FST_MOUNT
	ZFS_AC_KERNEL_SRC_BDI
	ZFS_AC_KERNEL_SRC_SET_NLINK
	ZFS_AC_KERNEL_SRC_SGET
	ZFS_AC_KERNEL_SRC_LSEEK_EXECUTE
	ZFS_AC_KERNEL_SRC_VFS_GETATTR
	ZFS_AC_KERNEL_SRC_VFS_FSYNC_2ARGS
	ZFS_AC_KERNEL_SRC_VFS_ITERATE
	ZFS_AC_KERNEL_SRC_VFS_DIRECT_IO
	ZFS_AC_KERNEL_SRC_VFS_RW_ITERATE
	ZFS_AC_KERNEL_SRC_VFS_GENERIC_WRITE_CHECKS
	ZFS_AC_KERNEL_SRC_VFS_IOV_ITER
	ZFS_AC_KERNEL_SRC_KMAP_ATOMIC_ARGS
	ZFS_AC_KERNEL_SRC_FOLLOW_DOWN_ONE
	ZFS_AC_KERNEL_SRC_MAKE_REQUEST_FN
	ZFS_AC_KERNEL_SRC_GENERIC_IO_ACCT
	ZFS_AC_KERNEL_SRC_FPU
	ZFS_AC_KERNEL_SRC_FMODE_T
	ZFS_AC_KERNEL_SRC_KUIDGID_T
	ZFS_AC_KERNEL_SRC_KUID_HELPERS
	ZFS_AC_KERNEL_SRC_MODULE_PARAM_CALL_CONST
	ZFS_AC_KERNEL_SRC_RENAME
	ZFS_AC_KERNEL_SRC_CURRENT_TIME
	ZFS_AC_KERNEL_SRC_USERNS_CAPABILITIES
	ZFS_AC_KERNEL_SRC_IN_COMPAT_SYSCALL
	ZFS_AC_KERNEL_SRC_KTIME
	ZFS_AC_KERNEL_SRC_TOTALRAM_PAGES_FUNC
	ZFS_AC_KERNEL_SRC_TOTALHIGH_PAGES
	ZFS_AC_KERNEL_SRC_KSTRTOUL
	ZFS_AC_KERNEL_SRC_PERCPU
	ZFS_AC_KERNEL_SRC_CPU_HOTPLUG
	ZFS_AC_KERNEL_SRC_GENERIC_FILLATTR_USERNS
	ZFS_AC_KERNEL_SRC_MKNOD
	ZFS_AC_KERNEL_SRC_SYMLINK
	ZFS_AC_KERNEL_SRC_BIO_MAX_SEGS
	+ ZFS_AC_KERNEL_SRC_SIGNAL_STOP
	+ ZFS_AC_KERNEL_SRC_SIGINFO
	+ ZFS_AC_KERNEL_SRC_SET_SPECIAL_STATE

	AC_MSG_CHECKING([for available kernel interfaces])
	ZFS_LINUX_TEST_COMPILE_ALL([kabi])
	AC_MSG_RESULT([done])
	])

	dnl #
	dnl # Check results of kernel interface tests.
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_TEST_RESULT], [
	ZFS_AC_KERNEL_ACCESS_OK_TYPE
	ZFS_AC_KERNEL_GLOBAL_PAGE_STATE
	ZFS_AC_KERNEL_OBJTOOL
	ZFS_AC_KERNEL_PDE_DATA
	ZFS_AC_KERNEL_FALLOCATE
	ZFS_AC_KERNEL_2ARGS_ZLIB_DEFLATE_WORKSPACESIZE
	ZFS_AC_KERNEL_RWSEM
	ZFS_AC_KERNEL_SCHED
	ZFS_AC_KERNEL_USLEEP_RANGE
	ZFS_AC_KERNEL_KMEM_CACHE
	ZFS_AC_KERNEL_KVMALLOC
	ZFS_AC_KERNEL_VMALLOC_PAGE_KERNEL
	ZFS_AC_KERNEL_WAIT
	ZFS_AC_KERNEL_INODE_TIMES
	ZFS_AC_KERNEL_INODE_LOCK
	ZFS_AC_KERNEL_GROUP_INFO_GID
	ZFS_AC_KERNEL_RW
	ZFS_AC_KERNEL_TIMER_SETUP
	ZFS_AC_KERNEL_SUPER_USER_NS
	ZFS_AC_KERNEL_PROC_OPERATIONS
	ZFS_AC_KERNEL_BLOCK_DEVICE_OPERATIONS
	ZFS_AC_KERNEL_BIO
	ZFS_AC_KERNEL_BLKDEV
	ZFS_AC_KERNEL_BLK_QUEUE
	ZFS_AC_KERNEL_REVALIDATE_DISK
	ZFS_AC_KERNEL_GET_DISK_RO
	ZFS_AC_KERNEL_GENERIC_READLINK_GLOBAL
	ZFS_AC_KERNEL_DISCARD_GRANULARITY
	ZFS_AC_KERNEL_INODE_OWNER_OR_CAPABLE
	ZFS_AC_KERNEL_XATTR
	ZFS_AC_KERNEL_ACL
	ZFS_AC_KERNEL_INODE_GETATTR
	ZFS_AC_KERNEL_INODE_SET_FLAGS
	ZFS_AC_KERNEL_INODE_SET_IVERSION
	ZFS_AC_KERNEL_SHOW_OPTIONS
	ZFS_AC_KERNEL_FILE_INODE
	ZFS_AC_KERNEL_FILE_DENTRY
	ZFS_AC_KERNEL_FSYNC
	ZFS_AC_KERNEL_AIO_FSYNC
	ZFS_AC_KERNEL_EVICT_INODE
	ZFS_AC_KERNEL_DIRTY_INODE
	ZFS_AC_KERNEL_SHRINKER
	ZFS_AC_KERNEL_MKDIR
	ZFS_AC_KERNEL_LOOKUP_FLAGS
	ZFS_AC_KERNEL_CREATE
	ZFS_AC_KERNEL_GET_LINK
	ZFS_AC_KERNEL_PUT_LINK
	ZFS_AC_KERNEL_TMPFILE
	ZFS_AC_KERNEL_AUTOMOUNT
	ZFS_AC_KERNEL_ENCODE_FH_WITH_INODE
	ZFS_AC_KERNEL_COMMIT_METADATA
	ZFS_AC_KERNEL_CLEAR_INODE
	ZFS_AC_KERNEL_SETATTR_PREPARE
	ZFS_AC_KERNEL_INSERT_INODE_LOCKED
	ZFS_AC_KERNEL_DENTRY
	ZFS_AC_KERNEL_TRUNCATE_SETSIZE
	ZFS_AC_KERNEL_SECURITY_INODE
	ZFS_AC_KERNEL_FST_MOUNT
	ZFS_AC_KERNEL_BDI
	ZFS_AC_KERNEL_SET_NLINK
	ZFS_AC_KERNEL_SGET
	ZFS_AC_KERNEL_LSEEK_EXECUTE
	ZFS_AC_KERNEL_VFS_GETATTR
	ZFS_AC_KERNEL_VFS_FSYNC_2ARGS
	ZFS_AC_KERNEL_VFS_ITERATE
	ZFS_AC_KERNEL_VFS_DIRECT_IO
	ZFS_AC_KERNEL_VFS_RW_ITERATE
	ZFS_AC_KERNEL_VFS_GENERIC_WRITE_CHECKS
	ZFS_AC_KERNEL_VFS_IOV_ITER
	ZFS_AC_KERNEL_KMAP_ATOMIC_ARGS
	ZFS_AC_KERNEL_FOLLOW_DOWN_ONE
	ZFS_AC_KERNEL_MAKE_REQUEST_FN
	ZFS_AC_KERNEL_GENERIC_IO_ACCT
	ZFS_AC_KERNEL_FPU
	ZFS_AC_KERNEL_FMODE_T
	ZFS_AC_KERNEL_KUIDGID_T
	ZFS_AC_KERNEL_KUID_HELPERS
	ZFS_AC_KERNEL_MODULE_PARAM_CALL_CONST
	ZFS_AC_KERNEL_RENAME
	ZFS_AC_KERNEL_CURRENT_TIME
	ZFS_AC_KERNEL_USERNS_CAPABILITIES
	ZFS_AC_KERNEL_IN_COMPAT_SYSCALL
	ZFS_AC_KERNEL_KTIME
	ZFS_AC_KERNEL_TOTALRAM_PAGES_FUNC
	ZFS_AC_KERNEL_TOTALHIGH_PAGES
	ZFS_AC_KERNEL_KSTRTOUL
	ZFS_AC_KERNEL_PERCPU
	ZFS_AC_KERNEL_CPU_HOTPLUG
	ZFS_AC_KERNEL_GENERIC_FILLATTR_USERNS
	ZFS_AC_KERNEL_MKNOD
	ZFS_AC_KERNEL_SYMLINK
	ZFS_AC_KERNEL_BIO_MAX_SEGS
	+ ZFS_AC_KERNEL_SIGNAL_STOP
	+ ZFS_AC_KERNEL_SIGINFO
	+ ZFS_AC_KERNEL_SET_SPECIAL_STATE
	])

	dnl #
	dnl # Detect name used for Module.symvers file in kernel
	dnl #
	AC_DEFUN([ZFS_AC_MODULE_SYMVERS], [
	modpost=$LINUX/scripts/Makefile.modpost
	AC_MSG_CHECKING([kernel file name for module symbols])
	AS_IF([test "x$enable_linux_builtin" != xyes -a -f "$modpost"], [
	AS_IF([grep -q Modules.symvers $modpost], [
	LINUX_SYMBOLS=Modules.symvers
	], [
	LINUX_SYMBOLS=Module.symvers
	])

	AS_IF([test ! -f "$LINUX_OBJ/$LINUX_SYMBOLS"], [
	AC_MSG_ERROR([
	*** Please make sure the kernel devel package for your distribution
	*** is installed. If you are building with a custom kernel, make sure
	*** the kernel is configured, built, and the '--with-linux=PATH'
	*** configure option refers to the location of the kernel source.
	])
	])
	], [
	LINUX_SYMBOLS=NONE
	])
	AC_MSG_RESULT($LINUX_SYMBOLS)
	AC_SUBST(LINUX_SYMBOLS)
	])

	dnl #
	dnl # Detect the kernel to be built against
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL], [
	AC_ARG_WITH([linux],
	AS_HELP_STRING([--with-linux=PATH],
	[Path to kernel source]),
	[kernelsrc="$withval"])

	AC_ARG_WITH(linux-obj,
	AS_HELP_STRING([--with-linux-obj=PATH],
	[Path to kernel build objects]),
	[kernelbuild="$withval"])

	AC_MSG_CHECKING([kernel source directory])
	AS_IF([test -z "$kernelsrc"], [
	AS_IF([test -e "/lib/modules/$(uname -r)/source"], [
	headersdir="/lib/modules/$(uname -r)/source"
	sourcelink=$(readlink -f "$headersdir")
	], [test -e "/lib/modules/$(uname -r)/build"], [
	headersdir="/lib/modules/$(uname -r)/build"
	sourcelink=$(readlink -f "$headersdir")
	], [
	sourcelink=$(ls -1d /usr/src/kernels/* \
	/usr/src/linux-* \
	2>/dev/null \| grep -v obj \| tail -1)
	])

	AS_IF([test -n "$sourcelink" && test -e ${sourcelink}], [
	kernelsrc=`readlink -f ${sourcelink}`
	], [
	kernelsrc="[Not found]"
	])
	], [
	AS_IF([test "$kernelsrc" = "NONE"], [
	kernsrcver=NONE
	])
	withlinux=yes
	])

	AC_MSG_RESULT([$kernelsrc])
	AS_IF([test ! -d "$kernelsrc"], [
	AC_MSG_ERROR([
	*** Please make sure the kernel devel package for your distribution
	*** is installed and then try again. If that fails, you can specify the
	*** location of the kernel source with the '--with-linux=PATH' option.])
	])

	AC_MSG_CHECKING([kernel build directory])
	AS_IF([test -z "$kernelbuild"], [
	AS_IF([test x$withlinux != xyes -a -e "/lib/modules/$(uname -r)/build"], [
	kernelbuild=`readlink -f /lib/modules/$(uname -r)/build`
	], [test -d ${kernelsrc}-obj/${target_cpu}/${target_cpu}], [
	kernelbuild=${kernelsrc}-obj/${target_cpu}/${target_cpu}
	], [test -d ${kernelsrc}-obj/${target_cpu}/default], [
	kernelbuild=${kernelsrc}-obj/${target_cpu}/default
	], [test -d `dirname ${kernelsrc}`/build-${target_cpu}], [
	kernelbuild=`dirname ${kernelsrc}`/build-${target_cpu}
	], [
	kernelbuild=${kernelsrc}
	])
	])
	AC_MSG_RESULT([$kernelbuild])

	AC_MSG_CHECKING([kernel source version])
	utsrelease1=$kernelbuild/include/linux/version.h
	utsrelease2=$kernelbuild/include/linux/utsrelease.h
	utsrelease3=$kernelbuild/include/generated/utsrelease.h
	AS_IF([test -r $utsrelease1 && fgrep -q UTS_RELEASE $utsrelease1], [
	utsrelease=$utsrelease1
	], [test -r $utsrelease2 && fgrep -q UTS_RELEASE $utsrelease2], [
	utsrelease=$utsrelease2
	], [test -r $utsrelease3 && fgrep -q UTS_RELEASE $utsrelease3], [
	utsrelease=$utsrelease3
	])

	AS_IF([test -n "$utsrelease"], [
	kernsrcver=$($AWK '/UTS_RELEASE/ { gsub(/"/, "", $[3]); print $[3] }' $utsrelease)
	AS_IF([test -z "$kernsrcver"], [
	AC_MSG_RESULT([Not found])
	AC_MSG_ERROR([
	*** Cannot determine kernel version.
	])
	])
	], [
	AC_MSG_RESULT([Not found])
	if test "x$enable_linux_builtin" != xyes; then
	AC_MSG_ERROR([
	*** Cannot find UTS_RELEASE definition.
	])
	else
	AC_MSG_ERROR([
	*** Cannot find UTS_RELEASE definition.
	*** Please run 'make prepare' inside the kernel source tree.])
	fi
	])

	AC_MSG_RESULT([$kernsrcver])

	AS_VERSION_COMPARE([$kernsrcver], [$ZFS_META_KVER_MIN], [
	AC_MSG_ERROR([
	*** Cannot build against kernel version $kernsrcver.
	*** The minimum supported kernel version is $ZFS_META_KVER_MIN.
	])
	])

	LINUX=${kernelsrc}
	LINUX_OBJ=${kernelbuild}
	LINUX_VERSION=${kernsrcver}

	AC_SUBST(LINUX)
	AC_SUBST(LINUX_OBJ)
	AC_SUBST(LINUX_VERSION)

	ZFS_AC_MODULE_SYMVERS
	])

	dnl #
	dnl # Detect the QAT module to be built against, QAT provides hardware
	dnl # acceleration for data compression:
	dnl #
	dnl # https://01.org/intel-quickassist-technology
	dnl #
	dnl # 1) Download and install QAT driver from the above link
	dnl # 2) Start QAT driver in your system:
	dnl # service qat_service start
	dnl # 3) Enable QAT in ZFS, e.g.:
	dnl # ./configure --with-qat=<qat-driver-path>/QAT1.6
	dnl # make
	dnl # 4) Set GZIP compression in ZFS dataset:
	dnl # zfs set compression = gzip <dataset>
	dnl #
	dnl # Then the data written to this ZFS pool is compressed by QAT accelerator
	dnl # automatically, and de-compressed by QAT when read from the pool.
	dnl #
	dnl # 1) Get QAT hardware statistics with:
	dnl # cat /proc/icp_dh895xcc_dev/qat
	dnl # 2) To disable QAT:
	dnl # insmod zfs.ko zfs_qat_disable=1
	dnl #
	AC_DEFUN([ZFS_AC_QAT], [
	AC_ARG_WITH([qat],
	AS_HELP_STRING([--with-qat=PATH],
	[Path to qat source]),
	AS_IF([test "$withval" = "yes"],
	AC_MSG_ERROR([--with-qat=PATH requires a PATH]),
	[qatsrc="$withval"]))

	AC_ARG_WITH([qat-obj],
	AS_HELP_STRING([--with-qat-obj=PATH],
	[Path to qat build objects]),
	[qatbuild="$withval"])

	AS_IF([test ! -z "${qatsrc}"], [
	AC_MSG_CHECKING([qat source directory])
	AC_MSG_RESULT([$qatsrc])
	QAT_SRC="${qatsrc}/quickassist"
	AS_IF([ test ! -e "$QAT_SRC/include/cpa.h"], [
	AC_MSG_ERROR([
	*** Please make sure the qat driver package is installed
	*** and specify the location of the qat source with the
	*** '--with-qat=PATH' option then try again. Failed to
	*** find cpa.h in:
	${QAT_SRC}/include])
	])
	])

	AS_IF([test ! -z "${qatsrc}"], [
	AC_MSG_CHECKING([qat build directory])
	AS_IF([test -z "$qatbuild"], [
	qatbuild="${qatsrc}/build"
	])

	AC_MSG_RESULT([$qatbuild])
	QAT_OBJ=${qatbuild}
	AS_IF([ ! test -e "$QAT_OBJ/icp_qa_al.ko" && ! test -e "$QAT_OBJ/qat_api.ko"], [
	AC_MSG_ERROR([
	*** Please make sure the qat driver is installed then try again.
	*** Failed to find icp_qa_al.ko or qat_api.ko in:
	$QAT_OBJ])
	])

	AC_SUBST(QAT_SRC)
	AC_SUBST(QAT_OBJ)

	AC_DEFINE(HAVE_QAT, 1,
	[qat is enabled and existed])
	])

	dnl #
	dnl # Detect the name used for the QAT Module.symvers file.
	dnl #
	AS_IF([test ! -z "${qatsrc}"], [
	AC_MSG_CHECKING([qat file for module symbols])
	QAT_SYMBOLS=$QAT_SRC/lookaside/access_layer/src/Module.symvers

	AS_IF([test -r $QAT_SYMBOLS], [
	AC_MSG_RESULT([$QAT_SYMBOLS])
	AC_SUBST(QAT_SYMBOLS)
	],[
	AC_MSG_ERROR([
	*** Please make sure the qat driver is installed then try again.
	*** Failed to find Module.symvers in:
	$QAT_SYMBOLS
	])
	])
	])
	])

	dnl #
	dnl # Basic toolchain sanity check.
	dnl #
	AC_DEFUN([ZFS_AC_KERNEL_TEST_MODULE], [
	AC_MSG_CHECKING([whether modules can be built])
	ZFS_LINUX_TRY_COMPILE([], [], [
	AC_MSG_RESULT([yes])
	],[
	AC_MSG_RESULT([no])
	if test "x$enable_linux_builtin" != xyes; then
	AC_MSG_ERROR([
	*** Unable to build an empty module.
	])
	else
	AC_MSG_ERROR([
	*** Unable to build an empty module.
	*** Please run 'make scripts' inside the kernel source tree.])
	fi
	])
	])

	dnl #
	dnl # ZFS_LINUX_CONFTEST_H
	dnl #
	AC_DEFUN([ZFS_LINUX_CONFTEST_H], [
	test -d build/$2 \|\| mkdir -p build/$2
	cat - <<_ACEOF >build/$2/$2.h
	$1
	_ACEOF
	])

	dnl #
	dnl # ZFS_LINUX_CONFTEST_C
	dnl #
	AC_DEFUN([ZFS_LINUX_CONFTEST_C], [
	test -d build/$2 \|\| mkdir -p build/$2
	cat confdefs.h - <<_ACEOF >build/$2/$2.c
	$1
	_ACEOF
	])

	dnl #
	dnl # ZFS_LINUX_CONFTEST_MAKEFILE
	dnl #
	dnl # $1 - test case name
	dnl # $2 - add to top-level Makefile
	dnl # $3 - additional build flags
	dnl #
	AC_DEFUN([ZFS_LINUX_CONFTEST_MAKEFILE], [
	test -d build \|\| mkdir -p build
	test -d build/$1 \|\| mkdir -p build/$1

	file=build/$1/Makefile

	dnl # Example command line to manually build source.
	cat - <<_ACEOF >$file
	# Example command line to manually build source
	# make modules -C $LINUX_OBJ $ARCH_UM M=$PWD/build/$1

	ccflags-y := -Werror $FRAME_LARGER_THAN
	_ACEOF

	dnl # Additional custom CFLAGS as requested.
	m4_ifval($3, [echo "ccflags-y += $3" >>$file], [])

	dnl # Test case source
	echo "obj-m := $1.o" >>$file

	AS_IF([test "x$2" = "xyes"], [echo "obj-m += $1/" >>build/Makefile], [])
	])

	dnl #
	dnl # ZFS_LINUX_TEST_PROGRAM(C)([PROLOGUE], [BODY])
	dnl #
	m4_define([ZFS_LINUX_TEST_PROGRAM], [
	#include <linux/module.h>
	$1

	int
	main (void)
	{
	$2
	;
	return 0;
	}

	MODULE_DESCRIPTION("conftest");
	MODULE_AUTHOR(ZFS_META_AUTHOR);
	MODULE_VERSION(ZFS_META_VERSION "-" ZFS_META_RELEASE);
	MODULE_LICENSE($3);
	])

	dnl #
	dnl # ZFS_LINUX_TEST_REMOVE
	dnl #
	dnl # Removes the specified test source and results.
	dnl #
	AC_DEFUN([ZFS_LINUX_TEST_REMOVE], [
	test -d build/$1 && rm -Rf build/$1
	test -f build/Makefile && sed '/$1/d' build/Makefile
	])

	dnl #
	dnl # ZFS_LINUX_COMPILE
	dnl #
	dnl # $1 - build dir
	dnl # $2 - test command
	dnl # $3 - pass command
	dnl # $4 - fail command
	dnl # $5 - set KBUILD_MODPOST_NOFINAL='yes'
	dnl # $6 - set KBUILD_MODPOST_WARN='yes'
	dnl #
	dnl # Used internally by ZFS_LINUX_TEST_{COMPILE,MODPOST}
	dnl #
	AC_DEFUN([ZFS_LINUX_COMPILE], [
	AC_TRY_COMMAND([
	KBUILD_MODPOST_NOFINAL="$5" KBUILD_MODPOST_WARN="$6"
	make modules -k -j$TEST_JOBS -C $LINUX_OBJ $ARCH_UM
	M=$PWD/$1 >$1/build.log 2>&1])
	AS_IF([AC_TRY_COMMAND([$2])], [$3], [$4])
	])

	dnl #
	dnl # ZFS_LINUX_TEST_COMPILE
	dnl #
	dnl # Perform a full compile excluding the final modpost phase.
	dnl #
	AC_DEFUN([ZFS_LINUX_TEST_COMPILE], [
	ZFS_LINUX_COMPILE([$2], [test -f $2/build.log], [
	mv $2/Makefile $2/Makefile.compile.$1
	mv $2/build.log $2/build.log.$1
	],[
	AC_MSG_ERROR([
	*** Unable to compile test source to determine kernel interfaces.])
	], [yes], [])
	])

	dnl #
	dnl # ZFS_LINUX_TEST_MODPOST
	dnl #
	dnl # Perform a full compile including the modpost phase. This may
	dnl # be an incremental build if the objects have already been built.
	dnl #
	AC_DEFUN([ZFS_LINUX_TEST_MODPOST], [
	ZFS_LINUX_COMPILE([$2], [test -f $2/build.log], [
	mv $2/Makefile $2/Makefile.modpost.$1
	cat $2/build.log >>build/build.log.$1
	],[
	AC_MSG_ERROR([
	*** Unable to modpost test source to determine kernel interfaces.])
	], [], [yes])
	])

	dnl #
	dnl # Perform the compilation of the test cases in two phases.
	dnl #
	dnl # Phase 1) attempt to build the object files for all of the tests
	dnl # defined by the ZFS_LINUX_TEST_SRC macro. But do not
	dnl # perform the final modpost stage.
	dnl #
	dnl # Phase 2) disable all tests which failed the initial compilation,
	dnl # then invoke the final modpost step for the remaining tests.
	dnl #
	dnl # This allows us efficiently build the test cases in parallel while
	dnl # remaining resilient to build failures which are expected when
	dnl # detecting the available kernel interfaces.
	dnl #
	dnl # The maximum allowed parallelism can be controlled by setting the
	dnl # TEST_JOBS environment variable. Otherwise, it default to $(nproc).
	dnl #
	AC_DEFUN([ZFS_LINUX_TEST_COMPILE_ALL], [
	dnl # Phase 1 - Compilation only, final linking is skipped.
	ZFS_LINUX_TEST_COMPILE([$1], [build])

	dnl #
	dnl # Phase 2 - When building external modules disable test cases
	dnl # which failed to compile and invoke modpost to verify the
	dnl # final linking.
	dnl #
	dnl # Test names suffixed with '_license' call modpost independently
	dnl # to ensure that a single incompatibility does not result in the
	dnl # modpost phase exiting early. This check is not performed on
	dnl # every symbol since the majority are compatible and doing so
	dnl # would significantly slow down this phase.
	dnl #
	dnl # When configuring for builtin (--enable-linux-builtin)
	dnl # fake the linking step artificially create the expected .ko
	dnl # files for tests which did compile. This is required for
	dnl # kernels which do not have loadable module support or have
	dnl # not yet been built.
	dnl #
	AS_IF([test "x$enable_linux_builtin" = "xno"], [
	for dir in $(awk '/^obj-m/ { print [$]3 }' \
	build/Makefile.compile.$1); do
	name=${dir%/}
	AS_IF([test -f build/$name/$name.o], [
	AS_IF([test "${name##*_}" = "license"], [
	ZFS_LINUX_TEST_MODPOST([$1],
	[build/$name])
	echo "obj-n += $dir" >>build/Makefile
	], [
	echo "obj-m += $dir" >>build/Makefile
	])
	], [
	echo "obj-n += $dir" >>build/Makefile
	])
	done

	ZFS_LINUX_TEST_MODPOST([$1], [build])
	], [
	for dir in $(awk '/^obj-m/ { print [$]3 }' \
	build/Makefile.compile.$1); do
	name=${dir%/}
	AS_IF([test -f build/$name/$name.o], [
	touch build/$name/$name.ko
	])
	done
	])
	])

	dnl #
	dnl # ZFS_LINUX_TEST_SRC
	dnl #
	dnl # $1 - name
	dnl # $2 - global
	dnl # $3 - source
	dnl # $4 - extra cflags
	dnl # $5 - check license-compatibility
	dnl #
	dnl # Check if the test source is buildable at all and then if it is
	dnl # license compatible.
	dnl #
	dnl # N.B because all of the test cases are compiled in parallel they
	dnl # must never depend on the results of previous tests. Each test
	dnl # needs to be entirely independent.
	dnl #
	AC_DEFUN([ZFS_LINUX_TEST_SRC], [
	ZFS_LINUX_CONFTEST_C([ZFS_LINUX_TEST_PROGRAM([[$2]], [[$3]],
	[["Dual BSD/GPL"]])], [$1])
	ZFS_LINUX_CONFTEST_MAKEFILE([$1], [yes], [$4])

	AS_IF([ test -n "$5" ], [
	ZFS_LINUX_CONFTEST_C([ZFS_LINUX_TEST_PROGRAM(
	[[$2]], [[$3]], [[$5]])], [$1_license])
	ZFS_LINUX_CONFTEST_MAKEFILE([$1_license], [yes], [$4])
	])
	])

	dnl #
	dnl # ZFS_LINUX_TEST_RESULT
	dnl #
	dnl # $1 - name of a test source (ZFS_LINUX_TEST_SRC)
	dnl # $2 - run on success (valid .ko generated)
	dnl # $3 - run on failure (unable to compile)
	dnl #
	AC_DEFUN([ZFS_LINUX_TEST_RESULT], [
	AS_IF([test -d build/$1], [
	AS_IF([test -f build/$1/$1.ko], [$2], [$3])
	], [
	AC_MSG_ERROR([
	*** No matching source for the "$1" test, check that
	*** both the test source and result macros refer to the same name.
	])
	])
	])

	dnl #
	dnl # ZFS_LINUX_TEST_ERROR
	dnl #
	dnl # Generic error message which can be used when none of the expected
	dnl # kernel interfaces were detected.
	dnl #
	AC_DEFUN([ZFS_LINUX_TEST_ERROR], [
	AC_MSG_ERROR([
	*** None of the expected "$1" interfaces were detected.
	*** This may be because your kernel version is newer than what is
	*** supported, or you are using a patched custom kernel with
	*** incompatible modifications.
	***
	*** ZFS Version: $ZFS_META_ALIAS
	*** Compatible Kernels: $ZFS_META_KVER_MIN - $ZFS_META_KVER_MAX
	])
	])

	dnl #
	dnl # ZFS_LINUX_TEST_RESULT_SYMBOL
	dnl #
	dnl # Like ZFS_LINUX_TEST_RESULT except ZFS_CHECK_SYMBOL_EXPORT is called to
	dnl # verify symbol exports, unless --enable-linux-builtin was provided to
	dnl # configure.
	dnl #
	AC_DEFUN([ZFS_LINUX_TEST_RESULT_SYMBOL], [
	AS_IF([ ! test -f build/$1/$1.ko], [
	$5
	], [
	AS_IF([test "x$enable_linux_builtin" != "xyes"], [
	ZFS_CHECK_SYMBOL_EXPORT([$2], [$3], [$4], [$5])
	], [
	$4
	])
	])
	])

	dnl #
	dnl # ZFS_LINUX_COMPILE_IFELSE
	dnl #
	AC_DEFUN([ZFS_LINUX_COMPILE_IFELSE], [
	ZFS_LINUX_TEST_REMOVE([conftest])

	m4_ifvaln([$1], [ZFS_LINUX_CONFTEST_C([$1], [conftest])])
	m4_ifvaln([$5], [ZFS_LINUX_CONFTEST_H([$5], [conftest])],
	[ZFS_LINUX_CONFTEST_H([], [conftest])])

	ZFS_LINUX_CONFTEST_MAKEFILE([conftest], [no],
	[m4_ifvaln([$5], [-I$PWD/build/conftest], [])])
	ZFS_LINUX_COMPILE([build/conftest], [$2], [$3], [$4], [], [])
	])

	dnl #
	dnl # ZFS_LINUX_TRY_COMPILE
	dnl #
	dnl # $1 - global
	dnl # $2 - source
	dnl # $3 - run on success (valid .ko generated)
	dnl # $4 - run on failure (unable to compile)
	dnl #
	dnl # When configuring as builtin (--enable-linux-builtin) for kernels
	dnl # without loadable module support (CONFIG_MODULES=n) only the object
	dnl # file is created. See ZFS_LINUX_TEST_COMPILE_ALL for details.
	dnl #
	AC_DEFUN([ZFS_LINUX_TRY_COMPILE], [
	AS_IF([test "x$enable_linux_builtin" = "xyes"], [
	ZFS_LINUX_COMPILE_IFELSE(
	[ZFS_LINUX_TEST_PROGRAM([[$1]], [[$2]],
	[[ZFS_META_LICENSE]])],
	[test -f build/conftest/conftest.o], [$3], [$4])
	], [
	ZFS_LINUX_COMPILE_IFELSE(
	[ZFS_LINUX_TEST_PROGRAM([[$1]], [[$2]],
	[[ZFS_META_LICENSE]])],
	[test -f build/conftest/conftest.ko], [$3], [$4])
	])
	])

	dnl #
	dnl # ZFS_CHECK_SYMBOL_EXPORT
	dnl #
	dnl # Check if a symbol is exported on not by consulting the symbols
	dnl # file, or optionally the source code.
	dnl #
	AC_DEFUN([ZFS_CHECK_SYMBOL_EXPORT], [
	grep -q -E '[[[:space:]]]$1[[[:space:]]]' \
	$LINUX_OBJ/$LINUX_SYMBOLS 2>/dev/null
	rc=$?
	if test $rc -ne 0; then
	export=0
	for file in $2; do
	grep -q -E "EXPORT_SYMBOL.*($1)" \
	"$LINUX/$file" 2>/dev/null
	rc=$?
	if test $rc -eq 0; then
	export=1
	break;
	fi
	done
	if test $export -eq 0; then :
	$4
	else :
	$3
	fi
	else :
	$3
	fi
	])

	dnl #
	dnl # ZFS_LINUX_TRY_COMPILE_SYMBOL
	dnl #
	dnl # Like ZFS_LINUX_TRY_COMPILER except ZFS_CHECK_SYMBOL_EXPORT is called
	dnl # to verify symbol exports, unless --enable-linux-builtin was provided
	dnl # to configure.
	dnl #
	AC_DEFUN([ZFS_LINUX_TRY_COMPILE_SYMBOL], [
	ZFS_LINUX_TRY_COMPILE([$1], [$2], [rc=0], [rc=1])
	if test $rc -ne 0; then :
	$6
	else
	if test "x$enable_linux_builtin" != xyes; then
	ZFS_CHECK_SYMBOL_EXPORT([$3], [$4], [rc=0], [rc=1])
	fi
	if test $rc -ne 0; then :
	$6
	else :
	$5
	fi
	fi
	])

	dnl #
	dnl # ZFS_LINUX_TRY_COMPILE_HEADER
	dnl # like ZFS_LINUX_TRY_COMPILE, except the contents conftest.h are
	dnl # provided via the fifth parameter
	dnl #
	AC_DEFUN([ZFS_LINUX_TRY_COMPILE_HEADER], [
	ZFS_LINUX_COMPILE_IFELSE(
	[ZFS_LINUX_TEST_PROGRAM([[$1]], [[$2]], [[ZFS_META_LICENSE]])],
	[test -f build/conftest/conftest.ko],
	[$3], [$4], [$5])
	])
	diff --git a/sys/contrib/openzfs/config/zfs-build.m4 b/sys/contrib/openzfs/config/zfs-build.m4
	index cd5996c0424c..cee5c87e770c 100644
	--- a/sys/contrib/openzfs/config/zfs-build.m4
	+++ b/sys/contrib/openzfs/config/zfs-build.m4
	@@ -1,601 +1,607 @@
	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 #
	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])])

	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 $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 \| fgrep -qx $'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])
	])

	AC_DEFUN([ZFS_AC_CONFIG_ALWAYS], [
	AX_COUNT_CPUS([])
	AC_SUBST(CPU_COUNT)

	ZFS_AC_CONFIG_ALWAYS_CC_NO_UNUSED_BUT_SET_VARIABLE
	ZFS_AC_CONFIG_ALWAYS_CC_NO_BOOL_COMPARE
	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_CC_NO_OMIT_FRAME_POINTER
	ZFS_AC_CONFIG_ALWAYS_CC_NO_IPA_SRA
	ZFS_AC_CONFIG_ALWAYS_CC_ASAN
	ZFS_AC_CONFIG_ALWAYS_TOOLCHAIN_SIMD
	ZFS_AC_CONFIG_ALWAYS_SYSTEM
	ZFS_AC_CONFIG_ALWAYS_ARCH
	ZFS_AC_CONFIG_ALWAYS_PYTHON
	ZFS_AC_CONFIG_ALWAYS_PYZFS
	ZFS_AC_CONFIG_ALWAYS_SED
	ZFS_AC_CONFIG_ALWAYS_CPPCHECK
	])

	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)
	])

	case "$ZFS_CONFIG" in
	kernel) ZFS_AC_CONFIG_KERNEL ;;
	user) ZFS_AC_CONFIG_USER ;;
	all) ZFS_AC_CONFIG_USER
	ZFS_AC_CONFIG_KERNEL ;;
	srpm) ;;
	*)
	AC_MSG_RESULT([Error!])
	AC_MSG_ERROR([Bad value "$ZFS_CONFIG" for --with-config,
	user kernel\|user\|all\|srpm]) ;;
	esac

	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_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)"'
	])
	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_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)
	])

	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/toss-release ; then
	VENDOR=toss ;
	elif test -f /etc/fedora-release ; then
	VENDOR=fedora ;
	elif test -f /etc/redhat-release ; then
	VENDOR=redhat ;
	elif test -f /etc/gentoo-release ; then
	VENDOR=gentoo ;
	elif test -f /etc/arch-release ; then
	VENDOR=arch ;
	elif test -f /etc/SuSE-release ; then
	VENDOR=sles ;
	elif test -f /etc/slackware-version ; then
	VENDOR=slackware ;
	elif test -f /etc/lunar.release ; then
	VENDOR=lunar ;
	elif test -f /etc/lsb-release ; then
	VENDOR=ubuntu ;
	elif test -f /etc/debian_version ; then
	VENDOR=debian ;
	elif test -f /etc/alpine-release ; then
	VENDOR=alpine ;
	elif test -f /bin/freebsd-version ; then
	VENDOR=freebsd ;
	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
	toss) DEFAULT_PACKAGE=rpm ;;
	redhat) DEFAULT_PACKAGE=rpm ;;
	fedora) DEFAULT_PACKAGE=rpm ;;
	gentoo) DEFAULT_PACKAGE=tgz ;;
	alpine) DEFAULT_PACKAGE=tgz ;;
	arch) DEFAULT_PACKAGE=tgz ;;
	sles) DEFAULT_PACKAGE=rpm ;;
	slackware) DEFAULT_PACKAGE=tgz ;;
	lunar) DEFAULT_PACKAGE=tgz ;;
	ubuntu) DEFAULT_PACKAGE=deb ;;
	debian) DEFAULT_PACKAGE=deb ;;
	freebsd) DEFAULT_PACKAGE=pkg ;;
	*) 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 init script type and shell])
	case "$VENDOR" in
	toss) DEFAULT_INIT_SCRIPT=redhat ;;
	redhat) DEFAULT_INIT_SCRIPT=redhat ;;
	fedora) DEFAULT_INIT_SCRIPT=fedora ;;
	gentoo) DEFAULT_INIT_SCRIPT=openrc ;;
	alpine) DEFAULT_INIT_SCRIPT=openrc ;;
	arch) DEFAULT_INIT_SCRIPT=lsb ;;
	sles) DEFAULT_INIT_SCRIPT=lsb ;;
	slackware) DEFAULT_INIT_SCRIPT=lsb ;;
	lunar) DEFAULT_INIT_SCRIPT=lunar ;;
	ubuntu) DEFAULT_INIT_SCRIPT=lsb ;;
	debian) DEFAULT_INIT_SCRIPT=lsb ;;
	freebsd) DEFAULT_INIT_SCRIPT=freebsd;;
	*) DEFAULT_INIT_SCRIPT=lsb ;;
	esac

	# On gentoo, it's possible that OpenRC isn't installed. Check if
	# /sbin/openrc-run exists, and if not, fall back to generic defaults.

	DEFAULT_INIT_SHELL="/bin/sh"
	AS_IF([test "$DEFAULT_INIT_SCRIPT" = "openrc"], [
	AS_IF([test -x "/sbin/openrc-run"],
	[DEFAULT_INIT_SHELL="/sbin/openrc-run"],
	[DEFAULT_INIT_SCRIPT=lsb])
	])

	AC_MSG_RESULT([$DEFAULT_INIT_SCRIPT:$DEFAULT_INIT_SHELL])
	AC_SUBST(DEFAULT_INIT_SCRIPT)
	AC_SUBST(DEFAULT_INIT_SHELL)

	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) initconfdir=/etc/conf.d ;;
	gentoo) initconfdir=/etc/conf.d ;;
	toss) initconfdir=/etc/sysconfig ;;
	redhat) initconfdir=/etc/sysconfig ;;
	fedora) initconfdir=/etc/sysconfig ;;
	sles) initconfdir=/etc/sysconfig ;;
	ubuntu) initconfdir=/etc/default ;;
	debian) initconfdir=/etc/default ;;
	freebsd) initconfdir=$sysconfdir/rc.conf.d;;
	*) 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)
	])

	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/sys/contrib/openzfs/contrib/bash_completion.d/.gitignore b/sys/contrib/openzfs/contrib/bash_completion.d/.gitignore
	new file mode 100644
	index 000000000000..0fd9cc63af2a
	--- /dev/null
	+++ b/sys/contrib/openzfs/contrib/bash_completion.d/.gitignore
	@@ -0,0 +1 @@
	+/zfs
	diff --git a/sys/contrib/openzfs/contrib/bash_completion.d/Makefile.am b/sys/contrib/openzfs/contrib/bash_completion.d/Makefile.am
	index 4f13af6b3c35..8fbe03688b48 100644
	--- a/sys/contrib/openzfs/contrib/bash_completion.d/Makefile.am
	+++ b/sys/contrib/openzfs/contrib/bash_completion.d/Makefile.am
	@@ -1,5 +1,8 @@
	+include $(top_srcdir)/config/Substfiles.am
	+
	bashcompletiondir = $(sysconfdir)/bash_completion.d

	noinst_DATA = zfs

	-EXTRA_DIST = $(noinst_DATA)
	+EXTRA_DIST += $(noinst_DATA)
	+SUBSTFILES += $(noinst_DATA)
	diff --git a/sys/contrib/openzfs/contrib/bash_completion.d/zfs b/sys/contrib/openzfs/contrib/bash_completion.d/zfs.in
	similarity index 98%
	rename from sys/contrib/openzfs/contrib/bash_completion.d/zfs
	rename to sys/contrib/openzfs/contrib/bash_completion.d/zfs.in
	index 094527340c80..8898fc735cd1 100644
	--- a/sys/contrib/openzfs/contrib/bash_completion.d/zfs
	+++ b/sys/contrib/openzfs/contrib/bash_completion.d/zfs.in
	@@ -1,481 +1,476 @@
	# Copyright (c) 2010-2016, Aneurin Price <aneurin.price@gmail.com>

	# Permission is hereby granted, free of charge, to any person
	# obtaining a copy of this software and associated documentation
	# files (the "Software"), to deal in the Software without
	# restriction, including without limitation the rights to use,
	# copy, modify, merge, publish, distribute, sublicense, and/or sell
	# copies of the Software, and to permit persons to whom the
	# Software is furnished to do so, subject to the following
	# conditions:

	# The above copyright notice and this permission notice shall be
	# included in all copies or substantial portions of the Software.

	# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
	# OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
	# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
	# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
	# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
	# OTHER DEALINGS IN THE SOFTWARE.

	-if [[ -w /dev/zfs ]]; then
	- __ZFS_CMD="zfs"
	- __ZPOOL_CMD="zpool"
	-else
	- __ZFS_CMD="sudo zfs"
	- __ZPOOL_CMD="sudo zpool"
	-fi
	+__ZFS_CMD="@sbindir@/zfs"
	+__ZPOOL_CMD="@sbindir@/zpool"

	# Disable bash's built-in hostname completion, as this makes it impossible to
	# provide completions containing an @-sign, which is necessary for completing
	# snapshot names. If bash_completion is in use, this will already be disabled
	# and replaced with better completions anyway.
	shopt -u hostcomplete

	__zfs_get_commands()
	{
	$__ZFS_CMD 2>&1 \| awk '/^\t[a-z]/ {print $1}' \| cut -f1 -d '\|' \| uniq
	}

	__zfs_get_properties()
	{
	$__ZFS_CMD get 2>&1 \| awk '$2 == "YES" \|\| $2 == "NO" {print $1}'; echo all name space
	}

	__zfs_get_editable_properties()
	{
	$__ZFS_CMD get 2>&1 \| awk '$2 == "YES" {print $1"="}'
	}

	__zfs_get_inheritable_properties()
	{
	$__ZFS_CMD get 2>&1 \| awk '$3 == "YES" {print $1}'
	}

	__zfs_list_datasets()
	{
	$__ZFS_CMD list -H -o name -s name -t filesystem,volume "$@"
	}

	__zfs_list_filesystems()
	{
	$__ZFS_CMD list -H -o name -s name -t filesystem
	}

	__zfs_match_snapshot()
	{
	local base_dataset=${cur%@*}
	if [[ $base_dataset != $cur ]]
	then
	$__ZFS_CMD list -H -o name -s name -t snapshot -d 1 $base_dataset
	else
	if [[ $cur != "" ]] && __zfs_list_datasets $cur &> /dev/null
	then
	$__ZFS_CMD list -H -o name -s name -t filesystem -r $cur \| tail -n +2
	# We output the base dataset name even though we might be
	# completing a command that can only take a snapshot, because it
	# prevents bash from considering the completion finished when it
	# ends in the bare @.
	echo $cur
	echo $cur@
	else
	local datasets=$(__zfs_list_datasets)
	# As above
	echo $datasets
	if [[ "$cur" == */ ]]
	then
	# If the current command ends with a slash, then the only way
	# it can be completed with a single tab press (ie. in this pass)
	# is if it has exactly one child, so that's the only time we
	# need to offer a suggestion with an @ appended.
	local num_children
	# This is actually off by one as zfs list includes the named
	# dataset in addition to its children
	num_children=$(__zfs_list_datasets -d 1 ${cur%/} 2> /dev/null \| wc -l)
	if [[ $num_children != 2 ]]
	then
	return 0
	fi
	fi
	echo "$datasets" \| awk '{print $1"@"}'
	fi
	fi
	}

	__zfs_match_snapshot_or_bookmark()
	{
	local base_dataset=${cur%[#@]*}
	if [[ $base_dataset != $cur ]]
	then
	if [[ $cur == @ ]]
	then
	$__ZFS_CMD list -H -o name -s name -t snapshot -d 1 $base_dataset
	else
	$__ZFS_CMD list -H -o name -s name -t bookmark -d 1 $base_dataset
	fi
	else
	$__ZFS_CMD list -H -o name -s name -t filesystem,volume
	if [[ $cur != "" ]] && $__ZFS_CMD list -H -o name -s name -t filesystem,volume $cur &> /dev/null
	then
	echo $cur@
	echo $cur#
	fi
	fi
	}

	__zfs_match_multiple_snapshots()
	{
	local existing_opts=$(expr "$cur" : '$.*$[%,]')
	if [[ $existing_opts ]]
	then
	local base_dataset=${cur%@*}
	if [[ $base_dataset != $cur ]]
	then
	local cur=${cur##*,}
	if [[ $cur =~ ^%\|%.*% ]]
	then
	# correct range syntax is start%end
	return 1
	fi
	local range_start=$(expr "$cur" : '$.*%$')
	$__ZFS_CMD list -H -o name -s name -t snapshot -d 1 $base_dataset \| sed 's$.*@$'$range_start'$g'
	fi
	else
	__zfs_match_snapshot_or_bookmark
	fi
	}

	__zfs_list_volumes()
	{
	$__ZFS_CMD list -H -o name -s name -t volume
	}

	__zfs_argument_chosen()
	{
	local word property
	for word in $(seq $((COMP_CWORD-1)) -1 2)
	do
	local prev="${COMP_WORDS[$word]}"
	if [[ ${COMP_WORDS[$word-1]} != -[tos] ]]
	then
	if [[ "$prev" == [^,], ]] \|\| [[ "$prev" == [@:\#] ]]
	then
	return 0
	fi
	for property in $@
	do
	if [[ $prev == "$property"* ]]
	then
	return 0
	fi
	done
	fi
	done
	return 1
	}

	__zfs_complete_ordered_arguments()
	{
	local list1=$1
	local list2=$2
	local cur=$3
	local extra=$4
	if __zfs_argument_chosen $list1
	then
	COMPREPLY=($(compgen -W "$list2 $extra" -- "$cur"))
	else
	COMPREPLY=($(compgen -W "$list1 $extra" -- "$cur"))
	fi
	}

	__zfs_complete_multiple_options()
	{
	local options=$1
	local cur=$2

	COMPREPLY=($(compgen -W "$options" -- "${cur##*,}"))
	local existing_opts=$(expr "$cur" : '$.*,$')
	- if [[ $existing_opts ]]
	+ if [[ $existing_opts ]]
	then
	COMPREPLY=( "${COMPREPLY[@]/#/${existing_opts}}" )
	fi
	}

	__zfs_complete_switch()
	{
	local options=$1
	if [[ ${cur:0:1} == - ]]
	then
	COMPREPLY=($(compgen -W "-{$options}" -- "$cur"))
	return 0
	else
	return 1
	fi
	}

	__zfs_complete_nospace()
	{
	# Google indicates that there may still be bash versions out there that
	# don't have compopt.
	if type compopt &> /dev/null
	then
	compopt -o nospace
	fi
	}

	__zfs_complete()
	{
	local cur prev cmd cmds
	COMPREPLY=()
	if type _get_comp_words_by_ref &> /dev/null
	then
	# Don't split on colon
	_get_comp_words_by_ref -n : -c cur -p prev -w COMP_WORDS -i COMP_CWORD
	else
	cur="${COMP_WORDS[COMP_CWORD]}"
	prev="${COMP_WORDS[COMP_CWORD-1]}"
	fi
	cmd="${COMP_WORDS[1]}"

	if [[ ${prev##*/} == zfs ]]
	then
	cmds=$(__zfs_get_commands)
	COMPREPLY=($(compgen -W "$cmds -?" -- "$cur"))
	return 0
	fi

	case "${cmd}" in
	bookmark)
	if __zfs_argument_chosen
	then
	COMPREPLY=($(compgen -W "${prev%@*}# ${prev/@/#}" -- "$cur"))
	else
	COMPREPLY=($(compgen -W "$(__zfs_match_snapshot)" -- "$cur"))
	fi
	;;
	clone)
	case "${prev}" in
	-o)
	COMPREPLY=($(compgen -W "$(__zfs_get_editable_properties)" -- "$cur"))
	__zfs_complete_nospace
	;;
	*)
	if ! __zfs_complete_switch "o,p"
	then
	if __zfs_argument_chosen
	then
	COMPREPLY=($(compgen -W "$(__zfs_list_datasets)" -- "$cur"))
	else
	COMPREPLY=($(compgen -W "$(__zfs_match_snapshot)" -- "$cur"))
	fi
	fi
	;;
	esac
	;;
	get)
	case "${prev}" in
	-d)
	COMPREPLY=($(compgen -W "" -- "$cur"))
	;;
	-t)
	__zfs_complete_multiple_options "filesystem volume snapshot bookmark all" "$cur"
	;;
	-s)
	__zfs_complete_multiple_options "local default inherited temporary received none" "$cur"
	;;
	-o)
	__zfs_complete_multiple_options "name property value source received all" "$cur"
	;;
	*)
	if ! __zfs_complete_switch "H,r,p,d,o,t,s"
	then
	if __zfs_argument_chosen $(__zfs_get_properties)
	then
	COMPREPLY=($(compgen -W "$(__zfs_match_snapshot)" -- "$cur"))
	else
	__zfs_complete_multiple_options "$(__zfs_get_properties)" "$cur"
	fi
	fi
	;;
	esac
	;;
	inherit)
	if ! __zfs_complete_switch "r"
	then
	__zfs_complete_ordered_arguments "$(__zfs_get_inheritable_properties)" "$(__zfs_match_snapshot)" $cur
	fi
	;;
	list)
	case "${prev}" in
	-d)
	COMPREPLY=($(compgen -W "" -- "$cur"))
	;;
	-t)
	__zfs_complete_multiple_options "filesystem volume snapshot bookmark all" "$cur"
	;;
	-o)
	__zfs_complete_multiple_options "$(__zfs_get_properties)" "$cur"
	;;
	-s\|-S)
	COMPREPLY=($(compgen -W "$(__zfs_get_properties)" -- "$cur"))
	;;
	*)
	if ! __zfs_complete_switch "H,r,d,o,t,s,S"
	then
	COMPREPLY=($(compgen -W "$(__zfs_match_snapshot)" -- "$cur"))
	fi
	;;
	esac
	;;
	promote)
	COMPREPLY=($(compgen -W "$(__zfs_list_filesystems)" -- "$cur"))
	;;
	rollback)
	if ! __zfs_complete_switch "r,R,f"
	then
	COMPREPLY=($(compgen -W "$(__zfs_match_snapshot)" -- "$cur"))
	fi
	;;
	send)
	if ! __zfs_complete_switch "D,n,P,p,R,v,e,L,i,I"
	then
	if __zfs_argument_chosen
	then
	COMPREPLY=($(compgen -W "$(__zfs_match_snapshot)" -- "$cur"))
	else
	if [[ $prev == -i ]]
	then
	COMPREPLY=($(compgen -W "$(__zfs_match_snapshot_or_bookmark)" -- "$cur"))
	else
	COMPREPLY=($(compgen -W "$(__zfs_match_snapshot)" -- "$cur"))
	fi
	fi
	fi
	;;
	snapshot)
	case "${prev}" in
	-o)
	COMPREPLY=($(compgen -W "$(__zfs_get_editable_properties)" -- "$cur"))
	__zfs_complete_nospace
	;;
	*)
	if ! __zfs_complete_switch "o,r"
	then
	COMPREPLY=($(compgen -W "$(__zfs_match_snapshot)" -- "$cur"))
	__zfs_complete_nospace
	fi
	;;
	esac
	;;
	set)
	__zfs_complete_ordered_arguments "$(__zfs_get_editable_properties)" "$(__zfs_match_snapshot)" $cur
	__zfs_complete_nospace
	;;
	upgrade)
	case "${prev}" in
	-a\|-V\|-v)
	COMPREPLY=($(compgen -W "" -- "$cur"))
	;;
	*)
	if ! __zfs_complete_switch "a,V,v,r"
	then
	COMPREPLY=($(compgen -W "$(__zfs_list_filesystems)" -- "$cur"))
	fi
	;;
	esac
	;;
	destroy)
	if ! __zfs_complete_switch "d,f,n,p,R,r,v"
	then
	__zfs_complete_multiple_options "$(__zfs_match_multiple_snapshots)" $cur
	__zfs_complete_nospace
	fi
	;;
	*)
	COMPREPLY=($(compgen -W "$(__zfs_match_snapshot)" -- "$cur"))
	;;
	esac
	if type __ltrim_colon_completions &> /dev/null
	then
	__ltrim_colon_completions "$cur"
	fi
	return 0
	}

	__zpool_get_commands()
	{
	$__ZPOOL_CMD 2>&1 \| awk '/^\t[a-z]/ {print $1}' \| uniq
	}

	__zpool_get_properties()
	{
	$__ZPOOL_CMD get 2>&1 \| awk '$2 == "YES" \|\| $2 == "NO" {print $1}'; echo all
	}

	__zpool_get_editable_properties()
	{
	$__ZPOOL_CMD get 2>&1 \| awk '$2 == "YES" {print $1"="}'
	}

	__zpool_list_pools()
	{
	$__ZPOOL_CMD list -H -o name
	}

	__zpool_complete()
	{
	local cur prev cmd cmds
	COMPREPLY=()
	cur="${COMP_WORDS[COMP_CWORD]}"
	prev="${COMP_WORDS[COMP_CWORD-1]}"
	cmd="${COMP_WORDS[1]}"

	if [[ ${prev##*/} == zpool ]]
	then
	cmds=$(__zpool_get_commands)
	COMPREPLY=($(compgen -W "$cmds" -- "$cur"))
	return 0
	fi

	case "${cmd}" in
	get)
	__zfs_complete_ordered_arguments "$(__zpool_get_properties)" "$(__zpool_list_pools)" $cur
	return 0
	;;
	import)
	if [[ $prev == -d ]]
	then
	_filedir -d
	else
	COMPREPLY=($(compgen -W "$(__zpool_list_pools) -d" -- "$cur"))
	fi
	return 0
	;;
	set)
	__zfs_complete_ordered_arguments "$(__zpool_get_editable_properties)" "$(__zpool_list_pools)" $cur
	__zfs_complete_nospace
	return 0
	;;
	add\|attach\|clear\|create\|detach\|offline\|online\|remove\|replace)
	local pools="$(__zpool_list_pools)"
	if __zfs_argument_chosen $pools
	then
	_filedir
	else
	COMPREPLY=($(compgen -W "$pools" -- "$cur"))
	fi
	return 0
	;;
	*)
	COMPREPLY=($(compgen -W "$(__zpool_list_pools)" -- "$cur"))
	return 0
	;;
	esac

	}

	complete -F __zfs_complete zfs
	complete -F __zpool_complete zpool
	diff --git a/sys/contrib/openzfs/contrib/bpftrace/zfs-trace.sh b/sys/contrib/openzfs/contrib/bpftrace/zfs-trace.sh
	index 13230b78c3c3..54f66f3ba3fd 100755
	--- a/sys/contrib/openzfs/contrib/bpftrace/zfs-trace.sh
	+++ b/sys/contrib/openzfs/contrib/bpftrace/zfs-trace.sh
	@@ -1,10 +1,10 @@
	#!/bin/sh

	-ZVER=$(cat /sys/module/zfs/version \| cut -f 1 -d '-')
	+ZVER=$(cut -f 1 -d '-' /sys/module/zfs/version)
	KVER=$(uname -r)

	-bpftrace \
	+exec bpftrace \
	--include "/usr/src/zfs-$ZVER/$KVER/zfs_config.h" \
	-I "/usr/src/zfs-$ZVER/include" \
	-I "/usr/src/zfs-$ZVER/include/spl" \
	"$@"
	diff --git a/sys/contrib/openzfs/contrib/dracut/02zfsexpandknowledge/module-setup.sh.in b/sys/contrib/openzfs/contrib/dracut/02zfsexpandknowledge/module-setup.sh.in
	index 8429bd109411..f4b7b8cdcce3 100755
	--- a/sys/contrib/openzfs/contrib/dracut/02zfsexpandknowledge/module-setup.sh.in
	+++ b/sys/contrib/openzfs/contrib/dracut/02zfsexpandknowledge/module-setup.sh.in
	@@ -1,136 +1,136 @@
	#!/usr/bin/env bash

	get_devtype() {
	local typ
	typ=$(udevadm info --query=property --name="$1" \| grep "^ID_FS_TYPE=" \| sed 's\|^ID_FS_TYPE=\|\|')
	if [ "$typ" = "" ] ; then
	typ=$(blkid -c /dev/null "$1" -o value -s TYPE)
	fi
	echo "$typ"
	}

	get_pool_devices() {
	# also present in 99zfssystemd
	local poolconfigtemp
	local poolconfigoutput
	local pooldev
	local prefix
	local resolved
	poolconfigtemp=`mktemp`
	@sbindir@/zpool list -v -H -P "$1" > "$poolconfigtemp" 2>&1
	if [ "$?" != "0" ] ; then
	poolconfigoutput=$(cat "$poolconfigtemp")
	dinfo "zfsexpandknowledge: pool $1 cannot be listed: $poolconfigoutput"
	else
	cat "$poolconfigtemp" \| awk -F '\t' '/\t\/dev/ { print $2 }' \| \
	while read pooldev ; do
	if [ -n "$pooldev" -a -e "$pooldev" ] ; then
	if [ -h "$pooldev" ] ; then
	resolved=`readlink -f "$pooldev"`
	else
	resolved="$pooldev"
	fi
	dinfo "zfsexpandknowledge: pool $1 has device $pooldev (which resolves to $resolved)"
	echo "$resolved"
	fi
	done
	fi
	rm -f "$poolconfigtemp"
	}

	find_zfs_block_devices() {
	local dev
	local blockdev
	local mp
	local fstype
	local pool
	local key
	local n
	local poolconfigoutput
	numfields=`head -1 /proc/self/mountinfo \| awk '{print NF}'`
	if [ "$numfields" == "10" ] ; then
	fields="n n n n mp n n fstype dev n"
	else
	fields="n n n n mp n n n fstype dev n"
	fi
	while read $fields ; do
	if [ "$fstype" != "zfs" ]; then continue ; fi
	if [ "$mp" == "$1" ]; then
	pool=$(echo "$dev" \| cut -d / -f 1)
	get_pool_devices "$pool"
	fi
	done < /proc/self/mountinfo
	}

	array_contains () {
	local e
	for e in "${@:2}"; do [[ "$e" == "$1" ]] && return 0; done
	return 1
	}

	check() {
	local mp
	local dev
	local blockdevs
	local fstype
	local majmin
	local _depdev
	local _depdevname
	local _depdevtype
	local _depmajmin
	local _dev

	if [[ $hostonly ]]; then

	for mp in \
	"/" \
	"/etc" \
	"/bin" \
	"/sbin" \
	"/lib" \
	"/lib64" \
	"/usr" \
	"/usr/bin" \
	"/usr/sbin" \
	"/usr/lib" \
	"/usr/lib64" \
	"/boot";
	do
	mp=$(readlink -f "$mp")
	mountpoint "$mp" >/dev/null 2>&1 \|\| continue
	blockdevs=$(find_zfs_block_devices "$mp")
	if [ -z "$blockdevs" ] ; then continue ; fi
	- dinfo "zfsexpandknowledge: block devices backing ZFS dataset $mp: $blockdevs"
	+ dinfo "zfsexpandknowledge: block devices backing ZFS dataset $mp: ${blockdevs//$'\n'/ }"
	for dev in $blockdevs
	do
	array_contains "$dev" "${host_devs[@]}" \|\| host_devs+=("$dev")
	fstype=$(get_devtype "$dev")
	host_fs_types["$dev"]="$fstype"
	majmin=$(get_maj_min "$dev")
	if [[ -d /sys/dev/block/$majmin/slaves ]] ; then
	for _depdev in /sys/dev/block/$majmin/slaves/*; do
	[[ -f $_depdev/dev ]] \|\| continue
	_depdev=/dev/$(basename "$_depdev")
	_depdevname=$(udevadm info --query=property --name="$_depdev" \| grep "^DEVNAME=" \| sed 's\|^DEVNAME=\|\|')
	_depdevtype=$(get_devtype "$_depdevname")
	_depmajmin=$(get_maj_min "$_depdevname")
	- dinfo "zfsexpandknowledge: underlying block device backing ZFS dataset $mp: $_depdevname"
	+ dinfo "zfsexpandknowledge: underlying block device backing ZFS dataset $mp: ${_depdevname//$'\n'/ }"
	array_contains "$_depdevname" "${host_devs[@]}" \|\| host_devs+=("$_depdevname")
	host_fs_types["$_depdevname"]="$_depdevtype"
	done
	fi
	done
	done
	for a in "${host_devs[@]}"
	do
	dinfo "zfsexpandknowledge: host device $a"
	done
	for a in "${!host_fs_types[@]}"
	do
	dinfo "zfsexpandknowledge: device $a of type ${host_fs_types[$a]}"
	done

	fi

	return 1
	}
	diff --git a/sys/contrib/openzfs/contrib/dracut/90zfs/zfs-generator.sh.in b/sys/contrib/openzfs/contrib/dracut/90zfs/zfs-generator.sh.in
	index 12293bd24f78..e3fbf334f7d0 100755
	--- a/sys/contrib/openzfs/contrib/dracut/90zfs/zfs-generator.sh.in
	+++ b/sys/contrib/openzfs/contrib/dracut/90zfs/zfs-generator.sh.in
	@@ -1,70 +1,118 @@
	#!/bin/sh

	-echo "zfs-generator: starting" >> /dev/kmsg
	+grep -wq debug /proc/cmdline && debug=1
	+[ -n "$debug" ] && echo "zfs-generator: starting" >> /dev/kmsg

	GENERATOR_DIR="$1"
	[ -n "$GENERATOR_DIR" ] \|\| {
	echo "zfs-generator: no generator directory specified, exiting" >> /dev/kmsg
	exit 1
	}

	[ -f /lib/dracut-lib.sh ] && dracutlib=/lib/dracut-lib.sh
	[ -f /usr/lib/dracut/modules.d/99base/dracut-lib.sh ] && dracutlib=/usr/lib/dracut/modules.d/99base/dracut-lib.sh
	-
	command -v getarg >/dev/null 2>&1 \|\| {
	- echo "zfs-generator: loading Dracut library from $dracutlib" >> /dev/kmsg
	+ [ -n "$debug" ] && echo "zfs-generator: loading Dracut library from $dracutlib" >> /dev/kmsg
	. "$dracutlib"
	}

	+. /lib/dracut-zfs-lib.sh
	+
	[ -z "$root" ] && root=$(getarg root=)
	[ -z "$rootfstype" ] && rootfstype=$(getarg rootfstype=)
	[ -z "$rootflags" ] && rootflags=$(getarg rootflags=)

	# If root is not ZFS= or zfs: or rootfstype is not zfs
	# then we are not supposed to handle it.
	[ "${root##zfs:}" = "${root}" ] &&
	[ "${root##ZFS=}" = "${root}" ] &&
	[ "$rootfstype" != "zfs" ] &&
	exit 0

	-rootfstype=zfs
	case ",${rootflags}," in
	,zfsutil,) ;;
	,,) rootflags=zfsutil ;;
	*) rootflags="zfsutil,${rootflags}" ;;
	esac

	-echo "zfs-generator: writing extension for sysroot.mount to $GENERATOR_DIR"/sysroot.mount.d/zfs-enhancement.conf >> /dev/kmsg
	+if [ "${root}" != "zfs:AUTO" ]; then
	+ root="${root##zfs:}"
	+ root="${root##ZFS=}"
	+fi

	-[ -d "$GENERATOR_DIR" ] \|\| mkdir "$GENERATOR_DIR"
	-[ -d "$GENERATOR_DIR"/sysroot.mount.d ] \|\| mkdir "$GENERATOR_DIR"/sysroot.mount.d
	+[ -n "$debug" ] && echo "zfs-generator: writing extension for sysroot.mount to $GENERATOR_DIR/sysroot.mount.d/zfs-enhancement.conf" >> /dev/kmsg

	+
	+mkdir -p "$GENERATOR_DIR"/sysroot.mount.d "$GENERATOR_DIR"/initrd-root-fs.target.requires "$GENERATOR_DIR"/dracut-pre-mount.service.d
	{
	echo "[Unit]"
	echo "Before=initrd-root-fs.target"
	echo "After=zfs-import.target"
	+ echo
	echo "[Mount]"
	- if [ "${root}" = "zfs:AUTO" ] ; then
	+ if [ "${root}" = "zfs:AUTO" ]; then
	echo "PassEnvironment=BOOTFS"
	echo 'What=${BOOTFS}'
	else
	- root="${root##zfs:}"
	- root="${root##ZFS=}"
	echo "What=${root}"
	fi
	- echo "Type=${rootfstype}"
	+ echo "Type=zfs"
	echo "Options=${rootflags}"
	} > "$GENERATOR_DIR"/sysroot.mount.d/zfs-enhancement.conf
	+ln -fs ../sysroot.mount "$GENERATOR_DIR"/initrd-root-fs.target.requires/sysroot.mount

	-[ -d "$GENERATOR_DIR"/initrd-root-fs.target.requires ] \|\| mkdir -p "$GENERATOR_DIR"/initrd-root-fs.target.requires
	-ln -s ../sysroot.mount "$GENERATOR_DIR"/initrd-root-fs.target.requires/sysroot.mount

	+if [ "${root}" = "zfs:AUTO" ]; then
	+ {
	+ echo "[Unit]"
	+ echo "Before=initrd-root-fs.target"
	+ echo "After=sysroot.mount"
	+ echo "DefaultDependencies=no"
	+ echo
	+ echo "[Service]"
	+ echo "Type=oneshot"
	+ echo "PassEnvironment=BOOTFS"
	+ echo "ExecStart=/bin/sh -c '" ' \
	+ . /lib/dracut-zfs-lib.sh; \
	+ _zfs_nonroot_necessities_cb() { \
	+ zfs mount \| grep -m1 -q "^$1 " && return 0; \
	+ echo "Mounting $1 on /sysroot$2"; \
	+ mount -o zfsutil -t zfs "$1" "/sysroot$2"; \
	+ }; \
	+ for_relevant_root_children "${BOOTFS}" _zfs_nonroot_necessities_cb;' \
	+ "'"
	+ } > "$GENERATOR_DIR"/zfs-nonroot-necessities.service
	+ ln -fs ../zfs-nonroot-necessities.service "$GENERATOR_DIR"/initrd-root-fs.target.requires/zfs-nonroot-necessities.service
	+else
	+ # We can solve this statically at generation time, so do!
	+ _zfs_generator_cb() {
	+ dset="${1}"
	+ mpnt="${2}"
	+ unit="sysroot$(echo "$mpnt" \| sed 's;/;-;g').mount"
	+
	+ {
	+ echo "[Unit]"
	+ echo "Before=initrd-root-fs.target"
	+ echo "After=sysroot.mount"
	+ echo
	+ echo "[Mount]"
	+ echo "Where=/sysroot${mpnt}"
	+ echo "What=${dset}"
	+ echo "Type=zfs"
	+ echo "Options=zfsutil"
	+ } > "$GENERATOR_DIR/${unit}"
	+ ln -fs ../"${unit}" "$GENERATOR_DIR"/initrd-root-fs.target.requires/"${unit}"
	+ }
	+
	+ for_relevant_root_children "${root}" _zfs_generator_cb
	+fi

	-[ -d "$GENERATOR_DIR"/dracut-pre-mount.service.d ] \|\| mkdir "$GENERATOR_DIR"/dracut-pre-mount.service.d

	{
	echo "[Unit]"
	echo "After=zfs-import.target"
	} > "$GENERATOR_DIR"/dracut-pre-mount.service.d/zfs-enhancement.conf

	-echo "zfs-generator: finished" >> /dev/kmsg
	+[ -n "$debug" ] && echo "zfs-generator: finished" >> /dev/kmsg
	+
	+exit 0
	diff --git a/sys/contrib/openzfs/contrib/dracut/90zfs/zfs-lib.sh.in b/sys/contrib/openzfs/contrib/dracut/90zfs/zfs-lib.sh.in
	index c39cc5cfff1f..f3cdd1503d34 100755
	--- a/sys/contrib/openzfs/contrib/dracut/90zfs/zfs-lib.sh.in
	+++ b/sys/contrib/openzfs/contrib/dracut/90zfs/zfs-lib.sh.in
	@@ -1,174 +1,211 @@
	#!/bin/sh

	command -v getarg >/dev/null \|\| . /lib/dracut-lib.sh
	command -v getargbool >/dev/null \|\| {
	# Compatibility with older Dracut versions.
	# With apologies to the Dracut developers.
	getargbool() {
	if ! [ -z "$_b" ]; then
	unset _b
	fi
	_default="$1"; shift
	_b=$(getarg "$@")
	[ $? -ne 0 ] && [ -z "$_b" ] && _b="$_default"
	if [ -n "$_b" ]; then
	[ "$_b" = "0" ] && return 1
	[ "$_b" = "no" ] && return 1
	[ "$_b" = "off" ] && return 1
	fi
	return 0
	}
	}

	OLDIFS="${IFS}"
	NEWLINE="
	"
	+TAB=" "

	ZPOOL_IMPORT_OPTS=""
	if getargbool 0 zfs_force -y zfs.force -y zfsforce ; then
	warn "ZFS: Will force-import pools if necessary."
	ZPOOL_IMPORT_OPTS="${ZPOOL_IMPORT_OPTS} -f"
	fi

	# find_bootfs
	# returns the first dataset with the bootfs attribute.
	find_bootfs() {
	IFS="${NEWLINE}"
	for dataset in $(zpool list -H -o bootfs); do
	case "${dataset}" in
	"" \| "-")
	continue
	;;
	"no pools available")
	IFS="${OLDIFS}"
	return 1
	;;
	*)
	IFS="${OLDIFS}"
	echo "${dataset}"
	return 0
	;;
	esac
	done

	IFS="${OLDIFS}"
	return 1
	}

	# import_pool POOL
	# imports the given zfs pool if it isn't imported already.
	import_pool() {
	- pool="${1}"
	+ pool="${1}"

	if ! zpool list -H "${pool}" > /dev/null 2>&1; then
	info "ZFS: Importing pool ${pool}..."
	if ! zpool import -N ${ZPOOL_IMPORT_OPTS} "${pool}" ; then
	warn "ZFS: Unable to import pool ${pool}"
	return 1
	fi
	fi

	return 0
	}

	+_mount_dataset_cb() {
	+ mount -o zfsutil -t zfs "${1}" "${NEWROOT}${2}"
	+}
	+
	# mount_dataset DATASET
	# mounts the given zfs dataset.
	mount_dataset() {
	- dataset="${1}"
	+ dataset="${1}"
	mountpoint="$(zfs get -H -o value mountpoint "${dataset}")"
	+ ret=0

	# We need zfsutil for non-legacy mounts and not for legacy mounts.
	if [ "${mountpoint}" = "legacy" ] ; then
	- mount -t zfs "${dataset}" "${NEWROOT}"
	+ mount -t zfs "${dataset}" "${NEWROOT}" \|\| ret=$?
	else
	- mount -o zfsutil -t zfs "${dataset}" "${NEWROOT}"
	+ mount -o zfsutil -t zfs "${dataset}" "${NEWROOT}" \|\| ret=$?
	+
	+ if [ "$ret" = "0" ]; then
	+ for_relevant_root_children "${dataset}" _mount_dataset_cb \|\| ret=$?
	+ fi
	fi

	- return $?
	+ return ${ret}
	+}
	+
	+# for_relevant_root_children DATASET EXEC
	+# Runs "EXEC dataset mountpoint" for all children of DATASET that are needed for system bringup
	+# Used by zfs-generator.sh and friends, too!
	+for_relevant_root_children() {
	+ dataset="${1}"
	+ exec="${2}"
	+
	+ zfs list -t filesystem -Ho name,mountpoint,canmount -r "${dataset}" \|
	+ (
	+ _ret=0
	+ while IFS="${TAB}" read -r dataset mountpoint canmount; do
	+ [ "$canmount" != "on" ] && continue
	+
	+ case "$mountpoint" in
	+ /etc\|/bin\|/lib\|/lib??\|/libx32\|/usr)
	+ # If these aren't mounted we may not be able to get to the real init at all, or pollute the dataset holding the rootfs
	+ "${exec}" "${dataset}" "${mountpoint}" \|\| _ret=$?
	+ ;;
	+ *)
	+ # Up to the real init to remount everything else it might need
	+ ;;
	+ esac
	+ done
	+ exit ${_ret}
	+ )
	}

	# export_all OPTS
	# exports all imported zfs pools.
	export_all() {
	- opts="${@}"
	+ opts="${@}"
	ret=0

	IFS="${NEWLINE}"
	for pool in $(zpool list -H -o name) ; do
	if zpool list -H "${pool}" > /dev/null 2>&1; then
	zpool export "${pool}" ${opts} \|\| ret=$?
	fi
	done
	IFS="${OLDIFS}"

	return ${ret}
	}

	# ask_for_password
	#
	# Wraps around plymouth ask-for-password and adds fallback to tty password ask
	# if plymouth is not present.
	#
	# --cmd command
	# Command to execute. Required.
	# --prompt prompt
	# Password prompt. Note that function already adds ':' at the end.
	# Recommended.
	# --tries n
	# How many times repeat command on its failure. Default is 3.
	# --ply-[cmd\|prompt\|tries]
	# Command/prompt/tries specific for plymouth password ask only.
	# --tty-[cmd\|prompt\|tries]
	# Command/prompt/tries specific for tty password ask only.
	# --tty-echo-off
	# Turn off input echo before tty command is executed and turn on after.
	# It's useful when password is read from stdin.
	ask_for_password() {
	ply_tries=3
	tty_tries=3
	while [ "$#" -gt 0 ]; do
	case "$1" in
	--cmd) ply_cmd="$2"; tty_cmd="$2"; shift;;
	--ply-cmd) ply_cmd="$2"; shift;;
	--tty-cmd) tty_cmd="$2"; shift;;
	--prompt) ply_prompt="$2"; tty_prompt="$2"; shift;;
	--ply-prompt) ply_prompt="$2"; shift;;
	--tty-prompt) tty_prompt="$2"; shift;;
	--tries) ply_tries="$2"; tty_tries="$2"; shift;;
	--ply-tries) ply_tries="$2"; shift;;
	--tty-tries) tty_tries="$2"; shift;;
	--tty-echo-off) tty_echo_off=yes;;
	esac
	shift
	done

	{ flock -s 9;
	# Prompt for password with plymouth, if installed and running.
	if plymouth --ping 2>/dev/null; then
	plymouth ask-for-password \
	--prompt "$ply_prompt" --number-of-tries="$ply_tries" \
	--command="$ply_cmd"
	ret=$?
	else
	if [ "$tty_echo_off" = yes ]; then
	stty_orig="$(stty -g)"
	stty -echo
	fi

	i=1
	while [ "$i" -le "$tty_tries" ]; do
	[ -n "$tty_prompt" ] && \
	printf "%s [%i/%i]:" "$tty_prompt" "$i" "$tty_tries" >&2
	eval "$tty_cmd" && ret=0 && break
	ret=$?
	i=$((i+1))
	[ -n "$tty_prompt" ] && printf '\n' >&2
	done
	unset i
	[ "$tty_echo_off" = yes ] && stty "$stty_orig"
	fi
	} 9>/.console_lock

	[ $ret -ne 0 ] && echo "Wrong password" >&2
	return $ret
	}
	diff --git a/sys/contrib/openzfs/contrib/dracut/90zfs/zfs-rollback-bootfs.service.in b/sys/contrib/openzfs/contrib/dracut/90zfs/zfs-rollback-bootfs.service.in
	index 4b058c1b8c9a..0d45f71eadce 100644
	--- a/sys/contrib/openzfs/contrib/dracut/90zfs/zfs-rollback-bootfs.service.in
	+++ b/sys/contrib/openzfs/contrib/dracut/90zfs/zfs-rollback-bootfs.service.in
	@@ -1,14 +1,14 @@
	[Unit]
	Description=Rollback bootfs just before it is mounted
	Requisite=zfs-import.target
	After=zfs-import.target zfs-snapshot-bootfs.service
	Before=dracut-mount.service
	DefaultDependencies=no
	ConditionKernelCommandLine=bootfs.rollback

	[Service]
	# ${BOOTFS} should have been set by zfs-env-bootfs.service
	Type=oneshot
	ExecStartPre=/bin/sh -c 'test -n "${BOOTFS}"'
	-ExecStart=/bin/sh -c '. /lib/dracut-lib.sh; SNAPNAME="$(getarg bootfs.rollback)"; /sbin/zfs rollback -Rf "${BOOTFS}@${SNAPNAME:-%v}"'
	+ExecStart=/bin/sh -c '. /lib/dracut-lib.sh; SNAPNAME="$(getarg bootfs.rollback)"; @sbindir@/zfs rollback -Rf "${BOOTFS}@${SNAPNAME:-%v}"'
	RemainAfterExit=yes
	diff --git a/sys/contrib/openzfs/contrib/dracut/90zfs/zfs-snapshot-bootfs.service.in b/sys/contrib/openzfs/contrib/dracut/90zfs/zfs-snapshot-bootfs.service.in
	index cfd5f7029f06..11513ba27b01 100644
	--- a/sys/contrib/openzfs/contrib/dracut/90zfs/zfs-snapshot-bootfs.service.in
	+++ b/sys/contrib/openzfs/contrib/dracut/90zfs/zfs-snapshot-bootfs.service.in
	@@ -1,14 +1,14 @@
	[Unit]
	Description=Snapshot bootfs just before it is mounted
	Requisite=zfs-import.target
	After=zfs-import.target
	Before=dracut-mount.service
	DefaultDependencies=no
	ConditionKernelCommandLine=bootfs.snapshot

	[Service]
	# ${BOOTFS} should have been set by zfs-env-bootfs.service
	Type=oneshot
	ExecStartPre=/bin/sh -c 'test -n "${BOOTFS}"'
	-ExecStart=-/bin/sh -c '. /lib/dracut-lib.sh; SNAPNAME="$(getarg bootfs.snapshot)"; /sbin/zfs snapshot "${BOOTFS}@${SNAPNAME:-%v}"'
	+ExecStart=-/bin/sh -c '. /lib/dracut-lib.sh; SNAPNAME="$(getarg bootfs.snapshot)"; @sbindir@/zfs snapshot "${BOOTFS}@${SNAPNAME:-%v}"'
	RemainAfterExit=yes
	diff --git a/sys/contrib/openzfs/contrib/initramfs/hooks/zfs.in b/sys/contrib/openzfs/contrib/initramfs/hooks/zfs.in
	index 67d27a7649b2..0a9cc87720ad 100755
	--- a/sys/contrib/openzfs/contrib/initramfs/hooks/zfs.in
	+++ b/sys/contrib/openzfs/contrib/initramfs/hooks/zfs.in
	@@ -1,109 +1,109 @@
	#!/bin/sh
	#
	-# Add ZoL filesystem capabilities to an initrd, usually for a native ZFS root.
	+# Add OpenZFS filesystem capabilities to an initrd, usually for a native ZFS root.
	#

	-# This hook installs udev rules for ZoL.
	+# This hook installs udev rules for OpenZFS.
	PREREQ="udev"

	# These prerequisites are provided by the zfsutils package. The zdb utility is
	# not strictly required, but it can be useful at the initramfs recovery prompt.
	COPY_EXEC_LIST="@sbindir@/zdb @sbindir@/zpool @sbindir@/zfs"
	COPY_EXEC_LIST="$COPY_EXEC_LIST @mounthelperdir@/mount.zfs @udevdir@/vdev_id"
	COPY_EXEC_LIST="$COPY_EXEC_LIST @udevdir@/zvol_id"
	COPY_FILE_LIST="/etc/hostid @sysconfdir@/zfs/zpool.cache"
	COPY_FILE_LIST="$COPY_FILE_LIST @initconfdir@/zfs"
	COPY_FILE_LIST="$COPY_FILE_LIST @sysconfdir@/zfs/zfs-functions"
	COPY_FILE_LIST="$COPY_FILE_LIST @sysconfdir@/zfs/vdev_id.conf"
	COPY_FILE_LIST="$COPY_FILE_LIST @udevruledir@/60-zvol.rules"
	COPY_FILE_LIST="$COPY_FILE_LIST @udevruledir@/69-vdev.rules"

	# These prerequisites are provided by the base system.
	COPY_EXEC_LIST="$COPY_EXEC_LIST /usr/bin/dirname /bin/hostname /sbin/blkid"
	COPY_EXEC_LIST="$COPY_EXEC_LIST /usr/bin/env"
	COPY_EXEC_LIST="$COPY_EXEC_LIST $(which systemd-ask-password)"

	# Explicitly specify all kernel modules because automatic dependency resolution
	# is unreliable on many systems.
	BASE_MODULES="zlib_deflate spl zavl zcommon znvpair zunicode zlua zfs icp"
	CRPT_MODULES="sun-ccm sun-gcm sun-ctr"
	MANUAL_ADD_MODULES_LIST="$BASE_MODULES"

	# Generic result code.
	RC=0

	case $1 in
	prereqs)
	echo "$PREREQ"
	exit 0
	;;
	esac

	for ii in $COPY_EXEC_LIST
	do
	if [ ! -x "$ii" ]
	then
	echo "Error: $ii is not executable."
	RC=2
	fi
	done

	if [ "$RC" -ne 0 ]
	then
	exit "$RC"
	fi

	. /usr/share/initramfs-tools/hook-functions

	mkdir -p "$DESTDIR/etc/"

	# ZDB uses pthreads for some functions, but the library dependency is not
	# automatically detected. The `find` utility and extended `cp` options are
	# used here because libgcc_s.so could be in a subdirectory of /lib for
	# multi-arch installations.
	cp --target-directory="$DESTDIR" --parents $(find /lib/ -type f -name libgcc_s.so.1)

	for ii in $COPY_EXEC_LIST
	do
	copy_exec "$ii"
	done

	for ii in $COPY_FILE_LIST
	do
	dir=$(dirname "$ii")
	[ -d "$dir" ] && mkdir -p "$DESTDIR/$dir"
	[ -f "$ii" ] && cp -p "$ii" "$DESTDIR/$ii"
	done

	for ii in $MANUAL_ADD_MODULES_LIST
	do
	manual_add_modules "$ii"
	done

	if [ -f "/etc/hostname" ]
	then
	cp -p "/etc/hostname" "$DESTDIR/etc/"
	else
	hostname >"$DESTDIR/etc/hostname"
	fi

	for ii in zfs zfs.conf spl spl.conf
	do
	if [ -f "/etc/modprobe.d/$ii" ]; then
	if [ ! -d "$DESTDIR/etc/modprobe.d" ]; then
	mkdir -p $DESTDIR/etc/modprobe.d
	fi
	cp -p "/etc/modprobe.d/$ii" $DESTDIR/etc/modprobe.d/
	fi
	done

	# With pull request #1476 (not yet merged) comes a verbose warning
	# if /usr/bin/net doesn't exist or isn't executable. Just create
	# a dummy...
	[ ! -d "$DESTDIR/usr/bin" ] && mkdir -p "$DESTDIR/usr/bin"
	if [ ! -x "$DESTDIR/usr/bin/net" ]; then
	touch "$DESTDIR/usr/bin/net"
	chmod +x "$DESTDIR/usr/bin/net"
	fi

	exit 0
	diff --git a/sys/contrib/openzfs/contrib/initramfs/scripts/zfs b/sys/contrib/openzfs/contrib/initramfs/scripts/zfs
	index 130aad5debd3..b7e9e57035f3 100644
	--- a/sys/contrib/openzfs/contrib/initramfs/scripts/zfs
	+++ b/sys/contrib/openzfs/contrib/initramfs/scripts/zfs
	@@ -1,1004 +1,990 @@
	# ZFS boot stub for initramfs-tools.
	#
	# In the initramfs environment, the /init script sources this stub to
	# override the default functions in the /scripts/local script.
	#
	# Enable this by passing boot=zfs on the kernel command line.
	#

	# Source the common functions
	. /etc/zfs/zfs-functions

	# Start interactive shell.
	# Use debian's panic() if defined, because it allows to prevent shell access
	# by setting panic in cmdline (e.g. panic=0 or panic=15).
	# See "4.5 Disable root prompt on the initramfs" of Securing Debian Manual:
	# https://www.debian.org/doc/manuals/securing-debian-howto/ch4.en.html
	shell() {
	if command -v panic > /dev/null 2>&1; then
	panic
	else
	/bin/sh
	fi
	}

	# This runs any scripts that should run before we start importing
	# pools and mounting any filesystems.
	pre_mountroot()
	{
	if command -v run_scripts > /dev/null 2>&1
	then
	if [ -f "/scripts/local-top" ] \|\| [ -d "/scripts/local-top" ]
	then
	[ "$quiet" != "y" ] && \
	zfs_log_begin_msg "Running /scripts/local-top"
	run_scripts /scripts/local-top
	[ "$quiet" != "y" ] && zfs_log_end_msg
	fi

	if [ -f "/scripts/local-premount" ] \|\| [ -d "/scripts/local-premount" ]
	then
	[ "$quiet" != "y" ] && \
	zfs_log_begin_msg "Running /scripts/local-premount"
	run_scripts /scripts/local-premount
	[ "$quiet" != "y" ] && zfs_log_end_msg
	fi
	fi
	}

	# If plymouth is available, hide the splash image.
	disable_plymouth()
	{
	if [ -x /bin/plymouth ] && /bin/plymouth --ping
	then
	/bin/plymouth hide-splash >/dev/null 2>&1
	fi
	}

	# Get a ZFS filesystem property value.
	get_fs_value()
	{
	fs="$1"
	value=$2

	"${ZFS}" get -H -ovalue "$value" "$fs" 2> /dev/null
	}

	# Find the 'bootfs' property on pool $1.
	# If the property does not contain '/', then ignore this
	# pool by exporting it again.
	find_rootfs()
	{
	pool="$1"

	# If 'POOL_IMPORTED' isn't set, no pool imported and therefore
	# we won't be able to find a root fs.
	[ -z "${POOL_IMPORTED}" ] && return 1

	# If it's already specified, just keep it mounted and exit
	# User (kernel command line) must be correct.
	[ -n "${ZFS_BOOTFS}" ] && return 0

	# Not set, try to find it in the 'bootfs' property of the pool.
	# NOTE: zpool does not support 'get -H -ovalue bootfs'...
	ZFS_BOOTFS=$("${ZPOOL}" list -H -obootfs "$pool")

	# Make sure it's not '-' and that it starts with /.
	if [ "${ZFS_BOOTFS}" != "-" ] && \
	get_fs_value "${ZFS_BOOTFS}" mountpoint \| grep -q '^/$'
	then
	# Keep it mounted
	POOL_IMPORTED=1
	return 0
	fi

	# Not boot fs here, export it and later try again..
	"${ZPOOL}" export "$pool"
	- POOL_IMPORTED=""
	-
	+ POOL_IMPORTED=
	+ ZFS_BOOTFS=
	return 1
	}

	# Support function to get a list of all pools, separated with ';'
	find_pools()
	{
	CMD="$*"

	pools=$($CMD 2> /dev/null \| \
	grep -E "pool:\|^[a-zA-Z0-9]" \| \
	sed 's@.*: @@' \| \
	while read -r pool; do \
	printf "%s" "$pool;"
	done)

	echo "${pools%%;}" # Return without the last ';'.
	}

	# Get a list of all available pools
	get_pools()
	{
	if [ -n "${ZFS_POOL_IMPORT}" ]; then
	echo "$ZFS_POOL_IMPORT"
	return 0
	fi

	# Get the base list of available pools.
	available_pools=$(find_pools "$ZPOOL" import)

	# Just in case - seen it happen (that a pool isn't visible/found
	# with a simple "zpool import" but only when using the "-d"
	# option or setting ZPOOL_IMPORT_PATH).
	if [ -d "/dev/disk/by-id" ]
	then
	npools=$(find_pools "$ZPOOL" import -d /dev/disk/by-id)
	if [ -n "$npools" ]
	then
	# Because we have found extra pool(s) here, which wasn't
	# found 'normally', we need to force USE_DISK_BY_ID to
	# make sure we're able to actually import it/them later.
	USE_DISK_BY_ID='yes'

	if [ -n "$available_pools" ]
	then
	# Filter out duplicates (pools found with the simple
	# "zpool import" but which is also found with the
	# "zpool import -d ...").
	npools=$(echo "$npools" \| sed "s,$available_pools,,")

	# Add the list to the existing list of
	# available pools
	available_pools="$available_pools;$npools"
	else
	available_pools="$npools"
	fi
	fi
	fi

	# Filter out any exceptions...
	if [ -n "$ZFS_POOL_EXCEPTIONS" ]
	then
	found=""
	apools=""
	OLD_IFS="$IFS" ; IFS=";"

	for pool in $available_pools
	do
	for exception in $ZFS_POOL_EXCEPTIONS
	do
	[ "$pool" = "$exception" ] && continue 2
	found="$pool"
	done

	if [ -n "$found" ]
	then
	if [ -n "$apools" ]
	then
	apools="$apools;$pool"
	else
	apools="$pool"
	fi
	fi
	done

	IFS="$OLD_IFS"
	available_pools="$apools"
	fi

	# Return list of available pools.
	echo "$available_pools"
	}

	# Import given pool $1
	import_pool()
	{
	pool="$1"

	# Verify that the pool isn't already imported
	# Make as sure as we can to not require '-f' to import.
	"${ZPOOL}" get name,guid -o value -H 2>/dev/null \| grep -Fxq "$pool" && return 0

	# For backwards compatibility, make sure that ZPOOL_IMPORT_PATH is set
	# to something we can use later with the real import(s). We want to
	# make sure we find all by* dirs, BUT by-vdev should be first (if it
	# exists).
	if [ -n "$USE_DISK_BY_ID" ] && [ -z "$ZPOOL_IMPORT_PATH" ]
	then
	dirs="$(for dir in $(echo /dev/disk/by-*)
	do
	# Ignore by-vdev here - we want it first!
	echo "$dir" \| grep -q /by-vdev && continue
	[ ! -d "$dir" ] && continue

	printf "%s" "$dir:"
	done \| sed 's,:$,,g')"

	if [ -d "/dev/disk/by-vdev" ]
	then
	# Add by-vdev at the beginning.
	ZPOOL_IMPORT_PATH="/dev/disk/by-vdev:"
	fi

	# ... and /dev at the very end, just for good measure.
	ZPOOL_IMPORT_PATH="$ZPOOL_IMPORT_PATH$dirs:/dev"
	fi

	# Needs to be exported for "zpool" to catch it.
	[ -n "$ZPOOL_IMPORT_PATH" ] && export ZPOOL_IMPORT_PATH


	[ "$quiet" != "y" ] && zfs_log_begin_msg \
	"Importing pool '${pool}' using defaults"

	ZFS_CMD="${ZPOOL} import -N ${ZPOOL_FORCE} ${ZPOOL_IMPORT_OPTS}"
	ZFS_STDERR="$($ZFS_CMD "$pool" 2>&1)"
	ZFS_ERROR="$?"
	if [ "${ZFS_ERROR}" != 0 ]
	then
	[ "$quiet" != "y" ] && zfs_log_failure_msg "${ZFS_ERROR}"

	if [ -f "${ZPOOL_CACHE}" ]
	then
	[ "$quiet" != "y" ] && zfs_log_begin_msg \
	"Importing pool '${pool}' using cachefile."

	ZFS_CMD="${ZPOOL} import -c ${ZPOOL_CACHE} -N ${ZPOOL_FORCE} ${ZPOOL_IMPORT_OPTS}"
	ZFS_STDERR="$($ZFS_CMD "$pool" 2>&1)"
	ZFS_ERROR="$?"
	fi

	if [ "${ZFS_ERROR}" != 0 ]
	then
	[ "$quiet" != "y" ] && zfs_log_failure_msg "${ZFS_ERROR}"

	disable_plymouth
	echo ""
	echo "Command: ${ZFS_CMD} '$pool'"
	echo "Message: $ZFS_STDERR"
	echo "Error: $ZFS_ERROR"
	echo ""
	echo "Failed to import pool '$pool'."
	echo "Manually import the pool and exit."
	shell
	fi
	fi

	[ "$quiet" != "y" ] && zfs_log_end_msg

	POOL_IMPORTED=1
	return 0
	}

	# Load ZFS modules
	# Loading a module in a initrd require a slightly different approach,
	# with more logging etc.
	load_module_initrd()
	{
	if [ "$ZFS_INITRD_PRE_MOUNTROOT_SLEEP" -gt 0 ] 2>/dev/null
	then
	if [ "$quiet" != "y" ]; then
	zfs_log_begin_msg "Sleeping for" \
	"$ZFS_INITRD_PRE_MOUNTROOT_SLEEP seconds..."
	fi
	sleep "$ZFS_INITRD_PRE_MOUNTROOT_SLEEP"
	[ "$quiet" != "y" ] && zfs_log_end_msg
	fi

	# Wait for all of the /dev/{hd,sd}[a-z] device nodes to appear.
	if command -v wait_for_udev > /dev/null 2>&1 ; then
	wait_for_udev 10
	elif command -v wait_for_dev > /dev/null 2>&1 ; then
	wait_for_dev
	fi

	# zpool import refuse to import without a valid /proc/self/mounts
	[ ! -f /proc/self/mounts ] && mount proc /proc

	# Load the module
	load_module "zfs" \|\| return 1

	if [ "$ZFS_INITRD_POST_MODPROBE_SLEEP" -gt 0 ] 2>/dev/null
	then
	if [ "$quiet" != "y" ]; then
	zfs_log_begin_msg "Sleeping for" \
	"$ZFS_INITRD_POST_MODPROBE_SLEEP seconds..."
	fi
	sleep "$ZFS_INITRD_POST_MODPROBE_SLEEP"
	[ "$quiet" != "y" ] && zfs_log_end_msg
	fi

	return 0
	}

	# Mount a given filesystem
	mount_fs()
	{
	fs="$1"

	# Check that the filesystem exists
	"${ZFS}" list -oname -tfilesystem -H "${fs}" > /dev/null 2>&1 \|\| return 1

	# Skip filesystems with canmount=off. The root fs should not have
	# canmount=off, but ignore it for backwards compatibility just in case.
	if [ "$fs" != "${ZFS_BOOTFS}" ]
	then
	canmount=$(get_fs_value "$fs" canmount)
	[ "$canmount" = "off" ] && return 0
	fi

	# Need the _original_ datasets mountpoint!
	mountpoint=$(get_fs_value "$fs" mountpoint)
	if [ "$mountpoint" = "legacy" ] \|\| [ "$mountpoint" = "none" ]; then
	# Can't use the mountpoint property. Might be one of our
	# clones. Check the 'org.zol:mountpoint' property set in
	# clone_snap() if that's usable.
	mountpoint=$(get_fs_value "$fs" org.zol:mountpoint)
	if [ "$mountpoint" = "legacy" ] \|\|
	[ "$mountpoint" = "none" ] \|\|
	[ "$mountpoint" = "-" ]
	then
	if [ "$fs" != "${ZFS_BOOTFS}" ]; then
	# We don't have a proper mountpoint and this
	# isn't the root fs.
	return 0
	else
	# Last hail-mary: Hope 'rootmnt' is set!
	mountpoint=""
	fi
	fi

	if [ "$mountpoint" = "legacy" ]; then
	ZFS_CMD="mount -t zfs"
	else
	# If it's not a legacy filesystem, it can only be a
	# native one...
	ZFS_CMD="mount -o zfsutil -t zfs"
	fi
	else
	ZFS_CMD="mount -o zfsutil -t zfs"
	fi

	# Possibly decrypt a filesystem using native encryption.
	decrypt_fs "$fs"

	[ "$quiet" != "y" ] && \
	zfs_log_begin_msg "Mounting '${fs}' on '${rootmnt}/${mountpoint}'"
	[ -n "${ZFS_DEBUG}" ] && \
	zfs_log_begin_msg "CMD: '$ZFS_CMD ${fs} ${rootmnt}/${mountpoint}'"

	ZFS_STDERR=$(${ZFS_CMD} "${fs}" "${rootmnt}/${mountpoint}" 2>&1)
	ZFS_ERROR=$?
	if [ "${ZFS_ERROR}" != 0 ]
	then
	[ "$quiet" != "y" ] && zfs_log_failure_msg "${ZFS_ERROR}"

	disable_plymouth
	echo ""
	echo "Command: ${ZFS_CMD} ${fs} ${rootmnt}/${mountpoint}"
	echo "Message: $ZFS_STDERR"
	echo "Error: $ZFS_ERROR"
	echo ""
	echo "Failed to mount ${fs} on ${rootmnt}/${mountpoint}."
	echo "Manually mount the filesystem and exit."
	shell
	else
	[ "$quiet" != "y" ] && zfs_log_end_msg
	fi

	return 0
	}

	# Unlock a ZFS native encrypted filesystem.
	decrypt_fs()
	{
	fs="$1"

	# If pool encryption is active and the zfs command understands '-o encryption'
	if [ "$(zpool list -H -o feature@encryption "$(echo "${fs}" \| awk -F/ '{print $1}')")" = 'active' ]; then

	# Determine dataset that holds key for root dataset
	ENCRYPTIONROOT="$(get_fs_value "${fs}" encryptionroot)"
	KEYLOCATION="$(get_fs_value "${ENCRYPTIONROOT}" keylocation)"

	echo "${ENCRYPTIONROOT}" > /run/zfs_fs_name

	# If root dataset is encrypted...
	if ! [ "${ENCRYPTIONROOT}" = "-" ]; then
	KEYSTATUS="$(get_fs_value "${ENCRYPTIONROOT}" keystatus)"
	# Continue only if the key needs to be loaded
	[ "$KEYSTATUS" = "unavailable" ] \|\| return 0
	TRY_COUNT=3

	# If key is stored in a file, do not prompt
	if ! [ "${KEYLOCATION}" = "prompt" ]; then
	$ZFS load-key "${ENCRYPTIONROOT}"

	# Prompt with plymouth, if active
	elif [ -e /bin/plymouth ] && /bin/plymouth --ping 2>/dev/null; then
	echo "plymouth" > /run/zfs_console_askpwd_cmd
	while [ $TRY_COUNT -gt 0 ]; do
	plymouth ask-for-password --prompt "Encrypted ZFS password for ${ENCRYPTIONROOT}" \| \
	$ZFS load-key "${ENCRYPTIONROOT}" && break
	TRY_COUNT=$((TRY_COUNT - 1))
	done

	# Prompt with systemd, if active
	elif [ -e /run/systemd/system ]; then
	echo "systemd-ask-password" > /run/zfs_console_askpwd_cmd
	while [ $TRY_COUNT -gt 0 ]; do
	systemd-ask-password "Encrypted ZFS password for ${ENCRYPTIONROOT}" --no-tty \| \
	$ZFS load-key "${ENCRYPTIONROOT}" && break
	TRY_COUNT=$((TRY_COUNT - 1))
	done

	# Prompt with ZFS tty, otherwise
	else
	# Temporarily setting "printk" to "7" allows the prompt to appear even when the "quiet" kernel option has been used
	echo "load-key" > /run/zfs_console_askpwd_cmd
	storeprintk="$(awk '{print $1}' /proc/sys/kernel/printk)"
	echo 7 > /proc/sys/kernel/printk
	$ZFS load-key "${ENCRYPTIONROOT}"
	echo "$storeprintk" > /proc/sys/kernel/printk
	fi
	fi
	fi

	return 0
	}

	# Destroy a given filesystem.
	destroy_fs()
	{
	fs="$1"

	[ "$quiet" != "y" ] && \
	zfs_log_begin_msg "Destroying '$fs'"

	ZFS_CMD="${ZFS} destroy $fs"
	ZFS_STDERR="$(${ZFS_CMD} 2>&1)"
	ZFS_ERROR="$?"
	if [ "${ZFS_ERROR}" != 0 ]
	then
	[ "$quiet" != "y" ] && zfs_log_failure_msg "${ZFS_ERROR}"

	disable_plymouth
	echo ""
	echo "Command: $ZFS_CMD"
	echo "Message: $ZFS_STDERR"
	echo "Error: $ZFS_ERROR"
	echo ""
	echo "Failed to destroy '$fs'. Please make sure that '$fs' is not available."
	echo "Hint: Try: zfs destroy -Rfn $fs"
	echo "If this dryrun looks good, then remove the 'n' from '-Rfn' and try again."
	shell
	else
	[ "$quiet" != "y" ] && zfs_log_end_msg
	fi

	return 0
	}

	# Clone snapshot $1 to destination filesystem $2
	# Set 'canmount=noauto' and 'mountpoint=none' so that we get to keep
	# manual control over it's mounting (i.e., make sure it's not automatically
	# mounted with a 'zfs mount -a' in the init/systemd scripts).
	clone_snap()
	{
	snap="$1"
	destfs="$2"
	mountpoint="$3"

	[ "$quiet" != "y" ] && zfs_log_begin_msg "Cloning '$snap' to '$destfs'"

	# Clone the snapshot into a dataset we can boot from
	# + We don't want this filesystem to be automatically mounted, we
	# want control over this here and nowhere else.
	# + We don't need any mountpoint set for the same reason.
	# We use the 'org.zol:mountpoint' property to remember the mountpoint.
	ZFS_CMD="${ZFS} clone -o canmount=noauto -o mountpoint=none"
	ZFS_CMD="${ZFS_CMD} -o org.zol:mountpoint=${mountpoint}"
	ZFS_CMD="${ZFS_CMD} $snap $destfs"
	ZFS_STDERR="$(${ZFS_CMD} 2>&1)"
	ZFS_ERROR="$?"
	if [ "${ZFS_ERROR}" != 0 ]
	then
	[ "$quiet" != "y" ] && zfs_log_failure_msg "${ZFS_ERROR}"

	disable_plymouth
	echo ""
	echo "Command: $ZFS_CMD"
	echo "Message: $ZFS_STDERR"
	echo "Error: $ZFS_ERROR"
	echo ""
	echo "Failed to clone snapshot."
	echo "Make sure that the any problems are corrected and then make sure"
	echo "that the dataset '$destfs' exists and is bootable."
	shell
	else
	[ "$quiet" != "y" ] && zfs_log_end_msg
	fi

	return 0
	}

	# Rollback a given snapshot.
	rollback_snap()
	{
	snap="$1"

	[ "$quiet" != "y" ] && zfs_log_begin_msg "Rollback $snap"

	ZFS_CMD="${ZFS} rollback -Rf $snap"
	ZFS_STDERR="$(${ZFS_CMD} 2>&1)"
	ZFS_ERROR="$?"
	if [ "${ZFS_ERROR}" != 0 ]
	then
	[ "$quiet" != "y" ] && zfs_log_failure_msg "${ZFS_ERROR}"

	disable_plymouth
	echo ""
	echo "Command: $ZFS_CMD"
	echo "Message: $ZFS_STDERR"
	echo "Error: $ZFS_ERROR"
	echo ""
	echo "Failed to rollback snapshot."
	shell
	else
	[ "$quiet" != "y" ] && zfs_log_end_msg
	fi

	return 0
	}

	# Get a list of snapshots, give them as a numbered list
	# to the user to choose from.
	ask_user_snap()
	{
	fs="$1"
	i=1

	# We need to temporarily disable debugging. Set 'debug' so we
	# remember to enabled it again.
	if [ -n "${ZFS_DEBUG}" ]; then
	unset ZFS_DEBUG
	set +x
	debug=1
	fi

	# Because we need the resulting snapshot, which is sent on
	# stdout to the caller, we use stderr for our questions.
	echo "What snapshot do you want to boot from?" > /dev/stderr
	while read -r snap; do
	echo " $i: ${snap}" > /dev/stderr
	eval "$(echo SNAP_$i=$snap)"
	i=$((i + 1))
	done <<EOT
	$("${ZFS}" list -H -oname -tsnapshot -r "${fs}")
	EOT

	echo "%s" " Snap nr [1-$((i-1))]? " > /dev/stderr
	read -r snapnr

	# Re-enable debugging.
	if [ -n "${debug}" ]; then
	ZFS_DEBUG=1
	set -x
	fi

	echo "$(eval echo '$SNAP_'$snapnr)"
	}

	setup_snapshot_booting()
	{
	snap="$1"
	retval=0

	# Make sure that the snapshot specified actually exists.
	if [ ! "$(get_fs_value "${snap}" type)" ]
	then
	# Snapshot does not exist (...@<null> ?)
	# ask the user for a snapshot to use.
	snap="$(ask_user_snap "${snap%%@*}")"
	fi

	# Separate the full snapshot ('$snap') into it's filesystem and
	# snapshot names. Would have been nice with a split() function..
	rootfs="${snap%%@*}"
	snapname="${snap##*@}"
	ZFS_BOOTFS="${rootfs}_${snapname}"

	if ! grep -qiE '(^\|[^\\](\\\\)* )(rollback)=(on\|yes\|1)( \|$)' /proc/cmdline
	then
	# If the destination dataset for the clone
	# already exists, destroy it. Recursively
	if [ "$(get_fs_value "${rootfs}_${snapname}" type)" ]; then
	filesystems=$("${ZFS}" list -oname -tfilesystem -H \
	-r -Sname "${ZFS_BOOTFS}")
	for fs in $filesystems; do
	destroy_fs "${fs}"
	done
	fi
	fi

	# Get all snapshots, recursively (might need to clone /usr, /var etc
	# as well).
	for s in $("${ZFS}" list -H -oname -tsnapshot -r "${rootfs}" \| \
	grep "${snapname}")
	do
	if grep -qiE '(^\|[^\\](\\\\)* )(rollback)=(on\|yes\|1)( \|$)' /proc/cmdline
	then
	# Rollback snapshot
	rollback_snap "$s" \|\| retval=$((retval + 1))
	else
	# Setup a destination filesystem name.
	# Ex: Called with 'rpool/ROOT/debian@snap2'
	# rpool/ROOT/debian@snap2 => rpool/ROOT/debian_snap2
	# rpool/ROOT/debian/boot@snap2 => rpool/ROOT/debian_snap2/boot
	# rpool/ROOT/debian/usr@snap2 => rpool/ROOT/debian_snap2/usr
	# rpool/ROOT/debian/var@snap2 => rpool/ROOT/debian_snap2/var
	subfs="${s##$rootfs}"
	subfs="${subfs%%@$snapname}"

	destfs="${rootfs}_${snapname}" # base fs.
	[ -n "$subfs" ] && destfs="${destfs}$subfs" # + sub fs.

	# Get the mountpoint of the filesystem, to be used
	# with clone_snap(). If legacy or none, then use
	# the sub fs value.
	mountpoint=$(get_fs_value "${s%%@*}" mountpoint)
	if [ "$mountpoint" = "legacy" ] \|\| \
	[ "$mountpoint" = "none" ]
	then
	if [ -n "${subfs}" ]; then
	mountpoint="${subfs}"
	else
	mountpoint="/"
	fi
	fi

	# Clone the snapshot into its own
	# filesystem
	clone_snap "$s" "${destfs}" "${mountpoint}" \|\| \
	retval=$((retval + 1))
	fi
	done

	# If we haven't return yet, we have a problem...
	return "${retval}"
	}

	# ================================================================

	# This is the main function.
	mountroot()
	{
	# ----------------------------------------------------------------
	# I N I T I A L S E T U P

	# ------------
	# Run the pre-mount scripts from /scripts/local-top.
	pre_mountroot

	# ------------
	# Source the default setup variables.
	[ -r '/etc/default/zfs' ] && . /etc/default/zfs

	# ------------
	# Support debug option
	if grep -qiE '(^\|[^\\](\\\\)* )(zfs_debug\|zfs\.debug\|zfsdebug)=(on\|yes\|1)( \|$)' /proc/cmdline
	then
	ZFS_DEBUG=1
	mkdir /var/log
	#exec 2> /var/log/boot.debug
	set -x
	fi

	# ------------
	# Load ZFS module etc.
	if ! load_module_initrd; then
	disable_plymouth
	echo ""
	echo "Failed to load ZFS modules."
	echo "Manually load the modules and exit."
	shell
	fi

	# ------------
	# Look for the cache file (if any).
	[ ! -f ${ZPOOL_CACHE} ] && unset ZPOOL_CACHE

	# ------------
	# Compatibility: 'ROOT' is for Debian GNU/Linux (etc),
	# 'root' is for Redhat/Fedora (etc),
	# 'REAL_ROOT' is for Gentoo
	if [ -z "$ROOT" ]
	then
	[ -n "$root" ] && ROOT=${root}

	[ -n "$REAL_ROOT" ] && ROOT=${REAL_ROOT}
	fi

	# ------------
	# Where to mount the root fs in the initrd - set outside this script
	# Compatibility: 'rootmnt' is for Debian GNU/Linux (etc),
	# 'NEWROOT' is for RedHat/Fedora (etc),
	# 'NEW_ROOT' is for Gentoo
	if [ -z "$rootmnt" ]
	then
	[ -n "$NEWROOT" ] && rootmnt=${NEWROOT}

	[ -n "$NEW_ROOT" ] && rootmnt=${NEW_ROOT}
	fi

	# ------------
	# No longer set in the defaults file, but it could have been set in
	# get_pools() in some circumstances. If it's something, but not 'yes',
	# it's no good to us.
	[ -n "$USE_DISK_BY_ID" ] && [ "$USE_DISK_BY_ID" != 'yes' ] && \
	unset USE_DISK_BY_ID

	# ----------------------------------------------------------------
	# P A R S E C O M M A N D L I N E O P T I O N S

	# This part is the really ugly part - there's so many options and permutations
	# 'out there', and if we should make this the 'primary' source for ZFS initrd
	# scripting, we need/should support them all.
	#
	# Supports the following kernel command line argument combinations
	# (in this order - first match win):
	#
	# rpool=<pool> (tries to finds bootfs automatically)
	# bootfs=<pool>/<dataset> (uses this for rpool - first part)
	# rpool=<pool> bootfs=<pool>/<dataset>
	# -B zfs-bootfs=<pool>/<fs> (uses this for rpool - first part)
	# rpool=rpool (default if none of the above is used)
	# root=<pool>/<dataset> (uses this for rpool - first part)
	# root=ZFS=<pool>/<dataset> (uses this for rpool - first part, without 'ZFS=')
	# root=zfs:AUTO (tries to detect both pool and rootfs
	# root=zfs:<pool>/<dataset> (uses this for rpool - first part, without 'zfs:')
	#
	# Option <dataset> could also be <snapshot>
	# Option <pool> could also be <guid>

	# ------------
	# Support force option
	# In addition, setting one of zfs_force, zfs.force or zfsforce to
	# 'yes', 'on' or '1' will make sure we force import the pool.
	# This should (almost) never be needed, but it's here for
	# completeness.
	ZPOOL_FORCE=""
	if grep -qiE '(^\|[^\\](\\\\)* )(zfs_force\|zfs\.force\|zfsforce)=(on\|yes\|1)( \|$)' /proc/cmdline
	then
	ZPOOL_FORCE="-f"
	fi

	# ------------
	# Look for 'rpool' and 'bootfs' parameter
	[ -n "$rpool" ] && ZFS_RPOOL="${rpool#rpool=}"
	[ -n "$bootfs" ] && ZFS_BOOTFS="${bootfs#bootfs=}"

	# ------------
	# If we have 'ROOT' (see above), but not 'ZFS_BOOTFS', then use
	# 'ROOT'
	[ -n "$ROOT" ] && [ -z "${ZFS_BOOTFS}" ] && ZFS_BOOTFS="$ROOT"

	# ------------
	# Check for the `-B zfs-bootfs=%s/%u,...` kind of parameter.
	# NOTE: Only use the pool name and dataset. The rest is not
	# supported by OpenZFS (whatever it's for).
	if [ -z "$ZFS_RPOOL" ]
	then
	# The ${zfs-bootfs} variable is set at the kernel command
	# line, usually by GRUB, but it cannot be referenced here
	# directly because bourne variable names cannot contain a
	# hyphen.
	#
	# Reassign the variable by dumping the environment and
	# stripping the zfs-bootfs= prefix. Let the shell handle
	# quoting through the eval command.
	eval ZFS_RPOOL=$(set \| sed -n -e 's,^zfs-bootfs=,,p')
	fi

	# ------------
	# No root fs or pool specified - do auto detect.
	if [ -z "$ZFS_RPOOL" ] && [ -z "${ZFS_BOOTFS}" ]
	then
	# Do auto detect. Do this by 'cheating' - set 'root=zfs:AUTO'
	# which will be caught later
	ROOT='zfs:AUTO'
	fi

	# ----------------------------------------------------------------
	# F I N D A N D I M P O R T C O R R E C T P O O L

	# ------------
	if [ "$ROOT" = "zfs:AUTO" ]
	then
	# Try to detect both pool and root fs.

	+ # If we got here, that means we don't have a hint so as to
	+ # the root dataset, but with root=zfs:AUTO on cmdline,
	+ # this says "zfs:AUTO" here and interferes with checks later
	+ ZFS_BOOTFS=
	+
	[ "$quiet" != "y" ] && \
	zfs_log_begin_msg "Attempting to import additional pools."

	# Get a list of pools available for import
	if [ -n "$ZFS_RPOOL" ]
	then
	# We've specified a pool - check only that
	POOLS=$ZFS_RPOOL
	else
	POOLS=$(get_pools)
	fi

	OLD_IFS="$IFS" ; IFS=";"
	for pool in $POOLS
	do
	[ -z "$pool" ] && continue

	- import_pool "$pool"
	- find_rootfs "$pool"
	+ IFS="$OLD_IFS" import_pool "$pool"
	+ IFS="$OLD_IFS" find_rootfs "$pool" && break
	done
	IFS="$OLD_IFS"

	[ "$quiet" != "y" ] && zfs_log_end_msg $ZFS_ERROR
	else
	# No auto - use value from the command line option.

	# Strip 'zfs:' and 'ZFS='.
	ZFS_BOOTFS="${ROOT#*[:=]}"

	# Strip everything after the first slash.
	ZFS_RPOOL="${ZFS_BOOTFS%%/*}"
	fi

	# Import the pool (if not already done so in the AUTO check above).
	if [ -n "$ZFS_RPOOL" ] && [ -z "${POOL_IMPORTED}" ]
	then
	[ "$quiet" != "y" ] && \
	zfs_log_begin_msg "Importing ZFS root pool '$ZFS_RPOOL'"

	import_pool "${ZFS_RPOOL}"
	find_rootfs "${ZFS_RPOOL}"

	[ "$quiet" != "y" ] && zfs_log_end_msg
	fi

	if [ -z "${POOL_IMPORTED}" ]
	then
	# No pool imported, this is serious!
	disable_plymouth
	echo ""
	echo "Command: $ZFS_CMD"
	echo "Message: $ZFS_STDERR"
	echo "Error: $ZFS_ERROR"
	echo ""
	echo "No pool imported. Manually import the root pool"
	echo "at the command prompt and then exit."
	echo "Hint: Try: zpool import -R ${rootmnt} -N ${ZFS_RPOOL}"
	shell
	fi

	# In case the pool was specified as guid, resolve guid to name
	pool="$("${ZPOOL}" get name,guid -o name,value -H \| \
	awk -v pool="${ZFS_RPOOL}" '$2 == pool { print $1 }')"
	if [ -n "$pool" ]; then
	# If $ZFS_BOOTFS contains guid, replace the guid portion with $pool
	ZFS_BOOTFS=$(echo "$ZFS_BOOTFS" \| \
	sed -e "s/$("${ZPOOL}" get guid -o value "$pool" -H)/$pool/g")
	ZFS_RPOOL="${pool}"
	fi

	- # Set the no-op scheduler on the disks containing the vdevs of
	- # the root pool. For single-queue devices, this scheduler is
	- # "noop", for multi-queue devices, it is "none".
	- # ZFS already does this for wholedisk vdevs (for all pools), so this
	- # is only important for partitions.
	- "${ZPOOL}" status -L "${ZFS_RPOOL}" 2> /dev/null \|
	- awk '/^\t / && !/(mirror\|raidz)/ {
	- dev=$1;
	- sub(/[0-9]+$/, "", dev);
	- print dev
	- }' \|
	- while read -r i
	- do
	- SCHEDULER=/sys/block/$i/queue/scheduler
	- if [ -e "${SCHEDULER}" ]
	- then
	- # Query to see what schedulers are available
	- case "$(cat "${SCHEDULER}")" in
	- noop) echo noop > "${SCHEDULER}" ;;
	- none) echo none > "${SCHEDULER}" ;;
	- esac
	- fi
	- done
	-

	# ----------------------------------------------------------------
	# P R E P A R E R O O T F I L E S Y S T E M

	if [ -n "${ZFS_BOOTFS}" ]
	then
	# Booting from a snapshot?
	# Will overwrite the ZFS_BOOTFS variable like so:
	# rpool/ROOT/debian@snap2 => rpool/ROOT/debian_snap2
	echo "${ZFS_BOOTFS}" \| grep -q '@' && \
	setup_snapshot_booting "${ZFS_BOOTFS}"
	fi

	if [ -z "${ZFS_BOOTFS}" ]
	then
	# Still nothing! Let the user sort this out.
	disable_plymouth
	echo ""
	echo "Error: Unknown root filesystem - no 'bootfs' pool property and"
	echo " not specified on the kernel command line."
	echo ""
	echo "Manually mount the root filesystem on $rootmnt and then exit."
	echo "Hint: Try: mount -o zfsutil -t zfs ${ZFS_RPOOL-rpool}/ROOT/system $rootmnt"
	shell
	fi

	# ----------------------------------------------------------------
	# M O U N T F I L E S Y S T E M S

	# * Ideally, the root filesystem would be mounted like this:
	#
	# zpool import -R "$rootmnt" -N "$ZFS_RPOOL"
	# zfs mount -o mountpoint=/ "${ZFS_BOOTFS}"
	#
	# but the MOUNTPOINT prefix is preserved on descendent filesystem
	# after the pivot into the regular root, which later breaks things
	# like `zfs mount -a` and the /proc/self/mounts refresh.
	#
	# * Mount additional filesystems required
	# Such as /usr, /var, /usr/local etc.
	# NOTE: Mounted in the order specified in the
	# ZFS_INITRD_ADDITIONAL_DATASETS variable so take care!

	# Go through the complete list (recursively) of all filesystems below
	# the real root dataset
	- filesystems=$("${ZFS}" list -oname -tfilesystem -H -r "${ZFS_BOOTFS}")
	- for fs in $filesystems $ZFS_INITRD_ADDITIONAL_DATASETS
	- do
	+ filesystems="$("${ZFS}" list -oname -tfilesystem -H -r "${ZFS_BOOTFS}")"
	+ OLD_IFS="$IFS" ; IFS="
	+"
	+ for fs in $filesystems; do
	+ IFS="$OLD_IFS" mount_fs "$fs"
	+ done
	+ IFS="$OLD_IFS"
	+ for fs in $ZFS_INITRD_ADDITIONAL_DATASETS; do
	mount_fs "$fs"
	done

	touch /run/zfs_unlock_complete
	if [ -e /run/zfs_unlock_complete_notify ]; then
	read -r zfs_unlock_complete_notify < /run/zfs_unlock_complete_notify
	fi

	# ------------
	# Debugging information
	if [ -n "${ZFS_DEBUG}" ]
	then
	#exec 2>&1-

	echo "DEBUG: imported pools:"
	"${ZPOOL}" list -H
	echo

	echo "DEBUG: mounted ZFS filesystems:"
	mount \| grep zfs
	echo

	echo "=> waiting for ENTER before continuing because of 'zfsdebug=1'. "
	printf "%s" " 'c' for shell, 'r' for reboot, 'ENTER' to continue. "
	read -r b

	[ "$b" = "c" ] && /bin/sh
	[ "$b" = "r" ] && reboot -f

	set +x
	fi

	# ------------
	# Run local bottom script
	if command -v run_scripts > /dev/null 2>&1
	then
	if [ -f "/scripts/local-bottom" ] \|\| [ -d "/scripts/local-bottom" ]
	then
	[ "$quiet" != "y" ] && \
	zfs_log_begin_msg "Running /scripts/local-bottom"
	run_scripts /scripts/local-bottom
	[ "$quiet" != "y" ] && zfs_log_end_msg
	fi
	fi
	}
	diff --git a/sys/contrib/openzfs/contrib/pyzfs/libzfs_core/test/test_libzfs_core.py b/sys/contrib/openzfs/contrib/pyzfs/libzfs_core/test/test_libzfs_core.py
	index 87138b305f73..d949d88d5a1e 100644
	--- a/sys/contrib/openzfs/contrib/pyzfs/libzfs_core/test/test_libzfs_core.py
	+++ b/sys/contrib/openzfs/contrib/pyzfs/libzfs_core/test/test_libzfs_core.py
	@@ -1,4380 +1,4380 @@
	#
	# Copyright 2015 ClusterHQ
	#
	# Licensed under the Apache License, Version 2.0 (the "License");
	# you may not use this file except in compliance with the License.
	# You may obtain a copy of the License at
	#
	# http://www.apache.org/licenses/LICENSE-2.0
	#
	# Unless required by applicable law or agreed to in writing, software
	# distributed under the License is distributed on an "AS IS" BASIS,
	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	# See the License for the specific language governing permissions and
	# limitations under the License.
	#

	"""
	Tests for `libzfs_core` operations.

	These are mostly functional and conformance tests that validate
	that the operations produce expected effects or fail with expected
	exceptions.
	"""
	from __future__ import absolute_import, division, print_function

	import unittest
	import contextlib
	import errno
	import filecmp
	import os
	import platform
	import resource
	import shutil
	import stat
	import subprocess
	import sys
	import tempfile
	import time
	import uuid
	import itertools
	import zlib
	from .. import _libzfs_core as lzc
	from .. import exceptions as lzc_exc
	from .._nvlist import packed_nvlist_out


	def _print(*args):
	for arg in args:
	print(arg, end=' ')
	print()


	@contextlib.contextmanager
	def suppress(exceptions=None):
	try:
	yield
	except BaseException as e:
	if exceptions is None or isinstance(e, exceptions):
	pass
	else:
	raise


	@contextlib.contextmanager
	def _zfs_mount(fs):
	mntdir = tempfile.mkdtemp()
	if platform.system() == 'SunOS':
	mount_cmd = ['mount', '-F', 'zfs', fs, mntdir]
	else:
	mount_cmd = ['mount', '-t', 'zfs', fs, mntdir]
	unmount_cmd = ['umount', '-f', mntdir]

	try:
	subprocess.check_output(mount_cmd, stderr=subprocess.STDOUT)
	try:
	yield mntdir
	finally:
	with suppress():
	subprocess.check_output(unmount_cmd, stderr=subprocess.STDOUT)
	except subprocess.CalledProcessError as e:
	print('failed to mount %s @ %s : %s' % (fs, mntdir, e.output))
	raise
	finally:
	os.rmdir(mntdir)


	# XXX On illumos it is impossible to explicitly mount a snapshot.
	# So, either we need to implicitly mount it using .zfs/snapshot/
	# or we need to create a clone and mount it readonly (and discard
	# it afterwards).
	# At the moment the former approach is implemented.

	# This dictionary is used to keep track of mounted filesystems
	# (not snapshots), so that we do not try to mount a filesystem
	# more than once in the case more than one snapshot of the
	# filesystem is accessed from the same context or the filesystem
	# and its snapshot are accessed.
	_mnttab = {}


	@contextlib.contextmanager
	def _illumos_mount_fs(fs):
	if fs in _mnttab:
	yield _mnttab[fs]
	else:
	with _zfs_mount(fs) as mntdir:
	_mnttab[fs] = mntdir
	try:
	yield mntdir
	finally:
	_mnttab.pop(fs, None)


	@contextlib.contextmanager
	def _illumos_mount_snap(fs):
	(base, snap) = fs.split('@', 1)
	with _illumos_mount_fs(base) as mntdir:
	yield os.path.join(mntdir, '.zfs', 'snapshot', snap)


	@contextlib.contextmanager
	def _zfs_mount_illumos(fs):
	if '@' not in fs:
	with _illumos_mount_fs(fs) as mntdir:
	yield mntdir
	else:
	with _illumos_mount_snap(fs) as mntdir:
	yield mntdir


	if platform.system() == 'SunOS':
	zfs_mount = _zfs_mount_illumos
	else:
	zfs_mount = _zfs_mount


	@contextlib.contextmanager
	def cleanup_fd():
	fd = os.open('/dev/zfs', os.O_EXCL)
	try:
	yield fd
	finally:
	os.close(fd)


	@contextlib.contextmanager
	def os_open(name, mode):
	fd = os.open(name, mode)
	try:
	yield fd
	finally:
	os.close(fd)


	@contextlib.contextmanager
	def dev_null():
	with tempfile.TemporaryFile(suffix='.zstream') as fd:
	yield fd.fileno()


	@contextlib.contextmanager
	def dev_zero():
	with os_open('/dev/zero', os.O_RDONLY) as fd:
	yield fd


	@contextlib.contextmanager
	def temp_file_in_fs(fs):
	with zfs_mount(fs) as mntdir:
	with tempfile.NamedTemporaryFile(dir=mntdir) as f:
	for i in range(1024):
	f.write(b'x' * 1024)
	f.flush()
	yield f.name


	def make_snapshots(fs, before, modified, after):
	def _maybe_snap(snap):
	if snap is not None:
	if not snap.startswith(fs):
	snap = fs + b'@' + snap
	lzc.lzc_snapshot([snap])
	return snap

	before = _maybe_snap(before)
	with temp_file_in_fs(fs) as name:
	modified = _maybe_snap(modified)
	after = _maybe_snap(after)

	return (name, (before, modified, after))


	@contextlib.contextmanager
	def streams(fs, first, second):
	(filename, snaps) = make_snapshots(fs, None, first, second)
	with tempfile.TemporaryFile(suffix='.zstream') as full:
	lzc.lzc_send(snaps[1], None, full.fileno())
	full.seek(0)
	if snaps[2] is not None:
	with tempfile.TemporaryFile(suffix='.zstream') as incremental:
	lzc.lzc_send(snaps[2], snaps[1], incremental.fileno())
	incremental.seek(0)
	yield (filename, (full, incremental))
	else:
	yield (filename, (full, None))


	@contextlib.contextmanager
	def encrypted_filesystem():
	fs = ZFSTest.pool.getFilesystem(b"encrypted")
	name = fs.getName()
	filename = None
	key = os.urandom(lzc.WRAPPING_KEY_LEN)
	with tempfile.NamedTemporaryFile() as f:
	filename = "file://" + f.name
	props = {
	b"encryption": lzc.zio_encrypt.ZIO_CRYPT_AES_256_CCM,
	b"keylocation": filename.encode(),
	b"keyformat": lzc.zfs_keyformat.ZFS_KEYFORMAT_RAW,
	}
	lzc.lzc_create(name, 'zfs', props=props, key=key)
	yield (name, key)


	def runtimeSkipIf(check_method, message):
	def _decorator(f):
	def _f(_self, args, *kwargs):
	if check_method(_self):
	return _self.skipTest(message)
	else:
	return f(_self, args, *kwargs)
	_f.__name__ = f.__name__
	return _f
	return _decorator


	def skipIfFeatureAvailable(feature, message):
	return runtimeSkipIf(
	lambda _self: _self.__class__.pool.isPoolFeatureAvailable(feature),
	message)


	def skipUnlessFeatureEnabled(feature, message):
	return runtimeSkipIf(
	lambda _self: not _self.__class__.pool.isPoolFeatureEnabled(feature),
	message)


	def skipUnlessBookmarksSupported(f):
	return skipUnlessFeatureEnabled(
	'bookmarks', 'bookmarks are not enabled')(f)


	def snap_always_unmounted_before_destruction():
	- # Apparently ZoL automatically unmounts the snapshot
	+ # Apparently OpenZFS automatically unmounts the snapshot
	# only if it is mounted at its default .zfs/snapshot
	- # mountpoint.
	+ # mountpoint under Linux.
	return (
	platform.system() != 'Linux', 'snapshot is not auto-unmounted')


	def illumos_bug_6379():
	# zfs_ioc_hold() panics on a bad cleanup fd
	return (
	platform.system() == 'SunOS',
	'see https://www.illumos.org/issues/6379')


	def needs_support(function):
	return unittest.skipUnless(
	lzc.is_supported(function),
	'{} not available'.format(function.__name__))


	class ZFSTest(unittest.TestCase):
	POOL_FILE_SIZE = 128 * 1024 * 1024
	FILESYSTEMS = [b'fs1', b'fs2', b'fs1/fs']

	pool = None
	misc_pool = None
	readonly_pool = None

	@classmethod
	def setUpClass(cls):
	try:
	cls.pool = _TempPool(filesystems=cls.FILESYSTEMS)
	cls.misc_pool = _TempPool()
	cls.readonly_pool = _TempPool(
	filesystems=cls.FILESYSTEMS, readonly=True)
	cls.pools = [cls.pool, cls.misc_pool, cls.readonly_pool]
	except Exception:
	cls._cleanUp()
	raise

	@classmethod
	def tearDownClass(cls):
	cls._cleanUp()

	@classmethod
	def _cleanUp(cls):
	for pool in [cls.pool, cls.misc_pool, cls.readonly_pool]:
	if pool is not None:
	pool.cleanUp()

	def setUp(self):
	pass

	def tearDown(self):
	for pool in ZFSTest.pools:
	pool.reset()

	def assertExists(self, name):
	self.assertTrue(
	lzc.lzc_exists(name), 'ZFS dataset %s does not exist' % (name, ))

	def assertNotExists(self, name):
	self.assertFalse(
	lzc.lzc_exists(name), 'ZFS dataset %s exists' % (name, ))

	def test_exists(self):
	self.assertExists(ZFSTest.pool.makeName())

	def test_exists_in_ro_pool(self):
	self.assertExists(ZFSTest.readonly_pool.makeName())

	def test_exists_failure(self):
	self.assertNotExists(ZFSTest.pool.makeName(b'nonexistent'))

	def test_create_fs(self):
	name = ZFSTest.pool.makeName(b"fs1/fs/test1")

	lzc.lzc_create(name)
	self.assertExists(name)

	def test_create_zvol(self):
	name = ZFSTest.pool.makeName(b"fs1/fs/zvol")
	props = {b"volsize": 1024 * 1024}

	lzc.lzc_create(name, ds_type='zvol', props=props)
	self.assertExists(name)
	# On Gentoo with ZFS 0.6.5.4 the volume is busy
	# and can not be destroyed right after its creation.
	# A reason for this is unknown at the moment.
	# Because of that the post-test clean up could fail.
	time.sleep(0.1)

	def test_create_fs_with_prop(self):
	name = ZFSTest.pool.makeName(b"fs1/fs/test2")
	props = {b"atime": 0}

	lzc.lzc_create(name, props=props)
	self.assertExists(name)

	def test_create_fs_wrong_ds_type(self):
	name = ZFSTest.pool.makeName(b"fs1/fs/test1")

	with self.assertRaises(lzc_exc.DatasetTypeInvalid):
	lzc.lzc_create(name, ds_type='wrong')

	def test_create_fs_below_zvol(self):
	name = ZFSTest.pool.makeName(b"fs1/fs/zvol")
	props = {b"volsize": 1024 * 1024}

	lzc.lzc_create(name, ds_type='zvol', props=props)
	with self.assertRaises(lzc_exc.WrongParent):
	lzc.lzc_create(name + b'/fs')

	def test_create_zvol_below_zvol(self):
	name = ZFSTest.pool.makeName(b"fs1/fs/zvol")
	props = {b"volsize": 1024 * 1024}

	lzc.lzc_create(name, ds_type='zvol', props=props)
	with self.assertRaises(lzc_exc.WrongParent):
	lzc.lzc_create(name + b'/zvol', ds_type='zvol', props=props)

	def test_create_fs_duplicate(self):
	name = ZFSTest.pool.makeName(b"fs1/fs/test6")

	lzc.lzc_create(name)

	with self.assertRaises(lzc_exc.FilesystemExists):
	lzc.lzc_create(name)

	def test_create_fs_in_ro_pool(self):
	name = ZFSTest.readonly_pool.makeName(b"fs")

	with self.assertRaises(lzc_exc.ReadOnlyPool):
	lzc.lzc_create(name)

	def test_create_fs_without_parent(self):
	name = ZFSTest.pool.makeName(b"fs1/nonexistent/test")

	with self.assertRaises(lzc_exc.ParentNotFound):
	lzc.lzc_create(name)
	self.assertNotExists(name)

	def test_create_fs_in_nonexistent_pool(self):
	name = b"no-such-pool/fs"

	with self.assertRaises(lzc_exc.ParentNotFound):
	lzc.lzc_create(name)
	self.assertNotExists(name)

	def test_create_fs_with_invalid_prop(self):
	name = ZFSTest.pool.makeName(b"fs1/fs/test3")
	props = {b"BOGUS": 0}

	with self.assertRaises(lzc_exc.PropertyInvalid):
	lzc.lzc_create(name, 'zfs', props)
	self.assertNotExists(name)

	def test_create_fs_with_invalid_prop_type(self):
	name = ZFSTest.pool.makeName(b"fs1/fs/test4")
	props = {b"recordsize": b"128k"}

	with self.assertRaises(lzc_exc.PropertyInvalid):
	lzc.lzc_create(name, 'zfs', props)
	self.assertNotExists(name)

	def test_create_fs_with_invalid_prop_val(self):
	name = ZFSTest.pool.makeName(b"fs1/fs/test5")
	props = {b"atime": 20}

	with self.assertRaises(lzc_exc.PropertyInvalid):
	lzc.lzc_create(name, 'zfs', props)
	self.assertNotExists(name)

	def test_create_fs_with_invalid_name(self):
	name = ZFSTest.pool.makeName(b"@badname")

	with self.assertRaises(lzc_exc.NameInvalid):
	lzc.lzc_create(name)
	self.assertNotExists(name)

	def test_create_fs_with_invalid_pool_name(self):
	name = b"bad!pool/fs"

	with self.assertRaises(lzc_exc.NameInvalid):
	lzc.lzc_create(name)
	self.assertNotExists(name)

	def test_create_encrypted_fs(self):
	fs = ZFSTest.pool.getFilesystem(b"encrypted")
	name = fs.getName()
	filename = None
	with tempfile.NamedTemporaryFile() as f:
	filename = "file://" + f.name
	props = {
	b"encryption": lzc.zio_encrypt.ZIO_CRYPT_AES_256_CCM,
	b"keylocation": filename.encode(),
	b"keyformat": lzc.zfs_keyformat.ZFS_KEYFORMAT_RAW,
	}
	key = os.urandom(lzc.WRAPPING_KEY_LEN)
	lzc.lzc_create(name, 'zfs', props=props, key=key)
	self.assertEqual(fs.getProperty("encryption"), b"aes-256-ccm")
	self.assertEqual(fs.getProperty("encryptionroot"), name)
	self.assertEqual(fs.getProperty("keylocation"), filename.encode())
	self.assertEqual(fs.getProperty("keyformat"), b"raw")

	def test_snapshot(self):
	snapname = ZFSTest.pool.makeName(b"@snap")
	snaps = [snapname]

	lzc.lzc_snapshot(snaps)
	self.assertExists(snapname)

	def test_snapshot_empty_list(self):
	lzc.lzc_snapshot([])

	def test_snapshot_user_props(self):
	snapname = ZFSTest.pool.makeName(b"@snap")
	snaps = [snapname]
	props = {b"user:foo": b"bar"}

	lzc.lzc_snapshot(snaps, props)
	self.assertExists(snapname)

	def test_snapshot_invalid_props(self):
	snapname = ZFSTest.pool.makeName(b"@snap")
	snaps = [snapname]
	props = {b"foo": b"bar"}

	with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
	lzc.lzc_snapshot(snaps, props)

	self.assertEqual(len(ctx.exception.errors), len(snaps))
	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.PropertyInvalid)
	self.assertNotExists(snapname)

	def test_snapshot_ro_pool(self):
	snapname1 = ZFSTest.readonly_pool.makeName(b"@snap")
	snapname2 = ZFSTest.readonly_pool.makeName(b"fs1@snap")
	snaps = [snapname1, snapname2]

	with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
	lzc.lzc_snapshot(snaps)

	# NB: one common error is reported.
	self.assertEqual(len(ctx.exception.errors), 1)
	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.ReadOnlyPool)
	self.assertNotExists(snapname1)
	self.assertNotExists(snapname2)

	def test_snapshot_nonexistent_pool(self):
	snapname = b"no-such-pool@snap"
	snaps = [snapname]

	with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
	lzc.lzc_snapshot(snaps)

	self.assertEqual(len(ctx.exception.errors), 1)
	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.FilesystemNotFound)

	def test_snapshot_nonexistent_fs(self):
	snapname = ZFSTest.pool.makeName(b"nonexistent@snap")
	snaps = [snapname]

	with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
	lzc.lzc_snapshot(snaps)

	self.assertEqual(len(ctx.exception.errors), 1)
	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.FilesystemNotFound)

	def test_snapshot_nonexistent_and_existent_fs(self):
	snapname1 = ZFSTest.pool.makeName(b"@snap")
	snapname2 = ZFSTest.pool.makeName(b"nonexistent@snap")
	snaps = [snapname1, snapname2]

	with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
	lzc.lzc_snapshot(snaps)

	self.assertEqual(len(ctx.exception.errors), 1)
	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.FilesystemNotFound)
	self.assertNotExists(snapname1)
	self.assertNotExists(snapname2)

	def test_multiple_snapshots_nonexistent_fs(self):
	snapname1 = ZFSTest.pool.makeName(b"nonexistent@snap1")
	snapname2 = ZFSTest.pool.makeName(b"nonexistent@snap2")
	snaps = [snapname1, snapname2]

	with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
	lzc.lzc_snapshot(snaps)

	# XXX two errors should be reported but alas
	self.assertEqual(len(ctx.exception.errors), 1)
	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.DuplicateSnapshots)
	self.assertNotExists(snapname1)
	self.assertNotExists(snapname2)

	def test_multiple_snapshots_multiple_nonexistent_fs(self):
	snapname1 = ZFSTest.pool.makeName(b"nonexistent1@snap")
	snapname2 = ZFSTest.pool.makeName(b"nonexistent2@snap")
	snaps = [snapname1, snapname2]

	with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
	lzc.lzc_snapshot(snaps)

	self.assertEqual(len(ctx.exception.errors), 2)
	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.FilesystemNotFound)
	self.assertNotExists(snapname1)
	self.assertNotExists(snapname2)

	def test_snapshot_already_exists(self):
	snapname = ZFSTest.pool.makeName(b"@snap")
	snaps = [snapname]

	lzc.lzc_snapshot(snaps)

	with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
	lzc.lzc_snapshot(snaps)

	self.assertEqual(len(ctx.exception.errors), 1)
	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.SnapshotExists)

	def test_multiple_snapshots_for_same_fs(self):
	snapname1 = ZFSTest.pool.makeName(b"@snap1")
	snapname2 = ZFSTest.pool.makeName(b"@snap2")
	snaps = [snapname1, snapname2]

	with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
	lzc.lzc_snapshot(snaps)

	self.assertEqual(len(ctx.exception.errors), 1)
	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.DuplicateSnapshots)
	self.assertNotExists(snapname1)
	self.assertNotExists(snapname2)

	def test_multiple_snapshots(self):
	snapname1 = ZFSTest.pool.makeName(b"@snap")
	snapname2 = ZFSTest.pool.makeName(b"fs1@snap")
	snaps = [snapname1, snapname2]

	lzc.lzc_snapshot(snaps)
	self.assertExists(snapname1)
	self.assertExists(snapname2)

	def test_multiple_existing_snapshots(self):
	snapname1 = ZFSTest.pool.makeName(b"@snap")
	snapname2 = ZFSTest.pool.makeName(b"fs1@snap")
	snaps = [snapname1, snapname2]

	lzc.lzc_snapshot(snaps)

	with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
	lzc.lzc_snapshot(snaps)

	self.assertEqual(len(ctx.exception.errors), 2)
	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.SnapshotExists)

	def test_multiple_new_and_existing_snapshots(self):
	snapname1 = ZFSTest.pool.makeName(b"@snap")
	snapname2 = ZFSTest.pool.makeName(b"fs1@snap")
	snapname3 = ZFSTest.pool.makeName(b"fs2@snap")
	snaps = [snapname1, snapname2]
	more_snaps = snaps + [snapname3]

	lzc.lzc_snapshot(snaps)

	with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
	lzc.lzc_snapshot(more_snaps)

	self.assertEqual(len(ctx.exception.errors), 2)
	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.SnapshotExists)
	self.assertNotExists(snapname3)

	def test_snapshot_multiple_errors(self):
	snapname1 = ZFSTest.pool.makeName(b"@snap")
	snapname2 = ZFSTest.pool.makeName(b"nonexistent@snap")
	snapname3 = ZFSTest.pool.makeName(b"fs1@snap")
	snaps = [snapname1]
	more_snaps = [snapname1, snapname2, snapname3]

	# create 'snapname1' snapshot
	lzc.lzc_snapshot(snaps)

	# attempt to create 3 snapshots:
	# 1. duplicate snapshot name
	# 2. refers to filesystem that doesn't exist
	# 3. could have succeeded if not for 1 and 2
	with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
	lzc.lzc_snapshot(more_snaps)

	# It seems that FilesystemNotFound overrides the other error,
	# but it doesn't have to.
	self.assertGreater(len(ctx.exception.errors), 0)
	for e in ctx.exception.errors:
	self.assertIsInstance(
	e, (lzc_exc.SnapshotExists, lzc_exc.FilesystemNotFound))
	self.assertNotExists(snapname2)
	self.assertNotExists(snapname3)

	def test_snapshot_different_pools(self):
	snapname1 = ZFSTest.pool.makeName(b"@snap")
	snapname2 = ZFSTest.misc_pool.makeName(b"@snap")
	snaps = [snapname1, snapname2]

	with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
	lzc.lzc_snapshot(snaps)

	# NB: one common error is reported.
	self.assertEqual(len(ctx.exception.errors), 1)
	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.PoolsDiffer)
	self.assertNotExists(snapname1)
	self.assertNotExists(snapname2)

	def test_snapshot_different_pools_ro_pool(self):
	snapname1 = ZFSTest.pool.makeName(b"@snap")
	snapname2 = ZFSTest.readonly_pool.makeName(b"@snap")
	snaps = [snapname1, snapname2]

	with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
	lzc.lzc_snapshot(snaps)

	# NB: one common error is reported.
	self.assertEqual(len(ctx.exception.errors), 1)
	for e in ctx.exception.errors:
	# NB: depending on whether the first attempted snapshot is
	# for the read-only pool a different error is reported.
	self.assertIsInstance(
	e, (lzc_exc.PoolsDiffer, lzc_exc.ReadOnlyPool))
	self.assertNotExists(snapname1)
	self.assertNotExists(snapname2)

	def test_snapshot_invalid_name(self):
	snapname1 = ZFSTest.pool.makeName(b"@bad&name")
	snapname2 = ZFSTest.pool.makeName(b"fs1@bad*name")
	snapname3 = ZFSTest.pool.makeName(b"fs2@snap")
	snaps = [snapname1, snapname2, snapname3]

	with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
	lzc.lzc_snapshot(snaps)

	# NB: one common error is reported.
	self.assertEqual(len(ctx.exception.errors), 1)
	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.NameInvalid)
	self.assertIsNone(e.name)

	def test_snapshot_too_long_complete_name(self):
	snapname1 = ZFSTest.pool.makeTooLongName(b"fs1@")
	snapname2 = ZFSTest.pool.makeTooLongName(b"fs2@")
	snapname3 = ZFSTest.pool.makeName(b"@snap")
	snaps = [snapname1, snapname2, snapname3]

	with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
	lzc.lzc_snapshot(snaps)

	self.assertEqual(len(ctx.exception.errors), 2)
	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.NameTooLong)
	self.assertIsNotNone(e.name)

	def test_snapshot_too_long_snap_name(self):
	snapname1 = ZFSTest.pool.makeTooLongComponent(b"fs1@")
	snapname2 = ZFSTest.pool.makeTooLongComponent(b"fs2@")
	snapname3 = ZFSTest.pool.makeName(b"@snap")
	snaps = [snapname1, snapname2, snapname3]

	with self.assertRaises(lzc_exc.SnapshotFailure) as ctx:
	lzc.lzc_snapshot(snaps)

	# NB: one common error is reported.
	self.assertEqual(len(ctx.exception.errors), 1)
	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.NameTooLong)
	self.assertIsNone(e.name)

	def test_destroy_nonexistent_snapshot(self):
	lzc.lzc_destroy_snaps([ZFSTest.pool.makeName(b"@nonexistent")], False)
	lzc.lzc_destroy_snaps([ZFSTest.pool.makeName(b"@nonexistent")], True)

	def test_destroy_snapshot_of_nonexistent_pool(self):
	with self.assertRaises(lzc_exc.SnapshotDestructionFailure) as ctx:
	lzc.lzc_destroy_snaps([b"no-such-pool@snap"], False)

	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.PoolNotFound)

	with self.assertRaises(lzc_exc.SnapshotDestructionFailure) as ctx:
	lzc.lzc_destroy_snaps([b"no-such-pool@snap"], True)

	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.PoolNotFound)

	# NB: note the difference from the nonexistent pool test.
	def test_destroy_snapshot_of_nonexistent_fs(self):
	lzc.lzc_destroy_snaps(
	[ZFSTest.pool.makeName(b"nonexistent@snap")], False)
	lzc.lzc_destroy_snaps(
	[ZFSTest.pool.makeName(b"nonexistent@snap")], True)

	# Apparently the name is not checked for validity.
	@unittest.expectedFailure
	def test_destroy_invalid_snap_name(self):
	with self.assertRaises(lzc_exc.SnapshotDestructionFailure):
	lzc.lzc_destroy_snaps(
	[ZFSTest.pool.makeName(b"@non$&*existent")], False)
	with self.assertRaises(lzc_exc.SnapshotDestructionFailure):
	lzc.lzc_destroy_snaps(
	[ZFSTest.pool.makeName(b"@non$&*existent")], True)

	# Apparently the full name is not checked for length.
	@unittest.expectedFailure
	def test_destroy_too_long_full_snap_name(self):
	snapname1 = ZFSTest.pool.makeTooLongName(b"fs1@")
	snaps = [snapname1]

	with self.assertRaises(lzc_exc.SnapshotDestructionFailure):
	lzc.lzc_destroy_snaps(snaps, False)
	with self.assertRaises(lzc_exc.SnapshotDestructionFailure):
	lzc.lzc_destroy_snaps(snaps, True)

	def test_destroy_too_long_short_snap_name(self):
	snapname1 = ZFSTest.pool.makeTooLongComponent(b"fs1@")
	snapname2 = ZFSTest.pool.makeTooLongComponent(b"fs2@")
	snapname3 = ZFSTest.pool.makeName(b"@snap")
	snaps = [snapname1, snapname2, snapname3]

	with self.assertRaises(lzc_exc.SnapshotDestructionFailure) as ctx:
	lzc.lzc_destroy_snaps(snaps, False)

	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.NameTooLong)

	@unittest.skipUnless(*snap_always_unmounted_before_destruction())
	def test_destroy_mounted_snap(self):
	snap = ZFSTest.pool.getRoot().getSnap()

	lzc.lzc_snapshot([snap])
	with zfs_mount(snap):
	# the snapshot should be force-unmounted
	lzc.lzc_destroy_snaps([snap], defer=False)
	self.assertNotExists(snap)

	def test_clone(self):
	# NB: note the special name for the snapshot.
	# Since currently we can not destroy filesystems,
	# it would be impossible to destroy the snapshot,
	# so no point in attempting to clean it up.
	snapname = ZFSTest.pool.makeName(b"fs2@origin1")
	name = ZFSTest.pool.makeName(b"fs1/fs/clone1")

	lzc.lzc_snapshot([snapname])

	lzc.lzc_clone(name, snapname)
	self.assertExists(name)

	def test_clone_nonexistent_snapshot(self):
	snapname = ZFSTest.pool.makeName(b"fs2@nonexistent")
	name = ZFSTest.pool.makeName(b"fs1/fs/clone2")

	# XXX The error should be SnapshotNotFound
	# but limitations of C interface do not allow
	# to differentiate between the errors.
	with self.assertRaises(lzc_exc.DatasetNotFound):
	lzc.lzc_clone(name, snapname)
	self.assertNotExists(name)

	def test_clone_nonexistent_parent_fs(self):
	snapname = ZFSTest.pool.makeName(b"fs2@origin3")
	name = ZFSTest.pool.makeName(b"fs1/nonexistent/clone3")

	lzc.lzc_snapshot([snapname])

	with self.assertRaises(lzc_exc.DatasetNotFound):
	lzc.lzc_clone(name, snapname)
	self.assertNotExists(name)

	def test_clone_to_nonexistent_pool(self):
	snapname = ZFSTest.pool.makeName(b"fs2@snap")
	name = b"no-such-pool/fs"

	lzc.lzc_snapshot([snapname])

	with self.assertRaises(lzc_exc.DatasetNotFound):
	lzc.lzc_clone(name, snapname)
	self.assertNotExists(name)

	def test_clone_invalid_snap_name(self):
	# Use a valid filesystem name of filesystem that
	# exists as a snapshot name
	snapname = ZFSTest.pool.makeName(b"fs1/fs")
	name = ZFSTest.pool.makeName(b"fs2/clone")

	with self.assertRaises(lzc_exc.SnapshotNameInvalid):
	lzc.lzc_clone(name, snapname)
	self.assertNotExists(name)

	def test_clone_invalid_snap_name_2(self):
	# Use a valid filesystem name of filesystem that
	# doesn't exist as a snapshot name
	snapname = ZFSTest.pool.makeName(b"fs1/nonexistent")
	name = ZFSTest.pool.makeName(b"fs2/clone")

	with self.assertRaises(lzc_exc.SnapshotNameInvalid):
	lzc.lzc_clone(name, snapname)
	self.assertNotExists(name)

	def test_clone_invalid_name(self):
	snapname = ZFSTest.pool.makeName(b"fs2@snap")
	name = ZFSTest.pool.makeName(b"fs1/bad#name")

	lzc.lzc_snapshot([snapname])

	with self.assertRaises(lzc_exc.FilesystemNameInvalid):
	lzc.lzc_clone(name, snapname)
	self.assertNotExists(name)

	def test_clone_invalid_pool_name(self):
	snapname = ZFSTest.pool.makeName(b"fs2@snap")
	name = b"bad!pool/fs1"

	lzc.lzc_snapshot([snapname])

	with self.assertRaises(lzc_exc.FilesystemNameInvalid):
	lzc.lzc_clone(name, snapname)
	self.assertNotExists(name)

	def test_clone_across_pools(self):
	snapname = ZFSTest.pool.makeName(b"fs2@snap")
	name = ZFSTest.misc_pool.makeName(b"clone1")

	lzc.lzc_snapshot([snapname])

	with self.assertRaises(lzc_exc.PoolsDiffer):
	lzc.lzc_clone(name, snapname)
	self.assertNotExists(name)

	def test_clone_across_pools_to_ro_pool(self):
	snapname = ZFSTest.pool.makeName(b"fs2@snap")
	name = ZFSTest.readonly_pool.makeName(b"fs1/clone1")

	lzc.lzc_snapshot([snapname])

	# it's legal to report either of the conditions
	with self.assertRaises((lzc_exc.ReadOnlyPool, lzc_exc.PoolsDiffer)):
	lzc.lzc_clone(name, snapname)
	self.assertNotExists(name)

	def test_destroy_cloned_fs(self):
	snapname1 = ZFSTest.pool.makeName(b"fs2@origin4")
	snapname2 = ZFSTest.pool.makeName(b"fs1@snap")
	clonename = ZFSTest.pool.makeName(b"fs1/fs/clone4")
	snaps = [snapname1, snapname2]

	lzc.lzc_snapshot(snaps)
	lzc.lzc_clone(clonename, snapname1)

	with self.assertRaises(lzc_exc.SnapshotDestructionFailure) as ctx:
	lzc.lzc_destroy_snaps(snaps, False)

	self.assertEqual(len(ctx.exception.errors), 1)
	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.SnapshotIsCloned)
	for snap in snaps:
	self.assertExists(snap)

	def test_deferred_destroy_cloned_fs(self):
	snapname1 = ZFSTest.pool.makeName(b"fs2@origin5")
	snapname2 = ZFSTest.pool.makeName(b"fs1@snap")
	clonename = ZFSTest.pool.makeName(b"fs1/fs/clone5")
	snaps = [snapname1, snapname2]

	lzc.lzc_snapshot(snaps)
	lzc.lzc_clone(clonename, snapname1)

	lzc.lzc_destroy_snaps(snaps, defer=True)

	self.assertExists(snapname1)
	self.assertNotExists(snapname2)

	def test_rollback(self):
	name = ZFSTest.pool.makeName(b"fs1")
	snapname = name + b"@snap"

	lzc.lzc_snapshot([snapname])
	ret = lzc.lzc_rollback(name)
	self.assertEqual(ret, snapname)

	def test_rollback_2(self):
	name = ZFSTest.pool.makeName(b"fs1")
	snapname1 = name + b"@snap1"
	snapname2 = name + b"@snap2"

	lzc.lzc_snapshot([snapname1])
	lzc.lzc_snapshot([snapname2])
	ret = lzc.lzc_rollback(name)
	self.assertEqual(ret, snapname2)

	def test_rollback_no_snaps(self):
	name = ZFSTest.pool.makeName(b"fs1")

	with self.assertRaises(lzc_exc.SnapshotNotFound):
	lzc.lzc_rollback(name)

	def test_rollback_non_existent_fs(self):
	name = ZFSTest.pool.makeName(b"nonexistent")

	with self.assertRaises(lzc_exc.FilesystemNotFound):
	lzc.lzc_rollback(name)

	def test_rollback_invalid_fs_name(self):
	name = ZFSTest.pool.makeName(b"bad~name")

	with self.assertRaises(lzc_exc.NameInvalid):
	lzc.lzc_rollback(name)

	def test_rollback_snap_name(self):
	name = ZFSTest.pool.makeName(b"fs1@snap")

	with self.assertRaises(lzc_exc.NameInvalid):
	lzc.lzc_rollback(name)

	def test_rollback_snap_name_2(self):
	name = ZFSTest.pool.makeName(b"fs1@snap")

	lzc.lzc_snapshot([name])
	with self.assertRaises(lzc_exc.NameInvalid):
	lzc.lzc_rollback(name)

	def test_rollback_too_long_fs_name(self):
	name = ZFSTest.pool.makeTooLongName()

	with self.assertRaises(lzc_exc.NameTooLong):
	lzc.lzc_rollback(name)

	def test_rollback_to_snap_name(self):
	name = ZFSTest.pool.makeName(b"fs1")
	snap = name + b"@snap"

	lzc.lzc_snapshot([snap])
	lzc.lzc_rollback_to(name, snap)

	def test_rollback_to_not_latest(self):
	fsname = ZFSTest.pool.makeName(b'fs1')
	snap1 = fsname + b"@snap1"
	snap2 = fsname + b"@snap2"

	lzc.lzc_snapshot([snap1])
	lzc.lzc_snapshot([snap2])
	with self.assertRaises(lzc_exc.SnapshotNotLatest):
	lzc.lzc_rollback_to(fsname, fsname + b"@snap1")

	@skipUnlessBookmarksSupported
	def test_bookmarks(self):
	snaps = [ZFSTest.pool.makeName(
	b'fs1@snap1'), ZFSTest.pool.makeName(b'fs2@snap1')]
	bmarks = [ZFSTest.pool.makeName(
	b'fs1#bmark1'), ZFSTest.pool.makeName(b'fs2#bmark1')]
	bmark_dict = {x: y for x, y in zip(bmarks, snaps)}

	lzc.lzc_snapshot(snaps)
	lzc.lzc_bookmark(bmark_dict)

	@skipUnlessBookmarksSupported
	def test_bookmarks_2(self):
	snaps = [ZFSTest.pool.makeName(
	b'fs1@snap1'), ZFSTest.pool.makeName(b'fs2@snap1')]
	bmarks = [ZFSTest.pool.makeName(
	b'fs1#bmark1'), ZFSTest.pool.makeName(b'fs2#bmark1')]
	bmark_dict = {x: y for x, y in zip(bmarks, snaps)}
	lzc.lzc_snapshot(snaps)
	lzc.lzc_bookmark(bmark_dict)
	lzc.lzc_destroy_snaps(snaps, defer=False)

	@skipUnlessBookmarksSupported
	def test_bookmark_copying(self):
	snaps = [ZFSTest.pool.makeName(s) for s in [
	b'fs1@snap1', b'fs1@snap2', b'fs2@snap1']]
	bmarks = [ZFSTest.pool.makeName(x) for x in [
	b'fs1#bmark1', b'fs1#bmark2', b'fs2#bmark1']]
	bmarks_copies = [ZFSTest.pool.makeName(x) for x in [
	b'fs1#bmark1_copy', b'fs1#bmark2_copy', b'fs2#bmark1_copy']]
	bmark_dict = {x: y for x, y in zip(bmarks, snaps)}
	bmark_copies_dict = {x: y for x, y in zip(bmarks_copies, bmarks)}

	for snap in snaps:
	lzc.lzc_snapshot([snap])
	lzc.lzc_bookmark(bmark_dict)

	lzc.lzc_bookmark(bmark_copies_dict)
	lzc.lzc_destroy_bookmarks(bmarks_copies)

	lzc.lzc_destroy_bookmarks(bmarks)
	lzc.lzc_destroy_snaps(snaps, defer=False)

	@skipUnlessBookmarksSupported
	def test_bookmarks_empty(self):
	lzc.lzc_bookmark({})

	@skipUnlessBookmarksSupported
	def test_bookmarks_foreign_source(self):
	snaps = [ZFSTest.pool.makeName(b'fs1@snap1')]
	bmarks = [ZFSTest.pool.makeName(b'fs2#bmark1')]
	bmark_dict = {x: y for x, y in zip(bmarks, snaps)}

	lzc.lzc_snapshot(snaps)
	with self.assertRaises(lzc_exc.BookmarkFailure) as ctx:
	lzc.lzc_bookmark(bmark_dict)

	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.BookmarkMismatch)

	@skipUnlessBookmarksSupported
	def test_bookmarks_invalid_name(self):
	snaps = [ZFSTest.pool.makeName(b'fs1@snap1')]
	bmarks = [ZFSTest.pool.makeName(b'fs1#bmark!')]
	bmark_dict = {x: y for x, y in zip(bmarks, snaps)}

	lzc.lzc_snapshot(snaps)
	with self.assertRaises(lzc_exc.BookmarkFailure) as ctx:
	lzc.lzc_bookmark(bmark_dict)

	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.NameInvalid)

	@skipUnlessBookmarksSupported
	def test_bookmarks_invalid_name_2(self):
	snaps = [ZFSTest.pool.makeName(b'fs1@snap1')]
	bmarks = [ZFSTest.pool.makeName(b'fs1@bmark')]
	bmark_dict = {x: y for x, y in zip(bmarks, snaps)}

	lzc.lzc_snapshot(snaps)
	with self.assertRaises(lzc_exc.BookmarkFailure) as ctx:
	lzc.lzc_bookmark(bmark_dict)

	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.NameInvalid)

	@skipUnlessBookmarksSupported
	def test_bookmarks_too_long_name(self):
	snaps = [ZFSTest.pool.makeName(b'fs1@snap1')]
	bmarks = [ZFSTest.pool.makeTooLongName(b'fs1#')]
	bmark_dict = {x: y for x, y in zip(bmarks, snaps)}

	lzc.lzc_snapshot(snaps)
	with self.assertRaises(lzc_exc.BookmarkFailure) as ctx:
	lzc.lzc_bookmark(bmark_dict)

	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.NameTooLong)

	@skipUnlessBookmarksSupported
	def test_bookmarks_too_long_name_2(self):
	snaps = [ZFSTest.pool.makeName(b'fs1@snap1')]
	bmarks = [ZFSTest.pool.makeTooLongComponent(b'fs1#')]
	bmark_dict = {x: y for x, y in zip(bmarks, snaps)}

	lzc.lzc_snapshot(snaps)
	with self.assertRaises(lzc_exc.BookmarkFailure) as ctx:
	lzc.lzc_bookmark(bmark_dict)

	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.NameTooLong)

	@skipUnlessBookmarksSupported
	def test_bookmarks_foreign_sources(self):
	snaps = [ZFSTest.pool.makeName(
	b'fs1@snap1'), ZFSTest.pool.makeName(b'fs2@snap1')]
	bmarks = [ZFSTest.pool.makeName(
	b'fs2#bmark1'), ZFSTest.pool.makeName(b'fs1#bmark1')]
	bmark_dict = {x: y for x, y in zip(bmarks, snaps)}

	lzc.lzc_snapshot(snaps)
	with self.assertRaises(lzc_exc.BookmarkFailure) as ctx:
	lzc.lzc_bookmark(bmark_dict)

	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.BookmarkMismatch)

	@skipUnlessBookmarksSupported
	def test_bookmarks_partially_foreign_sources(self):
	snaps = [ZFSTest.pool.makeName(
	b'fs1@snap1'), ZFSTest.pool.makeName(b'fs2@snap1')]
	bmarks = [ZFSTest.pool.makeName(
	b'fs2#bmark'), ZFSTest.pool.makeName(b'fs2#bmark1')]
	bmark_dict = {x: y for x, y in zip(bmarks, snaps)}

	lzc.lzc_snapshot(snaps)
	with self.assertRaises(lzc_exc.BookmarkFailure) as ctx:
	lzc.lzc_bookmark(bmark_dict)

	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.BookmarkMismatch)

	@skipUnlessBookmarksSupported
	def test_bookmarks_cross_pool(self):
	snaps = [ZFSTest.pool.makeName(
	b'fs1@snap1'), ZFSTest.misc_pool.makeName(b'@snap1')]
	bmarks = [ZFSTest.pool.makeName(
	b'fs1#bmark1'), ZFSTest.misc_pool.makeName(b'#bmark1')]
	bmark_dict = {x: y for x, y in zip(bmarks, snaps)}

	lzc.lzc_snapshot(snaps[0:1])
	lzc.lzc_snapshot(snaps[1:2])
	with self.assertRaises(lzc_exc.BookmarkFailure) as ctx:
	lzc.lzc_bookmark(bmark_dict)

	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.PoolsDiffer)

	@skipUnlessBookmarksSupported
	def test_bookmarks_missing_snap(self):
	fss = [ZFSTest.pool.makeName(b'fs1'), ZFSTest.pool.makeName(b'fs2')]
	snaps = [ZFSTest.pool.makeName(
	b'fs1@snap1'), ZFSTest.pool.makeName(b'fs2@snap1')]
	bmarks = [ZFSTest.pool.makeName(
	b'fs1#bmark1'), ZFSTest.pool.makeName(b'fs2#bmark1')]
	bmark_dict = {x: y for x, y in zip(bmarks, snaps)}

	lzc.lzc_snapshot(snaps[0:1]) # only create fs1@snap1

	with self.assertRaises(lzc_exc.BookmarkFailure) as ctx:
	lzc.lzc_bookmark(bmark_dict)

	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.SnapshotNotFound)

	# no new bookmarks are created if one or more sources do not exist
	for fs in fss:
	fsbmarks = lzc.lzc_get_bookmarks(fs)
	self.assertEqual(len(fsbmarks), 0)

	@skipUnlessBookmarksSupported
	def test_bookmarks_missing_snaps(self):
	fss = [ZFSTest.pool.makeName(b'fs1'), ZFSTest.pool.makeName(b'fs2')]
	snaps = [ZFSTest.pool.makeName(
	b'fs1@snap1'), ZFSTest.pool.makeName(b'fs2@snap1')]
	bmarks = [ZFSTest.pool.makeName(
	b'fs1#bmark1'), ZFSTest.pool.makeName(b'fs2#bmark1')]
	bmark_dict = {x: y for x, y in zip(bmarks, snaps)}

	# do not create any snapshots

	with self.assertRaises(lzc_exc.BookmarkFailure) as ctx:
	lzc.lzc_bookmark(bmark_dict)

	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.SnapshotNotFound)

	# no new bookmarks are created if one or more sources do not exist
	for fs in fss:
	fsbmarks = lzc.lzc_get_bookmarks(fs)
	self.assertEqual(len(fsbmarks), 0)

	@skipUnlessBookmarksSupported
	def test_bookmarks_for_the_same_snap(self):
	snap = ZFSTest.pool.makeName(b'fs1@snap1')
	bmark1 = ZFSTest.pool.makeName(b'fs1#bmark1')
	bmark2 = ZFSTest.pool.makeName(b'fs1#bmark2')
	bmark_dict = {bmark1: snap, bmark2: snap}

	lzc.lzc_snapshot([snap])
	lzc.lzc_bookmark(bmark_dict)

	@skipUnlessBookmarksSupported
	def test_bookmarks_for_the_same_snap_2(self):
	snap = ZFSTest.pool.makeName(b'fs1@snap1')
	bmark1 = ZFSTest.pool.makeName(b'fs1#bmark1')
	bmark2 = ZFSTest.pool.makeName(b'fs1#bmark2')
	bmark_dict1 = {bmark1: snap}
	bmark_dict2 = {bmark2: snap}

	lzc.lzc_snapshot([snap])
	lzc.lzc_bookmark(bmark_dict1)
	lzc.lzc_bookmark(bmark_dict2)

	@skipUnlessBookmarksSupported
	def test_bookmarks_duplicate_name(self):
	snap1 = ZFSTest.pool.makeName(b'fs1@snap1')
	snap2 = ZFSTest.pool.makeName(b'fs1@snap2')
	bmark = ZFSTest.pool.makeName(b'fs1#bmark')
	bmark_dict1 = {bmark: snap1}
	bmark_dict2 = {bmark: snap2}

	lzc.lzc_snapshot([snap1])
	lzc.lzc_snapshot([snap2])
	lzc.lzc_bookmark(bmark_dict1)
	with self.assertRaises(lzc_exc.BookmarkFailure) as ctx:
	lzc.lzc_bookmark(bmark_dict2)

	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.BookmarkExists)

	@skipUnlessBookmarksSupported
	def test_get_bookmarks(self):
	snap1 = ZFSTest.pool.makeName(b'fs1@snap1')
	snap2 = ZFSTest.pool.makeName(b'fs1@snap2')
	bmark = ZFSTest.pool.makeName(b'fs1#bmark')
	bmark1 = ZFSTest.pool.makeName(b'fs1#bmark1')
	bmark2 = ZFSTest.pool.makeName(b'fs1#bmark2')
	bmark_dict1 = {bmark1: snap1, bmark2: snap2}
	bmark_dict2 = {bmark: snap2}

	lzc.lzc_snapshot([snap1])
	lzc.lzc_snapshot([snap2])
	lzc.lzc_bookmark(bmark_dict1)
	lzc.lzc_bookmark(bmark_dict2)
	lzc.lzc_destroy_snaps([snap1, snap2], defer=False)

	bmarks = lzc.lzc_get_bookmarks(ZFSTest.pool.makeName(b'fs1'))
	self.assertEqual(len(bmarks), 3)
	for b in b'bmark', b'bmark1', b'bmark2':
	self.assertIn(b, bmarks)
	self.assertIsInstance(bmarks[b], dict)
	self.assertEqual(len(bmarks[b]), 0)

	bmarks = lzc.lzc_get_bookmarks(ZFSTest.pool.makeName(b'fs1'),
	[b'guid', b'createtxg', b'creation'])
	self.assertEqual(len(bmarks), 3)
	for b in b'bmark', b'bmark1', b'bmark2':
	self.assertIn(b, bmarks)
	self.assertIsInstance(bmarks[b], dict)
	self.assertEqual(len(bmarks[b]), 3)

	@skipUnlessBookmarksSupported
	def test_get_bookmarks_invalid_property(self):
	snap = ZFSTest.pool.makeName(b'fs1@snap')
	bmark = ZFSTest.pool.makeName(b'fs1#bmark')
	bmark_dict = {bmark: snap}

	lzc.lzc_snapshot([snap])
	lzc.lzc_bookmark(bmark_dict)

	bmarks = lzc.lzc_get_bookmarks(
	ZFSTest.pool.makeName(b'fs1'), [b'badprop'])
	self.assertEqual(len(bmarks), 1)
	for b in (b'bmark', ):
	self.assertIn(b, bmarks)
	self.assertIsInstance(bmarks[b], dict)
	self.assertEqual(len(bmarks[b]), 0)

	@skipUnlessBookmarksSupported
	def test_get_bookmarks_nonexistent_fs(self):
	with self.assertRaises(lzc_exc.FilesystemNotFound):
	lzc.lzc_get_bookmarks(ZFSTest.pool.makeName(b'nonexistent'))

	@skipUnlessBookmarksSupported
	def test_destroy_bookmarks(self):
	snap = ZFSTest.pool.makeName(b'fs1@snap')
	bmark = ZFSTest.pool.makeName(b'fs1#bmark')
	bmark_dict = {bmark: snap}

	lzc.lzc_snapshot([snap])
	lzc.lzc_bookmark(bmark_dict)

	lzc.lzc_destroy_bookmarks(
	[bmark, ZFSTest.pool.makeName(b'fs1#nonexistent')])
	bmarks = lzc.lzc_get_bookmarks(ZFSTest.pool.makeName(b'fs1'))
	self.assertEqual(len(bmarks), 0)

	@skipUnlessBookmarksSupported
	def test_destroy_bookmarks_invalid_name(self):
	snap = ZFSTest.pool.makeName(b'fs1@snap')
	bmark = ZFSTest.pool.makeName(b'fs1#bmark')
	bmark_dict = {bmark: snap}

	lzc.lzc_snapshot([snap])
	lzc.lzc_bookmark(bmark_dict)

	with self.assertRaises(lzc_exc.BookmarkDestructionFailure) as ctx:
	lzc.lzc_destroy_bookmarks(
	[bmark, ZFSTest.pool.makeName(b'fs1/nonexistent')])
	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.NameInvalid)

	bmarks = lzc.lzc_get_bookmarks(ZFSTest.pool.makeName(b'fs1'))
	self.assertEqual(len(bmarks), 1)
	self.assertIn(b'bmark', bmarks)

	@skipUnlessBookmarksSupported
	def test_destroy_bookmark_nonexistent_fs(self):
	lzc.lzc_destroy_bookmarks(
	[ZFSTest.pool.makeName(b'nonexistent#bmark')])

	@skipUnlessBookmarksSupported
	def test_destroy_bookmarks_empty(self):
	lzc.lzc_bookmark({})

	def test_snaprange_space(self):
	snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
	snap2 = ZFSTest.pool.makeName(b"fs1@snap2")
	snap3 = ZFSTest.pool.makeName(b"fs1@snap")

	lzc.lzc_snapshot([snap1])
	lzc.lzc_snapshot([snap2])
	lzc.lzc_snapshot([snap3])

	space = lzc.lzc_snaprange_space(snap1, snap2)
	self.assertIsInstance(space, (int, int))
	space = lzc.lzc_snaprange_space(snap2, snap3)
	self.assertIsInstance(space, (int, int))
	space = lzc.lzc_snaprange_space(snap1, snap3)
	self.assertIsInstance(space, (int, int))

	def test_snaprange_space_2(self):
	snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
	snap2 = ZFSTest.pool.makeName(b"fs1@snap2")
	snap3 = ZFSTest.pool.makeName(b"fs1@snap")

	lzc.lzc_snapshot([snap1])
	with zfs_mount(ZFSTest.pool.makeName(b"fs1")) as mntdir:
	with tempfile.NamedTemporaryFile(dir=mntdir) as f:
	for i in range(1024):
	f.write(b'x' * 1024)
	f.flush()
	lzc.lzc_snapshot([snap2])
	lzc.lzc_snapshot([snap3])

	space = lzc.lzc_snaprange_space(snap1, snap2)
	self.assertGreater(space, 1024 * 1024)
	space = lzc.lzc_snaprange_space(snap2, snap3)
	self.assertGreater(space, 1024 * 1024)
	space = lzc.lzc_snaprange_space(snap1, snap3)
	self.assertGreater(space, 1024 * 1024)

	def test_snaprange_space_same_snap(self):
	snap = ZFSTest.pool.makeName(b"fs1@snap")

	with zfs_mount(ZFSTest.pool.makeName(b"fs1")) as mntdir:
	with tempfile.NamedTemporaryFile(dir=mntdir) as f:
	for i in range(1024):
	f.write(b'x' * 1024)
	f.flush()
	lzc.lzc_snapshot([snap])

	space = lzc.lzc_snaprange_space(snap, snap)
	self.assertGreater(space, 1024 * 1024)
	self.assertAlmostEqual(space, 1024 * 1024, delta=1024 * 1024 // 20)

	def test_snaprange_space_wrong_order(self):
	snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
	snap2 = ZFSTest.pool.makeName(b"fs1@snap2")

	lzc.lzc_snapshot([snap1])
	lzc.lzc_snapshot([snap2])

	with self.assertRaises(lzc_exc.SnapshotMismatch):
	lzc.lzc_snaprange_space(snap2, snap1)

	def test_snaprange_space_unrelated(self):
	snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
	snap2 = ZFSTest.pool.makeName(b"fs2@snap2")

	lzc.lzc_snapshot([snap1])
	lzc.lzc_snapshot([snap2])

	with self.assertRaises(lzc_exc.SnapshotMismatch):
	lzc.lzc_snaprange_space(snap1, snap2)

	def test_snaprange_space_across_pools(self):
	snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
	snap2 = ZFSTest.misc_pool.makeName(b"@snap2")

	lzc.lzc_snapshot([snap1])
	lzc.lzc_snapshot([snap2])

	with self.assertRaises(lzc_exc.PoolsDiffer):
	lzc.lzc_snaprange_space(snap1, snap2)

	def test_snaprange_space_nonexistent(self):
	snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
	snap2 = ZFSTest.pool.makeName(b"fs1@snap2")

	lzc.lzc_snapshot([snap1])

	with self.assertRaises(lzc_exc.SnapshotNotFound) as ctx:
	lzc.lzc_snaprange_space(snap1, snap2)
	self.assertEqual(ctx.exception.name, snap2)

	with self.assertRaises(lzc_exc.SnapshotNotFound) as ctx:
	lzc.lzc_snaprange_space(snap2, snap1)
	self.assertEqual(ctx.exception.name, snap1)

	def test_snaprange_space_invalid_name(self):
	snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
	snap2 = ZFSTest.pool.makeName(b"fs1@sn#p")

	lzc.lzc_snapshot([snap1])

	with self.assertRaises(lzc_exc.NameInvalid):
	lzc.lzc_snaprange_space(snap1, snap2)

	def test_snaprange_space_not_snap(self):
	snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
	snap2 = ZFSTest.pool.makeName(b"fs1")

	lzc.lzc_snapshot([snap1])

	with self.assertRaises(lzc_exc.NameInvalid):
	lzc.lzc_snaprange_space(snap1, snap2)
	with self.assertRaises(lzc_exc.NameInvalid):
	lzc.lzc_snaprange_space(snap2, snap1)

	def test_snaprange_space_not_snap_2(self):
	snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
	snap2 = ZFSTest.pool.makeName(b"fs1#bmark")

	lzc.lzc_snapshot([snap1])

	with self.assertRaises(lzc_exc.NameInvalid):
	lzc.lzc_snaprange_space(snap1, snap2)
	with self.assertRaises(lzc_exc.NameInvalid):
	lzc.lzc_snaprange_space(snap2, snap1)

	def test_send_space(self):
	snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
	snap2 = ZFSTest.pool.makeName(b"fs1@snap2")
	snap3 = ZFSTest.pool.makeName(b"fs1@snap")

	lzc.lzc_snapshot([snap1])
	lzc.lzc_snapshot([snap2])
	lzc.lzc_snapshot([snap3])

	space = lzc.lzc_send_space(snap2, snap1)
	self.assertIsInstance(space, (int, int))
	space = lzc.lzc_send_space(snap3, snap2)
	self.assertIsInstance(space, (int, int))
	space = lzc.lzc_send_space(snap3, snap1)
	self.assertIsInstance(space, (int, int))
	space = lzc.lzc_send_space(snap1)
	self.assertIsInstance(space, (int, int))
	space = lzc.lzc_send_space(snap2)
	self.assertIsInstance(space, (int, int))
	space = lzc.lzc_send_space(snap3)
	self.assertIsInstance(space, (int, int))

	def test_send_space_2(self):
	snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
	snap2 = ZFSTest.pool.makeName(b"fs1@snap2")
	snap3 = ZFSTest.pool.makeName(b"fs1@snap")

	lzc.lzc_snapshot([snap1])
	with zfs_mount(ZFSTest.pool.makeName(b"fs1")) as mntdir:
	with tempfile.NamedTemporaryFile(dir=mntdir) as f:
	for i in range(1024):
	f.write(b'x' * 1024)
	f.flush()
	lzc.lzc_snapshot([snap2])
	lzc.lzc_snapshot([snap3])

	space = lzc.lzc_send_space(snap2, snap1)
	self.assertGreater(space, 1024 * 1024)

	space = lzc.lzc_send_space(snap3, snap2)

	space = lzc.lzc_send_space(snap3, snap1)

	space_empty = lzc.lzc_send_space(snap1)

	space = lzc.lzc_send_space(snap2)
	self.assertGreater(space, 1024 * 1024)

	space = lzc.lzc_send_space(snap3)
	self.assertEqual(space, space_empty)

	def test_send_space_same_snap(self):
	snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
	lzc.lzc_snapshot([snap1])
	with self.assertRaises(lzc_exc.SnapshotMismatch):
	lzc.lzc_send_space(snap1, snap1)

	def test_send_space_wrong_order(self):
	snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
	snap2 = ZFSTest.pool.makeName(b"fs1@snap2")

	lzc.lzc_snapshot([snap1])
	lzc.lzc_snapshot([snap2])

	with self.assertRaises(lzc_exc.SnapshotMismatch):
	lzc.lzc_send_space(snap1, snap2)

	def test_send_space_unrelated(self):
	snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
	snap2 = ZFSTest.pool.makeName(b"fs2@snap2")

	lzc.lzc_snapshot([snap1])
	lzc.lzc_snapshot([snap2])

	with self.assertRaises(lzc_exc.SnapshotMismatch):
	lzc.lzc_send_space(snap1, snap2)

	def test_send_space_across_pools(self):
	snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
	snap2 = ZFSTest.misc_pool.makeName(b"@snap2")

	lzc.lzc_snapshot([snap1])
	lzc.lzc_snapshot([snap2])

	with self.assertRaises(lzc_exc.PoolsDiffer):
	lzc.lzc_send_space(snap1, snap2)

	def test_send_space_nonexistent(self):
	snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
	snap2 = ZFSTest.pool.makeName(b"fs2@snap2")

	lzc.lzc_snapshot([snap1])

	with self.assertRaises(lzc_exc.SnapshotNotFound) as ctx:
	lzc.lzc_send_space(snap1, snap2)
	self.assertEqual(ctx.exception.name, snap1)

	with self.assertRaises(lzc_exc.SnapshotNotFound) as ctx:
	lzc.lzc_send_space(snap2, snap1)
	self.assertEqual(ctx.exception.name, snap2)

	with self.assertRaises(lzc_exc.SnapshotNotFound) as ctx:
	lzc.lzc_send_space(snap2)
	self.assertEqual(ctx.exception.name, snap2)

	def test_send_space_invalid_name(self):
	snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
	snap2 = ZFSTest.pool.makeName(b"fs1@sn!p")

	lzc.lzc_snapshot([snap1])

	with self.assertRaises(lzc_exc.NameInvalid) as ctx:
	lzc.lzc_send_space(snap2, snap1)
	self.assertEqual(ctx.exception.name, snap2)
	with self.assertRaises(lzc_exc.NameInvalid) as ctx:
	lzc.lzc_send_space(snap2)
	self.assertEqual(ctx.exception.name, snap2)
	with self.assertRaises(lzc_exc.NameInvalid) as ctx:
	lzc.lzc_send_space(snap1, snap2)
	self.assertEqual(ctx.exception.name, snap2)

	def test_send_space_not_snap(self):
	snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
	snap2 = ZFSTest.pool.makeName(b"fs1")

	lzc.lzc_snapshot([snap1])

	with self.assertRaises(lzc_exc.NameInvalid):
	lzc.lzc_send_space(snap1, snap2)
	with self.assertRaises(lzc_exc.NameInvalid):
	lzc.lzc_send_space(snap2, snap1)
	with self.assertRaises(lzc_exc.NameInvalid):
	lzc.lzc_send_space(snap2)

	def test_send_space_not_snap_2(self):
	snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
	snap2 = ZFSTest.pool.makeName(b"fs1#bmark")

	lzc.lzc_snapshot([snap1])

	with self.assertRaises(lzc_exc.NameInvalid):
	lzc.lzc_send_space(snap2, snap1)
	with self.assertRaises(lzc_exc.NameInvalid):
	lzc.lzc_send_space(snap2)

	def test_send_full(self):
	snap = ZFSTest.pool.makeName(b"fs1@snap")

	with zfs_mount(ZFSTest.pool.makeName(b"fs1")) as mntdir:
	with tempfile.NamedTemporaryFile(dir=mntdir) as f:
	for i in range(1024):
	f.write(b'x' * 1024)
	f.flush()
	lzc.lzc_snapshot([snap])

	with tempfile.TemporaryFile(suffix='.zstream') as output:
	estimate = lzc.lzc_send_space(snap)

	fd = output.fileno()
	lzc.lzc_send(snap, None, fd)
	st = os.fstat(fd)
	# 5%, arbitrary.
	self.assertAlmostEqual(st.st_size, estimate, delta=estimate // 20)

	def test_send_incremental(self):
	snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
	snap2 = ZFSTest.pool.makeName(b"fs1@snap2")

	lzc.lzc_snapshot([snap1])
	with zfs_mount(ZFSTest.pool.makeName(b"fs1")) as mntdir:
	with tempfile.NamedTemporaryFile(dir=mntdir) as f:
	for i in range(1024):
	f.write(b'x' * 1024)
	f.flush()
	lzc.lzc_snapshot([snap2])

	with tempfile.TemporaryFile(suffix='.zstream') as output:
	estimate = lzc.lzc_send_space(snap2, snap1)

	fd = output.fileno()
	lzc.lzc_send(snap2, snap1, fd)
	st = os.fstat(fd)
	# 5%, arbitrary.
	self.assertAlmostEqual(st.st_size, estimate, delta=estimate // 20)

	def test_send_flags(self):
	flags = ['embedded_data', 'large_blocks', 'compress', 'raw']
	snap = ZFSTest.pool.makeName(b"fs1@snap")
	lzc.lzc_snapshot([snap])

	for c in range(len(flags)):
	for flag in itertools.permutations(flags, c + 1):
	with dev_null() as fd:
	lzc.lzc_send(snap, None, fd, list(flag))

	def test_send_unknown_flags(self):
	snap = ZFSTest.pool.makeName(b"fs1@snap")
	lzc.lzc_snapshot([snap])
	with dev_null() as fd:
	with self.assertRaises(lzc_exc.UnknownStreamFeature):
	lzc.lzc_send(snap, None, fd, ['embedded_data', 'UNKNOWN'])

	def test_send_same_snap(self):
	snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
	lzc.lzc_snapshot([snap1])
	with tempfile.TemporaryFile(suffix='.zstream') as output:
	fd = output.fileno()
	with self.assertRaises(lzc_exc.SnapshotMismatch):
	lzc.lzc_send(snap1, snap1, fd)

	def test_send_wrong_order(self):
	snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
	snap2 = ZFSTest.pool.makeName(b"fs1@snap2")

	lzc.lzc_snapshot([snap1])
	lzc.lzc_snapshot([snap2])

	with tempfile.TemporaryFile(suffix='.zstream') as output:
	fd = output.fileno()
	with self.assertRaises(lzc_exc.SnapshotMismatch):
	lzc.lzc_send(snap1, snap2, fd)

	def test_send_unrelated(self):
	snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
	snap2 = ZFSTest.pool.makeName(b"fs2@snap2")

	lzc.lzc_snapshot([snap1])
	lzc.lzc_snapshot([snap2])

	with tempfile.TemporaryFile(suffix='.zstream') as output:
	fd = output.fileno()
	with self.assertRaises(lzc_exc.SnapshotMismatch):
	lzc.lzc_send(snap1, snap2, fd)

	def test_send_across_pools(self):
	snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
	snap2 = ZFSTest.misc_pool.makeName(b"@snap2")

	lzc.lzc_snapshot([snap1])
	lzc.lzc_snapshot([snap2])

	with tempfile.TemporaryFile(suffix='.zstream') as output:
	fd = output.fileno()
	with self.assertRaises(lzc_exc.PoolsDiffer):
	lzc.lzc_send(snap1, snap2, fd)

	def test_send_nonexistent(self):
	snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
	snap2 = ZFSTest.pool.makeName(b"fs1@snap2")

	lzc.lzc_snapshot([snap1])

	with tempfile.TemporaryFile(suffix='.zstream') as output:
	fd = output.fileno()
	with self.assertRaises(lzc_exc.SnapshotNotFound) as ctx:
	lzc.lzc_send(snap1, snap2, fd)
	self.assertEqual(ctx.exception.name, snap1)

	with self.assertRaises(lzc_exc.SnapshotNotFound) as ctx:
	lzc.lzc_send(snap2, snap1, fd)
	self.assertEqual(ctx.exception.name, snap2)

	with self.assertRaises(lzc_exc.SnapshotNotFound) as ctx:
	lzc.lzc_send(snap2, None, fd)
	self.assertEqual(ctx.exception.name, snap2)

	def test_send_invalid_name(self):
	snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
	snap2 = ZFSTest.pool.makeName(b"fs1@sn!p")

	lzc.lzc_snapshot([snap1])

	with tempfile.TemporaryFile(suffix='.zstream') as output:
	fd = output.fileno()
	with self.assertRaises(lzc_exc.NameInvalid) as ctx:
	lzc.lzc_send(snap2, snap1, fd)
	self.assertEqual(ctx.exception.name, snap2)
	with self.assertRaises(lzc_exc.NameInvalid) as ctx:
	lzc.lzc_send(snap2, None, fd)
	self.assertEqual(ctx.exception.name, snap2)
	with self.assertRaises(lzc_exc.NameInvalid) as ctx:
	lzc.lzc_send(snap1, snap2, fd)
	self.assertEqual(ctx.exception.name, snap2)

	# XXX Although undocumented the API allows to create an incremental
	# or full stream for a filesystem as if a temporary unnamed snapshot
	# is taken at some time after the call is made and before the stream
	# starts being produced.
	def test_send_filesystem(self):
	snap = ZFSTest.pool.makeName(b"fs1@snap1")
	fs = ZFSTest.pool.makeName(b"fs1")

	lzc.lzc_snapshot([snap])

	with tempfile.TemporaryFile(suffix='.zstream') as output:
	fd = output.fileno()
	lzc.lzc_send(fs, snap, fd)
	lzc.lzc_send(fs, None, fd)

	def test_send_from_filesystem(self):
	snap = ZFSTest.pool.makeName(b"fs1@snap1")
	fs = ZFSTest.pool.makeName(b"fs1")

	lzc.lzc_snapshot([snap])

	with tempfile.TemporaryFile(suffix='.zstream') as output:
	fd = output.fileno()
	with self.assertRaises(lzc_exc.NameInvalid):
	lzc.lzc_send(snap, fs, fd)

	@skipUnlessBookmarksSupported
	def test_send_bookmark(self):
	snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
	snap2 = ZFSTest.pool.makeName(b"fs1@snap2")
	bmark = ZFSTest.pool.makeName(b"fs1#bmark")

	lzc.lzc_snapshot([snap1])
	lzc.lzc_snapshot([snap2])
	lzc.lzc_bookmark({bmark: snap2})
	lzc.lzc_destroy_snaps([snap2], defer=False)

	with tempfile.TemporaryFile(suffix='.zstream') as output:
	fd = output.fileno()
	with self.assertRaises(lzc_exc.NameInvalid):
	lzc.lzc_send(bmark, snap1, fd)
	with self.assertRaises(lzc_exc.NameInvalid):
	lzc.lzc_send(bmark, None, fd)

	@skipUnlessBookmarksSupported
	def test_send_from_bookmark(self):
	snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
	snap2 = ZFSTest.pool.makeName(b"fs1@snap2")
	bmark = ZFSTest.pool.makeName(b"fs1#bmark")

	lzc.lzc_snapshot([snap1])
	lzc.lzc_snapshot([snap2])
	lzc.lzc_bookmark({bmark: snap1})
	lzc.lzc_destroy_snaps([snap1], defer=False)

	with tempfile.TemporaryFile(suffix='.zstream') as output:
	fd = output.fileno()
	lzc.lzc_send(snap2, bmark, fd)

	def test_send_bad_fd(self):
	snap = ZFSTest.pool.makeName(b"fs1@snap")
	lzc.lzc_snapshot([snap])

	with tempfile.TemporaryFile() as tmp:
	bad_fd = tmp.fileno()

	with self.assertRaises(lzc_exc.StreamIOError) as ctx:
	lzc.lzc_send(snap, None, bad_fd)
	self.assertEqual(ctx.exception.errno, errno.EBADF)

	def test_send_bad_fd_2(self):
	snap = ZFSTest.pool.makeName(b"fs1@snap")
	lzc.lzc_snapshot([snap])

	with self.assertRaises(lzc_exc.StreamIOError) as ctx:
	lzc.lzc_send(snap, None, -2)
	self.assertEqual(ctx.exception.errno, errno.EBADF)

	def test_send_bad_fd_3(self):
	snap = ZFSTest.pool.makeName(b"fs1@snap")
	lzc.lzc_snapshot([snap])

	with tempfile.TemporaryFile() as tmp:
	bad_fd = tmp.fileno()

	(soft, hard) = resource.getrlimit(resource.RLIMIT_NOFILE)
	bad_fd = hard + 1
	with self.assertRaises(lzc_exc.StreamIOError) as ctx:
	lzc.lzc_send(snap, None, bad_fd)
	self.assertEqual(ctx.exception.errno, errno.EBADF)

	def test_send_to_broken_pipe(self):
	snap = ZFSTest.pool.makeName(b"fs1@snap")
	lzc.lzc_snapshot([snap])

	if sys.version_info < (3, 0):
	proc = subprocess.Popen(['true'], stdin=subprocess.PIPE)
	proc.wait()
	with self.assertRaises(lzc_exc.StreamIOError) as ctx:
	lzc.lzc_send(snap, None, proc.stdin.fileno())
	self.assertEqual(ctx.exception.errno, errno.EPIPE)
	else:
	with subprocess.Popen(['true'], stdin=subprocess.PIPE) as proc:
	proc.wait()
	with self.assertRaises(lzc_exc.StreamIOError) as ctx:
	lzc.lzc_send(snap, None, proc.stdin.fileno())
	self.assertEqual(ctx.exception.errno, errno.EPIPE)

	def test_send_to_broken_pipe_2(self):
	snap = ZFSTest.pool.makeName(b"fs1@snap")
	with zfs_mount(ZFSTest.pool.makeName(b"fs1")) as mntdir:
	with tempfile.NamedTemporaryFile(dir=mntdir) as f:
	for i in range(1024):
	f.write(b'x' * 1024)
	f.flush()
	lzc.lzc_snapshot([snap])

	if sys.version_info < (3, 0):
	p = subprocess.Popen(['sleep', '2'], stdin=subprocess.PIPE)
	with self.assertRaises(lzc_exc.StreamIOError) as ctx:
	lzc.lzc_send(snap, None, p.stdin.fileno())
	self.assertTrue(ctx.exception.errno == errno.EPIPE or
	ctx.exception.errno == errno.EINTR)
	else:
	with subprocess.Popen(['sleep', '2'], stdin=subprocess.PIPE) as p:
	with self.assertRaises(lzc_exc.StreamIOError) as ctx:
	lzc.lzc_send(snap, None, p.stdin.fileno())
	self.assertTrue(ctx.exception.errno == errno.EPIPE or
	ctx.exception.errno == errno.EINTR)

	def test_send_to_ro_file(self):
	snap = ZFSTest.pool.makeName(b"fs1@snap")
	lzc.lzc_snapshot([snap])

	with tempfile.NamedTemporaryFile(
	suffix='.zstream', delete=False) as output:
	# tempfile always opens a temporary file in read-write mode
	# regardless of the specified mode, so we have to open it again.
	os.chmod(output.name, stat.S_IRUSR)
	fd = os.open(output.name, os.O_RDONLY)
	with self.assertRaises(lzc_exc.StreamIOError) as ctx:
	lzc.lzc_send(snap, None, fd)
	os.close(fd)
	self.assertEqual(ctx.exception.errno, errno.EBADF)

	def test_recv_full(self):
	src = ZFSTest.pool.makeName(b"fs1@snap")
	dst = ZFSTest.pool.makeName(b"fs2/received-1@snap")

	with temp_file_in_fs(ZFSTest.pool.makeName(b"fs1")) as name:
	lzc.lzc_snapshot([src])

	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(src, None, stream.fileno())
	stream.seek(0)
	lzc.lzc_receive(dst, stream.fileno())

	name = os.path.basename(name)
	with zfs_mount(src) as mnt1, zfs_mount(dst) as mnt2:
	self.assertTrue(
	filecmp.cmp(
	os.path.join(mnt1, name), os.path.join(mnt2, name), False))

	def test_recv_incremental(self):
	src1 = ZFSTest.pool.makeName(b"fs1@snap1")
	src2 = ZFSTest.pool.makeName(b"fs1@snap2")
	dst1 = ZFSTest.pool.makeName(b"fs2/received-2@snap1")
	dst2 = ZFSTest.pool.makeName(b"fs2/received-2@snap2")

	lzc.lzc_snapshot([src1])
	with temp_file_in_fs(ZFSTest.pool.makeName(b"fs1")) as name:
	lzc.lzc_snapshot([src2])

	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(src1, None, stream.fileno())
	stream.seek(0)
	lzc.lzc_receive(dst1, stream.fileno())
	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(src2, src1, stream.fileno())
	stream.seek(0)
	lzc.lzc_receive(dst2, stream.fileno())

	name = os.path.basename(name)
	with zfs_mount(src2) as mnt1, zfs_mount(dst2) as mnt2:
	self.assertTrue(
	filecmp.cmp(
	os.path.join(mnt1, name), os.path.join(mnt2, name), False))

	# This test case fails unless a patch from
	# https://clusterhq.atlassian.net/browse/ZFS-20
	# is applied to libzfs_core, otherwise it succeeds.
	@unittest.skip("fails with unpatched libzfs_core")
	def test_recv_without_explicit_snap_name(self):
	srcfs = ZFSTest.pool.makeName(b"fs1")
	src1 = srcfs + b"@snap1"
	src2 = srcfs + b"@snap2"
	dstfs = ZFSTest.pool.makeName(b"fs2/received-100")
	dst1 = dstfs + b'@snap1'
	dst2 = dstfs + b'@snap2'

	with streams(srcfs, src1, src2) as (_, (full, incr)):
	lzc.lzc_receive(dstfs, full.fileno())
	lzc.lzc_receive(dstfs, incr.fileno())
	self.assertExists(dst1)
	self.assertExists(dst2)

	def test_recv_clone(self):
	orig_src = ZFSTest.pool.makeName(b"fs2@send-origin")
	clone = ZFSTest.pool.makeName(b"fs1/fs/send-clone")
	clone_snap = clone + b"@snap"
	orig_dst = ZFSTest.pool.makeName(b"fs1/fs/recv-origin@snap")
	clone_dst = ZFSTest.pool.makeName(b"fs1/fs/recv-clone@snap")

	lzc.lzc_snapshot([orig_src])
	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(orig_src, None, stream.fileno())
	stream.seek(0)
	lzc.lzc_receive(orig_dst, stream.fileno())

	lzc.lzc_clone(clone, orig_src)
	lzc.lzc_snapshot([clone_snap])
	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(clone_snap, orig_src, stream.fileno())
	stream.seek(0)
	lzc.lzc_receive(clone_dst, stream.fileno(), origin=orig_dst)

	def test_recv_full_already_existing_empty_fs(self):
	src = ZFSTest.pool.makeName(b"fs1@snap")
	dstfs = ZFSTest.pool.makeName(b"fs2/received-3")
	dst = dstfs + b'@snap'

	with temp_file_in_fs(ZFSTest.pool.makeName(b"fs1")):
	lzc.lzc_snapshot([src])
	lzc.lzc_create(dstfs)
	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(src, None, stream.fileno())
	stream.seek(0)
	with self.assertRaises((
	lzc_exc.DestinationModified, lzc_exc.DatasetExists)):
	lzc.lzc_receive(dst, stream.fileno())

	def test_recv_full_into_root_empty_pool(self):
	empty_pool = None
	try:
	srcfs = ZFSTest.pool.makeName(b"fs1")
	empty_pool = _TempPool()
	dst = empty_pool.makeName(b'@snap')

	with streams(srcfs, b"snap", None) as (_, (stream, _)):
	with self.assertRaises((
	lzc_exc.DestinationModified, lzc_exc.DatasetExists)):
	lzc.lzc_receive(dst, stream.fileno())
	finally:
	if empty_pool is not None:
	empty_pool.cleanUp()

	def test_recv_full_into_ro_pool(self):
	srcfs = ZFSTest.pool.makeName(b"fs1")
	dst = ZFSTest.readonly_pool.makeName(b'fs2/received@snap')

	with streams(srcfs, b"snap", None) as (_, (stream, _)):
	with self.assertRaises(lzc_exc.ReadOnlyPool):
	lzc.lzc_receive(dst, stream.fileno())

	def test_recv_full_already_existing_modified_fs(self):
	src = ZFSTest.pool.makeName(b"fs1@snap")
	dstfs = ZFSTest.pool.makeName(b"fs2/received-5")
	dst = dstfs + b'@snap'

	with temp_file_in_fs(ZFSTest.pool.makeName(b"fs1")):
	lzc.lzc_snapshot([src])
	lzc.lzc_create(dstfs)
	with temp_file_in_fs(dstfs):
	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(src, None, stream.fileno())
	stream.seek(0)
	with self.assertRaises((
	lzc_exc.DestinationModified, lzc_exc.DatasetExists)):
	lzc.lzc_receive(dst, stream.fileno())

	def test_recv_full_already_existing_with_snapshots(self):
	src = ZFSTest.pool.makeName(b"fs1@snap")
	dstfs = ZFSTest.pool.makeName(b"fs2/received-4")
	dst = dstfs + b'@snap'

	with temp_file_in_fs(ZFSTest.pool.makeName(b"fs1")):
	lzc.lzc_snapshot([src])
	lzc.lzc_create(dstfs)
	lzc.lzc_snapshot([dstfs + b"@snap1"])
	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(src, None, stream.fileno())
	stream.seek(0)
	with self.assertRaises((
	lzc_exc.StreamMismatch, lzc_exc.DatasetExists)):
	lzc.lzc_receive(dst, stream.fileno())

	def test_recv_full_already_existing_snapshot(self):
	src = ZFSTest.pool.makeName(b"fs1@snap")
	dstfs = ZFSTest.pool.makeName(b"fs2/received-6")
	dst = dstfs + b'@snap'

	with temp_file_in_fs(ZFSTest.pool.makeName(b"fs1")):
	lzc.lzc_snapshot([src])
	lzc.lzc_create(dstfs)
	lzc.lzc_snapshot([dst])
	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(src, None, stream.fileno())
	stream.seek(0)
	with self.assertRaises(lzc_exc.DatasetExists):
	lzc.lzc_receive(dst, stream.fileno())

	def test_recv_full_missing_parent_fs(self):
	src = ZFSTest.pool.makeName(b"fs1@snap")
	dst = ZFSTest.pool.makeName(b"fs2/nonexistent/fs@snap")

	with temp_file_in_fs(ZFSTest.pool.makeName(b"fs1")):
	lzc.lzc_snapshot([src])
	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(src, None, stream.fileno())
	stream.seek(0)
	with self.assertRaises(lzc_exc.DatasetNotFound):
	lzc.lzc_receive(dst, stream.fileno())

	def test_recv_full_but_specify_origin(self):
	srcfs = ZFSTest.pool.makeName(b"fs1")
	src = srcfs + b"@snap"
	dstfs = ZFSTest.pool.makeName(b"fs2/received-30")
	dst = dstfs + b'@snap'
	origin1 = ZFSTest.pool.makeName(b"fs2@snap1")
	origin2 = ZFSTest.pool.makeName(b"fs2@snap2")

	lzc.lzc_snapshot([origin1])
	with streams(srcfs, src, None) as (_, (stream, _)):
	lzc.lzc_receive(dst, stream.fileno(), origin=origin1)
	origin = ZFSTest.pool.getFilesystem(
	b"fs2/received-30").getProperty('origin')
	self.assertEqual(origin, origin1)
	stream.seek(0)
	# because origin snap does not exist can't receive as a clone of it
	with self.assertRaises((
	lzc_exc.DatasetNotFound,
	lzc_exc.BadStream)):
	lzc.lzc_receive(dst, stream.fileno(), origin=origin2)

	def test_recv_full_existing_empty_fs_and_origin(self):
	srcfs = ZFSTest.pool.makeName(b"fs1")
	src = srcfs + b"@snap"
	dstfs = ZFSTest.pool.makeName(b"fs2/received-31")
	dst = dstfs + b'@snap'
	origin = dstfs + b'@dummy'

	lzc.lzc_create(dstfs)
	with streams(srcfs, src, None) as (_, (stream, _)):
	# because the destination fs already exists and has no snaps
	with self.assertRaises((
	lzc_exc.DestinationModified,
	lzc_exc.DatasetExists,
	lzc_exc.BadStream)):
	lzc.lzc_receive(dst, stream.fileno(), origin=origin)
	lzc.lzc_snapshot([origin])
	stream.seek(0)
	# because the destination fs already exists and has the snap
	with self.assertRaises((
	lzc_exc.StreamMismatch,
	lzc_exc.DatasetExists,
	lzc_exc.BadStream)):
	lzc.lzc_receive(dst, stream.fileno(), origin=origin)

	def test_recv_incremental_mounted_fs(self):
	srcfs = ZFSTest.pool.makeName(b"fs1")
	src1 = srcfs + b"@snap1"
	src2 = srcfs + b"@snap2"
	dstfs = ZFSTest.pool.makeName(b"fs2/received-7")
	dst1 = dstfs + b'@snap1'
	dst2 = dstfs + b'@snap2'

	with streams(srcfs, src1, src2) as (_, (full, incr)):
	lzc.lzc_receive(dst1, full.fileno())
	with zfs_mount(dstfs):
	lzc.lzc_receive(dst2, incr.fileno())

	def test_recv_incremental_modified_fs(self):
	srcfs = ZFSTest.pool.makeName(b"fs1")
	src1 = srcfs + b"@snap1"
	src2 = srcfs + b"@snap2"
	dstfs = ZFSTest.pool.makeName(b"fs2/received-15")
	dst1 = dstfs + b'@snap1'
	dst2 = dstfs + b'@snap2'

	with streams(srcfs, src1, src2) as (_, (full, incr)):
	lzc.lzc_receive(dst1, full.fileno())
	with temp_file_in_fs(dstfs):
	with self.assertRaises(lzc_exc.DestinationModified):
	lzc.lzc_receive(dst2, incr.fileno())

	def test_recv_incremental_snapname_used(self):
	srcfs = ZFSTest.pool.makeName(b"fs1")
	src1 = srcfs + b"@snap1"
	src2 = srcfs + b"@snap2"
	dstfs = ZFSTest.pool.makeName(b"fs2/received-8")
	dst1 = dstfs + b'@snap1'
	dst2 = dstfs + b'@snap2'

	with streams(srcfs, src1, src2) as (_, (full, incr)):
	lzc.lzc_receive(dst1, full.fileno())
	lzc.lzc_snapshot([dst2])
	with self.assertRaises(lzc_exc.DatasetExists):
	lzc.lzc_receive(dst2, incr.fileno())

	def test_recv_incremental_more_recent_snap_with_no_changes(self):
	srcfs = ZFSTest.pool.makeName(b"fs1")
	src1 = srcfs + b"@snap1"
	src2 = srcfs + b"@snap2"
	dstfs = ZFSTest.pool.makeName(b"fs2/received-9")
	dst1 = dstfs + b'@snap1'
	dst2 = dstfs + b'@snap2'
	dst_snap = dstfs + b'@snap'

	with streams(srcfs, src1, src2) as (_, (full, incr)):
	lzc.lzc_receive(dst1, full.fileno())
	lzc.lzc_snapshot([dst_snap])
	lzc.lzc_receive(dst2, incr.fileno())

	def test_recv_incremental_non_clone_but_set_origin(self):
	srcfs = ZFSTest.pool.makeName(b"fs1")
	src1 = srcfs + b"@snap1"
	src2 = srcfs + b"@snap2"
	dstfs = ZFSTest.pool.makeName(b"fs2/received-20")
	dst1 = dstfs + b'@snap1'
	dst2 = dstfs + b'@snap2'
	dst_snap = dstfs + b'@snap'

	with streams(srcfs, src1, src2) as (_, (full, incr)):
	lzc.lzc_receive(dst1, full.fileno())
	lzc.lzc_snapshot([dst_snap])
	# because cannot receive incremental and set origin on a non-clone
	with self.assertRaises(lzc_exc.BadStream):
	lzc.lzc_receive(dst2, incr.fileno(), origin=dst1)

	def test_recv_incremental_non_clone_but_set_random_origin(self):
	srcfs = ZFSTest.pool.makeName(b"fs1")
	src1 = srcfs + b"@snap1"
	src2 = srcfs + b"@snap2"
	dstfs = ZFSTest.pool.makeName(b"fs2/received-21")
	dst1 = dstfs + b'@snap1'
	dst2 = dstfs + b'@snap2'
	dst_snap = dstfs + b'@snap'

	with streams(srcfs, src1, src2) as (_, (full, incr)):
	lzc.lzc_receive(dst1, full.fileno())
	lzc.lzc_snapshot([dst_snap])
	# because origin snap does not exist can't receive as a clone of it
	with self.assertRaises((
	lzc_exc.DatasetNotFound,
	lzc_exc.BadStream)):
	lzc.lzc_receive(
	dst2, incr.fileno(),
	origin=ZFSTest.pool.makeName(b"fs2/fs@snap"))

	def test_recv_incremental_more_recent_snap(self):
	srcfs = ZFSTest.pool.makeName(b"fs1")
	src1 = srcfs + b"@snap1"
	src2 = srcfs + b"@snap2"
	dstfs = ZFSTest.pool.makeName(b"fs2/received-10")
	dst1 = dstfs + b'@snap1'
	dst2 = dstfs + b'@snap2'
	dst_snap = dstfs + b'@snap'

	with streams(srcfs, src1, src2) as (_, (full, incr)):
	lzc.lzc_receive(dst1, full.fileno())
	with temp_file_in_fs(dstfs):
	lzc.lzc_snapshot([dst_snap])
	with self.assertRaises(lzc_exc.DestinationModified):
	lzc.lzc_receive(dst2, incr.fileno())

	def test_recv_incremental_duplicate(self):
	srcfs = ZFSTest.pool.makeName(b"fs1")
	src1 = srcfs + b"@snap1"
	src2 = srcfs + b"@snap2"
	dstfs = ZFSTest.pool.makeName(b"fs2/received-11")
	dst1 = dstfs + b'@snap1'
	dst2 = dstfs + b'@snap2'
	dst_snap = dstfs + b'@snap'

	with streams(srcfs, src1, src2) as (_, (full, incr)):
	lzc.lzc_receive(dst1, full.fileno())
	lzc.lzc_receive(dst2, incr.fileno())
	incr.seek(0)
	with self.assertRaises(lzc_exc.DestinationModified):
	lzc.lzc_receive(dst_snap, incr.fileno())

	def test_recv_incremental_unrelated_fs(self):
	srcfs = ZFSTest.pool.makeName(b"fs1")
	src1 = srcfs + b"@snap1"
	src2 = srcfs + b"@snap2"
	dstfs = ZFSTest.pool.makeName(b"fs2/received-12")
	dst_snap = dstfs + b'@snap'

	with streams(srcfs, src1, src2) as (_, (_, incr)):
	lzc.lzc_create(dstfs)
	with self.assertRaises(lzc_exc.StreamMismatch):
	lzc.lzc_receive(dst_snap, incr.fileno())

	def test_recv_incremental_nonexistent_fs(self):
	srcfs = ZFSTest.pool.makeName(b"fs1")
	src1 = srcfs + b"@snap1"
	src2 = srcfs + b"@snap2"
	dstfs = ZFSTest.pool.makeName(b"fs2/received-13")
	dst_snap = dstfs + b'@snap'

	with streams(srcfs, src1, src2) as (_, (_, incr)):
	with self.assertRaises(lzc_exc.DatasetNotFound):
	lzc.lzc_receive(dst_snap, incr.fileno())

	def test_recv_incremental_same_fs(self):
	srcfs = ZFSTest.pool.makeName(b"fs1")
	src1 = srcfs + b"@snap1"
	src2 = srcfs + b"@snap2"
	src_snap = srcfs + b'@snap'

	with streams(srcfs, src1, src2) as (_, (_, incr)):
	with self.assertRaises(lzc_exc.DestinationModified):
	lzc.lzc_receive(src_snap, incr.fileno())

	def test_recv_clone_without_specifying_origin(self):
	orig_src = ZFSTest.pool.makeName(b"fs2@send-origin-2")
	clone = ZFSTest.pool.makeName(b"fs1/fs/send-clone-2")
	clone_snap = clone + b"@snap"
	orig_dst = ZFSTest.pool.makeName(b"fs1/fs/recv-origin-2@snap")
	clone_dst = ZFSTest.pool.makeName(b"fs1/fs/recv-clone-2@snap")

	lzc.lzc_snapshot([orig_src])
	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(orig_src, None, stream.fileno())
	stream.seek(0)
	lzc.lzc_receive(orig_dst, stream.fileno())

	lzc.lzc_clone(clone, orig_src)
	lzc.lzc_snapshot([clone_snap])
	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(clone_snap, orig_src, stream.fileno())
	stream.seek(0)
	with self.assertRaises(lzc_exc.BadStream):
	lzc.lzc_receive(clone_dst, stream.fileno())

	def test_recv_clone_invalid_origin(self):
	orig_src = ZFSTest.pool.makeName(b"fs2@send-origin-3")
	clone = ZFSTest.pool.makeName(b"fs1/fs/send-clone-3")
	clone_snap = clone + b"@snap"
	orig_dst = ZFSTest.pool.makeName(b"fs1/fs/recv-origin-3@snap")
	clone_dst = ZFSTest.pool.makeName(b"fs1/fs/recv-clone-3@snap")

	lzc.lzc_snapshot([orig_src])
	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(orig_src, None, stream.fileno())
	stream.seek(0)
	lzc.lzc_receive(orig_dst, stream.fileno())

	lzc.lzc_clone(clone, orig_src)
	lzc.lzc_snapshot([clone_snap])
	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(clone_snap, orig_src, stream.fileno())
	stream.seek(0)
	with self.assertRaises(lzc_exc.NameInvalid):
	lzc.lzc_receive(
	clone_dst, stream.fileno(),
	origin=ZFSTest.pool.makeName(b"fs1/fs"))

	def test_recv_clone_wrong_origin(self):
	orig_src = ZFSTest.pool.makeName(b"fs2@send-origin-4")
	clone = ZFSTest.pool.makeName(b"fs1/fs/send-clone-4")
	clone_snap = clone + b"@snap"
	orig_dst = ZFSTest.pool.makeName(b"fs1/fs/recv-origin-4@snap")
	clone_dst = ZFSTest.pool.makeName(b"fs1/fs/recv-clone-4@snap")
	wrong_origin = ZFSTest.pool.makeName(b"fs1/fs@snap")

	lzc.lzc_snapshot([orig_src])
	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(orig_src, None, stream.fileno())
	stream.seek(0)
	lzc.lzc_receive(orig_dst, stream.fileno())

	lzc.lzc_clone(clone, orig_src)
	lzc.lzc_snapshot([clone_snap])
	lzc.lzc_snapshot([wrong_origin])
	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(clone_snap, orig_src, stream.fileno())
	stream.seek(0)
	with self.assertRaises(lzc_exc.StreamMismatch):
	lzc.lzc_receive(
	clone_dst, stream.fileno(), origin=wrong_origin)

	def test_recv_clone_nonexistent_origin(self):
	orig_src = ZFSTest.pool.makeName(b"fs2@send-origin-5")
	clone = ZFSTest.pool.makeName(b"fs1/fs/send-clone-5")
	clone_snap = clone + b"@snap"
	orig_dst = ZFSTest.pool.makeName(b"fs1/fs/recv-origin-5@snap")
	clone_dst = ZFSTest.pool.makeName(b"fs1/fs/recv-clone-5@snap")
	wrong_origin = ZFSTest.pool.makeName(b"fs1/fs@snap")

	lzc.lzc_snapshot([orig_src])
	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(orig_src, None, stream.fileno())
	stream.seek(0)
	lzc.lzc_receive(orig_dst, stream.fileno())

	lzc.lzc_clone(clone, orig_src)
	lzc.lzc_snapshot([clone_snap])
	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(clone_snap, orig_src, stream.fileno())
	stream.seek(0)
	with self.assertRaises(lzc_exc.DatasetNotFound):
	lzc.lzc_receive(
	clone_dst, stream.fileno(), origin=wrong_origin)

	def test_force_recv_full_existing_fs(self):
	src = ZFSTest.pool.makeName(b"fs1@snap")
	dstfs = ZFSTest.pool.makeName(b"fs2/received-50")
	dst = dstfs + b'@snap'

	with temp_file_in_fs(ZFSTest.pool.makeName(b"fs1")):
	lzc.lzc_snapshot([src])

	lzc.lzc_create(dstfs)
	with temp_file_in_fs(dstfs):
	pass # enough to taint the fs

	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(src, None, stream.fileno())
	stream.seek(0)
	lzc.lzc_receive(dst, stream.fileno(), force=True)

	def test_force_recv_full_existing_modified_mounted_fs(self):
	src = ZFSTest.pool.makeName(b"fs1@snap")
	dstfs = ZFSTest.pool.makeName(b"fs2/received-53")
	dst = dstfs + b'@snap'

	with temp_file_in_fs(ZFSTest.pool.makeName(b"fs1")):
	lzc.lzc_snapshot([src])

	lzc.lzc_create(dstfs)

	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(src, None, stream.fileno())
	stream.seek(0)
	with zfs_mount(dstfs) as mntdir:
	f = tempfile.NamedTemporaryFile(dir=mntdir, delete=False)
	for i in range(1024):
	f.write(b'x' * 1024)
	lzc.lzc_receive(dst, stream.fileno(), force=True)
	# The temporary file disappears and any access, even close(),
	# results in EIO.
	self.assertFalse(os.path.exists(f.name))
	with self.assertRaises(IOError):
	f.close()

	# This test-case expects the behavior that should be there,
	# at the moment it may fail with DatasetExists or StreamMismatch
	# depending on the implementation.
	def test_force_recv_full_already_existing_with_snapshots(self):
	src = ZFSTest.pool.makeName(b"fs1@snap")
	dstfs = ZFSTest.pool.makeName(b"fs2/received-51")
	dst = dstfs + b'@snap'

	with temp_file_in_fs(ZFSTest.pool.makeName(b"fs1")):
	lzc.lzc_snapshot([src])

	lzc.lzc_create(dstfs)
	with temp_file_in_fs(dstfs):
	pass # enough to taint the fs
	lzc.lzc_snapshot([dstfs + b"@snap1"])

	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(src, None, stream.fileno())
	stream.seek(0)
	lzc.lzc_receive(dst, stream.fileno(), force=True)

	def test_force_recv_full_already_existing_with_same_snap(self):
	src = ZFSTest.pool.makeName(b"fs1@snap")
	dstfs = ZFSTest.pool.makeName(b"fs2/received-52")
	dst = dstfs + b'@snap'

	with temp_file_in_fs(ZFSTest.pool.makeName(b"fs1")):
	lzc.lzc_snapshot([src])

	lzc.lzc_create(dstfs)
	with temp_file_in_fs(dstfs):
	pass # enough to taint the fs
	lzc.lzc_snapshot([dst])

	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(src, None, stream.fileno())
	stream.seek(0)
	with self.assertRaises(lzc_exc.DatasetExists):
	lzc.lzc_receive(dst, stream.fileno(), force=True)

	def test_force_recv_full_missing_parent_fs(self):
	src = ZFSTest.pool.makeName(b"fs1@snap")
	dst = ZFSTest.pool.makeName(b"fs2/nonexistent/fs@snap")

	with temp_file_in_fs(ZFSTest.pool.makeName(b"fs1")):
	lzc.lzc_snapshot([src])
	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(src, None, stream.fileno())
	stream.seek(0)
	with self.assertRaises(lzc_exc.DatasetNotFound):
	lzc.lzc_receive(dst, stream.fileno(), force=True)

	def test_force_recv_incremental_modified_fs(self):
	srcfs = ZFSTest.pool.makeName(b"fs1")
	src1 = srcfs + b"@snap1"
	src2 = srcfs + b"@snap2"
	dstfs = ZFSTest.pool.makeName(b"fs2/received-60")
	dst1 = dstfs + b'@snap1'
	dst2 = dstfs + b'@snap2'

	with streams(srcfs, src1, src2) as (_, (full, incr)):
	lzc.lzc_receive(dst1, full.fileno())
	with temp_file_in_fs(dstfs):
	pass # enough to taint the fs
	lzc.lzc_receive(dst2, incr.fileno(), force=True)

	def test_force_recv_incremental_modified_mounted_fs(self):
	srcfs = ZFSTest.pool.makeName(b"fs1")
	src1 = srcfs + b"@snap1"
	src2 = srcfs + b"@snap2"
	dstfs = ZFSTest.pool.makeName(b"fs2/received-64")
	dst1 = dstfs + b'@snap1'
	dst2 = dstfs + b'@snap2'

	with streams(srcfs, src1, src2) as (_, (full, incr)):
	lzc.lzc_receive(dst1, full.fileno())
	with zfs_mount(dstfs) as mntdir:
	f = tempfile.NamedTemporaryFile(dir=mntdir, delete=False)
	for i in range(1024):
	f.write(b'x' * 1024)
	lzc.lzc_receive(dst2, incr.fileno(), force=True)
	# The temporary file disappears and any access, even close(),
	# results in EIO.
	self.assertFalse(os.path.exists(f.name))
	with self.assertRaises(IOError):
	f.close()

	def test_force_recv_incremental_modified_fs_plus_later_snap(self):
	srcfs = ZFSTest.pool.makeName(b"fs1")
	src1 = srcfs + b"@snap1"
	src2 = srcfs + b"@snap2"
	dstfs = ZFSTest.pool.makeName(b"fs2/received-61")
	dst1 = dstfs + b'@snap1'
	dst2 = dstfs + b'@snap2'
	dst3 = dstfs + b'@snap'

	with streams(srcfs, src1, src2) as (_, (full, incr)):
	lzc.lzc_receive(dst1, full.fileno())
	with temp_file_in_fs(dstfs):
	pass # enough to taint the fs
	lzc.lzc_snapshot([dst3])
	lzc.lzc_receive(dst2, incr.fileno(), force=True)
	self.assertExists(dst1)
	self.assertExists(dst2)
	self.assertNotExists(dst3)

	def test_force_recv_incremental_modified_fs_plus_same_name_snap(self):
	srcfs = ZFSTest.pool.makeName(b"fs1")
	src1 = srcfs + b"@snap1"
	src2 = srcfs + b"@snap2"
	dstfs = ZFSTest.pool.makeName(b"fs2/received-62")
	dst1 = dstfs + b'@snap1'
	dst2 = dstfs + b'@snap2'

	with streams(srcfs, src1, src2) as (_, (full, incr)):
	lzc.lzc_receive(dst1, full.fileno())
	with temp_file_in_fs(dstfs):
	pass # enough to taint the fs
	lzc.lzc_snapshot([dst2])
	with self.assertRaises(lzc_exc.DatasetExists):
	lzc.lzc_receive(dst2, incr.fileno(), force=True)

	def test_force_recv_incremental_modified_fs_plus_held_snap(self):
	srcfs = ZFSTest.pool.makeName(b"fs1")
	src1 = srcfs + b"@snap1"
	src2 = srcfs + b"@snap2"
	dstfs = ZFSTest.pool.makeName(b"fs2/received-63")
	dst1 = dstfs + b'@snap1'
	dst2 = dstfs + b'@snap2'
	dst3 = dstfs + b'@snap'

	with streams(srcfs, src1, src2) as (_, (full, incr)):
	lzc.lzc_receive(dst1, full.fileno())
	with temp_file_in_fs(dstfs):
	pass # enough to taint the fs
	lzc.lzc_snapshot([dst3])
	with cleanup_fd() as cfd:
	lzc.lzc_hold({dst3: b'tag'}, cfd)
	with self.assertRaises(lzc_exc.DatasetBusy):
	lzc.lzc_receive(dst2, incr.fileno(), force=True)
	self.assertExists(dst1)
	self.assertNotExists(dst2)
	self.assertExists(dst3)

	def test_force_recv_incremental_modified_fs_plus_cloned_snap(self):
	srcfs = ZFSTest.pool.makeName(b"fs1")
	src1 = srcfs + b"@snap1"
	src2 = srcfs + b"@snap2"
	dstfs = ZFSTest.pool.makeName(b"fs2/received-70")
	dst1 = dstfs + b'@snap1'
	dst2 = dstfs + b'@snap2'
	dst3 = dstfs + b'@snap'
	cloned = ZFSTest.pool.makeName(b"fs2/received-cloned-70")

	with streams(srcfs, src1, src2) as (_, (full, incr)):
	lzc.lzc_receive(dst1, full.fileno())
	with temp_file_in_fs(dstfs):
	pass # enough to taint the fs
	lzc.lzc_snapshot([dst3])
	lzc.lzc_clone(cloned, dst3)
	with self.assertRaises(lzc_exc.DatasetExists):
	lzc.lzc_receive(dst2, incr.fileno(), force=True)
	self.assertExists(dst1)
	self.assertNotExists(dst2)
	self.assertExists(dst3)

	def test_recv_incremental_into_cloned_fs(self):
	srcfs = ZFSTest.pool.makeName(b"fs1")
	src1 = srcfs + b"@snap1"
	src2 = srcfs + b"@snap2"
	dstfs = ZFSTest.pool.makeName(b"fs2/received-71")
	dst1 = dstfs + b'@snap1'
	cloned = ZFSTest.pool.makeName(b"fs2/received-cloned-71")
	dst2 = cloned + b'@snap'

	with streams(srcfs, src1, src2) as (_, (full, incr)):
	lzc.lzc_receive(dst1, full.fileno())
	lzc.lzc_clone(cloned, dst1)
	# test both graceful and with-force attempts
	with self.assertRaises(lzc_exc.StreamMismatch):
	lzc.lzc_receive(dst2, incr.fileno())
	incr.seek(0)
	with self.assertRaises(lzc_exc.StreamMismatch):
	lzc.lzc_receive(dst2, incr.fileno(), force=True)
	self.assertExists(dst1)
	self.assertNotExists(dst2)

	def test_recv_with_header_full(self):
	src = ZFSTest.pool.makeName(b"fs1@snap")
	dst = ZFSTest.pool.makeName(b"fs2/received")

	with temp_file_in_fs(ZFSTest.pool.makeName(b"fs1")) as name:
	lzc.lzc_snapshot([src])

	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(src, None, stream.fileno())
	stream.seek(0)

	(header, c_header) = lzc.receive_header(stream.fileno())
	self.assertEqual(src, header['drr_toname'])
	snap = header['drr_toname'].split(b'@', 1)[1]
	lzc.lzc_receive_with_header(
	dst + b'@' + snap, stream.fileno(), c_header)

	name = os.path.basename(name)
	with zfs_mount(src) as mnt1, zfs_mount(dst) as mnt2:
	self.assertTrue(
	filecmp.cmp(
	os.path.join(mnt1, name), os.path.join(mnt2, name), False))

	def test_recv_fs_below_zvol(self):
	send = ZFSTest.pool.makeName(b"fs1@snap")
	zvol = ZFSTest.pool.makeName(b"fs1/zvol")
	dest = zvol + b"/fs@snap"
	props = {b"volsize": 1024 * 1024}

	lzc.lzc_snapshot([send])
	lzc.lzc_create(zvol, ds_type='zvol', props=props)
	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(send, None, stream.fileno())
	stream.seek(0)
	with self.assertRaises(lzc_exc.WrongParent):
	lzc.lzc_receive(dest, stream.fileno())

	def test_recv_zvol_over_fs_with_children(self):
	parent = ZFSTest.pool.makeName(b"fs1")
	child = parent + b"subfs"
	zvol = ZFSTest.pool.makeName(b"fs1/zvol")
	send = zvol + b"@snap"
	props = {b"volsize": 1024 * 1024}

	lzc.lzc_create(child)
	lzc.lzc_create(zvol, ds_type='zvol', props=props)
	lzc.lzc_snapshot([send])
	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(send, None, stream.fileno())
	stream.seek(0)
	with self.assertRaises(lzc_exc.WrongParent):
	lzc.lzc_receive(parent + b"@snap", stream.fileno(), force=True)

	def test_recv_zvol_overwrite_rootds(self):
	zvol = ZFSTest.pool.makeName(b"fs1/zvol")
	snap = zvol + b"@snap"
	rootds = ZFSTest.pool.getRoot().getName()
	props = {b"volsize": 1024 * 1024}

	lzc.lzc_create(zvol, ds_type='zvol', props=props)
	lzc.lzc_snapshot([snap])
	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(snap, None, stream.fileno())
	stream.seek(0)
	with self.assertRaises(lzc_exc.WrongParent):
	lzc.lzc_receive(rootds + b"@snap", stream.fileno(), force=True)

	def test_send_full_across_clone_branch_point(self):
	origfs = ZFSTest.pool.makeName(b"fs2")

	(_, (fromsnap, origsnap, _)) = make_snapshots(
	origfs, b"snap1", b"send-origin-20", None)

	clonefs = ZFSTest.pool.makeName(b"fs1/fs/send-clone-20")
	lzc.lzc_clone(clonefs, origsnap)

	(_, (_, tosnap, _)) = make_snapshots(clonefs, None, b"snap", None)

	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(tosnap, None, stream.fileno())

	def test_send_incr_across_clone_branch_point(self):
	origfs = ZFSTest.pool.makeName(b"fs2")

	(_, (fromsnap, origsnap, _)) = make_snapshots(
	origfs, b"snap1", b"send-origin-21", None)

	clonefs = ZFSTest.pool.makeName(b"fs1/fs/send-clone-21")
	lzc.lzc_clone(clonefs, origsnap)

	(_, (_, tosnap, _)) = make_snapshots(clonefs, None, b"snap", None)

	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(tosnap, fromsnap, stream.fileno())

	def test_send_resume_token_full(self):
	src = ZFSTest.pool.makeName(b"fs1@snap")
	dstfs = ZFSTest.pool.getFilesystem(b"fs2/received")
	dst = dstfs.getSnap()

	with zfs_mount(ZFSTest.pool.makeName(b"fs1")) as mntdir:
	for i in range(1, 10):
	with tempfile.NamedTemporaryFile(dir=mntdir) as f:
	f.write(b'x' * 1024 * i)
	f.flush()
	lzc.lzc_snapshot([src])

	with tempfile.NamedTemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(src, None, stream.fileno())
	stream.seek(0)
	stream.truncate(1024 * 3)
	with self.assertRaises(lzc_exc.StreamTruncated):
	lzc.lzc_receive_resumable(dst, stream.fileno())
	# Resume token code from zfs_send_resume_token_to_nvlist()
	# XXX: if used more than twice move this code into an external func
	# format: <version>-<cksum>-<packed-size>-<compressed-payload>
	token = dstfs.getProperty("receive_resume_token")
	self.assertNotEqual(token, b'-')
	tokens = token.split(b'-')
	self.assertEqual(len(tokens), 4)
	version = tokens[0]
	packed_size = int(tokens[2], 16)
	compressed_nvs = tokens[3]
	# Validate resume token
	self.assertEqual(version, b'1') # ZFS_SEND_RESUME_TOKEN_VERSION
	if sys.version_info < (3, 0):
	payload = (
	zlib.decompress(str(bytearray.fromhex(compressed_nvs)))
	)
	else:
	payload = (
	zlib.decompress(bytearray.fromhex(compressed_nvs.decode()))
	)
	self.assertEqual(len(payload), packed_size)
	# Unpack
	resume_values = packed_nvlist_out(payload, packed_size)
	resumeobj = resume_values.get(b'object')
	resumeoff = resume_values.get(b'offset')
	with tempfile.NamedTemporaryFile(suffix='.zstream') as rstream:
	lzc.lzc_send_resume(
	src, None, rstream.fileno(), None, resumeobj, resumeoff)
	rstream.seek(0)
	lzc.lzc_receive_resumable(dst, rstream.fileno())

	def test_send_resume_token_incremental(self):
	snap1 = ZFSTest.pool.makeName(b"fs1@snap1")
	snap2 = ZFSTest.pool.makeName(b"fs1@snap2")
	dstfs = ZFSTest.pool.getFilesystem(b"fs2/received")
	dst1 = dstfs.getSnap()
	dst2 = dstfs.getSnap()

	lzc.lzc_snapshot([snap1])
	with tempfile.NamedTemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(snap1, None, stream.fileno())
	stream.seek(0)
	lzc.lzc_receive(dst1, stream.fileno())

	with zfs_mount(ZFSTest.pool.makeName(b"fs1")) as mntdir:
	for i in range(1, 10):
	with tempfile.NamedTemporaryFile(dir=mntdir) as f:
	f.write(b'x' * 1024 * i)
	f.flush()
	lzc.lzc_snapshot([snap2])

	with tempfile.NamedTemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(snap2, snap1, stream.fileno())
	stream.seek(0)
	stream.truncate(1024 * 3)
	with self.assertRaises(lzc_exc.StreamTruncated):
	lzc.lzc_receive_resumable(dst2, stream.fileno())
	# Resume token code from zfs_send_resume_token_to_nvlist()
	# format: <version>-<cksum>-<packed-size>-<compressed-payload>
	token = dstfs.getProperty("receive_resume_token")
	self.assertNotEqual(token, '-')
	tokens = token.split(b'-')
	self.assertEqual(len(tokens), 4)
	version = tokens[0]
	packed_size = int(tokens[2], 16)
	compressed_nvs = tokens[3]
	# Validate resume token
	self.assertEqual(version, b'1') # ZFS_SEND_RESUME_TOKEN_VERSION
	if sys.version_info < (3, 0):
	payload = (
	zlib.decompress(str(bytearray.fromhex(compressed_nvs)))
	)
	else:
	payload = (
	zlib.decompress(bytearray.fromhex(compressed_nvs.decode()))
	)
	self.assertEqual(len(payload), packed_size)
	# Unpack
	resume_values = packed_nvlist_out(payload, packed_size)
	resumeobj = resume_values.get(b'object')
	resumeoff = resume_values.get(b'offset')
	with tempfile.NamedTemporaryFile(suffix='.zstream') as rstream:
	lzc.lzc_send_resume(
	snap2, snap1, rstream.fileno(), None, resumeobj, resumeoff)
	rstream.seek(0)
	lzc.lzc_receive_resumable(dst2, rstream.fileno())

	def test_recv_full_across_clone_branch_point(self):
	origfs = ZFSTest.pool.makeName(b"fs2")

	(_, (fromsnap, origsnap, _)) = make_snapshots(
	origfs, b"snap1", b"send-origin-30", None)

	clonefs = ZFSTest.pool.makeName(b"fs1/fs/send-clone-30")
	lzc.lzc_clone(clonefs, origsnap)

	(_, (_, tosnap, _)) = make_snapshots(clonefs, None, b"snap", None)

	recvfs = ZFSTest.pool.makeName(b"fs1/recv-clone-30")
	recvsnap = recvfs + b"@snap"
	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(tosnap, None, stream.fileno())
	stream.seek(0)
	lzc.lzc_receive(recvsnap, stream.fileno())

	def test_recv_one(self):
	fromsnap = ZFSTest.pool.makeName(b"fs1@snap1")
	tosnap = ZFSTest.pool.makeName(b"recv@snap1")

	lzc.lzc_snapshot([fromsnap])
	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(fromsnap, None, stream.fileno())
	stream.seek(0)
	(header, c_header) = lzc.receive_header(stream.fileno())
	lzc.lzc_receive_one(tosnap, stream.fileno(), c_header)

	def test_recv_one_size(self):
	fromsnap = ZFSTest.pool.makeName(b"fs1@snap1")
	tosnap = ZFSTest.pool.makeName(b"recv@snap1")

	lzc.lzc_snapshot([fromsnap])
	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(fromsnap, None, stream.fileno())
	size = os.fstat(stream.fileno()).st_size
	stream.seek(0)
	(header, c_header) = lzc.receive_header(stream.fileno())
	(read, _) = lzc.lzc_receive_one(tosnap, stream.fileno(), c_header)
	self.assertAlmostEqual(read, size, delta=read * 0.05)

	def test_recv_one_props(self):
	fromsnap = ZFSTest.pool.makeName(b"fs1@snap1")
	fs = ZFSTest.pool.getFilesystem(b"recv")
	tosnap = fs.getName() + b"@snap1"
	props = {
	b"compression": 0x01,
	b"ns:prop": b"val"
	}

	lzc.lzc_snapshot([fromsnap])
	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(fromsnap, None, stream.fileno())
	stream.seek(0)
	(header, c_header) = lzc.receive_header(stream.fileno())
	lzc.lzc_receive_one(tosnap, stream.fileno(), c_header, props=props)
	self.assertExists(tosnap)
	self.assertEqual(fs.getProperty("compression", "received"), b"on")
	self.assertEqual(fs.getProperty("ns:prop", "received"), b"val")

	def test_recv_one_invalid_prop(self):
	fromsnap = ZFSTest.pool.makeName(b"fs1@snap1")
	fs = ZFSTest.pool.getFilesystem(b"recv")
	tosnap = fs.getName() + b"@snap1"
	props = {
	b"exec": 0xff,
	b"atime": 0x00
	}

	lzc.lzc_snapshot([fromsnap])
	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(fromsnap, None, stream.fileno())
	stream.seek(0)
	(header, c_header) = lzc.receive_header(stream.fileno())
	with self.assertRaises(lzc_exc.ReceivePropertyFailure) as ctx:
	lzc.lzc_receive_one(
	tosnap, stream.fileno(), c_header, props=props)
	self.assertExists(tosnap)
	self.assertEqual(fs.getProperty("atime", "received"), b"off")
	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.PropertyInvalid)
	self.assertEqual(e.name, b"exec")

	def test_recv_with_cmdprops(self):
	fromsnap = ZFSTest.pool.makeName(b"fs1@snap1")
	fs = ZFSTest.pool.getFilesystem(b"recv")
	tosnap = fs.getName() + b"@snap1"
	props = {}
	cmdprops = {
	b"compression": 0x01,
	b"ns:prop": b"val"
	}

	lzc.lzc_snapshot([fromsnap])
	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(fromsnap, None, stream.fileno())
	stream.seek(0)
	(header, c_header) = lzc.receive_header(stream.fileno())
	lzc.lzc_receive_with_cmdprops(
	tosnap, stream.fileno(), c_header, props=props,
	cmdprops=cmdprops)
	self.assertExists(tosnap)
	self.assertEqual(fs.getProperty("compression"), b"on")
	self.assertEqual(fs.getProperty("ns:prop"), b"val")

	def test_recv_with_cmdprops_and_recvprops(self):
	fromsnap = ZFSTest.pool.makeName(b"fs1@snap1")
	fs = ZFSTest.pool.getFilesystem(b"recv")
	tosnap = fs.getName() + b"@snap1"
	props = {
	b"atime": 0x01,
	b"exec": 0x00,
	b"ns:prop": b"abc"
	}
	cmdprops = {
	b"compression": 0x01,
	b"ns:prop": b"def",
	b"exec": None,
	}

	lzc.lzc_snapshot([fromsnap])
	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(fromsnap, None, stream.fileno())
	stream.seek(0)
	(header, c_header) = lzc.receive_header(stream.fileno())
	lzc.lzc_receive_with_cmdprops(
	tosnap, stream.fileno(), c_header, props=props,
	cmdprops=cmdprops)
	self.assertExists(tosnap)
	self.assertEqual(fs.getProperty("atime", True), b"on")
	self.assertEqual(fs.getProperty("exec", True), b"off")
	self.assertEqual(fs.getProperty("ns:prop", True), b"abc")
	self.assertEqual(fs.getProperty("compression"), b"on")
	self.assertEqual(fs.getProperty("ns:prop"), b"def")
	self.assertEqual(fs.getProperty("exec"), b"on")

	def test_recv_incr_across_clone_branch_point_no_origin(self):
	origfs = ZFSTest.pool.makeName(b"fs2")

	(_, (fromsnap, origsnap, _)) = make_snapshots(
	origfs, b"snap1", b"send-origin-32", None)

	clonefs = ZFSTest.pool.makeName(b"fs1/fs/send-clone-32")
	lzc.lzc_clone(clonefs, origsnap)

	(_, (_, tosnap, _)) = make_snapshots(clonefs, None, b"snap", None)

	recvfs = ZFSTest.pool.makeName(b"fs1/recv-clone-32")
	recvsnap1 = recvfs + b"@snap1"
	recvsnap2 = recvfs + b"@snap2"
	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(fromsnap, None, stream.fileno())
	stream.seek(0)
	lzc.lzc_receive(recvsnap1, stream.fileno())
	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(tosnap, fromsnap, stream.fileno())
	stream.seek(0)
	with self.assertRaises(lzc_exc.BadStream):
	lzc.lzc_receive(recvsnap2, stream.fileno())

	def test_recv_incr_across_clone_branch_point(self):
	origfs = ZFSTest.pool.makeName(b"fs2")

	(_, (fromsnap, origsnap, _)) = make_snapshots(
	origfs, b"snap1", b"send-origin-31", None)

	clonefs = ZFSTest.pool.makeName(b"fs1/fs/send-clone-31")
	lzc.lzc_clone(clonefs, origsnap)

	(_, (_, tosnap, _)) = make_snapshots(clonefs, None, b"snap", None)

	recvfs = ZFSTest.pool.makeName(b"fs1/recv-clone-31")
	recvsnap1 = recvfs + b"@snap1"
	recvsnap2 = recvfs + b"@snap2"
	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(fromsnap, None, stream.fileno())
	stream.seek(0)
	lzc.lzc_receive(recvsnap1, stream.fileno())
	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(tosnap, fromsnap, stream.fileno())
	stream.seek(0)
	with self.assertRaises(lzc_exc.BadStream):
	lzc.lzc_receive(recvsnap2, stream.fileno(), origin=recvsnap1)

	def test_recv_incr_across_clone_branch_point_new_fs(self):
	origfs = ZFSTest.pool.makeName(b"fs2")

	(_, (fromsnap, origsnap, _)) = make_snapshots(
	origfs, b"snap1", b"send-origin-33", None)

	clonefs = ZFSTest.pool.makeName(b"fs1/fs/send-clone-33")
	lzc.lzc_clone(clonefs, origsnap)

	(_, (_, tosnap, _)) = make_snapshots(clonefs, None, b"snap", None)

	recvfs1 = ZFSTest.pool.makeName(b"fs1/recv-clone-33")
	recvsnap1 = recvfs1 + b"@snap"
	recvfs2 = ZFSTest.pool.makeName(b"fs1/recv-clone-33_2")
	recvsnap2 = recvfs2 + b"@snap"
	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(fromsnap, None, stream.fileno())
	stream.seek(0)
	lzc.lzc_receive(recvsnap1, stream.fileno())
	with tempfile.TemporaryFile(suffix='.zstream') as stream:
	lzc.lzc_send(tosnap, fromsnap, stream.fileno())
	stream.seek(0)
	lzc.lzc_receive(recvsnap2, stream.fileno(), origin=recvsnap1)

	def test_recv_bad_stream(self):
	dstfs = ZFSTest.pool.makeName(b"fs2/received")
	dst_snap = dstfs + b'@snap'

	with dev_zero() as fd:
	with self.assertRaises(lzc_exc.BadStream):
	lzc.lzc_receive(dst_snap, fd)

	@needs_support(lzc.lzc_promote)
	def test_promote(self):
	origfs = ZFSTest.pool.makeName(b"fs2")
	snap = b"@promote-snap-1"
	origsnap = origfs + snap
	lzc.lzc_snap([origsnap])

	clonefs = ZFSTest.pool.makeName(b"fs1/fs/promote-clone-1")
	lzc.lzc_clone(clonefs, origsnap)

	lzc.lzc_promote(clonefs)
	# the snapshot now should belong to the promoted fs
	self.assertExists(clonefs + snap)

	@needs_support(lzc.lzc_promote)
	def test_promote_too_long_snapname(self):
	# origfs name must be shorter than clonefs name
	origfs = ZFSTest.pool.makeName(b"fs2")
	clonefs = ZFSTest.pool.makeName(b"fs1/fs/promote-clone-2")
	snapprefix = b"@promote-snap-2-"
	pad_len = 1 + lzc.MAXNAMELEN - len(clonefs) - len(snapprefix)
	snap = snapprefix + b'x' * pad_len
	origsnap = origfs + snap

	lzc.lzc_snap([origsnap])
	lzc.lzc_clone(clonefs, origsnap)

	# This may fail on older buggy systems.
	# See: https://www.illumos.org/issues/5909
	with self.assertRaises(lzc_exc.NameTooLong):
	lzc.lzc_promote(clonefs)

	@needs_support(lzc.lzc_promote)
	def test_promote_not_cloned(self):
	fs = ZFSTest.pool.makeName(b"fs2")
	with self.assertRaises(lzc_exc.NotClone):
	lzc.lzc_promote(fs)

	@unittest.skipIf(*illumos_bug_6379())
	def test_hold_bad_fd(self):
	snap = ZFSTest.pool.getRoot().getSnap()
	lzc.lzc_snapshot([snap])

	with tempfile.TemporaryFile() as tmp:
	bad_fd = tmp.fileno()

	with self.assertRaises(lzc_exc.BadHoldCleanupFD):
	lzc.lzc_hold({snap: b'tag'}, bad_fd)

	@unittest.skipIf(*illumos_bug_6379())
	def test_hold_bad_fd_2(self):
	snap = ZFSTest.pool.getRoot().getSnap()
	lzc.lzc_snapshot([snap])

	with self.assertRaises(lzc_exc.BadHoldCleanupFD):
	lzc.lzc_hold({snap: b'tag'}, -2)

	@unittest.skipIf(*illumos_bug_6379())
	def test_hold_bad_fd_3(self):
	snap = ZFSTest.pool.getRoot().getSnap()
	lzc.lzc_snapshot([snap])

	(soft, hard) = resource.getrlimit(resource.RLIMIT_NOFILE)
	bad_fd = hard + 1
	with self.assertRaises(lzc_exc.BadHoldCleanupFD):
	lzc.lzc_hold({snap: b'tag'}, bad_fd)

	@unittest.skipIf(*illumos_bug_6379())
	def test_hold_wrong_fd(self):
	snap = ZFSTest.pool.getRoot().getSnap()
	lzc.lzc_snapshot([snap])

	with tempfile.TemporaryFile() as tmp:
	fd = tmp.fileno()
	with self.assertRaises(lzc_exc.BadHoldCleanupFD):
	lzc.lzc_hold({snap: b'tag'}, fd)

	def test_hold_fd(self):
	snap = ZFSTest.pool.getRoot().getSnap()
	lzc.lzc_snapshot([snap])

	with cleanup_fd() as fd:
	lzc.lzc_hold({snap: b'tag'}, fd)

	def test_hold_empty(self):
	with cleanup_fd() as fd:
	lzc.lzc_hold({}, fd)

	def test_hold_empty_2(self):
	lzc.lzc_hold({})

	def test_hold_vs_snap_destroy(self):
	snap = ZFSTest.pool.getRoot().getSnap()
	lzc.lzc_snapshot([snap])

	with cleanup_fd() as fd:
	lzc.lzc_hold({snap: b'tag'}, fd)

	with self.assertRaises(lzc_exc.SnapshotDestructionFailure) as ctx:
	lzc.lzc_destroy_snaps([snap], defer=False)
	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.SnapshotIsHeld)

	lzc.lzc_destroy_snaps([snap], defer=True)
	self.assertExists(snap)

	# after automatic hold cleanup and deferred destruction
	self.assertNotExists(snap)

	def test_hold_many_tags(self):
	snap = ZFSTest.pool.getRoot().getSnap()
	lzc.lzc_snapshot([snap])

	with cleanup_fd() as fd:
	lzc.lzc_hold({snap: b'tag1'}, fd)
	lzc.lzc_hold({snap: b'tag2'}, fd)

	def test_hold_many_snaps(self):
	snap1 = ZFSTest.pool.getRoot().getSnap()
	snap2 = ZFSTest.pool.getRoot().getSnap()
	lzc.lzc_snapshot([snap1])
	lzc.lzc_snapshot([snap2])

	with cleanup_fd() as fd:
	lzc.lzc_hold({snap1: b'tag', snap2: b'tag'}, fd)

	def test_hold_many_with_one_missing(self):
	snap1 = ZFSTest.pool.getRoot().getSnap()
	snap2 = ZFSTest.pool.getRoot().getSnap()
	lzc.lzc_snapshot([snap1])

	with cleanup_fd() as fd:
	missing = lzc.lzc_hold({snap1: b'tag', snap2: b'tag'}, fd)
	self.assertEqual(len(missing), 1)
	self.assertEqual(missing[0], snap2)

	def test_hold_many_with_all_missing(self):
	snap1 = ZFSTest.pool.getRoot().getSnap()
	snap2 = ZFSTest.pool.getRoot().getSnap()

	with cleanup_fd() as fd:
	missing = lzc.lzc_hold({snap1: b'tag', snap2: b'tag'}, fd)
	self.assertEqual(len(missing), 2)
	self.assertEqual(sorted(missing), sorted([snap1, snap2]))

	def test_hold_missing_fs(self):
	# XXX skip pre-created filesystems
	ZFSTest.pool.getRoot().getFilesystem()
	ZFSTest.pool.getRoot().getFilesystem()
	ZFSTest.pool.getRoot().getFilesystem()
	ZFSTest.pool.getRoot().getFilesystem()
	ZFSTest.pool.getRoot().getFilesystem()
	snap = ZFSTest.pool.getRoot().getFilesystem().getSnap()

	snaps = lzc.lzc_hold({snap: b'tag'})
	self.assertEqual([snap], snaps)

	def test_hold_missing_fs_auto_cleanup(self):
	# XXX skip pre-created filesystems
	ZFSTest.pool.getRoot().getFilesystem()
	ZFSTest.pool.getRoot().getFilesystem()
	ZFSTest.pool.getRoot().getFilesystem()
	ZFSTest.pool.getRoot().getFilesystem()
	ZFSTest.pool.getRoot().getFilesystem()
	snap = ZFSTest.pool.getRoot().getFilesystem().getSnap()

	with cleanup_fd() as fd:
	snaps = lzc.lzc_hold({snap: b'tag'}, fd)
	self.assertEqual([snap], snaps)

	def test_hold_duplicate(self):
	snap = ZFSTest.pool.getRoot().getSnap()
	lzc.lzc_snapshot([snap])

	with cleanup_fd() as fd:
	lzc.lzc_hold({snap: b'tag'}, fd)
	with self.assertRaises(lzc_exc.HoldFailure) as ctx:
	lzc.lzc_hold({snap: b'tag'}, fd)
	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.HoldExists)

	def test_hold_across_pools(self):
	snap1 = ZFSTest.pool.getRoot().getSnap()
	snap2 = ZFSTest.misc_pool.getRoot().getSnap()
	lzc.lzc_snapshot([snap1])
	lzc.lzc_snapshot([snap2])

	with cleanup_fd() as fd:
	with self.assertRaises(lzc_exc.HoldFailure) as ctx:
	lzc.lzc_hold({snap1: b'tag', snap2: b'tag'}, fd)
	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.PoolsDiffer)

	def test_hold_too_long_tag(self):
	snap = ZFSTest.pool.getRoot().getSnap()
	tag = b't' * 256
	lzc.lzc_snapshot([snap])

	with cleanup_fd() as fd:
	with self.assertRaises(lzc_exc.HoldFailure) as ctx:
	lzc.lzc_hold({snap: tag}, fd)
	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.NameTooLong)
	self.assertEqual(e.name, tag)

	# Apparently the full snapshot name is not checked for length
	# and this snapshot is treated as simply missing.
	@unittest.expectedFailure
	def test_hold_too_long_snap_name(self):
	snap = ZFSTest.pool.getRoot().getTooLongSnap(False)
	with cleanup_fd() as fd:
	with self.assertRaises(lzc_exc.HoldFailure) as ctx:
	lzc.lzc_hold({snap: b'tag'}, fd)
	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.NameTooLong)
	self.assertEqual(e.name, snap)

	def test_hold_too_long_snap_name_2(self):
	snap = ZFSTest.pool.getRoot().getTooLongSnap(True)
	with cleanup_fd() as fd:
	with self.assertRaises(lzc_exc.HoldFailure) as ctx:
	lzc.lzc_hold({snap: b'tag'}, fd)
	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.NameTooLong)
	self.assertEqual(e.name, snap)

	def test_hold_invalid_snap_name(self):
	snap = ZFSTest.pool.getRoot().getSnap() + b'@bad'
	with cleanup_fd() as fd:
	with self.assertRaises(lzc_exc.HoldFailure) as ctx:
	lzc.lzc_hold({snap: b'tag'}, fd)
	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.NameInvalid)
	self.assertEqual(e.name, snap)

	def test_hold_invalid_snap_name_2(self):
	snap = ZFSTest.pool.getRoot().getFilesystem().getName()
	with cleanup_fd() as fd:
	with self.assertRaises(lzc_exc.HoldFailure) as ctx:
	lzc.lzc_hold({snap: b'tag'}, fd)
	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.NameInvalid)
	self.assertEqual(e.name, snap)

	def test_get_holds(self):
	snap = ZFSTest.pool.getRoot().getSnap()
	lzc.lzc_snapshot([snap])

	with cleanup_fd() as fd:
	lzc.lzc_hold({snap: b'tag1'}, fd)
	lzc.lzc_hold({snap: b'tag2'}, fd)

	holds = lzc.lzc_get_holds(snap)
	self.assertEqual(len(holds), 2)
	self.assertIn(b'tag1', holds)
	self.assertIn(b'tag2', holds)
	self.assertIsInstance(holds[b'tag1'], (int, int))

	def test_get_holds_after_auto_cleanup(self):
	snap = ZFSTest.pool.getRoot().getSnap()
	lzc.lzc_snapshot([snap])

	with cleanup_fd() as fd:
	lzc.lzc_hold({snap: b'tag1'}, fd)
	lzc.lzc_hold({snap: b'tag2'}, fd)

	holds = lzc.lzc_get_holds(snap)
	self.assertEqual(len(holds), 0)
	self.assertIsInstance(holds, dict)

	def test_get_holds_nonexistent_snap(self):
	snap = ZFSTest.pool.getRoot().getSnap()
	with self.assertRaises(lzc_exc.SnapshotNotFound):
	lzc.lzc_get_holds(snap)

	def test_get_holds_too_long_snap_name(self):
	snap = ZFSTest.pool.getRoot().getTooLongSnap(False)
	with self.assertRaises(lzc_exc.NameTooLong):
	lzc.lzc_get_holds(snap)

	def test_get_holds_too_long_snap_name_2(self):
	snap = ZFSTest.pool.getRoot().getTooLongSnap(True)
	with self.assertRaises(lzc_exc.NameTooLong):
	lzc.lzc_get_holds(snap)

	def test_get_holds_invalid_snap_name(self):
	snap = ZFSTest.pool.getRoot().getSnap() + b'@bad'
	with self.assertRaises(lzc_exc.NameInvalid):
	lzc.lzc_get_holds(snap)

	# A filesystem-like snapshot name is not recognized as
	# an invalid name.
	@unittest.expectedFailure
	def test_get_holds_invalid_snap_name_2(self):
	snap = ZFSTest.pool.getRoot().getFilesystem().getName()
	with self.assertRaises(lzc_exc.NameInvalid):
	lzc.lzc_get_holds(snap)

	def test_release_hold(self):
	snap = ZFSTest.pool.getRoot().getSnap()
	lzc.lzc_snapshot([snap])

	lzc.lzc_hold({snap: b'tag'})
	ret = lzc.lzc_release({snap: [b'tag']})
	self.assertEqual(len(ret), 0)

	def test_release_hold_empty(self):
	ret = lzc.lzc_release({})
	self.assertEqual(len(ret), 0)

	def test_release_hold_complex(self):
	snap1 = ZFSTest.pool.getRoot().getSnap()
	snap2 = ZFSTest.pool.getRoot().getSnap()
	snap3 = ZFSTest.pool.getRoot().getFilesystem().getSnap()
	lzc.lzc_snapshot([snap1])
	lzc.lzc_snapshot([snap2, snap3])

	lzc.lzc_hold({snap1: b'tag1'})
	lzc.lzc_hold({snap1: b'tag2'})
	lzc.lzc_hold({snap2: b'tag'})
	lzc.lzc_hold({snap3: b'tag1'})
	lzc.lzc_hold({snap3: b'tag2'})

	holds = lzc.lzc_get_holds(snap1)
	self.assertEqual(len(holds), 2)
	holds = lzc.lzc_get_holds(snap2)
	self.assertEqual(len(holds), 1)
	holds = lzc.lzc_get_holds(snap3)
	self.assertEqual(len(holds), 2)

	release = {
	snap1: [b'tag1', b'tag2'],
	snap2: [b'tag'],
	snap3: [b'tag2'],
	}
	ret = lzc.lzc_release(release)
	self.assertEqual(len(ret), 0)

	holds = lzc.lzc_get_holds(snap1)
	self.assertEqual(len(holds), 0)
	holds = lzc.lzc_get_holds(snap2)
	self.assertEqual(len(holds), 0)
	holds = lzc.lzc_get_holds(snap3)
	self.assertEqual(len(holds), 1)

	ret = lzc.lzc_release({snap3: [b'tag1']})
	self.assertEqual(len(ret), 0)
	holds = lzc.lzc_get_holds(snap3)
	self.assertEqual(len(holds), 0)

	def test_release_hold_before_auto_cleanup(self):
	snap = ZFSTest.pool.getRoot().getSnap()
	lzc.lzc_snapshot([snap])

	with cleanup_fd() as fd:
	lzc.lzc_hold({snap: b'tag'}, fd)
	ret = lzc.lzc_release({snap: [b'tag']})
	self.assertEqual(len(ret), 0)

	def test_release_hold_and_snap_destruction(self):
	snap = ZFSTest.pool.getRoot().getSnap()
	lzc.lzc_snapshot([snap])

	with cleanup_fd() as fd:
	lzc.lzc_hold({snap: b'tag1'}, fd)
	lzc.lzc_hold({snap: b'tag2'}, fd)

	lzc.lzc_destroy_snaps([snap], defer=True)
	self.assertExists(snap)

	lzc.lzc_release({snap: [b'tag1']})
	self.assertExists(snap)

	lzc.lzc_release({snap: [b'tag2']})
	self.assertNotExists(snap)

	def test_release_hold_and_multiple_snap_destruction(self):
	snap = ZFSTest.pool.getRoot().getSnap()
	lzc.lzc_snapshot([snap])

	with cleanup_fd() as fd:
	lzc.lzc_hold({snap: b'tag'}, fd)

	lzc.lzc_destroy_snaps([snap], defer=True)
	self.assertExists(snap)

	lzc.lzc_destroy_snaps([snap], defer=True)
	self.assertExists(snap)

	lzc.lzc_release({snap: [b'tag']})
	self.assertNotExists(snap)

	def test_release_hold_missing_tag(self):
	snap = ZFSTest.pool.getRoot().getSnap()
	lzc.lzc_snapshot([snap])

	ret = lzc.lzc_release({snap: [b'tag']})
	self.assertEqual(len(ret), 1)
	self.assertEqual(ret[0], snap + b'#tag')

	def test_release_hold_missing_snap(self):
	snap = ZFSTest.pool.getRoot().getSnap()

	ret = lzc.lzc_release({snap: [b'tag']})
	self.assertEqual(len(ret), 1)
	self.assertEqual(ret[0], snap)

	def test_release_hold_missing_snap_2(self):
	snap = ZFSTest.pool.getRoot().getSnap()

	ret = lzc.lzc_release({snap: [b'tag', b'another']})
	self.assertEqual(len(ret), 1)
	self.assertEqual(ret[0], snap)

	def test_release_hold_across_pools(self):
	snap1 = ZFSTest.pool.getRoot().getSnap()
	snap2 = ZFSTest.misc_pool.getRoot().getSnap()
	lzc.lzc_snapshot([snap1])
	lzc.lzc_snapshot([snap2])

	with cleanup_fd() as fd:
	lzc.lzc_hold({snap1: b'tag'}, fd)
	lzc.lzc_hold({snap2: b'tag'}, fd)
	with self.assertRaises(lzc_exc.HoldReleaseFailure) as ctx:
	lzc.lzc_release({snap1: [b'tag'], snap2: [b'tag']})
	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.PoolsDiffer)

	# Apparently the tag name is not verified,
	# only its existence is checked.
	@unittest.expectedFailure
	def test_release_hold_too_long_tag(self):
	snap = ZFSTest.pool.getRoot().getSnap()
	tag = b't' * 256
	lzc.lzc_snapshot([snap])

	with self.assertRaises(lzc_exc.HoldReleaseFailure):
	lzc.lzc_release({snap: [tag]})

	# Apparently the full snapshot name is not checked for length
	# and this snapshot is treated as simply missing.
	@unittest.expectedFailure
	def test_release_hold_too_long_snap_name(self):
	snap = ZFSTest.pool.getRoot().getTooLongSnap(False)

	with self.assertRaises(lzc_exc.HoldReleaseFailure):
	lzc.lzc_release({snap: [b'tag']})

	def test_release_hold_too_long_snap_name_2(self):
	snap = ZFSTest.pool.getRoot().getTooLongSnap(True)
	with self.assertRaises(lzc_exc.HoldReleaseFailure) as ctx:
	lzc.lzc_release({snap: [b'tag']})
	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.NameTooLong)
	self.assertEqual(e.name, snap)

	def test_release_hold_invalid_snap_name(self):
	snap = ZFSTest.pool.getRoot().getSnap() + b'@bad'
	with self.assertRaises(lzc_exc.HoldReleaseFailure) as ctx:
	lzc.lzc_release({snap: [b'tag']})
	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.NameInvalid)
	self.assertEqual(e.name, snap)

	def test_release_hold_invalid_snap_name_2(self):
	snap = ZFSTest.pool.getRoot().getFilesystem().getName()
	with self.assertRaises(lzc_exc.HoldReleaseFailure) as ctx:
	lzc.lzc_release({snap: [b'tag']})
	for e in ctx.exception.errors:
	self.assertIsInstance(e, lzc_exc.NameInvalid)
	self.assertEqual(e.name, snap)

	def test_sync_missing_pool(self):
	pool = b"nonexistent"
	with self.assertRaises(lzc_exc.PoolNotFound):
	lzc.lzc_sync(pool)

	def test_sync_pool_forced(self):
	pool = ZFSTest.pool.getRoot().getName()
	lzc.lzc_sync(pool, True)

	def test_reopen_missing_pool(self):
	pool = b"nonexistent"
	with self.assertRaises(lzc_exc.PoolNotFound):
	lzc.lzc_reopen(pool)

	def test_reopen_pool_no_restart(self):
	pool = ZFSTest.pool.getRoot().getName()
	lzc.lzc_reopen(pool, False)

	def test_channel_program_missing_pool(self):
	pool = b"nonexistent"
	with self.assertRaises(lzc_exc.PoolNotFound):
	lzc.lzc_channel_program(pool, b"return {}")

	def test_channel_program_timeout(self):
	pool = ZFSTest.pool.getRoot().getName()
	zcp = b"""
	for i = 1,10000 do
	zfs.sync.snapshot('""" + pool + b"""@zcp' .. i)
	end
	"""
	with self.assertRaises(lzc_exc.ZCPTimeout):
	lzc.lzc_channel_program(pool, zcp, instrlimit=1)

	def test_channel_program_memory_limit(self):
	pool = ZFSTest.pool.getRoot().getName()
	zcp = b"""
	for i = 1,10000 do
	zfs.sync.snapshot('""" + pool + b"""@zcp' .. i)
	end
	"""
	with self.assertRaises(lzc_exc.ZCPSpaceError):
	lzc.lzc_channel_program(pool, zcp, memlimit=1)

	def test_channel_program_invalid_limits(self):
	pool = ZFSTest.pool.getRoot().getName()
	zcp = b"""
	return {}
	"""
	with self.assertRaises(lzc_exc.ZCPLimitInvalid):
	lzc.lzc_channel_program(pool, zcp, instrlimit=0)
	with self.assertRaises(lzc_exc.ZCPLimitInvalid):
	lzc.lzc_channel_program(pool, zcp, memlimit=0)

	def test_channel_program_syntax_error(self):
	pool = ZFSTest.pool.getRoot().getName()
	zcp = b"""
	inv+val:id
	"""
	with self.assertRaises(lzc_exc.ZCPSyntaxError) as ctx:
	lzc.lzc_channel_program(pool, zcp)
	self.assertTrue(b"syntax error" in ctx.exception.details)

	def test_channel_program_sync_snapshot(self):
	pool = ZFSTest.pool.getRoot().getName()
	snapname = ZFSTest.pool.makeName(b"@zcp")
	zcp = b"""
	zfs.sync.snapshot('""" + snapname + b"""')
	"""
	lzc.lzc_channel_program(pool, zcp)
	self.assertExists(snapname)

	def test_channel_program_runtime_error(self):
	pool = ZFSTest.pool.getRoot().getName()

	# failing an assertion raises a runtime error
	with self.assertRaises(lzc_exc.ZCPRuntimeError) as ctx:
	lzc.lzc_channel_program(pool, b"assert(1 == 2)")
	self.assertTrue(
	b"assertion failed" in ctx.exception.details)
	# invoking the error() function raises a runtime error
	with self.assertRaises(lzc_exc.ZCPRuntimeError) as ctx:
	lzc.lzc_channel_program(pool, b"error()")

	def test_channel_program_nosync_runtime_error(self):
	pool = ZFSTest.pool.getRoot().getName()
	zcp = b"""
	zfs.sync.snapshot('""" + pool + b"""@zcp')
	"""
	# lzc_channel_program_nosync() allows only "read-only" operations
	with self.assertRaises(lzc_exc.ZCPRuntimeError) as ctx:
	lzc.lzc_channel_program_nosync(pool, zcp)
	self.assertTrue(
	b"running functions from the zfs.sync" in ctx.exception.details)

	def test_change_key_new(self):
	with encrypted_filesystem() as (fs, _):
	lzc.lzc_change_key(
	fs, 'new_key',
	props={b"keyformat": lzc.zfs_keyformat.ZFS_KEYFORMAT_RAW},
	key=os.urandom(lzc.WRAPPING_KEY_LEN))

	def test_change_key_missing_fs(self):
	name = b"nonexistent"

	with self.assertRaises(lzc_exc.FilesystemNotFound):
	lzc.lzc_change_key(
	name, 'new_key',
	props={b"keyformat": lzc.zfs_keyformat.ZFS_KEYFORMAT_RAW},
	key=os.urandom(lzc.WRAPPING_KEY_LEN))

	def test_change_key_not_loaded(self):
	with encrypted_filesystem() as (fs, _):
	lzc.lzc_unload_key(fs)
	with self.assertRaises(lzc_exc.EncryptionKeyNotLoaded):
	lzc.lzc_change_key(
	fs, 'new_key',
	props={b"keyformat": lzc.zfs_keyformat.ZFS_KEYFORMAT_RAW},
	key=os.urandom(lzc.WRAPPING_KEY_LEN))

	def test_change_key_invalid_property(self):
	with encrypted_filesystem() as (fs, _):
	with self.assertRaises(lzc_exc.PropertyInvalid):
	lzc.lzc_change_key(fs, 'new_key', props={b"invalid": b"prop"})

	def test_change_key_invalid_crypt_command(self):
	with encrypted_filesystem() as (fs, _):
	with self.assertRaises(lzc_exc.UnknownCryptCommand):
	lzc.lzc_change_key(fs, 'duplicate_key')

	def test_load_key(self):
	with encrypted_filesystem() as (fs, key):
	lzc.lzc_unload_key(fs)
	lzc.lzc_load_key(fs, False, key)

	def test_load_key_invalid(self):
	with encrypted_filesystem() as (fs, key):
	lzc.lzc_unload_key(fs)
	with self.assertRaises(lzc_exc.EncryptionKeyInvalid):
	lzc.lzc_load_key(fs, False, os.urandom(lzc.WRAPPING_KEY_LEN))

	def test_load_key_already_loaded(self):
	with encrypted_filesystem() as (fs, key):
	lzc.lzc_unload_key(fs)
	lzc.lzc_load_key(fs, False, key)
	with self.assertRaises(lzc_exc.EncryptionKeyAlreadyLoaded):
	lzc.lzc_load_key(fs, False, key)

	def test_load_key_missing_fs(self):
	name = b"nonexistent"

	with self.assertRaises(lzc_exc.FilesystemNotFound):
	lzc.lzc_load_key(name, False, key=os.urandom(lzc.WRAPPING_KEY_LEN))

	def test_unload_key(self):
	with encrypted_filesystem() as (fs, _):
	lzc.lzc_unload_key(fs)

	def test_unload_key_missing_fs(self):
	name = b"nonexistent"

	with self.assertRaises(lzc_exc.FilesystemNotFound):
	lzc.lzc_unload_key(name)

	def test_unload_key_busy(self):
	with encrypted_filesystem() as (fs, _):
	with zfs_mount(fs):
	with self.assertRaises(lzc_exc.DatasetBusy):
	lzc.lzc_unload_key(fs)

	def test_unload_key_not_loaded(self):
	with encrypted_filesystem() as (fs, _):
	lzc.lzc_unload_key(fs)
	with self.assertRaises(lzc_exc.EncryptionKeyNotLoaded):
	lzc.lzc_unload_key(fs)

	def test_checkpoint(self):
	pool = ZFSTest.pool.getRoot().getName()

	lzc.lzc_pool_checkpoint(pool)

	def test_checkpoint_missing_pool(self):
	pool = b"nonexistent"

	with self.assertRaises(lzc_exc.PoolNotFound):
	lzc.lzc_pool_checkpoint(pool)

	def test_checkpoint_already_exists(self):
	pool = ZFSTest.pool.getRoot().getName()

	lzc.lzc_pool_checkpoint(pool)
	with self.assertRaises(lzc_exc.CheckpointExists):
	lzc.lzc_pool_checkpoint(pool)

	def test_checkpoint_discard(self):
	pool = ZFSTest.pool.getRoot().getName()

	lzc.lzc_pool_checkpoint(pool)
	lzc.lzc_pool_checkpoint_discard(pool)

	def test_checkpoint_discard_missing_pool(self):
	pool = b"nonexistent"

	with self.assertRaises(lzc_exc.PoolNotFound):
	lzc.lzc_pool_checkpoint_discard(pool)

	def test_checkpoint_discard_missing_checkpoint(self):
	pool = ZFSTest.pool.getRoot().getName()

	with self.assertRaises(lzc_exc.CheckpointNotFound):
	lzc.lzc_pool_checkpoint_discard(pool)

	@needs_support(lzc.lzc_list_children)
	def test_list_children(self):
	name = ZFSTest.pool.makeName(b"fs1/fs")
	names = [ZFSTest.pool.makeName(b"fs1/fs/test1"),
	ZFSTest.pool.makeName(b"fs1/fs/test2"),
	ZFSTest.pool.makeName(b"fs1/fs/test3"), ]
	# and one snap to see that it is not listed
	snap = ZFSTest.pool.makeName(b"fs1/fs@test")

	for fs in names:
	lzc.lzc_create(fs)
	lzc.lzc_snapshot([snap])

	children = list(lzc.lzc_list_children(name))
	self.assertItemsEqual(children, names)

	@needs_support(lzc.lzc_list_children)
	def test_list_children_nonexistent(self):
	fs = ZFSTest.pool.makeName(b"nonexistent")

	with self.assertRaises(lzc_exc.DatasetNotFound):
	list(lzc.lzc_list_children(fs))

	@needs_support(lzc.lzc_list_children)
	def test_list_children_of_snap(self):
	snap = ZFSTest.pool.makeName(b"@newsnap")

	lzc.lzc_snapshot([snap])
	children = list(lzc.lzc_list_children(snap))
	self.assertEqual(children, [])

	@needs_support(lzc.lzc_list_snaps)
	def test_list_snaps(self):
	name = ZFSTest.pool.makeName(b"fs1/fs")
	names = [ZFSTest.pool.makeName(b"fs1/fs@test1"),
	ZFSTest.pool.makeName(b"fs1/fs@test2"),
	ZFSTest.pool.makeName(b"fs1/fs@test3"), ]
	# and one filesystem to see that it is not listed
	fs = ZFSTest.pool.makeName(b"fs1/fs/test")

	for snap in names:
	lzc.lzc_snapshot([snap])
	lzc.lzc_create(fs)

	snaps = list(lzc.lzc_list_snaps(name))
	self.assertItemsEqual(snaps, names)

	@needs_support(lzc.lzc_list_snaps)
	def test_list_snaps_nonexistent(self):
	fs = ZFSTest.pool.makeName(b"nonexistent")

	with self.assertRaises(lzc_exc.DatasetNotFound):
	list(lzc.lzc_list_snaps(fs))

	@needs_support(lzc.lzc_list_snaps)
	def test_list_snaps_of_snap(self):
	snap = ZFSTest.pool.makeName(b"@newsnap")

	lzc.lzc_snapshot([snap])
	snaps = list(lzc.lzc_list_snaps(snap))
	self.assertEqual(snaps, [])

	@needs_support(lzc.lzc_get_props)
	def test_get_fs_props(self):
	fs = ZFSTest.pool.makeName(b"new")
	props = {b"user:foo": b"bar"}

	lzc.lzc_create(fs, props=props)
	actual_props = lzc.lzc_get_props(fs)
	self.assertDictContainsSubset(props, actual_props)

	@needs_support(lzc.lzc_get_props)
	def test_get_fs_props_with_child(self):
	parent = ZFSTest.pool.makeName(b"parent")
	child = ZFSTest.pool.makeName(b"parent/child")
	parent_props = {b"user:foo": b"parent"}
	child_props = {b"user:foo": b"child"}

	lzc.lzc_create(parent, props=parent_props)
	lzc.lzc_create(child, props=child_props)
	actual_parent_props = lzc.lzc_get_props(parent)
	actual_child_props = lzc.lzc_get_props(child)
	self.assertDictContainsSubset(parent_props, actual_parent_props)
	self.assertDictContainsSubset(child_props, actual_child_props)

	@needs_support(lzc.lzc_get_props)
	def test_get_snap_props(self):
	snapname = ZFSTest.pool.makeName(b"@snap")
	snaps = [snapname]
	props = {b"user:foo": b"bar"}

	lzc.lzc_snapshot(snaps, props)
	actual_props = lzc.lzc_get_props(snapname)
	self.assertDictContainsSubset(props, actual_props)

	@needs_support(lzc.lzc_get_props)
	def test_get_props_nonexistent(self):
	fs = ZFSTest.pool.makeName(b"nonexistent")

	with self.assertRaises(lzc_exc.DatasetNotFound):
	lzc.lzc_get_props(fs)

	@needs_support(lzc.lzc_get_props)
	def test_get_mountpoint_none(self):
	'''
	If the mountpoint property is set to none, then its
	value is returned as `bytes` "none".
	Also, a child filesystem inherits that value.
	'''
	fs = ZFSTest.pool.makeName(b"new")
	child = ZFSTest.pool.makeName(b"new/child")
	props = {b"mountpoint": b"none"}

	lzc.lzc_create(fs, props=props)
	lzc.lzc_create(child)
	actual_props = lzc.lzc_get_props(fs)
	self.assertDictContainsSubset(props, actual_props)
	# check that mountpoint value is correctly inherited
	child_props = lzc.lzc_get_props(child)
	self.assertDictContainsSubset(props, child_props)

	@needs_support(lzc.lzc_get_props)
	def test_get_mountpoint_legacy(self):
	'''
	If the mountpoint property is set to legacy, then its
	value is returned as `bytes` "legacy".
	Also, a child filesystem inherits that value.
	'''
	fs = ZFSTest.pool.makeName(b"new")
	child = ZFSTest.pool.makeName(b"new/child")
	props = {b"mountpoint": b"legacy"}

	lzc.lzc_create(fs, props=props)
	lzc.lzc_create(child)
	actual_props = lzc.lzc_get_props(fs)
	self.assertDictContainsSubset(props, actual_props)
	# check that mountpoint value is correctly inherited
	child_props = lzc.lzc_get_props(child)
	self.assertDictContainsSubset(props, child_props)

	@needs_support(lzc.lzc_get_props)
	def test_get_mountpoint_path(self):
	'''
	If the mountpoint property is set to a path and the property
	is not explicitly set on a child filesystem, then its
	value is that of the parent filesystem with the child's
	name appended using the '/' separator.
	'''
	fs = ZFSTest.pool.makeName(b"new")
	child = ZFSTest.pool.makeName(b"new/child")
	props = {b"mountpoint": b"/mnt"}

	lzc.lzc_create(fs, props=props)
	lzc.lzc_create(child)
	actual_props = lzc.lzc_get_props(fs)
	self.assertDictContainsSubset(props, actual_props)
	# check that mountpoint value is correctly inherited
	child_props = lzc.lzc_get_props(child)
	self.assertDictContainsSubset(
	{b"mountpoint": b"/mnt/child"}, child_props)

	@needs_support(lzc.lzc_get_props)
	def test_get_snap_clones(self):
	fs = ZFSTest.pool.makeName(b"new")
	snap = ZFSTest.pool.makeName(b"@snap")
	clone1 = ZFSTest.pool.makeName(b"clone1")
	clone2 = ZFSTest.pool.makeName(b"clone2")

	lzc.lzc_create(fs)
	lzc.lzc_snapshot([snap])
	lzc.lzc_clone(clone1, snap)
	lzc.lzc_clone(clone2, snap)

	clones_prop = lzc.lzc_get_props(snap)["clones"]
	self.assertItemsEqual(clones_prop, [clone1, clone2])

	@needs_support(lzc.lzc_rename)
	def test_rename(self):
	src = ZFSTest.pool.makeName(b"source")
	tgt = ZFSTest.pool.makeName(b"target")

	lzc.lzc_create(src)
	lzc.lzc_rename(src, tgt)
	self.assertNotExists(src)
	self.assertExists(tgt)

	@needs_support(lzc.lzc_rename)
	def test_rename_nonexistent(self):
	src = ZFSTest.pool.makeName(b"source")
	tgt = ZFSTest.pool.makeName(b"target")

	with self.assertRaises(lzc_exc.FilesystemNotFound):
	lzc.lzc_rename(src, tgt)

	@needs_support(lzc.lzc_rename)
	def test_rename_existing_target(self):
	src = ZFSTest.pool.makeName(b"source")
	tgt = ZFSTest.pool.makeName(b"target")

	lzc.lzc_create(src)
	lzc.lzc_create(tgt)
	with self.assertRaises(lzc_exc.FilesystemExists):
	lzc.lzc_rename(src, tgt)

	@needs_support(lzc.lzc_rename)
	def test_rename_nonexistent_target_parent(self):
	src = ZFSTest.pool.makeName(b"source")
	tgt = ZFSTest.pool.makeName(b"parent/target")

	lzc.lzc_create(src)
	with self.assertRaises(lzc_exc.FilesystemNotFound):
	lzc.lzc_rename(src, tgt)

	@needs_support(lzc.lzc_rename)
	def test_rename_parent_is_zvol(self):
	src = ZFSTest.pool.makeName(b"source")
	zvol = ZFSTest.pool.makeName(b"parent")
	tgt = zvol + b"/target"
	props = {b"volsize": 1024 * 1024}

	lzc.lzc_create(src)
	lzc.lzc_create(zvol, ds_type='zvol', props=props)
	with self.assertRaises(lzc_exc.WrongParent):
	lzc.lzc_rename(src, tgt)

	@needs_support(lzc.lzc_destroy)
	def test_destroy(self):
	fs = ZFSTest.pool.makeName(b"test-fs")

	lzc.lzc_create(fs)
	lzc.lzc_destroy(fs)
	self.assertNotExists(fs)

	@needs_support(lzc.lzc_destroy)
	def test_destroy_nonexistent(self):
	fs = ZFSTest.pool.makeName(b"test-fs")

	with self.assertRaises(lzc_exc.FilesystemNotFound):
	lzc.lzc_destroy(fs)

	@needs_support(lzc.lzc_inherit_prop)
	def test_inherit_prop(self):
	parent = ZFSTest.pool.makeName(b"parent")
	child = ZFSTest.pool.makeName(b"parent/child")
	the_prop = b"user:foo"
	parent_props = {the_prop: b"parent"}
	child_props = {the_prop: b"child"}

	lzc.lzc_create(parent, props=parent_props)
	lzc.lzc_create(child, props=child_props)
	lzc.lzc_inherit_prop(child, the_prop)
	actual_props = lzc.lzc_get_props(child)
	self.assertDictContainsSubset(parent_props, actual_props)

	@needs_support(lzc.lzc_inherit_prop)
	def test_inherit_missing_prop(self):
	parent = ZFSTest.pool.makeName(b"parent")
	child = ZFSTest.pool.makeName(b"parent/child")
	the_prop = "user:foo"
	child_props = {the_prop: "child"}

	lzc.lzc_create(parent)
	lzc.lzc_create(child, props=child_props)
	lzc.lzc_inherit_prop(child, the_prop)
	actual_props = lzc.lzc_get_props(child)
	self.assertNotIn(the_prop, actual_props)

	@needs_support(lzc.lzc_inherit_prop)
	def test_inherit_readonly_prop(self):
	parent = ZFSTest.pool.makeName(b"parent")
	child = ZFSTest.pool.makeName(b"parent/child")
	the_prop = b"createtxg"

	lzc.lzc_create(parent)
	lzc.lzc_create(child)
	with self.assertRaises(lzc_exc.PropertyInvalid):
	lzc.lzc_inherit_prop(child, the_prop)

	@needs_support(lzc.lzc_inherit_prop)
	def test_inherit_unknown_prop(self):
	parent = ZFSTest.pool.makeName(b"parent")
	child = ZFSTest.pool.makeName(b"parent/child")
	the_prop = b"nosuchprop"

	lzc.lzc_create(parent)
	lzc.lzc_create(child)
	with self.assertRaises(lzc_exc.PropertyInvalid):
	lzc.lzc_inherit_prop(child, the_prop)

	@needs_support(lzc.lzc_inherit_prop)
	def test_inherit_prop_on_snap(self):
	fs = ZFSTest.pool.makeName(b"new")
	snapname = ZFSTest.pool.makeName(b"new@snap")
	prop = b"user:foo"
	fs_val = b"fs"
	snap_val = b"snap"

	lzc.lzc_create(fs, props={prop: fs_val})
	lzc.lzc_snapshot([snapname], props={prop: snap_val})

	actual_props = lzc.lzc_get_props(snapname)
	self.assertDictContainsSubset({prop: snap_val}, actual_props)

	lzc.lzc_inherit_prop(snapname, prop)
	actual_props = lzc.lzc_get_props(snapname)
	self.assertDictContainsSubset({prop: fs_val}, actual_props)

	@needs_support(lzc.lzc_set_prop)
	def test_set_fs_prop(self):
	fs = ZFSTest.pool.makeName(b"new")
	prop = b"user:foo"
	val = b"bar"

	lzc.lzc_create(fs)
	lzc.lzc_set_prop(fs, prop, val)
	actual_props = lzc.lzc_get_props(fs)
	self.assertDictContainsSubset({prop: val}, actual_props)

	@needs_support(lzc.lzc_set_prop)
	def test_set_snap_prop(self):
	snapname = ZFSTest.pool.makeName(b"@snap")
	prop = b"user:foo"
	val = b"bar"

	lzc.lzc_snapshot([snapname])
	lzc.lzc_set_prop(snapname, prop, val)
	actual_props = lzc.lzc_get_props(snapname)
	self.assertDictContainsSubset({prop: val}, actual_props)

	@needs_support(lzc.lzc_set_prop)
	def test_set_prop_nonexistent(self):
	fs = ZFSTest.pool.makeName(b"nonexistent")
	prop = b"user:foo"
	val = b"bar"

	with self.assertRaises(lzc_exc.DatasetNotFound):
	lzc.lzc_set_prop(fs, prop, val)

	@needs_support(lzc.lzc_set_prop)
	def test_set_sys_prop(self):
	fs = ZFSTest.pool.makeName(b"new")
	prop = b"recordsize"
	val = 4096

	lzc.lzc_create(fs)
	lzc.lzc_set_prop(fs, prop, val)
	actual_props = lzc.lzc_get_props(fs)
	self.assertDictContainsSubset({prop: val}, actual_props)

	@needs_support(lzc.lzc_set_prop)
	def test_set_invalid_prop(self):
	fs = ZFSTest.pool.makeName(b"new")
	prop = b"nosuchprop"
	val = 0

	lzc.lzc_create(fs)
	with self.assertRaises(lzc_exc.PropertyInvalid):
	lzc.lzc_set_prop(fs, prop, val)

	@needs_support(lzc.lzc_set_prop)
	def test_set_invalid_value_prop(self):
	fs = ZFSTest.pool.makeName(b"new")
	prop = b"atime"
	val = 100

	lzc.lzc_create(fs)
	with self.assertRaises(lzc_exc.PropertyInvalid):
	lzc.lzc_set_prop(fs, prop, val)

	@needs_support(lzc.lzc_set_prop)
	def test_set_invalid_value_prop_2(self):
	fs = ZFSTest.pool.makeName(b"new")
	prop = b"readonly"
	val = 100

	lzc.lzc_create(fs)
	with self.assertRaises(lzc_exc.PropertyInvalid):
	lzc.lzc_set_prop(fs, prop, val)

	@needs_support(lzc.lzc_set_prop)
	def test_set_prop_too_small_quota(self):
	fs = ZFSTest.pool.makeName(b"new")
	prop = b"refquota"
	val = 1

	lzc.lzc_create(fs)
	with self.assertRaises(lzc_exc.NoSpace):
	lzc.lzc_set_prop(fs, prop, val)

	@needs_support(lzc.lzc_set_prop)
	def test_set_readonly_prop(self):
	fs = ZFSTest.pool.makeName(b"new")
	prop = b"creation"
	val = 0

	lzc.lzc_create(fs)
	lzc.lzc_set_prop(fs, prop, val)
	actual_props = lzc.lzc_get_props(fs)
	# the change is silently ignored
	self.assertTrue(actual_props[prop] != val)


	class _TempPool(object):
	SNAPSHOTS = [b'snap', b'snap1', b'snap2']
	BOOKMARKS = [b'bmark', b'bmark1', b'bmark2']

	_cachefile_suffix = ".cachefile"

	# XXX Whether to do a sloppy but much faster cleanup
	# or a proper but slower one.
	_recreate_pools = True

	def __init__(self, size=128 * 1024 * 1024, readonly=False, filesystems=[]):
	self._filesystems = filesystems
	self._readonly = readonly
	if sys.version_info < (3, 0):
	self._pool_name = b'pool.' + bytes(uuid.uuid4())
	else:
	self._pool_name = b'pool.' + bytes(str(uuid.uuid4()),
	encoding='utf-8')
	self._root = _Filesystem(self._pool_name)
	(fd, self._pool_file_path) = tempfile.mkstemp(
	suffix='.zpool', prefix='tmp-')
	if readonly:
	cachefile = self._pool_file_path + _TempPool._cachefile_suffix
	else:
	cachefile = 'none'
	self._zpool_create = [
	'zpool', 'create', '-o', 'cachefile=' + cachefile,
	'-O', 'mountpoint=legacy', self._pool_name, self._pool_file_path]
	try:
	os.ftruncate(fd, size)
	os.close(fd)

	subprocess.check_output(
	self._zpool_create, stderr=subprocess.STDOUT)

	for fs in filesystems:
	lzc.lzc_create(self.makeName(fs))

	self._bmarks_supported = self.isPoolFeatureEnabled('bookmarks')

	if readonly:
	# To make a pool read-only it must exported and re-imported
	# with readonly option.
	# The most deterministic way to re-import the pool is by using
	# a cache file.
	# But the cache file has to be stashed away before the pool is
	# exported, because otherwise the pool is removed from the
	# cache.
	shutil.copyfile(cachefile, cachefile + '.tmp')
	subprocess.check_output(
	['zpool', 'export', '-f', self._pool_name],
	stderr=subprocess.STDOUT)
	os.rename(cachefile + '.tmp', cachefile)
	subprocess.check_output(
	['zpool', 'import', '-f', '-N', '-c', cachefile,
	'-o', 'readonly=on', self._pool_name],
	stderr=subprocess.STDOUT)
	os.remove(cachefile)

	except subprocess.CalledProcessError as e:
	self.cleanUp()
	if b'permission denied' in e.output:
	raise unittest.SkipTest(
	'insufficient privileges to run libzfs_core tests')
	print('command failed: ', e.output)
	raise
	except Exception:
	self.cleanUp()
	raise

	def reset(self):
	if self._readonly:
	return

	if not self.__class__._recreate_pools:
	snaps = []
	for fs in [''] + self._filesystems:
	for snap in self.__class__.SNAPSHOTS:
	snaps.append(self.makeName(fs + '@' + snap))
	self.getRoot().visitSnaps(lambda snap: snaps.append(snap))
	lzc.lzc_destroy_snaps(snaps, defer=False)

	if self._bmarks_supported:
	bmarks = []
	for fs in [''] + self._filesystems:
	for bmark in self.__class__.BOOKMARKS:
	bmarks.append(self.makeName(fs + '#' + bmark))
	self.getRoot().visitBookmarks(
	lambda bmark: bmarks.append(bmark))
	lzc.lzc_destroy_bookmarks(bmarks)
	self.getRoot().reset()
	return

	# On the Buildbot builders this may fail with "pool is busy"
	# Retry 5 times before raising an error
	retry = 0
	while True:
	try:
	subprocess.check_output(
	['zpool', 'destroy', '-f', self._pool_name],
	stderr=subprocess.STDOUT)
	subprocess.check_output(
	self._zpool_create, stderr=subprocess.STDOUT)
	break
	except subprocess.CalledProcessError as e:
	if b'pool is busy' in e.output and retry < 5:
	retry += 1
	time.sleep(1)
	continue
	else:
	print('command failed: ', e.output)
	raise
	for fs in self._filesystems:
	lzc.lzc_create(self.makeName(fs))
	self.getRoot().reset()

	def cleanUp(self):
	try:
	subprocess.check_output(
	['zpool', 'destroy', '-f', self._pool_name],
	stderr=subprocess.STDOUT)
	except Exception:
	pass
	try:
	os.remove(self._pool_file_path)
	except Exception:
	pass
	try:
	os.remove(self._pool_file_path + _TempPool._cachefile_suffix)
	except Exception:
	pass
	try:
	os.remove(
	self._pool_file_path + _TempPool._cachefile_suffix + '.tmp')
	except Exception:
	pass

	def makeName(self, relative=None):
	if not relative:
	return self._pool_name
	if relative.startswith((b'@', b'#')):
	return self._pool_name + relative
	return self._pool_name + b'/' + relative

	def makeTooLongName(self, prefix=None):
	if not prefix:
	prefix = b'x'
	prefix = self.makeName(prefix)
	pad_len = lzc.MAXNAMELEN + 1 - len(prefix)
	if pad_len > 0:
	return prefix + b'x' * pad_len
	else:
	return prefix

	def makeTooLongComponent(self, prefix=None):
	padding = b'x' * (lzc.MAXNAMELEN + 1)
	if not prefix:
	prefix = padding
	else:
	prefix = prefix + padding
	return self.makeName(prefix)

	def getRoot(self):
	return self._root

	def getFilesystem(self, fsname):
	return _Filesystem(self._pool_name + b'/' + fsname)

	def isPoolFeatureAvailable(self, feature):
	output = subprocess.check_output(
	['zpool', 'get', '-H', 'feature@' + feature, self._pool_name])
	output = output.strip()
	return output != ''

	def isPoolFeatureEnabled(self, feature):
	output = subprocess.check_output(
	['zpool', 'get', '-H', 'feature@' + feature, self._pool_name])
	output = output.split()[2]
	return output in [b'active', b'enabled']


	class _Filesystem(object):

	def __init__(self, name):
	self._name = name
	self.reset()

	def getName(self):
	return self._name

	def reset(self):
	self._children = []
	self._fs_id = 0
	self._snap_id = 0
	self._bmark_id = 0

	def getFilesystem(self):
	self._fs_id += 1
	fsname = self._name + b'/fs' + str(self._fs_id).encode()
	fs = _Filesystem(fsname)
	self._children.append(fs)
	return fs

	def getProperty(self, propname, received=False):
	if received:
	output = subprocess.check_output(
	['zfs', 'get', '-pH', '-o', 'received', propname, self._name])
	else:
	output = subprocess.check_output(
	['zfs', 'get', '-pH', '-o', 'value', propname, self._name])
	return output.strip()

	def _makeSnapName(self, i):
	return self._name + b'@snap' + str(i).encode()

	def getSnap(self):
	self._snap_id += 1
	return self._makeSnapName(self._snap_id)

	def _makeBookmarkName(self, i):
	return self._name + b'#bmark' + bytes(i)

	def getBookmark(self):
	self._bmark_id += 1
	return self._makeBookmarkName(self._bmark_id)

	def _makeTooLongName(self, too_long_component):
	if too_long_component:
	return b'x' * (lzc.MAXNAMELEN + 1)

	# Note that another character is used for one of '/', '@', '#'.
	comp_len = lzc.MAXNAMELEN - len(self._name)
	if comp_len > 0:
	return b'x' * comp_len
	else:
	return b'x'

	def getTooLongFilesystemName(self, too_long_component):
	return self._name + b'/' + self._makeTooLongName(too_long_component)

	def getTooLongSnap(self, too_long_component):
	return self._name + b'@' + self._makeTooLongName(too_long_component)

	def getTooLongBookmark(self, too_long_component):
	return self._name + b'#' + self._makeTooLongName(too_long_component)

	def _visitFilesystems(self, visitor):
	for child in self._children:
	child._visitFilesystems(visitor)
	visitor(self)

	def visitFilesystems(self, visitor):
	def _fsVisitor(fs):
	visitor(fs._name)

	self._visitFilesystems(_fsVisitor)

	def visitSnaps(self, visitor):
	def _snapVisitor(fs):
	for i in range(1, fs._snap_id + 1):
	visitor(fs._makeSnapName(i))

	self._visitFilesystems(_snapVisitor)

	def visitBookmarks(self, visitor):
	def _bmarkVisitor(fs):
	for i in range(1, fs._bmark_id + 1):
	visitor(fs._makeBookmarkName(i))

	self._visitFilesystems(_bmarkVisitor)


	# vim: softtabstop=4 tabstop=4 expandtab shiftwidth=4
	diff --git a/sys/contrib/openzfs/copy-builtin b/sys/contrib/openzfs/copy-builtin
	index 36e19545d9c4..cd6f259092ed 100755
	--- a/sys/contrib/openzfs/copy-builtin
	+++ b/sys/contrib/openzfs/copy-builtin
	@@ -1,79 +1,74 @@
	-#!/usr/bin/env bash
	+#!/bin/sh

	-set -e
	+set -ef

	usage()
	{
	echo "usage: $0 <kernel source tree>" >&2
	exit 1
	}

	[ "$#" -eq 1 ] \|\| usage
	-KERNEL_DIR="$(readlink --canonicalize-existing "$1")"
	+KERNEL_DIR="$1"

	if ! [ -e 'zfs_config.h' ]
	then
	- echo >&2
	- echo " $0: you did not run configure, or you're not in the ZFS source directory." >&2
	- echo " $0: run configure with --with-linux=$KERNEL_DIR and --enable-linux-builtin." >&2
	- echo >&2
	+ echo "$0: you did not run configure, or you're not in the ZFS source directory."
	+ echo "$0: run configure with --with-linux=$KERNEL_DIR and --enable-linux-builtin."
	+
	exit 1
	-fi
	+fi >&2

	-make clean \|\| true
	+make clean \|\|:
	make gitrev

	rm -rf "$KERNEL_DIR/include/zfs" "$KERNEL_DIR/fs/zfs"
	-cp --recursive include "$KERNEL_DIR/include/zfs"
	-cp --recursive module "$KERNEL_DIR/fs/zfs"
	+cp -R include "$KERNEL_DIR/include/zfs"
	+cp -R module "$KERNEL_DIR/fs/zfs"
	cp zfs_config.h "$KERNEL_DIR/include/zfs/"

	-cat > "$KERNEL_DIR/fs/zfs/Kconfig" <<"EOF"
	+cat > "$KERNEL_DIR/fs/zfs/Kconfig" <<EOF
	config ZFS
	tristate "ZFS filesystem support"
	depends on EFI_PARTITION
	select ZLIB_INFLATE
	select ZLIB_DEFLATE
	help
	This is the ZFS filesystem from the OpenZFS project.

	See https://github.com/openzfs/zfs

	To compile this file system support as a module, choose M here.

	If unsure, say N.
	EOF

	add_after()
	{
	- local FILE="$1"
	- local MARKER="$2"
	- local NEW="$3"
	- local LINE
	+ FILE="$1"
	+ MARKER="$2"
	+ NEW="$3"

	while IFS='' read -r LINE
	do
	- echo "$LINE"
	+ printf "%s\n" "$LINE"

	- if [ -n "$MARKER" -a "$LINE" = "$MARKER" ]
	+ if [ -n "$MARKER" ] && [ "$LINE" = "$MARKER" ]
	then
	- echo "$NEW"
	+ printf "%s\n" "$NEW"
	MARKER=''
	if IFS='' read -r LINE
	then
	- [ "$LINE" != "$NEW" ] && echo "$LINE"
	+ [ "$LINE" != "$NEW" ] && printf "%s\n" "$LINE"
	fi
	fi
	done < "$FILE" > "$FILE.new"

	mv "$FILE.new" "$FILE"
	}

	add_after "$KERNEL_DIR/fs/Kconfig" 'if BLOCK' 'source "fs/zfs/Kconfig"'
	add_after "$KERNEL_DIR/fs/Makefile" 'endif' 'obj-$(CONFIG_ZFS) += zfs/'

	-echo >&2
	-echo " $0: done." >&2
	-echo " $0: now you can build the kernel with ZFS support." >&2
	-echo " $0: make sure you enable ZFS support (CONFIG_ZFS) before building." >&2
	-echo >&2
	+echo "$0: done. now you can build the kernel with ZFS support." >&2
	+echo "$0: make sure you enable ZFS support (CONFIG_ZFS) before building." >&2
	diff --git a/sys/contrib/openzfs/etc/systemd/system-generators/zfs-mount-generator.in b/sys/contrib/openzfs/etc/systemd/system-generators/zfs-mount-generator.in
	index 28439f424ad9..c276fbbce59d 100755
	--- a/sys/contrib/openzfs/etc/systemd/system-generators/zfs-mount-generator.in
	+++ b/sys/contrib/openzfs/etc/systemd/system-generators/zfs-mount-generator.in
	@@ -1,473 +1,474 @@
	#!/bin/sh

	# zfs-mount-generator - generates systemd mount units for zfs
	# Copyright (c) 2017 Antonio Russo <antonio.e.russo@gmail.com>
	# Copyright (c) 2020 InsanePrawn <insane.prawny@gmail.com>
	#
	# Permission is hereby granted, free of charge, to any person obtaining
	# a copy of this software and associated documentation files (the
	# "Software"), to deal in the Software without restriction, including
	# without limitation the rights to use, copy, modify, merge, publish,
	# distribute, sublicense, and/or sell copies of the Software, and to
	# permit persons to whom the Software is furnished to do so, subject to
	# the following conditions:
	#
	# The above copyright notice and this permission notice shall be
	# included in all copies or substantial portions of the Software.
	#
	# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
	# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
	# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
	# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

	set -e

	FSLIST="@sysconfdir@/zfs/zfs-list.cache"

	[ -d "${FSLIST}" ] \|\| exit 0
	+[ "$(echo "${FSLIST}"/)" = "${FSLIST}/" ] && exit 0

	do_fail() {
	printf 'zfs-mount-generator: %s\n' "$*" > /dev/kmsg
	exit 1
	}

	# test if $1 is in space-separated list $2
	is_known() {
	query="$1"
	IFS=' '
	for element in $2 ; do
	if [ "$query" = "$element" ] ; then
	return 0
	fi
	done
	return 1
	}

	# create dependency on unit file $1
	# of type $2, i.e. "wants" or "requires"
	# in the target units from space-separated list $3
	create_dependencies() {
	unitfile="$1"
	suffix="$2"
	IFS=' '
	for target in $3 ; do
	target_dir="${dest_norm}/${target}.${suffix}/"
	mkdir -p "${target_dir}"
	ln -s "../${unitfile}" "${target_dir}"
	done
	}

	# see systemd.generator
	if [ $# -eq 0 ] ; then
	dest_norm="/tmp"
	elif [ $# -eq 3 ] ; then
	dest_norm="${1}"
	else
	do_fail "zero or three arguments required"
	fi

	pools=$(zpool list -H -o name \|\| true)

	# All needed information about each ZFS is available from
	# zfs list -H -t filesystem -o <properties>
	# cached in $FSLIST, and each line is processed by the following function:
	# See the list below for the properties and their order

	process_line() {

	# zfs list -H -o name,...
	# fields are tab separated
	IFS="$(printf '\t')"
	# shellcheck disable=SC2086
	set -- $1

	dataset="${1}"
	pool="${dataset%%/*}"
	p_mountpoint="${2}"
	p_canmount="${3}"
	p_atime="${4}"
	p_relatime="${5}"
	p_devices="${6}"
	p_exec="${7}"
	p_readonly="${8}"
	p_setuid="${9}"
	p_nbmand="${10}"
	p_encroot="${11}"
	p_keyloc="${12}"
	p_systemd_requires="${13}"
	p_systemd_requiresmountsfor="${14}"
	p_systemd_before="${15}"
	p_systemd_after="${16}"
	p_systemd_wantedby="${17}"
	p_systemd_requiredby="${18}"
	p_systemd_nofail="${19}"
	p_systemd_ignore="${20}"

	# Minimal pre-requisites to mount a ZFS dataset
	# By ordering before zfs-mount.service, we avoid race conditions.
	after="zfs-import.target"
	before="zfs-mount.service"
	wants="zfs-import.target"
	requires=""
	requiredmounts=""
	bindsto=""
	wantedby=""
	requiredby=""
	noauto="off"

	# If the pool is already imported, zfs-import.target is not needed. This
	# avoids a dependency loop on root-on-ZFS systems:
	# systemd-random-seed.service After (via RequiresMountsFor) var-lib.mount
	# After zfs-import.target After zfs-import-{cache,scan}.service After
	# cryptsetup.service After systemd-random-seed.service.
	#
	# Pools are newline-separated and may contain spaces in their names.
	# There is no better portable way to set IFS to just a newline. Using
	# $(printf '\n') doesn't work because $(...) strips trailing newlines.
	IFS="
	"
	for p in $pools ; do
	if [ "$p" = "$pool" ] ; then
	after=""
	wants=""
	break
	fi
	done

	if [ -n "${p_systemd_after}" ] && \
	[ "${p_systemd_after}" != "-" ] ; then
	after="${p_systemd_after} ${after}"
	fi

	if [ -n "${p_systemd_before}" ] && \
	[ "${p_systemd_before}" != "-" ] ; then
	before="${p_systemd_before} ${before}"
	fi

	if [ -n "${p_systemd_requires}" ] && \
	[ "${p_systemd_requires}" != "-" ] ; then
	requires="Requires=${p_systemd_requires}"
	fi

	if [ -n "${p_systemd_requiresmountsfor}" ] && \
	[ "${p_systemd_requiresmountsfor}" != "-" ] ; then
	requiredmounts="RequiresMountsFor=${p_systemd_requiresmountsfor}"
	fi

	# Handle encryption
	if [ -n "${p_encroot}" ] &&
	[ "${p_encroot}" != "-" ] ; then
	keyloadunit="zfs-load-key-$(systemd-escape "${p_encroot}").service"
	if [ "${p_encroot}" = "${dataset}" ] ; then
	keymountdep=""
	if [ "${p_keyloc%%://*}" = "file" ] ; then
	if [ -n "${requiredmounts}" ] ; then
	keymountdep="${requiredmounts} '${p_keyloc#file://}'"
	else
	keymountdep="RequiresMountsFor='${p_keyloc#file://}'"
	fi
	keyloadscript="@sbindir@/zfs load-key \"${dataset}\""
	elif [ "${p_keyloc}" = "prompt" ] ; then
	keyloadscript="\
	count=0;\
	while [ \$\$count -lt 3 ];do\
	systemd-ask-password --id=\"zfs:${dataset}\"\
	\"Enter passphrase for ${dataset}:\"\|\
	@sbindir@/zfs load-key \"${dataset}\" && exit 0;\
	count=\$\$((count + 1));\
	done;\
	exit 1"
	else
	printf 'zfs-mount-generator: (%s) invalid keylocation\n' \
	"${dataset}" >/dev/kmsg
	fi
	keyloadcmd="\
	/bin/sh -c '\
	set -eu;\
	keystatus=\"\$\$(@sbindir@/zfs get -H -o value keystatus \"${dataset}\")\";\
	[ \"\$\$keystatus\" = \"unavailable\" ] \|\| exit 0;\
	${keyloadscript}'"
	keyunloadcmd="\
	/bin/sh -c '\
	set -eu;\
	keystatus=\"\$\$(@sbindir@/zfs get -H -o value keystatus \"${dataset}\")\";\
	[ \"\$\$keystatus\" = \"available\" ] \|\| exit 0;\
	@sbindir@/zfs unload-key \"${dataset}\"'"



	# Generate the key-load .service unit
	#
	# Note: It is tempting to use a `<<EOF` style here-document for this, but
	# bash requires a writable /tmp or $TMPDIR for that. This is not always
	# available early during boot.
	#
	echo \
	"# Automatically generated by zfs-mount-generator

	[Unit]
	Description=Load ZFS key for ${dataset}
	SourcePath=${cachefile}
	Documentation=man:zfs-mount-generator(8)
	DefaultDependencies=no
	Wants=${wants}
	After=${after}
	${requires}
	${keymountdep}

	[Service]
	Type=oneshot
	RemainAfterExit=yes
	# This avoids a dependency loop involving systemd-journald.socket if this
	# dataset is a parent of the root filesystem.
	StandardOutput=null
	StandardError=null
	ExecStart=${keyloadcmd}
	ExecStop=${keyunloadcmd}" > "${dest_norm}/${keyloadunit}"
	fi
	# Update the dependencies for the mount file to want the
	# key-loading unit.
	wants="${wants}"
	bindsto="BindsTo=${keyloadunit}"
	after="${after} ${keyloadunit}"
	fi

	# Prepare the .mount unit

	# skip generation of the mount unit if org.openzfs.systemd:ignore is "on"
	if [ -n "${p_systemd_ignore}" ] ; then
	if [ "${p_systemd_ignore}" = "on" ] ; then
	return
	elif [ "${p_systemd_ignore}" = "-" ] \
	\|\| [ "${p_systemd_ignore}" = "off" ] ; then
	: # This is OK
	else
	do_fail "invalid org.openzfs.systemd:ignore for ${dataset}"
	fi
	fi

	# Check for canmount=off .
	if [ "${p_canmount}" = "off" ] ; then
	return
	elif [ "${p_canmount}" = "noauto" ] ; then
	noauto="on"
	elif [ "${p_canmount}" = "on" ] ; then
	: # This is OK
	else
	do_fail "invalid canmount for ${dataset}"
	fi

	# Check for legacy and blank mountpoints.
	if [ "${p_mountpoint}" = "legacy" ] ; then
	return
	elif [ "${p_mountpoint}" = "none" ] ; then
	return
	elif [ "${p_mountpoint%"${p_mountpoint#?}"}" != "/" ] ; then
	do_fail "invalid mountpoint for ${dataset}"
	fi

	# Escape the mountpoint per systemd policy.
	mountfile="$(systemd-escape --path --suffix=mount "${p_mountpoint}")"

	# Parse options
	# see lib/libzfs/libzfs_mount.c:zfs_add_options
	opts=""

	# atime
	if [ "${p_atime}" = on ] ; then
	# relatime
	if [ "${p_relatime}" = on ] ; then
	opts="${opts},atime,relatime"
	elif [ "${p_relatime}" = off ] ; then
	opts="${opts},atime,strictatime"
	else
	printf 'zfs-mount-generator: (%s) invalid relatime\n' \
	"${dataset}" >/dev/kmsg
	fi
	elif [ "${p_atime}" = off ] ; then
	opts="${opts},noatime"
	else
	printf 'zfs-mount-generator: (%s) invalid atime\n' \
	"${dataset}" >/dev/kmsg
	fi

	# devices
	if [ "${p_devices}" = on ] ; then
	opts="${opts},dev"
	elif [ "${p_devices}" = off ] ; then
	opts="${opts},nodev"
	else
	printf 'zfs-mount-generator: (%s) invalid devices\n' \
	"${dataset}" >/dev/kmsg
	fi

	# exec
	if [ "${p_exec}" = on ] ; then
	opts="${opts},exec"
	elif [ "${p_exec}" = off ] ; then
	opts="${opts},noexec"
	else
	printf 'zfs-mount-generator: (%s) invalid exec\n' \
	"${dataset}" >/dev/kmsg
	fi

	# readonly
	if [ "${p_readonly}" = on ] ; then
	opts="${opts},ro"
	elif [ "${p_readonly}" = off ] ; then
	opts="${opts},rw"
	else
	printf 'zfs-mount-generator: (%s) invalid readonly\n' \
	"${dataset}" >/dev/kmsg
	fi

	# setuid
	if [ "${p_setuid}" = on ] ; then
	opts="${opts},suid"
	elif [ "${p_setuid}" = off ] ; then
	opts="${opts},nosuid"
	else
	printf 'zfs-mount-generator: (%s) invalid setuid\n' \
	"${dataset}" >/dev/kmsg
	fi

	# nbmand
	if [ "${p_nbmand}" = on ] ; then
	opts="${opts},mand"
	elif [ "${p_nbmand}" = off ] ; then
	opts="${opts},nomand"
	else
	printf 'zfs-mount-generator: (%s) invalid nbmand\n' \
	"${dataset}" >/dev/kmsg
	fi

	if [ -n "${p_systemd_wantedby}" ] && \
	[ "${p_systemd_wantedby}" != "-" ] ; then
	noauto="on"
	if [ "${p_systemd_wantedby}" = "none" ] ; then
	wantedby=""
	else
	wantedby="${p_systemd_wantedby}"
	before="${before} ${wantedby}"
	fi
	fi

	if [ -n "${p_systemd_requiredby}" ] && \
	[ "${p_systemd_requiredby}" != "-" ] ; then
	noauto="on"
	if [ "${p_systemd_requiredby}" = "none" ] ; then
	requiredby=""
	else
	requiredby="${p_systemd_requiredby}"
	before="${before} ${requiredby}"
	fi
	fi

	# For datasets with canmount=on, a dependency is created for
	# local-fs.target by default. To avoid regressions, this dependency
	# is reduced to "wants" rather than "requires" when nofail is not "off".
	# THIS MAY CHANGE
	# noauto=on disables this behavior completely.
	if [ "${noauto}" != "on" ] ; then
	if [ "${p_systemd_nofail}" = "off" ] ; then
	requiredby="local-fs.target"
	before="${before} local-fs.target"
	else
	wantedby="local-fs.target"
	if [ "${p_systemd_nofail}" != "on" ] ; then
	before="${before} local-fs.target"
	fi
	fi
	fi

	# Handle existing files:
	# 1. We never overwrite existing files, although we may delete
	# files if we're sure they were created by us. (see 5.)
	# 2. We handle files differently based on canmount. Units with canmount=on
	# always have precedence over noauto. This is enforced by the sort pipe
	# in the loop around this function.
	# It is important to use $p_canmount and not $noauto here, since we
	# sort by canmount while other properties also modify $noauto, e.g.
	# org.openzfs.systemd:wanted-by.
	# 3. If no unit file exists for a noauto dataset, we create one.
	# Additionally, we use $noauto_files to track the unit file names
	# (which are the systemd-escaped mountpoints) of all (exclusively)
	# noauto datasets that had a file created.
	# 4. If the file to be created is found in the tracking variable,
	# we do NOT create it.
	# 5. If a file exists for a noauto dataset, we check whether the file
	# name is in the variable. If it is, we have multiple noauto datasets
	# for the same mountpoint. In such cases, we remove the file for safety.
	# To avoid further noauto datasets creating a file for this path again,
	# we leave the file name in the tracking variable.
	if [ -e "${dest_norm}/${mountfile}" ] ; then
	if is_known "$mountfile" "$noauto_files" ; then
	# if it's in $noauto_files, we must be noauto too. See 2.
	printf 'zfs-mount-generator: removing duplicate noauto %s\n' \
	"${mountfile}" >/dev/kmsg
	# See 5.
	rm "${dest_norm}/${mountfile}"
	else
	# don't log for canmount=noauto
	if [ "${p_canmount}" = "on" ] ; then
	printf 'zfs-mount-generator: %s already exists. Skipping.\n' \
	"${mountfile}" >/dev/kmsg
	fi
	fi
	# file exists; Skip current dataset.
	return
	else
	if is_known "${mountfile}" "${noauto_files}" ; then
	# See 4.
	return
	elif [ "${p_canmount}" = "noauto" ] ; then
	noauto_files="${mountfile} ${noauto_files}"
	fi
	fi

	# Create the .mount unit file.
	#
	# (Do not use `<<EOF`-style here-documents for this, see warning above)
	#
	echo \
	"# Automatically generated by zfs-mount-generator

	[Unit]
	SourcePath=${cachefile}
	Documentation=man:zfs-mount-generator(8)

	Before=${before}
	After=${after}
	Wants=${wants}
	${bindsto}
	${requires}
	${requiredmounts}

	[Mount]
	Where=${p_mountpoint}
	What=${dataset}
	Type=zfs
	Options=defaults${opts},zfsutil" > "${dest_norm}/${mountfile}"

	# Finally, create the appropriate dependencies
	create_dependencies "${mountfile}" "wants" "$wantedby"
	create_dependencies "${mountfile}" "requires" "$requiredby"

	}

	for cachefile in "${FSLIST}/"* ; do
	# Disable glob expansion to protect against special characters when parsing.
	set -f
	# Sort cachefile's lines by canmount, "on" before "noauto"
	# and feed each line into process_line
	sort -t "$(printf '\t')" -k 3 -r "${cachefile}" \| \
	( # subshell is necessary for `sort\|while read` and $noauto_files
	noauto_files=""
	while read -r fs ; do
	process_line "${fs}"
	done
	)
	done
	diff --git a/sys/contrib/openzfs/etc/zfs/zfs-functions.in b/sys/contrib/openzfs/etc/zfs/zfs-functions.in
	index c2ce6157c6e0..54f2ebc0e7ea 100644
	--- a/sys/contrib/openzfs/etc/zfs/zfs-functions.in
	+++ b/sys/contrib/openzfs/etc/zfs/zfs-functions.in
	@@ -1,434 +1,434 @@
	# This is a script with common functions etc used by zfs-import, zfs-mount,
	# zfs-share and zfs-zed.
	#
	# It is _NOT_ to be called independently
	#
	# Released under the 2-clause BSD license.
	#
	# The original script that acted as a template for this script came from
	# the Debian GNU/Linux kFreeBSD ZFS packages (which did not include a
	# licensing stansa) in the commit dated Mar 24, 2011:
	# https://github.com/zfsonlinux/pkg-zfs/commit/80a3ae582b59c0250d7912ba794dca9e669e605a

	PATH=/sbin:/bin:/usr/bin:/usr/sbin

	# Source function library
	if [ -f /etc/rc.d/init.d/functions ]; then
	- # RedHat and derivates
	+ # RedHat and derivatives
	. /etc/rc.d/init.d/functions
	elif [ -L /etc/init.d/functions.sh ]; then
	# Gentoo
	. /etc/init.d/functions.sh
	elif [ -f /lib/lsb/init-functions ]; then
	- # LSB, Debian GNU/Linux and derivates
	+ # LSB, Debian GNU/Linux and derivatives
	. /lib/lsb/init-functions
	fi

	# Of course the functions we need are called differently
	# on different distributions - it would be way too easy
	# otherwise!!
	if type log_failure_msg > /dev/null 2>&1 ; then
	# LSB functions - fall through
	zfs_log_begin_msg() { log_begin_msg "$1"; }
	zfs_log_end_msg() { log_end_msg "$1"; }
	zfs_log_failure_msg() { log_failure_msg "$1"; }
	zfs_log_progress_msg() { log_progress_msg "$1"; }
	elif type success > /dev/null 2>&1 ; then
	# Fedora/RedHat functions
	zfs_set_ifs() {
	# For some reason, the init function library have a problem
	# with a changed IFS, so this function goes around that.
	local tIFS="$1"
	if [ -n "$tIFS" ]
	then
	TMP_IFS="$IFS"
	IFS="$tIFS"
	fi
	}

	zfs_log_begin_msg() { echo -n "$1 "; }
	zfs_log_end_msg() {
	zfs_set_ifs "$OLD_IFS"
	if [ "$1" -eq 0 ]; then
	success
	else
	failure
	fi
	echo
	zfs_set_ifs "$TMP_IFS"
	}
	zfs_log_failure_msg() {
	zfs_set_ifs "$OLD_IFS"
	failure
	echo
	zfs_set_ifs "$TMP_IFS"
	}
	zfs_log_progress_msg() { echo -n $"$1"; }
	elif type einfo > /dev/null 2>&1 ; then
	# Gentoo functions
	zfs_log_begin_msg() { ebegin "$1"; }
	zfs_log_end_msg() { eend "$1"; }
	zfs_log_failure_msg() { eend "$1"; }
	# zfs_log_progress_msg() { echo -n "$1"; }
	zfs_log_progress_msg() { echo -n; }
	else
	# Unknown - simple substitutes.
	zfs_log_begin_msg() { echo -n "$1"; }
	zfs_log_end_msg() {
	ret=$1
	if [ "$ret" -ge 1 ]; then
	echo " failed!"
	else
	echo " success"
	fi
	return "$ret"
	}
	zfs_log_failure_msg() { echo "$1"; }
	zfs_log_progress_msg() { echo -n "$1"; }
	fi

	# Paths to what we need
	ZFS="@sbindir@/zfs"
	ZED="@sbindir@/zed"
	ZPOOL="@sbindir@/zpool"
	ZPOOL_CACHE="@sysconfdir@/zfs/zpool.cache"

	# Sensible defaults
	ZFS_MOUNT='yes'
	ZFS_UNMOUNT='yes'
	ZFS_SHARE='yes'
	ZFS_UNSHARE='yes'

	# Source zfs configuration, overriding the defaults
	if [ -f @initconfdir@/zfs ]; then
	. @initconfdir@/zfs
	fi

	# ----------------------------------------------------

	export ZFS ZED ZPOOL ZPOOL_CACHE ZFS_MOUNT ZFS_UNMOUNT ZFS_SHARE ZFS_UNSHARE

	zfs_action()
	{
	local MSG="$1"; shift
	local CMD="$*"
	local ret

	zfs_log_begin_msg "$MSG "
	$CMD
	ret=$?
	if [ "$ret" -eq 0 ]; then
	zfs_log_end_msg $ret
	else
	zfs_log_failure_msg $ret
	fi

	return $ret
	}

	# Returns
	# 0 if daemon has been started
	# 1 if daemon was already running
	# 2 if daemon could not be started
	# 3 if unsupported
	#
	zfs_daemon_start()
	{
	local PIDFILE="$1"; shift
	local DAEMON_BIN="$1"; shift
	local DAEMON_ARGS="$*"

	if type start-stop-daemon > /dev/null 2>&1 ; then
	# LSB functions
	start-stop-daemon --start --quiet --pidfile "$PIDFILE" \
	--exec "$DAEMON_BIN" --test > /dev/null \|\| return 1

	start-stop-daemon --start --quiet --exec "$DAEMON_BIN" -- \
	$DAEMON_ARGS \|\| return 2

	# On Debian GNU/Linux, there's a 'sendsigs' script that will
	# kill basically everything quite early and zed is stopped
	# much later than that. We don't want zed to be among them,
	# so add the zed pid to list of pids to ignore.
	if [ -f "$PIDFILE" -a -d /run/sendsigs.omit.d ]
	then
	ln -sf "$PIDFILE" /run/sendsigs.omit.d/zed
	fi
	elif type daemon > /dev/null 2>&1 ; then
	# Fedora/RedHat functions
	daemon --pidfile "$PIDFILE" "$DAEMON_BIN" $DAEMON_ARGS
	return $?
	else
	# Unsupported
	return 3
	fi

	return 0
	}

	# Returns
	# 0 if daemon has been stopped
	# 1 if daemon was already stopped
	# 2 if daemon could not be stopped
	# 3 if unsupported
	#
	zfs_daemon_stop()
	{
	local PIDFILE="$1"
	local DAEMON_BIN="$2"
	local DAEMON_NAME="$3"

	if type start-stop-daemon > /dev/null 2>&1 ; then
	# LSB functions
	start-stop-daemon --stop --quiet --retry=TERM/30/KILL/5 \
	--pidfile "$PIDFILE" --name "$DAEMON_NAME"
	[ "$?" = 0 ] && rm -f "$PIDFILE"

	return $?
	elif type killproc > /dev/null 2>&1 ; then
	# Fedora/RedHat functions
	killproc -p "$PIDFILE" "$DAEMON_NAME"
	[ "$?" = 0 ] && rm -f "$PIDFILE"

	return $?
	else
	# Unsupported
	return 3
	fi

	return 0
	}

	# Returns status
	zfs_daemon_status()
	{
	local PIDFILE="$1"
	local DAEMON_BIN="$2"
	local DAEMON_NAME="$3"

	if type status_of_proc > /dev/null 2>&1 ; then
	# LSB functions
	status_of_proc "$DAEMON_NAME" "$DAEMON_BIN"
	return $?
	elif type status > /dev/null 2>&1 ; then
	# Fedora/RedHat functions
	status -p "$PIDFILE" "$DAEMON_NAME"
	return $?
	else
	# Unsupported
	return 3
	fi

	return 0
	}

	zfs_daemon_reload()
	{
	local PIDFILE="$1"
	local DAEMON_NAME="$2"

	if type start-stop-daemon > /dev/null 2>&1 ; then
	# LSB functions
	start-stop-daemon --stop --signal 1 --quiet \
	--pidfile "$PIDFILE" --name "$DAEMON_NAME"
	return $?
	elif type killproc > /dev/null 2>&1 ; then
	# Fedora/RedHat functions
	killproc -p "$PIDFILE" "$DAEMON_NAME" -HUP
	return $?
	else
	# Unsupported
	return 3
	fi

	return 0
	}

	zfs_installed()
	{
	if [ ! -x "$ZPOOL" ]; then
	return 1
	else
	# Test if it works (will catch missing/broken libs etc)
	"$ZPOOL" -? > /dev/null 2>&1
	return $?
	fi

	if [ ! -x "$ZFS" ]; then
	return 2
	else
	# Test if it works (will catch missing/broken libs etc)
	"$ZFS" -? > /dev/null 2>&1
	return $?
	fi

	return 0
	}

	# Trigger udev and wait for it to settle.
	udev_trigger()
	{
	if [ -x /sbin/udevadm ]; then
	/sbin/udevadm trigger --action=change --subsystem-match=block
	/sbin/udevadm settle
	elif [ -x /sbin/udevsettle ]; then
	/sbin/udevtrigger
	/sbin/udevsettle
	fi
	}

	# Do a lot of checks to make sure it's 'safe' to continue with the import.
	checksystem()
	{
	if grep -qiE '(^\|[^\\](\\\\)* )zfs=(off\|no\|0)( \|$)' /proc/cmdline;
	then
	# Called with zfs=(off\|no\|0) - bail because we don't
	# want anything import, mounted or shared.
	# HOWEVER, only do this if we're called at the boot up
	# (from init), not if we're running interactively (as in
	# from the shell - we know what we're doing).
	[ -n "$init" ] && exit 3
	fi

	# Check if ZFS is installed.
	zfs_installed \|\| return 5

	# Just make sure that /dev/zfs is created.
	udev_trigger

	return 0
	}

	get_root_pool()
	{
	set -- $(mount \| grep ' on / ')
	[ "$5" = "zfs" ] && echo "${1%%/*}"
	}

	# Check if a variable is 'yes' (any case) or '1'
	# Returns TRUE if set.
	check_boolean()
	{
	local var="$1"

	echo "$var" \| grep -Eiq "^yes$\|^on$\|^true$\|^1$" && return 0 \|\| return 1
	}

	check_module_loaded()
	{
	module="$1"

	[ -r "/sys/module/${module}/version" ] && return 0 \|\| return 1
	}

	load_module()
	{
	module="$1"

	# Load the zfs module stack
	if ! check_module_loaded "$module"; then
	if ! /sbin/modprobe "$module"; then
	return 5
	fi
	fi
	return 0
	}

	# first parameter is a regular expression that filters mtab
	read_mtab()
	{
	local match="$1"
	local fs mntpnt fstype opts rest TMPFILE

	# Unset all MTAB_* variables
	unset $(env \| grep ^MTAB_ \| sed 's,=.*,,')

	while read -r fs mntpnt fstype opts rest; do
	if echo "$fs $mntpnt $fstype $opts" \| grep -qE "$match"; then
	# * Fix problems (!?) in the mounts file. It will record
	# 'rpool 1' as 'rpool\0401' instead of 'rpool\00401'
	# which seems to be the correct (at least as far as
	# 'printf' is concerned).
	# * We need to use the external echo, because the
	# internal one would interpret the backslash code
	# (incorrectly), giving us a instead.
	mntpnt=$(/bin/echo "$mntpnt" \| sed "s,\\\0,\\\00,g")
	fs=$(/bin/echo "$fs" \| sed "s,\\\0,\\\00,")

	# Remove 'unwanted' characters.
	mntpnt=$(printf '%b\n' "$mntpnt" \| sed -e 's,/,,g' \
	-e 's,-,,g' -e 's,\.,,g' -e 's, ,,g')
	fs=$(printf '%b\n' "$fs")

	# Set the variable.
	eval export MTAB_$mntpnt=\"$fs\"
	fi
	done < /proc/self/mounts
	}

	in_mtab()
	{
	local mntpnt="$1"
	# Remove 'unwanted' characters.
	mntpnt=$(printf '%b\n' "$mntpnt" \| sed -e 's,/,,g' \
	-e 's,-,,g' -e 's,\.,,g' -e 's, ,,g')
	local var

	var="$(eval echo MTAB_$mntpnt)"
	[ "$(eval echo "$""$var")" != "" ]
	return "$?"
	}

	# first parameter is a regular expression that filters fstab
	read_fstab()
	{
	local match="$1"
	local i var TMPFILE

	# Unset all FSTAB_* variables
	unset $(env \| grep ^FSTAB_ \| sed 's,=.*,,')

	i=0
	while read -r fs mntpnt fstype opts; do
	echo "$fs" \| egrep -qE '^#\|^$' && continue
	echo "$mntpnt" \| egrep -qE '^none\|^swap' && continue
	echo "$fstype" \| egrep -qE '^swap' && continue

	if echo "$fs $mntpnt $fstype $opts" \| grep -qE "$match"; then
	eval export FSTAB_dev_$i="$fs"
	fs=$(printf '%b\n' "$fs" \| sed 's,/,_,g')
	eval export FSTAB_$i="$mntpnt"

	i=$((i + 1))
	fi
	done < /etc/fstab
	}

	in_fstab()
	{
	local var

	var="$(eval echo FSTAB_$1)"
	[ "${var}" != "" ]
	return $?
	}

	is_mounted()
	{
	local mntpt="$1"
	local line

	mount \| \
	while read line; do
	if echo "$line" \| grep -q " on $mntpt "; then
	# returns:
	# 0 on unsuccessful match
	# 1 on a successful match
	return 1
	fi
	done

	# The negation will flip the subshell return result where the default
	# return value is 0 when a match is not found.
	return $(( !$? ))
	}
	diff --git a/sys/contrib/openzfs/include/libzfs.h b/sys/contrib/openzfs/include/libzfs.h
	index 5f0bc03be144..eeb4daae723b 100644
	--- a/sys/contrib/openzfs/include/libzfs.h
	+++ b/sys/contrib/openzfs/include/libzfs.h
	@@ -1,949 +1,953 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2011, 2020 by Delphix. All rights reserved.
	* Copyright Joyent, Inc.
	* Copyright (c) 2013 Steven Hartland. All rights reserved.
	* Copyright (c) 2016, Intel Corporation.
	* Copyright 2016 Nexenta Systems, Inc.
	* Copyright (c) 2017 Open-E, Inc. All Rights Reserved.
	* Copyright (c) 2019 Datto Inc.
	* Copyright (c) 2021, Colm Buckley <colm@tuatha.org>
	*/

	#ifndef _LIBZFS_H
	#define _LIBZFS_H

	#include <assert.h>
	#include <libnvpair.h>
	#include <sys/mnttab.h>
	#include <sys/param.h>
	#include <sys/types.h>
	#include <sys/varargs.h>
	#include <sys/fs/zfs.h>
	#include <sys/avl.h>
	#include <ucred.h>
	#include <libzfs_core.h>

	#ifdef __cplusplus
	extern "C" {
	#endif

	/*
	* Miscellaneous ZFS constants
	*/
	#define ZFS_MAXPROPLEN MAXPATHLEN
	#define ZPOOL_MAXPROPLEN MAXPATHLEN

	/*
	* libzfs errors
	*/
	typedef enum zfs_error {
	EZFS_SUCCESS = 0, /* no error -- success */
	EZFS_NOMEM = 2000, /* out of memory */
	EZFS_BADPROP, /* invalid property value */
	EZFS_PROPREADONLY, /* cannot set readonly property */
	EZFS_PROPTYPE, /* property does not apply to dataset type */
	EZFS_PROPNONINHERIT, /* property is not inheritable */
	EZFS_PROPSPACE, /* bad quota or reservation */
	EZFS_BADTYPE, /* dataset is not of appropriate type */
	EZFS_BUSY, /* pool or dataset is busy */
	EZFS_EXISTS, /* pool or dataset already exists */
	EZFS_NOENT, /* no such pool or dataset */
	EZFS_BADSTREAM, /* bad backup stream */
	EZFS_DSREADONLY, /* dataset is readonly */
	EZFS_VOLTOOBIG, /* volume is too large for 32-bit system */
	EZFS_INVALIDNAME, /* invalid dataset name */
	EZFS_BADRESTORE, /* unable to restore to destination */
	EZFS_BADBACKUP, /* backup failed */
	EZFS_BADTARGET, /* bad attach/detach/replace target */
	EZFS_NODEVICE, /* no such device in pool */
	EZFS_BADDEV, /* invalid device to add */
	EZFS_NOREPLICAS, /* no valid replicas */
	EZFS_RESILVERING, /* resilvering (healing reconstruction) */
	EZFS_BADVERSION, /* unsupported version */
	EZFS_POOLUNAVAIL, /* pool is currently unavailable */
	EZFS_DEVOVERFLOW, /* too many devices in one vdev */
	EZFS_BADPATH, /* must be an absolute path */
	EZFS_CROSSTARGET, /* rename or clone across pool or dataset */
	EZFS_ZONED, /* used improperly in local zone */
	EZFS_MOUNTFAILED, /* failed to mount dataset */
	EZFS_UMOUNTFAILED, /* failed to unmount dataset */
	EZFS_UNSHARENFSFAILED, /* failed to unshare over nfs */
	EZFS_SHARENFSFAILED, /* failed to share over nfs */
	EZFS_PERM, /* permission denied */
	EZFS_NOSPC, /* out of space */
	EZFS_FAULT, /* bad address */
	EZFS_IO, /* I/O error */
	EZFS_INTR, /* signal received */
	EZFS_ISSPARE, /* device is a hot spare */
	EZFS_INVALCONFIG, /* invalid vdev configuration */
	EZFS_RECURSIVE, /* recursive dependency */
	EZFS_NOHISTORY, /* no history object */
	EZFS_POOLPROPS, /* couldn't retrieve pool props */
	EZFS_POOL_NOTSUP, /* ops not supported for this type of pool */
	EZFS_POOL_INVALARG, /* invalid argument for this pool operation */
	EZFS_NAMETOOLONG, /* dataset name is too long */
	EZFS_OPENFAILED, /* open of device failed */
	EZFS_NOCAP, /* couldn't get capacity */
	EZFS_LABELFAILED, /* write of label failed */
	EZFS_BADWHO, /* invalid permission who */
	EZFS_BADPERM, /* invalid permission */
	EZFS_BADPERMSET, /* invalid permission set name */
	EZFS_NODELEGATION, /* delegated administration is disabled */
	EZFS_UNSHARESMBFAILED, /* failed to unshare over smb */
	EZFS_SHARESMBFAILED, /* failed to share over smb */
	EZFS_BADCACHE, /* bad cache file */
	EZFS_ISL2CACHE, /* device is for the level 2 ARC */
	EZFS_VDEVNOTSUP, /* unsupported vdev type */
	EZFS_NOTSUP, /* ops not supported on this dataset */
	EZFS_ACTIVE_SPARE, /* pool has active shared spare devices */
	EZFS_UNPLAYED_LOGS, /* log device has unplayed logs */
	EZFS_REFTAG_RELE, /* snapshot release: tag not found */
	EZFS_REFTAG_HOLD, /* snapshot hold: tag already exists */
	EZFS_TAGTOOLONG, /* snapshot hold/rele: tag too long */
	EZFS_PIPEFAILED, /* pipe create failed */
	EZFS_THREADCREATEFAILED, /* thread create failed */
	EZFS_POSTSPLIT_ONLINE, /* onlining a disk after splitting it */
	EZFS_SCRUBBING, /* currently scrubbing */
	EZFS_NO_SCRUB, /* no active scrub */
	EZFS_DIFF, /* general failure of zfs diff */
	EZFS_DIFFDATA, /* bad zfs diff data */
	EZFS_POOLREADONLY, /* pool is in read-only mode */
	EZFS_SCRUB_PAUSED, /* scrub currently paused */
	EZFS_ACTIVE_POOL, /* pool is imported on a different system */
	EZFS_CRYPTOFAILED, /* failed to setup encryption */
	EZFS_NO_PENDING, /* cannot cancel, no operation is pending */
	EZFS_CHECKPOINT_EXISTS, /* checkpoint exists */
	EZFS_DISCARDING_CHECKPOINT, /* currently discarding a checkpoint */
	EZFS_NO_CHECKPOINT, /* pool has no checkpoint */
	EZFS_DEVRM_IN_PROGRESS, /* a device is currently being removed */
	EZFS_VDEV_TOO_BIG, /* a device is too big to be used */
	EZFS_IOC_NOTSUPPORTED, /* operation not supported by zfs module */
	EZFS_TOOMANY, /* argument list too long */
	EZFS_INITIALIZING, /* currently initializing */
	EZFS_NO_INITIALIZE, /* no active initialize */
	EZFS_WRONG_PARENT, /* invalid parent dataset (e.g ZVOL) */
	EZFS_TRIMMING, /* currently trimming */
	EZFS_NO_TRIM, /* no active trim */
	EZFS_TRIM_NOTSUP, /* device does not support trim */
	EZFS_NO_RESILVER_DEFER, /* pool doesn't support resilver_defer */
	EZFS_EXPORT_IN_PROGRESS, /* currently exporting the pool */
	EZFS_REBUILDING, /* resilvering (sequential reconstrution) */
	EZFS_UNKNOWN
	} zfs_error_t;

	/*
	* The following data structures are all part
	* of the zfs_allow_t data structure which is
	* used for printing 'allow' permissions.
	* It is a linked list of zfs_allow_t's which
	* then contain avl tree's for user/group/sets/...
	* and each one of the entries in those trees have
	* avl tree's for the permissions they belong to and
	* whether they are local,descendent or local+descendent
	* permissions. The AVL trees are used primarily for
	* sorting purposes, but also so that we can quickly find
	* a given user and or permission.
	*/
	typedef struct zfs_perm_node {
	avl_node_t z_node;
	char z_pname[MAXPATHLEN];
	} zfs_perm_node_t;

	typedef struct zfs_allow_node {
	avl_node_t z_node;
	char z_key[MAXPATHLEN]; /* name, such as joe */
	avl_tree_t z_localdescend; /* local+descendent perms */
	avl_tree_t z_local; /* local permissions */
	avl_tree_t z_descend; /* descendent permissions */
	} zfs_allow_node_t;

	typedef struct zfs_allow {
	struct zfs_allow *z_next;
	char z_setpoint[MAXPATHLEN];
	avl_tree_t z_sets;
	avl_tree_t z_crperms;
	avl_tree_t z_user;
	avl_tree_t z_group;
	avl_tree_t z_everyone;
	} zfs_allow_t;

	/*
	* Basic handle types
	*/
	typedef struct zfs_handle zfs_handle_t;
	typedef struct zpool_handle zpool_handle_t;
	typedef struct libzfs_handle libzfs_handle_t;

	extern int zpool_wait(zpool_handle_t *, zpool_wait_activity_t);
	extern int zpool_wait_status(zpool_handle_t *, zpool_wait_activity_t,
	boolean_t , boolean_t );

	/*
	* Library initialization
	*/
	extern libzfs_handle_t *libzfs_init(void);
	extern void libzfs_fini(libzfs_handle_t *);

	extern libzfs_handle_t zpool_get_handle(zpool_handle_t );
	extern libzfs_handle_t zfs_get_handle(zfs_handle_t );

	extern void libzfs_print_on_error(libzfs_handle_t *, boolean_t);

	extern void zfs_save_arguments(int argc, char *, char , int);
	extern int zpool_log_history(libzfs_handle_t , const char );

	extern int libzfs_errno(libzfs_handle_t *);
	extern const char *libzfs_error_init(int);
	extern const char libzfs_error_action(libzfs_handle_t );
	extern const char libzfs_error_description(libzfs_handle_t );
	extern int zfs_standard_error(libzfs_handle_t , int, const char );
	extern void libzfs_mnttab_init(libzfs_handle_t *);
	extern void libzfs_mnttab_fini(libzfs_handle_t *);
	extern void libzfs_mnttab_cache(libzfs_handle_t *, boolean_t);
	extern int libzfs_mnttab_find(libzfs_handle_t , const char ,
	struct mnttab *);
	extern void libzfs_mnttab_add(libzfs_handle_t , const char ,
	const char , const char );
	extern void libzfs_mnttab_remove(libzfs_handle_t , const char );

	/*
	* Basic handle functions
	*/
	extern zpool_handle_t zpool_open(libzfs_handle_t , const char *);
	extern zpool_handle_t zpool_open_canfail(libzfs_handle_t , const char *);
	extern void zpool_close(zpool_handle_t *);
	extern const char zpool_get_name(zpool_handle_t );
	extern int zpool_get_state(zpool_handle_t *);
	extern const char *zpool_state_to_name(vdev_state_t, vdev_aux_t);
	extern const char *zpool_pool_state_to_name(pool_state_t);
	extern void zpool_free_handles(libzfs_handle_t *);

	/*
	* Iterate over all active pools in the system.
	*/
	typedef int (zpool_iter_f)(zpool_handle_t , void *);
	extern int zpool_iter(libzfs_handle_t , zpool_iter_f, void );
	extern boolean_t zpool_skip_pool(const char *);

	/*
	* Functions to create and destroy pools
	*/
	extern int zpool_create(libzfs_handle_t , const char , nvlist_t *,
	nvlist_t , nvlist_t );
	extern int zpool_destroy(zpool_handle_t , const char );
	extern int zpool_add(zpool_handle_t , nvlist_t );

	typedef struct splitflags {
	/* do not split, but return the config that would be split off */
	int dryrun : 1;

	/* after splitting, import the pool */
	int import : 1;
	int name_flags;
	} splitflags_t;

	typedef struct trimflags {
	/* requested vdevs are for the entire pool */
	boolean_t fullpool;

	/* request a secure trim, requires support from device */
	boolean_t secure;

	/* after starting trim, block until trim completes */
	boolean_t wait;

	/* trim at the requested rate in bytes/second */
	uint64_t rate;
	} trimflags_t;

	/*
	* Functions to manipulate pool and vdev state
	*/
	extern int zpool_scan(zpool_handle_t *, pool_scan_func_t, pool_scrub_cmd_t);
	extern int zpool_initialize(zpool_handle_t *, pool_initialize_func_t,
	nvlist_t *);
	extern int zpool_initialize_wait(zpool_handle_t *, pool_initialize_func_t,
	nvlist_t *);
	extern int zpool_trim(zpool_handle_t , pool_trim_func_t, nvlist_t ,
	trimflags_t *);

	extern int zpool_clear(zpool_handle_t , const char , nvlist_t *);
	extern int zpool_reguid(zpool_handle_t *);
	extern int zpool_reopen_one(zpool_handle_t , void );

	extern int zpool_sync_one(zpool_handle_t , void );

	extern int zpool_vdev_online(zpool_handle_t , const char , int,
	vdev_state_t *);
	extern int zpool_vdev_offline(zpool_handle_t , const char , boolean_t);
	extern int zpool_vdev_attach(zpool_handle_t , const char ,
	const char , nvlist_t , int, boolean_t);
	extern int zpool_vdev_detach(zpool_handle_t , const char );
	extern int zpool_vdev_remove(zpool_handle_t , const char );
	extern int zpool_vdev_remove_cancel(zpool_handle_t *);
	extern int zpool_vdev_indirect_size(zpool_handle_t , const char , uint64_t *);
	extern int zpool_vdev_split(zpool_handle_t , char , nvlist_t *, nvlist_t ,
	splitflags_t);

	extern int zpool_vdev_fault(zpool_handle_t *, uint64_t, vdev_aux_t);
	extern int zpool_vdev_degrade(zpool_handle_t *, uint64_t, vdev_aux_t);
	extern int zpool_vdev_clear(zpool_handle_t *, uint64_t);

	extern nvlist_t zpool_find_vdev(zpool_handle_t , const char , boolean_t ,
	boolean_t , boolean_t );
	extern nvlist_t zpool_find_vdev_by_physpath(zpool_handle_t , const char *,
	boolean_t , boolean_t , boolean_t *);
	extern int zpool_label_disk(libzfs_handle_t , zpool_handle_t , const char *);
	extern uint64_t zpool_vdev_path_to_guid(zpool_handle_t zhp, const char path);

	const char zpool_get_state_str(zpool_handle_t );

	/*
	* Functions to manage pool properties
	*/
	extern int zpool_set_prop(zpool_handle_t , const char , const char *);
	extern int zpool_get_prop(zpool_handle_t , zpool_prop_t, char ,
	size_t proplen, zprop_source_t *, boolean_t literal);
	extern uint64_t zpool_get_prop_int(zpool_handle_t *, zpool_prop_t,
	zprop_source_t *);
	extern int zpool_props_refresh(zpool_handle_t *);

	extern const char *zpool_prop_to_name(zpool_prop_t);
	extern const char *zpool_prop_values(zpool_prop_t);

	/*
	* Pool health statistics.
	*/
	typedef enum {
	/*
	* The following correspond to faults as defined in the (fault.fs.zfs.*)
	* event namespace. Each is associated with a corresponding message ID.
	* This must be kept in sync with the zfs_msgid_table in
	* lib/libzfs/libzfs_status.c.
	*/
	ZPOOL_STATUS_CORRUPT_CACHE, /* corrupt /kernel/drv/zpool.cache */
	ZPOOL_STATUS_MISSING_DEV_R, /* missing device with replicas */
	ZPOOL_STATUS_MISSING_DEV_NR, /* missing device with no replicas */
	ZPOOL_STATUS_CORRUPT_LABEL_R, /* bad device label with replicas */
	ZPOOL_STATUS_CORRUPT_LABEL_NR, /* bad device label with no replicas */
	ZPOOL_STATUS_BAD_GUID_SUM, /* sum of device guids didn't match */
	ZPOOL_STATUS_CORRUPT_POOL, /* pool metadata is corrupted */
	ZPOOL_STATUS_CORRUPT_DATA, /* data errors in user (meta)data */
	ZPOOL_STATUS_FAILING_DEV, /* device experiencing errors */
	ZPOOL_STATUS_VERSION_NEWER, /* newer on-disk version */
	ZPOOL_STATUS_HOSTID_MISMATCH, /* last accessed by another system */
	ZPOOL_STATUS_HOSTID_ACTIVE, /* currently active on another system */
	ZPOOL_STATUS_HOSTID_REQUIRED, /* multihost=on and hostid=0 */
	ZPOOL_STATUS_IO_FAILURE_WAIT, /* failed I/O, failmode 'wait' */
	ZPOOL_STATUS_IO_FAILURE_CONTINUE, /* failed I/O, failmode 'continue' */
	ZPOOL_STATUS_IO_FAILURE_MMP, /* failed MMP, failmode not 'panic' */
	ZPOOL_STATUS_BAD_LOG, /* cannot read log chain(s) */
	ZPOOL_STATUS_ERRATA, /* informational errata available */

	/*
	* If the pool has unsupported features but can still be opened in
	* read-only mode, its status is ZPOOL_STATUS_UNSUP_FEAT_WRITE. If the
	* pool has unsupported features but cannot be opened at all, its
	* status is ZPOOL_STATUS_UNSUP_FEAT_READ.
	*/
	ZPOOL_STATUS_UNSUP_FEAT_READ, /* unsupported features for read */
	ZPOOL_STATUS_UNSUP_FEAT_WRITE, /* unsupported features for write */

	/*
	* These faults have no corresponding message ID. At the time we are
	* checking the status, the original reason for the FMA fault (I/O or
	* checksum errors) has been lost.
	*/
	ZPOOL_STATUS_FAULTED_DEV_R, /* faulted device with replicas */
	ZPOOL_STATUS_FAULTED_DEV_NR, /* faulted device with no replicas */

	/*
	* The following are not faults per se, but still an error possibly
	* requiring administrative attention. There is no corresponding
	* message ID.
	*/
	ZPOOL_STATUS_VERSION_OLDER, /* older legacy on-disk version */
	ZPOOL_STATUS_FEAT_DISABLED, /* supported features are disabled */
	ZPOOL_STATUS_RESILVERING, /* device being resilvered */
	ZPOOL_STATUS_OFFLINE_DEV, /* device offline */
	ZPOOL_STATUS_REMOVED_DEV, /* removed device */
	ZPOOL_STATUS_REBUILDING, /* device being rebuilt */
	ZPOOL_STATUS_REBUILD_SCRUB, /* recommend scrubbing the pool */
	ZPOOL_STATUS_NON_NATIVE_ASHIFT, /* (e.g. 512e dev with ashift of 9) */
	ZPOOL_STATUS_COMPATIBILITY_ERR, /* bad 'compatibility' property */
	+ ZPOOL_STATUS_INCOMPATIBLE_FEAT, /* feature set outside compatibility */

	/*
	* Finally, the following indicates a healthy pool.
	*/
	ZPOOL_STATUS_OK
	} zpool_status_t;

	extern zpool_status_t zpool_get_status(zpool_handle_t , char *,
	zpool_errata_t *);
	extern zpool_status_t zpool_import_status(nvlist_t , char *,
	zpool_errata_t *);

	/*
	* Statistics and configuration functions.
	*/
	extern nvlist_t zpool_get_config(zpool_handle_t , nvlist_t **);
	extern nvlist_t zpool_get_features(zpool_handle_t );
	extern int zpool_refresh_stats(zpool_handle_t , boolean_t );
	extern int zpool_get_errlog(zpool_handle_t , nvlist_t *);

	/*
	* Import and export functions
	*/
	extern int zpool_export(zpool_handle_t , boolean_t, const char );
	extern int zpool_export_force(zpool_handle_t , const char );
	extern int zpool_import(libzfs_handle_t , nvlist_t , const char *,
	char *altroot);
	extern int zpool_import_props(libzfs_handle_t , nvlist_t , const char *,
	nvlist_t *, int);
	extern void zpool_print_unsup_feat(nvlist_t *config);

	/*
	* Miscellaneous pool functions
	*/
	struct zfs_cmd;

	extern const char *zfs_history_event_names[];

	typedef enum {
	VDEV_NAME_PATH = 1 << 0,
	VDEV_NAME_GUID = 1 << 1,
	VDEV_NAME_FOLLOW_LINKS = 1 << 2,
	VDEV_NAME_TYPE_ID = 1 << 3,
	} vdev_name_t;

	extern char zpool_vdev_name(libzfs_handle_t , zpool_handle_t , nvlist_t ,
	int name_flags);
	extern int zpool_upgrade(zpool_handle_t *, uint64_t);
	extern int zpool_get_history(zpool_handle_t , nvlist_t , uint64_t ,
	boolean_t *);
	extern int zpool_events_next(libzfs_handle_t , nvlist_t , int , unsigned,
	int);
	extern int zpool_events_clear(libzfs_handle_t , int );
	extern int zpool_events_seek(libzfs_handle_t *, uint64_t, int);
	extern void zpool_obj_to_path_ds(zpool_handle_t , uint64_t, uint64_t, char ,
	size_t);
	extern void zpool_obj_to_path(zpool_handle_t , uint64_t, uint64_t, char ,
	size_t);
	extern int zfs_ioctl(libzfs_handle_t , int, struct zfs_cmd );
	extern int zpool_get_physpath(zpool_handle_t , char , size_t);
	extern void zpool_explain_recover(libzfs_handle_t , const char , int,
	nvlist_t *);
	extern int zpool_checkpoint(zpool_handle_t *);
	extern int zpool_discard_checkpoint(zpool_handle_t *);
	extern boolean_t zpool_is_draid_spare(const char *);

	/*
	* Basic handle manipulations. These functions do not create or destroy the
	* underlying datasets, only the references to them.
	*/
	extern zfs_handle_t zfs_open(libzfs_handle_t , const char *, int);
	extern zfs_handle_t zfs_handle_dup(zfs_handle_t );
	extern void zfs_close(zfs_handle_t *);
	extern zfs_type_t zfs_get_type(const zfs_handle_t *);
	extern const char zfs_get_name(const zfs_handle_t );
	extern zpool_handle_t zfs_get_pool_handle(const zfs_handle_t );
	extern const char zfs_get_pool_name(const zfs_handle_t );

	/*
	* Property management functions. Some functions are shared with the kernel,
	* and are found in sys/fs/zfs.h.
	*/

	/*
	* zfs dataset property management
	*/
	extern const char *zfs_prop_default_string(zfs_prop_t);
	extern uint64_t zfs_prop_default_numeric(zfs_prop_t);
	extern const char *zfs_prop_column_name(zfs_prop_t);
	extern boolean_t zfs_prop_align_right(zfs_prop_t);

	extern nvlist_t zfs_valid_proplist(libzfs_handle_t , zfs_type_t, nvlist_t *,
	uint64_t, zfs_handle_t , zpool_handle_t , boolean_t, const char *);

	extern const char *zfs_prop_to_name(zfs_prop_t);
	extern int zfs_prop_set(zfs_handle_t , const char , const char *);
	extern int zfs_prop_set_list(zfs_handle_t , nvlist_t );
	extern int zfs_prop_get(zfs_handle_t , zfs_prop_t, char , size_t,
	zprop_source_t , char , size_t, boolean_t);
	extern int zfs_prop_get_recvd(zfs_handle_t , const char , char *, size_t,
	boolean_t);
	extern int zfs_prop_get_numeric(zfs_handle_t , zfs_prop_t, uint64_t ,
	zprop_source_t , char , size_t);
	extern int zfs_prop_get_userquota_int(zfs_handle_t zhp, const char propname,
	uint64_t *propvalue);
	extern int zfs_prop_get_userquota(zfs_handle_t zhp, const char propname,
	char *propbuf, int proplen, boolean_t literal);
	extern int zfs_prop_get_written_int(zfs_handle_t zhp, const char propname,
	uint64_t *propvalue);
	extern int zfs_prop_get_written(zfs_handle_t zhp, const char propname,
	char *propbuf, int proplen, boolean_t literal);
	extern int zfs_prop_get_feature(zfs_handle_t zhp, const char propname,
	char *buf, size_t len);
	extern uint64_t getprop_uint64(zfs_handle_t , zfs_prop_t, char *);
	extern uint64_t zfs_prop_get_int(zfs_handle_t *, zfs_prop_t);
	extern int zfs_prop_inherit(zfs_handle_t , const char , boolean_t);
	extern const char *zfs_prop_values(zfs_prop_t);
	extern int zfs_prop_is_string(zfs_prop_t prop);
	extern nvlist_t zfs_get_all_props(zfs_handle_t );
	extern nvlist_t zfs_get_user_props(zfs_handle_t );
	extern nvlist_t zfs_get_recvd_props(zfs_handle_t );
	extern nvlist_t zfs_get_clones_nvl(zfs_handle_t );

	extern int zfs_wait_status(zfs_handle_t *, zfs_wait_activity_t,
	boolean_t , boolean_t );

	/*
	* zfs encryption management
	*/
	extern int zfs_crypto_get_encryption_root(zfs_handle_t , boolean_t , char *);
	extern int zfs_crypto_create(libzfs_handle_t , char , nvlist_t , nvlist_t ,
	boolean_t stdin_available, uint8_t *, uint_t );
	extern int zfs_crypto_clone_check(libzfs_handle_t , zfs_handle_t , char *,
	nvlist_t *);
	extern int zfs_crypto_attempt_load_keys(libzfs_handle_t , char );
	extern int zfs_crypto_load_key(zfs_handle_t , boolean_t, char );
	extern int zfs_crypto_unload_key(zfs_handle_t *);
	extern int zfs_crypto_rewrap(zfs_handle_t , nvlist_t , boolean_t);

	typedef struct zprop_list {
	int pl_prop;
	char *pl_user_prop;
	struct zprop_list *pl_next;
	boolean_t pl_all;
	size_t pl_width;
	size_t pl_recvd_width;
	boolean_t pl_fixed;
	} zprop_list_t;

	extern int zfs_expand_proplist(zfs_handle_t , zprop_list_t *, boolean_t,
	boolean_t);
	extern void zfs_prune_proplist(zfs_handle_t , uint8_t );

	#define ZFS_MOUNTPOINT_NONE "none"
	#define ZFS_MOUNTPOINT_LEGACY "legacy"

	#define ZFS_FEATURE_DISABLED "disabled"
	#define ZFS_FEATURE_ENABLED "enabled"
	#define ZFS_FEATURE_ACTIVE "active"

	#define ZFS_UNSUPPORTED_INACTIVE "inactive"
	#define ZFS_UNSUPPORTED_READONLY "readonly"

	/*
	* zpool property management
	*/
	extern int zpool_expand_proplist(zpool_handle_t , zprop_list_t *, boolean_t);
	extern int zpool_prop_get_feature(zpool_handle_t , const char , char *,
	size_t);
	extern const char *zpool_prop_default_string(zpool_prop_t);
	extern uint64_t zpool_prop_default_numeric(zpool_prop_t);
	extern const char *zpool_prop_column_name(zpool_prop_t);
	extern boolean_t zpool_prop_align_right(zpool_prop_t);

	/*
	* Functions shared by zfs and zpool property management.
	*/
	extern int zprop_iter(zprop_func func, void *cb, boolean_t show_all,
	boolean_t ordered, zfs_type_t type);
	extern int zprop_get_list(libzfs_handle_t , char , zprop_list_t **,
	zfs_type_t);
	extern void zprop_free_list(zprop_list_t *);

	#define ZFS_GET_NCOLS 5

	typedef enum {
	GET_COL_NONE,
	GET_COL_NAME,
	GET_COL_PROPERTY,
	GET_COL_VALUE,
	GET_COL_RECVD,
	GET_COL_SOURCE
	} zfs_get_column_t;

	/*
	* Functions for printing zfs or zpool properties
	*/
	typedef struct zprop_get_cbdata {
	int cb_sources;
	zfs_get_column_t cb_columns[ZFS_GET_NCOLS];
	int cb_colwidths[ZFS_GET_NCOLS + 1];
	boolean_t cb_scripted;
	boolean_t cb_literal;
	boolean_t cb_first;
	zprop_list_t *cb_proplist;
	zfs_type_t cb_type;
	} zprop_get_cbdata_t;

	void zprop_print_one_property(const char , zprop_get_cbdata_t ,
	const char , const char , zprop_source_t, const char *,
	const char *);

	/*
	* Iterator functions.
	*/
	typedef int (zfs_iter_f)(zfs_handle_t , void *);
	extern int zfs_iter_root(libzfs_handle_t , zfs_iter_f, void );
	extern int zfs_iter_children(zfs_handle_t , zfs_iter_f, void );
	extern int zfs_iter_dependents(zfs_handle_t , boolean_t, zfs_iter_f, void );
	extern int zfs_iter_filesystems(zfs_handle_t , zfs_iter_f, void );
	extern int zfs_iter_snapshots(zfs_handle_t , boolean_t, zfs_iter_f, void ,
	uint64_t, uint64_t);
	extern int zfs_iter_snapshots_sorted(zfs_handle_t , zfs_iter_f, void ,
	uint64_t, uint64_t);
	extern int zfs_iter_snapspec(zfs_handle_t , const char , zfs_iter_f, void *);
	extern int zfs_iter_bookmarks(zfs_handle_t , zfs_iter_f, void );
	extern int zfs_iter_mounted(zfs_handle_t , zfs_iter_f, void );

	typedef struct get_all_cb {
	zfs_handle_t **cb_handles;
	size_t cb_alloc;
	size_t cb_used;
	} get_all_cb_t;

	void zfs_foreach_mountpoint(libzfs_handle_t , zfs_handle_t *, size_t,
	zfs_iter_f, void *, boolean_t);
	void libzfs_add_handle(get_all_cb_t , zfs_handle_t );

	/*
	* Functions to create and destroy datasets.
	*/
	extern int zfs_create(libzfs_handle_t , const char , zfs_type_t,
	nvlist_t *);
	extern int zfs_create_ancestors(libzfs_handle_t , const char );
	extern int zfs_destroy(zfs_handle_t *, boolean_t);
	extern int zfs_destroy_snaps(zfs_handle_t , char , boolean_t);
	extern int zfs_destroy_snaps_nvl(libzfs_handle_t , nvlist_t , boolean_t);
	extern int zfs_clone(zfs_handle_t , const char , nvlist_t *);
	extern int zfs_snapshot(libzfs_handle_t , const char , boolean_t, nvlist_t *);
	extern int zfs_snapshot_nvl(libzfs_handle_t hdl, nvlist_t snaps,
	nvlist_t *props);
	extern int zfs_rollback(zfs_handle_t , zfs_handle_t , boolean_t);

	typedef struct renameflags {
	/* recursive rename */
	int recursive : 1;

	/* don't unmount file systems */
	int nounmount : 1;

	/* force unmount file systems */
	int forceunmount : 1;
	} renameflags_t;

	extern int zfs_rename(zfs_handle_t , const char , renameflags_t);

	typedef struct sendflags {
	/* Amount of extra information to print. */
	int verbosity;

	/* recursive send (ie, -R) */
	boolean_t replicate;

	+ /* for recursive send, skip sending missing snapshots */
	+ boolean_t skipmissing;
	+
	/* for incrementals, do all intermediate snapshots */
	boolean_t doall;

	/* if dataset is a clone, do incremental from its origin */
	boolean_t fromorigin;

	/* field no longer used, maintained for backwards compatibility */
	boolean_t pad;

	/* send properties (ie, -p) */
	boolean_t props;

	/* do not send (no-op, ie. -n) */
	boolean_t dryrun;

	/* parsable verbose output (ie. -P) */
	boolean_t parsable;

	/* show progress (ie. -v) */
	boolean_t progress;

	/* large blocks (>128K) are permitted */
	boolean_t largeblock;

	/* WRITE_EMBEDDED records of type DATA are permitted */
	boolean_t embed_data;

	/* compressed WRITE records are permitted */
	boolean_t compress;

	/* raw encrypted records are permitted */
	boolean_t raw;

	/* only send received properties (ie. -b) */
	boolean_t backup;

	/* include snapshot holds in send stream */
	boolean_t holds;

	/* stream represents a partially received dataset */
	boolean_t saved;
	} sendflags_t;

	typedef boolean_t (snapfilter_cb_t)(zfs_handle_t , void );

	extern int zfs_send(zfs_handle_t , const char , const char *,
	sendflags_t , int, snapfilter_cb_t, void , nvlist_t **);
	extern int zfs_send_one(zfs_handle_t , const char , int, sendflags_t *,
	const char *);
	extern int zfs_send_progress(zfs_handle_t , int, uint64_t , uint64_t *);
	extern int zfs_send_resume(libzfs_handle_t , sendflags_t , int outfd,
	const char *);
	extern int zfs_send_saved(zfs_handle_t , sendflags_t , int, const char *);
	extern nvlist_t zfs_send_resume_token_to_nvlist(libzfs_handle_t hdl,
	const char *token);

	extern int zfs_promote(zfs_handle_t *);
	extern int zfs_hold(zfs_handle_t , const char , const char *,
	boolean_t, int);
	extern int zfs_hold_nvl(zfs_handle_t , int, nvlist_t );
	extern int zfs_release(zfs_handle_t , const char , const char *, boolean_t);
	extern int zfs_get_holds(zfs_handle_t , nvlist_t *);
	extern uint64_t zvol_volsize_to_reservation(zpool_handle_t *, uint64_t,
	nvlist_t *);

	typedef int (zfs_userspace_cb_t)(void arg, const char *domain,
	uid_t rid, uint64_t space);

	extern int zfs_userspace(zfs_handle_t *, zfs_userquota_prop_t,
	zfs_userspace_cb_t, void *);

	extern int zfs_get_fsacl(zfs_handle_t , nvlist_t *);
	extern int zfs_set_fsacl(zfs_handle_t , boolean_t, nvlist_t );

	typedef struct recvflags {
	/* print informational messages (ie, -v was specified) */
	boolean_t verbose;

	/* the destination is a prefix, not the exact fs (ie, -d) */
	boolean_t isprefix;

	/*
	* Only the tail of the sent snapshot path is appended to the
	* destination to determine the received snapshot name (ie, -e).
	*/
	boolean_t istail;

	/* do not actually do the recv, just check if it would work (ie, -n) */
	boolean_t dryrun;

	/* rollback/destroy filesystems as necessary (eg, -F) */
	boolean_t force;

	/* set "canmount=off" on all modified filesystems */
	boolean_t canmountoff;

	/*
	* Mark the file systems as "resumable" and do not destroy them if the
	* receive is interrupted
	*/
	boolean_t resumable;

	/* byteswap flag is used internally; callers need not specify */
	boolean_t byteswap;

	/* do not mount file systems as they are extracted (private) */
	boolean_t nomount;

	/* Was holds flag set in the compound header? */
	boolean_t holds;

	/* skip receive of snapshot holds */
	boolean_t skipholds;

	/* mount the filesystem unless nomount is specified */
	boolean_t domount;

	/* force unmount while recv snapshot (private) */
	boolean_t forceunmount;
	} recvflags_t;

	extern int zfs_receive(libzfs_handle_t , const char , nvlist_t *,
	recvflags_t , int, avl_tree_t );

	typedef enum diff_flags {
	ZFS_DIFF_PARSEABLE = 0x1,
	ZFS_DIFF_TIMESTAMP = 0x2,
	ZFS_DIFF_CLASSIFY = 0x4
	} diff_flags_t;

	extern int zfs_show_diffs(zfs_handle_t , int, const char , const char *,
	int);

	/*
	* Miscellaneous functions.
	*/
	extern const char *zfs_type_to_name(zfs_type_t);
	extern void zfs_refresh_properties(zfs_handle_t *);
	extern int zfs_name_valid(const char *, zfs_type_t);
	extern zfs_handle_t zfs_path_to_zhandle(libzfs_handle_t , const char *,
	zfs_type_t);
	extern int zfs_parent_name(zfs_handle_t , char , size_t);
	extern boolean_t zfs_dataset_exists(libzfs_handle_t , const char ,
	zfs_type_t);
	extern int zfs_spa_version(zfs_handle_t , int );
	extern boolean_t zfs_bookmark_exists(const char *path);

	/*
	* Mount support functions.
	*/
	extern boolean_t is_mounted(libzfs_handle_t , const char special, char **);
	extern boolean_t zfs_is_mounted(zfs_handle_t , char *);
	extern int zfs_mount(zfs_handle_t , const char , int);
	extern int zfs_mount_at(zfs_handle_t , const char , int, const char *);
	extern int zfs_unmount(zfs_handle_t , const char , int);
	extern int zfs_unmountall(zfs_handle_t *, int);

	#if defined(__linux__)
	extern int zfs_parse_mount_options(char mntopts, unsigned long mntflags,
	unsigned long zfsflags, int sloppy, char badopt, char *mtabopt);
	extern void zfs_adjust_mount_options(zfs_handle_t zhp, const char mntpoint,
	char mntopts, char mtabopt);
	#endif

	/*
	* Share support functions.
	*/
	extern boolean_t zfs_is_shared(zfs_handle_t *);
	extern int zfs_share(zfs_handle_t *);
	extern int zfs_unshare(zfs_handle_t *);

	/*
	* Protocol-specific share support functions.
	*/
	extern boolean_t zfs_is_shared_nfs(zfs_handle_t , char *);
	extern boolean_t zfs_is_shared_smb(zfs_handle_t , char *);
	extern int zfs_share_nfs(zfs_handle_t *);
	extern int zfs_share_smb(zfs_handle_t *);
	extern int zfs_shareall(zfs_handle_t *);
	extern int zfs_unshare_nfs(zfs_handle_t , const char );
	extern int zfs_unshare_smb(zfs_handle_t , const char );
	extern int zfs_unshareall_nfs(zfs_handle_t *);
	extern int zfs_unshareall_smb(zfs_handle_t *);
	extern int zfs_unshareall_bypath(zfs_handle_t , const char );
	extern int zfs_unshareall_bytype(zfs_handle_t , const char , const char *);
	extern int zfs_unshareall(zfs_handle_t *);
	extern int zfs_deleg_share_nfs(libzfs_handle_t , char , char , char ,
	void , void , int, zfs_share_op_t);
	extern void zfs_commit_nfs_shares(void);
	extern void zfs_commit_smb_shares(void);
	extern void zfs_commit_all_shares(void);
	extern void zfs_commit_shares(const char *);

	extern int zfs_nicestrtonum(libzfs_handle_t , const char , uint64_t *);

	/*
	* Utility functions to run an external process.
	*/
	#define STDOUT_VERBOSE 0x01
	#define STDERR_VERBOSE 0x02
	#define NO_DEFAULT_PATH 0x04 /* Don't use $PATH to lookup the command */

	int libzfs_run_process(const char , char *, int);
	int libzfs_run_process_get_stdout(const char , char [], char *[],
	char *[], int );
	int libzfs_run_process_get_stdout_nopath(const char , char [], char *[],
	char *[], int );

	void libzfs_free_str_array(char **, int);

	int libzfs_envvar_is_set(char *);

	/*
	* Utility functions for zfs version
	*/
	extern void zfs_version_userland(char *, int);
	extern int zfs_version_kernel(char *, int);
	extern int zfs_version_print(void);

	/*
	* Given a device or file, determine if it is part of a pool.
	*/
	extern int zpool_in_use(libzfs_handle_t , int, pool_state_t , char **,
	boolean_t *);

	/*
	* Label manipulation.
	*/
	extern int zpool_clear_label(int);
	extern int zpool_set_bootenv(zpool_handle_t , const nvlist_t );
	extern int zpool_get_bootenv(zpool_handle_t , nvlist_t *);

	/*
	* Management interfaces for SMB ACL files
	*/

	int zfs_smb_acl_add(libzfs_handle_t , char , char , char );
	int zfs_smb_acl_remove(libzfs_handle_t , char , char , char );
	int zfs_smb_acl_purge(libzfs_handle_t , char , char *);
	int zfs_smb_acl_rename(libzfs_handle_t , char , char , char , char *);

	/*
	* Enable and disable datasets within a pool by mounting/unmounting and
	* sharing/unsharing them.
	*/
	extern int zpool_enable_datasets(zpool_handle_t , const char , int);
	extern int zpool_disable_datasets(zpool_handle_t *, boolean_t);

	/*
	* Parse a features file for -o compatibility
	*/
	typedef enum {
	ZPOOL_COMPATIBILITY_OK,
	- ZPOOL_COMPATIBILITY_READERR,
	+ ZPOOL_COMPATIBILITY_WARNTOKEN,
	+ ZPOOL_COMPATIBILITY_BADTOKEN,
	ZPOOL_COMPATIBILITY_BADFILE,
	- ZPOOL_COMPATIBILITY_BADWORD,
	ZPOOL_COMPATIBILITY_NOFILES
	} zpool_compat_status_t;

	extern zpool_compat_status_t zpool_load_compat(const char *,
	- boolean_t , char , char *);
	+ boolean_t , char , size_t);

	#ifdef __FreeBSD__

	/*
	* Attach/detach the given filesystem to/from the given jail.
	*/
	extern int zfs_jail(zfs_handle_t *zhp, int jailid, int attach);

	/*
	* Set loader options for next boot.
	*/
	extern int zpool_nextboot(libzfs_handle_t , uint64_t, uint64_t, const char );

	#endif /* __FreeBSD__ */

	#ifdef __cplusplus
	}
	#endif

	#endif /* _LIBZFS_H */
	diff --git a/sys/contrib/openzfs/include/os/freebsd/spl/sys/Makefile.am b/sys/contrib/openzfs/include/os/freebsd/spl/sys/Makefile.am
	index 6bee47830d9c..4bb9beffc723 100644
	--- a/sys/contrib/openzfs/include/os/freebsd/spl/sys/Makefile.am
	+++ b/sys/contrib/openzfs/include/os/freebsd/spl/sys/Makefile.am
	@@ -1,75 +1,74 @@
	KERNEL_H = \
	acl_impl.h \
	acl.h \
	atomic.h \
	byteorder.h \
	callb.h \
	ccompat.h \
	ccompile.h \
	cmn_err.h \
	condvar.h \
	- console.h \
	cred.h \
	ctype.h \
	debug.h \
	dirent.h \
	disp.h \
	dkio.h \
	extdirent.h \
	fcntl.h \
	file.h \
	freebsd_rwlock.h \
	idmap.h \
	inttypes.h \
	isa_defs.h \
	kmem_cache.h \
	kidmap.h \
	kmem.h \
	kstat.h \
	list_impl.h \
	list.h \
	lock.h \
	Makefile.am \
	misc.h \
	mod_os.h \
	mode.h \
	mount.h \
	mutex.h \
	param.h \
	policy.h \
	proc.h \
	processor.h \
	procfs_list.h \
	random.h \
	rwlock.h \
	sdt.h \
	sid.h \
	sig.h \
	simd_x86.h \
	simd.h \
	spl_condvar.h \
	string.h \
	strings.h \
	sunddi.h \
	sysmacros.h \
	systeminfo.h \
	systm.h \
	taskq.h \
	thread.h \
	time.h \
	timer.h \
	trace_zfs.h \
	trace.h \
	types.h \
	types32.h \
	uio.h \
	uuid.h \
	vfs.h \
	vm.h \
	vmsystm.h \
	vnode_impl.h \
	vnode.h \
	zmod.h \
	zone.h

	noinst_HEADERS = $(KERNEL_H)
	diff --git a/sys/contrib/openzfs/include/os/freebsd/spl/sys/console.h b/sys/contrib/openzfs/include/os/freebsd/spl/sys/console.h
	deleted file mode 100644
	index a0bf8175e6ce..000000000000
	--- a/sys/contrib/openzfs/include/os/freebsd/spl/sys/console.h
	+++ /dev/null
	@@ -1,35 +0,0 @@
	-/*
	- * 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.
	- *
	- * $FreeBSD$
	- */
	-
	-#ifndef _SPL_CONSOLE_H
	-#define _SPL_CONSOLE_H
	-
	-#define console_vprintf vprintf
	-#define console_printf printf
	-
	-#endif /* _SPL_CONSOLE_H */
	diff --git a/sys/contrib/openzfs/include/os/freebsd/spl/sys/vnode.h b/sys/contrib/openzfs/include/os/freebsd/spl/sys/vnode.h
	index fa7bbd88c6c8..3670712a0456 100644
	--- a/sys/contrib/openzfs/include/os/freebsd/spl/sys/vnode.h
	+++ b/sys/contrib/openzfs/include/os/freebsd/spl/sys/vnode.h
	@@ -1,213 +1,208 @@
	/*
	* Copyright (c) 2007 Pawel Jakub Dawidek <pjd@FreeBSD.org>
	* 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.
	*
	* $FreeBSD$
	*/

	#ifndef _OPENSOLARIS_SYS_VNODE_H_
	#define _OPENSOLARIS_SYS_VNODE_H_

	struct vnode;
	struct vattr;
	struct xucred;

	typedef struct flock flock64_t;
	typedef struct vnode vnode_t;
	typedef struct vattr vattr_t;
	typedef enum vtype vtype_t;

	#include <sys/types.h>
	#include <sys/queue.h>
	#include_next <sys/sdt.h>
	#include <sys/namei.h>
	enum symfollow { NO_FOLLOW = NOFOLLOW };

	#define NOCRED ((struct ucred )0) / no credential available */
	#define F_FREESP 11 /* Free file space */

	#include <sys/proc.h>
	#include <sys/vnode_impl.h>
	#ifndef IN_BASE
	#include_next <sys/vnode.h>
	#endif
	#include <sys/mount.h>
	#include <sys/cred.h>
	#include <sys/fcntl.h>
	#include <sys/refcount.h>
	#include <sys/file.h>
	#include <sys/filedesc.h>
	#include <sys/syscallsubr.h>

	typedef struct vop_vector vnodeops_t;
	#define VOP_FID VOP_VPTOFH
	#define vop_fid vop_vptofh
	#define vop_fid_args vop_vptofh_args
	#define a_fid a_fhp

	-#define IS_XATTRDIR(dvp) (0)
	-
	-#define v_count v_usecount
	-
	#define rootvfs (rootvnode == NULL ? NULL : rootvnode->v_mount)

	-
	#ifndef IN_BASE
	static __inline int
	vn_is_readonly(vnode_t *vp)
	{
	return (vp->v_mount->mnt_flag & MNT_RDONLY);
	}
	#endif
	#define vn_vfswlock(vp) (0)
	#define vn_vfsunlock(vp) do { } while (0)
	#define vn_ismntpt(vp) \
	((vp)->v_type == VDIR && (vp)->v_mountedhere != NULL)
	#define vn_mountedvfs(vp) ((vp)->v_mountedhere)
	#define vn_has_cached_data(vp) \
	((vp)->v_object != NULL && \
	(vp)->v_object->resident_page_count > 0)
	#define vn_exists(vp) do { } while (0)
	#define vn_invalid(vp) do { } while (0)
	#define vn_renamepath(tdvp, svp, tnm, lentnm) do { } while (0)
	#define vn_free(vp) do { } while (0)
	#define vn_matchops(vp, vops) ((vp)->v_op == &(vops))

	#define VN_HOLD(v) vref(v)
	#define VN_RELE(v) vrele(v)
	#define VN_URELE(v) vput(v)

	#define vnevent_create(vp, ct) do { } while (0)
	#define vnevent_link(vp, ct) do { } while (0)
	#define vnevent_remove(vp, dvp, name, ct) do { } while (0)
	#define vnevent_rmdir(vp, dvp, name, ct) do { } while (0)
	#define vnevent_rename_src(vp, dvp, name, ct) do { } while (0)
	#define vnevent_rename_dest(vp, dvp, name, ct) do { } while (0)
	#define vnevent_rename_dest_dir(vp, ct) do { } while (0)

	#define specvp(vp, rdev, type, cr) (VN_HOLD(vp), (vp))
	#define MANDLOCK(vp, mode) (0)

	/*
	* We will use va_spare is place of Solaris' va_mask.
	* This field is initialized in zfs_setattr().
	*/
	#define va_mask va_spare
	/* TODO: va_fileid is shorter than va_nodeid !!! */
	#define va_nodeid va_fileid
	/* TODO: This field needs conversion! */
	#define va_nblocks va_bytes
	#define va_blksize va_blocksize
	#define va_seq va_gen

	#define MAXOFFSET_T OFF_MAX
	#define EXCL 0

	#define FCREAT O_CREAT
	#define FTRUNC O_TRUNC
	#define FEXCL O_EXCL
	#ifndef FDSYNC
	#define FDSYNC FFSYNC
	#endif
	#define FRSYNC FFSYNC
	#define FSYNC FFSYNC
	#define FOFFMAX 0x00
	#define FIGNORECASE 0x00

	/*
	* Attributes of interest to the caller of setattr or getattr.
	*/
	#define AT_MODE 0x00002
	#define AT_UID 0x00004
	#define AT_GID 0x00008
	#define AT_FSID 0x00010
	#define AT_NODEID 0x00020
	#define AT_NLINK 0x00040
	#define AT_SIZE 0x00080
	#define AT_ATIME 0x00100
	#define AT_MTIME 0x00200
	#define AT_CTIME 0x00400
	#define AT_RDEV 0x00800
	#define AT_BLKSIZE 0x01000
	#define AT_NBLOCKS 0x02000
	/* 0x04000 / / unused */
	#define AT_SEQ 0x08000
	/*
	* If AT_XVATTR is set then there are additional bits to process in
	* the xvattr_t's attribute bitmap. If this is not set then the bitmap
	* MUST be ignored. Note that this bit must be set/cleared explicitly.
	* That is, setting AT_ALL will NOT set AT_XVATTR.
	*/
	#define AT_XVATTR 0x10000

	#define AT_ALL (AT_MODE\|AT_UID\|AT_GID\|AT_FSID\|AT_NODEID\|\
	AT_NLINK\|AT_SIZE\|AT_ATIME\|AT_MTIME\|AT_CTIME\|\
	AT_RDEV\|AT_BLKSIZE\|AT_NBLOCKS\|AT_SEQ)

	#define AT_STAT (AT_MODE\|AT_UID\|AT_GID\|AT_FSID\|AT_NODEID\|AT_NLINK\|\
	AT_SIZE\|AT_ATIME\|AT_MTIME\|AT_CTIME\|AT_RDEV)

	#define AT_TIMES (AT_ATIME\|AT_MTIME\|AT_CTIME)

	#define AT_NOSET (AT_NLINK\|AT_RDEV\|AT_FSID\|AT_NODEID\|\
	AT_BLKSIZE\|AT_NBLOCKS\|AT_SEQ)

	#ifndef IN_BASE
	static __inline void
	vattr_init_mask(vattr_t *vap)
	{

	vap->va_mask = 0;

	if (vap->va_uid != (uid_t)VNOVAL)
	vap->va_mask \|= AT_UID;
	if (vap->va_gid != (gid_t)VNOVAL)
	vap->va_mask \|= AT_GID;
	if (vap->va_size != (u_quad_t)VNOVAL)
	vap->va_mask \|= AT_SIZE;
	if (vap->va_atime.tv_sec != VNOVAL)
	vap->va_mask \|= AT_ATIME;
	if (vap->va_mtime.tv_sec != VNOVAL)
	vap->va_mask \|= AT_MTIME;
	if (vap->va_mode != (uint16_t)VNOVAL)
	vap->va_mask \|= AT_MODE;
	if (vap->va_flags != VNOVAL)
	vap->va_mask \|= AT_XVATTR;
	}
	#endif

	#define RLIM64_INFINITY 0

	static __inline int
	vn_rename(char from, char to, enum uio_seg seg)
	{

	ASSERT(seg == UIO_SYSSPACE);

	return (kern_renameat(curthread, AT_FDCWD, from, AT_FDCWD, to, seg));
	}

	#include <sys/vfs.h>

	#endif /* _OPENSOLARIS_SYS_VNODE_H_ */
	diff --git a/sys/contrib/openzfs/include/os/freebsd/spl/sys/vnode_impl.h b/sys/contrib/openzfs/include/os/freebsd/spl/sys/vnode_impl.h
	index 94ec1ad4ef6f..c82b1fc9ad18 100644
	--- a/sys/contrib/openzfs/include/os/freebsd/spl/sys/vnode_impl.h
	+++ b/sys/contrib/openzfs/include/os/freebsd/spl/sys/vnode_impl.h
	@@ -1,268 +1,268 @@
	/*
	* 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) 1988, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright 2017 RackTop Systems.
	*/

	/* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */
	/* All Rights Reserved */

	/*
	* University Copyright- Copyright (c) 1982, 1986, 1988
	* The Regents of the University of California
	* All Rights Reserved
	*
	* University Acknowledgment- Portions of this document are derived from
	* software developed by the University of California, Berkeley, and its
	* contributors.
	*/

	#ifndef _SYS_VNODE_IMPL_H
	#define _SYS_VNODE_IMPL_H


	#define IS_DEVVP(vp) \
	((vp)->v_type == VCHR \|\| (vp)->v_type == VBLK \|\| (vp)->v_type == VFIFO)

	#define V_XATTRDIR 0x0000 /* attribute unnamed directory */

	#define AV_SCANSTAMP_SZ 32 /* length of anti-virus scanstamp */

	/*
	* The xvattr structure is really a variable length structure that
	* is made up of:
	* - The classic vattr_t (xva_vattr)
	* - a 32 bit quantity (xva_mapsize) that specifies the size of the
	* attribute bitmaps in 32 bit words.
	* - A pointer to the returned attribute bitmap (needed because the
	* previous element, the requested attribute bitmap) is variable length.
	* - The requested attribute bitmap, which is an array of 32 bit words.
	* Callers use the XVA_SET_REQ() macro to set the bits corresponding to
	* the attributes that are being requested.
	* - The returned attribute bitmap, which is an array of 32 bit words.
	* File systems that support optional attributes use the XVA_SET_RTN()
	* macro to set the bits corresponding to the attributes that are being
	* returned.
	* - The xoptattr_t structure which contains the attribute values
	*
	* xva_mapsize determines how many words in the attribute bitmaps.
	* Immediately following the attribute bitmaps is the xoptattr_t.
	* xva_getxoptattr() is used to get the pointer to the xoptattr_t
	* section.
	*/

	#define XVA_MAPSIZE 3 /* Size of attr bitmaps */
	#define XVA_MAGIC 0x78766174 /* Magic # for verification */

	/*
	* The xvattr structure is an extensible structure which permits optional
	* attributes to be requested/returned. File systems may or may not support
	* optional attributes. They do so at their own discretion but if they do
	* support optional attributes, they must register the VFSFT_XVATTR feature
	* so that the optional attributes can be set/retrieved.
	*
	* The fields of the xvattr structure are:
	*
	* xva_vattr - The first element of an xvattr is a legacy vattr structure
	* which includes the common attributes. If AT_XVATTR is set in the va_mask
	* then the entire structure is treated as an xvattr. If AT_XVATTR is not
	* set, then only the xva_vattr structure can be used.
	*
	* xva_magic - 0x78766174 (hex for "xvat"). Magic number for verification.
	*
	* xva_mapsize - Size of requested and returned attribute bitmaps.
	*
	* xva_rtnattrmapp - Pointer to xva_rtnattrmap[]. We need this since the
	* size of the array before it, xva_reqattrmap[], could change which means
	* the location of xva_rtnattrmap[] could change. This will allow unbundled
	* file systems to find the location of xva_rtnattrmap[] when the sizes change.
	*
	* xva_reqattrmap[] - Array of requested attributes. Attributes are
	* represented by a specific bit in a specific element of the attribute
	* map array. Callers set the bits corresponding to the attributes
	* that the caller wants to get/set.
	*
	* xva_rtnattrmap[] - Array of attributes that the file system was able to
	* process. Not all file systems support all optional attributes. This map
	* informs the caller which attributes the underlying file system was able
	* to set/get. (Same structure as the requested attributes array in terms
	* of each attribute corresponding to specific bits and array elements.)
	*
	* xva_xoptattrs - Structure containing values of optional attributes.
	* These values are only valid if the corresponding bits in xva_reqattrmap
	* are set and the underlying file system supports those attributes.
	*/



	/*
	* Attribute bits used in the extensible attribute's (xva's) attribute
	* bitmaps. Note that the bitmaps are made up of a variable length number
	* of 32-bit words. The convention is to use XAT{n}_{attrname} where "n"
	* is the element in the bitmap (starting at 1). This convention is for
	* the convenience of the maintainer to keep track of which element each
	* attribute belongs to.
	*
	* NOTE THAT CONSUMERS MUST NOT USE THE XATn_* DEFINES DIRECTLY. CONSUMERS
	* MUST USE THE XAT_* DEFINES.
	*/
	#define XAT0_INDEX 0LL /* Index into bitmap for XAT0 attrs */
	#define XAT0_CREATETIME 0x00000001 /* Create time of file */
	#define XAT0_ARCHIVE 0x00000002 /* Archive */
	#define XAT0_SYSTEM 0x00000004 /* System */
	#define XAT0_READONLY 0x00000008 /* Readonly */
	#define XAT0_HIDDEN 0x00000010 /* Hidden */
	#define XAT0_NOUNLINK 0x00000020 /* Nounlink */
	#define XAT0_IMMUTABLE 0x00000040 /* immutable */
	#define XAT0_APPENDONLY 0x00000080 /* appendonly */
	#define XAT0_NODUMP 0x00000100 /* nodump */
	#define XAT0_OPAQUE 0x00000200 /* opaque */
	#define XAT0_AV_QUARANTINED 0x00000400 /* anti-virus quarantine */
	#define XAT0_AV_MODIFIED 0x00000800 /* anti-virus modified */
	#define XAT0_AV_SCANSTAMP 0x00001000 /* anti-virus scanstamp */
	#define XAT0_REPARSE 0x00002000 /* FS reparse point */
	#define XAT0_GEN 0x00004000 /* object generation number */
	#define XAT0_OFFLINE 0x00008000 /* offline */
	#define XAT0_SPARSE 0x00010000 /* sparse */

	/* Support for XAT_* optional attributes */
	#define XVA_MASK 0xffffffff /* Used to mask off 32 bits */
	#define XVA_SHFT 32 /* Used to shift index */

	/*
	* Used to pry out the index and attribute bits from the XAT_* attributes
	* defined below. Note that we're masking things down to 32 bits then
	* casting to uint32_t.
	*/
	#define XVA_INDEX(attr) ((uint32_t)(((attr) >> XVA_SHFT) & XVA_MASK))
	#define XVA_ATTRBIT(attr) ((uint32_t)((attr) & XVA_MASK))

	/*
	* The following defines present a "flat namespace" so that consumers don't
	* need to keep track of which element belongs to which bitmap entry.
	*
	* NOTE THAT THESE MUST NEVER BE OR-ed TOGETHER
	*/
	#define XAT_CREATETIME ((XAT0_INDEX << XVA_SHFT) \| XAT0_CREATETIME)
	#define XAT_ARCHIVE ((XAT0_INDEX << XVA_SHFT) \| XAT0_ARCHIVE)
	#define XAT_SYSTEM ((XAT0_INDEX << XVA_SHFT) \| XAT0_SYSTEM)
	#define XAT_READONLY ((XAT0_INDEX << XVA_SHFT) \| XAT0_READONLY)
	#define XAT_HIDDEN ((XAT0_INDEX << XVA_SHFT) \| XAT0_HIDDEN)
	#define XAT_NOUNLINK ((XAT0_INDEX << XVA_SHFT) \| XAT0_NOUNLINK)
	#define XAT_IMMUTABLE ((XAT0_INDEX << XVA_SHFT) \| XAT0_IMMUTABLE)
	#define XAT_APPENDONLY ((XAT0_INDEX << XVA_SHFT) \| XAT0_APPENDONLY)
	#define XAT_NODUMP ((XAT0_INDEX << XVA_SHFT) \| XAT0_NODUMP)
	#define XAT_OPAQUE ((XAT0_INDEX << XVA_SHFT) \| XAT0_OPAQUE)
	#define XAT_AV_QUARANTINED ((XAT0_INDEX << XVA_SHFT) \| XAT0_AV_QUARANTINED)
	#define XAT_AV_MODIFIED ((XAT0_INDEX << XVA_SHFT) \| XAT0_AV_MODIFIED)
	#define XAT_AV_SCANSTAMP ((XAT0_INDEX << XVA_SHFT) \| XAT0_AV_SCANSTAMP)
	#define XAT_REPARSE ((XAT0_INDEX << XVA_SHFT) \| XAT0_REPARSE)
	#define XAT_GEN ((XAT0_INDEX << XVA_SHFT) \| XAT0_GEN)
	#define XAT_OFFLINE ((XAT0_INDEX << XVA_SHFT) \| XAT0_OFFLINE)
	#define XAT_SPARSE ((XAT0_INDEX << XVA_SHFT) \| XAT0_SPARSE)

	/*
	* The returned attribute map array (xva_rtnattrmap[]) is located past the
	* requested attribute map array (xva_reqattrmap[]). Its location changes
	* when the array sizes change. We use a separate pointer in a known location
	* (xva_rtnattrmapp) to hold the location of xva_rtnattrmap[]. This is
	* set in xva_init()
	*/
	#define XVA_RTNATTRMAP(xvap) ((xvap)->xva_rtnattrmapp)

	#define MODEMASK 07777 /* mode bits plus permission bits */
	#define PERMMASK 00777 /* permission bits */

	/*
	* VOP_ACCESS flags
	*/
	#define V_ACE_MASK 0x1 /* mask represents NFSv4 ACE permissions */

	/*
	* Flags for vnode operations.
	*/
	enum rm { RMFILE, RMDIRECTORY }; /* rm or rmdir (remove) */
	enum create { CRCREAT, CRMKNOD, CRMKDIR }; /* reason for create */

	/*
	* Structure used by various vnode operations to determine
	* the context (pid, host, identity) of a caller.
	*
	* The cc_caller_id is used to identify one or more callers who invoke
	* operations, possibly on behalf of others. For example, the NFS
	- * server could have it's own cc_caller_id which can be detected by
	+ * server could have its own cc_caller_id which can be detected by
	* vnode/vfs operations or (FEM) monitors on those operations. New
	* caller IDs are generated by fs_new_caller_id().
	*/
	typedef struct caller_context {
	pid_t cc_pid; /* Process ID of the caller */
	int cc_sysid; /* System ID, used for remote calls */
	u_longlong_t cc_caller_id; /* Identifier for (set of) caller(s) */
	ulong_t cc_flags;
	} caller_context_t;

	struct taskq;

	/*
	* Flags for VOP_LOOKUP
	*
	* Defined in file.h, but also possible, FIGNORECASE and FSEARCH
	*
	*/
	#define LOOKUP_DIR 0x01 /* want parent dir vp */
	#define LOOKUP_XATTR 0x02 /* lookup up extended attr dir */
	#define CREATE_XATTR_DIR 0x04 /* Create extended attr dir */
	#define LOOKUP_HAVE_SYSATTR_DIR 0x08 /* Already created virtual GFS dir */

	/*
	* Flags for VOP_READDIR
	*/
	#define V_RDDIR_ENTFLAGS 0x01 /* request dirent flags */
	#define V_RDDIR_ACCFILTER 0x02 /* filter out inaccessible dirents */

	/*
	* Public vnode manipulation functions.
	*/

	void vn_rele_async(struct vnode vp, struct taskq taskq);

	#define VN_RELE_ASYNC(vp, taskq) { \
	vn_rele_async(vp, taskq); \
	}

	/*
	* Flags to VOP_SETATTR/VOP_GETATTR.
	*/
	#define ATTR_UTIME 0x01 /* non-default utime(2) request */
	#define ATTR_EXEC 0x02 /* invocation from exec(2) */
	#define ATTR_COMM 0x04 /* yield common vp attributes */
	#define ATTR_HINT 0x08 /* information returned will be `hint' */
	#define ATTR_REAL 0x10 /* yield attributes of the real vp */
	#define ATTR_NOACLCHECK 0x20 /* Don't check ACL when checking permissions */
	#define ATTR_TRIGGER 0x40 /* Mount first if vnode is a trigger mount */

	#ifdef __cplusplus
	}
	#endif

	#endif /* _SYS_VNODE_H */
	diff --git a/sys/contrib/openzfs/include/os/freebsd/zfs/sys/zfs_znode_impl.h b/sys/contrib/openzfs/include/os/freebsd/zfs/sys/zfs_znode_impl.h
	index dde87973f961..e90008c70a87 100644
	--- a/sys/contrib/openzfs/include/os/freebsd/zfs/sys/zfs_znode_impl.h
	+++ b/sys/contrib/openzfs/include/os/freebsd/zfs/sys/zfs_znode_impl.h
	@@ -1,188 +1,188 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2012, 2015 by Delphix. All rights reserved.
	* Copyright (c) 2014 Integros [integros.com]
	* Copyright 2016 Nexenta Systems, Inc. All rights reserved.
	*/

	#ifndef _FREEBSD_ZFS_SYS_ZNODE_IMPL_H
	#define _FREEBSD_ZFS_SYS_ZNODE_IMPL_H

	#include <sys/list.h>
	#include <sys/dmu.h>
	#include <sys/sa.h>
	#include <sys/zfs_vfsops.h>
	#include <sys/rrwlock.h>
	#include <sys/zfs_sa.h>
	#include <sys/zfs_stat.h>
	#include <sys/zfs_rlock.h>
	#include <sys/zfs_acl.h>
	#include <sys/zil.h>
	#include <sys/zfs_project.h>
	#include <vm/vm_object.h>
	#include <sys/uio.h>

	#ifdef __cplusplus
	extern "C" {
	#endif

	/*
	* Directory entry locks control access to directory entries.
	* They are used to protect creates, deletes, and renames.
	* Each directory znode has a mutex and a list of locked names.
	*/
	#define ZNODE_OS_FIELDS \
	struct zfsvfs *z_zfsvfs; \
	vnode_t *z_vnode; \
	- char *z_cached_symlink; \
	+ char *z_cached_symlink; \
	uint64_t z_uid; \
	uint64_t z_gid; \
	uint64_t z_gen; \
	uint64_t z_atime[2]; \
	uint64_t z_links;

	#define ZFS_LINK_MAX UINT64_MAX

	/*
	* ZFS minor numbers can refer to either a control device instance or
	* a zvol. Depending on the value of zss_type, zss_data points to either
	* a zvol_state_t or a zfs_onexit_t.
	*/
	enum zfs_soft_state_type {
	ZSST_ZVOL,
	ZSST_CTLDEV
	};

	typedef struct zfs_soft_state {
	enum zfs_soft_state_type zss_type;
	void *zss_data;
	} zfs_soft_state_t;

	extern minor_t zfsdev_minor_alloc(void);

	/*
	* Range locking rules
	* --------------------
	* 1. When truncating a file (zfs_create, zfs_setattr, zfs_space) the whole
	* file range needs to be locked as RL_WRITER. Only then can the pages be
	* freed etc and zp_size reset. zp_size must be set within range lock.
	* 2. For writes and punching holes (zfs_write & zfs_space) just the range
	* being written or freed needs to be locked as RL_WRITER.
	* Multiple writes at the end of the file must coordinate zp_size updates
	* to ensure data isn't lost. A compare and swap loop is currently used
	* to ensure the file size is at least the offset last written.
	* 3. For reads (zfs_read, zfs_get_data & zfs_putapage) just the range being
	* read needs to be locked as RL_READER. A check against zp_size can then
	* be made for reading beyond end of file.
	*/

	/*
	* Convert between znode pointers and vnode pointers
	*/
	#define ZTOV(ZP) ((ZP)->z_vnode)
	#define ZTOI(ZP) ((ZP)->z_vnode)
	#define VTOZ(VP) ((struct znode *)(VP)->v_data)
	#define VTOZ_SMR(VP) ((znode_t *)vn_load_v_data_smr(VP))
	#define ITOZ(VP) ((struct znode *)(VP)->v_data)
	#define zhold(zp) vhold(ZTOV((zp)))
	#define zrele(zp) vrele(ZTOV((zp)))

	#define ZTOZSB(zp) ((zp)->z_zfsvfs)
	#define ITOZSB(vp) (VTOZ(vp)->z_zfsvfs)
	#define ZTOTYPE(zp) (ZTOV(zp)->v_type)
	#define ZTOGID(zp) ((zp)->z_gid)
	#define ZTOUID(zp) ((zp)->z_uid)
	#define ZTONLNK(zp) ((zp)->z_links)
	#define Z_ISBLK(type) ((type) == VBLK)
	#define Z_ISCHR(type) ((type) == VCHR)
	#define Z_ISLNK(type) ((type) == VLNK)
	#define Z_ISDIR(type) ((type) == VDIR)

	#define zn_has_cached_data(zp) vn_has_cached_data(ZTOV(zp))
	#define zn_rlimit_fsize(zp, uio) \
	vn_rlimit_fsize(ZTOV(zp), GET_UIO_STRUCT(uio), zfs_uio_td(uio))

	/* Called on entry to each ZFS vnode and vfs operation */
	#define ZFS_ENTER(zfsvfs) \
	{ \
	ZFS_TEARDOWN_ENTER_READ((zfsvfs), FTAG); \
	if (__predict_false((zfsvfs)->z_unmounted)) { \
	ZFS_TEARDOWN_EXIT_READ(zfsvfs, FTAG); \
	return (EIO); \
	} \
	}

	/* Must be called before exiting the vop */
	#define ZFS_EXIT(zfsvfs) ZFS_TEARDOWN_EXIT_READ(zfsvfs, FTAG)

	/* Verifies the znode is valid */
	#define ZFS_VERIFY_ZP(zp) \
	if (__predict_false((zp)->z_sa_hdl == NULL)) { \
	ZFS_EXIT((zp)->z_zfsvfs); \
	return (EIO); \
	} \

	/*
	* Macros for dealing with dmu_buf_hold
	*/
	#define ZFS_OBJ_HASH(obj_num) ((obj_num) & (ZFS_OBJ_MTX_SZ - 1))
	#define ZFS_OBJ_MUTEX(zfsvfs, obj_num) \
	(&(zfsvfs)->z_hold_mtx[ZFS_OBJ_HASH(obj_num)])
	#define ZFS_OBJ_HOLD_ENTER(zfsvfs, obj_num) \
	mutex_enter(ZFS_OBJ_MUTEX((zfsvfs), (obj_num)))
	#define ZFS_OBJ_HOLD_TRYENTER(zfsvfs, obj_num) \
	mutex_tryenter(ZFS_OBJ_MUTEX((zfsvfs), (obj_num)))
	#define ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num) \
	mutex_exit(ZFS_OBJ_MUTEX((zfsvfs), (obj_num)))

	/* Encode ZFS stored time values from a struct timespec */
	#define ZFS_TIME_ENCODE(tp, stmp) \
	{ \
	(stmp)[0] = (uint64_t)(tp)->tv_sec; \
	(stmp)[1] = (uint64_t)(tp)->tv_nsec; \
	}

	/* Decode ZFS stored time values to a struct timespec */
	#define ZFS_TIME_DECODE(tp, stmp) \
	{ \
	(tp)->tv_sec = (time_t)(stmp)[0]; \
	(tp)->tv_nsec = (long)(stmp)[1]; \
	}
	#define ZFS_ACCESSTIME_STAMP(zfsvfs, zp) \
	if ((zfsvfs)->z_atime && !((zfsvfs)->z_vfs->vfs_flag & VFS_RDONLY)) \
	zfs_tstamp_update_setup_ext(zp, ACCESSED, NULL, NULL, B_FALSE);

	extern void zfs_tstamp_update_setup_ext(struct znode *,
	uint_t, uint64_t [2], uint64_t [2], boolean_t have_tx);
	extern void zfs_znode_free(struct znode *);

	extern zil_replay_func_t *zfs_replay_vector[TX_MAX_TYPE];
	extern int zfsfstype;

	extern int zfs_znode_parent_and_name(struct znode zp, struct znode *dzpp,
	char *buf);
	#ifdef __cplusplus
	}
	#endif

	#endif /* _FREEBSD_SYS_FS_ZFS_ZNODE_H */
	diff --git a/sys/contrib/openzfs/include/os/linux/kernel/linux/blkdev_compat.h b/sys/contrib/openzfs/include/os/linux/kernel/linux/blkdev_compat.h
	index ee066537b900..87d541072015 100644
	--- a/sys/contrib/openzfs/include/os/linux/kernel/linux/blkdev_compat.h
	+++ b/sys/contrib/openzfs/include/os/linux/kernel/linux/blkdev_compat.h
	@@ -1,575 +1,579 @@
	/*
	* 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) 2011 Lawrence Livermore National Security, LLC.
	* Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
	* Written by Brian Behlendorf <behlendorf1@llnl.gov>.
	* LLNL-CODE-403049.
	*/

	#ifndef _ZFS_BLKDEV_H
	#define _ZFS_BLKDEV_H

	#include <linux/blkdev.h>
	#include <linux/elevator.h>
	#include <linux/backing-dev.h>
	#include <linux/hdreg.h>
	#include <linux/msdos_fs.h> /* for SECTOR_* */

	#ifndef HAVE_BLK_QUEUE_FLAG_SET
	static inline void
	blk_queue_flag_set(unsigned int flag, struct request_queue *q)
	{
	queue_flag_set(flag, q);
	}
	#endif

	#ifndef HAVE_BLK_QUEUE_FLAG_CLEAR
	static inline void
	blk_queue_flag_clear(unsigned int flag, struct request_queue *q)
	{
	queue_flag_clear(flag, q);
	}
	#endif

	/*
	- * 4.7 - 4.x API,
	+ * 4.7 API,
	* The blk_queue_write_cache() interface has replaced blk_queue_flush()
	* interface. However, the new interface is GPL-only thus we implement
	* our own trivial wrapper when the GPL-only version is detected.
	*
	* 2.6.36 - 4.6 API,
	* The blk_queue_flush() interface has replaced blk_queue_ordered()
	* interface. However, while the old interface was available to all the
	* new one is GPL-only. Thus if the GPL-only version is detected we
	* implement our own trivial helper.
	*/
	static inline void
	blk_queue_set_write_cache(struct request_queue *q, bool wc, bool fua)
	{
	#if defined(HAVE_BLK_QUEUE_WRITE_CACHE_GPL_ONLY)
	if (wc)
	blk_queue_flag_set(QUEUE_FLAG_WC, q);
	else
	blk_queue_flag_clear(QUEUE_FLAG_WC, q);
	if (fua)
	blk_queue_flag_set(QUEUE_FLAG_FUA, q);
	else
	blk_queue_flag_clear(QUEUE_FLAG_FUA, q);
	#elif defined(HAVE_BLK_QUEUE_WRITE_CACHE)
	blk_queue_write_cache(q, wc, fua);
	#elif defined(HAVE_BLK_QUEUE_FLUSH_GPL_ONLY)
	if (wc)
	q->flush_flags \|= REQ_FLUSH;
	if (fua)
	q->flush_flags \|= REQ_FUA;
	#elif defined(HAVE_BLK_QUEUE_FLUSH)
	blk_queue_flush(q, (wc ? REQ_FLUSH : 0) \| (fua ? REQ_FUA : 0));
	#else
	#error "Unsupported kernel"
	#endif
	}

	static inline void
	blk_queue_set_read_ahead(struct request_queue *q, unsigned long ra_pages)
	{
	#ifdef HAVE_BLK_QUEUE_BDI_DYNAMIC
	q->backing_dev_info->ra_pages = ra_pages;
	#else
	q->backing_dev_info.ra_pages = ra_pages;
	#endif
	}

	#ifdef HAVE_BIO_BVEC_ITER
	#define BIO_BI_SECTOR(bio) (bio)->bi_iter.bi_sector
	#define BIO_BI_SIZE(bio) (bio)->bi_iter.bi_size
	#define BIO_BI_IDX(bio) (bio)->bi_iter.bi_idx
	#define BIO_BI_SKIP(bio) (bio)->bi_iter.bi_bvec_done
	#define bio_for_each_segment4(bv, bvp, b, i) \
	bio_for_each_segment((bv), (b), (i))
	typedef struct bvec_iter bvec_iterator_t;
	#else
	#define BIO_BI_SECTOR(bio) (bio)->bi_sector
	#define BIO_BI_SIZE(bio) (bio)->bi_size
	#define BIO_BI_IDX(bio) (bio)->bi_idx
	#define BIO_BI_SKIP(bio) (0)
	#define bio_for_each_segment4(bv, bvp, b, i) \
	bio_for_each_segment((bvp), (b), (i))
	typedef int bvec_iterator_t;
	#endif

	static inline void
	bio_set_flags_failfast(struct block_device bdev, int flags)
	{
	#ifdef CONFIG_BUG
	/*
	* Disable FAILFAST for loopback devices because of the
	* following incorrect BUG_ON() in loop_make_request().
	* This support is also disabled for md devices because the
	* test suite layers md devices on top of loopback devices.
	* This may be removed when the loopback driver is fixed.
	*
	* BUG_ON(!lo \|\| (rw != READ && rw != WRITE));
	*/
	if ((MAJOR(bdev->bd_dev) == LOOP_MAJOR) \|\|
	(MAJOR(bdev->bd_dev) == MD_MAJOR))
	return;

	#ifdef BLOCK_EXT_MAJOR
	if (MAJOR(bdev->bd_dev) == BLOCK_EXT_MAJOR)
	return;
	#endif /* BLOCK_EXT_MAJOR */
	#endif /* CONFIG_BUG */

	*flags \|= REQ_FAILFAST_MASK;
	}

	/*
	* Maximum disk label length, it may be undefined for some kernels.
	*/
	#if !defined(DISK_NAME_LEN)
	#define DISK_NAME_LEN 32
	#endif /* DISK_NAME_LEN */

	#ifdef HAVE_BIO_BI_STATUS
	static inline int
	bi_status_to_errno(blk_status_t status)
	{
	switch (status) {
	case BLK_STS_OK:
	return (0);
	case BLK_STS_NOTSUPP:
	return (EOPNOTSUPP);
	case BLK_STS_TIMEOUT:
	return (ETIMEDOUT);
	case BLK_STS_NOSPC:
	return (ENOSPC);
	case BLK_STS_TRANSPORT:
	return (ENOLINK);
	case BLK_STS_TARGET:
	return (EREMOTEIO);
	case BLK_STS_NEXUS:
	return (EBADE);
	case BLK_STS_MEDIUM:
	return (ENODATA);
	case BLK_STS_PROTECTION:
	return (EILSEQ);
	case BLK_STS_RESOURCE:
	return (ENOMEM);
	case BLK_STS_AGAIN:
	return (EAGAIN);
	case BLK_STS_IOERR:
	return (EIO);
	default:
	return (EIO);
	}
	}

	static inline blk_status_t
	errno_to_bi_status(int error)
	{
	switch (error) {
	case 0:
	return (BLK_STS_OK);
	case EOPNOTSUPP:
	return (BLK_STS_NOTSUPP);
	case ETIMEDOUT:
	return (BLK_STS_TIMEOUT);
	case ENOSPC:
	return (BLK_STS_NOSPC);
	case ENOLINK:
	return (BLK_STS_TRANSPORT);
	case EREMOTEIO:
	return (BLK_STS_TARGET);
	case EBADE:
	return (BLK_STS_NEXUS);
	case ENODATA:
	return (BLK_STS_MEDIUM);
	case EILSEQ:
	return (BLK_STS_PROTECTION);
	case ENOMEM:
	return (BLK_STS_RESOURCE);
	case EAGAIN:
	return (BLK_STS_AGAIN);
	case EIO:
	return (BLK_STS_IOERR);
	default:
	return (BLK_STS_IOERR);
	}
	}
	#endif /* HAVE_BIO_BI_STATUS */

	/*
	* 4.3 API change
	* The bio_endio() prototype changed slightly. These are helper
	* macro's to ensure the prototype and invocation are handled.
	*/
	#ifdef HAVE_1ARG_BIO_END_IO_T
	#ifdef HAVE_BIO_BI_STATUS
	#define BIO_END_IO_ERROR(bio) bi_status_to_errno(bio->bi_status)
	#define BIO_END_IO_PROTO(fn, x, z) static void fn(struct bio *x)
	#define BIO_END_IO(bio, error) bio_set_bi_status(bio, error)
	static inline void
	bio_set_bi_status(struct bio *bio, int error)
	{
	ASSERT3S(error, <=, 0);
	bio->bi_status = errno_to_bi_status(-error);
	bio_endio(bio);
	}
	#else
	#define BIO_END_IO_ERROR(bio) (-(bio->bi_error))
	#define BIO_END_IO_PROTO(fn, x, z) static void fn(struct bio *x)
	#define BIO_END_IO(bio, error) bio_set_bi_error(bio, error)
	static inline void
	bio_set_bi_error(struct bio *bio, int error)
	{
	ASSERT3S(error, <=, 0);
	bio->bi_error = error;
	bio_endio(bio);
	}
	#endif /* HAVE_BIO_BI_STATUS */

	#else
	#define BIO_END_IO_PROTO(fn, x, z) static void fn(struct bio *x, int z)
	#define BIO_END_IO(bio, error) bio_endio(bio, error);
	#endif /* HAVE_1ARG_BIO_END_IO_T */

	/*
	- * 4.1 - x.y.z API,
	+ * 4.1 API,
	* 3.10.0 CentOS 7.x API,
	* blkdev_reread_part()
	*
	* For older kernels trigger a re-reading of the partition table by calling
	* check_disk_change() which calls flush_disk() to invalidate the device.
	*
	- * For newer kernels (as of 5.10), bdev_check_media_chage is used, in favor of
	+ * For newer kernels (as of 5.10), bdev_check_media_change is used, in favor of
	* check_disk_change(), with the modification that invalidation is no longer
	* forced.
	*/
	#ifdef HAVE_CHECK_DISK_CHANGE
	#define zfs_check_media_change(bdev) check_disk_change(bdev)
	#ifdef HAVE_BLKDEV_REREAD_PART
	#define vdev_bdev_reread_part(bdev) blkdev_reread_part(bdev)
	#else
	#define vdev_bdev_reread_part(bdev) check_disk_change(bdev)
	#endif /* HAVE_BLKDEV_REREAD_PART */
	#else
	#ifdef HAVE_BDEV_CHECK_MEDIA_CHANGE
	static inline int
	zfs_check_media_change(struct block_device *bdev)
	{
	+#ifdef HAVE_BLOCK_DEVICE_OPERATIONS_REVALIDATE_DISK
	struct gendisk *gd = bdev->bd_disk;
	const struct block_device_operations *bdo = gd->fops;
	+#endif

	if (!bdev_check_media_change(bdev))
	return (0);

	+#ifdef HAVE_BLOCK_DEVICE_OPERATIONS_REVALIDATE_DISK
	/*
	* Force revalidation, to mimic the old behavior of
	* check_disk_change()
	*/
	if (bdo->revalidate_disk)
	bdo->revalidate_disk(gd);
	+#endif

	return (0);
	}
	#define vdev_bdev_reread_part(bdev) zfs_check_media_change(bdev)
	#else
	/*
	* This is encountered if check_disk_change() and bdev_check_media_change()
	* are not available in the kernel - likely due to an API change that needs
	* to be chased down.
	*/
	#error "Unsupported kernel: no usable disk change check"
	#endif /* HAVE_BDEV_CHECK_MEDIA_CHANGE */
	#endif /* HAVE_CHECK_DISK_CHANGE */

	/*
	* 2.6.27 API change
	* The function was exported for use, prior to this it existed but the
	* symbol was not exported.
	*
	* 4.4.0-6.21 API change for Ubuntu
	* lookup_bdev() gained a second argument, FMODE_*, to check inode permissions.
	*
	* 5.11 API change
	* Changed to take a dev_t argument which is set on success and return a
	* non-zero error code on failure.
	*/
	static inline int
	vdev_lookup_bdev(const char path, dev_t dev)
	{
	#if defined(HAVE_DEVT_LOOKUP_BDEV)
	return (lookup_bdev(path, dev));
	#elif defined(HAVE_1ARG_LOOKUP_BDEV)
	struct block_device *bdev = lookup_bdev(path);
	if (IS_ERR(bdev))
	return (PTR_ERR(bdev));

	*dev = bdev->bd_dev;
	bdput(bdev);

	return (0);
	#elif defined(HAVE_MODE_LOOKUP_BDEV)
	struct block_device *bdev = lookup_bdev(path, FMODE_READ);
	if (IS_ERR(bdev))
	return (PTR_ERR(bdev));

	*dev = bdev->bd_dev;
	bdput(bdev);

	return (0);
	#else
	#error "Unsupported kernel"
	#endif
	}

	/*
	* Kernels without bio_set_op_attrs use bi_rw for the bio flags.
	*/
	#if !defined(HAVE_BIO_SET_OP_ATTRS)
	static inline void
	bio_set_op_attrs(struct bio *bio, unsigned rw, unsigned flags)
	{
	bio->bi_rw \|= rw \| flags;
	}
	#endif

	/*
	* bio_set_flush - Set the appropriate flags in a bio to guarantee
	* data are on non-volatile media on completion.
	*
	* 2.6.37 - 4.8 API,
	* Introduce WRITE_FLUSH, WRITE_FUA, and WRITE_FLUSH_FUA flags as a
	* replacement for WRITE_BARRIER to allow expressing richer semantics
	* to the block layer. It's up to the block layer to implement the
	* semantics correctly. Use the WRITE_FLUSH_FUA flag combination.
	*
	* 4.8 - 4.9 API,
	* REQ_FLUSH was renamed to REQ_PREFLUSH. For consistency with previous
	- * ZoL releases, prefer the WRITE_FLUSH_FUA flag set if it's available.
	+ * OpenZFS releases, prefer the WRITE_FLUSH_FUA flag set if it's available.
	*
	* 4.10 API,
	* The read/write flags and their modifiers, including WRITE_FLUSH,
	* WRITE_FUA and WRITE_FLUSH_FUA were removed from fs.h in
	* torvalds/linux@70fd7614 and replaced by direct flag modification
	* of the REQ_ flags in bio->bi_opf. Use REQ_PREFLUSH.
	*/
	static inline void
	bio_set_flush(struct bio *bio)
	{
	#if defined(HAVE_REQ_PREFLUSH) /* >= 4.10 */
	bio_set_op_attrs(bio, 0, REQ_PREFLUSH);
	#elif defined(WRITE_FLUSH_FUA) /* >= 2.6.37 and <= 4.9 */
	bio_set_op_attrs(bio, 0, WRITE_FLUSH_FUA);
	#else
	#error "Allowing the build will cause bio_set_flush requests to be ignored."
	#endif
	}

	/*
	- * 4.8 - 4.x API,
	+ * 4.8 API,
	* REQ_OP_FLUSH
	*
	* 4.8-rc0 - 4.8-rc1,
	* REQ_PREFLUSH
	*
	* 2.6.36 - 4.7 API,
	* REQ_FLUSH
	*
	* in all cases but may have a performance impact for some kernels. It
	* has the advantage of minimizing kernel specific changes in the zvol code.
	*
	*/
	static inline boolean_t
	bio_is_flush(struct bio *bio)
	{
	#if defined(HAVE_REQ_OP_FLUSH) && defined(HAVE_BIO_BI_OPF)
	return ((bio_op(bio) == REQ_OP_FLUSH) \|\| (bio->bi_opf & REQ_PREFLUSH));
	#elif defined(HAVE_REQ_PREFLUSH) && defined(HAVE_BIO_BI_OPF)
	return (bio->bi_opf & REQ_PREFLUSH);
	#elif defined(HAVE_REQ_PREFLUSH) && !defined(HAVE_BIO_BI_OPF)
	return (bio->bi_rw & REQ_PREFLUSH);
	#elif defined(HAVE_REQ_FLUSH)
	return (bio->bi_rw & REQ_FLUSH);
	#else
	#error "Unsupported kernel"
	#endif
	}

	/*
	- * 4.8 - 4.x API,
	+ * 4.8 API,
	* REQ_FUA flag moved to bio->bi_opf
	*
	* 2.6.x - 4.7 API,
	* REQ_FUA
	*/
	static inline boolean_t
	bio_is_fua(struct bio *bio)
	{
	#if defined(HAVE_BIO_BI_OPF)
	return (bio->bi_opf & REQ_FUA);
	#elif defined(REQ_FUA)
	return (bio->bi_rw & REQ_FUA);
	#else
	#error "Allowing the build will cause fua requests to be ignored."
	#endif
	}

	/*
	- * 4.8 - 4.x API,
	+ * 4.8 API,
	* REQ_OP_DISCARD
	*
	* 2.6.36 - 4.7 API,
	* REQ_DISCARD
	*
	* In all cases the normal I/O path is used for discards. The only
	* difference is how the kernel tags individual I/Os as discards.
	*/
	static inline boolean_t
	bio_is_discard(struct bio *bio)
	{
	#if defined(HAVE_REQ_OP_DISCARD)
	return (bio_op(bio) == REQ_OP_DISCARD);
	#elif defined(HAVE_REQ_DISCARD)
	return (bio->bi_rw & REQ_DISCARD);
	#else
	#error "Unsupported kernel"
	#endif
	}

	/*
	- * 4.8 - 4.x API,
	+ * 4.8 API,
	* REQ_OP_SECURE_ERASE
	*
	* 2.6.36 - 4.7 API,
	* REQ_SECURE
	*/
	static inline boolean_t
	bio_is_secure_erase(struct bio *bio)
	{
	#if defined(HAVE_REQ_OP_SECURE_ERASE)
	return (bio_op(bio) == REQ_OP_SECURE_ERASE);
	#elif defined(REQ_SECURE)
	return (bio->bi_rw & REQ_SECURE);
	#else
	return (0);
	#endif
	}

	/*
	* 2.6.33 API change
	* Discard granularity and alignment restrictions may now be set. For
	* older kernels which do not support this it is safe to skip it.
	*/
	static inline void
	blk_queue_discard_granularity(struct request_queue *q, unsigned int dg)
	{
	q->limits.discard_granularity = dg;
	}

	/*
	- * 4.8 - 4.x API,
	+ * 4.8 API,
	* blk_queue_secure_erase()
	*
	* 2.6.36 - 4.7 API,
	* blk_queue_secdiscard()
	*/
	static inline int
	blk_queue_discard_secure(struct request_queue *q)
	{
	#if defined(HAVE_BLK_QUEUE_SECURE_ERASE)
	return (blk_queue_secure_erase(q));
	#elif defined(HAVE_BLK_QUEUE_SECDISCARD)
	return (blk_queue_secdiscard(q));
	#else
	return (0);
	#endif
	}

	/*
	* A common holder for vdev_bdev_open() is used to relax the exclusive open
	* semantics slightly. Internal vdev disk callers may pass VDEV_HOLDER to
	* allow them to open the device multiple times. Other kernel callers and
	* user space processes which don't pass this value will get EBUSY. This is
	* currently required for the correct operation of hot spares.
	*/
	#define VDEV_HOLDER ((void *)0x2401de7)

	static inline unsigned long
	blk_generic_start_io_acct(struct request_queue *q __attribute__((unused)),
	struct gendisk *disk __attribute__((unused)),
	int rw __attribute__((unused)), struct bio *bio)
	{
	#if defined(HAVE_DISK_IO_ACCT)
	return (disk_start_io_acct(disk, bio_sectors(bio), bio_op(bio)));
	#elif defined(HAVE_BIO_IO_ACCT)
	return (bio_start_io_acct(bio));
	#elif defined(HAVE_GENERIC_IO_ACCT_3ARG)
	unsigned long start_time = jiffies;
	generic_start_io_acct(rw, bio_sectors(bio), &disk->part0);
	return (start_time);
	#elif defined(HAVE_GENERIC_IO_ACCT_4ARG)
	unsigned long start_time = jiffies;
	generic_start_io_acct(q, rw, bio_sectors(bio), &disk->part0);
	return (start_time);
	#else
	/* Unsupported */
	return (0);
	#endif
	}

	static inline void
	blk_generic_end_io_acct(struct request_queue *q __attribute__((unused)),
	struct gendisk *disk __attribute__((unused)),
	int rw __attribute__((unused)), struct bio *bio, unsigned long start_time)
	{
	#if defined(HAVE_DISK_IO_ACCT)
	disk_end_io_acct(disk, bio_op(bio), start_time);
	#elif defined(HAVE_BIO_IO_ACCT)
	bio_end_io_acct(bio, start_time);
	#elif defined(HAVE_GENERIC_IO_ACCT_3ARG)
	generic_end_io_acct(rw, &disk->part0, start_time);
	#elif defined(HAVE_GENERIC_IO_ACCT_4ARG)
	generic_end_io_acct(q, rw, &disk->part0, start_time);
	#endif
	}

	#ifndef HAVE_SUBMIT_BIO_IN_BLOCK_DEVICE_OPERATIONS
	static inline struct request_queue *
	blk_generic_alloc_queue(make_request_fn make_request, int node_id)
	{
	#if defined(HAVE_BLK_ALLOC_QUEUE_REQUEST_FN)
	return (blk_alloc_queue(make_request, node_id));
	#elif defined(HAVE_BLK_ALLOC_QUEUE_REQUEST_FN_RH)
	return (blk_alloc_queue_rh(make_request, node_id));
	#else
	struct request_queue *q = blk_alloc_queue(GFP_KERNEL);
	if (q != NULL)
	blk_queue_make_request(q, make_request);

	return (q);
	#endif
	}
	#endif /* !HAVE_SUBMIT_BIO_IN_BLOCK_DEVICE_OPERATIONS */

	#endif /* _ZFS_BLKDEV_H */
	diff --git a/sys/contrib/openzfs/include/os/linux/kernel/linux/mod_compat.h b/sys/contrib/openzfs/include/os/linux/kernel/linux/mod_compat.h
	index e96e95313009..cc42c3f7c743 100644
	--- a/sys/contrib/openzfs/include/os/linux/kernel/linux/mod_compat.h
	+++ b/sys/contrib/openzfs/include/os/linux/kernel/linux/mod_compat.h
	@@ -1,167 +1,167 @@
	/*
	* 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) 2016 Gvozden Neskovic <neskovic@gmail.com>.
	* Copyright (c) 2020 by Delphix. All rights reserved.
	*/

	#ifndef _MOD_COMPAT_H
	#define _MOD_COMPAT_H

	#include <linux/module.h>
	#include <linux/moduleparam.h>

	/* Grsecurity kernel API change */
	#ifdef MODULE_PARAM_CALL_CONST
	typedef const struct kernel_param zfs_kernel_param_t;
	#else
	typedef struct kernel_param zfs_kernel_param_t;
	#endif

	#define ZMOD_RW 0644
	#define ZMOD_RD 0444

	/* BEGIN CSTYLED */
	#define INT int
	#define UINT uint
	#define ULONG ulong
	#define LONG long
	#define STRING charp
	/* END CSTYLED */

	enum scope_prefix_types {
	zfs,
	zfs_arc,
	zfs_condense,
	zfs_dbuf,
	zfs_dbuf_cache,
	zfs_deadman,
	zfs_dedup,
	zfs_l2arc,
	zfs_livelist,
	zfs_livelist_condense,
	zfs_lua,
	zfs_metaslab,
	zfs_mg,
	zfs_multihost,
	zfs_prefetch,
	zfs_reconstruct,
	zfs_recv,
	zfs_send,
	zfs_spa,
	zfs_trim,
	zfs_txg,
	zfs_vdev,
	zfs_vdev_cache,
	zfs_vdev_file,
	zfs_vdev_mirror,
	zfs_vnops,
	zfs_zevent,
	zfs_zio,
	zfs_zil
	};

	/*
	* Declare a module parameter / sysctl node
	*
	- * "scope_prefix" the part of the the sysctl / sysfs tree the node resides under
	+ * "scope_prefix" the part of the sysctl / sysfs tree the node resides under
	* (currently a no-op on Linux)
	* "name_prefix" the part of the variable name that will be excluded from the
	* exported names on platforms with a hierarchical namespace
	* "name" the part of the variable that will be exposed on platforms with a
	* hierarchical namespace, or as name_prefix ## name on Linux
	* "type" the variable type
	* "perm" the permissions (read/write or read only)
	* "desc" a brief description of the option
	*
	* Examples:
	* ZFS_MODULE_PARAM(zfs_vdev_mirror, zfs_vdev_mirror_, rotating_inc, UINT,
	* ZMOD_RW, "Rotating media load increment for non-seeking I/O's");
	* on FreeBSD:
	* vfs.zfs.vdev.mirror.rotating_inc
	* on Linux:
	* zfs_vdev_mirror_rotating_inc
	*
	* ZFS_MODULE_PARAM(zfs, , dmu_prefetch_max, UINT, ZMOD_RW,
	* "Limit one prefetch call to this size");
	* on FreeBSD:
	* vfs.zfs.dmu_prefetch_max
	* on Linux:
	* dmu_prefetch_max
	*/
	/* BEGIN CSTYLED */
	#define ZFS_MODULE_PARAM(scope_prefix, name_prefix, name, type, perm, desc) \
	CTASSERT_GLOBAL((sizeof (scope_prefix) == sizeof (enum scope_prefix_types))); \
	module_param(name_prefix ## name, type, perm); \
	MODULE_PARM_DESC(name_prefix ## name, desc)
	/* END CSTYLED */

	/*
	* Declare a module parameter / sysctl node
	*
	* "scope_prefix" the part of the the sysctl / sysfs tree the node resides under
	* (currently a no-op on Linux)
	* "name_prefix" the part of the variable name that will be excluded from the
	* exported names on platforms with a hierarchical namespace
	* "name" the part of the variable that will be exposed on platforms with a
	* hierarchical namespace, or as name_prefix ## name on Linux
	* "setfunc" setter function
	* "getfunc" getter function
	* "perm" the permissions (read/write or read only)
	* "desc" a brief description of the option
	*
	* Examples:
	* ZFS_MODULE_PARAM_CALL(zfs_spa, spa_, slop_shift, param_set_slop_shift,
	* param_get_int, ZMOD_RW, "Reserved free space in pool");
	* on FreeBSD:
	* vfs.zfs.spa_slop_shift
	* on Linux:
	* spa_slop_shift
	*/
	/* BEGIN CSTYLED */
	#define ZFS_MODULE_PARAM_CALL(scope_prefix, name_prefix, name, setfunc, getfunc, perm, desc) \
	CTASSERT_GLOBAL((sizeof (scope_prefix) == sizeof (enum scope_prefix_types))); \
	module_param_call(name_prefix ## name, setfunc, getfunc, &name_prefix ## name, perm); \
	MODULE_PARM_DESC(name_prefix ## name, desc)
	/* END CSTYLED */

	/*
	* As above, but there is no variable with the name name_prefix ## name,
	* so NULL is passed to module_param_call instead.
	*/
	/* BEGIN CSTYLED */
	#define ZFS_MODULE_VIRTUAL_PARAM_CALL(scope_prefix, name_prefix, name, setfunc, getfunc, perm, desc) \
	CTASSERT_GLOBAL((sizeof (scope_prefix) == sizeof (enum scope_prefix_types))); \
	module_param_call(name_prefix ## name, setfunc, getfunc, NULL, perm); \
	MODULE_PARM_DESC(name_prefix ## name, desc)
	/* END CSTYLED */

	#define ZFS_MODULE_PARAM_ARGS const char buf, zfs_kernel_param_t kp

	#define ZFS_MODULE_DESCRIPTION(s) MODULE_DESCRIPTION(s)
	#define ZFS_MODULE_AUTHOR(s) MODULE_AUTHOR(s)
	#define ZFS_MODULE_LICENSE(s) MODULE_LICENSE(s)
	#define ZFS_MODULE_VERSION(s) MODULE_VERSION(s)

	#define module_init_early(fn) module_init(fn)

	#endif /* _MOD_COMPAT_H */
	diff --git a/sys/contrib/openzfs/include/os/linux/spl/sys/Makefile.am b/sys/contrib/openzfs/include/os/linux/spl/sys/Makefile.am
	index 0fd4cd37a7ec..a5b0d78e8bd7 100644
	--- a/sys/contrib/openzfs/include/os/linux/spl/sys/Makefile.am
	+++ b/sys/contrib/openzfs/include/os/linux/spl/sys/Makefile.am
	@@ -1,64 +1,63 @@
	KERNEL_H = \
	acl.h \
	atomic.h \
	byteorder.h \
	callb.h \
	callo.h \
	cmn_err.h \
	condvar.h \
	- console.h \
	cred.h \
	ctype.h \
	debug.h \
	disp.h \
	dkio.h \
	errno.h \
	fcntl.h \
	file.h \
	inttypes.h \
	isa_defs.h \
	kmem_cache.h \
	kmem.h \
	kstat.h \
	list.h \
	mod_os.h \
	mutex.h \
	param.h \
	processor.h \
	proc.h \
	procfs_list.h \
	random.h \
	rwlock.h \
	shrinker.h \
	sid.h \
	signal.h \
	simd.h \
	stat.h \
	strings.h \
	sunddi.h \
	sysmacros.h \
	systeminfo.h \
	taskq.h \
	thread.h \
	time.h \
	timer.h \
	trace.h \
	trace_spl.h \
	trace_taskq.h \
	tsd.h \
	types32.h \
	types.h \
	uio.h \
	user.h \
	vfs.h \
	vmem.h \
	vmsystm.h \
	vnode.h \
	wait.h \
	zmod.h \
	zone.h

	if CONFIG_KERNEL
	kerneldir = @prefix@/src/zfs-$(VERSION)/include/spl/sys
	kernel_HEADERS = $(KERNEL_H)
	endif
	diff --git a/sys/contrib/openzfs/include/os/linux/spl/sys/console.h b/sys/contrib/openzfs/include/os/linux/spl/sys/console.h
	deleted file mode 100644
	index 6af395cc2d78..000000000000
	--- a/sys/contrib/openzfs/include/os/linux/spl/sys/console.h
	+++ /dev/null
	@@ -1,30 +0,0 @@
	-/*
	- * Copyright (C) 2007-2010 Lawrence Livermore National Security, LLC.
	- * Copyright (C) 2007 The Regents of the University of California.
	- * Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
	- * Written by Brian Behlendorf <behlendorf1@llnl.gov>.
	- * UCRL-CODE-235197
	- *
	- * This file is part of the SPL, Solaris Porting Layer.
	- *
	- * The SPL is free software; you can redistribute it and/or modify it
	- * under the terms of the GNU General Public License as published by the
	- * Free Software Foundation; either version 2 of the License, or (at your
	- * option) any later version.
	- *
	- * The SPL is distributed in the hope that it will be useful, but WITHOUT
	- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	- * for more details.
	- *
	- * You should have received a copy of the GNU General Public License along
	- * with the SPL. If not, see <http://www.gnu.org/licenses/>.
	- */
	-
	-#ifndef _SPL_CONSOLE_H
	-#define _SPL_CONSOLE_H
	-
	-#define console_vprintf vprintk
	-#define console_printf printk
	-
	-#endif /* _SPL_CONSOLE_H */
	diff --git a/sys/contrib/openzfs/include/os/linux/spl/sys/signal.h b/sys/contrib/openzfs/include/os/linux/spl/sys/signal.h
	index fd32f08b3489..6b538c8966f2 100644
	--- a/sys/contrib/openzfs/include/os/linux/spl/sys/signal.h
	+++ b/sys/contrib/openzfs/include/os/linux/spl/sys/signal.h
	@@ -1,54 +1,38 @@
	/*
	* Copyright (C) 2007-2010 Lawrence Livermore National Security, LLC.
	* Copyright (C) 2007 The Regents of the University of California.
	* Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
	* Written by Brian Behlendorf <behlendorf1@llnl.gov>.
	* UCRL-CODE-235197
	*
	* This file is part of the SPL, Solaris Porting Layer.
	*
	* The SPL is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License as published by the
	* Free Software Foundation; either version 2 of the License, or (at your
	* option) any later version.
	*
	* The SPL is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* for more details.
	*
	* You should have received a copy of the GNU General Public License along
	* with the SPL. If not, see <http://www.gnu.org/licenses/>.
	*/

	#ifndef _SPL_SIGNAL_H
	#define _SPL_SIGNAL_H

	#include <linux/sched.h>

	#ifdef HAVE_SCHED_SIGNAL_HEADER
	#include <linux/sched/signal.h>
	#endif

	#define FORREAL 0 /* Usual side-effects */
	#define JUSTLOOKING 1 /* Don't stop the process */

	-/*
	- * The "why" argument indicates the allowable side-effects of the call:
	- *
	- * FORREAL: Extract the next pending signal from p_sig into p_cursig;
	- * stop the process if a stop has been requested or if a traced signal
	- * is pending.
	- *
	- * JUSTLOOKING: Don't stop the process, just indicate whether or not
	- * a signal might be pending (FORREAL is needed to tell for sure).
	- */
	-static __inline__ int
	-issig(int why)
	-{
	- ASSERT(why == FORREAL \|\| why == JUSTLOOKING);
	-
	- return (signal_pending(current));
	-}
	+extern int issig(int why);

	#endif /* SPL_SIGNAL_H */
	diff --git a/sys/contrib/openzfs/include/os/linux/spl/sys/thread.h b/sys/contrib/openzfs/include/os/linux/spl/sys/thread.h
	index 99d9c9bf3821..220742387b62 100644
	--- a/sys/contrib/openzfs/include/os/linux/spl/sys/thread.h
	+++ b/sys/contrib/openzfs/include/os/linux/spl/sys/thread.h
	@@ -1,73 +1,86 @@
	/*
	* Copyright (C) 2007-2010 Lawrence Livermore National Security, LLC.
	* Copyright (C) 2007 The Regents of the University of California.
	* Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
	* Written by Brian Behlendorf <behlendorf1@llnl.gov>.
	* UCRL-CODE-235197
	*
	* This file is part of the SPL, Solaris Porting Layer.
	*
	* The SPL is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License as published by the
	* Free Software Foundation; either version 2 of the License, or (at your
	* option) any later version.
	*
	* The SPL is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* for more details.
	*
	* You should have received a copy of the GNU General Public License along
	* with the SPL. If not, see <http://www.gnu.org/licenses/>.
	*/

	#ifndef _SPL_THREAD_H
	#define _SPL_THREAD_H

	#include <linux/module.h>
	#include <linux/mm.h>
	#include <linux/spinlock.h>
	#include <linux/kthread.h>
	#include <sys/types.h>
	#include <sys/sysmacros.h>
	#include <sys/tsd.h>

	/*
	* Thread interfaces
	*/
	#define TP_MAGIC 0x53535353

	#define TS_SLEEP TASK_INTERRUPTIBLE
	#define TS_RUN TASK_RUNNING
	#define TS_ZOMB EXIT_ZOMBIE
	#define TS_STOPPED TASK_STOPPED

	typedef void (thread_func_t)(void );

	#define thread_create_named(name, stk, stksize, func, arg, len, \
	pp, state, pri) \
	__thread_create(stk, stksize, (thread_func_t)func, \
	name, arg, len, pp, state, pri)

	/* BEGIN CSTYLED */
	#define thread_create(stk, stksize, func, arg, len, pp, state, pri) \
	__thread_create(stk, stksize, (thread_func_t)func, \
	#func, arg, len, pp, state, pri)
	/* END CSTYLED */

	#define thread_exit() __thread_exit()
	#define thread_join(t) VERIFY(0)
	#define curthread current
	#define getcomm() current->comm
	#define getpid() current->pid

	extern kthread_t *__thread_create(caddr_t stk, size_t stksize,
	thread_func_t func, const char name, void args, size_t len, proc_t *pp,
	int state, pri_t pri);
	extern void __thread_exit(void);
	extern struct task_struct spl_kthread_create(int (func)(void *),
	void *data, const char namefmt[], ...);

	extern proc_t p0;

	+#ifdef HAVE_SIGINFO
	+typedef kernel_siginfo_t spl_kernel_siginfo_t;
	+#else
	+typedef siginfo_t spl_kernel_siginfo_t;
	+#endif
	+
	+#ifdef HAVE_SET_SPECIAL_STATE
	+#define spl_set_special_state(x) set_special_state((x))
	+#else
	+#define spl_set_special_state(x) __set_current_state((x))
	+#endif
	+
	+
	#endif /* _SPL_THREAD_H */
	diff --git a/sys/contrib/openzfs/include/os/linux/zfs/sys/zpl.h b/sys/contrib/openzfs/include/os/linux/zfs/sys/zpl.h
	index 21825d1f378e..54f3fa0fdb0f 100644
	--- a/sys/contrib/openzfs/include/os/linux/zfs/sys/zpl.h
	+++ b/sys/contrib/openzfs/include/os/linux/zfs/sys/zpl.h
	@@ -1,192 +1,197 @@
	/*
	* 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) 2011, Lawrence Livermore National Security, LLC.
	*/

	#ifndef _SYS_ZPL_H
	#define _SYS_ZPL_H

	#include <sys/mntent.h>
	#include <sys/vfs.h>
	#include <linux/aio.h>
	#include <linux/dcache_compat.h>
	#include <linux/exportfs.h>
	#include <linux/falloc.h>
	#include <linux/parser.h>
	#include <linux/task_io_accounting_ops.h>
	#include <linux/vfs_compat.h>
	#include <linux/writeback.h>
	#include <linux/xattr_compat.h>

	/* zpl_inode.c */
	extern void zpl_vap_init(vattr_t vap, struct inode dir,
	umode_t mode, cred_t *cr);

	extern const struct inode_operations zpl_inode_operations;
	extern const struct inode_operations zpl_dir_inode_operations;
	extern const struct inode_operations zpl_symlink_inode_operations;
	extern const struct inode_operations zpl_special_inode_operations;
	extern dentry_operations_t zpl_dentry_operations;
	extern const struct address_space_operations zpl_address_space_operations;
	extern const struct file_operations zpl_file_operations;
	extern const struct file_operations zpl_dir_file_operations;

	/* zpl_super.c */
	extern void zpl_prune_sb(int64_t nr_to_scan, void *arg);

	extern const struct super_operations zpl_super_operations;
	extern const struct export_operations zpl_export_operations;
	extern struct file_system_type zpl_fs_type;

	/* zpl_xattr.c */
	extern ssize_t zpl_xattr_list(struct dentry dentry, char buf, size_t size);
	extern int zpl_xattr_security_init(struct inode ip, struct inode dip,
	const struct qstr *qstr);
	#if defined(CONFIG_FS_POSIX_ACL)
	#if defined(HAVE_SET_ACL)
	+#if defined(HAVE_SET_ACL_USERNS)
	+extern int zpl_set_acl(struct user_namespace userns, struct inode ip,
	+ struct posix_acl *acl, int type);
	+#else
	extern int zpl_set_acl(struct inode ip, struct posix_acl acl, int type);
	+#endif /* HAVE_SET_ACL_USERNS */
	#endif /* HAVE_SET_ACL */
	extern struct posix_acl zpl_get_acl(struct inode ip, int type);
	extern int zpl_init_acl(struct inode ip, struct inode dir);
	extern int zpl_chmod_acl(struct inode *ip);
	#else
	static inline int
	zpl_init_acl(struct inode ip, struct inode dir)
	{
	return (0);
	}

	static inline int
	zpl_chmod_acl(struct inode *ip)
	{
	return (0);
	}
	#endif /* CONFIG_FS_POSIX_ACL */

	extern xattr_handler_t *zpl_xattr_handlers[];

	/* zpl_ctldir.c */
	extern const struct file_operations zpl_fops_root;
	extern const struct inode_operations zpl_ops_root;

	extern const struct file_operations zpl_fops_snapdir;
	extern const struct inode_operations zpl_ops_snapdir;
	extern const struct dentry_operations zpl_dops_snapdirs;

	extern const struct file_operations zpl_fops_shares;
	extern const struct inode_operations zpl_ops_shares;

	#if defined(HAVE_VFS_ITERATE) \|\| defined(HAVE_VFS_ITERATE_SHARED)

	#define ZPL_DIR_CONTEXT_INIT(_dirent, _actor, _pos) { \
	.actor = _actor, \
	.pos = _pos, \
	}

	typedef struct dir_context zpl_dir_context_t;

	#define zpl_dir_emit dir_emit
	#define zpl_dir_emit_dot dir_emit_dot
	#define zpl_dir_emit_dotdot dir_emit_dotdot
	#define zpl_dir_emit_dots dir_emit_dots

	#else

	typedef struct zpl_dir_context {
	void *dirent;
	const filldir_t actor;
	loff_t pos;
	} zpl_dir_context_t;

	#define ZPL_DIR_CONTEXT_INIT(_dirent, _actor, _pos) { \
	.dirent = _dirent, \
	.actor = _actor, \
	.pos = _pos, \
	}

	static inline bool
	zpl_dir_emit(zpl_dir_context_t ctx, const char name, int namelen,
	uint64_t ino, unsigned type)
	{
	return (!ctx->actor(ctx->dirent, name, namelen, ctx->pos, ino, type));
	}

	static inline bool
	zpl_dir_emit_dot(struct file file, zpl_dir_context_t ctx)
	{
	return (ctx->actor(ctx->dirent, ".", 1, ctx->pos,
	file_inode(file)->i_ino, DT_DIR) == 0);
	}

	static inline bool
	zpl_dir_emit_dotdot(struct file file, zpl_dir_context_t ctx)
	{
	return (ctx->actor(ctx->dirent, "..", 2, ctx->pos,
	parent_ino(file_dentry(file)), DT_DIR) == 0);
	}

	static inline bool
	zpl_dir_emit_dots(struct file file, zpl_dir_context_t ctx)
	{
	if (ctx->pos == 0) {
	if (!zpl_dir_emit_dot(file, ctx))
	return (false);
	ctx->pos = 1;
	}
	if (ctx->pos == 1) {
	if (!zpl_dir_emit_dotdot(file, ctx))
	return (false);
	ctx->pos = 2;
	}
	return (true);
	}
	#endif /* HAVE_VFS_ITERATE */

	#if defined(HAVE_INODE_TIMESTAMP_TRUNCATE)
	#define zpl_inode_timestamp_truncate(ts, ip) timestamp_truncate(ts, ip)
	#elif defined(HAVE_INODE_TIMESPEC64_TIMES)
	#define zpl_inode_timestamp_truncate(ts, ip) \
	timespec64_trunc(ts, (ip)->i_sb->s_time_gran)
	#else
	#define zpl_inode_timestamp_truncate(ts, ip) \
	timespec_trunc(ts, (ip)->i_sb->s_time_gran)
	#endif

	#if defined(HAVE_INODE_OWNER_OR_CAPABLE)
	#define zpl_inode_owner_or_capable(ns, ip) inode_owner_or_capable(ip)
	#elif defined(HAVE_INODE_OWNER_OR_CAPABLE_IDMAPPED)
	#define zpl_inode_owner_or_capable(ns, ip) inode_owner_or_capable(ns, ip)
	#else
	#error "Unsupported kernel"
	#endif

	#ifdef HAVE_SETATTR_PREPARE_USERNS
	#define zpl_setattr_prepare(ns, dentry, ia) setattr_prepare(ns, dentry, ia)
	#else
	/*
	* Use kernel-provided version, or our own from
	* linux/vfs_compat.h
	*/
	#define zpl_setattr_prepare(ns, dentry, ia) setattr_prepare(dentry, ia)
	#endif

	#endif /* _SYS_ZPL_H */
	diff --git a/sys/contrib/openzfs/include/sys/dsl_scan.h b/sys/contrib/openzfs/include/sys/dsl_scan.h
	index 19c3dd599b10..fb1f1d65bad4 100644
	--- a/sys/contrib/openzfs/include/sys/dsl_scan.h
	+++ b/sys/contrib/openzfs/include/sys/dsl_scan.h
	@@ -1,194 +1,195 @@
	/*
	* 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) 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2012, 2017 by Delphix. All rights reserved.
	* Copyright (c) 2017, 2019, Datto Inc. All rights reserved.
	*/

	#ifndef _SYS_DSL_SCAN_H
	#define _SYS_DSL_SCAN_H

	#include <sys/zfs_context.h>
	#include <sys/zio.h>
	#include <sys/ddt.h>
	#include <sys/bplist.h>

	#ifdef __cplusplus
	extern "C" {
	#endif

	struct objset;
	struct dsl_dir;
	struct dsl_dataset;
	struct dsl_pool;
	struct dmu_tx;

	extern int zfs_scan_suspend_progress;

	/*
	* All members of this structure must be uint64_t, for byteswap
	* purposes.
	*/
	typedef struct dsl_scan_phys {
	uint64_t scn_func; /* pool_scan_func_t */
	uint64_t scn_state; /* dsl_scan_state_t */
	uint64_t scn_queue_obj;
	uint64_t scn_min_txg;
	uint64_t scn_max_txg;
	uint64_t scn_cur_min_txg;
	uint64_t scn_cur_max_txg;
	uint64_t scn_start_time;
	uint64_t scn_end_time;
	uint64_t scn_to_examine; /* total bytes to be scanned */
	uint64_t scn_examined; /* bytes scanned so far */
	uint64_t scn_to_process;
	uint64_t scn_processed;
	uint64_t scn_errors; /* scan I/O error count */
	uint64_t scn_ddt_class_max;
	ddt_bookmark_t scn_ddt_bookmark;
	zbookmark_phys_t scn_bookmark;
	uint64_t scn_flags; /* dsl_scan_flags_t */
	} dsl_scan_phys_t;

	#define SCAN_PHYS_NUMINTS (sizeof (dsl_scan_phys_t) / sizeof (uint64_t))

	typedef enum dsl_scan_flags {
	DSF_VISIT_DS_AGAIN = 1<<0,
	DSF_SCRUB_PAUSED = 1<<1,
	} dsl_scan_flags_t;

	#define DSL_SCAN_FLAGS_MASK (DSF_VISIT_DS_AGAIN)

	/*
	* Every pool will have one dsl_scan_t and this structure will contain
	* in-memory information about the scan and a pointer to the on-disk
	* representation (i.e. dsl_scan_phys_t). Most of the state of the scan
	* is contained on-disk to allow the scan to resume in the event of a reboot
	* or panic. This structure maintains information about the behavior of a
	* running scan, some caching information, and how it should traverse the pool.
	*
	* The following members of this structure direct the behavior of the scan:
	*
	* scn_suspending - a scan that cannot be completed in a single txg or
	* has exceeded its allotted time will need to suspend.
	* When this flag is set the scanner will stop traversing
	* the pool and write out the current state to disk.
	*
	* scn_restart_txg - directs the scanner to either restart or start a
	* a scan at the specified txg value.
	*
	* scn_done_txg - when a scan completes its traversal it will set
	* the completion txg to the next txg. This is necessary
	* to ensure that any blocks that were freed during
	* the scan but have not yet been processed (i.e deferred
	* frees) are accounted for.
	*
	* This structure also maintains information about deferred frees which are
	* a special kind of traversal. Deferred free can exist in either a bptree or
	* a bpobj structure. The scn_is_bptree flag will indicate the type of
	* deferred free that is in progress. If the deferred free is part of an
	* asynchronous destroy then the scn_async_destroying flag will be set.
	*/
	typedef struct dsl_scan {
	struct dsl_pool *scn_dp;
	uint64_t scn_restart_txg;
	uint64_t scn_done_txg;
	uint64_t scn_sync_start_time;
	uint64_t scn_issued_before_pass;

	/* for freeing blocks */
	boolean_t scn_is_bptree;
	boolean_t scn_async_destroying;
	boolean_t scn_async_stalled;
	uint64_t scn_async_block_min_time_ms;

	/* flags and stats for controlling scan state */
	boolean_t scn_is_sorted; /* doing sequential scan */
	boolean_t scn_clearing; /* scan is issuing sequential extents */
	boolean_t scn_checkpointing; /* scan is issuing all queued extents */
	boolean_t scn_suspending; /* scan is suspending until next txg */
	uint64_t scn_last_checkpoint; /* time of last checkpoint */

	/* members for thread synchronization */
	zio_t scn_zio_root; / root zio for waiting on IO */
	taskq_t scn_taskq; / task queue for issuing extents */

	/* for controlling scan prefetch, protected by spa_scrub_lock */
	boolean_t scn_prefetch_stop; /* prefetch should stop */
	zbookmark_phys_t scn_prefetch_bookmark; /* prefetch start bookmark */
	avl_tree_t scn_prefetch_queue; /* priority queue of prefetch IOs */
	uint64_t scn_maxinflight_bytes; /* max bytes in flight for pool */

	/* per txg statistics */
	uint64_t scn_visited_this_txg; /* total bps visited this txg */
	uint64_t scn_dedup_frees_this_txg; /* dedup bps freed this txg */
	uint64_t scn_holes_this_txg;
	uint64_t scn_lt_min_this_txg;
	uint64_t scn_gt_max_this_txg;
	uint64_t scn_ddt_contained_this_txg;
	uint64_t scn_objsets_visited_this_txg;
	uint64_t scn_avg_seg_size_this_txg;
	uint64_t scn_segs_this_txg;
	uint64_t scn_avg_zio_size_this_txg;
	uint64_t scn_zios_this_txg;

	/* members needed for syncing scan status to disk */
	dsl_scan_phys_t scn_phys; /* on disk representation of scan */
	dsl_scan_phys_t scn_phys_cached;
	avl_tree_t scn_queue; /* queue of datasets to scan */
	uint64_t scn_bytes_pending; /* outstanding data to issue */
	} dsl_scan_t;

	typedef struct dsl_scan_io_queue dsl_scan_io_queue_t;

	void scan_init(void);
	void scan_fini(void);
	int dsl_scan_init(struct dsl_pool *dp, uint64_t txg);
	+int dsl_scan_setup_check(void , dmu_tx_t );
	void dsl_scan_setup_sync(void , dmu_tx_t );
	void dsl_scan_fini(struct dsl_pool *dp);
	void dsl_scan_sync(struct dsl_pool , dmu_tx_t );
	int dsl_scan_cancel(struct dsl_pool *);
	int dsl_scan(struct dsl_pool *, pool_scan_func_t);
	void dsl_scan_assess_vdev(struct dsl_pool dp, vdev_t vd);
	boolean_t dsl_scan_scrubbing(const struct dsl_pool *dp);
	int dsl_scrub_set_pause_resume(const struct dsl_pool *dp, pool_scrub_cmd_t cmd);
	void dsl_scan_restart_resilver(struct dsl_pool *, uint64_t txg);
	boolean_t dsl_scan_resilvering(struct dsl_pool *dp);
	boolean_t dsl_scan_resilver_scheduled(struct dsl_pool *dp);
	boolean_t dsl_dataset_unstable(struct dsl_dataset *ds);
	void dsl_scan_ddt_entry(dsl_scan_t *scn, enum zio_checksum checksum,
	ddt_entry_t dde, dmu_tx_t tx);
	void dsl_scan_ds_destroyed(struct dsl_dataset ds, struct dmu_tx tx);
	void dsl_scan_ds_snapshotted(struct dsl_dataset ds, struct dmu_tx tx);
	void dsl_scan_ds_clone_swapped(struct dsl_dataset ds1, struct dsl_dataset ds2,
	struct dmu_tx *tx);
	boolean_t dsl_scan_active(dsl_scan_t *scn);
	boolean_t dsl_scan_is_paused_scrub(const dsl_scan_t *scn);
	void dsl_scan_freed(spa_t spa, const blkptr_t bp);
	void dsl_scan_io_queue_destroy(dsl_scan_io_queue_t *queue);
	void dsl_scan_io_queue_vdev_xfer(vdev_t svd, vdev_t tvd);

	#ifdef __cplusplus
	}
	#endif

	#endif /* _SYS_DSL_SCAN_H */
	diff --git a/sys/contrib/openzfs/include/sys/fm/util.h b/sys/contrib/openzfs/include/sys/fm/util.h
	index ea8c61a8b9bd..56ba8798beb0 100644
	--- a/sys/contrib/openzfs/include/sys/fm/util.h
	+++ b/sys/contrib/openzfs/include/sys/fm/util.h
	@@ -1,121 +1,120 @@
	/*
	* 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) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
	*/

	#ifndef _SYS_FM_UTIL_H
	#define _SYS_FM_UTIL_H

	#ifdef __cplusplus
	extern "C" {
	#endif

	#include <sys/nvpair.h>

	/*
	* Shared user/kernel definitions for class length, error channel name,
	* and kernel event publisher string.
	*/
	#define FM_MAX_CLASS 100
	#define FM_ERROR_CHAN "com.sun:fm:error"
	#define FM_PUB "fm"

	/*
	* ereport dump device transport support
	*
	* Ereports are written out to the dump device at a proscribed offset from the
	* end, similar to in-transit log messages. The ereports are represented as a
	* erpt_dump_t header followed by ed_size bytes of packed native nvlist data.
	*
	* NOTE: All of these constants and the header must be defined so they have the
	* same representation for both 32-bit and 64-bit producers and consumers.
	*/
	#define ERPT_MAGIC 0xf00d4eddU
	#define ERPT_MAX_ERRS 16
	#define ERPT_DATA_SZ (6 * 1024)
	#define ERPT_EVCH_MAX 256
	#define ERPT_HIWAT 64

	typedef struct erpt_dump {
	uint32_t ed_magic; /* ERPT_MAGIC or zero to indicate end */
	uint32_t ed_chksum; /* checksum32() of packed nvlist data */
	uint32_t ed_size; /* ereport (nvl) fixed buf size */
	uint32_t ed_pad; /* reserved for future use */
	hrtime_t ed_hrt_nsec; /* hrtime of this ereport */
	hrtime_t ed_hrt_base; /* hrtime sample corresponding to ed_tod_base */
	struct {
	uint64_t sec; /* seconds since gettimeofday() Epoch */
	uint64_t nsec; /* nanoseconds past ed_tod_base.sec */
	} ed_tod_base;
	} erpt_dump_t;

	#ifdef _KERNEL

	#define ZEVENT_SHUTDOWN 0x1

	typedef void zevent_cb_t(nvlist_t , nvlist_t );

	typedef struct zevent_s {
	nvlist_t ev_nvl; / protected by the zevent_lock */
	nvlist_t ev_detector; / " */
	list_t ev_ze_list; /* " */
	list_node_t ev_node; /* " */
	zevent_cb_t ev_cb; / " */
	uint64_t ev_eid;
	} zevent_t;

	typedef struct zfs_zevent {
	zevent_t ze_zevent; / protected by the zevent_lock */
	list_node_t ze_node; /* " */
	uint64_t ze_dropped; /* " */
	} zfs_zevent_t;

	extern void fm_init(void);
	extern void fm_fini(void);
	-extern void fm_nvprint(nvlist_t *);
	extern void zfs_zevent_post_cb(nvlist_t nvl, nvlist_t detector);
	extern int zfs_zevent_post(nvlist_t , nvlist_t , zevent_cb_t *);
	extern void zfs_zevent_drain_all(int *);
	extern int zfs_zevent_fd_hold(int, minor_t , zfs_zevent_t *);
	extern void zfs_zevent_fd_rele(int);
	extern int zfs_zevent_next(zfs_zevent_t , nvlist_t , uint64_t , uint64_t *);
	extern int zfs_zevent_wait(zfs_zevent_t *);
	extern int zfs_zevent_seek(zfs_zevent_t *, uint64_t);
	extern void zfs_zevent_init(zfs_zevent_t **);
	extern void zfs_zevent_destroy(zfs_zevent_t *);

	extern void zfs_zevent_track_duplicate(void);
	extern void zfs_ereport_init(void);
	extern void zfs_ereport_fini(void);
	#else

	static inline void fm_init(void) { }
	static inline void fm_fini(void) { }

	#endif /* _KERNEL */

	#ifdef __cplusplus
	}
	#endif

	#endif /* _SYS_FM_UTIL_H */
	diff --git a/sys/contrib/openzfs/include/sys/vdev_draid.h b/sys/contrib/openzfs/include/sys/vdev_draid.h
	index 65417a93c4ed..52ce4ba16105 100644
	--- a/sys/contrib/openzfs/include/sys/vdev_draid.h
	+++ b/sys/contrib/openzfs/include/sys/vdev_draid.h
	@@ -1,110 +1,110 @@
	/*
	* 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) 2016, Intel Corporation.
	* Copyright (c) 2020 by Lawrence Livermore National Security, LLC.
	*/

	#ifndef _SYS_VDEV_DRAID_H
	#define _SYS_VDEV_DRAID_H

	#include <sys/types.h>
	#include <sys/abd.h>
	#include <sys/nvpair.h>
	#include <sys/zio.h>
	#include <sys/vdev_impl.h>
	#include <sys/vdev_raidz_impl.h>
	#include <sys/vdev.h>

	#ifdef __cplusplus
	extern "C" {
	#endif

	/*
	* Constants required to generate and use dRAID permutations.
	*/
	#define VDEV_DRAID_SEED 0xd7a1d5eed
	#define VDEV_DRAID_MAX_MAPS 254
	#define VDEV_DRAID_ROWSHIFT SPA_MAXBLOCKSHIFT
	#define VDEV_DRAID_ROWHEIGHT (1ULL << VDEV_DRAID_ROWSHIFT)
	#define VDEV_DRAID_REFLOW_RESERVE (2 * VDEV_DRAID_ROWHEIGHT)

	/*
	* dRAID permutation map.
	*/
	typedef struct draid_map {
	- uint64_t dm_children; /* # of permuation columns */
	+ uint64_t dm_children; /* # of permutation columns */
	uint64_t dm_nperms; /* # of permutation rows */
	uint64_t dm_seed; /* dRAID map seed */
	uint64_t dm_checksum; /* Checksum of generated map */
	uint8_t dm_perms; / base permutation array */
	} draid_map_t;

	/*
	* dRAID configuration.
	*/
	typedef struct vdev_draid_config {
	/*
	* Values read from the dRAID nvlist configuration.
	*/
	uint64_t vdc_ndata; /* # of data devices in group */
	uint64_t vdc_nparity; /* # of parity devices in group */
	uint64_t vdc_nspares; /* # of distributed spares */
	uint64_t vdc_children; /* # of children */
	uint64_t vdc_ngroups; /* # groups per slice */

	/*
	* Immutable derived constants.
	*/
	uint8_t vdc_perms; / permutation array */
	uint64_t vdc_nperms; /* # of permutations */
	uint64_t vdc_groupwidth; /* = data + parity */
	uint64_t vdc_ndisks; /* = children - spares */
	uint64_t vdc_groupsz; /* = groupwidth * DRAID_ROWSIZE */
	uint64_t vdc_devslicesz; /* = (groupsz * groups) / ndisks */
	} vdev_draid_config_t;

	/*
	* Functions for handling dRAID permutation maps.
	*/
	extern uint64_t vdev_draid_rand(uint64_t *);
	extern int vdev_draid_lookup_map(uint64_t, const draid_map_t **);
	extern int vdev_draid_generate_perms(const draid_map_t , uint8_t *);

	/*
	* General dRAID support functions.
	*/
	extern boolean_t vdev_draid_readable(vdev_t *, uint64_t);
	extern boolean_t vdev_draid_missing(vdev_t *, uint64_t, uint64_t, uint64_t);
	extern uint64_t vdev_draid_asize_to_psize(vdev_t *, uint64_t);
	extern void vdev_draid_map_alloc_empty(zio_t , struct raidz_row );
	extern nvlist_t vdev_draid_read_config_spare(vdev_t );

	/* Functions for dRAID distributed spares. */
	extern vdev_t vdev_draid_spare_get_child(vdev_t , uint64_t);
	extern vdev_t vdev_draid_spare_get_parent(vdev_t );
	extern int vdev_draid_spare_create(nvlist_t , vdev_t , uint64_t *, uint64_t);

	#ifdef __cplusplus
	}
	#endif

	#endif /* _SYS_VDEV_DRAID_H */
	diff --git a/sys/contrib/openzfs/include/sys/vdev_impl.h b/sys/contrib/openzfs/include/sys/vdev_impl.h
	index db4fe1447ebc..3cfde40a77fe 100644
	--- a/sys/contrib/openzfs/include/sys/vdev_impl.h
	+++ b/sys/contrib/openzfs/include/sys/vdev_impl.h
	@@ -1,657 +1,658 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2011, 2020 by Delphix. All rights reserved.
	* Copyright (c) 2017, Intel Corporation.
	*/

	#ifndef _SYS_VDEV_IMPL_H
	#define _SYS_VDEV_IMPL_H

	#include <sys/avl.h>
	#include <sys/bpobj.h>
	#include <sys/dmu.h>
	#include <sys/metaslab.h>
	#include <sys/nvpair.h>
	#include <sys/space_map.h>
	#include <sys/vdev.h>
	#include <sys/dkio.h>
	#include <sys/uberblock_impl.h>
	#include <sys/vdev_indirect_mapping.h>
	#include <sys/vdev_indirect_births.h>
	#include <sys/vdev_rebuild.h>
	#include <sys/vdev_removal.h>
	#include <sys/zfs_ratelimit.h>

	#ifdef __cplusplus
	extern "C" {
	#endif

	/*
	* Virtual device descriptors.
	*
	* All storage pool operations go through the virtual device framework,
	* which provides data replication and I/O scheduling.
	*/

	/*
	* Forward declarations that lots of things need.
	*/
	typedef struct vdev_queue vdev_queue_t;
	typedef struct vdev_cache vdev_cache_t;
	typedef struct vdev_cache_entry vdev_cache_entry_t;
	struct abd;

	extern int zfs_vdev_queue_depth_pct;
	extern int zfs_vdev_def_queue_depth;
	extern uint32_t zfs_vdev_async_write_max_active;

	/*
	* Virtual device operations
	*/
	typedef int vdev_init_func_t(spa_t spa, nvlist_t nv, void **tsd);
	typedef void vdev_fini_func_t(vdev_t *vd);
	typedef int vdev_open_func_t(vdev_t vd, uint64_t size, uint64_t *max_size,
	uint64_t ashift, uint64_t pshift);
	typedef void vdev_close_func_t(vdev_t *vd);
	typedef uint64_t vdev_asize_func_t(vdev_t *vd, uint64_t psize);
	typedef uint64_t vdev_min_asize_func_t(vdev_t *vd);
	typedef uint64_t vdev_min_alloc_func_t(vdev_t *vd);
	typedef void vdev_io_start_func_t(zio_t *zio);
	typedef void vdev_io_done_func_t(zio_t *zio);
	typedef void vdev_state_change_func_t(vdev_t *vd, int, int);
	typedef boolean_t vdev_need_resilver_func_t(vdev_t vd, const dva_t dva,
	size_t psize, uint64_t phys_birth);
	typedef void vdev_hold_func_t(vdev_t *vd);
	typedef void vdev_rele_func_t(vdev_t *vd);

	typedef void vdev_remap_cb_t(uint64_t inner_offset, vdev_t *vd,
	uint64_t offset, uint64_t size, void *arg);
	typedef void vdev_remap_func_t(vdev_t *vd, uint64_t offset, uint64_t size,
	vdev_remap_cb_t callback, void *arg);
	/*
	* Given a target vdev, translates the logical range "in" to the physical
	* range "res"
	*/
	typedef void vdev_xlation_func_t(vdev_t cvd, const range_seg64_t logical,
	range_seg64_t physical, range_seg64_t remain);
	typedef uint64_t vdev_rebuild_asize_func_t(vdev_t *vd, uint64_t start,
	uint64_t size, uint64_t max_segment);
	typedef void vdev_metaslab_init_func_t(vdev_t vd, uint64_t startp,
	uint64_t *sizep);
	typedef void vdev_config_generate_func_t(vdev_t vd, nvlist_t nv);
	typedef uint64_t vdev_nparity_func_t(vdev_t *vd);
	typedef uint64_t vdev_ndisks_func_t(vdev_t *vd);

	typedef const struct vdev_ops {
	vdev_init_func_t *vdev_op_init;
	vdev_fini_func_t *vdev_op_fini;
	vdev_open_func_t *vdev_op_open;
	vdev_close_func_t *vdev_op_close;
	vdev_asize_func_t *vdev_op_asize;
	vdev_min_asize_func_t *vdev_op_min_asize;
	vdev_min_alloc_func_t *vdev_op_min_alloc;
	vdev_io_start_func_t *vdev_op_io_start;
	vdev_io_done_func_t *vdev_op_io_done;
	vdev_state_change_func_t *vdev_op_state_change;
	vdev_need_resilver_func_t *vdev_op_need_resilver;
	vdev_hold_func_t *vdev_op_hold;
	vdev_rele_func_t *vdev_op_rele;
	vdev_remap_func_t *vdev_op_remap;
	vdev_xlation_func_t *vdev_op_xlate;
	vdev_rebuild_asize_func_t *vdev_op_rebuild_asize;
	vdev_metaslab_init_func_t *vdev_op_metaslab_init;
	vdev_config_generate_func_t *vdev_op_config_generate;
	vdev_nparity_func_t *vdev_op_nparity;
	vdev_ndisks_func_t *vdev_op_ndisks;
	char vdev_op_type[16];
	boolean_t vdev_op_leaf;
	} vdev_ops_t;

	/*
	* Virtual device properties
	*/
	struct vdev_cache_entry {
	struct abd *ve_abd;
	uint64_t ve_offset;
	clock_t ve_lastused;
	avl_node_t ve_offset_node;
	avl_node_t ve_lastused_node;
	uint32_t ve_hits;
	uint16_t ve_missed_update;
	zio_t *ve_fill_io;
	};

	struct vdev_cache {
	avl_tree_t vc_offset_tree;
	avl_tree_t vc_lastused_tree;
	kmutex_t vc_lock;
	};

	typedef struct vdev_queue_class {
	uint32_t vqc_active;

	/*
	* Sorted by offset or timestamp, depending on if the queue is
	* LBA-ordered vs FIFO.
	*/
	avl_tree_t vqc_queued_tree;
	} vdev_queue_class_t;

	struct vdev_queue {
	vdev_t *vq_vdev;
	vdev_queue_class_t vq_class[ZIO_PRIORITY_NUM_QUEUEABLE];
	avl_tree_t vq_active_tree;
	avl_tree_t vq_read_offset_tree;
	avl_tree_t vq_write_offset_tree;
	avl_tree_t vq_trim_offset_tree;
	uint64_t vq_last_offset;
	zio_priority_t vq_last_prio; /* Last sent I/O priority. */
	uint32_t vq_ia_active; /* Active interactive I/Os. */
	uint32_t vq_nia_credit; /* Non-interactive I/Os credit. */
	hrtime_t vq_io_complete_ts; /* time last i/o completed */
	hrtime_t vq_io_delta_ts;
	zio_t vq_io_search; /* used as local for stack reduction */
	kmutex_t vq_lock;
	};

	typedef enum vdev_alloc_bias {
	VDEV_BIAS_NONE,
	VDEV_BIAS_LOG, /* dedicated to ZIL data (SLOG) */
	VDEV_BIAS_SPECIAL, /* dedicated to ddt, metadata, and small blks */
	VDEV_BIAS_DEDUP /* dedicated to dedup metadata */
	} vdev_alloc_bias_t;


	/*
	* On-disk indirect vdev state.
	*
	* An indirect vdev is described exclusively in the MOS config of a pool.
	* The config for an indirect vdev includes several fields, which are
	* accessed in memory by a vdev_indirect_config_t.
	*/
	typedef struct vdev_indirect_config {
	/*
	* Object (in MOS) which contains the indirect mapping. This object
	* contains an array of vdev_indirect_mapping_entry_phys_t ordered by
	* vimep_src. The bonus buffer for this object is a
	* vdev_indirect_mapping_phys_t. This object is allocated when a vdev
	* removal is initiated.
	*
	* Note that this object can be empty if none of the data on the vdev
	* has been copied yet.
	*/
	uint64_t vic_mapping_object;

	/*
	* Object (in MOS) which contains the birth times for the mapping
	* entries. This object contains an array of
	* vdev_indirect_birth_entry_phys_t sorted by vibe_offset. The bonus
	* buffer for this object is a vdev_indirect_birth_phys_t. This object
	* is allocated when a vdev removal is initiated.
	*
	* Note that this object can be empty if none of the vdev has yet been
	* copied.
	*/
	uint64_t vic_births_object;

	/*
	* This is the vdev ID which was removed previous to this vdev, or
	* UINT64_MAX if there are no previously removed vdevs.
	*/
	uint64_t vic_prev_indirect_vdev;
	} vdev_indirect_config_t;

	/*
	* Virtual device descriptor
	*/
	struct vdev {
	/*
	* Common to all vdev types.
	*/
	uint64_t vdev_id; /* child number in vdev parent */
	uint64_t vdev_guid; /* unique ID for this vdev */
	uint64_t vdev_guid_sum; /* self guid + all child guids */
	uint64_t vdev_orig_guid; /* orig. guid prior to remove */
	uint64_t vdev_asize; /* allocatable device capacity */
	uint64_t vdev_min_asize; /* min acceptable asize */
	uint64_t vdev_max_asize; /* max acceptable asize */
	uint64_t vdev_ashift; /* block alignment shift */

	/*
	* Logical block alignment shift
	*
	* The smallest sized/aligned I/O supported by the device.
	*/
	uint64_t vdev_logical_ashift;
	/*
	* Physical block alignment shift
	*
	* The device supports logical I/Os with vdev_logical_ashift
	* size/alignment, but optimum performance will be achieved by
	* aligning/sizing requests to vdev_physical_ashift. Smaller
	* requests may be inflated or incur device level read-modify-write
	* operations.
	*
	* May be 0 to indicate no preference (i.e. use vdev_logical_ashift).
	*/
	uint64_t vdev_physical_ashift;
	uint64_t vdev_state; /* see VDEV_STATE_* #defines */
	uint64_t vdev_prevstate; /* used when reopening a vdev */
	vdev_ops_t vdev_ops; / vdev operations */
	spa_t vdev_spa; / spa for this vdev */
	void vdev_tsd; / type-specific data */
	vdev_t vdev_top; / top-level vdev */
	vdev_t vdev_parent; / parent vdev */
	vdev_t *vdev_child; / array of children */
	uint64_t vdev_children; /* number of children */
	vdev_stat_t vdev_stat; /* virtual device statistics */
	vdev_stat_ex_t vdev_stat_ex; /* extended statistics */
	boolean_t vdev_expanding; /* expand the vdev? */
	boolean_t vdev_reopening; /* reopen in progress? */
	boolean_t vdev_nonrot; /* true if solid state */
	int vdev_load_error; /* error on last load */
	int vdev_open_error; /* error on last open */
	int vdev_validate_error; /* error on last validate */
	kthread_t vdev_open_thread; / thread opening children */
	kthread_t vdev_validate_thread; / thread validating children */
	uint64_t vdev_crtxg; /* txg when top-level was added */

	/*
	* Top-level vdev state.
	*/
	uint64_t vdev_ms_array; /* metaslab array object */
	uint64_t vdev_ms_shift; /* metaslab size shift */
	uint64_t vdev_ms_count; /* number of metaslabs */
	metaslab_group_t vdev_mg; / metaslab group */
	metaslab_group_t vdev_log_mg; / embedded slog metaslab group */
	metaslab_t *vdev_ms; / metaslab array */
	uint64_t vdev_pending_fastwrite; /* allocated fastwrites */
	txg_list_t vdev_ms_list; /* per-txg dirty metaslab lists */
	txg_list_t vdev_dtl_list; /* per-txg dirty DTL lists */
	txg_node_t vdev_txg_node; /* per-txg dirty vdev linkage */
	boolean_t vdev_remove_wanted; /* async remove wanted? */
	boolean_t vdev_probe_wanted; /* async probe wanted? */
	list_node_t vdev_config_dirty_node; /* config dirty list */
	list_node_t vdev_state_dirty_node; /* state dirty list */
	uint64_t vdev_deflate_ratio; /* deflation ratio (x512) */
	uint64_t vdev_islog; /* is an intent log device */
	uint64_t vdev_removing; /* device is being removed? */
	boolean_t vdev_ishole; /* is a hole in the namespace */
	uint64_t vdev_top_zap;
	vdev_alloc_bias_t vdev_alloc_bias; /* metaslab allocation bias */

	/* pool checkpoint related */
	space_map_t vdev_checkpoint_sm; / contains reserved blocks */

	/* Initialize related */
	boolean_t vdev_initialize_exit_wanted;
	vdev_initializing_state_t vdev_initialize_state;
	list_node_t vdev_initialize_node;
	kthread_t *vdev_initialize_thread;
	/* Protects vdev_initialize_thread and vdev_initialize_state. */
	kmutex_t vdev_initialize_lock;
	kcondvar_t vdev_initialize_cv;
	uint64_t vdev_initialize_offset[TXG_SIZE];
	uint64_t vdev_initialize_last_offset;
	range_tree_t vdev_initialize_tree; / valid while initializing */
	uint64_t vdev_initialize_bytes_est;
	uint64_t vdev_initialize_bytes_done;
	uint64_t vdev_initialize_action_time; /* start and end time */

	/* TRIM related */
	boolean_t vdev_trim_exit_wanted;
	boolean_t vdev_autotrim_exit_wanted;
	vdev_trim_state_t vdev_trim_state;
	list_node_t vdev_trim_node;
	kmutex_t vdev_autotrim_lock;
	kcondvar_t vdev_autotrim_cv;
	kthread_t *vdev_autotrim_thread;
	/* Protects vdev_trim_thread and vdev_trim_state. */
	kmutex_t vdev_trim_lock;
	kcondvar_t vdev_trim_cv;
	kthread_t *vdev_trim_thread;
	uint64_t vdev_trim_offset[TXG_SIZE];
	uint64_t vdev_trim_last_offset;
	uint64_t vdev_trim_bytes_est;
	uint64_t vdev_trim_bytes_done;
	uint64_t vdev_trim_rate; /* requested rate (bytes/sec) */
	uint64_t vdev_trim_partial; /* requested partial TRIM */
	uint64_t vdev_trim_secure; /* requested secure TRIM */
	uint64_t vdev_trim_action_time; /* start and end time */

	/* Rebuild related */
	boolean_t vdev_rebuilding;
	boolean_t vdev_rebuild_exit_wanted;
	boolean_t vdev_rebuild_cancel_wanted;
	boolean_t vdev_rebuild_reset_wanted;
	kmutex_t vdev_rebuild_lock;
	kcondvar_t vdev_rebuild_cv;
	kthread_t *vdev_rebuild_thread;
	vdev_rebuild_t vdev_rebuild_config;

	/* For limiting outstanding I/Os (initialize, TRIM) */
	kmutex_t vdev_initialize_io_lock;
	kcondvar_t vdev_initialize_io_cv;
	uint64_t vdev_initialize_inflight;
	kmutex_t vdev_trim_io_lock;
	kcondvar_t vdev_trim_io_cv;
	uint64_t vdev_trim_inflight[3];

	/*
	* Values stored in the config for an indirect or removing vdev.
	*/
	vdev_indirect_config_t vdev_indirect_config;

	/*
	* The vdev_indirect_rwlock protects the vdev_indirect_mapping
	* pointer from changing on indirect vdevs (when it is condensed).
	* Note that removing (not yet indirect) vdevs have different
	* access patterns (the mapping is not accessed from open context,
	* e.g. from zio_read) and locking strategy (e.g. svr_lock).
	*/
	krwlock_t vdev_indirect_rwlock;
	vdev_indirect_mapping_t *vdev_indirect_mapping;
	vdev_indirect_births_t *vdev_indirect_births;

	/*
	* In memory data structures used to manage the obsolete sm, for
	* indirect or removing vdevs.
	*
	* The vdev_obsolete_segments is the in-core record of the segments
	* that are no longer referenced anywhere in the pool (due to
	* being freed or remapped and not referenced by any snapshots).
	* During a sync, segments are added to vdev_obsolete_segments
	* via vdev_indirect_mark_obsolete(); at the end of each sync
	* pass, this is appended to vdev_obsolete_sm via
	* vdev_indirect_sync_obsolete(). The vdev_obsolete_lock
	* protects against concurrent modifications of vdev_obsolete_segments
	* from multiple zio threads.
	*/
	kmutex_t vdev_obsolete_lock;
	range_tree_t *vdev_obsolete_segments;
	space_map_t *vdev_obsolete_sm;

	/*
	* Protects the vdev_scan_io_queue field itself as well as the
	* structure's contents (when present).
	*/
	kmutex_t vdev_scan_io_queue_lock;
	struct dsl_scan_io_queue *vdev_scan_io_queue;

	/*
	* Leaf vdev state.
	*/
	range_tree_t vdev_dtl[DTL_TYPES]; / dirty time logs */
	space_map_t vdev_dtl_sm; / dirty time log space map */
	txg_node_t vdev_dtl_node; /* per-txg dirty DTL linkage */
	uint64_t vdev_dtl_object; /* DTL object */
	uint64_t vdev_psize; /* physical device capacity */
	uint64_t vdev_wholedisk; /* true if this is a whole disk */
	uint64_t vdev_offline; /* persistent offline state */
	uint64_t vdev_faulted; /* persistent faulted state */
	uint64_t vdev_degraded; /* persistent degraded state */
	uint64_t vdev_removed; /* persistent removed state */
	uint64_t vdev_resilver_txg; /* persistent resilvering state */
	uint64_t vdev_rebuild_txg; /* persistent rebuilding state */
	char vdev_path; / vdev path (if any) */
	char vdev_devid; / vdev devid (if any) */
	char vdev_physpath; / vdev device path (if any) */
	char vdev_enc_sysfs_path; / enclosure sysfs path */
	char vdev_fru; / physical FRU location */
	uint64_t vdev_not_present; /* not present during import */
	uint64_t vdev_unspare; /* unspare when resilvering done */
	boolean_t vdev_nowritecache; /* true if flushwritecache failed */
	boolean_t vdev_has_trim; /* TRIM is supported */
	boolean_t vdev_has_securetrim; /* secure TRIM is supported */
	boolean_t vdev_checkremove; /* temporary online test */
	boolean_t vdev_forcefault; /* force online fault */
	boolean_t vdev_splitting; /* split or repair in progress */
	boolean_t vdev_delayed_close; /* delayed device close? */
	boolean_t vdev_tmpoffline; /* device taken offline temporarily? */
	boolean_t vdev_detached; /* device detached? */
	boolean_t vdev_cant_read; /* vdev is failing all reads */
	boolean_t vdev_cant_write; /* vdev is failing all writes */
	boolean_t vdev_isspare; /* was a hot spare */
	boolean_t vdev_isl2cache; /* was a l2cache device */
	boolean_t vdev_copy_uberblocks; /* post expand copy uberblocks */
	boolean_t vdev_resilver_deferred; /* resilver deferred */
	vdev_queue_t vdev_queue; /* I/O deadline schedule queue */
	vdev_cache_t vdev_cache; /* physical block cache */
	spa_aux_vdev_t vdev_aux; / for l2cache and spares vdevs */
	zio_t vdev_probe_zio; / root of current probe */
	vdev_aux_t vdev_label_aux; /* on-disk aux state */
	uint64_t vdev_leaf_zap;
	hrtime_t vdev_mmp_pending; /* 0 if write finished */
	uint64_t vdev_mmp_kstat_id; /* to find kstat entry */
	uint64_t vdev_expansion_time; /* vdev's last expansion time */
	list_node_t vdev_leaf_node; /* leaf vdev list */

	/*
	* For DTrace to work in userland (libzpool) context, these fields must
	* remain at the end of the structure. DTrace will use the kernel's
	* CTF definition for 'struct vdev', and since the size of a kmutex_t is
	* larger in userland, the offsets for the rest of the fields would be
	* incorrect.
	*/
	kmutex_t vdev_dtl_lock; /* vdev_dtl_{map,resilver} */
	kmutex_t vdev_stat_lock; /* vdev_stat */
	kmutex_t vdev_probe_lock; /* protects vdev_probe_zio */

	/*
	- * We rate limit ZIO delay and ZIO checksum events, since they
	+ * We rate limit ZIO delay, deadman, and checksum events, since they
	* can flood ZED with tons of events when a drive is acting up.
	*/
	zfs_ratelimit_t vdev_delay_rl;
	+ zfs_ratelimit_t vdev_deadman_rl;
	zfs_ratelimit_t vdev_checksum_rl;
	};

	#define VDEV_PAD_SIZE (8 << 10)
	/* 2 padding areas (vl_pad1 and vl_be) to skip */
	#define VDEV_SKIP_SIZE VDEV_PAD_SIZE * 2
	#define VDEV_PHYS_SIZE (112 << 10)
	#define VDEV_UBERBLOCK_RING (128 << 10)

	/*
	* MMP blocks occupy the last MMP_BLOCKS_PER_LABEL slots in the uberblock
	* ring when MMP is enabled.
	*/
	#define MMP_BLOCKS_PER_LABEL 1

	/* The largest uberblock we support is 8k. */
	#define MAX_UBERBLOCK_SHIFT (13)
	#define VDEV_UBERBLOCK_SHIFT(vd) \
	MIN(MAX((vd)->vdev_top->vdev_ashift, UBERBLOCK_SHIFT), \
	MAX_UBERBLOCK_SHIFT)
	#define VDEV_UBERBLOCK_COUNT(vd) \
	(VDEV_UBERBLOCK_RING >> VDEV_UBERBLOCK_SHIFT(vd))
	#define VDEV_UBERBLOCK_OFFSET(vd, n) \
	offsetof(vdev_label_t, vl_uberblock[(n) << VDEV_UBERBLOCK_SHIFT(vd)])
	#define VDEV_UBERBLOCK_SIZE(vd) (1ULL << VDEV_UBERBLOCK_SHIFT(vd))

	typedef struct vdev_phys {
	char vp_nvlist[VDEV_PHYS_SIZE - sizeof (zio_eck_t)];
	zio_eck_t vp_zbt;
	} vdev_phys_t;

	typedef enum vbe_vers {
	/*
	* The bootenv file is stored as ascii text in the envblock.
	* It is used by the GRUB bootloader used on Linux to store the
	* contents of the grubenv file. The file is stored as raw ASCII,
	* and is protected by an embedded checksum. By default, GRUB will
	* check if the boot filesystem supports storing the environment data
	* in a special location, and if so, will invoke filesystem specific
	- * logic to retrieve it. This can be overriden by a variable, should
	+ * logic to retrieve it. This can be overridden by a variable, should
	* the user so desire.
	*/
	VB_RAW = 0,

	/*
	* The bootenv file is converted to an nvlist and then packed into the
	* envblock.
	*/
	VB_NVLIST = 1
	} vbe_vers_t;

	typedef struct vdev_boot_envblock {
	uint64_t vbe_version;
	char vbe_bootenv[VDEV_PAD_SIZE - sizeof (uint64_t) -
	sizeof (zio_eck_t)];
	zio_eck_t vbe_zbt;
	} vdev_boot_envblock_t;

	CTASSERT_GLOBAL(sizeof (vdev_boot_envblock_t) == VDEV_PAD_SIZE);

	typedef struct vdev_label {
	char vl_pad1[VDEV_PAD_SIZE]; /* 8K */
	vdev_boot_envblock_t vl_be; /* 8K */
	vdev_phys_t vl_vdev_phys; /* 112K */
	char vl_uberblock[VDEV_UBERBLOCK_RING]; /* 128K */
	} vdev_label_t; /* 256K total */

	/*
	* vdev_dirty() flags
	*/
	#define VDD_METASLAB 0x01
	#define VDD_DTL 0x02

	/* Offset of embedded boot loader region on each label */
	#define VDEV_BOOT_OFFSET (2 * sizeof (vdev_label_t))
	/*
	* Size of embedded boot loader region on each label.
	* The total size of the first two labels plus the boot area is 4MB.
	*/
	#define VDEV_BOOT_SIZE (7ULL << 19) /* 3.5M */

	/*
	* Size of label regions at the start and end of each leaf device.
	*/
	#define VDEV_LABEL_START_SIZE (2 * sizeof (vdev_label_t) + VDEV_BOOT_SIZE)
	#define VDEV_LABEL_END_SIZE (2 * sizeof (vdev_label_t))
	#define VDEV_LABELS 4
	#define VDEV_BEST_LABEL VDEV_LABELS
	#define VDEV_OFFSET_IS_LABEL(vd, off) \
	(((off) < VDEV_LABEL_START_SIZE) \|\| \
	((off) >= ((vd)->vdev_psize - VDEV_LABEL_END_SIZE)))

	#define VDEV_ALLOC_LOAD 0
	#define VDEV_ALLOC_ADD 1
	#define VDEV_ALLOC_SPARE 2
	#define VDEV_ALLOC_L2CACHE 3
	#define VDEV_ALLOC_ROOTPOOL 4
	#define VDEV_ALLOC_SPLIT 5
	#define VDEV_ALLOC_ATTACH 6

	/*
	* Allocate or free a vdev
	*/
	extern vdev_t vdev_alloc_common(spa_t spa, uint_t id, uint64_t guid,
	vdev_ops_t *ops);
	extern int vdev_alloc(spa_t spa, vdev_t vdp, nvlist_t config,
	vdev_t *parent, uint_t id, int alloctype);
	extern void vdev_free(vdev_t *vd);

	/*
	* Add or remove children and parents
	*/
	extern void vdev_add_child(vdev_t pvd, vdev_t cvd);
	extern void vdev_remove_child(vdev_t pvd, vdev_t cvd);
	extern void vdev_compact_children(vdev_t *pvd);
	extern vdev_t vdev_add_parent(vdev_t cvd, vdev_ops_t *ops);
	extern void vdev_remove_parent(vdev_t *cvd);

	/*
	* vdev sync load and sync
	*/
	extern boolean_t vdev_log_state_valid(vdev_t *vd);
	extern int vdev_load(vdev_t *vd);
	extern int vdev_dtl_load(vdev_t *vd);
	extern void vdev_sync(vdev_t *vd, uint64_t txg);
	extern void vdev_sync_done(vdev_t *vd, uint64_t txg);
	extern void vdev_dirty(vdev_t vd, int flags, void arg, uint64_t txg);
	extern void vdev_dirty_leaves(vdev_t *vd, int flags, uint64_t txg);

	/*
	* Available vdev types.
	*/
	extern vdev_ops_t vdev_root_ops;
	extern vdev_ops_t vdev_mirror_ops;
	extern vdev_ops_t vdev_replacing_ops;
	extern vdev_ops_t vdev_raidz_ops;
	extern vdev_ops_t vdev_draid_ops;
	extern vdev_ops_t vdev_draid_spare_ops;
	extern vdev_ops_t vdev_disk_ops;
	extern vdev_ops_t vdev_file_ops;
	extern vdev_ops_t vdev_missing_ops;
	extern vdev_ops_t vdev_hole_ops;
	extern vdev_ops_t vdev_spare_ops;
	extern vdev_ops_t vdev_indirect_ops;

	/*
	* Common size functions
	*/
	extern void vdev_default_xlate(vdev_t vd, const range_seg64_t logical_rs,
	range_seg64_t physical_rs, range_seg64_t remain_rs);
	extern uint64_t vdev_default_asize(vdev_t *vd, uint64_t psize);
	extern uint64_t vdev_default_min_asize(vdev_t *vd);
	extern uint64_t vdev_get_min_asize(vdev_t *vd);
	extern void vdev_set_min_asize(vdev_t *vd);
	extern uint64_t vdev_get_min_alloc(vdev_t *vd);
	extern uint64_t vdev_get_nparity(vdev_t *vd);
	extern uint64_t vdev_get_ndisks(vdev_t *vd);

	/*
	* Global variables
	*/
	extern int zfs_vdev_standard_sm_blksz;
	/* zdb uses this tunable, so it must be declared here to make lint happy. */
	extern int zfs_vdev_cache_size;

	/*
	* Functions from vdev_indirect.c
	*/
	extern void vdev_indirect_sync_obsolete(vdev_t vd, dmu_tx_t tx);
	extern boolean_t vdev_indirect_should_condense(vdev_t *vd);
	extern void spa_condense_indirect_start_sync(vdev_t vd, dmu_tx_t tx);
	extern int vdev_obsolete_sm_object(vdev_t vd, uint64_t sm_obj);
	extern int vdev_obsolete_counts_are_precise(vdev_t vd, boolean_t are_precise);

	/*
	* Other miscellaneous functions
	*/
	int vdev_checkpoint_sm_object(vdev_t vd, uint64_t sm_obj);
	void vdev_metaslab_group_create(vdev_t *vd);

	/*
	* Vdev ashift optimization tunables
	*/
	extern uint64_t zfs_vdev_min_auto_ashift;
	extern uint64_t zfs_vdev_max_auto_ashift;
	int param_set_min_auto_ashift(ZFS_MODULE_PARAM_ARGS);
	int param_set_max_auto_ashift(ZFS_MODULE_PARAM_ARGS);

	#ifdef __cplusplus
	}
	#endif

	#endif /* _SYS_VDEV_IMPL_H */
	diff --git a/sys/contrib/openzfs/include/sys/vdev_raidz_impl.h b/sys/contrib/openzfs/include/sys/vdev_raidz_impl.h
	index b94d59eb7762..908723da0c2a 100644
	--- a/sys/contrib/openzfs/include/sys/vdev_raidz_impl.h
	+++ b/sys/contrib/openzfs/include/sys/vdev_raidz_impl.h
	@@ -1,388 +1,389 @@
	/*
	* 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) 2016 Gvozden Nešković. All rights reserved.
	*/

	#ifndef _VDEV_RAIDZ_H
	#define _VDEV_RAIDZ_H

	#include <sys/types.h>
	#include <sys/debug.h>
	#include <sys/kstat.h>
	#include <sys/abd.h>
	#include <sys/vdev_impl.h>

	#ifdef __cplusplus
	extern "C" {
	#endif

	#define CODE_P (0U)
	#define CODE_Q (1U)
	#define CODE_R (2U)

	#define PARITY_P (1U)
	#define PARITY_PQ (2U)
	#define PARITY_PQR (3U)

	#define TARGET_X (0U)
	#define TARGET_Y (1U)
	#define TARGET_Z (2U)

	/*
	* Parity generation methods indexes
	*/
	enum raidz_math_gen_op {
	RAIDZ_GEN_P = 0,
	RAIDZ_GEN_PQ,
	RAIDZ_GEN_PQR,
	RAIDZ_GEN_NUM = 3
	};
	/*
	* Data reconstruction methods indexes
	*/
	enum raidz_rec_op {
	RAIDZ_REC_P = 0,
	RAIDZ_REC_Q,
	RAIDZ_REC_R,
	RAIDZ_REC_PQ,
	RAIDZ_REC_PR,
	RAIDZ_REC_QR,
	RAIDZ_REC_PQR,
	RAIDZ_REC_NUM = 7
	};

	extern const char *raidz_gen_name[RAIDZ_GEN_NUM];
	extern const char *raidz_rec_name[RAIDZ_REC_NUM];

	/*
	* Methods used to define raidz implementation
	*
	* @raidz_gen_f Parity generation function
	* @par1 pointer to raidz_map
	* @raidz_rec_f Data reconstruction function
	* @par1 pointer to raidz_map
	* @par2 array of reconstruction targets
	* @will_work_f Function returns TRUE if impl. is supported on the system
	* @init_impl_f Function is called once on init
	* @fini_impl_f Function is called once on fini
	*/
	typedef void (raidz_gen_f)(void );
	typedef int (raidz_rec_f)(void , const int *);
	typedef boolean_t (*will_work_f)(void);
	typedef void (*init_impl_f)(void);
	typedef void (*fini_impl_f)(void);

	#define RAIDZ_IMPL_NAME_MAX (20)

	typedef struct raidz_impl_ops {
	init_impl_f init;
	fini_impl_f fini;
	raidz_gen_f gen[RAIDZ_GEN_NUM]; /* Parity generate functions */
	raidz_rec_f rec[RAIDZ_REC_NUM]; /* Data reconstruction functions */
	will_work_f is_supported; /* Support check function */
	char name[RAIDZ_IMPL_NAME_MAX]; /* Name of the implementation */
	} raidz_impl_ops_t;

	typedef struct raidz_col {
	uint64_t rc_devidx; /* child device index for I/O */
	uint64_t rc_offset; /* device offset */
	uint64_t rc_size; /* I/O size */
	abd_t rc_abdstruct; /* rc_abd probably points here */
	abd_t rc_abd; / I/O data */
	abd_t rc_orig_data; / pre-reconstruction */
	int rc_error; /* I/O error for this device */
	uint8_t rc_tried; /* Did we attempt this I/O column? */
	uint8_t rc_skipped; /* Did we skip this I/O column? */
	uint8_t rc_need_orig_restore; /* need to restore from orig_data? */
	- uint8_t rc_repair; /* Write good data to this column */
	+ uint8_t rc_force_repair; /* Write good data to this column */
	+ uint8_t rc_allow_repair; /* Allow repair I/O to this column */
	} raidz_col_t;

	typedef struct raidz_row {
	uint64_t rr_cols; /* Regular column count */
	uint64_t rr_scols; /* Count including skipped columns */
	uint64_t rr_bigcols; /* Remainder data column count */
	uint64_t rr_missingdata; /* Count of missing data devices */
	uint64_t rr_missingparity; /* Count of missing parity devices */
	uint64_t rr_firstdatacol; /* First data column/parity count */
	abd_t rr_abd_empty; / dRAID empty sector buffer */
	int rr_nempty; /* empty sectors included in parity */
	#ifdef ZFS_DEBUG
	uint64_t rr_offset; /* Logical offset for _io_verify() /
	uint64_t rr_size; /* Physical size for _io_verify() /
	#endif
	raidz_col_t rr_col[0]; /* Flexible array of I/O columns */
	} raidz_row_t;

	typedef struct raidz_map {
	boolean_t rm_ecksuminjected; /* checksum error was injected */
	int rm_nrows; /* Regular row count */
	int rm_nskip; /* RAIDZ sectors skipped for padding */
	int rm_skipstart; /* Column index of padding start */
	const raidz_impl_ops_t rm_ops; / RAIDZ math operations */
	raidz_row_t rm_row[0]; / flexible array of rows */
	} raidz_map_t;


	#define RAIDZ_ORIGINAL_IMPL (INT_MAX)

	extern const raidz_impl_ops_t vdev_raidz_scalar_impl;
	extern boolean_t raidz_will_scalar_work(void);

	#if defined(__x86_64) && defined(HAVE_SSE2) /* only x86_64 for now */
	extern const raidz_impl_ops_t vdev_raidz_sse2_impl;
	#endif
	#if defined(__x86_64) && defined(HAVE_SSSE3) /* only x86_64 for now */
	extern const raidz_impl_ops_t vdev_raidz_ssse3_impl;
	#endif
	#if defined(__x86_64) && defined(HAVE_AVX2) /* only x86_64 for now */
	extern const raidz_impl_ops_t vdev_raidz_avx2_impl;
	#endif
	#if defined(__x86_64) && defined(HAVE_AVX512F) /* only x86_64 for now */
	extern const raidz_impl_ops_t vdev_raidz_avx512f_impl;
	#endif
	#if defined(__x86_64) && defined(HAVE_AVX512BW) /* only x86_64 for now */
	extern const raidz_impl_ops_t vdev_raidz_avx512bw_impl;
	#endif
	#if defined(__aarch64__)
	extern const raidz_impl_ops_t vdev_raidz_aarch64_neon_impl;
	extern const raidz_impl_ops_t vdev_raidz_aarch64_neonx2_impl;
	#endif
	#if defined(__powerpc__)
	extern const raidz_impl_ops_t vdev_raidz_powerpc_altivec_impl;
	#endif

	/*
	* Commonly used raidz_map helpers
	*
	* raidz_parity Returns parity of the RAIDZ block
	* raidz_ncols Returns number of columns the block spans
	* Note, all rows have the same number of columns.
	* raidz_nbigcols Returns number of big columns
	* raidz_col_p Returns pointer to a column
	* raidz_col_size Returns size of a column
	* raidz_big_size Returns size of big columns
	* raidz_short_size Returns size of short columns
	*/
	#define raidz_parity(rm) ((rm)->rm_row[0]->rr_firstdatacol)
	#define raidz_ncols(rm) ((rm)->rm_row[0]->rr_cols)
	#define raidz_nbigcols(rm) ((rm)->rm_bigcols)
	#define raidz_col_p(rm, c) ((rm)->rm_col + (c))
	#define raidz_col_size(rm, c) ((rm)->rm_col[c].rc_size)
	#define raidz_big_size(rm) (raidz_col_size(rm, CODE_P))
	#define raidz_short_size(rm) (raidz_col_size(rm, raidz_ncols(rm)-1))

	/*
	* Macro defines an RAIDZ parity generation method
	*
	* @code parity the function produce
	* @impl name of the implementation
	*/
	#define _RAIDZ_GEN_WRAP(code, impl) \
	static void \
	impl ## _gen_ ## code(void *rrp) \
	{ \
	raidz_row_t rr = (raidz_row_t )rrp; \
	raidz_generate_## code ## _impl(rr); \
	}

	/*
	* Macro defines an RAIDZ data reconstruction method
	*
	* @code parity the function produce
	* @impl name of the implementation
	*/
	#define _RAIDZ_REC_WRAP(code, impl) \
	static int \
	impl ## _rec_ ## code(void rrp, const int tgtidx) \
	{ \
	raidz_row_t rr = (raidz_row_t )rrp; \
	return (raidz_reconstruct_## code ## _impl(rr, tgtidx)); \
	}

	/*
	* Define all gen methods for an implementation
	*
	* @impl name of the implementation
	*/
	#define DEFINE_GEN_METHODS(impl) \
	_RAIDZ_GEN_WRAP(p, impl); \
	_RAIDZ_GEN_WRAP(pq, impl); \
	_RAIDZ_GEN_WRAP(pqr, impl)

	/*
	* Define all rec functions for an implementation
	*
	* @impl name of the implementation
	*/
	#define DEFINE_REC_METHODS(impl) \
	_RAIDZ_REC_WRAP(p, impl); \
	_RAIDZ_REC_WRAP(q, impl); \
	_RAIDZ_REC_WRAP(r, impl); \
	_RAIDZ_REC_WRAP(pq, impl); \
	_RAIDZ_REC_WRAP(pr, impl); \
	_RAIDZ_REC_WRAP(qr, impl); \
	_RAIDZ_REC_WRAP(pqr, impl)

	#define RAIDZ_GEN_METHODS(impl) \
	{ \
	[RAIDZ_GEN_P] = & impl ## _gen_p, \
	[RAIDZ_GEN_PQ] = & impl ## _gen_pq, \
	[RAIDZ_GEN_PQR] = & impl ## _gen_pqr \
	}

	#define RAIDZ_REC_METHODS(impl) \
	{ \
	[RAIDZ_REC_P] = & impl ## _rec_p, \
	[RAIDZ_REC_Q] = & impl ## _rec_q, \
	[RAIDZ_REC_R] = & impl ## _rec_r, \
	[RAIDZ_REC_PQ] = & impl ## _rec_pq, \
	[RAIDZ_REC_PR] = & impl ## _rec_pr, \
	[RAIDZ_REC_QR] = & impl ## _rec_qr, \
	[RAIDZ_REC_PQR] = & impl ## _rec_pqr \
	}


	typedef struct raidz_impl_kstat {
	uint64_t gen[RAIDZ_GEN_NUM]; /* gen method speed B/s */
	uint64_t rec[RAIDZ_REC_NUM]; /* rec method speed B/s */
	} raidz_impl_kstat_t;

	/*
	* Enumerate various multiplication constants
	* used in reconstruction methods
	*/
	typedef enum raidz_mul_info {
	/* Reconstruct Q */
	MUL_Q_X = 0,
	/* Reconstruct R */
	MUL_R_X = 0,
	/* Reconstruct PQ */
	MUL_PQ_X = 0,
	MUL_PQ_Y = 1,
	/* Reconstruct PR */
	MUL_PR_X = 0,
	MUL_PR_Y = 1,
	/* Reconstruct QR */
	MUL_QR_XQ = 0,
	MUL_QR_X = 1,
	MUL_QR_YQ = 2,
	MUL_QR_Y = 3,
	/* Reconstruct PQR */
	MUL_PQR_XP = 0,
	MUL_PQR_XQ = 1,
	MUL_PQR_XR = 2,
	MUL_PQR_YU = 3,
	MUL_PQR_YP = 4,
	MUL_PQR_YQ = 5,

	MUL_CNT = 6
	} raidz_mul_info_t;

	/*
	* Powers of 2 in the Galois field.
	*/
	extern const uint8_t vdev_raidz_pow2[256] __attribute__((aligned(256)));
	/* Logs of 2 in the Galois field defined above. */
	extern const uint8_t vdev_raidz_log2[256] __attribute__((aligned(256)));

	/*
	* Multiply a given number by 2 raised to the given power.
	*/
	static inline uint8_t
	vdev_raidz_exp2(const uint8_t a, const unsigned exp)
	{
	if (a == 0)
	return (0);

	return (vdev_raidz_pow2[(exp + (unsigned)vdev_raidz_log2[a]) % 255]);
	}

	/*
	* Galois Field operations.
	*
	* gf_exp2 - computes 2 raised to the given power
	* gf_exp2 - computes 4 raised to the given power
	* gf_mul - multiplication
	* gf_div - division
	* gf_inv - multiplicative inverse
	*/
	typedef unsigned gf_t;
	typedef unsigned gf_log_t;

	static inline gf_t
	gf_mul(const gf_t a, const gf_t b)
	{
	gf_log_t logsum;

	if (a == 0 \|\| b == 0)
	return (0);

	logsum = (gf_log_t)vdev_raidz_log2[a] + (gf_log_t)vdev_raidz_log2[b];

	return ((gf_t)vdev_raidz_pow2[logsum % 255]);
	}

	static inline gf_t
	gf_div(const gf_t a, const gf_t b)
	{
	gf_log_t logsum;

	ASSERT3U(b, >, 0);
	if (a == 0)
	return (0);

	logsum = (gf_log_t)255 + (gf_log_t)vdev_raidz_log2[a] -
	(gf_log_t)vdev_raidz_log2[b];

	return ((gf_t)vdev_raidz_pow2[logsum % 255]);
	}

	static inline gf_t
	gf_inv(const gf_t a)
	{
	gf_log_t logsum;

	ASSERT3U(a, >, 0);

	logsum = (gf_log_t)255 - (gf_log_t)vdev_raidz_log2[a];

	return ((gf_t)vdev_raidz_pow2[logsum]);
	}

	static inline gf_t
	gf_exp2(gf_log_t exp)
	{
	return (vdev_raidz_pow2[exp % 255]);
	}

	static inline gf_t
	gf_exp4(gf_log_t exp)
	{
	ASSERT3U(exp, <=, 255);
	return ((gf_t)vdev_raidz_pow2[(2 * exp) % 255]);
	}

	#ifdef __cplusplus
	}
	#endif

	#endif /* _VDEV_RAIDZ_H */
	diff --git a/sys/contrib/openzfs/include/sys/vdev_rebuild.h b/sys/contrib/openzfs/include/sys/vdev_rebuild.h
	index 61ae15c5d09a..b59fbe153903 100644
	--- a/sys/contrib/openzfs/include/sys/vdev_rebuild.h
	+++ b/sys/contrib/openzfs/include/sys/vdev_rebuild.h
	@@ -1,101 +1,101 @@
	/*
	* 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) 2018, Intel Corporation.
	* Copyright (c) 2020 by Lawrence Livermore National Security, LLC.
	*/

	#ifndef _SYS_VDEV_REBUILD_H
	#define _SYS_VDEV_REBUILD_H

	#include <sys/spa.h>

	#ifdef __cplusplus
	extern "C" {
	#endif

	/*
	* Number of entries in the physical vdev_rebuild_phys structure. This
	* state is stored per top-level as VDEV_ZAP_TOP_VDEV_REBUILD_PHYS.
	*/
	#define REBUILD_PHYS_ENTRIES 12

	/*
	* On-disk rebuild configuration and state. When adding new fields they
	* must be added to the end of the structure.
	*/
	typedef struct vdev_rebuild_phys {
	uint64_t vrp_rebuild_state; /* vdev_rebuild_state_t */
	uint64_t vrp_last_offset; /* last rebuilt offset */
	uint64_t vrp_min_txg; /* minimum missing txg */
	uint64_t vrp_max_txg; /* maximum missing txg */
	uint64_t vrp_start_time; /* start time */
	uint64_t vrp_end_time; /* end time */
	uint64_t vrp_scan_time_ms; /* total run time in ms */
	uint64_t vrp_bytes_scanned; /* alloc bytes scanned */
	uint64_t vrp_bytes_issued; /* read bytes rebuilt */
	uint64_t vrp_bytes_rebuilt; /* rebuilt bytes */
	uint64_t vrp_bytes_est; /* total bytes to scan */
	uint64_t vrp_errors; /* errors during rebuild */
	} vdev_rebuild_phys_t;

	/*
	* The vdev_rebuild_t describes the current state and how a top-level vdev
	* should be rebuilt. The core elements are the top-vdev, the metaslab being
	- * rebuilt, range tree containing the allocted extents and the on-disk state.
	+ * rebuilt, range tree containing the allocated extents and the on-disk state.
	*/
	typedef struct vdev_rebuild {
	vdev_t vr_top_vdev; / top-level vdev to rebuild */
	metaslab_t vr_scan_msp; / scanning disabled metaslab */
	range_tree_t vr_scan_tree; / scan ranges (in metaslab) */
	kmutex_t vr_io_lock; /* inflight IO lock */
	kcondvar_t vr_io_cv; /* inflight IO cv */

	/* In-core state and progress */
	uint64_t vr_scan_offset[TXG_SIZE];
	uint64_t vr_prev_scan_time_ms; /* any previous scan time */
	uint64_t vr_bytes_inflight_max; /* maximum bytes inflight */
	uint64_t vr_bytes_inflight; /* current bytes inflight */

	/* Per-rebuild pass statistics for calculating bandwidth */
	uint64_t vr_pass_start_time;
	uint64_t vr_pass_bytes_scanned;
	uint64_t vr_pass_bytes_issued;

	/* On-disk state updated by vdev_rebuild_zap_update_sync() */
	vdev_rebuild_phys_t vr_rebuild_phys;
	} vdev_rebuild_t;

	boolean_t vdev_rebuild_active(vdev_t *);

	int vdev_rebuild_load(vdev_t *);
	void vdev_rebuild(vdev_t *);
	void vdev_rebuild_stop_wait(vdev_t *);
	void vdev_rebuild_stop_all(spa_t *);
	void vdev_rebuild_restart(spa_t *);
	void vdev_rebuild_clear_sync(void , dmu_tx_t );
	int vdev_rebuild_get_stats(vdev_t , vdev_rebuild_stat_t );

	#ifdef __cplusplus
	}
	#endif

	#endif /* _SYS_VDEV_REBUILD_H */
	diff --git a/sys/contrib/openzfs/include/sys/zfs_context.h b/sys/contrib/openzfs/include/sys/zfs_context.h
	index 6cdcc6d30966..3fb390c3f6e3 100644
	--- a/sys/contrib/openzfs/include/sys/zfs_context.h
	+++ b/sys/contrib/openzfs/include/sys/zfs_context.h
	@@ -1,778 +1,778 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright 2011 Nexenta Systems, Inc. All rights reserved.
	* Copyright (c) 2012, 2018 by Delphix. All rights reserved.
	* Copyright (c) 2012, Joyent, Inc. All rights reserved.
	*/

	#ifndef _SYS_ZFS_CONTEXT_H
	#define _SYS_ZFS_CONTEXT_H

	#ifdef __cplusplus
	extern "C" {
	#endif

	/*
	* This code compiles in three different contexts. When __KERNEL__ is defined,
	* the code uses "unix-like" kernel interfaces. When _STANDALONE is defined, the
	* code is running in a reduced capacity environment of the boot loader which is
	* generally a subset of both POSIX and kernel interfaces (with a few unique
	* interfaces too). When neither are defined, it's in a userland POSIX or
	* similar environment.
	*/
	#if defined(__KERNEL__) \|\| defined(_STANDALONE)
	#include <sys/note.h>
	#include <sys/types.h>
	#include <sys/atomic.h>
	#include <sys/sysmacros.h>
	#include <sys/vmsystm.h>
	#include <sys/condvar.h>
	#include <sys/cmn_err.h>
	#include <sys/kmem.h>
	#include <sys/kmem_cache.h>
	#include <sys/vmem.h>
	#include <sys/taskq.h>
	#include <sys/param.h>
	#include <sys/disp.h>
	#include <sys/debug.h>
	#include <sys/random.h>
	#include <sys/strings.h>
	#include <sys/byteorder.h>
	#include <sys/list.h>
	#include <sys/time.h>
	#include <sys/zone.h>
	#include <sys/kstat.h>
	#include <sys/zfs_debug.h>
	#include <sys/sysevent.h>
	#include <sys/sysevent/eventdefs.h>
	#include <sys/zfs_delay.h>
	#include <sys/sunddi.h>
	#include <sys/ctype.h>
	#include <sys/disp.h>
	#include <sys/trace.h>
	#include <sys/procfs_list.h>
	#include <sys/mod.h>
	#include <sys/uio_impl.h>
	#include <sys/zfs_context_os.h>
	#else /* _KERNEL \|\| _STANDALONE */

	#define _SYS_MUTEX_H
	#define _SYS_RWLOCK_H
	#define _SYS_CONDVAR_H
	#define _SYS_VNODE_H
	#define _SYS_VFS_H
	#define _SYS_SUNDDI_H
	#define _SYS_CALLB_H

	#include <stdio.h>
	#include <stdlib.h>
	#include <stddef.h>
	#include <stdarg.h>
	#include <fcntl.h>
	#include <unistd.h>
	#include <errno.h>
	#include <string.h>
	#include <strings.h>
	#include <pthread.h>
	#include <setjmp.h>
	#include <assert.h>
	#include <umem.h>
	#include <limits.h>
	#include <atomic.h>
	#include <dirent.h>
	#include <time.h>
	#include <ctype.h>
	#include <signal.h>
	#include <sys/mman.h>
	#include <sys/note.h>
	#include <sys/types.h>
	#include <sys/cred.h>
	#include <sys/sysmacros.h>
	#include <sys/resource.h>
	#include <sys/byteorder.h>
	#include <sys/list.h>
	#include <sys/mod.h>
	#include <sys/uio.h>
	#include <sys/zfs_debug.h>
	#include <sys/kstat.h>
	#include <sys/u8_textprep.h>
	#include <sys/sysevent.h>
	#include <sys/sysevent/eventdefs.h>
	#include <sys/sunddi.h>
	#include <sys/debug.h>
	#include <sys/utsname.h>
	#include <sys/trace_zfs.h>

	#include <sys/zfs_context_os.h>

	/*
	* Stack
	*/

	#define noinline __attribute__((noinline))
	#define likely(x) __builtin_expect((x), 1)
	#define unlikely(x) __builtin_expect((x), 0)

	/*
	* Debugging
	*/

	/*
	* Note that we are not using the debugging levels.
	*/

	#define CE_CONT 0 /* continuation */
	#define CE_NOTE 1 /* notice */
	#define CE_WARN 2 /* warning */
	#define CE_PANIC 3 /* panic */
	#define CE_IGNORE 4 /* print nothing */

	/*
	* ZFS debugging
	*/

	extern void dprintf_setup(int argc, char *argv);

	extern void cmn_err(int, const char *, ...);
	extern void vcmn_err(int, const char *, va_list);
	extern void panic(const char *, ...) __NORETURN;
	extern void vpanic(const char *, va_list) __NORETURN;

	#define fm_panic panic

	extern int aok;

	/*
	* DTrace SDT probes have different signatures in userland than they do in
	* the kernel. If they're being used in kernel code, re-define them out of
	* existence for their counterparts in libzpool.
	*
	* Here's an example of how to use the set-error probes in userland:
	* zfs$target:::set-error /arg0 == EBUSY/ {stack();}
	*
	* Here's an example of how to use DTRACE_PROBE probes in userland:
	* If there is a probe declared as follows:
	* DTRACE_PROBE2(zfs__probe_name, uint64_t, blkid, dnode_t *, dn);
	* Then you can use it as follows:
	* zfs$target:::probe2 /copyinstr(arg0) == "zfs__probe_name"/
	* {printf("%u %p\n", arg1, arg2);}
	*/

	#ifdef DTRACE_PROBE
	#undef DTRACE_PROBE
	#endif /* DTRACE_PROBE */
	#define DTRACE_PROBE(a)

	#ifdef DTRACE_PROBE1
	#undef DTRACE_PROBE1
	#endif /* DTRACE_PROBE1 */
	#define DTRACE_PROBE1(a, b, c)

	#ifdef DTRACE_PROBE2
	#undef DTRACE_PROBE2
	#endif /* DTRACE_PROBE2 */
	#define DTRACE_PROBE2(a, b, c, d, e)

	#ifdef DTRACE_PROBE3
	#undef DTRACE_PROBE3
	#endif /* DTRACE_PROBE3 */
	#define DTRACE_PROBE3(a, b, c, d, e, f, g)

	#ifdef DTRACE_PROBE4
	#undef DTRACE_PROBE4
	#endif /* DTRACE_PROBE4 */
	#define DTRACE_PROBE4(a, b, c, d, e, f, g, h, i)

	/*
	* Tunables.
	*/
	typedef struct zfs_kernel_param {
	const char name; / unused stub */
	} zfs_kernel_param_t;

	#define ZFS_MODULE_PARAM(scope_prefix, name_prefix, name, type, perm, desc)
	#define ZFS_MODULE_PARAM_ARGS void
	#define ZFS_MODULE_PARAM_CALL(scope_prefix, name_prefix, name, setfunc, \
	getfunc, perm, desc)

	/*
	* Threads.
	*/
	typedef pthread_t kthread_t;

	#define TS_RUN 0x00000002
	#define TS_JOINABLE 0x00000004

	#define curthread ((void *)(uintptr_t)pthread_self())
	#define kpreempt(x) yield()
	#define getcomm() "unknown"

	#define thread_create_named(name, stk, stksize, func, arg, len, \
	pp, state, pri) \
	zk_thread_create(func, arg, stksize, state)
	#define thread_create(stk, stksize, func, arg, len, pp, state, pri) \
	zk_thread_create(func, arg, stksize, state)
	#define thread_exit() pthread_exit(NULL)
	#define thread_join(t) pthread_join((pthread_t)(t), NULL)

	#define newproc(f, a, cid, pri, ctp, pid) (ENOSYS)

	/* in libzpool, p0 exists only to have its address taken */
	typedef struct proc {
	uintptr_t this_is_never_used_dont_dereference_it;
	} proc_t;

	extern struct proc p0;
	#define curproc (&p0)

	#define PS_NONE -1

	extern kthread_t zk_thread_create(void (func)(void ), void arg,
	size_t stksize, int state);

	#define issig(why) (FALSE)
	#define ISSIG(thr, why) (FALSE)

	#define kpreempt_disable() ((void)0)
	#define kpreempt_enable() ((void)0)
	#define cond_resched() sched_yield()

	/*
	* Mutexes
	*/
	typedef struct kmutex {
	pthread_mutex_t m_lock;
	pthread_t m_owner;
	} kmutex_t;

	#define MUTEX_DEFAULT 0
	#define MUTEX_NOLOCKDEP MUTEX_DEFAULT
	#define MUTEX_HELD(mp) pthread_equal((mp)->m_owner, pthread_self())
	#define MUTEX_NOT_HELD(mp) !MUTEX_HELD(mp)

	extern void mutex_init(kmutex_t mp, char name, int type, void *cookie);
	extern void mutex_destroy(kmutex_t *mp);
	extern void mutex_enter(kmutex_t *mp);
	extern void mutex_exit(kmutex_t *mp);
	extern int mutex_tryenter(kmutex_t *mp);

	#define NESTED_SINGLE 1
	#define mutex_enter_nested(mp, class) mutex_enter(mp)
	/*
	* RW locks
	*/
	typedef struct krwlock {
	pthread_rwlock_t rw_lock;
	pthread_t rw_owner;
	uint_t rw_readers;
	} krwlock_t;

	typedef int krw_t;

	#define RW_READER 0
	#define RW_WRITER 1
	#define RW_DEFAULT RW_READER
	#define RW_NOLOCKDEP RW_READER

	#define RW_READ_HELD(rw) ((rw)->rw_readers > 0)
	#define RW_WRITE_HELD(rw) pthread_equal((rw)->rw_owner, pthread_self())
	#define RW_LOCK_HELD(rw) (RW_READ_HELD(rw) \|\| RW_WRITE_HELD(rw))

	extern void rw_init(krwlock_t rwlp, char name, int type, void *arg);
	extern void rw_destroy(krwlock_t *rwlp);
	extern void rw_enter(krwlock_t *rwlp, krw_t rw);
	extern int rw_tryenter(krwlock_t *rwlp, krw_t rw);
	extern int rw_tryupgrade(krwlock_t *rwlp);
	extern void rw_exit(krwlock_t *rwlp);
	#define rw_downgrade(rwlp) do { } while (0)

	/*
	* Credentials
	*/
	extern uid_t crgetuid(cred_t *cr);
	extern uid_t crgetruid(cred_t *cr);
	extern gid_t crgetgid(cred_t *cr);
	extern int crgetngroups(cred_t *cr);
	extern gid_t crgetgroups(cred_t cr);

	/*
	* Condition variables
	*/
	typedef pthread_cond_t kcondvar_t;

	#define CV_DEFAULT 0
	#define CALLOUT_FLAG_ABSOLUTE 0x2

	extern void cv_init(kcondvar_t cv, char name, int type, void *arg);
	extern void cv_destroy(kcondvar_t *cv);
	extern void cv_wait(kcondvar_t cv, kmutex_t mp);
	extern int cv_wait_sig(kcondvar_t cv, kmutex_t mp);
	extern int cv_timedwait(kcondvar_t cv, kmutex_t mp, clock_t abstime);
	extern int cv_timedwait_hires(kcondvar_t cvp, kmutex_t mp, hrtime_t tim,
	hrtime_t res, int flag);
	extern void cv_signal(kcondvar_t *cv);
	extern void cv_broadcast(kcondvar_t *cv);

	#define cv_timedwait_io(cv, mp, at) cv_timedwait(cv, mp, at)
	#define cv_timedwait_idle(cv, mp, at) cv_timedwait(cv, mp, at)
	#define cv_timedwait_sig(cv, mp, at) cv_timedwait(cv, mp, at)
	#define cv_wait_io(cv, mp) cv_wait(cv, mp)
	#define cv_wait_idle(cv, mp) cv_wait(cv, mp)
	#define cv_wait_io_sig(cv, mp) cv_wait_sig(cv, mp)
	#define cv_timedwait_sig_hires(cv, mp, t, r, f) \
	cv_timedwait_hires(cv, mp, t, r, f)
	#define cv_timedwait_idle_hires(cv, mp, t, r, f) \
	cv_timedwait_hires(cv, mp, t, r, f)

	/*
	* Thread-specific data
	*/
	#define tsd_get(k) pthread_getspecific(k)
	#define tsd_set(k, v) pthread_setspecific(k, v)
	#define tsd_create(kp, d) pthread_key_create((pthread_key_t *)kp, d)
	#define tsd_destroy(kp) /* nothing */
	#ifdef __FreeBSD__
	typedef off_t loff_t;
	#endif

	/*
	* kstat creation, installation and deletion
	*/
	extern kstat_t kstat_create(const char , int,
	const char , const char , uchar_t, ulong_t, uchar_t);
	extern void kstat_install(kstat_t *);
	extern void kstat_delete(kstat_t *);
	extern void kstat_waitq_enter(kstat_io_t *);
	extern void kstat_waitq_exit(kstat_io_t *);
	extern void kstat_runq_enter(kstat_io_t *);
	extern void kstat_runq_exit(kstat_io_t *);
	extern void kstat_waitq_to_runq(kstat_io_t *);
	extern void kstat_runq_back_to_waitq(kstat_io_t *);
	extern void kstat_set_raw_ops(kstat_t *ksp,
	int (headers)(char buf, size_t size),
	int (data)(char buf, size_t size, void *data),
	void (addr)(kstat_t *ksp, loff_t index));

	/*
	* procfs list manipulation
	*/

	typedef struct procfs_list {
	void *pl_private;
	kmutex_t pl_lock;
	list_t pl_list;
	uint64_t pl_next_id;
	size_t pl_node_offset;
	} procfs_list_t;

	#ifndef __cplusplus
	struct seq_file { };
	void seq_printf(struct seq_file m, const char fmt, ...);

	typedef struct procfs_list_node {
	list_node_t pln_link;
	uint64_t pln_id;
	} procfs_list_node_t;

	void procfs_list_install(const char *module,
	const char *submodule,
	const char *name,
	mode_t mode,
	procfs_list_t *procfs_list,
	int (show)(struct seq_file f, void *p),
	int (show_header)(struct seq_file f),
	int (clear)(procfs_list_t procfs_list),
	size_t procfs_list_node_off);
	void procfs_list_uninstall(procfs_list_t *procfs_list);
	void procfs_list_destroy(procfs_list_t *procfs_list);
	void procfs_list_add(procfs_list_t procfs_list, void p);
	#endif

	/*
	* Kernel memory
	*/
	#define KM_SLEEP UMEM_NOFAIL
	#define KM_PUSHPAGE KM_SLEEP
	#define KM_NOSLEEP UMEM_DEFAULT
	#define KM_NORMALPRI 0 /* not needed with UMEM_DEFAULT */
	#define KMC_NODEBUG UMC_NODEBUG
	#define KMC_KVMEM 0x0
	#define kmem_alloc(_s, _f) umem_alloc(_s, _f)
	#define kmem_zalloc(_s, _f) umem_zalloc(_s, _f)
	#define kmem_free(_b, _s) umem_free(_b, _s)
	#define vmem_alloc(_s, _f) kmem_alloc(_s, _f)
	#define vmem_zalloc(_s, _f) kmem_zalloc(_s, _f)
	#define vmem_free(_b, _s) kmem_free(_b, _s)
	#define kmem_cache_create(_a, _b, _c, _d, _e, _f, _g, _h, _i) \
	umem_cache_create(_a, _b, _c, _d, _e, _f, _g, _h, _i)
	#define kmem_cache_destroy(_c) umem_cache_destroy(_c)
	#define kmem_cache_alloc(_c, _f) umem_cache_alloc(_c, _f)
	#define kmem_cache_free(_c, _b) umem_cache_free(_c, _b)
	#define kmem_debugging() 0
	#define kmem_cache_reap_now(_c) umem_cache_reap_now(_c);
	#define kmem_cache_set_move(_c, _cb) /* nothing */
	#define POINTER_INVALIDATE(_pp) /* nothing */
	#define POINTER_IS_VALID(_p) 0

	typedef umem_cache_t kmem_cache_t;

	typedef enum kmem_cbrc {
	KMEM_CBRC_YES,
	KMEM_CBRC_NO,
	KMEM_CBRC_LATER,
	KMEM_CBRC_DONT_NEED,
	KMEM_CBRC_DONT_KNOW
	} kmem_cbrc_t;

	/*
	* Task queues
	*/

	#define TASKQ_NAMELEN 31

	typedef uintptr_t taskqid_t;
	typedef void (task_func_t)(void *);

	typedef struct taskq_ent {
	struct taskq_ent *tqent_next;
	struct taskq_ent *tqent_prev;
	task_func_t *tqent_func;
	void *tqent_arg;
	uintptr_t tqent_flags;
	} taskq_ent_t;

	typedef struct taskq {
	char tq_name[TASKQ_NAMELEN + 1];
	kmutex_t tq_lock;
	krwlock_t tq_threadlock;
	kcondvar_t tq_dispatch_cv;
	kcondvar_t tq_wait_cv;
	kthread_t **tq_threadlist;
	int tq_flags;
	int tq_active;
	int tq_nthreads;
	int tq_nalloc;
	int tq_minalloc;
	int tq_maxalloc;
	kcondvar_t tq_maxalloc_cv;
	int tq_maxalloc_wait;
	taskq_ent_t *tq_freelist;
	taskq_ent_t tq_task;
	} taskq_t;

	#define TQENT_FLAG_PREALLOC 0x1 /* taskq_dispatch_ent used */

	#define TASKQ_PREPOPULATE 0x0001
	#define TASKQ_CPR_SAFE 0x0002 /* Use CPR safe protocol */
	#define TASKQ_DYNAMIC 0x0004 /* Use dynamic thread scheduling */
	#define TASKQ_THREADS_CPU_PCT 0x0008 /* Scale # threads by # cpus */
	#define TASKQ_DC_BATCH 0x0010 /* Mark threads as batch */

	#define TQ_SLEEP KM_SLEEP /* Can block for memory */
	#define TQ_NOSLEEP KM_NOSLEEP /* cannot block for memory; may fail */
	#define TQ_NOQUEUE 0x02 /* Do not enqueue if can't dispatch */
	#define TQ_FRONT 0x08 /* Queue in front */

	#define TASKQID_INVALID ((taskqid_t)0)

	extern taskq_t *system_taskq;
	extern taskq_t *system_delay_taskq;

	extern taskq_t taskq_create(const char , int, pri_t, int, int, uint_t);
	#define taskq_create_proc(a, b, c, d, e, p, f) \
	(taskq_create(a, b, c, d, e, f))
	#define taskq_create_sysdc(a, b, d, e, p, dc, f) \
	(taskq_create(a, b, maxclsyspri, d, e, f))
	extern taskqid_t taskq_dispatch(taskq_t , task_func_t, void , uint_t);
	extern taskqid_t taskq_dispatch_delay(taskq_t , task_func_t, void , uint_t,
	clock_t);
	extern void taskq_dispatch_ent(taskq_t , task_func_t, void , uint_t,
	taskq_ent_t *);
	extern int taskq_empty_ent(taskq_ent_t *);
	extern void taskq_init_ent(taskq_ent_t *);
	extern void taskq_destroy(taskq_t *);
	extern void taskq_wait(taskq_t *);
	extern void taskq_wait_id(taskq_t *, taskqid_t);
	extern void taskq_wait_outstanding(taskq_t *, taskqid_t);
	extern int taskq_member(taskq_t , kthread_t );
	extern taskq_t *taskq_of_curthread(void);
	extern int taskq_cancel_id(taskq_t *, taskqid_t);
	extern void system_taskq_init(void);
	extern void system_taskq_fini(void);

	#define XVA_MAPSIZE 3
	#define XVA_MAGIC 0x78766174

	extern char *vn_dumpdir;
	#define AV_SCANSTAMP_SZ 32 /* length of anti-virus scanstamp */

	typedef struct xoptattr {
	inode_timespec_t xoa_createtime; /* Create time of file */
	uint8_t xoa_archive;
	uint8_t xoa_system;
	uint8_t xoa_readonly;
	uint8_t xoa_hidden;
	uint8_t xoa_nounlink;
	uint8_t xoa_immutable;
	uint8_t xoa_appendonly;
	uint8_t xoa_nodump;
	uint8_t xoa_settable;
	uint8_t xoa_opaque;
	uint8_t xoa_av_quarantined;
	uint8_t xoa_av_modified;
	uint8_t xoa_av_scanstamp[AV_SCANSTAMP_SZ];
	uint8_t xoa_reparse;
	uint8_t xoa_offline;
	uint8_t xoa_sparse;
	} xoptattr_t;

	typedef struct vattr {
	uint_t va_mask; /* bit-mask of attributes */
	u_offset_t va_size; /* file size in bytes */
	} vattr_t;


	typedef struct xvattr {
	vattr_t xva_vattr; /* Embedded vattr structure */
	uint32_t xva_magic; /* Magic Number */
	uint32_t xva_mapsize; /* Size of attr bitmap (32-bit words) */
	uint32_t xva_rtnattrmapp; / Ptr to xva_rtnattrmap[] */
	uint32_t xva_reqattrmap[XVA_MAPSIZE]; /* Requested attrs */
	uint32_t xva_rtnattrmap[XVA_MAPSIZE]; /* Returned attrs */
	xoptattr_t xva_xoptattrs; /* Optional attributes */
	} xvattr_t;

	typedef struct vsecattr {
	uint_t vsa_mask; /* See below */
	int vsa_aclcnt; /* ACL entry count */
	void vsa_aclentp; / pointer to ACL entries */
	int vsa_dfaclcnt; /* default ACL entry count */
	void vsa_dfaclentp; / pointer to default ACL entries */
	size_t vsa_aclentsz; /* ACE size in bytes of vsa_aclentp */
	} vsecattr_t;

	#define AT_MODE 0x00002
	#define AT_UID 0x00004
	#define AT_GID 0x00008
	#define AT_FSID 0x00010
	#define AT_NODEID 0x00020
	#define AT_NLINK 0x00040
	#define AT_SIZE 0x00080
	#define AT_ATIME 0x00100
	#define AT_MTIME 0x00200
	#define AT_CTIME 0x00400
	#define AT_RDEV 0x00800
	#define AT_BLKSIZE 0x01000
	#define AT_NBLOCKS 0x02000
	#define AT_SEQ 0x08000
	#define AT_XVATTR 0x10000

	#define CRCREAT 0

	#define F_FREESP 11
	#define FIGNORECASE 0x80000 /* request case-insensitive lookups */

	/*
	* Random stuff
	*/
	#define ddi_get_lbolt() (gethrtime() >> 23)
	#define ddi_get_lbolt64() (gethrtime() >> 23)
	#define hz 119 /* frequency when using gethrtime() >> 23 for lbolt */

	#define ddi_time_before(a, b) (a < b)
	#define ddi_time_after(a, b) ddi_time_before(b, a)
	#define ddi_time_before_eq(a, b) (!ddi_time_after(a, b))
	#define ddi_time_after_eq(a, b) ddi_time_before_eq(b, a)

	#define ddi_time_before64(a, b) (a < b)
	#define ddi_time_after64(a, b) ddi_time_before64(b, a)
	#define ddi_time_before_eq64(a, b) (!ddi_time_after64(a, b))
	#define ddi_time_after_eq64(a, b) ddi_time_before_eq64(b, a)

	extern void delay(clock_t ticks);

	#define SEC_TO_TICK(sec) ((sec) * hz)
	#define MSEC_TO_TICK(msec) (howmany((hrtime_t)(msec) * hz, MILLISEC))
	#define USEC_TO_TICK(usec) (howmany((hrtime_t)(usec) * hz, MICROSEC))
	#define NSEC_TO_TICK(nsec) (howmany((hrtime_t)(nsec) * hz, NANOSEC))

	#define max_ncpus 64
	#define boot_ncpus (sysconf(_SC_NPROCESSORS_ONLN))

	/*
	* Process priorities as defined by setpriority(2) and getpriority(2).
	*/
	#define minclsyspri 19
	#define maxclsyspri -20
	#define defclsyspri 0

	#define CPU_SEQID ((uintptr_t)pthread_self() & (max_ncpus - 1))
	#define CPU_SEQID_UNSTABLE CPU_SEQID

	#define kcred NULL
	#define CRED() NULL

	#define ptob(x) ((x) * PAGESIZE)

	#define NN_DIVISOR_1000 (1U << 0)
	#define NN_NUMBUF_SZ (6)

	extern uint64_t physmem;
	-extern char *random_path;
	-extern char *urandom_path;
	+extern const char *random_path;
	+extern const char *urandom_path;

	extern int highbit64(uint64_t i);
	extern int lowbit64(uint64_t i);
	extern int random_get_bytes(uint8_t *ptr, size_t len);
	extern int random_get_pseudo_bytes(uint8_t *ptr, size_t len);

	extern void kernel_init(int mode);
	extern void kernel_fini(void);
	extern void random_init(void);
	extern void random_fini(void);

	struct spa;
	extern void show_pool_stats(struct spa *);
	extern int set_global_var(char const *arg);

	typedef struct callb_cpr {
	kmutex_t *cc_lockp;
	} callb_cpr_t;

	#define CALLB_CPR_INIT(cp, lockp, func, name) { \
	(cp)->cc_lockp = lockp; \
	}

	#define CALLB_CPR_SAFE_BEGIN(cp) { \
	ASSERT(MUTEX_HELD((cp)->cc_lockp)); \
	}

	#define CALLB_CPR_SAFE_END(cp, lockp) { \
	ASSERT(MUTEX_HELD((cp)->cc_lockp)); \
	}

	#define CALLB_CPR_EXIT(cp) { \
	ASSERT(MUTEX_HELD((cp)->cc_lockp)); \
	mutex_exit((cp)->cc_lockp); \
	}

	#define zone_dataset_visible(x, y) (1)
	#define INGLOBALZONE(z) (1)
	extern uint32_t zone_get_hostid(void *zonep);

	extern char kmem_vasprintf(const char fmt, va_list adx);
	extern char kmem_asprintf(const char fmt, ...);
	#define kmem_strfree(str) kmem_free((str), strlen(str) + 1)
	#define kmem_strdup(s) strdup(s)

	/*
	* Hostname information
	*/
	extern char hw_serial[]; /* for userland-emulated hostid access */
	extern int ddi_strtoul(const char str, char *nptr, int base,
	unsigned long *result);

	extern int ddi_strtoull(const char str, char *nptr, int base,
	u_longlong_t *result);

	typedef struct utsname utsname_t;
	extern utsname_t *utsname(void);

	/* ZFS Boot Related stuff. */

	struct _buf {
	intptr_t _fd;
	};

	struct bootstat {
	uint64_t st_size;
	};

	typedef struct ace_object {
	uid_t a_who;
	uint32_t a_access_mask;
	uint16_t a_flags;
	uint16_t a_type;
	uint8_t a_obj_type[16];
	uint8_t a_inherit_obj_type[16];
	} ace_object_t;


	#define ACE_ACCESS_ALLOWED_OBJECT_ACE_TYPE 0x05
	#define ACE_ACCESS_DENIED_OBJECT_ACE_TYPE 0x06
	#define ACE_SYSTEM_AUDIT_OBJECT_ACE_TYPE 0x07
	#define ACE_SYSTEM_ALARM_OBJECT_ACE_TYPE 0x08

	extern int zfs_secpolicy_snapshot_perms(const char name, cred_t cr);
	extern int zfs_secpolicy_rename_perms(const char from, const char to,
	cred_t *cr);
	extern int zfs_secpolicy_destroy_perms(const char name, cred_t cr);
	extern int secpolicy_zfs(const cred_t *cr);
	extern int secpolicy_zfs_proc(const cred_t cr, proc_t proc);
	extern zoneid_t getzoneid(void);

	/* SID stuff */
	typedef struct ksiddomain {
	uint_t kd_ref;
	uint_t kd_len;
	char *kd_name;
	} ksiddomain_t;

	ksiddomain_t ksid_lookupdomain(const char );
	void ksiddomain_rele(ksiddomain_t *);

	#define DDI_SLEEP KM_SLEEP
	#define ddi_log_sysevent(_a, _b, _c, _d, _e, _f, _g) \
	sysevent_post_event(_c, _d, _b, "libzpool", _e, _f)

	#define zfs_sleep_until(wakeup) \
	do { \
	hrtime_t delta = wakeup - gethrtime(); \
	struct timespec ts; \
	ts.tv_sec = delta / NANOSEC; \
	ts.tv_nsec = delta % NANOSEC; \
	(void) nanosleep(&ts, NULL); \
	} while (0)

	typedef int fstrans_cookie_t;

	extern fstrans_cookie_t spl_fstrans_mark(void);
	extern void spl_fstrans_unmark(fstrans_cookie_t);
	extern int __spl_pf_fstrans_check(void);
	extern int kmem_cache_reap_active(void);

	#define ____cacheline_aligned

	/*
	* Kernel modules
	*/
	#define __init
	#define __exit

	#endif /* _KERNEL \|\| _STANDALONE */

	#ifdef __cplusplus
	};
	#endif

	#endif /* _SYS_ZFS_CONTEXT_H */
	diff --git a/sys/contrib/openzfs/lib/libshare/os/freebsd/nfs.c b/sys/contrib/openzfs/lib/libshare/os/freebsd/nfs.c
	index 5951b9eafa2b..56df3e66643c 100644
	--- a/sys/contrib/openzfs/lib/libshare/os/freebsd/nfs.c
	+++ b/sys/contrib/openzfs/lib/libshare/os/freebsd/nfs.c
	@@ -1,458 +1,459 @@
	/*
	* Copyright (c) 2007 Pawel Jakub Dawidek <pjd@FreeBSD.org>
	* 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.
	*
	* Copyright (c) 2020 by Delphix. All rights reserved.
	*/

	#include <sys/cdefs.h>
	__FBSDID("$FreeBSD$");

	#include <sys/param.h>
	#include <sys/vfs.h>

	#include <assert.h>
	#include <errno.h>
	#include <fcntl.h>
	#include <libutil.h>
	#include <signal.h>
	#include <stdio.h>
	#include <string.h>
	#include <unistd.h>
	#include <libintl.h>

	#include "libzfs_impl.h"
	#include "libshare_impl.h"
	#include "nfs.h"

	#define _PATH_MOUNTDPID "/var/run/mountd.pid"
	#define FILE_HEADER "# !!! DO NOT EDIT THIS FILE MANUALLY !!!\n\n"
	#define OPTSSIZE 1024
	#define MAXLINESIZE (PATH_MAX + OPTSSIZE)
	#define ZFS_EXPORTS_FILE "/etc/zfs/exports"
	#define ZFS_EXPORTS_LOCK ZFS_EXPORTS_FILE".lock"

	static sa_fstype_t *nfs_fstype;

	static int nfs_lock_fd = -1;

	/*
	* The nfs_exports_[lock\|unlock] is used to guard against conconcurrent
	* updates to the exports file. Each protocol is responsible for
	* providing the necessary locking to ensure consistency.
	*/
	static int
	nfs_exports_lock(void)
	{
	+ int err;
	+
	nfs_lock_fd = open(ZFS_EXPORTS_LOCK,
	- O_RDWR \| O_CREAT, 0600);
	+ O_RDWR \| O_CREAT \| O_CLOEXEC, 0600);
	if (nfs_lock_fd == -1) {
	+ err = errno;
	fprintf(stderr, "failed to lock %s: %s\n",
	- ZFS_EXPORTS_LOCK, strerror(errno));
	- return (errno);
	+ ZFS_EXPORTS_LOCK, strerror(err));
	+ return (err);
	}
	if (flock(nfs_lock_fd, LOCK_EX) != 0) {
	+ err = errno;
	fprintf(stderr, "failed to lock %s: %s\n",
	- ZFS_EXPORTS_LOCK, strerror(errno));
	- return (errno);
	+ ZFS_EXPORTS_LOCK, strerror(err));
	+ (void) close(nfs_lock_fd);
	+ return (err);
	}
	return (0);
	}

	static void
	nfs_exports_unlock(void)
	{
	verify(nfs_lock_fd > 0);

	if (flock(nfs_lock_fd, LOCK_UN) != 0) {
	fprintf(stderr, "failed to unlock %s: %s\n",
	ZFS_EXPORTS_LOCK, strerror(errno));
	}
	close(nfs_lock_fd);
	nfs_lock_fd = -1;
	}

	/*
	* Read one line from a file. Skip comments, empty lines and a line with a
	* mountpoint specified in the 'skip' argument.
	*
	* NOTE: This function returns a static buffer and thus is not thread-safe.
	*/
	static char *
	zgetline(FILE fd, const char skip)
	{
	static char line[MAXLINESIZE];
	size_t len, skiplen = 0;
	char *s, last;

	if (skip != NULL)
	skiplen = strlen(skip);
	for (;;) {
	s = fgets(line, sizeof (line), fd);
	if (s == NULL)
	return (NULL);
	/* Skip empty lines and comments. */
	if (line[0] == '\n' \|\| line[0] == '#')
	continue;
	len = strlen(line);
	if (line[len - 1] == '\n')
	line[len - 1] = '\0';
	last = line[skiplen];
	/* Skip the given mountpoint. */
	if (skip != NULL && strncmp(skip, line, skiplen) == 0 &&
	(last == '\t' \|\| last == ' ' \|\| last == '\0')) {
	continue;
	}
	break;
	}
	return (line);
	}

	/*
	* This function translate options to a format acceptable by exports(5), eg.
	*
	* -ro -network=192.168.0.0 -mask=255.255.255.0 -maproot=0 \
	* zfs.freebsd.org 69.147.83.54
	*
	* Accepted input formats:
	*
	* ro,network=192.168.0.0,mask=255.255.255.0,maproot=0,zfs.freebsd.org
	* ro network=192.168.0.0 mask=255.255.255.0 maproot=0 zfs.freebsd.org
	* -ro,-network=192.168.0.0,-mask=255.255.255.0,-maproot=0,zfs.freebsd.org
	* -ro -network=192.168.0.0 -mask=255.255.255.0 -maproot=0 \
	* zfs.freebsd.org
	*
	* Recognized keywords:
	*
	* ro, maproot, mapall, mask, network, sec, alldirs, public, webnfs,
	* index, quiet
	*
	* NOTE: This function returns a static buffer and thus is not thread-safe.
	*/
	static char *
	translate_opts(const char *shareopts)
	{
	static const char *known_opts[] = { "ro", "maproot", "mapall", "mask",
	"network", "sec", "alldirs", "public", "webnfs", "index", "quiet",
	NULL };
	static char newopts[OPTSSIZE];
	char oldopts[OPTSSIZE];
	char o, s = NULL;
	unsigned int i;
	size_t len;

	strlcpy(oldopts, shareopts, sizeof (oldopts));
	newopts[0] = '\0';
	s = oldopts;
	while ((o = strsep(&s, "-, ")) != NULL) {
	if (o[0] == '\0')
	continue;
	for (i = 0; known_opts[i] != NULL; i++) {
	len = strlen(known_opts[i]);
	if (strncmp(known_opts[i], o, len) == 0 &&
	(o[len] == '\0' \|\| o[len] == '=')) {
	strlcat(newopts, "-", sizeof (newopts));
	break;
	}
	}
	strlcat(newopts, o, sizeof (newopts));
	strlcat(newopts, " ", sizeof (newopts));
	}
	return (newopts);
	}

	static char *
	nfs_init_tmpfile(void)
	{
	char *tmpfile = NULL;

	if (asprintf(&tmpfile, "%s%s", ZFS_EXPORTS_FILE, ".XXXXXXXX") == -1) {
	fprintf(stderr, "Unable to allocate buffer for temporary "
	"file name\n");
	return (NULL);
	}

	int fd = mkstemp(tmpfile);
	if (fd == -1) {
	fprintf(stderr, "Unable to create temporary file: %s",
	strerror(errno));
	free(tmpfile);
	return (NULL);
	}
	close(fd);
	return (tmpfile);
	}

	static int
	nfs_fini_tmpfile(char *tmpfile)
	{
	if (rename(tmpfile, ZFS_EXPORTS_FILE) == -1) {
	fprintf(stderr, "Unable to rename %s: %s\n", tmpfile,
	strerror(errno));
	unlink(tmpfile);
	free(tmpfile);
	return (SA_SYSTEM_ERR);
	}
	free(tmpfile);
	return (SA_OK);
	}

	/*
	* This function copies all entries from the exports file to "filename",
	* omitting any entries for the specified mountpoint.
	*/
	static int
	nfs_copy_entries(char filename, const char mountpoint)
	{
	int error = SA_OK;
	char *line;

	- FILE *oldfp = fopen(ZFS_EXPORTS_FILE, "r");
	- FILE *newfp = fopen(filename, "w+");
	+ FILE *oldfp = fopen(ZFS_EXPORTS_FILE, "re");
	+ FILE *newfp = fopen(filename, "w+e");
	if (newfp == NULL) {
	fprintf(stderr, "failed to open %s file: %s", filename,
	strerror(errno));
	fclose(oldfp);
	return (SA_SYSTEM_ERR);
	}
	fputs(FILE_HEADER, newfp);

	/*
	* The ZFS_EXPORTS_FILE may not exist yet. If that's the
	* case then just write out the new file.
	*/
	if (oldfp != NULL) {
	while ((line = zgetline(oldfp, mountpoint)) != NULL)
	fprintf(newfp, "%s\n", line);
	if (ferror(oldfp) != 0) {
	error = ferror(oldfp);
	}
	if (fclose(oldfp) != 0) {
	fprintf(stderr, "Unable to close file %s: %s\n",
	filename, strerror(errno));
	error = error != 0 ? error : SA_SYSTEM_ERR;
	}
	}

	if (error == 0 && ferror(newfp) != 0) {
	error = ferror(newfp);
	}

	if (fclose(newfp) != 0) {
	fprintf(stderr, "Unable to close file %s: %s\n",
	filename, strerror(errno));
	error = error != 0 ? error : SA_SYSTEM_ERR;
	}
	return (error);
	}

	static int
	nfs_enable_share(sa_share_impl_t impl_share)
	{
	char *filename = NULL;
	int error;

	if ((filename = nfs_init_tmpfile()) == NULL)
	return (SA_SYSTEM_ERR);

	error = nfs_exports_lock();
	if (error != 0) {
	unlink(filename);
	free(filename);
	return (error);
	}

	error = nfs_copy_entries(filename, impl_share->sa_mountpoint);
	if (error != SA_OK) {
	unlink(filename);
	free(filename);
	nfs_exports_unlock();
	return (error);
	}

	- FILE *fp = fopen(filename, "a+");
	+ FILE *fp = fopen(filename, "a+e");
	if (fp == NULL) {
	fprintf(stderr, "failed to open %s file: %s", filename,
	strerror(errno));
	unlink(filename);
	free(filename);
	nfs_exports_unlock();
	return (SA_SYSTEM_ERR);
	}
	char *shareopts = FSINFO(impl_share, nfs_fstype)->shareopts;
	if (strcmp(shareopts, "on") == 0)
	shareopts = "";

	if (fprintf(fp, "%s\t%s\n", impl_share->sa_mountpoint,
	translate_opts(shareopts)) < 0) {
	fprintf(stderr, "failed to write to %s\n", filename);
	fclose(fp);
	unlink(filename);
	free(filename);
	nfs_exports_unlock();
	return (SA_SYSTEM_ERR);
	}

	if (fclose(fp) != 0) {
	fprintf(stderr, "Unable to close file %s: %s\n",
	filename, strerror(errno));
	unlink(filename);
	free(filename);
	nfs_exports_unlock();
	return (SA_SYSTEM_ERR);
	}
	error = nfs_fini_tmpfile(filename);
	nfs_exports_unlock();
	return (error);
	}

	static int
	nfs_disable_share(sa_share_impl_t impl_share)
	{
	int error;
	char *filename = NULL;

	if ((filename = nfs_init_tmpfile()) == NULL)
	return (SA_SYSTEM_ERR);

	error = nfs_exports_lock();
	if (error != 0) {
	unlink(filename);
	free(filename);
	return (error);
	}

	error = nfs_copy_entries(filename, impl_share->sa_mountpoint);
	if (error != SA_OK) {
	unlink(filename);
	free(filename);
	nfs_exports_unlock();
	return (error);
	}

	error = nfs_fini_tmpfile(filename);
	nfs_exports_unlock();
	return (error);
	}

	-/*
	- * NOTE: This function returns a static buffer and thus is not thread-safe.
	- */
	static boolean_t
	nfs_is_shared(sa_share_impl_t impl_share)
	{
	- static char line[MAXLINESIZE];
	- char *s, last;
	+ char *s, last, line[MAXLINESIZE];
	size_t len;
	char *mntpoint = impl_share->sa_mountpoint;
	size_t mntlen = strlen(mntpoint);

	- FILE *fp = fopen(ZFS_EXPORTS_FILE, "r");
	+ FILE *fp = fopen(ZFS_EXPORTS_FILE, "re");
	if (fp == NULL)
	return (B_FALSE);

	for (;;) {
	s = fgets(line, sizeof (line), fp);
	if (s == NULL)
	return (B_FALSE);
	/* Skip empty lines and comments. */
	if (line[0] == '\n' \|\| line[0] == '#')
	continue;
	len = strlen(line);
	if (line[len - 1] == '\n')
	line[len - 1] = '\0';
	last = line[mntlen];
	/* Skip the given mountpoint. */
	if (strncmp(mntpoint, line, mntlen) == 0 &&
	(last == '\t' \|\| last == ' ' \|\| last == '\0')) {
	fclose(fp);
	return (B_TRUE);
	}
	}
	fclose(fp);
	return (B_FALSE);
	}

	static int
	nfs_validate_shareopts(const char *shareopts)
	{
	return (SA_OK);
	}

	static int
	nfs_update_shareopts(sa_share_impl_t impl_share, const char *shareopts)
	{
	FSINFO(impl_share, nfs_fstype)->shareopts = (char *)shareopts;
	return (SA_OK);
	}

	static void
	nfs_clear_shareopts(sa_share_impl_t impl_share)
	{
	FSINFO(impl_share, nfs_fstype)->shareopts = NULL;
	}

	/*
	* Commit the shares by restarting mountd.
	*/
	static int
	nfs_commit_shares(void)
	{
	struct pidfh *pfh;
	pid_t mountdpid;

	pfh = pidfile_open(_PATH_MOUNTDPID, 0600, &mountdpid);
	if (pfh != NULL) {
	/* Mountd is not running. */
	pidfile_remove(pfh);
	return (SA_OK);
	}
	if (errno != EEXIST) {
	/* Cannot open pidfile for some reason. */
	return (SA_SYSTEM_ERR);
	}
	/* We have mountd(8) PID in mountdpid variable. */
	kill(mountdpid, SIGHUP);
	return (SA_OK);
	}

	static const sa_share_ops_t nfs_shareops = {
	.enable_share = nfs_enable_share,
	.disable_share = nfs_disable_share,
	.is_shared = nfs_is_shared,

	.validate_shareopts = nfs_validate_shareopts,
	.update_shareopts = nfs_update_shareopts,
	.clear_shareopts = nfs_clear_shareopts,
	.commit_shares = nfs_commit_shares,
	};

	/*
	* Initializes the NFS functionality of libshare.
	*/
	void
	libshare_nfs_init(void)
	{
	nfs_fstype = register_fstype("nfs", &nfs_shareops);
	}
	diff --git a/sys/contrib/openzfs/lib/libshare/os/linux/nfs.c b/sys/contrib/openzfs/lib/libshare/os/linux/nfs.c
	index 1efa321b7bc6..a7bcbd13856c 100644
	--- a/sys/contrib/openzfs/lib/libshare/os/linux/nfs.c
	+++ b/sys/contrib/openzfs/lib/libshare/os/linux/nfs.c
	@@ -1,724 +1,729 @@
	/*
	* 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) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2011 Gunnar Beutner
	* Copyright (c) 2012 Cyril Plisko. All rights reserved.
	* Copyright (c) 2019, 2020 by Delphix. All rights reserved.
	*/

	#include <dirent.h>
	#include <stdio.h>
	#include <string.h>
	#include <strings.h>
	#include <errno.h>
	#include <fcntl.h>
	#include <sys/file.h>
	#include <sys/stat.h>
	#include <sys/types.h>
	#include <sys/wait.h>
	#include <unistd.h>
	#include <libzfs.h>
	#include <libshare.h>
	#include "libshare_impl.h"
	#include "nfs.h"

	#define FILE_HEADER "# !!! DO NOT EDIT THIS FILE MANUALLY !!!\n\n"
	#define ZFS_EXPORTS_DIR "/etc/exports.d"
	#define ZFS_EXPORTS_FILE ZFS_EXPORTS_DIR"/zfs.exports"
	#define ZFS_EXPORTS_LOCK ZFS_EXPORTS_FILE".lock"

	static sa_fstype_t *nfs_fstype;

	typedef int (nfs_shareopt_callback_t)(const char opt, const char *value,
	void *cookie);

	typedef int (nfs_host_callback_t)(const char sharepath, const char *filename,
	const char host, const char security, const char access, void cookie);

	static int nfs_lock_fd = -1;

	/*
	* The nfs_exports_[lock\|unlock] is used to guard against conconcurrent
	* updates to the exports file. Each protocol is responsible for
	* providing the necessary locking to ensure consistency.
	*/
	static int
	nfs_exports_lock(void)
	{
	+ int err;
	+
	nfs_lock_fd = open(ZFS_EXPORTS_LOCK,
	- O_RDWR \| O_CREAT, 0600);
	+ O_RDWR \| O_CREAT \| O_CLOEXEC, 0600);
	if (nfs_lock_fd == -1) {
	+ err = errno;
	fprintf(stderr, "failed to lock %s: %s\n",
	- ZFS_EXPORTS_LOCK, strerror(errno));
	- return (errno);
	+ ZFS_EXPORTS_LOCK, strerror(err));
	+ return (err);
	}
	if (flock(nfs_lock_fd, LOCK_EX) != 0) {
	+ err = errno;
	fprintf(stderr, "failed to lock %s: %s\n",
	- ZFS_EXPORTS_LOCK, strerror(errno));
	- return (errno);
	+ ZFS_EXPORTS_LOCK, strerror(err));
	+ (void) close(nfs_lock_fd);
	+ return (err);
	}
	return (0);
	}

	static void
	nfs_exports_unlock(void)
	{
	verify(nfs_lock_fd > 0);

	if (flock(nfs_lock_fd, LOCK_UN) != 0) {
	fprintf(stderr, "failed to unlock %s: %s\n",
	ZFS_EXPORTS_LOCK, strerror(errno));
	}
	close(nfs_lock_fd);
	nfs_lock_fd = -1;
	}

	/*
	* Invokes the specified callback function for each Solaris share option
	* listed in the specified string.
	*/
	static int
	foreach_nfs_shareopt(const char *shareopts,
	nfs_shareopt_callback_t callback, void *cookie)
	{
	char shareopts_dup, opt, cur, value;
	int was_nul, error;

	if (shareopts == NULL)
	return (SA_OK);

	if (strcmp(shareopts, "on") == 0)
	shareopts = "rw,crossmnt";

	shareopts_dup = strdup(shareopts);


	if (shareopts_dup == NULL)
	return (SA_NO_MEMORY);

	opt = shareopts_dup;
	was_nul = 0;

	while (1) {
	cur = opt;

	while (cur != ',' && cur != '\0')
	cur++;

	if (*cur == '\0')
	was_nul = 1;

	*cur = '\0';

	if (cur > opt) {
	value = strchr(opt, '=');

	if (value != NULL) {
	*value = '\0';
	value++;
	}

	error = callback(opt, value, cookie);

	if (error != SA_OK) {
	free(shareopts_dup);
	return (error);
	}
	}

	opt = cur + 1;

	if (was_nul)
	break;
	}

	free(shareopts_dup);

	return (SA_OK);
	}

	typedef struct nfs_host_cookie_s {
	nfs_host_callback_t callback;
	const char *sharepath;
	void *cookie;
	const char *filename;
	const char *security;
	} nfs_host_cookie_t;

	/*
	* Helper function for foreach_nfs_host. This function checks whether the
	* current share option is a host specification and invokes a callback
	* function with information about the host.
	*/
	static int
	foreach_nfs_host_cb(const char opt, const char value, void *pcookie)
	{
	int error;
	const char *access;
	char host_dup, host, *next;
	nfs_host_cookie_t udata = (nfs_host_cookie_t )pcookie;

	#ifdef DEBUG
	fprintf(stderr, "foreach_nfs_host_cb: key=%s, value=%s\n", opt, value);
	#endif

	if (strcmp(opt, "sec") == 0)
	udata->security = value;

	if (strcmp(opt, "rw") == 0 \|\| strcmp(opt, "ro") == 0) {
	if (value == NULL)
	value = "*";

	access = opt;

	host_dup = strdup(value);

	if (host_dup == NULL)
	return (SA_NO_MEMORY);

	host = host_dup;

	do {
	next = strchr(host, ':');
	if (next != NULL) {
	*next = '\0';
	next++;
	}

	error = udata->callback(udata->filename,
	udata->sharepath, host, udata->security,
	access, udata->cookie);

	if (error != SA_OK) {
	free(host_dup);

	return (error);
	}

	host = next;
	} while (host != NULL);

	free(host_dup);
	}

	return (SA_OK);
	}

	/*
	* Invokes a callback function for all NFS hosts that are set for a share.
	*/
	static int
	foreach_nfs_host(sa_share_impl_t impl_share, char *filename,
	nfs_host_callback_t callback, void *cookie)
	{
	nfs_host_cookie_t udata;
	char *shareopts;

	udata.callback = callback;
	udata.sharepath = impl_share->sa_mountpoint;
	udata.cookie = cookie;
	udata.filename = filename;
	udata.security = "sys";

	shareopts = FSINFO(impl_share, nfs_fstype)->shareopts;

	return (foreach_nfs_shareopt(shareopts, foreach_nfs_host_cb,
	&udata));
	}

	/*
	* Converts a Solaris NFS host specification to its Linux equivalent.
	*/
	static int
	get_linux_hostspec(const char solaris_hostspec, char *plinux_hostspec)
	{
	/*
	* For now we just support CIDR masks (e.g. @192.168.0.0/16) and host
	* wildcards (e.g. *.example.org).
	*/
	if (solaris_hostspec[0] == '@') {
	/*
	* Solaris host specifier, e.g. @192.168.0.0/16; we just need
	* to skip the @ in this case
	*/
	*plinux_hostspec = strdup(solaris_hostspec + 1);
	} else {
	*plinux_hostspec = strdup(solaris_hostspec);
	}

	if (*plinux_hostspec == NULL) {
	return (SA_NO_MEMORY);
	}

	return (SA_OK);
	}

	/*
	* Adds a Linux share option to an array of NFS options.
	*/
	static int
	add_linux_shareopt(char *plinux_opts, const char key, const char *value)
	{
	size_t len = 0;
	char *new_linux_opts;

	if (*plinux_opts != NULL)
	len = strlen(*plinux_opts);

	new_linux_opts = realloc(*plinux_opts, len + 1 + strlen(key) +
	(value ? 1 + strlen(value) : 0) + 1);

	if (new_linux_opts == NULL)
	return (SA_NO_MEMORY);

	new_linux_opts[len] = '\0';

	if (len > 0)
	strcat(new_linux_opts, ",");

	strcat(new_linux_opts, key);

	if (value != NULL) {
	strcat(new_linux_opts, "=");
	strcat(new_linux_opts, value);
	}

	*plinux_opts = new_linux_opts;

	return (SA_OK);
	}

	/*
	* Validates and converts a single Solaris share option to its Linux
	* equivalent.
	*/
	static int
	get_linux_shareopts_cb(const char key, const char value, void *cookie)
	{
	char plinux_opts = (char )cookie;

	/* host-specific options, these are taken care of elsewhere */
	if (strcmp(key, "ro") == 0 \|\| strcmp(key, "rw") == 0 \|\|
	strcmp(key, "sec") == 0)
	return (SA_OK);

	if (strcmp(key, "anon") == 0)
	key = "anonuid";

	if (strcmp(key, "root_mapping") == 0) {
	(void) add_linux_shareopt(plinux_opts, "root_squash", NULL);
	key = "anonuid";
	}

	if (strcmp(key, "nosub") == 0)
	key = "subtree_check";

	if (strcmp(key, "insecure") != 0 && strcmp(key, "secure") != 0 &&
	strcmp(key, "async") != 0 && strcmp(key, "sync") != 0 &&
	strcmp(key, "no_wdelay") != 0 && strcmp(key, "wdelay") != 0 &&
	strcmp(key, "nohide") != 0 && strcmp(key, "hide") != 0 &&
	strcmp(key, "crossmnt") != 0 &&
	strcmp(key, "no_subtree_check") != 0 &&
	strcmp(key, "subtree_check") != 0 &&
	strcmp(key, "insecure_locks") != 0 &&
	strcmp(key, "secure_locks") != 0 &&
	strcmp(key, "no_auth_nlm") != 0 && strcmp(key, "auth_nlm") != 0 &&
	strcmp(key, "no_acl") != 0 && strcmp(key, "mountpoint") != 0 &&
	strcmp(key, "mp") != 0 && strcmp(key, "fsuid") != 0 &&
	strcmp(key, "refer") != 0 && strcmp(key, "replicas") != 0 &&
	strcmp(key, "root_squash") != 0 &&
	strcmp(key, "no_root_squash") != 0 &&
	strcmp(key, "all_squash") != 0 &&
	strcmp(key, "no_all_squash") != 0 && strcmp(key, "fsid") != 0 &&
	strcmp(key, "anonuid") != 0 && strcmp(key, "anongid") != 0) {
	return (SA_SYNTAX_ERR);
	}

	(void) add_linux_shareopt(plinux_opts, key, value);

	return (SA_OK);
	}

	/*
	* Takes a string containing Solaris share options (e.g. "sync,no_acl") and
	* converts them to a NULL-terminated array of Linux NFS options.
	*/
	static int
	get_linux_shareopts(const char shareopts, char *plinux_opts)
	{
	int error;

	assert(plinux_opts != NULL);

	*plinux_opts = NULL;

	/* no_subtree_check - Default as of nfs-utils v1.1.0 */
	(void) add_linux_shareopt(plinux_opts, "no_subtree_check", NULL);

	/* mountpoint - Restrict exports to ZFS mountpoints */
	(void) add_linux_shareopt(plinux_opts, "mountpoint", NULL);

	error = foreach_nfs_shareopt(shareopts, get_linux_shareopts_cb,
	plinux_opts);

	if (error != SA_OK) {
	free(*plinux_opts);
	*plinux_opts = NULL;
	}

	return (error);
	}

	static char *
	nfs_init_tmpfile(void)
	{
	char *tmpfile = NULL;
	struct stat sb;

	if (stat(ZFS_EXPORTS_DIR, &sb) < 0 &&
	mkdir(ZFS_EXPORTS_DIR, 0755) < 0) {
	fprintf(stderr, "failed to create %s: %s\n",
	ZFS_EXPORTS_DIR, strerror(errno));
	return (NULL);
	}

	if (asprintf(&tmpfile, "%s%s", ZFS_EXPORTS_FILE, ".XXXXXXXX") == -1) {
	fprintf(stderr, "Unable to allocate temporary file\n");
	return (NULL);
	}

	int fd = mkstemp(tmpfile);
	if (fd == -1) {
	fprintf(stderr, "Unable to create temporary file: %s",
	strerror(errno));
	free(tmpfile);
	return (NULL);
	}
	close(fd);
	return (tmpfile);
	}

	static int
	nfs_fini_tmpfile(char *tmpfile)
	{
	if (rename(tmpfile, ZFS_EXPORTS_FILE) == -1) {
	fprintf(stderr, "Unable to rename %s: %s\n", tmpfile,
	strerror(errno));
	unlink(tmpfile);
	free(tmpfile);
	return (SA_SYSTEM_ERR);
	}
	free(tmpfile);
	return (SA_OK);
	}

	/*
	* This function populates an entry into /etc/exports.d/zfs.exports.
	* This file is consumed by the linux nfs server so that zfs shares are
	* automatically exported upon boot or whenever the nfs server restarts.
	*/
	static int
	nfs_add_entry(const char filename, const char sharepath,
	const char host, const char security, const char *access_opts,
	void *pcookie)
	{
	int error;
	char *linuxhost;
	const char linux_opts = (const char )pcookie;

	error = get_linux_hostspec(host, &linuxhost);
	if (error != SA_OK)
	return (error);

	if (linux_opts == NULL)
	linux_opts = "";

	- FILE *fp = fopen(filename, "a+");
	+ FILE *fp = fopen(filename, "a+e");
	if (fp == NULL) {
	fprintf(stderr, "failed to open %s file: %s", filename,
	strerror(errno));
	free(linuxhost);
	return (SA_SYSTEM_ERR);
	}

	if (fprintf(fp, "%s %s(sec=%s,%s,%s)\n", sharepath, linuxhost,
	security, access_opts, linux_opts) < 0) {
	fprintf(stderr, "failed to write to %s\n", filename);
	free(linuxhost);
	fclose(fp);
	return (SA_SYSTEM_ERR);
	}

	free(linuxhost);
	if (fclose(fp) != 0) {
	fprintf(stderr, "Unable to close file %s: %s\n",
	filename, strerror(errno));
	return (SA_SYSTEM_ERR);
	}
	return (SA_OK);
	}

	/*
	* This function copies all entries from the exports file to "filename",
	* omitting any entries for the specified mountpoint.
	*/
	static int
	nfs_copy_entries(char filename, const char mountpoint)
	{
	char *buf = NULL;
	size_t buflen = 0;
	int error = SA_OK;

	- FILE *oldfp = fopen(ZFS_EXPORTS_FILE, "r");
	- FILE *newfp = fopen(filename, "w+");
	+ FILE *oldfp = fopen(ZFS_EXPORTS_FILE, "re");
	+ FILE *newfp = fopen(filename, "w+e");
	if (newfp == NULL) {
	fprintf(stderr, "failed to open %s file: %s", filename,
	strerror(errno));
	fclose(oldfp);
	return (SA_SYSTEM_ERR);
	}
	fputs(FILE_HEADER, newfp);

	/*
	* The ZFS_EXPORTS_FILE may not exist yet. If that's the
	* case then just write out the new file.
	*/
	if (oldfp != NULL) {
	while (getline(&buf, &buflen, oldfp) != -1) {
	char *space = NULL;

	if (buf[0] == '\n' \|\| buf[0] == '#')
	continue;

	if ((space = strchr(buf, ' ')) != NULL) {
	int mountpoint_len = strlen(mountpoint);

	if (space - buf == mountpoint_len &&
	strncmp(mountpoint, buf,
	mountpoint_len) == 0) {
	continue;
	}
	}
	fputs(buf, newfp);
	}

	if (ferror(oldfp) != 0) {
	error = ferror(oldfp);
	}
	if (fclose(oldfp) != 0) {
	fprintf(stderr, "Unable to close file %s: %s\n",
	filename, strerror(errno));
	error = error != 0 ? error : SA_SYSTEM_ERR;
	}
	}

	if (error == 0 && ferror(newfp) != 0) {
	error = ferror(newfp);
	}

	free(buf);
	if (fclose(newfp) != 0) {
	fprintf(stderr, "Unable to close file %s: %s\n",
	filename, strerror(errno));
	error = error != 0 ? error : SA_SYSTEM_ERR;
	}
	return (error);
	}

	/*
	* Enables NFS sharing for the specified share.
	*/
	static int
	nfs_enable_share(sa_share_impl_t impl_share)
	{
	char shareopts, linux_opts;
	char *filename = NULL;
	int error;

	if ((filename = nfs_init_tmpfile()) == NULL)
	return (SA_SYSTEM_ERR);

	error = nfs_exports_lock();
	if (error != 0) {
	unlink(filename);
	free(filename);
	return (error);
	}

	error = nfs_copy_entries(filename, impl_share->sa_mountpoint);
	if (error != SA_OK) {
	unlink(filename);
	free(filename);
	nfs_exports_unlock();
	return (error);
	}

	shareopts = FSINFO(impl_share, nfs_fstype)->shareopts;
	error = get_linux_shareopts(shareopts, &linux_opts);
	if (error != SA_OK) {
	unlink(filename);
	free(filename);
	nfs_exports_unlock();
	return (error);
	}

	error = foreach_nfs_host(impl_share, filename, nfs_add_entry,
	linux_opts);
	free(linux_opts);
	if (error == 0) {
	error = nfs_fini_tmpfile(filename);
	} else {
	unlink(filename);
	free(filename);
	}
	nfs_exports_unlock();
	return (error);
	}

	/*
	* Disables NFS sharing for the specified share.
	*/
	static int
	nfs_disable_share(sa_share_impl_t impl_share)
	{
	int error;
	char *filename = NULL;

	if ((filename = nfs_init_tmpfile()) == NULL)
	return (SA_SYSTEM_ERR);

	error = nfs_exports_lock();
	if (error != 0) {
	unlink(filename);
	free(filename);
	return (error);
	}

	error = nfs_copy_entries(filename, impl_share->sa_mountpoint);
	if (error != SA_OK) {
	unlink(filename);
	free(filename);
	nfs_exports_unlock();
	return (error);
	}
	error = nfs_fini_tmpfile(filename);
	nfs_exports_unlock();
	return (error);
	}

	static boolean_t
	nfs_is_shared(sa_share_impl_t impl_share)
	{
	size_t buflen = 0;
	char *buf = NULL;

	- FILE *fp = fopen(ZFS_EXPORTS_FILE, "r");
	+ FILE *fp = fopen(ZFS_EXPORTS_FILE, "re");
	if (fp == NULL) {
	return (B_FALSE);
	}
	while ((getline(&buf, &buflen, fp)) != -1) {
	char *space = NULL;

	if ((space = strchr(buf, ' ')) != NULL) {
	int mountpoint_len = strlen(impl_share->sa_mountpoint);

	if (space - buf == mountpoint_len &&
	strncmp(impl_share->sa_mountpoint, buf,
	mountpoint_len) == 0) {
	fclose(fp);
	free(buf);
	return (B_TRUE);
	}
	}
	}
	free(buf);
	fclose(fp);
	return (B_FALSE);
	}

	/*
	* Checks whether the specified NFS share options are syntactically correct.
	*/
	static int
	nfs_validate_shareopts(const char *shareopts)
	{
	char *linux_opts;
	int error;

	error = get_linux_shareopts(shareopts, &linux_opts);

	if (error != SA_OK)
	return (error);

	free(linux_opts);
	return (SA_OK);
	}

	static int
	nfs_update_shareopts(sa_share_impl_t impl_share, const char *shareopts)
	{
	FSINFO(impl_share, nfs_fstype)->shareopts = (char *)shareopts;
	return (SA_OK);
	}

	/*
	* Clears a share's NFS options. Used by libshare to
	* clean up shares that are about to be free()'d.
	*/
	static void
	nfs_clear_shareopts(sa_share_impl_t impl_share)
	{
	FSINFO(impl_share, nfs_fstype)->shareopts = NULL;
	}

	static int
	nfs_commit_shares(void)
	{
	char *argv[] = {
	"/usr/sbin/exportfs",
	"-ra",
	NULL
	};

	return (libzfs_run_process(argv[0], argv, 0));
	}

	static const sa_share_ops_t nfs_shareops = {
	.enable_share = nfs_enable_share,
	.disable_share = nfs_disable_share,
	.is_shared = nfs_is_shared,

	.validate_shareopts = nfs_validate_shareopts,
	.update_shareopts = nfs_update_shareopts,
	.clear_shareopts = nfs_clear_shareopts,
	.commit_shares = nfs_commit_shares,
	};

	/*
	* Initializes the NFS functionality of libshare.
	*/
	void
	libshare_nfs_init(void)
	{
	nfs_fstype = register_fstype("nfs", &nfs_shareops);
	}
	diff --git a/sys/contrib/openzfs/lib/libshare/os/linux/smb.c b/sys/contrib/openzfs/lib/libshare/os/linux/smb.c
	index 3dcf666eb695..45811ff268f9 100644
	--- a/sys/contrib/openzfs/lib/libshare/os/linux/smb.c
	+++ b/sys/contrib/openzfs/lib/libshare/os/linux/smb.c
	@@ -1,453 +1,453 @@
	/*
	* 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) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2011,2012 Turbo Fredriksson <turbo@bayour.com>, based on nfs.c
	* by Gunnar Beutner
	* Copyright (c) 2019, 2020 by Delphix. All rights reserved.
	*
	* This is an addition to the zfs device driver to add, modify and remove SMB
	* shares using the 'net share' command that comes with Samba.
	*
	* TESTING
	* Make sure that samba listens to 'localhost' (127.0.0.1) and that the options
	* 'usershare max shares' and 'usershare owner only' have been reviewed/set
	* accordingly (see zfs(8) for information).
	*
	* Once configuration in samba have been done, test that this
	* works with the following three commands (in this case, my ZFS
	* filesystem is called 'share/Test1'):
	*
	* (root)# net -U root -S 127.0.0.1 usershare add Test1 /share/Test1 \
	* "Comment: /share/Test1" "Everyone:F"
	* (root)# net usershare list \| grep -i test
	* (root)# net -U root -S 127.0.0.1 usershare delete Test1
	*
	* The first command will create a user share that gives everyone full access.
	* To limit the access below that, use normal UNIX commands (chmod, chown etc).
	*/

	#include <time.h>
	#include <stdlib.h>
	#include <stdio.h>
	#include <string.h>
	#include <strings.h>
	#include <fcntl.h>
	#include <sys/wait.h>
	#include <unistd.h>
	#include <dirent.h>
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <libzfs.h>
	#include <libshare.h>
	#include "libshare_impl.h"
	#include "smb.h"

	static boolean_t smb_available(void);

	static sa_fstype_t *smb_fstype;

	smb_share_t *smb_shares;
	static int smb_disable_share(sa_share_impl_t impl_share);
	static boolean_t smb_is_share_active(sa_share_impl_t impl_share);

	/*
	* Retrieve the list of SMB shares.
	*/
	static int
	smb_retrieve_shares(void)
	{
	int rc = SA_OK;
	char file_path[PATH_MAX], line[512], token, key, *value;
	char dup_value = NULL, path = NULL, comment = NULL, name = NULL;
	char *guest_ok = NULL;
	DIR *shares_dir;
	FILE *share_file_fp = NULL;
	struct dirent *directory;
	struct stat eStat;
	smb_share_t shares, new_shares = NULL;

	/* opendir(), stat() */
	shares_dir = opendir(SHARE_DIR);
	if (shares_dir == NULL)
	return (SA_SYSTEM_ERR);

	/* Go through the directory, looking for shares */
	while ((directory = readdir(shares_dir))) {
	if (directory->d_name[0] == '.')
	continue;

	snprintf(file_path, sizeof (file_path),
	"%s/%s", SHARE_DIR, directory->d_name);

	if (stat(file_path, &eStat) == -1) {
	rc = SA_SYSTEM_ERR;
	goto out;
	}

	if (!S_ISREG(eStat.st_mode))
	continue;

	- if ((share_file_fp = fopen(file_path, "r")) == NULL) {
	+ if ((share_file_fp = fopen(file_path, "re")) == NULL) {
	rc = SA_SYSTEM_ERR;
	goto out;
	}

	name = strdup(directory->d_name);
	if (name == NULL) {
	rc = SA_NO_MEMORY;
	goto out;
	}

	while (fgets(line, sizeof (line), share_file_fp)) {
	if (line[0] == '#')
	continue;

	/* Trim trailing new-line character(s). */
	while (line[strlen(line) - 1] == '\r' \|\|
	line[strlen(line) - 1] == '\n')
	line[strlen(line) - 1] = '\0';

	/* Split the line in two, separated by '=' */
	token = strchr(line, '=');
	if (token == NULL)
	continue;

	key = line;
	value = token + 1;
	*token = '\0';

	dup_value = strdup(value);
	if (dup_value == NULL) {
	rc = SA_NO_MEMORY;
	goto out;
	}

	if (strcmp(key, "path") == 0) {
	free(path);
	path = dup_value;
	} else if (strcmp(key, "comment") == 0) {
	free(comment);
	comment = dup_value;
	} else if (strcmp(key, "guest_ok") == 0) {
	free(guest_ok);
	guest_ok = dup_value;
	} else
	free(dup_value);

	dup_value = NULL;

	if (path == NULL \|\| comment == NULL \|\| guest_ok == NULL)
	continue; /* Incomplete share definition */
	else {
	shares = (smb_share_t *)
	malloc(sizeof (smb_share_t));
	if (shares == NULL) {
	rc = SA_NO_MEMORY;
	goto out;
	}

	(void) strlcpy(shares->name, name,
	sizeof (shares->name));

	(void) strlcpy(shares->path, path,
	sizeof (shares->path));

	(void) strlcpy(shares->comment, comment,
	sizeof (shares->comment));

	shares->guest_ok = atoi(guest_ok);

	shares->next = new_shares;
	new_shares = shares;

	free(path);
	free(comment);
	free(guest_ok);

	path = NULL;
	comment = NULL;
	guest_ok = NULL;
	}
	}

	out:
	if (share_file_fp != NULL) {
	fclose(share_file_fp);
	share_file_fp = NULL;
	}

	free(name);
	free(path);
	free(comment);
	free(guest_ok);

	name = NULL;
	path = NULL;
	comment = NULL;
	guest_ok = NULL;
	}
	closedir(shares_dir);

	smb_shares = new_shares;

	return (rc);
	}

	/*
	* Used internally by smb_enable_share to enable sharing for a single host.
	*/
	static int
	smb_enable_share_one(const char sharename, const char sharepath)
	{
	char argv[10], pos;
	char name[SMB_NAME_MAX], comment[SMB_COMMENT_MAX];
	int rc;

	/* Support ZFS share name regexp '[[:alnum:]_-.: ]' */
	strlcpy(name, sharename, sizeof (name));
	name [sizeof (name)-1] = '\0';

	pos = name;
	while (*pos != '\0') {
	switch (*pos) {
	case '/':
	case '-':
	case ':':
	case ' ':
	*pos = '_';
	}

	++pos;
	}

	/*
	* CMD: net -S NET_CMD_ARG_HOST usershare add Test1 /share/Test1 \
	* "Comment" "Everyone:F"
	*/
	snprintf(comment, sizeof (comment), "Comment: %s", sharepath);

	argv[0] = NET_CMD_PATH;
	argv[1] = (char *)"-S";
	argv[2] = NET_CMD_ARG_HOST;
	argv[3] = (char *)"usershare";
	argv[4] = (char *)"add";
	argv[5] = (char *)name;
	argv[6] = (char *)sharepath;
	argv[7] = (char *)comment;
	argv[8] = "Everyone:F";
	argv[9] = NULL;

	rc = libzfs_run_process(argv[0], argv, 0);
	if (rc < 0)
	return (SA_SYSTEM_ERR);

	/* Reload the share file */
	(void) smb_retrieve_shares();

	return (SA_OK);
	}

	/*
	* Enables SMB sharing for the specified share.
	*/
	static int
	smb_enable_share(sa_share_impl_t impl_share)
	{
	char *shareopts;

	if (!smb_available())
	return (SA_SYSTEM_ERR);

	if (smb_is_share_active(impl_share))
	smb_disable_share(impl_share);

	shareopts = FSINFO(impl_share, smb_fstype)->shareopts;
	if (shareopts == NULL) /* on/off */
	return (SA_SYSTEM_ERR);

	if (strcmp(shareopts, "off") == 0)
	return (SA_OK);

	/* Magic: Enable (i.e., 'create new') share */
	return (smb_enable_share_one(impl_share->sa_zfsname,
	impl_share->sa_mountpoint));
	}

	/*
	* Used internally by smb_disable_share to disable sharing for a single host.
	*/
	static int
	smb_disable_share_one(const char *sharename)
	{
	int rc;
	char *argv[7];

	/* CMD: net -S NET_CMD_ARG_HOST usershare delete Test1 */
	argv[0] = NET_CMD_PATH;
	argv[1] = (char *)"-S";
	argv[2] = NET_CMD_ARG_HOST;
	argv[3] = (char *)"usershare";
	argv[4] = (char *)"delete";
	argv[5] = strdup(sharename);
	argv[6] = NULL;

	rc = libzfs_run_process(argv[0], argv, 0);
	if (rc < 0)
	return (SA_SYSTEM_ERR);
	else
	return (SA_OK);
	}

	/*
	* Disables SMB sharing for the specified share.
	*/
	static int
	smb_disable_share(sa_share_impl_t impl_share)
	{
	smb_share_t *shares = smb_shares;

	if (!smb_available()) {
	/*
	* The share can't possibly be active, so nothing
	* needs to be done to disable it.
	*/
	return (SA_OK);
	}

	while (shares != NULL) {
	if (strcmp(impl_share->sa_mountpoint, shares->path) == 0)
	return (smb_disable_share_one(shares->name));

	shares = shares->next;
	}

	return (SA_OK);
	}

	/*
	* Checks whether the specified SMB share options are syntactically correct.
	*/
	static int
	smb_validate_shareopts(const char *shareopts)
	{
	/* TODO: Accept 'name' and sec/acl (?) */
	if ((strcmp(shareopts, "off") == 0) \|\| (strcmp(shareopts, "on") == 0))
	return (SA_OK);

	return (SA_SYNTAX_ERR);
	}

	/*
	* Checks whether a share is currently active.
	*/
	static boolean_t
	smb_is_share_active(sa_share_impl_t impl_share)
	{
	smb_share_t *iter = smb_shares;

	if (!smb_available())
	return (B_FALSE);

	/* Retrieve the list of (possible) active shares */
	smb_retrieve_shares();

	while (iter != NULL) {
	if (strcmp(impl_share->sa_mountpoint, iter->path) == 0)
	return (B_TRUE);

	iter = iter->next;
	}

	return (B_FALSE);
	}

	/*
	* Called to update a share's options. A share's options might be out of
	* date if the share was loaded from disk and the "sharesmb" dataset
	* property has changed in the meantime. This function also takes care
	* of re-enabling the share if necessary.
	*/
	static int
	smb_update_shareopts(sa_share_impl_t impl_share, const char *shareopts)
	{
	if (!impl_share)
	return (SA_SYSTEM_ERR);

	FSINFO(impl_share, smb_fstype)->shareopts = (char *)shareopts;
	return (SA_OK);
	}

	static int
	smb_update_shares(void)
	{
	/* Not implemented */
	return (0);
	}

	/*
	* Clears a share's SMB options. Used by libshare to
	* clean up shares that are about to be free()'d.
	*/
	static void
	smb_clear_shareopts(sa_share_impl_t impl_share)
	{
	FSINFO(impl_share, smb_fstype)->shareopts = NULL;
	}

	static const sa_share_ops_t smb_shareops = {
	.enable_share = smb_enable_share,
	.disable_share = smb_disable_share,
	.is_shared = smb_is_share_active,

	.validate_shareopts = smb_validate_shareopts,
	.update_shareopts = smb_update_shareopts,
	.clear_shareopts = smb_clear_shareopts,
	.commit_shares = smb_update_shares,
	};

	/*
	* Provides a convenient wrapper for determining SMB availability
	*/
	static boolean_t
	smb_available(void)
	{
	struct stat statbuf;

	if (lstat(SHARE_DIR, &statbuf) != 0 \|\|
	!S_ISDIR(statbuf.st_mode))
	return (B_FALSE);

	if (access(NET_CMD_PATH, F_OK) != 0)
	return (B_FALSE);

	return (B_TRUE);
	}

	/*
	* Initializes the SMB functionality of libshare.
	*/
	void
	libshare_smb_init(void)
	{
	smb_fstype = register_fstype("smb", &smb_shareops);
	}
	diff --git a/sys/contrib/openzfs/lib/libspl/os/linux/gethostid.c b/sys/contrib/openzfs/lib/libspl/os/linux/gethostid.c
	index 1eb93f441142..c04b7fd3eef3 100644
	--- a/sys/contrib/openzfs/lib/libspl/os/linux/gethostid.c
	+++ b/sys/contrib/openzfs/lib/libspl/os/linux/gethostid.c
	@@ -1,86 +1,79 @@
	/*
	* 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) 2017, Lawrence Livermore National Security, LLC.
	*/

	#include <fcntl.h>
	#include <stdlib.h>
	#include <stdio.h>
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <sys/systeminfo.h>

	static unsigned long
	get_spl_hostid(void)
	{
	FILE *f;
	unsigned long hostid;
	char *env;

	/*
	* Allow the hostid to be subverted for testing.
	*/
	env = getenv("ZFS_HOSTID");
	- if (env) {
	- hostid = strtoull(env, NULL, 0);
	- return (hostid & HOSTID_MASK);
	- }
	+ if (env)
	+ return (strtoull(env, NULL, 0));

	- f = fopen("/sys/module/spl/parameters/spl_hostid", "r");
	+ f = fopen("/proc/sys/kernel/spl/hostid", "re");
	if (!f)
	return (0);

	- if (fscanf(f, "%lu", &hostid) != 1)
	+ if (fscanf(f, "%lx", &hostid) != 1)
	hostid = 0;

	fclose(f);

	- return (hostid & HOSTID_MASK);
	+ return (hostid);
	}

	unsigned long
	get_system_hostid(void)
	{
	- unsigned long system_hostid = get_spl_hostid();
	+ unsigned long hostid = get_spl_hostid();
	+
	/*
	- * We do not use the library call gethostid() because
	- * it generates a hostid value that the kernel is
	- * unaware of, if the spl_hostid module parameter has not
	- * been set and there is no system hostid file (e.g.
	- * /etc/hostid). The kernel and userspace must agree.
	+ * We do not use gethostid(3) because it can return a bogus ID,
	+ * depending on the libc and /etc/hostid presence,
	+ * and the kernel and userspace must agree.
	* See comments above hostid_read() in the SPL.
	*/
	- if (system_hostid == 0) {
	- int fd, rc;
	- unsigned long hostid;
	- int hostid_size = 4; /* 4 bytes regardless of arch */
	-
	- fd = open("/etc/hostid", O_RDONLY);
	+ if (hostid == 0) {
	+ int fd = open("/etc/hostid", O_RDONLY \| O_CLOEXEC);
	if (fd >= 0) {
	- rc = read(fd, &hostid, hostid_size);
	- if (rc > 0)
	- system_hostid = (hostid & HOSTID_MASK);
	- close(fd);
	+ if (read(fd, &hostid, 4) < 0)
	+ hostid = 0;
	+ (void) close(fd);
	}
	}
	- return (system_hostid);
	+
	+ return (hostid & HOSTID_MASK);
	}
	diff --git a/sys/contrib/openzfs/lib/libspl/os/linux/getmntany.c b/sys/contrib/openzfs/lib/libspl/os/linux/getmntany.c
	index f42fcc047893..a27db60ec3cd 100644
	--- a/sys/contrib/openzfs/lib/libspl/os/linux/getmntany.c
	+++ b/sys/contrib/openzfs/lib/libspl/os/linux/getmntany.c
	@@ -1,165 +1,166 @@
	/*
	* 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 2005 Sun Microsystems, Inc. All rights reserved.
	* Copyright 2006 Ricardo Correia. All rights reserved.
	* Use is subject to license terms.
	*/

	/* Copyright (c) 1988 AT&T */
	/* All Rights Reserved */

	#include <stdio.h>
	#include <string.h>
	#include <mntent.h>
	#include <sys/errno.h>
	#include <sys/mnttab.h>

	#include <sys/types.h>
	#include <sys/sysmacros.h>
	#include <sys/stat.h>
	#include <unistd.h>

	#define BUFSIZE (MNT_LINE_MAX + 2)

	__thread char buf[BUFSIZE];

	#define DIFF(xx) ( \
	(mrefp->xx != NULL) && \
	(mgetp->xx == NULL \|\| strcmp(mrefp->xx, mgetp->xx) != 0))

	int
	getmntany(FILE fp, struct mnttab mgetp, struct mnttab *mrefp)
	{
	int ret;

	while (
	((ret = _sol_getmntent(fp, mgetp)) == 0) && (
	DIFF(mnt_special) \|\| DIFF(mnt_mountp) \|\|
	DIFF(mnt_fstype) \|\| DIFF(mnt_mntopts))) { }

	return (ret);
	}

	int
	_sol_getmntent(FILE fp, struct mnttab mgetp)
	{
	struct mntent mntbuf;
	struct mntent *ret;

	ret = getmntent_r(fp, &mntbuf, buf, BUFSIZE);

	if (ret != NULL) {
	mgetp->mnt_special = mntbuf.mnt_fsname;
	mgetp->mnt_mountp = mntbuf.mnt_dir;
	mgetp->mnt_fstype = mntbuf.mnt_type;
	mgetp->mnt_mntopts = mntbuf.mnt_opts;
	return (0);
	}

	if (feof(fp))
	return (-1);

	return (MNT_TOOLONG);
	}

	static int
	getextmntent_impl(FILE fp, struct extmnttab mp, int len)
	{
	int ret;
	struct stat64 st;

	ret = _sol_getmntent(fp, (struct mnttab *)mp);
	if (ret == 0) {
	if (stat64(mp->mnt_mountp, &st) != 0) {
	mp->mnt_major = 0;
	mp->mnt_minor = 0;
	return (ret);
	}
	mp->mnt_major = major(st.st_dev);
	mp->mnt_minor = minor(st.st_dev);
	}

	return (ret);
	}

	int
	getextmntent(const char path, struct extmnttab entry, struct stat64 *statbuf)
	{
	struct stat64 st;
	FILE *fp;
	int match;

	if (strlen(path) >= MAXPATHLEN) {
	(void) fprintf(stderr, "invalid object; pathname too long\n");
	return (-1);
	}

	/*
	* Search for the path in /proc/self/mounts. Rather than looking for the
	* specific path, which can be fooled by non-standard paths (i.e. ".."
	* or "//"), we stat() the path and search for the corresponding
	* (major,minor) device pair.
	*/
	if (stat64(path, statbuf) != 0) {
	(void) fprintf(stderr, "cannot open '%s': %s\n",
	path, strerror(errno));
	return (-1);
	}


	#ifdef HAVE_SETMNTENT
	- if ((fp = setmntent(MNTTAB, "r")) == NULL) {
	+ if ((fp = setmntent(MNTTAB, "re")) == NULL) {
	#else
	- if ((fp = fopen(MNTTAB, "r")) == NULL) {
	+ if ((fp = fopen(MNTTAB, "re")) == NULL) {
	#endif
	(void) fprintf(stderr, "cannot open %s\n", MNTTAB);
	return (-1);
	}

	/*
	* Search for the given (major,minor) pair in the mount table.
	*/

	match = 0;
	while (getextmntent_impl(fp, entry, sizeof (*entry)) == 0) {
	if (makedev(entry->mnt_major, entry->mnt_minor) ==
	statbuf->st_dev) {
	match = 1;
	break;
	}
	}
	+ (void) fclose(fp);

	if (!match) {
	(void) fprintf(stderr, "cannot find mountpoint for '%s'\n",
	path);
	return (-1);
	}

	if (stat64(entry->mnt_mountp, &st) != 0) {
	entry->mnt_major = 0;
	entry->mnt_minor = 0;
	return (-1);
	}

	return (0);
	}
	diff --git a/sys/contrib/openzfs/lib/libuutil/uu_open.c b/sys/contrib/openzfs/lib/libuutil/uu_open.c
	index cf5c5450b820..73117753c66e 100644
	--- a/sys/contrib/openzfs/lib/libuutil/uu_open.c
	+++ b/sys/contrib/openzfs/lib/libuutil/uu_open.c
	@@ -1,70 +1,64 @@
	/*
	* 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 "libuutil_common.h"

	#include <sys/time.h>

	#include <errno.h>
	#include <fcntl.h>
	#include <limits.h>
	#include <stdio.h>
	#include <unistd.h>

	-#ifdef _LP64
	-#define TMPPATHFMT "%s/uu%ld"
	-#else /* _LP64 */
	-#define TMPPATHFMT "%s/uu%lld"
	-#endif /* _LP64 */
	-
	/ARGSUSED/
	int
	uu_open_tmp(const char *dir, uint_t uflags)
	{
	int f;
	char *fname = uu_zalloc(PATH_MAX);

	if (fname == NULL)
	return (-1);

	for (;;) {
	(void) snprintf(fname, PATH_MAX, "%s/uu%lld", dir, gethrtime());

	- f = open(fname, O_CREAT \| O_EXCL \| O_RDWR, 0600);
	+ f = open(fname, O_CREAT \| O_EXCL \| O_RDWR \| O_CLOEXEC, 0600);

	if (f >= 0 \|\| errno != EEXIST)
	break;
	}

	if (f >= 0)
	(void) unlink(fname);

	uu_free(fname);

	return (f);
	}
	diff --git a/sys/contrib/openzfs/lib/libzfs/Makefile.am b/sys/contrib/openzfs/lib/libzfs/Makefile.am
	index 621021a1218e..1a7698b4760e 100644
	--- a/sys/contrib/openzfs/lib/libzfs/Makefile.am
	+++ b/sys/contrib/openzfs/lib/libzfs/Makefile.am
	@@ -1,98 +1,98 @@
	include $(top_srcdir)/config/Rules.am

	VPATH = \
	$(top_srcdir)/module/icp \
	$(top_srcdir)/module/zcommon \
	$(top_srcdir)/lib/libzfs

	# Suppress unused but set variable warnings often due to ASSERTs
	AM_CFLAGS += $(NO_UNUSED_BUT_SET_VARIABLE)
	AM_CFLAGS += $(LIBCRYPTO_CFLAGS) $(ZLIB_CFLAGS)

	pkgconfig_DATA = libzfs.pc

	lib_LTLIBRARIES = libzfs.la

	include $(top_srcdir)/config/Abigail.am

	USER_C = \
	libzfs_changelist.c \
	libzfs_config.c \
	libzfs_crypto.c \
	libzfs_dataset.c \
	libzfs_diff.c \
	libzfs_import.c \
	libzfs_iter.c \
	libzfs_mount.c \
	libzfs_pool.c \
	libzfs_sendrecv.c \
	libzfs_status.c \
	libzfs_util.c


	if BUILD_FREEBSD
	USER_C += \
	os/freebsd/libzfs_compat.c \
	os/freebsd/libzfs_ioctl_compat.c \
	os/freebsd/libzfs_zmount.c
	endif

	if BUILD_LINUX
	USER_C += \
	os/linux/libzfs_mount_os.c \
	os/linux/libzfs_pool_os.c \
	os/linux/libzfs_sendrecv_os.c \
	os/linux/libzfs_util_os.c
	endif

	KERNEL_C = \
	algs/sha2/sha2.c \
	cityhash.c \
	zfeature_common.c \
	zfs_comutil.c \
	zfs_deleg.c \
	zfs_fletcher.c \
	zfs_fletcher_aarch64_neon.c \
	zfs_fletcher_avx512.c \
	zfs_fletcher_intel.c \
	zfs_fletcher_sse.c \
	zfs_fletcher_superscalar.c \
	zfs_fletcher_superscalar4.c \
	zfs_namecheck.c \
	zfs_prop.c \
	zpool_prop.c \
	zprop_common.c

	dist_libzfs_la_SOURCES = \
	$(USER_C)

	nodist_libzfs_la_SOURCES = \
	$(KERNEL_C)

	libzfs_la_LIBADD = \
	$(abs_top_builddir)/lib/libshare/libshare.la \
	$(abs_top_builddir)/lib/libzfs_core/libzfs_core.la \
	$(abs_top_builddir)/lib/libnvpair/libnvpair.la \
	$(abs_top_builddir)/lib/libuutil/libuutil.la

	libzfs_la_LIBADD += -lm $(LIBCRYPTO_LIBS) $(ZLIB_LIBS) $(LTLIBINTL)

	libzfs_la_LDFLAGS = -pthread

	if !ASAN_ENABLED
	libzfs_la_LDFLAGS += -Wl,-z,defs
	endif

	if BUILD_FREEBSD
	libzfs_la_LIBADD += -lutil -lgeom
	endif

	-libzfs_la_LDFLAGS += -version-info 4:0:0
	+libzfs_la_LDFLAGS += -version-info 5:0:1

	include $(top_srcdir)/config/CppCheck.am

	# Library ABI
	EXTRA_DIST = libzfs.abi libzfs.suppr

	# Licensing data
	EXTRA_DIST += THIRDPARTYLICENSE.openssl THIRDPARTYLICENSE.openssl.descrip
	diff --git a/sys/contrib/openzfs/lib/libzfs/libzfs.abi b/sys/contrib/openzfs/lib/libzfs/libzfs.abi
	index 6cd8fa9357f9..572297123035 100644
	--- a/sys/contrib/openzfs/lib/libzfs/libzfs.abi
	+++ b/sys/contrib/openzfs/lib/libzfs/libzfs.abi
	@@ -1,6248 +1,6252 @@
	<abi-corpus path='libzfs.so' architecture='elf-amd-x86_64' soname='libzfs.so.4'>
	<elf-needed>
	<dependency name='libzfs_core.so.3'/>
	<dependency name='libnvpair.so.3'/>
	<dependency name='libuutil.so.3'/>
	<dependency name='libm.so.6'/>
	<dependency name='libcrypto.so.1.1'/>
	<dependency name='libz.so.1'/>
	<dependency name='libpthread.so.0'/>
	<dependency name='libc.so.6'/>
	</elf-needed>
	<elf-function-symbols>
	<elf-symbol name='SHA256Init' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='SHA2Final' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='SHA2Init' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='SHA2Update' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='SHA384Init' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='SHA512Init' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='bookmark_namecheck' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='changelist_free' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='changelist_gather' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='changelist_haszonedchild' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='changelist_postfix' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='changelist_prefix' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='changelist_remove' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='changelist_rename' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='changelist_unshare' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='cityhash4' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='color_end' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='color_start' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='create_parents' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='dataset_namecheck' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='dataset_nestcheck' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='do_mount' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='do_unmount' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='entity_namecheck' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='find_shares_object' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fletcher_2_byteswap' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fletcher_2_incremental_byteswap' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fletcher_2_incremental_native' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fletcher_2_native' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fletcher_4_byteswap' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fletcher_4_fini' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fletcher_4_impl_set' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fletcher_4_incremental_byteswap' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fletcher_4_incremental_native' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fletcher_4_init' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fletcher_4_native' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fletcher_4_native_varsize' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fletcher_init' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='get_dataset_depth' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='getprop_uint64' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='is_mounted' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='is_shared' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='isa_child_of' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='libshare_nfs_init' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='libshare_smb_init' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='libzfs_add_handle' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='libzfs_envvar_is_set' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='libzfs_errno' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='libzfs_error_action' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='libzfs_error_description' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='libzfs_error_init' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='libzfs_fini' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='libzfs_free_str_array' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='libzfs_init' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='libzfs_load_module' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='libzfs_mnttab_add' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='libzfs_mnttab_cache' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='libzfs_mnttab_find' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='libzfs_mnttab_fini' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='libzfs_mnttab_init' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='libzfs_mnttab_remove' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='libzfs_print_on_error' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='libzfs_run_process' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='libzfs_run_process_get_stdout' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='libzfs_run_process_get_stdout_nopath' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='libzfs_set_pipe_max' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='make_bookmark_handle' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='make_dataset_handle' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='make_dataset_handle_zc' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='make_dataset_simple_handle_zc' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='mountpoint_namecheck' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='namespace_clear' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='no_memory' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='permset_namecheck' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='pool_namecheck' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='printf_color' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='register_fstype' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='remove_mountpoint' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='sa_commit_shares' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='sa_disable_share' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='sa_enable_share' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='sa_errorstr' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='sa_is_shared' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='sa_validate_shareopts' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='snapshot_namecheck' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='unshare_one' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zcmd_alloc_dst_nvlist' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zcmd_expand_dst_nvlist' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zcmd_free_nvlists' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zcmd_read_dst_nvlist' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zcmd_write_conf_nvlist' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zcmd_write_src_nvlist' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfeature_depends_on' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfeature_is_supported' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfeature_is_valid_guid' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfeature_lookup_guid' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfeature_lookup_name' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_adjust_mount_options' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_alloc' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_allocatable_devs' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_asprintf' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_bookmark_exists' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_clone' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_close' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_commit_all_shares' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_commit_nfs_shares' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_commit_proto' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_commit_shares' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_commit_smb_shares' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_component_namecheck' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_create' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_create_ancestors' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_crypto_attempt_load_keys' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_crypto_clone_check' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_crypto_create' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_crypto_get_encryption_root' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_crypto_load_key' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_crypto_rewrap' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_crypto_unload_key' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_dataset_exists' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_dataset_name_hidden' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_deleg_canonicalize_perm' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_deleg_verify_nvlist' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_deleg_whokey' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_destroy' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_destroy_snaps' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_destroy_snaps_nvl' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_error' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_error_aux' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_error_fmt' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_expand_proplist' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_foreach_mountpoint' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_get_all_props' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_get_clones_nvl' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_get_fsacl' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_get_handle' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_get_holds' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_get_name' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_get_pool_handle' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_get_pool_name' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_get_recvd_props' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_get_type' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_get_user_props' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_handle_dup' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_hold' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_hold_nvl' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_ioctl' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_is_mountable' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_is_mounted' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_is_shared' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_is_shared_nfs' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_is_shared_proto' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_is_shared_smb' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_iter_bookmarks' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_iter_children' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_iter_dependents' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_iter_filesystems' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_iter_mounted' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_iter_root' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_iter_snapshots' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_iter_snapshots_sorted' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_iter_snapspec' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_mod_supported' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_mount' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_mount_at' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_mount_delegation_check' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_name_to_prop' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_name_valid' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_nicestrtonum' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_open' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_parent_name' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_parse_mount_options' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_parse_options' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_path_to_zhandle' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_promote' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_prop_align_right' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_prop_column_name' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_prop_default_numeric' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_prop_default_string' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_prop_delegatable' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_prop_encryption_key_param' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_prop_get' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_prop_get_int' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_prop_get_numeric' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_prop_get_recvd' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_prop_get_table' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_prop_get_type' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_prop_get_userquota' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_prop_get_userquota_int' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_prop_get_written' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_prop_get_written_int' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_prop_index_to_string' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_prop_inherit' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_prop_inheritable' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_prop_init' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_prop_is_string' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_prop_random_value' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_prop_readonly' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_prop_set' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_prop_set_list' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_prop_setonce' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_prop_string_to_index' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_prop_to_name' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_prop_user' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_prop_userquota' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_prop_valid_for_type' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_prop_valid_keylocation' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_prop_values' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_prop_visible' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_prop_written' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_prune_proplist' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_realloc' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_receive' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_refresh_properties' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_release' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_rename' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_rollback' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_save_arguments' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_send' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_send_one' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_send_progress' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_send_resume' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_send_resume_token_to_nvlist' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_send_saved' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_set_fsacl' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_setprop_error' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_share' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_share_nfs' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_share_proto' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_share_smb' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_shareall' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_show_diffs' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_smb_acl_add' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_smb_acl_purge' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_smb_acl_remove' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_smb_acl_rename' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_snapshot' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_snapshot_nvl' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_spa_version' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_spa_version_map' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_special_devs' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_standard_error' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_standard_error_fmt' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_strdup' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_type_to_name' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_unmount' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_unmountall' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_unshare' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_unshare_nfs' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_unshare_proto' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_unshare_smb' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_unshareall' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_unshareall_bypath' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_unshareall_bytype' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_unshareall_nfs' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_unshareall_smb' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_userspace' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_valid_proplist' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_validate_name' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_version_kernel' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_version_print' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_version_userland' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_wait_status' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_zpl_version_map' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_add' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_checkpoint' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_clear' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_clear_label' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_close' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_create' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_destroy' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_disable_datasets' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_discard_checkpoint' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_enable_datasets' type='func-type' binding='global-binding' visibility='default-visibility' alias='zpool_mount_datasets' is-defined='yes'/>
	<elf-symbol name='zpool_events_clear' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_events_next' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_events_seek' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_expand_proplist' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_explain_recover' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_export' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_export_force' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_feature_init' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_find_vdev' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_find_vdev_by_physpath' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_free_handles' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_get_bootenv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_get_config' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_get_errlog' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_get_features' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_get_handle' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_get_history' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_get_load_policy' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_get_name' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_get_physpath' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_get_prop' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_get_prop_int' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_get_state' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_get_state_str' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_get_status' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_import' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_import_props' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_import_status' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_in_use' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_initialize' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_initialize_wait' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_is_draid_spare' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_iter' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_label_disk' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_load_compat' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_log_history' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_mount_datasets' type='func-type' binding='weak-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_name_to_prop' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_name_valid' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_obj_to_path' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_obj_to_path_ds' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_open' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_open_canfail' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_open_silent' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_pool_state_to_name' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_print_unsup_feat' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_prop_align_right' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_prop_column_name' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_prop_default_numeric' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_prop_default_string' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_prop_feature' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_prop_get_feature' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_prop_get_table' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_prop_get_type' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_prop_index_to_string' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_prop_init' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_prop_random_value' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_prop_readonly' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_prop_setonce' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_prop_string_to_index' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_prop_to_name' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_prop_unsupported' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_prop_values' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_props_refresh' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_refresh_stats' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_reguid' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_relabel_disk' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_reopen_one' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_scan' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_set_bootenv' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_set_prop' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_skip_pool' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_standard_error' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_standard_error_fmt' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_state_to_name' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_sync_one' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_trim' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_unmount_datasets' type='func-type' binding='weak-binding' visibility='default-visibility' alias='zpool_disable_datasets' is-defined='yes'/>
	<elf-symbol name='zpool_upgrade' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_vdev_attach' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_vdev_clear' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_vdev_degrade' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_vdev_detach' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_vdev_fault' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_vdev_indirect_size' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_vdev_name' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_vdev_offline' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_vdev_online' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_vdev_path_to_guid' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_vdev_remove' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_vdev_remove_cancel' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_vdev_split' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_wait' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zpool_wait_status' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zprop_expand_list' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zprop_free_list' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zprop_get_list' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zprop_index_to_string' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zprop_iter' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zprop_iter_common' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zprop_name_to_prop' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zprop_parse_value' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zprop_print_one_property' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zprop_random_value' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zprop_register_hidden' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zprop_register_impl' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zprop_register_index' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zprop_register_number' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zprop_register_string' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zprop_string_to_index' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zprop_valid_for_type' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zprop_values' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zprop_width' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zvol_volsize_to_reservation' type='func-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	</elf-function-symbols>
	<elf-variable-symbols>
	<elf-symbol name='fletcher_4_abd_ops' size='24' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fletcher_4_avx2_ops' size='64' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fletcher_4_avx512bw_ops' size='64' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fletcher_4_avx512f_ops' size='64' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fletcher_4_sse2_ops' size='64' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fletcher_4_ssse3_ops' size='64' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fletcher_4_superscalar4_ops' size='64' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='fletcher_4_superscalar_ops' size='64' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='libzfs_config_ops' size='16' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='nfs_only' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='proto_table' size='48' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='share_all_proto' size='12' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='smb_only' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='smb_shares' size='8' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='spa_feature_table' size='1904' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfeature_checks_disable' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_deleg_perm_tab' size='512' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_history_event_names' size='328' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_max_dataset_nesting' size='4' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	<elf-symbol name='zfs_userquota_prop_prefixes' size='96' type='object-type' binding='global-binding' visibility='default-visibility' is-defined='yes'/>
	</elf-variable-symbols>
	<abi-instr version='1.0' address-size='64' path='libzfs_changelist.c' comp-dir-path='/home/colm/src/zfs/zfs/lib/libzfs' language='LANG_C99'>
	<class-decl name='prop_changelist' size-in-bits='448' is-struct='yes' visibility='default' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='75' column='1' id='type-id-1'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='cl_prop' type-id='type-id-2' visibility='default' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='76' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	<var-decl name='cl_realprop' type-id='type-id-2' visibility='default' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='77' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='cl_shareprop' type-id='type-id-2' visibility='default' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='78' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='cl_pool' type-id='type-id-3' visibility='default' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='79' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='cl_tree' type-id='type-id-4' visibility='default' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='80' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='cl_waslegacy' type-id='type-id-5' visibility='default' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='81' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='288'>
	<var-decl name='cl_allchildren' type-id='type-id-5' visibility='default' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='82' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='cl_alldependents' type-id='type-id-5' visibility='default' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='83' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='352'>
	<var-decl name='cl_mflags' type-id='type-id-6' visibility='default' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='84' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='cl_gflags' type-id='type-id-6' visibility='default' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='85' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='416'>
	<var-decl name='cl_haszonedchild' type-id='type-id-5' visibility='default' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='86' column='1'/>
	</data-member>
	</class-decl>
	<type-decl name='unnamed-enum-underlying-type' is-anonymous='yes' size-in-bits='32' alignment-in-bits='32' id='type-id-7'/>
	<enum-decl name='__anonymous_enum__' is-anonymous='yes' filepath='../../include/sys/fs/zfs.h' line='91' column='1' id='type-id-8'>
	<underlying-type type-id='type-id-7'/>
	<enumerator name='ZPROP_CONT' value='-2'/>
	<enumerator name='ZPROP_INVAL' value='-1'/>
	<enumerator name='ZFS_PROP_TYPE' value='0'/>
	<enumerator name='ZFS_PROP_CREATION' value='1'/>
	<enumerator name='ZFS_PROP_USED' value='2'/>
	<enumerator name='ZFS_PROP_AVAILABLE' value='3'/>
	<enumerator name='ZFS_PROP_REFERENCED' value='4'/>
	<enumerator name='ZFS_PROP_COMPRESSRATIO' value='5'/>
	<enumerator name='ZFS_PROP_MOUNTED' value='6'/>
	<enumerator name='ZFS_PROP_ORIGIN' value='7'/>
	<enumerator name='ZFS_PROP_QUOTA' value='8'/>
	<enumerator name='ZFS_PROP_RESERVATION' value='9'/>
	<enumerator name='ZFS_PROP_VOLSIZE' value='10'/>
	<enumerator name='ZFS_PROP_VOLBLOCKSIZE' value='11'/>
	<enumerator name='ZFS_PROP_RECORDSIZE' value='12'/>
	<enumerator name='ZFS_PROP_MOUNTPOINT' value='13'/>
	<enumerator name='ZFS_PROP_SHARENFS' value='14'/>
	<enumerator name='ZFS_PROP_CHECKSUM' value='15'/>
	<enumerator name='ZFS_PROP_COMPRESSION' value='16'/>
	<enumerator name='ZFS_PROP_ATIME' value='17'/>
	<enumerator name='ZFS_PROP_DEVICES' value='18'/>
	<enumerator name='ZFS_PROP_EXEC' value='19'/>
	<enumerator name='ZFS_PROP_SETUID' value='20'/>
	<enumerator name='ZFS_PROP_READONLY' value='21'/>
	<enumerator name='ZFS_PROP_ZONED' value='22'/>
	<enumerator name='ZFS_PROP_SNAPDIR' value='23'/>
	<enumerator name='ZFS_PROP_ACLMODE' value='24'/>
	<enumerator name='ZFS_PROP_ACLINHERIT' value='25'/>
	<enumerator name='ZFS_PROP_CREATETXG' value='26'/>
	<enumerator name='ZFS_PROP_NAME' value='27'/>
	<enumerator name='ZFS_PROP_CANMOUNT' value='28'/>
	<enumerator name='ZFS_PROP_ISCSIOPTIONS' value='29'/>
	<enumerator name='ZFS_PROP_XATTR' value='30'/>
	<enumerator name='ZFS_PROP_NUMCLONES' value='31'/>
	<enumerator name='ZFS_PROP_COPIES' value='32'/>
	<enumerator name='ZFS_PROP_VERSION' value='33'/>
	<enumerator name='ZFS_PROP_UTF8ONLY' value='34'/>
	<enumerator name='ZFS_PROP_NORMALIZE' value='35'/>
	<enumerator name='ZFS_PROP_CASE' value='36'/>
	<enumerator name='ZFS_PROP_VSCAN' value='37'/>
	<enumerator name='ZFS_PROP_NBMAND' value='38'/>
	<enumerator name='ZFS_PROP_SHARESMB' value='39'/>
	<enumerator name='ZFS_PROP_REFQUOTA' value='40'/>
	<enumerator name='ZFS_PROP_REFRESERVATION' value='41'/>
	<enumerator name='ZFS_PROP_GUID' value='42'/>
	<enumerator name='ZFS_PROP_PRIMARYCACHE' value='43'/>
	<enumerator name='ZFS_PROP_SECONDARYCACHE' value='44'/>
	<enumerator name='ZFS_PROP_USEDSNAP' value='45'/>
	<enumerator name='ZFS_PROP_USEDDS' value='46'/>
	<enumerator name='ZFS_PROP_USEDCHILD' value='47'/>
	<enumerator name='ZFS_PROP_USEDREFRESERV' value='48'/>
	<enumerator name='ZFS_PROP_USERACCOUNTING' value='49'/>
	<enumerator name='ZFS_PROP_STMF_SHAREINFO' value='50'/>
	<enumerator name='ZFS_PROP_DEFER_DESTROY' value='51'/>
	<enumerator name='ZFS_PROP_USERREFS' value='52'/>
	<enumerator name='ZFS_PROP_LOGBIAS' value='53'/>
	<enumerator name='ZFS_PROP_UNIQUE' value='54'/>
	<enumerator name='ZFS_PROP_OBJSETID' value='55'/>
	<enumerator name='ZFS_PROP_DEDUP' value='56'/>
	<enumerator name='ZFS_PROP_MLSLABEL' value='57'/>
	<enumerator name='ZFS_PROP_SYNC' value='58'/>
	<enumerator name='ZFS_PROP_DNODESIZE' value='59'/>
	<enumerator name='ZFS_PROP_REFRATIO' value='60'/>
	<enumerator name='ZFS_PROP_WRITTEN' value='61'/>
	<enumerator name='ZFS_PROP_CLONES' value='62'/>
	<enumerator name='ZFS_PROP_LOGICALUSED' value='63'/>
	<enumerator name='ZFS_PROP_LOGICALREFERENCED' value='64'/>
	<enumerator name='ZFS_PROP_INCONSISTENT' value='65'/>
	<enumerator name='ZFS_PROP_VOLMODE' value='66'/>
	<enumerator name='ZFS_PROP_FILESYSTEM_LIMIT' value='67'/>
	<enumerator name='ZFS_PROP_SNAPSHOT_LIMIT' value='68'/>
	<enumerator name='ZFS_PROP_FILESYSTEM_COUNT' value='69'/>
	<enumerator name='ZFS_PROP_SNAPSHOT_COUNT' value='70'/>
	<enumerator name='ZFS_PROP_SNAPDEV' value='71'/>
	<enumerator name='ZFS_PROP_ACLTYPE' value='72'/>
	<enumerator name='ZFS_PROP_SELINUX_CONTEXT' value='73'/>
	<enumerator name='ZFS_PROP_SELINUX_FSCONTEXT' value='74'/>
	<enumerator name='ZFS_PROP_SELINUX_DEFCONTEXT' value='75'/>
	<enumerator name='ZFS_PROP_SELINUX_ROOTCONTEXT' value='76'/>
	<enumerator name='ZFS_PROP_RELATIME' value='77'/>
	<enumerator name='ZFS_PROP_REDUNDANT_METADATA' value='78'/>
	<enumerator name='ZFS_PROP_OVERLAY' value='79'/>
	<enumerator name='ZFS_PROP_PREV_SNAP' value='80'/>
	<enumerator name='ZFS_PROP_RECEIVE_RESUME_TOKEN' value='81'/>
	<enumerator name='ZFS_PROP_ENCRYPTION' value='82'/>
	<enumerator name='ZFS_PROP_KEYLOCATION' value='83'/>
	<enumerator name='ZFS_PROP_KEYFORMAT' value='84'/>
	<enumerator name='ZFS_PROP_PBKDF2_SALT' value='85'/>
	<enumerator name='ZFS_PROP_PBKDF2_ITERS' value='86'/>
	<enumerator name='ZFS_PROP_ENCRYPTION_ROOT' value='87'/>
	<enumerator name='ZFS_PROP_KEY_GUID' value='88'/>
	<enumerator name='ZFS_PROP_KEYSTATUS' value='89'/>
	<enumerator name='ZFS_PROP_REMAPTXG' value='90'/>
	<enumerator name='ZFS_PROP_SPECIAL_SMALL_BLOCKS' value='91'/>
	<enumerator name='ZFS_PROP_IVSET_GUID' value='92'/>
	<enumerator name='ZFS_PROP_REDACTED' value='93'/>
	<enumerator name='ZFS_PROP_REDACT_SNAPS' value='94'/>
	<enumerator name='ZFS_NUM_PROPS' value='95'/>
	</enum-decl>
	<typedef-decl name='zfs_prop_t' type-id='type-id-8' filepath='../../include/sys/fs/zfs.h' line='190' column='1' id='type-id-2'/>
	<class-decl name='uu_avl_pool' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-9'/>
	<typedef-decl name='uu_avl_pool_t' type-id='type-id-9' filepath='../../include/libuutil.h' line='287' column='1' id='type-id-10'/>
	<pointer-type-def type-id='type-id-10' size-in-bits='64' id='type-id-3'/>
	<class-decl name='uu_avl' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-11'/>
	<typedef-decl name='uu_avl_t' type-id='type-id-11' filepath='../../include/libuutil.h' line='288' column='1' id='type-id-12'/>
	<pointer-type-def type-id='type-id-12' size-in-bits='64' id='type-id-4'/>
	<enum-decl name='__anonymous_enum__' is-anonymous='yes' filepath='../../lib/libspl/include/sys/stdtypes.h' line='26' column='1' id='type-id-13'>
	<underlying-type type-id='type-id-7'/>
	<enumerator name='B_FALSE' value='0'/>
	<enumerator name='B_TRUE' value='1'/>
	</enum-decl>
	<typedef-decl name='boolean_t' type-id='type-id-13' filepath='../../lib/libspl/include/sys/stdtypes.h' line='29' column='1' id='type-id-5'/>
	<type-decl name='int' size-in-bits='32' id='type-id-6'/>
	<typedef-decl name='prop_changelist_t' type-id='type-id-1' filepath='../../include/libzfs_impl.h' line='174' column='1' id='type-id-14'/>
	<pointer-type-def type-id='type-id-14' size-in-bits='64' id='type-id-15'/>
	<class-decl name='zfs_handle' size-in-bits='4928' is-struct='yes' visibility='default' filepath='../../include/libzfs_impl.h' line='77' column='1' id='type-id-16'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='zfs_hdl' type-id='type-id-17' visibility='default' filepath='../../include/libzfs_impl.h' line='78' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='zpool_hdl' type-id='type-id-18' visibility='default' filepath='../../include/libzfs_impl.h' line='79' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='zfs_name' type-id='type-id-19' visibility='default' filepath='../../include/libzfs_impl.h' line='80' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2176'>
	<var-decl name='zfs_type' type-id='type-id-20' visibility='default' filepath='../../include/libzfs_impl.h' line='81' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2208'>
	<var-decl name='zfs_head_type' type-id='type-id-20' visibility='default' filepath='../../include/libzfs_impl.h' line='82' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2240'>
	<var-decl name='zfs_dmustats' type-id='type-id-21' visibility='default' filepath='../../include/libzfs_impl.h' line='83' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='4544'>
	<var-decl name='zfs_props' type-id='type-id-22' visibility='default' filepath='../../include/libzfs_impl.h' line='84' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='4608'>
	<var-decl name='zfs_user_props' type-id='type-id-22' visibility='default' filepath='../../include/libzfs_impl.h' line='85' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='4672'>
	<var-decl name='zfs_recvd_props' type-id='type-id-22' visibility='default' filepath='../../include/libzfs_impl.h' line='86' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='4736'>
	<var-decl name='zfs_mntcheck' type-id='type-id-5' visibility='default' filepath='../../include/libzfs_impl.h' line='87' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='4800'>
	<var-decl name='zfs_mntopts' type-id='type-id-23' visibility='default' filepath='../../include/libzfs_impl.h' line='88' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='4864'>
	<var-decl name='zfs_props_table' type-id='type-id-24' visibility='default' filepath='../../include/libzfs_impl.h' line='89' column='1'/>
	</data-member>
	</class-decl>
	<class-decl name='libzfs_handle' size-in-bits='20224' is-struct='yes' visibility='default' filepath='../../include/libzfs_impl.h' line='48' column='1' id='type-id-25'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='libzfs_error' type-id='type-id-6' visibility='default' filepath='../../include/libzfs_impl.h' line='49' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	<var-decl name='libzfs_fd' type-id='type-id-6' visibility='default' filepath='../../include/libzfs_impl.h' line='50' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='libzfs_mnttab' type-id='type-id-26' visibility='default' filepath='../../include/libzfs_impl.h' line='51' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='libzfs_pool_handles' type-id='type-id-18' visibility='default' filepath='../../include/libzfs_impl.h' line='52' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='libzfs_ns_avlpool' type-id='type-id-3' visibility='default' filepath='../../include/libzfs_impl.h' line='53' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='libzfs_ns_avl' type-id='type-id-4' visibility='default' filepath='../../include/libzfs_impl.h' line='54' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='libzfs_ns_gen' type-id='type-id-27' visibility='default' filepath='../../include/libzfs_impl.h' line='55' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='libzfs_desc_active' type-id='type-id-6' visibility='default' filepath='../../include/libzfs_impl.h' line='56' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='416'>
	<var-decl name='libzfs_action' type-id='type-id-28' visibility='default' filepath='../../include/libzfs_impl.h' line='57' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='8608'>
	<var-decl name='libzfs_desc' type-id='type-id-28' visibility='default' filepath='../../include/libzfs_impl.h' line='58' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='16800'>
	<var-decl name='libzfs_printerr' type-id='type-id-6' visibility='default' filepath='../../include/libzfs_impl.h' line='59' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='16832'>
	<var-decl name='libzfs_storeerr' type-id='type-id-6' visibility='default' filepath='../../include/libzfs_impl.h' line='60' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='16864'>
	<var-decl name='libzfs_mnttab_enable' type-id='type-id-5' visibility='default' filepath='../../include/libzfs_impl.h' line='61' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='16896'>
	<var-decl name='libzfs_mnttab_cache_lock' type-id='type-id-29' visibility='default' filepath='../../include/libzfs_impl.h' line='68' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='17216'>
	<var-decl name='libzfs_mnttab_cache' type-id='type-id-30' visibility='default' filepath='../../include/libzfs_impl.h' line='69' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='17536'>
	<var-decl name='libzfs_pool_iter' type-id='type-id-6' visibility='default' filepath='../../include/libzfs_impl.h' line='70' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='17568'>
	<var-decl name='libzfs_chassis_id' type-id='type-id-19' visibility='default' filepath='../../include/libzfs_impl.h' line='71' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='19616'>
	<var-decl name='libzfs_prop_debug' type-id='type-id-5' visibility='default' filepath='../../include/libzfs_impl.h' line='72' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='19648'>
	<var-decl name='libzfs_urire' type-id='type-id-31' visibility='default' filepath='../../include/libzfs_impl.h' line='73' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='20160'>
	<var-decl name='libzfs_max_nvlist' type-id='type-id-27' visibility='default' filepath='../../include/libzfs_impl.h' line='74' column='1'/>
	</data-member>
	</class-decl>
	<class-decl name='_IO_FILE' size-in-bits='1728' is-struct='yes' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h' line='49' column='1' id='type-id-32'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='_flags' type-id='type-id-6' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h' line='51' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='_IO_read_ptr' type-id='type-id-23' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h' line='54' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='_IO_read_end' type-id='type-id-23' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h' line='55' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='_IO_read_base' type-id='type-id-23' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h' line='56' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='_IO_write_base' type-id='type-id-23' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h' line='57' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='_IO_write_ptr' type-id='type-id-23' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h' line='58' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='_IO_write_end' type-id='type-id-23' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h' line='59' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='448'>
	<var-decl name='_IO_buf_base' type-id='type-id-23' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h' line='60' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='512'>
	<var-decl name='_IO_buf_end' type-id='type-id-23' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h' line='61' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='576'>
	<var-decl name='_IO_save_base' type-id='type-id-23' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h' line='64' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='640'>
	<var-decl name='_IO_backup_base' type-id='type-id-23' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h' line='65' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='704'>
	<var-decl name='_IO_save_end' type-id='type-id-23' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h' line='66' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='768'>
	<var-decl name='_markers' type-id='type-id-33' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h' line='68' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='832'>
	<var-decl name='_chain' type-id='type-id-34' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h' line='70' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='896'>
	<var-decl name='_fileno' type-id='type-id-6' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h' line='72' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='928'>
	<var-decl name='_flags2' type-id='type-id-6' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h' line='73' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='960'>
	<var-decl name='_old_offset' type-id='type-id-35' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h' line='74' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1024'>
	<var-decl name='_cur_column' type-id='type-id-36' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h' line='77' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1040'>
	<var-decl name='_vtable_offset' type-id='type-id-37' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h' line='78' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1048'>
	<var-decl name='_shortbuf' type-id='type-id-38' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h' line='79' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1152'>
	<var-decl name='_offset' type-id='type-id-39' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h' line='89' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1216'>
	<var-decl name='_codecvt' type-id='type-id-40' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h' line='91' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1280'>
	<var-decl name='_wide_data' type-id='type-id-41' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h' line='92' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1344'>
	<var-decl name='_freeres_list' type-id='type-id-34' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h' line='93' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1408'>
	<var-decl name='_freeres_buf' type-id='type-id-42' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h' line='94' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1472'>
	<var-decl name='__pad5' type-id='type-id-43' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h' line='95' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1536'>
	<var-decl name='_mode' type-id='type-id-6' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h' line='96' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='1568'>
	<var-decl name='_unused2' type-id='type-id-44' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h' line='98' column='1'/>
	</data-member>
	</class-decl>
	<type-decl name='char' size-in-bits='8' id='type-id-45'/>
	<pointer-type-def type-id='type-id-45' size-in-bits='64' id='type-id-23'/>
	<class-decl name='_IO_marker' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-46'/>
	<pointer-type-def type-id='type-id-46' size-in-bits='64' id='type-id-33'/>
	<pointer-type-def type-id='type-id-32' size-in-bits='64' id='type-id-34'/>
	<type-decl name='long int' size-in-bits='64' id='type-id-47'/>
	<typedef-decl name='__off_t' type-id='type-id-47' filepath='/usr/include/x86_64-linux-gnu/bits/types.h' line='150' column='1' id='type-id-35'/>
	<type-decl name='unsigned short int' size-in-bits='16' id='type-id-36'/>
	<type-decl name='signed char' size-in-bits='8' id='type-id-37'/>
	<type-decl name='unsigned long int' size-in-bits='64' id='type-id-48'/>

	<array-type-def dimensions='1' type-id='type-id-45' size-in-bits='8' id='type-id-38'>
	<subrange length='1' type-id='type-id-48' id='type-id-49'/>

	</array-type-def>
	<typedef-decl name='__off64_t' type-id='type-id-47' filepath='/usr/include/x86_64-linux-gnu/bits/types.h' line='151' column='1' id='type-id-39'/>
	<class-decl name='_IO_codecvt' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-50'/>
	<pointer-type-def type-id='type-id-50' size-in-bits='64' id='type-id-40'/>
	<class-decl name='_IO_wide_data' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-51'/>
	<pointer-type-def type-id='type-id-51' size-in-bits='64' id='type-id-41'/>
	<type-decl name='void' id='type-id-52'/>
	<pointer-type-def type-id='type-id-52' size-in-bits='64' id='type-id-42'/>
	<typedef-decl name='size_t' type-id='type-id-48' filepath='/usr/lib/gcc/x86_64-linux-gnu/8/include/stddef.h' line='216' column='1' id='type-id-43'/>

	<array-type-def dimensions='1' type-id='type-id-45' size-in-bits='160' id='type-id-44'>
	<subrange length='20' type-id='type-id-48' id='type-id-53'/>

	</array-type-def>
	<typedef-decl name='FILE' type-id='type-id-32' filepath='/usr/include/x86_64-linux-gnu/bits/types/FILE.h' line='7' column='1' id='type-id-54'/>
	<pointer-type-def type-id='type-id-54' size-in-bits='64' id='type-id-26'/>
	<class-decl name='zpool_handle' size-in-bits='2560' is-struct='yes' visibility='default' filepath='../../include/libzfs_impl.h' line='98' column='1' id='type-id-55'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='zpool_hdl' type-id='type-id-17' visibility='default' filepath='../../include/libzfs_impl.h' line='99' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='zpool_next' type-id='type-id-18' visibility='default' filepath='../../include/libzfs_impl.h' line='100' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='zpool_name' type-id='type-id-19' visibility='default' filepath='../../include/libzfs_impl.h' line='101' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2176'>
	<var-decl name='zpool_state' type-id='type-id-6' visibility='default' filepath='../../include/libzfs_impl.h' line='102' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2240'>
	<var-decl name='zpool_config_size' type-id='type-id-43' visibility='default' filepath='../../include/libzfs_impl.h' line='103' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2304'>
	<var-decl name='zpool_config' type-id='type-id-22' visibility='default' filepath='../../include/libzfs_impl.h' line='104' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2368'>
	<var-decl name='zpool_old_config' type-id='type-id-22' visibility='default' filepath='../../include/libzfs_impl.h' line='105' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2432'>
	<var-decl name='zpool_props' type-id='type-id-22' visibility='default' filepath='../../include/libzfs_impl.h' line='106' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2496'>
	<var-decl name='zpool_start_block' type-id='type-id-56' visibility='default' filepath='../../include/libzfs_impl.h' line='107' column='1'/>
	</data-member>
	</class-decl>
	<typedef-decl name='libzfs_handle_t' type-id='type-id-25' filepath='../../include/libzfs.h' line='197' column='1' id='type-id-57'/>
	<pointer-type-def type-id='type-id-57' size-in-bits='64' id='type-id-17'/>
	<typedef-decl name='zpool_handle_t' type-id='type-id-55' filepath='../../include/libzfs.h' line='196' column='1' id='type-id-58'/>
	<pointer-type-def type-id='type-id-58' size-in-bits='64' id='type-id-18'/>

	<array-type-def dimensions='1' type-id='type-id-45' size-in-bits='2048' id='type-id-19'>
	<subrange length='256' type-id='type-id-48' id='type-id-59'/>

	</array-type-def>
	<class-decl name='nvlist' size-in-bits='192' is-struct='yes' visibility='default' filepath='../../include/sys/nvpair.h' line='85' column='1' id='type-id-60'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='nvl_version' type-id='type-id-61' visibility='default' filepath='../../include/sys/nvpair.h' line='86' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	<var-decl name='nvl_nvflag' type-id='type-id-62' visibility='default' filepath='../../include/sys/nvpair.h' line='87' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='nvl_priv' type-id='type-id-27' visibility='default' filepath='../../include/sys/nvpair.h' line='88' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='nvl_flag' type-id='type-id-62' visibility='default' filepath='../../include/sys/nvpair.h' line='89' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='160'>
	<var-decl name='nvl_pad' type-id='type-id-61' visibility='default' filepath='../../include/sys/nvpair.h' line='90' column='1'/>
	</data-member>
	</class-decl>
	<typedef-decl name='__int32_t' type-id='type-id-6' filepath='/usr/include/x86_64-linux-gnu/bits/types.h' line='40' column='1' id='type-id-63'/>
	<typedef-decl name='int32_t' type-id='type-id-63' filepath='/usr/include/x86_64-linux-gnu/bits/stdint-intn.h' line='26' column='1' id='type-id-61'/>
	<type-decl name='unsigned int' size-in-bits='32' id='type-id-64'/>
	<typedef-decl name='__uint32_t' type-id='type-id-64' filepath='/usr/include/x86_64-linux-gnu/bits/types.h' line='41' column='1' id='type-id-65'/>
	<typedef-decl name='uint32_t' type-id='type-id-65' filepath='/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h' line='26' column='1' id='type-id-62'/>
	<typedef-decl name='__uint64_t' type-id='type-id-48' filepath='/usr/include/x86_64-linux-gnu/bits/types.h' line='44' column='1' id='type-id-66'/>
	<typedef-decl name='uint64_t' type-id='type-id-66' filepath='/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h' line='27' column='1' id='type-id-27'/>
	<typedef-decl name='nvlist_t' type-id='type-id-60' filepath='../../include/sys/nvpair.h' line='91' column='1' id='type-id-67'/>
	<pointer-type-def type-id='type-id-67' size-in-bits='64' id='type-id-22'/>
	<type-decl name='long long int' size-in-bits='64' id='type-id-68'/>
	<typedef-decl name='longlong_t' type-id='type-id-68' filepath='../../lib/libspl/include/sys/stdtypes.h' line='36' column='1' id='type-id-69'/>
	<typedef-decl name='diskaddr_t' type-id='type-id-69' filepath='../../lib/libspl/include/sys/stdtypes.h' line='41' column='1' id='type-id-56'/>

	<array-type-def dimensions='1' type-id='type-id-45' size-in-bits='8192' id='type-id-28'>
	<subrange length='1024' type-id='type-id-48' id='type-id-70'/>

	</array-type-def>
	<union-decl name='__anonymous_union__' size-in-bits='320' is-anonymous='yes' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h' line='67' column='1' id='type-id-71'>
	<data-member access='private'>
	<var-decl name='__data' type-id='type-id-72' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h' line='69' column='1'/>
	</data-member>
	<data-member access='private'>
	<var-decl name='__size' type-id='type-id-73' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h' line='70' column='1'/>
	</data-member>
	<data-member access='private'>
	<var-decl name='__align' type-id='type-id-47' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h' line='71' column='1'/>
	</data-member>
	</union-decl>
	<class-decl name='__pthread_mutex_s' size-in-bits='320' is-struct='yes' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h' line='118' column='1' id='type-id-72'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='__lock' type-id='type-id-6' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h' line='120' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	<var-decl name='__count' type-id='type-id-64' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h' line='121' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='__owner' type-id='type-id-6' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h' line='122' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='96'>
	<var-decl name='__nusers' type-id='type-id-64' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h' line='124' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='__kind' type-id='type-id-6' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h' line='148' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='160'>
	<var-decl name='__spins' type-id='type-id-74' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h' line='154' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='176'>
	<var-decl name='__elision' type-id='type-id-74' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h' line='154' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='__list' type-id='type-id-75' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h' line='155' column='1'/>
	</data-member>
	</class-decl>
	<type-decl name='short int' size-in-bits='16' id='type-id-74'/>
	<class-decl name='__pthread_internal_list' size-in-bits='128' is-struct='yes' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h' line='82' column='1' id='type-id-76'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='__prev' type-id='type-id-77' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h' line='84' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='__next' type-id='type-id-77' visibility='default' filepath='/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h' line='85' column='1'/>
	</data-member>
	</class-decl>
	<pointer-type-def type-id='type-id-76' size-in-bits='64' id='type-id-77'/>
	<typedef-decl name='__pthread_list_t' type-id='type-id-76' filepath='/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h' line='86' column='1' id='type-id-75'/>

	<array-type-def dimensions='1' type-id='type-id-45' size-in-bits='320' id='type-id-73'>
	<subrange length='40' type-id='type-id-48' id='type-id-78'/>

	</array-type-def>
	<typedef-decl name='pthread_mutex_t' type-id='type-id-71' filepath='/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h' line='72' column='1' id='type-id-29'/>
	<class-decl name='avl_tree' size-in-bits='320' is-struct='yes' visibility='default' filepath='../../include/sys/avl_impl.h' line='146' column='1' id='type-id-79'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='avl_root' type-id='type-id-80' visibility='default' filepath='../../include/sys/avl_impl.h' line='147' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='avl_compar' type-id='type-id-81' visibility='default' filepath='../../include/sys/avl_impl.h' line='148' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='avl_offset' type-id='type-id-43' visibility='default' filepath='../../include/sys/avl_impl.h' line='149' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='avl_numnodes' type-id='type-id-82' visibility='default' filepath='../../include/sys/avl_impl.h' line='150' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='avl_size' type-id='type-id-43' visibility='default' filepath='../../include/sys/avl_impl.h' line='151' column='1'/>
	</data-member>
	</class-decl>
	<class-decl name='avl_node' size-in-bits='192' is-struct='yes' visibility='default' filepath='../../include/sys/avl_impl.h' line='90' column='1' id='type-id-83'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='avl_child' type-id='type-id-84' visibility='default' filepath='../../include/sys/avl_impl.h' line='91' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='avl_pcb' type-id='type-id-85' visibility='default' filepath='../../include/sys/avl_impl.h' line='92' column='1'/>
	</data-member>
	</class-decl>
	<pointer-type-def type-id='type-id-83' size-in-bits='64' id='type-id-80'/>

	<array-type-def dimensions='1' type-id='type-id-80' size-in-bits='128' id='type-id-84'>
	<subrange length='2' type-id='type-id-48' id='type-id-86'/>

	</array-type-def>
	<typedef-decl name='uintptr_t' type-id='type-id-48' filepath='/usr/include/stdint.h' line='90' column='1' id='type-id-85'/>
	<pointer-type-def type-id='type-id-87' size-in-bits='64' id='type-id-81'/>
	<typedef-decl name='ulong_t' type-id='type-id-48' filepath='../../lib/libspl/include/sys/stdtypes.h' line='34' column='1' id='type-id-82'/>
	<typedef-decl name='avl_tree_t' type-id='type-id-79' filepath='../../include/sys/avl.h' line='119' column='1' id='type-id-30'/>
	<class-decl name='re_pattern_buffer' size-in-bits='512' is-struct='yes' visibility='default' filepath='/usr/include/regex.h' line='413' column='1' id='type-id-88'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='buffer' type-id='type-id-89' visibility='default' filepath='/usr/include/regex.h' line='417' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='allocated' type-id='type-id-90' visibility='default' filepath='/usr/include/regex.h' line='420' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='used' type-id='type-id-90' visibility='default' filepath='/usr/include/regex.h' line='423' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='syntax' type-id='type-id-91' visibility='default' filepath='/usr/include/regex.h' line='426' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='fastmap' type-id='type-id-23' visibility='default' filepath='/usr/include/regex.h' line='431' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='translate' type-id='type-id-92' visibility='default' filepath='/usr/include/regex.h' line='437' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='re_nsub' type-id='type-id-43' visibility='default' filepath='/usr/include/regex.h' line='440' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='31'>
	<var-decl name='can_be_null' type-id='type-id-64' visibility='default' filepath='/usr/include/regex.h' line='446' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='29'>
	<var-decl name='regs_allocated' type-id='type-id-64' visibility='default' filepath='/usr/include/regex.h' line='457' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='28'>
	<var-decl name='fastmap_accurate' type-id='type-id-64' visibility='default' filepath='/usr/include/regex.h' line='461' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='27'>
	<var-decl name='no_sub' type-id='type-id-64' visibility='default' filepath='/usr/include/regex.h' line='465' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='26'>
	<var-decl name='not_bol' type-id='type-id-64' visibility='default' filepath='/usr/include/regex.h' line='469' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='25'>
	<var-decl name='not_eol' type-id='type-id-64' visibility='default' filepath='/usr/include/regex.h' line='472' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='24'>
	<var-decl name='newline_anchor' type-id='type-id-64' visibility='default' filepath='/usr/include/regex.h' line='475' column='1'/>
	</data-member>
	</class-decl>
	<class-decl name='re_dfa_t' is-struct='yes' visibility='default' is-declaration-only='yes' id='type-id-93'/>
	<pointer-type-def type-id='type-id-93' size-in-bits='64' id='type-id-89'/>
	<typedef-decl name='__re_long_size_t' type-id='type-id-48' filepath='/usr/include/regex.h' line='56' column='1' id='type-id-90'/>
	<typedef-decl name='reg_syntax_t' type-id='type-id-48' filepath='/usr/include/regex.h' line='72' column='1' id='type-id-91'/>
	<type-decl name='unsigned char' size-in-bits='8' id='type-id-94'/>
	<pointer-type-def type-id='type-id-94' size-in-bits='64' id='type-id-92'/>
	<typedef-decl name='regex_t' type-id='type-id-88' filepath='/usr/include/regex.h' line='478' column='1' id='type-id-31'/>
	<enum-decl name='__anonymous_enum__' is-anonymous='yes' filepath='../../include/sys/fs/zfs.h' line='52' column='1' id='type-id-95'>
	<underlying-type type-id='type-id-7'/>
	<enumerator name='ZFS_TYPE_FILESYSTEM' value='1'/>
	<enumerator name='ZFS_TYPE_SNAPSHOT' value='2'/>
	<enumerator name='ZFS_TYPE_VOLUME' value='4'/>
	<enumerator name='ZFS_TYPE_POOL' value='8'/>
	<enumerator name='ZFS_TYPE_BOOKMARK' value='16'/>
	</enum-decl>
	<typedef-decl name='zfs_type_t' type-id='type-id-95' filepath='../../include/sys/fs/zfs.h' line='58' column='1' id='type-id-20'/>
	<class-decl name='dmu_objset_stats' size-in-bits='2304' is-struct='yes' visibility='default' filepath='../../include/sys/dmu.h' line='931' column='1' id='type-id-96'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='dds_num_clones' type-id='type-id-27' visibility='default' filepath='../../include/sys/dmu.h' line='932' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='dds_creation_txg' type-id='type-id-27' visibility='default' filepath='../../include/sys/dmu.h' line='933' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='dds_guid' type-id='type-id-27' visibility='default' filepath='../../include/sys/dmu.h' line='934' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='dds_type' type-id='type-id-97' visibility='default' filepath='../../include/sys/dmu.h' line='935' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='224'>
	<var-decl name='dds_is_snapshot' type-id='type-id-98' visibility='default' filepath='../../include/sys/dmu.h' line='936' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='232'>
	<var-decl name='dds_inconsistent' type-id='type-id-98' visibility='default' filepath='../../include/sys/dmu.h' line='937' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='240'>
	<var-decl name='dds_redacted' type-id='type-id-98' visibility='default' filepath='../../include/sys/dmu.h' line='938' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='248'>
	<var-decl name='dds_origin' type-id='type-id-19' visibility='default' filepath='../../include/sys/dmu.h' line='939' column='1'/>
	</data-member>
	</class-decl>
	<enum-decl name='dmu_objset_type' filepath='../../include/sys/fs/zfs.h' line='64' column='1' id='type-id-99'>
	<underlying-type type-id='type-id-7'/>
	<enumerator name='DMU_OST_NONE' value='0'/>
	<enumerator name='DMU_OST_META' value='1'/>
	<enumerator name='DMU_OST_ZFS' value='2'/>
	<enumerator name='DMU_OST_ZVOL' value='3'/>
	<enumerator name='DMU_OST_OTHER' value='4'/>
	<enumerator name='DMU_OST_ANY' value='5'/>
	<enumerator name='DMU_OST_NUMTYPES' value='6'/>
	</enum-decl>
	<typedef-decl name='dmu_objset_type_t' type-id='type-id-99' filepath='../../include/sys/fs/zfs.h' line='72' column='1' id='type-id-97'/>
	<typedef-decl name='__uint8_t' type-id='type-id-94' filepath='/usr/include/x86_64-linux-gnu/bits/types.h' line='37' column='1' id='type-id-100'/>
	<typedef-decl name='uint8_t' type-id='type-id-100' filepath='/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h' line='24' column='1' id='type-id-98'/>
	<typedef-decl name='dmu_objset_stats_t' type-id='type-id-96' filepath='../../include/sys/dmu.h' line='940' column='1' id='type-id-21'/>
	<pointer-type-def type-id='type-id-98' size-in-bits='64' id='type-id-24'/>
	<typedef-decl name='zfs_handle_t' type-id='type-id-16' filepath='../../include/libzfs.h' line='195' column='1' id='type-id-101'/>
	<pointer-type-def type-id='type-id-101' size-in-bits='64' id='type-id-102'/>
	<function-decl name='changelist_gather' mangled-name='changelist_gather' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='624' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='changelist_gather'>
	<parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='624' column='1'/>
	<parameter type-id='type-id-2' name='prop' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='624' column='1'/>
	<parameter type-id='type-id-6' name='gather_flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='624' column='1'/>
	<parameter type-id='type-id-6' name='mnt_flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='625' column='1'/>
	<return type-id='type-id-15'/>
	</function-decl>
	<function-decl name='changelist_free' mangled-name='changelist_free' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='412' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='changelist_free'>
	<parameter type-id='type-id-15' name='clp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='412' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	<qualified-type-def type-id='type-id-45' const='yes' id='type-id-103'/>
	<pointer-type-def type-id='type-id-103' size-in-bits='64' id='type-id-104'/>
	<function-decl name='changelist_remove' mangled-name='changelist_remove' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='387' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='changelist_remove'>
	<parameter type-id='type-id-15' name='clp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='387' column='1'/>
	<parameter type-id='type-id-104' name='name' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='387' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='changelist_haszonedchild' mangled-name='changelist_haszonedchild' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='378' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='changelist_haszonedchild'>
	<parameter type-id='type-id-15' name='clp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='378' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<enum-decl name='__anonymous_enum__' is-anonymous='yes' filepath='../../include/libzfs_impl.h' line='110' column='1' id='type-id-105'>
	<underlying-type type-id='type-id-7'/>
	<enumerator name='PROTO_NFS' value='0'/>
	<enumerator name='PROTO_SMB' value='1'/>
	<enumerator name='PROTO_END' value='2'/>
	</enum-decl>
	<typedef-decl name='zfs_share_proto_t' type-id='type-id-105' filepath='../../include/libzfs_impl.h' line='114' column='1' id='type-id-106'/>
	<pointer-type-def type-id='type-id-106' size-in-bits='64' id='type-id-107'/>
	<function-decl name='changelist_unshare' mangled-name='changelist_unshare' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='348' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='changelist_unshare'>
	<parameter type-id='type-id-15' name='clp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='348' column='1'/>
	<parameter type-id='type-id-107' name='proto' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='348' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='changelist_rename' mangled-name='changelist_rename' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='311' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='changelist_rename'>
	<parameter type-id='type-id-15' name='clp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='311' column='1'/>
	<parameter type-id='type-id-104' name='src' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='311' column='1'/>
	<parameter type-id='type-id-104' name='dst' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='311' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='isa_child_of' mangled-name='isa_child_of' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='288' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='isa_child_of'>
	<parameter type-id='type-id-104' name='dataset' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='288' column='1'/>
	<parameter type-id='type-id-104' name='parent' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='288' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	<function-decl name='changelist_postfix' mangled-name='changelist_postfix' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='170' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='changelist_postfix'>
	<parameter type-id='type-id-15' name='clp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='170' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='changelist_prefix' mangled-name='changelist_prefix' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='96' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='changelist_prefix'>
	<parameter type-id='type-id-15' name='clp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_changelist.c' line='96' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zfs_alloc' mangled-name='zfs_alloc' filepath='../../include/libzfs_impl.h' line='139' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='uu_avl_pool_create' mangled-name='uu_avl_pool_create' filepath='../../include/libuutil.h' line='332' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='uu_avl_create' mangled-name='uu_avl_create' filepath='../../include/libuutil.h' line='351' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_prop_get' mangled-name='zfs_prop_get' filepath='../../include/libzfs.h' line='493' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_prop_get' mangled-name='zfs_prop_get' filepath='../../include/libzfs.h' line='494' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_iter_dependents' mangled-name='zfs_iter_dependents' filepath='../../include/libzfs.h' line='614' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_iter_dependents' mangled-name='zfs_iter_dependents' filepath='../../include/libzfs.h' line='615' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_get_name' mangled-name='zfs_get_name' filepath='../../include/libzfs.h' line='470' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_get_name' mangled-name='zfs_get_name' filepath='../../include/libzfs.h' line='471' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_open' mangled-name='zfs_open' filepath='../../include/libzfs.h' line='466' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_open' mangled-name='zfs_open' filepath='../../include/libzfs.h' line='467' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_is_shared' mangled-name='zfs_is_shared' filepath='../../include/libzfs.h' line='836' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_is_shared' mangled-name='zfs_is_shared' filepath='../../include/libzfs.h' line='840' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_prop_get_int' mangled-name='zfs_prop_get_int' filepath='../../include/libzfs.h' line='510' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_prop_get_int' mangled-name='zfs_prop_get_int' filepath='../../include/libzfs.h' line='511' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='uu_avl_node_init' mangled-name='uu_avl_node_init' filepath='../../include/libuutil.h' line='348' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='uu_avl_find' mangled-name='uu_avl_find' filepath='../../include/libuutil.h' line='370' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='free' mangled-name='free' filepath='/usr/include/stdlib.h' line='563' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_close' mangled-name='zfs_close' filepath='../../include/libzfs.h' line='468' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_close' mangled-name='zfs_close' filepath='../../include/libzfs.h' line='469' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_iter_children' mangled-name='zfs_iter_children' filepath='../../include/libzfs.h' line='613' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_iter_children' mangled-name='zfs_iter_children' filepath='../../include/libzfs.h' line='614' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_iter_mounted' mangled-name='zfs_iter_mounted' filepath='../../include/libzfs.h' line='622' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_iter_mounted' mangled-name='zfs_iter_mounted' filepath='../../include/libzfs.h' line='623' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_is_mounted' mangled-name='zfs_is_mounted' filepath='../../include/libzfs.h' line='820' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_is_mounted' mangled-name='zfs_is_mounted' filepath='../../include/libzfs.h' line='824' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='uu_avl_insert' mangled-name='uu_avl_insert' filepath='../../include/libuutil.h' line='371' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_error' mangled-name='zfs_error' filepath='../../include/libzfs_impl.h' line='136' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='strcmp' mangled-name='strcmp' filepath='/usr/include/string.h' line='136' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_get_handle' mangled-name='zfs_get_handle' filepath='../../include/libzfs.h' line='210' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='getzoneid' mangled-name='getzoneid' filepath='../../include/sys/zfs_context.h' line='731' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='getzoneid' mangled-name='getzoneid' filepath='../../include/sys/zfs_context.h' line='732' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='uu_avl_walk_start' mangled-name='uu_avl_walk_start' filepath='../../include/libuutil.h' line='366' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='uu_avl_remove' mangled-name='uu_avl_remove' filepath='../../include/libuutil.h' line='378' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='uu_avl_walk_next' mangled-name='uu_avl_walk_next' filepath='../../include/libuutil.h' line='367' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='uu_avl_walk_end' mangled-name='uu_avl_walk_end' filepath='../../include/libuutil.h' line='368' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='uu_avl_destroy' mangled-name='uu_avl_destroy' filepath='../../include/libuutil.h' line='354' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='uu_avl_pool_destroy' mangled-name='uu_avl_pool_destroy' filepath='../../include/libuutil.h' line='336' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_unshare_proto' mangled-name='zfs_unshare_proto' filepath='../../include/libzfs_impl.h' line='211' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_commit_proto' mangled-name='zfs_commit_proto' filepath='../../include/libzfs_impl.h' line='260' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='remove_mountpoint' mangled-name='remove_mountpoint' filepath='../../include/libzfs_impl.h' line='192' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='strlcpy' mangled-name='strlcpy' filepath='../../lib/libspl/include/string.h' line='37' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='strlen' mangled-name='strlen' filepath='/usr/include/string.h' line='384' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='strlcat' mangled-name='strlcat' filepath='../../lib/libspl/include/string.h' line='33' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='strncmp' mangled-name='strncmp' filepath='/usr/include/string.h' line='139' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_refresh_properties' mangled-name='zfs_refresh_properties' filepath='../../include/libzfs.h' line='806' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_refresh_properties' mangled-name='zfs_refresh_properties' filepath='../../include/libzfs.h' line='810' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_share_nfs' mangled-name='zfs_share_nfs' filepath='../../include/libzfs.h' line='845' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_share_nfs' mangled-name='zfs_share_nfs' filepath='../../include/libzfs.h' line='849' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_unshare_smb' mangled-name='zfs_unshare_smb' filepath='../../include/libzfs.h' line='849' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_unshare_smb' mangled-name='zfs_unshare_smb' filepath='../../include/libzfs.h' line='853' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_unshare_nfs' mangled-name='zfs_unshare_nfs' filepath='../../include/libzfs.h' line='848' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_unshare_nfs' mangled-name='zfs_unshare_nfs' filepath='../../include/libzfs.h' line='852' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_share_smb' mangled-name='zfs_share_smb' filepath='../../include/libzfs.h' line='846' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_share_smb' mangled-name='zfs_share_smb' filepath='../../include/libzfs.h' line='850' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_mount' mangled-name='zfs_mount' filepath='../../include/libzfs.h' line='821' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_mount' mangled-name='zfs_mount' filepath='../../include/libzfs.h' line='825' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='uu_avl_last' mangled-name='uu_avl_last' filepath='../../include/libuutil.h' line='359' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_commit_nfs_shares' mangled-name='zfs_commit_nfs_shares' filepath='../../include/libzfs.h' line='857' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_commit_nfs_shares' mangled-name='zfs_commit_nfs_shares' filepath='../../include/libzfs.h' line='861' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_commit_smb_shares' mangled-name='zfs_commit_smb_shares' filepath='../../include/libzfs.h' line='858' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_commit_smb_shares' mangled-name='zfs_commit_smb_shares' filepath='../../include/libzfs.h' line='862' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_unmount' mangled-name='zfs_unmount' filepath='../../include/libzfs.h' line='823' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_unmount' mangled-name='zfs_unmount' filepath='../../include/libzfs.h' line='827' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-type size-in-bits='64' id='type-id-87'>
	<parameter type-id='type-id-42'/>
	<parameter type-id='type-id-42'/>
	<return type-id='type-id-6'/>
	</function-type>
	</abi-instr>
	<abi-instr version='1.0' address-size='64' path='libzfs_config.c' comp-dir-path='/home/colm/src/zfs/zfs/lib/libzfs' language='LANG_C99'>
	<pointer-type-def type-id='type-id-108' size-in-bits='64' id='type-id-109'/>
	- <typedef-decl name='zfs_iter_f' type-id='type-id-109' filepath='../../include/libzfs.h' line='611' column='1' id='type-id-110'/>
	+ <typedef-decl name='zfs_iter_f' type-id='type-id-109' filepath='../../include/libzfs.h' line='612' column='1' id='type-id-110'/>
	<function-decl name='zfs_iter_root' mangled-name='zfs_iter_root' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_config.c' line='434' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_root'>
	<parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_config.c' line='434' column='1'/>
	<parameter type-id='type-id-110' name='func' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_config.c' line='434' column='1'/>
	<parameter type-id='type-id-42' name='data' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_config.c' line='434' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<pointer-type-def type-id='type-id-111' size-in-bits='64' id='type-id-112'/>
	<typedef-decl name='zpool_iter_f' type-id='type-id-112' filepath='../../include/libzfs.h' line='246' column='1' id='type-id-113'/>
	<function-decl name='zpool_iter' mangled-name='zpool_iter' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_config.c' line='389' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_iter'>
	<parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_config.c' line='389' column='1'/>
	<parameter type-id='type-id-113' name='func' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_config.c' line='389' column='1'/>
	<parameter type-id='type-id-42' name='data' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_config.c' line='389' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zpool_skip_pool' mangled-name='zpool_skip_pool' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_config.c' line='340' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_skip_pool'>
	<parameter type-id='type-id-104' name='poolname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_config.c' line='340' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	<pointer-type-def type-id='type-id-5' size-in-bits='64' id='type-id-114'/>
	<function-decl name='zpool_refresh_stats' mangled-name='zpool_refresh_stats' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_config.c' line='265' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_refresh_stats'>
	<parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_config.c' line='265' column='1'/>
	<parameter type-id='type-id-114' name='missing' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_config.c' line='265' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zpool_get_features' mangled-name='zpool_get_features' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_config.c' line='232' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_features'>
	<parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_config.c' line='232' column='1'/>
	<return type-id='type-id-22'/>
	</function-decl>
	<pointer-type-def type-id='type-id-22' size-in-bits='64' id='type-id-115'/>
	<function-decl name='zpool_get_config' mangled-name='zpool_get_config' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_config.c' line='220' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_config'>
	<parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_config.c' line='220' column='1'/>
	<parameter type-id='type-id-115' name='oldconfig' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_config.c' line='220' column='1'/>
	<return type-id='type-id-22'/>
	</function-decl>
	<function-decl name='namespace_clear' mangled-name='namespace_clear' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_config.c' line='79' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='namespace_clear'>
	<parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_config.c' line='79' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='uu_avl_first' mangled-name='uu_avl_first' filepath='../../include/libuutil.h' line='358' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='make_dataset_handle' mangled-name='make_dataset_handle' filepath='../../include/libzfs_impl.h' line='196' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='uu_avl_next' mangled-name='uu_avl_next' filepath='../../include/libuutil.h' line='361' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zpool_open_silent' mangled-name='zpool_open_silent' filepath='../../include/libzfs_impl.h' line='200' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='strchr' mangled-name='strchr' filepath='/usr/include/string.h' line='225' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='getenv' mangled-name='getenv' filepath='/usr/include/stdlib.h' line='631' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='__builtin_memset' mangled-name='memset' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='strcpy' mangled-name='strcpy' filepath='/usr/include/string.h' line='121' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zcmd_alloc_dst_nvlist' mangled-name='zcmd_alloc_dst_nvlist' filepath='../../include/libzfs_impl.h' line='176' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='__errno_location' mangled-name='__errno_location' filepath='/usr/include/errno.h' line='37' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zcmd_expand_dst_nvlist' mangled-name='zcmd_expand_dst_nvlist' filepath='../../include/libzfs_impl.h' line='179' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_ioctl' mangled-name='zfs_ioctl' filepath='../../include/libzfs.h' line='454' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_ioctl' mangled-name='zfs_ioctl' filepath='../../include/libzfs.h' line='455' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zcmd_read_dst_nvlist' mangled-name='zcmd_read_dst_nvlist' filepath='../../include/libzfs_impl.h' line='180' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zcmd_free_nvlists' mangled-name='zcmd_free_nvlists' filepath='../../include/libzfs_impl.h' line='181' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='nvlist_free' mangled-name='nvlist_free' filepath='../../include/sys/nvpair.h' line='152' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='nvlist_exists' mangled-name='nvlist_exists' filepath='../../include/sys/nvpair.h' line='238' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='nvlist_lookup_nvlist' mangled-name='nvlist_lookup_nvlist' filepath='../../include/sys/nvpair.h' line='214' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='libspl_assertf' mangled-name='libspl_assertf' filepath='../../lib/libspl/include/assert.h' line='40' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='no_memory' mangled-name='no_memory' filepath='../../include/libzfs_impl.h' line='143' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='nvlist_dup' mangled-name='nvlist_dup' filepath='../../include/sys/nvpair.h' line='156' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='nvpair_name' mangled-name='nvpair_name' filepath='../../include/sys/nvpair.h' line='244' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_strdup' mangled-name='zfs_strdup' filepath='../../include/libzfs_impl.h' line='142' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='nvpair_value_nvlist' mangled-name='nvpair_value_nvlist' filepath='../../include/sys/nvpair.h' line='258' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='dcgettext' mangled-name='dcgettext' filepath='/usr/include/libintl.h' line='51' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_standard_error' mangled-name='zfs_standard_error' filepath='../../include/libzfs_impl.h' line='145' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='uu_avl_teardown' mangled-name='uu_avl_teardown' filepath='../../include/libuutil.h' line='376' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='nvlist_next_nvpair' mangled-name='nvlist_next_nvpair' filepath='../../include/sys/nvpair.h' line='242' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-type size-in-bits='64' id='type-id-108'>
	<parameter type-id='type-id-102'/>
	<parameter type-id='type-id-42'/>
	<return type-id='type-id-6'/>
	</function-type>
	<function-type size-in-bits='64' id='type-id-111'>
	<parameter type-id='type-id-18'/>
	<parameter type-id='type-id-42'/>
	<return type-id='type-id-6'/>
	</function-type>
	</abi-instr>
	<abi-instr version='1.0' address-size='64' path='libzfs_crypto.c' comp-dir-path='/home/colm/src/zfs/zfs/lib/libzfs' language='LANG_C99'>
	- <function-decl name='zfs_crypto_rewrap' mangled-name='zfs_crypto_rewrap' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='1389' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_crypto_rewrap'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='1389' column='1'/>
	- <parameter type-id='type-id-22' name='raw_props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='1389' column='1'/>
	- <parameter type-id='type-id-5' name='inheritkey' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='1389' column='1'/>
	+ <function-decl name='zfs_crypto_rewrap' mangled-name='zfs_crypto_rewrap' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='1387' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_crypto_rewrap'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='1387' column='1'/>
	+ <parameter type-id='type-id-22' name='raw_props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='1387' column='1'/>
	+ <parameter type-id='type-id-5' name='inheritkey' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='1387' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_crypto_unload_key' mangled-name='zfs_crypto_unload_key' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='1253' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_crypto_unload_key'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='1253' column='1'/>
	+ <function-decl name='zfs_crypto_unload_key' mangled-name='zfs_crypto_unload_key' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='1251' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_crypto_unload_key'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='1251' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_crypto_load_key' mangled-name='zfs_crypto_load_key' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='1085' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_crypto_load_key'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='1085' column='1'/>
	- <parameter type-id='type-id-5' name='noop' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='1085' column='1'/>
	- <parameter type-id='type-id-23' name='alt_keylocation' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='1085' column='1'/>
	+ <function-decl name='zfs_crypto_load_key' mangled-name='zfs_crypto_load_key' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='1083' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_crypto_load_key'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='1083' column='1'/>
	+ <parameter type-id='type-id-5' name='noop' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='1083' column='1'/>
	+ <parameter type-id='type-id-23' name='alt_keylocation' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='1083' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_crypto_attempt_load_keys' mangled-name='zfs_crypto_attempt_load_keys' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='1050' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_crypto_attempt_load_keys'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='1050' column='1'/>
	- <parameter type-id='type-id-23' name='fsname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='1050' column='1'/>
	+ <function-decl name='zfs_crypto_attempt_load_keys' mangled-name='zfs_crypto_attempt_load_keys' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='1048' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_crypto_attempt_load_keys'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='1048' column='1'/>
	+ <parameter type-id='type-id-23' name='fsname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='1048' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_crypto_clone_check' mangled-name='zfs_crypto_clone_check' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='984' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_crypto_clone_check'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='984' column='1'/>
	- <parameter type-id='type-id-102' name='origin_zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='984' column='1'/>
	- <parameter type-id='type-id-23' name='parent_name' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='985' column='1'/>
	- <parameter type-id='type-id-22' name='props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='985' column='1'/>
	+ <function-decl name='zfs_crypto_clone_check' mangled-name='zfs_crypto_clone_check' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='982' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_crypto_clone_check'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='982' column='1'/>
	+ <parameter type-id='type-id-102' name='origin_zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='982' column='1'/>
	+ <parameter type-id='type-id-23' name='parent_name' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='983' column='1'/>
	+ <parameter type-id='type-id-22' name='props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='983' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<pointer-type-def type-id='type-id-24' size-in-bits='64' id='type-id-116'/>
	<typedef-decl name='uint_t' type-id='type-id-64' filepath='../../lib/libspl/include/sys/stdtypes.h' line='33' column='1' id='type-id-117'/>
	<pointer-type-def type-id='type-id-117' size-in-bits='64' id='type-id-118'/>
	- <function-decl name='zfs_crypto_create' mangled-name='zfs_crypto_create' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='812' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_crypto_create'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='812' column='1'/>
	- <parameter type-id='type-id-23' name='parent_name' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='812' column='1'/>
	- <parameter type-id='type-id-22' name='props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='812' column='1'/>
	- <parameter type-id='type-id-22' name='pool_props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='813' column='1'/>
	- <parameter type-id='type-id-5' name='stdin_available' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='813' column='1'/>
	- <parameter type-id='type-id-116' name='wkeydata_out' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='813' column='1'/>
	- <parameter type-id='type-id-118' name='wkeylen_out' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='814' column='1'/>
	+ <function-decl name='zfs_crypto_create' mangled-name='zfs_crypto_create' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='810' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_crypto_create'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='810' column='1'/>
	+ <parameter type-id='type-id-23' name='parent_name' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='810' column='1'/>
	+ <parameter type-id='type-id-22' name='props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='810' column='1'/>
	+ <parameter type-id='type-id-22' name='pool_props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='811' column='1'/>
	+ <parameter type-id='type-id-5' name='stdin_available' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='811' column='1'/>
	+ <parameter type-id='type-id-116' name='wkeydata_out' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='811' column='1'/>
	+ <parameter type-id='type-id-118' name='wkeylen_out' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='812' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_crypto_get_encryption_root' mangled-name='zfs_crypto_get_encryption_root' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='781' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_crypto_get_encryption_root'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='781' column='1'/>
	- <parameter type-id='type-id-114' name='is_encroot' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='781' column='1'/>
	- <parameter type-id='type-id-23' name='buf' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='782' column='1'/>
	+ <function-decl name='zfs_crypto_get_encryption_root' mangled-name='zfs_crypto_get_encryption_root' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='779' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_crypto_get_encryption_root'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='779' column='1'/>
	+ <parameter type-id='type-id-114' name='is_encroot' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='779' column='1'/>
	+ <parameter type-id='type-id-23' name='buf' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_crypto.c' line='780' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zfs_name_to_prop' mangled-name='zfs_name_to_prop' filepath='../../include/sys/fs/zfs.h' line='313' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_error_aux' mangled-name='zfs_error_aux' filepath='../../include/libzfs_impl.h' line='138' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fnvlist_alloc' mangled-name='fnvlist_alloc' filepath='../../include/sys/nvpair.h' line='276' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_valid_proplist' mangled-name='zfs_valid_proplist' filepath='../../include/libzfs.h' line='487' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_valid_proplist' mangled-name='zfs_valid_proplist' filepath='../../include/libzfs.h' line='488' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='snprintf' mangled-name='snprintf' filepath='/usr/include/stdio.h' line='354' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_parent_name' mangled-name='zfs_parent_name' filepath='../../include/libzfs.h' line='810' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_parent_name' mangled-name='zfs_parent_name' filepath='../../include/libzfs.h' line='814' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='lzc_change_key' mangled-name='lzc_change_key' filepath='../../include/libzfs_core.h' line='64' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_prop_to_name' mangled-name='zfs_prop_to_name' filepath='../../include/libzfs.h' line='490' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_prop_to_name' mangled-name='zfs_prop_to_name' filepath='../../include/libzfs.h' line='491' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='nvlist_lookup_uint64' mangled-name='nvlist_lookup_uint64' filepath='../../include/sys/nvpair.h' line='212' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='nvlist_lookup_string' mangled-name='nvlist_lookup_string' filepath='../../include/sys/nvpair.h' line='213' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='nvlist_add_uint64' mangled-name='nvlist_add_uint64' filepath='../../include/sys/nvpair.h' line='178' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='nvlist_add_string' mangled-name='nvlist_add_string' filepath='../../include/sys/nvpair.h' line='179' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='lzc_unload_key' mangled-name='lzc_unload_key' filepath='../../include/libzfs_core.h' line='63' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='lzc_load_key' mangled-name='lzc_load_key' filepath='../../include/libzfs_core.h' line='62' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_handle_dup' mangled-name='zfs_handle_dup' filepath='../../include/libzfs.h' line='467' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_handle_dup' mangled-name='zfs_handle_dup' filepath='../../include/libzfs.h' line='468' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='printf' mangled-name='printf' filepath='/usr/include/stdio.h' line='332' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_iter_filesystems' mangled-name='zfs_iter_filesystems' filepath='../../include/libzfs.h' line='615' column='1' visibility='default' binding='global' size-in-bits='64'>
	- <return type-id='type-id-52'/>
	- </function-decl>
	- <function-decl name='read' mangled-name='read' filepath='/usr/include/unistd.h' line='360' column='1' visibility='default' binding='global' size-in-bits='64'>
	- <return type-id='type-id-52'/>
	- </function-decl>
	- <function-decl name='open' mangled-name='open64' filepath='/usr/include/fcntl.h' line='171' column='1' visibility='default' binding='global' size-in-bits='64'>
	- <return type-id='type-id-52'/>
	- </function-decl>
	- <function-decl name='close' mangled-name='close' filepath='/usr/include/unistd.h' line='353' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_iter_filesystems' mangled-name='zfs_iter_filesystems' filepath='../../include/libzfs.h' line='616' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='calloc' mangled-name='calloc' filepath='/usr/include/stdlib.h' line='541' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='__builtin_memcpy' mangled-name='memcpy' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='regexec' mangled-name='regexec' filepath='/usr/include/regex.h' line='643' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fileno' mangled-name='fileno' filepath='/usr/include/stdio.h' line='792' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='isatty' mangled-name='isatty' filepath='/usr/include/unistd.h' line='779' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='__getdelim' mangled-name='__getdelim' filepath='/usr/include/stdio.h' line='609' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='sigemptyset' mangled-name='sigemptyset' filepath='/usr/include/signal.h' line='196' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='sigaction' mangled-name='sigaction' filepath='/usr/include/signal.h' line='240' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fputc' mangled-name='fputc' filepath='/usr/include/stdio.h' line='527' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fflush' mangled-name='fflush' filepath='/usr/include/stdio.h' line='218' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='tcgetattr' mangled-name='tcgetattr' filepath='/usr/include/termios.h' line='66' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='tcsetattr' mangled-name='tcsetattr' filepath='/usr/include/termios.h' line='70' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='__builtin_putchar' mangled-name='putchar' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='getpid' mangled-name='getpid' filepath='/usr/include/unistd.h' line='628' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='kill' mangled-name='kill' filepath='/usr/include/signal.h' line='112' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='__ctype_b_loc' mangled-name='__ctype_b_loc' filepath='/usr/include/ctype.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zpool_get_features' mangled-name='zpool_get_features' filepath='../../include/libzfs.h' line='412' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zpool_get_features' mangled-name='zpool_get_features' filepath='../../include/libzfs.h' line='413' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zpool_get_prop_int' mangled-name='zpool_get_prop_int' filepath='../../include/libzfs.h' line='329' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='malloc' mangled-name='malloc' filepath='/usr/include/stdlib.h' line='539' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fread' mangled-name='fread' filepath='/usr/include/stdio.h' line='652' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='ferror' mangled-name='ferror' filepath='/usr/include/stdio.h' line='767' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fopen' mangled-name='fopen64' filepath='/usr/include/stdio.h' line='257' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fclose' mangled-name='fclose' filepath='/usr/include/stdio.h' line='213' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='sscanf' mangled-name='sscanf' filepath='/usr/include/stdio.h' line='399' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='__builtin_memmove' mangled-name='memmove' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='PKCS5_PBKDF2_HMAC_SHA1' mangled-name='PKCS5_PBKDF2_HMAC_SHA1' filepath='/usr/include/openssl/evp.h' line='1087' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	+ <function-decl name='read' mangled-name='read' filepath='/usr/include/unistd.h' line='360' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <return type-id='type-id-52'/>
	+ </function-decl>
	+ <function-decl name='open' mangled-name='open64' filepath='/usr/include/fcntl.h' line='171' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <return type-id='type-id-52'/>
	+ </function-decl>
	+ <function-decl name='close' mangled-name='close' filepath='/usr/include/unistd.h' line='353' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <return type-id='type-id-52'/>
	+ </function-decl>
	</abi-instr>
	<abi-instr version='1.0' address-size='64' path='libzfs_dataset.c' comp-dir-path='/home/colm/src/zfs/zfs/lib/libzfs' language='LANG_C99'>
	- <enum-decl name='__anonymous_enum__' is-anonymous='yes' filepath='../../include/sys/fs/zfs.h' line='1431' column='1' id='type-id-119'>
	+ <enum-decl name='__anonymous_enum__' is-anonymous='yes' filepath='../../include/sys/fs/zfs.h' line='1439' column='1' id='type-id-119'>
	<underlying-type type-id='type-id-7'/>
	<enumerator name='ZFS_WAIT_DELETEQ' value='0'/>
	<enumerator name='ZFS_WAIT_NUM_ACTIVITIES' value='1'/>
	</enum-decl>
	- <typedef-decl name='zfs_wait_activity_t' type-id='type-id-119' filepath='../../include/sys/fs/zfs.h' line='1434' column='1' id='type-id-120'/>
	- <function-decl name='zfs_wait_status' mangled-name='zfs_wait_status' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5547' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_wait_status'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5547' column='1'/>
	- <parameter type-id='type-id-120' name='activity' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5547' column='1'/>
	- <parameter type-id='type-id-114' name='missing' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5548' column='1'/>
	- <parameter type-id='type-id-114' name='waited' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5548' column='1'/>
	- <return type-id='type-id-6'/>
	- </function-decl>
	- <function-decl name='zvol_volsize_to_reservation' mangled-name='zvol_volsize_to_reservation' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5491' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zvol_volsize_to_reservation'>
	- <parameter type-id='type-id-18' name='zph' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5491' column='1'/>
	- <parameter type-id='type-id-27' name='volsize' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5491' column='1'/>
	- <parameter type-id='type-id-22' name='props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5492' column='1'/>
	+ <typedef-decl name='zfs_wait_activity_t' type-id='type-id-119' filepath='../../include/sys/fs/zfs.h' line='1442' column='1' id='type-id-120'/>
	+ <function-decl name='zfs_wait_status' mangled-name='zfs_wait_status' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5546' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_wait_status'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5546' column='1'/>
	+ <parameter type-id='type-id-120' name='activity' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5546' column='1'/>
	+ <parameter type-id='type-id-114' name='missing' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5547' column='1'/>
	+ <parameter type-id='type-id-114' name='waited' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5547' column='1'/>
	+ <return type-id='type-id-6'/>
	+ </function-decl>
	+ <function-decl name='zvol_volsize_to_reservation' mangled-name='zvol_volsize_to_reservation' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5490' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zvol_volsize_to_reservation'>
	+ <parameter type-id='type-id-18' name='zph' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5490' column='1'/>
	+ <parameter type-id='type-id-27' name='volsize' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5490' column='1'/>
	+ <parameter type-id='type-id-22' name='props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5491' column='1'/>
	<return type-id='type-id-27'/>
	</function-decl>
	- <function-decl name='zfs_get_holds' mangled-name='zfs_get_holds' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5233' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_holds'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5233' column='1'/>
	- <parameter type-id='type-id-115' name='nvl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5233' column='1'/>
	+ <function-decl name='zfs_get_holds' mangled-name='zfs_get_holds' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5232' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_holds'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5232' column='1'/>
	+ <parameter type-id='type-id-115' name='nvl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5232' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_set_fsacl' mangled-name='zfs_set_fsacl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5179' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_set_fsacl'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5179' column='1'/>
	- <parameter type-id='type-id-5' name='un' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5179' column='1'/>
	- <parameter type-id='type-id-22' name='nvl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5179' column='1'/>
	+ <function-decl name='zfs_set_fsacl' mangled-name='zfs_set_fsacl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5178' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_set_fsacl'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5178' column='1'/>
	+ <parameter type-id='type-id-5' name='un' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5178' column='1'/>
	+ <parameter type-id='type-id-22' name='nvl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5178' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_get_fsacl' mangled-name='zfs_get_fsacl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5112' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_fsacl'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5112' column='1'/>
	- <parameter type-id='type-id-115' name='nvl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5112' column='1'/>
	+ <function-decl name='zfs_get_fsacl' mangled-name='zfs_get_fsacl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5111' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_fsacl'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5111' column='1'/>
	+ <parameter type-id='type-id-115' name='nvl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5111' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_release' mangled-name='zfs_release' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5031' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_release'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5031' column='1'/>
	- <parameter type-id='type-id-104' name='snapname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5031' column='1'/>
	- <parameter type-id='type-id-104' name='tag' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5031' column='1'/>
	- <parameter type-id='type-id-5' name='recursive' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5032' column='1'/>
	+ <function-decl name='zfs_release' mangled-name='zfs_release' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5030' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_release'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5030' column='1'/>
	+ <parameter type-id='type-id-104' name='snapname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5030' column='1'/>
	+ <parameter type-id='type-id-104' name='tag' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5030' column='1'/>
	+ <parameter type-id='type-id-5' name='recursive' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='5031' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_hold_nvl' mangled-name='zfs_hold_nvl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4932' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_hold_nvl'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4932' column='1'/>
	- <parameter type-id='type-id-6' name='cleanup_fd' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4932' column='1'/>
	- <parameter type-id='type-id-22' name='holds' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4932' column='1'/>
	+ <function-decl name='zfs_hold_nvl' mangled-name='zfs_hold_nvl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4931' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_hold_nvl'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4931' column='1'/>
	+ <parameter type-id='type-id-6' name='cleanup_fd' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4931' column='1'/>
	+ <parameter type-id='type-id-22' name='holds' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4931' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_hold' mangled-name='zfs_hold' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4900' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_hold'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4900' column='1'/>
	- <parameter type-id='type-id-104' name='snapname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4900' column='1'/>
	- <parameter type-id='type-id-104' name='tag' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4900' column='1'/>
	- <parameter type-id='type-id-5' name='recursive' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4901' column='1'/>
	- <parameter type-id='type-id-6' name='cleanup_fd' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4901' column='1'/>
	+ <function-decl name='zfs_hold' mangled-name='zfs_hold' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4899' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_hold'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4899' column='1'/>
	+ <parameter type-id='type-id-104' name='snapname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4899' column='1'/>
	+ <parameter type-id='type-id-104' name='tag' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4899' column='1'/>
	+ <parameter type-id='type-id-5' name='recursive' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4900' column='1'/>
	+ <parameter type-id='type-id-6' name='cleanup_fd' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4900' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<enum-decl name='__anonymous_enum__' is-anonymous='yes' filepath='../../include/sys/fs/zfs.h' line='192' column='1' id='type-id-121'>
	<underlying-type type-id='type-id-7'/>
	<enumerator name='ZFS_PROP_USERUSED' value='0'/>
	<enumerator name='ZFS_PROP_USERQUOTA' value='1'/>
	<enumerator name='ZFS_PROP_GROUPUSED' value='2'/>
	<enumerator name='ZFS_PROP_GROUPQUOTA' value='3'/>
	<enumerator name='ZFS_PROP_USEROBJUSED' value='4'/>
	<enumerator name='ZFS_PROP_USEROBJQUOTA' value='5'/>
	<enumerator name='ZFS_PROP_GROUPOBJUSED' value='6'/>
	<enumerator name='ZFS_PROP_GROUPOBJQUOTA' value='7'/>
	<enumerator name='ZFS_PROP_PROJECTUSED' value='8'/>
	<enumerator name='ZFS_PROP_PROJECTQUOTA' value='9'/>
	<enumerator name='ZFS_PROP_PROJECTOBJUSED' value='10'/>
	<enumerator name='ZFS_PROP_PROJECTOBJQUOTA' value='11'/>
	<enumerator name='ZFS_NUM_USERQUOTA_PROPS' value='12'/>
	</enum-decl>
	<typedef-decl name='zfs_userquota_prop_t' type-id='type-id-121' filepath='../../include/sys/fs/zfs.h' line='206' column='1' id='type-id-122'/>
	<typedef-decl name='__uid_t' type-id='type-id-64' filepath='/usr/include/x86_64-linux-gnu/bits/types.h' line='144' column='1' id='type-id-123'/>
	<typedef-decl name='uid_t' type-id='type-id-123' filepath='/usr/include/x86_64-linux-gnu/sys/types.h' line='79' column='1' id='type-id-124'/>
	<pointer-type-def type-id='type-id-125' size-in-bits='64' id='type-id-126'/>
	- <typedef-decl name='zfs_userspace_cb_t' type-id='type-id-126' filepath='../../include/libzfs.h' line='734' column='1' id='type-id-127'/>
	- <function-decl name='zfs_userspace' mangled-name='zfs_userspace' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4820' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_userspace'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4820' column='1'/>
	- <parameter type-id='type-id-122' name='type' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4820' column='1'/>
	- <parameter type-id='type-id-127' name='func' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4821' column='1'/>
	- <parameter type-id='type-id-42' name='arg' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4821' column='1'/>
	+ <typedef-decl name='zfs_userspace_cb_t' type-id='type-id-126' filepath='../../include/libzfs.h' line='738' column='1' id='type-id-127'/>
	+ <function-decl name='zfs_userspace' mangled-name='zfs_userspace' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4819' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_userspace'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4819' column='1'/>
	+ <parameter type-id='type-id-122' name='type' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4819' column='1'/>
	+ <parameter type-id='type-id-127' name='func' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4820' column='1'/>
	+ <parameter type-id='type-id-42' name='arg' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4820' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_smb_acl_rename' mangled-name='zfs_smb_acl_rename' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4812' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_smb_acl_rename'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4812' column='1'/>
	- <parameter type-id='type-id-23' name='dataset' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4812' column='1'/>
	- <parameter type-id='type-id-23' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4812' column='1'/>
	- <parameter type-id='type-id-23' name='oldname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4813' column='1'/>
	- <parameter type-id='type-id-23' name='newname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4813' column='1'/>
	+ <function-decl name='zfs_smb_acl_rename' mangled-name='zfs_smb_acl_rename' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4811' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_smb_acl_rename'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4811' column='1'/>
	+ <parameter type-id='type-id-23' name='dataset' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4811' column='1'/>
	+ <parameter type-id='type-id-23' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4811' column='1'/>
	+ <parameter type-id='type-id-23' name='oldname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4812' column='1'/>
	+ <parameter type-id='type-id-23' name='newname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4812' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_smb_acl_purge' mangled-name='zfs_smb_acl_purge' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4805' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_smb_acl_purge'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4805' column='1'/>
	- <parameter type-id='type-id-23' name='dataset' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4805' column='1'/>
	- <parameter type-id='type-id-23' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4805' column='1'/>
	+ <function-decl name='zfs_smb_acl_purge' mangled-name='zfs_smb_acl_purge' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4804' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_smb_acl_purge'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4804' column='1'/>
	+ <parameter type-id='type-id-23' name='dataset' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4804' column='1'/>
	+ <parameter type-id='type-id-23' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4804' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_smb_acl_remove' mangled-name='zfs_smb_acl_remove' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4797' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_smb_acl_remove'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4797' column='1'/>
	- <parameter type-id='type-id-23' name='dataset' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4797' column='1'/>
	- <parameter type-id='type-id-23' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4798' column='1'/>
	- <parameter type-id='type-id-23' name='resource' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4798' column='1'/>
	+ <function-decl name='zfs_smb_acl_remove' mangled-name='zfs_smb_acl_remove' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4796' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_smb_acl_remove'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4796' column='1'/>
	+ <parameter type-id='type-id-23' name='dataset' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4796' column='1'/>
	+ <parameter type-id='type-id-23' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4797' column='1'/>
	+ <parameter type-id='type-id-23' name='resource' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4797' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_smb_acl_add' mangled-name='zfs_smb_acl_add' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4789' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_smb_acl_add'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4797' column='1'/>
	- <parameter type-id='type-id-23' name='dataset' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4797' column='1'/>
	- <parameter type-id='type-id-23' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4798' column='1'/>
	- <parameter type-id='type-id-23' name='resource' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4798' column='1'/>
	+ <function-decl name='zfs_smb_acl_add' mangled-name='zfs_smb_acl_add' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4788' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_smb_acl_add'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4796' column='1'/>
	+ <parameter type-id='type-id-23' name='dataset' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4796' column='1'/>
	+ <parameter type-id='type-id-23' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4797' column='1'/>
	+ <parameter type-id='type-id-23' name='resource' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4797' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_prune_proplist' mangled-name='zfs_prune_proplist' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4707' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prune_proplist'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4707' column='1'/>
	- <parameter type-id='type-id-24' name='props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4707' column='1'/>
	+ <function-decl name='zfs_prune_proplist' mangled-name='zfs_prune_proplist' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4706' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prune_proplist'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4706' column='1'/>
	+ <parameter type-id='type-id-24' name='props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4706' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	- <class-decl name='zprop_list' size-in-bits='448' is-struct='yes' visibility='default' filepath='../../include/libzfs.h' line='535' column='1' id='type-id-128'>
	+ <class-decl name='zprop_list' size-in-bits='448' is-struct='yes' visibility='default' filepath='../../include/libzfs.h' line='536' column='1' id='type-id-128'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='pl_prop' type-id='type-id-6' visibility='default' filepath='../../include/libzfs.h' line='536' column='1'/>
	+ <var-decl name='pl_prop' type-id='type-id-6' visibility='default' filepath='../../include/libzfs.h' line='537' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='pl_user_prop' type-id='type-id-23' visibility='default' filepath='../../include/libzfs.h' line='537' column='1'/>
	+ <var-decl name='pl_user_prop' type-id='type-id-23' visibility='default' filepath='../../include/libzfs.h' line='538' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='pl_next' type-id='type-id-129' visibility='default' filepath='../../include/libzfs.h' line='538' column='1'/>
	+ <var-decl name='pl_next' type-id='type-id-129' visibility='default' filepath='../../include/libzfs.h' line='539' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='pl_all' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='539' column='1'/>
	+ <var-decl name='pl_all' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='540' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='pl_width' type-id='type-id-43' visibility='default' filepath='../../include/libzfs.h' line='540' column='1'/>
	+ <var-decl name='pl_width' type-id='type-id-43' visibility='default' filepath='../../include/libzfs.h' line='541' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	- <var-decl name='pl_recvd_width' type-id='type-id-43' visibility='default' filepath='../../include/libzfs.h' line='541' column='1'/>
	+ <var-decl name='pl_recvd_width' type-id='type-id-43' visibility='default' filepath='../../include/libzfs.h' line='542' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	- <var-decl name='pl_fixed' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='542' column='1'/>
	+ <var-decl name='pl_fixed' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='543' column='1'/>
	</data-member>
	</class-decl>
	<pointer-type-def type-id='type-id-128' size-in-bits='64' id='type-id-129'/>
	- <typedef-decl name='zprop_list_t' type-id='type-id-128' filepath='../../include/libzfs.h' line='543' column='1' id='type-id-130'/>
	+ <typedef-decl name='zprop_list_t' type-id='type-id-128' filepath='../../include/libzfs.h' line='544' column='1' id='type-id-130'/>
	<pointer-type-def type-id='type-id-130' size-in-bits='64' id='type-id-131'/>
	<pointer-type-def type-id='type-id-131' size-in-bits='64' id='type-id-132'/>
	- <function-decl name='zfs_expand_proplist' mangled-name='zfs_expand_proplist' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4610' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_expand_proplist'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4610' column='1'/>
	- <parameter type-id='type-id-132' name='plp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4610' column='1'/>
	- <parameter type-id='type-id-5' name='received' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4610' column='1'/>
	- <parameter type-id='type-id-5' name='literal' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4611' column='1'/>
	+ <function-decl name='zfs_expand_proplist' mangled-name='zfs_expand_proplist' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4609' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_expand_proplist'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4609' column='1'/>
	+ <parameter type-id='type-id-132' name='plp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4609' column='1'/>
	+ <parameter type-id='type-id-5' name='received' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4609' column='1'/>
	+ <parameter type-id='type-id-5' name='literal' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4610' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_get_user_props' mangled-name='zfs_get_user_props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4591' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_user_props'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4591' column='1'/>
	+ <function-decl name='zfs_get_user_props' mangled-name='zfs_get_user_props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4590' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_user_props'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4590' column='1'/>
	<return type-id='type-id-22'/>
	</function-decl>
	- <function-decl name='zfs_get_recvd_props' mangled-name='zfs_get_recvd_props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4582' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_recvd_props'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4582' column='1'/>
	+ <function-decl name='zfs_get_recvd_props' mangled-name='zfs_get_recvd_props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4581' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_recvd_props'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4581' column='1'/>
	<return type-id='type-id-22'/>
	</function-decl>
	- <function-decl name='zfs_get_all_props' mangled-name='zfs_get_all_props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4576' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_all_props'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4591' column='1'/>
	+ <function-decl name='zfs_get_all_props' mangled-name='zfs_get_all_props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4575' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_all_props'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4590' column='1'/>
	<return type-id='type-id-22'/>
	</function-decl>
	- <class-decl name='renameflags' size-in-bits='32' is-struct='yes' visibility='default' filepath='../../include/libzfs.h' line='649' column='1' id='type-id-133'>
	+ <class-decl name='renameflags' size-in-bits='32' is-struct='yes' visibility='default' filepath='../../include/libzfs.h' line='650' column='1' id='type-id-133'>
	<data-member access='public' layout-offset-in-bits='31'>
	- <var-decl name='recursive' type-id='type-id-6' visibility='default' filepath='../../include/libzfs.h' line='651' column='1'/>
	+ <var-decl name='recursive' type-id='type-id-6' visibility='default' filepath='../../include/libzfs.h' line='652' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='30'>
	- <var-decl name='nounmount' type-id='type-id-6' visibility='default' filepath='../../include/libzfs.h' line='654' column='1'/>
	+ <var-decl name='nounmount' type-id='type-id-6' visibility='default' filepath='../../include/libzfs.h' line='655' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='29'>
	- <var-decl name='forceunmount' type-id='type-id-6' visibility='default' filepath='../../include/libzfs.h' line='657' column='1'/>
	+ <var-decl name='forceunmount' type-id='type-id-6' visibility='default' filepath='../../include/libzfs.h' line='658' column='1'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='renameflags_t' type-id='type-id-133' filepath='../../include/libzfs.h' line='658' column='1' id='type-id-134'/>
	- <function-decl name='zfs_rename' mangled-name='zfs_rename' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4374' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_rename'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4374' column='1'/>
	- <parameter type-id='type-id-104' name='target' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4374' column='1'/>
	- <parameter type-id='type-id-134' name='flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4374' column='1'/>
	+ <typedef-decl name='renameflags_t' type-id='type-id-133' filepath='../../include/libzfs.h' line='659' column='1' id='type-id-134'/>
	+ <function-decl name='zfs_rename' mangled-name='zfs_rename' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4373' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_rename'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4373' column='1'/>
	+ <parameter type-id='type-id-104' name='target' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4373' column='1'/>
	+ <parameter type-id='type-id-134' name='flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4373' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_rollback' mangled-name='zfs_rollback' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4274' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_rollback'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4274' column='1'/>
	- <parameter type-id='type-id-102' name='snap' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4274' column='1'/>
	- <parameter type-id='type-id-5' name='force' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4274' column='1'/>
	+ <function-decl name='zfs_rollback' mangled-name='zfs_rollback' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4273' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_rollback'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4273' column='1'/>
	+ <parameter type-id='type-id-102' name='snap' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4273' column='1'/>
	+ <parameter type-id='type-id-5' name='force' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4273' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_snapshot' mangled-name='zfs_snapshot' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4173' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_snapshot'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4173' column='1'/>
	- <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4173' column='1'/>
	- <parameter type-id='type-id-5' name='recursive' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4173' column='1'/>
	- <parameter type-id='type-id-22' name='props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4174' column='1'/>
	+ <function-decl name='zfs_snapshot' mangled-name='zfs_snapshot' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4172' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_snapshot'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4172' column='1'/>
	+ <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4172' column='1'/>
	+ <parameter type-id='type-id-5' name='recursive' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4172' column='1'/>
	+ <parameter type-id='type-id-22' name='props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4173' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_snapshot_nvl' mangled-name='zfs_snapshot_nvl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4093' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_snapshot_nvl'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4093' column='1'/>
	- <parameter type-id='type-id-22' name='snaps' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4093' column='1'/>
	- <parameter type-id='type-id-22' name='props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4093' column='1'/>
	+ <function-decl name='zfs_snapshot_nvl' mangled-name='zfs_snapshot_nvl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4092' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_snapshot_nvl'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4092' column='1'/>
	+ <parameter type-id='type-id-22' name='snaps' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4092' column='1'/>
	+ <parameter type-id='type-id-22' name='props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4092' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_promote' mangled-name='zfs_promote' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4009' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_promote'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4009' column='1'/>
	+ <function-decl name='zfs_promote' mangled-name='zfs_promote' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4008' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_promote'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='4008' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_clone' mangled-name='zfs_clone' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3923' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_clone'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3923' column='1'/>
	- <parameter type-id='type-id-104' name='target' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3923' column='1'/>
	- <parameter type-id='type-id-22' name='props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3923' column='1'/>
	+ <function-decl name='zfs_clone' mangled-name='zfs_clone' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3922' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_clone'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3922' column='1'/>
	+ <parameter type-id='type-id-104' name='target' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3922' column='1'/>
	+ <parameter type-id='type-id-22' name='props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3922' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_destroy_snaps_nvl' mangled-name='zfs_destroy_snaps_nvl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3876' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_destroy_snaps_nvl'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3876' column='1'/>
	- <parameter type-id='type-id-22' name='snaps' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3876' column='1'/>
	- <parameter type-id='type-id-5' name='defer' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3876' column='1'/>
	+ <function-decl name='zfs_destroy_snaps_nvl' mangled-name='zfs_destroy_snaps_nvl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3875' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_destroy_snaps_nvl'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3875' column='1'/>
	+ <parameter type-id='type-id-22' name='snaps' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3875' column='1'/>
	+ <parameter type-id='type-id-5' name='defer' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3875' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_destroy_snaps' mangled-name='zfs_destroy_snaps' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3852' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_destroy_snaps'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3852' column='1'/>
	- <parameter type-id='type-id-23' name='snapname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3852' column='1'/>
	- <parameter type-id='type-id-5' name='defer' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3852' column='1'/>
	+ <function-decl name='zfs_destroy_snaps' mangled-name='zfs_destroy_snaps' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3851' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_destroy_snaps'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3851' column='1'/>
	+ <parameter type-id='type-id-23' name='snapname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3851' column='1'/>
	+ <parameter type-id='type-id-5' name='defer' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3851' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_destroy' mangled-name='zfs_destroy' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3784' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_destroy'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3784' column='1'/>
	- <parameter type-id='type-id-5' name='defer' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3784' column='1'/>
	+ <function-decl name='zfs_destroy' mangled-name='zfs_destroy' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3783' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_destroy'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3783' column='1'/>
	+ <parameter type-id='type-id-5' name='defer' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3783' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_create' mangled-name='zfs_create' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3609' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_create'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3609' column='1'/>
	- <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3609' column='1'/>
	- <parameter type-id='type-id-20' name='type' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3609' column='1'/>
	- <parameter type-id='type-id-22' name='props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3610' column='1'/>
	+ <function-decl name='zfs_create' mangled-name='zfs_create' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3608' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_create'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3608' column='1'/>
	+ <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3608' column='1'/>
	+ <parameter type-id='type-id-20' name='type' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3608' column='1'/>
	+ <parameter type-id='type-id-22' name='props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3609' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_create_ancestors' mangled-name='zfs_create_ancestors' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3572' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_create_ancestors'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3572' column='1'/>
	- <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3572' column='1'/>
	+ <function-decl name='zfs_create_ancestors' mangled-name='zfs_create_ancestors' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3571' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_create_ancestors'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3571' column='1'/>
	+ <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3571' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='create_parents' mangled-name='create_parents' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3498' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='create_parents'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3498' column='1'/>
	- <parameter type-id='type-id-23' name='target' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3498' column='1'/>
	- <parameter type-id='type-id-6' name='prefixlen' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3498' column='1'/>
	+ <function-decl name='create_parents' mangled-name='create_parents' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3497' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='create_parents'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3497' column='1'/>
	+ <parameter type-id='type-id-23' name='target' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3497' column='1'/>
	+ <parameter type-id='type-id-6' name='prefixlen' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3497' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_parent_name' mangled-name='zfs_parent_name' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3377' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_parent_name'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3377' column='1'/>
	- <parameter type-id='type-id-23' name='buf' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3377' column='1'/>
	- <parameter type-id='type-id-43' name='buflen' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3377' column='1'/>
	+ <function-decl name='zfs_parent_name' mangled-name='zfs_parent_name' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3376' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_parent_name'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3376' column='1'/>
	+ <parameter type-id='type-id-23' name='buf' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3376' column='1'/>
	+ <parameter type-id='type-id-43' name='buflen' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3376' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<qualified-type-def type-id='type-id-101' const='yes' id='type-id-135'/>
	<pointer-type-def type-id='type-id-135' size-in-bits='64' id='type-id-136'/>
	- <function-decl name='zfs_get_type' mangled-name='zfs_get_type' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3331' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_type'>
	- <parameter type-id='type-id-136' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3331' column='1'/>
	+ <function-decl name='zfs_get_type' mangled-name='zfs_get_type' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3330' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_type'>
	+ <parameter type-id='type-id-136' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3330' column='1'/>
	<return type-id='type-id-20'/>
	</function-decl>
	- <function-decl name='zfs_get_pool_name' mangled-name='zfs_get_pool_name' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3322' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_pool_name'>
	- <parameter type-id='type-id-136' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3322' column='1'/>
	+ <function-decl name='zfs_get_pool_name' mangled-name='zfs_get_pool_name' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3321' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_pool_name'>
	+ <parameter type-id='type-id-136' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3321' column='1'/>
	<return type-id='type-id-104'/>
	</function-decl>
	- <function-decl name='zfs_get_name' mangled-name='zfs_get_name' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3313' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_name'>
	- <parameter type-id='type-id-136' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3322' column='1'/>
	+ <function-decl name='zfs_get_name' mangled-name='zfs_get_name' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3312' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_name'>
	+ <parameter type-id='type-id-136' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3321' column='1'/>
	<return type-id='type-id-104'/>
	</function-decl>
	- <function-decl name='zfs_prop_get_written' mangled-name='zfs_prop_get_written' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3288' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_get_written'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3288' column='1'/>
	- <parameter type-id='type-id-104' name='propname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3288' column='1'/>
	- <parameter type-id='type-id-23' name='propbuf' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3289' column='1'/>
	- <parameter type-id='type-id-6' name='proplen' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3289' column='1'/>
	- <parameter type-id='type-id-5' name='literal' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3289' column='1'/>
	+ <function-decl name='zfs_prop_get_written' mangled-name='zfs_prop_get_written' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3287' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_get_written'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3287' column='1'/>
	+ <parameter type-id='type-id-104' name='propname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3287' column='1'/>
	+ <parameter type-id='type-id-23' name='propbuf' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3288' column='1'/>
	+ <parameter type-id='type-id-6' name='proplen' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3288' column='1'/>
	+ <parameter type-id='type-id-5' name='literal' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3288' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<pointer-type-def type-id='type-id-27' size-in-bits='64' id='type-id-137'/>
	- <function-decl name='zfs_prop_get_written_int' mangled-name='zfs_prop_get_written_int' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3253' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_get_written_int'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3253' column='1'/>
	- <parameter type-id='type-id-104' name='propname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3253' column='1'/>
	- <parameter type-id='type-id-137' name='propvalue' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3254' column='1'/>
	+ <function-decl name='zfs_prop_get_written_int' mangled-name='zfs_prop_get_written_int' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3252' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_get_written_int'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3252' column='1'/>
	+ <parameter type-id='type-id-104' name='propname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3252' column='1'/>
	+ <parameter type-id='type-id-137' name='propvalue' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3253' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_prop_get_userquota' mangled-name='zfs_prop_get_userquota' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3217' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_get_userquota'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3217' column='1'/>
	- <parameter type-id='type-id-104' name='propname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3217' column='1'/>
	- <parameter type-id='type-id-23' name='propbuf' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3218' column='1'/>
	- <parameter type-id='type-id-6' name='proplen' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3218' column='1'/>
	- <parameter type-id='type-id-5' name='literal' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3218' column='1'/>
	+ <function-decl name='zfs_prop_get_userquota' mangled-name='zfs_prop_get_userquota' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3216' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_get_userquota'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3216' column='1'/>
	+ <parameter type-id='type-id-104' name='propname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3216' column='1'/>
	+ <parameter type-id='type-id-23' name='propbuf' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3217' column='1'/>
	+ <parameter type-id='type-id-6' name='proplen' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3217' column='1'/>
	+ <parameter type-id='type-id-5' name='literal' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3217' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_prop_get_userquota_int' mangled-name='zfs_prop_get_userquota_int' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3207' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_get_userquota_int'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3207' column='1'/>
	- <parameter type-id='type-id-104' name='propname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3207' column='1'/>
	- <parameter type-id='type-id-137' name='propvalue' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3208' column='1'/>
	+ <function-decl name='zfs_prop_get_userquota_int' mangled-name='zfs_prop_get_userquota_int' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3206' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_get_userquota_int'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3206' column='1'/>
	+ <parameter type-id='type-id-104' name='propname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3206' column='1'/>
	+ <parameter type-id='type-id-137' name='propvalue' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3207' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<enum-decl name='__anonymous_enum__' is-anonymous='yes' filepath='../../include/sys/fs/zfs.h' line='259' column='1' id='type-id-138'>
	<underlying-type type-id='type-id-7'/>
	<enumerator name='ZPROP_SRC_NONE' value='1'/>
	<enumerator name='ZPROP_SRC_DEFAULT' value='2'/>
	<enumerator name='ZPROP_SRC_TEMPORARY' value='4'/>
	<enumerator name='ZPROP_SRC_LOCAL' value='8'/>
	<enumerator name='ZPROP_SRC_INHERITED' value='16'/>
	<enumerator name='ZPROP_SRC_RECEIVED' value='32'/>
	</enum-decl>
	<typedef-decl name='zprop_source_t' type-id='type-id-138' filepath='../../include/sys/fs/zfs.h' line='266' column='1' id='type-id-139'/>
	<pointer-type-def type-id='type-id-139' size-in-bits='64' id='type-id-140'/>
	- <function-decl name='zfs_prop_get_numeric' mangled-name='zfs_prop_get_numeric' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3003' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_get_numeric'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3003' column='1'/>
	- <parameter type-id='type-id-2' name='prop' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3003' column='1'/>
	- <parameter type-id='type-id-137' name='value' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3003' column='1'/>
	- <parameter type-id='type-id-140' name='src' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3004' column='1'/>
	- <parameter type-id='type-id-23' name='statbuf' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3004' column='1'/>
	- <parameter type-id='type-id-43' name='statlen' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3004' column='1'/>
	- <return type-id='type-id-6'/>
	- </function-decl>
	- <function-decl name='zfs_prop_get_int' mangled-name='zfs_prop_get_int' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2980' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_get_int'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2980' column='1'/>
	- <parameter type-id='type-id-2' name='prop' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2980' column='1'/>
	+ <function-decl name='zfs_prop_get_numeric' mangled-name='zfs_prop_get_numeric' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3002' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_get_numeric'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3002' column='1'/>
	+ <parameter type-id='type-id-2' name='prop' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3002' column='1'/>
	+ <parameter type-id='type-id-137' name='value' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3002' column='1'/>
	+ <parameter type-id='type-id-140' name='src' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3003' column='1'/>
	+ <parameter type-id='type-id-23' name='statbuf' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3003' column='1'/>
	+ <parameter type-id='type-id-43' name='statlen' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3003' column='1'/>
	+ <return type-id='type-id-6'/>
	+ </function-decl>
	+ <function-decl name='zfs_prop_get_int' mangled-name='zfs_prop_get_int' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2979' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_get_int'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2979' column='1'/>
	+ <parameter type-id='type-id-2' name='prop' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2979' column='1'/>
	<return type-id='type-id-27'/>
	</function-decl>
	- <function-decl name='zfs_prop_get' mangled-name='zfs_prop_get' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2605' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_get'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2605' column='1'/>
	- <parameter type-id='type-id-2' name='prop' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2605' column='1'/>
	- <parameter type-id='type-id-23' name='propbuf' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2605' column='1'/>
	- <parameter type-id='type-id-43' name='proplen' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2605' column='1'/>
	- <parameter type-id='type-id-140' name='src' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2606' column='1'/>
	- <parameter type-id='type-id-23' name='statbuf' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2606' column='1'/>
	- <parameter type-id='type-id-43' name='statlen' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2606' column='1'/>
	- <parameter type-id='type-id-5' name='literal' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2606' column='1'/>
	+ <function-decl name='zfs_prop_get' mangled-name='zfs_prop_get' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2604' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_get'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2604' column='1'/>
	+ <parameter type-id='type-id-2' name='prop' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2604' column='1'/>
	+ <parameter type-id='type-id-23' name='propbuf' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2604' column='1'/>
	+ <parameter type-id='type-id-43' name='proplen' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2604' column='1'/>
	+ <parameter type-id='type-id-140' name='src' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2605' column='1'/>
	+ <parameter type-id='type-id-23' name='statbuf' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2605' column='1'/>
	+ <parameter type-id='type-id-43' name='statlen' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2605' column='1'/>
	+ <parameter type-id='type-id-5' name='literal' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2605' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_get_clones_nvl' mangled-name='zfs_get_clones_nvl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2436' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_clones_nvl'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2436' column='1'/>
	+ <function-decl name='zfs_get_clones_nvl' mangled-name='zfs_get_clones_nvl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2435' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_clones_nvl'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2435' column='1'/>
	<return type-id='type-id-22'/>
	</function-decl>
	- <function-decl name='zfs_prop_get_recvd' mangled-name='zfs_prop_get_recvd' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2349' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_get_recvd'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2349' column='1'/>
	- <parameter type-id='type-id-104' name='propname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2349' column='1'/>
	- <parameter type-id='type-id-23' name='propbuf' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2349' column='1'/>
	- <parameter type-id='type-id-43' name='proplen' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2350' column='1'/>
	- <parameter type-id='type-id-5' name='literal' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2350' column='1'/>
	+ <function-decl name='zfs_prop_get_recvd' mangled-name='zfs_prop_get_recvd' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2348' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_get_recvd'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2348' column='1'/>
	+ <parameter type-id='type-id-104' name='propname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2348' column='1'/>
	+ <parameter type-id='type-id-23' name='propbuf' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2348' column='1'/>
	+ <parameter type-id='type-id-43' name='proplen' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2349' column='1'/>
	+ <parameter type-id='type-id-5' name='literal' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2349' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_prop_inherit' mangled-name='zfs_prop_inherit' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1927' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_inherit'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1927' column='1'/>
	- <parameter type-id='type-id-104' name='propname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1927' column='1'/>
	- <parameter type-id='type-id-5' name='received' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1927' column='1'/>
	+ <function-decl name='zfs_prop_inherit' mangled-name='zfs_prop_inherit' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1926' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_inherit'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1926' column='1'/>
	+ <parameter type-id='type-id-104' name='propname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1926' column='1'/>
	+ <parameter type-id='type-id-5' name='received' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1926' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_prop_set_list' mangled-name='zfs_prop_set_list' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1745' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_set_list'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1745' column='1'/>
	- <parameter type-id='type-id-22' name='props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1745' column='1'/>
	+ <function-decl name='zfs_prop_set_list' mangled-name='zfs_prop_set_list' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1744' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_set_list'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1744' column='1'/>
	+ <parameter type-id='type-id-22' name='props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1744' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_prop_set' mangled-name='zfs_prop_set' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1714' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_set'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1714' column='1'/>
	- <parameter type-id='type-id-104' name='propname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1714' column='1'/>
	- <parameter type-id='type-id-104' name='propval' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1714' column='1'/>
	+ <function-decl name='zfs_prop_set' mangled-name='zfs_prop_set' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1713' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_set'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1713' column='1'/>
	+ <parameter type-id='type-id-104' name='propname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1713' column='1'/>
	+ <parameter type-id='type-id-104' name='propval' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1713' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_valid_proplist' mangled-name='zfs_valid_proplist' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1005' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_valid_proplist'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1005' column='1'/>
	- <parameter type-id='type-id-20' name='type' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1005' column='1'/>
	- <parameter type-id='type-id-22' name='nvl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1005' column='1'/>
	- <parameter type-id='type-id-27' name='zoned' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1006' column='1'/>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1006' column='1'/>
	- <parameter type-id='type-id-18' name='zpool_hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1006' column='1'/>
	- <parameter type-id='type-id-5' name='key_params_ok' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1007' column='1'/>
	- <parameter type-id='type-id-104' name='errbuf' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1007' column='1'/>
	+ <function-decl name='zfs_valid_proplist' mangled-name='zfs_valid_proplist' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1004' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_valid_proplist'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1004' column='1'/>
	+ <parameter type-id='type-id-20' name='type' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1004' column='1'/>
	+ <parameter type-id='type-id-22' name='nvl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1004' column='1'/>
	+ <parameter type-id='type-id-27' name='zoned' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1005' column='1'/>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1005' column='1'/>
	+ <parameter type-id='type-id-18' name='zpool_hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1005' column='1'/>
	+ <parameter type-id='type-id-5' name='key_params_ok' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1006' column='1'/>
	+ <parameter type-id='type-id-104' name='errbuf' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='1006' column='1'/>
	<return type-id='type-id-22'/>
	</function-decl>
	<pointer-type-def type-id='type-id-6' size-in-bits='64' id='type-id-141'/>
	- <function-decl name='zfs_spa_version' mangled-name='zfs_spa_version' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='968' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_spa_version'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='968' column='1'/>
	- <parameter type-id='type-id-141' name='spa_version' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='968' column='1'/>
	+ <function-decl name='zfs_spa_version' mangled-name='zfs_spa_version' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='967' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_spa_version'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='967' column='1'/>
	+ <parameter type-id='type-id-141' name='spa_version' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='967' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='libzfs_mnttab_remove' mangled-name='libzfs_mnttab_remove' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='948' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_mnttab_remove'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='948' column='1'/>
	- <parameter type-id='type-id-104' name='fsname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='948' column='1'/>
	+ <function-decl name='libzfs_mnttab_remove' mangled-name='libzfs_mnttab_remove' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='947' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_mnttab_remove'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='947' column='1'/>
	+ <parameter type-id='type-id-104' name='fsname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='947' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='libzfs_mnttab_add' mangled-name='libzfs_mnttab_add' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='918' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_mnttab_add'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='918' column='1'/>
	- <parameter type-id='type-id-104' name='special' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='918' column='1'/>
	- <parameter type-id='type-id-104' name='mountp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='919' column='1'/>
	- <parameter type-id='type-id-104' name='mntopts' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='919' column='1'/>
	+ <function-decl name='libzfs_mnttab_add' mangled-name='libzfs_mnttab_add' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='917' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_mnttab_add'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='917' column='1'/>
	+ <parameter type-id='type-id-104' name='special' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='917' column='1'/>
	+ <parameter type-id='type-id-104' name='mountp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='918' column='1'/>
	+ <parameter type-id='type-id-104' name='mntopts' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='918' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='libzfs_mnttab_cache' mangled-name='libzfs_mnttab_cache' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='866' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_mnttab_cache'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='866' column='1'/>
	- <parameter type-id='type-id-5' name='enable' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='866' column='1'/>
	+ <function-decl name='libzfs_mnttab_cache' mangled-name='libzfs_mnttab_cache' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='865' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_mnttab_cache'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='865' column='1'/>
	+ <parameter type-id='type-id-5' name='enable' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='865' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='libzfs_mnttab_fini' mangled-name='libzfs_mnttab_fini' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='848' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_mnttab_fini'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='848' column='1'/>
	+ <function-decl name='libzfs_mnttab_fini' mangled-name='libzfs_mnttab_fini' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='847' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_mnttab_fini'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='847' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='libzfs_mnttab_init' mangled-name='libzfs_mnttab_init' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='801' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_mnttab_init'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='801' column='1'/>
	+ <function-decl name='libzfs_mnttab_init' mangled-name='libzfs_mnttab_init' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='800' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_mnttab_init'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='800' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_close' mangled-name='zfs_close' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='773' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_close'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='773' column='1'/>
	+ <function-decl name='zfs_close' mangled-name='zfs_close' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='772' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_close'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='772' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_open' mangled-name='zfs_open' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='684' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_open'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='684' column='1'/>
	- <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='684' column='1'/>
	- <parameter type-id='type-id-6' name='types' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='684' column='1'/>
	+ <function-decl name='zfs_open' mangled-name='zfs_open' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='683' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_open'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='683' column='1'/>
	+ <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='683' column='1'/>
	+ <parameter type-id='type-id-6' name='types' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='683' column='1'/>
	<return type-id='type-id-102'/>
	</function-decl>
	- <function-decl name='make_bookmark_handle' mangled-name='make_bookmark_handle' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='619' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='make_bookmark_handle'>
	- <parameter type-id='type-id-102' name='parent' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='619' column='1'/>
	- <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='619' column='1'/>
	- <parameter type-id='type-id-22' name='bmark_props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='620' column='1'/>
	+ <function-decl name='make_bookmark_handle' mangled-name='make_bookmark_handle' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='618' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='make_bookmark_handle'>
	+ <parameter type-id='type-id-102' name='parent' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='618' column='1'/>
	+ <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='618' column='1'/>
	+ <parameter type-id='type-id-22' name='bmark_props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='619' column='1'/>
	<return type-id='type-id-102'/>
	</function-decl>
	- <function-decl name='zfs_bookmark_exists' mangled-name='zfs_bookmark_exists' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='588' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_bookmark_exists'>
	- <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='588' column='1'/>
	+ <function-decl name='zfs_bookmark_exists' mangled-name='zfs_bookmark_exists' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='587' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_bookmark_exists'>
	+ <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='587' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	- <function-decl name='zfs_handle_dup' mangled-name='zfs_handle_dup' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='541' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_handle_dup'>
	- <parameter type-id='type-id-102' name='zhp_orig' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='541' column='1'/>
	+ <function-decl name='zfs_handle_dup' mangled-name='zfs_handle_dup' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='540' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_handle_dup'>
	+ <parameter type-id='type-id-102' name='zhp_orig' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='540' column='1'/>
	<return type-id='type-id-102'/>
	</function-decl>
	<class-decl name='zfs_cmd' size-in-bits='109952' is-struct='yes' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='477' column='1' id='type-id-142'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='zc_name' type-id='type-id-143' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='478' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32768'>
	<var-decl name='zc_nvlist_src' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='479' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32832'>
	<var-decl name='zc_nvlist_src_size' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='480' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32896'>
	<var-decl name='zc_nvlist_dst' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='481' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32960'>
	<var-decl name='zc_nvlist_dst_size' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='482' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='33024'>
	<var-decl name='zc_nvlist_dst_filled' type-id='type-id-5' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='483' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='33056'>
	<var-decl name='zc_pad2' type-id='type-id-6' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='484' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='33088'>
	<var-decl name='zc_history' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='490' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='33152'>
	<var-decl name='zc_value' type-id='type-id-144' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='491' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='98688'>
	<var-decl name='zc_string' type-id='type-id-19' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='492' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='100736'>
	<var-decl name='zc_guid' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='493' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='100800'>
	<var-decl name='zc_nvlist_conf' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='494' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='100864'>
	<var-decl name='zc_nvlist_conf_size' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='495' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='100928'>
	<var-decl name='zc_cookie' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='496' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='100992'>
	<var-decl name='zc_objset_type' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='497' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='101056'>
	<var-decl name='zc_perm_action' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='498' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='101120'>
	<var-decl name='zc_history_len' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='499' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='101184'>
	<var-decl name='zc_history_offset' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='500' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='101248'>
	<var-decl name='zc_obj' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='501' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='101312'>
	<var-decl name='zc_iflags' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='502' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='101376'>
	<var-decl name='zc_share' type-id='type-id-145' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='503' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='101632'>
	<var-decl name='zc_objset_stats' type-id='type-id-21' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='504' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='103936'>
	<var-decl name='zc_begin_record' type-id='type-id-146' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='505' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='106368'>
	<var-decl name='zc_inject_record' type-id='type-id-147' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='506' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='109184'>
	<var-decl name='zc_defer_destroy' type-id='type-id-62' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='507' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='109216'>
	<var-decl name='zc_flags' type-id='type-id-62' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='508' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='109248'>
	<var-decl name='zc_action_handle' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='509' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='109312'>
	<var-decl name='zc_cleanup_fd' type-id='type-id-6' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='510' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='109344'>
	<var-decl name='zc_simple' type-id='type-id-98' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='511' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='109352'>
	<var-decl name='zc_pad' type-id='type-id-148' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='512' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='109376'>
	<var-decl name='zc_sendobj' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='513' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='109440'>
	<var-decl name='zc_fromobj' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='514' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='109504'>
	<var-decl name='zc_createtxg' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='515' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='109568'>
	<var-decl name='zc_stat' type-id='type-id-149' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='516' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='109888'>
	<var-decl name='zc_zoneid' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='517' column='1'/>
	</data-member>
	</class-decl>

	<array-type-def dimensions='1' type-id='type-id-45' size-in-bits='32768' id='type-id-143'>
	<subrange length='4096' type-id='type-id-48' id='type-id-150'/>

	</array-type-def>

	<array-type-def dimensions='1' type-id='type-id-45' size-in-bits='65536' id='type-id-144'>
	<subrange length='8192' type-id='type-id-48' id='type-id-151'/>

	</array-type-def>
	<class-decl name='zfs_share' size-in-bits='256' is-struct='yes' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='452' column='1' id='type-id-152'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='z_exportdata' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='453' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='z_sharedata' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='454' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='z_sharetype' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='455' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='z_sharemax' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='456' column='1'/>
	</data-member>
	</class-decl>
	<typedef-decl name='zfs_share_t' type-id='type-id-152' filepath='../../include/sys/zfs_ioctl.h' line='457' column='1' id='type-id-145'/>
	<class-decl name='drr_begin' size-in-bits='2432' is-struct='yes' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='231' column='1' id='type-id-146'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='drr_magic' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='232' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='drr_versioninfo' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='233' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='drr_creation_time' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='234' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='drr_type' type-id='type-id-97' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='235' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='224'>
	<var-decl name='drr_flags' type-id='type-id-62' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='236' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='drr_toguid' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='237' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='drr_fromguid' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='238' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='drr_toname' type-id='type-id-19' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='239' column='1'/>
	</data-member>
	</class-decl>
	<class-decl name='zinject_record' size-in-bits='2816' is-struct='yes' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='403' column='1' id='type-id-153'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='zi_objset' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='404' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='zi_object' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='405' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='zi_start' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='406' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='zi_end' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='407' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='zi_guid' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='408' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='zi_level' type-id='type-id-62' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='409' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='352'>
	<var-decl name='zi_error' type-id='type-id-62' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='410' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='zi_type' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='411' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='448'>
	<var-decl name='zi_freq' type-id='type-id-62' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='412' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='480'>
	<var-decl name='zi_failfast' type-id='type-id-62' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='413' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='512'>
	<var-decl name='zi_func' type-id='type-id-19' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='414' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2560'>
	<var-decl name='zi_iotype' type-id='type-id-62' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='415' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2592'>
	<var-decl name='zi_duration' type-id='type-id-61' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='416' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2624'>
	<var-decl name='zi_timer' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='417' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2688'>
	<var-decl name='zi_nlanes' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='418' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2752'>
	<var-decl name='zi_cmd' type-id='type-id-62' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='419' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2784'>
	<var-decl name='zi_dvas' type-id='type-id-62' visibility='default' filepath='../../include/sys/zfs_ioctl.h' line='420' column='1'/>
	</data-member>
	</class-decl>
	<typedef-decl name='zinject_record_t' type-id='type-id-153' filepath='../../include/sys/zfs_ioctl.h' line='421' column='1' id='type-id-147'/>

	<array-type-def dimensions='1' type-id='type-id-98' size-in-bits='24' id='type-id-148'>
	<subrange length='3' type-id='type-id-48' id='type-id-154'/>

	</array-type-def>
	<class-decl name='zfs_stat' size-in-bits='320' is-struct='yes' visibility='default' filepath='../../include/sys/zfs_stat.h' line='42' column='1' id='type-id-155'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='zs_gen' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_stat.h' line='43' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='zs_mode' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_stat.h' line='44' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='zs_links' type-id='type-id-27' visibility='default' filepath='../../include/sys/zfs_stat.h' line='45' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='zs_ctime' type-id='type-id-156' visibility='default' filepath='../../include/sys/zfs_stat.h' line='46' column='1'/>
	</data-member>
	</class-decl>

	<array-type-def dimensions='1' type-id='type-id-27' size-in-bits='128' id='type-id-156'>
	<subrange length='2' type-id='type-id-48' id='type-id-86'/>

	</array-type-def>
	<typedef-decl name='zfs_stat_t' type-id='type-id-155' filepath='../../include/sys/zfs_stat.h' line='47' column='1' id='type-id-149'/>
	<typedef-decl name='zfs_cmd_t' type-id='type-id-142' filepath='../../include/sys/zfs_ioctl.h' line='518' column='1' id='type-id-157'/>
	<pointer-type-def type-id='type-id-157' size-in-bits='64' id='type-id-158'/>
	- <function-decl name='make_dataset_simple_handle_zc' mangled-name='make_dataset_simple_handle_zc' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='524' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='make_dataset_simple_handle_zc'>
	- <parameter type-id='type-id-102' name='pzhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='524' column='1'/>
	- <parameter type-id='type-id-158' name='zc' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='524' column='1'/>
	+ <function-decl name='make_dataset_simple_handle_zc' mangled-name='make_dataset_simple_handle_zc' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='523' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='make_dataset_simple_handle_zc'>
	+ <parameter type-id='type-id-102' name='pzhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='523' column='1'/>
	+ <parameter type-id='type-id-158' name='zc' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='523' column='1'/>
	<return type-id='type-id-102'/>
	</function-decl>
	- <function-decl name='make_dataset_handle_zc' mangled-name='make_dataset_handle_zc' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='507' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='make_dataset_handle_zc'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='507' column='1'/>
	- <parameter type-id='type-id-158' name='zc' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='507' column='1'/>
	+ <function-decl name='make_dataset_handle_zc' mangled-name='make_dataset_handle_zc' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='506' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='make_dataset_handle_zc'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='506' column='1'/>
	+ <parameter type-id='type-id-158' name='zc' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='506' column='1'/>
	<return type-id='type-id-102'/>
	</function-decl>
	- <function-decl name='make_dataset_handle' mangled-name='make_dataset_handle' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='478' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='make_dataset_handle'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='478' column='1'/>
	- <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='478' column='1'/>
	+ <function-decl name='make_dataset_handle' mangled-name='make_dataset_handle' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='477' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='make_dataset_handle'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='477' column='1'/>
	+ <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='477' column='1'/>
	<return type-id='type-id-102'/>
	</function-decl>
	- <function-decl name='zfs_refresh_properties' mangled-name='zfs_refresh_properties' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='434' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_refresh_properties'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='434' column='1'/>
	+ <function-decl name='zfs_refresh_properties' mangled-name='zfs_refresh_properties' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='433' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_refresh_properties'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='433' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zpool_free_handles' mangled-name='zpool_free_handles' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='313' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_free_handles'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='313' column='1'/>
	+ <function-decl name='zpool_free_handles' mangled-name='zpool_free_handles' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='312' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_free_handles'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='312' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_name_valid' mangled-name='zfs_name_valid' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='222' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_name_valid'>
	- <parameter type-id='type-id-104' name='name' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='222' column='1'/>
	- <parameter type-id='type-id-20' name='type' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='222' column='1'/>
	+ <function-decl name='zfs_name_valid' mangled-name='zfs_name_valid' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='221' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_name_valid'>
	+ <parameter type-id='type-id-104' name='name' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='221' column='1'/>
	+ <parameter type-id='type-id-20' name='type' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='221' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_validate_name' mangled-name='zfs_validate_name' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='106' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_validate_name'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='106' column='1'/>
	- <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='106' column='1'/>
	- <parameter type-id='type-id-6' name='type' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='106' column='1'/>
	- <parameter type-id='type-id-5' name='modifying' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='107' column='1'/>
	+ <function-decl name='zfs_validate_name' mangled-name='zfs_validate_name' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='105' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_validate_name'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='105' column='1'/>
	+ <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='105' column='1'/>
	+ <parameter type-id='type-id-6' name='type' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='105' column='1'/>
	+ <parameter type-id='type-id-5' name='modifying' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='106' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_type_to_name' mangled-name='zfs_type_to_name' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='80' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_type_to_name'>
	- <parameter type-id='type-id-20' name='type' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='80' column='1'/>
	+ <function-decl name='zfs_type_to_name' mangled-name='zfs_type_to_name' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='79' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_type_to_name'>
	+ <parameter type-id='type-id-20' name='type' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='79' column='1'/>
	<return type-id='type-id-104'/>
	</function-decl>
	<class-decl name='mnttab' size-in-bits='256' is-struct='yes' visibility='default' filepath='../../lib/libspl/include/os/linux/sys/mnttab.h' line='49' column='1' id='type-id-159'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='mnt_special' type-id='type-id-23' visibility='default' filepath='../../lib/libspl/include/os/linux/sys/mnttab.h' line='50' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='mnt_mountp' type-id='type-id-23' visibility='default' filepath='../../lib/libspl/include/os/linux/sys/mnttab.h' line='51' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='mnt_fstype' type-id='type-id-23' visibility='default' filepath='../../lib/libspl/include/os/linux/sys/mnttab.h' line='52' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='mnt_mntopts' type-id='type-id-23' visibility='default' filepath='../../lib/libspl/include/os/linux/sys/mnttab.h' line='53' column='1'/>
	</data-member>
	</class-decl>
	<pointer-type-def type-id='type-id-159' size-in-bits='64' id='type-id-160'/>
	- <function-decl name='libzfs_mnttab_find' mangled-name='libzfs_mnttab_find' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='872' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_mnttab_find'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='872' column='1'/>
	- <parameter type-id='type-id-104' name='fsname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='872' column='1'/>
	- <parameter type-id='type-id-160' name='entry' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='873' column='1'/>
	+ <function-decl name='libzfs_mnttab_find' mangled-name='libzfs_mnttab_find' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='871' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_mnttab_find'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='871' column='1'/>
	+ <parameter type-id='type-id-104' name='fsname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='871' column='1'/>
	+ <parameter type-id='type-id-160' name='entry' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='872' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<pointer-type-def type-id='type-id-23' size-in-bits='64' id='type-id-161'/>
	- <function-decl name='getprop_uint64' mangled-name='getprop_uint64' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2038' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='getprop_uint64'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2038' column='1'/>
	- <parameter type-id='type-id-2' name='prop' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2038' column='1'/>
	- <parameter type-id='type-id-161' name='source' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2038' column='1'/>
	+ <function-decl name='getprop_uint64' mangled-name='getprop_uint64' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2037' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='getprop_uint64'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2037' column='1'/>
	+ <parameter type-id='type-id-2' name='prop' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2037' column='1'/>
	+ <parameter type-id='type-id-161' name='source' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='2037' column='1'/>
	<return type-id='type-id-27'/>
	</function-decl>
	- <function-decl name='zfs_dataset_exists' mangled-name='zfs_dataset_exists' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3472' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_dataset_exists'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3472' column='1'/>
	- <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3472' column='1'/>
	- <parameter type-id='type-id-20' name='types' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3472' column='1'/>
	+ <function-decl name='zfs_dataset_exists' mangled-name='zfs_dataset_exists' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3471' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_dataset_exists'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3471' column='1'/>
	+ <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3471' column='1'/>
	+ <parameter type-id='type-id-20' name='types' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='3471' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	<function-decl name='lzc_wait_fs' mangled-name='lzc_wait_fs' filepath='../../include/libzfs_core.h' line='136' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_standard_error_fmt' mangled-name='zfs_standard_error_fmt' filepath='../../include/libzfs_impl.h' line='146' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='nvlist_lookup_nvlist_array' mangled-name='nvlist_lookup_nvlist_array' filepath='../../include/sys/nvpair.h' line='227' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zpool_get_config' mangled-name='zpool_get_config' filepath='../../include/libzfs.h' line='411' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zpool_get_config' mangled-name='zpool_get_config' filepath='../../include/libzfs.h' line='412' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='strtol' mangled-name='strtol' filepath='/usr/include/stdlib.h' line='176' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='lzc_get_holds' mangled-name='lzc_get_holds' filepath='../../include/libzfs_core.h' line='75' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='nvlist_size' mangled-name='nvlist_size' filepath='../../include/sys/nvpair.h' line='153' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='nvlist_pack' mangled-name='nvlist_pack' filepath='../../include/sys/nvpair.h' line='154' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='nvlist_unpack' mangled-name='nvlist_unpack' filepath='../../include/sys/nvpair.h' line='155' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='strerror' mangled-name='strerror' filepath='/usr/include/string.h' line='396' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='nvlist_empty' mangled-name='nvlist_empty' filepath='../../include/sys/nvpair.h' line='239' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='lzc_release' mangled-name='lzc_release' filepath='../../include/libzfs_core.h' line='74' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fnvlist_free' mangled-name='fnvlist_free' filepath='../../include/sys/nvpair.h' line='277' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fnvpair_value_int32' mangled-name='fnvpair_value_int32' filepath='../../include/sys/nvpair.h' line='345' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fnvlist_add_boolean' mangled-name='fnvlist_add_boolean' filepath='../../include/sys/nvpair.h' line='286' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fnvlist_add_nvlist' mangled-name='fnvlist_add_nvlist' filepath='../../include/sys/nvpair.h' line='298' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='lzc_hold' mangled-name='lzc_hold' filepath='../../include/libzfs_core.h' line='73' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='ioctl' mangled-name='ioctl' filepath='/usr/include/x86_64-linux-gnu/sys/ioctl.h' line='41' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='nvlist_alloc' mangled-name='nvlist_alloc' filepath='../../include/sys/nvpair.h' line='151' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zcmd_write_src_nvlist' mangled-name='zcmd_write_src_nvlist' filepath='../../include/libzfs_impl.h' line='177' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='nvpair_type' mangled-name='nvpair_type' filepath='../../include/sys/nvpair.h' line='245' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='nvlist_remove' mangled-name='nvlist_remove' filepath='../../include/sys/nvpair.h' line='198' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zprop_expand_list' mangled-name='zprop_expand_list' filepath='../../include/libzfs_impl.h' line='156' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='changelist_gather' mangled-name='changelist_gather' filepath='../../include/libzfs_impl.h' line='188' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='changelist_haszonedchild' mangled-name='changelist_haszonedchild' filepath='../../include/libzfs_impl.h' line='190' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='changelist_prefix' mangled-name='changelist_prefix' filepath='../../include/libzfs_impl.h' line='183' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='changelist_rename' mangled-name='changelist_rename' filepath='../../include/libzfs_impl.h' line='185' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='changelist_postfix' mangled-name='changelist_postfix' filepath='../../include/libzfs_impl.h' line='184' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='changelist_free' mangled-name='changelist_free' filepath='../../include/libzfs_impl.h' line='187' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_iter_snapshots' mangled-name='zfs_iter_snapshots' filepath='../../include/libzfs.h' line='616' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_iter_snapshots' mangled-name='zfs_iter_snapshots' filepath='../../include/libzfs.h' line='617' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_iter_bookmarks' mangled-name='zfs_iter_bookmarks' filepath='../../include/libzfs.h' line='621' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_iter_bookmarks' mangled-name='zfs_iter_bookmarks' filepath='../../include/libzfs.h' line='622' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='lzc_rollback_to' mangled-name='lzc_rollback_to' filepath='../../include/libzfs_core.h' line='118' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='changelist_remove' mangled-name='changelist_remove' filepath='../../include/libzfs_impl.h' line='186' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='strcspn' mangled-name='strcspn' filepath='/usr/include/string.h' line='272' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zpool_open' mangled-name='zpool_open' filepath='../../include/libzfs.h' line='234' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zpool_close' mangled-name='zpool_close' filepath='../../include/libzfs.h' line='236' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='lzc_snapshot' mangled-name='lzc_snapshot' filepath='../../include/libzfs_core.h' line='52' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='lzc_promote' mangled-name='lzc_promote' filepath='../../include/libzfs_core.h' line='56' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_crypto_clone_check' mangled-name='zfs_crypto_clone_check' filepath='../../include/libzfs.h' line='528' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_crypto_clone_check' mangled-name='zfs_crypto_clone_check' filepath='../../include/libzfs.h' line='529' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='lzc_clone' mangled-name='lzc_clone' filepath='../../include/libzfs_core.h' line='55' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='lzc_destroy_snaps' mangled-name='lzc_destroy_snaps' filepath='../../include/libzfs_core.h' line='57' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='lzc_destroy_bookmarks' mangled-name='lzc_destroy_bookmarks' filepath='../../include/libzfs_core.h' line='61' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='lzc_destroy' mangled-name='lzc_destroy' filepath='../../include/libzfs_core.h' line='121' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_prop_default_numeric' mangled-name='zfs_prop_default_numeric' filepath='../../include/libzfs.h' line='483' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_prop_default_numeric' mangled-name='zfs_prop_default_numeric' filepath='../../include/libzfs.h' line='484' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='dataset_nestcheck' mangled-name='dataset_nestcheck' filepath='../../include/zfs_namecheck.h' line='62' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_crypto_create' mangled-name='zfs_crypto_create' filepath='../../include/libzfs.h' line='526' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_crypto_create' mangled-name='zfs_crypto_create' filepath='../../include/libzfs.h' line='527' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='lzc_create' mangled-name='lzc_create' filepath='../../include/libzfs_core.h' line='53' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='strdup' mangled-name='strdup' filepath='/usr/include/string.h' line='166' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_share' mangled-name='zfs_share' filepath='../../include/libzfs.h' line='837' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_share' mangled-name='zfs_share' filepath='../../include/libzfs.h' line='841' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_commit_all_shares' mangled-name='zfs_commit_all_shares' filepath='../../include/libzfs.h' line='859' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_commit_all_shares' mangled-name='zfs_commit_all_shares' filepath='../../include/libzfs.h' line='863' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='strncpy' mangled-name='strncpy' filepath='/usr/include/string.h' line='124' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='strrchr' mangled-name='strrchr' filepath='/usr/include/string.h' line='252' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_nicebytes' mangled-name='zfs_nicebytes' filepath='../../include/libzutil.h' line='134' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_nicenum' mangled-name='zfs_nicenum' filepath='../../include/libzutil.h' line='135' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_prop_valid_for_type' mangled-name='zfs_prop_valid_for_type' filepath='../../include/sys/fs/zfs.h' line='320' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_error_fmt' mangled-name='zfs_error_fmt' filepath='../../include/libzfs_impl.h' line='137' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='localtime_r' mangled-name='localtime_r' filepath='/usr/include/time.h' line='133' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='strftime' mangled-name='strftime' filepath='/usr/include/time.h' line='88' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zpool_get_prop' mangled-name='zpool_get_prop' filepath='../../include/libzfs.h' line='327' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='nvlist_lookup_uint64_array' mangled-name='nvlist_lookup_uint64_array' filepath='../../include/sys/nvpair.h' line='225' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_prop_get_type' mangled-name='zfs_prop_get_type' filepath='../../include/zfs_prop.h' line='91' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_prop_index_to_string' mangled-name='zfs_prop_index_to_string' filepath='../../include/sys/fs/zfs.h' line='317' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_prop_readonly' mangled-name='zfs_prop_readonly' filepath='../../include/sys/fs/zfs.h' line='306' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='abort' mangled-name='abort' filepath='/usr/include/stdlib.h' line='588' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='nvlist_lookup_int64' mangled-name='nvlist_lookup_int64' filepath='../../include/sys/nvpair.h' line='211' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fprintf' mangled-name='fprintf' filepath='/usr/include/stdio.h' line='326' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fnvlist_add_string' mangled-name='fnvlist_add_string' filepath='../../include/sys/nvpair.h' line='297' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='lzc_channel_program_nosync' mangled-name='lzc_channel_program_nosync' filepath='../../include/libzfs_core.h' line='125' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fnvlist_lookup_nvlist' mangled-name='fnvlist_lookup_nvlist' filepath='../../include/sys/nvpair.h' line='329' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='strsep' mangled-name='strsep' filepath='/usr/include/string.h' line='439' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='nvlist_add_nvlist' mangled-name='nvlist_add_nvlist' filepath='../../include/sys/nvpair.h' line='180' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='hasmntopt' mangled-name='hasmntopt' filepath='/usr/include/mntent.h' line='89' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_prop_setonce' mangled-name='zfs_prop_setonce' filepath='../../include/sys/fs/zfs.h' line='309' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_prop_inheritable' mangled-name='zfs_prop_inheritable' filepath='../../include/sys/fs/zfs.h' line='308' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_prop_user' mangled-name='zfs_prop_user' filepath='../../include/sys/fs/zfs.h' line='314' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_setprop_error' mangled-name='zfs_setprop_error' filepath='../../include/libzfs_impl.h' line='147' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fnvlist_add_uint64' mangled-name='fnvlist_add_uint64' filepath='../../include/sys/nvpair.h' line='296' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fnvpair_value_uint64' mangled-name='fnvpair_value_uint64' filepath='../../include/sys/nvpair.h' line='350' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='nvpair_value_uint64' mangled-name='nvpair_value_uint64' filepath='../../include/sys/nvpair.h' line='256' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='asprintf' mangled-name='asprintf' filepath='/usr/include/stdio.h' line='372' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='nvlist_add_uint64_array' mangled-name='nvlist_add_uint64_array' filepath='../../include/sys/nvpair.h' line='190' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='nvpair_value_string' mangled-name='nvpair_value_string' filepath='../../include/sys/nvpair.h' line='257' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_nicestrtonum' mangled-name='zfs_nicestrtonum' filepath='../../include/libzfs.h' line='862' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_nicestrtonum' mangled-name='zfs_nicestrtonum' filepath='../../include/libzfs.h' line='866' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zpool_prop_get_feature' mangled-name='zpool_prop_get_feature' filepath='../../include/libzfs.h' line='563' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zpool_prop_get_feature' mangled-name='zpool_prop_get_feature' filepath='../../include/libzfs.h' line='564' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='mountpoint_namecheck' mangled-name='mountpoint_namecheck' filepath='../../include/zfs_namecheck.h' line='63' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_parse_options' mangled-name='zfs_parse_options' filepath='../../include/libzfs_impl.h' line='209' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_prop_encryption_key_param' mangled-name='zfs_prop_encryption_key_param' filepath='../../include/sys/fs/zfs.h' line='310' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zprop_parse_value' mangled-name='zprop_parse_value' filepath='../../include/libzfs_impl.h' line='154' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_prop_userquota' mangled-name='zfs_prop_userquota' filepath='../../include/sys/fs/zfs.h' line='315' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_prop_written' mangled-name='zfs_prop_written' filepath='../../include/sys/fs/zfs.h' line='316' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_prop_valid_keylocation' mangled-name='zfs_prop_valid_keylocation' filepath='../../include/sys/fs/zfs.h' line='311' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='pthread_mutex_lock' mangled-name='pthread_mutex_lock' filepath='/usr/include/pthread.h' line='763' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='avl_find' mangled-name='avl_find' filepath='../../include/sys/avl.h' line='175' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='avl_remove' mangled-name='avl_remove' filepath='../../include/sys/avl.h' line='260' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='pthread_mutex_unlock' mangled-name='pthread_mutex_unlock' filepath='/usr/include/pthread.h' line='774' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='avl_numnodes' mangled-name='avl_numnodes' filepath='../../include/sys/avl.h' line='281' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='avl_add' mangled-name='avl_add' filepath='../../include/sys/avl.h' line='252' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='avl_destroy_nodes' mangled-name='avl_destroy_nodes' filepath='../../include/sys/avl.h' line='309' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='avl_destroy' mangled-name='avl_destroy' filepath='../../include/sys/avl.h' line='317' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='pthread_mutex_destroy' mangled-name='pthread_mutex_destroy' filepath='/usr/include/pthread.h' line='755' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='pthread_mutex_init' mangled-name='pthread_mutex_init' filepath='/usr/include/pthread.h' line='750' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='avl_create' mangled-name='avl_create' filepath='../../include/sys/avl.h' line='163' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='lzc_get_bookmarks' mangled-name='lzc_get_bookmarks' filepath='../../include/libzfs_core.h' line='59' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zpool_get_name' mangled-name='zpool_get_name' filepath='../../include/libzfs.h' line='237' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zpool_open_canfail' mangled-name='zpool_open_canfail' filepath='../../include/libzfs.h' line='235' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zpool_name_valid' mangled-name='zpool_name_valid' filepath='../../include/libzfs_impl.h' line='202' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='entity_namecheck' mangled-name='entity_namecheck' filepath='../../include/zfs_namecheck.h' line='58' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='strtoul' mangled-name='strtoul' filepath='/usr/include/stdlib.h' line='180' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='getgrnam' mangled-name='getgrnam' filepath='/usr/include/grp.h' line='107' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='getpwnam' mangled-name='getpwnam' filepath='/usr/include/pwd.h' line='116' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_prop_default_string' mangled-name='zfs_prop_default_string' filepath='../../include/libzfs.h' line='482' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_prop_default_string' mangled-name='zfs_prop_default_string' filepath='../../include/libzfs.h' line='483' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fnvlist_lookup_string' mangled-name='fnvlist_lookup_string' filepath='../../include/sys/nvpair.h' line='328' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='strstr' mangled-name='strstr' filepath='/usr/include/string.h' line='329' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='lzc_exists' mangled-name='lzc_exists' filepath='../../include/libzfs_core.h' line='115' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='nvlist_add_boolean' mangled-name='nvlist_add_boolean' filepath='../../include/sys/nvpair.h' line='168' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='freopen' mangled-name='freopen64' filepath='/usr/include/stdio.h' line='260' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='getmntany' mangled-name='getmntany' filepath='../../lib/libspl/include/os/linux/sys/mnttab.h' line='73' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='_sol_getmntent' mangled-name='_sol_getmntent' filepath='../../lib/libspl/include/os/linux/sys/mnttab.h' line='74' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='nvlist_remove_all' mangled-name='nvlist_remove_all' filepath='../../include/sys/nvpair.h' line='199' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-type size-in-bits='64' id='type-id-125'>
	<parameter type-id='type-id-42'/>
	<parameter type-id='type-id-104'/>
	<parameter type-id='type-id-124'/>
	<parameter type-id='type-id-27'/>
	<return type-id='type-id-6'/>
	</function-type>
	</abi-instr>
	<abi-instr version='1.0' address-size='64' path='libzfs_diff.c' comp-dir-path='/home/colm/src/zfs/zfs/lib/libzfs' language='LANG_C99'>
	<function-decl name='zfs_show_diffs' mangled-name='zfs_show_diffs' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_diff.c' line='716' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_show_diffs'>
	<parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_diff.c' line='716' column='1'/>
	<parameter type-id='type-id-6' name='outfd' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_diff.c' line='716' column='1'/>
	<parameter type-id='type-id-104' name='fromsnap' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_diff.c' line='716' column='1'/>
	<parameter type-id='type-id-104' name='tosnap' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_diff.c' line='717' column='1'/>
	<parameter type-id='type-id-6' name='flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_diff.c' line='717' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zfs_asprintf' mangled-name='zfs_asprintf' filepath='../../include/libzfs_impl.h' line='141' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_validate_name' mangled-name='zfs_validate_name' filepath='../../include/libzfs_impl.h' line='204' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='find_shares_object' mangled-name='find_shares_object' filepath='../../include/libzfs_impl.h' line='258' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='pipe' mangled-name='pipe' filepath='/usr/include/unistd.h' line='417' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='pipe2' mangled-name='pipe2' filepath='/usr/include/unistd.h' line='422' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='pthread_create' mangled-name='pthread_create' filepath='/usr/include/pthread.h' line='234' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='pthread_join' mangled-name='pthread_join' filepath='/usr/include/pthread.h' line='251' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='pthread_cancel' mangled-name='pthread_cancel' filepath='/usr/include/pthread.h' line='514' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fdopen' mangled-name='fdopen' filepath='/usr/include/stdio.h' line='279' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='__builtin_fwrite' mangled-name='fwrite' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='is_mounted' mangled-name='is_mounted' filepath='../../include/libzfs.h' line='819' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='is_mounted' mangled-name='is_mounted' filepath='../../include/libzfs.h' line='823' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	</abi-instr>
	<abi-instr version='1.0' address-size='64' path='libzfs_import.c' comp-dir-path='/home/colm/src/zfs/zfs/lib/libzfs' language='LANG_C99'>
	<class-decl name='pool_config_ops' size-in-bits='128' is-struct='yes' visibility='default' filepath='../../include/libzutil.h' line='51' column='1' id='type-id-162'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='pco_refresh_config' type-id='type-id-163' visibility='default' filepath='../../include/libzutil.h' line='52' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='pco_pool_active' type-id='type-id-164' visibility='default' filepath='../../include/libzutil.h' line='53' column='1'/>
	</data-member>
	</class-decl>
	<typedef-decl name='refresh_config_func_t' type-id='type-id-165' filepath='../../include/libzutil.h' line='47' column='1' id='type-id-166'/>
	<pointer-type-def type-id='type-id-166' size-in-bits='64' id='type-id-163'/>
	<typedef-decl name='pool_active_func_t' type-id='type-id-167' filepath='../../include/libzutil.h' line='49' column='1' id='type-id-168'/>
	<pointer-type-def type-id='type-id-168' size-in-bits='64' id='type-id-164'/>
	<qualified-type-def type-id='type-id-162' const='yes' id='type-id-169'/>
	<typedef-decl name='pool_config_ops_t' type-id='type-id-169' filepath='../../include/libzutil.h' line='54' column='1' id='type-id-170'/>
	<var-decl name='libzfs_config_ops' type-id='type-id-170' mangled-name='libzfs_config_ops' visibility='default' filepath='../../include/libzutil.h' line='59' column='1' elf-symbol-id='libzfs_config_ops'/>
	- <enum-decl name='pool_state' filepath='../../include/sys/fs/zfs.h' line='906' column='1' id='type-id-171'>
	+ <enum-decl name='pool_state' filepath='../../include/sys/fs/zfs.h' line='914' column='1' id='type-id-171'>
	<underlying-type type-id='type-id-7'/>
	<enumerator name='POOL_STATE_ACTIVE' value='0'/>
	<enumerator name='POOL_STATE_EXPORTED' value='1'/>
	<enumerator name='POOL_STATE_DESTROYED' value='2'/>
	<enumerator name='POOL_STATE_SPARE' value='3'/>
	<enumerator name='POOL_STATE_L2CACHE' value='4'/>
	<enumerator name='POOL_STATE_UNINITIALIZED' value='5'/>
	<enumerator name='POOL_STATE_UNAVAIL' value='6'/>
	<enumerator name='POOL_STATE_POTENTIALLY_ACTIVE' value='7'/>
	</enum-decl>
	- <typedef-decl name='pool_state_t' type-id='type-id-171' filepath='../../include/sys/fs/zfs.h' line='915' column='1' id='type-id-172'/>
	+ <typedef-decl name='pool_state_t' type-id='type-id-171' filepath='../../include/sys/fs/zfs.h' line='923' column='1' id='type-id-172'/>
	<pointer-type-def type-id='type-id-172' size-in-bits='64' id='type-id-173'/>
	<function-decl name='zpool_in_use' mangled-name='zpool_in_use' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_import.c' line='300' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_in_use'>
	<parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_import.c' line='300' column='1'/>
	<parameter type-id='type-id-6' name='fd' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_import.c' line='300' column='1'/>
	<parameter type-id='type-id-173' name='state' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_import.c' line='300' column='1'/>
	<parameter type-id='type-id-161' name='namestr' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_import.c' line='300' column='1'/>
	<parameter type-id='type-id-114' name='inuse' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_import.c' line='301' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zpool_clear_label' mangled-name='zpool_clear_label' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_import.c' line='144' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_clear_label'>
	<parameter type-id='type-id-6' name='fd' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_import.c' line='144' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zpool_read_label' mangled-name='zpool_read_label' filepath='../../include/libzutil.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zpool_iter' mangled-name='zpool_iter' filepath='../../include/libzfs.h' line='247' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='pread64' mangled-name='pread64' filepath='/usr/include/unistd.h' line='404' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='pwrite64' mangled-name='pwrite64' filepath='/usr/include/unistd.h' line='408' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='__fxstat64' mangled-name='__fxstat64' filepath='/usr/include/x86_64-linux-gnu/sys/stat.h' line='428' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zcmd_write_conf_nvlist' mangled-name='zcmd_write_conf_nvlist' filepath='../../include/libzfs_impl.h' line='178' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-type size-in-bits='64' id='type-id-167'>
	<parameter type-id='type-id-42'/>
	<parameter type-id='type-id-104'/>
	<parameter type-id='type-id-27'/>
	<parameter type-id='type-id-114'/>
	<return type-id='type-id-6'/>
	</function-type>
	<function-type size-in-bits='64' id='type-id-165'>
	<parameter type-id='type-id-42'/>
	<parameter type-id='type-id-22'/>
	<return type-id='type-id-22'/>
	</function-type>
	</abi-instr>
	<abi-instr version='1.0' address-size='64' path='libzfs_iter.c' comp-dir-path='/home/colm/src/zfs/zfs/lib/libzfs' language='LANG_C99'>
	<function-decl name='zfs_iter_mounted' mangled-name='zfs_iter_mounted' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='559' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_mounted'>
	<parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='559' column='1'/>
	<parameter type-id='type-id-110' name='func' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='559' column='1'/>
	<parameter type-id='type-id-42' name='data' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='559' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zfs_iter_dependents' mangled-name='zfs_iter_dependents' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='543' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_dependents'>
	<parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='543' column='1'/>
	<parameter type-id='type-id-5' name='allowrecursion' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='543' column='1'/>
	<parameter type-id='type-id-110' name='func' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='544' column='1'/>
	<parameter type-id='type-id-42' name='data' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='544' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zfs_iter_children' mangled-name='zfs_iter_children' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='460' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_children'>
	<parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='460' column='1'/>
	<parameter type-id='type-id-110' name='func' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='460' column='1'/>
	<parameter type-id='type-id-42' name='data' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='460' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zfs_iter_snapspec' mangled-name='zfs_iter_snapspec' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='383' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_snapspec'>
	<parameter type-id='type-id-102' name='fs_zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='383' column='1'/>
	<parameter type-id='type-id-104' name='spec_orig' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='383' column='1'/>
	<parameter type-id='type-id-110' name='func' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='384' column='1'/>
	<parameter type-id='type-id-42' name='arg' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='384' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zfs_iter_snapshots_sorted' mangled-name='zfs_iter_snapshots_sorted' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='309' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_snapshots_sorted'>
	<parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='309' column='1'/>
	<parameter type-id='type-id-110' name='callback' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='309' column='1'/>
	<parameter type-id='type-id-42' name='data' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='309' column='1'/>
	<parameter type-id='type-id-27' name='min_txg' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='310' column='1'/>
	<parameter type-id='type-id-27' name='max_txg' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='310' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zfs_iter_bookmarks' mangled-name='zfs_iter_bookmarks' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='202' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_bookmarks'>
	<parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='202' column='1'/>
	<parameter type-id='type-id-110' name='func' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='202' column='1'/>
	<parameter type-id='type-id-42' name='data' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='202' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zfs_iter_snapshots' mangled-name='zfs_iter_snapshots' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='143' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_snapshots'>
	<parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='143' column='1'/>
	<parameter type-id='type-id-5' name='simple' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='143' column='1'/>
	<parameter type-id='type-id-110' name='func' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='143' column='1'/>
	<parameter type-id='type-id-42' name='data' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='144' column='1'/>
	<parameter type-id='type-id-27' name='min_txg' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='144' column='1'/>
	<parameter type-id='type-id-27' name='max_txg' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='144' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zfs_iter_filesystems' mangled-name='zfs_iter_filesystems' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='107' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_iter_filesystems'>
	<parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='107' column='1'/>
	<parameter type-id='type-id-110' name='func' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='107' column='1'/>
	<parameter type-id='type-id-42' name='data' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_iter.c' line='107' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_get_clones_nvl' mangled-name='zfs_get_clones_nvl' filepath='../../include/libzfs.h' line='517' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_get_clones_nvl' mangled-name='zfs_get_clones_nvl' filepath='../../include/libzfs.h' line='518' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_dataset_exists' mangled-name='zfs_dataset_exists' filepath='../../include/libzfs.h' line='811' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_dataset_exists' mangled-name='zfs_dataset_exists' filepath='../../include/libzfs.h' line='815' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='avl_first' mangled-name='avl_first' filepath='../../include/sys/avl.h' line='205' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='avl_walk' mangled-name='avl_walk' filepath='../../include/sys/avl_impl.h' line='158' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='make_bookmark_handle' mangled-name='make_bookmark_handle' filepath='../../include/libzfs_impl.h' line='197' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fnvpair_value_nvlist' mangled-name='fnvpair_value_nvlist' filepath='../../include/sys/nvpair.h' line='352' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_get_type' mangled-name='zfs_get_type' filepath='../../include/libzfs.h' line='469' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_get_type' mangled-name='zfs_get_type' filepath='../../include/libzfs.h' line='470' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='make_dataset_simple_handle_zc' mangled-name='make_dataset_simple_handle_zc' filepath='../../include/libzfs_impl.h' line='152' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='make_dataset_handle_zc' mangled-name='make_dataset_handle_zc' filepath='../../include/libzfs_impl.h' line='151' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	</abi-instr>
	<abi-instr version='1.0' address-size='64' path='libzfs_mount.c' comp-dir-path='/home/colm/src/zfs/zfs/lib/libzfs' language='LANG_C99'>
	<class-decl name='__anonymous_struct__' size-in-bits='192' is-struct='yes' is-anonymous='yes' naming-typedef-id='type-id-174' visibility='default' filepath='../../include/libzfs_impl.h' line='214' column='1' id='type-id-175'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='p_prop' type-id='type-id-2' visibility='default' filepath='../../include/libzfs_impl.h' line='215' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='p_name' type-id='type-id-23' visibility='default' filepath='../../include/libzfs_impl.h' line='216' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='p_share_err' type-id='type-id-6' visibility='default' filepath='../../include/libzfs_impl.h' line='217' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='160'>
	<var-decl name='p_unshare_err' type-id='type-id-6' visibility='default' filepath='../../include/libzfs_impl.h' line='218' column='1'/>
	</data-member>
	</class-decl>
	<typedef-decl name='proto_table_t' type-id='type-id-175' filepath='../../include/libzfs_impl.h' line='219' column='1' id='type-id-174'/>

	<array-type-def dimensions='1' type-id='type-id-174' size-in-bits='384' id='type-id-176'>
	<subrange length='2' type-id='type-id-48' id='type-id-86'/>

	</array-type-def>
	<var-decl name='proto_table' type-id='type-id-176' mangled-name='proto_table' visibility='default' filepath='../../include/libzfs_impl.h' line='242' column='1' elf-symbol-id='proto_table'/>

	<array-type-def dimensions='1' type-id='type-id-106' size-in-bits='64' alignment-in-bits='32' id='type-id-177'>
	<subrange length='2' type-id='type-id-48' id='type-id-86'/>

	</array-type-def>
	<var-decl name='nfs_only' type-id='type-id-177' mangled-name='nfs_only' visibility='default' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='110' column='1' elf-symbol-id='nfs_only'/>
	<var-decl name='smb_only' type-id='type-id-177' mangled-name='smb_only' visibility='default' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='115' column='1' elf-symbol-id='smb_only'/>

	<array-type-def dimensions='1' type-id='type-id-106' size-in-bits='96' alignment-in-bits='32' id='type-id-178'>
	<subrange length='3' type-id='type-id-48' id='type-id-154'/>

	</array-type-def>
	<var-decl name='share_all_proto' type-id='type-id-178' mangled-name='share_all_proto' visibility='default' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='119' column='1' elf-symbol-id='share_all_proto'/>
	- <function-decl name='zpool_disable_datasets' mangled-name='zpool_unmount_datasets' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1484' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_unmount_datasets'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1484' column='1'/>
	- <parameter type-id='type-id-5' name='force' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1484' column='1'/>
	+ <function-decl name='zpool_disable_datasets' mangled-name='zpool_unmount_datasets' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1505' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_unmount_datasets'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1505' column='1'/>
	+ <parameter type-id='type-id-5' name='force' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1505' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_enable_datasets' mangled-name='zpool_enable_datasets' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1414' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_enable_datasets'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1414' column='1'/>
	- <parameter type-id='type-id-104' name='mntopts' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1414' column='1'/>
	- <parameter type-id='type-id-6' name='flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1414' column='1'/>
	+ <function-decl name='zpool_enable_datasets' mangled-name='zpool_enable_datasets' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1435' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_enable_datasets'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1435' column='1'/>
	+ <parameter type-id='type-id-104' name='mntopts' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1435' column='1'/>
	+ <parameter type-id='type-id-6' name='flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1435' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<pointer-type-def type-id='type-id-102' size-in-bits='64' id='type-id-179'/>
	- <function-decl name='zfs_foreach_mountpoint' mangled-name='zfs_foreach_mountpoint' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1353' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_foreach_mountpoint'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1353' column='1'/>
	- <parameter type-id='type-id-179' name='handles' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1353' column='1'/>
	- <parameter type-id='type-id-43' name='num_handles' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1354' column='1'/>
	- <parameter type-id='type-id-110' name='func' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1354' column='1'/>
	- <parameter type-id='type-id-42' name='data' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1354' column='1'/>
	- <parameter type-id='type-id-5' name='parallel' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1354' column='1'/>
	+ <function-decl name='zfs_foreach_mountpoint' mangled-name='zfs_foreach_mountpoint' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1374' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_foreach_mountpoint'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1374' column='1'/>
	+ <parameter type-id='type-id-179' name='handles' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1374' column='1'/>
	+ <parameter type-id='type-id-43' name='num_handles' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1375' column='1'/>
	+ <parameter type-id='type-id-110' name='func' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1375' column='1'/>
	+ <parameter type-id='type-id-42' name='data' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1375' column='1'/>
	+ <parameter type-id='type-id-5' name='parallel' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1375' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	- <class-decl name='get_all_cb' size-in-bits='192' is-struct='yes' visibility='default' filepath='../../include/libzfs.h' line='624' column='1' id='type-id-180'>
	+ <class-decl name='get_all_cb' size-in-bits='192' is-struct='yes' visibility='default' filepath='../../include/libzfs.h' line='625' column='1' id='type-id-180'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='cb_handles' type-id='type-id-179' visibility='default' filepath='../../include/libzfs.h' line='625' column='1'/>
	+ <var-decl name='cb_handles' type-id='type-id-179' visibility='default' filepath='../../include/libzfs.h' line='626' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='cb_alloc' type-id='type-id-43' visibility='default' filepath='../../include/libzfs.h' line='626' column='1'/>
	+ <var-decl name='cb_alloc' type-id='type-id-43' visibility='default' filepath='../../include/libzfs.h' line='627' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='cb_used' type-id='type-id-43' visibility='default' filepath='../../include/libzfs.h' line='627' column='1'/>
	+ <var-decl name='cb_used' type-id='type-id-43' visibility='default' filepath='../../include/libzfs.h' line='628' column='1'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='get_all_cb_t' type-id='type-id-180' filepath='../../include/libzfs.h' line='628' column='1' id='type-id-181'/>
	+ <typedef-decl name='get_all_cb_t' type-id='type-id-180' filepath='../../include/libzfs.h' line='629' column='1' id='type-id-181'/>
	<pointer-type-def type-id='type-id-181' size-in-bits='64' id='type-id-182'/>
	- <function-decl name='libzfs_add_handle' mangled-name='libzfs_add_handle' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1031' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_add_handle'>
	- <parameter type-id='type-id-182' name='cbp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1031' column='1'/>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1031' column='1'/>
	+ <function-decl name='libzfs_add_handle' mangled-name='libzfs_add_handle' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1052' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_add_handle'>
	+ <parameter type-id='type-id-182' name='cbp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1052' column='1'/>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1052' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='remove_mountpoint' mangled-name='remove_mountpoint' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1005' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='remove_mountpoint'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1005' column='1'/>
	+ <function-decl name='remove_mountpoint' mangled-name='remove_mountpoint' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1026' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='remove_mountpoint'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1026' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_unshareall_bytype' mangled-name='zfs_unshareall_bytype' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='980' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unshareall_bytype'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='980' column='1'/>
	- <parameter type-id='type-id-104' name='mountpoint' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='980' column='1'/>
	- <parameter type-id='type-id-104' name='proto' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='981' column='1'/>
	+ <function-decl name='zfs_unshareall_bytype' mangled-name='zfs_unshareall_bytype' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1001' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unshareall_bytype'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1001' column='1'/>
	+ <parameter type-id='type-id-104' name='mountpoint' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1001' column='1'/>
	+ <parameter type-id='type-id-104' name='proto' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='1002' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_unshareall_bypath' mangled-name='zfs_unshareall_bypath' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='974' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unshareall_bypath'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='974' column='1'/>
	- <parameter type-id='type-id-104' name='mountpoint' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='974' column='1'/>
	+ <function-decl name='zfs_unshareall_bypath' mangled-name='zfs_unshareall_bypath' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='995' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unshareall_bypath'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='995' column='1'/>
	+ <parameter type-id='type-id-104' name='mountpoint' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='995' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_unshareall' mangled-name='zfs_unshareall' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='968' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unshareall'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='968' column='1'/>
	+ <function-decl name='zfs_unshareall' mangled-name='zfs_unshareall' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='989' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unshareall'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='989' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_unshareall_smb' mangled-name='zfs_unshareall_smb' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='962' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unshareall_smb'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='968' column='1'/>
	+ <function-decl name='zfs_unshareall_smb' mangled-name='zfs_unshareall_smb' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='983' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unshareall_smb'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='989' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_unshareall_nfs' mangled-name='zfs_unshareall_nfs' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='956' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unshareall_nfs'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='968' column='1'/>
	+ <function-decl name='zfs_unshareall_nfs' mangled-name='zfs_unshareall_nfs' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='977' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unshareall_nfs'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='989' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_unshare_smb' mangled-name='zfs_unshare_smb' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='931' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unshare_smb'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='974' column='1'/>
	- <parameter type-id='type-id-104' name='mountpoint' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='974' column='1'/>
	+ <function-decl name='zfs_unshare_smb' mangled-name='zfs_unshare_smb' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='952' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unshare_smb'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='995' column='1'/>
	+ <parameter type-id='type-id-104' name='mountpoint' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='995' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_unshare_nfs' mangled-name='zfs_unshare_nfs' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='925' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unshare_nfs'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='974' column='1'/>
	- <parameter type-id='type-id-104' name='mountpoint' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='974' column='1'/>
	+ <function-decl name='zfs_unshare_nfs' mangled-name='zfs_unshare_nfs' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='946' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unshare_nfs'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='995' column='1'/>
	+ <parameter type-id='type-id-104' name='mountpoint' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='995' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_unshare_proto' mangled-name='zfs_unshare_proto' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='887' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unshare_proto'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='887' column='1'/>
	- <parameter type-id='type-id-104' name='mountpoint' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='887' column='1'/>
	- <parameter type-id='type-id-107' name='proto' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='888' column='1'/>
	+ <function-decl name='zfs_unshare_proto' mangled-name='zfs_unshare_proto' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='908' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unshare_proto'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='908' column='1'/>
	+ <parameter type-id='type-id-104' name='mountpoint' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='908' column='1'/>
	+ <parameter type-id='type-id-107' name='proto' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='909' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_share_smb' mangled-name='zfs_share_smb' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='872' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_share_smb'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='968' column='1'/>
	+ <function-decl name='zfs_share_smb' mangled-name='zfs_share_smb' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='893' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_share_smb'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='989' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_share_nfs' mangled-name='zfs_share_nfs' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='866' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_share_nfs'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='968' column='1'/>
	+ <function-decl name='zfs_share_nfs' mangled-name='zfs_share_nfs' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='887' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_share_nfs'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='989' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_commit_shares' mangled-name='zfs_commit_shares' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='855' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_commit_shares'>
	- <parameter type-id='type-id-104' name='proto' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='855' column='1'/>
	+ <function-decl name='zfs_commit_shares' mangled-name='zfs_commit_shares' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='876' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_commit_shares'>
	+ <parameter type-id='type-id-104' name='proto' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='876' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_commit_proto' mangled-name='zfs_commit_proto' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='828' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_commit_proto'>
	- <parameter type-id='type-id-107' name='proto' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='828' column='1'/>
	+ <function-decl name='zfs_commit_proto' mangled-name='zfs_commit_proto' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='849' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_commit_proto'>
	+ <parameter type-id='type-id-107' name='proto' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='849' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_parse_options' mangled-name='zfs_parse_options' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='822' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_parse_options'>
	- <parameter type-id='type-id-23' name='options' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='822' column='1'/>
	- <parameter type-id='type-id-106' name='proto' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='822' column='1'/>
	+ <function-decl name='zfs_parse_options' mangled-name='zfs_parse_options' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='843' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_parse_options'>
	+ <parameter type-id='type-id-23' name='options' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='843' column='1'/>
	+ <parameter type-id='type-id-106' name='proto' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='843' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_is_shared_smb' mangled-name='zfs_is_shared_smb' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='809' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_is_shared_smb'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='809' column='1'/>
	- <parameter type-id='type-id-161' name='where' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='809' column='1'/>
	+ <function-decl name='zfs_is_shared_smb' mangled-name='zfs_is_shared_smb' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='830' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_is_shared_smb'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='830' column='1'/>
	+ <parameter type-id='type-id-161' name='where' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='830' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	- <function-decl name='zfs_is_shared_nfs' mangled-name='zfs_is_shared_nfs' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='802' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_is_shared_nfs'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='809' column='1'/>
	- <parameter type-id='type-id-161' name='where' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='809' column='1'/>
	+ <function-decl name='zfs_is_shared_nfs' mangled-name='zfs_is_shared_nfs' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='823' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_is_shared_nfs'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='830' column='1'/>
	+ <parameter type-id='type-id-161' name='where' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='830' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	<enum-decl name='__anonymous_enum__' is-anonymous='yes' filepath='../../include/libzfs_impl.h' line='120' column='1' id='type-id-183'>
	<underlying-type type-id='type-id-7'/>
	<enumerator name='SHARED_NOT_SHARED' value='0'/>
	<enumerator name='SHARED_NFS' value='2'/>
	<enumerator name='SHARED_SMB' value='4'/>
	</enum-decl>
	<typedef-decl name='zfs_share_type_t' type-id='type-id-183' filepath='../../include/libzfs_impl.h' line='124' column='1' id='type-id-184'/>
	- <function-decl name='zfs_is_shared_proto' mangled-name='zfs_is_shared_proto' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='780' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_is_shared_proto'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='780' column='1'/>
	- <parameter type-id='type-id-161' name='where' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='780' column='1'/>
	- <parameter type-id='type-id-106' name='proto' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='780' column='1'/>
	+ <function-decl name='zfs_is_shared_proto' mangled-name='zfs_is_shared_proto' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='801' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_is_shared_proto'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='801' column='1'/>
	+ <parameter type-id='type-id-161' name='where' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='801' column='1'/>
	+ <parameter type-id='type-id-106' name='proto' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='801' column='1'/>
	<return type-id='type-id-184'/>
	</function-decl>
	- <function-decl name='zfs_unshare' mangled-name='zfs_unshare' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='770' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unshare'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='968' column='1'/>
	+ <function-decl name='zfs_unshare' mangled-name='zfs_unshare' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='791' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unshare'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='989' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_share' mangled-name='zfs_share' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='763' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_share'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='968' column='1'/>
	+ <function-decl name='zfs_share' mangled-name='zfs_share' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='784' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_share'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='989' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_share_proto' mangled-name='zfs_share_proto' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='718' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_share_proto'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='718' column='1'/>
	- <parameter type-id='type-id-107' name='proto' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='718' column='1'/>
	+ <function-decl name='zfs_share_proto' mangled-name='zfs_share_proto' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='739' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_share_proto'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='739' column='1'/>
	+ <parameter type-id='type-id-107' name='proto' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='739' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='unshare_one' mangled-name='unshare_one' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='678' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='unshare_one'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='678' column='1'/>
	- <parameter type-id='type-id-104' name='name' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='678' column='1'/>
	- <parameter type-id='type-id-104' name='mountpoint' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='678' column='1'/>
	- <parameter type-id='type-id-106' name='proto' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='679' column='1'/>
	+ <function-decl name='unshare_one' mangled-name='unshare_one' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='699' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='unshare_one'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='699' column='1'/>
	+ <parameter type-id='type-id-104' name='name' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='699' column='1'/>
	+ <parameter type-id='type-id-104' name='mountpoint' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='699' column='1'/>
	+ <parameter type-id='type-id-106' name='proto' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='700' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_is_shared' mangled-name='zfs_is_shared' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='659' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_is_shared'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='659' column='1'/>
	+ <function-decl name='zfs_is_shared' mangled-name='zfs_is_shared' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='680' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_is_shared'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='680' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	- <function-decl name='zfs_unmountall' mangled-name='zfs_unmountall' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='642' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unmountall'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='642' column='1'/>
	- <parameter type-id='type-id-6' name='flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='642' column='1'/>
	+ <function-decl name='zfs_unmountall' mangled-name='zfs_unmountall' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='663' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unmountall'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='663' column='1'/>
	+ <parameter type-id='type-id-6' name='flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='663' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_unmount' mangled-name='zfs_unmount' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='568' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unmount'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='568' column='1'/>
	- <parameter type-id='type-id-104' name='mountpoint' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='568' column='1'/>
	- <parameter type-id='type-id-6' name='flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='568' column='1'/>
	+ <function-decl name='zfs_unmount' mangled-name='zfs_unmount' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='589' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_unmount'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='589' column='1'/>
	+ <parameter type-id='type-id-104' name='mountpoint' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='589' column='1'/>
	+ <parameter type-id='type-id-6' name='flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='589' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zfs_mount_at' mangled-name='zfs_mount_at' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='382' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_mount_at'>
	<parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='382' column='1'/>
	<parameter type-id='type-id-104' name='options' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='382' column='1'/>
	<parameter type-id='type-id-6' name='flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='382' column='1'/>
	<parameter type-id='type-id-104' name='mountpoint' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='383' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zfs_mount' mangled-name='zfs_mount' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='367' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_mount'>
	<parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='367' column='1'/>
	<parameter type-id='type-id-104' name='options' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='367' column='1'/>
	<parameter type-id='type-id-6' name='flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='367' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zfs_is_mounted' mangled-name='zfs_is_mounted' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='238' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_is_mounted'>
	<parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='238' column='1'/>
	<parameter type-id='type-id-161' name='where' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='238' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	<function-decl name='is_mounted' mangled-name='is_mounted' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='224' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='is_mounted'>
	<parameter type-id='type-id-17' name='zfs_hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='224' column='1'/>
	<parameter type-id='type-id-104' name='special' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='224' column='1'/>
	<parameter type-id='type-id-161' name='where' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='224' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	<function-decl name='zfs_is_mountable' mangled-name='zfs_is_mountable' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='265' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_is_mountable'>
	<parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='265' column='1'/>
	<parameter type-id='type-id-23' name='buf' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='265' column='1'/>
	<parameter type-id='type-id-43' name='buflen' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='265' column='1'/>
	<parameter type-id='type-id-140' name='source' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='266' column='1'/>
	<parameter type-id='type-id-6' name='flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='266' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	- <function-decl name='is_shared' mangled-name='is_shared' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='697' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='is_shared'>
	- <parameter type-id='type-id-104' name='mountpoint' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='697' column='1'/>
	- <parameter type-id='type-id-106' name='proto' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='697' column='1'/>
	+ <function-decl name='is_shared' mangled-name='is_shared' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='718' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='is_shared'>
	+ <parameter type-id='type-id-104' name='mountpoint' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='718' column='1'/>
	+ <parameter type-id='type-id-106' name='proto' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_mount.c' line='718' column='1'/>
	<return type-id='type-id-184'/>
	</function-decl>
	<function-decl name='zfs_realloc' mangled-name='zfs_realloc' filepath='../../include/libzfs_impl.h' line='140' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='do_unmount' mangled-name='do_unmount' filepath='../../include/libzfs_impl.h' line='246' column='1' visibility='default' binding='global' size-in-bits='64'>
	- <return type-id='type-id-52'/>
	- </function-decl>
	<function-decl name='qsort' mangled-name='qsort' filepath='/usr/include/stdlib.h' line='827' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='tpool_dispatch' mangled-name='tpool_dispatch' filepath='../../include/thread_pool.h' line='44' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='tpool_create' mangled-name='tpool_create' filepath='../../include/thread_pool.h' line='42' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='tpool_wait' mangled-name='tpool_wait' filepath='../../include/thread_pool.h' line='48' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='tpool_destroy' mangled-name='tpool_destroy' filepath='../../include/thread_pool.h' line='46' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='rmdir' mangled-name='rmdir' filepath='/usr/include/unistd.h' line='834' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='changelist_unshare' mangled-name='changelist_unshare' filepath='../../include/libzfs_impl.h' line='189' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='libzfs_mnttab_find' mangled-name='libzfs_mnttab_find' filepath='../../include/libzfs.h' line='225' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='sa_commit_shares' mangled-name='sa_commit_shares' filepath='../../lib/libspl/include/libshare.h' line='81' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='sa_validate_shareopts' mangled-name='sa_validate_shareopts' filepath='../../lib/libspl/include/libshare.h' line='84' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='sa_enable_share' mangled-name='sa_enable_share' filepath='../../lib/libspl/include/libshare.h' line='77' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='sa_errorstr' mangled-name='sa_errorstr' filepath='../../lib/libspl/include/libshare.h' line='74' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='sa_disable_share' mangled-name='sa_disable_share' filepath='../../lib/libspl/include/libshare.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='libzfs_mnttab_remove' mangled-name='libzfs_mnttab_remove' filepath='../../include/libzfs.h' line='229' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_crypto_get_encryption_root' mangled-name='zfs_crypto_get_encryption_root' filepath='../../include/libzfs.h' line='525' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_crypto_get_encryption_root' mangled-name='zfs_crypto_get_encryption_root' filepath='../../include/libzfs.h' line='526' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_crypto_unload_key' mangled-name='zfs_crypto_unload_key' filepath='../../include/libzfs.h' line='532' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_crypto_unload_key' mangled-name='zfs_crypto_unload_key' filepath='../../include/libzfs.h' line='533' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <return type-id='type-id-52'/>
	+ </function-decl>
	+ <function-decl name='do_unmount' mangled-name='do_unmount' filepath='../../include/libzfs_impl.h' line='246' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_spa_version' mangled-name='zfs_spa_version' filepath='../../include/libzfs.h' line='813' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_spa_version' mangled-name='zfs_spa_version' filepath='../../include/libzfs.h' line='817' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='__lxstat' mangled-name='__lxstat64' filepath='/usr/include/x86_64-linux-gnu/sys/stat.h' line='412' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='openat' mangled-name='openat64' filepath='/usr/include/fcntl.h' line='196' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fdopendir' mangled-name='fdopendir' filepath='/usr/include/dirent.h' line='141' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='readdir64' mangled-name='readdir64' filepath='/usr/include/dirent.h' line='173' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='closedir' mangled-name='closedir' filepath='/usr/include/dirent.h' line='149' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='__xstat' mangled-name='__xstat64' filepath='/usr/include/x86_64-linux-gnu/sys/stat.h' line='409' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='statfs64' mangled-name='statfs64' filepath='/usr/include/x86_64-linux-gnu/sys/statfs.h' line='43' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='do_mount' mangled-name='do_mount' filepath='../../include/libzfs_impl.h' line='244' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='libzfs_mnttab_add' mangled-name='libzfs_mnttab_add' filepath='../../include/libzfs.h' line='227' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='mkdirp' mangled-name='mkdirp' filepath='../../lib/libspl/include/libgen.h' line='33' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_crypto_load_key' mangled-name='zfs_crypto_load_key' filepath='../../include/libzfs.h' line='531' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_crypto_load_key' mangled-name='zfs_crypto_load_key' filepath='../../include/libzfs.h' line='532' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='getprop_uint64' mangled-name='getprop_uint64' filepath='../../include/libzfs.h' line='509' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='getprop_uint64' mangled-name='getprop_uint64' filepath='../../include/libzfs.h' line='510' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='sa_is_shared' mangled-name='sa_is_shared' filepath='../../lib/libspl/include/libshare.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	</abi-instr>
	<abi-instr version='1.0' address-size='64' path='libzfs_pool.c' comp-dir-path='/home/colm/src/zfs/zfs/lib/libzfs' language='LANG_C99'>
	- <function-decl name='zpool_get_bootenv' mangled-name='zpool_get_bootenv' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4689' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_bootenv'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4689' column='1'/>
	- <parameter type-id='type-id-115' name='nvlp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4689' column='1'/>
	+ <function-decl name='zpool_get_bootenv' mangled-name='zpool_get_bootenv' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4699' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_bootenv'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4699' column='1'/>
	+ <parameter type-id='type-id-115' name='nvlp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4699' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<qualified-type-def type-id='type-id-67' const='yes' id='type-id-185'/>
	<pointer-type-def type-id='type-id-185' size-in-bits='64' id='type-id-186'/>
	- <function-decl name='zpool_set_bootenv' mangled-name='zpool_set_bootenv' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4676' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_set_bootenv'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4676' column='1'/>
	- <parameter type-id='type-id-186' name='envmap' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4676' column='1'/>
	+ <function-decl name='zpool_set_bootenv' mangled-name='zpool_set_bootenv' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4686' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_set_bootenv'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4686' column='1'/>
	+ <parameter type-id='type-id-186' name='envmap' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4686' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <enum-decl name='__anonymous_enum__' is-anonymous='yes' filepath='../../include/sys/fs/zfs.h' line='1419' column='1' id='type-id-187'>
	+ <enum-decl name='__anonymous_enum__' is-anonymous='yes' filepath='../../include/sys/fs/zfs.h' line='1427' column='1' id='type-id-187'>
	<underlying-type type-id='type-id-7'/>
	<enumerator name='ZPOOL_WAIT_CKPT_DISCARD' value='0'/>
	<enumerator name='ZPOOL_WAIT_FREE' value='1'/>
	<enumerator name='ZPOOL_WAIT_INITIALIZE' value='2'/>
	<enumerator name='ZPOOL_WAIT_REPLACE' value='3'/>
	<enumerator name='ZPOOL_WAIT_REMOVE' value='4'/>
	<enumerator name='ZPOOL_WAIT_RESILVER' value='5'/>
	<enumerator name='ZPOOL_WAIT_SCRUB' value='6'/>
	<enumerator name='ZPOOL_WAIT_TRIM' value='7'/>
	<enumerator name='ZPOOL_WAIT_NUM_ACTIVITIES' value='8'/>
	</enum-decl>
	- <typedef-decl name='zpool_wait_activity_t' type-id='type-id-187' filepath='../../include/sys/fs/zfs.h' line='1429' column='1' id='type-id-188'/>
	- <function-decl name='zpool_wait_status' mangled-name='zpool_wait_status' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4658' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_wait_status'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4658' column='1'/>
	- <parameter type-id='type-id-188' name='activity' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4658' column='1'/>
	- <parameter type-id='type-id-114' name='missing' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4659' column='1'/>
	- <parameter type-id='type-id-114' name='waited' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4659' column='1'/>
	+ <typedef-decl name='zpool_wait_activity_t' type-id='type-id-187' filepath='../../include/sys/fs/zfs.h' line='1437' column='1' id='type-id-188'/>
	+ <function-decl name='zpool_wait_status' mangled-name='zpool_wait_status' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4668' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_wait_status'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4668' column='1'/>
	+ <parameter type-id='type-id-188' name='activity' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4668' column='1'/>
	+ <parameter type-id='type-id-114' name='missing' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4669' column='1'/>
	+ <parameter type-id='type-id-114' name='waited' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4669' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_wait' mangled-name='zpool_wait' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4631' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_wait'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4631' column='1'/>
	- <parameter type-id='type-id-188' name='activity' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4631' column='1'/>
	+ <function-decl name='zpool_wait' mangled-name='zpool_wait' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4641' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_wait'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4641' column='1'/>
	+ <parameter type-id='type-id-188' name='activity' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4641' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_obj_to_path_ds' mangled-name='zpool_obj_to_path_ds' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4622' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_obj_to_path_ds'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4622' column='1'/>
	- <parameter type-id='type-id-27' name='dsobj' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4622' column='1'/>
	- <parameter type-id='type-id-27' name='obj' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4622' column='1'/>
	- <parameter type-id='type-id-23' name='pathname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4623' column='1'/>
	- <parameter type-id='type-id-43' name='len' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4623' column='1'/>
	+ <function-decl name='zpool_obj_to_path_ds' mangled-name='zpool_obj_to_path_ds' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4632' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_obj_to_path_ds'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4632' column='1'/>
	+ <parameter type-id='type-id-27' name='dsobj' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4632' column='1'/>
	+ <parameter type-id='type-id-27' name='obj' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4632' column='1'/>
	+ <parameter type-id='type-id-23' name='pathname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4633' column='1'/>
	+ <parameter type-id='type-id-43' name='len' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4633' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zpool_obj_to_path' mangled-name='zpool_obj_to_path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4615' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_obj_to_path'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4622' column='1'/>
	- <parameter type-id='type-id-27' name='dsobj' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4622' column='1'/>
	- <parameter type-id='type-id-27' name='obj' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4622' column='1'/>
	- <parameter type-id='type-id-23' name='pathname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4623' column='1'/>
	- <parameter type-id='type-id-43' name='len' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4623' column='1'/>
	+ <function-decl name='zpool_obj_to_path' mangled-name='zpool_obj_to_path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4625' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_obj_to_path'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4632' column='1'/>
	+ <parameter type-id='type-id-27' name='dsobj' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4632' column='1'/>
	+ <parameter type-id='type-id-27' name='obj' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4632' column='1'/>
	+ <parameter type-id='type-id-23' name='pathname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4633' column='1'/>
	+ <parameter type-id='type-id-43' name='len' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4633' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zpool_events_seek' mangled-name='zpool_events_seek' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4533' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_events_seek'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4533' column='1'/>
	- <parameter type-id='type-id-27' name='eid' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4533' column='1'/>
	- <parameter type-id='type-id-6' name='zevent_fd' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4533' column='1'/>
	+ <function-decl name='zpool_events_seek' mangled-name='zpool_events_seek' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4543' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_events_seek'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4543' column='1'/>
	+ <parameter type-id='type-id-27' name='eid' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4543' column='1'/>
	+ <parameter type-id='type-id-6' name='zevent_fd' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4543' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_events_clear' mangled-name='zpool_events_clear' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4510' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_events_clear'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4510' column='1'/>
	- <parameter type-id='type-id-141' name='count' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4510' column='1'/>
	+ <function-decl name='zpool_events_clear' mangled-name='zpool_events_clear' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4520' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_events_clear'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4520' column='1'/>
	+ <parameter type-id='type-id-141' name='count' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4520' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_events_next' mangled-name='zpool_events_next' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4450' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_events_next'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4450' column='1'/>
	- <parameter type-id='type-id-115' name='nvp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4450' column='1'/>
	- <parameter type-id='type-id-141' name='dropped' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4451' column='1'/>
	- <parameter type-id='type-id-64' name='flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4451' column='1'/>
	- <parameter type-id='type-id-6' name='zevent_fd' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4451' column='1'/>
	+ <function-decl name='zpool_events_next' mangled-name='zpool_events_next' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4460' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_events_next'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4460' column='1'/>
	+ <parameter type-id='type-id-115' name='nvp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4460' column='1'/>
	+ <parameter type-id='type-id-141' name='dropped' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4461' column='1'/>
	+ <parameter type-id='type-id-64' name='flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4461' column='1'/>
	+ <parameter type-id='type-id-6' name='zevent_fd' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4461' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_get_history' mangled-name='zpool_get_history' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4380' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_history'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4380' column='1'/>
	- <parameter type-id='type-id-115' name='nvhisp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4380' column='1'/>
	- <parameter type-id='type-id-137' name='off' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4380' column='1'/>
	- <parameter type-id='type-id-114' name='eof' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4381' column='1'/>
	+ <function-decl name='zpool_get_history' mangled-name='zpool_get_history' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4390' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_history'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4390' column='1'/>
	+ <parameter type-id='type-id-115' name='nvhisp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4390' column='1'/>
	+ <parameter type-id='type-id-137' name='off' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4390' column='1'/>
	+ <parameter type-id='type-id-114' name='eof' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4391' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_log_history' mangled-name='zpool_log_history' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4311' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_log_history'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4311' column='1'/>
	- <parameter type-id='type-id-104' name='message' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4311' column='1'/>
	+ <function-decl name='zpool_log_history' mangled-name='zpool_log_history' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4321' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_log_history'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4321' column='1'/>
	+ <parameter type-id='type-id-104' name='message' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4321' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_save_arguments' mangled-name='zfs_save_arguments' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4299' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_save_arguments'>
	- <parameter type-id='type-id-6' name='argc' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4299' column='1'/>
	- <parameter type-id='type-id-161' name='argv' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4299' column='1'/>
	- <parameter type-id='type-id-23' name='string' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4299' column='1'/>
	- <parameter type-id='type-id-6' name='len' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4299' column='1'/>
	+ <function-decl name='zfs_save_arguments' mangled-name='zfs_save_arguments' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4309' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_save_arguments'>
	+ <parameter type-id='type-id-6' name='argc' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4309' column='1'/>
	+ <parameter type-id='type-id-161' name='argv' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4309' column='1'/>
	+ <parameter type-id='type-id-23' name='string' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4309' column='1'/>
	+ <parameter type-id='type-id-6' name='len' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4309' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zpool_upgrade' mangled-name='zpool_upgrade' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4283' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_upgrade'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4283' column='1'/>
	- <parameter type-id='type-id-27' name='new_version' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4283' column='1'/>
	+ <function-decl name='zpool_upgrade' mangled-name='zpool_upgrade' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4293' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_upgrade'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4293' column='1'/>
	+ <parameter type-id='type-id-27' name='new_version' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4293' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_get_errlog' mangled-name='zpool_get_errlog' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4184' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_errlog'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4184' column='1'/>
	- <parameter type-id='type-id-115' name='nverrlistp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4184' column='1'/>
	+ <function-decl name='zpool_get_errlog' mangled-name='zpool_get_errlog' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4194' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_errlog'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4194' column='1'/>
	+ <parameter type-id='type-id-115' name='nverrlistp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4194' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_vdev_name' mangled-name='zpool_vdev_name' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4059' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_name'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4059' column='1'/>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4059' column='1'/>
	- <parameter type-id='type-id-22' name='nv' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4059' column='1'/>
	- <parameter type-id='type-id-6' name='name_flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4060' column='1'/>
	+ <function-decl name='zpool_vdev_name' mangled-name='zpool_vdev_name' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4069' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_name'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4069' column='1'/>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4069' column='1'/>
	+ <parameter type-id='type-id-22' name='nv' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4069' column='1'/>
	+ <parameter type-id='type-id-6' name='name_flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4070' column='1'/>
	<return type-id='type-id-23'/>
	</function-decl>
	- <function-decl name='zpool_sync_one' mangled-name='zpool_sync_one' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4022' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_sync_one'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4022' column='1'/>
	- <parameter type-id='type-id-42' name='data' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4022' column='1'/>
	+ <function-decl name='zpool_sync_one' mangled-name='zpool_sync_one' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4032' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_sync_one'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4032' column='1'/>
	+ <parameter type-id='type-id-42' name='data' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4032' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_reopen_one' mangled-name='zpool_reopen_one' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4004' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_reopen_one'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4004' column='1'/>
	- <parameter type-id='type-id-42' name='data' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4004' column='1'/>
	+ <function-decl name='zpool_reopen_one' mangled-name='zpool_reopen_one' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4014' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_reopen_one'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4014' column='1'/>
	+ <parameter type-id='type-id-42' name='data' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4014' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_reguid' mangled-name='zpool_reguid' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3984' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_reguid'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3984' column='1'/>
	+ <function-decl name='zpool_reguid' mangled-name='zpool_reguid' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3994' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_reguid'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3994' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_vdev_clear' mangled-name='zpool_vdev_clear' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3960' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_clear'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3960' column='1'/>
	- <parameter type-id='type-id-27' name='guid' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3960' column='1'/>
	+ <function-decl name='zpool_vdev_clear' mangled-name='zpool_vdev_clear' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3970' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_clear'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3970' column='1'/>
	+ <parameter type-id='type-id-27' name='guid' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3970' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_clear' mangled-name='zpool_clear' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3884' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_clear'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3884' column='1'/>
	- <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3884' column='1'/>
	- <parameter type-id='type-id-22' name='rewindnvl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3884' column='1'/>
	+ <function-decl name='zpool_clear' mangled-name='zpool_clear' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3894' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_clear'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3894' column='1'/>
	+ <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3894' column='1'/>
	+ <parameter type-id='type-id-22' name='rewindnvl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3894' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_vdev_indirect_size' mangled-name='zpool_vdev_indirect_size' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3851' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_indirect_size'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3851' column='1'/>
	- <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3851' column='1'/>
	- <parameter type-id='type-id-137' name='sizep' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3852' column='1'/>
	+ <function-decl name='zpool_vdev_indirect_size' mangled-name='zpool_vdev_indirect_size' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3861' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_indirect_size'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3861' column='1'/>
	+ <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3861' column='1'/>
	+ <parameter type-id='type-id-137' name='sizep' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3862' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_vdev_remove_cancel' mangled-name='zpool_vdev_remove_cancel' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3831' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_remove_cancel'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3984' column='1'/>
	+ <function-decl name='zpool_vdev_remove_cancel' mangled-name='zpool_vdev_remove_cancel' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3841' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_remove_cancel'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3994' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_vdev_remove' mangled-name='zpool_vdev_remove' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3759' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_remove'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3759' column='1'/>
	- <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3759' column='1'/>
	+ <function-decl name='zpool_vdev_remove' mangled-name='zpool_vdev_remove' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3769' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_remove'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3769' column='1'/>
	+ <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3769' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<class-decl name='splitflags' size-in-bits='64' is-struct='yes' visibility='default' filepath='../../include/libzfs.h' line='258' column='1' id='type-id-189'>
	<data-member access='public' layout-offset-in-bits='31'>
	<var-decl name='dryrun' type-id='type-id-6' visibility='default' filepath='../../include/libzfs.h' line='260' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='30'>
	<var-decl name='import' type-id='type-id-6' visibility='default' filepath='../../include/libzfs.h' line='263' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	<var-decl name='name_flags' type-id='type-id-6' visibility='default' filepath='../../include/libzfs.h' line='264' column='1'/>
	</data-member>
	</class-decl>
	<typedef-decl name='splitflags_t' type-id='type-id-189' filepath='../../include/libzfs.h' line='265' column='1' id='type-id-190'/>
	- <function-decl name='zpool_vdev_split' mangled-name='zpool_vdev_split' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3515' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_split'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3515' column='1'/>
	- <parameter type-id='type-id-23' name='newname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3515' column='1'/>
	- <parameter type-id='type-id-115' name='newroot' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3515' column='1'/>
	- <parameter type-id='type-id-22' name='props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3516' column='1'/>
	- <parameter type-id='type-id-190' name='flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3516' column='1'/>
	+ <function-decl name='zpool_vdev_split' mangled-name='zpool_vdev_split' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3525' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_split'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3525' column='1'/>
	+ <parameter type-id='type-id-23' name='newname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3525' column='1'/>
	+ <parameter type-id='type-id-115' name='newroot' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3525' column='1'/>
	+ <parameter type-id='type-id-22' name='props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3526' column='1'/>
	+ <parameter type-id='type-id-190' name='flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3526' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_vdev_detach' mangled-name='zpool_vdev_detach' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3418' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_detach'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3418' column='1'/>
	- <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3418' column='1'/>
	+ <function-decl name='zpool_vdev_detach' mangled-name='zpool_vdev_detach' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3428' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_detach'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3428' column='1'/>
	+ <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3428' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_vdev_attach' mangled-name='zpool_vdev_attach' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3245' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_attach'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3245' column='1'/>
	- <parameter type-id='type-id-104' name='old_disk' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3245' column='1'/>
	- <parameter type-id='type-id-104' name='new_disk' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3246' column='1'/>
	- <parameter type-id='type-id-22' name='nvroot' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3246' column='1'/>
	- <parameter type-id='type-id-6' name='replacing' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3246' column='1'/>
	- <parameter type-id='type-id-5' name='rebuild' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3246' column='1'/>
	+ <function-decl name='zpool_vdev_attach' mangled-name='zpool_vdev_attach' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3255' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_attach'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3255' column='1'/>
	+ <parameter type-id='type-id-104' name='old_disk' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3255' column='1'/>
	+ <parameter type-id='type-id-104' name='new_disk' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3256' column='1'/>
	+ <parameter type-id='type-id-22' name='nvroot' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3256' column='1'/>
	+ <parameter type-id='type-id-6' name='replacing' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3256' column='1'/>
	+ <parameter type-id='type-id-5' name='rebuild' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3256' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <enum-decl name='vdev_aux' filepath='../../include/sys/fs/zfs.h' line='876' column='1' id='type-id-191'>
	+ <enum-decl name='vdev_aux' filepath='../../include/sys/fs/zfs.h' line='884' column='1' id='type-id-191'>
	<underlying-type type-id='type-id-7'/>
	<enumerator name='VDEV_AUX_NONE' value='0'/>
	<enumerator name='VDEV_AUX_OPEN_FAILED' value='1'/>
	<enumerator name='VDEV_AUX_CORRUPT_DATA' value='2'/>
	<enumerator name='VDEV_AUX_NO_REPLICAS' value='3'/>
	<enumerator name='VDEV_AUX_BAD_GUID_SUM' value='4'/>
	<enumerator name='VDEV_AUX_TOO_SMALL' value='5'/>
	<enumerator name='VDEV_AUX_BAD_LABEL' value='6'/>
	<enumerator name='VDEV_AUX_VERSION_NEWER' value='7'/>
	<enumerator name='VDEV_AUX_VERSION_OLDER' value='8'/>
	<enumerator name='VDEV_AUX_UNSUP_FEAT' value='9'/>
	<enumerator name='VDEV_AUX_SPARED' value='10'/>
	<enumerator name='VDEV_AUX_ERR_EXCEEDED' value='11'/>
	<enumerator name='VDEV_AUX_IO_FAILURE' value='12'/>
	<enumerator name='VDEV_AUX_BAD_LOG' value='13'/>
	<enumerator name='VDEV_AUX_EXTERNAL' value='14'/>
	<enumerator name='VDEV_AUX_SPLIT_POOL' value='15'/>
	<enumerator name='VDEV_AUX_BAD_ASHIFT' value='16'/>
	<enumerator name='VDEV_AUX_EXTERNAL_PERSIST' value='17'/>
	<enumerator name='VDEV_AUX_ACTIVE' value='18'/>
	<enumerator name='VDEV_AUX_CHILDREN_OFFLINE' value='19'/>
	<enumerator name='VDEV_AUX_ASHIFT_TOO_BIG' value='20'/>
	</enum-decl>
	- <typedef-decl name='vdev_aux_t' type-id='type-id-191' filepath='../../include/sys/fs/zfs.h' line='898' column='1' id='type-id-192'/>
	- <function-decl name='zpool_vdev_degrade' mangled-name='zpool_vdev_degrade' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3191' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_degrade'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3191' column='1'/>
	- <parameter type-id='type-id-27' name='guid' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3191' column='1'/>
	- <parameter type-id='type-id-192' name='aux' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3191' column='1'/>
	+ <typedef-decl name='vdev_aux_t' type-id='type-id-191' filepath='../../include/sys/fs/zfs.h' line='906' column='1' id='type-id-192'/>
	+ <function-decl name='zpool_vdev_degrade' mangled-name='zpool_vdev_degrade' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3201' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_degrade'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3201' column='1'/>
	+ <parameter type-id='type-id-27' name='guid' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3201' column='1'/>
	+ <parameter type-id='type-id-192' name='aux' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3201' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_vdev_fault' mangled-name='zpool_vdev_fault' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3156' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_fault'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3156' column='1'/>
	- <parameter type-id='type-id-27' name='guid' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3156' column='1'/>
	- <parameter type-id='type-id-192' name='aux' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3156' column='1'/>
	+ <function-decl name='zpool_vdev_fault' mangled-name='zpool_vdev_fault' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3166' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_fault'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3166' column='1'/>
	+ <parameter type-id='type-id-27' name='guid' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3166' column='1'/>
	+ <parameter type-id='type-id-192' name='aux' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3166' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_vdev_offline' mangled-name='zpool_vdev_offline' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3106' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_offline'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3106' column='1'/>
	- <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3106' column='1'/>
	- <parameter type-id='type-id-5' name='istmp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3106' column='1'/>
	+ <function-decl name='zpool_vdev_offline' mangled-name='zpool_vdev_offline' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3116' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_offline'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3116' column='1'/>
	+ <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3116' column='1'/>
	+ <parameter type-id='type-id-5' name='istmp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3116' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <enum-decl name='vdev_state' filepath='../../include/sys/fs/zfs.h' line='859' column='1' id='type-id-193'>
	+ <enum-decl name='vdev_state' filepath='../../include/sys/fs/zfs.h' line='867' column='1' id='type-id-193'>
	<underlying-type type-id='type-id-7'/>
	<enumerator name='VDEV_STATE_UNKNOWN' value='0'/>
	<enumerator name='VDEV_STATE_CLOSED' value='1'/>
	<enumerator name='VDEV_STATE_OFFLINE' value='2'/>
	<enumerator name='VDEV_STATE_REMOVED' value='3'/>
	<enumerator name='VDEV_STATE_CANT_OPEN' value='4'/>
	<enumerator name='VDEV_STATE_FAULTED' value='5'/>
	<enumerator name='VDEV_STATE_DEGRADED' value='6'/>
	<enumerator name='VDEV_STATE_HEALTHY' value='7'/>
	</enum-decl>
	- <typedef-decl name='vdev_state_t' type-id='type-id-193' filepath='../../include/sys/fs/zfs.h' line='868' column='1' id='type-id-194'/>
	+ <typedef-decl name='vdev_state_t' type-id='type-id-193' filepath='../../include/sys/fs/zfs.h' line='876' column='1' id='type-id-194'/>
	<pointer-type-def type-id='type-id-194' size-in-bits='64' id='type-id-195'/>
	- <function-decl name='zpool_vdev_online' mangled-name='zpool_vdev_online' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3019' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_online'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3019' column='1'/>
	- <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3019' column='1'/>
	- <parameter type-id='type-id-6' name='flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3019' column='1'/>
	- <parameter type-id='type-id-195' name='newstate' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3020' column='1'/>
	+ <function-decl name='zpool_vdev_online' mangled-name='zpool_vdev_online' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3029' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_online'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3029' column='1'/>
	+ <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3029' column='1'/>
	+ <parameter type-id='type-id-6' name='flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3029' column='1'/>
	+ <parameter type-id='type-id-195' name='newstate' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3030' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_vdev_path_to_guid' mangled-name='zpool_vdev_path_to_guid' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3009' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_path_to_guid'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3009' column='1'/>
	- <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3009' column='1'/>
	+ <function-decl name='zpool_vdev_path_to_guid' mangled-name='zpool_vdev_path_to_guid' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3019' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_vdev_path_to_guid'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3019' column='1'/>
	+ <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='3019' column='1'/>
	<return type-id='type-id-27'/>
	</function-decl>
	- <function-decl name='zpool_get_physpath' mangled-name='zpool_get_physpath' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2971' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_physpath'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2971' column='1'/>
	- <parameter type-id='type-id-23' name='physpath' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2971' column='1'/>
	- <parameter type-id='type-id-43' name='phypath_size' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2971' column='1'/>
	+ <function-decl name='zpool_get_physpath' mangled-name='zpool_get_physpath' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2981' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_physpath'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2981' column='1'/>
	+ <parameter type-id='type-id-23' name='physpath' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2981' column='1'/>
	+ <parameter type-id='type-id-43' name='phypath_size' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2981' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_find_vdev' mangled-name='zpool_find_vdev' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2798' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_find_vdev'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2798' column='1'/>
	- <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2798' column='1'/>
	- <parameter type-id='type-id-114' name='avail_spare' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2798' column='1'/>
	- <parameter type-id='type-id-114' name='l2cache' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2799' column='1'/>
	- <parameter type-id='type-id-114' name='log' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2799' column='1'/>
	+ <function-decl name='zpool_find_vdev' mangled-name='zpool_find_vdev' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2808' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_find_vdev'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2808' column='1'/>
	+ <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2808' column='1'/>
	+ <parameter type-id='type-id-114' name='avail_spare' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2808' column='1'/>
	+ <parameter type-id='type-id-114' name='l2cache' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2809' column='1'/>
	+ <parameter type-id='type-id-114' name='log' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2809' column='1'/>
	<return type-id='type-id-22'/>
	</function-decl>
	- <function-decl name='zpool_find_vdev_by_physpath' mangled-name='zpool_find_vdev_by_physpath' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2747' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_find_vdev_by_physpath'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2747' column='1'/>
	- <parameter type-id='type-id-104' name='ppath' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2747' column='1'/>
	- <parameter type-id='type-id-114' name='avail_spare' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2748' column='1'/>
	- <parameter type-id='type-id-114' name='l2cache' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2748' column='1'/>
	- <parameter type-id='type-id-114' name='log' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2748' column='1'/>
	+ <function-decl name='zpool_find_vdev_by_physpath' mangled-name='zpool_find_vdev_by_physpath' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2757' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_find_vdev_by_physpath'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2757' column='1'/>
	+ <parameter type-id='type-id-104' name='ppath' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2757' column='1'/>
	+ <parameter type-id='type-id-114' name='avail_spare' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2758' column='1'/>
	+ <parameter type-id='type-id-114' name='l2cache' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2758' column='1'/>
	+ <parameter type-id='type-id-114' name='log' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2758' column='1'/>
	<return type-id='type-id-22'/>
	</function-decl>
	- <enum-decl name='pool_scan_func' filepath='../../include/sys/fs/zfs.h' line='930' column='1' id='type-id-196'>
	+ <enum-decl name='pool_scan_func' filepath='../../include/sys/fs/zfs.h' line='938' column='1' id='type-id-196'>
	<underlying-type type-id='type-id-7'/>
	<enumerator name='POOL_SCAN_NONE' value='0'/>
	<enumerator name='POOL_SCAN_SCRUB' value='1'/>
	<enumerator name='POOL_SCAN_RESILVER' value='2'/>
	<enumerator name='POOL_SCAN_FUNCS' value='3'/>
	</enum-decl>
	- <typedef-decl name='pool_scan_func_t' type-id='type-id-196' filepath='../../include/sys/fs/zfs.h' line='935' column='1' id='type-id-197'/>
	- <enum-decl name='pool_scrub_cmd' filepath='../../include/sys/fs/zfs.h' line='940' column='1' id='type-id-198'>
	+ <typedef-decl name='pool_scan_func_t' type-id='type-id-196' filepath='../../include/sys/fs/zfs.h' line='943' column='1' id='type-id-197'/>
	+ <enum-decl name='pool_scrub_cmd' filepath='../../include/sys/fs/zfs.h' line='948' column='1' id='type-id-198'>
	<underlying-type type-id='type-id-7'/>
	<enumerator name='POOL_SCRUB_NORMAL' value='0'/>
	<enumerator name='POOL_SCRUB_PAUSE' value='1'/>
	<enumerator name='POOL_SCRUB_FLAGS_END' value='2'/>
	</enum-decl>
	- <typedef-decl name='pool_scrub_cmd_t' type-id='type-id-198' filepath='../../include/sys/fs/zfs.h' line='944' column='1' id='type-id-199'/>
	- <function-decl name='zpool_scan' mangled-name='zpool_scan' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2502' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_scan'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2502' column='1'/>
	- <parameter type-id='type-id-197' name='func' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2502' column='1'/>
	- <parameter type-id='type-id-199' name='cmd' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2502' column='1'/>
	+ <typedef-decl name='pool_scrub_cmd_t' type-id='type-id-198' filepath='../../include/sys/fs/zfs.h' line='952' column='1' id='type-id-199'/>
	+ <function-decl name='zpool_scan' mangled-name='zpool_scan' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2482' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_scan'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2482' column='1'/>
	+ <parameter type-id='type-id-197' name='func' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2482' column='1'/>
	+ <parameter type-id='type-id-199' name='cmd' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2482' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <enum-decl name='pool_trim_func' filepath='../../include/sys/fs/zfs.h' line='1169' column='1' id='type-id-200'>
	+ <enum-decl name='pool_trim_func' filepath='../../include/sys/fs/zfs.h' line='1177' column='1' id='type-id-200'>
	<underlying-type type-id='type-id-7'/>
	<enumerator name='POOL_TRIM_START' value='0'/>
	<enumerator name='POOL_TRIM_CANCEL' value='1'/>
	<enumerator name='POOL_TRIM_SUSPEND' value='2'/>
	<enumerator name='POOL_TRIM_FUNCS' value='3'/>
	</enum-decl>
	- <typedef-decl name='pool_trim_func_t' type-id='type-id-200' filepath='../../include/sys/fs/zfs.h' line='1174' column='1' id='type-id-201'/>
	+ <typedef-decl name='pool_trim_func_t' type-id='type-id-200' filepath='../../include/sys/fs/zfs.h' line='1182' column='1' id='type-id-201'/>
	<class-decl name='trimflags' size-in-bits='192' is-struct='yes' visibility='default' filepath='../../include/libzfs.h' line='267' column='1' id='type-id-202'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='fullpool' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='269' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	<var-decl name='secure' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='272' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='wait' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='275' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='rate' type-id='type-id-27' visibility='default' filepath='../../include/libzfs.h' line='278' column='1'/>
	</data-member>
	</class-decl>
	<typedef-decl name='trimflags_t' type-id='type-id-202' filepath='../../include/libzfs.h' line='279' column='1' id='type-id-203'/>
	<pointer-type-def type-id='type-id-203' size-in-bits='64' id='type-id-204'/>
	- <function-decl name='zpool_trim' mangled-name='zpool_trim' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2446' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_trim'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2446' column='1'/>
	- <parameter type-id='type-id-201' name='cmd_type' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2446' column='1'/>
	- <parameter type-id='type-id-22' name='vds' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2446' column='1'/>
	- <parameter type-id='type-id-204' name='trim_flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2447' column='1'/>
	+ <function-decl name='zpool_trim' mangled-name='zpool_trim' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2426' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_trim'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2426' column='1'/>
	+ <parameter type-id='type-id-201' name='cmd_type' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2426' column='1'/>
	+ <parameter type-id='type-id-22' name='vds' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2426' column='1'/>
	+ <parameter type-id='type-id-204' name='trim_flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2427' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <enum-decl name='pool_initialize_func' filepath='../../include/sys/fs/zfs.h' line='1159' column='1' id='type-id-205'>
	+ <enum-decl name='pool_initialize_func' filepath='../../include/sys/fs/zfs.h' line='1167' column='1' id='type-id-205'>
	<underlying-type type-id='type-id-7'/>
	<enumerator name='POOL_INITIALIZE_START' value='0'/>
	<enumerator name='POOL_INITIALIZE_CANCEL' value='1'/>
	<enumerator name='POOL_INITIALIZE_SUSPEND' value='2'/>
	<enumerator name='POOL_INITIALIZE_FUNCS' value='3'/>
	</enum-decl>
	- <typedef-decl name='pool_initialize_func_t' type-id='type-id-205' filepath='../../include/sys/fs/zfs.h' line='1164' column='1' id='type-id-206'/>
	- <function-decl name='zpool_initialize_wait' mangled-name='zpool_initialize_wait' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2337' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_initialize_wait'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2337' column='1'/>
	- <parameter type-id='type-id-206' name='cmd_type' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2337' column='1'/>
	- <parameter type-id='type-id-22' name='vds' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2338' column='1'/>
	+ <typedef-decl name='pool_initialize_func_t' type-id='type-id-205' filepath='../../include/sys/fs/zfs.h' line='1172' column='1' id='type-id-206'/>
	+ <function-decl name='zpool_initialize_wait' mangled-name='zpool_initialize_wait' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2317' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_initialize_wait'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2317' column='1'/>
	+ <parameter type-id='type-id-206' name='cmd_type' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2317' column='1'/>
	+ <parameter type-id='type-id-22' name='vds' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2318' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_initialize' mangled-name='zpool_initialize' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2330' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_initialize'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2337' column='1'/>
	- <parameter type-id='type-id-206' name='cmd_type' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2337' column='1'/>
	- <parameter type-id='type-id-22' name='vds' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2338' column='1'/>
	+ <function-decl name='zpool_initialize' mangled-name='zpool_initialize' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2310' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_initialize'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2317' column='1'/>
	+ <parameter type-id='type-id-206' name='cmd_type' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2317' column='1'/>
	+ <parameter type-id='type-id-22' name='vds' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='2318' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_import_props' mangled-name='zpool_import_props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1941' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_import_props'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1941' column='1'/>
	- <parameter type-id='type-id-22' name='config' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1941' column='1'/>
	- <parameter type-id='type-id-104' name='newname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1941' column='1'/>
	- <parameter type-id='type-id-22' name='props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1942' column='1'/>
	- <parameter type-id='type-id-6' name='flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1942' column='1'/>
	+ <function-decl name='zpool_import_props' mangled-name='zpool_import_props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1921' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_import_props'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1921' column='1'/>
	+ <parameter type-id='type-id-22' name='config' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1921' column='1'/>
	+ <parameter type-id='type-id-104' name='newname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1921' column='1'/>
	+ <parameter type-id='type-id-22' name='props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1922' column='1'/>
	+ <parameter type-id='type-id-6' name='flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1922' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_print_unsup_feat' mangled-name='zpool_print_unsup_feat' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1910' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_print_unsup_feat'>
	- <parameter type-id='type-id-22' name='config' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1910' column='1'/>
	+ <function-decl name='zpool_print_unsup_feat' mangled-name='zpool_print_unsup_feat' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1890' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_print_unsup_feat'>
	+ <parameter type-id='type-id-22' name='config' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1890' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zpool_import' mangled-name='zpool_import' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1852' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_import'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1852' column='1'/>
	- <parameter type-id='type-id-22' name='config' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1852' column='1'/>
	- <parameter type-id='type-id-104' name='newname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1852' column='1'/>
	- <parameter type-id='type-id-23' name='altroot' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1853' column='1'/>
	+ <function-decl name='zpool_import' mangled-name='zpool_import' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1832' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_import'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1832' column='1'/>
	+ <parameter type-id='type-id-22' name='config' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1832' column='1'/>
	+ <parameter type-id='type-id-104' name='newname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1832' column='1'/>
	+ <parameter type-id='type-id-23' name='altroot' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1833' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_explain_recover' mangled-name='zpool_explain_recover' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1765' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_explain_recover'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1765' column='1'/>
	- <parameter type-id='type-id-104' name='name' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1765' column='1'/>
	- <parameter type-id='type-id-6' name='reason' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1765' column='1'/>
	- <parameter type-id='type-id-22' name='config' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1766' column='1'/>
	+ <function-decl name='zpool_explain_recover' mangled-name='zpool_explain_recover' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1745' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_explain_recover'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1745' column='1'/>
	+ <parameter type-id='type-id-104' name='name' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1745' column='1'/>
	+ <parameter type-id='type-id-6' name='reason' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1745' column='1'/>
	+ <parameter type-id='type-id-22' name='config' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1746' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zpool_export_force' mangled-name='zpool_export_force' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1707' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_export_force'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1707' column='1'/>
	- <parameter type-id='type-id-104' name='log_str' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1707' column='1'/>
	+ <function-decl name='zpool_export_force' mangled-name='zpool_export_force' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1687' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_export_force'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1687' column='1'/>
	+ <parameter type-id='type-id-104' name='log_str' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1687' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_export' mangled-name='zpool_export' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1701' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_export'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1701' column='1'/>
	- <parameter type-id='type-id-5' name='force' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1701' column='1'/>
	- <parameter type-id='type-id-104' name='log_str' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1701' column='1'/>
	+ <function-decl name='zpool_export' mangled-name='zpool_export' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1681' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_export'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1681' column='1'/>
	+ <parameter type-id='type-id-5' name='force' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1681' column='1'/>
	+ <parameter type-id='type-id-104' name='log_str' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1681' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_add' mangled-name='zpool_add' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1557' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_add'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1557' column='1'/>
	- <parameter type-id='type-id-22' name='nvroot' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1557' column='1'/>
	+ <function-decl name='zpool_add' mangled-name='zpool_add' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1537' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_add'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1537' column='1'/>
	+ <parameter type-id='type-id-22' name='nvroot' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1537' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_discard_checkpoint' mangled-name='zpool_discard_checkpoint' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1535' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_discard_checkpoint'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1535' column='1'/>
	+ <function-decl name='zpool_discard_checkpoint' mangled-name='zpool_discard_checkpoint' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1515' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_discard_checkpoint'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1515' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_checkpoint' mangled-name='zpool_checkpoint' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1514' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_checkpoint'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1535' column='1'/>
	+ <function-decl name='zpool_checkpoint' mangled-name='zpool_checkpoint' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1494' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_checkpoint'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1515' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_destroy' mangled-name='zpool_destroy' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1471' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_destroy'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1471' column='1'/>
	- <parameter type-id='type-id-104' name='log_str' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1471' column='1'/>
	+ <function-decl name='zpool_destroy' mangled-name='zpool_destroy' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1451' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_destroy'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1451' column='1'/>
	+ <parameter type-id='type-id-104' name='log_str' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1451' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_create' mangled-name='zpool_create' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1292' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_create'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1292' column='1'/>
	- <parameter type-id='type-id-104' name='pool' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1292' column='1'/>
	- <parameter type-id='type-id-22' name='nvroot' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1292' column='1'/>
	- <parameter type-id='type-id-22' name='props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1293' column='1'/>
	- <parameter type-id='type-id-22' name='fsprops' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1293' column='1'/>
	+ <function-decl name='zpool_create' mangled-name='zpool_create' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1272' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_create'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1272' column='1'/>
	+ <parameter type-id='type-id-104' name='pool' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1272' column='1'/>
	+ <parameter type-id='type-id-22' name='nvroot' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1272' column='1'/>
	+ <parameter type-id='type-id-22' name='props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1273' column='1'/>
	+ <parameter type-id='type-id-22' name='fsprops' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1273' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_is_draid_spare' mangled-name='zpool_is_draid_spare' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1273' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_is_draid_spare'>
	- <parameter type-id='type-id-104' name='name' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1273' column='1'/>
	+ <function-decl name='zpool_is_draid_spare' mangled-name='zpool_is_draid_spare' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1253' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_is_draid_spare'>
	+ <parameter type-id='type-id-104' name='name' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1253' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	- <function-decl name='zpool_get_state' mangled-name='zpool_get_state' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1202' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_state'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1202' column='1'/>
	+ <function-decl name='zpool_get_state' mangled-name='zpool_get_state' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1182' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_state'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1182' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_get_name' mangled-name='zpool_get_name' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1192' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_name'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1192' column='1'/>
	+ <function-decl name='zpool_get_name' mangled-name='zpool_get_name' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1172' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_name'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1172' column='1'/>
	<return type-id='type-id-104'/>
	</function-decl>
	- <function-decl name='zpool_close' mangled-name='zpool_close' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1180' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_close'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1180' column='1'/>
	+ <function-decl name='zpool_close' mangled-name='zpool_close' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1160' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_close'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1160' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zpool_open' mangled-name='zpool_open' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1159' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_open'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1159' column='1'/>
	- <parameter type-id='type-id-104' name='pool' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1159' column='1'/>
	+ <function-decl name='zpool_open' mangled-name='zpool_open' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1139' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_open'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1139' column='1'/>
	+ <parameter type-id='type-id-104' name='pool' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1139' column='1'/>
	<return type-id='type-id-18'/>
	</function-decl>
	<pointer-type-def type-id='type-id-18' size-in-bits='64' id='type-id-207'/>
	- <function-decl name='zpool_open_silent' mangled-name='zpool_open_silent' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1128' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_open_silent'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1128' column='1'/>
	- <parameter type-id='type-id-104' name='pool' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1128' column='1'/>
	- <parameter type-id='type-id-207' name='ret' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1128' column='1'/>
	+ <function-decl name='zpool_open_silent' mangled-name='zpool_open_silent' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1108' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_open_silent'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1108' column='1'/>
	+ <parameter type-id='type-id-104' name='pool' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1108' column='1'/>
	+ <parameter type-id='type-id-207' name='ret' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1108' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_open_canfail' mangled-name='zpool_open_canfail' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1086' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_open_canfail'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1086' column='1'/>
	- <parameter type-id='type-id-104' name='pool' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1086' column='1'/>
	+ <function-decl name='zpool_open_canfail' mangled-name='zpool_open_canfail' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1066' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_open_canfail'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1066' column='1'/>
	+ <parameter type-id='type-id-104' name='pool' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='1066' column='1'/>
	<return type-id='type-id-18'/>
	</function-decl>
	- <function-decl name='zpool_name_valid' mangled-name='zpool_name_valid' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='987' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_name_valid'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='987' column='1'/>
	- <parameter type-id='type-id-5' name='isopen' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='987' column='1'/>
	- <parameter type-id='type-id-104' name='pool' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='987' column='1'/>
	+ <function-decl name='zpool_name_valid' mangled-name='zpool_name_valid' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='967' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_name_valid'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='967' column='1'/>
	+ <parameter type-id='type-id-5' name='isopen' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='967' column='1'/>
	+ <parameter type-id='type-id-104' name='pool' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='967' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	- <function-decl name='zpool_prop_get_feature' mangled-name='zpool_prop_get_feature' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='925' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_get_feature'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='925' column='1'/>
	- <parameter type-id='type-id-104' name='propname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='925' column='1'/>
	- <parameter type-id='type-id-23' name='buf' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='925' column='1'/>
	- <parameter type-id='type-id-43' name='len' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='926' column='1'/>
	+ <function-decl name='zpool_prop_get_feature' mangled-name='zpool_prop_get_feature' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='905' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_get_feature'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='905' column='1'/>
	+ <parameter type-id='type-id-104' name='propname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='905' column='1'/>
	+ <parameter type-id='type-id-23' name='buf' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='905' column='1'/>
	+ <parameter type-id='type-id-43' name='len' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='906' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_expand_proplist' mangled-name='zpool_expand_proplist' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='827' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_expand_proplist'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='827' column='1'/>
	- <parameter type-id='type-id-132' name='plp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='827' column='1'/>
	- <parameter type-id='type-id-5' name='literal' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='828' column='1'/>
	+ <function-decl name='zpool_expand_proplist' mangled-name='zpool_expand_proplist' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='807' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_expand_proplist'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='807' column='1'/>
	+ <parameter type-id='type-id-132' name='plp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='807' column='1'/>
	+ <parameter type-id='type-id-5' name='literal' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='808' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_set_prop' mangled-name='zpool_set_prop' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='771' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_set_prop'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='771' column='1'/>
	- <parameter type-id='type-id-104' name='propname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='771' column='1'/>
	- <parameter type-id='type-id-104' name='propval' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='771' column='1'/>
	+ <function-decl name='zpool_set_prop' mangled-name='zpool_set_prop' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='751' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_set_prop'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='751' column='1'/>
	+ <parameter type-id='type-id-104' name='propname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='751' column='1'/>
	+ <parameter type-id='type-id-104' name='propval' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='751' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<enum-decl name='__anonymous_enum__' is-anonymous='yes' filepath='../../include/sys/fs/zfs.h' line='215' column='1' id='type-id-208'>
	<underlying-type type-id='type-id-7'/>
	<enumerator name='ZPOOL_PROP_INVAL' value='-1'/>
	<enumerator name='ZPOOL_PROP_NAME' value='0'/>
	<enumerator name='ZPOOL_PROP_SIZE' value='1'/>
	<enumerator name='ZPOOL_PROP_CAPACITY' value='2'/>
	<enumerator name='ZPOOL_PROP_ALTROOT' value='3'/>
	<enumerator name='ZPOOL_PROP_HEALTH' value='4'/>
	<enumerator name='ZPOOL_PROP_GUID' value='5'/>
	<enumerator name='ZPOOL_PROP_VERSION' value='6'/>
	<enumerator name='ZPOOL_PROP_BOOTFS' value='7'/>
	<enumerator name='ZPOOL_PROP_DELEGATION' value='8'/>
	<enumerator name='ZPOOL_PROP_AUTOREPLACE' value='9'/>
	<enumerator name='ZPOOL_PROP_CACHEFILE' value='10'/>
	<enumerator name='ZPOOL_PROP_FAILUREMODE' value='11'/>
	<enumerator name='ZPOOL_PROP_LISTSNAPS' value='12'/>
	<enumerator name='ZPOOL_PROP_AUTOEXPAND' value='13'/>
	<enumerator name='ZPOOL_PROP_DEDUPDITTO' value='14'/>
	<enumerator name='ZPOOL_PROP_DEDUPRATIO' value='15'/>
	<enumerator name='ZPOOL_PROP_FREE' value='16'/>
	<enumerator name='ZPOOL_PROP_ALLOCATED' value='17'/>
	<enumerator name='ZPOOL_PROP_READONLY' value='18'/>
	<enumerator name='ZPOOL_PROP_ASHIFT' value='19'/>
	<enumerator name='ZPOOL_PROP_COMMENT' value='20'/>
	<enumerator name='ZPOOL_PROP_EXPANDSZ' value='21'/>
	<enumerator name='ZPOOL_PROP_FREEING' value='22'/>
	<enumerator name='ZPOOL_PROP_FRAGMENTATION' value='23'/>
	<enumerator name='ZPOOL_PROP_LEAKED' value='24'/>
	<enumerator name='ZPOOL_PROP_MAXBLOCKSIZE' value='25'/>
	<enumerator name='ZPOOL_PROP_TNAME' value='26'/>
	<enumerator name='ZPOOL_PROP_MAXDNODESIZE' value='27'/>
	<enumerator name='ZPOOL_PROP_MULTIHOST' value='28'/>
	<enumerator name='ZPOOL_PROP_CHECKPOINT' value='29'/>
	<enumerator name='ZPOOL_PROP_LOAD_GUID' value='30'/>
	<enumerator name='ZPOOL_PROP_AUTOTRIM' value='31'/>
	<enumerator name='ZPOOL_PROP_COMPATIBILITY' value='32'/>
	<enumerator name='ZPOOL_NUM_PROPS' value='33'/>
	</enum-decl>
	<typedef-decl name='zpool_prop_t' type-id='type-id-208' filepath='../../include/sys/fs/zfs.h' line='251' column='1' id='type-id-209'/>
	- <function-decl name='zpool_get_prop' mangled-name='zpool_get_prop' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='285' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_prop'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='285' column='1'/>
	- <parameter type-id='type-id-209' name='prop' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='285' column='1'/>
	- <parameter type-id='type-id-23' name='buf' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='285' column='1'/>
	- <parameter type-id='type-id-43' name='len' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='286' column='1'/>
	- <parameter type-id='type-id-140' name='srctype' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='286' column='1'/>
	- <parameter type-id='type-id-5' name='literal' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='286' column='1'/>
	+ <function-decl name='zpool_get_prop' mangled-name='zpool_get_prop' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='284' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_prop'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='284' column='1'/>
	+ <parameter type-id='type-id-209' name='prop' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='284' column='1'/>
	+ <parameter type-id='type-id-23' name='buf' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='284' column='1'/>
	+ <parameter type-id='type-id-43' name='len' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='285' column='1'/>
	+ <parameter type-id='type-id-140' name='srctype' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='285' column='1'/>
	+ <parameter type-id='type-id-5' name='literal' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='285' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_pool_state_to_name' mangled-name='zpool_pool_state_to_name' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='222' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_pool_state_to_name'>
	- <parameter type-id='type-id-172' name='state' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='222' column='1'/>
	+ <function-decl name='zpool_pool_state_to_name' mangled-name='zpool_pool_state_to_name' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='221' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_pool_state_to_name'>
	+ <parameter type-id='type-id-172' name='state' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='221' column='1'/>
	<return type-id='type-id-104'/>
	</function-decl>
	- <function-decl name='zpool_state_to_name' mangled-name='zpool_state_to_name' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='189' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_state_to_name'>
	- <parameter type-id='type-id-194' name='state' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='189' column='1'/>
	- <parameter type-id='type-id-192' name='aux' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='189' column='1'/>
	+ <function-decl name='zpool_state_to_name' mangled-name='zpool_state_to_name' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='188' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_state_to_name'>
	+ <parameter type-id='type-id-194' name='state' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='188' column='1'/>
	+ <parameter type-id='type-id-192' name='aux' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='188' column='1'/>
	<return type-id='type-id-104'/>
	</function-decl>
	- <function-decl name='zpool_get_prop_int' mangled-name='zpool_get_prop_int' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='147' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_prop_int'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='147' column='1'/>
	- <parameter type-id='type-id-209' name='prop' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='147' column='1'/>
	- <parameter type-id='type-id-140' name='src' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='147' column='1'/>
	+ <function-decl name='zpool_get_prop_int' mangled-name='zpool_get_prop_int' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='146' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_prop_int'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='146' column='1'/>
	+ <parameter type-id='type-id-209' name='prop' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='146' column='1'/>
	+ <parameter type-id='type-id-140' name='src' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='146' column='1'/>
	<return type-id='type-id-27'/>
	</function-decl>
	- <function-decl name='zpool_props_refresh' mangled-name='zpool_props_refresh' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='107' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_props_refresh'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='107' column='1'/>
	+ <function-decl name='zpool_props_refresh' mangled-name='zpool_props_refresh' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='106' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_props_refresh'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='106' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_get_state_str' mangled-name='zpool_get_state_str' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='253' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_state_str'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='253' column='1'/>
	+ <function-decl name='zpool_get_state_str' mangled-name='zpool_get_state_str' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='252' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_state_str'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='252' column='1'/>
	<return type-id='type-id-104'/>
	</function-decl>
	- <enum-decl name='__anonymous_enum__' is-anonymous='yes' filepath='../../include/libzfs.h' line='920' column='1' id='type-id-210'>
	+ <enum-decl name='__anonymous_enum__' is-anonymous='yes' filepath='../../include/libzfs.h' line='924' column='1' id='type-id-210'>
	<underlying-type type-id='type-id-7'/>
	<enumerator name='ZPOOL_COMPATIBILITY_OK' value='0'/>
	- <enumerator name='ZPOOL_COMPATIBILITY_READERR' value='1'/>
	- <enumerator name='ZPOOL_COMPATIBILITY_BADFILE' value='2'/>
	- <enumerator name='ZPOOL_COMPATIBILITY_BADWORD' value='3'/>
	+ <enumerator name='ZPOOL_COMPATIBILITY_WARNTOKEN' value='1'/>
	+ <enumerator name='ZPOOL_COMPATIBILITY_BADTOKEN' value='2'/>
	+ <enumerator name='ZPOOL_COMPATIBILITY_BADFILE' value='3'/>
	<enumerator name='ZPOOL_COMPATIBILITY_NOFILES' value='4'/>
	</enum-decl>
	- <typedef-decl name='zpool_compat_status_t' type-id='type-id-210' filepath='../../include/libzfs.h' line='926' column='1' id='type-id-211'/>
	- <function-decl name='zpool_load_compat' mangled-name='zpool_load_compat' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4738' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_load_compat'>
	- <parameter type-id='type-id-104' name='compatibility' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4738' column='1'/>
	- <parameter type-id='type-id-114' name='features' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4739' column='1'/>
	- <parameter type-id='type-id-23' name='badtoken' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4739' column='1'/>
	- <parameter type-id='type-id-23' name='badfile' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4739' column='1'/>
	+ <typedef-decl name='zpool_compat_status_t' type-id='type-id-210' filepath='../../include/libzfs.h' line='930' column='1' id='type-id-211'/>
	+ <function-decl name='zpool_load_compat' mangled-name='zpool_load_compat' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4751' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_load_compat'>
	+ <parameter type-id='type-id-104' name='compat' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4751' column='1'/>
	+ <parameter type-id='type-id-114' name='features' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4751' column='1'/>
	+ <parameter type-id='type-id-23' name='report' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4751' column='1'/>
	+ <parameter type-id='type-id-43' name='rlen' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_pool.c' line='4752' column='1'/>
	<return type-id='type-id-211'/>
	</function-decl>
	<function-decl name='lzc_get_bootenv' mangled-name='lzc_get_bootenv' filepath='../../include/libzfs_core.h' line='139' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zpool_standard_error_fmt' mangled-name='zpool_standard_error_fmt' filepath='../../include/libzfs_impl.h' line='149' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='lzc_set_bootenv' mangled-name='lzc_set_bootenv' filepath='../../include/libzfs_core.h' line='138' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='lzc_wait' mangled-name='lzc_wait' filepath='../../include/libzfs_core.h' line='134' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zpool_history_unpack' mangled-name='zpool_history_unpack' filepath='../../include/libzutil.h' line='144' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='nvlist_add_nvlist_array' mangled-name='nvlist_add_nvlist_array' filepath='../../include/sys/nvpair.h' line='192' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='__xpg_basename' mangled-name='__xpg_basename' filepath='/usr/include/libgen.h' line='34' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='memcmp' mangled-name='memcmp' filepath='/usr/include/string.h' line='63' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='realpath' mangled-name='realpath' filepath='/usr/include/stdlib.h' line='797' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='strncasecmp' mangled-name='strncasecmp' filepath='/usr/include/strings.h' line='120' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_strip_partition' mangled-name='zfs_strip_partition' filepath='../../include/libzutil.h' line='99' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_strip_path' mangled-name='zfs_strip_path' filepath='../../include/libzutil.h' line='100' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zpool_get_handle' mangled-name='zpool_get_handle' filepath='../../include/libzfs.h' line='209' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fnvlist_add_boolean_value' mangled-name='fnvlist_add_boolean_value' filepath='../../include/sys/nvpair.h' line='287' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='lzc_sync' mangled-name='lzc_sync' filepath='../../include/libzfs_core.h' line='128' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='lzc_reopen' mangled-name='lzc_reopen' filepath='../../include/libzfs_core.h' line='129' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zpool_standard_error' mangled-name='zpool_standard_error' filepath='../../include/libzfs_impl.h' line='148' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zpool_get_load_policy' mangled-name='zpool_get_load_policy' filepath='../../include/zfs_comutil.h' line='38' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fnvlist_lookup_uint64' mangled-name='fnvlist_lookup_uint64' filepath='../../include/sys/nvpair.h' line='327' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zpool_prop_to_name' mangled-name='zpool_prop_to_name' filepath='../../include/libzfs.h' line='333' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfeature_lookup_guid' mangled-name='zfeature_lookup_guid' filepath='../../include/zfeature_common.h' line='126' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfeature_lookup_guid' mangled-name='zfeature_lookup_guid' filepath='../../include/zfeature_common.h' line='124' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_resolve_shortname' mangled-name='zfs_resolve_shortname' filepath='../../include/libzutil.h' line='97' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zpool_relabel_disk' mangled-name='zpool_relabel_disk' filepath='../../include/libzfs_impl.h' line='256' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='strtoull' mangled-name='strtoull' filepath='/usr/include/stdlib.h' line='205' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_strcmp_pathname' mangled-name='zfs_strcmp_pathname' filepath='../../include/libzutil.h' line='102' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='lzc_wait_tag' mangled-name='lzc_wait_tag' filepath='../../include/libzfs_core.h' line='135' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='lzc_trim' mangled-name='lzc_trim' filepath='../../include/libzfs_core.h' line='67' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fnvpair_value_int64' mangled-name='fnvpair_value_int64' filepath='../../include/sys/nvpair.h' line='346' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='lzc_initialize' mangled-name='lzc_initialize' filepath='../../include/libzfs_core.h' line='65' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfeature_lookup_name' mangled-name='zfeature_lookup_name' filepath='../../include/zfeature_common.h' line='127' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfeature_lookup_name' mangled-name='zfeature_lookup_name' filepath='../../include/zfeature_common.h' line='125' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='lzc_pool_checkpoint_discard' mangled-name='lzc_pool_checkpoint_discard' filepath='../../include/libzfs_core.h' line='132' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='lzc_pool_checkpoint' mangled-name='lzc_pool_checkpoint' filepath='../../include/libzfs_core.h' line='131' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='nvlist_add_uint8_array' mangled-name='nvlist_add_uint8_array' filepath='../../include/sys/nvpair.h' line='184' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zpool_refresh_stats' mangled-name='zpool_refresh_stats' filepath='../../include/libzfs.h' line='413' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zpool_refresh_stats' mangled-name='zpool_refresh_stats' filepath='../../include/libzfs.h' line='414' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='pool_namecheck' mangled-name='pool_namecheck' filepath='../../include/zfs_namecheck.h' line='57' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zpool_prop_feature' mangled-name='zpool_prop_feature' filepath='../../include/sys/fs/zfs.h' line='331' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfeature_is_supported' mangled-name='zfeature_is_supported' filepath='../../include/zfeature_common.h' line='125' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfeature_is_supported' mangled-name='zfeature_is_supported' filepath='../../include/zfeature_common.h' line='123' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_name_valid' mangled-name='zfs_name_valid' filepath='../../include/libzfs.h' line='807' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_name_valid' mangled-name='zfs_name_valid' filepath='../../include/libzfs.h' line='811' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zpool_name_to_prop' mangled-name='zpool_name_to_prop' filepath='../../include/sys/fs/zfs.h' line='325' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zpool_prop_readonly' mangled-name='zpool_prop_readonly' filepath='../../include/sys/fs/zfs.h' line='329' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zpool_prop_setonce' mangled-name='zpool_prop_setonce' filepath='../../include/sys/fs/zfs.h' line='330' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='get_system_hostid' mangled-name='get_system_hostid' filepath='../../lib/libspl/include/sys/systeminfo.h' line='36' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zpool_prop_get_type' mangled-name='zpool_prop_get_type' filepath='../../include/zfs_prop.h' line='99' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zpool_prop_index_to_string' mangled-name='zpool_prop_index_to_string' filepath='../../include/sys/fs/zfs.h' line='333' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zpool_prop_default_numeric' mangled-name='zpool_prop_default_numeric' filepath='../../include/libzfs.h' line='566' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zpool_prop_default_numeric' mangled-name='zpool_prop_default_numeric' filepath='../../include/libzfs.h' line='567' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zpool_prop_default_string' mangled-name='zpool_prop_default_string' filepath='../../include/libzfs.h' line='565' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zpool_prop_default_string' mangled-name='zpool_prop_default_string' filepath='../../include/libzfs.h' line='566' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='mmap' mangled-name='mmap64' filepath='/usr/include/x86_64-linux-gnu/sys/mman.h' line='61' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='strtok_r' mangled-name='strtok_r' filepath='/usr/include/string.h' line='345' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='munmap' mangled-name='munmap' filepath='/usr/include/x86_64-linux-gnu/sys/mman.h' line='76' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='strchrnul' mangled-name='strchrnul' filepath='/usr/include/string.h' line='265' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='strtok_r' mangled-name='strtok_r' filepath='/usr/include/string.h' line='345' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='munmap' mangled-name='munmap' filepath='/usr/include/x86_64-linux-gnu/sys/mman.h' line='76' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='strchrnul' mangled-name='strchrnul' filepath='/usr/include/string.h' line='265' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zpool_get_status' mangled-name='zpool_get_status' filepath='../../include/libzfs.h' line='403' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zpool_get_status' mangled-name='zpool_get_status' filepath='../../include/libzfs.h' line='404' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fnvlist_add_int64' mangled-name='fnvlist_add_int64' filepath='../../include/sys/nvpair.h' line='295' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	</abi-instr>
	<abi-instr version='1.0' address-size='64' path='libzfs_sendrecv.c' comp-dir-path='/home/colm/src/zfs/zfs/lib/libzfs' language='LANG_C99'>
	- <class-decl name='recvflags' size-in-bits='416' is-struct='yes' visibility='default' filepath='../../include/libzfs.h' line='743' column='1' id='type-id-212'>
	+ <class-decl name='recvflags' size-in-bits='416' is-struct='yes' visibility='default' filepath='../../include/libzfs.h' line='747' column='1' id='type-id-212'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='verbose' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='745' column='1'/>
	+ <var-decl name='verbose' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='749' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	- <var-decl name='isprefix' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='748' column='1'/>
	+ <var-decl name='isprefix' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='752' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='istail' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='754' column='1'/>
	+ <var-decl name='istail' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='758' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='96'>
	- <var-decl name='dryrun' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='757' column='1'/>
	+ <var-decl name='dryrun' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='761' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='force' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='760' column='1'/>
	+ <var-decl name='force' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='764' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='160'>
	- <var-decl name='canmountoff' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='763' column='1'/>
	+ <var-decl name='canmountoff' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='767' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='resumable' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='769' column='1'/>
	+ <var-decl name='resumable' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='773' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='224'>
	- <var-decl name='byteswap' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='772' column='1'/>
	+ <var-decl name='byteswap' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='776' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='nomount' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='775' column='1'/>
	+ <var-decl name='nomount' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='779' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='288'>
	- <var-decl name='holds' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='778' column='1'/>
	+ <var-decl name='holds' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='782' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	- <var-decl name='skipholds' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='781' column='1'/>
	+ <var-decl name='skipholds' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='785' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='352'>
	- <var-decl name='domount' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='784' column='1'/>
	+ <var-decl name='domount' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='788' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	- <var-decl name='forceunmount' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='787' column='1'/>
	+ <var-decl name='forceunmount' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='791' column='1'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='recvflags_t' type-id='type-id-212' filepath='../../include/libzfs.h' line='788' column='1' id='type-id-213'/>
	+ <typedef-decl name='recvflags_t' type-id='type-id-212' filepath='../../include/libzfs.h' line='792' column='1' id='type-id-213'/>
	<pointer-type-def type-id='type-id-213' size-in-bits='64' id='type-id-214'/>
	<pointer-type-def type-id='type-id-30' size-in-bits='64' id='type-id-215'/>
	- <function-decl name='zfs_receive' mangled-name='zfs_receive' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='5103' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_receive'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='5103' column='1'/>
	- <parameter type-id='type-id-104' name='tosnap' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='5103' column='1'/>
	- <parameter type-id='type-id-22' name='props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='5103' column='1'/>
	- <parameter type-id='type-id-214' name='flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='5104' column='1'/>
	- <parameter type-id='type-id-6' name='infd' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='5104' column='1'/>
	- <parameter type-id='type-id-215' name='stream_avl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='5104' column='1'/>
	+ <function-decl name='zfs_receive' mangled-name='zfs_receive' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='5121' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_receive'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='5121' column='1'/>
	+ <parameter type-id='type-id-104' name='tosnap' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='5121' column='1'/>
	+ <parameter type-id='type-id-22' name='props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='5121' column='1'/>
	+ <parameter type-id='type-id-214' name='flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='5122' column='1'/>
	+ <parameter type-id='type-id-6' name='infd' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='5122' column='1'/>
	+ <parameter type-id='type-id-215' name='stream_avl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='5122' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <class-decl name='sendflags' size-in-bits='512' is-struct='yes' visibility='default' filepath='../../include/libzfs.h' line='662' column='1' id='type-id-216'>
	+ <class-decl name='sendflags' size-in-bits='544' is-struct='yes' visibility='default' filepath='../../include/libzfs.h' line='663' column='1' id='type-id-216'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='verbosity' type-id='type-id-6' visibility='default' filepath='../../include/libzfs.h' line='664' column='1'/>
	+ <var-decl name='verbosity' type-id='type-id-6' visibility='default' filepath='../../include/libzfs.h' line='665' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	- <var-decl name='replicate' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='667' column='1'/>
	+ <var-decl name='replicate' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='668' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='doall' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='670' column='1'/>
	+ <var-decl name='skipmissing' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='671' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='96'>
	- <var-decl name='fromorigin' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='673' column='1'/>
	+ <var-decl name='doall' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='674' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='pad' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='676' column='1'/>
	+ <var-decl name='fromorigin' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='677' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='160'>
	- <var-decl name='props' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='679' column='1'/>
	+ <var-decl name='pad' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='680' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='dryrun' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='682' column='1'/>
	+ <var-decl name='props' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='683' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='224'>
	- <var-decl name='parsable' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='685' column='1'/>
	+ <var-decl name='dryrun' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='686' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='progress' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='688' column='1'/>
	+ <var-decl name='parsable' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='689' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='288'>
	- <var-decl name='largeblock' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='691' column='1'/>
	+ <var-decl name='progress' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='692' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	- <var-decl name='embed_data' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='694' column='1'/>
	+ <var-decl name='largeblock' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='695' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='352'>
	- <var-decl name='compress' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='697' column='1'/>
	+ <var-decl name='embed_data' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='698' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	- <var-decl name='raw' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='700' column='1'/>
	+ <var-decl name='compress' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='701' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='416'>
	- <var-decl name='backup' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='703' column='1'/>
	+ <var-decl name='raw' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='704' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='448'>
	- <var-decl name='holds' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='706' column='1'/>
	+ <var-decl name='backup' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='707' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='480'>
	- <var-decl name='saved' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='709' column='1'/>
	+ <var-decl name='holds' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='710' column='1'/>
	+ </data-member>
	+ <data-member access='public' layout-offset-in-bits='512'>
	+ <var-decl name='saved' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='713' column='1'/>
	</data-member>
	</class-decl>
	- <typedef-decl name='sendflags_t' type-id='type-id-216' filepath='../../include/libzfs.h' line='710' column='1' id='type-id-217'/>
	+ <typedef-decl name='sendflags_t' type-id='type-id-216' filepath='../../include/libzfs.h' line='714' column='1' id='type-id-217'/>
	<pointer-type-def type-id='type-id-217' size-in-bits='64' id='type-id-218'/>
	- <function-decl name='zfs_send_one' mangled-name='zfs_send_one' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='2377' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_send_one'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='2377' column='1'/>
	- <parameter type-id='type-id-104' name='from' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='2377' column='1'/>
	- <parameter type-id='type-id-6' name='fd' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='2377' column='1'/>
	- <parameter type-id='type-id-218' name='flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='2377' column='1'/>
	- <parameter type-id='type-id-104' name='redactbook' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='2378' column='1'/>
	+ <function-decl name='zfs_send_one' mangled-name='zfs_send_one' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='2395' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_send_one'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='2395' column='1'/>
	+ <parameter type-id='type-id-104' name='from' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='2395' column='1'/>
	+ <parameter type-id='type-id-6' name='fd' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='2395' column='1'/>
	+ <parameter type-id='type-id-218' name='flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='2395' column='1'/>
	+ <parameter type-id='type-id-104' name='redactbook' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='2396' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <typedef-decl name='snapfilter_cb_t' type-id='type-id-219' filepath='../../include/libzfs.h' line='712' column='1' id='type-id-220'/>
	+ <typedef-decl name='snapfilter_cb_t' type-id='type-id-219' filepath='../../include/libzfs.h' line='716' column='1' id='type-id-220'/>
	<pointer-type-def type-id='type-id-220' size-in-bits='64' id='type-id-221'/>
	- <function-decl name='zfs_send' mangled-name='zfs_send' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='2103' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_send'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='2103' column='1'/>
	- <parameter type-id='type-id-104' name='fromsnap' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='2103' column='1'/>
	- <parameter type-id='type-id-104' name='tosnap' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='2103' column='1'/>
	- <parameter type-id='type-id-218' name='flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='2104' column='1'/>
	- <parameter type-id='type-id-6' name='outfd' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='2104' column='1'/>
	- <parameter type-id='type-id-221' name='filter_func' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='2104' column='1'/>
	- <parameter type-id='type-id-42' name='cb_arg' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='2105' column='1'/>
	- <parameter type-id='type-id-115' name='debugnvp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='2105' column='1'/>
	- <return type-id='type-id-6'/>
	- </function-decl>
	- <function-decl name='zfs_send_saved' mangled-name='zfs_send_saved' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='1851' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_send_saved'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='1851' column='1'/>
	- <parameter type-id='type-id-218' name='flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='1851' column='1'/>
	- <parameter type-id='type-id-6' name='outfd' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='1851' column='1'/>
	- <parameter type-id='type-id-104' name='resume_token' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='1852' column='1'/>
	- <return type-id='type-id-6'/>
	- </function-decl>
	- <function-decl name='zfs_send_resume' mangled-name='zfs_send_resume' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='1825' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_send_resume'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='1825' column='1'/>
	- <parameter type-id='type-id-218' name='flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='1825' column='1'/>
	- <parameter type-id='type-id-6' name='outfd' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='1825' column='1'/>
	- <parameter type-id='type-id-104' name='resume_token' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='1826' column='1'/>
	- <return type-id='type-id-6'/>
	- </function-decl>
	- <function-decl name='zfs_send_resume_token_to_nvlist' mangled-name='zfs_send_resume_token_to_nvlist' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='1352' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_send_resume_token_to_nvlist'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='1352' column='1'/>
	- <parameter type-id='type-id-104' name='token' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='1352' column='1'/>
	+ <function-decl name='zfs_send' mangled-name='zfs_send' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='2120' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_send'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='2120' column='1'/>
	+ <parameter type-id='type-id-104' name='fromsnap' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='2120' column='1'/>
	+ <parameter type-id='type-id-104' name='tosnap' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='2120' column='1'/>
	+ <parameter type-id='type-id-218' name='flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='2121' column='1'/>
	+ <parameter type-id='type-id-6' name='outfd' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='2121' column='1'/>
	+ <parameter type-id='type-id-221' name='filter_func' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='2121' column='1'/>
	+ <parameter type-id='type-id-42' name='cb_arg' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='2122' column='1'/>
	+ <parameter type-id='type-id-115' name='debugnvp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='2122' column='1'/>
	+ <return type-id='type-id-6'/>
	+ </function-decl>
	+ <function-decl name='zfs_send_saved' mangled-name='zfs_send_saved' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='1868' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_send_saved'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='1868' column='1'/>
	+ <parameter type-id='type-id-218' name='flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='1868' column='1'/>
	+ <parameter type-id='type-id-6' name='outfd' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='1868' column='1'/>
	+ <parameter type-id='type-id-104' name='resume_token' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='1869' column='1'/>
	+ <return type-id='type-id-6'/>
	+ </function-decl>
	+ <function-decl name='zfs_send_resume' mangled-name='zfs_send_resume' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='1842' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_send_resume'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='1842' column='1'/>
	+ <parameter type-id='type-id-218' name='flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='1842' column='1'/>
	+ <parameter type-id='type-id-6' name='outfd' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='1842' column='1'/>
	+ <parameter type-id='type-id-104' name='resume_token' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='1843' column='1'/>
	+ <return type-id='type-id-6'/>
	+ </function-decl>
	+ <function-decl name='zfs_send_resume_token_to_nvlist' mangled-name='zfs_send_resume_token_to_nvlist' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='1369' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_send_resume_token_to_nvlist'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='1369' column='1'/>
	+ <parameter type-id='type-id-104' name='token' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='1369' column='1'/>
	<return type-id='type-id-22'/>
	</function-decl>
	- <function-decl name='zfs_send_progress' mangled-name='zfs_send_progress' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='866' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_send_progress'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='866' column='1'/>
	- <parameter type-id='type-id-6' name='fd' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='866' column='1'/>
	- <parameter type-id='type-id-137' name='bytes_written' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='866' column='1'/>
	- <parameter type-id='type-id-137' name='blocks_visited' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='867' column='1'/>
	+ <function-decl name='zfs_send_progress' mangled-name='zfs_send_progress' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='883' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_send_progress'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='883' column='1'/>
	+ <parameter type-id='type-id-6' name='fd' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='883' column='1'/>
	+ <parameter type-id='type-id-137' name='bytes_written' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='883' column='1'/>
	+ <parameter type-id='type-id-137' name='blocks_visited' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_sendrecv.c' line='884' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='libzfs_set_pipe_max' mangled-name='libzfs_set_pipe_max' filepath='../../include/libzfs_impl.h' line='259' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='perror' mangled-name='perror' filepath='/usr/include/stdio.h' line='781' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_prop_set' mangled-name='zfs_prop_set' filepath='../../include/libzfs.h' line='491' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_prop_set' mangled-name='zfs_prop_set' filepath='../../include/libzfs.h' line='492' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='nvlist_lookup_boolean' mangled-name='nvlist_lookup_boolean' filepath='../../include/sys/nvpair.h' line='202' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fletcher_4_incremental_byteswap' mangled-name='fletcher_4_incremental_byteswap' filepath='../../include/zfs_fletcher.h' line='60' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='strcat' mangled-name='strcat' filepath='/usr/include/string.h' line='129' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fnvlist_merge' mangled-name='fnvlist_merge' filepath='../../include/sys/nvpair.h' line='283' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='create_parents' mangled-name='create_parents' filepath='../../include/libzfs_impl.h' line='193' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='nvpair_value_int32' mangled-name='nvpair_value_int32' filepath='../../include/sys/nvpair.h' line='253' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='time' mangled-name='time' filepath='/usr/include/time.h' line='75' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fnvlist_add_nvpair' mangled-name='fnvlist_add_nvpair' filepath='../../include/sys/nvpair.h' line='299' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fnvlist_remove' mangled-name='fnvlist_remove' filepath='../../include/sys/nvpair.h' line='313' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='lzc_receive_with_cmdprops' mangled-name='lzc_receive_with_cmdprops' filepath='../../include/libzfs_core.h' line='105' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='sprintf' mangled-name='sprintf' filepath='/usr/include/stdio.h' line='334' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='__builtin_puts' mangled-name='puts' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fnvlist_lookup_uint64_array' mangled-name='fnvlist_lookup_uint64_array' filepath='../../include/sys/nvpair.h' line='339' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='lzc_send_redacted' mangled-name='lzc_send_redacted' filepath='../../include/libzfs_core.h' line='92' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_hold_nvl' mangled-name='zfs_hold_nvl' filepath='../../include/libzfs.h' line='728' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_hold_nvl' mangled-name='zfs_hold_nvl' filepath='../../include/libzfs.h' line='732' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_get_pool_handle' mangled-name='zfs_get_pool_handle' filepath='../../include/libzfs.h' line='471' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_get_pool_handle' mangled-name='zfs_get_pool_handle' filepath='../../include/libzfs.h' line='472' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fnvlist_size' mangled-name='fnvlist_size' filepath='../../include/sys/nvpair.h' line='278' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fletcher_4_incremental_native' mangled-name='fletcher_4_incremental_native' filepath='../../include/zfs_fletcher.h' line='59' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='write' mangled-name='write' filepath='/usr/include/unistd.h' line='366' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fnvlist_lookup_boolean_value' mangled-name='fnvlist_lookup_boolean_value' filepath='../../include/sys/nvpair.h' line='318' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='strndup' mangled-name='strndup' filepath='/usr/include/string.h' line='174' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='lzc_send_resume_redacted' mangled-name='lzc_send_resume_redacted' filepath='../../include/libzfs_core.h' line='94' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='nvlist_print' mangled-name='nvlist_print' filepath='../../include/libnvpair.h' line='49' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='lzc_send_space_resume_redacted' mangled-name='lzc_send_space_resume_redacted' filepath='../../include/libzfs_core.h' line='110' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fletcher_4_native_varsize' mangled-name='fletcher_4_native_varsize' filepath='../../include/zfs_fletcher.h' line='57' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='uncompress' mangled-name='uncompress' filepath='/usr/include/zlib.h' line='1265' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_iter_snapshots_sorted' mangled-name='zfs_iter_snapshots_sorted' filepath='../../include/libzfs.h' line='618' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_iter_snapshots_sorted' mangled-name='zfs_iter_snapshots_sorted' filepath='../../include/libzfs.h' line='619' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='lzc_send_space' mangled-name='lzc_send_space' filepath='../../include/libzfs_core.h' line='109' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='sleep' mangled-name='sleep' filepath='/usr/include/unistd.h' line='444' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='localtime' mangled-name='localtime' filepath='/usr/include/time.h' line='123' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_get_recvd_props' mangled-name='zfs_get_recvd_props' filepath='../../include/libzfs.h' line='516' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_get_recvd_props' mangled-name='zfs_get_recvd_props' filepath='../../include/libzfs.h' line='517' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='lzc_rename' mangled-name='lzc_rename' filepath='../../include/libzfs_core.h' line='120' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-type size-in-bits='64' id='type-id-219'>
	<parameter type-id='type-id-102'/>
	<parameter type-id='type-id-42'/>
	<return type-id='type-id-5'/>
	</function-type>
	</abi-instr>
	<abi-instr version='1.0' address-size='64' path='libzfs_status.c' comp-dir-path='/home/colm/src/zfs/zfs/lib/libzfs' language='LANG_C99'>
	<enum-decl name='__anonymous_enum__' is-anonymous='yes' filepath='../../include/libzfs.h' line='339' column='1' id='type-id-222'>
	<underlying-type type-id='type-id-7'/>
	<enumerator name='ZPOOL_STATUS_CORRUPT_CACHE' value='0'/>
	<enumerator name='ZPOOL_STATUS_MISSING_DEV_R' value='1'/>
	<enumerator name='ZPOOL_STATUS_MISSING_DEV_NR' value='2'/>
	<enumerator name='ZPOOL_STATUS_CORRUPT_LABEL_R' value='3'/>
	<enumerator name='ZPOOL_STATUS_CORRUPT_LABEL_NR' value='4'/>
	<enumerator name='ZPOOL_STATUS_BAD_GUID_SUM' value='5'/>
	<enumerator name='ZPOOL_STATUS_CORRUPT_POOL' value='6'/>
	<enumerator name='ZPOOL_STATUS_CORRUPT_DATA' value='7'/>
	<enumerator name='ZPOOL_STATUS_FAILING_DEV' value='8'/>
	<enumerator name='ZPOOL_STATUS_VERSION_NEWER' value='9'/>
	<enumerator name='ZPOOL_STATUS_HOSTID_MISMATCH' value='10'/>
	<enumerator name='ZPOOL_STATUS_HOSTID_ACTIVE' value='11'/>
	<enumerator name='ZPOOL_STATUS_HOSTID_REQUIRED' value='12'/>
	<enumerator name='ZPOOL_STATUS_IO_FAILURE_WAIT' value='13'/>
	<enumerator name='ZPOOL_STATUS_IO_FAILURE_CONTINUE' value='14'/>
	<enumerator name='ZPOOL_STATUS_IO_FAILURE_MMP' value='15'/>
	<enumerator name='ZPOOL_STATUS_BAD_LOG' value='16'/>
	<enumerator name='ZPOOL_STATUS_ERRATA' value='17'/>
	<enumerator name='ZPOOL_STATUS_UNSUP_FEAT_READ' value='18'/>
	<enumerator name='ZPOOL_STATUS_UNSUP_FEAT_WRITE' value='19'/>
	<enumerator name='ZPOOL_STATUS_FAULTED_DEV_R' value='20'/>
	<enumerator name='ZPOOL_STATUS_FAULTED_DEV_NR' value='21'/>
	<enumerator name='ZPOOL_STATUS_VERSION_OLDER' value='22'/>
	<enumerator name='ZPOOL_STATUS_FEAT_DISABLED' value='23'/>
	<enumerator name='ZPOOL_STATUS_RESILVERING' value='24'/>
	<enumerator name='ZPOOL_STATUS_OFFLINE_DEV' value='25'/>
	<enumerator name='ZPOOL_STATUS_REMOVED_DEV' value='26'/>
	<enumerator name='ZPOOL_STATUS_REBUILDING' value='27'/>
	<enumerator name='ZPOOL_STATUS_REBUILD_SCRUB' value='28'/>
	<enumerator name='ZPOOL_STATUS_NON_NATIVE_ASHIFT' value='29'/>
	<enumerator name='ZPOOL_STATUS_COMPATIBILITY_ERR' value='30'/>
	- <enumerator name='ZPOOL_STATUS_OK' value='31'/>
	+ <enumerator name='ZPOOL_STATUS_INCOMPATIBLE_FEAT' value='31'/>
	+ <enumerator name='ZPOOL_STATUS_OK' value='32'/>
	</enum-decl>
	- <typedef-decl name='zpool_status_t' type-id='type-id-222' filepath='../../include/libzfs.h' line='401' column='1' id='type-id-223'/>
	- <enum-decl name='zpool_errata' filepath='../../include/sys/fs/zfs.h' line='1042' column='1' id='type-id-224'>
	+ <typedef-decl name='zpool_status_t' type-id='type-id-222' filepath='../../include/libzfs.h' line='402' column='1' id='type-id-223'/>
	+ <enum-decl name='zpool_errata' filepath='../../include/sys/fs/zfs.h' line='1050' column='1' id='type-id-224'>
	<underlying-type type-id='type-id-7'/>
	<enumerator name='ZPOOL_ERRATA_NONE' value='0'/>
	<enumerator name='ZPOOL_ERRATA_ZOL_2094_SCRUB' value='1'/>
	<enumerator name='ZPOOL_ERRATA_ZOL_2094_ASYNC_DESTROY' value='2'/>
	<enumerator name='ZPOOL_ERRATA_ZOL_6845_ENCRYPTION' value='3'/>
	<enumerator name='ZPOOL_ERRATA_ZOL_8308_ENCRYPTION' value='4'/>
	</enum-decl>
	- <typedef-decl name='zpool_errata_t' type-id='type-id-224' filepath='../../include/sys/fs/zfs.h' line='1048' column='1' id='type-id-225'/>
	+ <typedef-decl name='zpool_errata_t' type-id='type-id-224' filepath='../../include/sys/fs/zfs.h' line='1056' column='1' id='type-id-225'/>
	<pointer-type-def type-id='type-id-225' size-in-bits='64' id='type-id-226'/>
	- <function-decl name='zpool_import_status' mangled-name='zpool_import_status' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_status.c' line='519' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_import_status'>
	- <parameter type-id='type-id-22' name='config' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_status.c' line='519' column='1'/>
	- <parameter type-id='type-id-161' name='msgid' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_status.c' line='519' column='1'/>
	- <parameter type-id='type-id-226' name='errata' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_status.c' line='519' column='1'/>
	+ <function-decl name='zpool_import_status' mangled-name='zpool_import_status' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_status.c' line='533' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_import_status'>
	+ <parameter type-id='type-id-22' name='config' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_status.c' line='533' column='1'/>
	+ <parameter type-id='type-id-161' name='msgid' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_status.c' line='533' column='1'/>
	+ <parameter type-id='type-id-226' name='errata' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_status.c' line='533' column='1'/>
	<return type-id='type-id-223'/>
	</function-decl>
	- <function-decl name='zpool_get_status' mangled-name='zpool_get_status' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_status.c' line='495' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_status'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_status.c' line='495' column='1'/>
	- <parameter type-id='type-id-161' name='msgid' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_status.c' line='495' column='1'/>
	- <parameter type-id='type-id-226' name='errata' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_status.c' line='495' column='1'/>
	+ <function-decl name='zpool_get_status' mangled-name='zpool_get_status' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_status.c' line='509' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_status'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_status.c' line='509' column='1'/>
	+ <parameter type-id='type-id-161' name='msgid' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_status.c' line='509' column='1'/>
	+ <parameter type-id='type-id-226' name='errata' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_status.c' line='509' column='1'/>
	<return type-id='type-id-223'/>
	</function-decl>
	- <function-decl name='zpool_load_compat' mangled-name='zpool_load_compat' filepath='../../include/libzfs.h' line='928' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zpool_load_compat' mangled-name='zpool_load_compat' filepath='../../include/libzfs.h' line='932' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	</abi-instr>
	<abi-instr version='1.0' address-size='64' path='libzfs_util.c' comp-dir-path='/home/colm/src/zfs/zfs/lib/libzfs' language='LANG_C99'>
	- <function-decl name='printf_color' mangled-name='printf_color' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='2088' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='printf_color'>
	- <parameter type-id='type-id-23' name='color' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='2088' column='1'/>
	- <parameter type-id='type-id-23' name='format' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='2088' column='1'/>
	+ <function-decl name='printf_color' mangled-name='printf_color' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='2084' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='printf_color'>
	+ <parameter type-id='type-id-23' name='color' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='2084' column='1'/>
	+ <parameter type-id='type-id-23' name='format' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='2084' column='1'/>
	<parameter is-variadic='yes'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='color_end' mangled-name='color_end' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='2080' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='color_end'>
	+ <function-decl name='color_end' mangled-name='color_end' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='2076' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='color_end'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='color_start' mangled-name='color_start' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='2073' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='color_start'>
	- <parameter type-id='type-id-23' name='color' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='2073' column='1'/>
	+ <function-decl name='color_start' mangled-name='color_start' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='2069' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='color_start'>
	+ <parameter type-id='type-id-23' name='color' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='2069' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_version_print' mangled-name='zfs_version_print' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1994' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_version_print'>
	+ <function-decl name='zfs_version_print' mangled-name='zfs_version_print' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1990' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_version_print'>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_version_userland' mangled-name='zfs_version_userland' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1984' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_version_userland'>
	- <parameter type-id='type-id-23' name='version' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1984' column='1'/>
	- <parameter type-id='type-id-6' name='len' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1984' column='1'/>
	+ <function-decl name='zfs_version_userland' mangled-name='zfs_version_userland' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1980' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_version_userland'>
	+ <parameter type-id='type-id-23' name='version' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1980' column='1'/>
	+ <parameter type-id='type-id-6' name='len' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1980' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	<pointer-type-def type-id='type-id-227' size-in-bits='64' id='type-id-228'/>
	<typedef-decl name='zprop_func' type-id='type-id-228' filepath='../../include/sys/fs/zfs.h' line='287' column='1' id='type-id-229'/>
	- <function-decl name='zprop_iter' mangled-name='zprop_iter' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1974' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_iter'>
	- <parameter type-id='type-id-229' name='func' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1974' column='1'/>
	- <parameter type-id='type-id-42' name='cb' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1974' column='1'/>
	- <parameter type-id='type-id-5' name='show_all' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1974' column='1'/>
	- <parameter type-id='type-id-5' name='ordered' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1974' column='1'/>
	- <parameter type-id='type-id-20' name='type' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1975' column='1'/>
	+ <function-decl name='zprop_iter' mangled-name='zprop_iter' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1970' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_iter'>
	+ <parameter type-id='type-id-229' name='func' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1970' column='1'/>
	+ <parameter type-id='type-id-42' name='cb' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1970' column='1'/>
	+ <parameter type-id='type-id-5' name='show_all' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1970' column='1'/>
	+ <parameter type-id='type-id-5' name='ordered' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1970' column='1'/>
	+ <parameter type-id='type-id-20' name='type' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1971' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zprop_expand_list' mangled-name='zprop_expand_list' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1933' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_expand_list'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1933' column='1'/>
	- <parameter type-id='type-id-132' name='plp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1933' column='1'/>
	- <parameter type-id='type-id-20' name='type' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1933' column='1'/>
	+ <function-decl name='zprop_expand_list' mangled-name='zprop_expand_list' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1929' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_expand_list'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1929' column='1'/>
	+ <parameter type-id='type-id-132' name='plp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1929' column='1'/>
	+ <parameter type-id='type-id-20' name='type' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1929' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zprop_free_list' mangled-name='zprop_free_list' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1895' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_free_list'>
	- <parameter type-id='type-id-131' name='pl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1895' column='1'/>
	+ <function-decl name='zprop_free_list' mangled-name='zprop_free_list' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1891' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_free_list'>
	+ <parameter type-id='type-id-131' name='pl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1891' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zprop_get_list' mangled-name='zprop_get_list' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1814' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_get_list'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1814' column='1'/>
	- <parameter type-id='type-id-23' name='props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1814' column='1'/>
	- <parameter type-id='type-id-132' name='listp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1814' column='1'/>
	- <parameter type-id='type-id-20' name='type' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1815' column='1'/>
	+ <function-decl name='zprop_get_list' mangled-name='zprop_get_list' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1810' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_get_list'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1810' column='1'/>
	+ <parameter type-id='type-id-23' name='props' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1810' column='1'/>
	+ <parameter type-id='type-id-132' name='listp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1810' column='1'/>
	+ <parameter type-id='type-id-20' name='type' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1811' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<class-decl name='nvpair' size-in-bits='128' is-struct='yes' visibility='default' filepath='../../include/sys/nvpair.h' line='73' column='1' id='type-id-230'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='nvp_size' type-id='type-id-61' visibility='default' filepath='../../include/sys/nvpair.h' line='74' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	<var-decl name='nvp_name_sz' type-id='type-id-231' visibility='default' filepath='../../include/sys/nvpair.h' line='75' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='48'>
	<var-decl name='nvp_reserve' type-id='type-id-231' visibility='default' filepath='../../include/sys/nvpair.h' line='76' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='nvp_value_elem' type-id='type-id-61' visibility='default' filepath='../../include/sys/nvpair.h' line='77' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='96'>
	<var-decl name='nvp_type' type-id='type-id-232' visibility='default' filepath='../../include/sys/nvpair.h' line='78' column='1'/>
	</data-member>
	</class-decl>
	<typedef-decl name='__int16_t' type-id='type-id-74' filepath='/usr/include/x86_64-linux-gnu/bits/types.h' line='38' column='1' id='type-id-233'/>
	<typedef-decl name='int16_t' type-id='type-id-233' filepath='/usr/include/x86_64-linux-gnu/bits/stdint-intn.h' line='25' column='1' id='type-id-231'/>
	<enum-decl name='__anonymous_enum__' is-anonymous='yes' filepath='../../include/sys/nvpair.h' line='37' column='1' id='type-id-234'>
	<underlying-type type-id='type-id-7'/>
	<enumerator name='DATA_TYPE_DONTCARE' value='-1'/>
	<enumerator name='DATA_TYPE_UNKNOWN' value='0'/>
	<enumerator name='DATA_TYPE_BOOLEAN' value='1'/>
	<enumerator name='DATA_TYPE_BYTE' value='2'/>
	<enumerator name='DATA_TYPE_INT16' value='3'/>
	<enumerator name='DATA_TYPE_UINT16' value='4'/>
	<enumerator name='DATA_TYPE_INT32' value='5'/>
	<enumerator name='DATA_TYPE_UINT32' value='6'/>
	<enumerator name='DATA_TYPE_INT64' value='7'/>
	<enumerator name='DATA_TYPE_UINT64' value='8'/>
	<enumerator name='DATA_TYPE_STRING' value='9'/>
	<enumerator name='DATA_TYPE_BYTE_ARRAY' value='10'/>
	<enumerator name='DATA_TYPE_INT16_ARRAY' value='11'/>
	<enumerator name='DATA_TYPE_UINT16_ARRAY' value='12'/>
	<enumerator name='DATA_TYPE_INT32_ARRAY' value='13'/>
	<enumerator name='DATA_TYPE_UINT32_ARRAY' value='14'/>
	<enumerator name='DATA_TYPE_INT64_ARRAY' value='15'/>
	<enumerator name='DATA_TYPE_UINT64_ARRAY' value='16'/>
	<enumerator name='DATA_TYPE_STRING_ARRAY' value='17'/>
	<enumerator name='DATA_TYPE_HRTIME' value='18'/>
	<enumerator name='DATA_TYPE_NVLIST' value='19'/>
	<enumerator name='DATA_TYPE_NVLIST_ARRAY' value='20'/>
	<enumerator name='DATA_TYPE_BOOLEAN_VALUE' value='21'/>
	<enumerator name='DATA_TYPE_INT8' value='22'/>
	<enumerator name='DATA_TYPE_UINT8' value='23'/>
	<enumerator name='DATA_TYPE_BOOLEAN_ARRAY' value='24'/>
	<enumerator name='DATA_TYPE_INT8_ARRAY' value='25'/>
	<enumerator name='DATA_TYPE_UINT8_ARRAY' value='26'/>
	<enumerator name='DATA_TYPE_DOUBLE' value='27'/>
	</enum-decl>
	<typedef-decl name='data_type_t' type-id='type-id-234' filepath='../../include/sys/nvpair.h' line='71' column='1' id='type-id-232'/>
	<typedef-decl name='nvpair_t' type-id='type-id-230' filepath='../../include/sys/nvpair.h' line='82' column='1' id='type-id-235'/>
	<pointer-type-def type-id='type-id-235' size-in-bits='64' id='type-id-236'/>
	- <function-decl name='zprop_parse_value' mangled-name='zprop_parse_value' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1606' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_parse_value'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1606' column='1'/>
	- <parameter type-id='type-id-236' name='elem' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1606' column='1'/>
	- <parameter type-id='type-id-6' name='prop' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1606' column='1'/>
	- <parameter type-id='type-id-20' name='type' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1607' column='1'/>
	- <parameter type-id='type-id-22' name='ret' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1607' column='1'/>
	- <parameter type-id='type-id-161' name='svalp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1607' column='1'/>
	- <parameter type-id='type-id-137' name='ivalp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1607' column='1'/>
	- <parameter type-id='type-id-104' name='errbuf' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1608' column='1'/>
	+ <function-decl name='zprop_parse_value' mangled-name='zprop_parse_value' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1602' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_parse_value'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1602' column='1'/>
	+ <parameter type-id='type-id-236' name='elem' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1602' column='1'/>
	+ <parameter type-id='type-id-6' name='prop' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1602' column='1'/>
	+ <parameter type-id='type-id-20' name='type' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1603' column='1'/>
	+ <parameter type-id='type-id-22' name='ret' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1603' column='1'/>
	+ <parameter type-id='type-id-161' name='svalp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1603' column='1'/>
	+ <parameter type-id='type-id-137' name='ivalp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1603' column='1'/>
	+ <parameter type-id='type-id-104' name='errbuf' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1604' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_nicestrtonum' mangled-name='zfs_nicestrtonum' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1521' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_nicestrtonum'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1521' column='1'/>
	- <parameter type-id='type-id-104' name='value' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1521' column='1'/>
	- <parameter type-id='type-id-137' name='num' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1521' column='1'/>
	+ <function-decl name='zfs_nicestrtonum' mangled-name='zfs_nicestrtonum' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1517' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_nicestrtonum'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1517' column='1'/>
	+ <parameter type-id='type-id-104' name='value' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1517' column='1'/>
	+ <parameter type-id='type-id-137' name='num' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1517' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <class-decl name='zprop_get_cbdata' size-in-bits='640' is-struct='yes' visibility='default' filepath='../../include/libzfs.h' line='593' column='1' id='type-id-237'>
	+ <class-decl name='zprop_get_cbdata' size-in-bits='640' is-struct='yes' visibility='default' filepath='../../include/libzfs.h' line='594' column='1' id='type-id-237'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='cb_sources' type-id='type-id-6' visibility='default' filepath='../../include/libzfs.h' line='594' column='1'/>
	+ <var-decl name='cb_sources' type-id='type-id-6' visibility='default' filepath='../../include/libzfs.h' line='595' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='32'>
	- <var-decl name='cb_columns' type-id='type-id-238' visibility='default' filepath='../../include/libzfs.h' line='595' column='1'/>
	+ <var-decl name='cb_columns' type-id='type-id-238' visibility='default' filepath='../../include/libzfs.h' line='596' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='cb_colwidths' type-id='type-id-239' visibility='default' filepath='../../include/libzfs.h' line='596' column='1'/>
	+ <var-decl name='cb_colwidths' type-id='type-id-239' visibility='default' filepath='../../include/libzfs.h' line='597' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	- <var-decl name='cb_scripted' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='597' column='1'/>
	+ <var-decl name='cb_scripted' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='598' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='416'>
	- <var-decl name='cb_literal' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='598' column='1'/>
	+ <var-decl name='cb_literal' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='599' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='448'>
	- <var-decl name='cb_first' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='599' column='1'/>
	+ <var-decl name='cb_first' type-id='type-id-5' visibility='default' filepath='../../include/libzfs.h' line='600' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='512'>
	- <var-decl name='cb_proplist' type-id='type-id-131' visibility='default' filepath='../../include/libzfs.h' line='600' column='1'/>
	+ <var-decl name='cb_proplist' type-id='type-id-131' visibility='default' filepath='../../include/libzfs.h' line='601' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='576'>
	- <var-decl name='cb_type' type-id='type-id-20' visibility='default' filepath='../../include/libzfs.h' line='601' column='1'/>
	+ <var-decl name='cb_type' type-id='type-id-20' visibility='default' filepath='../../include/libzfs.h' line='602' column='1'/>
	</data-member>
	</class-decl>
	- <enum-decl name='__anonymous_enum__' is-anonymous='yes' filepath='../../include/libzfs.h' line='581' column='1' id='type-id-240'>
	+ <enum-decl name='__anonymous_enum__' is-anonymous='yes' filepath='../../include/libzfs.h' line='582' column='1' id='type-id-240'>
	<underlying-type type-id='type-id-7'/>
	<enumerator name='GET_COL_NONE' value='0'/>
	<enumerator name='GET_COL_NAME' value='1'/>
	<enumerator name='GET_COL_PROPERTY' value='2'/>
	<enumerator name='GET_COL_VALUE' value='3'/>
	<enumerator name='GET_COL_RECVD' value='4'/>
	<enumerator name='GET_COL_SOURCE' value='5'/>
	</enum-decl>
	- <typedef-decl name='zfs_get_column_t' type-id='type-id-240' filepath='../../include/libzfs.h' line='588' column='1' id='type-id-241'/>
	+ <typedef-decl name='zfs_get_column_t' type-id='type-id-240' filepath='../../include/libzfs.h' line='589' column='1' id='type-id-241'/>

	<array-type-def dimensions='1' type-id='type-id-241' size-in-bits='160' alignment-in-bits='32' id='type-id-238'>
	<subrange length='5' type-id='type-id-48' id='type-id-242'/>

	</array-type-def>

	<array-type-def dimensions='1' type-id='type-id-6' size-in-bits='192' id='type-id-239'>
	<subrange length='6' type-id='type-id-48' id='type-id-243'/>

	</array-type-def>
	- <typedef-decl name='zprop_get_cbdata_t' type-id='type-id-237' filepath='../../include/libzfs.h' line='602' column='1' id='type-id-244'/>
	+ <typedef-decl name='zprop_get_cbdata_t' type-id='type-id-237' filepath='../../include/libzfs.h' line='603' column='1' id='type-id-244'/>
	<pointer-type-def type-id='type-id-244' size-in-bits='64' id='type-id-245'/>
	- <function-decl name='zprop_print_one_property' mangled-name='zprop_print_one_property' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1389' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_print_one_property'>
	- <parameter type-id='type-id-104' name='name' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1389' column='1'/>
	- <parameter type-id='type-id-245' name='cbp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1389' column='1'/>
	- <parameter type-id='type-id-104' name='propname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1390' column='1'/>
	- <parameter type-id='type-id-104' name='value' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1390' column='1'/>
	- <parameter type-id='type-id-139' name='sourcetype' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1390' column='1'/>
	- <parameter type-id='type-id-104' name='source' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1391' column='1'/>
	- <parameter type-id='type-id-104' name='recvd_value' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1391' column='1'/>
	+ <function-decl name='zprop_print_one_property' mangled-name='zprop_print_one_property' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1385' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_print_one_property'>
	+ <parameter type-id='type-id-104' name='name' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1385' column='1'/>
	+ <parameter type-id='type-id-245' name='cbp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1385' column='1'/>
	+ <parameter type-id='type-id-104' name='propname' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1386' column='1'/>
	+ <parameter type-id='type-id-104' name='value' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1386' column='1'/>
	+ <parameter type-id='type-id-139' name='sourcetype' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1386' column='1'/>
	+ <parameter type-id='type-id-104' name='source' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1387' column='1'/>
	+ <parameter type-id='type-id-104' name='recvd_value' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1387' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zcmd_read_dst_nvlist' mangled-name='zcmd_read_dst_nvlist' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1249' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zcmd_read_dst_nvlist'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1249' column='1'/>
	- <parameter type-id='type-id-158' name='zc' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1249' column='1'/>
	- <parameter type-id='type-id-115' name='nvlp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1249' column='1'/>
	+ <function-decl name='zcmd_read_dst_nvlist' mangled-name='zcmd_read_dst_nvlist' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1245' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zcmd_read_dst_nvlist'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1245' column='1'/>
	+ <parameter type-id='type-id-158' name='zc' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1245' column='1'/>
	+ <parameter type-id='type-id-115' name='nvlp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1245' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zcmd_write_src_nvlist' mangled-name='zcmd_write_src_nvlist' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1239' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zcmd_write_src_nvlist'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1239' column='1'/>
	- <parameter type-id='type-id-158' name='zc' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1239' column='1'/>
	- <parameter type-id='type-id-22' name='nvl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1239' column='1'/>
	+ <function-decl name='zcmd_write_src_nvlist' mangled-name='zcmd_write_src_nvlist' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1235' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zcmd_write_src_nvlist'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1235' column='1'/>
	+ <parameter type-id='type-id-158' name='zc' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1235' column='1'/>
	+ <parameter type-id='type-id-22' name='nvl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1235' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zcmd_write_conf_nvlist' mangled-name='zcmd_write_conf_nvlist' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1232' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zcmd_write_conf_nvlist'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1239' column='1'/>
	- <parameter type-id='type-id-158' name='zc' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1239' column='1'/>
	- <parameter type-id='type-id-22' name='nvl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1239' column='1'/>
	+ <function-decl name='zcmd_write_conf_nvlist' mangled-name='zcmd_write_conf_nvlist' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1228' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zcmd_write_conf_nvlist'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1235' column='1'/>
	+ <parameter type-id='type-id-158' name='zc' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1235' column='1'/>
	+ <parameter type-id='type-id-22' name='nvl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1235' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zcmd_free_nvlists' mangled-name='zcmd_free_nvlists' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1201' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zcmd_free_nvlists'>
	- <parameter type-id='type-id-158' name='zc' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1201' column='1'/>
	+ <function-decl name='zcmd_free_nvlists' mangled-name='zcmd_free_nvlists' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1197' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zcmd_free_nvlists'>
	+ <parameter type-id='type-id-158' name='zc' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1197' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zcmd_expand_dst_nvlist' mangled-name='zcmd_expand_dst_nvlist' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1186' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zcmd_expand_dst_nvlist'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1186' column='1'/>
	- <parameter type-id='type-id-158' name='zc' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1186' column='1'/>
	+ <function-decl name='zcmd_expand_dst_nvlist' mangled-name='zcmd_expand_dst_nvlist' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1182' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zcmd_expand_dst_nvlist'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1182' column='1'/>
	+ <parameter type-id='type-id-158' name='zc' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1182' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zcmd_alloc_dst_nvlist' mangled-name='zcmd_alloc_dst_nvlist' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1167' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zcmd_alloc_dst_nvlist'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1167' column='1'/>
	- <parameter type-id='type-id-158' name='zc' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1167' column='1'/>
	- <parameter type-id='type-id-43' name='len' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1167' column='1'/>
	+ <function-decl name='zcmd_alloc_dst_nvlist' mangled-name='zcmd_alloc_dst_nvlist' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1163' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zcmd_alloc_dst_nvlist'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1163' column='1'/>
	+ <parameter type-id='type-id-158' name='zc' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1163' column='1'/>
	+ <parameter type-id='type-id-43' name='len' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1163' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfs_path_to_zhandle' mangled-name='zfs_path_to_zhandle' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1134' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_path_to_zhandle'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1134' column='1'/>
	- <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1134' column='1'/>
	- <parameter type-id='type-id-20' name='argtype' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1134' column='1'/>
	+ <function-decl name='zfs_path_to_zhandle' mangled-name='zfs_path_to_zhandle' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1130' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_path_to_zhandle'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1130' column='1'/>
	+ <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1130' column='1'/>
	+ <parameter type-id='type-id-20' name='argtype' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1130' column='1'/>
	<return type-id='type-id-102'/>
	</function-decl>
	- <function-decl name='zfs_get_pool_handle' mangled-name='zfs_get_pool_handle' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1122' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_pool_handle'>
	- <parameter type-id='type-id-136' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1122' column='1'/>
	+ <function-decl name='zfs_get_pool_handle' mangled-name='zfs_get_pool_handle' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1118' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_pool_handle'>
	+ <parameter type-id='type-id-136' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1118' column='1'/>
	<return type-id='type-id-18'/>
	</function-decl>
	- <function-decl name='zfs_get_handle' mangled-name='zfs_get_handle' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1116' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_handle'>
	- <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1116' column='1'/>
	+ <function-decl name='zfs_get_handle' mangled-name='zfs_get_handle' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1112' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_get_handle'>
	+ <parameter type-id='type-id-102' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1112' column='1'/>
	<return type-id='type-id-17'/>
	</function-decl>
	- <function-decl name='zpool_get_handle' mangled-name='zpool_get_handle' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1110' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_handle'>
	- <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1110' column='1'/>
	+ <function-decl name='zpool_get_handle' mangled-name='zpool_get_handle' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1106' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_handle'>
	+ <parameter type-id='type-id-18' name='zhp' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1106' column='1'/>
	<return type-id='type-id-17'/>
	</function-decl>
	- <function-decl name='libzfs_fini' mangled-name='libzfs_fini' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1091' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_fini'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1091' column='1'/>
	+ <function-decl name='libzfs_fini' mangled-name='libzfs_fini' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1087' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_fini'>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1087' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='libzfs_init' mangled-name='libzfs_init' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1007' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_init'>
	+ <function-decl name='libzfs_init' mangled-name='libzfs_init' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='1003' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_init'>
	<return type-id='type-id-17'/>
	</function-decl>
	- <function-decl name='libzfs_envvar_is_set' mangled-name='libzfs_envvar_is_set' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='995' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_envvar_is_set'>
	- <parameter type-id='type-id-23' name='envvar' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='995' column='1'/>
	+ <function-decl name='libzfs_envvar_is_set' mangled-name='libzfs_envvar_is_set' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='991' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_envvar_is_set'>
	+ <parameter type-id='type-id-23' name='envvar' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='991' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='libzfs_free_str_array' mangled-name='libzfs_free_str_array' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='980' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_free_str_array'>
	- <parameter type-id='type-id-161' name='strs' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='980' column='1'/>
	- <parameter type-id='type-id-6' name='count' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='980' column='1'/>
	+ <function-decl name='libzfs_free_str_array' mangled-name='libzfs_free_str_array' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='976' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_free_str_array'>
	+ <parameter type-id='type-id-161' name='strs' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='976' column='1'/>
	+ <parameter type-id='type-id-6' name='count' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='976' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	<pointer-type-def type-id='type-id-161' size-in-bits='64' id='type-id-246'/>
	- <function-decl name='libzfs_run_process_get_stdout_nopath' mangled-name='libzfs_run_process_get_stdout_nopath' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='968' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_run_process_get_stdout_nopath'>
	- <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='968' column='1'/>
	- <parameter type-id='type-id-161' name='argv' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='968' column='1'/>
	- <parameter type-id='type-id-161' name='env' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='969' column='1'/>
	- <parameter type-id='type-id-246' name='lines' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='969' column='1'/>
	- <parameter type-id='type-id-141' name='lines_cnt' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='969' column='1'/>
	+ <function-decl name='libzfs_run_process_get_stdout_nopath' mangled-name='libzfs_run_process_get_stdout_nopath' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='964' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_run_process_get_stdout_nopath'>
	+ <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='964' column='1'/>
	+ <parameter type-id='type-id-161' name='argv' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='964' column='1'/>
	+ <parameter type-id='type-id-161' name='env' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='965' column='1'/>
	+ <parameter type-id='type-id-246' name='lines' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='965' column='1'/>
	+ <parameter type-id='type-id-141' name='lines_cnt' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='965' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='libzfs_run_process_get_stdout' mangled-name='libzfs_run_process_get_stdout' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='957' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_run_process_get_stdout'>
	- <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='968' column='1'/>
	- <parameter type-id='type-id-161' name='argv' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='968' column='1'/>
	- <parameter type-id='type-id-161' name='env' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='969' column='1'/>
	- <parameter type-id='type-id-246' name='lines' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='969' column='1'/>
	- <parameter type-id='type-id-141' name='lines_cnt' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='969' column='1'/>
	+ <function-decl name='libzfs_run_process_get_stdout' mangled-name='libzfs_run_process_get_stdout' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='953' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_run_process_get_stdout'>
	+ <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='964' column='1'/>
	+ <parameter type-id='type-id-161' name='argv' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='964' column='1'/>
	+ <parameter type-id='type-id-161' name='env' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='965' column='1'/>
	+ <parameter type-id='type-id-246' name='lines' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='965' column='1'/>
	+ <parameter type-id='type-id-141' name='lines_cnt' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='965' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='libzfs_run_process' mangled-name='libzfs_run_process' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='945' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_run_process'>
	- <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='945' column='1'/>
	- <parameter type-id='type-id-161' name='argv' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='945' column='1'/>
	- <parameter type-id='type-id-6' name='flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='945' column='1'/>
	+ <function-decl name='libzfs_run_process' mangled-name='libzfs_run_process' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='941' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_run_process'>
	+ <parameter type-id='type-id-104' name='path' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='941' column='1'/>
	+ <parameter type-id='type-id-161' name='argv' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='941' column='1'/>
	+ <parameter type-id='type-id-6' name='flags' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='941' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='libzfs_print_on_error' mangled-name='libzfs_print_on_error' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='823' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_print_on_error'>
	- <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='866' column='1'/>
	- <parameter type-id='type-id-5' name='enable' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='866' column='1'/>
	+ <parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='865' column='1'/>
	+ <parameter type-id='type-id-5' name='enable' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_dataset.c' line='865' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_strdup' mangled-name='zfs_strdup' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='812' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_strdup'>
	<parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='812' column='1'/>
	<parameter type-id='type-id-104' name='str' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='812' column='1'/>
	<return type-id='type-id-23'/>
	</function-decl>
	<function-decl name='zfs_realloc' mangled-name='zfs_realloc' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='795' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_realloc'>
	<parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='795' column='1'/>
	<parameter type-id='type-id-42' name='ptr' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='795' column='1'/>
	<parameter type-id='type-id-43' name='oldsize' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='795' column='1'/>
	<parameter type-id='type-id-43' name='newsize' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='795' column='1'/>
	<return type-id='type-id-42'/>
	</function-decl>
	<function-decl name='zfs_asprintf' mangled-name='zfs_asprintf' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='773' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_asprintf'>
	<parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='773' column='1'/>
	<parameter type-id='type-id-104' name='fmt' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='773' column='1'/>
	<parameter is-variadic='yes'/>
	<return type-id='type-id-23'/>
	</function-decl>
	<function-decl name='zfs_alloc' mangled-name='zfs_alloc' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='758' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_alloc'>
	<parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='758' column='1'/>
	<parameter type-id='type-id-43' name='size' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='758' column='1'/>
	<return type-id='type-id-42'/>
	</function-decl>
	<function-decl name='no_memory' mangled-name='no_memory' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='749' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='no_memory'>
	<parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='749' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zpool_standard_error_fmt' mangled-name='zpool_standard_error_fmt' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='615' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_standard_error_fmt'>
	<parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='615' column='1'/>
	<parameter type-id='type-id-6' name='error' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='615' column='1'/>
	<parameter type-id='type-id-104' name='fmt' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='615' column='1'/>
	<parameter is-variadic='yes'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zpool_standard_error' mangled-name='zpool_standard_error' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='608' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_standard_error'>
	<parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='608' column='1'/>
	<parameter type-id='type-id-6' name='error' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='608' column='1'/>
	<parameter type-id='type-id-104' name='msg' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='608' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zfs_setprop_error' mangled-name='zfs_setprop_error' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='496' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_setprop_error'>
	<parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='496' column='1'/>
	<parameter type-id='type-id-2' name='prop' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='496' column='1'/>
	<parameter type-id='type-id-6' name='err' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='496' column='1'/>
	<parameter type-id='type-id-23' name='errbuf' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='497' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_standard_error_fmt' mangled-name='zfs_standard_error_fmt' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='405' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_standard_error_fmt'>
	<parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='405' column='1'/>
	<parameter type-id='type-id-6' name='error' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='405' column='1'/>
	<parameter type-id='type-id-104' name='fmt' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='405' column='1'/>
	<parameter is-variadic='yes'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zfs_standard_error' mangled-name='zfs_standard_error' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='398' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_standard_error'>
	<parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='608' column='1'/>
	<parameter type-id='type-id-6' name='error' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='608' column='1'/>
	<parameter type-id='type-id-104' name='msg' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='608' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zfs_error_fmt' mangled-name='zfs_error_fmt' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='354' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_error_fmt'>
	<parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='354' column='1'/>
	<parameter type-id='type-id-6' name='error' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='354' column='1'/>
	<parameter type-id='type-id-104' name='fmt' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='354' column='1'/>
	<parameter is-variadic='yes'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zfs_error' mangled-name='zfs_error' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='347' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_error'>
	<parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='608' column='1'/>
	<parameter type-id='type-id-6' name='error' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='608' column='1'/>
	<parameter type-id='type-id-104' name='msg' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='608' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zfs_error_aux' mangled-name='zfs_error_aux' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='306' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_error_aux'>
	<parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='306' column='1'/>
	<parameter type-id='type-id-104' name='fmt' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='306' column='1'/>
	<parameter is-variadic='yes'/>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='libzfs_error_action' mangled-name='libzfs_error_action' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='76' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_error_action'>
	<parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='76' column='1'/>
	<return type-id='type-id-104'/>
	</function-decl>
	<function-decl name='libzfs_errno' mangled-name='libzfs_errno' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='70' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_errno'>
	<parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='70' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='libzfs_error_description' mangled-name='libzfs_error_description' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='82' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_error_description'>
	<parameter type-id='type-id-17' name='hdl' filepath='/home/colm/src/zfs/zfs/lib/libzfs/libzfs_util.c' line='82' column='1'/>
	<return type-id='type-id-104'/>
	</function-decl>
	<function-decl name='vfprintf' mangled-name='vfprintf' filepath='/usr/include/stdio.h' line='341' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zfs_version_kernel' mangled-name='zfs_version_kernel' filepath='../../include/libzfs.h' line='885' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zfs_version_kernel' mangled-name='zfs_version_kernel' filepath='../../include/libzfs.h' line='889' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zprop_iter_common' mangled-name='zprop_iter_common' filepath='../../include/zfs_prop.h' line='120' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zprop_width' mangled-name='zprop_width' filepath='../../include/zfs_prop.h' line='126' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zprop_name_to_prop' mangled-name='zprop_name_to_prop' filepath='../../include/zfs_prop.h' line='121' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zprop_valid_for_type' mangled-name='zprop_valid_for_type' filepath='../../include/zfs_prop.h' line='127' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zpool_prop_unsupported' mangled-name='zpool_prop_unsupported' filepath='../../include/sys/fs/zfs.h' line='332' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zprop_string_to_index' mangled-name='zprop_string_to_index' filepath='../../include/zfs_prop.h' line='122' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zprop_values' mangled-name='zprop_values' filepath='../../include/zfs_prop.h' line='125' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='strtod' mangled-name='strtod' filepath='/usr/include/stdlib.h' line='117' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='pow' mangled-name='pow' filepath='/usr/include/x86_64-linux-gnu/bits/mathcalls.h' line='140' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='__ctype_toupper_loc' mangled-name='__ctype_toupper_loc' filepath='/usr/include/ctype.h' line='83' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='getextmntent' mangled-name='getextmntent' filepath='../../lib/libspl/include/os/linux/sys/mnttab.h' line='75' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zpool_free_handles' mangled-name='zpool_free_handles' filepath='../../include/libzfs.h' line='241' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='namespace_clear' mangled-name='namespace_clear' filepath='../../include/libzfs_impl.h' line='207' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='libzfs_mnttab_fini' mangled-name='libzfs_mnttab_fini' filepath='../../include/libzfs.h' line='223' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='libzfs_core_fini' mangled-name='libzfs_core_fini' filepath='../../include/libzfs_core.h' line='42' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='regfree' mangled-name='regfree' filepath='/usr/include/regex.h' line='651' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fletcher_4_fini' mangled-name='fletcher_4_fini' filepath='../../include/zfs_fletcher.h' line='63' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fletcher_4_fini'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zpool_prop_get_table' mangled-name='zpool_prop_get_table' filepath='../../include/zfs_prop.h' line='100' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_prop_get_table' mangled-name='zfs_prop_get_table' filepath='../../include/zfs_prop.h' line='93' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='libzfs_load_module' mangled-name='libzfs_load_module' filepath='../../include/libzfs_impl.h' line='255' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='regcomp' mangled-name='regcomp' filepath='/usr/include/regex.h' line='639' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='libzfs_core_init' mangled-name='libzfs_core_init' filepath='../../include/libzfs_core.h' line='41' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_prop_init' mangled-name='zfs_prop_init' filepath='../../include/zfs_prop.h' line='90' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zpool_prop_init' mangled-name='zpool_prop_init' filepath='../../include/zfs_prop.h' line='98' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='zpool_feature_init' mangled-name='zpool_feature_init' filepath='../../include/zfeature_common.h' line='130' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='zpool_feature_init' mangled-name='zpool_feature_init' filepath='../../include/zfeature_common.h' line='128' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='libzfs_mnttab_init' mangled-name='libzfs_mnttab_init' filepath='../../include/libzfs.h' line='222' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fletcher_4_init' mangled-name='fletcher_4_init' filepath='../../include/zfs_fletcher.h' line='62' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='strnlen' mangled-name='strnlen' filepath='/usr/include/string.h' line='390' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='realloc' mangled-name='realloc' filepath='/usr/include/stdlib.h' line='549' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='waitpid' mangled-name='waitpid' filepath='/usr/include/x86_64-linux-gnu/sys/wait.h' line='100' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='vfork' mangled-name='vfork' filepath='/usr/include/unistd.h' line='764' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='execve' mangled-name='execve' filepath='/usr/include/unistd.h' line='551' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='_exit' mangled-name='_exit' filepath='/usr/include/unistd.h' line='603' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='dup2' mangled-name='dup2' filepath='/usr/include/unistd.h' line='534' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='execvpe' mangled-name='execvpe' filepath='/usr/include/unistd.h' line='590' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='execv' mangled-name='execv' filepath='/usr/include/unistd.h' line='563' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='execvp' mangled-name='execvp' filepath='/usr/include/unistd.h' line='578' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='vasprintf' mangled-name='vasprintf' filepath='/usr/include/stdio.h' line='366' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='vsnprintf' mangled-name='vsnprintf' filepath='/usr/include/stdio.h' line='358' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='exit' mangled-name='exit' filepath='/usr/include/stdlib.h' line='614' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-type size-in-bits='64' id='type-id-227'>
	<parameter type-id='type-id-6'/>
	<parameter type-id='type-id-42'/>
	<return type-id='type-id-6'/>
	</function-type>
	</abi-instr>
	<abi-instr version='1.0' address-size='64' path='os/linux/libzfs_mount_os.c' comp-dir-path='/home/colm/src/zfs/zfs/lib/libzfs' language='LANG_C99'>
	- <function-decl name='zfs_mount_delegation_check' mangled-name='zfs_mount_delegation_check' filepath='os/linux/libzfs_mount_os.c' line='408' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_mount_delegation_check'>
	+ <function-decl name='zfs_mount_delegation_check' mangled-name='zfs_mount_delegation_check' filepath='os/linux/libzfs_mount_os.c' line='410' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_mount_delegation_check'>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='do_unmount' mangled-name='do_unmount' filepath='os/linux/libzfs_mount_os.c' line='377' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='do_unmount'>
	<parameter type-id='type-id-104' name='mntpt' filepath='os/linux/libzfs_mount_os.c' line='377' column='1'/>
	<parameter type-id='type-id-6' name='flags' filepath='os/linux/libzfs_mount_os.c' line='377' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='do_mount' mangled-name='do_mount' filepath='os/linux/libzfs_mount_os.c' line='323' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='do_mount'>
	<parameter type-id='type-id-102' name='zhp' filepath='os/linux/libzfs_mount_os.c' line='323' column='1'/>
	<parameter type-id='type-id-104' name='mntpt' filepath='os/linux/libzfs_mount_os.c' line='323' column='1'/>
	<parameter type-id='type-id-23' name='opts' filepath='os/linux/libzfs_mount_os.c' line='323' column='1'/>
	<parameter type-id='type-id-6' name='flags' filepath='os/linux/libzfs_mount_os.c' line='323' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zfs_adjust_mount_options' mangled-name='zfs_adjust_mount_options' filepath='os/linux/libzfs_mount_os.c' line='273' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_adjust_mount_options'>
	<parameter type-id='type-id-102' name='zhp' filepath='os/linux/libzfs_mount_os.c' line='273' column='1'/>
	<parameter type-id='type-id-104' name='mntpoint' filepath='os/linux/libzfs_mount_os.c' line='273' column='1'/>
	<parameter type-id='type-id-23' name='mntopts' filepath='os/linux/libzfs_mount_os.c' line='274' column='1'/>
	<parameter type-id='type-id-23' name='mtabopt' filepath='os/linux/libzfs_mount_os.c' line='274' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	<pointer-type-def type-id='type-id-48' size-in-bits='64' id='type-id-247'/>
	<function-decl name='zfs_parse_mount_options' mangled-name='zfs_parse_mount_options' filepath='os/linux/libzfs_mount_os.c' line='183' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_parse_mount_options'>
	<parameter type-id='type-id-23' name='mntopts' filepath='os/linux/libzfs_mount_os.c' line='183' column='1'/>
	<parameter type-id='type-id-247' name='mntflags' filepath='os/linux/libzfs_mount_os.c' line='183' column='1'/>
	<parameter type-id='type-id-247' name='zfsflags' filepath='os/linux/libzfs_mount_os.c' line='184' column='1'/>
	<parameter type-id='type-id-6' name='sloppy' filepath='os/linux/libzfs_mount_os.c' line='184' column='1'/>
	<parameter type-id='type-id-23' name='badopt' filepath='os/linux/libzfs_mount_os.c' line='184' column='1'/>
	<parameter type-id='type-id-23' name='mtabopt' filepath='os/linux/libzfs_mount_os.c' line='184' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='geteuid' mangled-name='geteuid' filepath='/usr/include/unistd.h' line='678' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='libzfs_envvar_is_set' mangled-name='libzfs_envvar_is_set' filepath='../../include/libzfs.h' line='879' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='umount2' mangled-name='umount2' filepath='/usr/include/x86_64-linux-gnu/sys/mount.h' line='146' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='libzfs_run_process' mangled-name='libzfs_run_process' filepath='../../include/libzfs.h' line='871' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='libzfs_envvar_is_set' mangled-name='libzfs_envvar_is_set' filepath='../../include/libzfs.h' line='883' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	- <function-decl name='umount2' mangled-name='umount2' filepath='/usr/include/x86_64-linux-gnu/sys/mount.h' line='146' column='1' visibility='default' binding='global' size-in-bits='64'>
	+ <function-decl name='libzfs_run_process' mangled-name='libzfs_run_process' filepath='../../include/libzfs.h' line='875' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='mount' mangled-name='mount' filepath='/usr/include/x86_64-linux-gnu/sys/mount.h' line='138' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	</abi-instr>
	<abi-instr version='1.0' address-size='64' path='os/linux/libzfs_pool_os.c' comp-dir-path='/home/colm/src/zfs/zfs/lib/libzfs' language='LANG_C99'>
	<function-decl name='zpool_label_disk' mangled-name='zpool_label_disk' filepath='os/linux/libzfs_pool_os.c' line='212' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_label_disk'>
	<parameter type-id='type-id-17' name='hdl' filepath='os/linux/libzfs_pool_os.c' line='212' column='1'/>
	<parameter type-id='type-id-18' name='zhp' filepath='os/linux/libzfs_pool_os.c' line='212' column='1'/>
	<parameter type-id='type-id-104' name='name' filepath='os/linux/libzfs_pool_os.c' line='212' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zpool_relabel_disk' mangled-name='zpool_relabel_disk' filepath='os/linux/libzfs_pool_os.c' line='61' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_relabel_disk'>
	<parameter type-id='type-id-17' name='hdl' filepath='os/linux/libzfs_pool_os.c' line='61' column='1'/>
	<parameter type-id='type-id-104' name='path' filepath='os/linux/libzfs_pool_os.c' line='61' column='1'/>
	<parameter type-id='type-id-104' name='msg' filepath='os/linux/libzfs_pool_os.c' line='61' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='rand' mangled-name='rand' filepath='/usr/include/stdlib.h' line='453' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='efi_alloc_and_read' mangled-name='efi_alloc_and_read' filepath='../../include/sys/efi_partition.h' line='367' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='efi_free' mangled-name='efi_free' filepath='../../include/sys/efi_partition.h' line='370' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='efi_alloc_and_init' mangled-name='efi_alloc_and_init' filepath='../../include/sys/efi_partition.h' line='366' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='efi_write' mangled-name='efi_write' filepath='../../include/sys/efi_partition.h' line='368' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fsync' mangled-name='fsync' filepath='/usr/include/unistd.h' line='954' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='efi_rescan' mangled-name='efi_rescan' filepath='../../include/sys/efi_partition.h' line='369' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_append_partition' mangled-name='zfs_append_partition' filepath='../../include/libzutil.h' line='96' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zpool_label_disk_wait' mangled-name='zpool_label_disk_wait' filepath='../../include/libzutil.h' line='80' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='efi_use_whole_disk' mangled-name='efi_use_whole_disk' filepath='../../include/sys/efi_partition.h' line='374' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	</abi-instr>
	<abi-instr version='1.0' address-size='64' path='os/linux/libzfs_sendrecv_os.c' comp-dir-path='/home/colm/src/zfs/zfs/lib/libzfs' language='LANG_C99'>
	<function-decl name='libzfs_set_pipe_max' mangled-name='libzfs_set_pipe_max' filepath='os/linux/libzfs_sendrecv_os.c' line='36' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_set_pipe_max'>
	<parameter type-id='type-id-6' name='infd' filepath='os/linux/libzfs_sendrecv_os.c' line='36' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fscanf' mangled-name='fscanf' filepath='/usr/include/stdio.h' line='391' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fcntl' mangled-name='fcntl64' filepath='/usr/include/fcntl.h' line='151' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	</abi-instr>
	<abi-instr version='1.0' address-size='64' path='os/linux/libzfs_util_os.c' comp-dir-path='/home/colm/src/zfs/zfs/lib/libzfs' language='LANG_C99'>
	<function-decl name='zfs_version_kernel' mangled-name='zfs_version_kernel' filepath='os/linux/libzfs_util_os.c' line='192' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_version_kernel'>
	<parameter type-id='type-id-23' name='version' filepath='os/linux/libzfs_util_os.c' line='192' column='1'/>
	<parameter type-id='type-id-6' name='len' filepath='os/linux/libzfs_util_os.c' line='192' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<class-decl name='differ_info' size-in-bits='9024' is-struct='yes' visibility='default' filepath='../../include/libzfs_impl.h' line='221' column='1' id='type-id-248'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='zhp' type-id='type-id-102' visibility='default' filepath='../../include/libzfs_impl.h' line='222' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='fromsnap' type-id='type-id-23' visibility='default' filepath='../../include/libzfs_impl.h' line='223' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='frommnt' type-id='type-id-23' visibility='default' filepath='../../include/libzfs_impl.h' line='224' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='tosnap' type-id='type-id-23' visibility='default' filepath='../../include/libzfs_impl.h' line='225' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='tomnt' type-id='type-id-23' visibility='default' filepath='../../include/libzfs_impl.h' line='226' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='ds' type-id='type-id-23' visibility='default' filepath='../../include/libzfs_impl.h' line='227' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='dsmnt' type-id='type-id-23' visibility='default' filepath='../../include/libzfs_impl.h' line='228' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='448'>
	<var-decl name='tmpsnap' type-id='type-id-23' visibility='default' filepath='../../include/libzfs_impl.h' line='229' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='512'>
	<var-decl name='errbuf' type-id='type-id-28' visibility='default' filepath='../../include/libzfs_impl.h' line='230' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='8704'>
	<var-decl name='isclone' type-id='type-id-5' visibility='default' filepath='../../include/libzfs_impl.h' line='231' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='8736'>
	<var-decl name='scripted' type-id='type-id-5' visibility='default' filepath='../../include/libzfs_impl.h' line='232' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='8768'>
	<var-decl name='classify' type-id='type-id-5' visibility='default' filepath='../../include/libzfs_impl.h' line='233' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='8800'>
	<var-decl name='timestamped' type-id='type-id-5' visibility='default' filepath='../../include/libzfs_impl.h' line='234' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='8832'>
	<var-decl name='shares' type-id='type-id-27' visibility='default' filepath='../../include/libzfs_impl.h' line='235' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='8896'>
	<var-decl name='zerr' type-id='type-id-6' visibility='default' filepath='../../include/libzfs_impl.h' line='236' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='8928'>
	<var-decl name='cleanupfd' type-id='type-id-6' visibility='default' filepath='../../include/libzfs_impl.h' line='237' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='8960'>
	<var-decl name='outputfd' type-id='type-id-6' visibility='default' filepath='../../include/libzfs_impl.h' line='238' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='8992'>
	<var-decl name='datafd' type-id='type-id-6' visibility='default' filepath='../../include/libzfs_impl.h' line='239' column='1'/>
	</data-member>
	</class-decl>
	<typedef-decl name='differ_info_t' type-id='type-id-248' filepath='../../include/libzfs_impl.h' line='240' column='1' id='type-id-249'/>
	<pointer-type-def type-id='type-id-249' size-in-bits='64' id='type-id-250'/>
	<function-decl name='find_shares_object' mangled-name='find_shares_object' filepath='os/linux/libzfs_util_os.c' line='169' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='find_shares_object'>
	<parameter type-id='type-id-250' name='di' filepath='os/linux/libzfs_util_os.c' line='169' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='libzfs_load_module' mangled-name='libzfs_load_module' filepath='os/linux/libzfs_util_os.c' line='163' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_load_module'>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='libzfs_error_init' mangled-name='libzfs_error_init' filepath='os/linux/libzfs_util_os.c' line='55' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='libzfs_error_init'>
	<parameter type-id='type-id-6' name='error' filepath='os/linux/libzfs_util_os.c' line='55' column='1'/>
	<return type-id='type-id-104'/>
	</function-decl>
	<function-decl name='zfs_ioctl' mangled-name='zfs_ioctl' filepath='os/linux/libzfs_util_os.c' line='49' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_ioctl'>
	<parameter type-id='type-id-17' name='hdl' filepath='os/linux/libzfs_util_os.c' line='49' column='1'/>
	<parameter type-id='type-id-6' name='request' filepath='os/linux/libzfs_util_os.c' line='49' column='1'/>
	<parameter type-id='type-id-158' name='zc' filepath='os/linux/libzfs_util_os.c' line='49' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='clock_gettime' mangled-name='clock_gettime' filepath='/usr/include/time.h' line='219' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='sched_yield' mangled-name='sched_yield' filepath='/usr/include/sched.h' line='68' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='usleep' mangled-name='usleep' filepath='/usr/include/unistd.h' line='460' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='access' mangled-name='access' filepath='/usr/include/unistd.h' line='287' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	</abi-instr>
	<abi-instr version='1.0' address-size='64' path='../../module/icp/algs/sha2/sha2.c' comp-dir-path='/home/colm/src/zfs/zfs/lib/libzfs' language='LANG_C99'>
	<class-decl name='__anonymous_struct__' size-in-bits='1728' is-struct='yes' is-anonymous='yes' naming-typedef-id='type-id-251' visibility='default' filepath='../../lib/libspl/include/sys/sha2.h' line='69' column='1' id='type-id-252'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='algotype' type-id='type-id-62' visibility='default' filepath='../../lib/libspl/include/sys/sha2.h' line='70' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='state' type-id='type-id-253' visibility='default' filepath='../../lib/libspl/include/sys/sha2.h' line='76' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='576'>
	<var-decl name='count' type-id='type-id-254' visibility='default' filepath='../../lib/libspl/include/sys/sha2.h' line='81' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='704'>
	<var-decl name='buf_un' type-id='type-id-255' visibility='default' filepath='../../lib/libspl/include/sys/sha2.h' line='86' column='1'/>
	</data-member>
	</class-decl>
	<union-decl name='__anonymous_union__' size-in-bits='512' is-anonymous='yes' visibility='default' filepath='../../lib/libspl/include/sys/sha2.h' line='73' column='1' id='type-id-253'>
	<data-member access='private'>
	<var-decl name='s32' type-id='type-id-256' visibility='default' filepath='../../lib/libspl/include/sys/sha2.h' line='74' column='1'/>
	</data-member>
	<data-member access='private'>
	<var-decl name='s64' type-id='type-id-257' visibility='default' filepath='../../lib/libspl/include/sys/sha2.h' line='75' column='1'/>
	</data-member>
	</union-decl>

	<array-type-def dimensions='1' type-id='type-id-62' size-in-bits='256' id='type-id-256'>
	<subrange length='8' type-id='type-id-48' id='type-id-258'/>

	</array-type-def>

	<array-type-def dimensions='1' type-id='type-id-27' size-in-bits='512' id='type-id-257'>
	<subrange length='8' type-id='type-id-48' id='type-id-258'/>

	</array-type-def>
	<union-decl name='__anonymous_union__' size-in-bits='128' is-anonymous='yes' visibility='default' filepath='../../lib/libspl/include/sys/sha2.h' line='78' column='1' id='type-id-254'>
	<data-member access='private'>
	<var-decl name='c32' type-id='type-id-259' visibility='default' filepath='../../lib/libspl/include/sys/sha2.h' line='79' column='1'/>
	</data-member>
	<data-member access='private'>
	<var-decl name='c64' type-id='type-id-156' visibility='default' filepath='../../lib/libspl/include/sys/sha2.h' line='80' column='1'/>
	</data-member>
	</union-decl>

	<array-type-def dimensions='1' type-id='type-id-62' size-in-bits='64' id='type-id-259'>
	<subrange length='2' type-id='type-id-48' id='type-id-86'/>

	</array-type-def>
	<union-decl name='__anonymous_union__' size-in-bits='1024' is-anonymous='yes' visibility='default' filepath='../../lib/libspl/include/sys/sha2.h' line='82' column='1' id='type-id-255'>
	<data-member access='private'>
	<var-decl name='buf8' type-id='type-id-260' visibility='default' filepath='../../lib/libspl/include/sys/sha2.h' line='83' column='1'/>
	</data-member>
	<data-member access='private'>
	<var-decl name='buf32' type-id='type-id-261' visibility='default' filepath='../../lib/libspl/include/sys/sha2.h' line='84' column='1'/>
	</data-member>
	<data-member access='private'>
	<var-decl name='buf64' type-id='type-id-262' visibility='default' filepath='../../lib/libspl/include/sys/sha2.h' line='85' column='1'/>
	</data-member>
	</union-decl>

	<array-type-def dimensions='1' type-id='type-id-98' size-in-bits='1024' id='type-id-260'>
	<subrange length='128' type-id='type-id-48' id='type-id-263'/>

	</array-type-def>

	<array-type-def dimensions='1' type-id='type-id-62' size-in-bits='1024' id='type-id-261'>
	<subrange length='32' type-id='type-id-48' id='type-id-264'/>

	</array-type-def>

	<array-type-def dimensions='1' type-id='type-id-27' size-in-bits='1024' id='type-id-262'>
	<subrange length='16' type-id='type-id-48' id='type-id-265'/>

	</array-type-def>
	<typedef-decl name='SHA2_CTX' type-id='type-id-252' filepath='../../lib/libspl/include/sys/sha2.h' line='87' column='1' id='type-id-251'/>
	<pointer-type-def type-id='type-id-251' size-in-bits='64' id='type-id-266'/>
	<function-decl name='SHA2Final' mangled-name='SHA2Final' filepath='../../module/icp/algs/sha2/sha2.c' line='904' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='SHA2Final'>
	<parameter type-id='type-id-42' name='digest' filepath='../../module/icp/algs/sha2/sha2.c' line='904' column='1'/>
	<parameter type-id='type-id-266' name='ctx' filepath='../../module/icp/algs/sha2/sha2.c' line='904' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='SHA2Update' mangled-name='SHA2Update' filepath='../../module/icp/algs/sha2/sha2.c' line='782' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='SHA2Update'>
	<parameter type-id='type-id-266' name='ctx' filepath='../../module/icp/algs/sha2/sha2.c' line='782' column='1'/>
	<parameter type-id='type-id-42' name='inptr' filepath='../../module/icp/algs/sha2/sha2.c' line='782' column='1'/>
	<parameter type-id='type-id-43' name='input_len' filepath='../../module/icp/algs/sha2/sha2.c' line='782' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	<typedef-decl name='SHA512_CTX' type-id='type-id-251' filepath='../../lib/libspl/include/sys/sha2.h' line='91' column='1' id='type-id-267'/>
	<pointer-type-def type-id='type-id-267' size-in-bits='64' id='type-id-268'/>
	<function-decl name='SHA512Init' mangled-name='SHA512Init' filepath='../../module/icp/algs/sha2/sha2.c' line='763' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='SHA512Init'>
	<parameter type-id='type-id-268' name='ctx' filepath='../../module/icp/algs/sha2/sha2.c' line='763' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	<typedef-decl name='SHA384_CTX' type-id='type-id-251' filepath='../../lib/libspl/include/sys/sha2.h' line='90' column='1' id='type-id-269'/>
	<pointer-type-def type-id='type-id-269' size-in-bits='64' id='type-id-270'/>
	<function-decl name='SHA384Init' mangled-name='SHA384Init' filepath='../../module/icp/algs/sha2/sha2.c' line='757' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='SHA384Init'>
	<parameter type-id='type-id-270' name='ctx' filepath='../../module/icp/algs/sha2/sha2.c' line='757' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	<typedef-decl name='SHA256_CTX' type-id='type-id-251' filepath='../../lib/libspl/include/sys/sha2.h' line='89' column='1' id='type-id-271'/>
	<pointer-type-def type-id='type-id-271' size-in-bits='64' id='type-id-272'/>
	<function-decl name='SHA256Init' mangled-name='SHA256Init' filepath='../../module/icp/algs/sha2/sha2.c' line='751' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='SHA256Init'>
	<parameter type-id='type-id-272' name='ctx' filepath='../../module/icp/algs/sha2/sha2.c' line='751' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='SHA2Init' mangled-name='SHA2Init' filepath='../../module/icp/algs/sha2/sha2.c' line='674' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='SHA2Init'>
	<parameter type-id='type-id-27' name='mech' filepath='../../module/icp/algs/sha2/sha2.c' line='674' column='1'/>
	<parameter type-id='type-id-266' name='ctx' filepath='../../module/icp/algs/sha2/sha2.c' line='674' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='htonl' mangled-name='htonl' filepath='../../lib/libspl/include/os/linux/sys/byteorder.h' line='79' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	</abi-instr>
	<abi-instr version='1.0' address-size='64' path='../../module/zcommon/cityhash.c' comp-dir-path='/home/colm/src/zfs/zfs/lib/libzfs' language='LANG_C99'>
	<function-decl name='cityhash4' mangled-name='cityhash4' filepath='../../module/zcommon/cityhash.c' line='53' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='cityhash4'>
	<parameter type-id='type-id-27' name='w1' filepath='../../module/zcommon/cityhash.c' line='53' column='1'/>
	<parameter type-id='type-id-27' name='w2' filepath='../../module/zcommon/cityhash.c' line='53' column='1'/>
	<parameter type-id='type-id-27' name='w3' filepath='../../module/zcommon/cityhash.c' line='53' column='1'/>
	<parameter type-id='type-id-27' name='w4' filepath='../../module/zcommon/cityhash.c' line='53' column='1'/>
	<return type-id='type-id-27'/>
	</function-decl>
	</abi-instr>
	<abi-instr version='1.0' address-size='64' path='../../module/zcommon/zfeature_common.c' comp-dir-path='/home/colm/src/zfs/zfs/lib/libzfs' language='LANG_C99'>
	<var-decl name='zfeature_checks_disable' type-id='type-id-5' mangled-name='zfeature_checks_disable' visibility='default' filepath='../../module/zcommon/zfeature_common.c' line='49' column='1' elf-symbol-id='zfeature_checks_disable'/>
	- <class-decl name='zfeature_info' size-in-bits='448' is-struct='yes' visibility='default' filepath='../../include/zfeature_common.h' line='105' column='1' id='type-id-273'>
	+ <class-decl name='zfeature_info' size-in-bits='448' is-struct='yes' visibility='default' filepath='../../include/zfeature_common.h' line='103' column='1' id='type-id-273'>
	<data-member access='public' layout-offset-in-bits='0'>
	- <var-decl name='fi_feature' type-id='type-id-274' visibility='default' filepath='../../include/zfeature_common.h' line='106' column='1'/>
	+ <var-decl name='fi_feature' type-id='type-id-274' visibility='default' filepath='../../include/zfeature_common.h' line='104' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	- <var-decl name='fi_uname' type-id='type-id-104' visibility='default' filepath='../../include/zfeature_common.h' line='107' column='1'/>
	+ <var-decl name='fi_uname' type-id='type-id-104' visibility='default' filepath='../../include/zfeature_common.h' line='105' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	- <var-decl name='fi_guid' type-id='type-id-104' visibility='default' filepath='../../include/zfeature_common.h' line='108' column='1'/>
	+ <var-decl name='fi_guid' type-id='type-id-104' visibility='default' filepath='../../include/zfeature_common.h' line='106' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	- <var-decl name='fi_desc' type-id='type-id-104' visibility='default' filepath='../../include/zfeature_common.h' line='109' column='1'/>
	+ <var-decl name='fi_desc' type-id='type-id-104' visibility='default' filepath='../../include/zfeature_common.h' line='107' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	- <var-decl name='fi_flags' type-id='type-id-275' visibility='default' filepath='../../include/zfeature_common.h' line='110' column='1'/>
	+ <var-decl name='fi_flags' type-id='type-id-275' visibility='default' filepath='../../include/zfeature_common.h' line='108' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='288'>
	- <var-decl name='fi_zfs_mod_supported' type-id='type-id-5' visibility='default' filepath='../../include/zfeature_common.h' line='111' column='1'/>
	+ <var-decl name='fi_zfs_mod_supported' type-id='type-id-5' visibility='default' filepath='../../include/zfeature_common.h' line='109' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	- <var-decl name='fi_type' type-id='type-id-276' visibility='default' filepath='../../include/zfeature_common.h' line='112' column='1'/>
	+ <var-decl name='fi_type' type-id='type-id-276' visibility='default' filepath='../../include/zfeature_common.h' line='110' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	- <var-decl name='fi_depends' type-id='type-id-277' visibility='default' filepath='../../include/zfeature_common.h' line='114' column='1'/>
	+ <var-decl name='fi_depends' type-id='type-id-277' visibility='default' filepath='../../include/zfeature_common.h' line='112' column='1'/>
	</data-member>
	</class-decl>
	<enum-decl name='spa_feature' filepath='../../include/zfeature_common.h' line='42' column='1' id='type-id-278'>
	<underlying-type type-id='type-id-7'/>
	<enumerator name='SPA_FEATURE_NONE' value='-1'/>
	<enumerator name='SPA_FEATURE_ASYNC_DESTROY' value='0'/>
	<enumerator name='SPA_FEATURE_EMPTY_BPOBJ' value='1'/>
	<enumerator name='SPA_FEATURE_LZ4_COMPRESS' value='2'/>
	<enumerator name='SPA_FEATURE_MULTI_VDEV_CRASH_DUMP' value='3'/>
	<enumerator name='SPA_FEATURE_SPACEMAP_HISTOGRAM' value='4'/>
	<enumerator name='SPA_FEATURE_ENABLED_TXG' value='5'/>
	<enumerator name='SPA_FEATURE_HOLE_BIRTH' value='6'/>
	<enumerator name='SPA_FEATURE_EXTENSIBLE_DATASET' value='7'/>
	<enumerator name='SPA_FEATURE_EMBEDDED_DATA' value='8'/>
	<enumerator name='SPA_FEATURE_BOOKMARKS' value='9'/>
	<enumerator name='SPA_FEATURE_FS_SS_LIMIT' value='10'/>
	<enumerator name='SPA_FEATURE_LARGE_BLOCKS' value='11'/>
	<enumerator name='SPA_FEATURE_LARGE_DNODE' value='12'/>
	<enumerator name='SPA_FEATURE_SHA512' value='13'/>
	<enumerator name='SPA_FEATURE_SKEIN' value='14'/>
	<enumerator name='SPA_FEATURE_EDONR' value='15'/>
	<enumerator name='SPA_FEATURE_USEROBJ_ACCOUNTING' value='16'/>
	<enumerator name='SPA_FEATURE_ENCRYPTION' value='17'/>
	<enumerator name='SPA_FEATURE_PROJECT_QUOTA' value='18'/>
	<enumerator name='SPA_FEATURE_DEVICE_REMOVAL' value='19'/>
	<enumerator name='SPA_FEATURE_OBSOLETE_COUNTS' value='20'/>
	<enumerator name='SPA_FEATURE_POOL_CHECKPOINT' value='21'/>
	<enumerator name='SPA_FEATURE_SPACEMAP_V2' value='22'/>
	<enumerator name='SPA_FEATURE_ALLOCATION_CLASSES' value='23'/>
	<enumerator name='SPA_FEATURE_RESILVER_DEFER' value='24'/>
	<enumerator name='SPA_FEATURE_BOOKMARK_V2' value='25'/>
	<enumerator name='SPA_FEATURE_REDACTION_BOOKMARKS' value='26'/>
	<enumerator name='SPA_FEATURE_REDACTED_DATASETS' value='27'/>
	<enumerator name='SPA_FEATURE_BOOKMARK_WRITTEN' value='28'/>
	<enumerator name='SPA_FEATURE_LOG_SPACEMAP' value='29'/>
	<enumerator name='SPA_FEATURE_LIVELIST' value='30'/>
	<enumerator name='SPA_FEATURE_DEVICE_REBUILD' value='31'/>
	<enumerator name='SPA_FEATURE_ZSTD_COMPRESS' value='32'/>
	<enumerator name='SPA_FEATURE_DRAID' value='33'/>
	<enumerator name='SPA_FEATURES' value='34'/>
	</enum-decl>
	- <typedef-decl name='spa_feature_t' type-id='type-id-278' filepath='../../include/zfeature_common.h' line='81' column='1' id='type-id-274'/>
	- <enum-decl name='zfeature_flags' filepath='../../include/zfeature_common.h' line='85' column='1' id='type-id-279'>
	+ <typedef-decl name='spa_feature_t' type-id='type-id-278' filepath='../../include/zfeature_common.h' line='79' column='1' id='type-id-274'/>
	+ <enum-decl name='zfeature_flags' filepath='../../include/zfeature_common.h' line='83' column='1' id='type-id-279'>
	<underlying-type type-id='type-id-7'/>
	<enumerator name='ZFEATURE_FLAG_READONLY_COMPAT' value='1'/>
	<enumerator name='ZFEATURE_FLAG_MOS' value='2'/>
	<enumerator name='ZFEATURE_FLAG_ACTIVATE_ON_ENABLE' value='4'/>
	<enumerator name='ZFEATURE_FLAG_PER_DATASET' value='8'/>
	</enum-decl>
	- <typedef-decl name='zfeature_flags_t' type-id='type-id-279' filepath='../../include/zfeature_common.h' line='97' column='1' id='type-id-275'/>
	- <enum-decl name='zfeature_type' filepath='../../include/zfeature_common.h' line='99' column='1' id='type-id-280'>
	+ <typedef-decl name='zfeature_flags_t' type-id='type-id-279' filepath='../../include/zfeature_common.h' line='95' column='1' id='type-id-275'/>
	+ <enum-decl name='zfeature_type' filepath='../../include/zfeature_common.h' line='97' column='1' id='type-id-280'>
	<underlying-type type-id='type-id-7'/>
	<enumerator name='ZFEATURE_TYPE_BOOLEAN' value='0'/>
	<enumerator name='ZFEATURE_TYPE_UINT64_ARRAY' value='1'/>
	<enumerator name='ZFEATURE_NUM_TYPES' value='2'/>
	</enum-decl>
	- <typedef-decl name='zfeature_type_t' type-id='type-id-280' filepath='../../include/zfeature_common.h' line='103' column='1' id='type-id-276'/>
	+ <typedef-decl name='zfeature_type_t' type-id='type-id-280' filepath='../../include/zfeature_common.h' line='101' column='1' id='type-id-276'/>
	<qualified-type-def type-id='type-id-274' const='yes' id='type-id-281'/>
	<pointer-type-def type-id='type-id-281' size-in-bits='64' id='type-id-277'/>
	- <typedef-decl name='zfeature_info_t' type-id='type-id-273' filepath='../../include/zfeature_common.h' line='115' column='1' id='type-id-282'/>
	+ <typedef-decl name='zfeature_info_t' type-id='type-id-273' filepath='../../include/zfeature_common.h' line='113' column='1' id='type-id-282'/>

	<array-type-def dimensions='1' type-id='type-id-282' size-in-bits='15232' id='type-id-283'>
	<subrange length='34' type-id='type-id-48' id='type-id-284'/>

	</array-type-def>
	- <var-decl name='spa_feature_table' type-id='type-id-283' mangled-name='spa_feature_table' visibility='default' filepath='../../include/zfeature_common.h' line='121' column='1' elf-symbol-id='spa_feature_table'/>
	- <function-decl name='zfeature_depends_on' mangled-name='zfeature_depends_on' filepath='../../module/zcommon/zfeature_common.c' line='144' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfeature_depends_on'>
	- <parameter type-id='type-id-274' name='fid' filepath='../../module/zcommon/zfeature_common.c' line='144' column='1'/>
	- <parameter type-id='type-id-274' name='check' filepath='../../module/zcommon/zfeature_common.c' line='144' column='1'/>
	+ <var-decl name='spa_feature_table' type-id='type-id-283' mangled-name='spa_feature_table' visibility='default' filepath='../../include/zfeature_common.h' line='119' column='1' elf-symbol-id='spa_feature_table'/>
	+ <function-decl name='zfeature_depends_on' mangled-name='zfeature_depends_on' filepath='../../module/zcommon/zfeature_common.c' line='146' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfeature_depends_on'>
	+ <parameter type-id='type-id-274' name='fid' filepath='../../module/zcommon/zfeature_common.c' line='146' column='1'/>
	+ <parameter type-id='type-id-274' name='check' filepath='../../module/zcommon/zfeature_common.c' line='146' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	<pointer-type-def type-id='type-id-274' size-in-bits='64' id='type-id-285'/>
	- <function-decl name='zfeature_lookup_name' mangled-name='zfeature_lookup_name' filepath='../../module/zcommon/zfeature_common.c' line='127' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfeature_lookup_name'>
	- <parameter type-id='type-id-104' name='name' filepath='../../module/zcommon/zfeature_common.c' line='127' column='1'/>
	- <parameter type-id='type-id-285' name='res' filepath='../../module/zcommon/zfeature_common.c' line='127' column='1'/>
	+ <function-decl name='zfeature_lookup_name' mangled-name='zfeature_lookup_name' filepath='../../module/zcommon/zfeature_common.c' line='129' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfeature_lookup_name'>
	+ <parameter type-id='type-id-104' name='name' filepath='../../module/zcommon/zfeature_common.c' line='129' column='1'/>
	+ <parameter type-id='type-id-285' name='res' filepath='../../module/zcommon/zfeature_common.c' line='129' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zfeature_lookup_guid' mangled-name='zfeature_lookup_guid' filepath='../../module/zcommon/zfeature_common.c' line='110' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfeature_lookup_guid'>
	- <parameter type-id='type-id-104' name='name' filepath='../../module/zcommon/zfeature_common.c' line='127' column='1'/>
	- <parameter type-id='type-id-285' name='res' filepath='../../module/zcommon/zfeature_common.c' line='127' column='1'/>
	+ <function-decl name='zfeature_lookup_guid' mangled-name='zfeature_lookup_guid' filepath='../../module/zcommon/zfeature_common.c' line='112' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfeature_lookup_guid'>
	+ <parameter type-id='type-id-104' name='name' filepath='../../module/zcommon/zfeature_common.c' line='129' column='1'/>
	+ <parameter type-id='type-id-285' name='res' filepath='../../module/zcommon/zfeature_common.c' line='129' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zfeature_is_supported' mangled-name='zfeature_is_supported' filepath='../../module/zcommon/zfeature_common.c' line='96' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfeature_is_supported'>
	<parameter type-id='type-id-104' name='guid' filepath='../../module/zcommon/zfeature_common.c' line='96' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	<function-decl name='zfeature_is_valid_guid' mangled-name='zfeature_is_valid_guid' filepath='../../module/zcommon/zfeature_common.c' line='74' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfeature_is_valid_guid'>
	<parameter type-id='type-id-104' name='name' filepath='../../module/zcommon/zfeature_common.c' line='74' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	- <function-decl name='zfs_mod_supported' mangled-name='zfs_mod_supported' filepath='../../module/zcommon/zfeature_common.c' line='185' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_mod_supported'>
	- <parameter type-id='type-id-104' name='scope' filepath='../../module/zcommon/zfeature_common.c' line='185' column='1'/>
	- <parameter type-id='type-id-104' name='name' filepath='../../module/zcommon/zfeature_common.c' line='185' column='1'/>
	+ <function-decl name='zfs_mod_supported' mangled-name='zfs_mod_supported' filepath='../../module/zcommon/zfeature_common.c' line='187' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_mod_supported'>
	+ <parameter type-id='type-id-104' name='scope' filepath='../../module/zcommon/zfeature_common.c' line='187' column='1'/>
	+ <parameter type-id='type-id-104' name='name' filepath='../../module/zcommon/zfeature_common.c' line='187' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	</abi-instr>
	<abi-instr version='1.0' address-size='64' path='../../module/zcommon/zfs_comutil.c' comp-dir-path='/home/colm/src/zfs/zfs/lib/libzfs' language='LANG_C99'>

	<array-type-def dimensions='1' type-id='type-id-104' size-in-bits='2624' id='type-id-286'>
	<subrange length='41' type-id='type-id-48' id='type-id-287'/>

	</array-type-def>
	<var-decl name='zfs_history_event_names' type-id='type-id-286' mangled-name='zfs_history_event_names' visibility='default' filepath='../../include/zfs_comutil.h' line='46' column='1' elf-symbol-id='zfs_history_event_names'/>
	<function-decl name='zfs_dataset_name_hidden' mangled-name='zfs_dataset_name_hidden' filepath='../../module/zcommon/zfs_comutil.c' line='239' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_dataset_name_hidden'>
	<parameter type-id='type-id-104' name='name' filepath='../../module/zcommon/zfs_comutil.c' line='239' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	<function-decl name='zfs_spa_version_map' mangled-name='zfs_spa_version_map' filepath='../../module/zcommon/zfs_comutil.c' line='177' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_spa_version_map'>
	<parameter type-id='type-id-6' name='zpl_version' filepath='../../module/zcommon/zfs_comutil.c' line='177' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zfs_zpl_version_map' mangled-name='zfs_zpl_version_map' filepath='../../module/zcommon/zfs_comutil.c' line='159' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_zpl_version_map'>
	<parameter type-id='type-id-6' name='zpl_version' filepath='../../module/zcommon/zfs_comutil.c' line='177' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<class-decl name='zpool_load_policy' size-in-bits='256' is-struct='yes' visibility='default' filepath='../../include/sys/fs/zfs.h' line='591' column='1' id='type-id-288'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='zlp_rewind' type-id='type-id-62' visibility='default' filepath='../../include/sys/fs/zfs.h' line='592' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='zlp_maxmeta' type-id='type-id-27' visibility='default' filepath='../../include/sys/fs/zfs.h' line='593' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='zlp_maxdata' type-id='type-id-27' visibility='default' filepath='../../include/sys/fs/zfs.h' line='594' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='zlp_txg' type-id='type-id-27' visibility='default' filepath='../../include/sys/fs/zfs.h' line='595' column='1'/>
	</data-member>
	</class-decl>
	<typedef-decl name='zpool_load_policy_t' type-id='type-id-288' filepath='../../include/sys/fs/zfs.h' line='596' column='1' id='type-id-289'/>
	<pointer-type-def type-id='type-id-289' size-in-bits='64' id='type-id-290'/>
	<function-decl name='zpool_get_load_policy' mangled-name='zpool_get_load_policy' filepath='../../module/zcommon/zfs_comutil.c' line='99' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_get_load_policy'>
	<parameter type-id='type-id-22' name='nvl' filepath='../../module/zcommon/zfs_comutil.c' line='99' column='1'/>
	<parameter type-id='type-id-290' name='zlpp' filepath='../../module/zcommon/zfs_comutil.c' line='99' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_special_devs' mangled-name='zfs_special_devs' filepath='../../module/zcommon/zfs_comutil.c' line='71' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_special_devs'>
	<parameter type-id='type-id-22' name='nv' filepath='../../module/zcommon/zfs_comutil.c' line='71' column='1'/>
	<parameter type-id='type-id-23' name='type' filepath='../../module/zcommon/zfs_comutil.c' line='71' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	<function-decl name='zfs_allocatable_devs' mangled-name='zfs_allocatable_devs' filepath='../../module/zcommon/zfs_comutil.c' line='46' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_allocatable_devs'>
	<parameter type-id='type-id-22' name='nv' filepath='../../module/zcommon/zfs_comutil.c' line='46' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	<function-decl name='nvpair_value_uint32' mangled-name='nvpair_value_uint32' filepath='../../include/sys/nvpair.h' line='254' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	</abi-instr>
	<abi-instr version='1.0' address-size='64' path='../../module/zcommon/zfs_deleg.c' comp-dir-path='/home/colm/src/zfs/zfs/lib/libzfs' language='LANG_C99'>
	<class-decl name='zfs_deleg_perm_tab' size-in-bits='128' is-struct='yes' visibility='default' filepath='../../include/zfs_deleg.h' line='83' column='1' id='type-id-291'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='z_perm' type-id='type-id-23' visibility='default' filepath='../../include/zfs_deleg.h' line='84' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='z_note' type-id='type-id-292' visibility='default' filepath='../../include/zfs_deleg.h' line='85' column='1'/>
	</data-member>
	</class-decl>
	<enum-decl name='__anonymous_enum__' is-anonymous='yes' filepath='../../include/zfs_deleg.h' line='48' column='1' id='type-id-293'>
	<underlying-type type-id='type-id-7'/>
	<enumerator name='ZFS_DELEG_NOTE_CREATE' value='0'/>
	<enumerator name='ZFS_DELEG_NOTE_DESTROY' value='1'/>
	<enumerator name='ZFS_DELEG_NOTE_SNAPSHOT' value='2'/>
	<enumerator name='ZFS_DELEG_NOTE_ROLLBACK' value='3'/>
	<enumerator name='ZFS_DELEG_NOTE_CLONE' value='4'/>
	<enumerator name='ZFS_DELEG_NOTE_PROMOTE' value='5'/>
	<enumerator name='ZFS_DELEG_NOTE_RENAME' value='6'/>
	<enumerator name='ZFS_DELEG_NOTE_SEND' value='7'/>
	<enumerator name='ZFS_DELEG_NOTE_RECEIVE' value='8'/>
	<enumerator name='ZFS_DELEG_NOTE_ALLOW' value='9'/>
	<enumerator name='ZFS_DELEG_NOTE_USERPROP' value='10'/>
	<enumerator name='ZFS_DELEG_NOTE_MOUNT' value='11'/>
	<enumerator name='ZFS_DELEG_NOTE_SHARE' value='12'/>
	<enumerator name='ZFS_DELEG_NOTE_USERQUOTA' value='13'/>
	<enumerator name='ZFS_DELEG_NOTE_GROUPQUOTA' value='14'/>
	<enumerator name='ZFS_DELEG_NOTE_USERUSED' value='15'/>
	<enumerator name='ZFS_DELEG_NOTE_GROUPUSED' value='16'/>
	<enumerator name='ZFS_DELEG_NOTE_USEROBJQUOTA' value='17'/>
	<enumerator name='ZFS_DELEG_NOTE_GROUPOBJQUOTA' value='18'/>
	<enumerator name='ZFS_DELEG_NOTE_USEROBJUSED' value='19'/>
	<enumerator name='ZFS_DELEG_NOTE_GROUPOBJUSED' value='20'/>
	<enumerator name='ZFS_DELEG_NOTE_HOLD' value='21'/>
	<enumerator name='ZFS_DELEG_NOTE_RELEASE' value='22'/>
	<enumerator name='ZFS_DELEG_NOTE_DIFF' value='23'/>
	<enumerator name='ZFS_DELEG_NOTE_BOOKMARK' value='24'/>
	<enumerator name='ZFS_DELEG_NOTE_LOAD_KEY' value='25'/>
	<enumerator name='ZFS_DELEG_NOTE_CHANGE_KEY' value='26'/>
	<enumerator name='ZFS_DELEG_NOTE_PROJECTUSED' value='27'/>
	<enumerator name='ZFS_DELEG_NOTE_PROJECTQUOTA' value='28'/>
	<enumerator name='ZFS_DELEG_NOTE_PROJECTOBJUSED' value='29'/>
	<enumerator name='ZFS_DELEG_NOTE_PROJECTOBJQUOTA' value='30'/>
	<enumerator name='ZFS_DELEG_NOTE_NONE' value='31'/>
	</enum-decl>
	<typedef-decl name='zfs_deleg_note_t' type-id='type-id-293' filepath='../../include/zfs_deleg.h' line='81' column='1' id='type-id-292'/>
	<typedef-decl name='zfs_deleg_perm_tab_t' type-id='type-id-291' filepath='../../include/zfs_deleg.h' line='86' column='1' id='type-id-294'/>

	<array-type-def dimensions='1' type-id='type-id-294' size-in-bits='infinite' id='type-id-295'>
	<subrange length='infinite' id='type-id-296'/>

	</array-type-def>
	<var-decl name='zfs_deleg_perm_tab' type-id='type-id-295' mangled-name='zfs_deleg_perm_tab' visibility='default' filepath='../../include/zfs_deleg.h' line='88' column='1' elf-symbol-id='zfs_deleg_perm_tab'/>
	<enum-decl name='__anonymous_enum__' is-anonymous='yes' filepath='../../include/sys/fs/zfs.h' line='340' column='1' id='type-id-297'>
	<underlying-type type-id='type-id-7'/>
	<enumerator name='ZFS_DELEG_WHO_UNKNOWN' value='0'/>
	<enumerator name='ZFS_DELEG_USER' value='117'/>
	<enumerator name='ZFS_DELEG_USER_SETS' value='85'/>
	<enumerator name='ZFS_DELEG_GROUP' value='103'/>
	<enumerator name='ZFS_DELEG_GROUP_SETS' value='71'/>
	<enumerator name='ZFS_DELEG_EVERYONE' value='101'/>
	<enumerator name='ZFS_DELEG_EVERYONE_SETS' value='69'/>
	<enumerator name='ZFS_DELEG_CREATE' value='99'/>
	<enumerator name='ZFS_DELEG_CREATE_SETS' value='67'/>
	<enumerator name='ZFS_DELEG_NAMED_SET' value='115'/>
	<enumerator name='ZFS_DELEG_NAMED_SET_SETS' value='83'/>
	</enum-decl>
	<typedef-decl name='zfs_deleg_who_type_t' type-id='type-id-297' filepath='../../include/sys/fs/zfs.h' line='352' column='1' id='type-id-298'/>
	<function-decl name='zfs_deleg_whokey' mangled-name='zfs_deleg_whokey' filepath='../../module/zcommon/zfs_deleg.c' line='211' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_deleg_whokey'>
	<parameter type-id='type-id-23' name='attr' filepath='../../module/zcommon/zfs_deleg.c' line='211' column='1'/>
	<parameter type-id='type-id-298' name='type' filepath='../../module/zcommon/zfs_deleg.c' line='211' column='1'/>
	<parameter type-id='type-id-45' name='inheritchr' filepath='../../module/zcommon/zfs_deleg.c' line='212' column='1'/>
	<parameter type-id='type-id-42' name='data' filepath='../../module/zcommon/zfs_deleg.c' line='212' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_deleg_verify_nvlist' mangled-name='zfs_deleg_verify_nvlist' filepath='../../module/zcommon/zfs_deleg.c' line='157' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_deleg_verify_nvlist'>
	<parameter type-id='type-id-22' name='nvp' filepath='../../module/zcommon/zfs_deleg.c' line='157' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zfs_deleg_canonicalize_perm' mangled-name='zfs_deleg_canonicalize_perm' filepath='../../module/zcommon/zfs_deleg.c' line='90' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_deleg_canonicalize_perm'>
	<parameter type-id='type-id-104' name='perm' filepath='../../module/zcommon/zfs_deleg.c' line='90' column='1'/>
	<return type-id='type-id-104'/>
	</function-decl>
	<function-decl name='permset_namecheck' mangled-name='permset_namecheck' filepath='../../include/zfs_namecheck.h' line='65' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_prop_delegatable' mangled-name='zfs_prop_delegatable' filepath='../../include/zfs_prop.h' line='92' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	</abi-instr>
	<abi-instr version='1.0' address-size='64' path='../../module/zcommon/zfs_fletcher.c' comp-dir-path='/home/colm/src/zfs/zfs/lib/libzfs' language='LANG_C99'>
	<class-decl name='zio_abd_checksum_func' size-in-bits='192' is-struct='yes' visibility='default' filepath='../../include/sys/zio_checksum.h' line='77' column='1' id='type-id-299'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='acf_init' type-id='type-id-300' visibility='default' filepath='../../include/sys/zio_checksum.h' line='78' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='acf_fini' type-id='type-id-301' visibility='default' filepath='../../include/sys/zio_checksum.h' line='79' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='acf_iter' type-id='type-id-302' visibility='default' filepath='../../include/sys/zio_checksum.h' line='80' column='1'/>
	</data-member>
	</class-decl>
	<class-decl name='zio_abd_checksum_data' size-in-bits='256' is-struct='yes' visibility='default' filepath='../../include/sys/zio_checksum.h' line='66' column='1' id='type-id-303'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='acd_byteorder' type-id='type-id-304' visibility='default' filepath='../../include/sys/zio_checksum.h' line='67' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='acd_ctx' type-id='type-id-305' visibility='default' filepath='../../include/sys/zio_checksum.h' line='68' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='acd_zcp' type-id='type-id-306' visibility='default' filepath='../../include/sys/zio_checksum.h' line='69' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='acd_private' type-id='type-id-42' visibility='default' filepath='../../include/sys/zio_checksum.h' line='70' column='1'/>
	</data-member>
	</class-decl>
	<enum-decl name='__anonymous_enum__' is-anonymous='yes' filepath='../../include/sys/zio_checksum.h' line='61' column='1' id='type-id-307'>
	<underlying-type type-id='type-id-7'/>
	<enumerator name='ZIO_CHECKSUM_NATIVE' value='0'/>
	<enumerator name='ZIO_CHECKSUM_BYTESWAP' value='1'/>
	</enum-decl>
	<typedef-decl name='zio_byteorder_t' type-id='type-id-307' filepath='../../include/sys/zio_checksum.h' line='64' column='1' id='type-id-304'/>
	<union-decl name='fletcher_4_ctx' size-in-bits='2048' visibility='default' filepath='../../include/zfs_fletcher.h' line='90' column='1' id='type-id-308'>
	<data-member access='private'>
	<var-decl name='scalar' type-id='type-id-309' visibility='default' filepath='../../include/zfs_fletcher.h' line='91' column='1'/>
	</data-member>
	<data-member access='private'>
	<var-decl name='superscalar' type-id='type-id-310' visibility='default' filepath='../../include/zfs_fletcher.h' line='92' column='1'/>
	</data-member>
	<data-member access='private'>
	<var-decl name='sse' type-id='type-id-311' visibility='default' filepath='../../include/zfs_fletcher.h' line='95' column='1'/>
	</data-member>
	<data-member access='private'>
	<var-decl name='avx' type-id='type-id-312' visibility='default' filepath='../../include/zfs_fletcher.h' line='98' column='1'/>
	</data-member>
	<data-member access='private'>
	<var-decl name='avx512' type-id='type-id-313' visibility='default' filepath='../../include/zfs_fletcher.h' line='101' column='1'/>
	</data-member>
	</union-decl>
	<class-decl name='zio_cksum' size-in-bits='256' is-struct='yes' visibility='default' filepath='../../include/sys/spa_checksum.h' line='38' column='1' id='type-id-314'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='zc_word' type-id='type-id-315' visibility='default' filepath='../../include/sys/spa_checksum.h' line='39' column='1'/>
	</data-member>
	</class-decl>

	<array-type-def dimensions='1' type-id='type-id-27' size-in-bits='256' id='type-id-315'>
	<subrange length='4' type-id='type-id-48' id='type-id-316'/>

	</array-type-def>
	<typedef-decl name='zio_cksum_t' type-id='type-id-314' filepath='../../include/sys/spa_checksum.h' line='40' column='1' id='type-id-309'/>
	<class-decl name='zfs_fletcher_superscalar' size-in-bits='256' is-struct='yes' visibility='default' filepath='../../include/zfs_fletcher.h' line='69' column='1' id='type-id-317'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='v' type-id='type-id-315' visibility='default' filepath='../../include/zfs_fletcher.h' line='70' column='1'/>
	</data-member>
	</class-decl>
	<typedef-decl name='zfs_fletcher_superscalar_t' type-id='type-id-317' filepath='../../include/zfs_fletcher.h' line='71' column='1' id='type-id-318'/>

	<array-type-def dimensions='1' type-id='type-id-318' size-in-bits='1024' id='type-id-310'>
	<subrange length='4' type-id='type-id-48' id='type-id-316'/>

	</array-type-def>
	<class-decl name='zfs_fletcher_sse' size-in-bits='128' is-struct='yes' visibility='default' filepath='../../include/zfs_fletcher.h' line='73' column='1' id='type-id-319'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='v' type-id='type-id-156' visibility='default' filepath='../../include/zfs_fletcher.h' line='74' column='1'/>
	</data-member>
	</class-decl>
	<typedef-decl name='zfs_fletcher_sse_t' type-id='type-id-319' filepath='../../include/zfs_fletcher.h' line='75' column='1' id='type-id-320'/>

	<array-type-def dimensions='1' type-id='type-id-320' size-in-bits='512' id='type-id-311'>
	<subrange length='4' type-id='type-id-48' id='type-id-316'/>

	</array-type-def>
	<class-decl name='zfs_fletcher_avx' size-in-bits='256' is-struct='yes' visibility='default' filepath='../../include/zfs_fletcher.h' line='77' column='1' id='type-id-321'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='v' type-id='type-id-315' visibility='default' filepath='../../include/zfs_fletcher.h' line='78' column='1'/>
	</data-member>
	</class-decl>
	<typedef-decl name='zfs_fletcher_avx_t' type-id='type-id-321' filepath='../../include/zfs_fletcher.h' line='79' column='1' id='type-id-322'/>

	<array-type-def dimensions='1' type-id='type-id-322' size-in-bits='1024' id='type-id-312'>
	<subrange length='4' type-id='type-id-48' id='type-id-316'/>

	</array-type-def>
	<class-decl name='zfs_fletcher_avx512' size-in-bits='512' is-struct='yes' visibility='default' filepath='../../include/zfs_fletcher.h' line='81' column='1' id='type-id-323'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='v' type-id='type-id-257' visibility='default' filepath='../../include/zfs_fletcher.h' line='82' column='1'/>
	</data-member>
	</class-decl>
	<typedef-decl name='zfs_fletcher_avx512_t' type-id='type-id-323' filepath='../../include/zfs_fletcher.h' line='83' column='1' id='type-id-324'/>

	<array-type-def dimensions='1' type-id='type-id-324' size-in-bits='2048' id='type-id-313'>
	<subrange length='4' type-id='type-id-48' id='type-id-316'/>

	</array-type-def>
	<typedef-decl name='fletcher_4_ctx_t' type-id='type-id-308' filepath='../../include/zfs_fletcher.h' line='106' column='1' id='type-id-325'/>
	<pointer-type-def type-id='type-id-325' size-in-bits='64' id='type-id-305'/>
	<pointer-type-def type-id='type-id-309' size-in-bits='64' id='type-id-306'/>
	<typedef-decl name='zio_abd_checksum_data_t' type-id='type-id-303' filepath='../../include/sys/zio_checksum.h' line='71' column='1' id='type-id-326'/>
	<pointer-type-def type-id='type-id-326' size-in-bits='64' id='type-id-327'/>
	<typedef-decl name='zio_abd_checksum_init_t' type-id='type-id-328' filepath='../../include/sys/zio_checksum.h' line='73' column='1' id='type-id-329'/>
	<pointer-type-def type-id='type-id-329' size-in-bits='64' id='type-id-300'/>
	<typedef-decl name='zio_abd_checksum_fini_t' type-id='type-id-328' filepath='../../include/sys/zio_checksum.h' line='74' column='1' id='type-id-330'/>
	<pointer-type-def type-id='type-id-330' size-in-bits='64' id='type-id-301'/>
	<typedef-decl name='zio_abd_checksum_iter_t' type-id='type-id-331' filepath='../../include/sys/zio_checksum.h' line='75' column='1' id='type-id-332'/>
	<pointer-type-def type-id='type-id-332' size-in-bits='64' id='type-id-302'/>
	<qualified-type-def type-id='type-id-299' const='yes' id='type-id-333'/>
	<typedef-decl name='zio_abd_checksum_func_t' type-id='type-id-333' filepath='../../include/sys/zio_checksum.h' line='81' column='1' id='type-id-334'/>
	<var-decl name='fletcher_4_abd_ops' type-id='type-id-334' mangled-name='fletcher_4_abd_ops' visibility='default' filepath='../../include/sys/zio_checksum.h' line='125' column='1' elf-symbol-id='fletcher_4_abd_ops'/>
	<function-decl name='fletcher_4_incremental_byteswap' mangled-name='fletcher_4_incremental_byteswap' filepath='../../module/zcommon/zfs_fletcher.c' line='589' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fletcher_4_incremental_byteswap'>
	<parameter type-id='type-id-42' name='buf' filepath='../../module/zcommon/zfs_fletcher.c' line='589' column='1'/>
	<parameter type-id='type-id-43' name='size' filepath='../../module/zcommon/zfs_fletcher.c' line='589' column='1'/>
	<parameter type-id='type-id-42' name='data' filepath='../../module/zcommon/zfs_fletcher.c' line='589' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='fletcher_4_native_varsize' mangled-name='fletcher_4_native_varsize' filepath='../../module/zcommon/zfs_fletcher.c' line='488' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fletcher_4_native_varsize'>
	<parameter type-id='type-id-42' name='buf' filepath='../../module/zcommon/zfs_fletcher.c' line='488' column='1'/>
	<parameter type-id='type-id-27' name='size' filepath='../../module/zcommon/zfs_fletcher.c' line='488' column='1'/>
	<parameter type-id='type-id-306' name='zcp' filepath='../../module/zcommon/zfs_fletcher.c' line='488' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fletcher_4_impl_set' mangled-name='fletcher_4_impl_set' filepath='../../module/zcommon/zfs_fletcher.c' line='369' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fletcher_4_impl_set'>
	<parameter type-id='type-id-104' name='val' filepath='../../module/zcommon/zfs_fletcher.c' line='369' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='fletcher_2_byteswap' mangled-name='fletcher_2_byteswap' filepath='../../module/zcommon/zfs_fletcher.c' line='297' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fletcher_2_byteswap'>
	<parameter type-id='type-id-42' name='buf' filepath='../../module/zcommon/zfs_fletcher.c' line='297' column='1'/>
	<parameter type-id='type-id-27' name='size' filepath='../../module/zcommon/zfs_fletcher.c' line='297' column='1'/>
	<parameter type-id='type-id-42' name='ctx_template' filepath='../../module/zcommon/zfs_fletcher.c' line='298' column='1'/>
	<parameter type-id='type-id-306' name='zcp' filepath='../../module/zcommon/zfs_fletcher.c' line='298' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fletcher_2_incremental_byteswap' mangled-name='fletcher_2_incremental_byteswap' filepath='../../module/zcommon/zfs_fletcher.c' line='271' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fletcher_2_incremental_byteswap'>
	<parameter type-id='type-id-42' name='buf' filepath='../../module/zcommon/zfs_fletcher.c' line='271' column='1'/>
	<parameter type-id='type-id-43' name='size' filepath='../../module/zcommon/zfs_fletcher.c' line='271' column='1'/>
	<parameter type-id='type-id-42' name='data' filepath='../../module/zcommon/zfs_fletcher.c' line='271' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='fletcher_2_native' mangled-name='fletcher_2_native' filepath='../../module/zcommon/zfs_fletcher.c' line='263' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fletcher_2_native'>
	<parameter type-id='type-id-42' name='buf' filepath='../../module/zcommon/zfs_fletcher.c' line='297' column='1'/>
	<parameter type-id='type-id-27' name='size' filepath='../../module/zcommon/zfs_fletcher.c' line='297' column='1'/>
	<parameter type-id='type-id-42' name='ctx_template' filepath='../../module/zcommon/zfs_fletcher.c' line='298' column='1'/>
	<parameter type-id='type-id-306' name='zcp' filepath='../../module/zcommon/zfs_fletcher.c' line='298' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fletcher_2_incremental_native' mangled-name='fletcher_2_incremental_native' filepath='../../module/zcommon/zfs_fletcher.c' line='237' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fletcher_2_incremental_native'>
	<parameter type-id='type-id-42' name='buf' filepath='../../module/zcommon/zfs_fletcher.c' line='271' column='1'/>
	<parameter type-id='type-id-43' name='size' filepath='../../module/zcommon/zfs_fletcher.c' line='271' column='1'/>
	<parameter type-id='type-id-42' name='data' filepath='../../module/zcommon/zfs_fletcher.c' line='271' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='fletcher_init' mangled-name='fletcher_init' filepath='../../module/zcommon/zfs_fletcher.c' line='231' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fletcher_init'>
	<parameter type-id='type-id-306' name='zcp' filepath='../../module/zcommon/zfs_fletcher.c' line='231' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fletcher_4_native' mangled-name='fletcher_4_native' filepath='../../module/zcommon/zfs_fletcher.c' line='465' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fletcher_4_native'>
	<parameter type-id='type-id-42' name='buf' filepath='../../module/zcommon/zfs_fletcher.c' line='465' column='1'/>
	<parameter type-id='type-id-27' name='size' filepath='../../module/zcommon/zfs_fletcher.c' line='465' column='1'/>
	<parameter type-id='type-id-42' name='ctx_template' filepath='../../module/zcommon/zfs_fletcher.c' line='466' column='1'/>
	<parameter type-id='type-id-306' name='zcp' filepath='../../module/zcommon/zfs_fletcher.c' line='466' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fletcher_4_byteswap' mangled-name='fletcher_4_byteswap' filepath='../../module/zcommon/zfs_fletcher.c' line='507' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fletcher_4_byteswap'>
	<parameter type-id='type-id-42' name='buf' filepath='../../module/zcommon/zfs_fletcher.c' line='507' column='1'/>
	<parameter type-id='type-id-27' name='size' filepath='../../module/zcommon/zfs_fletcher.c' line='507' column='1'/>
	<parameter type-id='type-id-42' name='ctx_template' filepath='../../module/zcommon/zfs_fletcher.c' line='508' column='1'/>
	<parameter type-id='type-id-306' name='zcp' filepath='../../module/zcommon/zfs_fletcher.c' line='508' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fletcher_4_incremental_native' mangled-name='fletcher_4_incremental_native' filepath='../../module/zcommon/zfs_fletcher.c' line='577' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='fletcher_4_incremental_native'>
	<parameter type-id='type-id-42' name='buf' filepath='../../module/zcommon/zfs_fletcher.c' line='577' column='1'/>
	<parameter type-id='type-id-43' name='size' filepath='../../module/zcommon/zfs_fletcher.c' line='577' column='1'/>
	<parameter type-id='type-id-42' name='data' filepath='../../module/zcommon/zfs_fletcher.c' line='577' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='membar_producer' mangled-name='membar_producer' filepath='../../lib/libspl/include/atomic.h' line='280' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='atomic_swap_32' mangled-name='atomic_swap_32' filepath='../../lib/libspl/include/atomic.h' line='240' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-type size-in-bits='64' id='type-id-331'>
	<parameter type-id='type-id-42'/>
	<parameter type-id='type-id-43'/>
	<parameter type-id='type-id-42'/>
	<return type-id='type-id-6'/>
	</function-type>
	<function-type size-in-bits='64' id='type-id-328'>
	<parameter type-id='type-id-327'/>
	<return type-id='type-id-52'/>
	</function-type>
	</abi-instr>
	<abi-instr version='1.0' address-size='64' path='../../module/zcommon/zfs_fletcher_avx512.c' comp-dir-path='/home/colm/src/zfs/zfs/lib/libzfs' language='LANG_C99'>
	<class-decl name='fletcher_4_func' size-in-bits='512' is-struct='yes' visibility='default' filepath='../../include/zfs_fletcher.h' line='116' column='1' id='type-id-335'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='init_native' type-id='type-id-336' visibility='default' filepath='../../include/zfs_fletcher.h' line='117' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='fini_native' type-id='type-id-337' visibility='default' filepath='../../include/zfs_fletcher.h' line='118' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='compute_native' type-id='type-id-338' visibility='default' filepath='../../include/zfs_fletcher.h' line='119' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='init_byteswap' type-id='type-id-336' visibility='default' filepath='../../include/zfs_fletcher.h' line='120' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='fini_byteswap' type-id='type-id-337' visibility='default' filepath='../../include/zfs_fletcher.h' line='121' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='compute_byteswap' type-id='type-id-338' visibility='default' filepath='../../include/zfs_fletcher.h' line='122' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='valid' type-id='type-id-339' visibility='default' filepath='../../include/zfs_fletcher.h' line='123' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='448'>
	<var-decl name='name' type-id='type-id-104' visibility='default' filepath='../../include/zfs_fletcher.h' line='124' column='1'/>
	</data-member>
	</class-decl>
	<pointer-type-def type-id='type-id-340' size-in-bits='64' id='type-id-341'/>
	<typedef-decl name='fletcher_4_init_f' type-id='type-id-341' filepath='../../include/zfs_fletcher.h' line='111' column='1' id='type-id-336'/>
	<pointer-type-def type-id='type-id-342' size-in-bits='64' id='type-id-343'/>
	<typedef-decl name='fletcher_4_fini_f' type-id='type-id-343' filepath='../../include/zfs_fletcher.h' line='112' column='1' id='type-id-337'/>
	<pointer-type-def type-id='type-id-344' size-in-bits='64' id='type-id-345'/>
	<typedef-decl name='fletcher_4_compute_f' type-id='type-id-345' filepath='../../include/zfs_fletcher.h' line='113' column='1' id='type-id-338'/>
	<pointer-type-def type-id='type-id-346' size-in-bits='64' id='type-id-339'/>
	<typedef-decl name='fletcher_4_ops_t' type-id='type-id-335' filepath='../../include/zfs_fletcher.h' line='125' column='1' id='type-id-347'/>
	<qualified-type-def type-id='type-id-347' const='yes' id='type-id-348'/>
	<var-decl name='fletcher_4_avx512f_ops' type-id='type-id-348' mangled-name='fletcher_4_avx512f_ops' visibility='default' filepath='../../include/zfs_fletcher.h' line='143' column='1' elf-symbol-id='fletcher_4_avx512f_ops'/>
	<var-decl name='fletcher_4_avx512bw_ops' type-id='type-id-348' mangled-name='fletcher_4_avx512bw_ops' visibility='default' filepath='../../include/zfs_fletcher.h' line='147' column='1' elf-symbol-id='fletcher_4_avx512bw_ops'/>
	<function-type size-in-bits='64' id='type-id-346'>
	<return type-id='type-id-5'/>
	</function-type>
	<function-type size-in-bits='64' id='type-id-340'>
	<parameter type-id='type-id-305'/>
	<return type-id='type-id-52'/>
	</function-type>
	<function-type size-in-bits='64' id='type-id-344'>
	<parameter type-id='type-id-305'/>
	<parameter type-id='type-id-42'/>
	<parameter type-id='type-id-27'/>
	<return type-id='type-id-52'/>
	</function-type>
	<function-type size-in-bits='64' id='type-id-342'>
	<parameter type-id='type-id-305'/>
	<parameter type-id='type-id-306'/>
	<return type-id='type-id-52'/>
	</function-type>
	</abi-instr>
	<abi-instr version='1.0' address-size='64' path='../../module/zcommon/zfs_fletcher_intel.c' comp-dir-path='/home/colm/src/zfs/zfs/lib/libzfs' language='LANG_C99'>
	<var-decl name='fletcher_4_avx2_ops' type-id='type-id-348' mangled-name='fletcher_4_avx2_ops' visibility='default' filepath='../../include/zfs_fletcher.h' line='139' column='1' elf-symbol-id='fletcher_4_avx2_ops'/>
	</abi-instr>
	<abi-instr version='1.0' address-size='64' path='../../module/zcommon/zfs_fletcher_sse.c' comp-dir-path='/home/colm/src/zfs/zfs/lib/libzfs' language='LANG_C99'>
	<var-decl name='fletcher_4_sse2_ops' type-id='type-id-348' mangled-name='fletcher_4_sse2_ops' visibility='default' filepath='../../include/zfs_fletcher.h' line='131' column='1' elf-symbol-id='fletcher_4_sse2_ops'/>
	<var-decl name='fletcher_4_ssse3_ops' type-id='type-id-348' mangled-name='fletcher_4_ssse3_ops' visibility='default' filepath='../../include/zfs_fletcher.h' line='135' column='1' elf-symbol-id='fletcher_4_ssse3_ops'/>
	</abi-instr>
	<abi-instr version='1.0' address-size='64' path='../../module/zcommon/zfs_fletcher_superscalar.c' comp-dir-path='/home/colm/src/zfs/zfs/lib/libzfs' language='LANG_C99'>
	<var-decl name='fletcher_4_superscalar_ops' type-id='type-id-348' mangled-name='fletcher_4_superscalar_ops' visibility='default' filepath='../../include/zfs_fletcher.h' line='127' column='1' elf-symbol-id='fletcher_4_superscalar_ops'/>
	</abi-instr>
	<abi-instr version='1.0' address-size='64' path='../../module/zcommon/zfs_fletcher_superscalar4.c' comp-dir-path='/home/colm/src/zfs/zfs/lib/libzfs' language='LANG_C99'>
	<var-decl name='fletcher_4_superscalar4_ops' type-id='type-id-348' mangled-name='fletcher_4_superscalar4_ops' visibility='default' filepath='../../include/zfs_fletcher.h' line='128' column='1' elf-symbol-id='fletcher_4_superscalar4_ops'/>
	</abi-instr>
	<abi-instr version='1.0' address-size='64' path='../../module/zcommon/zfs_namecheck.c' comp-dir-path='/home/colm/src/zfs/zfs/lib/libzfs' language='LANG_C99'>
	<var-decl name='zfs_max_dataset_nesting' type-id='type-id-6' mangled-name='zfs_max_dataset_nesting' visibility='default' filepath='../../include/zfs_namecheck.h' line='54' column='1' elf-symbol-id='zfs_max_dataset_nesting'/>
	<enum-decl name='__anonymous_enum__' is-anonymous='yes' filepath='../../include/zfs_namecheck.h' line='36' column='1' id='type-id-349'>
	<underlying-type type-id='type-id-7'/>
	<enumerator name='NAME_ERR_LEADING_SLASH' value='0'/>
	<enumerator name='NAME_ERR_EMPTY_COMPONENT' value='1'/>
	<enumerator name='NAME_ERR_TRAILING_SLASH' value='2'/>
	<enumerator name='NAME_ERR_INVALCHAR' value='3'/>
	<enumerator name='NAME_ERR_MULTIPLE_DELIMITERS' value='4'/>
	<enumerator name='NAME_ERR_NOLETTER' value='5'/>
	<enumerator name='NAME_ERR_RESERVED' value='6'/>
	<enumerator name='NAME_ERR_DISKLIKE' value='7'/>
	<enumerator name='NAME_ERR_TOOLONG' value='8'/>
	<enumerator name='NAME_ERR_SELF_REF' value='9'/>
	<enumerator name='NAME_ERR_PARENT_REF' value='10'/>
	<enumerator name='NAME_ERR_NO_AT' value='11'/>
	<enumerator name='NAME_ERR_NO_POUND' value='12'/>
	</enum-decl>
	<typedef-decl name='namecheck_err_t' type-id='type-id-349' filepath='../../include/zfs_namecheck.h' line='50' column='1' id='type-id-350'/>
	<pointer-type-def type-id='type-id-350' size-in-bits='64' id='type-id-351'/>
	<function-decl name='pool_namecheck' mangled-name='pool_namecheck' filepath='../../module/zcommon/zfs_namecheck.c' line='407' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='pool_namecheck'>
	<parameter type-id='type-id-104' name='pool' filepath='../../module/zcommon/zfs_namecheck.c' line='407' column='1'/>
	<parameter type-id='type-id-351' name='why' filepath='../../module/zcommon/zfs_namecheck.c' line='407' column='1'/>
	<parameter type-id='type-id-23' name='what' filepath='../../module/zcommon/zfs_namecheck.c' line='407' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='mountpoint_namecheck' mangled-name='mountpoint_namecheck' filepath='../../module/zcommon/zfs_namecheck.c' line='361' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='mountpoint_namecheck'>
	<parameter type-id='type-id-104' name='path' filepath='../../module/zcommon/zfs_namecheck.c' line='361' column='1'/>
	<parameter type-id='type-id-351' name='why' filepath='../../module/zcommon/zfs_namecheck.c' line='361' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='snapshot_namecheck' mangled-name='snapshot_namecheck' filepath='../../module/zcommon/zfs_namecheck.c' line='338' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='snapshot_namecheck'>
	<parameter type-id='type-id-104' name='pool' filepath='../../module/zcommon/zfs_namecheck.c' line='407' column='1'/>
	<parameter type-id='type-id-351' name='why' filepath='../../module/zcommon/zfs_namecheck.c' line='407' column='1'/>
	<parameter type-id='type-id-23' name='what' filepath='../../module/zcommon/zfs_namecheck.c' line='407' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='bookmark_namecheck' mangled-name='bookmark_namecheck' filepath='../../module/zcommon/zfs_namecheck.c' line='319' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='bookmark_namecheck'>
	<parameter type-id='type-id-104' name='pool' filepath='../../module/zcommon/zfs_namecheck.c' line='407' column='1'/>
	<parameter type-id='type-id-351' name='why' filepath='../../module/zcommon/zfs_namecheck.c' line='407' column='1'/>
	<parameter type-id='type-id-23' name='what' filepath='../../module/zcommon/zfs_namecheck.c' line='407' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='dataset_namecheck' mangled-name='dataset_namecheck' filepath='../../module/zcommon/zfs_namecheck.c' line='300' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='dataset_namecheck'>
	<parameter type-id='type-id-104' name='pool' filepath='../../module/zcommon/zfs_namecheck.c' line='407' column='1'/>
	<parameter type-id='type-id-351' name='why' filepath='../../module/zcommon/zfs_namecheck.c' line='407' column='1'/>
	<parameter type-id='type-id-23' name='what' filepath='../../module/zcommon/zfs_namecheck.c' line='407' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='dataset_nestcheck' mangled-name='dataset_nestcheck' filepath='../../module/zcommon/zfs_namecheck.c' line='161' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='dataset_nestcheck'>
	<parameter type-id='type-id-104' name='path' filepath='../../module/zcommon/zfs_namecheck.c' line='161' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='permset_namecheck' mangled-name='permset_namecheck' filepath='../../module/zcommon/zfs_namecheck.c' line='135' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='permset_namecheck'>
	<parameter type-id='type-id-104' name='path' filepath='../../module/zcommon/zfs_namecheck.c' line='135' column='1'/>
	<parameter type-id='type-id-351' name='why' filepath='../../module/zcommon/zfs_namecheck.c' line='135' column='1'/>
	<parameter type-id='type-id-23' name='what' filepath='../../module/zcommon/zfs_namecheck.c' line='135' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='get_dataset_depth' mangled-name='get_dataset_depth' filepath='../../module/zcommon/zfs_namecheck.c' line='70' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='get_dataset_depth'>
	<parameter type-id='type-id-104' name='path' filepath='../../module/zcommon/zfs_namecheck.c' line='70' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zfs_component_namecheck' mangled-name='zfs_component_namecheck' filepath='../../module/zcommon/zfs_namecheck.c' line='98' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_component_namecheck'>
	<parameter type-id='type-id-104' name='path' filepath='../../module/zcommon/zfs_namecheck.c' line='98' column='1'/>
	<parameter type-id='type-id-351' name='why' filepath='../../module/zcommon/zfs_namecheck.c' line='98' column='1'/>
	<parameter type-id='type-id-23' name='what' filepath='../../module/zcommon/zfs_namecheck.c' line='98' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='entity_namecheck' mangled-name='entity_namecheck' filepath='../../module/zcommon/zfs_namecheck.c' line='182' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='entity_namecheck'>
	<parameter type-id='type-id-104' name='path' filepath='../../module/zcommon/zfs_namecheck.c' line='182' column='1'/>
	<parameter type-id='type-id-351' name='why' filepath='../../module/zcommon/zfs_namecheck.c' line='182' column='1'/>
	<parameter type-id='type-id-23' name='what' filepath='../../module/zcommon/zfs_namecheck.c' line='182' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	</abi-instr>
	<abi-instr version='1.0' address-size='64' path='../../module/zcommon/zfs_prop.c' comp-dir-path='/home/colm/src/zfs/zfs/lib/libzfs' language='LANG_C99'>

	<array-type-def dimensions='1' type-id='type-id-104' size-in-bits='768' id='type-id-352'>
	<subrange length='12' type-id='type-id-48' id='type-id-353'/>

	</array-type-def>
	<var-decl name='zfs_userquota_prop_prefixes' type-id='type-id-352' mangled-name='zfs_userquota_prop_prefixes' visibility='default' filepath='../../include/sys/fs/zfs.h' line='208' column='1' elf-symbol-id='zfs_userquota_prop_prefixes'/>
	<function-decl name='zfs_prop_align_right' mangled-name='zfs_prop_align_right' filepath='../../module/zcommon/zfs_prop.c' line='984' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_align_right'>
	<parameter type-id='type-id-2' name='prop' filepath='../../module/zcommon/zfs_prop.c' line='984' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	<function-decl name='zfs_prop_column_name' mangled-name='zfs_prop_column_name' filepath='../../module/zcommon/zfs_prop.c' line='974' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_column_name'>
	<parameter type-id='type-id-2' name='prop' filepath='../../module/zcommon/zfs_prop.c' line='974' column='1'/>
	<return type-id='type-id-104'/>
	</function-decl>
	<function-decl name='zfs_prop_is_string' mangled-name='zfs_prop_is_string' filepath='../../module/zcommon/zfs_prop.c' line='963' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_is_string'>
	<parameter type-id='type-id-2' name='prop' filepath='../../module/zcommon/zfs_prop.c' line='963' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zfs_prop_values' mangled-name='zfs_prop_values' filepath='../../module/zcommon/zfs_prop.c' line='952' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_values'>
	<parameter type-id='type-id-2' name='prop' filepath='../../module/zcommon/zfs_prop.c' line='974' column='1'/>
	<return type-id='type-id-104'/>
	</function-decl>
	<function-decl name='zfs_prop_valid_keylocation' mangled-name='zfs_prop_valid_keylocation' filepath='../../module/zcommon/zfs_prop.c' line='931' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_valid_keylocation'>
	<parameter type-id='type-id-104' name='str' filepath='../../module/zcommon/zfs_prop.c' line='931' column='1'/>
	<parameter type-id='type-id-5' name='encrypted' filepath='../../module/zcommon/zfs_prop.c' line='931' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	<function-decl name='zfs_prop_encryption_key_param' mangled-name='zfs_prop_encryption_key_param' filepath='../../module/zcommon/zfs_prop.c' line='915' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_encryption_key_param'>
	<parameter type-id='type-id-2' name='prop' filepath='../../module/zcommon/zfs_prop.c' line='984' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	<function-decl name='zfs_prop_inheritable' mangled-name='zfs_prop_inheritable' filepath='../../module/zcommon/zfs_prop.c' line='904' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_inheritable'>
	<parameter type-id='type-id-2' name='prop' filepath='../../module/zcommon/zfs_prop.c' line='984' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	<function-decl name='zfs_prop_to_name' mangled-name='zfs_prop_to_name' filepath='../../module/zcommon/zfs_prop.c' line='895' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_to_name'>
	<parameter type-id='type-id-2' name='prop' filepath='../../module/zcommon/zfs_prop.c' line='974' column='1'/>
	<return type-id='type-id-104'/>
	</function-decl>
	<function-decl name='zfs_prop_default_numeric' mangled-name='zfs_prop_default_numeric' filepath='../../module/zcommon/zfs_prop.c' line='885' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_default_numeric'>
	<parameter type-id='type-id-2' name='prop' filepath='../../module/zcommon/zfs_prop.c' line='885' column='1'/>
	<return type-id='type-id-27'/>
	</function-decl>
	<function-decl name='zfs_prop_default_string' mangled-name='zfs_prop_default_string' filepath='../../module/zcommon/zfs_prop.c' line='879' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_default_string'>
	<parameter type-id='type-id-2' name='prop' filepath='../../module/zcommon/zfs_prop.c' line='974' column='1'/>
	<return type-id='type-id-104'/>
	</function-decl>
	<function-decl name='zfs_prop_setonce' mangled-name='zfs_prop_setonce' filepath='../../module/zcommon/zfs_prop.c' line='872' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_setonce'>
	<parameter type-id='type-id-2' name='prop' filepath='../../module/zcommon/zfs_prop.c' line='984' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	<function-decl name='zfs_prop_visible' mangled-name='zfs_prop_visible' filepath='../../module/zcommon/zfs_prop.c' line='862' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_visible'>
	<parameter type-id='type-id-2' name='prop' filepath='../../module/zcommon/zfs_prop.c' line='984' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	<function-decl name='zfs_prop_readonly' mangled-name='zfs_prop_readonly' filepath='../../module/zcommon/zfs_prop.c' line='851' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_readonly'>
	<parameter type-id='type-id-2' name='prop' filepath='../../module/zcommon/zfs_prop.c' line='984' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	<enum-decl name='__anonymous_enum__' is-anonymous='yes' filepath='../../include/zfs_prop.h' line='40' column='1' id='type-id-354'>
	<underlying-type type-id='type-id-7'/>
	<enumerator name='PROP_TYPE_NUMBER' value='0'/>
	<enumerator name='PROP_TYPE_STRING' value='1'/>
	<enumerator name='PROP_TYPE_INDEX' value='2'/>
	</enum-decl>
	<typedef-decl name='zprop_type_t' type-id='type-id-354' filepath='../../include/zfs_prop.h' line='44' column='1' id='type-id-355'/>
	<function-decl name='zfs_prop_get_type' mangled-name='zfs_prop_get_type' filepath='../../module/zcommon/zfs_prop.c' line='842' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_get_type'>
	<parameter type-id='type-id-2' name='prop' filepath='../../module/zcommon/zfs_prop.c' line='842' column='1'/>
	<return type-id='type-id-355'/>
	</function-decl>
	<function-decl name='zfs_prop_valid_for_type' mangled-name='zfs_prop_valid_for_type' filepath='../../module/zcommon/zfs_prop.c' line='836' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_valid_for_type'>
	<parameter type-id='type-id-6' name='prop' filepath='../../module/zcommon/zfs_prop.c' line='836' column='1'/>
	<parameter type-id='type-id-20' name='types' filepath='../../module/zcommon/zfs_prop.c' line='836' column='1'/>
	<parameter type-id='type-id-5' name='headcheck' filepath='../../module/zcommon/zfs_prop.c' line='836' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	<function-decl name='zfs_prop_random_value' mangled-name='zfs_prop_random_value' filepath='../../module/zcommon/zfs_prop.c' line='827' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_random_value'>
	<parameter type-id='type-id-2' name='prop' filepath='../../module/zcommon/zfs_prop.c' line='827' column='1'/>
	<parameter type-id='type-id-27' name='seed' filepath='../../module/zcommon/zfs_prop.c' line='827' column='1'/>
	<return type-id='type-id-27'/>
	</function-decl>
	<pointer-type-def type-id='type-id-104' size-in-bits='64' id='type-id-356'/>
	<function-decl name='zfs_prop_index_to_string' mangled-name='zfs_prop_index_to_string' filepath='../../module/zcommon/zfs_prop.c' line='821' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_index_to_string'>
	<parameter type-id='type-id-2' name='prop' filepath='../../module/zcommon/zfs_prop.c' line='821' column='1'/>
	<parameter type-id='type-id-27' name='index' filepath='../../module/zcommon/zfs_prop.c' line='821' column='1'/>
	<parameter type-id='type-id-356' name='string' filepath='../../module/zcommon/zfs_prop.c' line='821' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zfs_prop_string_to_index' mangled-name='zfs_prop_string_to_index' filepath='../../module/zcommon/zfs_prop.c' line='815' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_string_to_index'>
	<parameter type-id='type-id-2' name='prop' filepath='../../module/zcommon/zfs_prop.c' line='815' column='1'/>
	<parameter type-id='type-id-104' name='string' filepath='../../module/zcommon/zfs_prop.c' line='815' column='1'/>
	<parameter type-id='type-id-137' name='index' filepath='../../module/zcommon/zfs_prop.c' line='815' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zfs_prop_written' mangled-name='zfs_prop_written' filepath='../../module/zcommon/zfs_prop.c' line='802' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_written'>
	<parameter type-id='type-id-104' name='name' filepath='../../module/zcommon/zfs_prop.c' line='802' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	<function-decl name='zfs_prop_userquota' mangled-name='zfs_prop_userquota' filepath='../../module/zcommon/zfs_prop.c' line='782' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_userquota'>
	<parameter type-id='type-id-104' name='name' filepath='../../module/zcommon/zfs_prop.c' line='782' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	<function-decl name='zfs_prop_user' mangled-name='zfs_prop_user' filepath='../../module/zcommon/zfs_prop.c' line='756' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_user'>
	<parameter type-id='type-id-104' name='name' filepath='../../module/zcommon/zfs_prop.c' line='756' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	<function-decl name='zfs_name_to_prop' mangled-name='zfs_name_to_prop' filepath='../../module/zcommon/zfs_prop.c' line='735' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_name_to_prop'>
	<parameter type-id='type-id-104' name='propname' filepath='../../module/zcommon/zfs_prop.c' line='735' column='1'/>
	<return type-id='type-id-2'/>
	</function-decl>
	<function-decl name='zfs_prop_delegatable' mangled-name='zfs_prop_delegatable' filepath='../../module/zcommon/zfs_prop.c' line='720' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_delegatable'>
	<parameter type-id='type-id-2' name='prop' filepath='../../module/zcommon/zfs_prop.c' line='720' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	<class-decl name='__anonymous_struct__' size-in-bits='704' is-struct='yes' is-anonymous='yes' naming-typedef-id='type-id-357' visibility='default' filepath='../../include/zfs_prop.h' line='67' column='1' id='type-id-358'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='pd_name' type-id='type-id-104' visibility='default' filepath='../../include/zfs_prop.h' line='68' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='pd_propnum' type-id='type-id-6' visibility='default' filepath='../../include/zfs_prop.h' line='69' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='96'>
	<var-decl name='pd_proptype' type-id='type-id-355' visibility='default' filepath='../../include/zfs_prop.h' line='70' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='pd_strdefault' type-id='type-id-104' visibility='default' filepath='../../include/zfs_prop.h' line='71' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='pd_numdefault' type-id='type-id-27' visibility='default' filepath='../../include/zfs_prop.h' line='72' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='pd_attr' type-id='type-id-359' visibility='default' filepath='../../include/zfs_prop.h' line='73' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='288'>
	<var-decl name='pd_types' type-id='type-id-6' visibility='default' filepath='../../include/zfs_prop.h' line='74' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='pd_values' type-id='type-id-104' visibility='default' filepath='../../include/zfs_prop.h' line='76' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='pd_colname' type-id='type-id-104' visibility='default' filepath='../../include/zfs_prop.h' line='77' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='448'>
	<var-decl name='pd_rightalign' type-id='type-id-5' visibility='default' filepath='../../include/zfs_prop.h' line='78' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='480'>
	<var-decl name='pd_visible' type-id='type-id-5' visibility='default' filepath='../../include/zfs_prop.h' line='79' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='512'>
	<var-decl name='pd_zfs_mod_supported' type-id='type-id-5' visibility='default' filepath='../../include/zfs_prop.h' line='81' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='576'>
	<var-decl name='pd_table' type-id='type-id-360' visibility='default' filepath='../../include/zfs_prop.h' line='82' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='640'>
	<var-decl name='pd_table_size' type-id='type-id-43' visibility='default' filepath='../../include/zfs_prop.h' line='84' column='1'/>
	</data-member>
	</class-decl>
	<enum-decl name='__anonymous_enum__' is-anonymous='yes' filepath='../../include/zfs_prop.h' line='46' column='1' id='type-id-361'>
	<underlying-type type-id='type-id-7'/>
	<enumerator name='PROP_DEFAULT' value='0'/>
	<enumerator name='PROP_READONLY' value='1'/>
	<enumerator name='PROP_INHERIT' value='2'/>
	<enumerator name='PROP_ONETIME' value='3'/>
	<enumerator name='PROP_ONETIME_DEFAULT' value='4'/>
	</enum-decl>
	<typedef-decl name='zprop_attr_t' type-id='type-id-361' filepath='../../include/zfs_prop.h' line='60' column='1' id='type-id-359'/>
	<class-decl name='zfs_index' size-in-bits='128' is-struct='yes' visibility='default' filepath='../../include/zfs_prop.h' line='62' column='1' id='type-id-362'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='pi_name' type-id='type-id-104' visibility='default' filepath='../../include/zfs_prop.h' line='63' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='pi_value' type-id='type-id-27' visibility='default' filepath='../../include/zfs_prop.h' line='64' column='1'/>
	</data-member>
	</class-decl>
	<typedef-decl name='zprop_index_t' type-id='type-id-362' filepath='../../include/zfs_prop.h' line='65' column='1' id='type-id-363'/>
	<qualified-type-def type-id='type-id-363' const='yes' id='type-id-364'/>
	<pointer-type-def type-id='type-id-364' size-in-bits='64' id='type-id-360'/>
	<typedef-decl name='zprop_desc_t' type-id='type-id-358' filepath='../../include/zfs_prop.h' line='85' column='1' id='type-id-357'/>
	<pointer-type-def type-id='type-id-357' size-in-bits='64' id='type-id-365'/>
	<function-decl name='zfs_prop_get_table' mangled-name='zfs_prop_get_table' filepath='../../module/zcommon/zfs_prop.c' line='69' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zfs_prop_get_table'>
	<return type-id='type-id-365'/>
	</function-decl>
	<function-decl name='zprop_random_value' mangled-name='zprop_random_value' filepath='../../include/zfs_prop.h' line='124' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zprop_index_to_string' mangled-name='zprop_index_to_string' filepath='../../include/zfs_prop.h' line='123' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zprop_register_index' mangled-name='zprop_register_index' filepath='../../include/zfs_prop.h' line='112' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zprop_register_string' mangled-name='zprop_register_string' filepath='../../include/zfs_prop.h' line='108' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zprop_register_number' mangled-name='zprop_register_number' filepath='../../include/zfs_prop.h' line='110' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zprop_register_hidden' mangled-name='zprop_register_hidden' filepath='../../include/zfs_prop.h' line='114' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zprop_register_impl' mangled-name='zprop_register_impl' filepath='../../include/zfs_prop.h' line='105' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	</abi-instr>
	<abi-instr version='1.0' address-size='64' path='../../module/zcommon/zpool_prop.c' comp-dir-path='/home/colm/src/zfs/zfs/lib/libzfs' language='LANG_C99'>
	- <function-decl name='zpool_prop_align_right' mangled-name='zpool_prop_align_right' filepath='../../module/zcommon/zpool_prop.c' line='256' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_align_right'>
	- <parameter type-id='type-id-209' name='prop' filepath='../../module/zcommon/zpool_prop.c' line='256' column='1'/>
	+ <function-decl name='zpool_prop_align_right' mangled-name='zpool_prop_align_right' filepath='../../module/zcommon/zpool_prop.c' line='257' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_align_right'>
	+ <parameter type-id='type-id-209' name='prop' filepath='../../module/zcommon/zpool_prop.c' line='257' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	- <function-decl name='zpool_prop_column_name' mangled-name='zpool_prop_column_name' filepath='../../module/zcommon/zpool_prop.c' line='250' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_column_name'>
	- <parameter type-id='type-id-209' name='prop' filepath='../../module/zcommon/zpool_prop.c' line='250' column='1'/>
	+ <function-decl name='zpool_prop_column_name' mangled-name='zpool_prop_column_name' filepath='../../module/zcommon/zpool_prop.c' line='251' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_column_name'>
	+ <parameter type-id='type-id-209' name='prop' filepath='../../module/zcommon/zpool_prop.c' line='251' column='1'/>
	<return type-id='type-id-104'/>
	</function-decl>
	- <function-decl name='zpool_prop_values' mangled-name='zpool_prop_values' filepath='../../module/zcommon/zpool_prop.c' line='244' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_values'>
	- <parameter type-id='type-id-209' name='prop' filepath='../../module/zcommon/zpool_prop.c' line='250' column='1'/>
	+ <function-decl name='zpool_prop_values' mangled-name='zpool_prop_values' filepath='../../module/zcommon/zpool_prop.c' line='245' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_values'>
	+ <parameter type-id='type-id-209' name='prop' filepath='../../module/zcommon/zpool_prop.c' line='251' column='1'/>
	<return type-id='type-id-104'/>
	</function-decl>
	- <function-decl name='zpool_prop_random_value' mangled-name='zpool_prop_random_value' filepath='../../module/zcommon/zpool_prop.c' line='235' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_random_value'>
	- <parameter type-id='type-id-209' name='prop' filepath='../../module/zcommon/zpool_prop.c' line='235' column='1'/>
	- <parameter type-id='type-id-27' name='seed' filepath='../../module/zcommon/zpool_prop.c' line='235' column='1'/>
	+ <function-decl name='zpool_prop_random_value' mangled-name='zpool_prop_random_value' filepath='../../module/zcommon/zpool_prop.c' line='236' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_random_value'>
	+ <parameter type-id='type-id-209' name='prop' filepath='../../module/zcommon/zpool_prop.c' line='236' column='1'/>
	+ <parameter type-id='type-id-27' name='seed' filepath='../../module/zcommon/zpool_prop.c' line='236' column='1'/>
	<return type-id='type-id-27'/>
	</function-decl>
	- <function-decl name='zpool_prop_index_to_string' mangled-name='zpool_prop_index_to_string' filepath='../../module/zcommon/zpool_prop.c' line='228' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_index_to_string'>
	- <parameter type-id='type-id-209' name='prop' filepath='../../module/zcommon/zpool_prop.c' line='228' column='1'/>
	- <parameter type-id='type-id-27' name='index' filepath='../../module/zcommon/zpool_prop.c' line='228' column='1'/>
	- <parameter type-id='type-id-356' name='string' filepath='../../module/zcommon/zpool_prop.c' line='229' column='1'/>
	+ <function-decl name='zpool_prop_index_to_string' mangled-name='zpool_prop_index_to_string' filepath='../../module/zcommon/zpool_prop.c' line='229' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_index_to_string'>
	+ <parameter type-id='type-id-209' name='prop' filepath='../../module/zcommon/zpool_prop.c' line='229' column='1'/>
	+ <parameter type-id='type-id-27' name='index' filepath='../../module/zcommon/zpool_prop.c' line='229' column='1'/>
	+ <parameter type-id='type-id-356' name='string' filepath='../../module/zcommon/zpool_prop.c' line='230' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_prop_string_to_index' mangled-name='zpool_prop_string_to_index' filepath='../../module/zcommon/zpool_prop.c' line='221' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_string_to_index'>
	- <parameter type-id='type-id-209' name='prop' filepath='../../module/zcommon/zpool_prop.c' line='221' column='1'/>
	- <parameter type-id='type-id-104' name='string' filepath='../../module/zcommon/zpool_prop.c' line='221' column='1'/>
	- <parameter type-id='type-id-137' name='index' filepath='../../module/zcommon/zpool_prop.c' line='222' column='1'/>
	+ <function-decl name='zpool_prop_string_to_index' mangled-name='zpool_prop_string_to_index' filepath='../../module/zcommon/zpool_prop.c' line='222' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_string_to_index'>
	+ <parameter type-id='type-id-209' name='prop' filepath='../../module/zcommon/zpool_prop.c' line='222' column='1'/>
	+ <parameter type-id='type-id-104' name='string' filepath='../../module/zcommon/zpool_prop.c' line='222' column='1'/>
	+ <parameter type-id='type-id-137' name='index' filepath='../../module/zcommon/zpool_prop.c' line='223' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	- <function-decl name='zpool_prop_unsupported' mangled-name='zpool_prop_unsupported' filepath='../../module/zcommon/zpool_prop.c' line='214' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_unsupported'>
	- <parameter type-id='type-id-104' name='name' filepath='../../module/zcommon/zpool_prop.c' line='214' column='1'/>
	+ <function-decl name='zpool_prop_unsupported' mangled-name='zpool_prop_unsupported' filepath='../../module/zcommon/zpool_prop.c' line='215' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_unsupported'>
	+ <parameter type-id='type-id-104' name='name' filepath='../../module/zcommon/zpool_prop.c' line='215' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	- <function-decl name='zpool_prop_feature' mangled-name='zpool_prop_feature' filepath='../../module/zcommon/zpool_prop.c' line='204' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_feature'>
	- <parameter type-id='type-id-104' name='name' filepath='../../module/zcommon/zpool_prop.c' line='214' column='1'/>
	+ <function-decl name='zpool_prop_feature' mangled-name='zpool_prop_feature' filepath='../../module/zcommon/zpool_prop.c' line='205' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_feature'>
	+ <parameter type-id='type-id-104' name='name' filepath='../../module/zcommon/zpool_prop.c' line='215' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	- <function-decl name='zpool_prop_default_numeric' mangled-name='zpool_prop_default_numeric' filepath='../../module/zcommon/zpool_prop.c' line='195' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_default_numeric'>
	- <parameter type-id='type-id-209' name='prop' filepath='../../module/zcommon/zpool_prop.c' line='195' column='1'/>
	+ <function-decl name='zpool_prop_default_numeric' mangled-name='zpool_prop_default_numeric' filepath='../../module/zcommon/zpool_prop.c' line='196' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_default_numeric'>
	+ <parameter type-id='type-id-209' name='prop' filepath='../../module/zcommon/zpool_prop.c' line='196' column='1'/>
	<return type-id='type-id-27'/>
	</function-decl>
	- <function-decl name='zpool_prop_default_string' mangled-name='zpool_prop_default_string' filepath='../../module/zcommon/zpool_prop.c' line='189' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_default_string'>
	- <parameter type-id='type-id-209' name='prop' filepath='../../module/zcommon/zpool_prop.c' line='250' column='1'/>
	+ <function-decl name='zpool_prop_default_string' mangled-name='zpool_prop_default_string' filepath='../../module/zcommon/zpool_prop.c' line='190' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_default_string'>
	+ <parameter type-id='type-id-209' name='prop' filepath='../../module/zcommon/zpool_prop.c' line='251' column='1'/>
	<return type-id='type-id-104'/>
	</function-decl>
	- <function-decl name='zpool_prop_setonce' mangled-name='zpool_prop_setonce' filepath='../../module/zcommon/zpool_prop.c' line='183' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_setonce'>
	- <parameter type-id='type-id-209' name='prop' filepath='../../module/zcommon/zpool_prop.c' line='256' column='1'/>
	+ <function-decl name='zpool_prop_setonce' mangled-name='zpool_prop_setonce' filepath='../../module/zcommon/zpool_prop.c' line='184' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_setonce'>
	+ <parameter type-id='type-id-209' name='prop' filepath='../../module/zcommon/zpool_prop.c' line='257' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	- <function-decl name='zpool_prop_readonly' mangled-name='zpool_prop_readonly' filepath='../../module/zcommon/zpool_prop.c' line='177' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_readonly'>
	- <parameter type-id='type-id-209' name='prop' filepath='../../module/zcommon/zpool_prop.c' line='256' column='1'/>
	+ <function-decl name='zpool_prop_readonly' mangled-name='zpool_prop_readonly' filepath='../../module/zcommon/zpool_prop.c' line='178' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_readonly'>
	+ <parameter type-id='type-id-209' name='prop' filepath='../../module/zcommon/zpool_prop.c' line='257' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	- <function-decl name='zpool_prop_get_type' mangled-name='zpool_prop_get_type' filepath='../../module/zcommon/zpool_prop.c' line='171' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_get_type'>
	- <parameter type-id='type-id-209' name='prop' filepath='../../module/zcommon/zpool_prop.c' line='171' column='1'/>
	+ <function-decl name='zpool_prop_get_type' mangled-name='zpool_prop_get_type' filepath='../../module/zcommon/zpool_prop.c' line='172' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_get_type'>
	+ <parameter type-id='type-id-209' name='prop' filepath='../../module/zcommon/zpool_prop.c' line='172' column='1'/>
	<return type-id='type-id-355'/>
	</function-decl>
	- <function-decl name='zpool_prop_to_name' mangled-name='zpool_prop_to_name' filepath='../../module/zcommon/zpool_prop.c' line='165' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_to_name'>
	- <parameter type-id='type-id-209' name='prop' filepath='../../module/zcommon/zpool_prop.c' line='250' column='1'/>
	+ <function-decl name='zpool_prop_to_name' mangled-name='zpool_prop_to_name' filepath='../../module/zcommon/zpool_prop.c' line='166' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_to_name'>
	+ <parameter type-id='type-id-209' name='prop' filepath='../../module/zcommon/zpool_prop.c' line='251' column='1'/>
	<return type-id='type-id-104'/>
	</function-decl>
	- <function-decl name='zpool_name_to_prop' mangled-name='zpool_name_to_prop' filepath='../../module/zcommon/zpool_prop.c' line='155' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_name_to_prop'>
	- <parameter type-id='type-id-104' name='propname' filepath='../../module/zcommon/zpool_prop.c' line='155' column='1'/>
	+ <function-decl name='zpool_name_to_prop' mangled-name='zpool_name_to_prop' filepath='../../module/zcommon/zpool_prop.c' line='156' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_name_to_prop'>
	+ <parameter type-id='type-id-104' name='propname' filepath='../../module/zcommon/zpool_prop.c' line='156' column='1'/>
	<return type-id='type-id-209'/>
	</function-decl>
	<function-decl name='zpool_prop_get_table' mangled-name='zpool_prop_get_table' filepath='../../module/zcommon/zpool_prop.c' line='45' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zpool_prop_get_table'>
	<return type-id='type-id-365'/>
	</function-decl>
	</abi-instr>
	<abi-instr version='1.0' address-size='64' path='../../module/zcommon/zprop_common.c' comp-dir-path='/home/colm/src/zfs/zfs/lib/libzfs' language='LANG_C99'>
	<function-decl name='zprop_width' mangled-name='zprop_width' filepath='../../module/zcommon/zprop_common.c' line='401' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_width'>
	<parameter type-id='type-id-6' name='prop' filepath='../../module/zcommon/zprop_common.c' line='401' column='1'/>
	<parameter type-id='type-id-114' name='fixed' filepath='../../module/zcommon/zprop_common.c' line='401' column='1'/>
	<parameter type-id='type-id-20' name='type' filepath='../../module/zcommon/zprop_common.c' line='401' column='1'/>
	<return type-id='type-id-43'/>
	</function-decl>
	<function-decl name='zprop_valid_for_type' mangled-name='zprop_valid_for_type' filepath='../../module/zcommon/zprop_common.c' line='380' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_valid_for_type'>
	<parameter type-id='type-id-6' name='prop' filepath='../../module/zcommon/zprop_common.c' line='380' column='1'/>
	<parameter type-id='type-id-20' name='type' filepath='../../module/zcommon/zprop_common.c' line='380' column='1'/>
	<parameter type-id='type-id-5' name='headcheck' filepath='../../module/zcommon/zprop_common.c' line='380' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	<function-decl name='zprop_values' mangled-name='zprop_values' filepath='../../module/zcommon/zprop_common.c' line='360' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_values'>
	<parameter type-id='type-id-6' name='prop' filepath='../../module/zcommon/zprop_common.c' line='360' column='1'/>
	<parameter type-id='type-id-20' name='type' filepath='../../module/zcommon/zprop_common.c' line='360' column='1'/>
	<return type-id='type-id-104'/>
	</function-decl>
	<function-decl name='zprop_random_value' mangled-name='zprop_random_value' filepath='../../module/zcommon/zprop_common.c' line='344' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_random_value'>
	<parameter type-id='type-id-6' name='prop' filepath='../../module/zcommon/zprop_common.c' line='344' column='1'/>
	<parameter type-id='type-id-27' name='seed' filepath='../../module/zcommon/zprop_common.c' line='344' column='1'/>
	<parameter type-id='type-id-20' name='type' filepath='../../module/zcommon/zprop_common.c' line='344' column='1'/>
	<return type-id='type-id-27'/>
	</function-decl>
	<function-decl name='zprop_index_to_string' mangled-name='zprop_index_to_string' filepath='../../module/zcommon/zprop_common.c' line='315' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_index_to_string'>
	<parameter type-id='type-id-6' name='prop' filepath='../../module/zcommon/zprop_common.c' line='315' column='1'/>
	<parameter type-id='type-id-27' name='index' filepath='../../module/zcommon/zprop_common.c' line='315' column='1'/>
	<parameter type-id='type-id-356' name='string' filepath='../../module/zcommon/zprop_common.c' line='315' column='1'/>
	<parameter type-id='type-id-20' name='type' filepath='../../module/zcommon/zprop_common.c' line='316' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zprop_string_to_index' mangled-name='zprop_string_to_index' filepath='../../module/zcommon/zprop_common.c' line='289' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_string_to_index'>
	<parameter type-id='type-id-6' name='prop' filepath='../../module/zcommon/zprop_common.c' line='289' column='1'/>
	<parameter type-id='type-id-104' name='string' filepath='../../module/zcommon/zprop_common.c' line='289' column='1'/>
	<parameter type-id='type-id-137' name='index' filepath='../../module/zcommon/zprop_common.c' line='289' column='1'/>
	<parameter type-id='type-id-20' name='type' filepath='../../module/zcommon/zprop_common.c' line='290' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zprop_name_to_prop' mangled-name='zprop_name_to_prop' filepath='../../module/zcommon/zprop_common.c' line='274' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_name_to_prop'>
	<parameter type-id='type-id-104' name='propname' filepath='../../module/zcommon/zprop_common.c' line='274' column='1'/>
	<parameter type-id='type-id-20' name='type' filepath='../../module/zcommon/zprop_common.c' line='274' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zprop_iter_common' mangled-name='zprop_iter_common' filepath='../../module/zcommon/zprop_common.c' line='185' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_iter_common'>
	<parameter type-id='type-id-229' name='func' filepath='../../module/zcommon/zprop_common.c' line='185' column='1'/>
	<parameter type-id='type-id-42' name='cb' filepath='../../module/zcommon/zprop_common.c' line='185' column='1'/>
	<parameter type-id='type-id-5' name='show_all' filepath='../../module/zcommon/zprop_common.c' line='185' column='1'/>
	<parameter type-id='type-id-5' name='ordered' filepath='../../module/zcommon/zprop_common.c' line='186' column='1'/>
	<parameter type-id='type-id-20' name='type' filepath='../../module/zcommon/zprop_common.c' line='186' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='zprop_register_hidden' mangled-name='zprop_register_hidden' filepath='../../module/zcommon/zprop_common.c' line='150' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_register_hidden'>
	<parameter type-id='type-id-6' name='prop' filepath='../../module/zcommon/zprop_common.c' line='150' column='1'/>
	<parameter type-id='type-id-104' name='name' filepath='../../module/zcommon/zprop_common.c' line='150' column='1'/>
	<parameter type-id='type-id-355' name='type' filepath='../../module/zcommon/zprop_common.c' line='150' column='1'/>
	<parameter type-id='type-id-359' name='attr' filepath='../../module/zcommon/zprop_common.c' line='151' column='1'/>
	<parameter type-id='type-id-6' name='objset_types' filepath='../../module/zcommon/zprop_common.c' line='151' column='1'/>
	<parameter type-id='type-id-104' name='colname' filepath='../../module/zcommon/zprop_common.c' line='151' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zprop_register_index' mangled-name='zprop_register_index' filepath='../../module/zcommon/zprop_common.c' line='141' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_register_index'>
	<parameter type-id='type-id-6' name='prop' filepath='../../module/zcommon/zprop_common.c' line='141' column='1'/>
	<parameter type-id='type-id-104' name='name' filepath='../../module/zcommon/zprop_common.c' line='141' column='1'/>
	<parameter type-id='type-id-27' name='def' filepath='../../module/zcommon/zprop_common.c' line='141' column='1'/>
	<parameter type-id='type-id-359' name='attr' filepath='../../module/zcommon/zprop_common.c' line='142' column='1'/>
	<parameter type-id='type-id-6' name='objset_types' filepath='../../module/zcommon/zprop_common.c' line='142' column='1'/>
	<parameter type-id='type-id-104' name='values' filepath='../../module/zcommon/zprop_common.c' line='142' column='1'/>
	<parameter type-id='type-id-104' name='colname' filepath='../../module/zcommon/zprop_common.c' line='143' column='1'/>
	<parameter type-id='type-id-360' name='idx_tbl' filepath='../../module/zcommon/zprop_common.c' line='143' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zprop_register_number' mangled-name='zprop_register_number' filepath='../../module/zcommon/zprop_common.c' line='132' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_register_number'>
	<parameter type-id='type-id-6' name='prop' filepath='../../module/zcommon/zprop_common.c' line='132' column='1'/>
	<parameter type-id='type-id-104' name='name' filepath='../../module/zcommon/zprop_common.c' line='132' column='1'/>
	<parameter type-id='type-id-27' name='def' filepath='../../module/zcommon/zprop_common.c' line='132' column='1'/>
	<parameter type-id='type-id-359' name='attr' filepath='../../module/zcommon/zprop_common.c' line='133' column='1'/>
	<parameter type-id='type-id-6' name='objset_types' filepath='../../module/zcommon/zprop_common.c' line='133' column='1'/>
	<parameter type-id='type-id-104' name='values' filepath='../../module/zcommon/zprop_common.c' line='133' column='1'/>
	<parameter type-id='type-id-104' name='colname' filepath='../../module/zcommon/zprop_common.c' line='134' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zprop_register_string' mangled-name='zprop_register_string' filepath='../../module/zcommon/zprop_common.c' line='122' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_register_string'>
	<parameter type-id='type-id-6' name='prop' filepath='../../module/zcommon/zprop_common.c' line='122' column='1'/>
	<parameter type-id='type-id-104' name='name' filepath='../../module/zcommon/zprop_common.c' line='122' column='1'/>
	<parameter type-id='type-id-104' name='def' filepath='../../module/zcommon/zprop_common.c' line='122' column='1'/>
	<parameter type-id='type-id-359' name='attr' filepath='../../module/zcommon/zprop_common.c' line='123' column='1'/>
	<parameter type-id='type-id-6' name='objset_types' filepath='../../module/zcommon/zprop_common.c' line='123' column='1'/>
	<parameter type-id='type-id-104' name='values' filepath='../../module/zcommon/zprop_common.c' line='123' column='1'/>
	<parameter type-id='type-id-104' name='colname' filepath='../../module/zcommon/zprop_common.c' line='124' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zprop_register_impl' mangled-name='zprop_register_impl' filepath='../../module/zcommon/zprop_common.c' line='89' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='zprop_register_impl'>
	<parameter type-id='type-id-6' name='prop' filepath='../../module/zcommon/zprop_common.c' line='89' column='1'/>
	<parameter type-id='type-id-104' name='name' filepath='../../module/zcommon/zprop_common.c' line='89' column='1'/>
	<parameter type-id='type-id-355' name='type' filepath='../../module/zcommon/zprop_common.c' line='89' column='1'/>
	<parameter type-id='type-id-27' name='numdefault' filepath='../../module/zcommon/zprop_common.c' line='90' column='1'/>
	<parameter type-id='type-id-104' name='strdefault' filepath='../../module/zcommon/zprop_common.c' line='90' column='1'/>
	<parameter type-id='type-id-359' name='attr' filepath='../../module/zcommon/zprop_common.c' line='90' column='1'/>
	<parameter type-id='type-id-6' name='objset_types' filepath='../../module/zcommon/zprop_common.c' line='91' column='1'/>
	<parameter type-id='type-id-104' name='values' filepath='../../module/zcommon/zprop_common.c' line='91' column='1'/>
	<parameter type-id='type-id-104' name='colname' filepath='../../module/zcommon/zprop_common.c' line='91' column='1'/>
	<parameter type-id='type-id-5' name='rightalign' filepath='../../module/zcommon/zprop_common.c' line='92' column='1'/>
	<parameter type-id='type-id-5' name='visible' filepath='../../module/zcommon/zprop_common.c' line='92' column='1'/>
	<parameter type-id='type-id-360' name='idx_tbl' filepath='../../module/zcommon/zprop_common.c' line='92' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='__ctype_tolower_loc' mangled-name='__ctype_tolower_loc' filepath='/usr/include/ctype.h' line='81' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='zfs_mod_supported' mangled-name='zfs_mod_supported' filepath='../../include/sys/zfs_sysfs.h' line='38' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	</abi-instr>
	<abi-instr version='1.0' address-size='64' path='libshare.c' comp-dir-path='/home/colm/src/zfs/zfs/lib/libshare' language='LANG_C99'>
	<function-decl name='sa_validate_shareopts' mangled-name='sa_validate_shareopts' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare.c' line='299' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='sa_validate_shareopts'>
	<parameter type-id='type-id-23' name='options' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare.c' line='299' column='1'/>
	<parameter type-id='type-id-23' name='proto' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare.c' line='299' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='sa_errorstr' mangled-name='sa_errorstr' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare.c' line='182' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='sa_errorstr'>
	<parameter type-id='type-id-6' name='err' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare.c' line='182' column='1'/>
	<return type-id='type-id-23'/>
	</function-decl>
	<function-decl name='sa_commit_shares' mangled-name='sa_commit_shares' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare.c' line='166' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='sa_commit_shares'>
	<parameter type-id='type-id-104' name='protocol' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare.c' line='166' column='1'/>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='sa_is_shared' mangled-name='sa_is_shared' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare.c' line='144' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='sa_is_shared'>
	<parameter type-id='type-id-104' name='mountpoint' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare.c' line='144' column='1'/>
	<parameter type-id='type-id-23' name='protocol' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare.c' line='144' column='1'/>
	<return type-id='type-id-5'/>
	</function-decl>
	<function-decl name='sa_disable_share' mangled-name='sa_disable_share' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare.c' line='115' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='sa_disable_share'>
	<parameter type-id='type-id-104' name='mountpoint' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare.c' line='115' column='1'/>
	<parameter type-id='type-id-23' name='protocol' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare.c' line='115' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<function-decl name='sa_enable_share' mangled-name='sa_enable_share' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare.c' line='80' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='sa_enable_share'>
	<parameter type-id='type-id-104' name='zfsname' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare.c' line='80' column='1'/>
	<parameter type-id='type-id-104' name='mountpoint' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare.c' line='80' column='1'/>
	<parameter type-id='type-id-104' name='shareopts' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare.c' line='81' column='1'/>
	<parameter type-id='type-id-23' name='protocol' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare.c' line='81' column='1'/>
	<return type-id='type-id-6'/>
	</function-decl>
	<class-decl name='sa_fstype' size-in-bits='256' is-struct='yes' visibility='default' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare_impl.h' line='53' column='1' id='type-id-366'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='next' type-id='type-id-367' visibility='default' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare_impl.h' line='54' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='name' type-id='type-id-104' visibility='default' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare_impl.h' line='56' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='ops' type-id='type-id-368' visibility='default' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare_impl.h' line='57' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='fsinfo_index' type-id='type-id-6' visibility='default' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare_impl.h' line='58' column='1'/>
	</data-member>
	</class-decl>
	<pointer-type-def type-id='type-id-366' size-in-bits='64' id='type-id-367'/>
	<class-decl name='sa_share_ops' size-in-bits='448' is-struct='yes' visibility='default' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare_impl.h' line='42' column='1' id='type-id-369'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='enable_share' type-id='type-id-370' visibility='default' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare_impl.h' line='43' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='disable_share' type-id='type-id-370' visibility='default' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare_impl.h' line='44' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='is_shared' type-id='type-id-371' visibility='default' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare_impl.h' line='45' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='192'>
	<var-decl name='validate_shareopts' type-id='type-id-372' visibility='default' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare_impl.h' line='46' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='256'>
	<var-decl name='update_shareopts' type-id='type-id-373' visibility='default' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare_impl.h' line='47' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='320'>
	<var-decl name='clear_shareopts' type-id='type-id-374' visibility='default' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare_impl.h' line='49' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='384'>
	<var-decl name='commit_shares' type-id='type-id-375' visibility='default' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare_impl.h' line='50' column='1'/>
	</data-member>
	</class-decl>
	<class-decl name='sa_share_impl' size-in-bits='192' is-struct='yes' visibility='default' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare_impl.h' line='32' column='1' id='type-id-376'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='sa_mountpoint' type-id='type-id-23' visibility='default' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare_impl.h' line='33' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='64'>
	<var-decl name='sa_zfsname' type-id='type-id-23' visibility='default' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare_impl.h' line='34' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='128'>
	<var-decl name='sa_fsinfo' type-id='type-id-377' visibility='default' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare_impl.h' line='36' column='1'/>
	</data-member>
	</class-decl>
	<class-decl name='sa_share_fsinfo' size-in-bits='64' is-struct='yes' visibility='default' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare_impl.h' line='28' column='1' id='type-id-378'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='shareopts' type-id='type-id-23' visibility='default' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare_impl.h' line='29' column='1'/>
	</data-member>
	</class-decl>
	<typedef-decl name='sa_share_fsinfo_t' type-id='type-id-378' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare_impl.h' line='30' column='1' id='type-id-379'/>
	<pointer-type-def type-id='type-id-379' size-in-bits='64' id='type-id-377'/>
	<pointer-type-def type-id='type-id-376' size-in-bits='64' id='type-id-380'/>
	<typedef-decl name='sa_share_impl_t' type-id='type-id-380' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare_impl.h' line='37' column='1' id='type-id-381'/>
	<pointer-type-def type-id='type-id-382' size-in-bits='64' id='type-id-370'/>
	<pointer-type-def type-id='type-id-383' size-in-bits='64' id='type-id-371'/>
	<pointer-type-def type-id='type-id-384' size-in-bits='64' id='type-id-372'/>
	<pointer-type-def type-id='type-id-385' size-in-bits='64' id='type-id-373'/>
	<pointer-type-def type-id='type-id-386' size-in-bits='64' id='type-id-374'/>
	<pointer-type-def type-id='type-id-387' size-in-bits='64' id='type-id-375'/>
	<typedef-decl name='sa_share_ops_t' type-id='type-id-369' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare_impl.h' line='51' column='1' id='type-id-388'/>
	<qualified-type-def type-id='type-id-388' const='yes' id='type-id-389'/>
	<pointer-type-def type-id='type-id-389' size-in-bits='64' id='type-id-368'/>
	<typedef-decl name='sa_fstype_t' type-id='type-id-366' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare_impl.h' line='59' column='1' id='type-id-390'/>
	<pointer-type-def type-id='type-id-390' size-in-bits='64' id='type-id-391'/>
	<function-decl name='register_fstype' mangled-name='register_fstype' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare.c' line='51' column='1' visibility='default' binding='global' size-in-bits='64' elf-symbol-id='register_fstype'>
	<parameter type-id='type-id-104' name='name' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare.c' line='51' column='1'/>
	<parameter type-id='type-id-368' name='ops' filepath='/home/colm/src/zfs/zfs/lib/libshare/libshare.c' line='51' column='1'/>
	<return type-id='type-id-391'/>
	</function-decl>
	<function-decl name='libshare_nfs_init' mangled-name='libshare_nfs_init' filepath='/home/colm/src/zfs/zfs/lib/libshare/nfs.h' line='27' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='libshare_smb_init' mangled-name='libshare_smb_init' filepath='/home/colm/src/zfs/zfs/lib/libshare/smb.h' line='49' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-type size-in-bits='64' id='type-id-387'>
	<return type-id='type-id-6'/>
	</function-type>
	<function-type size-in-bits='64' id='type-id-384'>
	<parameter type-id='type-id-104'/>
	<return type-id='type-id-6'/>
	</function-type>
	<function-type size-in-bits='64' id='type-id-382'>
	<parameter type-id='type-id-381'/>
	<return type-id='type-id-6'/>
	</function-type>
	<function-type size-in-bits='64' id='type-id-385'>
	<parameter type-id='type-id-381'/>
	<parameter type-id='type-id-104'/>
	<return type-id='type-id-6'/>
	</function-type>
	<function-type size-in-bits='64' id='type-id-383'>
	<parameter type-id='type-id-381'/>
	<return type-id='type-id-5'/>
	</function-type>
	<function-type size-in-bits='64' id='type-id-386'>
	<parameter type-id='type-id-381'/>
	<return type-id='type-id-52'/>
	</function-type>
	</abi-instr>
	<abi-instr version='1.0' address-size='64' path='os/linux/nfs.c' comp-dir-path='/home/colm/src/zfs/zfs/lib/libshare' language='LANG_C99'>
	<function-decl name='register_fstype' mangled-name='register_fstype' filepath='./libshare_impl.h' line='61' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='unlink' mangled-name='unlink' filepath='/usr/include/unistd.h' line='825' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fputs' mangled-name='fputs' filepath='/usr/include/stdio.h' line='632' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='mkstemp' mangled-name='mkstemp64' filepath='/usr/include/stdlib.h' line='688' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='mkdir' mangled-name='mkdir' filepath='/usr/include/x86_64-linux-gnu/sys/stat.h' line='317' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='__builtin_stpcpy' mangled-name='stpcpy' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='flock' mangled-name='flock' filepath='/usr/include/x86_64-linux-gnu/sys/file.h' line='51' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='rename' mangled-name='rename' filepath='/usr/include/stdio.h' line='148' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	</abi-instr>
	<abi-instr version='1.0' address-size='64' path='os/linux/smb.c' comp-dir-path='/home/colm/src/zfs/zfs/lib/libshare' language='LANG_C99'>
	<class-decl name='smb_share_s' size-in-bits='36992' is-struct='yes' visibility='default' filepath='./smb.h' line='38' column='1' id='type-id-392'>
	<data-member access='public' layout-offset-in-bits='0'>
	<var-decl name='name' type-id='type-id-393' visibility='default' filepath='./smb.h' line='39' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='2040'>
	<var-decl name='path' type-id='type-id-143' visibility='default' filepath='./smb.h' line='40' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='34808'>
	<var-decl name='comment' type-id='type-id-393' visibility='default' filepath='./smb.h' line='41' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='36864'>
	<var-decl name='guest_ok' type-id='type-id-5' visibility='default' filepath='./smb.h' line='42' column='1'/>
	</data-member>
	<data-member access='public' layout-offset-in-bits='36928'>
	<var-decl name='next' type-id='type-id-394' visibility='default' filepath='./smb.h' line='44' column='1'/>
	</data-member>
	</class-decl>

	<array-type-def dimensions='1' type-id='type-id-45' size-in-bits='2040' id='type-id-393'>
	<subrange length='255' type-id='type-id-48' id='type-id-395'/>

	</array-type-def>
	<pointer-type-def type-id='type-id-392' size-in-bits='64' id='type-id-394'/>
	<typedef-decl name='smb_share_t' type-id='type-id-392' filepath='./smb.h' line='45' column='1' id='type-id-396'/>
	<pointer-type-def type-id='type-id-396' size-in-bits='64' id='type-id-397'/>
	<var-decl name='smb_shares' type-id='type-id-397' mangled-name='smb_shares' visibility='default' filepath='./smb.h' line='47' column='1' elf-symbol-id='smb_shares'/>
	<function-decl name='opendir' mangled-name='opendir' filepath='/usr/include/dirent.h' line='134' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	<function-decl name='fgets' mangled-name='fgets' filepath='/usr/include/stdio.h' line='570' column='1' visibility='default' binding='global' size-in-bits='64'>
	<return type-id='type-id-52'/>
	</function-decl>
	</abi-instr>
	</abi-corpus>
	diff --git a/sys/contrib/openzfs/lib/libzfs/libzfs_crypto.c b/sys/contrib/openzfs/lib/libzfs/libzfs_crypto.c
	index fe3a0f28360e..5fb93d265965 100644
	--- a/sys/contrib/openzfs/lib/libzfs/libzfs_crypto.c
	+++ b/sys/contrib/openzfs/lib/libzfs/libzfs_crypto.c
	@@ -1,1625 +1,1619 @@
	/*
	* CDDL HEADER START
	*
	* This file and its contents are supplied under the terms of the
	* Common Development and Distribution License ("CDDL"), version 1.0.
	* You may only use this file in accordance with the terms of version
	* 1.0 of the CDDL.
	*
	* A full copy of the text of the CDDL should have accompanied this
	* source. A copy of the CDDL is also available via the Internet at
	* http://www.illumos.org/license/CDDL.
	*
	* CDDL HEADER END
	*/

	/*
	* Copyright (c) 2017, Datto, Inc. All rights reserved.
	* Copyright 2020 Joyent, Inc.
	*/

	#include <sys/zfs_context.h>
	#include <sys/fs/zfs.h>
	#include <sys/dsl_crypt.h>
	#include <libintl.h>
	#include <termios.h>
	#include <signal.h>
	#include <errno.h>
	#include <openssl/evp.h>
	#include <libzfs.h>
	#include "libzfs_impl.h"
	#include "zfeature_common.h"

	/*
	* User keys are used to decrypt the master encryption keys of a dataset. This
	* indirection allows a user to change his / her access key without having to
	* re-encrypt the entire dataset. User keys can be provided in one of several
	* ways. Raw keys are simply given to the kernel as is. Similarly, hex keys
	* are converted to binary and passed into the kernel. Password based keys are
	* a bit more complicated. Passwords alone do not provide suitable entropy for
	* encryption and may be too short or too long to be used. In order to derive
	* a more appropriate key we use a PBKDF2 function. This function is designed
	* to take a (relatively) long time to calculate in order to discourage
	* attackers from guessing from a list of common passwords. PBKDF2 requires
	* 2 additional parameters. The first is the number of iterations to run, which
	* will ultimately determine how long it takes to derive the resulting key from
	* the password. The second parameter is a salt that is randomly generated for
	* each dataset. The salt is used to "tweak" PBKDF2 such that a group of
	* attackers cannot reasonably generate a table of commonly known passwords to
	* their output keys and expect it work for all past and future PBKDF2 users.
	* We store the salt as a hidden property of the dataset (although it is
	* technically ok if the salt is known to the attacker).
	*/

	-typedef enum key_locator {
	- KEY_LOCATOR_NONE,
	- KEY_LOCATOR_PROMPT,
	- KEY_LOCATOR_URI
	-} key_locator_t;
	-
	#define MIN_PASSPHRASE_LEN 8
	#define MAX_PASSPHRASE_LEN 512
	#define MAX_KEY_PROMPT_ATTEMPTS 3

	static int caught_interrupt;

	static int get_key_material_file(libzfs_handle_t , const char , const char *,
	zfs_keyformat_t, boolean_t, uint8_t *, size_t );

	static zfs_uri_handler_t uri_handlers[] = {
	{ "file", get_key_material_file },
	{ NULL, NULL }
	};

	static int
	pkcs11_get_urandom(uint8_t *buf, size_t bytes)
	{
	int rand;
	ssize_t bytes_read = 0;

	- rand = open("/dev/urandom", O_RDONLY);
	+ rand = open("/dev/urandom", O_RDONLY \| O_CLOEXEC);

	if (rand < 0)
	return (rand);

	while (bytes_read < bytes) {
	ssize_t rc = read(rand, buf + bytes_read, bytes - bytes_read);
	if (rc < 0)
	break;
	bytes_read += rc;
	}

	(void) close(rand);

	return (bytes_read);
	}

	static int
	zfs_prop_parse_keylocation(libzfs_handle_t restrict hdl, const char str,
	zfs_keylocation_t restrict locp, char *restrict schemep)
	{
	*locp = ZFS_KEYLOCATION_NONE;
	*schemep = NULL;

	if (strcmp("prompt", str) == 0) {
	*locp = ZFS_KEYLOCATION_PROMPT;
	return (0);
	}

	regmatch_t pmatch[2];

	if (regexec(&hdl->libzfs_urire, str, ARRAY_SIZE(pmatch),
	pmatch, 0) == 0) {
	size_t scheme_len;

	if (pmatch[1].rm_so == -1) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"Invalid URI"));
	return (EINVAL);
	}

	scheme_len = pmatch[1].rm_eo - pmatch[1].rm_so;

	*schemep = calloc(1, scheme_len + 1);
	if (*schemep == NULL) {
	int ret = errno;

	errno = 0;
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"Invalid URI"));
	return (ret);
	}

	(void) memcpy(*schemep, str + pmatch[1].rm_so, scheme_len);
	*locp = ZFS_KEYLOCATION_URI;
	return (0);
	}

	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "Invalid keylocation"));
	return (EINVAL);
	}

	static int
	hex_key_to_raw(char hex, int hexlen, uint8_t out)
	{
	int ret, i;
	unsigned int c;

	for (i = 0; i < hexlen; i += 2) {
	if (!isxdigit(hex[i]) \|\| !isxdigit(hex[i + 1])) {
	ret = EINVAL;
	goto error;
	}

	ret = sscanf(&hex[i], "%02x", &c);
	if (ret != 1) {
	ret = EINVAL;
	goto error;
	}

	out[i / 2] = c;
	}

	return (0);

	error:
	return (ret);
	}


	static void
	catch_signal(int sig)
	{
	caught_interrupt = sig;
	}

	static const char *
	get_format_prompt_string(zfs_keyformat_t format)
	{
	switch (format) {
	case ZFS_KEYFORMAT_RAW:
	return ("raw key");
	case ZFS_KEYFORMAT_HEX:
	return ("hex key");
	case ZFS_KEYFORMAT_PASSPHRASE:
	return ("passphrase");
	default:
	/* shouldn't happen */
	return (NULL);
	}
	}

	/* do basic validation of the key material */
	static int
	validate_key(libzfs_handle_t *hdl, zfs_keyformat_t keyformat,
	const char *key, size_t keylen)
	{
	switch (keyformat) {
	case ZFS_KEYFORMAT_RAW:
	/* verify the key length is correct */
	if (keylen < WRAPPING_KEY_LEN) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"Raw key too short (expected %u)."),
	WRAPPING_KEY_LEN);
	return (EINVAL);
	}

	if (keylen > WRAPPING_KEY_LEN) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"Raw key too long (expected %u)."),
	WRAPPING_KEY_LEN);
	return (EINVAL);
	}
	break;
	case ZFS_KEYFORMAT_HEX:
	/* verify the key length is correct */
	if (keylen < WRAPPING_KEY_LEN * 2) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"Hex key too short (expected %u)."),
	WRAPPING_KEY_LEN * 2);
	return (EINVAL);
	}

	if (keylen > WRAPPING_KEY_LEN * 2) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"Hex key too long (expected %u)."),
	WRAPPING_KEY_LEN * 2);
	return (EINVAL);
	}

	/* check for invalid hex digits */
	for (size_t i = 0; i < WRAPPING_KEY_LEN * 2; i++) {
	if (!isxdigit(key[i])) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"Invalid hex character detected."));
	return (EINVAL);
	}
	}
	break;
	case ZFS_KEYFORMAT_PASSPHRASE:
	/* verify the length is within bounds */
	if (keylen > MAX_PASSPHRASE_LEN) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"Passphrase too long (max %u)."),
	MAX_PASSPHRASE_LEN);
	return (EINVAL);
	}

	if (keylen < MIN_PASSPHRASE_LEN) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"Passphrase too short (min %u)."),
	MIN_PASSPHRASE_LEN);
	return (EINVAL);
	}
	break;
	default:
	/* can't happen, checked above */
	break;
	}

	return (0);
	}

	static int
	libzfs_getpassphrase(zfs_keyformat_t keyformat, boolean_t is_reenter,
	boolean_t new_key, const char *fsname,
	char *restrict res, size_t restrict reslen)
	{
	FILE *f = stdin;
	size_t buflen = 0;
	ssize_t bytes;
	int ret = 0;
	struct termios old_term, new_term;
	struct sigaction act, osigint, osigtstp;

	*res = NULL;
	*reslen = 0;

	/*
	* handle SIGINT and ignore SIGSTP. This is necessary to
	* restore the state of the terminal.
	*/
	caught_interrupt = 0;
	act.sa_flags = 0;
	(void) sigemptyset(&act.sa_mask);
	act.sa_handler = catch_signal;

	(void) sigaction(SIGINT, &act, &osigint);
	act.sa_handler = SIG_IGN;
	(void) sigaction(SIGTSTP, &act, &osigtstp);

	(void) printf("%s %s%s",
	is_reenter ? "Re-enter" : "Enter",
	new_key ? "new " : "",
	get_format_prompt_string(keyformat));
	if (fsname != NULL)
	(void) printf(" for '%s'", fsname);
	(void) fputc(':', stdout);
	(void) fflush(stdout);

	/* disable the terminal echo for key input */
	(void) tcgetattr(fileno(f), &old_term);

	new_term = old_term;
	new_term.c_lflag &= ~(ECHO \| ECHOE \| ECHOK \| ECHONL);

	ret = tcsetattr(fileno(f), TCSAFLUSH, &new_term);
	if (ret != 0) {
	ret = errno;
	errno = 0;
	goto out;
	}

	bytes = getline(res, &buflen, f);
	if (bytes < 0) {
	ret = errno;
	errno = 0;
	goto out;
	}

	/* trim the ending newline if it exists */
	if (bytes > 0 && (*res)[bytes - 1] == '\n') {
	(*res)[bytes - 1] = '\0';
	bytes--;
	}

	*reslen = bytes;

	out:
	/* reset the terminal */
	(void) tcsetattr(fileno(f), TCSAFLUSH, &old_term);
	(void) sigaction(SIGINT, &osigint, NULL);
	(void) sigaction(SIGTSTP, &osigtstp, NULL);

	/* if we caught a signal, re-throw it now */
	if (caught_interrupt != 0)
	(void) kill(getpid(), caught_interrupt);

	/* print the newline that was not echo'd */
	(void) printf("\n");

	return (ret);
	}

	static int
	get_key_interactive(libzfs_handle_t restrict hdl, const char fsname,
	zfs_keyformat_t keyformat, boolean_t confirm_key, boolean_t newkey,
	uint8_t *restrict outbuf, size_t restrict len_out)
	{
	char buf = NULL, buf2 = NULL;
	size_t buflen = 0, buf2len = 0;
	int ret = 0;

	ASSERT(isatty(fileno(stdin)));

	/* raw keys cannot be entered on the terminal */
	if (keyformat == ZFS_KEYFORMAT_RAW) {
	ret = EINVAL;
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"Cannot enter raw keys on the terminal"));
	goto out;
	}

	/* prompt for the key */
	if ((ret = libzfs_getpassphrase(keyformat, B_FALSE, newkey, fsname,
	&buf, &buflen)) != 0) {
	free(buf);
	buf = NULL;
	buflen = 0;
	goto out;
	}

	if (!confirm_key)
	goto out;

	if ((ret = validate_key(hdl, keyformat, buf, buflen)) != 0) {
	free(buf);
	return (ret);
	}

	ret = libzfs_getpassphrase(keyformat, B_TRUE, newkey, fsname, &buf2,
	&buf2len);
	if (ret != 0) {
	free(buf);
	free(buf2);
	buf = buf2 = NULL;
	buflen = buf2len = 0;
	goto out;
	}

	if (buflen != buf2len \|\| strcmp(buf, buf2) != 0) {
	free(buf);
	buf = NULL;
	buflen = 0;

	ret = EINVAL;
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"Provided keys do not match."));
	}

	free(buf2);

	out:
	outbuf = (uint8_t )buf;
	*len_out = buflen;
	return (ret);
	}

	static int
	get_key_material_raw(FILE *fd, zfs_keyformat_t keyformat,
	uint8_t *buf, size_t len_out)
	{
	int ret = 0;
	size_t buflen = 0;

	*len_out = 0;

	/* read the key material */
	if (keyformat != ZFS_KEYFORMAT_RAW) {
	ssize_t bytes;

	bytes = getline((char **)buf, &buflen, fd);
	if (bytes < 0) {
	ret = errno;
	errno = 0;
	goto out;
	}

	/* trim the ending newline if it exists */
	if (bytes > 0 && (*buf)[bytes - 1] == '\n') {
	(*buf)[bytes - 1] = '\0';
	bytes--;
	}

	*len_out = bytes;
	} else {
	size_t n;

	/*
	* Raw keys may have newline characters in them and so can't
	* use getline(). Here we attempt to read 33 bytes so that we
	* can properly check the key length (the file should only have
	* 32 bytes).
	*/
	buf = malloc((WRAPPING_KEY_LEN + 1) sizeof (uint8_t));
	if (*buf == NULL) {
	ret = ENOMEM;
	goto out;
	}

	n = fread(*buf, 1, WRAPPING_KEY_LEN + 1, fd);
	if (n == 0 \|\| ferror(fd)) {
	/* size errors are handled by the calling function */
	free(*buf);
	*buf = NULL;
	ret = errno;
	errno = 0;
	goto out;
	}

	*len_out = n;
	}
	out:
	return (ret);
	}

	static int
	get_key_material_file(libzfs_handle_t hdl, const char uri,
	const char *fsname, zfs_keyformat_t keyformat, boolean_t newkey,
	uint8_t *restrict buf, size_t restrict len_out)
	{
	FILE *f = NULL;
	int ret = 0;

	if (strlen(uri) < 7)
	return (EINVAL);

	- if ((f = fopen(uri + 7, "r")) == NULL) {
	+ if ((f = fopen(uri + 7, "re")) == NULL) {
	ret = errno;
	errno = 0;
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"Failed to open key material file"));
	return (ret);
	}

	ret = get_key_material_raw(f, keyformat, buf, len_out);

	(void) fclose(f);

	return (ret);
	}

	/*
	* Attempts to fetch key material, no matter where it might live. The key
	* material is allocated and returned in km_out. *can_retry_out will be set
	* to B_TRUE if the user is providing the key material interactively, allowing
	* for re-entry attempts.
	*/
	static int
	get_key_material(libzfs_handle_t *hdl, boolean_t do_verify, boolean_t newkey,
	zfs_keyformat_t keyformat, char keylocation, const char fsname,
	uint8_t *km_out, size_t kmlen_out, boolean_t *can_retry_out)
	{
	int ret;
	zfs_keylocation_t keyloc = ZFS_KEYLOCATION_NONE;
	uint8_t *km = NULL;
	size_t kmlen = 0;
	char *uri_scheme = NULL;
	zfs_uri_handler_t *handler = NULL;
	boolean_t can_retry = B_FALSE;

	/* verify and parse the keylocation */
	ret = zfs_prop_parse_keylocation(hdl, keylocation, &keyloc,
	&uri_scheme);
	if (ret != 0)
	goto error;

	/* open the appropriate file descriptor */
	switch (keyloc) {
	case ZFS_KEYLOCATION_PROMPT:
	if (isatty(fileno(stdin))) {
	- can_retry = B_TRUE;
	+ can_retry = keyformat != ZFS_KEYFORMAT_RAW;
	ret = get_key_interactive(hdl, fsname, keyformat,
	do_verify, newkey, &km, &kmlen);
	} else {
	/* fetch the key material into the buffer */
	ret = get_key_material_raw(stdin, keyformat, &km,
	&kmlen);
	}

	if (ret != 0)
	goto error;

	break;
	case ZFS_KEYLOCATION_URI:
	ret = ENOTSUP;

	for (handler = uri_handlers; handler->zuh_scheme != NULL;
	handler++) {
	if (strcmp(handler->zuh_scheme, uri_scheme) != 0)
	continue;

	if ((ret = handler->zuh_handler(hdl, keylocation,
	fsname, keyformat, newkey, &km, &kmlen)) != 0)
	goto error;

	break;
	}

	if (ret == ENOTSUP) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"URI scheme is not supported"));
	goto error;
	}

	break;
	default:
	ret = EINVAL;
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"Invalid keylocation."));
	goto error;
	}

	if ((ret = validate_key(hdl, keyformat, (const char *)km, kmlen)) != 0)
	goto error;

	*km_out = km;
	*kmlen_out = kmlen;
	if (can_retry_out != NULL)
	*can_retry_out = can_retry;

	free(uri_scheme);
	return (0);

	error:
	free(km);

	*km_out = NULL;
	*kmlen_out = 0;

	if (can_retry_out != NULL)
	*can_retry_out = can_retry;

	free(uri_scheme);
	return (ret);
	}

	static int
	derive_key(libzfs_handle_t *hdl, zfs_keyformat_t format, uint64_t iters,
	uint8_t *key_material, size_t key_material_len, uint64_t salt,
	uint8_t **key_out)
	{
	int ret;
	uint8_t *key;

	*key_out = NULL;

	key = zfs_alloc(hdl, WRAPPING_KEY_LEN);
	if (!key)
	return (ENOMEM);

	switch (format) {
	case ZFS_KEYFORMAT_RAW:
	bcopy(key_material, key, WRAPPING_KEY_LEN);
	break;
	case ZFS_KEYFORMAT_HEX:
	ret = hex_key_to_raw((char *)key_material,
	WRAPPING_KEY_LEN * 2, key);
	if (ret != 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"Invalid hex key provided."));
	goto error;
	}
	break;
	case ZFS_KEYFORMAT_PASSPHRASE:
	salt = LE_64(salt);

	ret = PKCS5_PBKDF2_HMAC_SHA1((char *)key_material,
	strlen((char )key_material), ((uint8_t )&salt),
	sizeof (uint64_t), iters, WRAPPING_KEY_LEN, key);
	if (ret != 1) {
	ret = EIO;
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"Failed to generate key from passphrase."));
	goto error;
	}
	break;
	default:
	ret = EINVAL;
	goto error;
	}

	*key_out = key;
	return (0);

	error:
	free(key);

	*key_out = NULL;
	return (ret);
	}

	static boolean_t
	encryption_feature_is_enabled(zpool_handle_t *zph)
	{
	nvlist_t *features;
	uint64_t feat_refcount;

	/* check that features can be enabled */
	if (zpool_get_prop_int(zph, ZPOOL_PROP_VERSION, NULL)
	< SPA_VERSION_FEATURES)
	return (B_FALSE);

	/* check for crypto feature */
	features = zpool_get_features(zph);
	if (!features \|\| nvlist_lookup_uint64(features,
	spa_feature_table[SPA_FEATURE_ENCRYPTION].fi_guid,
	&feat_refcount) != 0)
	return (B_FALSE);

	return (B_TRUE);
	}

	static int
	populate_create_encryption_params_nvlists(libzfs_handle_t *hdl,
	zfs_handle_t *zhp, boolean_t newkey, zfs_keyformat_t keyformat,
	char keylocation, nvlist_t props, uint8_t *wkeydata, uint_t wkeylen)
	{
	int ret;
	uint64_t iters = 0, salt = 0;
	uint8_t *key_material = NULL;
	size_t key_material_len = 0;
	uint8_t *key_data = NULL;
	const char *fsname = (zhp) ? zfs_get_name(zhp) : NULL;

	/* get key material from keyformat and keylocation */
	ret = get_key_material(hdl, B_TRUE, newkey, keyformat, keylocation,
	fsname, &key_material, &key_material_len, NULL);
	if (ret != 0)
	goto error;

	/* passphrase formats require a salt and pbkdf2 iters property */
	if (keyformat == ZFS_KEYFORMAT_PASSPHRASE) {
	/* always generate a new salt */
	ret = pkcs11_get_urandom((uint8_t *)&salt, sizeof (uint64_t));
	if (ret != sizeof (uint64_t)) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"Failed to generate salt."));
	goto error;
	}

	ret = nvlist_add_uint64(props,
	zfs_prop_to_name(ZFS_PROP_PBKDF2_SALT), salt);
	if (ret != 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"Failed to add salt to properties."));
	goto error;
	}

	/*
	* If not otherwise specified, use the default number of
	* pbkdf2 iterations. If specified, we have already checked
	* that the given value is greater than MIN_PBKDF2_ITERATIONS
	* during zfs_valid_proplist().
	*/
	ret = nvlist_lookup_uint64(props,
	zfs_prop_to_name(ZFS_PROP_PBKDF2_ITERS), &iters);
	if (ret == ENOENT) {
	iters = DEFAULT_PBKDF2_ITERATIONS;
	ret = nvlist_add_uint64(props,
	zfs_prop_to_name(ZFS_PROP_PBKDF2_ITERS), iters);
	if (ret != 0)
	goto error;
	} else if (ret != 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"Failed to get pbkdf2 iterations."));
	goto error;
	}
	} else {
	/* check that pbkdf2iters was not specified by the user */
	ret = nvlist_lookup_uint64(props,
	zfs_prop_to_name(ZFS_PROP_PBKDF2_ITERS), &iters);
	if (ret == 0) {
	ret = EINVAL;
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"Cannot specify pbkdf2iters with a non-passphrase "
	"keyformat."));
	goto error;
	}
	}

	/* derive a key from the key material */
	ret = derive_key(hdl, keyformat, iters, key_material, key_material_len,
	salt, &key_data);
	if (ret != 0)
	goto error;

	free(key_material);

	*wkeydata = key_data;
	*wkeylen = WRAPPING_KEY_LEN;
	return (0);

	error:
	if (key_material != NULL)
	free(key_material);
	if (key_data != NULL)
	free(key_data);

	*wkeydata = NULL;
	*wkeylen = 0;
	return (ret);
	}

	static boolean_t
	proplist_has_encryption_props(nvlist_t *props)
	{
	int ret;
	uint64_t intval;
	char *strval;

	ret = nvlist_lookup_uint64(props,
	zfs_prop_to_name(ZFS_PROP_ENCRYPTION), &intval);
	if (ret == 0 && intval != ZIO_CRYPT_OFF)
	return (B_TRUE);

	ret = nvlist_lookup_string(props,
	zfs_prop_to_name(ZFS_PROP_KEYLOCATION), &strval);
	if (ret == 0 && strcmp(strval, "none") != 0)
	return (B_TRUE);

	ret = nvlist_lookup_uint64(props,
	zfs_prop_to_name(ZFS_PROP_KEYFORMAT), &intval);
	if (ret == 0)
	return (B_TRUE);

	ret = nvlist_lookup_uint64(props,
	zfs_prop_to_name(ZFS_PROP_PBKDF2_ITERS), &intval);
	if (ret == 0)
	return (B_TRUE);

	return (B_FALSE);
	}

	int
	zfs_crypto_get_encryption_root(zfs_handle_t zhp, boolean_t is_encroot,
	char *buf)
	{
	int ret;
	char prop_encroot[MAXNAMELEN];

	/* if the dataset isn't encrypted, just return */
	if (zfs_prop_get_int(zhp, ZFS_PROP_ENCRYPTION) == ZIO_CRYPT_OFF) {
	*is_encroot = B_FALSE;
	if (buf != NULL)
	buf[0] = '\0';
	return (0);
	}

	ret = zfs_prop_get(zhp, ZFS_PROP_ENCRYPTION_ROOT, prop_encroot,
	sizeof (prop_encroot), NULL, NULL, 0, B_TRUE);
	if (ret != 0) {
	*is_encroot = B_FALSE;
	if (buf != NULL)
	buf[0] = '\0';
	return (ret);
	}

	*is_encroot = strcmp(prop_encroot, zfs_get_name(zhp)) == 0;
	if (buf != NULL)
	strcpy(buf, prop_encroot);

	return (0);
	}

	int
	zfs_crypto_create(libzfs_handle_t hdl, char parent_name, nvlist_t *props,
	nvlist_t pool_props, boolean_t stdin_available, uint8_t *wkeydata_out,
	uint_t *wkeylen_out)
	{
	int ret;
	char errbuf[1024];
	uint64_t crypt = ZIO_CRYPT_INHERIT, pcrypt = ZIO_CRYPT_INHERIT;
	uint64_t keyformat = ZFS_KEYFORMAT_NONE;
	char *keylocation = NULL;
	zfs_handle_t *pzhp = NULL;
	uint8_t *wkeydata = NULL;
	uint_t wkeylen = 0;
	boolean_t local_crypt = B_TRUE;

	(void) snprintf(errbuf, sizeof (errbuf),
	dgettext(TEXT_DOMAIN, "Encryption create error"));

	/* lookup crypt from props */
	ret = nvlist_lookup_uint64(props,
	zfs_prop_to_name(ZFS_PROP_ENCRYPTION), &crypt);
	if (ret != 0)
	local_crypt = B_FALSE;

	/* lookup key location and format from props */
	(void) nvlist_lookup_uint64(props,
	zfs_prop_to_name(ZFS_PROP_KEYFORMAT), &keyformat);
	(void) nvlist_lookup_string(props,
	zfs_prop_to_name(ZFS_PROP_KEYLOCATION), &keylocation);

	if (parent_name != NULL) {
	/* get a reference to parent dataset */
	pzhp = make_dataset_handle(hdl, parent_name);
	if (pzhp == NULL) {
	ret = ENOENT;
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"Failed to lookup parent."));
	goto out;
	}

	/* Lookup parent's crypt */
	pcrypt = zfs_prop_get_int(pzhp, ZFS_PROP_ENCRYPTION);

	/* Params require the encryption feature */
	if (!encryption_feature_is_enabled(pzhp->zpool_hdl)) {
	if (proplist_has_encryption_props(props)) {
	ret = EINVAL;
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"Encryption feature not enabled."));
	goto out;
	}

	ret = 0;
	goto out;
	}
	} else {
	/*
	* special case for root dataset where encryption feature
	* feature won't be on disk yet
	*/
	if (!nvlist_exists(pool_props, "feature@encryption")) {
	if (proplist_has_encryption_props(props)) {
	ret = EINVAL;
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"Encryption feature not enabled."));
	goto out;
	}

	ret = 0;
	goto out;
	}

	pcrypt = ZIO_CRYPT_OFF;
	}

	/* Get the inherited encryption property if we don't have it locally */
	if (!local_crypt)
	crypt = pcrypt;

	/*
	* At this point crypt should be the actual encryption value. If
	* encryption is off just verify that no encryption properties have
	* been specified and return.
	*/
	if (crypt == ZIO_CRYPT_OFF) {
	if (proplist_has_encryption_props(props)) {
	ret = EINVAL;
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"Encryption must be turned on to set encryption "
	"properties."));
	goto out;
	}

	ret = 0;
	goto out;
	}

	/*
	* If we have a parent crypt it is valid to specify encryption alone.
	* This will result in a child that is encrypted with the chosen
	* encryption suite that will also inherit the parent's key. If
	* the parent is not encrypted we need an encryption suite provided.
	*/
	if (pcrypt == ZIO_CRYPT_OFF && keylocation == NULL &&
	keyformat == ZFS_KEYFORMAT_NONE) {
	ret = EINVAL;
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"Keyformat required for new encryption root."));
	goto out;
	}

	/*
	* Specifying a keylocation implies this will be a new encryption root.
	* Check that a keyformat is also specified.
	*/
	if (keylocation != NULL && keyformat == ZFS_KEYFORMAT_NONE) {
	ret = EINVAL;
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"Keyformat required for new encryption root."));
	goto out;
	}

	/* default to prompt if no keylocation is specified */
	if (keyformat != ZFS_KEYFORMAT_NONE && keylocation == NULL) {
	keylocation = "prompt";
	ret = nvlist_add_string(props,
	zfs_prop_to_name(ZFS_PROP_KEYLOCATION), keylocation);
	if (ret != 0)
	goto out;
	}

	/*
	* If a local key is provided, this dataset will be a new
	* encryption root. Populate the encryption params.
	*/
	if (keylocation != NULL) {
	/*
	* 'zfs recv -o keylocation=prompt' won't work because stdin
	* is being used by the send stream, so we disallow it.
	*/
	if (!stdin_available && strcmp(keylocation, "prompt") == 0) {
	ret = EINVAL;
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "Cannot use "
	"'prompt' keylocation because stdin is in use."));
	goto out;
	}

	ret = populate_create_encryption_params_nvlists(hdl, NULL,
	- B_FALSE, keyformat, keylocation, props, &wkeydata,
	+ B_TRUE, keyformat, keylocation, props, &wkeydata,
	&wkeylen);
	if (ret != 0)
	goto out;
	}

	if (pzhp != NULL)
	zfs_close(pzhp);

	*wkeydata_out = wkeydata;
	*wkeylen_out = wkeylen;
	return (0);

	out:
	if (pzhp != NULL)
	zfs_close(pzhp);
	if (wkeydata != NULL)
	free(wkeydata);

	*wkeydata_out = NULL;
	*wkeylen_out = 0;
	return (ret);
	}

	int
	zfs_crypto_clone_check(libzfs_handle_t hdl, zfs_handle_t origin_zhp,
	char parent_name, nvlist_t props)
	{
	char errbuf[1024];

	(void) snprintf(errbuf, sizeof (errbuf),
	dgettext(TEXT_DOMAIN, "Encryption clone error"));

	/*
	* No encryption properties should be specified. They will all be
	* inherited from the origin dataset.
	*/
	if (nvlist_exists(props, zfs_prop_to_name(ZFS_PROP_KEYFORMAT)) \|\|
	nvlist_exists(props, zfs_prop_to_name(ZFS_PROP_KEYLOCATION)) \|\|
	nvlist_exists(props, zfs_prop_to_name(ZFS_PROP_ENCRYPTION)) \|\|
	nvlist_exists(props, zfs_prop_to_name(ZFS_PROP_PBKDF2_ITERS))) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"Encryption properties must inherit from origin dataset."));
	return (EINVAL);
	}

	return (0);
	}

	typedef struct loadkeys_cbdata {
	uint64_t cb_numfailed;
	uint64_t cb_numattempted;
	} loadkey_cbdata_t;

	static int
	load_keys_cb(zfs_handle_t zhp, void arg)
	{
	int ret;
	boolean_t is_encroot;
	loadkey_cbdata_t *cb = arg;
	uint64_t keystatus = zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS);

	/* only attempt to load keys for encryption roots */
	ret = zfs_crypto_get_encryption_root(zhp, &is_encroot, NULL);
	if (ret != 0 \|\| !is_encroot)
	goto out;

	/* don't attempt to load already loaded keys */
	if (keystatus == ZFS_KEYSTATUS_AVAILABLE)
	goto out;

	/* Attempt to load the key. Record status in cb. */
	cb->cb_numattempted++;

	ret = zfs_crypto_load_key(zhp, B_FALSE, NULL);
	if (ret)
	cb->cb_numfailed++;

	out:
	(void) zfs_iter_filesystems(zhp, load_keys_cb, cb);
	zfs_close(zhp);

	/* always return 0, since this function is best effort */
	return (0);
	}

	/*
	* This function is best effort. It attempts to load all the keys for the given
	* filesystem and all of its children.
	*/
	int
	zfs_crypto_attempt_load_keys(libzfs_handle_t hdl, char fsname)
	{
	int ret;
	zfs_handle_t *zhp = NULL;
	loadkey_cbdata_t cb = { 0 };

	zhp = zfs_open(hdl, fsname, ZFS_TYPE_FILESYSTEM \| ZFS_TYPE_VOLUME);
	if (zhp == NULL) {
	ret = ENOENT;
	goto error;
	}

	ret = load_keys_cb(zfs_handle_dup(zhp), &cb);
	if (ret)
	goto error;

	(void) printf(gettext("%llu / %llu keys successfully loaded\n"),
	(u_longlong_t)(cb.cb_numattempted - cb.cb_numfailed),
	(u_longlong_t)cb.cb_numattempted);

	if (cb.cb_numfailed != 0) {
	ret = -1;
	goto error;
	}

	zfs_close(zhp);
	return (0);

	error:
	if (zhp != NULL)
	zfs_close(zhp);
	return (ret);
	}

	int
	zfs_crypto_load_key(zfs_handle_t zhp, boolean_t noop, char alt_keylocation)
	{
	int ret, attempts = 0;
	char errbuf[1024];
	uint64_t keystatus, iters = 0, salt = 0;
	uint64_t keyformat = ZFS_KEYFORMAT_NONE;
	char prop_keylocation[MAXNAMELEN];
	char prop_encroot[MAXNAMELEN];
	char *keylocation = NULL;
	uint8_t key_material = NULL, key_data = NULL;
	size_t key_material_len;
	boolean_t is_encroot, can_retry = B_FALSE, correctible = B_FALSE;

	(void) snprintf(errbuf, sizeof (errbuf),
	dgettext(TEXT_DOMAIN, "Key load error"));

	/* check that encryption is enabled for the pool */
	if (!encryption_feature_is_enabled(zhp->zpool_hdl)) {
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"Encryption feature not enabled."));
	ret = EINVAL;
	goto error;
	}

	/* Fetch the keyformat. Check that the dataset is encrypted. */
	keyformat = zfs_prop_get_int(zhp, ZFS_PROP_KEYFORMAT);
	if (keyformat == ZFS_KEYFORMAT_NONE) {
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"'%s' is not encrypted."), zfs_get_name(zhp));
	ret = EINVAL;
	goto error;
	}

	/*
	* Fetch the key location. Check that we are working with an
	* encryption root.
	*/
	ret = zfs_crypto_get_encryption_root(zhp, &is_encroot, prop_encroot);
	if (ret != 0) {
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"Failed to get encryption root for '%s'."),
	zfs_get_name(zhp));
	goto error;
	} else if (!is_encroot) {
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"Keys must be loaded for encryption root of '%s' (%s)."),
	zfs_get_name(zhp), prop_encroot);
	ret = EINVAL;
	goto error;
	}

	/*
	* if the caller has elected to override the keylocation property
	* use that instead
	*/
	if (alt_keylocation != NULL) {
	keylocation = alt_keylocation;
	} else {
	ret = zfs_prop_get(zhp, ZFS_PROP_KEYLOCATION, prop_keylocation,
	sizeof (prop_keylocation), NULL, NULL, 0, B_TRUE);
	if (ret != 0) {
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"Failed to get keylocation for '%s'."),
	zfs_get_name(zhp));
	goto error;
	}

	keylocation = prop_keylocation;
	}

	/* check that the key is unloaded unless this is a noop */
	if (!noop) {
	keystatus = zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS);
	if (keystatus == ZFS_KEYSTATUS_AVAILABLE) {
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"Key already loaded for '%s'."), zfs_get_name(zhp));
	ret = EEXIST;
	goto error;
	}
	}

	/* passphrase formats require a salt and pbkdf2_iters property */
	if (keyformat == ZFS_KEYFORMAT_PASSPHRASE) {
	salt = zfs_prop_get_int(zhp, ZFS_PROP_PBKDF2_SALT);
	iters = zfs_prop_get_int(zhp, ZFS_PROP_PBKDF2_ITERS);
	}

	try_again:
	/* fetching and deriving the key are correctable errors. set the flag */
	correctible = B_TRUE;

	/* get key material from key format and location */
	ret = get_key_material(zhp->zfs_hdl, B_FALSE, B_FALSE, keyformat,
	keylocation, zfs_get_name(zhp), &key_material, &key_material_len,
	&can_retry);
	if (ret != 0)
	goto error;

	/* derive a key from the key material */
	ret = derive_key(zhp->zfs_hdl, keyformat, iters, key_material,
	key_material_len, salt, &key_data);
	if (ret != 0)
	goto error;

	correctible = B_FALSE;

	/* pass the wrapping key and noop flag to the ioctl */
	ret = lzc_load_key(zhp->zfs_name, noop, key_data, WRAPPING_KEY_LEN);
	if (ret != 0) {
	switch (ret) {
	case EPERM:
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"Permission denied."));
	break;
	case EINVAL:
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"Invalid parameters provided for dataset %s."),
	zfs_get_name(zhp));
	break;
	case EEXIST:
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"Key already loaded for '%s'."), zfs_get_name(zhp));
	break;
	case EBUSY:
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"'%s' is busy."), zfs_get_name(zhp));
	break;
	case EACCES:
	correctible = B_TRUE;
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"Incorrect key provided for '%s'."),
	zfs_get_name(zhp));
	break;
	}
	goto error;
	}

	free(key_material);
	free(key_data);

	return (0);

	error:
	zfs_error(zhp->zfs_hdl, EZFS_CRYPTOFAILED, errbuf);
	if (key_material != NULL) {
	free(key_material);
	key_material = NULL;
	}
	if (key_data != NULL) {
	free(key_data);
	key_data = NULL;
	}

	/*
	* Here we decide if it is ok to allow the user to retry entering their
	* key. The can_retry flag will be set if the user is entering their
	* key from an interactive prompt. The correctable flag will only be
	* set if an error that occurred could be corrected by retrying. Both
	* flags are needed to allow the user to attempt key entry again
	*/
	attempts++;
	if (can_retry && correctible && attempts < MAX_KEY_PROMPT_ATTEMPTS)
	goto try_again;

	return (ret);
	}

	int
	zfs_crypto_unload_key(zfs_handle_t *zhp)
	{
	int ret;
	char errbuf[1024];
	char prop_encroot[MAXNAMELEN];
	uint64_t keystatus, keyformat;
	boolean_t is_encroot;

	(void) snprintf(errbuf, sizeof (errbuf),
	dgettext(TEXT_DOMAIN, "Key unload error"));

	/* check that encryption is enabled for the pool */
	if (!encryption_feature_is_enabled(zhp->zpool_hdl)) {
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"Encryption feature not enabled."));
	ret = EINVAL;
	goto error;
	}

	/* Fetch the keyformat. Check that the dataset is encrypted. */
	keyformat = zfs_prop_get_int(zhp, ZFS_PROP_KEYFORMAT);
	if (keyformat == ZFS_KEYFORMAT_NONE) {
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"'%s' is not encrypted."), zfs_get_name(zhp));
	ret = EINVAL;
	goto error;
	}

	/*
	* Fetch the key location. Check that we are working with an
	* encryption root.
	*/
	ret = zfs_crypto_get_encryption_root(zhp, &is_encroot, prop_encroot);
	if (ret != 0) {
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"Failed to get encryption root for '%s'."),
	zfs_get_name(zhp));
	goto error;
	} else if (!is_encroot) {
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"Keys must be unloaded for encryption root of '%s' (%s)."),
	zfs_get_name(zhp), prop_encroot);
	ret = EINVAL;
	goto error;
	}

	/* check that the key is loaded */
	keystatus = zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS);
	if (keystatus == ZFS_KEYSTATUS_UNAVAILABLE) {
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"Key already unloaded for '%s'."), zfs_get_name(zhp));
	ret = EACCES;
	goto error;
	}

	/* call the ioctl */
	ret = lzc_unload_key(zhp->zfs_name);

	if (ret != 0) {
	switch (ret) {
	case EPERM:
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"Permission denied."));
	break;
	case EACCES:
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"Key already unloaded for '%s'."),
	zfs_get_name(zhp));
	break;
	case EBUSY:
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"'%s' is busy."), zfs_get_name(zhp));
	break;
	}
	zfs_error(zhp->zfs_hdl, EZFS_CRYPTOFAILED, errbuf);
	}

	return (ret);

	error:
	zfs_error(zhp->zfs_hdl, EZFS_CRYPTOFAILED, errbuf);
	return (ret);
	}

	static int
	zfs_crypto_verify_rewrap_nvlist(zfs_handle_t zhp, nvlist_t props,
	nvlist_t *props_out, char errbuf)
	{
	int ret;
	nvpair_t *elem = NULL;
	zfs_prop_t prop;
	nvlist_t *new_props = NULL;

	new_props = fnvlist_alloc();

	/*
	* loop through all provided properties, we should only have
	* keyformat, keylocation and pbkdf2iters. The actual validation of
	* values is done by zfs_valid_proplist().
	*/
	while ((elem = nvlist_next_nvpair(props, elem)) != NULL) {
	const char *propname = nvpair_name(elem);
	prop = zfs_name_to_prop(propname);

	switch (prop) {
	case ZFS_PROP_PBKDF2_ITERS:
	case ZFS_PROP_KEYFORMAT:
	case ZFS_PROP_KEYLOCATION:
	break;
	default:
	ret = EINVAL;
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"Only keyformat, keylocation and pbkdf2iters may "
	"be set with this command."));
	goto error;
	}
	}

	new_props = zfs_valid_proplist(zhp->zfs_hdl, zhp->zfs_type, props,
	zfs_prop_get_int(zhp, ZFS_PROP_ZONED), NULL, zhp->zpool_hdl,
	B_TRUE, errbuf);
	if (new_props == NULL) {
	ret = EINVAL;
	goto error;
	}

	*props_out = new_props;
	return (0);

	error:
	nvlist_free(new_props);
	*props_out = NULL;
	return (ret);
	}

	int
	zfs_crypto_rewrap(zfs_handle_t zhp, nvlist_t raw_props, boolean_t inheritkey)
	{
	int ret;
	char errbuf[1024];
	boolean_t is_encroot;
	nvlist_t *props = NULL;
	uint8_t *wkeydata = NULL;
	uint_t wkeylen = 0;
	dcp_cmd_t cmd = (inheritkey) ? DCP_CMD_INHERIT : DCP_CMD_NEW_KEY;
	uint64_t crypt, pcrypt, keystatus, pkeystatus;
	uint64_t keyformat = ZFS_KEYFORMAT_NONE;
	zfs_handle_t *pzhp = NULL;
	char *keylocation = NULL;
	char origin_name[MAXNAMELEN];
	char prop_keylocation[MAXNAMELEN];
	char parent_name[ZFS_MAX_DATASET_NAME_LEN];

	(void) snprintf(errbuf, sizeof (errbuf),
	dgettext(TEXT_DOMAIN, "Key change error"));

	/* check that encryption is enabled for the pool */
	if (!encryption_feature_is_enabled(zhp->zpool_hdl)) {
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"Encryption feature not enabled."));
	ret = EINVAL;
	goto error;
	}

	/* get crypt from dataset */
	crypt = zfs_prop_get_int(zhp, ZFS_PROP_ENCRYPTION);
	if (crypt == ZIO_CRYPT_OFF) {
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"Dataset not encrypted."));
	ret = EINVAL;
	goto error;
	}

	/* get the encryption root of the dataset */
	ret = zfs_crypto_get_encryption_root(zhp, &is_encroot, NULL);
	if (ret != 0) {
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"Failed to get encryption root for '%s'."),
	zfs_get_name(zhp));
	goto error;
	}

	/* Clones use their origin's key and cannot rewrap it */
	ret = zfs_prop_get(zhp, ZFS_PROP_ORIGIN, origin_name,
	sizeof (origin_name), NULL, NULL, 0, B_TRUE);
	if (ret == 0 && strcmp(origin_name, "") != 0) {
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"Keys cannot be changed on clones."));
	ret = EINVAL;
	goto error;
	}

	/*
	* If the user wants to use the inheritkey variant of this function
	* we don't need to collect any crypto arguments.
	*/
	if (!inheritkey) {
	/* validate the provided properties */
	ret = zfs_crypto_verify_rewrap_nvlist(zhp, raw_props, &props,
	errbuf);
	if (ret != 0)
	goto error;

	/*
	* Load keyformat and keylocation from the nvlist. Fetch from
	* the dataset properties if not specified.
	*/
	(void) nvlist_lookup_uint64(props,
	zfs_prop_to_name(ZFS_PROP_KEYFORMAT), &keyformat);
	(void) nvlist_lookup_string(props,
	zfs_prop_to_name(ZFS_PROP_KEYLOCATION), &keylocation);

	if (is_encroot) {
	/*
	* If this is already an encryption root, just keep
	* any properties not set by the user.
	*/
	if (keyformat == ZFS_KEYFORMAT_NONE) {
	keyformat = zfs_prop_get_int(zhp,
	ZFS_PROP_KEYFORMAT);
	ret = nvlist_add_uint64(props,
	zfs_prop_to_name(ZFS_PROP_KEYFORMAT),
	keyformat);
	if (ret != 0) {
	zfs_error_aux(zhp->zfs_hdl,
	dgettext(TEXT_DOMAIN, "Failed to "
	"get existing keyformat "
	"property."));
	goto error;
	}
	}

	if (keylocation == NULL) {
	ret = zfs_prop_get(zhp, ZFS_PROP_KEYLOCATION,
	prop_keylocation, sizeof (prop_keylocation),
	NULL, NULL, 0, B_TRUE);
	if (ret != 0) {
	zfs_error_aux(zhp->zfs_hdl,
	dgettext(TEXT_DOMAIN, "Failed to "
	"get existing keylocation "
	"property."));
	goto error;
	}

	keylocation = prop_keylocation;
	}
	} else {
	/* need a new key for non-encryption roots */
	if (keyformat == ZFS_KEYFORMAT_NONE) {
	ret = EINVAL;
	zfs_error_aux(zhp->zfs_hdl,
	dgettext(TEXT_DOMAIN, "Keyformat required "
	"for new encryption root."));
	goto error;
	}

	/* default to prompt if no keylocation is specified */
	if (keylocation == NULL) {
	keylocation = "prompt";
	ret = nvlist_add_string(props,
	zfs_prop_to_name(ZFS_PROP_KEYLOCATION),
	keylocation);
	if (ret != 0)
	goto error;
	}
	}

	/* fetch the new wrapping key and associated properties */
	ret = populate_create_encryption_params_nvlists(zhp->zfs_hdl,
	zhp, B_TRUE, keyformat, keylocation, props, &wkeydata,
	&wkeylen);
	if (ret != 0)
	goto error;
	} else {
	/* check that zhp is an encryption root */
	if (!is_encroot) {
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"Key inheritting can only be performed on "
	"encryption roots."));
	ret = EINVAL;
	goto error;
	}

	/* get the parent's name */
	ret = zfs_parent_name(zhp, parent_name, sizeof (parent_name));
	if (ret != 0) {
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"Root dataset cannot inherit key."));
	ret = EINVAL;
	goto error;
	}

	/* get a handle to the parent */
	pzhp = make_dataset_handle(zhp->zfs_hdl, parent_name);
	if (pzhp == NULL) {
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"Failed to lookup parent."));
	ret = ENOENT;
	goto error;
	}

	/* parent must be encrypted */
	pcrypt = zfs_prop_get_int(pzhp, ZFS_PROP_ENCRYPTION);
	if (pcrypt == ZIO_CRYPT_OFF) {
	zfs_error_aux(pzhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"Parent must be encrypted."));
	ret = EINVAL;
	goto error;
	}

	/* check that the parent's key is loaded */
	pkeystatus = zfs_prop_get_int(pzhp, ZFS_PROP_KEYSTATUS);
	if (pkeystatus == ZFS_KEYSTATUS_UNAVAILABLE) {
	zfs_error_aux(pzhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"Parent key must be loaded."));
	ret = EACCES;
	goto error;
	}
	}

	/* check that the key is loaded */
	keystatus = zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS);
	if (keystatus == ZFS_KEYSTATUS_UNAVAILABLE) {
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"Key must be loaded."));
	ret = EACCES;
	goto error;
	}

	/* call the ioctl */
	ret = lzc_change_key(zhp->zfs_name, cmd, props, wkeydata, wkeylen);
	if (ret != 0) {
	switch (ret) {
	case EPERM:
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"Permission denied."));
	break;
	case EINVAL:
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"Invalid properties for key change."));
	break;
	case EACCES:
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"Key is not currently loaded."));
	break;
	}
	zfs_error(zhp->zfs_hdl, EZFS_CRYPTOFAILED, errbuf);
	}

	if (pzhp != NULL)
	zfs_close(pzhp);
	if (props != NULL)
	nvlist_free(props);
	if (wkeydata != NULL)
	free(wkeydata);

	return (ret);

	error:
	if (pzhp != NULL)
	zfs_close(pzhp);
	if (props != NULL)
	nvlist_free(props);
	if (wkeydata != NULL)
	free(wkeydata);

	zfs_error(zhp->zfs_hdl, EZFS_CRYPTOFAILED, errbuf);
	return (ret);
	}
	diff --git a/sys/contrib/openzfs/lib/libzfs/libzfs_dataset.c b/sys/contrib/openzfs/lib/libzfs/libzfs_dataset.c
	index 4598e87f2921..e734189478b3 100644
	--- a/sys/contrib/openzfs/lib/libzfs/libzfs_dataset.c
	+++ b/sys/contrib/openzfs/lib/libzfs/libzfs_dataset.c
	@@ -1,5560 +1,5562 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright 2019 Joyent, Inc.
	* Copyright (c) 2011, 2020 by Delphix. All rights reserved.
	* Copyright (c) 2012 DEY Storage Systems, Inc. All rights reserved.
	* Copyright (c) 2012 Pawel Jakub Dawidek <pawel@dawidek.net>.
	* Copyright (c) 2013 Martin Matuska. All rights reserved.
	* Copyright (c) 2013 Steven Hartland. All rights reserved.
	* Copyright 2017 Nexenta Systems, Inc.
	* Copyright 2016 Igor Kozhukhov <ikozhukhov@gmail.com>
	* Copyright 2017-2018 RackTop Systems.
	* Copyright (c) 2019 Datto Inc.
	* Copyright (c) 2019, loli10K <ezomori.nozomu@gmail.com>
	+ * Copyright (c) 2021 Matt Fiddaman
	*/

	#include <ctype.h>
	#include <errno.h>
	#include <libintl.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <strings.h>
	#include <unistd.h>
	#include <stddef.h>
	#include <zone.h>
	#include <fcntl.h>
	#include <sys/mntent.h>
	#include <sys/mount.h>
	#include <pwd.h>
	#include <grp.h>
	#include <ucred.h>
	#ifdef HAVE_IDMAP
	#include <idmap.h>
	#include <aclutils.h>
	#include <directory.h>
	#endif /* HAVE_IDMAP */

	#include <sys/dnode.h>
	#include <sys/spa.h>
	#include <sys/zap.h>
	#include <sys/dsl_crypt.h>
	#include <libzfs.h>
	#include <libzutil.h>

	#include "zfs_namecheck.h"
	#include "zfs_prop.h"
	#include "libzfs_impl.h"
	#include "zfs_deleg.h"

	static int userquota_propname_decode(const char *propname, boolean_t zoned,
	zfs_userquota_prop_t typep, char domain, int domainlen, uint64_t *ridp);

	/*
	* Given a single type (not a mask of types), return the type in a human
	* readable form.
	*/
	const char *
	zfs_type_to_name(zfs_type_t type)
	{
	switch (type) {
	case ZFS_TYPE_FILESYSTEM:
	return (dgettext(TEXT_DOMAIN, "filesystem"));
	case ZFS_TYPE_SNAPSHOT:
	return (dgettext(TEXT_DOMAIN, "snapshot"));
	case ZFS_TYPE_VOLUME:
	return (dgettext(TEXT_DOMAIN, "volume"));
	case ZFS_TYPE_POOL:
	return (dgettext(TEXT_DOMAIN, "pool"));
	case ZFS_TYPE_BOOKMARK:
	return (dgettext(TEXT_DOMAIN, "bookmark"));
	default:
	assert(!"unhandled zfs_type_t");
	}

	return (NULL);
	}

	/*
	* Validate a ZFS path. This is used even before trying to open the dataset, to
	* provide a more meaningful error message. We call zfs_error_aux() to
	* explain exactly why the name was not valid.
	*/
	int
	zfs_validate_name(libzfs_handle_t hdl, const char path, int type,
	boolean_t modifying)
	{
	namecheck_err_t why;
	char what;

	if (!(type & ZFS_TYPE_SNAPSHOT) && strchr(path, '@') != NULL) {
	if (hdl != NULL)
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"snapshot delimiter '@' is not expected here"));
	return (0);
	}

	if (type == ZFS_TYPE_SNAPSHOT && strchr(path, '@') == NULL) {
	if (hdl != NULL)
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"missing '@' delimiter in snapshot name"));
	return (0);
	}

	if (!(type & ZFS_TYPE_BOOKMARK) && strchr(path, '#') != NULL) {
	if (hdl != NULL)
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"bookmark delimiter '#' is not expected here"));
	return (0);
	}

	if (type == ZFS_TYPE_BOOKMARK && strchr(path, '#') == NULL) {
	if (hdl != NULL)
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"missing '#' delimiter in bookmark name"));
	return (0);
	}

	if (modifying && strchr(path, '%') != NULL) {
	if (hdl != NULL)
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"invalid character %c in name"), '%');
	return (0);
	}

	if (entity_namecheck(path, &why, &what) != 0) {
	if (hdl != NULL) {
	switch (why) {
	case NAME_ERR_TOOLONG:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"name is too long"));
	break;

	case NAME_ERR_LEADING_SLASH:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"leading slash in name"));
	break;

	case NAME_ERR_EMPTY_COMPONENT:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"empty component or misplaced '@'"
	" or '#' delimiter in name"));
	break;

	case NAME_ERR_TRAILING_SLASH:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"trailing slash in name"));
	break;

	case NAME_ERR_INVALCHAR:
	zfs_error_aux(hdl,
	dgettext(TEXT_DOMAIN, "invalid character "
	"'%c' in name"), what);
	break;

	case NAME_ERR_MULTIPLE_DELIMITERS:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"multiple '@' and/or '#' delimiters in "
	"name"));
	break;

	case NAME_ERR_NOLETTER:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"pool doesn't begin with a letter"));
	break;

	case NAME_ERR_RESERVED:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"name is reserved"));
	break;

	case NAME_ERR_DISKLIKE:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"reserved disk name"));
	break;

	case NAME_ERR_SELF_REF:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"self reference, '.' is found in name"));
	break;

	case NAME_ERR_PARENT_REF:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"parent reference, '..' is found in name"));
	break;

	default:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"(%d) not defined"), why);
	break;
	}
	}

	return (0);
	}

	return (-1);
	}

	int
	zfs_name_valid(const char *name, zfs_type_t type)
	{
	if (type == ZFS_TYPE_POOL)
	return (zpool_name_valid(NULL, B_FALSE, name));
	return (zfs_validate_name(NULL, name, type, B_FALSE));
	}

	/*
	* This function takes the raw DSL properties, and filters out the user-defined
	* properties into a separate nvlist.
	*/
	static nvlist_t *
	process_user_props(zfs_handle_t zhp, nvlist_t props)
	{
	libzfs_handle_t *hdl = zhp->zfs_hdl;
	nvpair_t *elem;
	nvlist_t *propval;
	nvlist_t *nvl;

	if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0) {
	(void) no_memory(hdl);
	return (NULL);
	}

	elem = NULL;
	while ((elem = nvlist_next_nvpair(props, elem)) != NULL) {
	if (!zfs_prop_user(nvpair_name(elem)))
	continue;

	verify(nvpair_value_nvlist(elem, &propval) == 0);
	if (nvlist_add_nvlist(nvl, nvpair_name(elem), propval) != 0) {
	nvlist_free(nvl);
	(void) no_memory(hdl);
	return (NULL);
	}
	}

	return (nvl);
	}

	static zpool_handle_t *
	zpool_add_handle(zfs_handle_t zhp, const char pool_name)
	{
	libzfs_handle_t *hdl = zhp->zfs_hdl;
	zpool_handle_t *zph;

	if ((zph = zpool_open_canfail(hdl, pool_name)) != NULL) {
	if (hdl->libzfs_pool_handles != NULL)
	zph->zpool_next = hdl->libzfs_pool_handles;
	hdl->libzfs_pool_handles = zph;
	}
	return (zph);
	}

	static zpool_handle_t *
	zpool_find_handle(zfs_handle_t zhp, const char pool_name, int len)
	{
	libzfs_handle_t *hdl = zhp->zfs_hdl;
	zpool_handle_t *zph = hdl->libzfs_pool_handles;

	while ((zph != NULL) &&
	(strncmp(pool_name, zpool_get_name(zph), len) != 0))
	zph = zph->zpool_next;
	return (zph);
	}

	/*
	* Returns a handle to the pool that contains the provided dataset.
	* If a handle to that pool already exists then that handle is returned.
	* Otherwise, a new handle is created and added to the list of handles.
	*/
	static zpool_handle_t *
	zpool_handle(zfs_handle_t *zhp)
	{
	char *pool_name;
	int len;
	zpool_handle_t *zph;

	len = strcspn(zhp->zfs_name, "/@#") + 1;
	pool_name = zfs_alloc(zhp->zfs_hdl, len);
	(void) strlcpy(pool_name, zhp->zfs_name, len);

	zph = zpool_find_handle(zhp, pool_name, len);
	if (zph == NULL)
	zph = zpool_add_handle(zhp, pool_name);

	free(pool_name);
	return (zph);
	}

	void
	zpool_free_handles(libzfs_handle_t *hdl)
	{
	zpool_handle_t next, zph = hdl->libzfs_pool_handles;

	while (zph != NULL) {
	next = zph->zpool_next;
	zpool_close(zph);
	zph = next;
	}
	hdl->libzfs_pool_handles = NULL;
	}

	/*
	* Utility function to gather stats (objset and zpl) for the given object.
	*/
	static int
	get_stats_ioctl(zfs_handle_t zhp, zfs_cmd_t zc)
	{
	libzfs_handle_t *hdl = zhp->zfs_hdl;

	(void) strlcpy(zc->zc_name, zhp->zfs_name, sizeof (zc->zc_name));

	while (zfs_ioctl(hdl, ZFS_IOC_OBJSET_STATS, zc) != 0) {
	if (errno == ENOMEM) {
	if (zcmd_expand_dst_nvlist(hdl, zc) != 0) {
	return (-1);
	}
	} else {
	return (-1);
	}
	}
	return (0);
	}

	/*
	* Utility function to get the received properties of the given object.
	*/
	static int
	get_recvd_props_ioctl(zfs_handle_t *zhp)
	{
	libzfs_handle_t *hdl = zhp->zfs_hdl;
	nvlist_t *recvdprops;
	zfs_cmd_t zc = {"\0"};
	int err;

	if (zcmd_alloc_dst_nvlist(hdl, &zc, 0) != 0)
	return (-1);

	(void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));

	while (zfs_ioctl(hdl, ZFS_IOC_OBJSET_RECVD_PROPS, &zc) != 0) {
	if (errno == ENOMEM) {
	if (zcmd_expand_dst_nvlist(hdl, &zc) != 0) {
	return (-1);
	}
	} else {
	zcmd_free_nvlists(&zc);
	return (-1);
	}
	}

	err = zcmd_read_dst_nvlist(zhp->zfs_hdl, &zc, &recvdprops);
	zcmd_free_nvlists(&zc);
	if (err != 0)
	return (-1);

	nvlist_free(zhp->zfs_recvd_props);
	zhp->zfs_recvd_props = recvdprops;

	return (0);
	}

	static int
	put_stats_zhdl(zfs_handle_t zhp, zfs_cmd_t zc)
	{
	nvlist_t allprops, userprops;

	zhp->zfs_dmustats = zc->zc_objset_stats; /* structure assignment */

	if (zcmd_read_dst_nvlist(zhp->zfs_hdl, zc, &allprops) != 0) {
	return (-1);
	}

	/*
	* XXX Why do we store the user props separately, in addition to
	* storing them in zfs_props?
	*/
	if ((userprops = process_user_props(zhp, allprops)) == NULL) {
	nvlist_free(allprops);
	return (-1);
	}

	nvlist_free(zhp->zfs_props);
	nvlist_free(zhp->zfs_user_props);

	zhp->zfs_props = allprops;
	zhp->zfs_user_props = userprops;

	return (0);
	}

	static int
	get_stats(zfs_handle_t *zhp)
	{
	int rc = 0;
	zfs_cmd_t zc = {"\0"};

	if (zcmd_alloc_dst_nvlist(zhp->zfs_hdl, &zc, 0) != 0)
	return (-1);
	if (get_stats_ioctl(zhp, &zc) != 0)
	rc = -1;
	else if (put_stats_zhdl(zhp, &zc) != 0)
	rc = -1;
	zcmd_free_nvlists(&zc);
	return (rc);
	}

	/*
	* Refresh the properties currently stored in the handle.
	*/
	void
	zfs_refresh_properties(zfs_handle_t *zhp)
	{
	(void) get_stats(zhp);
	}

	/*
	* Makes a handle from the given dataset name. Used by zfs_open() and
	* zfs_iter_* to create child handles on the fly.
	*/
	static int
	make_dataset_handle_common(zfs_handle_t zhp, zfs_cmd_t zc)
	{
	if (put_stats_zhdl(zhp, zc) != 0)
	return (-1);

	/*
	* We've managed to open the dataset and gather statistics. Determine
	* the high-level type.
	*/
	if (zhp->zfs_dmustats.dds_type == DMU_OST_ZVOL)
	zhp->zfs_head_type = ZFS_TYPE_VOLUME;
	else if (zhp->zfs_dmustats.dds_type == DMU_OST_ZFS)
	zhp->zfs_head_type = ZFS_TYPE_FILESYSTEM;
	else if (zhp->zfs_dmustats.dds_type == DMU_OST_OTHER)
	return (-1);
	else
	abort();

	if (zhp->zfs_dmustats.dds_is_snapshot)
	zhp->zfs_type = ZFS_TYPE_SNAPSHOT;
	else if (zhp->zfs_dmustats.dds_type == DMU_OST_ZVOL)
	zhp->zfs_type = ZFS_TYPE_VOLUME;
	else if (zhp->zfs_dmustats.dds_type == DMU_OST_ZFS)
	zhp->zfs_type = ZFS_TYPE_FILESYSTEM;
	else
	abort(); /* we should never see any other types */

	if ((zhp->zpool_hdl = zpool_handle(zhp)) == NULL)
	return (-1);

	return (0);
	}

	zfs_handle_t *
	make_dataset_handle(libzfs_handle_t hdl, const char path)
	{
	zfs_cmd_t zc = {"\0"};

	zfs_handle_t *zhp = calloc(1, sizeof (zfs_handle_t));

	if (zhp == NULL)
	return (NULL);

	zhp->zfs_hdl = hdl;
	(void) strlcpy(zhp->zfs_name, path, sizeof (zhp->zfs_name));
	if (zcmd_alloc_dst_nvlist(hdl, &zc, 0) != 0) {
	free(zhp);
	return (NULL);
	}
	if (get_stats_ioctl(zhp, &zc) == -1) {
	zcmd_free_nvlists(&zc);
	free(zhp);
	return (NULL);
	}
	if (make_dataset_handle_common(zhp, &zc) == -1) {
	free(zhp);
	zhp = NULL;
	}
	zcmd_free_nvlists(&zc);
	return (zhp);
	}

	zfs_handle_t *
	make_dataset_handle_zc(libzfs_handle_t hdl, zfs_cmd_t zc)
	{
	zfs_handle_t *zhp = calloc(1, sizeof (zfs_handle_t));

	if (zhp == NULL)
	return (NULL);

	zhp->zfs_hdl = hdl;
	(void) strlcpy(zhp->zfs_name, zc->zc_name, sizeof (zhp->zfs_name));
	if (make_dataset_handle_common(zhp, zc) == -1) {
	free(zhp);
	return (NULL);
	}
	return (zhp);
	}

	zfs_handle_t *
	make_dataset_simple_handle_zc(zfs_handle_t pzhp, zfs_cmd_t zc)
	{
	zfs_handle_t *zhp = calloc(1, sizeof (zfs_handle_t));

	if (zhp == NULL)
	return (NULL);

	zhp->zfs_hdl = pzhp->zfs_hdl;
	(void) strlcpy(zhp->zfs_name, zc->zc_name, sizeof (zhp->zfs_name));
	zhp->zfs_head_type = pzhp->zfs_type;
	zhp->zfs_type = ZFS_TYPE_SNAPSHOT;
	zhp->zpool_hdl = zpool_handle(zhp);

	return (zhp);
	}

	zfs_handle_t *
	zfs_handle_dup(zfs_handle_t *zhp_orig)
	{
	zfs_handle_t *zhp = calloc(1, sizeof (zfs_handle_t));

	if (zhp == NULL)
	return (NULL);

	zhp->zfs_hdl = zhp_orig->zfs_hdl;
	zhp->zpool_hdl = zhp_orig->zpool_hdl;
	(void) strlcpy(zhp->zfs_name, zhp_orig->zfs_name,
	sizeof (zhp->zfs_name));
	zhp->zfs_type = zhp_orig->zfs_type;
	zhp->zfs_head_type = zhp_orig->zfs_head_type;
	zhp->zfs_dmustats = zhp_orig->zfs_dmustats;
	if (zhp_orig->zfs_props != NULL) {
	if (nvlist_dup(zhp_orig->zfs_props, &zhp->zfs_props, 0) != 0) {
	(void) no_memory(zhp->zfs_hdl);
	zfs_close(zhp);
	return (NULL);
	}
	}
	if (zhp_orig->zfs_user_props != NULL) {
	if (nvlist_dup(zhp_orig->zfs_user_props,
	&zhp->zfs_user_props, 0) != 0) {
	(void) no_memory(zhp->zfs_hdl);
	zfs_close(zhp);
	return (NULL);
	}
	}
	if (zhp_orig->zfs_recvd_props != NULL) {
	if (nvlist_dup(zhp_orig->zfs_recvd_props,
	&zhp->zfs_recvd_props, 0)) {
	(void) no_memory(zhp->zfs_hdl);
	zfs_close(zhp);
	return (NULL);
	}
	}
	zhp->zfs_mntcheck = zhp_orig->zfs_mntcheck;
	if (zhp_orig->zfs_mntopts != NULL) {
	zhp->zfs_mntopts = zfs_strdup(zhp_orig->zfs_hdl,
	zhp_orig->zfs_mntopts);
	}
	zhp->zfs_props_table = zhp_orig->zfs_props_table;
	return (zhp);
	}

	boolean_t
	zfs_bookmark_exists(const char *path)
	{
	nvlist_t *bmarks;
	nvlist_t *props;
	char fsname[ZFS_MAX_DATASET_NAME_LEN];
	char *bmark_name;
	char *pound;
	int err;
	boolean_t rv;

	(void) strlcpy(fsname, path, sizeof (fsname));
	pound = strchr(fsname, '#');
	if (pound == NULL)
	return (B_FALSE);

	*pound = '\0';
	bmark_name = pound + 1;
	props = fnvlist_alloc();
	err = lzc_get_bookmarks(fsname, props, &bmarks);
	nvlist_free(props);
	if (err != 0) {
	nvlist_free(bmarks);
	return (B_FALSE);
	}

	rv = nvlist_exists(bmarks, bmark_name);
	nvlist_free(bmarks);
	return (rv);
	}

	zfs_handle_t *
	make_bookmark_handle(zfs_handle_t parent, const char path,
	nvlist_t *bmark_props)
	{
	zfs_handle_t *zhp = calloc(1, sizeof (zfs_handle_t));

	if (zhp == NULL)
	return (NULL);

	/* Fill in the name. */
	zhp->zfs_hdl = parent->zfs_hdl;
	(void) strlcpy(zhp->zfs_name, path, sizeof (zhp->zfs_name));

	/* Set the property lists. */
	if (nvlist_dup(bmark_props, &zhp->zfs_props, 0) != 0) {
	free(zhp);
	return (NULL);
	}

	/* Set the types. */
	zhp->zfs_head_type = parent->zfs_head_type;
	zhp->zfs_type = ZFS_TYPE_BOOKMARK;

	if ((zhp->zpool_hdl = zpool_handle(zhp)) == NULL) {
	nvlist_free(zhp->zfs_props);
	free(zhp);
	return (NULL);
	}

	return (zhp);
	}

	struct zfs_open_bookmarks_cb_data {
	const char *path;
	zfs_handle_t *zhp;
	};

	static int
	zfs_open_bookmarks_cb(zfs_handle_t zhp, void data)
	{
	struct zfs_open_bookmarks_cb_data *dp = data;

	/*
	* Is it the one we are looking for?
	*/
	if (strcmp(dp->path, zfs_get_name(zhp)) == 0) {
	/*
	* We found it. Save it and let the caller know we are done.
	*/
	dp->zhp = zhp;
	return (EEXIST);
	}

	/*
	* Not found. Close the handle and ask for another one.
	*/
	zfs_close(zhp);
	return (0);
	}

	/*
	* Opens the given snapshot, bookmark, filesystem, or volume. The 'types'
	* argument is a mask of acceptable types. The function will print an
	* appropriate error message and return NULL if it can't be opened.
	*/
	zfs_handle_t *
	zfs_open(libzfs_handle_t hdl, const char path, int types)
	{
	zfs_handle_t *zhp;
	char errbuf[1024];
	char *bookp;

	(void) snprintf(errbuf, sizeof (errbuf),
	dgettext(TEXT_DOMAIN, "cannot open '%s'"), path);

	/*
	* Validate the name before we even try to open it.
	*/
	if (!zfs_validate_name(hdl, path, types, B_FALSE)) {
	(void) zfs_error(hdl, EZFS_INVALIDNAME, errbuf);
	return (NULL);
	}

	/*
	* Bookmarks needs to be handled separately.
	*/
	bookp = strchr(path, '#');
	if (bookp == NULL) {
	/*
	* Try to get stats for the dataset, which will tell us if it
	* exists.
	*/
	errno = 0;
	if ((zhp = make_dataset_handle(hdl, path)) == NULL) {
	(void) zfs_standard_error(hdl, errno, errbuf);
	return (NULL);
	}
	} else {
	char dsname[ZFS_MAX_DATASET_NAME_LEN];
	zfs_handle_t *pzhp;
	struct zfs_open_bookmarks_cb_data cb_data = {path, NULL};

	/*
	* We need to cut out '#' and everything after '#'
	* to get the parent dataset name only.
	*/
	assert(bookp - path < sizeof (dsname));
	(void) strncpy(dsname, path, bookp - path);
	dsname[bookp - path] = '\0';

	/*
	* Create handle for the parent dataset.
	*/
	errno = 0;
	if ((pzhp = make_dataset_handle(hdl, dsname)) == NULL) {
	(void) zfs_standard_error(hdl, errno, errbuf);
	return (NULL);
	}

	/*
	* Iterate bookmarks to find the right one.
	*/
	errno = 0;
	if ((zfs_iter_bookmarks(pzhp, zfs_open_bookmarks_cb,
	&cb_data) == 0) && (cb_data.zhp == NULL)) {
	(void) zfs_error(hdl, EZFS_NOENT, errbuf);
	zfs_close(pzhp);
	return (NULL);
	}
	if (cb_data.zhp == NULL) {
	(void) zfs_standard_error(hdl, errno, errbuf);
	zfs_close(pzhp);
	return (NULL);
	}
	zhp = cb_data.zhp;

	/*
	* Cleanup.
	*/
	zfs_close(pzhp);
	}

	if (!(types & zhp->zfs_type)) {
	(void) zfs_error(hdl, EZFS_BADTYPE, errbuf);
	zfs_close(zhp);
	return (NULL);
	}

	return (zhp);
	}

	/*
	* Release a ZFS handle. Nothing to do but free the associated memory.
	*/
	void
	zfs_close(zfs_handle_t *zhp)
	{
	if (zhp->zfs_mntopts)
	free(zhp->zfs_mntopts);
	nvlist_free(zhp->zfs_props);
	nvlist_free(zhp->zfs_user_props);
	nvlist_free(zhp->zfs_recvd_props);
	free(zhp);
	}

	typedef struct mnttab_node {
	struct mnttab mtn_mt;
	avl_node_t mtn_node;
	} mnttab_node_t;

	static int
	libzfs_mnttab_cache_compare(const void arg1, const void arg2)
	{
	const mnttab_node_t mtn1 = (const mnttab_node_t )arg1;
	const mnttab_node_t mtn2 = (const mnttab_node_t )arg2;
	int rv;

	rv = strcmp(mtn1->mtn_mt.mnt_special, mtn2->mtn_mt.mnt_special);

	return (TREE_ISIGN(rv));
	}

	void
	libzfs_mnttab_init(libzfs_handle_t *hdl)
	{
	pthread_mutex_init(&hdl->libzfs_mnttab_cache_lock, NULL);
	assert(avl_numnodes(&hdl->libzfs_mnttab_cache) == 0);
	avl_create(&hdl->libzfs_mnttab_cache, libzfs_mnttab_cache_compare,
	sizeof (mnttab_node_t), offsetof(mnttab_node_t, mtn_node));
	}

	static int
	libzfs_mnttab_update(libzfs_handle_t *hdl)
	{
	struct mnttab entry;

	/* Reopen MNTTAB to prevent reading stale data from open file */
	- if (freopen(MNTTAB, "r", hdl->libzfs_mnttab) == NULL)
	+ if (freopen(MNTTAB, "re", hdl->libzfs_mnttab) == NULL)
	return (ENOENT);

	while (getmntent(hdl->libzfs_mnttab, &entry) == 0) {
	mnttab_node_t *mtn;
	avl_index_t where;

	if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0)
	continue;

	mtn = zfs_alloc(hdl, sizeof (mnttab_node_t));
	mtn->mtn_mt.mnt_special = zfs_strdup(hdl, entry.mnt_special);
	mtn->mtn_mt.mnt_mountp = zfs_strdup(hdl, entry.mnt_mountp);
	mtn->mtn_mt.mnt_fstype = zfs_strdup(hdl, entry.mnt_fstype);
	mtn->mtn_mt.mnt_mntopts = zfs_strdup(hdl, entry.mnt_mntopts);

	/* Exclude duplicate mounts */
	if (avl_find(&hdl->libzfs_mnttab_cache, mtn, &where) != NULL) {
	free(mtn->mtn_mt.mnt_special);
	free(mtn->mtn_mt.mnt_mountp);
	free(mtn->mtn_mt.mnt_fstype);
	free(mtn->mtn_mt.mnt_mntopts);
	free(mtn);
	continue;
	}

	avl_add(&hdl->libzfs_mnttab_cache, mtn);
	}

	return (0);
	}

	void
	libzfs_mnttab_fini(libzfs_handle_t *hdl)
	{
	void *cookie = NULL;
	mnttab_node_t *mtn;

	while ((mtn = avl_destroy_nodes(&hdl->libzfs_mnttab_cache, &cookie))
	!= NULL) {
	free(mtn->mtn_mt.mnt_special);
	free(mtn->mtn_mt.mnt_mountp);
	free(mtn->mtn_mt.mnt_fstype);
	free(mtn->mtn_mt.mnt_mntopts);
	free(mtn);
	}
	avl_destroy(&hdl->libzfs_mnttab_cache);
	(void) pthread_mutex_destroy(&hdl->libzfs_mnttab_cache_lock);
	}

	void
	libzfs_mnttab_cache(libzfs_handle_t *hdl, boolean_t enable)
	{
	hdl->libzfs_mnttab_enable = enable;
	}

	int
	libzfs_mnttab_find(libzfs_handle_t hdl, const char fsname,
	struct mnttab *entry)
	{
	mnttab_node_t find;
	mnttab_node_t *mtn;
	int ret = ENOENT;

	if (!hdl->libzfs_mnttab_enable) {
	struct mnttab srch = { 0 };

	if (avl_numnodes(&hdl->libzfs_mnttab_cache))
	libzfs_mnttab_fini(hdl);

	/* Reopen MNTTAB to prevent reading stale data from open file */
	- if (freopen(MNTTAB, "r", hdl->libzfs_mnttab) == NULL)
	+ if (freopen(MNTTAB, "re", hdl->libzfs_mnttab) == NULL)
	return (ENOENT);

	srch.mnt_special = (char *)fsname;
	srch.mnt_fstype = MNTTYPE_ZFS;
	if (getmntany(hdl->libzfs_mnttab, entry, &srch) == 0)
	return (0);
	else
	return (ENOENT);
	}

	pthread_mutex_lock(&hdl->libzfs_mnttab_cache_lock);
	if (avl_numnodes(&hdl->libzfs_mnttab_cache) == 0) {
	int error;

	if ((error = libzfs_mnttab_update(hdl)) != 0) {
	pthread_mutex_unlock(&hdl->libzfs_mnttab_cache_lock);
	return (error);
	}
	}

	find.mtn_mt.mnt_special = (char *)fsname;
	mtn = avl_find(&hdl->libzfs_mnttab_cache, &find, NULL);
	if (mtn) {
	*entry = mtn->mtn_mt;
	ret = 0;
	}
	pthread_mutex_unlock(&hdl->libzfs_mnttab_cache_lock);
	return (ret);
	}

	void
	libzfs_mnttab_add(libzfs_handle_t hdl, const char special,
	const char mountp, const char mntopts)
	{
	mnttab_node_t *mtn;

	pthread_mutex_lock(&hdl->libzfs_mnttab_cache_lock);
	if (avl_numnodes(&hdl->libzfs_mnttab_cache) != 0) {
	mtn = zfs_alloc(hdl, sizeof (mnttab_node_t));
	mtn->mtn_mt.mnt_special = zfs_strdup(hdl, special);
	mtn->mtn_mt.mnt_mountp = zfs_strdup(hdl, mountp);
	mtn->mtn_mt.mnt_fstype = zfs_strdup(hdl, MNTTYPE_ZFS);
	mtn->mtn_mt.mnt_mntopts = zfs_strdup(hdl, mntopts);
	/*
	* Another thread may have already added this entry
	* via libzfs_mnttab_update. If so we should skip it.
	*/
	if (avl_find(&hdl->libzfs_mnttab_cache, mtn, NULL) != NULL) {
	free(mtn->mtn_mt.mnt_special);
	free(mtn->mtn_mt.mnt_mountp);
	free(mtn->mtn_mt.mnt_fstype);
	free(mtn->mtn_mt.mnt_mntopts);
	free(mtn);
	} else {
	avl_add(&hdl->libzfs_mnttab_cache, mtn);
	}
	}
	pthread_mutex_unlock(&hdl->libzfs_mnttab_cache_lock);
	}

	void
	libzfs_mnttab_remove(libzfs_handle_t hdl, const char fsname)
	{
	mnttab_node_t find;
	mnttab_node_t *ret;

	pthread_mutex_lock(&hdl->libzfs_mnttab_cache_lock);
	find.mtn_mt.mnt_special = (char *)fsname;
	if ((ret = avl_find(&hdl->libzfs_mnttab_cache, (void *)&find, NULL))
	!= NULL) {
	avl_remove(&hdl->libzfs_mnttab_cache, ret);
	free(ret->mtn_mt.mnt_special);
	free(ret->mtn_mt.mnt_mountp);
	free(ret->mtn_mt.mnt_fstype);
	free(ret->mtn_mt.mnt_mntopts);
	free(ret);
	}
	pthread_mutex_unlock(&hdl->libzfs_mnttab_cache_lock);
	}

	int
	zfs_spa_version(zfs_handle_t zhp, int spa_version)
	{
	zpool_handle_t *zpool_handle = zhp->zpool_hdl;

	if (zpool_handle == NULL)
	return (-1);

	*spa_version = zpool_get_prop_int(zpool_handle,
	ZPOOL_PROP_VERSION, NULL);
	return (0);
	}

	/*
	* The choice of reservation property depends on the SPA version.
	*/
	static int
	zfs_which_resv_prop(zfs_handle_t zhp, zfs_prop_t resv_prop)
	{
	int spa_version;

	if (zfs_spa_version(zhp, &spa_version) < 0)
	return (-1);

	if (spa_version >= SPA_VERSION_REFRESERVATION)
	*resv_prop = ZFS_PROP_REFRESERVATION;
	else
	*resv_prop = ZFS_PROP_RESERVATION;

	return (0);
	}

	/*
	* Given an nvlist of properties to set, validates that they are correct, and
	* parses any numeric properties (index, boolean, etc) if they are specified as
	* strings.
	*/
	nvlist_t *
	zfs_valid_proplist(libzfs_handle_t hdl, zfs_type_t type, nvlist_t nvl,
	uint64_t zoned, zfs_handle_t zhp, zpool_handle_t zpool_hdl,
	boolean_t key_params_ok, const char *errbuf)
	{
	nvpair_t *elem;
	uint64_t intval;
	char *strval;
	zfs_prop_t prop;
	nvlist_t *ret;
	int chosen_normal = -1;
	int chosen_utf = -1;

	if (nvlist_alloc(&ret, NV_UNIQUE_NAME, 0) != 0) {
	(void) no_memory(hdl);
	return (NULL);
	}

	/*
	* Make sure this property is valid and applies to this type.
	*/

	elem = NULL;
	while ((elem = nvlist_next_nvpair(nvl, elem)) != NULL) {
	const char *propname = nvpair_name(elem);

	prop = zfs_name_to_prop(propname);
	if (prop == ZPROP_INVAL && zfs_prop_user(propname)) {
	/*
	* This is a user property: make sure it's a
	* string, and that it's less than ZAP_MAXNAMELEN.
	*/
	if (nvpair_type(elem) != DATA_TYPE_STRING) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"'%s' must be a string"), propname);
	(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
	goto error;
	}

	if (strlen(nvpair_name(elem)) >= ZAP_MAXNAMELEN) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"property name '%s' is too long"),
	propname);
	(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
	goto error;
	}

	(void) nvpair_value_string(elem, &strval);
	if (nvlist_add_string(ret, propname, strval) != 0) {
	(void) no_memory(hdl);
	goto error;
	}
	continue;
	}

	/*
	* Currently, only user properties can be modified on
	* snapshots.
	*/
	if (type == ZFS_TYPE_SNAPSHOT) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"this property can not be modified for snapshots"));
	(void) zfs_error(hdl, EZFS_PROPTYPE, errbuf);
	goto error;
	}

	if (prop == ZPROP_INVAL && zfs_prop_userquota(propname)) {
	zfs_userquota_prop_t uqtype;
	char *newpropname = NULL;
	char domain[128];
	uint64_t rid;
	uint64_t valary[3];
	int rc;

	if (userquota_propname_decode(propname, zoned,
	&uqtype, domain, sizeof (domain), &rid) != 0) {
	zfs_error_aux(hdl,
	dgettext(TEXT_DOMAIN,
	"'%s' has an invalid user/group name"),
	propname);
	(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
	goto error;
	}

	if (uqtype != ZFS_PROP_USERQUOTA &&
	uqtype != ZFS_PROP_GROUPQUOTA &&
	uqtype != ZFS_PROP_USEROBJQUOTA &&
	uqtype != ZFS_PROP_GROUPOBJQUOTA &&
	uqtype != ZFS_PROP_PROJECTQUOTA &&
	uqtype != ZFS_PROP_PROJECTOBJQUOTA) {
	zfs_error_aux(hdl,
	dgettext(TEXT_DOMAIN, "'%s' is readonly"),
	propname);
	(void) zfs_error(hdl, EZFS_PROPREADONLY,
	errbuf);
	goto error;
	}

	if (nvpair_type(elem) == DATA_TYPE_STRING) {
	(void) nvpair_value_string(elem, &strval);
	if (strcmp(strval, "none") == 0) {
	intval = 0;
	} else if (zfs_nicestrtonum(hdl,
	strval, &intval) != 0) {
	(void) zfs_error(hdl,
	EZFS_BADPROP, errbuf);
	goto error;
	}
	} else if (nvpair_type(elem) ==
	DATA_TYPE_UINT64) {
	(void) nvpair_value_uint64(elem, &intval);
	if (intval == 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"use 'none' to disable "
	"{user\|group\|project}quota"));
	goto error;
	}
	} else {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"'%s' must be a number"), propname);
	(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
	goto error;
	}

	/*
	* Encode the prop name as
	* userquota@<hex-rid>-domain, to make it easy
	* for the kernel to decode.
	*/
	rc = asprintf(&newpropname, "%s%llx-%s",
	zfs_userquota_prop_prefixes[uqtype],
	(longlong_t)rid, domain);
	if (rc == -1 \|\| newpropname == NULL) {
	(void) no_memory(hdl);
	goto error;
	}

	valary[0] = uqtype;
	valary[1] = rid;
	valary[2] = intval;
	if (nvlist_add_uint64_array(ret, newpropname,
	valary, 3) != 0) {
	free(newpropname);
	(void) no_memory(hdl);
	goto error;
	}
	free(newpropname);
	continue;
	} else if (prop == ZPROP_INVAL && zfs_prop_written(propname)) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"'%s' is readonly"),
	propname);
	(void) zfs_error(hdl, EZFS_PROPREADONLY, errbuf);
	goto error;
	}

	if (prop == ZPROP_INVAL) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"invalid property '%s'"), propname);
	(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
	goto error;
	}

	if (!zfs_prop_valid_for_type(prop, type, B_FALSE)) {
	zfs_error_aux(hdl,
	dgettext(TEXT_DOMAIN, "'%s' does not "
	"apply to datasets of this type"), propname);
	(void) zfs_error(hdl, EZFS_PROPTYPE, errbuf);
	goto error;
	}

	if (zfs_prop_readonly(prop) &&
	!(zfs_prop_setonce(prop) && zhp == NULL) &&
	!(zfs_prop_encryption_key_param(prop) && key_params_ok)) {
	zfs_error_aux(hdl,
	dgettext(TEXT_DOMAIN, "'%s' is readonly"),
	propname);
	(void) zfs_error(hdl, EZFS_PROPREADONLY, errbuf);
	goto error;
	}

	if (zprop_parse_value(hdl, elem, prop, type, ret,
	&strval, &intval, errbuf) != 0)
	goto error;

	/*
	* Perform some additional checks for specific properties.
	*/
	switch (prop) {
	case ZFS_PROP_VERSION:
	{
	int version;

	if (zhp == NULL)
	break;
	version = zfs_prop_get_int(zhp, ZFS_PROP_VERSION);
	if (intval < version) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"Can not downgrade; already at version %u"),
	version);
	(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
	goto error;
	}
	break;
	}

	case ZFS_PROP_VOLBLOCKSIZE:
	case ZFS_PROP_RECORDSIZE:
	{
	int maxbs = SPA_MAXBLOCKSIZE;
	char buf[64];

	if (zpool_hdl != NULL) {
	maxbs = zpool_get_prop_int(zpool_hdl,
	ZPOOL_PROP_MAXBLOCKSIZE, NULL);
	}
	/*
	* The value must be a power of two between
	* SPA_MINBLOCKSIZE and maxbs.
	*/
	if (intval < SPA_MINBLOCKSIZE \|\|
	intval > maxbs \|\| !ISP2(intval)) {
	zfs_nicebytes(maxbs, buf, sizeof (buf));
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"'%s' must be power of 2 from 512B "
	"to %s"), propname, buf);
	(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
	goto error;
	}
	break;
	}

	case ZFS_PROP_SPECIAL_SMALL_BLOCKS:
	{
	int maxbs = SPA_OLD_MAXBLOCKSIZE;
	char buf[64];

	if (zpool_hdl != NULL) {
	char state[64] = "";

	maxbs = zpool_get_prop_int(zpool_hdl,
	ZPOOL_PROP_MAXBLOCKSIZE, NULL);

	/*
	* Issue a warning but do not fail so that
	* tests for settable properties succeed.
	*/
	if (zpool_prop_get_feature(zpool_hdl,
	"feature@allocation_classes", state,
	sizeof (state)) != 0 \|\|
	strcmp(state, ZFS_FEATURE_ACTIVE) != 0) {
	(void) fprintf(stderr, gettext(
	"%s: property requires a special "
	"device in the pool\n"), propname);
	}
	}
	if (intval != 0 &&
	(intval < SPA_MINBLOCKSIZE \|\|
	intval > maxbs \|\| !ISP2(intval))) {
	zfs_nicebytes(maxbs, buf, sizeof (buf));
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"invalid '%s=%d' property: must be zero or "
	"a power of 2 from 512B to %s"), propname,
	intval, buf);
	(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
	goto error;
	}
	break;
	}

	case ZFS_PROP_MLSLABEL:
	{
	#ifdef HAVE_MLSLABEL
	/*
	* Verify the mlslabel string and convert to
	* internal hex label string.
	*/

	m_label_t *new_sl;
	char hex = NULL; / internal label string */

	/* Default value is already OK. */
	if (strcasecmp(strval, ZFS_MLSLABEL_DEFAULT) == 0)
	break;

	/* Verify the label can be converted to binary form */
	if (((new_sl = m_label_alloc(MAC_LABEL)) == NULL) \|\|
	(str_to_label(strval, &new_sl, MAC_LABEL,
	L_NO_CORRECTION, NULL) == -1)) {
	goto badlabel;
	}

	/* Now translate to hex internal label string */
	if (label_to_str(new_sl, &hex, M_INTERNAL,
	DEF_NAMES) != 0) {
	if (hex)
	free(hex);
	goto badlabel;
	}
	m_label_free(new_sl);

	/* If string is already in internal form, we're done. */
	if (strcmp(strval, hex) == 0) {
	free(hex);
	break;
	}

	/* Replace the label string with the internal form. */
	(void) nvlist_remove(ret, zfs_prop_to_name(prop),
	DATA_TYPE_STRING);
	verify(nvlist_add_string(ret, zfs_prop_to_name(prop),
	hex) == 0);
	free(hex);

	break;

	badlabel:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"invalid mlslabel '%s'"), strval);
	(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
	m_label_free(new_sl); /* OK if null */
	goto error;
	#else
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"mlslabels are unsupported"));
	(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
	goto error;
	#endif /* HAVE_MLSLABEL */
	}

	case ZFS_PROP_MOUNTPOINT:
	{
	namecheck_err_t why;

	if (strcmp(strval, ZFS_MOUNTPOINT_NONE) == 0 \|\|
	strcmp(strval, ZFS_MOUNTPOINT_LEGACY) == 0)
	break;

	if (mountpoint_namecheck(strval, &why)) {
	switch (why) {
	case NAME_ERR_LEADING_SLASH:
	zfs_error_aux(hdl,
	dgettext(TEXT_DOMAIN,
	"'%s' must be an absolute path, "
	"'none', or 'legacy'"), propname);
	break;
	case NAME_ERR_TOOLONG:
	zfs_error_aux(hdl,
	dgettext(TEXT_DOMAIN,
	"component of '%s' is too long"),
	propname);
	break;

	default:
	zfs_error_aux(hdl,
	dgettext(TEXT_DOMAIN,
	"(%d) not defined"),
	why);
	break;
	}
	(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
	goto error;
	}
	}

	/FALLTHRU/

	case ZFS_PROP_SHARESMB:
	case ZFS_PROP_SHARENFS:
	/*
	* For the mountpoint and sharenfs or sharesmb
	* properties, check if it can be set in a
	* global/non-global zone based on
	* the zoned property value:
	*
	* global zone non-global zone
	* --------------------------------------------------
	* zoned=on mountpoint (no) mountpoint (yes)
	* sharenfs (no) sharenfs (no)
	* sharesmb (no) sharesmb (no)
	*
	* zoned=off mountpoint (yes) N/A
	* sharenfs (yes)
	* sharesmb (yes)
	*/
	if (zoned) {
	if (getzoneid() == GLOBAL_ZONEID) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"'%s' cannot be set on "
	"dataset in a non-global zone"),
	propname);
	(void) zfs_error(hdl, EZFS_ZONED,
	errbuf);
	goto error;
	} else if (prop == ZFS_PROP_SHARENFS \|\|
	prop == ZFS_PROP_SHARESMB) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"'%s' cannot be set in "
	"a non-global zone"), propname);
	(void) zfs_error(hdl, EZFS_ZONED,
	errbuf);
	goto error;
	}
	} else if (getzoneid() != GLOBAL_ZONEID) {
	/*
	* If zoned property is 'off', this must be in
	* a global zone. If not, something is wrong.
	*/
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"'%s' cannot be set while dataset "
	"'zoned' property is set"), propname);
	(void) zfs_error(hdl, EZFS_ZONED, errbuf);
	goto error;
	}

	/*
	* At this point, it is legitimate to set the
	* property. Now we want to make sure that the
	* property value is valid if it is sharenfs.
	*/
	if ((prop == ZFS_PROP_SHARENFS \|\|
	prop == ZFS_PROP_SHARESMB) &&
	strcmp(strval, "on") != 0 &&
	strcmp(strval, "off") != 0) {
	zfs_share_proto_t proto;

	if (prop == ZFS_PROP_SHARESMB)
	proto = PROTO_SMB;
	else
	proto = PROTO_NFS;

	if (zfs_parse_options(strval, proto) != SA_OK) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"'%s' cannot be set to invalid "
	"options"), propname);
	(void) zfs_error(hdl, EZFS_BADPROP,
	errbuf);
	goto error;
	}
	}

	break;

	case ZFS_PROP_KEYLOCATION:
	if (!zfs_prop_valid_keylocation(strval, B_FALSE)) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"invalid keylocation"));
	(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
	goto error;
	}

	if (zhp != NULL) {
	uint64_t crypt =
	zfs_prop_get_int(zhp, ZFS_PROP_ENCRYPTION);

	if (crypt == ZIO_CRYPT_OFF &&
	strcmp(strval, "none") != 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"keylocation must be 'none' "
	"for unencrypted datasets"));
	(void) zfs_error(hdl, EZFS_BADPROP,
	errbuf);
	goto error;
	} else if (crypt != ZIO_CRYPT_OFF &&
	strcmp(strval, "none") == 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"keylocation must not be 'none' "
	"for encrypted datasets"));
	(void) zfs_error(hdl, EZFS_BADPROP,
	errbuf);
	goto error;
	}
	}
	break;

	case ZFS_PROP_PBKDF2_ITERS:
	if (intval < MIN_PBKDF2_ITERATIONS) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"minimum pbkdf2 iterations is %u"),
	MIN_PBKDF2_ITERATIONS);
	(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
	goto error;
	}
	break;

	case ZFS_PROP_UTF8ONLY:
	chosen_utf = (int)intval;
	break;

	case ZFS_PROP_NORMALIZE:
	chosen_normal = (int)intval;
	break;

	default:
	break;
	}

	/*
	* For changes to existing volumes, we have some additional
	* checks to enforce.
	*/
	if (type == ZFS_TYPE_VOLUME && zhp != NULL) {
	uint64_t blocksize = zfs_prop_get_int(zhp,
	ZFS_PROP_VOLBLOCKSIZE);
	char buf[64];

	switch (prop) {
	case ZFS_PROP_VOLSIZE:
	if (intval % blocksize != 0) {
	zfs_nicebytes(blocksize, buf,
	sizeof (buf));
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"'%s' must be a multiple of "
	"volume block size (%s)"),
	propname, buf);
	(void) zfs_error(hdl, EZFS_BADPROP,
	errbuf);
	goto error;
	}

	if (intval == 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"'%s' cannot be zero"),
	propname);
	(void) zfs_error(hdl, EZFS_BADPROP,
	errbuf);
	goto error;
	}
	break;

	default:
	break;
	}
	}

	/* check encryption properties */
	if (zhp != NULL) {
	int64_t crypt = zfs_prop_get_int(zhp,
	ZFS_PROP_ENCRYPTION);

	switch (prop) {
	case ZFS_PROP_COPIES:
	if (crypt != ZIO_CRYPT_OFF && intval > 2) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"encrypted datasets cannot have "
	"3 copies"));
	(void) zfs_error(hdl, EZFS_BADPROP,
	errbuf);
	goto error;
	}
	break;
	default:
	break;
	}
	}
	}

	/*
	* If normalization was chosen, but no UTF8 choice was made,
	* enforce rejection of non-UTF8 names.
	*
	* If normalization was chosen, but rejecting non-UTF8 names
	* was explicitly not chosen, it is an error.
	*/
	if (chosen_normal > 0 && chosen_utf < 0) {
	if (nvlist_add_uint64(ret,
	zfs_prop_to_name(ZFS_PROP_UTF8ONLY), 1) != 0) {
	(void) no_memory(hdl);
	goto error;
	}
	} else if (chosen_normal > 0 && chosen_utf == 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"'%s' must be set 'on' if normalization chosen"),
	zfs_prop_to_name(ZFS_PROP_UTF8ONLY));
	(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
	goto error;
	}
	return (ret);

	error:
	nvlist_free(ret);
	return (NULL);
	}

	static int
	zfs_add_synthetic_resv(zfs_handle_t zhp, nvlist_t nvl)
	{
	uint64_t old_volsize;
	uint64_t new_volsize;
	uint64_t old_reservation;
	uint64_t new_reservation;
	zfs_prop_t resv_prop;
	nvlist_t *props;
	zpool_handle_t *zph = zpool_handle(zhp);

	/*
	* If this is an existing volume, and someone is setting the volsize,
	* make sure that it matches the reservation, or add it if necessary.
	*/
	old_volsize = zfs_prop_get_int(zhp, ZFS_PROP_VOLSIZE);
	if (zfs_which_resv_prop(zhp, &resv_prop) < 0)
	return (-1);
	old_reservation = zfs_prop_get_int(zhp, resv_prop);

	props = fnvlist_alloc();
	fnvlist_add_uint64(props, zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE),
	zfs_prop_get_int(zhp, ZFS_PROP_VOLBLOCKSIZE));

	if ((zvol_volsize_to_reservation(zph, old_volsize, props) !=
	old_reservation) \|\| nvlist_exists(nvl,
	zfs_prop_to_name(resv_prop))) {
	fnvlist_free(props);
	return (0);
	}
	if (nvlist_lookup_uint64(nvl, zfs_prop_to_name(ZFS_PROP_VOLSIZE),
	&new_volsize) != 0) {
	fnvlist_free(props);
	return (-1);
	}
	new_reservation = zvol_volsize_to_reservation(zph, new_volsize, props);
	fnvlist_free(props);

	if (nvlist_add_uint64(nvl, zfs_prop_to_name(resv_prop),
	new_reservation) != 0) {
	(void) no_memory(zhp->zfs_hdl);
	return (-1);
	}
	return (1);
	}

	/*
	* Helper for 'zfs {set\|clone} refreservation=auto'. Must be called after
	* zfs_valid_proplist(), as it is what sets the UINT64_MAX sentinel value.
	* Return codes must match zfs_add_synthetic_resv().
	*/
	static int
	zfs_fix_auto_resv(zfs_handle_t zhp, nvlist_t nvl)
	{
	uint64_t volsize;
	uint64_t resvsize;
	zfs_prop_t prop;
	nvlist_t *props;

	if (!ZFS_IS_VOLUME(zhp)) {
	return (0);
	}

	if (zfs_which_resv_prop(zhp, &prop) != 0) {
	return (-1);
	}

	if (prop != ZFS_PROP_REFRESERVATION) {
	return (0);
	}

	if (nvlist_lookup_uint64(nvl, zfs_prop_to_name(prop), &resvsize) != 0) {
	/* No value being set, so it can't be "auto" */
	return (0);
	}
	if (resvsize != UINT64_MAX) {
	/* Being set to a value other than "auto" */
	return (0);
	}

	props = fnvlist_alloc();

	fnvlist_add_uint64(props, zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE),
	zfs_prop_get_int(zhp, ZFS_PROP_VOLBLOCKSIZE));

	if (nvlist_lookup_uint64(nvl, zfs_prop_to_name(ZFS_PROP_VOLSIZE),
	&volsize) != 0) {
	volsize = zfs_prop_get_int(zhp, ZFS_PROP_VOLSIZE);
	}

	resvsize = zvol_volsize_to_reservation(zpool_handle(zhp), volsize,
	props);
	fnvlist_free(props);

	(void) nvlist_remove_all(nvl, zfs_prop_to_name(prop));
	if (nvlist_add_uint64(nvl, zfs_prop_to_name(prop), resvsize) != 0) {
	(void) no_memory(zhp->zfs_hdl);
	return (-1);
	}
	return (1);
	}

	static boolean_t
	zfs_is_namespace_prop(zfs_prop_t prop)
	{
	switch (prop) {

	case ZFS_PROP_ATIME:
	case ZFS_PROP_RELATIME:
	case ZFS_PROP_DEVICES:
	case ZFS_PROP_EXEC:
	case ZFS_PROP_SETUID:
	case ZFS_PROP_READONLY:
	case ZFS_PROP_XATTR:
	case ZFS_PROP_NBMAND:
	return (B_TRUE);

	default:
	return (B_FALSE);
	}
	}

	/*
	* Given a property name and value, set the property for the given dataset.
	*/
	int
	zfs_prop_set(zfs_handle_t zhp, const char propname, const char *propval)
	{
	int ret = -1;
	char errbuf[1024];
	libzfs_handle_t *hdl = zhp->zfs_hdl;
	nvlist_t *nvl = NULL;

	(void) snprintf(errbuf, sizeof (errbuf),
	dgettext(TEXT_DOMAIN, "cannot set property for '%s'"),
	zhp->zfs_name);

	if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0 \|\|
	nvlist_add_string(nvl, propname, propval) != 0) {
	(void) no_memory(hdl);
	goto error;
	}

	ret = zfs_prop_set_list(zhp, nvl);

	error:
	nvlist_free(nvl);
	return (ret);
	}



	/*
	* Given an nvlist of property names and values, set the properties for the
	* given dataset.
	*/
	int
	zfs_prop_set_list(zfs_handle_t zhp, nvlist_t props)
	{
	zfs_cmd_t zc = {"\0"};
	int ret = -1;
	prop_changelist_t **cls = NULL;
	int cl_idx;
	char errbuf[1024];
	libzfs_handle_t *hdl = zhp->zfs_hdl;
	nvlist_t *nvl;
	int nvl_len = 0;
	int added_resv = 0;
	zfs_prop_t prop = 0;
	nvpair_t *elem;

	(void) snprintf(errbuf, sizeof (errbuf),
	dgettext(TEXT_DOMAIN, "cannot set property for '%s'"),
	zhp->zfs_name);

	if ((nvl = zfs_valid_proplist(hdl, zhp->zfs_type, props,
	zfs_prop_get_int(zhp, ZFS_PROP_ZONED), zhp, zhp->zpool_hdl,
	B_FALSE, errbuf)) == NULL)
	goto error;

	/*
	* We have to check for any extra properties which need to be added
	* before computing the length of the nvlist.
	*/
	for (elem = nvlist_next_nvpair(nvl, NULL);
	elem != NULL;
	elem = nvlist_next_nvpair(nvl, elem)) {
	if (zfs_name_to_prop(nvpair_name(elem)) == ZFS_PROP_VOLSIZE &&
	(added_resv = zfs_add_synthetic_resv(zhp, nvl)) == -1) {
	goto error;
	}
	}

	if (added_resv != 1 &&
	(added_resv = zfs_fix_auto_resv(zhp, nvl)) == -1) {
	goto error;
	}

	/*
	* Check how many properties we're setting and allocate an array to
	* store changelist pointers for postfix().
	*/
	for (elem = nvlist_next_nvpair(nvl, NULL);
	elem != NULL;
	elem = nvlist_next_nvpair(nvl, elem))
	nvl_len++;
	if ((cls = calloc(nvl_len, sizeof (prop_changelist_t *))) == NULL)
	goto error;

	cl_idx = 0;
	for (elem = nvlist_next_nvpair(nvl, NULL);
	elem != NULL;
	elem = nvlist_next_nvpair(nvl, elem)) {

	prop = zfs_name_to_prop(nvpair_name(elem));

	assert(cl_idx < nvl_len);
	/*
	* We don't want to unmount & remount the dataset when changing
	* its canmount property to 'on' or 'noauto'. We only use
	* the changelist logic to unmount when setting canmount=off.
	*/
	if (prop != ZFS_PROP_CANMOUNT \|\|
	(fnvpair_value_uint64(elem) == ZFS_CANMOUNT_OFF &&
	zfs_is_mounted(zhp, NULL))) {
	cls[cl_idx] = changelist_gather(zhp, prop, 0, 0);
	if (cls[cl_idx] == NULL)
	goto error;
	}

	if (prop == ZFS_PROP_MOUNTPOINT &&
	changelist_haszonedchild(cls[cl_idx])) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"child dataset with inherited mountpoint is used "
	"in a non-global zone"));
	ret = zfs_error(hdl, EZFS_ZONED, errbuf);
	goto error;
	}

	if (cls[cl_idx] != NULL &&
	(ret = changelist_prefix(cls[cl_idx])) != 0)
	goto error;

	cl_idx++;
	}
	assert(cl_idx == nvl_len);

	/*
	* Execute the corresponding ioctl() to set this list of properties.
	*/
	(void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));

	if ((ret = zcmd_write_src_nvlist(hdl, &zc, nvl)) != 0 \|\|
	(ret = zcmd_alloc_dst_nvlist(hdl, &zc, 0)) != 0)
	goto error;

	ret = zfs_ioctl(hdl, ZFS_IOC_SET_PROP, &zc);

	if (ret != 0) {
	if (zc.zc_nvlist_dst_filled == B_FALSE) {
	(void) zfs_standard_error(hdl, errno, errbuf);
	goto error;
	}

	/* Get the list of unset properties back and report them. */
	nvlist_t *errorprops = NULL;
	if (zcmd_read_dst_nvlist(hdl, &zc, &errorprops) != 0)
	goto error;
	for (nvpair_t *elem = nvlist_next_nvpair(errorprops, NULL);
	elem != NULL;
	elem = nvlist_next_nvpair(errorprops, elem)) {
	prop = zfs_name_to_prop(nvpair_name(elem));
	zfs_setprop_error(hdl, prop, errno, errbuf);
	}
	nvlist_free(errorprops);

	if (added_resv && errno == ENOSPC) {
	/* clean up the volsize property we tried to set */
	uint64_t old_volsize = zfs_prop_get_int(zhp,
	ZFS_PROP_VOLSIZE);
	nvlist_free(nvl);
	nvl = NULL;
	zcmd_free_nvlists(&zc);

	if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0)
	goto error;
	if (nvlist_add_uint64(nvl,
	zfs_prop_to_name(ZFS_PROP_VOLSIZE),
	old_volsize) != 0)
	goto error;
	if (zcmd_write_src_nvlist(hdl, &zc, nvl) != 0)
	goto error;
	(void) zfs_ioctl(hdl, ZFS_IOC_SET_PROP, &zc);
	}
	} else {
	for (cl_idx = 0; cl_idx < nvl_len; cl_idx++) {
	if (cls[cl_idx] != NULL) {
	int clp_err = changelist_postfix(cls[cl_idx]);
	if (clp_err != 0)
	ret = clp_err;
	}
	}

	if (ret == 0) {
	/*
	* Refresh the statistics so the new property
	* value is reflected.
	*/
	(void) get_stats(zhp);

	/*
	* Remount the filesystem to propagate the change
	* if one of the options handled by the generic
	* Linux namespace layer has been modified.
	*/
	if (zfs_is_namespace_prop(prop) &&
	zfs_is_mounted(zhp, NULL))
	ret = zfs_mount(zhp, MNTOPT_REMOUNT, 0);
	}
	}

	error:
	nvlist_free(nvl);
	zcmd_free_nvlists(&zc);
	if (cls != NULL) {
	for (cl_idx = 0; cl_idx < nvl_len; cl_idx++) {
	if (cls[cl_idx] != NULL)
	changelist_free(cls[cl_idx]);
	}
	free(cls);
	}
	return (ret);
	}

	/*
	* Given a property, inherit the value from the parent dataset, or if received
	* is TRUE, revert to the received value, if any.
	*/
	int
	zfs_prop_inherit(zfs_handle_t zhp, const char propname, boolean_t received)
	{
	zfs_cmd_t zc = {"\0"};
	int ret;
	prop_changelist_t *cl;
	libzfs_handle_t *hdl = zhp->zfs_hdl;
	char errbuf[1024];
	zfs_prop_t prop;

	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
	"cannot inherit %s for '%s'"), propname, zhp->zfs_name);

	zc.zc_cookie = received;
	if ((prop = zfs_name_to_prop(propname)) == ZPROP_INVAL) {
	/*
	* For user properties, the amount of work we have to do is very
	* small, so just do it here.
	*/
	if (!zfs_prop_user(propname)) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"invalid property"));
	return (zfs_error(hdl, EZFS_BADPROP, errbuf));
	}

	(void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
	(void) strlcpy(zc.zc_value, propname, sizeof (zc.zc_value));

	if (zfs_ioctl(zhp->zfs_hdl, ZFS_IOC_INHERIT_PROP, &zc) != 0)
	return (zfs_standard_error(hdl, errno, errbuf));

	+ (void) get_stats(zhp);
	return (0);
	}

	/*
	* Verify that this property is inheritable.
	*/
	if (zfs_prop_readonly(prop))
	return (zfs_error(hdl, EZFS_PROPREADONLY, errbuf));

	if (!zfs_prop_inheritable(prop) && !received)
	return (zfs_error(hdl, EZFS_PROPNONINHERIT, errbuf));

	/*
	* Check to see if the value applies to this type
	*/
	if (!zfs_prop_valid_for_type(prop, zhp->zfs_type, B_FALSE))
	return (zfs_error(hdl, EZFS_PROPTYPE, errbuf));

	/*
	* Normalize the name, to get rid of shorthand abbreviations.
	*/
	propname = zfs_prop_to_name(prop);
	(void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
	(void) strlcpy(zc.zc_value, propname, sizeof (zc.zc_value));

	if (prop == ZFS_PROP_MOUNTPOINT && getzoneid() == GLOBAL_ZONEID &&
	zfs_prop_get_int(zhp, ZFS_PROP_ZONED)) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"dataset is used in a non-global zone"));
	return (zfs_error(hdl, EZFS_ZONED, errbuf));
	}

	/*
	* Determine datasets which will be affected by this change, if any.
	*/
	if ((cl = changelist_gather(zhp, prop, 0, 0)) == NULL)
	return (-1);

	if (prop == ZFS_PROP_MOUNTPOINT && changelist_haszonedchild(cl)) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"child dataset with inherited mountpoint is used "
	"in a non-global zone"));
	ret = zfs_error(hdl, EZFS_ZONED, errbuf);
	goto error;
	}

	if ((ret = changelist_prefix(cl)) != 0)
	goto error;

	if ((ret = zfs_ioctl(zhp->zfs_hdl, ZFS_IOC_INHERIT_PROP, &zc)) != 0) {
	return (zfs_standard_error(hdl, errno, errbuf));
	} else {

	if ((ret = changelist_postfix(cl)) != 0)
	goto error;

	/*
	* Refresh the statistics so the new property is reflected.
	*/
	(void) get_stats(zhp);

	/*
	* Remount the filesystem to propagate the change
	* if one of the options handled by the generic
	* Linux namespace layer has been modified.
	*/
	if (zfs_is_namespace_prop(prop) &&
	zfs_is_mounted(zhp, NULL))
	ret = zfs_mount(zhp, MNTOPT_REMOUNT, 0);
	}

	error:
	changelist_free(cl);
	return (ret);
	}

	/*
	* True DSL properties are stored in an nvlist. The following two functions
	* extract them appropriately.
	*/
	uint64_t
	getprop_uint64(zfs_handle_t zhp, zfs_prop_t prop, char *source)
	{
	nvlist_t *nv;
	uint64_t value;

	*source = NULL;
	if (nvlist_lookup_nvlist(zhp->zfs_props,
	zfs_prop_to_name(prop), &nv) == 0) {
	verify(nvlist_lookup_uint64(nv, ZPROP_VALUE, &value) == 0);
	(void) nvlist_lookup_string(nv, ZPROP_SOURCE, source);
	} else {
	verify(!zhp->zfs_props_table \|\|
	zhp->zfs_props_table[prop] == B_TRUE);
	value = zfs_prop_default_numeric(prop);
	*source = "";
	}

	return (value);
	}

	static const char *
	getprop_string(zfs_handle_t zhp, zfs_prop_t prop, char *source)
	{
	nvlist_t *nv;
	const char *value;

	*source = NULL;
	if (nvlist_lookup_nvlist(zhp->zfs_props,
	zfs_prop_to_name(prop), &nv) == 0) {
	value = fnvlist_lookup_string(nv, ZPROP_VALUE);
	(void) nvlist_lookup_string(nv, ZPROP_SOURCE, source);
	} else {
	verify(!zhp->zfs_props_table \|\|
	zhp->zfs_props_table[prop] == B_TRUE);
	value = zfs_prop_default_string(prop);
	*source = "";
	}

	return (value);
	}

	static boolean_t
	zfs_is_recvd_props_mode(zfs_handle_t *zhp)
	{
	return (zhp->zfs_props == zhp->zfs_recvd_props);
	}

	static void
	zfs_set_recvd_props_mode(zfs_handle_t zhp, uint64_t cookie)
	{
	*cookie = (uint64_t)(uintptr_t)zhp->zfs_props;
	zhp->zfs_props = zhp->zfs_recvd_props;
	}

	static void
	zfs_unset_recvd_props_mode(zfs_handle_t zhp, uint64_t cookie)
	{
	zhp->zfs_props = (nvlist_t )(uintptr_t)cookie;
	*cookie = 0;
	}

	/*
	* Internal function for getting a numeric property. Both zfs_prop_get() and
	* zfs_prop_get_int() are built using this interface.
	*
	* Certain properties can be overridden using 'mount -o'. In this case, scan
	* the contents of the /proc/self/mounts entry, searching for the
	* appropriate options. If they differ from the on-disk values, report the
	* current values and mark the source "temporary".
	*/
	static int
	get_numeric_property(zfs_handle_t zhp, zfs_prop_t prop, zprop_source_t src,
	char *source, uint64_t val)
	{
	zfs_cmd_t zc = {"\0"};
	nvlist_t *zplprops = NULL;
	struct mnttab mnt;
	char *mntopt_on = NULL;
	char *mntopt_off = NULL;
	boolean_t received = zfs_is_recvd_props_mode(zhp);

	*source = NULL;

	/*
	* If the property is being fetched for a snapshot, check whether
	* the property is valid for the snapshot's head dataset type.
	*/
	if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT &&
	!zfs_prop_valid_for_type(prop, zhp->zfs_head_type, B_TRUE)) {
	*val = zfs_prop_default_numeric(prop);
	return (-1);
	}

	switch (prop) {
	case ZFS_PROP_ATIME:
	mntopt_on = MNTOPT_ATIME;
	mntopt_off = MNTOPT_NOATIME;
	break;

	case ZFS_PROP_RELATIME:
	mntopt_on = MNTOPT_RELATIME;
	mntopt_off = MNTOPT_NORELATIME;
	break;

	case ZFS_PROP_DEVICES:
	mntopt_on = MNTOPT_DEVICES;
	mntopt_off = MNTOPT_NODEVICES;
	break;

	case ZFS_PROP_EXEC:
	mntopt_on = MNTOPT_EXEC;
	mntopt_off = MNTOPT_NOEXEC;
	break;

	case ZFS_PROP_READONLY:
	mntopt_on = MNTOPT_RO;
	mntopt_off = MNTOPT_RW;
	break;

	case ZFS_PROP_SETUID:
	mntopt_on = MNTOPT_SETUID;
	mntopt_off = MNTOPT_NOSETUID;
	break;

	case ZFS_PROP_XATTR:
	mntopt_on = MNTOPT_XATTR;
	mntopt_off = MNTOPT_NOXATTR;
	break;

	case ZFS_PROP_NBMAND:
	mntopt_on = MNTOPT_NBMAND;
	mntopt_off = MNTOPT_NONBMAND;
	break;

	default:
	break;
	}

	/*
	* Because looking up the mount options is potentially expensive
	* (iterating over all of /proc/self/mounts), we defer its
	* calculation until we're looking up a property which requires
	* its presence.
	*/
	if (!zhp->zfs_mntcheck &&
	(mntopt_on != NULL \|\| prop == ZFS_PROP_MOUNTED)) {
	libzfs_handle_t *hdl = zhp->zfs_hdl;
	struct mnttab entry;

	if (libzfs_mnttab_find(hdl, zhp->zfs_name, &entry) == 0) {
	zhp->zfs_mntopts = zfs_strdup(hdl,
	entry.mnt_mntopts);
	if (zhp->zfs_mntopts == NULL)
	return (-1);
	}

	zhp->zfs_mntcheck = B_TRUE;
	}

	if (zhp->zfs_mntopts == NULL)
	mnt.mnt_mntopts = "";
	else
	mnt.mnt_mntopts = zhp->zfs_mntopts;

	switch (prop) {
	case ZFS_PROP_ATIME:
	case ZFS_PROP_RELATIME:
	case ZFS_PROP_DEVICES:
	case ZFS_PROP_EXEC:
	case ZFS_PROP_READONLY:
	case ZFS_PROP_SETUID:
	#ifndef __FreeBSD__
	case ZFS_PROP_XATTR:
	#endif
	case ZFS_PROP_NBMAND:
	*val = getprop_uint64(zhp, prop, source);

	if (received)
	break;

	if (hasmntopt(&mnt, mntopt_on) && !*val) {
	*val = B_TRUE;
	if (src)
	*src = ZPROP_SRC_TEMPORARY;
	} else if (hasmntopt(&mnt, mntopt_off) && *val) {
	*val = B_FALSE;
	if (src)
	*src = ZPROP_SRC_TEMPORARY;
	}
	break;

	case ZFS_PROP_CANMOUNT:
	case ZFS_PROP_VOLSIZE:
	case ZFS_PROP_QUOTA:
	case ZFS_PROP_REFQUOTA:
	case ZFS_PROP_RESERVATION:
	case ZFS_PROP_REFRESERVATION:
	case ZFS_PROP_FILESYSTEM_LIMIT:
	case ZFS_PROP_SNAPSHOT_LIMIT:
	case ZFS_PROP_FILESYSTEM_COUNT:
	case ZFS_PROP_SNAPSHOT_COUNT:
	*val = getprop_uint64(zhp, prop, source);

	if (*source == NULL) {
	/* not default, must be local */
	*source = zhp->zfs_name;
	}
	break;

	case ZFS_PROP_MOUNTED:
	*val = (zhp->zfs_mntopts != NULL);
	break;

	case ZFS_PROP_NUMCLONES:
	*val = zhp->zfs_dmustats.dds_num_clones;
	break;

	case ZFS_PROP_VERSION:
	case ZFS_PROP_NORMALIZE:
	case ZFS_PROP_UTF8ONLY:
	case ZFS_PROP_CASE:
	if (zcmd_alloc_dst_nvlist(zhp->zfs_hdl, &zc, 0) != 0)
	return (-1);
	(void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
	if (zfs_ioctl(zhp->zfs_hdl, ZFS_IOC_OBJSET_ZPLPROPS, &zc)) {
	zcmd_free_nvlists(&zc);
	if (prop == ZFS_PROP_VERSION &&
	zhp->zfs_type == ZFS_TYPE_VOLUME)
	*val = zfs_prop_default_numeric(prop);
	return (-1);
	}
	if (zcmd_read_dst_nvlist(zhp->zfs_hdl, &zc, &zplprops) != 0 \|\|
	nvlist_lookup_uint64(zplprops, zfs_prop_to_name(prop),
	val) != 0) {
	zcmd_free_nvlists(&zc);
	return (-1);
	}
	nvlist_free(zplprops);
	zcmd_free_nvlists(&zc);
	break;

	case ZFS_PROP_INCONSISTENT:
	*val = zhp->zfs_dmustats.dds_inconsistent;
	break;

	case ZFS_PROP_REDACTED:
	*val = zhp->zfs_dmustats.dds_redacted;
	break;

	default:
	switch (zfs_prop_get_type(prop)) {
	case PROP_TYPE_NUMBER:
	case PROP_TYPE_INDEX:
	*val = getprop_uint64(zhp, prop, source);
	/*
	* If we tried to use a default value for a
	* readonly property, it means that it was not
	* present. Note this only applies to "truly"
	* readonly properties, not set-once properties
	* like volblocksize.
	*/
	if (zfs_prop_readonly(prop) &&
	!zfs_prop_setonce(prop) &&
	source != NULL && (source)[0] == '\0') {
	*source = NULL;
	return (-1);
	}
	break;

	case PROP_TYPE_STRING:
	default:
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"cannot get non-numeric property"));
	return (zfs_error(zhp->zfs_hdl, EZFS_BADPROP,
	dgettext(TEXT_DOMAIN, "internal error")));
	}
	}

	return (0);
	}

	/*
	* Calculate the source type, given the raw source string.
	*/
	static void
	get_source(zfs_handle_t zhp, zprop_source_t srctype, char *source,
	char *statbuf, size_t statlen)
	{
	if (statbuf == NULL \|\|
	srctype == NULL \|\| *srctype == ZPROP_SRC_TEMPORARY) {
	return;
	}

	if (source == NULL) {
	*srctype = ZPROP_SRC_NONE;
	} else if (source[0] == '\0') {
	*srctype = ZPROP_SRC_DEFAULT;
	} else if (strstr(source, ZPROP_SOURCE_VAL_RECVD) != NULL) {
	*srctype = ZPROP_SRC_RECEIVED;
	} else {
	if (strcmp(source, zhp->zfs_name) == 0) {
	*srctype = ZPROP_SRC_LOCAL;
	} else {
	(void) strlcpy(statbuf, source, statlen);
	*srctype = ZPROP_SRC_INHERITED;
	}
	}

	}

	int
	zfs_prop_get_recvd(zfs_handle_t zhp, const char propname, char *propbuf,
	size_t proplen, boolean_t literal)
	{
	zfs_prop_t prop;
	int err = 0;

	if (zhp->zfs_recvd_props == NULL)
	if (get_recvd_props_ioctl(zhp) != 0)
	return (-1);

	prop = zfs_name_to_prop(propname);

	if (prop != ZPROP_INVAL) {
	uint64_t cookie;
	if (!nvlist_exists(zhp->zfs_recvd_props, propname))
	return (-1);
	zfs_set_recvd_props_mode(zhp, &cookie);
	err = zfs_prop_get(zhp, prop, propbuf, proplen,
	NULL, NULL, 0, literal);
	zfs_unset_recvd_props_mode(zhp, &cookie);
	} else {
	nvlist_t *propval;
	char *recvdval;
	if (nvlist_lookup_nvlist(zhp->zfs_recvd_props,
	propname, &propval) != 0)
	return (-1);
	verify(nvlist_lookup_string(propval, ZPROP_VALUE,
	&recvdval) == 0);
	(void) strlcpy(propbuf, recvdval, proplen);
	}

	return (err == 0 ? 0 : -1);
	}

	static int
	get_clones_string(zfs_handle_t zhp, char propbuf, size_t proplen)
	{
	nvlist_t *value;
	nvpair_t *pair;

	value = zfs_get_clones_nvl(zhp);
	- if (value == NULL)
	+ if (value == NULL \|\| nvlist_empty(value))
	return (-1);

	propbuf[0] = '\0';
	for (pair = nvlist_next_nvpair(value, NULL); pair != NULL;
	pair = nvlist_next_nvpair(value, pair)) {
	if (propbuf[0] != '\0')
	(void) strlcat(propbuf, ",", proplen);
	(void) strlcat(propbuf, nvpair_name(pair), proplen);
	}

	return (0);
	}

	struct get_clones_arg {
	uint64_t numclones;
	nvlist_t *value;
	const char *origin;
	char buf[ZFS_MAX_DATASET_NAME_LEN];
	};

	static int
	get_clones_cb(zfs_handle_t zhp, void arg)
	{
	struct get_clones_arg *gca = arg;

	if (gca->numclones == 0) {
	zfs_close(zhp);
	return (0);
	}

	if (zfs_prop_get(zhp, ZFS_PROP_ORIGIN, gca->buf, sizeof (gca->buf),
	NULL, NULL, 0, B_TRUE) != 0)
	goto out;
	if (strcmp(gca->buf, gca->origin) == 0) {
	fnvlist_add_boolean(gca->value, zfs_get_name(zhp));
	gca->numclones--;
	}

	out:
	(void) zfs_iter_children(zhp, get_clones_cb, gca);
	zfs_close(zhp);
	return (0);
	}

	nvlist_t *
	zfs_get_clones_nvl(zfs_handle_t *zhp)
	{
	nvlist_t nv, value;

	if (nvlist_lookup_nvlist(zhp->zfs_props,
	zfs_prop_to_name(ZFS_PROP_CLONES), &nv) != 0) {
	struct get_clones_arg gca;

	/*
	* if this is a snapshot, then the kernel wasn't able
	* to get the clones. Do it by slowly iterating.
	*/
	if (zhp->zfs_type != ZFS_TYPE_SNAPSHOT)
	return (NULL);
	if (nvlist_alloc(&nv, NV_UNIQUE_NAME, 0) != 0)
	return (NULL);
	if (nvlist_alloc(&value, NV_UNIQUE_NAME, 0) != 0) {
	nvlist_free(nv);
	return (NULL);
	}

	gca.numclones = zfs_prop_get_int(zhp, ZFS_PROP_NUMCLONES);
	gca.value = value;
	gca.origin = zhp->zfs_name;

	if (gca.numclones != 0) {
	zfs_handle_t *root;
	char pool[ZFS_MAX_DATASET_NAME_LEN];
	char *cp = pool;

	/* get the pool name */
	(void) strlcpy(pool, zhp->zfs_name, sizeof (pool));
	(void) strsep(&cp, "/@");
	root = zfs_open(zhp->zfs_hdl, pool,
	ZFS_TYPE_FILESYSTEM);
	if (root == NULL) {
	nvlist_free(nv);
	nvlist_free(value);
	return (NULL);
	}

	(void) get_clones_cb(root, &gca);
	}

	if (gca.numclones != 0 \|\|
	nvlist_add_nvlist(nv, ZPROP_VALUE, value) != 0 \|\|
	nvlist_add_nvlist(zhp->zfs_props,
	zfs_prop_to_name(ZFS_PROP_CLONES), nv) != 0) {
	nvlist_free(nv);
	nvlist_free(value);
	return (NULL);
	}
	nvlist_free(nv);
	nvlist_free(value);
	verify(0 == nvlist_lookup_nvlist(zhp->zfs_props,
	zfs_prop_to_name(ZFS_PROP_CLONES), &nv));
	}

	verify(nvlist_lookup_nvlist(nv, ZPROP_VALUE, &value) == 0);

	return (value);
	}

	static int
	get_rsnaps_string(zfs_handle_t zhp, char propbuf, size_t proplen)
	{
	nvlist_t *value;
	uint64_t *snaps;
	uint_t nsnaps;

	if (nvlist_lookup_nvlist(zhp->zfs_props,
	zfs_prop_to_name(ZFS_PROP_REDACT_SNAPS), &value) != 0)
	return (-1);
	if (nvlist_lookup_uint64_array(value, ZPROP_VALUE, &snaps,
	&nsnaps) != 0)
	return (-1);
	if (nsnaps == 0) {
	/* There's no redaction snapshots; pass a special value back */
	(void) snprintf(propbuf, proplen, "none");
	return (0);
	}
	propbuf[0] = '\0';
	for (int i = 0; i < nsnaps; i++) {
	char buf[128];
	if (propbuf[0] != '\0')
	(void) strlcat(propbuf, ",", proplen);
	(void) snprintf(buf, sizeof (buf), "%llu",
	(u_longlong_t)snaps[i]);
	(void) strlcat(propbuf, buf, proplen);
	}

	return (0);
	}

	/*
	* Accepts a property and value and checks that the value
	* matches the one found by the channel program. If they are
	* not equal, print both of them.
	*/
	static void
	zcp_check(zfs_handle_t *zhp, zfs_prop_t prop, uint64_t intval,
	const char *strval)
	{
	if (!zhp->zfs_hdl->libzfs_prop_debug)
	return;
	int error;
	char *poolname = zhp->zpool_hdl->zpool_name;
	const char *prop_name = zfs_prop_to_name(prop);
	const char *program =
	"args = ...\n"
	"ds = args['dataset']\n"
	"prop = args['property']\n"
	"value, setpoint = zfs.get_prop(ds, prop)\n"
	"return {value=value, setpoint=setpoint}\n";
	nvlist_t *outnvl;
	nvlist_t *retnvl;
	nvlist_t *argnvl = fnvlist_alloc();

	fnvlist_add_string(argnvl, "dataset", zhp->zfs_name);
	fnvlist_add_string(argnvl, "property", zfs_prop_to_name(prop));

	error = lzc_channel_program_nosync(poolname, program,
	10 * 1000 * 1000, 10 * 1024 * 1024, argnvl, &outnvl);

	if (error == 0) {
	retnvl = fnvlist_lookup_nvlist(outnvl, "return");
	if (zfs_prop_get_type(prop) == PROP_TYPE_NUMBER) {
	int64_t ans;
	error = nvlist_lookup_int64(retnvl, "value", &ans);
	if (error != 0) {
	(void) fprintf(stderr, "%s: zcp check error: "
	"%u\n", prop_name, error);
	return;
	}
	if (ans != intval) {
	(void) fprintf(stderr, "%s: zfs found %llu, "
	"but zcp found %llu\n", prop_name,
	(u_longlong_t)intval, (u_longlong_t)ans);
	}
	} else {
	char *str_ans;
	error = nvlist_lookup_string(retnvl, "value", &str_ans);
	if (error != 0) {
	(void) fprintf(stderr, "%s: zcp check error: "
	"%u\n", prop_name, error);
	return;
	}
	if (strcmp(strval, str_ans) != 0) {
	(void) fprintf(stderr,
	"%s: zfs found '%s', but zcp found '%s'\n",
	prop_name, strval, str_ans);
	}
	}
	} else {
	(void) fprintf(stderr, "%s: zcp check failed, channel program "
	"error: %u\n", prop_name, error);
	}
	nvlist_free(argnvl);
	nvlist_free(outnvl);
	}

	/*
	* Retrieve a property from the given object. If 'literal' is specified, then
	* numbers are left as exact values. Otherwise, numbers are converted to a
	* human-readable form.
	*
	* Returns 0 on success, or -1 on error.
	*/
	int
	zfs_prop_get(zfs_handle_t zhp, zfs_prop_t prop, char propbuf, size_t proplen,
	zprop_source_t src, char statbuf, size_t statlen, boolean_t literal)
	{
	char *source = NULL;
	uint64_t val;
	const char *str;
	const char *strval;
	boolean_t received = zfs_is_recvd_props_mode(zhp);

	/*
	* Check to see if this property applies to our object
	*/
	if (!zfs_prop_valid_for_type(prop, zhp->zfs_type, B_FALSE))
	return (-1);

	if (received && zfs_prop_readonly(prop))
	return (-1);

	if (src)
	*src = ZPROP_SRC_NONE;

	switch (prop) {
	case ZFS_PROP_CREATION:
	/*
	* 'creation' is a time_t stored in the statistics. We convert
	* this into a string unless 'literal' is specified.
	*/
	{
	val = getprop_uint64(zhp, prop, &source);
	time_t time = (time_t)val;
	struct tm t;

	if (literal \|\|
	localtime_r(&time, &t) == NULL \|\|
	strftime(propbuf, proplen, "%a %b %e %k:%M %Y",
	&t) == 0)
	(void) snprintf(propbuf, proplen, "%llu",
	(u_longlong_t)val);
	}
	zcp_check(zhp, prop, val, NULL);
	break;

	case ZFS_PROP_MOUNTPOINT:
	/*
	* Getting the precise mountpoint can be tricky.
	*
	* - for 'none' or 'legacy', return those values.
	* - for inherited mountpoints, we want to take everything
	* after our ancestor and append it to the inherited value.
	*
	* If the pool has an alternate root, we want to prepend that
	* root to any values we return.
	*/

	str = getprop_string(zhp, prop, &source);

	if (str[0] == '/') {
	char buf[MAXPATHLEN];
	char *root = buf;
	const char *relpath;

	/*
	* If we inherit the mountpoint, even from a dataset
	* with a received value, the source will be the path of
	* the dataset we inherit from. If source is
	* ZPROP_SOURCE_VAL_RECVD, the received value is not
	* inherited.
	*/
	if (strcmp(source, ZPROP_SOURCE_VAL_RECVD) == 0) {
	relpath = "";
	} else {
	relpath = zhp->zfs_name + strlen(source);
	if (relpath[0] == '/')
	relpath++;
	}

	if ((zpool_get_prop(zhp->zpool_hdl,
	ZPOOL_PROP_ALTROOT, buf, MAXPATHLEN, NULL,
	B_FALSE)) \|\| (strcmp(root, "-") == 0))
	root[0] = '\0';
	/*
	* Special case an alternate root of '/'. This will
	* avoid having multiple leading slashes in the
	* mountpoint path.
	*/
	if (strcmp(root, "/") == 0)
	root++;

	/*
	* If the mountpoint is '/' then skip over this
	* if we are obtaining either an alternate root or
	* an inherited mountpoint.
	*/
	if (str[1] == '\0' && (root[0] != '\0' \|\|
	relpath[0] != '\0'))
	str++;

	if (relpath[0] == '\0')
	(void) snprintf(propbuf, proplen, "%s%s",
	root, str);
	else
	(void) snprintf(propbuf, proplen, "%s%s%s%s",
	root, str, relpath[0] == '@' ? "" : "/",
	relpath);
	} else {
	/* 'legacy' or 'none' */
	(void) strlcpy(propbuf, str, proplen);
	}
	zcp_check(zhp, prop, 0, propbuf);
	break;

	case ZFS_PROP_ORIGIN:
	str = getprop_string(zhp, prop, &source);
	if (str == NULL)
	return (-1);
	(void) strlcpy(propbuf, str, proplen);
	zcp_check(zhp, prop, 0, str);
	break;

	case ZFS_PROP_REDACT_SNAPS:
	if (get_rsnaps_string(zhp, propbuf, proplen) != 0)
	return (-1);
	break;

	case ZFS_PROP_CLONES:
	if (get_clones_string(zhp, propbuf, proplen) != 0)
	return (-1);
	break;

	case ZFS_PROP_QUOTA:
	case ZFS_PROP_REFQUOTA:
	case ZFS_PROP_RESERVATION:
	case ZFS_PROP_REFRESERVATION:

	if (get_numeric_property(zhp, prop, src, &source, &val) != 0)
	return (-1);
	/*
	* If quota or reservation is 0, we translate this into 'none'
	* (unless literal is set), and indicate that it's the default
	* value. Otherwise, we print the number nicely and indicate
	* that its set locally.
	*/
	if (val == 0) {
	if (literal)
	(void) strlcpy(propbuf, "0", proplen);
	else
	(void) strlcpy(propbuf, "none", proplen);
	} else {
	if (literal)
	(void) snprintf(propbuf, proplen, "%llu",
	(u_longlong_t)val);
	else
	zfs_nicebytes(val, propbuf, proplen);
	}
	zcp_check(zhp, prop, val, NULL);
	break;

	case ZFS_PROP_FILESYSTEM_LIMIT:
	case ZFS_PROP_SNAPSHOT_LIMIT:
	case ZFS_PROP_FILESYSTEM_COUNT:
	case ZFS_PROP_SNAPSHOT_COUNT:

	if (get_numeric_property(zhp, prop, src, &source, &val) != 0)
	return (-1);

	/*
	* If limit is UINT64_MAX, we translate this into 'none' (unless
	* literal is set), and indicate that it's the default value.
	* Otherwise, we print the number nicely and indicate that it's
	* set locally.
	*/
	if (literal) {
	(void) snprintf(propbuf, proplen, "%llu",
	(u_longlong_t)val);
	} else if (val == UINT64_MAX) {
	(void) strlcpy(propbuf, "none", proplen);
	} else {
	zfs_nicenum(val, propbuf, proplen);
	}

	zcp_check(zhp, prop, val, NULL);
	break;

	case ZFS_PROP_REFRATIO:
	case ZFS_PROP_COMPRESSRATIO:
	if (get_numeric_property(zhp, prop, src, &source, &val) != 0)
	return (-1);
	if (literal)
	(void) snprintf(propbuf, proplen, "%llu.%02llu",
	(u_longlong_t)(val / 100),
	(u_longlong_t)(val % 100));
	else
	(void) snprintf(propbuf, proplen, "%llu.%02llux",
	(u_longlong_t)(val / 100),
	(u_longlong_t)(val % 100));
	zcp_check(zhp, prop, val, NULL);
	break;

	case ZFS_PROP_TYPE:
	switch (zhp->zfs_type) {
	case ZFS_TYPE_FILESYSTEM:
	str = "filesystem";
	break;
	case ZFS_TYPE_VOLUME:
	str = "volume";
	break;
	case ZFS_TYPE_SNAPSHOT:
	str = "snapshot";
	break;
	case ZFS_TYPE_BOOKMARK:
	str = "bookmark";
	break;
	default:
	abort();
	}
	(void) snprintf(propbuf, proplen, "%s", str);
	zcp_check(zhp, prop, 0, propbuf);
	break;

	case ZFS_PROP_MOUNTED:
	/*
	* The 'mounted' property is a pseudo-property that described
	* whether the filesystem is currently mounted. Even though
	* it's a boolean value, the typical values of "on" and "off"
	* don't make sense, so we translate to "yes" and "no".
	*/
	if (get_numeric_property(zhp, ZFS_PROP_MOUNTED,
	src, &source, &val) != 0)
	return (-1);
	if (val)
	(void) strlcpy(propbuf, "yes", proplen);
	else
	(void) strlcpy(propbuf, "no", proplen);
	break;

	case ZFS_PROP_NAME:
	/*
	* The 'name' property is a pseudo-property derived from the
	* dataset name. It is presented as a real property to simplify
	* consumers.
	*/
	(void) strlcpy(propbuf, zhp->zfs_name, proplen);
	zcp_check(zhp, prop, 0, propbuf);
	break;

	case ZFS_PROP_MLSLABEL:
	{
	#ifdef HAVE_MLSLABEL
	m_label_t *new_sl = NULL;
	char ascii = NULL; / human readable label */

	(void) strlcpy(propbuf,
	getprop_string(zhp, prop, &source), proplen);

	if (literal \|\| (strcasecmp(propbuf,
	ZFS_MLSLABEL_DEFAULT) == 0))
	break;

	/*
	* Try to translate the internal hex string to
	* human-readable output. If there are any
	* problems just use the hex string.
	*/

	if (str_to_label(propbuf, &new_sl, MAC_LABEL,
	L_NO_CORRECTION, NULL) == -1) {
	m_label_free(new_sl);
	break;
	}

	if (label_to_str(new_sl, &ascii, M_LABEL,
	DEF_NAMES) != 0) {
	if (ascii)
	free(ascii);
	m_label_free(new_sl);
	break;
	}
	m_label_free(new_sl);

	(void) strlcpy(propbuf, ascii, proplen);
	free(ascii);
	#else
	(void) strlcpy(propbuf,
	getprop_string(zhp, prop, &source), proplen);
	#endif /* HAVE_MLSLABEL */
	}
	break;

	case ZFS_PROP_GUID:
	case ZFS_PROP_CREATETXG:
	case ZFS_PROP_OBJSETID:
	case ZFS_PROP_PBKDF2_ITERS:
	/*
	* These properties are stored as numbers, but they are
	* identifiers or counters.
	* We don't want them to be pretty printed, because pretty
	* printing truncates their values making them useless.
	*/
	if (get_numeric_property(zhp, prop, src, &source, &val) != 0)
	return (-1);
	(void) snprintf(propbuf, proplen, "%llu", (u_longlong_t)val);
	zcp_check(zhp, prop, val, NULL);
	break;

	case ZFS_PROP_REFERENCED:
	case ZFS_PROP_AVAILABLE:
	case ZFS_PROP_USED:
	case ZFS_PROP_USEDSNAP:
	case ZFS_PROP_USEDDS:
	case ZFS_PROP_USEDREFRESERV:
	case ZFS_PROP_USEDCHILD:
	if (get_numeric_property(zhp, prop, src, &source, &val) != 0)
	return (-1);
	if (literal) {
	(void) snprintf(propbuf, proplen, "%llu",
	(u_longlong_t)val);
	} else {
	zfs_nicebytes(val, propbuf, proplen);
	}
	zcp_check(zhp, prop, val, NULL);
	break;

	default:
	switch (zfs_prop_get_type(prop)) {
	case PROP_TYPE_NUMBER:
	if (get_numeric_property(zhp, prop, src,
	&source, &val) != 0) {
	return (-1);
	}

	if (literal) {
	(void) snprintf(propbuf, proplen, "%llu",
	(u_longlong_t)val);
	} else {
	zfs_nicenum(val, propbuf, proplen);
	}
	zcp_check(zhp, prop, val, NULL);
	break;

	case PROP_TYPE_STRING:
	str = getprop_string(zhp, prop, &source);
	if (str == NULL)
	return (-1);

	(void) strlcpy(propbuf, str, proplen);
	zcp_check(zhp, prop, 0, str);
	break;

	case PROP_TYPE_INDEX:
	if (get_numeric_property(zhp, prop, src,
	&source, &val) != 0)
	return (-1);
	if (zfs_prop_index_to_string(prop, val, &strval) != 0)
	return (-1);

	(void) strlcpy(propbuf, strval, proplen);
	zcp_check(zhp, prop, 0, strval);
	break;

	default:
	abort();
	}
	}

	get_source(zhp, src, source, statbuf, statlen);

	return (0);
	}

	/*
	* Utility function to get the given numeric property. Does no validation that
	* the given property is the appropriate type; should only be used with
	* hard-coded property types.
	*/
	uint64_t
	zfs_prop_get_int(zfs_handle_t *zhp, zfs_prop_t prop)
	{
	char *source;
	uint64_t val = 0;

	(void) get_numeric_property(zhp, prop, NULL, &source, &val);

	return (val);
	}

	static int
	zfs_prop_set_int(zfs_handle_t *zhp, zfs_prop_t prop, uint64_t val)
	{
	char buf[64];

	(void) snprintf(buf, sizeof (buf), "%llu", (longlong_t)val);
	return (zfs_prop_set(zhp, zfs_prop_to_name(prop), buf));
	}

	/*
	* Similar to zfs_prop_get(), but returns the value as an integer.
	*/
	int
	zfs_prop_get_numeric(zfs_handle_t zhp, zfs_prop_t prop, uint64_t value,
	zprop_source_t src, char statbuf, size_t statlen)
	{
	char *source;

	/*
	* Check to see if this property applies to our object
	*/
	if (!zfs_prop_valid_for_type(prop, zhp->zfs_type, B_FALSE)) {
	return (zfs_error_fmt(zhp->zfs_hdl, EZFS_PROPTYPE,
	dgettext(TEXT_DOMAIN, "cannot get property '%s'"),
	zfs_prop_to_name(prop)));
	}

	if (src)
	*src = ZPROP_SRC_NONE;

	if (get_numeric_property(zhp, prop, src, &source, value) != 0)
	return (-1);

	get_source(zhp, src, source, statbuf, statlen);

	return (0);
	}

	#ifdef HAVE_IDMAP
	static int
	idmap_id_to_numeric_domain_rid(uid_t id, boolean_t isuser,
	char *domainp, idmap_rid_t ridp)
	{
	idmap_get_handle_t *get_hdl = NULL;
	idmap_stat status;
	int err = EINVAL;

	if (idmap_get_create(&get_hdl) != IDMAP_SUCCESS)
	goto out;

	if (isuser) {
	err = idmap_get_sidbyuid(get_hdl, id,
	IDMAP_REQ_FLG_USE_CACHE, domainp, ridp, &status);
	} else {
	err = idmap_get_sidbygid(get_hdl, id,
	IDMAP_REQ_FLG_USE_CACHE, domainp, ridp, &status);
	}
	if (err == IDMAP_SUCCESS &&
	idmap_get_mappings(get_hdl) == IDMAP_SUCCESS &&
	status == IDMAP_SUCCESS)
	err = 0;
	else
	err = EINVAL;
	out:
	if (get_hdl)
	idmap_get_destroy(get_hdl);
	return (err);
	}
	#endif /* HAVE_IDMAP */

	/*
	* convert the propname into parameters needed by kernel
	* Eg: userquota@ahrens -> ZFS_PROP_USERQUOTA, "", 126829
	* Eg: userused@matt@domain -> ZFS_PROP_USERUSED, "S-1-123-456", 789
	* Eg: groupquota@staff -> ZFS_PROP_GROUPQUOTA, "", 1234
	* Eg: groupused@staff -> ZFS_PROP_GROUPUSED, "", 1234
	* Eg: projectquota@123 -> ZFS_PROP_PROJECTQUOTA, "", 123
	* Eg: projectused@789 -> ZFS_PROP_PROJECTUSED, "", 789
	*/
	static int
	userquota_propname_decode(const char *propname, boolean_t zoned,
	zfs_userquota_prop_t typep, char domain, int domainlen, uint64_t *ridp)
	{
	zfs_userquota_prop_t type;
	char *cp;
	boolean_t isuser;
	boolean_t isgroup;
	boolean_t isproject;
	struct passwd *pw;
	struct group *gr;

	domain[0] = '\0';

	/* Figure out the property type ({user\|group\|project}{quota\|space}) */
	for (type = 0; type < ZFS_NUM_USERQUOTA_PROPS; type++) {
	if (strncmp(propname, zfs_userquota_prop_prefixes[type],
	strlen(zfs_userquota_prop_prefixes[type])) == 0)
	break;
	}
	if (type == ZFS_NUM_USERQUOTA_PROPS)
	return (EINVAL);
	*typep = type;

	isuser = (type == ZFS_PROP_USERQUOTA \|\| type == ZFS_PROP_USERUSED \|\|
	type == ZFS_PROP_USEROBJQUOTA \|\|
	type == ZFS_PROP_USEROBJUSED);
	isgroup = (type == ZFS_PROP_GROUPQUOTA \|\| type == ZFS_PROP_GROUPUSED \|\|
	type == ZFS_PROP_GROUPOBJQUOTA \|\|
	type == ZFS_PROP_GROUPOBJUSED);
	isproject = (type == ZFS_PROP_PROJECTQUOTA \|\|
	type == ZFS_PROP_PROJECTUSED \|\| type == ZFS_PROP_PROJECTOBJQUOTA \|\|
	type == ZFS_PROP_PROJECTOBJUSED);

	cp = strchr(propname, '@') + 1;

	if (isuser && (pw = getpwnam(cp)) != NULL) {
	if (zoned && getzoneid() == GLOBAL_ZONEID)
	return (ENOENT);
	*ridp = pw->pw_uid;
	} else if (isgroup && (gr = getgrnam(cp)) != NULL) {
	if (zoned && getzoneid() == GLOBAL_ZONEID)
	return (ENOENT);
	*ridp = gr->gr_gid;
	} else if (!isproject && strchr(cp, '@')) {
	#ifdef HAVE_IDMAP
	/*
	* It's a SID name (eg "user@domain") that needs to be
	* turned into S-1-domainID-RID.
	*/
	directory_error_t e;
	char *numericsid = NULL;
	char *end;

	if (zoned && getzoneid() == GLOBAL_ZONEID)
	return (ENOENT);
	if (isuser) {
	e = directory_sid_from_user_name(NULL,
	cp, &numericsid);
	} else {
	e = directory_sid_from_group_name(NULL,
	cp, &numericsid);
	}
	if (e != NULL) {
	directory_error_free(e);
	return (ENOENT);
	}
	if (numericsid == NULL)
	return (ENOENT);
	cp = numericsid;
	(void) strlcpy(domain, cp, domainlen);
	cp = strrchr(domain, '-');
	*cp = '\0';
	cp++;

	errno = 0;
	*ridp = strtoull(cp, &end, 10);
	free(numericsid);

	if (errno != 0 \|\| *end != '\0')
	return (EINVAL);
	#else
	return (ENOSYS);
	#endif /* HAVE_IDMAP */
	} else {
	/* It's a user/group/project ID (eg "12345"). */
	uid_t id;
	char *end;
	id = strtoul(cp, &end, 10);
	if (*end != '\0')
	return (EINVAL);
	if (id > MAXUID && !isproject) {
	#ifdef HAVE_IDMAP
	/* It's an ephemeral ID. */
	idmap_rid_t rid;
	char *mapdomain;

	if (idmap_id_to_numeric_domain_rid(id, isuser,
	&mapdomain, &rid) != 0)
	return (ENOENT);
	(void) strlcpy(domain, mapdomain, domainlen);
	*ridp = rid;
	#else
	return (ENOSYS);
	#endif /* HAVE_IDMAP */
	} else {
	*ridp = id;
	}
	}

	return (0);
	}

	static int
	zfs_prop_get_userquota_common(zfs_handle_t zhp, const char propname,
	uint64_t propvalue, zfs_userquota_prop_t typep)
	{
	int err;
	zfs_cmd_t zc = {"\0"};

	(void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));

	err = userquota_propname_decode(propname,
	zfs_prop_get_int(zhp, ZFS_PROP_ZONED),
	typep, zc.zc_value, sizeof (zc.zc_value), &zc.zc_guid);
	zc.zc_objset_type = *typep;
	if (err)
	return (err);

	err = zfs_ioctl(zhp->zfs_hdl, ZFS_IOC_USERSPACE_ONE, &zc);
	if (err)
	return (err);

	*propvalue = zc.zc_cookie;
	return (0);
	}

	int
	zfs_prop_get_userquota_int(zfs_handle_t zhp, const char propname,
	uint64_t *propvalue)
	{
	zfs_userquota_prop_t type;

	return (zfs_prop_get_userquota_common(zhp, propname, propvalue,
	&type));
	}

	int
	zfs_prop_get_userquota(zfs_handle_t zhp, const char propname,
	char *propbuf, int proplen, boolean_t literal)
	{
	int err;
	uint64_t propvalue;
	zfs_userquota_prop_t type;

	err = zfs_prop_get_userquota_common(zhp, propname, &propvalue,
	&type);

	if (err)
	return (err);

	if (literal) {
	(void) snprintf(propbuf, proplen, "%llu",
	(u_longlong_t)propvalue);
	} else if (propvalue == 0 &&
	(type == ZFS_PROP_USERQUOTA \|\| type == ZFS_PROP_GROUPQUOTA \|\|
	type == ZFS_PROP_USEROBJQUOTA \|\| type == ZFS_PROP_GROUPOBJQUOTA \|\|
	type == ZFS_PROP_PROJECTQUOTA \|\|
	type == ZFS_PROP_PROJECTOBJQUOTA)) {
	(void) strlcpy(propbuf, "none", proplen);
	} else if (type == ZFS_PROP_USERQUOTA \|\| type == ZFS_PROP_GROUPQUOTA \|\|
	type == ZFS_PROP_USERUSED \|\| type == ZFS_PROP_GROUPUSED \|\|
	type == ZFS_PROP_PROJECTUSED \|\| type == ZFS_PROP_PROJECTQUOTA) {
	zfs_nicebytes(propvalue, propbuf, proplen);
	} else {
	zfs_nicenum(propvalue, propbuf, proplen);
	}
	return (0);
	}

	/*
	* propname must start with "written@" or "written#".
	*/
	int
	zfs_prop_get_written_int(zfs_handle_t zhp, const char propname,
	uint64_t *propvalue)
	{
	int err;
	zfs_cmd_t zc = {"\0"};
	const char *snapname;

	(void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));

	assert(zfs_prop_written(propname));
	snapname = propname + strlen("written@");
	if (strchr(snapname, '@') != NULL \|\| strchr(snapname, '#') != NULL) {
	/* full snapshot or bookmark name specified */
	(void) strlcpy(zc.zc_value, snapname, sizeof (zc.zc_value));
	} else {
	/* snapname is the short name, append it to zhp's fsname */
	char *cp;

	(void) strlcpy(zc.zc_value, zhp->zfs_name,
	sizeof (zc.zc_value));
	cp = strchr(zc.zc_value, '@');
	if (cp != NULL)
	*cp = '\0';
	(void) strlcat(zc.zc_value, snapname - 1, sizeof (zc.zc_value));
	}

	err = zfs_ioctl(zhp->zfs_hdl, ZFS_IOC_SPACE_WRITTEN, &zc);
	if (err)
	return (err);

	*propvalue = zc.zc_cookie;
	return (0);
	}

	int
	zfs_prop_get_written(zfs_handle_t zhp, const char propname,
	char *propbuf, int proplen, boolean_t literal)
	{
	int err;
	uint64_t propvalue;

	err = zfs_prop_get_written_int(zhp, propname, &propvalue);

	if (err)
	return (err);

	if (literal) {
	(void) snprintf(propbuf, proplen, "%llu",
	(u_longlong_t)propvalue);
	} else {
	zfs_nicebytes(propvalue, propbuf, proplen);
	}

	return (0);
	}

	/*
	* Returns the name of the given zfs handle.
	*/
	const char *
	zfs_get_name(const zfs_handle_t *zhp)
	{
	return (zhp->zfs_name);
	}

	/*
	* Returns the name of the parent pool for the given zfs handle.
	*/
	const char *
	zfs_get_pool_name(const zfs_handle_t *zhp)
	{
	return (zhp->zpool_hdl->zpool_name);
	}

	/*
	* Returns the type of the given zfs handle.
	*/
	zfs_type_t
	zfs_get_type(const zfs_handle_t *zhp)
	{
	return (zhp->zfs_type);
	}

	/*
	* Is one dataset name a child dataset of another?
	*
	* Needs to handle these cases:
	* Dataset 1 "a/foo" "a/foo" "a/foo" "a/foo"
	* Dataset 2 "a/fo" "a/foobar" "a/bar/baz" "a/foo/bar"
	* Descendant? No. No. No. Yes.
	*/
	static boolean_t
	is_descendant(const char ds1, const char ds2)
	{
	size_t d1len = strlen(ds1);

	/* ds2 can't be a descendant if it's smaller */
	if (strlen(ds2) < d1len)
	return (B_FALSE);

	/* otherwise, compare strings and verify that there's a '/' char */
	return (ds2[d1len] == '/' && (strncmp(ds1, ds2, d1len) == 0));
	}

	/*
	* Given a complete name, return just the portion that refers to the parent.
	* Will return -1 if there is no parent (path is just the name of the
	* pool).
	*/
	static int
	parent_name(const char path, char buf, size_t buflen)
	{
	char *slashp;

	(void) strlcpy(buf, path, buflen);

	if ((slashp = strrchr(buf, '/')) == NULL)
	return (-1);
	*slashp = '\0';

	return (0);
	}

	int
	zfs_parent_name(zfs_handle_t zhp, char buf, size_t buflen)
	{
	return (parent_name(zfs_get_name(zhp), buf, buflen));
	}

	/*
	* If accept_ancestor is false, then check to make sure that the given path has
	* a parent, and that it exists. If accept_ancestor is true, then find the
	* closest existing ancestor for the given path. In prefixlen return the
	* length of already existing prefix of the given path. We also fetch the
	* 'zoned' property, which is used to validate property settings when creating
	* new datasets.
	*/
	static int
	check_parents(libzfs_handle_t hdl, const char path, uint64_t *zoned,
	boolean_t accept_ancestor, int *prefixlen)
	{
	zfs_cmd_t zc = {"\0"};
	char parent[ZFS_MAX_DATASET_NAME_LEN];
	char *slash;
	zfs_handle_t *zhp;
	char errbuf[1024];
	uint64_t is_zoned;

	(void) snprintf(errbuf, sizeof (errbuf),
	dgettext(TEXT_DOMAIN, "cannot create '%s'"), path);

	/* get parent, and check to see if this is just a pool */
	if (parent_name(path, parent, sizeof (parent)) != 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"missing dataset name"));
	return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
	}

	/* check to see if the pool exists */
	if ((slash = strchr(parent, '/')) == NULL)
	slash = parent + strlen(parent);
	(void) strncpy(zc.zc_name, parent, slash - parent);
	zc.zc_name[slash - parent] = '\0';
	if (zfs_ioctl(hdl, ZFS_IOC_OBJSET_STATS, &zc) != 0 &&
	errno == ENOENT) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"no such pool '%s'"), zc.zc_name);
	return (zfs_error(hdl, EZFS_NOENT, errbuf));
	}

	/* check to see if the parent dataset exists */
	while ((zhp = make_dataset_handle(hdl, parent)) == NULL) {
	if (errno == ENOENT && accept_ancestor) {
	/*
	* Go deeper to find an ancestor, give up on top level.
	*/
	if (parent_name(parent, parent, sizeof (parent)) != 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"no such pool '%s'"), zc.zc_name);
	return (zfs_error(hdl, EZFS_NOENT, errbuf));
	}
	} else if (errno == ENOENT) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"parent does not exist"));
	return (zfs_error(hdl, EZFS_NOENT, errbuf));
	} else
	return (zfs_standard_error(hdl, errno, errbuf));
	}

	is_zoned = zfs_prop_get_int(zhp, ZFS_PROP_ZONED);
	if (zoned != NULL)
	*zoned = is_zoned;

	/* we are in a non-global zone, but parent is in the global zone */
	if (getzoneid() != GLOBAL_ZONEID && !is_zoned) {
	(void) zfs_standard_error(hdl, EPERM, errbuf);
	zfs_close(zhp);
	return (-1);
	}

	/* make sure parent is a filesystem */
	if (zfs_get_type(zhp) != ZFS_TYPE_FILESYSTEM) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"parent is not a filesystem"));
	(void) zfs_error(hdl, EZFS_BADTYPE, errbuf);
	zfs_close(zhp);
	return (-1);
	}

	zfs_close(zhp);
	if (prefixlen != NULL)
	*prefixlen = strlen(parent);
	return (0);
	}

	/*
	* Finds whether the dataset of the given type(s) exists.
	*/
	boolean_t
	zfs_dataset_exists(libzfs_handle_t hdl, const char path, zfs_type_t types)
	{
	zfs_handle_t *zhp;

	if (!zfs_validate_name(hdl, path, types, B_FALSE))
	return (B_FALSE);

	/*
	* Try to get stats for the dataset, which will tell us if it exists.
	*/
	if ((zhp = make_dataset_handle(hdl, path)) != NULL) {
	int ds_type = zhp->zfs_type;

	zfs_close(zhp);
	if (types & ds_type)
	return (B_TRUE);
	}
	return (B_FALSE);
	}

	/*
	* Given a path to 'target', create all the ancestors between
	* the prefixlen portion of the path, and the target itself.
	* Fail if the initial prefixlen-ancestor does not already exist.
	*/
	int
	create_parents(libzfs_handle_t hdl, char target, int prefixlen)
	{
	zfs_handle_t *h;
	char *cp;
	const char *opname;

	/* make sure prefix exists */
	cp = target + prefixlen;
	if (*cp != '/') {
	assert(strchr(cp, '/') == NULL);
	h = zfs_open(hdl, target, ZFS_TYPE_FILESYSTEM);
	} else {
	*cp = '\0';
	h = zfs_open(hdl, target, ZFS_TYPE_FILESYSTEM);
	*cp = '/';
	}
	if (h == NULL)
	return (-1);
	zfs_close(h);

	/*
	* Attempt to create, mount, and share any ancestor filesystems,
	* up to the prefixlen-long one.
	*/
	for (cp = target + prefixlen + 1;
	(cp = strchr(cp, '/')) != NULL; *cp = '/', cp++) {

	*cp = '\0';

	h = make_dataset_handle(hdl, target);
	if (h) {
	/* it already exists, nothing to do here */
	zfs_close(h);
	continue;
	}

	if (zfs_create(hdl, target, ZFS_TYPE_FILESYSTEM,
	NULL) != 0) {
	opname = dgettext(TEXT_DOMAIN, "create");
	goto ancestorerr;
	}

	h = zfs_open(hdl, target, ZFS_TYPE_FILESYSTEM);
	if (h == NULL) {
	opname = dgettext(TEXT_DOMAIN, "open");
	goto ancestorerr;
	}

	if (zfs_mount(h, NULL, 0) != 0) {
	opname = dgettext(TEXT_DOMAIN, "mount");
	goto ancestorerr;
	}

	if (zfs_share(h) != 0) {
	opname = dgettext(TEXT_DOMAIN, "share");
	goto ancestorerr;
	}

	zfs_close(h);
	}
	zfs_commit_all_shares();

	return (0);

	ancestorerr:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"failed to %s ancestor '%s'"), opname, target);
	return (-1);
	}

	/*
	* Creates non-existing ancestors of the given path.
	*/
	int
	zfs_create_ancestors(libzfs_handle_t hdl, const char path)
	{
	int prefix;
	char *path_copy;
	char errbuf[1024];
	int rc = 0;

	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
	"cannot create '%s'"), path);

	/*
	* Check that we are not passing the nesting limit
	* before we start creating any ancestors.
	*/
	if (dataset_nestcheck(path) != 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"maximum name nesting depth exceeded"));
	return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
	}

	if (check_parents(hdl, path, NULL, B_TRUE, &prefix) != 0)
	return (-1);

	if ((path_copy = strdup(path)) != NULL) {
	rc = create_parents(hdl, path_copy, prefix);
	free(path_copy);
	}
	if (path_copy == NULL \|\| rc != 0)
	return (-1);

	return (0);
	}

	/*
	* Create a new filesystem or volume.
	*/
	int
	zfs_create(libzfs_handle_t hdl, const char path, zfs_type_t type,
	nvlist_t *props)
	{
	int ret;
	uint64_t size = 0;
	uint64_t blocksize = zfs_prop_default_numeric(ZFS_PROP_VOLBLOCKSIZE);
	uint64_t zoned;
	enum lzc_dataset_type ost;
	zpool_handle_t *zpool_handle;
	uint8_t *wkeydata = NULL;
	uint_t wkeylen = 0;
	char errbuf[1024];
	char parent[ZFS_MAX_DATASET_NAME_LEN];

	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
	"cannot create '%s'"), path);

	/* validate the path, taking care to note the extended error message */
	if (!zfs_validate_name(hdl, path, type, B_TRUE))
	return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));

	if (dataset_nestcheck(path) != 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"maximum name nesting depth exceeded"));
	return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
	}

	/* validate parents exist */
	if (check_parents(hdl, path, &zoned, B_FALSE, NULL) != 0)
	return (-1);

	/*
	* The failure modes when creating a dataset of a different type over
	* one that already exists is a little strange. In particular, if you
	* try to create a dataset on top of an existing dataset, the ioctl()
	* will return ENOENT, not EEXIST. To prevent this from happening, we
	* first try to see if the dataset exists.
	*/
	if (zfs_dataset_exists(hdl, path, ZFS_TYPE_DATASET)) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"dataset already exists"));
	return (zfs_error(hdl, EZFS_EXISTS, errbuf));
	}

	if (type == ZFS_TYPE_VOLUME)
	ost = LZC_DATSET_TYPE_ZVOL;
	else
	ost = LZC_DATSET_TYPE_ZFS;

	/* open zpool handle for prop validation */
	char pool_path[ZFS_MAX_DATASET_NAME_LEN];
	(void) strlcpy(pool_path, path, sizeof (pool_path));

	/* truncate pool_path at first slash */
	char *p = strchr(pool_path, '/');
	if (p != NULL)
	*p = '\0';

	if ((zpool_handle = zpool_open(hdl, pool_path)) == NULL)
	return (-1);

	if (props && (props = zfs_valid_proplist(hdl, type, props,
	zoned, NULL, zpool_handle, B_TRUE, errbuf)) == 0) {
	zpool_close(zpool_handle);
	return (-1);
	}
	zpool_close(zpool_handle);

	if (type == ZFS_TYPE_VOLUME) {
	/*
	* If we are creating a volume, the size and block size must
	* satisfy a few restraints. First, the blocksize must be a
	* valid block size between SPA_{MIN,MAX}BLOCKSIZE. Second, the
	* volsize must be a multiple of the block size, and cannot be
	* zero.
	*/
	if (props == NULL \|\| nvlist_lookup_uint64(props,
	zfs_prop_to_name(ZFS_PROP_VOLSIZE), &size) != 0) {
	nvlist_free(props);
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"missing volume size"));
	return (zfs_error(hdl, EZFS_BADPROP, errbuf));
	}

	if ((ret = nvlist_lookup_uint64(props,
	zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE),
	&blocksize)) != 0) {
	if (ret == ENOENT) {
	blocksize = zfs_prop_default_numeric(
	ZFS_PROP_VOLBLOCKSIZE);
	} else {
	nvlist_free(props);
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"missing volume block size"));
	return (zfs_error(hdl, EZFS_BADPROP, errbuf));
	}
	}

	if (size == 0) {
	nvlist_free(props);
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"volume size cannot be zero"));
	return (zfs_error(hdl, EZFS_BADPROP, errbuf));
	}

	if (size % blocksize != 0) {
	nvlist_free(props);
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"volume size must be a multiple of volume block "
	"size"));
	return (zfs_error(hdl, EZFS_BADPROP, errbuf));
	}
	}

	(void) parent_name(path, parent, sizeof (parent));
	if (zfs_crypto_create(hdl, parent, props, NULL, B_TRUE,
	&wkeydata, &wkeylen) != 0) {
	nvlist_free(props);
	return (zfs_error(hdl, EZFS_CRYPTOFAILED, errbuf));
	}

	/* create the dataset */
	ret = lzc_create(path, ost, props, wkeydata, wkeylen);
	nvlist_free(props);
	if (wkeydata != NULL)
	free(wkeydata);

	/* check for failure */
	if (ret != 0) {
	switch (errno) {
	case ENOENT:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"no such parent '%s'"), parent);
	return (zfs_error(hdl, EZFS_NOENT, errbuf));

	case ENOTSUP:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"pool must be upgraded to set this "
	"property or value"));
	return (zfs_error(hdl, EZFS_BADVERSION, errbuf));

	case EACCES:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"encryption root's key is not loaded "
	"or provided"));
	return (zfs_error(hdl, EZFS_CRYPTOFAILED, errbuf));

	case ERANGE:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"invalid property value(s) specified"));
	return (zfs_error(hdl, EZFS_BADPROP, errbuf));
	#ifdef _ILP32
	case EOVERFLOW:
	/*
	* This platform can't address a volume this big.
	*/
	if (type == ZFS_TYPE_VOLUME)
	return (zfs_error(hdl, EZFS_VOLTOOBIG,
	errbuf));
	#endif
	/* FALLTHROUGH */
	default:
	return (zfs_standard_error(hdl, errno, errbuf));
	}
	}

	return (0);
	}

	/*
	* Destroys the given dataset. The caller must make sure that the filesystem
	* isn't mounted, and that there are no active dependents. If the file system
	* does not exist this function does nothing.
	*/
	int
	zfs_destroy(zfs_handle_t *zhp, boolean_t defer)
	{
	int error;

	if (zhp->zfs_type != ZFS_TYPE_SNAPSHOT && defer)
	return (EINVAL);

	if (zhp->zfs_type == ZFS_TYPE_BOOKMARK) {
	nvlist_t *nv = fnvlist_alloc();
	fnvlist_add_boolean(nv, zhp->zfs_name);
	error = lzc_destroy_bookmarks(nv, NULL);
	fnvlist_free(nv);
	if (error != 0) {
	return (zfs_standard_error_fmt(zhp->zfs_hdl, error,
	dgettext(TEXT_DOMAIN, "cannot destroy '%s'"),
	zhp->zfs_name));
	}
	return (0);
	}

	if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT) {
	nvlist_t *nv = fnvlist_alloc();
	fnvlist_add_boolean(nv, zhp->zfs_name);
	error = lzc_destroy_snaps(nv, defer, NULL);
	fnvlist_free(nv);
	} else {
	error = lzc_destroy(zhp->zfs_name);
	}

	if (error != 0 && error != ENOENT) {
	return (zfs_standard_error_fmt(zhp->zfs_hdl, errno,
	dgettext(TEXT_DOMAIN, "cannot destroy '%s'"),
	zhp->zfs_name));
	}

	remove_mountpoint(zhp);

	return (0);
	}

	struct destroydata {
	nvlist_t *nvl;
	const char *snapname;
	};

	static int
	zfs_check_snap_cb(zfs_handle_t zhp, void arg)
	{
	struct destroydata *dd = arg;
	char name[ZFS_MAX_DATASET_NAME_LEN];
	int rv = 0;

	if (snprintf(name, sizeof (name), "%s@%s", zhp->zfs_name,
	dd->snapname) >= sizeof (name))
	return (EINVAL);

	if (lzc_exists(name))
	verify(nvlist_add_boolean(dd->nvl, name) == 0);

	rv = zfs_iter_filesystems(zhp, zfs_check_snap_cb, dd);
	zfs_close(zhp);
	return (rv);
	}

	/*
	* Destroys all snapshots with the given name in zhp & descendants.
	*/
	int
	zfs_destroy_snaps(zfs_handle_t zhp, char snapname, boolean_t defer)
	{
	int ret;
	struct destroydata dd = { 0 };

	dd.snapname = snapname;
	verify(nvlist_alloc(&dd.nvl, NV_UNIQUE_NAME, 0) == 0);
	(void) zfs_check_snap_cb(zfs_handle_dup(zhp), &dd);

	if (nvlist_empty(dd.nvl)) {
	ret = zfs_standard_error_fmt(zhp->zfs_hdl, ENOENT,
	dgettext(TEXT_DOMAIN, "cannot destroy '%s@%s'"),
	zhp->zfs_name, snapname);
	} else {
	ret = zfs_destroy_snaps_nvl(zhp->zfs_hdl, dd.nvl, defer);
	}
	nvlist_free(dd.nvl);
	return (ret);
	}

	/*
	* Destroys all the snapshots named in the nvlist.
	*/
	int
	zfs_destroy_snaps_nvl(libzfs_handle_t hdl, nvlist_t snaps, boolean_t defer)
	{
	int ret;
	nvlist_t *errlist = NULL;
	nvpair_t *pair;

	ret = lzc_destroy_snaps(snaps, defer, &errlist);

	if (ret == 0) {
	nvlist_free(errlist);
	return (0);
	}

	if (nvlist_empty(errlist)) {
	char errbuf[1024];
	(void) snprintf(errbuf, sizeof (errbuf),
	dgettext(TEXT_DOMAIN, "cannot destroy snapshots"));

	ret = zfs_standard_error(hdl, ret, errbuf);
	}
	for (pair = nvlist_next_nvpair(errlist, NULL);
	pair != NULL; pair = nvlist_next_nvpair(errlist, pair)) {
	char errbuf[1024];
	(void) snprintf(errbuf, sizeof (errbuf),
	dgettext(TEXT_DOMAIN, "cannot destroy snapshot %s"),
	nvpair_name(pair));

	switch (fnvpair_value_int32(pair)) {
	case EEXIST:
	zfs_error_aux(hdl,
	dgettext(TEXT_DOMAIN, "snapshot is cloned"));
	ret = zfs_error(hdl, EZFS_EXISTS, errbuf);
	break;
	default:
	ret = zfs_standard_error(hdl, errno, errbuf);
	break;
	}
	}

	nvlist_free(errlist);
	return (ret);
	}

	/*
	* Clones the given dataset. The target must be of the same type as the source.
	*/
	int
	zfs_clone(zfs_handle_t zhp, const char target, nvlist_t *props)
	{
	char parent[ZFS_MAX_DATASET_NAME_LEN];
	int ret;
	char errbuf[1024];
	libzfs_handle_t *hdl = zhp->zfs_hdl;
	uint64_t zoned;

	assert(zhp->zfs_type == ZFS_TYPE_SNAPSHOT);

	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
	"cannot create '%s'"), target);

	/* validate the target/clone name */
	if (!zfs_validate_name(hdl, target, ZFS_TYPE_FILESYSTEM, B_TRUE))
	return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));

	/* validate parents exist */
	if (check_parents(hdl, target, &zoned, B_FALSE, NULL) != 0)
	return (-1);

	(void) parent_name(target, parent, sizeof (parent));

	/* do the clone */

	if (props) {
	zfs_type_t type;

	if (ZFS_IS_VOLUME(zhp)) {
	type = ZFS_TYPE_VOLUME;
	} else {
	type = ZFS_TYPE_FILESYSTEM;
	}
	if ((props = zfs_valid_proplist(hdl, type, props, zoned,
	zhp, zhp->zpool_hdl, B_TRUE, errbuf)) == NULL)
	return (-1);
	if (zfs_fix_auto_resv(zhp, props) == -1) {
	nvlist_free(props);
	return (-1);
	}
	}

	if (zfs_crypto_clone_check(hdl, zhp, parent, props) != 0) {
	nvlist_free(props);
	return (zfs_error(hdl, EZFS_CRYPTOFAILED, errbuf));
	}

	ret = lzc_clone(target, zhp->zfs_name, props);
	nvlist_free(props);

	if (ret != 0) {
	switch (errno) {

	case ENOENT:
	/*
	* The parent doesn't exist. We should have caught this
	* above, but there may a race condition that has since
	* destroyed the parent.
	*
	* At this point, we don't know whether it's the source
	* that doesn't exist anymore, or whether the target
	* dataset doesn't exist.
	*/
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"no such parent '%s'"), parent);
	return (zfs_error(zhp->zfs_hdl, EZFS_NOENT, errbuf));

	case EXDEV:
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"source and target pools differ"));
	return (zfs_error(zhp->zfs_hdl, EZFS_CROSSTARGET,
	errbuf));

	default:
	return (zfs_standard_error(zhp->zfs_hdl, errno,
	errbuf));
	}
	}

	return (ret);
	}

	/*
	* Promotes the given clone fs to be the clone parent.
	*/
	int
	zfs_promote(zfs_handle_t *zhp)
	{
	libzfs_handle_t *hdl = zhp->zfs_hdl;
	char snapname[ZFS_MAX_DATASET_NAME_LEN];
	int ret;
	char errbuf[1024];

	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
	"cannot promote '%s'"), zhp->zfs_name);

	if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"snapshots can not be promoted"));
	return (zfs_error(hdl, EZFS_BADTYPE, errbuf));
	}

	if (zhp->zfs_dmustats.dds_origin[0] == '\0') {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"not a cloned filesystem"));
	return (zfs_error(hdl, EZFS_BADTYPE, errbuf));
	}

	if (!zfs_validate_name(hdl, zhp->zfs_name, zhp->zfs_type, B_TRUE))
	return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));

	ret = lzc_promote(zhp->zfs_name, snapname, sizeof (snapname));

	if (ret != 0) {
	switch (ret) {
	case EACCES:
	/*
	* Promoting encrypted dataset outside its
	* encryption root.
	*/
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"cannot promote dataset outside its "
	"encryption root"));
	return (zfs_error(hdl, EZFS_EXISTS, errbuf));

	case EEXIST:
	/* There is a conflicting snapshot name. */
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"conflicting snapshot '%s' from parent '%s'"),
	snapname, zhp->zfs_dmustats.dds_origin);
	return (zfs_error(hdl, EZFS_EXISTS, errbuf));

	default:
	return (zfs_standard_error(hdl, ret, errbuf));
	}
	}
	return (ret);
	}

	typedef struct snapdata {
	nvlist_t *sd_nvl;
	const char *sd_snapname;
	} snapdata_t;

	static int
	zfs_snapshot_cb(zfs_handle_t zhp, void arg)
	{
	snapdata_t *sd = arg;
	char name[ZFS_MAX_DATASET_NAME_LEN];
	int rv = 0;

	if (zfs_prop_get_int(zhp, ZFS_PROP_INCONSISTENT) == 0) {
	if (snprintf(name, sizeof (name), "%s@%s", zfs_get_name(zhp),
	sd->sd_snapname) >= sizeof (name))
	return (EINVAL);

	fnvlist_add_boolean(sd->sd_nvl, name);

	rv = zfs_iter_filesystems(zhp, zfs_snapshot_cb, sd);
	}
	zfs_close(zhp);

	return (rv);
	}

	/*
	* Creates snapshots. The keys in the snaps nvlist are the snapshots to be
	* created.
	*/
	int
	zfs_snapshot_nvl(libzfs_handle_t hdl, nvlist_t snaps, nvlist_t *props)
	{
	int ret;
	char errbuf[1024];
	nvpair_t *elem;
	nvlist_t *errors;
	zpool_handle_t *zpool_hdl;
	char pool[ZFS_MAX_DATASET_NAME_LEN];

	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
	"cannot create snapshots "));

	elem = NULL;
	while ((elem = nvlist_next_nvpair(snaps, elem)) != NULL) {
	const char *snapname = nvpair_name(elem);

	/* validate the target name */
	if (!zfs_validate_name(hdl, snapname, ZFS_TYPE_SNAPSHOT,
	B_TRUE)) {
	(void) snprintf(errbuf, sizeof (errbuf),
	dgettext(TEXT_DOMAIN,
	"cannot create snapshot '%s'"), snapname);
	return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
	}
	}

	/*
	* get pool handle for prop validation. assumes all snaps are in the
	* same pool, as does lzc_snapshot (below).
	*/
	elem = nvlist_next_nvpair(snaps, NULL);
	(void) strlcpy(pool, nvpair_name(elem), sizeof (pool));
	pool[strcspn(pool, "/@")] = '\0';
	zpool_hdl = zpool_open(hdl, pool);
	if (zpool_hdl == NULL)
	return (-1);

	if (props != NULL &&
	(props = zfs_valid_proplist(hdl, ZFS_TYPE_SNAPSHOT,
	props, B_FALSE, NULL, zpool_hdl, B_FALSE, errbuf)) == NULL) {
	zpool_close(zpool_hdl);
	return (-1);
	}
	zpool_close(zpool_hdl);

	ret = lzc_snapshot(snaps, props, &errors);

	if (ret != 0) {
	boolean_t printed = B_FALSE;
	for (elem = nvlist_next_nvpair(errors, NULL);
	elem != NULL;
	elem = nvlist_next_nvpair(errors, elem)) {
	(void) snprintf(errbuf, sizeof (errbuf),
	dgettext(TEXT_DOMAIN,
	"cannot create snapshot '%s'"), nvpair_name(elem));
	(void) zfs_standard_error(hdl,
	fnvpair_value_int32(elem), errbuf);
	printed = B_TRUE;
	}
	if (!printed) {
	switch (ret) {
	case EXDEV:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"multiple snapshots of same "
	"fs not allowed"));
	(void) zfs_error(hdl, EZFS_EXISTS, errbuf);

	break;
	default:
	(void) zfs_standard_error(hdl, ret, errbuf);
	}
	}
	}

	nvlist_free(props);
	nvlist_free(errors);
	return (ret);
	}

	int
	zfs_snapshot(libzfs_handle_t hdl, const char path, boolean_t recursive,
	nvlist_t *props)
	{
	int ret;
	snapdata_t sd = { 0 };
	char fsname[ZFS_MAX_DATASET_NAME_LEN];
	char *cp;
	zfs_handle_t *zhp;
	char errbuf[1024];

	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
	"cannot snapshot %s"), path);

	if (!zfs_validate_name(hdl, path, ZFS_TYPE_SNAPSHOT, B_TRUE))
	return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));

	(void) strlcpy(fsname, path, sizeof (fsname));
	cp = strchr(fsname, '@');
	*cp = '\0';
	sd.sd_snapname = cp + 1;

	if ((zhp = zfs_open(hdl, fsname, ZFS_TYPE_FILESYSTEM \|
	ZFS_TYPE_VOLUME)) == NULL) {
	return (-1);
	}

	verify(nvlist_alloc(&sd.sd_nvl, NV_UNIQUE_NAME, 0) == 0);
	if (recursive) {
	(void) zfs_snapshot_cb(zfs_handle_dup(zhp), &sd);
	} else {
	fnvlist_add_boolean(sd.sd_nvl, path);
	}

	ret = zfs_snapshot_nvl(hdl, sd.sd_nvl, props);
	nvlist_free(sd.sd_nvl);
	zfs_close(zhp);
	return (ret);
	}

	/*
	* Destroy any more recent snapshots. We invoke this callback on any dependents
	* of the snapshot first. If the 'cb_dependent' member is non-zero, then this
	* is a dependent and we should just destroy it without checking the transaction
	* group.
	*/
	typedef struct rollback_data {
	const char cb_target; / the snapshot */
	uint64_t cb_create; /* creation time reference */
	boolean_t cb_error;
	boolean_t cb_force;
	} rollback_data_t;

	static int
	rollback_destroy_dependent(zfs_handle_t zhp, void data)
	{
	rollback_data_t *cbp = data;
	prop_changelist_t *clp;

	/* We must destroy this clone; first unmount it */
	clp = changelist_gather(zhp, ZFS_PROP_NAME, 0,
	cbp->cb_force ? MS_FORCE: 0);
	if (clp == NULL \|\| changelist_prefix(clp) != 0) {
	cbp->cb_error = B_TRUE;
	zfs_close(zhp);
	return (0);
	}
	if (zfs_destroy(zhp, B_FALSE) != 0)
	cbp->cb_error = B_TRUE;
	else
	changelist_remove(clp, zhp->zfs_name);
	(void) changelist_postfix(clp);
	changelist_free(clp);

	zfs_close(zhp);
	return (0);
	}

	static int
	rollback_destroy(zfs_handle_t zhp, void data)
	{
	rollback_data_t *cbp = data;

	if (zfs_prop_get_int(zhp, ZFS_PROP_CREATETXG) > cbp->cb_create) {
	cbp->cb_error \|= zfs_iter_dependents(zhp, B_FALSE,
	rollback_destroy_dependent, cbp);

	cbp->cb_error \|= zfs_destroy(zhp, B_FALSE);
	}

	zfs_close(zhp);
	return (0);
	}

	/*
	* Given a dataset, rollback to a specific snapshot, discarding any
	* data changes since then and making it the active dataset.
	*
	* Any snapshots and bookmarks more recent than the target are
	* destroyed, along with their dependents (i.e. clones).
	*/
	int
	zfs_rollback(zfs_handle_t zhp, zfs_handle_t snap, boolean_t force)
	{
	rollback_data_t cb = { 0 };
	int err;
	boolean_t restore_resv = 0;
	uint64_t old_volsize = 0, new_volsize;
	zfs_prop_t resv_prop = { 0 };
	uint64_t min_txg = 0;

	assert(zhp->zfs_type == ZFS_TYPE_FILESYSTEM \|\|
	zhp->zfs_type == ZFS_TYPE_VOLUME);

	/*
	* Destroy all recent snapshots and their dependents.
	*/
	cb.cb_force = force;
	cb.cb_target = snap->zfs_name;
	cb.cb_create = zfs_prop_get_int(snap, ZFS_PROP_CREATETXG);

	if (cb.cb_create > 0)
	min_txg = cb.cb_create;

	(void) zfs_iter_snapshots(zhp, B_FALSE, rollback_destroy, &cb,
	min_txg, 0);

	(void) zfs_iter_bookmarks(zhp, rollback_destroy, &cb);

	if (cb.cb_error)
	return (-1);

	/*
	* Now that we have verified that the snapshot is the latest,
	* rollback to the given snapshot.
	*/

	if (zhp->zfs_type == ZFS_TYPE_VOLUME) {
	if (zfs_which_resv_prop(zhp, &resv_prop) < 0)
	return (-1);
	old_volsize = zfs_prop_get_int(zhp, ZFS_PROP_VOLSIZE);
	restore_resv =
	(old_volsize == zfs_prop_get_int(zhp, resv_prop));
	}

	/*
	* Pass both the filesystem and the wanted snapshot names,
	* we would get an error back if the snapshot is destroyed or
	* a new snapshot is created before this request is processed.
	*/
	err = lzc_rollback_to(zhp->zfs_name, snap->zfs_name);
	if (err != 0) {
	char errbuf[1024];

	(void) snprintf(errbuf, sizeof (errbuf),
	dgettext(TEXT_DOMAIN, "cannot rollback '%s'"),
	zhp->zfs_name);
	switch (err) {
	case EEXIST:
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"there is a snapshot or bookmark more recent "
	"than '%s'"), snap->zfs_name);
	(void) zfs_error(zhp->zfs_hdl, EZFS_EXISTS, errbuf);
	break;
	case ESRCH:
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"'%s' is not found among snapshots of '%s'"),
	snap->zfs_name, zhp->zfs_name);
	(void) zfs_error(zhp->zfs_hdl, EZFS_NOENT, errbuf);
	break;
	case EINVAL:
	(void) zfs_error(zhp->zfs_hdl, EZFS_BADTYPE, errbuf);
	break;
	default:
	(void) zfs_standard_error(zhp->zfs_hdl, err, errbuf);
	}
	return (err);
	}

	/*
	* For volumes, if the pre-rollback volsize matched the pre-
	* rollback reservation and the volsize has changed then set
	* the reservation property to the post-rollback volsize.
	* Make a new handle since the rollback closed the dataset.
	*/
	if ((zhp->zfs_type == ZFS_TYPE_VOLUME) &&
	(zhp = make_dataset_handle(zhp->zfs_hdl, zhp->zfs_name))) {
	if (restore_resv) {
	new_volsize = zfs_prop_get_int(zhp, ZFS_PROP_VOLSIZE);
	if (old_volsize != new_volsize)
	err = zfs_prop_set_int(zhp, resv_prop,
	new_volsize);
	}
	zfs_close(zhp);
	}
	return (err);
	}

	/*
	* Renames the given dataset.
	*/
	int
	zfs_rename(zfs_handle_t zhp, const char target, renameflags_t flags)
	{
	int ret = 0;
	zfs_cmd_t zc = {"\0"};
	char *delim;
	prop_changelist_t *cl = NULL;
	char parent[ZFS_MAX_DATASET_NAME_LEN];
	char property[ZFS_MAXPROPLEN];
	libzfs_handle_t *hdl = zhp->zfs_hdl;
	char errbuf[1024];

	/* if we have the same exact name, just return success */
	if (strcmp(zhp->zfs_name, target) == 0)
	return (0);

	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
	"cannot rename to '%s'"), target);

	/* make sure source name is valid */
	if (!zfs_validate_name(hdl, zhp->zfs_name, zhp->zfs_type, B_TRUE))
	return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));

	/*
	* Make sure the target name is valid
	*/
	if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT) {
	if ((strchr(target, '@') == NULL) \|\|
	*target == '@') {
	/*
	* Snapshot target name is abbreviated,
	* reconstruct full dataset name
	*/
	(void) strlcpy(parent, zhp->zfs_name,
	sizeof (parent));
	delim = strchr(parent, '@');
	if (strchr(target, '@') == NULL)
	*(++delim) = '\0';
	else
	*delim = '\0';
	(void) strlcat(parent, target, sizeof (parent));
	target = parent;
	} else {
	/*
	* Make sure we're renaming within the same dataset.
	*/
	delim = strchr(target, '@');
	if (strncmp(zhp->zfs_name, target, delim - target)
	!= 0 \|\| zhp->zfs_name[delim - target] != '@') {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"snapshots must be part of same "
	"dataset"));
	return (zfs_error(hdl, EZFS_CROSSTARGET,
	errbuf));
	}
	}

	if (!zfs_validate_name(hdl, target, zhp->zfs_type, B_TRUE))
	return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
	} else {
	if (flags.recursive) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"recursive rename must be a snapshot"));
	return (zfs_error(hdl, EZFS_BADTYPE, errbuf));
	}

	if (!zfs_validate_name(hdl, target, zhp->zfs_type, B_TRUE))
	return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));

	/* validate parents */
	if (check_parents(hdl, target, NULL, B_FALSE, NULL) != 0)
	return (-1);

	/* make sure we're in the same pool */
	verify((delim = strchr(target, '/')) != NULL);
	if (strncmp(zhp->zfs_name, target, delim - target) != 0 \|\|
	zhp->zfs_name[delim - target] != '/') {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"datasets must be within same pool"));
	return (zfs_error(hdl, EZFS_CROSSTARGET, errbuf));
	}

	/* new name cannot be a child of the current dataset name */
	if (is_descendant(zhp->zfs_name, target)) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"New dataset name cannot be a descendant of "
	"current dataset name"));
	return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
	}
	}

	(void) snprintf(errbuf, sizeof (errbuf),
	dgettext(TEXT_DOMAIN, "cannot rename '%s'"), zhp->zfs_name);

	if (getzoneid() == GLOBAL_ZONEID &&
	zfs_prop_get_int(zhp, ZFS_PROP_ZONED)) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"dataset is used in a non-global zone"));
	return (zfs_error(hdl, EZFS_ZONED, errbuf));
	}

	/*
	* Avoid unmounting file systems with mountpoint property set to
	* 'legacy' or 'none' even if -u option is not given.
	*/
	if (zhp->zfs_type == ZFS_TYPE_FILESYSTEM &&
	!flags.recursive && !flags.nounmount &&
	zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, property,
	sizeof (property), NULL, NULL, 0, B_FALSE) == 0 &&
	(strcmp(property, "legacy") == 0 \|\|
	strcmp(property, "none") == 0)) {
	flags.nounmount = B_TRUE;
	}
	if (flags.recursive) {
	char *parentname = zfs_strdup(zhp->zfs_hdl, zhp->zfs_name);
	if (parentname == NULL) {
	ret = -1;
	goto error;
	}
	delim = strchr(parentname, '@');
	*delim = '\0';
	zfs_handle_t *zhrp = zfs_open(zhp->zfs_hdl, parentname,
	ZFS_TYPE_DATASET);
	free(parentname);
	if (zhrp == NULL) {
	ret = -1;
	goto error;
	}
	zfs_close(zhrp);
	} else if (zhp->zfs_type != ZFS_TYPE_SNAPSHOT) {
	if ((cl = changelist_gather(zhp, ZFS_PROP_NAME,
	flags.nounmount ? CL_GATHER_DONT_UNMOUNT :
	CL_GATHER_ITER_MOUNTED,
	flags.forceunmount ? MS_FORCE : 0)) == NULL)
	return (-1);

	if (changelist_haszonedchild(cl)) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"child dataset with inherited mountpoint is used "
	"in a non-global zone"));
	(void) zfs_error(hdl, EZFS_ZONED, errbuf);
	ret = -1;
	goto error;
	}

	if ((ret = changelist_prefix(cl)) != 0)
	goto error;
	}

	if (ZFS_IS_VOLUME(zhp))
	zc.zc_objset_type = DMU_OST_ZVOL;
	else
	zc.zc_objset_type = DMU_OST_ZFS;

	(void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
	(void) strlcpy(zc.zc_value, target, sizeof (zc.zc_value));

	zc.zc_cookie = !!flags.recursive;
	zc.zc_cookie \|= (!!flags.nounmount) << 1;

	if ((ret = zfs_ioctl(zhp->zfs_hdl, ZFS_IOC_RENAME, &zc)) != 0) {
	/*
	* if it was recursive, the one that actually failed will
	* be in zc.zc_name
	*/
	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
	"cannot rename '%s'"), zc.zc_name);

	if (flags.recursive && errno == EEXIST) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"a child dataset already has a snapshot "
	"with the new name"));
	(void) zfs_error(hdl, EZFS_EXISTS, errbuf);
	} else if (errno == EACCES) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"cannot move encrypted child outside of "
	"its encryption root"));
	(void) zfs_error(hdl, EZFS_CRYPTOFAILED, errbuf);
	} else {
	(void) zfs_standard_error(zhp->zfs_hdl, errno, errbuf);
	}

	/*
	* On failure, we still want to remount any filesystems that
	* were previously mounted, so we don't alter the system state.
	*/
	if (cl != NULL)
	(void) changelist_postfix(cl);
	} else {
	if (cl != NULL) {
	changelist_rename(cl, zfs_get_name(zhp), target);
	ret = changelist_postfix(cl);
	}
	}

	error:
	if (cl != NULL) {
	changelist_free(cl);
	}
	return (ret);
	}

	nvlist_t *
	zfs_get_all_props(zfs_handle_t *zhp)
	{
	return (zhp->zfs_props);
	}

	nvlist_t *
	zfs_get_recvd_props(zfs_handle_t *zhp)
	{
	if (zhp->zfs_recvd_props == NULL)
	if (get_recvd_props_ioctl(zhp) != 0)
	return (NULL);
	return (zhp->zfs_recvd_props);
	}

	nvlist_t *
	zfs_get_user_props(zfs_handle_t *zhp)
	{
	return (zhp->zfs_user_props);
	}

	/*
	* This function is used by 'zfs list' to determine the exact set of columns to
	* display, and their maximum widths. This does two main things:
	*
	* - If this is a list of all properties, then expand the list to include
	* all native properties, and set a flag so that for each dataset we look
	* for new unique user properties and add them to the list.
	*
	* - For non fixed-width properties, keep track of the maximum width seen
	* so that we can size the column appropriately. If the user has
	* requested received property values, we also need to compute the width
	* of the RECEIVED column.
	*/
	int
	zfs_expand_proplist(zfs_handle_t zhp, zprop_list_t *plp, boolean_t received,
	boolean_t literal)
	{
	libzfs_handle_t *hdl = zhp->zfs_hdl;
	zprop_list_t *entry;
	zprop_list_t last, start;
	nvlist_t userprops, propval;
	nvpair_t *elem;
	char *strval;
	char buf[ZFS_MAXPROPLEN];

	if (zprop_expand_list(hdl, plp, ZFS_TYPE_DATASET) != 0)
	return (-1);

	userprops = zfs_get_user_props(zhp);

	entry = *plp;
	if (entry->pl_all && nvlist_next_nvpair(userprops, NULL) != NULL) {
	/*
	* Go through and add any user properties as necessary. We
	* start by incrementing our list pointer to the first
	* non-native property.
	*/
	start = plp;
	while (*start != NULL) {
	if ((*start)->pl_prop == ZPROP_INVAL)
	break;
	start = &(*start)->pl_next;
	}

	elem = NULL;
	while ((elem = nvlist_next_nvpair(userprops, elem)) != NULL) {
	/*
	* See if we've already found this property in our list.
	*/
	for (last = start; *last != NULL;
	last = &(*last)->pl_next) {
	if (strcmp((*last)->pl_user_prop,
	nvpair_name(elem)) == 0)
	break;
	}

	if (*last == NULL) {
	if ((entry = zfs_alloc(hdl,
	sizeof (zprop_list_t))) == NULL \|\|
	((entry->pl_user_prop = zfs_strdup(hdl,
	nvpair_name(elem)))) == NULL) {
	free(entry);
	return (-1);
	}

	entry->pl_prop = ZPROP_INVAL;
	entry->pl_width = strlen(nvpair_name(elem));
	entry->pl_all = B_TRUE;
	*last = entry;
	}
	}
	}

	/*
	* Now go through and check the width of any non-fixed columns
	*/
	for (entry = *plp; entry != NULL; entry = entry->pl_next) {
	if (entry->pl_fixed && !literal)
	continue;

	if (entry->pl_prop != ZPROP_INVAL) {
	if (zfs_prop_get(zhp, entry->pl_prop,
	buf, sizeof (buf), NULL, NULL, 0, literal) == 0) {
	if (strlen(buf) > entry->pl_width)
	entry->pl_width = strlen(buf);
	}
	if (received && zfs_prop_get_recvd(zhp,
	zfs_prop_to_name(entry->pl_prop),
	buf, sizeof (buf), literal) == 0)
	if (strlen(buf) > entry->pl_recvd_width)
	entry->pl_recvd_width = strlen(buf);
	} else {
	if (nvlist_lookup_nvlist(userprops, entry->pl_user_prop,
	&propval) == 0) {
	verify(nvlist_lookup_string(propval,
	ZPROP_VALUE, &strval) == 0);
	if (strlen(strval) > entry->pl_width)
	entry->pl_width = strlen(strval);
	}
	if (received && zfs_prop_get_recvd(zhp,
	entry->pl_user_prop,
	buf, sizeof (buf), literal) == 0)
	if (strlen(buf) > entry->pl_recvd_width)
	entry->pl_recvd_width = strlen(buf);
	}
	}

	return (0);
	}

	void
	zfs_prune_proplist(zfs_handle_t zhp, uint8_t props)
	{
	nvpair_t *curr;
	nvpair_t *next;

	/*
	* Keep a reference to the props-table against which we prune the
	* properties.
	*/
	zhp->zfs_props_table = props;

	curr = nvlist_next_nvpair(zhp->zfs_props, NULL);

	while (curr) {
	zfs_prop_t zfs_prop = zfs_name_to_prop(nvpair_name(curr));
	next = nvlist_next_nvpair(zhp->zfs_props, curr);

	/*
	* User properties will result in ZPROP_INVAL, and since we
	* only know how to prune standard ZFS properties, we always
	* leave these in the list. This can also happen if we
	* encounter an unknown DSL property (when running older
	* software, for example).
	*/
	if (zfs_prop != ZPROP_INVAL && props[zfs_prop] == B_FALSE)
	(void) nvlist_remove(zhp->zfs_props,
	nvpair_name(curr), nvpair_type(curr));
	curr = next;
	}
	}

	static int
	zfs_smb_acl_mgmt(libzfs_handle_t hdl, char dataset, char *path,
	zfs_smb_acl_op_t cmd, char resource1, char resource2)
	{
	zfs_cmd_t zc = {"\0"};
	nvlist_t *nvlist = NULL;
	int error;

	(void) strlcpy(zc.zc_name, dataset, sizeof (zc.zc_name));
	(void) strlcpy(zc.zc_value, path, sizeof (zc.zc_value));
	zc.zc_cookie = (uint64_t)cmd;

	if (cmd == ZFS_SMB_ACL_RENAME) {
	if (nvlist_alloc(&nvlist, NV_UNIQUE_NAME, 0) != 0) {
	(void) no_memory(hdl);
	return (0);
	}
	}

	switch (cmd) {
	case ZFS_SMB_ACL_ADD:
	case ZFS_SMB_ACL_REMOVE:
	(void) strlcpy(zc.zc_string, resource1, sizeof (zc.zc_string));
	break;
	case ZFS_SMB_ACL_RENAME:
	if (nvlist_add_string(nvlist, ZFS_SMB_ACL_SRC,
	resource1) != 0) {
	(void) no_memory(hdl);
	return (-1);
	}
	if (nvlist_add_string(nvlist, ZFS_SMB_ACL_TARGET,
	resource2) != 0) {
	(void) no_memory(hdl);
	return (-1);
	}
	if (zcmd_write_src_nvlist(hdl, &zc, nvlist) != 0) {
	nvlist_free(nvlist);
	return (-1);
	}
	break;
	case ZFS_SMB_ACL_PURGE:
	break;
	default:
	return (-1);
	}
	error = ioctl(hdl->libzfs_fd, ZFS_IOC_SMB_ACL, &zc);
	nvlist_free(nvlist);
	return (error);
	}

	int
	zfs_smb_acl_add(libzfs_handle_t hdl, char dataset,
	char path, char resource)
	{
	return (zfs_smb_acl_mgmt(hdl, dataset, path, ZFS_SMB_ACL_ADD,
	resource, NULL));
	}

	int
	zfs_smb_acl_remove(libzfs_handle_t hdl, char dataset,
	char path, char resource)
	{
	return (zfs_smb_acl_mgmt(hdl, dataset, path, ZFS_SMB_ACL_REMOVE,
	resource, NULL));
	}

	int
	zfs_smb_acl_purge(libzfs_handle_t hdl, char dataset, char *path)
	{
	return (zfs_smb_acl_mgmt(hdl, dataset, path, ZFS_SMB_ACL_PURGE,
	NULL, NULL));
	}

	int
	zfs_smb_acl_rename(libzfs_handle_t hdl, char dataset, char *path,
	char oldname, char newname)
	{
	return (zfs_smb_acl_mgmt(hdl, dataset, path, ZFS_SMB_ACL_RENAME,
	oldname, newname));
	}

	int
	zfs_userspace(zfs_handle_t *zhp, zfs_userquota_prop_t type,
	zfs_userspace_cb_t func, void *arg)
	{
	zfs_cmd_t zc = {"\0"};
	zfs_useracct_t buf[100];
	libzfs_handle_t *hdl = zhp->zfs_hdl;
	int ret;

	(void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));

	zc.zc_objset_type = type;
	zc.zc_nvlist_dst = (uintptr_t)buf;

	for (;;) {
	zfs_useracct_t *zua = buf;

	zc.zc_nvlist_dst_size = sizeof (buf);
	if (zfs_ioctl(hdl, ZFS_IOC_USERSPACE_MANY, &zc) != 0) {
	char errbuf[1024];

	if ((errno == ENOTSUP &&
	(type == ZFS_PROP_USEROBJUSED \|\|
	type == ZFS_PROP_GROUPOBJUSED \|\|
	type == ZFS_PROP_USEROBJQUOTA \|\|
	type == ZFS_PROP_GROUPOBJQUOTA \|\|
	type == ZFS_PROP_PROJECTOBJUSED \|\|
	type == ZFS_PROP_PROJECTOBJQUOTA \|\|
	type == ZFS_PROP_PROJECTUSED \|\|
	type == ZFS_PROP_PROJECTQUOTA)))
	break;

	(void) snprintf(errbuf, sizeof (errbuf),
	dgettext(TEXT_DOMAIN,
	"cannot get used/quota for %s"), zc.zc_name);
	return (zfs_standard_error_fmt(hdl, errno, errbuf));
	}
	if (zc.zc_nvlist_dst_size == 0)
	break;

	while (zc.zc_nvlist_dst_size > 0) {
	if ((ret = func(arg, zua->zu_domain, zua->zu_rid,
	zua->zu_space)) != 0)
	return (ret);
	zua++;
	zc.zc_nvlist_dst_size -= sizeof (zfs_useracct_t);
	}
	}

	return (0);
	}

	struct holdarg {
	nvlist_t *nvl;
	const char *snapname;
	const char *tag;
	boolean_t recursive;
	int error;
	};

	static int
	zfs_hold_one(zfs_handle_t zhp, void arg)
	{
	struct holdarg *ha = arg;
	char name[ZFS_MAX_DATASET_NAME_LEN];
	int rv = 0;

	if (snprintf(name, sizeof (name), "%s@%s", zhp->zfs_name,
	ha->snapname) >= sizeof (name))
	return (EINVAL);

	if (lzc_exists(name))
	fnvlist_add_string(ha->nvl, name, ha->tag);

	if (ha->recursive)
	rv = zfs_iter_filesystems(zhp, zfs_hold_one, ha);
	zfs_close(zhp);
	return (rv);
	}

	int
	zfs_hold(zfs_handle_t zhp, const char snapname, const char *tag,
	boolean_t recursive, int cleanup_fd)
	{
	int ret;
	struct holdarg ha;

	ha.nvl = fnvlist_alloc();
	ha.snapname = snapname;
	ha.tag = tag;
	ha.recursive = recursive;
	(void) zfs_hold_one(zfs_handle_dup(zhp), &ha);

	if (nvlist_empty(ha.nvl)) {
	char errbuf[1024];

	fnvlist_free(ha.nvl);
	ret = ENOENT;
	(void) snprintf(errbuf, sizeof (errbuf),
	dgettext(TEXT_DOMAIN,
	"cannot hold snapshot '%s@%s'"),
	zhp->zfs_name, snapname);
	(void) zfs_standard_error(zhp->zfs_hdl, ret, errbuf);
	return (ret);
	}

	ret = zfs_hold_nvl(zhp, cleanup_fd, ha.nvl);
	fnvlist_free(ha.nvl);

	return (ret);
	}

	int
	zfs_hold_nvl(zfs_handle_t zhp, int cleanup_fd, nvlist_t holds)
	{
	int ret;
	nvlist_t *errors;
	libzfs_handle_t *hdl = zhp->zfs_hdl;
	char errbuf[1024];
	nvpair_t *elem;

	errors = NULL;
	ret = lzc_hold(holds, cleanup_fd, &errors);

	if (ret == 0) {
	/* There may be errors even in the success case. */
	fnvlist_free(errors);
	return (0);
	}

	if (nvlist_empty(errors)) {
	/* no hold-specific errors */
	(void) snprintf(errbuf, sizeof (errbuf),
	dgettext(TEXT_DOMAIN, "cannot hold"));
	switch (ret) {
	case ENOTSUP:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"pool must be upgraded"));
	(void) zfs_error(hdl, EZFS_BADVERSION, errbuf);
	break;
	case EINVAL:
	(void) zfs_error(hdl, EZFS_BADTYPE, errbuf);
	break;
	default:
	(void) zfs_standard_error(hdl, ret, errbuf);
	}
	}

	for (elem = nvlist_next_nvpair(errors, NULL);
	elem != NULL;
	elem = nvlist_next_nvpair(errors, elem)) {
	(void) snprintf(errbuf, sizeof (errbuf),
	dgettext(TEXT_DOMAIN,
	"cannot hold snapshot '%s'"), nvpair_name(elem));
	switch (fnvpair_value_int32(elem)) {
	case E2BIG:
	/*
	* Temporary tags wind up having the ds object id
	* prepended. So even if we passed the length check
	* above, it's still possible for the tag to wind
	* up being slightly too long.
	*/
	(void) zfs_error(hdl, EZFS_TAGTOOLONG, errbuf);
	break;
	case EINVAL:
	(void) zfs_error(hdl, EZFS_BADTYPE, errbuf);
	break;
	case EEXIST:
	(void) zfs_error(hdl, EZFS_REFTAG_HOLD, errbuf);
	break;
	default:
	(void) zfs_standard_error(hdl,
	fnvpair_value_int32(elem), errbuf);
	}
	}

	fnvlist_free(errors);
	return (ret);
	}

	static int
	zfs_release_one(zfs_handle_t zhp, void arg)
	{
	struct holdarg *ha = arg;
	char name[ZFS_MAX_DATASET_NAME_LEN];
	int rv = 0;
	nvlist_t *existing_holds;

	if (snprintf(name, sizeof (name), "%s@%s", zhp->zfs_name,
	ha->snapname) >= sizeof (name)) {
	ha->error = EINVAL;
	rv = EINVAL;
	}

	if (lzc_get_holds(name, &existing_holds) != 0) {
	ha->error = ENOENT;
	} else if (!nvlist_exists(existing_holds, ha->tag)) {
	ha->error = ESRCH;
	} else {
	nvlist_t *torelease = fnvlist_alloc();
	fnvlist_add_boolean(torelease, ha->tag);
	fnvlist_add_nvlist(ha->nvl, name, torelease);
	fnvlist_free(torelease);
	}

	if (ha->recursive)
	rv = zfs_iter_filesystems(zhp, zfs_release_one, ha);
	zfs_close(zhp);
	return (rv);
	}

	int
	zfs_release(zfs_handle_t zhp, const char snapname, const char *tag,
	boolean_t recursive)
	{
	int ret;
	struct holdarg ha;
	nvlist_t *errors = NULL;
	nvpair_t *elem;
	libzfs_handle_t *hdl = zhp->zfs_hdl;
	char errbuf[1024];

	ha.nvl = fnvlist_alloc();
	ha.snapname = snapname;
	ha.tag = tag;
	ha.recursive = recursive;
	ha.error = 0;
	(void) zfs_release_one(zfs_handle_dup(zhp), &ha);

	if (nvlist_empty(ha.nvl)) {
	fnvlist_free(ha.nvl);
	ret = ha.error;
	(void) snprintf(errbuf, sizeof (errbuf),
	dgettext(TEXT_DOMAIN,
	"cannot release hold from snapshot '%s@%s'"),
	zhp->zfs_name, snapname);
	if (ret == ESRCH) {
	(void) zfs_error(hdl, EZFS_REFTAG_RELE, errbuf);
	} else {
	(void) zfs_standard_error(hdl, ret, errbuf);
	}
	return (ret);
	}

	ret = lzc_release(ha.nvl, &errors);
	fnvlist_free(ha.nvl);

	if (ret == 0) {
	/* There may be errors even in the success case. */
	fnvlist_free(errors);
	return (0);
	}

	if (nvlist_empty(errors)) {
	/* no hold-specific errors */
	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
	"cannot release"));
	switch (errno) {
	case ENOTSUP:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"pool must be upgraded"));
	(void) zfs_error(hdl, EZFS_BADVERSION, errbuf);
	break;
	default:
	(void) zfs_standard_error_fmt(hdl, errno, errbuf);
	}
	}

	for (elem = nvlist_next_nvpair(errors, NULL);
	elem != NULL;
	elem = nvlist_next_nvpair(errors, elem)) {
	(void) snprintf(errbuf, sizeof (errbuf),
	dgettext(TEXT_DOMAIN,
	"cannot release hold from snapshot '%s'"),
	nvpair_name(elem));
	switch (fnvpair_value_int32(elem)) {
	case ESRCH:
	(void) zfs_error(hdl, EZFS_REFTAG_RELE, errbuf);
	break;
	case EINVAL:
	(void) zfs_error(hdl, EZFS_BADTYPE, errbuf);
	break;
	default:
	(void) zfs_standard_error_fmt(hdl,
	fnvpair_value_int32(elem), errbuf);
	}
	}

	fnvlist_free(errors);
	return (ret);
	}

	int
	zfs_get_fsacl(zfs_handle_t zhp, nvlist_t *nvl)
	{
	zfs_cmd_t zc = {"\0"};
	libzfs_handle_t *hdl = zhp->zfs_hdl;
	int nvsz = 2048;
	void *nvbuf;
	int err = 0;
	char errbuf[1024];

	assert(zhp->zfs_type == ZFS_TYPE_VOLUME \|\|
	zhp->zfs_type == ZFS_TYPE_FILESYSTEM);

	tryagain:

	nvbuf = malloc(nvsz);
	if (nvbuf == NULL) {
	err = (zfs_error(hdl, EZFS_NOMEM, strerror(errno)));
	goto out;
	}

	zc.zc_nvlist_dst_size = nvsz;
	zc.zc_nvlist_dst = (uintptr_t)nvbuf;

	(void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));

	if (zfs_ioctl(hdl, ZFS_IOC_GET_FSACL, &zc) != 0) {
	(void) snprintf(errbuf, sizeof (errbuf),
	dgettext(TEXT_DOMAIN, "cannot get permissions on '%s'"),
	zc.zc_name);
	switch (errno) {
	case ENOMEM:
	free(nvbuf);
	nvsz = zc.zc_nvlist_dst_size;
	goto tryagain;

	case ENOTSUP:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"pool must be upgraded"));
	err = zfs_error(hdl, EZFS_BADVERSION, errbuf);
	break;
	case EINVAL:
	err = zfs_error(hdl, EZFS_BADTYPE, errbuf);
	break;
	case ENOENT:
	err = zfs_error(hdl, EZFS_NOENT, errbuf);
	break;
	default:
	err = zfs_standard_error_fmt(hdl, errno, errbuf);
	break;
	}
	} else {
	/* success */
	int rc = nvlist_unpack(nvbuf, zc.zc_nvlist_dst_size, nvl, 0);
	if (rc) {
	(void) snprintf(errbuf, sizeof (errbuf), dgettext(
	TEXT_DOMAIN, "cannot get permissions on '%s'"),
	zc.zc_name);
	err = zfs_standard_error_fmt(hdl, rc, errbuf);
	}
	}

	free(nvbuf);
	out:
	return (err);
	}

	int
	zfs_set_fsacl(zfs_handle_t zhp, boolean_t un, nvlist_t nvl)
	{
	zfs_cmd_t zc = {"\0"};
	libzfs_handle_t *hdl = zhp->zfs_hdl;
	char *nvbuf;
	char errbuf[1024];
	size_t nvsz;
	int err;

	assert(zhp->zfs_type == ZFS_TYPE_VOLUME \|\|
	zhp->zfs_type == ZFS_TYPE_FILESYSTEM);

	err = nvlist_size(nvl, &nvsz, NV_ENCODE_NATIVE);
	assert(err == 0);

	nvbuf = malloc(nvsz);

	err = nvlist_pack(nvl, &nvbuf, &nvsz, NV_ENCODE_NATIVE, 0);
	assert(err == 0);

	zc.zc_nvlist_src_size = nvsz;
	zc.zc_nvlist_src = (uintptr_t)nvbuf;
	zc.zc_perm_action = un;

	(void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));

	if (zfs_ioctl(hdl, ZFS_IOC_SET_FSACL, &zc) != 0) {
	(void) snprintf(errbuf, sizeof (errbuf),
	dgettext(TEXT_DOMAIN, "cannot set permissions on '%s'"),
	zc.zc_name);
	switch (errno) {
	case ENOTSUP:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"pool must be upgraded"));
	err = zfs_error(hdl, EZFS_BADVERSION, errbuf);
	break;
	case EINVAL:
	err = zfs_error(hdl, EZFS_BADTYPE, errbuf);
	break;
	case ENOENT:
	err = zfs_error(hdl, EZFS_NOENT, errbuf);
	break;
	default:
	err = zfs_standard_error_fmt(hdl, errno, errbuf);
	break;
	}
	}

	free(nvbuf);

	return (err);
	}

	int
	zfs_get_holds(zfs_handle_t zhp, nvlist_t *nvl)
	{
	int err;
	char errbuf[1024];

	err = lzc_get_holds(zhp->zfs_name, nvl);

	if (err != 0) {
	libzfs_handle_t *hdl = zhp->zfs_hdl;

	(void) snprintf(errbuf, sizeof (errbuf),
	dgettext(TEXT_DOMAIN, "cannot get holds for '%s'"),
	zhp->zfs_name);
	switch (err) {
	case ENOTSUP:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"pool must be upgraded"));
	err = zfs_error(hdl, EZFS_BADVERSION, errbuf);
	break;
	case EINVAL:
	err = zfs_error(hdl, EZFS_BADTYPE, errbuf);
	break;
	case ENOENT:
	err = zfs_error(hdl, EZFS_NOENT, errbuf);
	break;
	default:
	err = zfs_standard_error_fmt(hdl, errno, errbuf);
	break;
	}
	}

	return (err);
	}

	/*
	* The theory of raidz space accounting
	*
	* The "referenced" property of RAIDZ vdevs is scaled such that a 128KB block
	* will "reference" 128KB, even though it allocates more than that, to store the
	* parity information (and perhaps skip sectors). This concept of the
	* "referenced" (and other DMU space accounting) being lower than the allocated
	* space by a constant factor is called "raidz deflation."
	*
	* As mentioned above, the constant factor for raidz deflation assumes a 128KB
	* block size. However, zvols typically have a much smaller block size (default
	* 8KB). These smaller blocks may require proportionally much more parity
	* information (and perhaps skip sectors). In this case, the change to the
	* "referenced" property may be much more than the logical block size.
	*
	* Suppose a raidz vdev has 5 disks with ashift=12. A 128k block may be written
	* as follows.
	*
	* +-------+-------+-------+-------+-------+
	* \| disk1 \| disk2 \| disk3 \| disk4 \| disk5 \|
	* +-------+-------+-------+-------+-------+
	* \| P0 \| D0 \| D8 \| D16 \| D24 \|
	* \| P1 \| D1 \| D9 \| D17 \| D25 \|
	* \| P2 \| D2 \| D10 \| D18 \| D26 \|
	* \| P3 \| D3 \| D11 \| D19 \| D27 \|
	* \| P4 \| D4 \| D12 \| D20 \| D28 \|
	* \| P5 \| D5 \| D13 \| D21 \| D29 \|
	* \| P6 \| D6 \| D14 \| D22 \| D30 \|
	* \| P7 \| D7 \| D15 \| D23 \| D31 \|
	* +-------+-------+-------+-------+-------+
	*
	* Above, notice that 160k was allocated: 8 x 4k parity sectors + 32 x 4k data
	* sectors. The dataset's referenced will increase by 128k and the pool's
	* allocated and free properties will be adjusted by 160k.
	*
	* A 4k block written to the same raidz vdev will require two 4k sectors. The
	* blank cells represent unallocated space.
	*
	* +-------+-------+-------+-------+-------+
	* \| disk1 \| disk2 \| disk3 \| disk4 \| disk5 \|
	* +-------+-------+-------+-------+-------+
	* \| P0 \| D0 \| \| \| \|
	* +-------+-------+-------+-------+-------+
	*
	* Above, notice that the 4k block required one sector for parity and another
	* for data. vdev_raidz_asize() will return 8k and as such the pool's allocated
	* and free properties will be adjusted by 8k. The dataset will not be charged
	* 8k. Rather, it will be charged a value that is scaled according to the
	* overhead of the 128k block on the same vdev. This 8k allocation will be
	* charged 8k * 128k / 160k. 128k is from SPA_OLD_MAXBLOCKSIZE and 160k is as
	* calculated in the 128k block example above.
	*
	* Every raidz allocation is sized to be a multiple of nparity+1 sectors. That
	* is, every raidz1 allocation will be a multiple of 2 sectors, raidz2
	* allocations are a multiple of 3 sectors, and raidz3 allocations are a
	* multiple of of 4 sectors. When a block does not fill the required number of
	* sectors, skip blocks (sectors) are used.
	*
	* An 8k block being written to a raidz vdev may be written as follows:
	*
	* +-------+-------+-------+-------+-------+
	* \| disk1 \| disk2 \| disk3 \| disk4 \| disk5 \|
	* +-------+-------+-------+-------+-------+
	* \| P0 \| D0 \| D1 \| S0 \| \|
	* +-------+-------+-------+-------+-------+
	*
	* In order to maintain the nparity+1 allocation size, a skip block (S0) was
	* added. For this 8k block, the pool's allocated and free properties are
	* adjusted by 16k and the dataset's referenced is increased by 16k * 128k /
	* 160k. Again, 128k is from SPA_OLD_MAXBLOCKSIZE and 160k is as calculated in
	* the 128k block example above.
	*
	- * The situtation is slightly different for dRAID since the minimum allocation
	+ * The situation is slightly different for dRAID since the minimum allocation
	* size is the full group width. The same 8K block above would be written as
	* follows in a dRAID group:
	*
	* +-------+-------+-------+-------+-------+
	* \| disk1 \| disk2 \| disk3 \| disk4 \| disk5 \|
	* +-------+-------+-------+-------+-------+
	* \| P0 \| D0 \| D1 \| S0 \| S1 \|
	* +-------+-------+-------+-------+-------+
	*
	* Compression may lead to a variety of block sizes being written for the same
	* volume or file. There is no clear way to reserve just the amount of space
	* that will be required, so the worst case (no compression) is assumed.
	* Note that metadata blocks will typically be compressed, so the reservation
	* size returned by zvol_volsize_to_reservation() will generally be slightly
	* larger than the maximum that the volume can reference.
	*/

	/*
	* Derived from function of same name in module/zfs/vdev_raidz.c. Returns the
	* amount of space (in bytes) that will be allocated for the specified block
	* size. Note that the "referenced" space accounted will be less than this, but
	* not necessarily equal to "blksize", due to RAIDZ deflation.
	*/
	static uint64_t
	vdev_raidz_asize(uint64_t ndisks, uint64_t nparity, uint64_t ashift,
	uint64_t blksize)
	{
	uint64_t asize, ndata;

	ASSERT3U(ndisks, >, nparity);
	ndata = ndisks - nparity;
	asize = ((blksize - 1) >> ashift) + 1;
	asize += nparity * ((asize + ndata - 1) / ndata);
	asize = roundup(asize, nparity + 1) << ashift;

	return (asize);
	}

	/*
	* Derived from function of same name in module/zfs/vdev_draid.c. Returns the
	* amount of space (in bytes) that will be allocated for the specified block
	* size.
	*/
	static uint64_t
	vdev_draid_asize(uint64_t ndisks, uint64_t nparity, uint64_t ashift,
	uint64_t blksize)
	{
	ASSERT3U(ndisks, >, nparity);
	uint64_t ndata = ndisks - nparity;
	uint64_t rows = ((blksize - 1) / (ndata << ashift)) + 1;
	uint64_t asize = (rows * ndisks) << ashift;

	return (asize);
	}

	/*
	* Determine how much space will be allocated if it lands on the most space-
	* inefficient top-level vdev. Returns the size in bytes required to store one
	* copy of the volume data. See theory comment above.
	*/
	static uint64_t
	volsize_from_vdevs(zpool_handle_t *zhp, uint64_t nblocks, uint64_t blksize)
	{
	nvlist_t config, tree, **vdevs;
	uint_t nvdevs;
	uint64_t ret = 0;

	config = zpool_get_config(zhp, NULL);
	if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, &tree) != 0 \|\|
	nvlist_lookup_nvlist_array(tree, ZPOOL_CONFIG_CHILDREN,
	&vdevs, &nvdevs) != 0) {
	return (nblocks * blksize);
	}

	for (int v = 0; v < nvdevs; v++) {
	char *type;
	uint64_t nparity, ashift, asize, tsize;
	uint64_t volsize;

	if (nvlist_lookup_string(vdevs[v], ZPOOL_CONFIG_TYPE,
	&type) != 0)
	continue;

	if (strcmp(type, VDEV_TYPE_RAIDZ) != 0 &&
	strcmp(type, VDEV_TYPE_DRAID) != 0)
	continue;

	if (nvlist_lookup_uint64(vdevs[v],
	ZPOOL_CONFIG_NPARITY, &nparity) != 0)
	continue;

	if (nvlist_lookup_uint64(vdevs[v],
	ZPOOL_CONFIG_ASHIFT, &ashift) != 0)
	continue;

	if (strcmp(type, VDEV_TYPE_RAIDZ) == 0) {
	nvlist_t **disks;
	uint_t ndisks;

	if (nvlist_lookup_nvlist_array(vdevs[v],
	ZPOOL_CONFIG_CHILDREN, &disks, &ndisks) != 0)
	continue;

	/* allocation size for the "typical" 128k block */
	tsize = vdev_raidz_asize(ndisks, nparity, ashift,
	SPA_OLD_MAXBLOCKSIZE);

	/* allocation size for the blksize block */
	asize = vdev_raidz_asize(ndisks, nparity, ashift,
	blksize);
	} else {
	uint64_t ndata;

	if (nvlist_lookup_uint64(vdevs[v],
	ZPOOL_CONFIG_DRAID_NDATA, &ndata) != 0)
	continue;

	/* allocation size for the "typical" 128k block */
	tsize = vdev_draid_asize(ndata + nparity, nparity,
	ashift, SPA_OLD_MAXBLOCKSIZE);

	/* allocation size for the blksize block */
	asize = vdev_draid_asize(ndata + nparity, nparity,
	ashift, blksize);
	}

	/*
	* Scale this size down as a ratio of 128k / tsize.
	* See theory statement above.
	*/
	volsize = nblocks * asize * SPA_OLD_MAXBLOCKSIZE / tsize;
	if (volsize > ret) {
	ret = volsize;
	}
	}

	if (ret == 0) {
	ret = nblocks * blksize;
	}

	return (ret);
	}

	/*
	* Convert the zvol's volume size to an appropriate reservation. See theory
	* comment above.
	*
	* Note: If this routine is updated, it is necessary to update the ZFS test
	* suite's shell version in reservation.shlib.
	*/
	uint64_t
	zvol_volsize_to_reservation(zpool_handle_t *zph, uint64_t volsize,
	nvlist_t *props)
	{
	uint64_t numdb;
	uint64_t nblocks, volblocksize;
	int ncopies;
	char *strval;

	if (nvlist_lookup_string(props,
	zfs_prop_to_name(ZFS_PROP_COPIES), &strval) == 0)
	ncopies = atoi(strval);
	else
	ncopies = 1;
	if (nvlist_lookup_uint64(props,
	zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE),
	&volblocksize) != 0)
	volblocksize = ZVOL_DEFAULT_BLOCKSIZE;

	nblocks = volsize / volblocksize;
	/*
	* Metadata defaults to using 128k blocks, not volblocksize blocks. For
	* this reason, only the data blocks are scaled based on vdev config.
	*/
	volsize = volsize_from_vdevs(zph, nblocks, volblocksize);

	/* start with metadnode L0-L6 */
	numdb = 7;
	/* calculate number of indirects */
	while (nblocks > 1) {
	nblocks += DNODES_PER_LEVEL - 1;
	nblocks /= DNODES_PER_LEVEL;
	numdb += nblocks;
	}
	numdb *= MIN(SPA_DVAS_PER_BP, ncopies + 1);
	volsize *= ncopies;
	/*
	* this is exactly DN_MAX_INDBLKSHIFT when metadata isn't
	* compressed, but in practice they compress down to about
	* 1100 bytes
	*/
	numdb *= 1ULL << DN_MAX_INDBLKSHIFT;
	volsize += numdb;
	return (volsize);
	}

	/*
	* Wait for the given activity and return the status of the wait (whether or not
	* any waiting was done) in the 'waited' parameter. Non-existent fses are
	* reported via the 'missing' parameter, rather than by printing an error
	* message. This is convenient when this function is called in a loop over a
	* long period of time (as it is, for example, by zfs's wait cmd). In that
	* scenario, a fs being exported or destroyed should be considered a normal
	* event, so we don't want to print an error when we find that the fs doesn't
	* exist.
	*/
	int
	zfs_wait_status(zfs_handle_t *zhp, zfs_wait_activity_t activity,
	boolean_t missing, boolean_t waited)
	{
	int error = lzc_wait_fs(zhp->zfs_name, activity, waited);
	*missing = (error == ENOENT);
	if (*missing)
	return (0);

	if (error != 0) {
	(void) zfs_standard_error_fmt(zhp->zfs_hdl, error,
	dgettext(TEXT_DOMAIN, "error waiting in fs '%s'"),
	zhp->zfs_name);
	}

	return (error);
	}
	diff --git a/sys/contrib/openzfs/lib/libzfs/libzfs_diff.c b/sys/contrib/openzfs/lib/libzfs/libzfs_diff.c
	index 7941a5883074..12e079b0eeb7 100644
	--- a/sys/contrib/openzfs/lib/libzfs/libzfs_diff.c
	+++ b/sys/contrib/openzfs/lib/libzfs/libzfs_diff.c
	@@ -1,797 +1,797 @@
	/*
	* 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) 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright 2015 Nexenta Systems, Inc. All rights reserved.
	* Copyright (c) 2015, 2018 by Delphix. All rights reserved.
	* Copyright 2016 Joyent, Inc.
	* Copyright 2016 Igor Kozhukhov <ikozhukhov@gmail.com>
	*/

	/*
	* zfs diff support
	*/
	#include <ctype.h>
	#include <errno.h>
	#include <libintl.h>
	#include <string.h>
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <fcntl.h>
	#include <stddef.h>
	#include <unistd.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <stropts.h>
	#include <pthread.h>
	#include <sys/zfs_ioctl.h>
	#include <libzfs.h>
	#include "libzfs_impl.h"

	#define ZDIFF_SNAPDIR "/.zfs/snapshot/"
	#define ZDIFF_PREFIX "zfs-diff-%d"

	#define ZDIFF_ADDED '+'
	#define ZDIFF_MODIFIED 'M'
	#define ZDIFF_REMOVED '-'
	#define ZDIFF_RENAMED 'R'


	/*
	* Given a {dsname, object id}, get the object path
	*/
	static int
	get_stats_for_obj(differ_info_t di, const char dsname, uint64_t obj,
	char pn, int maxlen, zfs_stat_t sb)
	{
	zfs_cmd_t zc = {"\0"};
	int error;

	(void) strlcpy(zc.zc_name, dsname, sizeof (zc.zc_name));
	zc.zc_obj = obj;

	errno = 0;
	error = zfs_ioctl(di->zhp->zfs_hdl, ZFS_IOC_OBJ_TO_STATS, &zc);
	di->zerr = errno;

	/* we can get stats even if we failed to get a path */
	(void) memcpy(sb, &zc.zc_stat, sizeof (zfs_stat_t));
	if (error == 0) {
	ASSERT(di->zerr == 0);
	(void) strlcpy(pn, zc.zc_value, maxlen);
	return (0);
	}

	if (di->zerr == ESTALE) {
	(void) snprintf(pn, maxlen, "(on_delete_queue)");
	return (0);
	} else if (di->zerr == EPERM) {
	(void) snprintf(di->errbuf, sizeof (di->errbuf),
	dgettext(TEXT_DOMAIN,
	"The sys_config privilege or diff delegated permission "
	"is needed\nto discover path names"));
	return (-1);
	} else if (di->zerr == EACCES) {
	(void) snprintf(di->errbuf, sizeof (di->errbuf),
	dgettext(TEXT_DOMAIN,
	"Key must be loaded to discover path names"));
	return (-1);
	} else {
	(void) snprintf(di->errbuf, sizeof (di->errbuf),
	dgettext(TEXT_DOMAIN,
	"Unable to determine path or stats for "
	"object %lld in %s"), (longlong_t)obj, dsname);
	return (-1);
	}
	}

	/*
	* stream_bytes
	*
	* Prints a file name out a character at a time. If the character is
	* not in the range of what we consider "printable" ASCII, display it
	* as an escaped 4-digit octal value. ASCII values less than a space
	* are all control characters and we declare the upper end as the
	* DELete character. This also is the last 7-bit ASCII character.
	* We choose to treat all 8-bit ASCII as not printable for this
	* application.
	*/
	static void
	stream_bytes(FILE fp, const char string)
	{
	char c;

	while ((c = *string++) != '\0') {
	if (c > ' ' && c != '\\' && c < '\177') {
	(void) fprintf(fp, "%c", c);
	} else {
	(void) fprintf(fp, "\\%04o", (uint8_t)c);
	}
	}
	}

	static void
	print_what(FILE *fp, mode_t what)
	{
	char symbol;

	switch (what & S_IFMT) {
	case S_IFBLK:
	symbol = 'B';
	break;
	case S_IFCHR:
	symbol = 'C';
	break;
	case S_IFDIR:
	symbol = '/';
	break;
	#ifdef S_IFDOOR
	case S_IFDOOR:
	symbol = '>';
	break;
	#endif
	case S_IFIFO:
	symbol = '\|';
	break;
	case S_IFLNK:
	symbol = '@';
	break;
	#ifdef S_IFPORT
	case S_IFPORT:
	symbol = 'P';
	break;
	#endif
	case S_IFSOCK:
	symbol = '=';
	break;
	case S_IFREG:
	symbol = 'F';
	break;
	default:
	symbol = '?';
	break;
	}
	(void) fprintf(fp, "%c", symbol);
	}

	static void
	print_cmn(FILE fp, differ_info_t di, const char *file)
	{
	stream_bytes(fp, di->dsmnt);
	stream_bytes(fp, file);
	}

	static void
	print_rename(FILE fp, differ_info_t di, const char old, const char new,
	zfs_stat_t *isb)
	{
	if (di->timestamped)
	(void) fprintf(fp, "%10lld.%09lld\t",
	(longlong_t)isb->zs_ctime[0],
	(longlong_t)isb->zs_ctime[1]);
	(void) fprintf(fp, "%c\t", ZDIFF_RENAMED);
	if (di->classify) {
	print_what(fp, isb->zs_mode);
	(void) fprintf(fp, "\t");
	}
	print_cmn(fp, di, old);
	if (di->scripted)
	(void) fprintf(fp, "\t");
	else
	(void) fprintf(fp, " -> ");
	print_cmn(fp, di, new);
	(void) fprintf(fp, "\n");
	}

	static void
	print_link_change(FILE fp, differ_info_t di, int delta, const char *file,
	zfs_stat_t *isb)
	{
	if (di->timestamped)
	(void) fprintf(fp, "%10lld.%09lld\t",
	(longlong_t)isb->zs_ctime[0],
	(longlong_t)isb->zs_ctime[1]);
	(void) fprintf(fp, "%c\t", ZDIFF_MODIFIED);
	if (di->classify) {
	print_what(fp, isb->zs_mode);
	(void) fprintf(fp, "\t");
	}
	print_cmn(fp, di, file);
	(void) fprintf(fp, "\t(%+d)", delta);
	(void) fprintf(fp, "\n");
	}

	static void
	print_file(FILE fp, differ_info_t di, char type, const char *file,
	zfs_stat_t *isb)
	{
	if (di->timestamped)
	(void) fprintf(fp, "%10lld.%09lld\t",
	(longlong_t)isb->zs_ctime[0],
	(longlong_t)isb->zs_ctime[1]);
	(void) fprintf(fp, "%c\t", type);
	if (di->classify) {
	print_what(fp, isb->zs_mode);
	(void) fprintf(fp, "\t");
	}
	print_cmn(fp, di, file);
	(void) fprintf(fp, "\n");
	}

	static int
	write_inuse_diffs_one(FILE fp, differ_info_t di, uint64_t dobj)
	{
	struct zfs_stat fsb, tsb;
	mode_t fmode, tmode;
	char fobjname[MAXPATHLEN], tobjname[MAXPATHLEN];
	int fobjerr, tobjerr;
	int change;

	if (dobj == di->shares)
	return (0);

	/*
	* Check the from and to snapshots for info on the object. If
	* we get ENOENT, then the object just didn't exist in that
	* snapshot. If we get ENOTSUP, then we tried to get
	* info on a non-ZPL object, which we don't care about anyway.
	*/
	fobjerr = get_stats_for_obj(di, di->fromsnap, dobj, fobjname,
	MAXPATHLEN, &fsb);
	if (fobjerr && di->zerr != ENOENT && di->zerr != ENOTSUP)
	return (-1);

	tobjerr = get_stats_for_obj(di, di->tosnap, dobj, tobjname,
	MAXPATHLEN, &tsb);
	if (tobjerr && di->zerr != ENOENT && di->zerr != ENOTSUP)
	return (-1);

	/*
	* Unallocated object sharing the same meta dnode block
	*/
	if (fobjerr && tobjerr) {
	ASSERT(di->zerr == ENOENT \|\| di->zerr == ENOTSUP);
	di->zerr = 0;
	return (0);
	}

	di->zerr = 0; /* negate get_stats_for_obj() from side that failed */
	fmode = fsb.zs_mode & S_IFMT;
	tmode = tsb.zs_mode & S_IFMT;
	if (fmode == S_IFDIR \|\| tmode == S_IFDIR \|\| fsb.zs_links == 0 \|\|
	tsb.zs_links == 0)
	change = 0;
	else
	change = tsb.zs_links - fsb.zs_links;

	if (fobjerr) {
	if (change) {
	print_link_change(fp, di, change, tobjname, &tsb);
	return (0);
	}
	print_file(fp, di, ZDIFF_ADDED, tobjname, &tsb);
	return (0);
	} else if (tobjerr) {
	if (change) {
	print_link_change(fp, di, change, fobjname, &fsb);
	return (0);
	}
	print_file(fp, di, ZDIFF_REMOVED, fobjname, &fsb);
	return (0);
	}

	if (fmode != tmode && fsb.zs_gen == tsb.zs_gen)
	tsb.zs_gen++; /* Force a generational difference */

	/* Simple modification or no change */
	if (fsb.zs_gen == tsb.zs_gen) {
	/* No apparent changes. Could we assert !this? */
	if (fsb.zs_ctime[0] == tsb.zs_ctime[0] &&
	fsb.zs_ctime[1] == tsb.zs_ctime[1])
	return (0);
	if (change) {
	print_link_change(fp, di, change,
	change > 0 ? fobjname : tobjname, &tsb);
	} else if (strcmp(fobjname, tobjname) == 0) {
	print_file(fp, di, ZDIFF_MODIFIED, fobjname, &tsb);
	} else {
	print_rename(fp, di, fobjname, tobjname, &tsb);
	}
	return (0);
	} else {
	/* file re-created or object re-used */
	print_file(fp, di, ZDIFF_REMOVED, fobjname, &fsb);
	print_file(fp, di, ZDIFF_ADDED, tobjname, &tsb);
	return (0);
	}
	}

	static int
	write_inuse_diffs(FILE fp, differ_info_t di, dmu_diff_record_t *dr)
	{
	uint64_t o;
	int err;

	for (o = dr->ddr_first; o <= dr->ddr_last; o++) {
	if ((err = write_inuse_diffs_one(fp, di, o)) != 0)
	return (err);
	}
	return (0);
	}

	static int
	describe_free(FILE fp, differ_info_t di, uint64_t object, char *namebuf,
	int maxlen)
	{
	struct zfs_stat sb;

	if (get_stats_for_obj(di, di->fromsnap, object, namebuf,
	maxlen, &sb) != 0) {
	return (-1);
	}
	/* Don't print if in the delete queue on from side */
	if (di->zerr == ESTALE) {
	di->zerr = 0;
	return (0);
	}

	print_file(fp, di, ZDIFF_REMOVED, namebuf, &sb);
	return (0);
	}

	static int
	write_free_diffs(FILE fp, differ_info_t di, dmu_diff_record_t *dr)
	{
	zfs_cmd_t zc = {"\0"};
	libzfs_handle_t *lhdl = di->zhp->zfs_hdl;
	char fobjname[MAXPATHLEN];

	(void) strlcpy(zc.zc_name, di->fromsnap, sizeof (zc.zc_name));
	zc.zc_obj = dr->ddr_first - 1;

	ASSERT(di->zerr == 0);

	while (zc.zc_obj < dr->ddr_last) {
	int err;

	err = zfs_ioctl(lhdl, ZFS_IOC_NEXT_OBJ, &zc);
	if (err == 0) {
	if (zc.zc_obj == di->shares) {
	zc.zc_obj++;
	continue;
	}
	if (zc.zc_obj > dr->ddr_last) {
	break;
	}
	err = describe_free(fp, di, zc.zc_obj, fobjname,
	MAXPATHLEN);
	if (err)
	break;
	} else if (errno == ESRCH) {
	break;
	} else {
	(void) snprintf(di->errbuf, sizeof (di->errbuf),
	dgettext(TEXT_DOMAIN,
	"next allocated object (> %lld) find failure"),
	(longlong_t)zc.zc_obj);
	di->zerr = errno;
	break;
	}
	}
	if (di->zerr)
	return (-1);
	return (0);
	}

	static void *
	differ(void *arg)
	{
	differ_info_t *di = arg;
	dmu_diff_record_t dr;
	FILE *ofp;
	int err = 0;

	if ((ofp = fdopen(di->outputfd, "w")) == NULL) {
	di->zerr = errno;
	strlcpy(di->errbuf, strerror(errno), sizeof (di->errbuf));
	(void) close(di->datafd);
	return ((void *)-1);
	}

	for (;;) {
	char cp = (char )&dr;
	int len = sizeof (dr);
	int rv;

	do {
	rv = read(di->datafd, cp, len);
	cp += rv;
	len -= rv;
	} while (len > 0 && rv > 0);

	if (rv < 0 \|\| (rv == 0 && len != sizeof (dr))) {
	di->zerr = EPIPE;
	break;
	} else if (rv == 0) {
	/* end of file at a natural breaking point */
	break;
	}

	switch (dr.ddr_type) {
	case DDR_FREE:
	err = write_free_diffs(ofp, di, &dr);
	break;
	case DDR_INUSE:
	err = write_inuse_diffs(ofp, di, &dr);
	break;
	default:
	di->zerr = EPIPE;
	break;
	}

	if (err \|\| di->zerr)
	break;
	}

	(void) fclose(ofp);
	(void) close(di->datafd);
	if (err)
	return ((void *)-1);
	if (di->zerr) {
	ASSERT(di->zerr == EPIPE);
	(void) snprintf(di->errbuf, sizeof (di->errbuf),
	dgettext(TEXT_DOMAIN,
	"Internal error: bad data from diff IOCTL"));
	return ((void *)-1);
	}
	return ((void *)0);
	}

	static int
	make_temp_snapshot(differ_info_t *di)
	{
	libzfs_handle_t *hdl = di->zhp->zfs_hdl;
	zfs_cmd_t zc = {"\0"};

	(void) snprintf(zc.zc_value, sizeof (zc.zc_value),
	ZDIFF_PREFIX, getpid());
	(void) strlcpy(zc.zc_name, di->ds, sizeof (zc.zc_name));
	zc.zc_cleanup_fd = di->cleanupfd;

	if (zfs_ioctl(hdl, ZFS_IOC_TMP_SNAPSHOT, &zc) != 0) {
	int err = errno;
	if (err == EPERM) {
	(void) snprintf(di->errbuf, sizeof (di->errbuf),
	dgettext(TEXT_DOMAIN, "The diff delegated "
	"permission is needed in order\nto create a "
	"just-in-time snapshot for diffing\n"));
	return (zfs_error(hdl, EZFS_DIFF, di->errbuf));
	} else {
	(void) snprintf(di->errbuf, sizeof (di->errbuf),
	dgettext(TEXT_DOMAIN, "Cannot create just-in-time "
	"snapshot of '%s'"), zc.zc_name);
	return (zfs_standard_error(hdl, err, di->errbuf));
	}
	}

	di->tmpsnap = zfs_strdup(hdl, zc.zc_value);
	di->tosnap = zfs_asprintf(hdl, "%s@%s", di->ds, di->tmpsnap);
	return (0);
	}

	static void
	teardown_differ_info(differ_info_t *di)
	{
	free(di->ds);
	free(di->dsmnt);
	free(di->fromsnap);
	free(di->frommnt);
	free(di->tosnap);
	free(di->tmpsnap);
	free(di->tomnt);
	(void) close(di->cleanupfd);
	}

	static int
	get_snapshot_names(differ_info_t di, const char fromsnap,
	const char *tosnap)
	{
	libzfs_handle_t *hdl = di->zhp->zfs_hdl;
	char *atptrf = NULL;
	char *atptrt = NULL;
	int fdslen, fsnlen;
	int tdslen, tsnlen;

	/*
	* Can accept
	* fdslen fsnlen tdslen tsnlen
	* dataset@snap1
	* 0. dataset@snap1 dataset@snap2 >0 >1 >0 >1
	* 1. dataset@snap1 @snap2 >0 >1 ==0 >1
	* 2. dataset@snap1 dataset >0 >1 >0 ==0
	* 3. @snap1 dataset@snap2 ==0 >1 >0 >1
	* 4. @snap1 dataset ==0 >1 >0 ==0
	*/
	if (tosnap == NULL) {
	/* only a from snapshot given, must be valid */
	(void) snprintf(di->errbuf, sizeof (di->errbuf),
	dgettext(TEXT_DOMAIN,
	"Badly formed snapshot name %s"), fromsnap);

	if (!zfs_validate_name(hdl, fromsnap, ZFS_TYPE_SNAPSHOT,
	B_FALSE)) {
	return (zfs_error(hdl, EZFS_INVALIDNAME,
	di->errbuf));
	}

	atptrf = strchr(fromsnap, '@');
	ASSERT(atptrf != NULL);
	fdslen = atptrf - fromsnap;

	di->fromsnap = zfs_strdup(hdl, fromsnap);
	di->ds = zfs_strdup(hdl, fromsnap);
	di->ds[fdslen] = '\0';

	/* the to snap will be a just-in-time snap of the head */
	return (make_temp_snapshot(di));
	}

	(void) snprintf(di->errbuf, sizeof (di->errbuf),
	dgettext(TEXT_DOMAIN,
	"Unable to determine which snapshots to compare"));

	atptrf = strchr(fromsnap, '@');
	atptrt = strchr(tosnap, '@');
	fdslen = atptrf ? atptrf - fromsnap : strlen(fromsnap);
	tdslen = atptrt ? atptrt - tosnap : strlen(tosnap);
	fsnlen = strlen(fromsnap) - fdslen; /* includes @ sign */
	tsnlen = strlen(tosnap) - tdslen; /* includes @ sign */

	if (fsnlen <= 1 \|\| tsnlen == 1 \|\| (fdslen == 0 && tdslen == 0)) {
	return (zfs_error(hdl, EZFS_INVALIDNAME, di->errbuf));
	} else if ((fdslen > 0 && tdslen > 0) &&
	((tdslen != fdslen \|\| strncmp(fromsnap, tosnap, fdslen) != 0))) {
	/*
	* not the same dataset name, might be okay if
	* tosnap is a clone of a fromsnap descendant.
	*/
	char origin[ZFS_MAX_DATASET_NAME_LEN];
	zprop_source_t src;
	zfs_handle_t *zhp;

	di->ds = zfs_alloc(di->zhp->zfs_hdl, tdslen + 1);
	(void) strncpy(di->ds, tosnap, tdslen);
	di->ds[tdslen] = '\0';

	zhp = zfs_open(hdl, di->ds, ZFS_TYPE_FILESYSTEM);
	while (zhp != NULL) {
	if (zfs_prop_get(zhp, ZFS_PROP_ORIGIN, origin,
	sizeof (origin), &src, NULL, 0, B_FALSE) != 0) {
	(void) zfs_close(zhp);
	zhp = NULL;
	break;
	}
	if (strncmp(origin, fromsnap, fsnlen) == 0)
	break;

	(void) zfs_close(zhp);
	zhp = zfs_open(hdl, origin, ZFS_TYPE_FILESYSTEM);
	}

	if (zhp == NULL) {
	(void) snprintf(di->errbuf, sizeof (di->errbuf),
	dgettext(TEXT_DOMAIN,
	"Not an earlier snapshot from the same fs"));
	return (zfs_error(hdl, EZFS_INVALIDNAME, di->errbuf));
	} else {
	(void) zfs_close(zhp);
	}

	di->isclone = B_TRUE;
	di->fromsnap = zfs_strdup(hdl, fromsnap);
	if (tsnlen) {
	di->tosnap = zfs_strdup(hdl, tosnap);
	} else {
	return (make_temp_snapshot(di));
	}
	} else {
	int dslen = fdslen ? fdslen : tdslen;

	di->ds = zfs_alloc(hdl, dslen + 1);
	(void) strncpy(di->ds, fdslen ? fromsnap : tosnap, dslen);
	di->ds[dslen] = '\0';

	di->fromsnap = zfs_asprintf(hdl, "%s%s", di->ds, atptrf);
	if (tsnlen) {
	di->tosnap = zfs_asprintf(hdl, "%s%s", di->ds, atptrt);
	} else {
	return (make_temp_snapshot(di));
	}
	}
	return (0);
	}

	static int
	get_mountpoint(differ_info_t di, char dsnm, char **mntpt)
	{
	boolean_t mounted;

	mounted = is_mounted(di->zhp->zfs_hdl, dsnm, mntpt);
	if (mounted == B_FALSE) {
	(void) snprintf(di->errbuf, sizeof (di->errbuf),
	dgettext(TEXT_DOMAIN,
	"Cannot diff an unmounted snapshot"));
	return (zfs_error(di->zhp->zfs_hdl, EZFS_BADTYPE, di->errbuf));
	}

	/* Avoid a double slash at the beginning of root-mounted datasets */
	if (*mntpt == '/' && (*mntpt + 1) == '\0')
	**mntpt = '\0';
	return (0);
	}

	static int
	get_mountpoints(differ_info_t *di)
	{
	char *strptr;
	char *frommntpt;

	/*
	* first get the mountpoint for the parent dataset
	*/
	if (get_mountpoint(di, di->ds, &di->dsmnt) != 0)
	return (-1);

	strptr = strchr(di->tosnap, '@');
	ASSERT3P(strptr, !=, NULL);
	di->tomnt = zfs_asprintf(di->zhp->zfs_hdl, "%s%s%s", di->dsmnt,
	ZDIFF_SNAPDIR, ++strptr);

	strptr = strchr(di->fromsnap, '@');
	ASSERT3P(strptr, !=, NULL);

	frommntpt = di->dsmnt;
	if (di->isclone) {
	char *mntpt;
	int err;

	*strptr = '\0';
	err = get_mountpoint(di, di->fromsnap, &mntpt);
	*strptr = '@';
	if (err != 0)
	return (-1);
	frommntpt = mntpt;
	}

	di->frommnt = zfs_asprintf(di->zhp->zfs_hdl, "%s%s%s", frommntpt,
	ZDIFF_SNAPDIR, ++strptr);

	if (di->isclone)
	free(frommntpt);

	return (0);
	}

	static int
	setup_differ_info(zfs_handle_t zhp, const char fromsnap,
	const char tosnap, differ_info_t di)
	{
	di->zhp = zhp;

	- di->cleanupfd = open(ZFS_DEV, O_RDWR);
	+ di->cleanupfd = open(ZFS_DEV, O_RDWR \| O_CLOEXEC);
	VERIFY(di->cleanupfd >= 0);

	if (get_snapshot_names(di, fromsnap, tosnap) != 0)
	return (-1);

	if (get_mountpoints(di) != 0)
	return (-1);

	if (find_shares_object(di) != 0)
	return (-1);

	return (0);
	}

	int
	zfs_show_diffs(zfs_handle_t zhp, int outfd, const char fromsnap,
	const char *tosnap, int flags)
	{
	zfs_cmd_t zc = {"\0"};
	char errbuf[1024];
	differ_info_t di = { 0 };
	pthread_t tid;
	int pipefd[2];
	int iocerr;

	(void) snprintf(errbuf, sizeof (errbuf),
	dgettext(TEXT_DOMAIN, "zfs diff failed"));

	if (setup_differ_info(zhp, fromsnap, tosnap, &di)) {
	teardown_differ_info(&di);
	return (-1);
	}

	- if (pipe(pipefd)) {
	+ if (pipe2(pipefd, O_CLOEXEC)) {
	zfs_error_aux(zhp->zfs_hdl, strerror(errno));
	teardown_differ_info(&di);
	return (zfs_error(zhp->zfs_hdl, EZFS_PIPEFAILED, errbuf));
	}

	di.scripted = (flags & ZFS_DIFF_PARSEABLE);
	di.classify = (flags & ZFS_DIFF_CLASSIFY);
	di.timestamped = (flags & ZFS_DIFF_TIMESTAMP);

	di.outputfd = outfd;
	di.datafd = pipefd[0];

	if (pthread_create(&tid, NULL, differ, &di)) {
	zfs_error_aux(zhp->zfs_hdl, strerror(errno));
	(void) close(pipefd[0]);
	(void) close(pipefd[1]);
	teardown_differ_info(&di);
	return (zfs_error(zhp->zfs_hdl,
	EZFS_THREADCREATEFAILED, errbuf));
	}

	/* do the ioctl() */
	(void) strlcpy(zc.zc_value, di.fromsnap, strlen(di.fromsnap) + 1);
	(void) strlcpy(zc.zc_name, di.tosnap, strlen(di.tosnap) + 1);
	zc.zc_cookie = pipefd[1];

	iocerr = zfs_ioctl(zhp->zfs_hdl, ZFS_IOC_DIFF, &zc);
	if (iocerr != 0) {
	(void) snprintf(errbuf, sizeof (errbuf),
	dgettext(TEXT_DOMAIN, "Unable to obtain diffs"));
	if (errno == EPERM) {
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"\n The sys_mount privilege or diff delegated "
	"permission is needed\n to execute the "
	"diff ioctl"));
	} else if (errno == EXDEV) {
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"\n Not an earlier snapshot from the same fs"));
	} else if (errno != EPIPE \|\| di.zerr == 0) {
	zfs_error_aux(zhp->zfs_hdl, strerror(errno));
	}
	(void) close(pipefd[1]);
	(void) pthread_cancel(tid);
	(void) pthread_join(tid, NULL);
	teardown_differ_info(&di);
	if (di.zerr != 0 && di.zerr != EPIPE) {
	zfs_error_aux(zhp->zfs_hdl, strerror(di.zerr));
	return (zfs_error(zhp->zfs_hdl, EZFS_DIFF, di.errbuf));
	} else {
	return (zfs_error(zhp->zfs_hdl, EZFS_DIFFDATA, errbuf));
	}
	}

	(void) close(pipefd[1]);
	(void) pthread_join(tid, NULL);

	if (di.zerr != 0) {
	zfs_error_aux(zhp->zfs_hdl, strerror(di.zerr));
	return (zfs_error(zhp->zfs_hdl, EZFS_DIFF, di.errbuf));
	}
	teardown_differ_info(&di);
	return (0);
	}
	diff --git a/sys/contrib/openzfs/lib/libzfs/libzfs_iter.c b/sys/contrib/openzfs/lib/libzfs/libzfs_iter.c
	index 7ee326bc6905..7806e21cd9a9 100644
	--- a/sys/contrib/openzfs/lib/libzfs/libzfs_iter.c
	+++ b/sys/contrib/openzfs/lib/libzfs/libzfs_iter.c
	@@ -1,600 +1,600 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2013, 2019 by Delphix. All rights reserved.
	* Copyright 2014 Nexenta Systems, Inc. All rights reserved.
	* Copyright (c) 2019 Datto Inc.
	*/

	#include <stdio.h>
	#include <stdlib.h>
	#include <strings.h>
	#include <unistd.h>
	#include <stddef.h>
	#include <libintl.h>
	#include <libzfs.h>
	#include <libzutil.h>
	#include <sys/mntent.h>

	#include "libzfs_impl.h"

	static int
	zfs_iter_clones(zfs_handle_t zhp, zfs_iter_f func, void data)
	{
	nvlist_t *nvl = zfs_get_clones_nvl(zhp);
	nvpair_t *pair;

	if (nvl == NULL)
	return (0);

	for (pair = nvlist_next_nvpair(nvl, NULL); pair != NULL;
	pair = nvlist_next_nvpair(nvl, pair)) {
	zfs_handle_t *clone = zfs_open(zhp->zfs_hdl, nvpair_name(pair),
	ZFS_TYPE_FILESYSTEM \| ZFS_TYPE_VOLUME);
	if (clone != NULL) {
	int err = func(clone, data);
	if (err != 0)
	return (err);
	}
	}
	return (0);
	}

	static int
	zfs_do_list_ioctl(zfs_handle_t zhp, int arg, zfs_cmd_t zc)
	{
	int rc;
	uint64_t orig_cookie;

	orig_cookie = zc->zc_cookie;
	top:
	(void) strlcpy(zc->zc_name, zhp->zfs_name, sizeof (zc->zc_name));
	rc = zfs_ioctl(zhp->zfs_hdl, arg, zc);

	if (rc == -1) {
	switch (errno) {
	case ENOMEM:
	/* expand nvlist memory and try again */
	if (zcmd_expand_dst_nvlist(zhp->zfs_hdl, zc) != 0) {
	zcmd_free_nvlists(zc);
	return (-1);
	}
	zc->zc_cookie = orig_cookie;
	goto top;
	/*
	* An errno value of ESRCH indicates normal completion.
	* If ENOENT is returned, then the underlying dataset
	* has been removed since we obtained the handle.
	*/
	case ESRCH:
	case ENOENT:
	rc = 1;
	break;
	default:
	rc = zfs_standard_error(zhp->zfs_hdl, errno,
	dgettext(TEXT_DOMAIN,
	"cannot iterate filesystems"));
	break;
	}
	}
	return (rc);
	}

	/*
	* Iterate over all child filesystems
	*/
	int
	zfs_iter_filesystems(zfs_handle_t zhp, zfs_iter_f func, void data)
	{
	zfs_cmd_t zc = {"\0"};
	zfs_handle_t *nzhp;
	int ret;

	if (zhp->zfs_type != ZFS_TYPE_FILESYSTEM)
	return (0);

	if (zcmd_alloc_dst_nvlist(zhp->zfs_hdl, &zc, 0) != 0)
	return (-1);

	while ((ret = zfs_do_list_ioctl(zhp, ZFS_IOC_DATASET_LIST_NEXT,
	&zc)) == 0) {
	/*
	* Silently ignore errors, as the only plausible explanation is
	* that the pool has since been removed.
	*/
	if ((nzhp = make_dataset_handle_zc(zhp->zfs_hdl,
	&zc)) == NULL) {
	continue;
	}

	if ((ret = func(nzhp, data)) != 0) {
	zcmd_free_nvlists(&zc);
	return (ret);
	}
	}
	zcmd_free_nvlists(&zc);
	return ((ret < 0) ? ret : 0);
	}

	/*
	* Iterate over all snapshots
	*/
	int
	zfs_iter_snapshots(zfs_handle_t *zhp, boolean_t simple, zfs_iter_f func,
	void *data, uint64_t min_txg, uint64_t max_txg)
	{
	zfs_cmd_t zc = {"\0"};
	zfs_handle_t *nzhp;
	int ret;
	nvlist_t *range_nvl = NULL;

	if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT \|\|
	zhp->zfs_type == ZFS_TYPE_BOOKMARK)
	return (0);

	zc.zc_simple = simple;

	if (zcmd_alloc_dst_nvlist(zhp->zfs_hdl, &zc, 0) != 0)
	return (-1);

	if (min_txg != 0) {
	range_nvl = fnvlist_alloc();
	fnvlist_add_uint64(range_nvl, SNAP_ITER_MIN_TXG, min_txg);
	}
	if (max_txg != 0) {
	if (range_nvl == NULL)
	range_nvl = fnvlist_alloc();
	fnvlist_add_uint64(range_nvl, SNAP_ITER_MAX_TXG, max_txg);
	}

	if (range_nvl != NULL &&
	zcmd_write_src_nvlist(zhp->zfs_hdl, &zc, range_nvl) != 0) {
	zcmd_free_nvlists(&zc);
	fnvlist_free(range_nvl);
	return (-1);
	}

	while ((ret = zfs_do_list_ioctl(zhp, ZFS_IOC_SNAPSHOT_LIST_NEXT,
	&zc)) == 0) {

	if (simple)
	nzhp = make_dataset_simple_handle_zc(zhp, &zc);
	else
	nzhp = make_dataset_handle_zc(zhp->zfs_hdl, &zc);
	if (nzhp == NULL)
	continue;

	if ((ret = func(nzhp, data)) != 0) {
	zcmd_free_nvlists(&zc);
	fnvlist_free(range_nvl);
	return (ret);
	}
	}
	zcmd_free_nvlists(&zc);
	fnvlist_free(range_nvl);
	return ((ret < 0) ? ret : 0);
	}

	/*
	* Iterate over all bookmarks
	*/
	int
	zfs_iter_bookmarks(zfs_handle_t zhp, zfs_iter_f func, void data)
	{
	zfs_handle_t *nzhp;
	nvlist_t *props = NULL;
	nvlist_t *bmarks = NULL;
	int err;
	nvpair_t *pair;

	if ((zfs_get_type(zhp) & (ZFS_TYPE_SNAPSHOT \| ZFS_TYPE_BOOKMARK)) != 0)
	return (0);

	/* Setup the requested properties nvlist. */
	props = fnvlist_alloc();
	for (zfs_prop_t p = 0; p < ZFS_NUM_PROPS; p++) {
	if (zfs_prop_valid_for_type(p, ZFS_TYPE_BOOKMARK, B_FALSE)) {
	fnvlist_add_boolean(props, zfs_prop_to_name(p));
	}
	}
	fnvlist_add_boolean(props, "redact_complete");

	if ((err = lzc_get_bookmarks(zhp->zfs_name, props, &bmarks)) != 0)
	goto out;

	for (pair = nvlist_next_nvpair(bmarks, NULL);
	pair != NULL; pair = nvlist_next_nvpair(bmarks, pair)) {
	char name[ZFS_MAX_DATASET_NAME_LEN];
	char *bmark_name;
	nvlist_t *bmark_props;

	bmark_name = nvpair_name(pair);
	bmark_props = fnvpair_value_nvlist(pair);

	if (snprintf(name, sizeof (name), "%s#%s", zhp->zfs_name,
	bmark_name) >= sizeof (name)) {
	err = EINVAL;
	goto out;
	}

	nzhp = make_bookmark_handle(zhp, name, bmark_props);
	if (nzhp == NULL)
	continue;

	if ((err = func(nzhp, data)) != 0)
	goto out;
	}

	out:
	fnvlist_free(props);
	fnvlist_free(bmarks);

	return (err);
	}

	/*
	* Routines for dealing with the sorted snapshot functionality
	*/
	typedef struct zfs_node {
	zfs_handle_t *zn_handle;
	avl_node_t zn_avlnode;
	} zfs_node_t;

	static int
	zfs_sort_snaps(zfs_handle_t zhp, void data)
	{
	avl_tree_t *avl = data;
	zfs_node_t *node;
	zfs_node_t search;

	search.zn_handle = zhp;
	node = avl_find(avl, &search, NULL);
	if (node) {
	/*
	* If this snapshot was renamed while we were creating the
	* AVL tree, it's possible that we already inserted it under
	* its old name. Remove the old handle before adding the new
	* one.
	*/
	zfs_close(node->zn_handle);
	avl_remove(avl, node);
	free(node);
	}

	node = zfs_alloc(zhp->zfs_hdl, sizeof (zfs_node_t));
	node->zn_handle = zhp;
	avl_add(avl, node);

	return (0);
	}

	static int
	zfs_snapshot_compare(const void larg, const void rarg)
	{
	zfs_handle_t l = ((zfs_node_t )larg)->zn_handle;
	zfs_handle_t r = ((zfs_node_t )rarg)->zn_handle;
	uint64_t lcreate, rcreate;

	/*
	* Sort them according to creation time. We use the hidden
	* CREATETXG property to get an absolute ordering of snapshots.
	*/
	lcreate = zfs_prop_get_int(l, ZFS_PROP_CREATETXG);
	rcreate = zfs_prop_get_int(r, ZFS_PROP_CREATETXG);

	return (TREE_CMP(lcreate, rcreate));
	}

	int
	zfs_iter_snapshots_sorted(zfs_handle_t zhp, zfs_iter_f callback, void data,
	uint64_t min_txg, uint64_t max_txg)
	{
	int ret = 0;
	zfs_node_t *node;
	avl_tree_t avl;
	void *cookie = NULL;

	avl_create(&avl, zfs_snapshot_compare,
	sizeof (zfs_node_t), offsetof(zfs_node_t, zn_avlnode));

	ret = zfs_iter_snapshots(zhp, B_FALSE, zfs_sort_snaps, &avl, min_txg,
	max_txg);

	for (node = avl_first(&avl); node != NULL; node = AVL_NEXT(&avl, node))
	ret \|= callback(node->zn_handle, data);

	while ((node = avl_destroy_nodes(&avl, &cookie)) != NULL)
	free(node);

	avl_destroy(&avl);

	return (ret);
	}

	typedef struct {
	char *ssa_first;
	char *ssa_last;
	boolean_t ssa_seenfirst;
	boolean_t ssa_seenlast;
	zfs_iter_f ssa_func;
	void *ssa_arg;
	} snapspec_arg_t;

	static int
	snapspec_cb(zfs_handle_t zhp, void arg)
	{
	snapspec_arg_t *ssa = arg;
	const char *shortsnapname;
	int err = 0;

	if (ssa->ssa_seenlast)
	return (0);

	shortsnapname = strchr(zfs_get_name(zhp), '@') + 1;
	if (!ssa->ssa_seenfirst && strcmp(shortsnapname, ssa->ssa_first) == 0)
	ssa->ssa_seenfirst = B_TRUE;
	if (strcmp(shortsnapname, ssa->ssa_last) == 0)
	ssa->ssa_seenlast = B_TRUE;

	if (ssa->ssa_seenfirst) {
	err = ssa->ssa_func(zhp, ssa->ssa_arg);
	} else {
	zfs_close(zhp);
	}

	return (err);
	}

	/*
	* spec is a string like "A,B%C,D"
	*
	* <snaps>, where <snaps> can be:
	* <snap> (single snapshot)
	* <snap>%<snap> (range of snapshots, inclusive)
	* %<snap> (range of snapshots, starting with earliest)
	* <snap>% (range of snapshots, ending with last)
	* % (all snapshots)
	* <snaps>[,...] (comma separated list of the above)
	*
	* If a snapshot can not be opened, continue trying to open the others, but
	* return ENOENT at the end.
	*/
	int
	zfs_iter_snapspec(zfs_handle_t fs_zhp, const char spec_orig,
	zfs_iter_f func, void *arg)
	{
	char buf, comma_separated, *cp;
	int err = 0;
	int ret = 0;

	buf = zfs_strdup(fs_zhp->zfs_hdl, spec_orig);
	cp = buf;

	while ((comma_separated = strsep(&cp, ",")) != NULL) {
	char *pct = strchr(comma_separated, '%');
	if (pct != NULL) {
	snapspec_arg_t ssa = { 0 };
	ssa.ssa_func = func;
	ssa.ssa_arg = arg;

	if (pct == comma_separated)
	ssa.ssa_seenfirst = B_TRUE;
	else
	ssa.ssa_first = comma_separated;
	*pct = '\0';
	ssa.ssa_last = pct + 1;

	/*
	* If there is a lastname specified, make sure it
	* exists.
	*/
	if (ssa.ssa_last[0] != '\0') {
	char snapname[ZFS_MAX_DATASET_NAME_LEN];
	(void) snprintf(snapname, sizeof (snapname),
	"%s@%s", zfs_get_name(fs_zhp),
	ssa.ssa_last);
	if (!zfs_dataset_exists(fs_zhp->zfs_hdl,
	snapname, ZFS_TYPE_SNAPSHOT)) {
	ret = ENOENT;
	continue;
	}
	}

	err = zfs_iter_snapshots_sorted(fs_zhp,
	snapspec_cb, &ssa, 0, 0);
	if (ret == 0)
	ret = err;
	if (ret == 0 && (!ssa.ssa_seenfirst \|\|
	(ssa.ssa_last[0] != '\0' && !ssa.ssa_seenlast))) {
	ret = ENOENT;
	}
	} else {
	char snapname[ZFS_MAX_DATASET_NAME_LEN];
	zfs_handle_t *snap_zhp;
	(void) snprintf(snapname, sizeof (snapname), "%s@%s",
	zfs_get_name(fs_zhp), comma_separated);
	snap_zhp = make_dataset_handle(fs_zhp->zfs_hdl,
	snapname);
	if (snap_zhp == NULL) {
	ret = ENOENT;
	continue;
	}
	err = func(snap_zhp, arg);
	if (ret == 0)
	ret = err;
	}
	}

	free(buf);
	return (ret);
	}

	/*
	* Iterate over all children, snapshots and filesystems
	* Process snapshots before filesystems because they are nearer the input
	* handle: this is extremely important when used with zfs_iter_f functions
	* looking for data, following the logic that we would like to find it as soon
	* and as close as possible.
	*/
	int
	zfs_iter_children(zfs_handle_t zhp, zfs_iter_f func, void data)
	{
	int ret;

	if ((ret = zfs_iter_snapshots(zhp, B_FALSE, func, data, 0, 0)) != 0)
	return (ret);

	return (zfs_iter_filesystems(zhp, func, data));
	}


	typedef struct iter_stack_frame {
	struct iter_stack_frame *next;
	zfs_handle_t *zhp;
	} iter_stack_frame_t;

	typedef struct iter_dependents_arg {
	boolean_t first;
	boolean_t allowrecursion;
	iter_stack_frame_t *stack;
	zfs_iter_f func;
	void *data;
	} iter_dependents_arg_t;

	static int
	iter_dependents_cb(zfs_handle_t zhp, void arg)
	{
	iter_dependents_arg_t *ida = arg;
	int err = 0;
	boolean_t first = ida->first;
	ida->first = B_FALSE;

	if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT) {
	err = zfs_iter_clones(zhp, iter_dependents_cb, ida);
	} else if (zhp->zfs_type != ZFS_TYPE_BOOKMARK) {
	iter_stack_frame_t isf;
	iter_stack_frame_t *f;

	/*
	* check if there is a cycle by seeing if this fs is already
	* on the stack.
	*/
	for (f = ida->stack; f != NULL; f = f->next) {
	if (f->zhp->zfs_dmustats.dds_guid ==
	zhp->zfs_dmustats.dds_guid) {
	if (ida->allowrecursion) {
	zfs_close(zhp);
	return (0);
	} else {
	zfs_error_aux(zhp->zfs_hdl,
	dgettext(TEXT_DOMAIN,
	"recursive dependency at '%s'"),
	zfs_get_name(zhp));
	err = zfs_error(zhp->zfs_hdl,
	EZFS_RECURSIVE,
	dgettext(TEXT_DOMAIN,
	"cannot determine dependent "
	"datasets"));
	zfs_close(zhp);
	return (err);
	}
	}
	}

	isf.zhp = zhp;
	isf.next = ida->stack;
	ida->stack = &isf;
	err = zfs_iter_filesystems(zhp, iter_dependents_cb, ida);
	if (err == 0)
	err = zfs_iter_snapshots(zhp, B_FALSE,
	iter_dependents_cb, ida, 0, 0);
	ida->stack = isf.next;
	}

	if (!first && err == 0)
	err = ida->func(zhp, ida->data);
	else
	zfs_close(zhp);

	return (err);
	}

	int
	zfs_iter_dependents(zfs_handle_t *zhp, boolean_t allowrecursion,
	zfs_iter_f func, void *data)
	{
	iter_dependents_arg_t ida;
	ida.allowrecursion = allowrecursion;
	ida.stack = NULL;
	ida.func = func;
	ida.data = data;
	ida.first = B_TRUE;
	return (iter_dependents_cb(zfs_handle_dup(zhp), &ida));
	}

	/*
	* Iterate over mounted children of the specified dataset
	*/
	int
	zfs_iter_mounted(zfs_handle_t zhp, zfs_iter_f func, void data)
	{
	char mnt_prop[ZFS_MAXPROPLEN];
	struct mnttab entry;
	zfs_handle_t *mtab_zhp;
	size_t namelen = strlen(zhp->zfs_name);
	FILE *mnttab;
	int err = 0;

	- if ((mnttab = fopen(MNTTAB, "r")) == NULL)
	+ if ((mnttab = fopen(MNTTAB, "re")) == NULL)
	return (ENOENT);

	while (err == 0 && getmntent(mnttab, &entry) == 0) {
	/* Ignore non-ZFS entries */
	if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0)
	continue;

	/* Ignore datasets not within the provided dataset */
	if (strncmp(entry.mnt_special, zhp->zfs_name, namelen) != 0 \|\|
	(entry.mnt_special[namelen] != '/' &&
	entry.mnt_special[namelen] != '@'))
	continue;

	if ((mtab_zhp = zfs_open(zhp->zfs_hdl, entry.mnt_special,
	ZFS_TYPE_FILESYSTEM)) == NULL)
	continue;

	/* Ignore legacy mounts as they are user managed */
	verify(zfs_prop_get(mtab_zhp, ZFS_PROP_MOUNTPOINT, mnt_prop,
	sizeof (mnt_prop), NULL, NULL, 0, B_FALSE) == 0);
	if (strcmp(mnt_prop, "legacy") == 0) {
	zfs_close(mtab_zhp);
	continue;
	}

	err = func(mtab_zhp, data);
	}

	fclose(mnttab);

	return (err);
	}
	diff --git a/sys/contrib/openzfs/lib/libzfs/libzfs_mount.c b/sys/contrib/openzfs/lib/libzfs/libzfs_mount.c
	index 2a543daac9ae..d3f7e6106c6b 100644
	--- a/sys/contrib/openzfs/lib/libzfs/libzfs_mount.c
	+++ b/sys/contrib/openzfs/lib/libzfs/libzfs_mount.c
	@@ -1,1635 +1,1658 @@
	/*
	* 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 2015 Nexenta Systems, Inc. All rights reserved.
	* Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2014, 2021 by Delphix. All rights reserved.
	* Copyright 2016 Igor Kozhukhov <ikozhukhov@gmail.com>
	* Copyright 2017 RackTop Systems.
	* Copyright (c) 2018 Datto Inc.
	* Copyright 2018 OmniOS Community Edition (OmniOSce) Association.
	*/

	/*
	* Routines to manage ZFS mounts. We separate all the nasty routines that have
	* to deal with the OS. The following functions are the main entry points --
	* they are used by mount and unmount and when changing a filesystem's
	* mountpoint.
	*
	* zfs_is_mounted()
	* zfs_mount()
	* zfs_mount_at()
	* zfs_unmount()
	* zfs_unmountall()
	*
	* This file also contains the functions used to manage sharing filesystems via
	* NFS and iSCSI:
	*
	* zfs_is_shared()
	* zfs_share()
	* zfs_unshare()
	*
	* zfs_is_shared_nfs()
	* zfs_is_shared_smb()
	* zfs_share_proto()
	* zfs_shareall();
	* zfs_unshare_nfs()
	* zfs_unshare_smb()
	* zfs_unshareall_nfs()
	* zfs_unshareall_smb()
	* zfs_unshareall()
	* zfs_unshareall_bypath()
	*
	* The following functions are available for pool consumers, and will
	* mount/unmount and share/unshare all datasets within pool:
	*
	* zpool_enable_datasets()
	* zpool_disable_datasets()
	*/

	#include <dirent.h>
	#include <dlfcn.h>
	#include <errno.h>
	#include <fcntl.h>
	#include <libgen.h>
	#include <libintl.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <strings.h>
	#include <unistd.h>
	#include <zone.h>
	#include <sys/mntent.h>
	#include <sys/mount.h>
	#include <sys/stat.h>
	#include <sys/vfs.h>
	#include <sys/dsl_crypt.h>

	#include <libzfs.h>

	#include "libzfs_impl.h"
	#include <thread_pool.h>

	#include <libshare.h>
	#include <sys/systeminfo.h>
	#define MAXISALEN 257 /* based on sysinfo(2) man page */

	static int mount_tp_nthr = 512; /* tpool threads for multi-threaded mounting */

	static void zfs_mount_task(void *);
	zfs_share_type_t zfs_is_shared_proto(zfs_handle_t , char *,
	zfs_share_proto_t);

	/*
	* The share protocols table must be in the same order as the zfs_share_proto_t
	* enum in libzfs_impl.h
	*/
	proto_table_t proto_table[PROTO_END] = {
	{ZFS_PROP_SHARENFS, "nfs", EZFS_SHARENFSFAILED, EZFS_UNSHARENFSFAILED},
	{ZFS_PROP_SHARESMB, "smb", EZFS_SHARESMBFAILED, EZFS_UNSHARESMBFAILED},
	};

	zfs_share_proto_t nfs_only[] = {
	PROTO_NFS,
	PROTO_END
	};

	zfs_share_proto_t smb_only[] = {
	PROTO_SMB,
	PROTO_END
	};
	zfs_share_proto_t share_all_proto[] = {
	PROTO_NFS,
	PROTO_SMB,
	PROTO_END
	};



	static boolean_t
	dir_is_empty_stat(const char *dirname)
	{
	struct stat st;

	/*
	* We only want to return false if the given path is a non empty
	* directory, all other errors are handled elsewhere.
	*/
	if (stat(dirname, &st) < 0 \|\| !S_ISDIR(st.st_mode)) {
	return (B_TRUE);
	}

	/*
	* An empty directory will still have two entries in it, one
	* entry for each of "." and "..".
	*/
	if (st.st_size > 2) {
	return (B_FALSE);
	}

	return (B_TRUE);
	}

	static boolean_t
	dir_is_empty_readdir(const char *dirname)
	{
	DIR *dirp;
	struct dirent64 *dp;
	int dirfd;

	if ((dirfd = openat(AT_FDCWD, dirname,
	O_RDONLY \| O_NDELAY \| O_LARGEFILE \| O_CLOEXEC, 0)) < 0) {
	return (B_TRUE);
	}

	if ((dirp = fdopendir(dirfd)) == NULL) {
	(void) close(dirfd);
	return (B_TRUE);
	}

	while ((dp = readdir64(dirp)) != NULL) {

	if (strcmp(dp->d_name, ".") == 0 \|\|
	strcmp(dp->d_name, "..") == 0)
	continue;

	(void) closedir(dirp);
	return (B_FALSE);
	}

	(void) closedir(dirp);
	return (B_TRUE);
	}

	/*
	* Returns true if the specified directory is empty. If we can't open the
	* directory at all, return true so that the mount can fail with a more
	* informative error message.
	*/
	static boolean_t
	dir_is_empty(const char *dirname)
	{
	struct statfs64 st;

	/*
	* If the statvfs call fails or the filesystem is not a ZFS
	* filesystem, fall back to the slow path which uses readdir.
	*/
	if ((statfs64(dirname, &st) != 0) \|\|
	(st.f_type != ZFS_SUPER_MAGIC)) {
	return (dir_is_empty_readdir(dirname));
	}

	/*
	* At this point, we know the provided path is on a ZFS
	* filesystem, so we can use stat instead of readdir to
	* determine if the directory is empty or not. We try to avoid
	* using readdir because that requires opening "dirname"; this
	* open file descriptor can potentially end up in a child
	* process if there's a concurrent fork, thus preventing the
	* zfs_mount() from otherwise succeeding (the open file
	* descriptor inherited by the child process will cause the
	* parent's mount to fail with EBUSY). The performance
	* implications of replacing the open, read, and close with a
	* single stat is nice; but is not the main motivation for the
	* added complexity.
	*/
	return (dir_is_empty_stat(dirname));
	}

	/*
	* Checks to see if the mount is active. If the filesystem is mounted, we fill
	* in 'where' with the current mountpoint, and return 1. Otherwise, we return
	* 0.
	*/
	boolean_t
	is_mounted(libzfs_handle_t zfs_hdl, const char special, char **where)
	{
	struct mnttab entry;

	if (libzfs_mnttab_find(zfs_hdl, special, &entry) != 0)
	return (B_FALSE);

	if (where != NULL)
	*where = zfs_strdup(zfs_hdl, entry.mnt_mountp);

	return (B_TRUE);
	}

	boolean_t
	zfs_is_mounted(zfs_handle_t zhp, char *where)
	{
	return (is_mounted(zhp->zfs_hdl, zfs_get_name(zhp), where));
	}

	/*
	* Checks any higher order concerns about whether the given dataset is
	* mountable, false otherwise. zfs_is_mountable_internal specifically assumes
	* that the caller has verified the sanity of mounting the dataset at
	* mountpoint to the extent the caller wants.
	*/
	static boolean_t
	zfs_is_mountable_internal(zfs_handle_t zhp, const char mountpoint)
	{

	if (zfs_prop_get_int(zhp, ZFS_PROP_ZONED) &&
	getzoneid() == GLOBAL_ZONEID)
	return (B_FALSE);

	return (B_TRUE);
	}

	/*
	* Returns true if the given dataset is mountable, false otherwise. Returns the
	* mountpoint in 'buf'.
	*/
	boolean_t
	zfs_is_mountable(zfs_handle_t zhp, char buf, size_t buflen,
	zprop_source_t *source, int flags)
	{
	char sourceloc[MAXNAMELEN];
	zprop_source_t sourcetype;

	if (!zfs_prop_valid_for_type(ZFS_PROP_MOUNTPOINT, zhp->zfs_type,
	B_FALSE))
	return (B_FALSE);

	verify(zfs_prop_get(zhp, ZFS_PROP_MOUNTPOINT, buf, buflen,
	&sourcetype, sourceloc, sizeof (sourceloc), B_FALSE) == 0);

	if (strcmp(buf, ZFS_MOUNTPOINT_NONE) == 0 \|\|
	strcmp(buf, ZFS_MOUNTPOINT_LEGACY) == 0)
	return (B_FALSE);

	if (zfs_prop_get_int(zhp, ZFS_PROP_CANMOUNT) == ZFS_CANMOUNT_OFF)
	return (B_FALSE);

	if (!zfs_is_mountable_internal(zhp, buf))
	return (B_FALSE);

	if (zfs_prop_get_int(zhp, ZFS_PROP_REDACTED) && !(flags & MS_FORCE))
	return (B_FALSE);

	if (source)
	*source = sourcetype;

	return (B_TRUE);
	}

	/*
	* The filesystem is mounted by invoking the system mount utility rather
	* than by the system call mount(2). This ensures that the /etc/mtab
	* file is correctly locked for the update. Performing our own locking
	* and /etc/mtab update requires making an unsafe assumption about how
	* the mount utility performs its locking. Unfortunately, this also means
	* in the case of a mount failure we do not have the exact errno. We must
	* make due with return value from the mount process.
	*
	* In the long term a shared library called libmount is under development
	* which provides a common API to address the locking and errno issues.
	* Once the standard mount utility has been updated to use this library
	* we can add an autoconf check to conditionally use it.
	*
	* http://www.kernel.org/pub/linux/utils/util-linux/libmount-docs/index.html
	*/

	static int
	zfs_add_option(zfs_handle_t zhp, char options, int len,
	zfs_prop_t prop, char on, char off)
	{
	char *source;
	uint64_t value;

	/* Skip adding duplicate default options */
	if ((strstr(options, on) != NULL) \|\| (strstr(options, off) != NULL))
	return (0);

	/*
	* zfs_prop_get_int() is not used to ensure our mount options
	* are not influenced by the current /proc/self/mounts contents.
	*/
	value = getprop_uint64(zhp, prop, &source);

	(void) strlcat(options, ",", len);
	(void) strlcat(options, value ? on : off, len);

	return (0);
	}

	static int
	zfs_add_options(zfs_handle_t zhp, char options, int len)
	{
	int error = 0;

	error = zfs_add_option(zhp, options, len,
	ZFS_PROP_ATIME, MNTOPT_ATIME, MNTOPT_NOATIME);
	/*
	* don't add relatime/strictatime when atime=off, otherwise strictatime
	* will force atime=on
	*/
	if (strstr(options, MNTOPT_NOATIME) == NULL) {
	error = zfs_add_option(zhp, options, len,
	ZFS_PROP_RELATIME, MNTOPT_RELATIME, MNTOPT_STRICTATIME);
	}
	error = error ? error : zfs_add_option(zhp, options, len,
	ZFS_PROP_DEVICES, MNTOPT_DEVICES, MNTOPT_NODEVICES);
	error = error ? error : zfs_add_option(zhp, options, len,
	ZFS_PROP_EXEC, MNTOPT_EXEC, MNTOPT_NOEXEC);
	error = error ? error : zfs_add_option(zhp, options, len,
	ZFS_PROP_READONLY, MNTOPT_RO, MNTOPT_RW);
	error = error ? error : zfs_add_option(zhp, options, len,
	ZFS_PROP_SETUID, MNTOPT_SETUID, MNTOPT_NOSETUID);
	error = error ? error : zfs_add_option(zhp, options, len,
	ZFS_PROP_NBMAND, MNTOPT_NBMAND, MNTOPT_NONBMAND);

	return (error);
	}

	int
	zfs_mount(zfs_handle_t zhp, const char options, int flags)
	{
	char mountpoint[ZFS_MAXPROPLEN];

	if (!zfs_is_mountable(zhp, mountpoint, sizeof (mountpoint), NULL,
	flags))
	return (0);

	return (zfs_mount_at(zhp, options, flags, mountpoint));
	}

	/*
	* Mount the given filesystem.
	*/
	int
	zfs_mount_at(zfs_handle_t zhp, const char options, int flags,
	const char *mountpoint)
	{
	struct stat buf;
	char mntopts[MNT_LINE_MAX];
	char overlay[ZFS_MAXPROPLEN];
	+ char prop_encroot[MAXNAMELEN];
	+ boolean_t is_encroot;
	+ zfs_handle_t *encroot_hp = zhp;
	libzfs_handle_t *hdl = zhp->zfs_hdl;
	uint64_t keystatus;
	int remount = 0, rc;

	if (options == NULL) {
	(void) strlcpy(mntopts, MNTOPT_DEFAULTS, sizeof (mntopts));
	} else {
	(void) strlcpy(mntopts, options, sizeof (mntopts));
	}

	if (strstr(mntopts, MNTOPT_REMOUNT) != NULL)
	remount = 1;

	/* Potentially duplicates some checks if invoked by zfs_mount(). */
	if (!zfs_is_mountable_internal(zhp, mountpoint))
	return (0);

	/*
	* If the pool is imported read-only then all mounts must be read-only
	*/
	if (zpool_get_prop_int(zhp->zpool_hdl, ZPOOL_PROP_READONLY, NULL))
	(void) strlcat(mntopts, "," MNTOPT_RO, sizeof (mntopts));

	/*
	* Append default mount options which apply to the mount point.
	* This is done because under Linux (unlike Solaris) multiple mount
	* points may reference a single super block. This means that just
	* given a super block there is no back reference to update the per
	* mount point options.
	*/
	rc = zfs_add_options(zhp, mntopts, sizeof (mntopts));
	if (rc) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"default options unavailable"));
	return (zfs_error_fmt(hdl, EZFS_MOUNTFAILED,
	dgettext(TEXT_DOMAIN, "cannot mount '%s'"),
	mountpoint));
	}

	/*
	* If the filesystem is encrypted the key must be loaded in order to
	* mount. If the key isn't loaded, the MS_CRYPT flag decides whether
	* or not we attempt to load the keys. Note: we must call
	* zfs_refresh_properties() here since some callers of this function
	* (most notably zpool_enable_datasets()) may implicitly load our key
	* by loading the parent's key first.
	*/
	if (zfs_prop_get_int(zhp, ZFS_PROP_ENCRYPTION) != ZIO_CRYPT_OFF) {
	zfs_refresh_properties(zhp);
	keystatus = zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS);

	/*
	* If the key is unavailable and MS_CRYPT is set give the
	* user a chance to enter the key. Otherwise just fail
	* immediately.
	*/
	if (keystatus == ZFS_KEYSTATUS_UNAVAILABLE) {
	if (flags & MS_CRYPT) {
	- rc = zfs_crypto_load_key(zhp, B_FALSE, NULL);
	+ rc = zfs_crypto_get_encryption_root(zhp,
	+ &is_encroot, prop_encroot);
	+ if (rc) {
	+ zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	+ "Failed to get encryption root for "
	+ "'%s'."), zfs_get_name(zhp));
	+ return (rc);
	+ }
	+
	+ if (!is_encroot) {
	+ encroot_hp = zfs_open(hdl, prop_encroot,
	+ ZFS_TYPE_DATASET);
	+ if (encroot_hp == NULL)
	+ return (hdl->libzfs_error);
	+ }
	+
	+ rc = zfs_crypto_load_key(encroot_hp,
	+ B_FALSE, NULL);
	+
	+ if (!is_encroot)
	+ zfs_close(encroot_hp);
	if (rc)
	return (rc);
	} else {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"encryption key not loaded"));
	return (zfs_error_fmt(hdl, EZFS_MOUNTFAILED,
	dgettext(TEXT_DOMAIN, "cannot mount '%s'"),
	mountpoint));
	}
	}

	}

	/*
	* Append zfsutil option so the mount helper allow the mount
	*/
	strlcat(mntopts, "," MNTOPT_ZFSUTIL, sizeof (mntopts));

	/* Create the directory if it doesn't already exist */
	if (lstat(mountpoint, &buf) != 0) {
	if (mkdirp(mountpoint, 0755) != 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"failed to create mountpoint: %s"),
	strerror(errno));
	return (zfs_error_fmt(hdl, EZFS_MOUNTFAILED,
	dgettext(TEXT_DOMAIN, "cannot mount '%s'"),
	mountpoint));
	}
	}

	/*
	* Overlay mounts are enabled by default but may be disabled
	* via the 'overlay' property. The -O flag remains for compatibility.
	*/
	if (!(flags & MS_OVERLAY)) {
	if (zfs_prop_get(zhp, ZFS_PROP_OVERLAY, overlay,
	sizeof (overlay), NULL, NULL, 0, B_FALSE) == 0) {
	if (strcmp(overlay, "on") == 0) {
	flags \|= MS_OVERLAY;
	}
	}
	}

	/*
	* Determine if the mountpoint is empty. If so, refuse to perform the
	* mount. We don't perform this check if 'remount' is
	* specified or if overlay option (-O) is given
	*/
	if ((flags & MS_OVERLAY) == 0 && !remount &&
	!dir_is_empty(mountpoint)) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"directory is not empty"));
	return (zfs_error_fmt(hdl, EZFS_MOUNTFAILED,
	dgettext(TEXT_DOMAIN, "cannot mount '%s'"), mountpoint));
	}

	/* perform the mount */
	rc = do_mount(zhp, mountpoint, mntopts, flags);
	if (rc) {
	/*
	* Generic errors are nasty, but there are just way too many
	* from mount(), and they're well-understood. We pick a few
	* common ones to improve upon.
	*/
	if (rc == EBUSY) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"mountpoint or dataset is busy"));
	} else if (rc == EPERM) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"Insufficient privileges"));
	} else if (rc == ENOTSUP) {
	char buf[256];
	int spa_version;

	VERIFY(zfs_spa_version(zhp, &spa_version) == 0);
	(void) snprintf(buf, sizeof (buf),
	dgettext(TEXT_DOMAIN, "Can't mount a version %lld "
	"file system on a version %d pool. Pool must be"
	" upgraded to mount this file system."),
	(u_longlong_t)zfs_prop_get_int(zhp,
	ZFS_PROP_VERSION), spa_version);
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, buf));
	} else {
	zfs_error_aux(hdl, strerror(rc));
	}
	return (zfs_error_fmt(hdl, EZFS_MOUNTFAILED,
	dgettext(TEXT_DOMAIN, "cannot mount '%s'"),
	zhp->zfs_name));
	}

	/* remove the mounted entry before re-adding on remount */
	if (remount)
	libzfs_mnttab_remove(hdl, zhp->zfs_name);

	/* add the mounted entry into our cache */
	libzfs_mnttab_add(hdl, zfs_get_name(zhp), mountpoint, mntopts);
	return (0);
	}

	/*
	* Unmount a single filesystem.
	*/
	static int
	unmount_one(libzfs_handle_t hdl, const char mountpoint, int flags)
	{
	int error;

	error = do_unmount(mountpoint, flags);
	if (error != 0) {
	int libzfs_err;

	switch (error) {
	case EBUSY:
	libzfs_err = EZFS_BUSY;
	break;
	case EIO:
	libzfs_err = EZFS_IO;
	break;
	case ENOENT:
	libzfs_err = EZFS_NOENT;
	break;
	case ENOMEM:
	libzfs_err = EZFS_NOMEM;
	break;
	case EPERM:
	libzfs_err = EZFS_PERM;
	break;
	default:
	libzfs_err = EZFS_UMOUNTFAILED;
	}
	return (zfs_error_fmt(hdl, libzfs_err,
	dgettext(TEXT_DOMAIN, "cannot unmount '%s'"),
	mountpoint));
	}

	return (0);
	}

	/*
	* Unmount the given filesystem.
	*/
	int
	zfs_unmount(zfs_handle_t zhp, const char mountpoint, int flags)
	{
	libzfs_handle_t *hdl = zhp->zfs_hdl;
	struct mnttab entry;
	char *mntpt = NULL;
	boolean_t encroot, unmounted = B_FALSE;

	/* check to see if we need to unmount the filesystem */
	if (mountpoint != NULL \|\| ((zfs_get_type(zhp) == ZFS_TYPE_FILESYSTEM) &&
	libzfs_mnttab_find(hdl, zhp->zfs_name, &entry) == 0)) {
	/*
	* mountpoint may have come from a call to
	* getmnt/getmntany if it isn't NULL. If it is NULL,
	* we know it comes from libzfs_mnttab_find which can
	* then get freed later. We strdup it to play it safe.
	*/
	if (mountpoint == NULL)
	mntpt = zfs_strdup(hdl, entry.mnt_mountp);
	else
	mntpt = zfs_strdup(hdl, mountpoint);

	/*
	* Unshare and unmount the filesystem
	*/
	if (zfs_unshare_proto(zhp, mntpt, share_all_proto) != 0) {
	free(mntpt);
	return (-1);
	}
	zfs_commit_all_shares();

	if (unmount_one(hdl, mntpt, flags) != 0) {
	free(mntpt);
	(void) zfs_shareall(zhp);
	zfs_commit_all_shares();
	return (-1);
	}

	libzfs_mnttab_remove(hdl, zhp->zfs_name);
	free(mntpt);
	unmounted = B_TRUE;
	}

	/*
	* If the MS_CRYPT flag is provided we must ensure we attempt to
	* unload the dataset's key regardless of whether we did any work
	* to unmount it. We only do this for encryption roots.
	*/
	if ((flags & MS_CRYPT) != 0 &&
	zfs_prop_get_int(zhp, ZFS_PROP_ENCRYPTION) != ZIO_CRYPT_OFF) {
	zfs_refresh_properties(zhp);

	if (zfs_crypto_get_encryption_root(zhp, &encroot, NULL) != 0 &&
	unmounted) {
	(void) zfs_mount(zhp, NULL, 0);
	return (-1);
	}

	if (encroot && zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS) ==
	ZFS_KEYSTATUS_AVAILABLE &&
	zfs_crypto_unload_key(zhp) != 0) {
	(void) zfs_mount(zhp, NULL, 0);
	return (-1);
	}
	}

	return (0);
	}

	/*
	* Unmount this filesystem and any children inheriting the mountpoint property.
	* To do this, just act like we're changing the mountpoint property, but don't
	* remount the filesystems afterwards.
	*/
	int
	zfs_unmountall(zfs_handle_t *zhp, int flags)
	{
	prop_changelist_t *clp;
	int ret;

	clp = changelist_gather(zhp, ZFS_PROP_MOUNTPOINT,
	CL_GATHER_ITER_MOUNTED, flags);
	if (clp == NULL)
	return (-1);

	ret = changelist_prefix(clp);
	changelist_free(clp);

	return (ret);
	}

	boolean_t
	zfs_is_shared(zfs_handle_t *zhp)
	{
	zfs_share_type_t rc = 0;
	zfs_share_proto_t *curr_proto;

	if (ZFS_IS_VOLUME(zhp))
	return (B_FALSE);

	for (curr_proto = share_all_proto; *curr_proto != PROTO_END;
	curr_proto++)
	rc \|= zfs_is_shared_proto(zhp, NULL, *curr_proto);

	return (rc ? B_TRUE : B_FALSE);
	}

	/*
	* Unshare a filesystem by mountpoint.
	*/
	int
	unshare_one(libzfs_handle_t hdl, const char name, const char *mountpoint,
	zfs_share_proto_t proto)
	{
	int err;

	err = sa_disable_share(mountpoint, proto_table[proto].p_name);
	if (err != SA_OK) {
	return (zfs_error_fmt(hdl, proto_table[proto].p_unshare_err,
	dgettext(TEXT_DOMAIN, "cannot unshare '%s': %s"),
	name, sa_errorstr(err)));
	}
	return (0);
	}

	/*
	* Query libshare for the given mountpoint and protocol, returning
	* a zfs_share_type_t value.
	*/
	zfs_share_type_t
	is_shared(const char *mountpoint, zfs_share_proto_t proto)
	{
	if (sa_is_shared(mountpoint, proto_table[proto].p_name)) {
	switch (proto) {
	case PROTO_NFS:
	return (SHARED_NFS);
	case PROTO_SMB:
	return (SHARED_SMB);
	default:
	return (SHARED_NOT_SHARED);
	}
	}
	return (SHARED_NOT_SHARED);
	}

	/*
	* Share the given filesystem according to the options in the specified
	* protocol specific properties (sharenfs, sharesmb). We rely
	* on "libshare" to do the dirty work for us.
	*/
	int
	zfs_share_proto(zfs_handle_t zhp, zfs_share_proto_t proto)
	{
	char mountpoint[ZFS_MAXPROPLEN];
	char shareopts[ZFS_MAXPROPLEN];
	char sourcestr[ZFS_MAXPROPLEN];
	zfs_share_proto_t *curr_proto;
	zprop_source_t sourcetype;
	int err = 0;

	if (!zfs_is_mountable(zhp, mountpoint, sizeof (mountpoint), NULL, 0))
	return (0);

	for (curr_proto = proto; *curr_proto != PROTO_END; curr_proto++) {
	/*
	* Return success if there are no share options.
	*/
	if (zfs_prop_get(zhp, proto_table[*curr_proto].p_prop,
	shareopts, sizeof (shareopts), &sourcetype, sourcestr,
	ZFS_MAXPROPLEN, B_FALSE) != 0 \|\|
	strcmp(shareopts, "off") == 0)
	continue;

	/*
	* If the 'zoned' property is set, then zfs_is_mountable()
	* will have already bailed out if we are in the global zone.
	* But local zones cannot be NFS servers, so we ignore it for
	* local zones as well.
	*/
	if (zfs_prop_get_int(zhp, ZFS_PROP_ZONED))
	continue;

	err = sa_enable_share(zfs_get_name(zhp), mountpoint, shareopts,
	proto_table[*curr_proto].p_name);
	if (err != SA_OK) {
	return (zfs_error_fmt(zhp->zfs_hdl,
	proto_table[*curr_proto].p_share_err,
	dgettext(TEXT_DOMAIN, "cannot share '%s: %s'"),
	zfs_get_name(zhp), sa_errorstr(err)));
	}

	}
	return (0);
	}

	int
	zfs_share(zfs_handle_t *zhp)
	{
	assert(!ZFS_IS_VOLUME(zhp));
	return (zfs_share_proto(zhp, share_all_proto));
	}

	int
	zfs_unshare(zfs_handle_t *zhp)
	{
	assert(!ZFS_IS_VOLUME(zhp));
	return (zfs_unshareall(zhp));
	}

	/*
	* Check to see if the filesystem is currently shared.
	*/
	zfs_share_type_t
	zfs_is_shared_proto(zfs_handle_t zhp, char *where, zfs_share_proto_t proto)
	{
	char *mountpoint;
	zfs_share_type_t rc;

	if (!zfs_is_mounted(zhp, &mountpoint))
	return (SHARED_NOT_SHARED);

	if ((rc = is_shared(mountpoint, proto))
	!= SHARED_NOT_SHARED) {
	if (where != NULL)
	*where = mountpoint;
	else
	free(mountpoint);
	return (rc);
	} else {
	free(mountpoint);
	return (SHARED_NOT_SHARED);
	}
	}

	boolean_t
	zfs_is_shared_nfs(zfs_handle_t zhp, char *where)
	{
	return (zfs_is_shared_proto(zhp, where,
	PROTO_NFS) != SHARED_NOT_SHARED);
	}

	boolean_t
	zfs_is_shared_smb(zfs_handle_t zhp, char *where)
	{
	return (zfs_is_shared_proto(zhp, where,
	PROTO_SMB) != SHARED_NOT_SHARED);
	}

	/*
	* zfs_parse_options(options, proto)
	*
	* Call the legacy parse interface to get the protocol specific
	* options using the NULL arg to indicate that this is a "parse" only.
	*/
	int
	zfs_parse_options(char *options, zfs_share_proto_t proto)
	{
	return (sa_validate_shareopts(options, proto_table[proto].p_name));
	}

	void
	zfs_commit_proto(zfs_share_proto_t *proto)
	{
	zfs_share_proto_t *curr_proto;
	for (curr_proto = proto; *curr_proto != PROTO_END; curr_proto++) {
	sa_commit_shares(proto_table[*curr_proto].p_name);
	}
	}

	void
	zfs_commit_nfs_shares(void)
	{
	zfs_commit_proto(nfs_only);
	}

	void
	zfs_commit_smb_shares(void)
	{
	zfs_commit_proto(smb_only);
	}

	void
	zfs_commit_all_shares(void)
	{
	zfs_commit_proto(share_all_proto);
	}

	void
	zfs_commit_shares(const char *proto)
	{
	if (proto == NULL)
	zfs_commit_proto(share_all_proto);
	else if (strcmp(proto, "nfs") == 0)
	zfs_commit_proto(nfs_only);
	else if (strcmp(proto, "smb") == 0)
	zfs_commit_proto(smb_only);
	}

	int
	zfs_share_nfs(zfs_handle_t *zhp)
	{
	return (zfs_share_proto(zhp, nfs_only));
	}

	int
	zfs_share_smb(zfs_handle_t *zhp)
	{
	return (zfs_share_proto(zhp, smb_only));
	}

	int
	zfs_shareall(zfs_handle_t *zhp)
	{
	return (zfs_share_proto(zhp, share_all_proto));
	}

	/*
	* Unshare the given filesystem.
	*/
	int
	zfs_unshare_proto(zfs_handle_t zhp, const char mountpoint,
	zfs_share_proto_t *proto)
	{
	libzfs_handle_t *hdl = zhp->zfs_hdl;
	struct mnttab entry;
	char *mntpt = NULL;

	/* check to see if need to unmount the filesystem */
	if (mountpoint != NULL)
	mntpt = zfs_strdup(hdl, mountpoint);

	if (mountpoint != NULL \|\| ((zfs_get_type(zhp) == ZFS_TYPE_FILESYSTEM) &&
	libzfs_mnttab_find(hdl, zfs_get_name(zhp), &entry) == 0)) {
	zfs_share_proto_t *curr_proto;

	if (mountpoint == NULL)
	mntpt = zfs_strdup(zhp->zfs_hdl, entry.mnt_mountp);

	for (curr_proto = proto; *curr_proto != PROTO_END;
	curr_proto++) {

	if (is_shared(mntpt, *curr_proto)) {
	if (unshare_one(hdl, zhp->zfs_name,
	mntpt, *curr_proto) != 0) {
	if (mntpt != NULL)
	free(mntpt);
	return (-1);
	}
	}
	}
	}
	if (mntpt != NULL)
	free(mntpt);

	return (0);
	}

	int
	zfs_unshare_nfs(zfs_handle_t zhp, const char mountpoint)
	{
	return (zfs_unshare_proto(zhp, mountpoint, nfs_only));
	}

	int
	zfs_unshare_smb(zfs_handle_t zhp, const char mountpoint)
	{
	return (zfs_unshare_proto(zhp, mountpoint, smb_only));
	}

	/*
	* Same as zfs_unmountall(), but for NFS and SMB unshares.
	*/
	static int
	zfs_unshareall_proto(zfs_handle_t zhp, zfs_share_proto_t proto)
	{
	prop_changelist_t *clp;
	int ret;

	clp = changelist_gather(zhp, ZFS_PROP_SHARENFS, 0, 0);
	if (clp == NULL)
	return (-1);

	ret = changelist_unshare(clp, proto);
	changelist_free(clp);

	return (ret);
	}

	int
	zfs_unshareall_nfs(zfs_handle_t *zhp)
	{
	return (zfs_unshareall_proto(zhp, nfs_only));
	}

	int
	zfs_unshareall_smb(zfs_handle_t *zhp)
	{
	return (zfs_unshareall_proto(zhp, smb_only));
	}

	int
	zfs_unshareall(zfs_handle_t *zhp)
	{
	return (zfs_unshareall_proto(zhp, share_all_proto));
	}

	int
	zfs_unshareall_bypath(zfs_handle_t zhp, const char mountpoint)
	{
	return (zfs_unshare_proto(zhp, mountpoint, share_all_proto));
	}

	int
	zfs_unshareall_bytype(zfs_handle_t zhp, const char mountpoint,
	const char *proto)
	{
	if (proto == NULL)
	return (zfs_unshare_proto(zhp, mountpoint, share_all_proto));
	if (strcmp(proto, "nfs") == 0)
	return (zfs_unshare_proto(zhp, mountpoint, nfs_only));
	else if (strcmp(proto, "smb") == 0)
	return (zfs_unshare_proto(zhp, mountpoint, smb_only));
	else
	return (1);
	}

	/*
	* Remove the mountpoint associated with the current dataset, if necessary.
	* We only remove the underlying directory if:
	*
	* - The mountpoint is not 'none' or 'legacy'
	* - The mountpoint is non-empty
	* - The mountpoint is the default or inherited
	* - The 'zoned' property is set, or we're in a local zone
	*
	* Any other directories we leave alone.
	*/
	void
	remove_mountpoint(zfs_handle_t *zhp)
	{
	char mountpoint[ZFS_MAXPROPLEN];
	zprop_source_t source;

	if (!zfs_is_mountable(zhp, mountpoint, sizeof (mountpoint),
	&source, 0))
	return;

	if (source == ZPROP_SRC_DEFAULT \|\|
	source == ZPROP_SRC_INHERITED) {
	/*
	* Try to remove the directory, silently ignoring any errors.
	* The filesystem may have since been removed or moved around,
	* and this error isn't really useful to the administrator in
	* any way.
	*/
	(void) rmdir(mountpoint);
	}
	}

	/*
	* Add the given zfs handle to the cb_handles array, dynamically reallocating
	* the array if it is out of space.
	*/
	void
	libzfs_add_handle(get_all_cb_t cbp, zfs_handle_t zhp)
	{
	if (cbp->cb_alloc == cbp->cb_used) {
	size_t newsz;
	zfs_handle_t **newhandles;

	newsz = cbp->cb_alloc != 0 ? cbp->cb_alloc * 2 : 64;
	newhandles = zfs_realloc(zhp->zfs_hdl,
	cbp->cb_handles, cbp->cb_alloc * sizeof (zfs_handle_t *),
	newsz * sizeof (zfs_handle_t *));
	cbp->cb_handles = newhandles;
	cbp->cb_alloc = newsz;
	}
	cbp->cb_handles[cbp->cb_used++] = zhp;
	}

	/*
	* Recursive helper function used during file system enumeration
	*/
	static int
	zfs_iter_cb(zfs_handle_t zhp, void data)
	{
	get_all_cb_t *cbp = data;

	if (!(zfs_get_type(zhp) & ZFS_TYPE_FILESYSTEM)) {
	zfs_close(zhp);
	return (0);
	}

	if (zfs_prop_get_int(zhp, ZFS_PROP_CANMOUNT) == ZFS_CANMOUNT_NOAUTO) {
	zfs_close(zhp);
	return (0);
	}

	if (zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS) ==
	ZFS_KEYSTATUS_UNAVAILABLE) {
	zfs_close(zhp);
	return (0);
	}

	/*
	* If this filesystem is inconsistent and has a receive resume
	* token, we can not mount it.
	*/
	if (zfs_prop_get_int(zhp, ZFS_PROP_INCONSISTENT) &&
	zfs_prop_get(zhp, ZFS_PROP_RECEIVE_RESUME_TOKEN,
	NULL, 0, NULL, NULL, 0, B_TRUE) == 0) {
	zfs_close(zhp);
	return (0);
	}

	libzfs_add_handle(cbp, zhp);
	if (zfs_iter_filesystems(zhp, zfs_iter_cb, cbp) != 0) {
	zfs_close(zhp);
	return (-1);
	}
	return (0);
	}

	/*
	* Sort comparator that compares two mountpoint paths. We sort these paths so
	* that subdirectories immediately follow their parents. This means that we
	* effectively treat the '/' character as the lowest value non-nul char.
	* Since filesystems from non-global zones can have the same mountpoint
	* as other filesystems, the comparator sorts global zone filesystems to
	* the top of the list. This means that the global zone will traverse the
	* filesystem list in the correct order and can stop when it sees the
	* first zoned filesystem. In a non-global zone, only the delegated
	* filesystems are seen.
	*
	* An example sorted list using this comparator would look like:
	*
	* /foo
	* /foo/bar
	* /foo/bar/baz
	* /foo/baz
	* /foo.bar
	* /foo (NGZ1)
	* /foo (NGZ2)
	*
	* The mounting code depends on this ordering to deterministically iterate
	* over filesystems in order to spawn parallel mount tasks.
	*/
	static int
	mountpoint_cmp(const void arga, const void argb)
	{
	zfs_handle_t const zap = arga;
	zfs_handle_t za = zap;
	zfs_handle_t const zbp = argb;
	zfs_handle_t zb = zbp;
	char mounta[MAXPATHLEN];
	char mountb[MAXPATHLEN];
	const char *a = mounta;
	const char *b = mountb;
	boolean_t gota, gotb;
	uint64_t zoneda, zonedb;

	zoneda = zfs_prop_get_int(za, ZFS_PROP_ZONED);
	zonedb = zfs_prop_get_int(zb, ZFS_PROP_ZONED);
	if (zoneda && !zonedb)
	return (1);
	if (!zoneda && zonedb)
	return (-1);

	gota = (zfs_get_type(za) == ZFS_TYPE_FILESYSTEM);
	if (gota) {
	verify(zfs_prop_get(za, ZFS_PROP_MOUNTPOINT, mounta,
	sizeof (mounta), NULL, NULL, 0, B_FALSE) == 0);
	}
	gotb = (zfs_get_type(zb) == ZFS_TYPE_FILESYSTEM);
	if (gotb) {
	verify(zfs_prop_get(zb, ZFS_PROP_MOUNTPOINT, mountb,
	sizeof (mountb), NULL, NULL, 0, B_FALSE) == 0);
	}

	if (gota && gotb) {
	while (a != '\0' && (a == *b)) {
	a++;
	b++;
	}
	if (a == b)
	return (0);
	if (*a == '\0')
	return (-1);
	if (*b == '\0')
	return (1);
	if (*a == '/')
	return (-1);
	if (*b == '/')
	return (1);
	return (a < b ? -1 : a > b);
	}

	if (gota)
	return (-1);
	if (gotb)
	return (1);

	/*
	* If neither filesystem has a mountpoint, revert to sorting by
	* dataset name.
	*/
	return (strcmp(zfs_get_name(za), zfs_get_name(zb)));
	}

	/*
	* Return true if path2 is a child of path1 or path2 equals path1 or
	* path1 is "/" (path2 is always a child of "/").
	*/
	static boolean_t
	libzfs_path_contains(const char path1, const char path2)
	{
	return (strcmp(path1, path2) == 0 \|\| strcmp(path1, "/") == 0 \|\|
	(strstr(path2, path1) == path2 && path2[strlen(path1)] == '/'));
	}

	/*
	* Given a mountpoint specified by idx in the handles array, find the first
	* non-descendent of that mountpoint and return its index. Descendant paths
	* start with the parent's path. This function relies on the ordering
	* enforced by mountpoint_cmp().
	*/
	static int
	non_descendant_idx(zfs_handle_t **handles, size_t num_handles, int idx)
	{
	char parent[ZFS_MAXPROPLEN];
	char child[ZFS_MAXPROPLEN];
	int i;

	verify(zfs_prop_get(handles[idx], ZFS_PROP_MOUNTPOINT, parent,
	sizeof (parent), NULL, NULL, 0, B_FALSE) == 0);

	for (i = idx + 1; i < num_handles; i++) {
	verify(zfs_prop_get(handles[i], ZFS_PROP_MOUNTPOINT, child,
	sizeof (child), NULL, NULL, 0, B_FALSE) == 0);
	if (!libzfs_path_contains(parent, child))
	break;
	}
	return (i);
	}

	typedef struct mnt_param {
	libzfs_handle_t *mnt_hdl;
	tpool_t *mnt_tp;
	zfs_handle_t *mnt_zhps; / filesystems to mount */
	size_t mnt_num_handles;
	int mnt_idx; /* Index of selected entry to mount */
	zfs_iter_f mnt_func;
	void *mnt_data;
	} mnt_param_t;

	/*
	* Allocate and populate the parameter struct for mount function, and
	* schedule mounting of the entry selected by idx.
	*/
	static void
	zfs_dispatch_mount(libzfs_handle_t hdl, zfs_handle_t *handles,
	size_t num_handles, int idx, zfs_iter_f func, void data, tpool_t tp)
	{
	mnt_param_t *mnt_param = zfs_alloc(hdl, sizeof (mnt_param_t));

	mnt_param->mnt_hdl = hdl;
	mnt_param->mnt_tp = tp;
	mnt_param->mnt_zhps = handles;
	mnt_param->mnt_num_handles = num_handles;
	mnt_param->mnt_idx = idx;
	mnt_param->mnt_func = func;
	mnt_param->mnt_data = data;

	(void) tpool_dispatch(tp, zfs_mount_task, (void*)mnt_param);
	}

	/*
	* This is the structure used to keep state of mounting or sharing operations
	* during a call to zpool_enable_datasets().
	*/
	typedef struct mount_state {
	/*
	* ms_mntstatus is set to -1 if any mount fails. While multiple threads
	* could update this variable concurrently, no synchronization is
	* needed as it's only ever set to -1.
	*/
	int ms_mntstatus;
	int ms_mntflags;
	const char *ms_mntopts;
	} mount_state_t;

	static int
	zfs_mount_one(zfs_handle_t zhp, void arg)
	{
	mount_state_t *ms = arg;
	int ret = 0;

	/*
	* don't attempt to mount encrypted datasets with
	* unloaded keys
	*/
	if (zfs_prop_get_int(zhp, ZFS_PROP_KEYSTATUS) ==
	ZFS_KEYSTATUS_UNAVAILABLE)
	return (0);

	if (zfs_mount(zhp, ms->ms_mntopts, ms->ms_mntflags) != 0)
	ret = ms->ms_mntstatus = -1;
	return (ret);
	}

	static int
	zfs_share_one(zfs_handle_t zhp, void arg)
	{
	mount_state_t *ms = arg;
	int ret = 0;

	if (zfs_share(zhp) != 0)
	ret = ms->ms_mntstatus = -1;
	return (ret);
	}

	/*
	* Thread pool function to mount one file system. On completion, it finds and
	* schedules its children to be mounted. This depends on the sorting done in
	* zfs_foreach_mountpoint(). Note that the degenerate case (chain of entries
	* each descending from the previous) will have no parallelism since we always
	* have to wait for the parent to finish mounting before we can schedule
	* its children.
	*/
	static void
	zfs_mount_task(void *arg)
	{
	mnt_param_t *mp = arg;
	int idx = mp->mnt_idx;
	zfs_handle_t **handles = mp->mnt_zhps;
	size_t num_handles = mp->mnt_num_handles;
	char mountpoint[ZFS_MAXPROPLEN];

	verify(zfs_prop_get(handles[idx], ZFS_PROP_MOUNTPOINT, mountpoint,
	sizeof (mountpoint), NULL, NULL, 0, B_FALSE) == 0);

	if (mp->mnt_func(handles[idx], mp->mnt_data) != 0)
	return;

	/*
	* We dispatch tasks to mount filesystems with mountpoints underneath
	* this one. We do this by dispatching the next filesystem with a
	* descendant mountpoint of the one we just mounted, then skip all of
	* its descendants, dispatch the next descendant mountpoint, and so on.
	* The non_descendant_idx() function skips over filesystems that are
	* descendants of the filesystem we just dispatched.
	*/
	for (int i = idx + 1; i < num_handles;
	i = non_descendant_idx(handles, num_handles, i)) {
	char child[ZFS_MAXPROPLEN];
	verify(zfs_prop_get(handles[i], ZFS_PROP_MOUNTPOINT,
	child, sizeof (child), NULL, NULL, 0, B_FALSE) == 0);

	if (!libzfs_path_contains(mountpoint, child))
	break; /* not a descendant, return */
	zfs_dispatch_mount(mp->mnt_hdl, handles, num_handles, i,
	mp->mnt_func, mp->mnt_data, mp->mnt_tp);
	}
	free(mp);
	}

	/*
	* Issue the func callback for each ZFS handle contained in the handles
	* array. This function is used to mount all datasets, and so this function
	* guarantees that filesystems for parent mountpoints are called before their
	* children. As such, before issuing any callbacks, we first sort the array
	* of handles by mountpoint.
	*
	* Callbacks are issued in one of two ways:
	*
	* 1. Sequentially: If the parallel argument is B_FALSE or the ZFS_SERIAL_MOUNT
	* environment variable is set, then we issue callbacks sequentially.
	*
	* 2. In parallel: If the parallel argument is B_TRUE and the ZFS_SERIAL_MOUNT
	* environment variable is not set, then we use a tpool to dispatch threads
	* to mount filesystems in parallel. This function dispatches tasks to mount
	* the filesystems at the top-level mountpoints, and these tasks in turn
	* are responsible for recursively mounting filesystems in their children
	* mountpoints.
	*/
	void
	zfs_foreach_mountpoint(libzfs_handle_t hdl, zfs_handle_t *handles,
	size_t num_handles, zfs_iter_f func, void *data, boolean_t parallel)
	{
	zoneid_t zoneid = getzoneid();

	/*
	* The ZFS_SERIAL_MOUNT environment variable is an undocumented
	* variable that can be used as a convenience to do a/b comparison
	* of serial vs. parallel mounting.
	*/
	boolean_t serial_mount = !parallel \|\|
	(getenv("ZFS_SERIAL_MOUNT") != NULL);

	/*
	* Sort the datasets by mountpoint. See mountpoint_cmp for details
	* of how these are sorted.
	*/
	qsort(handles, num_handles, sizeof (zfs_handle_t *), mountpoint_cmp);

	if (serial_mount) {
	for (int i = 0; i < num_handles; i++) {
	func(handles[i], data);
	}
	return;
	}

	/*
	* Issue the callback function for each dataset using a parallel
	* algorithm that uses a thread pool to manage threads.
	*/
	tpool_t *tp = tpool_create(1, mount_tp_nthr, 0, NULL);

	/*
	* There may be multiple "top level" mountpoints outside of the pool's
	* root mountpoint, e.g.: /foo /bar. Dispatch a mount task for each of
	* these.
	*/
	for (int i = 0; i < num_handles;
	i = non_descendant_idx(handles, num_handles, i)) {
	/*
	* Since the mountpoints have been sorted so that the zoned
	* filesystems are at the end, a zoned filesystem seen from
	* the global zone means that we're done.
	*/
	if (zoneid == GLOBAL_ZONEID &&
	zfs_prop_get_int(handles[i], ZFS_PROP_ZONED))
	break;
	zfs_dispatch_mount(hdl, handles, num_handles, i, func, data,
	tp);
	}

	tpool_wait(tp); /* wait for all scheduled mounts to complete */
	tpool_destroy(tp);
	}

	/*
	* Mount and share all datasets within the given pool. This assumes that no
	* datasets within the pool are currently mounted.
	*/
	#pragma weak zpool_mount_datasets = zpool_enable_datasets
	int
	zpool_enable_datasets(zpool_handle_t zhp, const char mntopts, int flags)
	{
	get_all_cb_t cb = { 0 };
	mount_state_t ms = { 0 };
	zfs_handle_t *zfsp;
	int ret = 0;

	if ((zfsp = zfs_open(zhp->zpool_hdl, zhp->zpool_name,
	ZFS_TYPE_DATASET)) == NULL)
	goto out;

	/*
	* Gather all non-snapshot datasets within the pool. Start by adding
	* the root filesystem for this pool to the list, and then iterate
	* over all child filesystems.
	*/
	libzfs_add_handle(&cb, zfsp);
	if (zfs_iter_filesystems(zfsp, zfs_iter_cb, &cb) != 0)
	goto out;

	/*
	* Mount all filesystems
	*/
	ms.ms_mntopts = mntopts;
	ms.ms_mntflags = flags;
	zfs_foreach_mountpoint(zhp->zpool_hdl, cb.cb_handles, cb.cb_used,
	zfs_mount_one, &ms, B_TRUE);
	if (ms.ms_mntstatus != 0)
	ret = ms.ms_mntstatus;

	/*
	* Share all filesystems that need to be shared. This needs to be
	* a separate pass because libshare is not mt-safe, and so we need
	* to share serially.
	*/
	ms.ms_mntstatus = 0;
	zfs_foreach_mountpoint(zhp->zpool_hdl, cb.cb_handles, cb.cb_used,
	zfs_share_one, &ms, B_FALSE);
	if (ms.ms_mntstatus != 0)
	ret = ms.ms_mntstatus;
	else
	zfs_commit_all_shares();

	out:
	for (int i = 0; i < cb.cb_used; i++)
	zfs_close(cb.cb_handles[i]);
	free(cb.cb_handles);

	return (ret);
	}

	static int
	mountpoint_compare(const void a, const void b)
	{
	const char mounta = ((char **)a);
	const char mountb = ((char **)b);

	return (strcmp(mountb, mounta));
	}

	/* alias for 2002/240 */
	#pragma weak zpool_unmount_datasets = zpool_disable_datasets
	/*
	* Unshare and unmount all datasets within the given pool. We don't want to
	* rely on traversing the DSL to discover the filesystems within the pool,
	* because this may be expensive (if not all of them are mounted), and can fail
	* arbitrarily (on I/O error, for example). Instead, we walk /proc/self/mounts
	* and gather all the filesystems that are currently mounted.
	*/
	int
	zpool_disable_datasets(zpool_handle_t *zhp, boolean_t force)
	{
	int used, alloc;
	struct mnttab entry;
	size_t namelen;
	char **mountpoints = NULL;
	zfs_handle_t **datasets = NULL;
	libzfs_handle_t *hdl = zhp->zpool_hdl;
	int i;
	int ret = -1;
	int flags = (force ? MS_FORCE : 0);

	namelen = strlen(zhp->zpool_name);

	/* Reopen MNTTAB to prevent reading stale data from open file */
	- if (freopen(MNTTAB, "r", hdl->libzfs_mnttab) == NULL)
	+ if (freopen(MNTTAB, "re", hdl->libzfs_mnttab) == NULL)
	return (ENOENT);

	used = alloc = 0;
	while (getmntent(hdl->libzfs_mnttab, &entry) == 0) {
	/*
	* Ignore non-ZFS entries.
	*/
	if (entry.mnt_fstype == NULL \|\|
	strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0)
	continue;

	/*
	* Ignore filesystems not within this pool.
	*/
	if (entry.mnt_mountp == NULL \|\|
	strncmp(entry.mnt_special, zhp->zpool_name, namelen) != 0 \|\|
	(entry.mnt_special[namelen] != '/' &&
	entry.mnt_special[namelen] != '\0'))
	continue;

	/*
	* At this point we've found a filesystem within our pool. Add
	* it to our growing list.
	*/
	if (used == alloc) {
	if (alloc == 0) {
	if ((mountpoints = zfs_alloc(hdl,
	8 * sizeof (void *))) == NULL)
	goto out;

	if ((datasets = zfs_alloc(hdl,
	8 * sizeof (void *))) == NULL)
	goto out;

	alloc = 8;
	} else {
	void *ptr;

	if ((ptr = zfs_realloc(hdl, mountpoints,
	alloc * sizeof (void *),
	alloc * 2 * sizeof (void *))) == NULL)
	goto out;
	mountpoints = ptr;

	if ((ptr = zfs_realloc(hdl, datasets,
	alloc * sizeof (void *),
	alloc * 2 * sizeof (void *))) == NULL)
	goto out;
	datasets = ptr;

	alloc *= 2;
	}
	}

	if ((mountpoints[used] = zfs_strdup(hdl,
	entry.mnt_mountp)) == NULL)
	goto out;

	/*
	* This is allowed to fail, in case there is some I/O error. It
	* is only used to determine if we need to remove the underlying
	* mountpoint, so failure is not fatal.
	*/
	datasets[used] = make_dataset_handle(hdl, entry.mnt_special);

	used++;
	}

	/*
	* At this point, we have the entire list of filesystems, so sort it by
	* mountpoint.
	*/
	qsort(mountpoints, used, sizeof (char *), mountpoint_compare);

	/*
	* Walk through and first unshare everything.
	*/
	for (i = 0; i < used; i++) {
	zfs_share_proto_t *curr_proto;
	for (curr_proto = share_all_proto; *curr_proto != PROTO_END;
	curr_proto++) {
	if (is_shared(mountpoints[i], *curr_proto) &&
	unshare_one(hdl, mountpoints[i],
	mountpoints[i], *curr_proto) != 0)
	goto out;
	}
	}
	zfs_commit_all_shares();

	/*
	* Now unmount everything, removing the underlying directories as
	* appropriate.
	*/
	for (i = 0; i < used; i++) {
	if (unmount_one(hdl, mountpoints[i], flags) != 0)
	goto out;
	}

	for (i = 0; i < used; i++) {
	if (datasets[i])
	remove_mountpoint(datasets[i]);
	}

	ret = 0;
	out:
	for (i = 0; i < used; i++) {
	if (datasets[i])
	zfs_close(datasets[i]);
	free(mountpoints[i]);
	}
	free(datasets);
	free(mountpoints);

	return (ret);
	}
	diff --git a/sys/contrib/openzfs/lib/libzfs/libzfs_pool.c b/sys/contrib/openzfs/lib/libzfs/libzfs_pool.c
	index 9ef97cd677ff..d4849ee5bd9b 100644
	--- a/sys/contrib/openzfs/lib/libzfs/libzfs_pool.c
	+++ b/sys/contrib/openzfs/lib/libzfs/libzfs_pool.c
	@@ -1,4922 +1,4940 @@
	/*
	* 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 2015 Nexenta Systems, Inc. All rights reserved.
	* Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2011, 2020 by Delphix. All rights reserved.
	* Copyright 2016 Igor Kozhukhov <ikozhukhov@gmail.com>
	* Copyright (c) 2018 Datto Inc.
	* Copyright (c) 2017 Open-E, Inc. All Rights Reserved.
	* Copyright (c) 2017, Intel Corporation.
	* Copyright (c) 2018, loli10K <ezomori.nozomu@gmail.com>
	* Copyright (c) 2021, Colm Buckley <colm@tuatha.org>
	*/

	#include <errno.h>
	#include <libintl.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <strings.h>
	#include <unistd.h>
	#include <libgen.h>
	#include <zone.h>
	#include <sys/stat.h>
	#include <sys/efi_partition.h>
	#include <sys/systeminfo.h>
	#include <sys/zfs_ioctl.h>
	#include <sys/zfs_sysfs.h>
	#include <sys/vdev_disk.h>
	#include <sys/types.h>
	#include <dlfcn.h>
	#include <libzutil.h>
	#include <fcntl.h>

	#include "zfs_namecheck.h"
	#include "zfs_prop.h"
	#include "libzfs_impl.h"
	#include "zfs_comutil.h"
	#include "zfeature_common.h"

	static boolean_t zpool_vdev_is_interior(const char *name);

	typedef struct prop_flags {
	int create:1; /* Validate property on creation */
	int import:1; /* Validate property on import */
	} prop_flags_t;

	/*
	* ====================================================================
	* zpool property functions
	* ====================================================================
	*/

	static int
	zpool_get_all_props(zpool_handle_t *zhp)
	{
	zfs_cmd_t zc = {"\0"};
	libzfs_handle_t *hdl = zhp->zpool_hdl;

	(void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));

	if (zcmd_alloc_dst_nvlist(hdl, &zc, 0) != 0)
	return (-1);

	while (zfs_ioctl(hdl, ZFS_IOC_POOL_GET_PROPS, &zc) != 0) {
	if (errno == ENOMEM) {
	if (zcmd_expand_dst_nvlist(hdl, &zc) != 0) {
	zcmd_free_nvlists(&zc);
	return (-1);
	}
	} else {
	zcmd_free_nvlists(&zc);
	return (-1);
	}
	}

	if (zcmd_read_dst_nvlist(hdl, &zc, &zhp->zpool_props) != 0) {
	zcmd_free_nvlists(&zc);
	return (-1);
	}

	zcmd_free_nvlists(&zc);

	return (0);
	}

	int
	zpool_props_refresh(zpool_handle_t *zhp)
	{
	nvlist_t *old_props;

	old_props = zhp->zpool_props;

	if (zpool_get_all_props(zhp) != 0)
	return (-1);

	nvlist_free(old_props);
	return (0);
	}

	static const char *
	zpool_get_prop_string(zpool_handle_t *zhp, zpool_prop_t prop,
	zprop_source_t *src)
	{
	nvlist_t nv, nvl;
	uint64_t ival;
	char *value;
	zprop_source_t source;

	nvl = zhp->zpool_props;
	if (nvlist_lookup_nvlist(nvl, zpool_prop_to_name(prop), &nv) == 0) {
	verify(nvlist_lookup_uint64(nv, ZPROP_SOURCE, &ival) == 0);
	source = ival;
	verify(nvlist_lookup_string(nv, ZPROP_VALUE, &value) == 0);
	} else {
	source = ZPROP_SRC_DEFAULT;
	if ((value = (char *)zpool_prop_default_string(prop)) == NULL)
	value = "-";
	}

	if (src)
	*src = source;

	return (value);
	}

	uint64_t
	zpool_get_prop_int(zpool_handle_t zhp, zpool_prop_t prop, zprop_source_t src)
	{
	nvlist_t nv, nvl;
	uint64_t value;
	zprop_source_t source;

	if (zhp->zpool_props == NULL && zpool_get_all_props(zhp)) {
	/*
	* zpool_get_all_props() has most likely failed because
	* the pool is faulted, but if all we need is the top level
	* vdev's guid then get it from the zhp config nvlist.
	*/
	if ((prop == ZPOOL_PROP_GUID) &&
	(nvlist_lookup_nvlist(zhp->zpool_config,
	ZPOOL_CONFIG_VDEV_TREE, &nv) == 0) &&
	(nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &value)
	== 0)) {
	return (value);
	}
	return (zpool_prop_default_numeric(prop));
	}

	nvl = zhp->zpool_props;
	if (nvlist_lookup_nvlist(nvl, zpool_prop_to_name(prop), &nv) == 0) {
	verify(nvlist_lookup_uint64(nv, ZPROP_SOURCE, &value) == 0);
	source = value;
	verify(nvlist_lookup_uint64(nv, ZPROP_VALUE, &value) == 0);
	} else {
	source = ZPROP_SRC_DEFAULT;
	value = zpool_prop_default_numeric(prop);
	}

	if (src)
	*src = source;

	return (value);
	}

	/*
	* Map VDEV STATE to printed strings.
	*/
	const char *
	zpool_state_to_name(vdev_state_t state, vdev_aux_t aux)
	{
	switch (state) {
	case VDEV_STATE_CLOSED:
	case VDEV_STATE_OFFLINE:
	return (gettext("OFFLINE"));
	case VDEV_STATE_REMOVED:
	return (gettext("REMOVED"));
	case VDEV_STATE_CANT_OPEN:
	if (aux == VDEV_AUX_CORRUPT_DATA \|\| aux == VDEV_AUX_BAD_LOG)
	return (gettext("FAULTED"));
	else if (aux == VDEV_AUX_SPLIT_POOL)
	return (gettext("SPLIT"));
	else
	return (gettext("UNAVAIL"));
	case VDEV_STATE_FAULTED:
	return (gettext("FAULTED"));
	case VDEV_STATE_DEGRADED:
	return (gettext("DEGRADED"));
	case VDEV_STATE_HEALTHY:
	return (gettext("ONLINE"));

	default:
	break;
	}

	return (gettext("UNKNOWN"));
	}

	/*
	* Map POOL STATE to printed strings.
	*/
	const char *
	zpool_pool_state_to_name(pool_state_t state)
	{
	switch (state) {
	default:
	break;
	case POOL_STATE_ACTIVE:
	return (gettext("ACTIVE"));
	case POOL_STATE_EXPORTED:
	return (gettext("EXPORTED"));
	case POOL_STATE_DESTROYED:
	return (gettext("DESTROYED"));
	case POOL_STATE_SPARE:
	return (gettext("SPARE"));
	case POOL_STATE_L2CACHE:
	return (gettext("L2CACHE"));
	case POOL_STATE_UNINITIALIZED:
	return (gettext("UNINITIALIZED"));
	case POOL_STATE_UNAVAIL:
	return (gettext("UNAVAIL"));
	case POOL_STATE_POTENTIALLY_ACTIVE:
	return (gettext("POTENTIALLY_ACTIVE"));
	}

	return (gettext("UNKNOWN"));
	}

	/*
	* Given a pool handle, return the pool health string ("ONLINE", "DEGRADED",
	* "SUSPENDED", etc).
	*/
	const char *
	zpool_get_state_str(zpool_handle_t *zhp)
	{
	zpool_errata_t errata;
	zpool_status_t status;
	nvlist_t *nvroot;
	vdev_stat_t *vs;
	uint_t vsc;
	const char *str;

	status = zpool_get_status(zhp, NULL, &errata);

	if (zpool_get_state(zhp) == POOL_STATE_UNAVAIL) {
	str = gettext("FAULTED");
	} else if (status == ZPOOL_STATUS_IO_FAILURE_WAIT \|\|
	status == ZPOOL_STATUS_IO_FAILURE_MMP) {
	str = gettext("SUSPENDED");
	} else {
	verify(nvlist_lookup_nvlist(zpool_get_config(zhp, NULL),
	ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0);
	verify(nvlist_lookup_uint64_array(nvroot,
	ZPOOL_CONFIG_VDEV_STATS, (uint64_t **)&vs, &vsc)
	== 0);
	str = zpool_state_to_name(vs->vs_state, vs->vs_aux);
	}
	return (str);
	}

	/*
	* Get a zpool property value for 'prop' and return the value in
	* a pre-allocated buffer.
	*/
	int
	zpool_get_prop(zpool_handle_t zhp, zpool_prop_t prop, char buf,
	size_t len, zprop_source_t *srctype, boolean_t literal)
	{
	uint64_t intval;
	const char *strval;
	zprop_source_t src = ZPROP_SRC_NONE;

	if (zpool_get_state(zhp) == POOL_STATE_UNAVAIL) {
	switch (prop) {
	case ZPOOL_PROP_NAME:
	(void) strlcpy(buf, zpool_get_name(zhp), len);
	break;

	case ZPOOL_PROP_HEALTH:
	(void) strlcpy(buf, zpool_get_state_str(zhp), len);
	break;

	case ZPOOL_PROP_GUID:
	intval = zpool_get_prop_int(zhp, prop, &src);
	(void) snprintf(buf, len, "%llu", (u_longlong_t)intval);
	break;

	case ZPOOL_PROP_ALTROOT:
	case ZPOOL_PROP_CACHEFILE:
	case ZPOOL_PROP_COMMENT:
	case ZPOOL_PROP_COMPATIBILITY:
	if (zhp->zpool_props != NULL \|\|
	zpool_get_all_props(zhp) == 0) {
	(void) strlcpy(buf,
	zpool_get_prop_string(zhp, prop, &src),
	len);
	break;
	}
	/* FALLTHROUGH */
	default:
	(void) strlcpy(buf, "-", len);
	break;
	}

	if (srctype != NULL)
	*srctype = src;
	return (0);
	}

	if (zhp->zpool_props == NULL && zpool_get_all_props(zhp) &&
	prop != ZPOOL_PROP_NAME)
	return (-1);

	switch (zpool_prop_get_type(prop)) {
	case PROP_TYPE_STRING:
	(void) strlcpy(buf, zpool_get_prop_string(zhp, prop, &src),
	len);
	break;

	case PROP_TYPE_NUMBER:
	intval = zpool_get_prop_int(zhp, prop, &src);

	switch (prop) {
	case ZPOOL_PROP_SIZE:
	case ZPOOL_PROP_ALLOCATED:
	case ZPOOL_PROP_FREE:
	case ZPOOL_PROP_FREEING:
	case ZPOOL_PROP_LEAKED:
	case ZPOOL_PROP_ASHIFT:
	if (literal)
	(void) snprintf(buf, len, "%llu",
	(u_longlong_t)intval);
	else
	(void) zfs_nicenum(intval, buf, len);
	break;

	case ZPOOL_PROP_EXPANDSZ:
	case ZPOOL_PROP_CHECKPOINT:
	if (intval == 0) {
	(void) strlcpy(buf, "-", len);
	} else if (literal) {
	(void) snprintf(buf, len, "%llu",
	(u_longlong_t)intval);
	} else {
	(void) zfs_nicebytes(intval, buf, len);
	}
	break;

	case ZPOOL_PROP_CAPACITY:
	if (literal) {
	(void) snprintf(buf, len, "%llu",
	(u_longlong_t)intval);
	} else {
	(void) snprintf(buf, len, "%llu%%",
	(u_longlong_t)intval);
	}
	break;

	case ZPOOL_PROP_FRAGMENTATION:
	if (intval == UINT64_MAX) {
	(void) strlcpy(buf, "-", len);
	} else if (literal) {
	(void) snprintf(buf, len, "%llu",
	(u_longlong_t)intval);
	} else {
	(void) snprintf(buf, len, "%llu%%",
	(u_longlong_t)intval);
	}
	break;

	case ZPOOL_PROP_DEDUPRATIO:
	if (literal)
	(void) snprintf(buf, len, "%llu.%02llu",
	(u_longlong_t)(intval / 100),
	(u_longlong_t)(intval % 100));
	else
	(void) snprintf(buf, len, "%llu.%02llux",
	(u_longlong_t)(intval / 100),
	(u_longlong_t)(intval % 100));
	break;

	case ZPOOL_PROP_HEALTH:
	(void) strlcpy(buf, zpool_get_state_str(zhp), len);
	break;
	case ZPOOL_PROP_VERSION:
	if (intval >= SPA_VERSION_FEATURES) {
	(void) snprintf(buf, len, "-");
	break;
	}
	/* FALLTHROUGH */
	default:
	(void) snprintf(buf, len, "%llu", (u_longlong_t)intval);
	}
	break;

	case PROP_TYPE_INDEX:
	intval = zpool_get_prop_int(zhp, prop, &src);
	if (zpool_prop_index_to_string(prop, intval, &strval)
	!= 0)
	return (-1);
	(void) strlcpy(buf, strval, len);
	break;

	default:
	abort();
	}

	if (srctype)
	*srctype = src;

	return (0);
	}

	/*
	* Check if the bootfs name has the same pool name as it is set to.
	* Assuming bootfs is a valid dataset name.
	*/
	static boolean_t
	bootfs_name_valid(const char pool, const char bootfs)
	{
	int len = strlen(pool);
	if (bootfs[0] == '\0')
	return (B_TRUE);

	if (!zfs_name_valid(bootfs, ZFS_TYPE_FILESYSTEM\|ZFS_TYPE_SNAPSHOT))
	return (B_FALSE);

	if (strncmp(pool, bootfs, len) == 0 &&
	(bootfs[len] == '/' \|\| bootfs[len] == '\0'))
	return (B_TRUE);

	return (B_FALSE);
	}

	/*
	* Given an nvlist of zpool properties to be set, validate that they are
	* correct, and parse any numeric properties (index, boolean, etc) if they are
	* specified as strings.
	*/
	static nvlist_t *
	zpool_valid_proplist(libzfs_handle_t hdl, const char poolname,
	nvlist_t props, uint64_t version, prop_flags_t flags, char errbuf)
	{
	nvpair_t *elem;
	nvlist_t *retprops;
	zpool_prop_t prop;
	char *strval;
	uint64_t intval;
	char slash, check;
	struct stat64 statbuf;
	zpool_handle_t *zhp;
	- char badword[ZFS_MAXPROPLEN];
	- char badfile[MAXPATHLEN];
	+ char report[1024];

	if (nvlist_alloc(&retprops, NV_UNIQUE_NAME, 0) != 0) {
	(void) no_memory(hdl);
	return (NULL);
	}

	elem = NULL;
	while ((elem = nvlist_next_nvpair(props, elem)) != NULL) {
	const char *propname = nvpair_name(elem);

	prop = zpool_name_to_prop(propname);
	if (prop == ZPOOL_PROP_INVAL && zpool_prop_feature(propname)) {
	int err;
	char *fname = strchr(propname, '@') + 1;

	err = zfeature_lookup_name(fname, NULL);
	if (err != 0) {
	ASSERT3U(err, ==, ENOENT);
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"feature '%s' unsupported by kernel"),
	fname);
	(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
	goto error;
	}

	if (nvpair_type(elem) != DATA_TYPE_STRING) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"'%s' must be a string"), propname);
	(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
	goto error;
	}

	(void) nvpair_value_string(elem, &strval);
	if (strcmp(strval, ZFS_FEATURE_ENABLED) != 0 &&
	strcmp(strval, ZFS_FEATURE_DISABLED) != 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"property '%s' can only be set to "
	"'enabled' or 'disabled'"), propname);
	(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
	goto error;
	}

	if (!flags.create &&
	strcmp(strval, ZFS_FEATURE_DISABLED) == 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"property '%s' can only be set to "
	"'disabled' at creation time"), propname);
	(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
	goto error;
	}

	if (nvlist_add_uint64(retprops, propname, 0) != 0) {
	(void) no_memory(hdl);
	goto error;
	}
	continue;
	}

	/*
	* Make sure this property is valid and applies to this type.
	*/
	if (prop == ZPOOL_PROP_INVAL) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"invalid property '%s'"), propname);
	(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
	goto error;
	}

	if (zpool_prop_readonly(prop)) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "'%s' "
	"is readonly"), propname);
	(void) zfs_error(hdl, EZFS_PROPREADONLY, errbuf);
	goto error;
	}

	if (!flags.create && zpool_prop_setonce(prop)) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"property '%s' can only be set at "
	"creation time"), propname);
	(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
	goto error;
	}

	if (zprop_parse_value(hdl, elem, prop, ZFS_TYPE_POOL, retprops,
	&strval, &intval, errbuf) != 0)
	goto error;

	/*
	* Perform additional checking for specific properties.
	*/
	switch (prop) {
	case ZPOOL_PROP_VERSION:
	if (intval < version \|\|
	!SPA_VERSION_IS_SUPPORTED(intval)) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"property '%s' number %d is invalid."),
	propname, intval);
	(void) zfs_error(hdl, EZFS_BADVERSION, errbuf);
	goto error;
	}
	break;

	case ZPOOL_PROP_ASHIFT:
	if (intval != 0 &&
	(intval < ASHIFT_MIN \|\| intval > ASHIFT_MAX)) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"property '%s' number %d is invalid, only "
	"values between %" PRId32 " and "
	"%" PRId32 " are allowed."),
	propname, intval, ASHIFT_MIN, ASHIFT_MAX);
	(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
	goto error;
	}
	break;

	case ZPOOL_PROP_BOOTFS:
	if (flags.create \|\| flags.import) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"property '%s' cannot be set at creation "
	"or import time"), propname);
	(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
	goto error;
	}

	if (version < SPA_VERSION_BOOTFS) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"pool must be upgraded to support "
	"'%s' property"), propname);
	(void) zfs_error(hdl, EZFS_BADVERSION, errbuf);
	goto error;
	}

	/*
	* bootfs property value has to be a dataset name and
	* the dataset has to be in the same pool as it sets to.
	*/
	if (!bootfs_name_valid(poolname, strval)) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "'%s' "
	"is an invalid name"), strval);
	(void) zfs_error(hdl, EZFS_INVALIDNAME, errbuf);
	goto error;
	}

	if ((zhp = zpool_open_canfail(hdl, poolname)) == NULL) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"could not open pool '%s'"), poolname);
	(void) zfs_error(hdl, EZFS_OPENFAILED, errbuf);
	goto error;
	}
	zpool_close(zhp);
	break;

	case ZPOOL_PROP_ALTROOT:
	if (!flags.create && !flags.import) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"property '%s' can only be set during pool "
	"creation or import"), propname);
	(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
	goto error;
	}

	if (strval[0] != '/') {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"bad alternate root '%s'"), strval);
	(void) zfs_error(hdl, EZFS_BADPATH, errbuf);
	goto error;
	}
	break;

	case ZPOOL_PROP_CACHEFILE:
	if (strval[0] == '\0')
	break;

	if (strcmp(strval, "none") == 0)
	break;

	if (strval[0] != '/') {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"property '%s' must be empty, an "
	"absolute path, or 'none'"), propname);
	(void) zfs_error(hdl, EZFS_BADPATH, errbuf);
	goto error;
	}

	slash = strrchr(strval, '/');

	if (slash[1] == '\0' \|\| strcmp(slash, "/.") == 0 \|\|
	strcmp(slash, "/..") == 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"'%s' is not a valid file"), strval);
	(void) zfs_error(hdl, EZFS_BADPATH, errbuf);
	goto error;
	}

	*slash = '\0';

	if (strval[0] != '\0' &&
	(stat64(strval, &statbuf) != 0 \|\|
	!S_ISDIR(statbuf.st_mode))) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"'%s' is not a valid directory"),
	strval);
	(void) zfs_error(hdl, EZFS_BADPATH, errbuf);
	goto error;
	}

	*slash = '/';
	break;

	case ZPOOL_PROP_COMPATIBILITY:
	- switch (zpool_load_compat(strval, NULL,
	- badword, badfile)) {
	+ switch (zpool_load_compat(strval, NULL, report, 1024)) {
	case ZPOOL_COMPATIBILITY_OK:
	+ case ZPOOL_COMPATIBILITY_WARNTOKEN:
	break;
	- case ZPOOL_COMPATIBILITY_READERR:
	- zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	- "error reading feature file '%s'"),
	- badfile);
	- (void) zfs_error(hdl, EZFS_BADPROP, errbuf);
	- goto error;
	case ZPOOL_COMPATIBILITY_BADFILE:
	- zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	- "feature file '%s' too large or not "
	- "newline-terminated"),
	- badfile);
	- (void) zfs_error(hdl, EZFS_BADPROP, errbuf);
	- goto error;
	- case ZPOOL_COMPATIBILITY_BADWORD:
	- zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	- "unknown feature '%s' in feature "
	- "file '%s'"),
	- badword, badfile);
	- (void) zfs_error(hdl, EZFS_BADPROP, errbuf);
	- goto error;
	+ case ZPOOL_COMPATIBILITY_BADTOKEN:
	case ZPOOL_COMPATIBILITY_NOFILES:
	- zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	- "no feature files specified"));
	+ zfs_error_aux(hdl, report);
	(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
	goto error;
	}
	break;

	case ZPOOL_PROP_COMMENT:
	for (check = strval; *check != '\0'; check++) {
	if (!isprint(*check)) {
	zfs_error_aux(hdl,
	dgettext(TEXT_DOMAIN,
	"comment may only have printable "
	"characters"));
	(void) zfs_error(hdl, EZFS_BADPROP,
	errbuf);
	goto error;
	}
	}
	if (strlen(strval) > ZPROP_MAX_COMMENT) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"comment must not exceed %d characters"),
	ZPROP_MAX_COMMENT);
	(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
	goto error;
	}
	break;
	case ZPOOL_PROP_READONLY:
	if (!flags.import) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"property '%s' can only be set at "
	"import time"), propname);
	(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
	goto error;
	}
	break;
	case ZPOOL_PROP_MULTIHOST:
	if (get_system_hostid() == 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"requires a non-zero system hostid"));
	(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
	goto error;
	}
	break;
	case ZPOOL_PROP_DEDUPDITTO:
	printf("Note: property '%s' no longer has "
	"any effect\n", propname);
	break;

	default:
	break;
	}
	}

	return (retprops);
	error:
	nvlist_free(retprops);
	return (NULL);
	}

	/*
	* Set zpool property : propname=propval.
	*/
	int
	zpool_set_prop(zpool_handle_t zhp, const char propname, const char *propval)
	{
	zfs_cmd_t zc = {"\0"};
	int ret = -1;
	char errbuf[1024];
	nvlist_t *nvl = NULL;
	nvlist_t *realprops;
	uint64_t version;
	prop_flags_t flags = { 0 };

	(void) snprintf(errbuf, sizeof (errbuf),
	dgettext(TEXT_DOMAIN, "cannot set property for '%s'"),
	zhp->zpool_name);

	if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0) != 0)
	return (no_memory(zhp->zpool_hdl));

	if (nvlist_add_string(nvl, propname, propval) != 0) {
	nvlist_free(nvl);
	return (no_memory(zhp->zpool_hdl));
	}

	version = zpool_get_prop_int(zhp, ZPOOL_PROP_VERSION, NULL);
	if ((realprops = zpool_valid_proplist(zhp->zpool_hdl,
	zhp->zpool_name, nvl, version, flags, errbuf)) == NULL) {
	nvlist_free(nvl);
	return (-1);
	}

	nvlist_free(nvl);
	nvl = realprops;

	/*
	* Execute the corresponding ioctl() to set this property.
	*/
	(void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));

	if (zcmd_write_src_nvlist(zhp->zpool_hdl, &zc, nvl) != 0) {
	nvlist_free(nvl);
	return (-1);
	}

	ret = zfs_ioctl(zhp->zpool_hdl, ZFS_IOC_POOL_SET_PROPS, &zc);

	zcmd_free_nvlists(&zc);
	nvlist_free(nvl);

	if (ret)
	(void) zpool_standard_error(zhp->zpool_hdl, errno, errbuf);
	else
	(void) zpool_props_refresh(zhp);

	return (ret);
	}

	int
	zpool_expand_proplist(zpool_handle_t zhp, zprop_list_t *plp,
	boolean_t literal)
	{
	libzfs_handle_t *hdl = zhp->zpool_hdl;
	zprop_list_t *entry;
	char buf[ZFS_MAXPROPLEN];
	nvlist_t *features = NULL;
	nvpair_t *nvp;
	zprop_list_t **last;
	boolean_t firstexpand = (NULL == *plp);
	int i;

	if (zprop_expand_list(hdl, plp, ZFS_TYPE_POOL) != 0)
	return (-1);

	last = plp;
	while (*last != NULL)
	last = &(*last)->pl_next;

	if ((*plp)->pl_all)
	features = zpool_get_features(zhp);

	if ((*plp)->pl_all && firstexpand) {
	for (i = 0; i < SPA_FEATURES; i++) {
	zprop_list_t *entry = zfs_alloc(hdl,
	sizeof (zprop_list_t));
	entry->pl_prop = ZPROP_INVAL;
	entry->pl_user_prop = zfs_asprintf(hdl, "feature@%s",
	spa_feature_table[i].fi_uname);
	entry->pl_width = strlen(entry->pl_user_prop);
	entry->pl_all = B_TRUE;

	*last = entry;
	last = &entry->pl_next;
	}
	}

	/* add any unsupported features */
	for (nvp = nvlist_next_nvpair(features, NULL);
	nvp != NULL; nvp = nvlist_next_nvpair(features, nvp)) {
	char *propname;
	boolean_t found;
	zprop_list_t *entry;

	if (zfeature_is_supported(nvpair_name(nvp)))
	continue;

	propname = zfs_asprintf(hdl, "unsupported@%s",
	nvpair_name(nvp));

	/*
	* Before adding the property to the list make sure that no
	* other pool already added the same property.
	*/
	found = B_FALSE;
	entry = *plp;
	while (entry != NULL) {
	if (entry->pl_user_prop != NULL &&
	strcmp(propname, entry->pl_user_prop) == 0) {
	found = B_TRUE;
	break;
	}
	entry = entry->pl_next;
	}
	if (found) {
	free(propname);
	continue;
	}

	entry = zfs_alloc(hdl, sizeof (zprop_list_t));
	entry->pl_prop = ZPROP_INVAL;
	entry->pl_user_prop = propname;
	entry->pl_width = strlen(entry->pl_user_prop);
	entry->pl_all = B_TRUE;

	*last = entry;
	last = &entry->pl_next;
	}

	for (entry = *plp; entry != NULL; entry = entry->pl_next) {
	if (entry->pl_fixed && !literal)
	continue;

	if (entry->pl_prop != ZPROP_INVAL &&
	zpool_get_prop(zhp, entry->pl_prop, buf, sizeof (buf),
	NULL, literal) == 0) {
	if (strlen(buf) > entry->pl_width)
	entry->pl_width = strlen(buf);
	}
	}

	return (0);
	}

	/*
	* Get the state for the given feature on the given ZFS pool.
	*/
	int
	zpool_prop_get_feature(zpool_handle_t zhp, const char propname, char *buf,
	size_t len)
	{
	uint64_t refcount;
	boolean_t found = B_FALSE;
	nvlist_t *features = zpool_get_features(zhp);
	boolean_t supported;
	const char *feature = strchr(propname, '@') + 1;

	supported = zpool_prop_feature(propname);
	ASSERT(supported \|\| zpool_prop_unsupported(propname));

	/*
	* Convert from feature name to feature guid. This conversion is
	* unnecessary for unsupported@... properties because they already
	* use guids.
	*/
	if (supported) {
	int ret;
	spa_feature_t fid;

	ret = zfeature_lookup_name(feature, &fid);
	if (ret != 0) {
	(void) strlcpy(buf, "-", len);
	return (ENOTSUP);
	}
	feature = spa_feature_table[fid].fi_guid;
	}

	if (nvlist_lookup_uint64(features, feature, &refcount) == 0)
	found = B_TRUE;

	if (supported) {
	if (!found) {
	(void) strlcpy(buf, ZFS_FEATURE_DISABLED, len);
	} else {
	if (refcount == 0)
	(void) strlcpy(buf, ZFS_FEATURE_ENABLED, len);
	else
	(void) strlcpy(buf, ZFS_FEATURE_ACTIVE, len);
	}
	} else {
	if (found) {
	if (refcount == 0) {
	(void) strcpy(buf, ZFS_UNSUPPORTED_INACTIVE);
	} else {
	(void) strcpy(buf, ZFS_UNSUPPORTED_READONLY);
	}
	} else {
	(void) strlcpy(buf, "-", len);
	return (ENOTSUP);
	}
	}

	return (0);
	}

	/*
	* Validate the given pool name, optionally putting an extended error message in
	* 'buf'.
	*/
	boolean_t
	zpool_name_valid(libzfs_handle_t hdl, boolean_t isopen, const char pool)
	{
	namecheck_err_t why;
	char what;
	int ret;

	ret = pool_namecheck(pool, &why, &what);

	/*
	* The rules for reserved pool names were extended at a later point.
	* But we need to support users with existing pools that may now be
	* invalid. So we only check for this expanded set of names during a
	* create (or import), and only in userland.
	*/
	if (ret == 0 && !isopen &&
	(strncmp(pool, "mirror", 6) == 0 \|\|
	strncmp(pool, "raidz", 5) == 0 \|\|
	strncmp(pool, "draid", 5) == 0 \|\|
	strncmp(pool, "spare", 5) == 0 \|\|
	strcmp(pool, "log") == 0)) {
	if (hdl != NULL)
	zfs_error_aux(hdl,
	dgettext(TEXT_DOMAIN, "name is reserved"));
	return (B_FALSE);
	}


	if (ret != 0) {
	if (hdl != NULL) {
	switch (why) {
	case NAME_ERR_TOOLONG:
	zfs_error_aux(hdl,
	dgettext(TEXT_DOMAIN, "name is too long"));
	break;

	case NAME_ERR_INVALCHAR:
	zfs_error_aux(hdl,
	dgettext(TEXT_DOMAIN, "invalid character "
	"'%c' in pool name"), what);
	break;

	case NAME_ERR_NOLETTER:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"name must begin with a letter"));
	break;

	case NAME_ERR_RESERVED:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"name is reserved"));
	break;

	case NAME_ERR_DISKLIKE:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"pool name is reserved"));
	break;

	case NAME_ERR_LEADING_SLASH:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"leading slash in name"));
	break;

	case NAME_ERR_EMPTY_COMPONENT:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"empty component in name"));
	break;

	case NAME_ERR_TRAILING_SLASH:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"trailing slash in name"));
	break;

	case NAME_ERR_MULTIPLE_DELIMITERS:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"multiple '@' and/or '#' delimiters in "
	"name"));
	break;

	case NAME_ERR_NO_AT:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"permission set is missing '@'"));
	break;

	default:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"(%d) not defined"), why);
	break;
	}
	}
	return (B_FALSE);
	}

	return (B_TRUE);
	}

	/*
	* Open a handle to the given pool, even if the pool is currently in the FAULTED
	* state.
	*/
	zpool_handle_t *
	zpool_open_canfail(libzfs_handle_t hdl, const char pool)
	{
	zpool_handle_t *zhp;
	boolean_t missing;

	/*
	* Make sure the pool name is valid.
	*/
	if (!zpool_name_valid(hdl, B_TRUE, pool)) {
	(void) zfs_error_fmt(hdl, EZFS_INVALIDNAME,
	dgettext(TEXT_DOMAIN, "cannot open '%s'"),
	pool);
	return (NULL);
	}

	if ((zhp = zfs_alloc(hdl, sizeof (zpool_handle_t))) == NULL)
	return (NULL);

	zhp->zpool_hdl = hdl;
	(void) strlcpy(zhp->zpool_name, pool, sizeof (zhp->zpool_name));

	if (zpool_refresh_stats(zhp, &missing) != 0) {
	zpool_close(zhp);
	return (NULL);
	}

	if (missing) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "no such pool"));
	(void) zfs_error_fmt(hdl, EZFS_NOENT,
	dgettext(TEXT_DOMAIN, "cannot open '%s'"), pool);
	zpool_close(zhp);
	return (NULL);
	}

	return (zhp);
	}

	/*
	* Like the above, but silent on error. Used when iterating over pools (because
	* the configuration cache may be out of date).
	*/
	int
	zpool_open_silent(libzfs_handle_t hdl, const char pool, zpool_handle_t **ret)
	{
	zpool_handle_t *zhp;
	boolean_t missing;

	if ((zhp = zfs_alloc(hdl, sizeof (zpool_handle_t))) == NULL)
	return (-1);

	zhp->zpool_hdl = hdl;
	(void) strlcpy(zhp->zpool_name, pool, sizeof (zhp->zpool_name));

	if (zpool_refresh_stats(zhp, &missing) != 0) {
	zpool_close(zhp);
	return (-1);
	}

	if (missing) {
	zpool_close(zhp);
	*ret = NULL;
	return (0);
	}

	*ret = zhp;
	return (0);
	}

	/*
	* Similar to zpool_open_canfail(), but refuses to open pools in the faulted
	* state.
	*/
	zpool_handle_t *
	zpool_open(libzfs_handle_t hdl, const char pool)
	{
	zpool_handle_t *zhp;

	if ((zhp = zpool_open_canfail(hdl, pool)) == NULL)
	return (NULL);

	if (zhp->zpool_state == POOL_STATE_UNAVAIL) {
	(void) zfs_error_fmt(hdl, EZFS_POOLUNAVAIL,
	dgettext(TEXT_DOMAIN, "cannot open '%s'"), zhp->zpool_name);
	zpool_close(zhp);
	return (NULL);
	}

	return (zhp);
	}

	/*
	* Close the handle. Simply frees the memory associated with the handle.
	*/
	void
	zpool_close(zpool_handle_t *zhp)
	{
	nvlist_free(zhp->zpool_config);
	nvlist_free(zhp->zpool_old_config);
	nvlist_free(zhp->zpool_props);
	free(zhp);
	}

	/*
	* Return the name of the pool.
	*/
	const char *
	zpool_get_name(zpool_handle_t *zhp)
	{
	return (zhp->zpool_name);
	}


	/*
	* Return the state of the pool (ACTIVE or UNAVAILABLE)
	*/
	int
	zpool_get_state(zpool_handle_t *zhp)
	{
	return (zhp->zpool_state);
	}

	/*
	* Check if vdev list contains a special vdev
	*/
	static boolean_t
	zpool_has_special_vdev(nvlist_t *nvroot)
	{
	nvlist_t **child;
	uint_t children;

	if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN, &child,
	&children) == 0) {
	for (uint_t c = 0; c < children; c++) {
	char *bias;

	if (nvlist_lookup_string(child[c],
	ZPOOL_CONFIG_ALLOCATION_BIAS, &bias) == 0 &&
	strcmp(bias, VDEV_ALLOC_BIAS_SPECIAL) == 0) {
	return (B_TRUE);
	}
	}
	}
	return (B_FALSE);
	}

	/*
	* Check if vdev list contains a dRAID vdev
	*/
	static boolean_t
	zpool_has_draid_vdev(nvlist_t *nvroot)
	{
	nvlist_t **child;
	uint_t children;

	if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN,
	&child, &children) == 0) {
	for (uint_t c = 0; c < children; c++) {
	char *type;

	if (nvlist_lookup_string(child[c],
	ZPOOL_CONFIG_TYPE, &type) == 0 &&
	strcmp(type, VDEV_TYPE_DRAID) == 0) {
	return (B_TRUE);
	}
	}
	}
	return (B_FALSE);
	}

	/*
	* Output a dRAID top-level vdev name in to the provided buffer.
	*/
	static char *
	zpool_draid_name(char *name, int len, uint64_t data, uint64_t parity,
	uint64_t spares, uint64_t children)
	{
	snprintf(name, len, "%s%llu:%llud:%lluc:%llus",
	VDEV_TYPE_DRAID, (u_longlong_t)parity, (u_longlong_t)data,
	(u_longlong_t)children, (u_longlong_t)spares);

	return (name);
	}

	/*
	* Return B_TRUE if the provided name is a dRAID spare name.
	*/
	boolean_t
	zpool_is_draid_spare(const char *name)
	{
	uint64_t spare_id, parity, vdev_id;

	if (sscanf(name, VDEV_TYPE_DRAID "%llu-%llu-%llu",
	(u_longlong_t )&parity, (u_longlong_t )&vdev_id,
	(u_longlong_t *)&spare_id) == 3) {
	return (B_TRUE);
	}

	return (B_FALSE);
	}

	/*
	* Create the named pool, using the provided vdev list. It is assumed
	* that the consumer has already validated the contents of the nvlist, so we
	* don't have to worry about error semantics.
	*/
	int
	zpool_create(libzfs_handle_t hdl, const char pool, nvlist_t *nvroot,
	nvlist_t props, nvlist_t fsprops)
	{
	zfs_cmd_t zc = {"\0"};
	nvlist_t *zc_fsprops = NULL;
	nvlist_t *zc_props = NULL;
	nvlist_t *hidden_args = NULL;
	uint8_t *wkeydata = NULL;
	uint_t wkeylen = 0;
	char msg[1024];
	int ret = -1;

	(void) snprintf(msg, sizeof (msg), dgettext(TEXT_DOMAIN,
	"cannot create '%s'"), pool);

	if (!zpool_name_valid(hdl, B_FALSE, pool))
	return (zfs_error(hdl, EZFS_INVALIDNAME, msg));

	if (zcmd_write_conf_nvlist(hdl, &zc, nvroot) != 0)
	return (-1);

	if (props) {
	prop_flags_t flags = { .create = B_TRUE, .import = B_FALSE };

	if ((zc_props = zpool_valid_proplist(hdl, pool, props,
	SPA_VERSION_1, flags, msg)) == NULL) {
	goto create_failed;
	}
	}

	if (fsprops) {
	uint64_t zoned;
	char *zonestr;

	zoned = ((nvlist_lookup_string(fsprops,
	zfs_prop_to_name(ZFS_PROP_ZONED), &zonestr) == 0) &&
	strcmp(zonestr, "on") == 0);

	if ((zc_fsprops = zfs_valid_proplist(hdl, ZFS_TYPE_FILESYSTEM,
	fsprops, zoned, NULL, NULL, B_TRUE, msg)) == NULL) {
	goto create_failed;
	}

	if (nvlist_exists(zc_fsprops,
	zfs_prop_to_name(ZFS_PROP_SPECIAL_SMALL_BLOCKS)) &&
	!zpool_has_special_vdev(nvroot)) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"%s property requires a special vdev"),
	zfs_prop_to_name(ZFS_PROP_SPECIAL_SMALL_BLOCKS));
	(void) zfs_error(hdl, EZFS_BADPROP, msg);
	goto create_failed;
	}

	if (!zc_props &&
	(nvlist_alloc(&zc_props, NV_UNIQUE_NAME, 0) != 0)) {
	goto create_failed;
	}
	if (zfs_crypto_create(hdl, NULL, zc_fsprops, props, B_TRUE,
	&wkeydata, &wkeylen) != 0) {
	zfs_error(hdl, EZFS_CRYPTOFAILED, msg);
	goto create_failed;
	}
	if (nvlist_add_nvlist(zc_props,
	ZPOOL_ROOTFS_PROPS, zc_fsprops) != 0) {
	goto create_failed;
	}
	if (wkeydata != NULL) {
	if (nvlist_alloc(&hidden_args, NV_UNIQUE_NAME, 0) != 0)
	goto create_failed;

	if (nvlist_add_uint8_array(hidden_args, "wkeydata",
	wkeydata, wkeylen) != 0)
	goto create_failed;

	if (nvlist_add_nvlist(zc_props, ZPOOL_HIDDEN_ARGS,
	hidden_args) != 0)
	goto create_failed;
	}
	}

	if (zc_props && zcmd_write_src_nvlist(hdl, &zc, zc_props) != 0)
	goto create_failed;

	(void) strlcpy(zc.zc_name, pool, sizeof (zc.zc_name));

	if ((ret = zfs_ioctl(hdl, ZFS_IOC_POOL_CREATE, &zc)) != 0) {

	zcmd_free_nvlists(&zc);
	nvlist_free(zc_props);
	nvlist_free(zc_fsprops);
	nvlist_free(hidden_args);
	if (wkeydata != NULL)
	free(wkeydata);

	switch (errno) {
	case EBUSY:
	/*
	* This can happen if the user has specified the same
	* device multiple times. We can't reliably detect this
	* until we try to add it and see we already have a
	* label. This can also happen under if the device is
	* part of an active md or lvm device.
	*/
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"one or more vdevs refer to the same device, or "
	"one of\nthe devices is part of an active md or "
	"lvm device"));
	return (zfs_error(hdl, EZFS_BADDEV, msg));

	case ERANGE:
	/*
	* This happens if the record size is smaller or larger
	* than the allowed size range, or not a power of 2.
	*
	* NOTE: although zfs_valid_proplist is called earlier,
	* this case may have slipped through since the
	* pool does not exist yet and it is therefore
	* impossible to read properties e.g. max blocksize
	* from the pool.
	*/
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"record size invalid"));
	return (zfs_error(hdl, EZFS_BADPROP, msg));

	case EOVERFLOW:
	/*
	* This occurs when one of the devices is below
	* SPA_MINDEVSIZE. Unfortunately, we can't detect which
	* device was the problem device since there's no
	* reliable way to determine device size from userland.
	*/
	{
	char buf[64];

	zfs_nicebytes(SPA_MINDEVSIZE, buf,
	sizeof (buf));

	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"one or more devices is less than the "
	"minimum size (%s)"), buf);
	}
	return (zfs_error(hdl, EZFS_BADDEV, msg));

	case ENOSPC:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"one or more devices is out of space"));
	return (zfs_error(hdl, EZFS_BADDEV, msg));

	case EINVAL:
	if (zpool_has_draid_vdev(nvroot) &&
	zfeature_lookup_name("draid", NULL) != 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"dRAID vdevs are unsupported by the "
	"kernel"));
	return (zfs_error(hdl, EZFS_BADDEV, msg));
	} else {
	return (zpool_standard_error(hdl, errno, msg));
	}

	default:
	return (zpool_standard_error(hdl, errno, msg));
	}
	}

	create_failed:
	zcmd_free_nvlists(&zc);
	nvlist_free(zc_props);
	nvlist_free(zc_fsprops);
	nvlist_free(hidden_args);
	if (wkeydata != NULL)
	free(wkeydata);
	return (ret);
	}

	/*
	* Destroy the given pool. It is up to the caller to ensure that there are no
	* datasets left in the pool.
	*/
	int
	zpool_destroy(zpool_handle_t zhp, const char log_str)
	{
	zfs_cmd_t zc = {"\0"};
	zfs_handle_t *zfp = NULL;
	libzfs_handle_t *hdl = zhp->zpool_hdl;
	char msg[1024];

	if (zhp->zpool_state == POOL_STATE_ACTIVE &&
	(zfp = zfs_open(hdl, zhp->zpool_name, ZFS_TYPE_FILESYSTEM)) == NULL)
	return (-1);

	(void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
	zc.zc_history = (uint64_t)(uintptr_t)log_str;

	if (zfs_ioctl(hdl, ZFS_IOC_POOL_DESTROY, &zc) != 0) {
	(void) snprintf(msg, sizeof (msg), dgettext(TEXT_DOMAIN,
	"cannot destroy '%s'"), zhp->zpool_name);

	if (errno == EROFS) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"one or more devices is read only"));
	(void) zfs_error(hdl, EZFS_BADDEV, msg);
	} else {
	(void) zpool_standard_error(hdl, errno, msg);
	}

	if (zfp)
	zfs_close(zfp);
	return (-1);
	}

	if (zfp) {
	remove_mountpoint(zfp);
	zfs_close(zfp);
	}

	return (0);
	}

	/*
	* Create a checkpoint in the given pool.
	*/
	int
	zpool_checkpoint(zpool_handle_t *zhp)
	{
	libzfs_handle_t *hdl = zhp->zpool_hdl;
	char msg[1024];
	int error;

	error = lzc_pool_checkpoint(zhp->zpool_name);
	if (error != 0) {
	(void) snprintf(msg, sizeof (msg), dgettext(TEXT_DOMAIN,
	"cannot checkpoint '%s'"), zhp->zpool_name);
	(void) zpool_standard_error(hdl, error, msg);
	return (-1);
	}

	return (0);
	}

	/*
	* Discard the checkpoint from the given pool.
	*/
	int
	zpool_discard_checkpoint(zpool_handle_t *zhp)
	{
	libzfs_handle_t *hdl = zhp->zpool_hdl;
	char msg[1024];
	int error;

	error = lzc_pool_checkpoint_discard(zhp->zpool_name);
	if (error != 0) {
	(void) snprintf(msg, sizeof (msg), dgettext(TEXT_DOMAIN,
	"cannot discard checkpoint in '%s'"), zhp->zpool_name);
	(void) zpool_standard_error(hdl, error, msg);
	return (-1);
	}

	return (0);
	}

	/*
	* Add the given vdevs to the pool. The caller must have already performed the
	* necessary verification to ensure that the vdev specification is well-formed.
	*/
	int
	zpool_add(zpool_handle_t zhp, nvlist_t nvroot)
	{
	zfs_cmd_t zc = {"\0"};
	int ret;
	libzfs_handle_t *hdl = zhp->zpool_hdl;
	char msg[1024];
	nvlist_t spares, l2cache;
	uint_t nspares, nl2cache;

	(void) snprintf(msg, sizeof (msg), dgettext(TEXT_DOMAIN,
	"cannot add to '%s'"), zhp->zpool_name);

	if (zpool_get_prop_int(zhp, ZPOOL_PROP_VERSION, NULL) <
	SPA_VERSION_SPARES &&
	nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES,
	&spares, &nspares) == 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "pool must be "
	"upgraded to add hot spares"));
	return (zfs_error(hdl, EZFS_BADVERSION, msg));
	}

	if (zpool_get_prop_int(zhp, ZPOOL_PROP_VERSION, NULL) <
	SPA_VERSION_L2CACHE &&
	nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE,
	&l2cache, &nl2cache) == 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "pool must be "
	"upgraded to add cache devices"));
	return (zfs_error(hdl, EZFS_BADVERSION, msg));
	}

	if (zcmd_write_conf_nvlist(hdl, &zc, nvroot) != 0)
	return (-1);
	(void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));

	if (zfs_ioctl(hdl, ZFS_IOC_VDEV_ADD, &zc) != 0) {
	switch (errno) {
	case EBUSY:
	/*
	* This can happen if the user has specified the same
	* device multiple times. We can't reliably detect this
	* until we try to add it and see we already have a
	* label.
	*/
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"one or more vdevs refer to the same device"));
	(void) zfs_error(hdl, EZFS_BADDEV, msg);
	break;

	case EINVAL:

	if (zpool_has_draid_vdev(nvroot) &&
	zfeature_lookup_name("draid", NULL) != 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"dRAID vdevs are unsupported by the "
	"kernel"));
	} else {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"invalid config; a pool with removing/"
	"removed vdevs does not support adding "
	"raidz or dRAID vdevs"));
	}

	(void) zfs_error(hdl, EZFS_BADDEV, msg);
	break;

	case EOVERFLOW:
	/*
	* This occurs when one of the devices is below
	* SPA_MINDEVSIZE. Unfortunately, we can't detect which
	* device was the problem device since there's no
	* reliable way to determine device size from userland.
	*/
	{
	char buf[64];

	zfs_nicebytes(SPA_MINDEVSIZE, buf,
	sizeof (buf));

	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"device is less than the minimum "
	"size (%s)"), buf);
	}
	(void) zfs_error(hdl, EZFS_BADDEV, msg);
	break;

	case ENOTSUP:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"pool must be upgraded to add these vdevs"));
	(void) zfs_error(hdl, EZFS_BADVERSION, msg);
	break;

	default:
	(void) zpool_standard_error(hdl, errno, msg);
	}

	ret = -1;
	} else {
	ret = 0;
	}

	zcmd_free_nvlists(&zc);

	return (ret);
	}

	/*
	* Exports the pool from the system. The caller must ensure that there are no
	* mounted datasets in the pool.
	*/
	static int
	zpool_export_common(zpool_handle_t *zhp, boolean_t force, boolean_t hardforce,
	const char *log_str)
	{
	zfs_cmd_t zc = {"\0"};
	char msg[1024];

	(void) snprintf(msg, sizeof (msg), dgettext(TEXT_DOMAIN,
	"cannot export '%s'"), zhp->zpool_name);

	(void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
	zc.zc_cookie = force;
	zc.zc_guid = hardforce;
	zc.zc_history = (uint64_t)(uintptr_t)log_str;

	if (zfs_ioctl(zhp->zpool_hdl, ZFS_IOC_POOL_EXPORT, &zc) != 0) {
	switch (errno) {
	case EXDEV:
	zfs_error_aux(zhp->zpool_hdl, dgettext(TEXT_DOMAIN,
	"use '-f' to override the following errors:\n"
	"'%s' has an active shared spare which could be"
	" used by other pools once '%s' is exported."),
	zhp->zpool_name, zhp->zpool_name);
	return (zfs_error(zhp->zpool_hdl, EZFS_ACTIVE_SPARE,
	msg));
	default:
	return (zpool_standard_error_fmt(zhp->zpool_hdl, errno,
	msg));
	}
	}

	return (0);
	}

	int
	zpool_export(zpool_handle_t zhp, boolean_t force, const char log_str)
	{
	return (zpool_export_common(zhp, force, B_FALSE, log_str));
	}

	int
	zpool_export_force(zpool_handle_t zhp, const char log_str)
	{
	return (zpool_export_common(zhp, B_TRUE, B_TRUE, log_str));
	}

	static void
	zpool_rewind_exclaim(libzfs_handle_t hdl, const char name, boolean_t dryrun,
	nvlist_t *config)
	{
	nvlist_t *nv = NULL;
	uint64_t rewindto;
	int64_t loss = -1;
	struct tm t;
	char timestr[128];

	if (!hdl->libzfs_printerr \|\| config == NULL)
	return;

	if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_LOAD_INFO, &nv) != 0 \|\|
	nvlist_lookup_nvlist(nv, ZPOOL_CONFIG_REWIND_INFO, &nv) != 0) {
	return;
	}

	if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_LOAD_TIME, &rewindto) != 0)
	return;
	(void) nvlist_lookup_int64(nv, ZPOOL_CONFIG_REWIND_TIME, &loss);

	if (localtime_r((time_t *)&rewindto, &t) != NULL &&
	strftime(timestr, 128, "%c", &t) != 0) {
	if (dryrun) {
	(void) printf(dgettext(TEXT_DOMAIN,
	"Would be able to return %s "
	"to its state as of %s.\n"),
	name, timestr);
	} else {
	(void) printf(dgettext(TEXT_DOMAIN,
	"Pool %s returned to its state as of %s.\n"),
	name, timestr);
	}
	if (loss > 120) {
	(void) printf(dgettext(TEXT_DOMAIN,
	"%s approximately %lld "),
	dryrun ? "Would discard" : "Discarded",
	((longlong_t)loss + 30) / 60);
	(void) printf(dgettext(TEXT_DOMAIN,
	"minutes of transactions.\n"));
	} else if (loss > 0) {
	(void) printf(dgettext(TEXT_DOMAIN,
	"%s approximately %lld "),
	dryrun ? "Would discard" : "Discarded",
	(longlong_t)loss);
	(void) printf(dgettext(TEXT_DOMAIN,
	"seconds of transactions.\n"));
	}
	}
	}

	void
	zpool_explain_recover(libzfs_handle_t hdl, const char name, int reason,
	nvlist_t *config)
	{
	nvlist_t *nv = NULL;
	int64_t loss = -1;
	uint64_t edata = UINT64_MAX;
	uint64_t rewindto;
	struct tm t;
	char timestr[128];

	if (!hdl->libzfs_printerr)
	return;

	if (reason >= 0)
	(void) printf(dgettext(TEXT_DOMAIN, "action: "));
	else
	(void) printf(dgettext(TEXT_DOMAIN, "\t"));

	/* All attempted rewinds failed if ZPOOL_CONFIG_LOAD_TIME missing */
	if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_LOAD_INFO, &nv) != 0 \|\|
	nvlist_lookup_nvlist(nv, ZPOOL_CONFIG_REWIND_INFO, &nv) != 0 \|\|
	nvlist_lookup_uint64(nv, ZPOOL_CONFIG_LOAD_TIME, &rewindto) != 0)
	goto no_info;

	(void) nvlist_lookup_int64(nv, ZPOOL_CONFIG_REWIND_TIME, &loss);
	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_LOAD_DATA_ERRORS,
	&edata);

	(void) printf(dgettext(TEXT_DOMAIN,
	"Recovery is possible, but will result in some data loss.\n"));

	if (localtime_r((time_t *)&rewindto, &t) != NULL &&
	strftime(timestr, 128, "%c", &t) != 0) {
	(void) printf(dgettext(TEXT_DOMAIN,
	"\tReturning the pool to its state as of %s\n"
	"\tshould correct the problem. "),
	timestr);
	} else {
	(void) printf(dgettext(TEXT_DOMAIN,
	"\tReverting the pool to an earlier state "
	"should correct the problem.\n\t"));
	}

	if (loss > 120) {
	(void) printf(dgettext(TEXT_DOMAIN,
	"Approximately %lld minutes of data\n"
	"\tmust be discarded, irreversibly. "),
	((longlong_t)loss + 30) / 60);
	} else if (loss > 0) {
	(void) printf(dgettext(TEXT_DOMAIN,
	"Approximately %lld seconds of data\n"
	"\tmust be discarded, irreversibly. "),
	(longlong_t)loss);
	}
	if (edata != 0 && edata != UINT64_MAX) {
	if (edata == 1) {
	(void) printf(dgettext(TEXT_DOMAIN,
	"After rewind, at least\n"
	"\tone persistent user-data error will remain. "));
	} else {
	(void) printf(dgettext(TEXT_DOMAIN,
	"After rewind, several\n"
	"\tpersistent user-data errors will remain. "));
	}
	}
	(void) printf(dgettext(TEXT_DOMAIN,
	"Recovery can be attempted\n\tby executing 'zpool %s -F %s'. "),
	reason >= 0 ? "clear" : "import", name);

	(void) printf(dgettext(TEXT_DOMAIN,
	"A scrub of the pool\n"
	"\tis strongly recommended after recovery.\n"));
	return;

	no_info:
	(void) printf(dgettext(TEXT_DOMAIN,
	"Destroy and re-create the pool from\n\ta backup source.\n"));
	}

	/*
	* zpool_import() is a contracted interface. Should be kept the same
	* if possible.
	*
	* Applications should use zpool_import_props() to import a pool with
	* new properties value to be set.
	*/
	int
	zpool_import(libzfs_handle_t hdl, nvlist_t config, const char *newname,
	char *altroot)
	{
	nvlist_t *props = NULL;
	int ret;

	if (altroot != NULL) {
	if (nvlist_alloc(&props, NV_UNIQUE_NAME, 0) != 0) {
	return (zfs_error_fmt(hdl, EZFS_NOMEM,
	dgettext(TEXT_DOMAIN, "cannot import '%s'"),
	newname));
	}

	if (nvlist_add_string(props,
	zpool_prop_to_name(ZPOOL_PROP_ALTROOT), altroot) != 0 \|\|
	nvlist_add_string(props,
	zpool_prop_to_name(ZPOOL_PROP_CACHEFILE), "none") != 0) {
	nvlist_free(props);
	return (zfs_error_fmt(hdl, EZFS_NOMEM,
	dgettext(TEXT_DOMAIN, "cannot import '%s'"),
	newname));
	}
	}

	ret = zpool_import_props(hdl, config, newname, props,
	ZFS_IMPORT_NORMAL);
	nvlist_free(props);
	return (ret);
	}

	static void
	print_vdev_tree(libzfs_handle_t hdl, const char name, nvlist_t *nv,
	int indent)
	{
	nvlist_t **child;
	uint_t c, children;
	char *vname;
	uint64_t is_log = 0;

	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_IS_LOG,
	&is_log);

	if (name != NULL)
	(void) printf("\t%*s%s%s\n", indent, "", name,
	is_log ? " [log]" : "");

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
	&child, &children) != 0)
	return;

	for (c = 0; c < children; c++) {
	vname = zpool_vdev_name(hdl, NULL, child[c], VDEV_NAME_TYPE_ID);
	print_vdev_tree(hdl, vname, child[c], indent + 2);
	free(vname);
	}
	}

	void
	zpool_print_unsup_feat(nvlist_t *config)
	{
	nvlist_t nvinfo, unsup_feat;
	nvpair_t *nvp;

	verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_LOAD_INFO, &nvinfo) ==
	0);
	verify(nvlist_lookup_nvlist(nvinfo, ZPOOL_CONFIG_UNSUP_FEAT,
	&unsup_feat) == 0);

	for (nvp = nvlist_next_nvpair(unsup_feat, NULL); nvp != NULL;
	nvp = nvlist_next_nvpair(unsup_feat, nvp)) {
	char *desc;

	verify(nvpair_type(nvp) == DATA_TYPE_STRING);
	verify(nvpair_value_string(nvp, &desc) == 0);

	if (strlen(desc) > 0)
	(void) printf("\t%s (%s)\n", nvpair_name(nvp), desc);
	else
	(void) printf("\t%s\n", nvpair_name(nvp));
	}
	}

	/*
	* Import the given pool using the known configuration and a list of
	* properties to be set. The configuration should have come from
	* zpool_find_import(). The 'newname' parameters control whether the pool
	* is imported with a different name.
	*/
	int
	zpool_import_props(libzfs_handle_t hdl, nvlist_t config, const char *newname,
	nvlist_t *props, int flags)
	{
	zfs_cmd_t zc = {"\0"};
	zpool_load_policy_t policy;
	nvlist_t *nv = NULL;
	nvlist_t *nvinfo = NULL;
	nvlist_t *missing = NULL;
	char *thename;
	char *origname;
	int ret;
	int error = 0;
	char errbuf[1024];

	verify(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME,
	&origname) == 0);

	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
	"cannot import pool '%s'"), origname);

	if (newname != NULL) {
	if (!zpool_name_valid(hdl, B_FALSE, newname))
	return (zfs_error_fmt(hdl, EZFS_INVALIDNAME,
	dgettext(TEXT_DOMAIN, "cannot import '%s'"),
	newname));
	thename = (char *)newname;
	} else {
	thename = origname;
	}

	if (props != NULL) {
	uint64_t version;
	prop_flags_t flags = { .create = B_FALSE, .import = B_TRUE };

	verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION,
	&version) == 0);

	if ((props = zpool_valid_proplist(hdl, origname,
	props, version, flags, errbuf)) == NULL)
	return (-1);
	if (zcmd_write_src_nvlist(hdl, &zc, props) != 0) {
	nvlist_free(props);
	return (-1);
	}
	nvlist_free(props);
	}

	(void) strlcpy(zc.zc_name, thename, sizeof (zc.zc_name));

	verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID,
	&zc.zc_guid) == 0);

	if (zcmd_write_conf_nvlist(hdl, &zc, config) != 0) {
	zcmd_free_nvlists(&zc);
	return (-1);
	}
	if (zcmd_alloc_dst_nvlist(hdl, &zc, zc.zc_nvlist_conf_size * 2) != 0) {
	zcmd_free_nvlists(&zc);
	return (-1);
	}

	zc.zc_cookie = flags;
	while ((ret = zfs_ioctl(hdl, ZFS_IOC_POOL_IMPORT, &zc)) != 0 &&
	errno == ENOMEM) {
	if (zcmd_expand_dst_nvlist(hdl, &zc) != 0) {
	zcmd_free_nvlists(&zc);
	return (-1);
	}
	}
	if (ret != 0)
	error = errno;

	(void) zcmd_read_dst_nvlist(hdl, &zc, &nv);

	zcmd_free_nvlists(&zc);

	zpool_get_load_policy(config, &policy);

	if (error) {
	char desc[1024];
	char aux[256];

	/*
	* Dry-run failed, but we print out what success
	* looks like if we found a best txg
	*/
	if (policy.zlp_rewind & ZPOOL_TRY_REWIND) {
	zpool_rewind_exclaim(hdl, newname ? origname : thename,
	B_TRUE, nv);
	nvlist_free(nv);
	return (-1);
	}

	if (newname == NULL)
	(void) snprintf(desc, sizeof (desc),
	dgettext(TEXT_DOMAIN, "cannot import '%s'"),
	thename);
	else
	(void) snprintf(desc, sizeof (desc),
	dgettext(TEXT_DOMAIN, "cannot import '%s' as '%s'"),
	origname, thename);

	switch (error) {
	case ENOTSUP:
	if (nv != NULL && nvlist_lookup_nvlist(nv,
	ZPOOL_CONFIG_LOAD_INFO, &nvinfo) == 0 &&
	nvlist_exists(nvinfo, ZPOOL_CONFIG_UNSUP_FEAT)) {
	(void) printf(dgettext(TEXT_DOMAIN, "This "
	"pool uses the following feature(s) not "
	"supported by this system:\n"));
	zpool_print_unsup_feat(nv);
	if (nvlist_exists(nvinfo,
	ZPOOL_CONFIG_CAN_RDONLY)) {
	(void) printf(dgettext(TEXT_DOMAIN,
	"All unsupported features are only "
	"required for writing to the pool."
	"\nThe pool can be imported using "
	"'-o readonly=on'.\n"));
	}
	}
	/*
	* Unsupported version.
	*/
	(void) zfs_error(hdl, EZFS_BADVERSION, desc);
	break;

	case EREMOTEIO:
	if (nv != NULL && nvlist_lookup_nvlist(nv,
	ZPOOL_CONFIG_LOAD_INFO, &nvinfo) == 0) {
	char *hostname = "<unknown>";
	uint64_t hostid = 0;
	mmp_state_t mmp_state;

	mmp_state = fnvlist_lookup_uint64(nvinfo,
	ZPOOL_CONFIG_MMP_STATE);

	if (nvlist_exists(nvinfo,
	ZPOOL_CONFIG_MMP_HOSTNAME))
	hostname = fnvlist_lookup_string(nvinfo,
	ZPOOL_CONFIG_MMP_HOSTNAME);

	if (nvlist_exists(nvinfo,
	ZPOOL_CONFIG_MMP_HOSTID))
	hostid = fnvlist_lookup_uint64(nvinfo,
	ZPOOL_CONFIG_MMP_HOSTID);

	if (mmp_state == MMP_STATE_ACTIVE) {
	(void) snprintf(aux, sizeof (aux),
	dgettext(TEXT_DOMAIN, "pool is imp"
	"orted on host '%s' (hostid=%lx).\n"
	"Export the pool on the other "
	"system, then run 'zpool import'."),
	hostname, (unsigned long) hostid);
	} else if (mmp_state == MMP_STATE_NO_HOSTID) {
	(void) snprintf(aux, sizeof (aux),
	dgettext(TEXT_DOMAIN, "pool has "
	"the multihost property on and "
	"the\nsystem's hostid is not set. "
	"Set a unique system hostid with "
	"the zgenhostid(8) command.\n"));
	}

	(void) zfs_error_aux(hdl, aux);
	}
	(void) zfs_error(hdl, EZFS_ACTIVE_POOL, desc);
	break;

	case EINVAL:
	(void) zfs_error(hdl, EZFS_INVALCONFIG, desc);
	break;

	case EROFS:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"one or more devices is read only"));
	(void) zfs_error(hdl, EZFS_BADDEV, desc);
	break;

	case ENXIO:
	if (nv && nvlist_lookup_nvlist(nv,
	ZPOOL_CONFIG_LOAD_INFO, &nvinfo) == 0 &&
	nvlist_lookup_nvlist(nvinfo,
	ZPOOL_CONFIG_MISSING_DEVICES, &missing) == 0) {
	(void) printf(dgettext(TEXT_DOMAIN,
	"The devices below are missing or "
	"corrupted, use '-m' to import the pool "
	"anyway:\n"));
	print_vdev_tree(hdl, NULL, missing, 2);
	(void) printf("\n");
	}
	(void) zpool_standard_error(hdl, error, desc);
	break;

	case EEXIST:
	(void) zpool_standard_error(hdl, error, desc);
	break;

	case EBUSY:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"one or more devices are already in use\n"));
	(void) zfs_error(hdl, EZFS_BADDEV, desc);
	break;
	case ENAMETOOLONG:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"new name of at least one dataset is longer than "
	"the maximum allowable length"));
	(void) zfs_error(hdl, EZFS_NAMETOOLONG, desc);
	break;
	default:
	(void) zpool_standard_error(hdl, error, desc);
	zpool_explain_recover(hdl,
	newname ? origname : thename, -error, nv);
	break;
	}

	nvlist_free(nv);
	ret = -1;
	} else {
	zpool_handle_t *zhp;

	/*
	* This should never fail, but play it safe anyway.
	*/
	if (zpool_open_silent(hdl, thename, &zhp) != 0)
	ret = -1;
	else if (zhp != NULL)
	zpool_close(zhp);
	if (policy.zlp_rewind &
	(ZPOOL_DO_REWIND \| ZPOOL_TRY_REWIND)) {
	zpool_rewind_exclaim(hdl, newname ? origname : thename,
	((policy.zlp_rewind & ZPOOL_TRY_REWIND) != 0), nv);
	}
	nvlist_free(nv);
	return (0);
	}

	return (ret);
	}

	/*
	* Translate vdev names to guids. If a vdev_path is determined to be
	* unsuitable then a vd_errlist is allocated and the vdev path and errno
	* are added to it.
	*/
	static int
	zpool_translate_vdev_guids(zpool_handle_t zhp, nvlist_t vds,
	nvlist_t vdev_guids, nvlist_t guids_to_paths, nvlist_t **vd_errlist)
	{
	nvlist_t *errlist = NULL;
	int error = 0;

	for (nvpair_t *elem = nvlist_next_nvpair(vds, NULL); elem != NULL;
	elem = nvlist_next_nvpair(vds, elem)) {
	boolean_t spare, cache;

	char *vd_path = nvpair_name(elem);
	nvlist_t *tgt = zpool_find_vdev(zhp, vd_path, &spare, &cache,
	NULL);

	if ((tgt == NULL) \|\| cache \|\| spare) {
	if (errlist == NULL) {
	errlist = fnvlist_alloc();
	error = EINVAL;
	}

	uint64_t err = (tgt == NULL) ? EZFS_NODEVICE :
	(spare ? EZFS_ISSPARE : EZFS_ISL2CACHE);
	fnvlist_add_int64(errlist, vd_path, err);
	continue;
	}

	uint64_t guid = fnvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID);
	fnvlist_add_uint64(vdev_guids, vd_path, guid);

	char msg[MAXNAMELEN];
	(void) snprintf(msg, sizeof (msg), "%llu", (u_longlong_t)guid);
	fnvlist_add_string(guids_to_paths, msg, vd_path);
	}

	if (error != 0) {
	verify(errlist != NULL);
	if (vd_errlist != NULL)
	*vd_errlist = errlist;
	else
	fnvlist_free(errlist);
	}

	return (error);
	}

	static int
	xlate_init_err(int err)
	{
	switch (err) {
	case ENODEV:
	return (EZFS_NODEVICE);
	case EINVAL:
	case EROFS:
	return (EZFS_BADDEV);
	case EBUSY:
	return (EZFS_INITIALIZING);
	case ESRCH:
	return (EZFS_NO_INITIALIZE);
	}
	return (err);
	}

	/*
	* Begin, suspend, or cancel the initialization (initializing of all free
	* blocks) for the given vdevs in the given pool.
	*/
	static int
	zpool_initialize_impl(zpool_handle_t *zhp, pool_initialize_func_t cmd_type,
	nvlist_t *vds, boolean_t wait)
	{
	int err;

	nvlist_t *vdev_guids = fnvlist_alloc();
	nvlist_t *guids_to_paths = fnvlist_alloc();
	nvlist_t *vd_errlist = NULL;
	nvlist_t *errlist;
	nvpair_t *elem;

	err = zpool_translate_vdev_guids(zhp, vds, vdev_guids,
	guids_to_paths, &vd_errlist);

	if (err != 0) {
	verify(vd_errlist != NULL);
	goto list_errors;
	}

	err = lzc_initialize(zhp->zpool_name, cmd_type,
	vdev_guids, &errlist);

	if (err != 0) {
	if (errlist != NULL) {
	vd_errlist = fnvlist_lookup_nvlist(errlist,
	ZPOOL_INITIALIZE_VDEVS);
	goto list_errors;
	}
	(void) zpool_standard_error(zhp->zpool_hdl, err,
	dgettext(TEXT_DOMAIN, "operation failed"));
	goto out;
	}

	if (wait) {
	for (elem = nvlist_next_nvpair(vdev_guids, NULL); elem != NULL;
	elem = nvlist_next_nvpair(vdev_guids, elem)) {

	uint64_t guid = fnvpair_value_uint64(elem);

	err = lzc_wait_tag(zhp->zpool_name,
	ZPOOL_WAIT_INITIALIZE, guid, NULL);
	if (err != 0) {
	(void) zpool_standard_error_fmt(zhp->zpool_hdl,
	err, dgettext(TEXT_DOMAIN, "error "
	"waiting for '%s' to initialize"),
	nvpair_name(elem));

	goto out;
	}
	}
	}
	goto out;

	list_errors:
	for (elem = nvlist_next_nvpair(vd_errlist, NULL); elem != NULL;
	elem = nvlist_next_nvpair(vd_errlist, elem)) {
	int64_t vd_error = xlate_init_err(fnvpair_value_int64(elem));
	char *path;

	if (nvlist_lookup_string(guids_to_paths, nvpair_name(elem),
	&path) != 0)
	path = nvpair_name(elem);

	(void) zfs_error_fmt(zhp->zpool_hdl, vd_error,
	"cannot initialize '%s'", path);
	}

	out:
	fnvlist_free(vdev_guids);
	fnvlist_free(guids_to_paths);

	if (vd_errlist != NULL)
	fnvlist_free(vd_errlist);

	return (err == 0 ? 0 : -1);
	}

	int
	zpool_initialize(zpool_handle_t *zhp, pool_initialize_func_t cmd_type,
	nvlist_t *vds)
	{
	return (zpool_initialize_impl(zhp, cmd_type, vds, B_FALSE));
	}

	int
	zpool_initialize_wait(zpool_handle_t *zhp, pool_initialize_func_t cmd_type,
	nvlist_t *vds)
	{
	return (zpool_initialize_impl(zhp, cmd_type, vds, B_TRUE));
	}

	static int
	xlate_trim_err(int err)
	{
	switch (err) {
	case ENODEV:
	return (EZFS_NODEVICE);
	case EINVAL:
	case EROFS:
	return (EZFS_BADDEV);
	case EBUSY:
	return (EZFS_TRIMMING);
	case ESRCH:
	return (EZFS_NO_TRIM);
	case EOPNOTSUPP:
	return (EZFS_TRIM_NOTSUP);
	}
	return (err);
	}

	static int
	zpool_trim_wait(zpool_handle_t zhp, nvlist_t vdev_guids)
	{
	int err;
	nvpair_t *elem;

	for (elem = nvlist_next_nvpair(vdev_guids, NULL); elem != NULL;
	elem = nvlist_next_nvpair(vdev_guids, elem)) {

	uint64_t guid = fnvpair_value_uint64(elem);

	err = lzc_wait_tag(zhp->zpool_name,
	ZPOOL_WAIT_TRIM, guid, NULL);
	if (err != 0) {
	(void) zpool_standard_error_fmt(zhp->zpool_hdl,
	err, dgettext(TEXT_DOMAIN, "error "
	"waiting to trim '%s'"), nvpair_name(elem));

	return (err);
	}
	}
	return (0);
	}

	/*
	* Check errlist and report any errors, omitting ones which should be
	* suppressed. Returns B_TRUE if any errors were reported.
	*/
	static boolean_t
	check_trim_errs(zpool_handle_t zhp, trimflags_t trim_flags,
	nvlist_t guids_to_paths, nvlist_t vds, nvlist_t *errlist)
	{
	nvpair_t *elem;
	boolean_t reported_errs = B_FALSE;
	int num_vds = 0;
	int num_suppressed_errs = 0;

	for (elem = nvlist_next_nvpair(vds, NULL);
	elem != NULL; elem = nvlist_next_nvpair(vds, elem)) {
	num_vds++;
	}

	for (elem = nvlist_next_nvpair(errlist, NULL);
	elem != NULL; elem = nvlist_next_nvpair(errlist, elem)) {
	int64_t vd_error = xlate_trim_err(fnvpair_value_int64(elem));
	char *path;

	/*
	* If only the pool was specified, and it was not a secure
	* trim then suppress warnings for individual vdevs which
	* do not support trimming.
	*/
	if (vd_error == EZFS_TRIM_NOTSUP &&
	trim_flags->fullpool &&
	!trim_flags->secure) {
	num_suppressed_errs++;
	continue;
	}

	reported_errs = B_TRUE;
	if (nvlist_lookup_string(guids_to_paths, nvpair_name(elem),
	&path) != 0)
	path = nvpair_name(elem);

	(void) zfs_error_fmt(zhp->zpool_hdl, vd_error,
	"cannot trim '%s'", path);
	}

	if (num_suppressed_errs == num_vds) {
	(void) zfs_error_aux(zhp->zpool_hdl, dgettext(TEXT_DOMAIN,
	"no devices in pool support trim operations"));
	(void) (zfs_error(zhp->zpool_hdl, EZFS_TRIM_NOTSUP,
	dgettext(TEXT_DOMAIN, "cannot trim")));
	reported_errs = B_TRUE;
	}

	return (reported_errs);
	}

	/*
	* Begin, suspend, or cancel the TRIM (discarding of all free blocks) for
	* the given vdevs in the given pool.
	*/
	int
	zpool_trim(zpool_handle_t zhp, pool_trim_func_t cmd_type, nvlist_t vds,
	trimflags_t *trim_flags)
	{
	int err;
	int retval = 0;

	nvlist_t *vdev_guids = fnvlist_alloc();
	nvlist_t *guids_to_paths = fnvlist_alloc();
	nvlist_t *errlist = NULL;

	err = zpool_translate_vdev_guids(zhp, vds, vdev_guids,
	guids_to_paths, &errlist);
	if (err != 0) {
	check_trim_errs(zhp, trim_flags, guids_to_paths, vds, errlist);
	retval = -1;
	goto out;
	}

	err = lzc_trim(zhp->zpool_name, cmd_type, trim_flags->rate,
	trim_flags->secure, vdev_guids, &errlist);
	if (err != 0) {
	nvlist_t *vd_errlist;
	if (errlist != NULL && nvlist_lookup_nvlist(errlist,
	ZPOOL_TRIM_VDEVS, &vd_errlist) == 0) {
	if (check_trim_errs(zhp, trim_flags, guids_to_paths,
	vds, vd_errlist)) {
	retval = -1;
	goto out;
	}
	} else {
	char msg[1024];

	(void) snprintf(msg, sizeof (msg),
	dgettext(TEXT_DOMAIN, "operation failed"));
	zpool_standard_error(zhp->zpool_hdl, err, msg);
	retval = -1;
	goto out;
	}
	}


	if (trim_flags->wait)
	retval = zpool_trim_wait(zhp, vdev_guids);

	out:
	if (errlist != NULL)
	fnvlist_free(errlist);
	fnvlist_free(vdev_guids);
	fnvlist_free(guids_to_paths);
	return (retval);
	}

	/*
	* Scan the pool.
	*/
	int
	zpool_scan(zpool_handle_t *zhp, pool_scan_func_t func, pool_scrub_cmd_t cmd)
	{
	zfs_cmd_t zc = {"\0"};
	char msg[1024];
	int err;
	libzfs_handle_t *hdl = zhp->zpool_hdl;

	(void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
	zc.zc_cookie = func;
	zc.zc_flags = cmd;

	if (zfs_ioctl(hdl, ZFS_IOC_POOL_SCAN, &zc) == 0)
	return (0);

	err = errno;

	/* ECANCELED on a scrub means we resumed a paused scrub */
	if (err == ECANCELED && func == POOL_SCAN_SCRUB &&
	cmd == POOL_SCRUB_NORMAL)
	return (0);

	if (err == ENOENT && func != POOL_SCAN_NONE && cmd == POOL_SCRUB_NORMAL)
	return (0);

	if (func == POOL_SCAN_SCRUB) {
	if (cmd == POOL_SCRUB_PAUSE) {
	(void) snprintf(msg, sizeof (msg), dgettext(TEXT_DOMAIN,
	"cannot pause scrubbing %s"), zc.zc_name);
	} else {
	assert(cmd == POOL_SCRUB_NORMAL);
	(void) snprintf(msg, sizeof (msg), dgettext(TEXT_DOMAIN,
	"cannot scrub %s"), zc.zc_name);
	}
	} else if (func == POOL_SCAN_RESILVER) {
	assert(cmd == POOL_SCRUB_NORMAL);
	(void) snprintf(msg, sizeof (msg), dgettext(TEXT_DOMAIN,
	"cannot restart resilver on %s"), zc.zc_name);
	} else if (func == POOL_SCAN_NONE) {
	(void) snprintf(msg, sizeof (msg),
	dgettext(TEXT_DOMAIN, "cannot cancel scrubbing %s"),
	zc.zc_name);
	} else {
	assert(!"unexpected result");
	}

	if (err == EBUSY) {
	nvlist_t *nvroot;
	pool_scan_stat_t *ps = NULL;
	uint_t psc;

	verify(nvlist_lookup_nvlist(zhp->zpool_config,
	ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0);
	(void) nvlist_lookup_uint64_array(nvroot,
	ZPOOL_CONFIG_SCAN_STATS, (uint64_t **)&ps, &psc);
	if (ps && ps->pss_func == POOL_SCAN_SCRUB &&
	ps->pss_state == DSS_SCANNING) {
	if (cmd == POOL_SCRUB_PAUSE)
	return (zfs_error(hdl, EZFS_SCRUB_PAUSED, msg));
	else
	return (zfs_error(hdl, EZFS_SCRUBBING, msg));
	} else {
	return (zfs_error(hdl, EZFS_RESILVERING, msg));
	}
	} else if (err == ENOENT) {
	return (zfs_error(hdl, EZFS_NO_SCRUB, msg));
	} else if (err == ENOTSUP && func == POOL_SCAN_RESILVER) {
	return (zfs_error(hdl, EZFS_NO_RESILVER_DEFER, msg));
	} else {
	return (zpool_standard_error(hdl, err, msg));
	}
	}

	/*
	* Find a vdev that matches the search criteria specified. We use the
	* the nvpair name to determine how we should look for the device.
	* 'avail_spare' is set to TRUE if the provided guid refers to an AVAIL
	* spare; but FALSE if its an INUSE spare.
	*/
	static nvlist_t *
	vdev_to_nvlist_iter(nvlist_t nv, nvlist_t search, boolean_t *avail_spare,
	boolean_t l2cache, boolean_t log)
	{
	uint_t c, children;
	nvlist_t **child;
	nvlist_t *ret;
	uint64_t is_log;
	char *srchkey;
	nvpair_t *pair = nvlist_next_nvpair(search, NULL);

	/* Nothing to look for */
	if (search == NULL \|\| pair == NULL)
	return (NULL);

	/* Obtain the key we will use to search */
	srchkey = nvpair_name(pair);

	switch (nvpair_type(pair)) {
	case DATA_TYPE_UINT64:
	if (strcmp(srchkey, ZPOOL_CONFIG_GUID) == 0) {
	uint64_t srchval, theguid;

	verify(nvpair_value_uint64(pair, &srchval) == 0);
	verify(nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID,
	&theguid) == 0);
	if (theguid == srchval)
	return (nv);
	}
	break;

	case DATA_TYPE_STRING: {
	char srchval, val;

	verify(nvpair_value_string(pair, &srchval) == 0);
	if (nvlist_lookup_string(nv, srchkey, &val) != 0)
	break;

	/*
	* Search for the requested value. Special cases:
	*
	* - ZPOOL_CONFIG_PATH for whole disk entries. These end in
	* "-part1", or "p1". The suffix is hidden from the user,
	* but included in the string, so this matches around it.
	* - ZPOOL_CONFIG_PATH for short names zfs_strcmp_shortname()
	* is used to check all possible expanded paths.
	* - looking for a top-level vdev name (i.e. ZPOOL_CONFIG_TYPE).
	*
	* Otherwise, all other searches are simple string compares.
	*/
	if (strcmp(srchkey, ZPOOL_CONFIG_PATH) == 0) {
	uint64_t wholedisk = 0;

	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_WHOLE_DISK,
	&wholedisk);
	if (zfs_strcmp_pathname(srchval, val, wholedisk) == 0)
	return (nv);

	} else if (strcmp(srchkey, ZPOOL_CONFIG_TYPE) == 0 && val) {
	char type, idx, end, p;
	uint64_t id, vdev_id;

	/*
	* Determine our vdev type, keeping in mind
	* that the srchval is composed of a type and
	* vdev id pair (i.e. mirror-4).
	*/
	if ((type = strdup(srchval)) == NULL)
	return (NULL);

	if ((p = strrchr(type, '-')) == NULL) {
	free(type);
	break;
	}
	idx = p + 1;
	*p = '\0';

	/*
	* If the types don't match then keep looking.
	*/
	if (strncmp(val, type, strlen(val)) != 0) {
	free(type);
	break;
	}

	verify(zpool_vdev_is_interior(type));
	verify(nvlist_lookup_uint64(nv, ZPOOL_CONFIG_ID,
	&id) == 0);

	errno = 0;
	vdev_id = strtoull(idx, &end, 10);

	/*
	* If we are looking for a raidz and a parity is
	* specified, make sure it matches.
	*/
	int rzlen = strlen(VDEV_TYPE_RAIDZ);
	assert(rzlen == strlen(VDEV_TYPE_DRAID));
	int typlen = strlen(type);
	if ((strncmp(type, VDEV_TYPE_RAIDZ, rzlen) == 0 \|\|
	strncmp(type, VDEV_TYPE_DRAID, rzlen) == 0) &&
	typlen != rzlen) {
	uint64_t vdev_parity;
	int parity = *(type + rzlen) - '0';

	if (parity <= 0 \|\| parity > 3 \|\|
	(typlen - rzlen) != 1) {
	/*
	* Nonsense parity specified, can
	* never match
	*/
	free(type);
	return (NULL);
	}
	verify(nvlist_lookup_uint64(nv,
	ZPOOL_CONFIG_NPARITY, &vdev_parity) == 0);
	if ((int)vdev_parity != parity) {
	free(type);
	break;
	}
	}

	free(type);
	if (errno != 0)
	return (NULL);

	/*
	* Now verify that we have the correct vdev id.
	*/
	if (vdev_id == id)
	return (nv);
	}

	/*
	* Common case
	*/
	if (strcmp(srchval, val) == 0)
	return (nv);
	break;
	}

	default:
	break;
	}

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
	&child, &children) != 0)
	return (NULL);

	for (c = 0; c < children; c++) {
	if ((ret = vdev_to_nvlist_iter(child[c], search,
	avail_spare, l2cache, NULL)) != NULL) {
	/*
	* The 'is_log' value is only set for the toplevel
	* vdev, not the leaf vdevs. So we always lookup the
	* log device from the root of the vdev tree (where
	* 'log' is non-NULL).
	*/
	if (log != NULL &&
	nvlist_lookup_uint64(child[c],
	ZPOOL_CONFIG_IS_LOG, &is_log) == 0 &&
	is_log) {
	*log = B_TRUE;
	}
	return (ret);
	}
	}

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_SPARES,
	&child, &children) == 0) {
	for (c = 0; c < children; c++) {
	if ((ret = vdev_to_nvlist_iter(child[c], search,
	avail_spare, l2cache, NULL)) != NULL) {
	*avail_spare = B_TRUE;
	return (ret);
	}
	}
	}

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_L2CACHE,
	&child, &children) == 0) {
	for (c = 0; c < children; c++) {
	if ((ret = vdev_to_nvlist_iter(child[c], search,
	avail_spare, l2cache, NULL)) != NULL) {
	*l2cache = B_TRUE;
	return (ret);
	}
	}
	}

	return (NULL);
	}

	/*
	* Given a physical path or guid, find the associated vdev.
	*/
	nvlist_t *
	zpool_find_vdev_by_physpath(zpool_handle_t zhp, const char ppath,
	boolean_t avail_spare, boolean_t l2cache, boolean_t *log)
	{
	nvlist_t search, nvroot, *ret;
	uint64_t guid;
	char *end;

	verify(nvlist_alloc(&search, NV_UNIQUE_NAME, KM_SLEEP) == 0);

	guid = strtoull(ppath, &end, 0);
	if (guid != 0 && *end == '\0') {
	verify(nvlist_add_uint64(search, ZPOOL_CONFIG_GUID, guid) == 0);
	} else {
	verify(nvlist_add_string(search, ZPOOL_CONFIG_PHYS_PATH,
	ppath) == 0);
	}

	verify(nvlist_lookup_nvlist(zhp->zpool_config, ZPOOL_CONFIG_VDEV_TREE,
	&nvroot) == 0);

	*avail_spare = B_FALSE;
	*l2cache = B_FALSE;
	if (log != NULL)
	*log = B_FALSE;
	ret = vdev_to_nvlist_iter(nvroot, search, avail_spare, l2cache, log);
	nvlist_free(search);

	return (ret);
	}

	/*
	* Determine if we have an "interior" top-level vdev (i.e mirror/raidz).
	*/
	static boolean_t
	zpool_vdev_is_interior(const char *name)
	{
	if (strncmp(name, VDEV_TYPE_RAIDZ, strlen(VDEV_TYPE_RAIDZ)) == 0 \|\|
	strncmp(name, VDEV_TYPE_SPARE, strlen(VDEV_TYPE_SPARE)) == 0 \|\|
	strncmp(name,
	VDEV_TYPE_REPLACING, strlen(VDEV_TYPE_REPLACING)) == 0 \|\|
	strncmp(name, VDEV_TYPE_MIRROR, strlen(VDEV_TYPE_MIRROR)) == 0)
	return (B_TRUE);

	if (strncmp(name, VDEV_TYPE_DRAID, strlen(VDEV_TYPE_DRAID)) == 0 &&
	!zpool_is_draid_spare(name))
	return (B_TRUE);

	return (B_FALSE);
	}

	nvlist_t *
	zpool_find_vdev(zpool_handle_t zhp, const char path, boolean_t *avail_spare,
	boolean_t l2cache, boolean_t log)
	{
	char *end;
	nvlist_t nvroot, search, *ret;
	uint64_t guid;

	verify(nvlist_alloc(&search, NV_UNIQUE_NAME, KM_SLEEP) == 0);

	guid = strtoull(path, &end, 0);
	if (guid != 0 && *end == '\0') {
	verify(nvlist_add_uint64(search, ZPOOL_CONFIG_GUID, guid) == 0);
	} else if (zpool_vdev_is_interior(path)) {
	verify(nvlist_add_string(search, ZPOOL_CONFIG_TYPE, path) == 0);
	} else {
	verify(nvlist_add_string(search, ZPOOL_CONFIG_PATH, path) == 0);
	}

	verify(nvlist_lookup_nvlist(zhp->zpool_config, ZPOOL_CONFIG_VDEV_TREE,
	&nvroot) == 0);

	*avail_spare = B_FALSE;
	*l2cache = B_FALSE;
	if (log != NULL)
	*log = B_FALSE;
	ret = vdev_to_nvlist_iter(nvroot, search, avail_spare, l2cache, log);
	nvlist_free(search);

	return (ret);
	}

	static int
	vdev_is_online(nvlist_t *nv)
	{
	uint64_t ival;

	if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_OFFLINE, &ival) == 0 \|\|
	nvlist_lookup_uint64(nv, ZPOOL_CONFIG_FAULTED, &ival) == 0 \|\|
	nvlist_lookup_uint64(nv, ZPOOL_CONFIG_REMOVED, &ival) == 0)
	return (0);

	return (1);
	}

	/*
	* Helper function for zpool_get_physpaths().
	*/
	static int
	vdev_get_one_physpath(nvlist_t config, char physpath, size_t physpath_size,
	size_t *bytes_written)
	{
	size_t bytes_left, pos, rsz;
	char *tmppath;
	const char *format;

	if (nvlist_lookup_string(config, ZPOOL_CONFIG_PHYS_PATH,
	&tmppath) != 0)
	return (EZFS_NODEVICE);

	pos = *bytes_written;
	bytes_left = physpath_size - pos;
	format = (pos == 0) ? "%s" : " %s";

	rsz = snprintf(physpath + pos, bytes_left, format, tmppath);
	*bytes_written += rsz;

	if (rsz >= bytes_left) {
	/* if physpath was not copied properly, clear it */
	if (bytes_left != 0) {
	physpath[pos] = 0;
	}
	return (EZFS_NOSPC);
	}
	return (0);
	}

	static int
	vdev_get_physpaths(nvlist_t nv, char physpath, size_t phypath_size,
	size_t *rsz, boolean_t is_spare)
	{
	char *type;
	int ret;

	if (nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &type) != 0)
	return (EZFS_INVALCONFIG);

	if (strcmp(type, VDEV_TYPE_DISK) == 0) {
	/*
	* An active spare device has ZPOOL_CONFIG_IS_SPARE set.
	* For a spare vdev, we only want to boot from the active
	* spare device.
	*/
	if (is_spare) {
	uint64_t spare = 0;
	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_IS_SPARE,
	&spare);
	if (!spare)
	return (EZFS_INVALCONFIG);
	}

	if (vdev_is_online(nv)) {
	if ((ret = vdev_get_one_physpath(nv, physpath,
	phypath_size, rsz)) != 0)
	return (ret);
	}
	} else if (strcmp(type, VDEV_TYPE_MIRROR) == 0 \|\|
	strcmp(type, VDEV_TYPE_RAIDZ) == 0 \|\|
	strcmp(type, VDEV_TYPE_REPLACING) == 0 \|\|
	(is_spare = (strcmp(type, VDEV_TYPE_SPARE) == 0))) {
	nvlist_t **child;
	uint_t count;
	int i, ret;

	if (nvlist_lookup_nvlist_array(nv,
	ZPOOL_CONFIG_CHILDREN, &child, &count) != 0)
	return (EZFS_INVALCONFIG);

	for (i = 0; i < count; i++) {
	ret = vdev_get_physpaths(child[i], physpath,
	phypath_size, rsz, is_spare);
	if (ret == EZFS_NOSPC)
	return (ret);
	}
	}

	return (EZFS_POOL_INVALARG);
	}

	/*
	* Get phys_path for a root pool config.
	* Return 0 on success; non-zero on failure.
	*/
	static int
	zpool_get_config_physpath(nvlist_t config, char physpath, size_t phypath_size)
	{
	size_t rsz;
	nvlist_t *vdev_root;
	nvlist_t **child;
	uint_t count;
	char *type;

	rsz = 0;

	if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
	&vdev_root) != 0)
	return (EZFS_INVALCONFIG);

	if (nvlist_lookup_string(vdev_root, ZPOOL_CONFIG_TYPE, &type) != 0 \|\|
	nvlist_lookup_nvlist_array(vdev_root, ZPOOL_CONFIG_CHILDREN,
	&child, &count) != 0)
	return (EZFS_INVALCONFIG);

	/*
	* root pool can only have a single top-level vdev.
	*/
	if (strcmp(type, VDEV_TYPE_ROOT) != 0 \|\| count != 1)
	return (EZFS_POOL_INVALARG);

	(void) vdev_get_physpaths(child[0], physpath, phypath_size, &rsz,
	B_FALSE);

	/* No online devices */
	if (rsz == 0)
	return (EZFS_NODEVICE);

	return (0);
	}

	/*
	* Get phys_path for a root pool
	* Return 0 on success; non-zero on failure.
	*/
	int
	zpool_get_physpath(zpool_handle_t zhp, char physpath, size_t phypath_size)
	{
	return (zpool_get_config_physpath(zhp->zpool_config, physpath,
	phypath_size));
	}

	/*
	* Convert a vdev path to a GUID. Returns GUID or 0 on error.
	*
	* If is_spare, is_l2cache, or is_log is non-NULL, then store within it
	* if the VDEV is a spare, l2cache, or log device. If they're NULL then
	* ignore them.
	*/
	static uint64_t
	zpool_vdev_path_to_guid_impl(zpool_handle_t zhp, const char path,
	boolean_t is_spare, boolean_t is_l2cache, boolean_t *is_log)
	{
	uint64_t guid;
	boolean_t spare = B_FALSE, l2cache = B_FALSE, log = B_FALSE;
	nvlist_t *tgt;

	if ((tgt = zpool_find_vdev(zhp, path, &spare, &l2cache,
	&log)) == NULL)
	return (0);

	verify(nvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID, &guid) == 0);
	if (is_spare != NULL)
	*is_spare = spare;
	if (is_l2cache != NULL)
	*is_l2cache = l2cache;
	if (is_log != NULL)
	*is_log = log;

	return (guid);
	}

	/* Convert a vdev path to a GUID. Returns GUID or 0 on error. */
	uint64_t
	zpool_vdev_path_to_guid(zpool_handle_t zhp, const char path)
	{
	return (zpool_vdev_path_to_guid_impl(zhp, path, NULL, NULL, NULL));
	}

	/*
	* Bring the specified vdev online. The 'flags' parameter is a set of the
	* ZFS_ONLINE_* flags.
	*/
	int
	zpool_vdev_online(zpool_handle_t zhp, const char path, int flags,
	vdev_state_t *newstate)
	{
	zfs_cmd_t zc = {"\0"};
	char msg[1024];
	char *pathname;
	nvlist_t *tgt;
	boolean_t avail_spare, l2cache, islog;
	libzfs_handle_t *hdl = zhp->zpool_hdl;
	int error;

	if (flags & ZFS_ONLINE_EXPAND) {
	(void) snprintf(msg, sizeof (msg),
	dgettext(TEXT_DOMAIN, "cannot expand %s"), path);
	} else {
	(void) snprintf(msg, sizeof (msg),
	dgettext(TEXT_DOMAIN, "cannot online %s"), path);
	}

	(void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
	if ((tgt = zpool_find_vdev(zhp, path, &avail_spare, &l2cache,
	&islog)) == NULL)
	return (zfs_error(hdl, EZFS_NODEVICE, msg));

	verify(nvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID, &zc.zc_guid) == 0);

	if (avail_spare)
	return (zfs_error(hdl, EZFS_ISSPARE, msg));

	if ((flags & ZFS_ONLINE_EXPAND \|\|
	zpool_get_prop_int(zhp, ZPOOL_PROP_AUTOEXPAND, NULL)) &&
	nvlist_lookup_string(tgt, ZPOOL_CONFIG_PATH, &pathname) == 0) {
	uint64_t wholedisk = 0;

	(void) nvlist_lookup_uint64(tgt, ZPOOL_CONFIG_WHOLE_DISK,
	&wholedisk);

	/*
	* XXX - L2ARC 1.0 devices can't support expansion.
	*/
	if (l2cache) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"cannot expand cache devices"));
	return (zfs_error(hdl, EZFS_VDEVNOTSUP, msg));
	}

	if (wholedisk) {
	const char *fullpath = path;
	char buf[MAXPATHLEN];

	if (path[0] != '/') {
	error = zfs_resolve_shortname(path, buf,
	sizeof (buf));
	if (error != 0)
	return (zfs_error(hdl, EZFS_NODEVICE,
	msg));

	fullpath = buf;
	}

	error = zpool_relabel_disk(hdl, fullpath, msg);
	if (error != 0)
	return (error);
	}
	}

	zc.zc_cookie = VDEV_STATE_ONLINE;
	zc.zc_obj = flags;

	if (zfs_ioctl(hdl, ZFS_IOC_VDEV_SET_STATE, &zc) != 0) {
	if (errno == EINVAL) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "was split "
	"from this pool into a new one. Use '%s' "
	"instead"), "zpool detach");
	return (zfs_error(hdl, EZFS_POSTSPLIT_ONLINE, msg));
	}
	return (zpool_standard_error(hdl, errno, msg));
	}

	*newstate = zc.zc_cookie;
	return (0);
	}

	/*
	* Take the specified vdev offline
	*/
	int
	zpool_vdev_offline(zpool_handle_t zhp, const char path, boolean_t istmp)
	{
	zfs_cmd_t zc = {"\0"};
	char msg[1024];
	nvlist_t *tgt;
	boolean_t avail_spare, l2cache;
	libzfs_handle_t *hdl = zhp->zpool_hdl;

	(void) snprintf(msg, sizeof (msg),
	dgettext(TEXT_DOMAIN, "cannot offline %s"), path);

	(void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
	if ((tgt = zpool_find_vdev(zhp, path, &avail_spare, &l2cache,
	NULL)) == NULL)
	return (zfs_error(hdl, EZFS_NODEVICE, msg));

	verify(nvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID, &zc.zc_guid) == 0);

	if (avail_spare)
	return (zfs_error(hdl, EZFS_ISSPARE, msg));

	zc.zc_cookie = VDEV_STATE_OFFLINE;
	zc.zc_obj = istmp ? ZFS_OFFLINE_TEMPORARY : 0;

	if (zfs_ioctl(hdl, ZFS_IOC_VDEV_SET_STATE, &zc) == 0)
	return (0);

	switch (errno) {
	case EBUSY:

	/*
	* There are no other replicas of this device.
	*/
	return (zfs_error(hdl, EZFS_NOREPLICAS, msg));

	case EEXIST:
	/*
	* The log device has unplayed logs
	*/
	return (zfs_error(hdl, EZFS_UNPLAYED_LOGS, msg));

	default:
	return (zpool_standard_error(hdl, errno, msg));
	}
	}

	/*
	* Mark the given vdev faulted.
	*/
	int
	zpool_vdev_fault(zpool_handle_t *zhp, uint64_t guid, vdev_aux_t aux)
	{
	zfs_cmd_t zc = {"\0"};
	char msg[1024];
	libzfs_handle_t *hdl = zhp->zpool_hdl;

	(void) snprintf(msg, sizeof (msg),
	dgettext(TEXT_DOMAIN, "cannot fault %llu"), (u_longlong_t)guid);

	(void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
	zc.zc_guid = guid;
	zc.zc_cookie = VDEV_STATE_FAULTED;
	zc.zc_obj = aux;

	if (zfs_ioctl(hdl, ZFS_IOC_VDEV_SET_STATE, &zc) == 0)
	return (0);

	switch (errno) {
	case EBUSY:

	/*
	* There are no other replicas of this device.
	*/
	return (zfs_error(hdl, EZFS_NOREPLICAS, msg));

	default:
	return (zpool_standard_error(hdl, errno, msg));
	}

	}

	/*
	* Mark the given vdev degraded.
	*/
	int
	zpool_vdev_degrade(zpool_handle_t *zhp, uint64_t guid, vdev_aux_t aux)
	{
	zfs_cmd_t zc = {"\0"};
	char msg[1024];
	libzfs_handle_t *hdl = zhp->zpool_hdl;

	(void) snprintf(msg, sizeof (msg),
	dgettext(TEXT_DOMAIN, "cannot degrade %llu"), (u_longlong_t)guid);

	(void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
	zc.zc_guid = guid;
	zc.zc_cookie = VDEV_STATE_DEGRADED;
	zc.zc_obj = aux;

	if (zfs_ioctl(hdl, ZFS_IOC_VDEV_SET_STATE, &zc) == 0)
	return (0);

	return (zpool_standard_error(hdl, errno, msg));
	}

	/*
	* Returns TRUE if the given nvlist is a vdev that was originally swapped in as
	* a hot spare.
	*/
	static boolean_t
	is_replacing_spare(nvlist_t search, nvlist_t tgt, int which)
	{
	nvlist_t **child;
	uint_t c, children;
	char *type;

	if (nvlist_lookup_nvlist_array(search, ZPOOL_CONFIG_CHILDREN, &child,
	&children) == 0) {
	verify(nvlist_lookup_string(search, ZPOOL_CONFIG_TYPE,
	&type) == 0);

	if ((strcmp(type, VDEV_TYPE_SPARE) == 0 \|\|
	strcmp(type, VDEV_TYPE_DRAID_SPARE) == 0) &&
	children == 2 && child[which] == tgt)
	return (B_TRUE);

	for (c = 0; c < children; c++)
	if (is_replacing_spare(child[c], tgt, which))
	return (B_TRUE);
	}

	return (B_FALSE);
	}

	/*
	* Attach new_disk (fully described by nvroot) to old_disk.
	* If 'replacing' is specified, the new disk will replace the old one.
	*/
	int
	zpool_vdev_attach(zpool_handle_t zhp, const char old_disk,
	const char new_disk, nvlist_t nvroot, int replacing, boolean_t rebuild)
	{
	zfs_cmd_t zc = {"\0"};
	char msg[1024];
	int ret;
	nvlist_t *tgt;
	boolean_t avail_spare, l2cache, islog;
	uint64_t val;
	char *newname;
	nvlist_t **child;
	uint_t children;
	nvlist_t *config_root;
	libzfs_handle_t *hdl = zhp->zpool_hdl;

	if (replacing)
	(void) snprintf(msg, sizeof (msg), dgettext(TEXT_DOMAIN,
	"cannot replace %s with %s"), old_disk, new_disk);
	else
	(void) snprintf(msg, sizeof (msg), dgettext(TEXT_DOMAIN,
	"cannot attach %s to %s"), new_disk, old_disk);

	(void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
	if ((tgt = zpool_find_vdev(zhp, old_disk, &avail_spare, &l2cache,
	&islog)) == NULL)
	return (zfs_error(hdl, EZFS_NODEVICE, msg));

	if (avail_spare)
	return (zfs_error(hdl, EZFS_ISSPARE, msg));

	if (l2cache)
	return (zfs_error(hdl, EZFS_ISL2CACHE, msg));

	verify(nvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID, &zc.zc_guid) == 0);
	zc.zc_cookie = replacing;
	zc.zc_simple = rebuild;

	if (rebuild &&
	zfeature_lookup_guid("org.openzfs:device_rebuild", NULL) != 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"the loaded zfs module doesn't support device rebuilds"));
	return (zfs_error(hdl, EZFS_POOL_NOTSUP, msg));
	}

	if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN,
	&child, &children) != 0 \|\| children != 1) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"new device must be a single disk"));
	return (zfs_error(hdl, EZFS_INVALCONFIG, msg));
	}

	verify(nvlist_lookup_nvlist(zpool_get_config(zhp, NULL),
	ZPOOL_CONFIG_VDEV_TREE, &config_root) == 0);

	if ((newname = zpool_vdev_name(NULL, NULL, child[0], 0)) == NULL)
	return (-1);

	/*
	* If the target is a hot spare that has been swapped in, we can only
	* replace it with another hot spare.
	*/
	if (replacing &&
	nvlist_lookup_uint64(tgt, ZPOOL_CONFIG_IS_SPARE, &val) == 0 &&
	(zpool_find_vdev(zhp, newname, &avail_spare, &l2cache,
	NULL) == NULL \|\| !avail_spare) &&
	is_replacing_spare(config_root, tgt, 1)) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"can only be replaced by another hot spare"));
	free(newname);
	return (zfs_error(hdl, EZFS_BADTARGET, msg));
	}

	free(newname);

	if (zcmd_write_conf_nvlist(hdl, &zc, nvroot) != 0)
	return (-1);

	ret = zfs_ioctl(hdl, ZFS_IOC_VDEV_ATTACH, &zc);

	zcmd_free_nvlists(&zc);

	if (ret == 0)
	return (0);

	switch (errno) {
	case ENOTSUP:
	/*
	* Can't attach to or replace this type of vdev.
	*/
	if (replacing) {
	uint64_t version = zpool_get_prop_int(zhp,
	ZPOOL_PROP_VERSION, NULL);

	if (islog) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"cannot replace a log with a spare"));
	} else if (rebuild) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"only mirror and dRAID vdevs support "
	"sequential reconstruction"));
	} else if (zpool_is_draid_spare(new_disk)) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"dRAID spares can only replace child "
	"devices in their parent's dRAID vdev"));
	} else if (version >= SPA_VERSION_MULTI_REPLACE) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"already in replacing/spare config; wait "
	"for completion or use 'zpool detach'"));
	} else {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"cannot replace a replacing device"));
	}
	} else {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"can only attach to mirrors and top-level "
	"disks"));
	}
	(void) zfs_error(hdl, EZFS_BADTARGET, msg);
	break;

	case EINVAL:
	/*
	* The new device must be a single disk.
	*/
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"new device must be a single disk"));
	(void) zfs_error(hdl, EZFS_INVALCONFIG, msg);
	break;

	case EBUSY:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "%s is busy, "
	"or device removal is in progress"),
	new_disk);
	(void) zfs_error(hdl, EZFS_BADDEV, msg);
	break;

	case EOVERFLOW:
	/*
	* The new device is too small.
	*/
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"device is too small"));
	(void) zfs_error(hdl, EZFS_BADDEV, msg);
	break;

	case EDOM:
	/*
	* The new device has a different optimal sector size.
	*/
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"new device has a different optimal sector size; use the "
	"option '-o ashift=N' to override the optimal size"));
	(void) zfs_error(hdl, EZFS_BADDEV, msg);
	break;

	case ENAMETOOLONG:
	/*
	* The resulting top-level vdev spec won't fit in the label.
	*/
	(void) zfs_error(hdl, EZFS_DEVOVERFLOW, msg);
	break;

	default:
	(void) zpool_standard_error(hdl, errno, msg);
	}

	return (-1);
	}

	/*
	* Detach the specified device.
	*/
	int
	zpool_vdev_detach(zpool_handle_t zhp, const char path)
	{
	zfs_cmd_t zc = {"\0"};
	char msg[1024];
	nvlist_t *tgt;
	boolean_t avail_spare, l2cache;
	libzfs_handle_t *hdl = zhp->zpool_hdl;

	(void) snprintf(msg, sizeof (msg),
	dgettext(TEXT_DOMAIN, "cannot detach %s"), path);

	(void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
	if ((tgt = zpool_find_vdev(zhp, path, &avail_spare, &l2cache,
	NULL)) == NULL)
	return (zfs_error(hdl, EZFS_NODEVICE, msg));

	if (avail_spare)
	return (zfs_error(hdl, EZFS_ISSPARE, msg));

	if (l2cache)
	return (zfs_error(hdl, EZFS_ISL2CACHE, msg));

	verify(nvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID, &zc.zc_guid) == 0);

	if (zfs_ioctl(hdl, ZFS_IOC_VDEV_DETACH, &zc) == 0)
	return (0);

	switch (errno) {

	case ENOTSUP:
	/*
	* Can't detach from this type of vdev.
	*/
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "only "
	"applicable to mirror and replacing vdevs"));
	(void) zfs_error(hdl, EZFS_BADTARGET, msg);
	break;

	case EBUSY:
	/*
	* There are no other replicas of this device.
	*/
	(void) zfs_error(hdl, EZFS_NOREPLICAS, msg);
	break;

	default:
	(void) zpool_standard_error(hdl, errno, msg);
	}

	return (-1);
	}

	/*
	* Find a mirror vdev in the source nvlist.
	*
	* The mchild array contains a list of disks in one of the top-level mirrors
	* of the source pool. The schild array contains a list of disks that the
	* user specified on the command line. We loop over the mchild array to
	* see if any entry in the schild array matches.
	*
	* If a disk in the mchild array is found in the schild array, we return
	* the index of that entry. Otherwise we return -1.
	*/
	static int
	find_vdev_entry(zpool_handle_t zhp, nvlist_t *mchild, uint_t mchildren,
	nvlist_t **schild, uint_t schildren)
	{
	uint_t mc;

	for (mc = 0; mc < mchildren; mc++) {
	uint_t sc;
	char *mpath = zpool_vdev_name(zhp->zpool_hdl, zhp,
	mchild[mc], 0);

	for (sc = 0; sc < schildren; sc++) {
	char *spath = zpool_vdev_name(zhp->zpool_hdl, zhp,
	schild[sc], 0);
	boolean_t result = (strcmp(mpath, spath) == 0);

	free(spath);
	if (result) {
	free(mpath);
	return (mc);
	}
	}

	free(mpath);
	}

	return (-1);
	}

	/*
	* Split a mirror pool. If newroot points to null, then a new nvlist
	* is generated and it is the responsibility of the caller to free it.
	*/
	int
	zpool_vdev_split(zpool_handle_t zhp, char newname, nvlist_t **newroot,
	nvlist_t *props, splitflags_t flags)
	{
	zfs_cmd_t zc = {"\0"};
	char msg[1024], *bias;
	nvlist_t tree, config, child, newchild, *newconfig = NULL;
	nvlist_t *varray = NULL, zc_props = NULL;
	uint_t c, children, newchildren, lastlog = 0, vcount, found = 0;
	libzfs_handle_t *hdl = zhp->zpool_hdl;
	uint64_t vers, readonly = B_FALSE;
	boolean_t freelist = B_FALSE, memory_err = B_TRUE;
	int retval = 0;

	(void) snprintf(msg, sizeof (msg),
	dgettext(TEXT_DOMAIN, "Unable to split %s"), zhp->zpool_name);

	if (!zpool_name_valid(hdl, B_FALSE, newname))
	return (zfs_error(hdl, EZFS_INVALIDNAME, msg));

	if ((config = zpool_get_config(zhp, NULL)) == NULL) {
	(void) fprintf(stderr, gettext("Internal error: unable to "
	"retrieve pool configuration\n"));
	return (-1);
	}

	verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, &tree)
	== 0);
	verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION, &vers) == 0);

	if (props) {
	prop_flags_t flags = { .create = B_FALSE, .import = B_TRUE };
	if ((zc_props = zpool_valid_proplist(hdl, zhp->zpool_name,
	props, vers, flags, msg)) == NULL)
	return (-1);
	(void) nvlist_lookup_uint64(zc_props,
	zpool_prop_to_name(ZPOOL_PROP_READONLY), &readonly);
	if (readonly) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"property %s can only be set at import time"),
	zpool_prop_to_name(ZPOOL_PROP_READONLY));
	return (-1);
	}
	}

	if (nvlist_lookup_nvlist_array(tree, ZPOOL_CONFIG_CHILDREN, &child,
	&children) != 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"Source pool is missing vdev tree"));
	nvlist_free(zc_props);
	return (-1);
	}

	varray = zfs_alloc(hdl, children * sizeof (nvlist_t *));
	vcount = 0;

	if (*newroot == NULL \|\|
	nvlist_lookup_nvlist_array(*newroot, ZPOOL_CONFIG_CHILDREN,
	&newchild, &newchildren) != 0)
	newchildren = 0;

	for (c = 0; c < children; c++) {
	uint64_t is_log = B_FALSE, is_hole = B_FALSE;
	boolean_t is_special = B_FALSE, is_dedup = B_FALSE;
	char *type;
	nvlist_t *mchild, vdev;
	uint_t mchildren;
	int entry;

	/*
	* Unlike cache & spares, slogs are stored in the
	* ZPOOL_CONFIG_CHILDREN array. We filter them out here.
	*/
	(void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG,
	&is_log);
	(void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_HOLE,
	&is_hole);
	if (is_log \|\| is_hole) {
	/*
	* Create a hole vdev and put it in the config.
	*/
	if (nvlist_alloc(&vdev, NV_UNIQUE_NAME, 0) != 0)
	goto out;
	if (nvlist_add_string(vdev, ZPOOL_CONFIG_TYPE,
	VDEV_TYPE_HOLE) != 0)
	goto out;
	if (nvlist_add_uint64(vdev, ZPOOL_CONFIG_IS_HOLE,
	1) != 0)
	goto out;
	if (lastlog == 0)
	lastlog = vcount;
	varray[vcount++] = vdev;
	continue;
	}
	lastlog = 0;
	verify(nvlist_lookup_string(child[c], ZPOOL_CONFIG_TYPE, &type)
	== 0);

	if (strcmp(type, VDEV_TYPE_INDIRECT) == 0) {
	vdev = child[c];
	if (nvlist_dup(vdev, &varray[vcount++], 0) != 0)
	goto out;
	continue;
	} else if (strcmp(type, VDEV_TYPE_MIRROR) != 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"Source pool must be composed only of mirrors\n"));
	retval = zfs_error(hdl, EZFS_INVALCONFIG, msg);
	goto out;
	}

	if (nvlist_lookup_string(child[c],
	ZPOOL_CONFIG_ALLOCATION_BIAS, &bias) == 0) {
	if (strcmp(bias, VDEV_ALLOC_BIAS_SPECIAL) == 0)
	is_special = B_TRUE;
	else if (strcmp(bias, VDEV_ALLOC_BIAS_DEDUP) == 0)
	is_dedup = B_TRUE;
	}
	verify(nvlist_lookup_nvlist_array(child[c],
	ZPOOL_CONFIG_CHILDREN, &mchild, &mchildren) == 0);

	/* find or add an entry for this top-level vdev */
	if (newchildren > 0 &&
	(entry = find_vdev_entry(zhp, mchild, mchildren,
	newchild, newchildren)) >= 0) {
	/* We found a disk that the user specified. */
	vdev = mchild[entry];
	++found;
	} else {
	/* User didn't specify a disk for this vdev. */
	vdev = mchild[mchildren - 1];
	}

	if (nvlist_dup(vdev, &varray[vcount++], 0) != 0)
	goto out;

	if (flags.dryrun != 0) {
	if (is_dedup == B_TRUE) {
	if (nvlist_add_string(varray[vcount - 1],
	ZPOOL_CONFIG_ALLOCATION_BIAS,
	VDEV_ALLOC_BIAS_DEDUP) != 0)
	goto out;
	} else if (is_special == B_TRUE) {
	if (nvlist_add_string(varray[vcount - 1],
	ZPOOL_CONFIG_ALLOCATION_BIAS,
	VDEV_ALLOC_BIAS_SPECIAL) != 0)
	goto out;
	}
	}
	}

	/* did we find every disk the user specified? */
	if (found != newchildren) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "Device list must "
	"include at most one disk from each mirror"));
	retval = zfs_error(hdl, EZFS_INVALCONFIG, msg);
	goto out;
	}

	/* Prepare the nvlist for populating. */
	if (*newroot == NULL) {
	if (nvlist_alloc(newroot, NV_UNIQUE_NAME, 0) != 0)
	goto out;
	freelist = B_TRUE;
	if (nvlist_add_string(*newroot, ZPOOL_CONFIG_TYPE,
	VDEV_TYPE_ROOT) != 0)
	goto out;
	} else {
	verify(nvlist_remove_all(*newroot, ZPOOL_CONFIG_CHILDREN) == 0);
	}

	/* Add all the children we found */
	if (nvlist_add_nvlist_array(*newroot, ZPOOL_CONFIG_CHILDREN, varray,
	lastlog == 0 ? vcount : lastlog) != 0)
	goto out;

	/*
	* If we're just doing a dry run, exit now with success.
	*/
	if (flags.dryrun) {
	memory_err = B_FALSE;
	freelist = B_FALSE;
	goto out;
	}

	/* now build up the config list & call the ioctl */
	if (nvlist_alloc(&newconfig, NV_UNIQUE_NAME, 0) != 0)
	goto out;

	if (nvlist_add_nvlist(newconfig,
	ZPOOL_CONFIG_VDEV_TREE, *newroot) != 0 \|\|
	nvlist_add_string(newconfig,
	ZPOOL_CONFIG_POOL_NAME, newname) != 0 \|\|
	nvlist_add_uint64(newconfig, ZPOOL_CONFIG_VERSION, vers) != 0)
	goto out;

	/*
	* The new pool is automatically part of the namespace unless we
	* explicitly export it.
	*/
	if (!flags.import)
	zc.zc_cookie = ZPOOL_EXPORT_AFTER_SPLIT;
	(void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
	(void) strlcpy(zc.zc_string, newname, sizeof (zc.zc_string));
	if (zcmd_write_conf_nvlist(hdl, &zc, newconfig) != 0)
	goto out;
	if (zc_props != NULL && zcmd_write_src_nvlist(hdl, &zc, zc_props) != 0)
	goto out;

	if (zfs_ioctl(hdl, ZFS_IOC_VDEV_SPLIT, &zc) != 0) {
	retval = zpool_standard_error(hdl, errno, msg);
	goto out;
	}

	freelist = B_FALSE;
	memory_err = B_FALSE;

	out:
	if (varray != NULL) {
	int v;

	for (v = 0; v < vcount; v++)
	nvlist_free(varray[v]);
	free(varray);
	}
	zcmd_free_nvlists(&zc);
	nvlist_free(zc_props);
	nvlist_free(newconfig);
	if (freelist) {
	nvlist_free(*newroot);
	*newroot = NULL;
	}

	if (retval != 0)
	return (retval);

	if (memory_err)
	return (no_memory(hdl));

	return (0);
	}

	/*
	* Remove the given device.
	*/
	int
	zpool_vdev_remove(zpool_handle_t zhp, const char path)
	{
	zfs_cmd_t zc = {"\0"};
	char msg[1024];
	nvlist_t *tgt;
	boolean_t avail_spare, l2cache, islog;
	libzfs_handle_t *hdl = zhp->zpool_hdl;
	uint64_t version;

	(void) snprintf(msg, sizeof (msg),
	dgettext(TEXT_DOMAIN, "cannot remove %s"), path);

	if (zpool_is_draid_spare(path)) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"dRAID spares cannot be removed"));
	return (zfs_error(hdl, EZFS_NODEVICE, msg));
	}

	(void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
	if ((tgt = zpool_find_vdev(zhp, path, &avail_spare, &l2cache,
	&islog)) == NULL)
	return (zfs_error(hdl, EZFS_NODEVICE, msg));

	version = zpool_get_prop_int(zhp, ZPOOL_PROP_VERSION, NULL);
	if (islog && version < SPA_VERSION_HOLES) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"pool must be upgraded to support log removal"));
	return (zfs_error(hdl, EZFS_BADVERSION, msg));
	}

	zc.zc_guid = fnvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID);

	if (zfs_ioctl(hdl, ZFS_IOC_VDEV_REMOVE, &zc) == 0)
	return (0);

	switch (errno) {

	case EINVAL:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"invalid config; all top-level vdevs must "
	"have the same sector size and not be raidz."));
	(void) zfs_error(hdl, EZFS_INVALCONFIG, msg);
	break;

	case EBUSY:
	if (islog) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"Mount encrypted datasets to replay logs."));
	} else {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"Pool busy; removal may already be in progress"));
	}
	(void) zfs_error(hdl, EZFS_BUSY, msg);
	break;

	case EACCES:
	if (islog) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"Mount encrypted datasets to replay logs."));
	(void) zfs_error(hdl, EZFS_BUSY, msg);
	} else {
	(void) zpool_standard_error(hdl, errno, msg);
	}
	break;

	default:
	(void) zpool_standard_error(hdl, errno, msg);
	}
	return (-1);
	}

	int
	zpool_vdev_remove_cancel(zpool_handle_t *zhp)
	{
	zfs_cmd_t zc;
	char msg[1024];
	libzfs_handle_t *hdl = zhp->zpool_hdl;

	(void) snprintf(msg, sizeof (msg),
	dgettext(TEXT_DOMAIN, "cannot cancel removal"));

	bzero(&zc, sizeof (zc));
	(void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
	zc.zc_cookie = 1;

	if (zfs_ioctl(hdl, ZFS_IOC_VDEV_REMOVE, &zc) == 0)
	return (0);

	return (zpool_standard_error(hdl, errno, msg));
	}

	int
	zpool_vdev_indirect_size(zpool_handle_t zhp, const char path,
	uint64_t *sizep)
	{
	char msg[1024];
	nvlist_t *tgt;
	boolean_t avail_spare, l2cache, islog;
	libzfs_handle_t *hdl = zhp->zpool_hdl;

	(void) snprintf(msg, sizeof (msg),
	dgettext(TEXT_DOMAIN, "cannot determine indirect size of %s"),
	path);

	if ((tgt = zpool_find_vdev(zhp, path, &avail_spare, &l2cache,
	&islog)) == NULL)
	return (zfs_error(hdl, EZFS_NODEVICE, msg));

	if (avail_spare \|\| l2cache \|\| islog) {
	*sizep = 0;
	return (0);
	}

	if (nvlist_lookup_uint64(tgt, ZPOOL_CONFIG_INDIRECT_SIZE, sizep) != 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"indirect size not available"));
	return (zfs_error(hdl, EINVAL, msg));
	}
	return (0);
	}

	/*
	* Clear the errors for the pool, or the particular device if specified.
	*/
	int
	zpool_clear(zpool_handle_t zhp, const char path, nvlist_t *rewindnvl)
	{
	zfs_cmd_t zc = {"\0"};
	char msg[1024];
	nvlist_t *tgt;
	zpool_load_policy_t policy;
	boolean_t avail_spare, l2cache;
	libzfs_handle_t *hdl = zhp->zpool_hdl;
	nvlist_t *nvi = NULL;
	int error;

	if (path)
	(void) snprintf(msg, sizeof (msg),
	dgettext(TEXT_DOMAIN, "cannot clear errors for %s"),
	path);
	else
	(void) snprintf(msg, sizeof (msg),
	dgettext(TEXT_DOMAIN, "cannot clear errors for %s"),
	zhp->zpool_name);

	(void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
	if (path) {
	if ((tgt = zpool_find_vdev(zhp, path, &avail_spare,
	&l2cache, NULL)) == NULL)
	return (zfs_error(hdl, EZFS_NODEVICE, msg));

	/*
	* Don't allow error clearing for hot spares. Do allow
	* error clearing for l2cache devices.
	*/
	if (avail_spare)
	return (zfs_error(hdl, EZFS_ISSPARE, msg));

	verify(nvlist_lookup_uint64(tgt, ZPOOL_CONFIG_GUID,
	&zc.zc_guid) == 0);
	}

	zpool_get_load_policy(rewindnvl, &policy);
	zc.zc_cookie = policy.zlp_rewind;

	if (zcmd_alloc_dst_nvlist(hdl, &zc, zhp->zpool_config_size * 2) != 0)
	return (-1);

	if (zcmd_write_src_nvlist(hdl, &zc, rewindnvl) != 0)
	return (-1);

	while ((error = zfs_ioctl(hdl, ZFS_IOC_CLEAR, &zc)) != 0 &&
	errno == ENOMEM) {
	if (zcmd_expand_dst_nvlist(hdl, &zc) != 0) {
	zcmd_free_nvlists(&zc);
	return (-1);
	}
	}

	if (!error \|\| ((policy.zlp_rewind & ZPOOL_TRY_REWIND) &&
	errno != EPERM && errno != EACCES)) {
	if (policy.zlp_rewind &
	(ZPOOL_DO_REWIND \| ZPOOL_TRY_REWIND)) {
	(void) zcmd_read_dst_nvlist(hdl, &zc, &nvi);
	zpool_rewind_exclaim(hdl, zc.zc_name,
	((policy.zlp_rewind & ZPOOL_TRY_REWIND) != 0),
	nvi);
	nvlist_free(nvi);
	}
	zcmd_free_nvlists(&zc);
	return (0);
	}

	zcmd_free_nvlists(&zc);
	return (zpool_standard_error(hdl, errno, msg));
	}

	/*
	* Similar to zpool_clear(), but takes a GUID (used by fmd).
	*/
	int
	zpool_vdev_clear(zpool_handle_t *zhp, uint64_t guid)
	{
	zfs_cmd_t zc = {"\0"};
	char msg[1024];
	libzfs_handle_t *hdl = zhp->zpool_hdl;

	(void) snprintf(msg, sizeof (msg),
	dgettext(TEXT_DOMAIN, "cannot clear errors for %llx"),
	(u_longlong_t)guid);

	(void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
	zc.zc_guid = guid;
	zc.zc_cookie = ZPOOL_NO_REWIND;

	if (zfs_ioctl(hdl, ZFS_IOC_CLEAR, &zc) == 0)
	return (0);

	return (zpool_standard_error(hdl, errno, msg));
	}

	/*
	* Change the GUID for a pool.
	*/
	int
	zpool_reguid(zpool_handle_t *zhp)
	{
	char msg[1024];
	libzfs_handle_t *hdl = zhp->zpool_hdl;
	zfs_cmd_t zc = {"\0"};

	(void) snprintf(msg, sizeof (msg),
	dgettext(TEXT_DOMAIN, "cannot reguid '%s'"), zhp->zpool_name);

	(void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
	if (zfs_ioctl(hdl, ZFS_IOC_POOL_REGUID, &zc) == 0)
	return (0);

	return (zpool_standard_error(hdl, errno, msg));
	}

	/*
	* Reopen the pool.
	*/
	int
	zpool_reopen_one(zpool_handle_t zhp, void data)
	{
	libzfs_handle_t *hdl = zpool_get_handle(zhp);
	const char *pool_name = zpool_get_name(zhp);
	boolean_t *scrub_restart = data;
	int error;

	error = lzc_reopen(pool_name, *scrub_restart);
	if (error) {
	return (zpool_standard_error_fmt(hdl, error,
	dgettext(TEXT_DOMAIN, "cannot reopen '%s'"), pool_name));
	}

	return (0);
	}

	/* call into libzfs_core to execute the sync IOCTL per pool */
	int
	zpool_sync_one(zpool_handle_t zhp, void data)
	{
	int ret;
	libzfs_handle_t *hdl = zpool_get_handle(zhp);
	const char *pool_name = zpool_get_name(zhp);
	boolean_t *force = data;
	nvlist_t *innvl = fnvlist_alloc();

	fnvlist_add_boolean_value(innvl, "force", *force);
	if ((ret = lzc_sync(pool_name, innvl, NULL)) != 0) {
	nvlist_free(innvl);
	return (zpool_standard_error_fmt(hdl, ret,
	dgettext(TEXT_DOMAIN, "sync '%s' failed"), pool_name));
	}
	nvlist_free(innvl);

	return (0);
	}

	#define PATH_BUF_LEN 64

	/*
	* Given a vdev, return the name to display in iostat. If the vdev has a path,
	* we use that, stripping off any leading "/dev/dsk/"; if not, we use the type.
	* We also check if this is a whole disk, in which case we strip off the
	* trailing 's0' slice name.
	*
	* This routine is also responsible for identifying when disks have been
	* reconfigured in a new location. The kernel will have opened the device by
	* devid, but the path will still refer to the old location. To catch this, we
	* first do a path -> devid translation (which is fast for the common case). If
	* the devid matches, we're done. If not, we do a reverse devid -> path
	* translation and issue the appropriate ioctl() to update the path of the vdev.
	* If 'zhp' is NULL, then this is an exported pool, and we don't need to do any
	* of these checks.
	*/
	char *
	zpool_vdev_name(libzfs_handle_t hdl, zpool_handle_t zhp, nvlist_t *nv,
	int name_flags)
	{
	char path, type, *env;
	uint64_t value;
	char buf[PATH_BUF_LEN];
	char tmpbuf[PATH_BUF_LEN];

	/*
	* vdev_name will be "root"/"root-0" for the root vdev, but it is the
	* zpool name that will be displayed to the user.
	*/
	verify(nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &type) == 0);
	if (zhp != NULL && strcmp(type, "root") == 0)
	return (zfs_strdup(hdl, zpool_get_name(zhp)));

	env = getenv("ZPOOL_VDEV_NAME_PATH");
	if (env && (strtoul(env, NULL, 0) > 0 \|\|
	!strncasecmp(env, "YES", 3) \|\| !strncasecmp(env, "ON", 2)))
	name_flags \|= VDEV_NAME_PATH;

	env = getenv("ZPOOL_VDEV_NAME_GUID");
	if (env && (strtoul(env, NULL, 0) > 0 \|\|
	!strncasecmp(env, "YES", 3) \|\| !strncasecmp(env, "ON", 2)))
	name_flags \|= VDEV_NAME_GUID;

	env = getenv("ZPOOL_VDEV_NAME_FOLLOW_LINKS");
	if (env && (strtoul(env, NULL, 0) > 0 \|\|
	!strncasecmp(env, "YES", 3) \|\| !strncasecmp(env, "ON", 2)))
	name_flags \|= VDEV_NAME_FOLLOW_LINKS;

	if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_NOT_PRESENT, &value) == 0 \|\|
	name_flags & VDEV_NAME_GUID) {
	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &value);
	(void) snprintf(buf, sizeof (buf), "%llu", (u_longlong_t)value);
	path = buf;
	} else if (nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path) == 0) {
	if (name_flags & VDEV_NAME_FOLLOW_LINKS) {
	char *rp = realpath(path, NULL);
	if (rp) {
	strlcpy(buf, rp, sizeof (buf));
	path = buf;
	free(rp);
	}
	}

	/*
	* For a block device only use the name.
	*/
	if ((strcmp(type, VDEV_TYPE_DISK) == 0) &&
	!(name_flags & VDEV_NAME_PATH)) {
	path = zfs_strip_path(path);
	}

	/*
	* Remove the partition from the path if this is a whole disk.
	*/
	if (strcmp(type, VDEV_TYPE_DRAID_SPARE) != 0 &&
	nvlist_lookup_uint64(nv, ZPOOL_CONFIG_WHOLE_DISK, &value)
	== 0 && value && !(name_flags & VDEV_NAME_PATH)) {
	return (zfs_strip_partition(path));
	}
	} else {
	path = type;

	/*
	* If it's a raidz device, we need to stick in the parity level.
	*/
	if (strcmp(path, VDEV_TYPE_RAIDZ) == 0) {
	verify(nvlist_lookup_uint64(nv, ZPOOL_CONFIG_NPARITY,
	&value) == 0);
	(void) snprintf(buf, sizeof (buf), "%s%llu", path,
	(u_longlong_t)value);
	path = buf;
	}

	/*
	* If it's a dRAID device, we add parity, groups, and spares.
	*/
	if (strcmp(path, VDEV_TYPE_DRAID) == 0) {
	uint64_t ndata, nparity, nspares;
	nvlist_t **child;
	uint_t children;

	verify(nvlist_lookup_nvlist_array(nv,
	ZPOOL_CONFIG_CHILDREN, &child, &children) == 0);
	verify(nvlist_lookup_uint64(nv,
	ZPOOL_CONFIG_NPARITY, &nparity) == 0);
	verify(nvlist_lookup_uint64(nv,
	ZPOOL_CONFIG_DRAID_NDATA, &ndata) == 0);
	verify(nvlist_lookup_uint64(nv,
	ZPOOL_CONFIG_DRAID_NSPARES, &nspares) == 0);

	path = zpool_draid_name(buf, sizeof (buf), ndata,
	nparity, nspares, children);
	}

	/*
	* We identify each top-level vdev by using a <type-id>
	* naming convention.
	*/
	if (name_flags & VDEV_NAME_TYPE_ID) {
	uint64_t id;
	verify(nvlist_lookup_uint64(nv, ZPOOL_CONFIG_ID,
	&id) == 0);
	(void) snprintf(tmpbuf, sizeof (tmpbuf), "%s-%llu",
	path, (u_longlong_t)id);
	path = tmpbuf;
	}
	}

	return (zfs_strdup(hdl, path));
	}

	static int
	zbookmark_mem_compare(const void a, const void b)
	{
	return (memcmp(a, b, sizeof (zbookmark_phys_t)));
	}

	/*
	* Retrieve the persistent error log, uniquify the members, and return to the
	* caller.
	*/
	int
	zpool_get_errlog(zpool_handle_t zhp, nvlist_t *nverrlistp)
	{
	zfs_cmd_t zc = {"\0"};
	libzfs_handle_t *hdl = zhp->zpool_hdl;
	uint64_t count;
	zbookmark_phys_t *zb = NULL;
	int i;

	/*
	* Retrieve the raw error list from the kernel. If the number of errors
	* has increased, allocate more space and continue until we get the
	* entire list.
	*/
	verify(nvlist_lookup_uint64(zhp->zpool_config, ZPOOL_CONFIG_ERRCOUNT,
	&count) == 0);
	if (count == 0)
	return (0);
	zc.zc_nvlist_dst = (uintptr_t)zfs_alloc(zhp->zpool_hdl,
	count * sizeof (zbookmark_phys_t));
	zc.zc_nvlist_dst_size = count;
	(void) strcpy(zc.zc_name, zhp->zpool_name);
	for (;;) {
	if (zfs_ioctl(zhp->zpool_hdl, ZFS_IOC_ERROR_LOG,
	&zc) != 0) {
	free((void *)(uintptr_t)zc.zc_nvlist_dst);
	if (errno == ENOMEM) {
	void *dst;

	count = zc.zc_nvlist_dst_size;
	dst = zfs_alloc(zhp->zpool_hdl, count *
	sizeof (zbookmark_phys_t));
	zc.zc_nvlist_dst = (uintptr_t)dst;
	} else {
	return (zpool_standard_error_fmt(hdl, errno,
	dgettext(TEXT_DOMAIN, "errors: List of "
	"errors unavailable")));
	}
	} else {
	break;
	}
	}

	/*
	* Sort the resulting bookmarks. This is a little confusing due to the
	* implementation of ZFS_IOC_ERROR_LOG. The bookmarks are copied last
	* to first, and 'zc_nvlist_dst_size' indicates the number of bookmarks
	* _not_ copied as part of the process. So we point the start of our
	* array appropriate and decrement the total number of elements.
	*/
	zb = ((zbookmark_phys_t *)(uintptr_t)zc.zc_nvlist_dst) +
	zc.zc_nvlist_dst_size;
	count -= zc.zc_nvlist_dst_size;

	qsort(zb, count, sizeof (zbookmark_phys_t), zbookmark_mem_compare);

	verify(nvlist_alloc(nverrlistp, 0, KM_SLEEP) == 0);

	/*
	* Fill in the nverrlistp with nvlist's of dataset and object numbers.
	*/
	for (i = 0; i < count; i++) {
	nvlist_t *nv;

	/* ignoring zb_blkid and zb_level for now */
	if (i > 0 && zb[i-1].zb_objset == zb[i].zb_objset &&
	zb[i-1].zb_object == zb[i].zb_object)
	continue;

	if (nvlist_alloc(&nv, NV_UNIQUE_NAME, KM_SLEEP) != 0)
	goto nomem;
	if (nvlist_add_uint64(nv, ZPOOL_ERR_DATASET,
	zb[i].zb_objset) != 0) {
	nvlist_free(nv);
	goto nomem;
	}
	if (nvlist_add_uint64(nv, ZPOOL_ERR_OBJECT,
	zb[i].zb_object) != 0) {
	nvlist_free(nv);
	goto nomem;
	}
	if (nvlist_add_nvlist(*nverrlistp, "ejk", nv) != 0) {
	nvlist_free(nv);
	goto nomem;
	}
	nvlist_free(nv);
	}

	free((void *)(uintptr_t)zc.zc_nvlist_dst);
	return (0);

	nomem:
	free((void *)(uintptr_t)zc.zc_nvlist_dst);
	return (no_memory(zhp->zpool_hdl));
	}

	/*
	* Upgrade a ZFS pool to the latest on-disk version.
	*/
	int
	zpool_upgrade(zpool_handle_t *zhp, uint64_t new_version)
	{
	zfs_cmd_t zc = {"\0"};
	libzfs_handle_t *hdl = zhp->zpool_hdl;

	(void) strcpy(zc.zc_name, zhp->zpool_name);
	zc.zc_cookie = new_version;

	if (zfs_ioctl(hdl, ZFS_IOC_POOL_UPGRADE, &zc) != 0)
	return (zpool_standard_error_fmt(hdl, errno,
	dgettext(TEXT_DOMAIN, "cannot upgrade '%s'"),
	zhp->zpool_name));
	return (0);
	}

	void
	zfs_save_arguments(int argc, char *argv, char string, int len)
	{
	int i;

	(void) strlcpy(string, basename(argv[0]), len);
	for (i = 1; i < argc; i++) {
	(void) strlcat(string, " ", len);
	(void) strlcat(string, argv[i], len);
	}
	}

	int
	zpool_log_history(libzfs_handle_t hdl, const char message)
	{
	zfs_cmd_t zc = {"\0"};
	nvlist_t *args;
	int err;

	args = fnvlist_alloc();
	fnvlist_add_string(args, "message", message);
	err = zcmd_write_src_nvlist(hdl, &zc, args);
	if (err == 0)
	err = zfs_ioctl(hdl, ZFS_IOC_LOG_HISTORY, &zc);
	nvlist_free(args);
	zcmd_free_nvlists(&zc);
	return (err);
	}

	/*
	* Perform ioctl to get some command history of a pool.
	*
	* 'buf' is the buffer to fill up to 'len' bytes. 'off' is the
	* logical offset of the history buffer to start reading from.
	*
	* Upon return, 'off' is the next logical offset to read from and
	* 'len' is the actual amount of bytes read into 'buf'.
	*/
	static int
	get_history(zpool_handle_t zhp, char buf, uint64_t off, uint64_t len)
	{
	zfs_cmd_t zc = {"\0"};
	libzfs_handle_t *hdl = zhp->zpool_hdl;

	(void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));

	zc.zc_history = (uint64_t)(uintptr_t)buf;
	zc.zc_history_len = *len;
	zc.zc_history_offset = *off;

	if (zfs_ioctl(hdl, ZFS_IOC_POOL_GET_HISTORY, &zc) != 0) {
	switch (errno) {
	case EPERM:
	return (zfs_error_fmt(hdl, EZFS_PERM,
	dgettext(TEXT_DOMAIN,
	"cannot show history for pool '%s'"),
	zhp->zpool_name));
	case ENOENT:
	return (zfs_error_fmt(hdl, EZFS_NOHISTORY,
	dgettext(TEXT_DOMAIN, "cannot get history for pool "
	"'%s'"), zhp->zpool_name));
	case ENOTSUP:
	return (zfs_error_fmt(hdl, EZFS_BADVERSION,
	dgettext(TEXT_DOMAIN, "cannot get history for pool "
	"'%s', pool must be upgraded"), zhp->zpool_name));
	default:
	return (zpool_standard_error_fmt(hdl, errno,
	dgettext(TEXT_DOMAIN,
	"cannot get history for '%s'"), zhp->zpool_name));
	}
	}

	*len = zc.zc_history_len;
	*off = zc.zc_history_offset;

	return (0);
	}

	/*
	* Retrieve the command history of a pool.
	*/
	int
	zpool_get_history(zpool_handle_t zhp, nvlist_t nvhisp, uint64_t off,
	boolean_t *eof)
	{
	char *buf;
	int buflen = 128 * 1024;
	nvlist_t **records = NULL;
	uint_t numrecords = 0;
	int err, i;
	uint64_t start = *off;

	buf = malloc(buflen);
	if (buf == NULL)
	return (ENOMEM);
	/* process about 1MB a time */
	while (off - start < 1024 1024) {
	uint64_t bytes_read = buflen;
	uint64_t leftover;

	if ((err = get_history(zhp, buf, off, &bytes_read)) != 0)
	break;

	/* if nothing else was read in, we're at EOF, just return */
	if (!bytes_read) {
	*eof = B_TRUE;
	break;
	}

	if ((err = zpool_history_unpack(buf, bytes_read,
	&leftover, &records, &numrecords)) != 0)
	break;
	*off -= leftover;
	if (leftover == bytes_read) {
	/*
	* no progress made, because buffer is not big enough
	* to hold this record; resize and retry.
	*/
	buflen *= 2;
	free(buf);
	buf = malloc(buflen);
	if (buf == NULL)
	return (ENOMEM);
	}
	}

	free(buf);

	if (!err) {
	verify(nvlist_alloc(nvhisp, NV_UNIQUE_NAME, 0) == 0);
	verify(nvlist_add_nvlist_array(*nvhisp, ZPOOL_HIST_RECORD,
	records, numrecords) == 0);
	}
	for (i = 0; i < numrecords; i++)
	nvlist_free(records[i]);
	free(records);

	return (err);
	}

	/*
	* Retrieve the next event given the passed 'zevent_fd' file descriptor.
	* If there is a new event available 'nvp' will contain a newly allocated
	* nvlist and 'dropped' will be set to the number of missed events since
	* the last call to this function. When 'nvp' is set to NULL it indicates
	* no new events are available. In either case the function returns 0 and
	* it is up to the caller to free 'nvp'. In the case of a fatal error the
	* function will return a non-zero value. When the function is called in
	* blocking mode (the default, unless the ZEVENT_NONBLOCK flag is passed),
	* it will not return until a new event is available.
	*/
	int
	zpool_events_next(libzfs_handle_t hdl, nvlist_t *nvp,
	int *dropped, unsigned flags, int zevent_fd)
	{
	zfs_cmd_t zc = {"\0"};
	int error = 0;

	*nvp = NULL;
	*dropped = 0;
	zc.zc_cleanup_fd = zevent_fd;

	if (flags & ZEVENT_NONBLOCK)
	zc.zc_guid = ZEVENT_NONBLOCK;

	if (zcmd_alloc_dst_nvlist(hdl, &zc, ZEVENT_SIZE) != 0)
	return (-1);

	retry:
	if (zfs_ioctl(hdl, ZFS_IOC_EVENTS_NEXT, &zc) != 0) {
	switch (errno) {
	case ESHUTDOWN:
	error = zfs_error_fmt(hdl, EZFS_POOLUNAVAIL,
	dgettext(TEXT_DOMAIN, "zfs shutdown"));
	goto out;
	case ENOENT:
	/* Blocking error case should not occur */
	if (!(flags & ZEVENT_NONBLOCK))
	error = zpool_standard_error_fmt(hdl, errno,
	dgettext(TEXT_DOMAIN, "cannot get event"));

	goto out;
	case ENOMEM:
	if (zcmd_expand_dst_nvlist(hdl, &zc) != 0) {
	error = zfs_error_fmt(hdl, EZFS_NOMEM,
	dgettext(TEXT_DOMAIN, "cannot get event"));
	goto out;
	} else {
	goto retry;
	}
	default:
	error = zpool_standard_error_fmt(hdl, errno,
	dgettext(TEXT_DOMAIN, "cannot get event"));
	goto out;
	}
	}

	error = zcmd_read_dst_nvlist(hdl, &zc, nvp);
	if (error != 0)
	goto out;

	*dropped = (int)zc.zc_cookie;
	out:
	zcmd_free_nvlists(&zc);

	return (error);
	}

	/*
	* Clear all events.
	*/
	int
	zpool_events_clear(libzfs_handle_t hdl, int count)
	{
	zfs_cmd_t zc = {"\0"};
	char msg[1024];

	(void) snprintf(msg, sizeof (msg), dgettext(TEXT_DOMAIN,
	"cannot clear events"));

	if (zfs_ioctl(hdl, ZFS_IOC_EVENTS_CLEAR, &zc) != 0)
	return (zpool_standard_error_fmt(hdl, errno, msg));

	if (count != NULL)
	count = (int)zc.zc_cookie; / # of events cleared */

	return (0);
	}

	/*
	* Seek to a specific EID, ZEVENT_SEEK_START, or ZEVENT_SEEK_END for
	* the passed zevent_fd file handle. On success zero is returned,
	* otherwise -1 is returned and hdl->libzfs_error is set to the errno.
	*/
	int
	zpool_events_seek(libzfs_handle_t *hdl, uint64_t eid, int zevent_fd)
	{
	zfs_cmd_t zc = {"\0"};
	int error = 0;

	zc.zc_guid = eid;
	zc.zc_cleanup_fd = zevent_fd;

	if (zfs_ioctl(hdl, ZFS_IOC_EVENTS_SEEK, &zc) != 0) {
	switch (errno) {
	case ENOENT:
	error = zfs_error_fmt(hdl, EZFS_NOENT,
	dgettext(TEXT_DOMAIN, "cannot get event"));
	break;

	case ENOMEM:
	error = zfs_error_fmt(hdl, EZFS_NOMEM,
	dgettext(TEXT_DOMAIN, "cannot get event"));
	break;

	default:
	error = zpool_standard_error_fmt(hdl, errno,
	dgettext(TEXT_DOMAIN, "cannot get event"));
	break;
	}
	}

	return (error);
	}

	static void
	zpool_obj_to_path_impl(zpool_handle_t *zhp, uint64_t dsobj, uint64_t obj,
	char *pathname, size_t len, boolean_t always_unmounted)
	{
	zfs_cmd_t zc = {"\0"};
	boolean_t mounted = B_FALSE;
	char *mntpnt = NULL;
	char dsname[ZFS_MAX_DATASET_NAME_LEN];

	if (dsobj == 0) {
	/* special case for the MOS */
	(void) snprintf(pathname, len, "<metadata>:<0x%llx>",
	(longlong_t)obj);
	return;
	}

	/* get the dataset's name */
	(void) strlcpy(zc.zc_name, zhp->zpool_name, sizeof (zc.zc_name));
	zc.zc_obj = dsobj;
	if (zfs_ioctl(zhp->zpool_hdl,
	ZFS_IOC_DSOBJ_TO_DSNAME, &zc) != 0) {
	/* just write out a path of two object numbers */
	(void) snprintf(pathname, len, "<0x%llx>:<0x%llx>",
	(longlong_t)dsobj, (longlong_t)obj);
	return;
	}
	(void) strlcpy(dsname, zc.zc_value, sizeof (dsname));

	/* find out if the dataset is mounted */
	mounted = !always_unmounted && is_mounted(zhp->zpool_hdl, dsname,
	&mntpnt);

	/* get the corrupted object's path */
	(void) strlcpy(zc.zc_name, dsname, sizeof (zc.zc_name));
	zc.zc_obj = obj;
	if (zfs_ioctl(zhp->zpool_hdl, ZFS_IOC_OBJ_TO_PATH,
	&zc) == 0) {
	if (mounted) {
	(void) snprintf(pathname, len, "%s%s", mntpnt,
	zc.zc_value);
	} else {
	(void) snprintf(pathname, len, "%s:%s",
	dsname, zc.zc_value);
	}
	} else {
	(void) snprintf(pathname, len, "%s:<0x%llx>", dsname,
	(longlong_t)obj);
	}
	free(mntpnt);
	}

	void
	zpool_obj_to_path(zpool_handle_t *zhp, uint64_t dsobj, uint64_t obj,
	char *pathname, size_t len)
	{
	zpool_obj_to_path_impl(zhp, dsobj, obj, pathname, len, B_FALSE);
	}

	void
	zpool_obj_to_path_ds(zpool_handle_t *zhp, uint64_t dsobj, uint64_t obj,
	char *pathname, size_t len)
	{
	zpool_obj_to_path_impl(zhp, dsobj, obj, pathname, len, B_TRUE);
	}
	/*
	* Wait while the specified activity is in progress in the pool.
	*/
	int
	zpool_wait(zpool_handle_t *zhp, zpool_wait_activity_t activity)
	{
	boolean_t missing;

	int error = zpool_wait_status(zhp, activity, &missing, NULL);

	if (missing) {
	(void) zpool_standard_error_fmt(zhp->zpool_hdl, ENOENT,
	dgettext(TEXT_DOMAIN, "error waiting in pool '%s'"),
	zhp->zpool_name);
	return (ENOENT);
	} else {
	return (error);
	}
	}

	/*
	* Wait for the given activity and return the status of the wait (whether or not
	* any waiting was done) in the 'waited' parameter. Non-existent pools are
	* reported via the 'missing' parameter, rather than by printing an error
	* message. This is convenient when this function is called in a loop over a
	* long period of time (as it is, for example, by zpool's wait cmd). In that
	* scenario, a pool being exported or destroyed should be considered a normal
	* event, so we don't want to print an error when we find that the pool doesn't
	* exist.
	*/
	int
	zpool_wait_status(zpool_handle_t *zhp, zpool_wait_activity_t activity,
	boolean_t missing, boolean_t waited)
	{
	int error = lzc_wait(zhp->zpool_name, activity, waited);
	*missing = (error == ENOENT);
	if (*missing)
	return (0);

	if (error != 0) {
	(void) zpool_standard_error_fmt(zhp->zpool_hdl, error,
	dgettext(TEXT_DOMAIN, "error waiting in pool '%s'"),
	zhp->zpool_name);
	}

	return (error);
	}

	int
	zpool_set_bootenv(zpool_handle_t zhp, const nvlist_t envmap)
	{
	int error = lzc_set_bootenv(zhp->zpool_name, envmap);
	if (error != 0) {
	(void) zpool_standard_error_fmt(zhp->zpool_hdl, error,
	dgettext(TEXT_DOMAIN,
	"error setting bootenv in pool '%s'"), zhp->zpool_name);
	}

	return (error);
	}

	int
	zpool_get_bootenv(zpool_handle_t zhp, nvlist_t *nvlp)
	{
	nvlist_t *nvl;
	int error;

	nvl = NULL;
	error = lzc_get_bootenv(zhp->zpool_name, &nvl);
	if (error != 0) {
	(void) zpool_standard_error_fmt(zhp->zpool_hdl, error,
	dgettext(TEXT_DOMAIN,
	"error getting bootenv in pool '%s'"), zhp->zpool_name);
	} else {
	*nvlp = nvl;
	}

	return (error);
	}

	/*
	* Attempt to read and parse feature file(s) (from "compatibility" property).
	* Files contain zpool feature names, comma or whitespace-separated.
	* Comments (# character to next newline) are discarded.
	*
	* Arguments:
	* compatibility : string containing feature filenames
	* features : either NULL or pointer to array of boolean
	- * badtoken : either NULL or pointer to char[ZFS_MAXPROPLEN]
	- * badfile : either NULL or pointer to char[MAXPATHLEN]
	+ * report : either NULL or pointer to string buffer
	+ * rlen : length of "report" buffer
	*
	* compatibility is NULL (unset), "", "off", "legacy", or list of
	* comma-separated filenames. filenames should either be absolute,
	* or relative to:
	* 1) ZPOOL_SYSCONF_COMPAT_D (eg: /etc/zfs/compatibility.d) or
	* 2) ZPOOL_DATA_COMPAT_D (eg: /usr/share/zfs/compatibility.d).
	* (Unset), "" or "off" => enable all features
	* "legacy" => disable all features
	+ *
	* Any feature names read from files which match unames in spa_feature_table
	* will have the corresponding boolean set in the features array (if non-NULL).
	* If more than one feature set specified, only features present in all of
	* them will be set.
	*
	- * An unreadable filename will be strlcpy'd to badfile (if non-NULL).
	- * An unrecognized feature will be strlcpy'd to badtoken (if non-NULL).
	+ * "report" if not NULL will be populated with a suitable status message.
	*
	* Return values:
	* ZPOOL_COMPATIBILITY_OK : files read and parsed ok
	- * ZPOOL_COMPATIBILITY_READERR : file could not be opened / mmap'd
	* ZPOOL_COMPATIBILITY_BADFILE : file too big or not a text file
	- * ZPOOL_COMPATIBILITY_BADWORD : file contains invalid feature name
	- * ZPOOL_COMPATIBILITY_NOFILES : no file names found
	+ * ZPOOL_COMPATIBILITY_BADTOKEN : SYSCONF file contains invalid feature name
	+ * ZPOOL_COMPATIBILITY_WARNTOKEN : DATA file contains invalid feature name
	+ * ZPOOL_COMPATIBILITY_NOFILES : no feature files found
	*/
	zpool_compat_status_t
	-zpool_load_compat(const char *compatibility,
	- boolean_t features, char badtoken, char *badfile)
	+zpool_load_compat(const char compat, boolean_t features, char *report,
	+ size_t rlen)
	{
	int sdirfd, ddirfd, featfd;
	- int i;
	struct stat fs;
	- char fc; / mmap of file */
	- char ps, ls, ws; / strtok state */
	+ char *fc;
	+ char ps, ls, *ws;
	char file, line, *word;
	- char filenames[ZFS_MAXPROPLEN];
	- int filecount = 0;
	+
	+ char l_compat[ZFS_MAXPROPLEN];
	+
	+ boolean_t ret_nofiles = B_TRUE;
	+ boolean_t ret_badfile = B_FALSE;
	+ boolean_t ret_badtoken = B_FALSE;
	+ boolean_t ret_warntoken = B_FALSE;

	/* special cases (unset), "" and "off" => enable all features */
	- if (compatibility == NULL \|\| compatibility[0] == '\0' \|\|
	- strcmp(compatibility, ZPOOL_COMPAT_OFF) == 0) {
	+ if (compat == NULL \|\| compat[0] == '\0' \|\|
	+ strcmp(compat, ZPOOL_COMPAT_OFF) == 0) {
	if (features != NULL)
	- for (i = 0; i < SPA_FEATURES; i++)
	+ for (uint_t i = 0; i < SPA_FEATURES; i++)
	features[i] = B_TRUE;
	+ if (report != NULL)
	+ strlcpy(report, gettext("all features enabled"), rlen);
	return (ZPOOL_COMPATIBILITY_OK);
	}

	/* Final special case "legacy" => disable all features */
	- if (strcmp(compatibility, ZPOOL_COMPAT_LEGACY) == 0) {
	+ if (strcmp(compat, ZPOOL_COMPAT_LEGACY) == 0) {
	if (features != NULL)
	- for (i = 0; i < SPA_FEATURES; i++)
	+ for (uint_t i = 0; i < SPA_FEATURES; i++)
	features[i] = B_FALSE;
	+ if (report != NULL)
	+ strlcpy(report, gettext("all features disabled"), rlen);
	return (ZPOOL_COMPATIBILITY_OK);
	}

	/*
	* Start with all true; will be ANDed with results from each file
	*/
	if (features != NULL)
	- for (i = 0; i < SPA_FEATURES; i++)
	+ for (uint_t i = 0; i < SPA_FEATURES; i++)
	features[i] = B_TRUE;

	+ char err_badfile[1024] = "";
	+ char err_badtoken[1024] = "";
	+
	/*
	* We ignore errors from the directory open()
	* as they're only needed if the filename is relative
	* which will be checked during the openat().
	*/
	-#ifdef O_PATH
	- sdirfd = open(ZPOOL_SYSCONF_COMPAT_D, O_DIRECTORY \| O_PATH);
	- ddirfd = open(ZPOOL_DATA_COMPAT_D, O_DIRECTORY \| O_PATH);
	-#else
	- sdirfd = open(ZPOOL_SYSCONF_COMPAT_D, O_DIRECTORY \| O_RDONLY);
	- ddirfd = open(ZPOOL_DATA_COMPAT_D, O_DIRECTORY \| O_RDONLY);
	+#ifndef O_PATH
	+#define O_PATH O_RDONLY
	#endif
	+ sdirfd = open(ZPOOL_SYSCONF_COMPAT_D, O_DIRECTORY \| O_PATH \| O_CLOEXEC);
	+ ddirfd = open(ZPOOL_DATA_COMPAT_D, O_DIRECTORY \| O_PATH \| O_CLOEXEC);

	- (void) strlcpy(filenames, compatibility, ZFS_MAXPROPLEN);
	- file = strtok_r(filenames, ",", &ps);
	- while (file != NULL) {
	- boolean_t features_local[SPA_FEATURES];
	+ (void) strlcpy(l_compat, compat, ZFS_MAXPROPLEN);

	- /* try sysconfdir first, then datadir */
	- if ((featfd = openat(sdirfd, file, 0, O_RDONLY)) < 0)
	- featfd = openat(ddirfd, file, 0, O_RDONLY);
	+ for (file = strtok_r(l_compat, ",", &ps);
	+ file != NULL;
	+ file = strtok_r(NULL, ",", &ps)) {

	- if (featfd < 0 \|\| fstat(featfd, &fs) < 0) {
	- (void) close(featfd);
	- (void) close(sdirfd);
	- (void) close(ddirfd);
	- if (badfile != NULL)
	- (void) strlcpy(badfile, file, MAXPATHLEN);
	- return (ZPOOL_COMPATIBILITY_READERR);
	+ boolean_t l_features[SPA_FEATURES] = {B_FALSE};
	+
	+ enum { Z_SYSCONF, Z_DATA } source;
	+
	+ /* try sysconfdir first, then datadir */
	+ source = Z_SYSCONF;
	+ if ((featfd = openat(sdirfd, file, O_RDONLY \| O_CLOEXEC)) < 0) {
	+ featfd = openat(ddirfd, file, O_RDONLY \| O_CLOEXEC);
	+ source = Z_DATA;
	}

	- /* Too big or too small */
	- if (fs.st_size < 1 \|\| fs.st_size > ZPOOL_COMPAT_MAXSIZE) {
	+ /* File readable and correct size? */
	+ if (featfd < 0 \|\|
	+ fstat(featfd, &fs) < 0 \|\|
	+ fs.st_size < 1 \|\|
	+ fs.st_size > ZPOOL_COMPAT_MAXSIZE) {
	(void) close(featfd);
	- (void) close(sdirfd);
	- (void) close(ddirfd);
	- if (badfile != NULL)
	- (void) strlcpy(badfile, file, MAXPATHLEN);
	- return (ZPOOL_COMPATIBILITY_BADFILE);
	+ strlcat(err_badfile, file, ZFS_MAXPROPLEN);
	+ strlcat(err_badfile, " ", ZFS_MAXPROPLEN);
	+ ret_badfile = B_TRUE;
	+ continue;
	}

	+#if !defined(MAP_POPULATE) && defined(MAP_PREFAULT_READ)
	+#define MAP_POPULATE MAP_PREFAULT_READ
	+#elif !defined(MAP_POPULATE)
	+#define MAP_POPULATE 0
	+#endif
	/* private mmap() so we can strtok safely */
	fc = (char *)mmap(NULL, fs.st_size,
	- PROT_READ\|PROT_WRITE, MAP_PRIVATE, featfd, 0);
	+ PROT_READ\|PROT_WRITE, MAP_PRIVATE\|MAP_POPULATE, featfd, 0);
	(void) close(featfd);

	- if (fc < 0) {
	- (void) close(sdirfd);
	- (void) close(ddirfd);
	- if (badfile != NULL)
	- (void) strlcpy(badfile, file, MAXPATHLEN);
	- return (ZPOOL_COMPATIBILITY_READERR);
	- }
	-
	- /* Text file sanity check - last char should be newline */
	- if (fc[fs.st_size - 1] != '\n') {
	+ /* map ok, and last character == newline? */
	+ if (fc == MAP_FAILED \|\| fc[fs.st_size - 1] != '\n') {
	(void) munmap((void *) fc, fs.st_size);
	- (void) close(sdirfd);
	- (void) close(ddirfd);
	- if (badfile != NULL)
	- (void) strlcpy(badfile, file, MAXPATHLEN);
	- return (ZPOOL_COMPATIBILITY_BADFILE);
	+ strlcat(err_badfile, file, ZFS_MAXPROPLEN);
	+ strlcat(err_badfile, " ", ZFS_MAXPROPLEN);
	+ ret_badfile = B_TRUE;
	+ continue;
	}

	- /* replace with NUL to ensure we have a delimiter */
	- fc[fs.st_size - 1] = '\0';
	+ ret_nofiles = B_FALSE;

	- for (i = 0; i < SPA_FEATURES; i++)
	- features_local[i] = B_FALSE;
	+ /* replace last char with NUL to ensure we have a delimiter */
	+ fc[fs.st_size - 1] = '\0';

	- line = strtok_r(fc, "\n", &ls);
	- while (line != NULL) {
	+ for (line = strtok_r(fc, "\n", &ls);
	+ line != NULL;
	+ line = strtok_r(NULL, "\n", &ls)) {
	/* discard comments */
	*(strchrnul(line, '#')) = '\0';

	- word = strtok_r(line, ", \t", &ws);
	- while (word != NULL) {
	+ for (word = strtok_r(line, ", \t", &ws);
	+ word != NULL;
	+ word = strtok_r(NULL, ", \t", &ws)) {
	/* Find matching feature name */
	- for (i = 0; i < SPA_FEATURES; i++) {
	+ uint_t f;
	+ for (f = 0; f < SPA_FEATURES; f++) {
	zfeature_info_t *fi =
	- &spa_feature_table[i];
	+ &spa_feature_table[f];
	if (strcmp(word, fi->fi_uname) == 0) {
	- features_local[i] = B_TRUE;
	+ l_features[f] = B_TRUE;
	break;
	}
	}
	- if (i == SPA_FEATURES) {
	- if (badtoken != NULL)
	- (void) strlcpy(badtoken, word,
	- ZFS_MAXPROPLEN);
	- if (badfile != NULL)
	- (void) strlcpy(badfile, file,
	- MAXPATHLEN);
	- (void) munmap((void *) fc, fs.st_size);
	- (void) close(sdirfd);
	- (void) close(ddirfd);
	- return (ZPOOL_COMPATIBILITY_BADWORD);
	- }
	- word = strtok_r(NULL, ", \t", &ws);
	+ if (f < SPA_FEATURES)
	+ continue;
	+
	+ /* found an unrecognized word */
	+ /* lightly sanitize it */
	+ if (strlen(word) > 32)
	+ word[32] = '\0';
	+ for (char c = word; c != '\0'; c++)
	+ if (!isprint(*c))
	+ *c = '?';
	+
	+ strlcat(err_badtoken, word, ZFS_MAXPROPLEN);
	+ strlcat(err_badtoken, " ", ZFS_MAXPROPLEN);
	+ if (source == Z_SYSCONF)
	+ ret_badtoken = B_TRUE;
	+ else
	+ ret_warntoken = B_TRUE;
	}
	- line = strtok_r(NULL, "\n", &ls);
	}
	(void) munmap((void *) fc, fs.st_size);
	- if (features != NULL) {
	- for (i = 0; i < SPA_FEATURES; i++)
	- features[i] &= features_local[i];
	- }
	- filecount++;
	- file = strtok_r(NULL, ",", &ps);
	+
	+ if (features != NULL)
	+ for (uint_t i = 0; i < SPA_FEATURES; i++)
	+ features[i] &= l_features[i];
	}
	(void) close(sdirfd);
	(void) close(ddirfd);
	- if (filecount == 0)
	+
	+ /* Return the most serious error */
	+ if (ret_badfile) {
	+ if (report != NULL)
	+ snprintf(report, rlen, gettext("could not read/"
	+ "parse feature file(s): %s"), err_badfile);
	+ return (ZPOOL_COMPATIBILITY_BADFILE);
	+ }
	+ if (ret_nofiles) {
	+ if (report != NULL)
	+ strlcpy(report,
	+ gettext("no valid compatibility files specified"),
	+ rlen);
	return (ZPOOL_COMPATIBILITY_NOFILES);
	+ }
	+ if (ret_badtoken) {
	+ if (report != NULL)
	+ snprintf(report, rlen, gettext("invalid feature "
	+ "name(s) in local compatibility files: %s"),
	+ err_badtoken);
	+ return (ZPOOL_COMPATIBILITY_BADTOKEN);
	+ }
	+ if (ret_warntoken) {
	+ if (report != NULL)
	+ snprintf(report, rlen, gettext("unrecognized feature "
	+ "name(s) in distribution compatibility files: %s"),
	+ err_badtoken);
	+ return (ZPOOL_COMPATIBILITY_WARNTOKEN);
	+ }
	+ if (report != NULL)
	+ strlcpy(report, gettext("compatibility set ok"), rlen);
	return (ZPOOL_COMPATIBILITY_OK);
	}
	diff --git a/sys/contrib/openzfs/lib/libzfs/libzfs_sendrecv.c b/sys/contrib/openzfs/lib/libzfs/libzfs_sendrecv.c
	index bc887e72a23c..511895d18658 100644
	--- a/sys/contrib/openzfs/lib/libzfs/libzfs_sendrecv.c
	+++ b/sys/contrib/openzfs/lib/libzfs/libzfs_sendrecv.c
	@@ -1,5181 +1,5201 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2011, 2020 by Delphix. All rights reserved.
	* Copyright (c) 2012, Joyent, Inc. All rights reserved.
	* Copyright (c) 2012 Pawel Jakub Dawidek <pawel@dawidek.net>.
	* All rights reserved
	* Copyright (c) 2013 Steven Hartland. All rights reserved.
	* Copyright 2015, OmniTI Computer Consulting, Inc. All rights reserved.
	* Copyright 2016 Igor Kozhukhov <ikozhukhov@gmail.com>
	* Copyright (c) 2018, loli10K <ezomori.nozomu@gmail.com>. All rights reserved.
	* Copyright (c) 2019 Datto Inc.
	*/

	#include <assert.h>
	#include <ctype.h>
	#include <errno.h>
	#include <libintl.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <strings.h>
	#include <unistd.h>
	#include <stddef.h>
	#include <fcntl.h>
	#include <sys/mount.h>
	#include <sys/mntent.h>
	#include <sys/mnttab.h>
	#include <sys/avl.h>
	#include <sys/debug.h>
	#include <sys/stat.h>
	#include <pthread.h>
	#include <umem.h>
	#include <time.h>

	#include <libzfs.h>
	#include <libzfs_core.h>
	#include <libzutil.h>

	#include "zfs_namecheck.h"
	#include "zfs_prop.h"
	#include "zfs_fletcher.h"
	#include "libzfs_impl.h"
	#include <cityhash.h>
	#include <zlib.h>
	#include <sys/zio_checksum.h>
	#include <sys/dsl_crypt.h>
	#include <sys/ddt.h>
	#include <sys/socket.h>
	#include <sys/sha2.h>

	static int zfs_receive_impl(libzfs_handle_t , const char , const char *,
	recvflags_t , int, const char , nvlist_t , avl_tree_t , char **,
	const char , nvlist_t );
	static int guid_to_name_redact_snaps(libzfs_handle_t hdl, const char parent,
	uint64_t guid, boolean_t bookmark_ok, uint64_t *redact_snap_guids,
	uint64_t num_redact_snaps, char *name);
	static int guid_to_name(libzfs_handle_t , const char ,
	uint64_t, boolean_t, char *);

	typedef struct progress_arg {
	zfs_handle_t *pa_zhp;
	int pa_fd;
	boolean_t pa_parsable;
	boolean_t pa_estimate;
	int pa_verbosity;
	} progress_arg_t;

	static int
	dump_record(dmu_replay_record_t drr, void payload, int payload_len,
	zio_cksum_t *zc, int outfd)
	{
	ASSERT3U(offsetof(dmu_replay_record_t, drr_u.drr_checksum.drr_checksum),
	==, sizeof (dmu_replay_record_t) - sizeof (zio_cksum_t));
	fletcher_4_incremental_native(drr,
	offsetof(dmu_replay_record_t, drr_u.drr_checksum.drr_checksum), zc);
	if (drr->drr_type != DRR_BEGIN) {
	ASSERT(ZIO_CHECKSUM_IS_ZERO(&drr->drr_u.
	drr_checksum.drr_checksum));
	drr->drr_u.drr_checksum.drr_checksum = *zc;
	}
	fletcher_4_incremental_native(&drr->drr_u.drr_checksum.drr_checksum,
	sizeof (zio_cksum_t), zc);
	if (write(outfd, drr, sizeof (*drr)) == -1)
	return (errno);
	if (payload_len != 0) {
	fletcher_4_incremental_native(payload, payload_len, zc);
	if (write(outfd, payload, payload_len) == -1)
	return (errno);
	}
	return (0);
	}

	/*
	* Routines for dealing with the AVL tree of fs-nvlists
	*/
	typedef struct fsavl_node {
	avl_node_t fn_node;
	nvlist_t *fn_nvfs;
	char *fn_snapname;
	uint64_t fn_guid;
	} fsavl_node_t;

	static int
	fsavl_compare(const void arg1, const void arg2)
	{
	const fsavl_node_t fn1 = (const fsavl_node_t )arg1;
	const fsavl_node_t fn2 = (const fsavl_node_t )arg2;

	return (TREE_CMP(fn1->fn_guid, fn2->fn_guid));
	}

	/*
	* Given the GUID of a snapshot, find its containing filesystem and
	* (optionally) name.
	*/
	static nvlist_t *
	fsavl_find(avl_tree_t avl, uint64_t snapguid, char *snapname)
	{
	fsavl_node_t fn_find;
	fsavl_node_t *fn;

	fn_find.fn_guid = snapguid;

	fn = avl_find(avl, &fn_find, NULL);
	if (fn) {
	if (snapname)
	*snapname = fn->fn_snapname;
	return (fn->fn_nvfs);
	}
	return (NULL);
	}

	static void
	fsavl_destroy(avl_tree_t *avl)
	{
	fsavl_node_t *fn;
	void *cookie;

	if (avl == NULL)
	return;

	cookie = NULL;
	while ((fn = avl_destroy_nodes(avl, &cookie)) != NULL)
	free(fn);
	avl_destroy(avl);
	free(avl);
	}

	/*
	* Given an nvlist, produce an avl tree of snapshots, ordered by guid
	*/
	static avl_tree_t *
	fsavl_create(nvlist_t *fss)
	{
	avl_tree_t *fsavl;
	nvpair_t *fselem = NULL;

	if ((fsavl = malloc(sizeof (avl_tree_t))) == NULL)
	return (NULL);

	avl_create(fsavl, fsavl_compare, sizeof (fsavl_node_t),
	offsetof(fsavl_node_t, fn_node));

	while ((fselem = nvlist_next_nvpair(fss, fselem)) != NULL) {
	nvlist_t nvfs, snaps;
	nvpair_t *snapelem = NULL;

	nvfs = fnvpair_value_nvlist(fselem);
	snaps = fnvlist_lookup_nvlist(nvfs, "snaps");

	while ((snapelem =
	nvlist_next_nvpair(snaps, snapelem)) != NULL) {
	fsavl_node_t *fn;
	uint64_t guid;

	guid = fnvpair_value_uint64(snapelem);
	if ((fn = malloc(sizeof (fsavl_node_t))) == NULL) {
	fsavl_destroy(fsavl);
	return (NULL);
	}
	fn->fn_nvfs = nvfs;
	fn->fn_snapname = nvpair_name(snapelem);
	fn->fn_guid = guid;

	/*
	* Note: if there are multiple snaps with the
	* same GUID, we ignore all but one.
	*/
	if (avl_find(fsavl, fn, NULL) == NULL)
	avl_add(fsavl, fn);
	else
	free(fn);
	}
	}

	return (fsavl);
	}

	/*
	* Routines for dealing with the giant nvlist of fs-nvlists, etc.
	*/
	typedef struct send_data {
	/*
	* assigned inside every recursive call,
	* restored from *_save on return:
	*
	* guid of fromsnap snapshot in parent dataset
	* txg of fromsnap snapshot in current dataset
	* txg of tosnap snapshot in current dataset
	*/

	uint64_t parent_fromsnap_guid;
	uint64_t fromsnap_txg;
	uint64_t tosnap_txg;

	/* the nvlists get accumulated during depth-first traversal */
	nvlist_t *parent_snaps;
	nvlist_t *fss;
	nvlist_t *snapprops;
	nvlist_t snapholds; / user holds */

	/* send-receive configuration, does not change during traversal */
	const char *fsname;
	const char *fromsnap;
	const char *tosnap;
	boolean_t recursive;
	boolean_t raw;
	boolean_t doall;
	boolean_t replicate;
	+ boolean_t skipmissing;
	boolean_t verbose;
	boolean_t backup;
	boolean_t seenfrom;
	boolean_t seento;
	boolean_t holds; /* were holds requested with send -h */
	boolean_t props;

	/*
	* The header nvlist is of the following format:
	* {
	* "tosnap" -> string
	* "fromsnap" -> string (if incremental)
	* "fss" -> {
	* id -> {
	*
	* "name" -> string (full name; for debugging)
	* "parentfromsnap" -> number (guid of fromsnap in parent)
	*
	* "props" -> { name -> value (only if set here) }
	* "snaps" -> { name (lastname) -> number (guid) }
	* "snapprops" -> { name (lastname) -> { name -> value } }
	* "snapholds" -> { name (lastname) -> { holdname -> crtime } }
	*
	* "origin" -> number (guid) (if clone)
	* "is_encroot" -> boolean
	* "sent" -> boolean (not on-disk)
	* }
	* }
	* }
	*
	*/
	} send_data_t;

	static void
	send_iterate_prop(zfs_handle_t zhp, boolean_t received_only, nvlist_t nv);

	static int
	send_iterate_snap(zfs_handle_t zhp, void arg)
	{
	send_data_t *sd = arg;
	uint64_t guid = zhp->zfs_dmustats.dds_guid;
	uint64_t txg = zhp->zfs_dmustats.dds_creation_txg;
	char *snapname;
	nvlist_t *nv;
	boolean_t isfromsnap, istosnap, istosnapwithnofrom;

	snapname = strrchr(zhp->zfs_name, '@')+1;
	isfromsnap = (sd->fromsnap != NULL &&
	strcmp(sd->fromsnap, snapname) == 0);
	istosnap = (sd->tosnap != NULL && (strcmp(sd->tosnap, snapname) == 0));
	istosnapwithnofrom = (istosnap && sd->fromsnap == NULL);

	if (sd->tosnap_txg != 0 && txg > sd->tosnap_txg) {
	if (sd->verbose) {
	(void) fprintf(stderr, dgettext(TEXT_DOMAIN,
	"skipping snapshot %s because it was created "
	"after the destination snapshot (%s)\n"),
	zhp->zfs_name, sd->tosnap);
	}
	zfs_close(zhp);
	return (0);
	}

	fnvlist_add_uint64(sd->parent_snaps, snapname, guid);
	/*
	* NB: if there is no fromsnap here (it's a newly created fs in
	* an incremental replication), we will substitute the tosnap.
	*/
	if (isfromsnap \|\| (sd->parent_fromsnap_guid == 0 && istosnap)) {
	sd->parent_fromsnap_guid = guid;
	}

	if (!sd->recursive) {

	/*
	* To allow a doall stream to work properly
	* with a NULL fromsnap
	*/
	if (sd->doall && sd->fromsnap == NULL && !sd->seenfrom) {
	sd->seenfrom = B_TRUE;
	}

	if (!sd->seenfrom && isfromsnap) {
	sd->seenfrom = B_TRUE;
	zfs_close(zhp);
	return (0);
	}

	if ((sd->seento \|\| !sd->seenfrom) && !istosnapwithnofrom) {
	zfs_close(zhp);
	return (0);
	}

	if (istosnap)
	sd->seento = B_TRUE;
	}

	nv = fnvlist_alloc();
	send_iterate_prop(zhp, sd->backup, nv);
	fnvlist_add_nvlist(sd->snapprops, snapname, nv);
	fnvlist_free(nv);
	if (sd->holds) {
	nvlist_t *holds = fnvlist_alloc();
	int err = lzc_get_holds(zhp->zfs_name, &holds);
	if (err == 0) {
	fnvlist_add_nvlist(sd->snapholds, snapname, holds);
	}
	fnvlist_free(holds);
	}

	zfs_close(zhp);
	return (0);
	}

	static void
	send_iterate_prop(zfs_handle_t zhp, boolean_t received_only, nvlist_t nv)
	{
	nvlist_t *props = NULL;
	nvpair_t *elem = NULL;

	if (received_only)
	props = zfs_get_recvd_props(zhp);
	else
	props = zhp->zfs_props;

	while ((elem = nvlist_next_nvpair(props, elem)) != NULL) {
	char *propname = nvpair_name(elem);
	zfs_prop_t prop = zfs_name_to_prop(propname);
	nvlist_t *propnv;

	if (!zfs_prop_user(propname)) {
	/*
	* Realistically, this should never happen. However,
	* we want the ability to add DSL properties without
	* needing to make incompatible version changes. We
	* need to ignore unknown properties to allow older
	* software to still send datasets containing these
	* properties, with the unknown properties elided.
	*/
	if (prop == ZPROP_INVAL)
	continue;

	if (zfs_prop_readonly(prop))
	continue;
	}

	verify(nvpair_value_nvlist(elem, &propnv) == 0);
	if (prop == ZFS_PROP_QUOTA \|\| prop == ZFS_PROP_RESERVATION \|\|
	prop == ZFS_PROP_REFQUOTA \|\|
	prop == ZFS_PROP_REFRESERVATION) {
	char *source;
	uint64_t value;
	verify(nvlist_lookup_uint64(propnv,
	ZPROP_VALUE, &value) == 0);
	if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT)
	continue;
	/*
	* May have no source before SPA_VERSION_RECVD_PROPS,
	* but is still modifiable.
	*/
	if (nvlist_lookup_string(propnv,
	ZPROP_SOURCE, &source) == 0) {
	if ((strcmp(source, zhp->zfs_name) != 0) &&
	(strcmp(source,
	ZPROP_SOURCE_VAL_RECVD) != 0))
	continue;
	}
	} else {
	char *source;
	if (nvlist_lookup_string(propnv,
	ZPROP_SOURCE, &source) != 0)
	continue;
	if ((strcmp(source, zhp->zfs_name) != 0) &&
	(strcmp(source, ZPROP_SOURCE_VAL_RECVD) != 0))
	continue;
	}

	if (zfs_prop_user(propname) \|\|
	zfs_prop_get_type(prop) == PROP_TYPE_STRING) {
	char *value;
	value = fnvlist_lookup_string(propnv, ZPROP_VALUE);
	fnvlist_add_string(nv, propname, value);
	} else {
	uint64_t value;
	value = fnvlist_lookup_uint64(propnv, ZPROP_VALUE);
	fnvlist_add_uint64(nv, propname, value);
	}
	}
	}

	/*
	* returns snapshot creation txg
	* and returns 0 if the snapshot does not exist
	*/
	static uint64_t
	get_snap_txg(libzfs_handle_t hdl, const char fs, const char *snap)
	{
	char name[ZFS_MAX_DATASET_NAME_LEN];
	uint64_t txg = 0;

	if (fs == NULL \|\| fs[0] == '\0' \|\| snap == NULL \|\| snap[0] == '\0')
	return (txg);

	(void) snprintf(name, sizeof (name), "%s@%s", fs, snap);
	if (zfs_dataset_exists(hdl, name, ZFS_TYPE_SNAPSHOT)) {
	zfs_handle_t *zhp = zfs_open(hdl, name, ZFS_TYPE_SNAPSHOT);
	if (zhp != NULL) {
	txg = zfs_prop_get_int(zhp, ZFS_PROP_CREATETXG);
	zfs_close(zhp);
	}
	}

	return (txg);
	}

	/*
	* recursively generate nvlists describing datasets. See comment
	* for the data structure send_data_t above for description of contents
	* of the nvlist.
	*/
	static int
	send_iterate_fs(zfs_handle_t zhp, void arg)
	{
	send_data_t *sd = arg;
	nvlist_t nvfs = NULL, nv = NULL;
	int rv = 0;
	uint64_t min_txg = 0, max_txg = 0;
	uint64_t parent_fromsnap_guid_save = sd->parent_fromsnap_guid;
	uint64_t fromsnap_txg_save = sd->fromsnap_txg;
	uint64_t tosnap_txg_save = sd->tosnap_txg;
	uint64_t txg = zhp->zfs_dmustats.dds_creation_txg;
	uint64_t guid = zhp->zfs_dmustats.dds_guid;
	uint64_t fromsnap_txg, tosnap_txg;
	char guidstring[64];

	fromsnap_txg = get_snap_txg(zhp->zfs_hdl, zhp->zfs_name, sd->fromsnap);
	if (fromsnap_txg != 0)
	sd->fromsnap_txg = fromsnap_txg;

	tosnap_txg = get_snap_txg(zhp->zfs_hdl, zhp->zfs_name, sd->tosnap);
	if (tosnap_txg != 0)
	sd->tosnap_txg = tosnap_txg;

	/*
	* on the send side, if the current dataset does not have tosnap,
	* perform two additional checks:
	*
	* - skip sending the current dataset if it was created later than
	* the parent tosnap
	* - return error if the current dataset was created earlier than
	- * the parent tosnap
	+ * the parent tosnap, unless --skip-missing specified. Then
	+ * just print a warning
	*/
	if (sd->tosnap != NULL && tosnap_txg == 0) {
	if (sd->tosnap_txg != 0 && txg > sd->tosnap_txg) {
	if (sd->verbose) {
	(void) fprintf(stderr, dgettext(TEXT_DOMAIN,
	"skipping dataset %s: snapshot %s does "
	"not exist\n"), zhp->zfs_name, sd->tosnap);
	}
	+ } else if (sd->skipmissing) {
	+ (void) fprintf(stderr, dgettext(TEXT_DOMAIN,
	+ "WARNING: skipping dataset %s and its children:"
	+ " snapshot %s does not exist\n"),
	+ zhp->zfs_name, sd->tosnap);
	} else {
	(void) fprintf(stderr, dgettext(TEXT_DOMAIN,
	"cannot send %s@%s%s: snapshot %s@%s does not "
	"exist\n"), sd->fsname, sd->tosnap, sd->recursive ?
	dgettext(TEXT_DOMAIN, " recursively") : "",
	zhp->zfs_name, sd->tosnap);
	rv = EZFS_NOENT;
	}
	goto out;
	}

	nvfs = fnvlist_alloc();
	fnvlist_add_string(nvfs, "name", zhp->zfs_name);
	fnvlist_add_uint64(nvfs, "parentfromsnap",
	sd->parent_fromsnap_guid);

	if (zhp->zfs_dmustats.dds_origin[0]) {
	zfs_handle_t *origin = zfs_open(zhp->zfs_hdl,
	zhp->zfs_dmustats.dds_origin, ZFS_TYPE_SNAPSHOT);
	if (origin == NULL) {
	rv = -1;
	goto out;
	}
	fnvlist_add_uint64(nvfs, "origin",
	origin->zfs_dmustats.dds_guid);

	zfs_close(origin);
	}

	/* iterate over props */
	if (sd->props \|\| sd->backup \|\| sd->recursive) {
	nv = fnvlist_alloc();
	send_iterate_prop(zhp, sd->backup, nv);
	}
	if (zfs_prop_get_int(zhp, ZFS_PROP_ENCRYPTION) != ZIO_CRYPT_OFF) {
	boolean_t encroot;

	/* determine if this dataset is an encryption root */
	if (zfs_crypto_get_encryption_root(zhp, &encroot, NULL) != 0) {
	rv = -1;
	goto out;
	}

	if (encroot)
	fnvlist_add_boolean(nvfs, "is_encroot");

	/*
	* Encrypted datasets can only be sent with properties if
	* the raw flag is specified because the receive side doesn't
	* currently have a mechanism for recursively asking the user
	* for new encryption parameters.
	*/
	if (!sd->raw) {
	(void) fprintf(stderr, dgettext(TEXT_DOMAIN,
	"cannot send %s@%s: encrypted dataset %s may not "
	"be sent with properties without the raw flag\n"),
	sd->fsname, sd->tosnap, zhp->zfs_name);
	rv = -1;
	goto out;
	}

	}

	if (nv != NULL)
	fnvlist_add_nvlist(nvfs, "props", nv);

	/* iterate over snaps, and set sd->parent_fromsnap_guid */
	sd->parent_fromsnap_guid = 0;
	sd->parent_snaps = fnvlist_alloc();
	sd->snapprops = fnvlist_alloc();
	if (sd->holds)
	sd->snapholds = fnvlist_alloc();

	/*
	* If this is a "doall" send, a replicate send or we're just trying
	* to gather a list of previous snapshots, iterate through all the
	* snaps in the txg range. Otherwise just look at the one we're
	* interested in.
	*/
	if (sd->doall \|\| sd->replicate \|\| sd->tosnap == NULL) {
	if (!sd->replicate && fromsnap_txg != 0)
	min_txg = fromsnap_txg;
	if (!sd->replicate && tosnap_txg != 0)
	max_txg = tosnap_txg;
	(void) zfs_iter_snapshots_sorted(zhp, send_iterate_snap, sd,
	min_txg, max_txg);
	} else {
	char snapname[MAXPATHLEN] = { 0 };
	zfs_handle_t *snap;

	(void) snprintf(snapname, sizeof (snapname), "%s@%s",
	zhp->zfs_name, sd->tosnap);
	if (sd->fromsnap != NULL)
	sd->seenfrom = B_TRUE;
	snap = zfs_open(zhp->zfs_hdl, snapname,
	ZFS_TYPE_SNAPSHOT);
	if (snap != NULL)
	(void) send_iterate_snap(snap, sd);
	}

	fnvlist_add_nvlist(nvfs, "snaps", sd->parent_snaps);
	fnvlist_add_nvlist(nvfs, "snapprops", sd->snapprops);
	if (sd->holds)
	fnvlist_add_nvlist(nvfs, "snapholds", sd->snapholds);
	fnvlist_free(sd->parent_snaps);
	fnvlist_free(sd->snapprops);
	fnvlist_free(sd->snapholds);

	/* Do not allow the size of the properties list to exceed the limit */
	if ((fnvlist_size(nvfs) + fnvlist_size(sd->fss)) >
	zhp->zfs_hdl->libzfs_max_nvlist) {
	(void) fprintf(stderr, dgettext(TEXT_DOMAIN,
	"warning: cannot send %s@%s: the size of the list of "
	"snapshots and properties is too large to be received "
	"successfully.\n"
	"Select a smaller number of snapshots to send.\n"),
	zhp->zfs_name, sd->tosnap);
	rv = EZFS_NOSPC;
	goto out;
	}
	/* add this fs to nvlist */
	(void) snprintf(guidstring, sizeof (guidstring),
	"0x%llx", (longlong_t)guid);
	fnvlist_add_nvlist(sd->fss, guidstring, nvfs);

	/* iterate over children */
	if (sd->recursive)
	rv = zfs_iter_filesystems(zhp, send_iterate_fs, sd);

	out:
	sd->parent_fromsnap_guid = parent_fromsnap_guid_save;
	sd->fromsnap_txg = fromsnap_txg_save;
	sd->tosnap_txg = tosnap_txg_save;
	fnvlist_free(nv);
	fnvlist_free(nvfs);

	zfs_close(zhp);
	return (rv);
	}

	static int
	gather_nvlist(libzfs_handle_t hdl, const char fsname, const char *fromsnap,
	const char *tosnap, boolean_t recursive, boolean_t raw, boolean_t doall,
	- boolean_t replicate, boolean_t verbose, boolean_t backup, boolean_t holds,
	- boolean_t props, nvlist_t nvlp, avl_tree_t avlp)
	+ boolean_t replicate, boolean_t skipmissing, boolean_t verbose,
	+ boolean_t backup, boolean_t holds, boolean_t props, nvlist_t **nvlp,
	+ avl_tree_t **avlp)
	{
	zfs_handle_t *zhp;
	send_data_t sd = { 0 };
	int error;

	zhp = zfs_open(hdl, fsname, ZFS_TYPE_FILESYSTEM \| ZFS_TYPE_VOLUME);
	if (zhp == NULL)
	return (EZFS_BADTYPE);

	sd.fss = fnvlist_alloc();
	sd.fsname = fsname;
	sd.fromsnap = fromsnap;
	sd.tosnap = tosnap;
	sd.recursive = recursive;
	sd.raw = raw;
	sd.doall = doall;
	sd.replicate = replicate;
	+ sd.skipmissing = skipmissing;
	sd.verbose = verbose;
	sd.backup = backup;
	sd.holds = holds;
	sd.props = props;

	if ((error = send_iterate_fs(zhp, &sd)) != 0) {
	fnvlist_free(sd.fss);
	if (avlp != NULL)
	*avlp = NULL;
	*nvlp = NULL;
	return (error);
	}

	if (avlp != NULL && (*avlp = fsavl_create(sd.fss)) == NULL) {
	fnvlist_free(sd.fss);
	*nvlp = NULL;
	return (EZFS_NOMEM);
	}

	*nvlp = sd.fss;
	return (0);
	}

	/*
	* Routines specific to "zfs send"
	*/
	typedef struct send_dump_data {
	/* these are all just the short snapname (the part after the @) */
	const char *fromsnap;
	const char *tosnap;
	char prevsnap[ZFS_MAX_DATASET_NAME_LEN];
	uint64_t prevsnap_obj;
	boolean_t seenfrom, seento, replicate, doall, fromorigin;
	boolean_t dryrun, parsable, progress, embed_data, std_out;
	boolean_t large_block, compress, raw, holds;
	int outfd;
	boolean_t err;
	nvlist_t *fss;
	nvlist_t *snapholds;
	avl_tree_t *fsavl;
	snapfilter_cb_t *filter_cb;
	void *filter_cb_arg;
	nvlist_t *debugnv;
	char holdtag[ZFS_MAX_DATASET_NAME_LEN];
	int cleanup_fd;
	int verbosity;
	uint64_t size;
	} send_dump_data_t;

	static int
	zfs_send_space(zfs_handle_t zhp, const char snapname, const char *from,
	enum lzc_send_flags flags, uint64_t *spacep)
	{
	libzfs_handle_t *hdl = zhp->zfs_hdl;
	int error;

	assert(snapname != NULL);
	error = lzc_send_space(snapname, from, flags, spacep);

	if (error != 0) {
	char errbuf[1024];
	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
	"warning: cannot estimate space for '%s'"), snapname);

	switch (error) {
	case EXDEV:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"not an earlier snapshot from the same fs"));
	return (zfs_error(hdl, EZFS_CROSSTARGET, errbuf));

	case ENOENT:
	if (zfs_dataset_exists(hdl, snapname,
	ZFS_TYPE_SNAPSHOT)) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"incremental source (%s) does not exist"),
	snapname);
	}
	return (zfs_error(hdl, EZFS_NOENT, errbuf));

	case EDQUOT:
	case EFBIG:
	case EIO:
	case ENOLINK:
	case ENOSPC:
	case ENOSTR:
	case ENXIO:
	case EPIPE:
	case ERANGE:
	case EFAULT:
	case EROFS:
	case EINVAL:
	zfs_error_aux(hdl, strerror(error));
	return (zfs_error(hdl, EZFS_BADBACKUP, errbuf));

	default:
	return (zfs_standard_error(hdl, error, errbuf));
	}
	}

	return (0);
	}

	/*
	* Dumps a backup of the given snapshot (incremental from fromsnap if it's not
	* NULL) to the file descriptor specified by outfd.
	*/
	static int
	dump_ioctl(zfs_handle_t zhp, const char fromsnap, uint64_t fromsnap_obj,
	boolean_t fromorigin, int outfd, enum lzc_send_flags flags,
	nvlist_t *debugnv)
	{
	zfs_cmd_t zc = {"\0"};
	libzfs_handle_t *hdl = zhp->zfs_hdl;
	nvlist_t *thisdbg;

	assert(zhp->zfs_type == ZFS_TYPE_SNAPSHOT);
	assert(fromsnap_obj == 0 \|\| !fromorigin);

	(void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
	zc.zc_cookie = outfd;
	zc.zc_obj = fromorigin;
	zc.zc_sendobj = zfs_prop_get_int(zhp, ZFS_PROP_OBJSETID);
	zc.zc_fromobj = fromsnap_obj;
	zc.zc_flags = flags;

	thisdbg = fnvlist_alloc();
	if (fromsnap && fromsnap[0] != '\0') {
	fnvlist_add_string(thisdbg, "fromsnap", fromsnap);
	}

	if (zfs_ioctl(zhp->zfs_hdl, ZFS_IOC_SEND, &zc) != 0) {
	char errbuf[1024];
	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
	"warning: cannot send '%s'"), zhp->zfs_name);

	fnvlist_add_uint64(thisdbg, "error", errno);
	if (debugnv) {
	fnvlist_add_nvlist(debugnv, zhp->zfs_name, thisdbg);
	}
	fnvlist_free(thisdbg);

	switch (errno) {
	case EXDEV:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"not an earlier snapshot from the same fs"));
	return (zfs_error(hdl, EZFS_CROSSTARGET, errbuf));

	case EACCES:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"source key must be loaded"));
	return (zfs_error(hdl, EZFS_CRYPTOFAILED, errbuf));

	case ENOENT:
	if (zfs_dataset_exists(hdl, zc.zc_name,
	ZFS_TYPE_SNAPSHOT)) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"incremental source (@%s) does not exist"),
	zc.zc_value);
	}
	return (zfs_error(hdl, EZFS_NOENT, errbuf));

	case EDQUOT:
	case EFBIG:
	case EIO:
	case ENOLINK:
	case ENOSPC:
	case ENOSTR:
	case ENXIO:
	case EPIPE:
	case ERANGE:
	case EFAULT:
	case EROFS:
	zfs_error_aux(hdl, strerror(errno));
	return (zfs_error(hdl, EZFS_BADBACKUP, errbuf));

	default:
	return (zfs_standard_error(hdl, errno, errbuf));
	}
	}

	if (debugnv)
	fnvlist_add_nvlist(debugnv, zhp->zfs_name, thisdbg);
	fnvlist_free(thisdbg);

	return (0);
	}

	static void
	gather_holds(zfs_handle_t zhp, send_dump_data_t sdd)
	{
	assert(zhp->zfs_type == ZFS_TYPE_SNAPSHOT);

	/*
	* zfs_send() only sets snapholds for sends that need them,
	* e.g. replication and doall.
	*/
	if (sdd->snapholds == NULL)
	return;

	fnvlist_add_string(sdd->snapholds, zhp->zfs_name, sdd->holdtag);
	}

	int
	zfs_send_progress(zfs_handle_t zhp, int fd, uint64_t bytes_written,
	uint64_t *blocks_visited)
	{
	zfs_cmd_t zc = {"\0"};

	(void) strlcpy(zc.zc_name, zhp->zfs_name, sizeof (zc.zc_name));
	zc.zc_cookie = fd;
	if (zfs_ioctl(zhp->zfs_hdl, ZFS_IOC_SEND_PROGRESS, &zc) != 0)
	return (errno);
	if (bytes_written != NULL)
	*bytes_written = zc.zc_cookie;
	if (blocks_visited != NULL)
	*blocks_visited = zc.zc_objset_type;
	return (0);
	}

	static void *
	send_progress_thread(void *arg)
	{
	progress_arg_t *pa = arg;
	zfs_handle_t *zhp = pa->pa_zhp;
	uint64_t bytes;
	uint64_t blocks;
	char buf[16];
	time_t t;
	struct tm *tm;
	boolean_t firstloop = B_TRUE;

	/*
	* Print the progress from ZFS_IOC_SEND_PROGRESS every second.
	*/
	for (;;) {
	int err;
	(void) sleep(1);
	if ((err = zfs_send_progress(zhp, pa->pa_fd, &bytes,
	&blocks)) != 0) {
	if (err == EINTR \|\| err == ENOENT)
	return ((void *)0);
	return ((void *)(uintptr_t)err);
	}

	if (firstloop && !pa->pa_parsable) {
	(void) fprintf(stderr,
	"TIME %s %sSNAPSHOT %s\n",
	pa->pa_estimate ? "BYTES" : " SENT",
	pa->pa_verbosity >= 2 ? " BLOCKS " : "",
	zhp->zfs_name);
	firstloop = B_FALSE;
	}

	(void) time(&t);
	tm = localtime(&t);

	if (pa->pa_verbosity >= 2 && pa->pa_parsable) {
	(void) fprintf(stderr,
	"%02d:%02d:%02d\t%llu\t%llu\t%s\n",
	tm->tm_hour, tm->tm_min, tm->tm_sec,
	(u_longlong_t)bytes, (u_longlong_t)blocks,
	zhp->zfs_name);
	} else if (pa->pa_verbosity >= 2) {
	zfs_nicenum(bytes, buf, sizeof (buf));
	(void) fprintf(stderr,
	"%02d:%02d:%02d %5s %8llu %s\n",
	tm->tm_hour, tm->tm_min, tm->tm_sec,
	buf, (u_longlong_t)blocks, zhp->zfs_name);
	} else if (pa->pa_parsable) {
	(void) fprintf(stderr, "%02d:%02d:%02d\t%llu\t%s\n",
	tm->tm_hour, tm->tm_min, tm->tm_sec,
	(u_longlong_t)bytes, zhp->zfs_name);
	} else {
	zfs_nicebytes(bytes, buf, sizeof (buf));
	(void) fprintf(stderr, "%02d:%02d:%02d %5s %s\n",
	tm->tm_hour, tm->tm_min, tm->tm_sec,
	buf, zhp->zfs_name);
	}
	}
	}

	static void
	send_print_verbose(FILE fout, const char tosnap, const char *fromsnap,
	uint64_t size, boolean_t parsable)
	{
	if (parsable) {
	if (fromsnap != NULL) {
	(void) fprintf(fout, "incremental\t%s\t%s",
	fromsnap, tosnap);
	} else {
	(void) fprintf(fout, "full\t%s",
	tosnap);
	}
	} else {
	if (fromsnap != NULL) {
	if (strchr(fromsnap, '@') == NULL &&
	strchr(fromsnap, '#') == NULL) {
	(void) fprintf(fout, dgettext(TEXT_DOMAIN,
	"send from @%s to %s"),
	fromsnap, tosnap);
	} else {
	(void) fprintf(fout, dgettext(TEXT_DOMAIN,
	"send from %s to %s"),
	fromsnap, tosnap);
	}
	} else {
	(void) fprintf(fout, dgettext(TEXT_DOMAIN,
	"full send of %s"),
	tosnap);
	}
	}

	if (parsable) {
	(void) fprintf(fout, "\t%llu",
	(longlong_t)size);
	} else if (size != 0) {
	char buf[16];
	zfs_nicebytes(size, buf, sizeof (buf));
	(void) fprintf(fout, dgettext(TEXT_DOMAIN,
	" estimated size is %s"), buf);
	}
	(void) fprintf(fout, "\n");
	}

	static int
	dump_snapshot(zfs_handle_t zhp, void arg)
	{
	send_dump_data_t *sdd = arg;
	progress_arg_t pa = { 0 };
	pthread_t tid;
	char *thissnap;
	enum lzc_send_flags flags = 0;
	int err;
	boolean_t isfromsnap, istosnap, fromorigin;
	boolean_t exclude = B_FALSE;
	FILE *fout = sdd->std_out ? stdout : stderr;

	err = 0;
	thissnap = strchr(zhp->zfs_name, '@') + 1;
	isfromsnap = (sdd->fromsnap != NULL &&
	strcmp(sdd->fromsnap, thissnap) == 0);

	if (!sdd->seenfrom && isfromsnap) {
	gather_holds(zhp, sdd);
	sdd->seenfrom = B_TRUE;
	(void) strlcpy(sdd->prevsnap, thissnap,
	sizeof (sdd->prevsnap));
	sdd->prevsnap_obj = zfs_prop_get_int(zhp, ZFS_PROP_OBJSETID);
	zfs_close(zhp);
	return (0);
	}

	if (sdd->seento \|\| !sdd->seenfrom) {
	zfs_close(zhp);
	return (0);
	}

	istosnap = (strcmp(sdd->tosnap, thissnap) == 0);
	if (istosnap)
	sdd->seento = B_TRUE;

	if (sdd->large_block)
	flags \|= LZC_SEND_FLAG_LARGE_BLOCK;
	if (sdd->embed_data)
	flags \|= LZC_SEND_FLAG_EMBED_DATA;
	if (sdd->compress)
	flags \|= LZC_SEND_FLAG_COMPRESS;
	if (sdd->raw)
	flags \|= LZC_SEND_FLAG_RAW;

	if (!sdd->doall && !isfromsnap && !istosnap) {
	if (sdd->replicate) {
	char *snapname;
	nvlist_t *snapprops;
	/*
	* Filter out all intermediate snapshots except origin
	* snapshots needed to replicate clones.
	*/
	nvlist_t *nvfs = fsavl_find(sdd->fsavl,
	zhp->zfs_dmustats.dds_guid, &snapname);

	snapprops = fnvlist_lookup_nvlist(nvfs, "snapprops");
	snapprops = fnvlist_lookup_nvlist(snapprops, thissnap);
	exclude = !nvlist_exists(snapprops, "is_clone_origin");
	} else {
	exclude = B_TRUE;
	}
	}

	/*
	* If a filter function exists, call it to determine whether
	* this snapshot will be sent.
	*/
	if (exclude \|\| (sdd->filter_cb != NULL &&
	sdd->filter_cb(zhp, sdd->filter_cb_arg) == B_FALSE)) {
	/*
	* This snapshot is filtered out. Don't send it, and don't
	* set prevsnap_obj, so it will be as if this snapshot didn't
	* exist, and the next accepted snapshot will be sent as
	* an incremental from the last accepted one, or as the
	* first (and full) snapshot in the case of a replication,
	* non-incremental send.
	*/
	zfs_close(zhp);
	return (0);
	}

	gather_holds(zhp, sdd);
	fromorigin = sdd->prevsnap[0] == '\0' &&
	(sdd->fromorigin \|\| sdd->replicate);

	if (sdd->verbosity != 0) {
	uint64_t size = 0;
	char fromds[ZFS_MAX_DATASET_NAME_LEN];

	if (sdd->prevsnap[0] != '\0') {
	(void) strlcpy(fromds, zhp->zfs_name, sizeof (fromds));
	*(strchr(fromds, '@') + 1) = '\0';
	(void) strlcat(fromds, sdd->prevsnap, sizeof (fromds));
	}
	if (zfs_send_space(zhp, zhp->zfs_name,
	sdd->prevsnap[0] ? fromds : NULL, flags, &size) != 0) {
	size = 0; /* cannot estimate send space */
	} else {
	send_print_verbose(fout, zhp->zfs_name,
	sdd->prevsnap[0] ? sdd->prevsnap : NULL,
	size, sdd->parsable);
	}
	sdd->size += size;
	}

	if (!sdd->dryrun) {
	/*
	* If progress reporting is requested, spawn a new thread to
	* poll ZFS_IOC_SEND_PROGRESS at a regular interval.
	*/
	if (sdd->progress) {
	pa.pa_zhp = zhp;
	pa.pa_fd = sdd->outfd;
	pa.pa_parsable = sdd->parsable;
	pa.pa_estimate = B_FALSE;
	pa.pa_verbosity = sdd->verbosity;

	if ((err = pthread_create(&tid, NULL,
	send_progress_thread, &pa)) != 0) {
	zfs_close(zhp);
	return (err);
	}
	}

	err = dump_ioctl(zhp, sdd->prevsnap, sdd->prevsnap_obj,
	fromorigin, sdd->outfd, flags, sdd->debugnv);

	if (sdd->progress) {
	void *status = NULL;
	(void) pthread_cancel(tid);
	(void) pthread_join(tid, &status);
	int error = (int)(uintptr_t)status;
	if (error != 0 && status != PTHREAD_CANCELED) {
	char errbuf[1024];
	(void) snprintf(errbuf, sizeof (errbuf),
	dgettext(TEXT_DOMAIN,
	"progress thread exited nonzero"));
	return (zfs_standard_error(zhp->zfs_hdl, error,
	errbuf));
	}
	}
	}

	(void) strcpy(sdd->prevsnap, thissnap);
	sdd->prevsnap_obj = zfs_prop_get_int(zhp, ZFS_PROP_OBJSETID);
	zfs_close(zhp);
	return (err);
	}

	static int
	dump_filesystem(zfs_handle_t zhp, void arg)
	{
	int rv = 0;
	send_dump_data_t *sdd = arg;
	boolean_t missingfrom = B_FALSE;
	zfs_cmd_t zc = {"\0"};
	uint64_t min_txg = 0, max_txg = 0;

	(void) snprintf(zc.zc_name, sizeof (zc.zc_name), "%s@%s",
	zhp->zfs_name, sdd->tosnap);
	if (zfs_ioctl(zhp->zfs_hdl, ZFS_IOC_OBJSET_STATS, &zc) != 0) {
	(void) fprintf(stderr, dgettext(TEXT_DOMAIN,
	"WARNING: could not send %s@%s: does not exist\n"),
	zhp->zfs_name, sdd->tosnap);
	sdd->err = B_TRUE;
	return (0);
	}

	if (sdd->replicate && sdd->fromsnap) {
	/*
	* If this fs does not have fromsnap, and we're doing
	* recursive, we need to send a full stream from the
	* beginning (or an incremental from the origin if this
	* is a clone). If we're doing non-recursive, then let
	* them get the error.
	*/
	(void) snprintf(zc.zc_name, sizeof (zc.zc_name), "%s@%s",
	zhp->zfs_name, sdd->fromsnap);
	if (zfs_ioctl(zhp->zfs_hdl,
	ZFS_IOC_OBJSET_STATS, &zc) != 0) {
	missingfrom = B_TRUE;
	}
	}

	sdd->seenfrom = sdd->seento = sdd->prevsnap[0] = 0;
	sdd->prevsnap_obj = 0;
	if (sdd->fromsnap == NULL \|\| missingfrom)
	sdd->seenfrom = B_TRUE;



	/*
	* Iterate through all snapshots and process the ones we will be
	* sending. If we only have a "from" and "to" snapshot to deal
	* with, we can avoid iterating through all the other snapshots.
	*/
	if (sdd->doall \|\| sdd->replicate \|\| sdd->tosnap == NULL) {
	if (!sdd->replicate && sdd->fromsnap != NULL)
	min_txg = get_snap_txg(zhp->zfs_hdl, zhp->zfs_name,
	sdd->fromsnap);
	if (!sdd->replicate && sdd->tosnap != NULL)
	max_txg = get_snap_txg(zhp->zfs_hdl, zhp->zfs_name,
	sdd->tosnap);
	rv = zfs_iter_snapshots_sorted(zhp, dump_snapshot, arg,
	min_txg, max_txg);
	} else {
	char snapname[MAXPATHLEN] = { 0 };
	zfs_handle_t *snap;

	if (!sdd->seenfrom) {
	(void) snprintf(snapname, sizeof (snapname),
	"%s@%s", zhp->zfs_name, sdd->fromsnap);
	snap = zfs_open(zhp->zfs_hdl, snapname,
	ZFS_TYPE_SNAPSHOT);
	if (snap != NULL)
	rv = dump_snapshot(snap, sdd);
	else
	rv = -1;
	}

	if (rv == 0) {
	(void) snprintf(snapname, sizeof (snapname),
	"%s@%s", zhp->zfs_name, sdd->tosnap);
	snap = zfs_open(zhp->zfs_hdl, snapname,
	ZFS_TYPE_SNAPSHOT);
	if (snap != NULL)
	rv = dump_snapshot(snap, sdd);
	else
	rv = -1;
	}
	}

	if (!sdd->seenfrom) {
	(void) fprintf(stderr, dgettext(TEXT_DOMAIN,
	"WARNING: could not send %s@%s:\n"
	"incremental source (%s@%s) does not exist\n"),
	zhp->zfs_name, sdd->tosnap,
	zhp->zfs_name, sdd->fromsnap);
	sdd->err = B_TRUE;
	} else if (!sdd->seento) {
	if (sdd->fromsnap) {
	(void) fprintf(stderr, dgettext(TEXT_DOMAIN,
	"WARNING: could not send %s@%s:\n"
	"incremental source (%s@%s) "
	"is not earlier than it\n"),
	zhp->zfs_name, sdd->tosnap,
	zhp->zfs_name, sdd->fromsnap);
	} else {
	(void) fprintf(stderr, dgettext(TEXT_DOMAIN,
	"WARNING: "
	"could not send %s@%s: does not exist\n"),
	zhp->zfs_name, sdd->tosnap);
	}
	sdd->err = B_TRUE;
	}

	return (rv);
	}

	static int
	dump_filesystems(zfs_handle_t rzhp, void arg)
	{
	send_dump_data_t *sdd = arg;
	nvpair_t *fspair;
	boolean_t needagain, progress;

	if (!sdd->replicate)
	return (dump_filesystem(rzhp, sdd));

	/* Mark the clone origin snapshots. */
	for (fspair = nvlist_next_nvpair(sdd->fss, NULL); fspair;
	fspair = nvlist_next_nvpair(sdd->fss, fspair)) {
	nvlist_t *nvfs;
	uint64_t origin_guid = 0;

	nvfs = fnvpair_value_nvlist(fspair);
	(void) nvlist_lookup_uint64(nvfs, "origin", &origin_guid);
	if (origin_guid != 0) {
	char *snapname;
	nvlist_t *origin_nv = fsavl_find(sdd->fsavl,
	origin_guid, &snapname);
	if (origin_nv != NULL) {
	nvlist_t *snapprops;
	snapprops = fnvlist_lookup_nvlist(origin_nv,
	"snapprops");
	snapprops = fnvlist_lookup_nvlist(snapprops,
	snapname);
	fnvlist_add_boolean(snapprops,
	"is_clone_origin");
	}
	}
	}
	again:
	needagain = progress = B_FALSE;
	for (fspair = nvlist_next_nvpair(sdd->fss, NULL); fspair;
	fspair = nvlist_next_nvpair(sdd->fss, fspair)) {
	nvlist_t fslist, parent_nv;
	char *fsname;
	zfs_handle_t *zhp;
	int err;
	uint64_t origin_guid = 0;
	uint64_t parent_guid = 0;

	fslist = fnvpair_value_nvlist(fspair);
	if (nvlist_lookup_boolean(fslist, "sent") == 0)
	continue;

	fsname = fnvlist_lookup_string(fslist, "name");
	(void) nvlist_lookup_uint64(fslist, "origin", &origin_guid);
	(void) nvlist_lookup_uint64(fslist, "parentfromsnap",
	&parent_guid);

	if (parent_guid != 0) {
	parent_nv = fsavl_find(sdd->fsavl, parent_guid, NULL);
	if (!nvlist_exists(parent_nv, "sent")) {
	/* parent has not been sent; skip this one */
	needagain = B_TRUE;
	continue;
	}
	}

	if (origin_guid != 0) {
	nvlist_t *origin_nv = fsavl_find(sdd->fsavl,
	origin_guid, NULL);
	if (origin_nv != NULL &&
	!nvlist_exists(origin_nv, "sent")) {
	/*
	* origin has not been sent yet;
	* skip this clone.
	*/
	needagain = B_TRUE;
	continue;
	}
	}

	zhp = zfs_open(rzhp->zfs_hdl, fsname, ZFS_TYPE_DATASET);
	if (zhp == NULL)
	return (-1);
	err = dump_filesystem(zhp, sdd);
	fnvlist_add_boolean(fslist, "sent");
	progress = B_TRUE;
	zfs_close(zhp);
	if (err)
	return (err);
	}
	if (needagain) {
	assert(progress);
	goto again;
	}

	/* clean out the sent flags in case we reuse this fss */
	for (fspair = nvlist_next_nvpair(sdd->fss, NULL); fspair;
	fspair = nvlist_next_nvpair(sdd->fss, fspair)) {
	nvlist_t *fslist;

	fslist = fnvpair_value_nvlist(fspair);
	(void) nvlist_remove_all(fslist, "sent");
	}

	return (0);
	}

	nvlist_t *
	zfs_send_resume_token_to_nvlist(libzfs_handle_t hdl, const char token)
	{
	unsigned int version;
	int nread, i;
	unsigned long long checksum, packed_len;

	/*
	* Decode token header, which is:
	* <token version>-<checksum of payload>-<uncompressed payload length>
	* Note that the only supported token version is 1.
	*/
	nread = sscanf(token, "%u-%llx-%llx-",
	&version, &checksum, &packed_len);
	if (nread != 3) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"resume token is corrupt (invalid format)"));
	return (NULL);
	}

	if (version != ZFS_SEND_RESUME_TOKEN_VERSION) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"resume token is corrupt (invalid version %u)"),
	version);
	return (NULL);
	}

	/* convert hexadecimal representation to binary */
	token = strrchr(token, '-') + 1;
	int len = strlen(token) / 2;
	unsigned char *compressed = zfs_alloc(hdl, len);
	for (i = 0; i < len; i++) {
	nread = sscanf(token + i * 2, "%2hhx", compressed + i);
	if (nread != 1) {
	free(compressed);
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"resume token is corrupt "
	"(payload is not hex-encoded)"));
	return (NULL);
	}
	}

	/* verify checksum */
	zio_cksum_t cksum;
	fletcher_4_native_varsize(compressed, len, &cksum);
	if (cksum.zc_word[0] != checksum) {
	free(compressed);
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"resume token is corrupt (incorrect checksum)"));
	return (NULL);
	}

	/* uncompress */
	void *packed = zfs_alloc(hdl, packed_len);
	uLongf packed_len_long = packed_len;
	if (uncompress(packed, &packed_len_long, compressed, len) != Z_OK \|\|
	packed_len_long != packed_len) {
	free(packed);
	free(compressed);
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"resume token is corrupt (decompression failed)"));
	return (NULL);
	}

	/* unpack nvlist */
	nvlist_t *nv;
	int error = nvlist_unpack(packed, packed_len, &nv, KM_SLEEP);
	free(packed);
	free(compressed);
	if (error != 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"resume token is corrupt (nvlist_unpack failed)"));
	return (NULL);
	}
	return (nv);
	}
	static enum lzc_send_flags
	lzc_flags_from_sendflags(const sendflags_t *flags)
	{
	enum lzc_send_flags lzc_flags = 0;
	if (flags->largeblock)
	lzc_flags \|= LZC_SEND_FLAG_LARGE_BLOCK;
	if (flags->embed_data)
	lzc_flags \|= LZC_SEND_FLAG_EMBED_DATA;
	if (flags->compress)
	lzc_flags \|= LZC_SEND_FLAG_COMPRESS;
	if (flags->raw)
	lzc_flags \|= LZC_SEND_FLAG_RAW;
	if (flags->saved)
	lzc_flags \|= LZC_SEND_FLAG_SAVED;
	return (lzc_flags);
	}

	static int
	estimate_size(zfs_handle_t zhp, const char from, int fd, sendflags_t *flags,
	uint64_t resumeobj, uint64_t resumeoff, uint64_t bytes,
	const char redactbook, char errbuf)
	{
	uint64_t size;
	FILE *fout = flags->dryrun ? stdout : stderr;
	progress_arg_t pa = { 0 };
	int err = 0;
	pthread_t ptid;

	if (flags->progress) {
	pa.pa_zhp = zhp;
	pa.pa_fd = fd;
	pa.pa_parsable = flags->parsable;
	pa.pa_estimate = B_TRUE;
	pa.pa_verbosity = flags->verbosity;

	err = pthread_create(&ptid, NULL,
	send_progress_thread, &pa);
	if (err != 0) {
	zfs_error_aux(zhp->zfs_hdl, strerror(errno));
	return (zfs_error(zhp->zfs_hdl,
	EZFS_THREADCREATEFAILED, errbuf));
	}
	}

	err = lzc_send_space_resume_redacted(zhp->zfs_name, from,
	lzc_flags_from_sendflags(flags), resumeobj, resumeoff, bytes,
	redactbook, fd, &size);

	if (flags->progress) {
	void *status = NULL;
	(void) pthread_cancel(ptid);
	(void) pthread_join(ptid, &status);
	int error = (int)(uintptr_t)status;
	if (error != 0 && status != PTHREAD_CANCELED) {
	char errbuf[1024];
	(void) snprintf(errbuf, sizeof (errbuf),
	dgettext(TEXT_DOMAIN, "progress thread exited "
	"nonzero"));
	return (zfs_standard_error(zhp->zfs_hdl, error,
	errbuf));
	}
	}

	if (err != 0) {
	zfs_error_aux(zhp->zfs_hdl, strerror(err));
	return (zfs_error(zhp->zfs_hdl, EZFS_BADBACKUP,
	errbuf));
	}
	send_print_verbose(fout, zhp->zfs_name, from, size,
	flags->parsable);

	if (flags->parsable) {
	(void) fprintf(fout, "size\t%llu\n", (longlong_t)size);
	} else {
	char buf[16];
	zfs_nicenum(size, buf, sizeof (buf));
	(void) fprintf(fout, dgettext(TEXT_DOMAIN,
	"total estimated size is %s\n"), buf);
	}
	return (0);
	}

	static boolean_t
	redact_snaps_contains(const uint64_t *snaps, uint64_t num_snaps, uint64_t guid)
	{
	for (int i = 0; i < num_snaps; i++) {
	if (snaps[i] == guid)
	return (B_TRUE);
	}
	return (B_FALSE);
	}

	static boolean_t
	redact_snaps_equal(const uint64_t *snaps1, uint64_t num_snaps1,
	const uint64_t *snaps2, uint64_t num_snaps2)
	{
	if (num_snaps1 != num_snaps2)
	return (B_FALSE);
	for (int i = 0; i < num_snaps1; i++) {
	if (!redact_snaps_contains(snaps2, num_snaps2, snaps1[i]))
	return (B_FALSE);
	}
	return (B_TRUE);
	}

	/*
	* Check that the list of redaction snapshots in the bookmark matches the send
	* we're resuming, and return whether or not it's complete.
	*
	* Note that the caller needs to free the contents of *bookname with free() if
	* this function returns successfully.
	*/
	static int
	find_redact_book(libzfs_handle_t hdl, const char path,
	const uint64_t *redact_snap_guids, int num_redact_snaps,
	char **bookname)
	{
	char errbuf[1024];
	int error = 0;
	nvlist_t *props = fnvlist_alloc();
	nvlist_t *bmarks;

	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
	"cannot resume send"));

	fnvlist_add_boolean(props, "redact_complete");
	fnvlist_add_boolean(props, zfs_prop_to_name(ZFS_PROP_REDACT_SNAPS));
	error = lzc_get_bookmarks(path, props, &bmarks);
	fnvlist_free(props);
	if (error != 0) {
	if (error == ESRCH) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"nonexistent redaction bookmark provided"));
	} else if (error == ENOENT) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"dataset to be sent no longer exists"));
	} else {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"unknown error: %s"), strerror(error));
	}
	return (zfs_error(hdl, EZFS_BADPROP, errbuf));
	}
	nvpair_t *pair;
	for (pair = nvlist_next_nvpair(bmarks, NULL); pair;
	pair = nvlist_next_nvpair(bmarks, pair)) {

	nvlist_t *bmark = fnvpair_value_nvlist(pair);
	nvlist_t *vallist = fnvlist_lookup_nvlist(bmark,
	zfs_prop_to_name(ZFS_PROP_REDACT_SNAPS));
	uint_t len = 0;
	uint64_t *bmarksnaps = fnvlist_lookup_uint64_array(vallist,
	ZPROP_VALUE, &len);
	if (redact_snaps_equal(redact_snap_guids,
	num_redact_snaps, bmarksnaps, len)) {
	break;
	}
	}
	if (pair == NULL) {
	fnvlist_free(bmarks);
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"no appropriate redaction bookmark exists"));
	return (zfs_error(hdl, EZFS_BADPROP, errbuf));
	}
	char *name = nvpair_name(pair);
	nvlist_t *bmark = fnvpair_value_nvlist(pair);
	nvlist_t *vallist = fnvlist_lookup_nvlist(bmark, "redact_complete");
	boolean_t complete = fnvlist_lookup_boolean_value(vallist,
	ZPROP_VALUE);
	if (!complete) {
	fnvlist_free(bmarks);
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"incomplete redaction bookmark provided"));
	return (zfs_error(hdl, EZFS_BADPROP, errbuf));
	}
	*bookname = strndup(name, ZFS_MAX_DATASET_NAME_LEN);
	ASSERT3P(*bookname, !=, NULL);
	fnvlist_free(bmarks);
	return (0);
	}

	static int
	zfs_send_resume_impl(libzfs_handle_t hdl, sendflags_t flags, int outfd,
	nvlist_t *resume_nvl)
	{
	char errbuf[1024];
	char *toname;
	char *fromname = NULL;
	uint64_t resumeobj, resumeoff, toguid, fromguid, bytes;
	zfs_handle_t *zhp;
	int error = 0;
	char name[ZFS_MAX_DATASET_NAME_LEN];
	enum lzc_send_flags lzc_flags = 0;
	FILE *fout = (flags->verbosity > 0 && flags->dryrun) ? stdout : stderr;
	uint64_t *redact_snap_guids = NULL;
	int num_redact_snaps = 0;
	char *redact_book = NULL;

	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
	"cannot resume send"));

	if (flags->verbosity != 0) {
	(void) fprintf(fout, dgettext(TEXT_DOMAIN,
	"resume token contents:\n"));
	nvlist_print(fout, resume_nvl);
	}

	if (nvlist_lookup_string(resume_nvl, "toname", &toname) != 0 \|\|
	nvlist_lookup_uint64(resume_nvl, "object", &resumeobj) != 0 \|\|
	nvlist_lookup_uint64(resume_nvl, "offset", &resumeoff) != 0 \|\|
	nvlist_lookup_uint64(resume_nvl, "bytes", &bytes) != 0 \|\|
	nvlist_lookup_uint64(resume_nvl, "toguid", &toguid) != 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"resume token is corrupt"));
	return (zfs_error(hdl, EZFS_FAULT, errbuf));
	}
	fromguid = 0;
	(void) nvlist_lookup_uint64(resume_nvl, "fromguid", &fromguid);

	if (flags->largeblock \|\| nvlist_exists(resume_nvl, "largeblockok"))
	lzc_flags \|= LZC_SEND_FLAG_LARGE_BLOCK;
	if (flags->embed_data \|\| nvlist_exists(resume_nvl, "embedok"))
	lzc_flags \|= LZC_SEND_FLAG_EMBED_DATA;
	if (flags->compress \|\| nvlist_exists(resume_nvl, "compressok"))
	lzc_flags \|= LZC_SEND_FLAG_COMPRESS;
	if (flags->raw \|\| nvlist_exists(resume_nvl, "rawok"))
	lzc_flags \|= LZC_SEND_FLAG_RAW;
	if (flags->saved \|\| nvlist_exists(resume_nvl, "savedok"))
	lzc_flags \|= LZC_SEND_FLAG_SAVED;

	if (flags->saved) {
	(void) strcpy(name, toname);
	} else {
	error = guid_to_name(hdl, toname, toguid, B_FALSE, name);
	if (error != 0) {
	if (zfs_dataset_exists(hdl, toname, ZFS_TYPE_DATASET)) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"'%s' is no longer the same snapshot "
	"used in the initial send"), toname);
	} else {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"'%s' used in the initial send no "
	"longer exists"), toname);
	}
	return (zfs_error(hdl, EZFS_BADPATH, errbuf));
	}
	}

	zhp = zfs_open(hdl, name, ZFS_TYPE_DATASET);
	if (zhp == NULL) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"unable to access '%s'"), name);
	return (zfs_error(hdl, EZFS_BADPATH, errbuf));
	}

	if (nvlist_lookup_uint64_array(resume_nvl, "book_redact_snaps",
	&redact_snap_guids, (uint_t *)&num_redact_snaps) != 0) {
	num_redact_snaps = -1;
	}

	if (fromguid != 0) {
	if (guid_to_name_redact_snaps(hdl, toname, fromguid, B_TRUE,
	redact_snap_guids, num_redact_snaps, name) != 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"incremental source %#llx no longer exists"),
	(longlong_t)fromguid);
	return (zfs_error(hdl, EZFS_BADPATH, errbuf));
	}
	fromname = name;
	}

	redact_snap_guids = NULL;

	if (nvlist_lookup_uint64_array(resume_nvl,
	zfs_prop_to_name(ZFS_PROP_REDACT_SNAPS), &redact_snap_guids,
	(uint_t *)&num_redact_snaps) == 0) {
	char path[ZFS_MAX_DATASET_NAME_LEN];

	(void) strlcpy(path, toname, sizeof (path));
	char *at = strchr(path, '@');
	ASSERT3P(at, !=, NULL);

	*at = '\0';

	if ((error = find_redact_book(hdl, path, redact_snap_guids,
	num_redact_snaps, &redact_book)) != 0) {
	return (error);
	}
	}

	if (flags->verbosity != 0) {
	/*
	* Some of these may have come from the resume token, set them
	* here for size estimate purposes.
	*/
	sendflags_t tmpflags = *flags;
	if (lzc_flags & LZC_SEND_FLAG_LARGE_BLOCK)
	tmpflags.largeblock = B_TRUE;
	if (lzc_flags & LZC_SEND_FLAG_COMPRESS)
	tmpflags.compress = B_TRUE;
	if (lzc_flags & LZC_SEND_FLAG_EMBED_DATA)
	tmpflags.embed_data = B_TRUE;
	error = estimate_size(zhp, fromname, outfd, &tmpflags,
	resumeobj, resumeoff, bytes, redact_book, errbuf);
	}

	if (!flags->dryrun) {
	progress_arg_t pa = { 0 };
	pthread_t tid;
	/*
	* If progress reporting is requested, spawn a new thread to
	* poll ZFS_IOC_SEND_PROGRESS at a regular interval.
	*/
	if (flags->progress) {
	pa.pa_zhp = zhp;
	pa.pa_fd = outfd;
	pa.pa_parsable = flags->parsable;
	pa.pa_estimate = B_FALSE;
	pa.pa_verbosity = flags->verbosity;

	error = pthread_create(&tid, NULL,
	send_progress_thread, &pa);
	if (error != 0) {
	if (redact_book != NULL)
	free(redact_book);
	zfs_close(zhp);
	return (error);
	}
	}

	error = lzc_send_resume_redacted(zhp->zfs_name, fromname, outfd,
	lzc_flags, resumeobj, resumeoff, redact_book);
	if (redact_book != NULL)
	free(redact_book);

	if (flags->progress) {
	void *status = NULL;
	(void) pthread_cancel(tid);
	(void) pthread_join(tid, &status);
	int error = (int)(uintptr_t)status;
	if (error != 0 && status != PTHREAD_CANCELED) {
	char errbuf[1024];
	(void) snprintf(errbuf, sizeof (errbuf),
	dgettext(TEXT_DOMAIN,
	"progress thread exited nonzero"));
	return (zfs_standard_error(hdl, error, errbuf));
	}
	}

	char errbuf[1024];
	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
	"warning: cannot send '%s'"), zhp->zfs_name);

	zfs_close(zhp);

	switch (error) {
	case 0:
	return (0);
	case EACCES:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"source key must be loaded"));
	return (zfs_error(hdl, EZFS_CRYPTOFAILED, errbuf));
	case ESRCH:
	if (lzc_exists(zhp->zfs_name)) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"incremental source could not be found"));
	}
	return (zfs_error(hdl, EZFS_NOENT, errbuf));

	case EXDEV:
	case ENOENT:
	case EDQUOT:
	case EFBIG:
	case EIO:
	case ENOLINK:
	case ENOSPC:
	case ENOSTR:
	case ENXIO:
	case EPIPE:
	case ERANGE:
	case EFAULT:
	case EROFS:
	zfs_error_aux(hdl, strerror(errno));
	return (zfs_error(hdl, EZFS_BADBACKUP, errbuf));

	default:
	return (zfs_standard_error(hdl, errno, errbuf));
	}
	} else {
	if (redact_book != NULL)
	free(redact_book);
	}

	zfs_close(zhp);

	return (error);
	}

	int
	zfs_send_resume(libzfs_handle_t hdl, sendflags_t flags, int outfd,
	const char *resume_token)
	{
	int ret;
	char errbuf[1024];
	nvlist_t *resume_nvl;

	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
	"cannot resume send"));

	resume_nvl = zfs_send_resume_token_to_nvlist(hdl, resume_token);
	if (resume_nvl == NULL) {
	/*
	* zfs_error_aux has already been set by
	* zfs_send_resume_token_to_nvlist()
	*/
	return (zfs_error(hdl, EZFS_FAULT, errbuf));
	}

	ret = zfs_send_resume_impl(hdl, flags, outfd, resume_nvl);
	fnvlist_free(resume_nvl);

	return (ret);
	}

	int
	zfs_send_saved(zfs_handle_t zhp, sendflags_t flags, int outfd,
	const char *resume_token)
	{
	int ret;
	libzfs_handle_t *hdl = zhp->zfs_hdl;
	nvlist_t saved_nvl = NULL, resume_nvl = NULL;
	uint64_t saved_guid = 0, resume_guid = 0;
	uint64_t obj = 0, off = 0, bytes = 0;
	char token_buf[ZFS_MAXPROPLEN];
	char errbuf[1024];

	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
	"saved send failed"));

	ret = zfs_prop_get(zhp, ZFS_PROP_RECEIVE_RESUME_TOKEN,
	token_buf, sizeof (token_buf), NULL, NULL, 0, B_TRUE);
	if (ret != 0)
	goto out;

	saved_nvl = zfs_send_resume_token_to_nvlist(hdl, token_buf);
	if (saved_nvl == NULL) {
	/*
	* zfs_error_aux has already been set by
	* zfs_send_resume_token_to_nvlist()
	*/
	ret = zfs_error(hdl, EZFS_FAULT, errbuf);
	goto out;
	}

	/*
	* If a resume token is provided we use the object and offset
	* from that instead of the default, which starts from the
	* beginning.
	*/
	if (resume_token != NULL) {
	resume_nvl = zfs_send_resume_token_to_nvlist(hdl,
	resume_token);
	if (resume_nvl == NULL) {
	ret = zfs_error(hdl, EZFS_FAULT, errbuf);
	goto out;
	}

	if (nvlist_lookup_uint64(resume_nvl, "object", &obj) != 0 \|\|
	nvlist_lookup_uint64(resume_nvl, "offset", &off) != 0 \|\|
	nvlist_lookup_uint64(resume_nvl, "bytes", &bytes) != 0 \|\|
	nvlist_lookup_uint64(resume_nvl, "toguid",
	&resume_guid) != 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"provided resume token is corrupt"));
	ret = zfs_error(hdl, EZFS_FAULT, errbuf);
	goto out;
	}

	if (nvlist_lookup_uint64(saved_nvl, "toguid",
	&saved_guid)) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"dataset's resume token is corrupt"));
	ret = zfs_error(hdl, EZFS_FAULT, errbuf);
	goto out;
	}

	if (resume_guid != saved_guid) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"provided resume token does not match dataset"));
	ret = zfs_error(hdl, EZFS_BADBACKUP, errbuf);
	goto out;
	}
	}

	(void) nvlist_remove_all(saved_nvl, "object");
	fnvlist_add_uint64(saved_nvl, "object", obj);

	(void) nvlist_remove_all(saved_nvl, "offset");
	fnvlist_add_uint64(saved_nvl, "offset", off);

	(void) nvlist_remove_all(saved_nvl, "bytes");
	fnvlist_add_uint64(saved_nvl, "bytes", bytes);

	(void) nvlist_remove_all(saved_nvl, "toname");
	fnvlist_add_string(saved_nvl, "toname", zhp->zfs_name);

	ret = zfs_send_resume_impl(hdl, flags, outfd, saved_nvl);

	out:
	fnvlist_free(saved_nvl);
	fnvlist_free(resume_nvl);
	return (ret);
	}

	/*
	* This function informs the target system that the recursive send is complete.
	* The record is also expected in the case of a send -p.
	*/
	static int
	send_conclusion_record(int fd, zio_cksum_t *zc)
	{
	dmu_replay_record_t drr = { 0 };
	drr.drr_type = DRR_END;
	if (zc != NULL)
	drr.drr_u.drr_end.drr_checksum = *zc;
	if (write(fd, &drr, sizeof (drr)) == -1) {
	return (errno);
	}
	return (0);
	}

	/*
	* This function is responsible for sending the records that contain the
	* necessary information for the target system's libzfs to be able to set the
	* properties of the filesystem being received, or to be able to prepare for
	* a recursive receive.
	*
	* The "zhp" argument is the handle of the snapshot we are sending
	* (the "tosnap"). The "from" argument is the short snapshot name (the part
	* after the @) of the incremental source.
	*/
	static int
	send_prelim_records(zfs_handle_t zhp, const char from, int fd,
	boolean_t gather_props, boolean_t recursive, boolean_t verbose,
	- boolean_t dryrun, boolean_t raw, boolean_t replicate, boolean_t backup,
	- boolean_t holds, boolean_t props, boolean_t doall,
	+ boolean_t dryrun, boolean_t raw, boolean_t replicate, boolean_t skipmissing,
	+ boolean_t backup, boolean_t holds, boolean_t props, boolean_t doall,
	nvlist_t fssp, avl_tree_t fsavlp)
	{
	int err = 0;
	char *packbuf = NULL;
	size_t buflen = 0;
	zio_cksum_t zc = { {0} };
	int featureflags = 0;
	/* name of filesystem/volume that contains snapshot we are sending */
	char tofs[ZFS_MAX_DATASET_NAME_LEN];
	/* short name of snap we are sending */
	char *tosnap = "";

	char errbuf[1024];
	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
	"warning: cannot send '%s'"), zhp->zfs_name);
	if (zhp->zfs_type == ZFS_TYPE_FILESYSTEM && zfs_prop_get_int(zhp,
	ZFS_PROP_VERSION) >= ZPL_VERSION_SA) {
	featureflags \|= DMU_BACKUP_FEATURE_SA_SPILL;
	}

	if (holds)
	featureflags \|= DMU_BACKUP_FEATURE_HOLDS;

	(void) strlcpy(tofs, zhp->zfs_name, ZFS_MAX_DATASET_NAME_LEN);
	char *at = strchr(tofs, '@');
	if (at != NULL) {
	*at = '\0';
	tosnap = at + 1;
	}

	if (gather_props) {
	nvlist_t *hdrnv = fnvlist_alloc();
	nvlist_t *fss = NULL;

	if (from != NULL)
	fnvlist_add_string(hdrnv, "fromsnap", from);
	fnvlist_add_string(hdrnv, "tosnap", tosnap);
	if (!recursive)
	fnvlist_add_boolean(hdrnv, "not_recursive");

	if (raw) {
	fnvlist_add_boolean(hdrnv, "raw");
	}

	if ((err = gather_nvlist(zhp->zfs_hdl, tofs,
	- from, tosnap, recursive, raw, doall, replicate, verbose,
	- backup, holds, props, &fss, fsavlp)) != 0) {
	+ from, tosnap, recursive, raw, doall, replicate, skipmissing,
	+ verbose, backup, holds, props, &fss, fsavlp)) != 0) {
	return (zfs_error(zhp->zfs_hdl, EZFS_BADBACKUP,
	errbuf));
	}
	/*
	* Do not allow the size of the properties list to exceed
	* the limit
	*/
	if ((fnvlist_size(fss) + fnvlist_size(hdrnv)) >
	zhp->zfs_hdl->libzfs_max_nvlist) {
	(void) snprintf(errbuf, sizeof (errbuf),
	dgettext(TEXT_DOMAIN, "warning: cannot send '%s': "
	"the size of the list of snapshots and properties "
	"is too large to be received successfully.\n"
	"Select a smaller number of snapshots to send.\n"),
	zhp->zfs_name);
	return (zfs_error(zhp->zfs_hdl, EZFS_NOSPC,
	errbuf));
	}
	fnvlist_add_nvlist(hdrnv, "fss", fss);
	VERIFY0(nvlist_pack(hdrnv, &packbuf, &buflen, NV_ENCODE_XDR,
	0));
	if (fssp != NULL) {
	*fssp = fss;
	} else {
	fnvlist_free(fss);
	}
	fnvlist_free(hdrnv);
	}

	if (!dryrun) {
	dmu_replay_record_t drr = { 0 };
	/* write first begin record */
	drr.drr_type = DRR_BEGIN;
	drr.drr_u.drr_begin.drr_magic = DMU_BACKUP_MAGIC;
	DMU_SET_STREAM_HDRTYPE(drr.drr_u.drr_begin.
	drr_versioninfo, DMU_COMPOUNDSTREAM);
	DMU_SET_FEATUREFLAGS(drr.drr_u.drr_begin.
	drr_versioninfo, featureflags);
	if (snprintf(drr.drr_u.drr_begin.drr_toname,
	sizeof (drr.drr_u.drr_begin.drr_toname), "%s@%s", tofs,
	tosnap) >= sizeof (drr.drr_u.drr_begin.drr_toname)) {
	return (zfs_error(zhp->zfs_hdl, EZFS_BADBACKUP,
	errbuf));
	}
	drr.drr_payloadlen = buflen;

	err = dump_record(&drr, packbuf, buflen, &zc, fd);
	free(packbuf);
	if (err != 0) {
	zfs_error_aux(zhp->zfs_hdl, strerror(err));
	return (zfs_error(zhp->zfs_hdl, EZFS_BADBACKUP,
	errbuf));
	}
	err = send_conclusion_record(fd, &zc);
	if (err != 0) {
	zfs_error_aux(zhp->zfs_hdl, strerror(err));
	return (zfs_error(zhp->zfs_hdl, EZFS_BADBACKUP,
	errbuf));
	}
	}
	return (0);
	}

	/*
	* Generate a send stream. The "zhp" argument is the filesystem/volume
	* that contains the snapshot to send. The "fromsnap" argument is the
	* short name (the part after the '@') of the snapshot that is the
	* incremental source to send from (if non-NULL). The "tosnap" argument
	* is the short name of the snapshot to send.
	*
	* The content of the send stream is the snapshot identified by
	* 'tosnap'. Incremental streams are requested in two ways:
	* - from the snapshot identified by "fromsnap" (if non-null) or
	* - from the origin of the dataset identified by zhp, which must
	* be a clone. In this case, "fromsnap" is null and "fromorigin"
	* is TRUE.
	*
	* The send stream is recursive (i.e. dumps a hierarchy of snapshots) and
	* uses a special header (with a hdrtype field of DMU_COMPOUNDSTREAM)
	* if "replicate" is set. If "doall" is set, dump all the intermediate
	* snapshots. The DMU_COMPOUNDSTREAM header is used in the "doall"
	* case too. If "props" is set, send properties.
	*/
	int
	zfs_send(zfs_handle_t zhp, const char fromsnap, const char *tosnap,
	sendflags_t *flags, int outfd, snapfilter_cb_t filter_func,
	void cb_arg, nvlist_t *debugnvp)
	{
	char errbuf[1024];
	send_dump_data_t sdd = { 0 };
	int err = 0;
	nvlist_t *fss = NULL;
	avl_tree_t *fsavl = NULL;
	static uint64_t holdseq;
	int spa_version;
	int featureflags = 0;
	FILE *fout;

	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
	"cannot send '%s'"), zhp->zfs_name);

	if (fromsnap && fromsnap[0] == '\0') {
	zfs_error_aux(zhp->zfs_hdl, dgettext(TEXT_DOMAIN,
	"zero-length incremental source"));
	return (zfs_error(zhp->zfs_hdl, EZFS_NOENT, errbuf));
	}

	if (zhp->zfs_type == ZFS_TYPE_FILESYSTEM) {
	uint64_t version;
	version = zfs_prop_get_int(zhp, ZFS_PROP_VERSION);
	if (version >= ZPL_VERSION_SA) {
	featureflags \|= DMU_BACKUP_FEATURE_SA_SPILL;
	}
	}

	if (flags->holds)
	featureflags \|= DMU_BACKUP_FEATURE_HOLDS;

	if (flags->replicate \|\| flags->doall \|\| flags->props \|\|
	flags->holds \|\| flags->backup) {
	char full_tosnap_name[ZFS_MAX_DATASET_NAME_LEN];
	if (snprintf(full_tosnap_name, sizeof (full_tosnap_name),
	"%s@%s", zhp->zfs_name, tosnap) >=
	sizeof (full_tosnap_name)) {
	err = EINVAL;
	goto stderr_out;
	}
	zfs_handle_t *tosnap = zfs_open(zhp->zfs_hdl,
	full_tosnap_name, ZFS_TYPE_SNAPSHOT);
	if (tosnap == NULL) {
	err = -1;
	goto err_out;
	}
	err = send_prelim_records(tosnap, fromsnap, outfd,
	flags->replicate \|\| flags->props \|\| flags->holds,
	flags->replicate, flags->verbosity > 0, flags->dryrun,
	- flags->raw, flags->replicate, flags->backup, flags->holds,
	- flags->props, flags->doall, &fss, &fsavl);
	+ flags->raw, flags->replicate, flags->skipmissing,
	+ flags->backup, flags->holds, flags->props, flags->doall,
	+ &fss, &fsavl);
	zfs_close(tosnap);
	if (err != 0)
	goto err_out;
	}

	/* dump each stream */
	sdd.fromsnap = fromsnap;
	sdd.tosnap = tosnap;
	sdd.outfd = outfd;
	sdd.replicate = flags->replicate;
	sdd.doall = flags->doall;
	sdd.fromorigin = flags->fromorigin;
	sdd.fss = fss;
	sdd.fsavl = fsavl;
	sdd.verbosity = flags->verbosity;
	sdd.parsable = flags->parsable;
	sdd.progress = flags->progress;
	sdd.dryrun = flags->dryrun;
	sdd.large_block = flags->largeblock;
	sdd.embed_data = flags->embed_data;
	sdd.compress = flags->compress;
	sdd.raw = flags->raw;
	sdd.holds = flags->holds;
	sdd.filter_cb = filter_func;
	sdd.filter_cb_arg = cb_arg;
	if (debugnvp)
	sdd.debugnv = *debugnvp;
	if (sdd.verbosity != 0 && sdd.dryrun)
	sdd.std_out = B_TRUE;
	fout = sdd.std_out ? stdout : stderr;

	/*
	* Some flags require that we place user holds on the datasets that are
	* being sent so they don't get destroyed during the send. We can skip
	* this step if the pool is imported read-only since the datasets cannot
	* be destroyed.
	*/
	if (!flags->dryrun && !zpool_get_prop_int(zfs_get_pool_handle(zhp),
	ZPOOL_PROP_READONLY, NULL) &&
	zfs_spa_version(zhp, &spa_version) == 0 &&
	spa_version >= SPA_VERSION_USERREFS &&
	(flags->doall \|\| flags->replicate)) {
	++holdseq;
	(void) snprintf(sdd.holdtag, sizeof (sdd.holdtag),
	".send-%d-%llu", getpid(), (u_longlong_t)holdseq);
	- sdd.cleanup_fd = open(ZFS_DEV, O_RDWR);
	+ sdd.cleanup_fd = open(ZFS_DEV, O_RDWR \| O_CLOEXEC);
	if (sdd.cleanup_fd < 0) {
	err = errno;
	goto stderr_out;
	}
	sdd.snapholds = fnvlist_alloc();
	} else {
	sdd.cleanup_fd = -1;
	sdd.snapholds = NULL;
	}

	if (flags->verbosity != 0 \|\| sdd.snapholds != NULL) {
	/*
	* Do a verbose no-op dry run to get all the verbose output
	* or to gather snapshot hold's before generating any data,
	* then do a non-verbose real run to generate the streams.
	*/
	sdd.dryrun = B_TRUE;
	err = dump_filesystems(zhp, &sdd);

	if (err != 0)
	goto stderr_out;

	if (flags->verbosity != 0) {
	if (flags->parsable) {
	(void) fprintf(fout, "size\t%llu\n",
	(longlong_t)sdd.size);
	} else {
	char buf[16];
	zfs_nicebytes(sdd.size, buf, sizeof (buf));
	(void) fprintf(fout, dgettext(TEXT_DOMAIN,
	"total estimated size is %s\n"), buf);
	}
	}

	/* Ensure no snaps found is treated as an error. */
	if (!sdd.seento) {
	err = ENOENT;
	goto err_out;
	}

	/* Skip the second run if dryrun was requested. */
	if (flags->dryrun)
	goto err_out;

	if (sdd.snapholds != NULL) {
	err = zfs_hold_nvl(zhp, sdd.cleanup_fd, sdd.snapholds);
	if (err != 0)
	goto stderr_out;

	fnvlist_free(sdd.snapholds);
	sdd.snapholds = NULL;
	}

	sdd.dryrun = B_FALSE;
	sdd.verbosity = 0;
	}

	err = dump_filesystems(zhp, &sdd);
	fsavl_destroy(fsavl);
	fnvlist_free(fss);

	/* Ensure no snaps found is treated as an error. */
	if (err == 0 && !sdd.seento)
	err = ENOENT;

	if (sdd.cleanup_fd != -1) {
	VERIFY(0 == close(sdd.cleanup_fd));
	sdd.cleanup_fd = -1;
	}

	if (!flags->dryrun && (flags->replicate \|\| flags->doall \|\|
	flags->props \|\| flags->backup \|\| flags->holds)) {
	/*
	* write final end record. NB: want to do this even if
	* there was some error, because it might not be totally
	* failed.
	*/
	err = send_conclusion_record(outfd, NULL);
	if (err != 0)
	return (zfs_standard_error(zhp->zfs_hdl, err, errbuf));
	}

	return (err \|\| sdd.err);

	stderr_out:
	err = zfs_standard_error(zhp->zfs_hdl, err, errbuf);
	err_out:
	fsavl_destroy(fsavl);
	fnvlist_free(fss);
	fnvlist_free(sdd.snapholds);

	if (sdd.cleanup_fd != -1)
	VERIFY(0 == close(sdd.cleanup_fd));
	return (err);
	}

	static zfs_handle_t *
	name_to_dir_handle(libzfs_handle_t hdl, const char snapname)
	{
	char dirname[ZFS_MAX_DATASET_NAME_LEN];
	(void) strlcpy(dirname, snapname, ZFS_MAX_DATASET_NAME_LEN);
	char *c = strchr(dirname, '@');
	if (c != NULL)
	*c = '\0';
	return (zfs_open(hdl, dirname, ZFS_TYPE_DATASET));
	}

	/*
	* Returns B_TRUE if earlier is an earlier snapshot in later's timeline; either
	* an earlier snapshot in the same filesystem, or a snapshot before later's
	* origin, or it's origin's origin, etc.
	*/
	static boolean_t
	snapshot_is_before(zfs_handle_t earlier, zfs_handle_t later)
	{
	boolean_t ret;
	uint64_t later_txg =
	(later->zfs_type == ZFS_TYPE_FILESYSTEM \|\|
	later->zfs_type == ZFS_TYPE_VOLUME ?
	UINT64_MAX : zfs_prop_get_int(later, ZFS_PROP_CREATETXG));
	uint64_t earlier_txg = zfs_prop_get_int(earlier, ZFS_PROP_CREATETXG);

	if (earlier_txg >= later_txg)
	return (B_FALSE);

	zfs_handle_t *earlier_dir = name_to_dir_handle(earlier->zfs_hdl,
	earlier->zfs_name);
	zfs_handle_t *later_dir = name_to_dir_handle(later->zfs_hdl,
	later->zfs_name);

	if (strcmp(earlier_dir->zfs_name, later_dir->zfs_name) == 0) {
	zfs_close(earlier_dir);
	zfs_close(later_dir);
	return (B_TRUE);
	}

	char clonename[ZFS_MAX_DATASET_NAME_LEN];
	if (zfs_prop_get(later_dir, ZFS_PROP_ORIGIN, clonename,
	ZFS_MAX_DATASET_NAME_LEN, NULL, NULL, 0, B_TRUE) != 0) {
	zfs_close(earlier_dir);
	zfs_close(later_dir);
	return (B_FALSE);
	}

	zfs_handle_t *origin = zfs_open(earlier->zfs_hdl, clonename,
	ZFS_TYPE_DATASET);
	uint64_t origin_txg = zfs_prop_get_int(origin, ZFS_PROP_CREATETXG);

	/*
	* If "earlier" is exactly the origin, then
	* snapshot_is_before(earlier, origin) will return false (because
	* they're the same).
	*/
	if (origin_txg == earlier_txg &&
	strcmp(origin->zfs_name, earlier->zfs_name) == 0) {
	zfs_close(earlier_dir);
	zfs_close(later_dir);
	zfs_close(origin);
	return (B_TRUE);
	}
	zfs_close(earlier_dir);
	zfs_close(later_dir);

	ret = snapshot_is_before(earlier, origin);
	zfs_close(origin);
	return (ret);
	}

	/*
	* The "zhp" argument is the handle of the dataset to send (typically a
	* snapshot). The "from" argument is the full name of the snapshot or
	* bookmark that is the incremental source.
	*/
	int
	zfs_send_one(zfs_handle_t zhp, const char from, int fd, sendflags_t *flags,
	const char *redactbook)
	{
	int err;
	libzfs_handle_t *hdl = zhp->zfs_hdl;
	char *name = zhp->zfs_name;
	int orig_fd = fd;
	pthread_t ptid;
	progress_arg_t pa = { 0 };

	char errbuf[1024];
	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
	"warning: cannot send '%s'"), name);

	if (from != NULL && strchr(from, '@')) {
	zfs_handle_t *from_zhp = zfs_open(hdl, from,
	ZFS_TYPE_DATASET);
	if (from_zhp == NULL)
	return (-1);
	if (!snapshot_is_before(from_zhp, zhp)) {
	zfs_close(from_zhp);
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"not an earlier snapshot from the same fs"));
	return (zfs_error(hdl, EZFS_CROSSTARGET, errbuf));
	}
	zfs_close(from_zhp);
	}

	if (redactbook != NULL) {
	char bookname[ZFS_MAX_DATASET_NAME_LEN];
	nvlist_t *redact_snaps;
	zfs_handle_t *book_zhp;
	char at, pound;
	int dsnamelen;

	pound = strchr(redactbook, '#');
	if (pound != NULL)
	redactbook = pound + 1;
	at = strchr(name, '@');
	if (at == NULL) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"cannot do a redacted send to a filesystem"));
	return (zfs_error(hdl, EZFS_BADTYPE, errbuf));
	}
	dsnamelen = at - name;
	if (snprintf(bookname, sizeof (bookname), "%.*s#%s",
	dsnamelen, name, redactbook)
	>= sizeof (bookname)) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"invalid bookmark name"));
	return (zfs_error(hdl, EZFS_INVALIDNAME, errbuf));
	}
	book_zhp = zfs_open(hdl, bookname, ZFS_TYPE_BOOKMARK);
	if (book_zhp == NULL)
	return (-1);
	if (nvlist_lookup_nvlist(book_zhp->zfs_props,
	zfs_prop_to_name(ZFS_PROP_REDACT_SNAPS),
	&redact_snaps) != 0 \|\| redact_snaps == NULL) {
	zfs_close(book_zhp);
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"not a redaction bookmark"));
	return (zfs_error(hdl, EZFS_BADTYPE, errbuf));
	}
	zfs_close(book_zhp);
	}

	/*
	* Send fs properties
	*/
	if (flags->props \|\| flags->holds \|\| flags->backup) {
	/*
	* Note: the header generated by send_prelim_records()
	* assumes that the incremental source is in the same
	* filesystem/volume as the target (which is a requirement
	* when doing "zfs send -R"). But that isn't always the
	* case here (e.g. send from snap in origin, or send from
	* bookmark). We pass from=NULL, which will omit this
	* information from the prelim records; it isn't used
	* when receiving this type of stream.
	*/
	err = send_prelim_records(zhp, NULL, fd, B_TRUE, B_FALSE,
	flags->verbosity > 0, flags->dryrun, flags->raw,
	- flags->replicate, flags->backup, flags->holds,
	+ flags->replicate, B_FALSE, flags->backup, flags->holds,
	flags->props, flags->doall, NULL, NULL);
	if (err != 0)
	return (err);
	}

	/*
	* Perform size estimate if verbose was specified.
	*/
	if (flags->verbosity != 0) {
	err = estimate_size(zhp, from, fd, flags, 0, 0, 0, redactbook,
	errbuf);
	if (err != 0)
	return (err);
	}

	if (flags->dryrun)
	return (0);

	/*
	* If progress reporting is requested, spawn a new thread to poll
	* ZFS_IOC_SEND_PROGRESS at a regular interval.
	*/
	if (flags->progress) {
	pa.pa_zhp = zhp;
	pa.pa_fd = fd;
	pa.pa_parsable = flags->parsable;
	pa.pa_estimate = B_FALSE;
	pa.pa_verbosity = flags->verbosity;

	err = pthread_create(&ptid, NULL,
	send_progress_thread, &pa);
	if (err != 0) {
	zfs_error_aux(zhp->zfs_hdl, strerror(errno));
	return (zfs_error(zhp->zfs_hdl,
	EZFS_THREADCREATEFAILED, errbuf));
	}
	}

	err = lzc_send_redacted(name, from, fd,
	lzc_flags_from_sendflags(flags), redactbook);

	if (flags->progress) {
	void *status = NULL;
	if (err != 0)
	(void) pthread_cancel(ptid);
	(void) pthread_join(ptid, &status);
	int error = (int)(uintptr_t)status;
	if (error != 0 && status != PTHREAD_CANCELED) {
	char errbuf[1024];
	(void) snprintf(errbuf, sizeof (errbuf),
	dgettext(TEXT_DOMAIN, "progress thread exited "
	"nonzero"));
	return (zfs_standard_error(hdl, error, errbuf));
	}
	}

	if (flags->props \|\| flags->holds \|\| flags->backup) {
	/* Write the final end record. */
	err = send_conclusion_record(orig_fd, NULL);
	if (err != 0)
	return (zfs_standard_error(hdl, err, errbuf));
	}
	if (err != 0) {
	switch (errno) {
	case EXDEV:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"not an earlier snapshot from the same fs"));
	return (zfs_error(hdl, EZFS_CROSSTARGET, errbuf));

	case ENOENT:
	case ESRCH:
	if (lzc_exists(name)) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"incremental source (%s) does not exist"),
	from);
	}
	return (zfs_error(hdl, EZFS_NOENT, errbuf));

	case EACCES:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"dataset key must be loaded"));
	return (zfs_error(hdl, EZFS_CRYPTOFAILED, errbuf));

	case EBUSY:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"target is busy; if a filesystem, "
	"it must not be mounted"));
	return (zfs_error(hdl, EZFS_BUSY, errbuf));

	case EDQUOT:
	case EFAULT:
	case EFBIG:
	case EINVAL:
	case EIO:
	case ENOLINK:
	case ENOSPC:
	case ENOSTR:
	case ENXIO:
	case EPIPE:
	case ERANGE:
	case EROFS:
	zfs_error_aux(hdl, strerror(errno));
	return (zfs_error(hdl, EZFS_BADBACKUP, errbuf));

	default:
	return (zfs_standard_error(hdl, errno, errbuf));
	}
	}
	return (err != 0);
	}

	/*
	* Routines specific to "zfs recv"
	*/

	static int
	recv_read(libzfs_handle_t hdl, int fd, void buf, int ilen,
	boolean_t byteswap, zio_cksum_t *zc)
	{
	char *cp = buf;
	int rv;
	int len = ilen;

	do {
	rv = read(fd, cp, len);
	cp += rv;
	len -= rv;
	} while (rv > 0);

	if (rv < 0 \|\| len != 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"failed to read from stream"));
	return (zfs_error(hdl, EZFS_BADSTREAM, dgettext(TEXT_DOMAIN,
	"cannot receive")));
	}

	if (zc) {
	if (byteswap)
	fletcher_4_incremental_byteswap(buf, ilen, zc);
	else
	fletcher_4_incremental_native(buf, ilen, zc);
	}
	return (0);
	}

	static int
	recv_read_nvlist(libzfs_handle_t hdl, int fd, int len, nvlist_t *nvp,
	boolean_t byteswap, zio_cksum_t *zc)
	{
	char *buf;
	int err;

	buf = zfs_alloc(hdl, len);
	if (buf == NULL)
	return (ENOMEM);

	if (len > hdl->libzfs_max_nvlist) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "nvlist too large"));
	free(buf);
	return (ENOMEM);
	}

	err = recv_read(hdl, fd, buf, len, byteswap, zc);
	if (err != 0) {
	free(buf);
	return (err);
	}

	err = nvlist_unpack(buf, len, nvp, 0);
	free(buf);
	if (err != 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "invalid "
	"stream (malformed nvlist)"));
	return (EINVAL);
	}
	return (0);
	}

	/*
	* Returns the grand origin (origin of origin of origin...) of a given handle.
	* If this dataset is not a clone, it simply returns a copy of the original
	* handle.
	*/
	static zfs_handle_t *
	recv_open_grand_origin(zfs_handle_t *zhp)
	{
	char origin[ZFS_MAX_DATASET_NAME_LEN];
	zprop_source_t src;
	zfs_handle_t *ozhp = zfs_handle_dup(zhp);

	while (ozhp != NULL) {
	if (zfs_prop_get(ozhp, ZFS_PROP_ORIGIN, origin,
	sizeof (origin), &src, NULL, 0, B_FALSE) != 0)
	break;

	(void) zfs_close(ozhp);
	ozhp = zfs_open(zhp->zfs_hdl, origin, ZFS_TYPE_FILESYSTEM);
	}

	return (ozhp);
	}

	static int
	recv_rename_impl(zfs_handle_t zhp, const char name, const char *newname)
	{
	int err;
	zfs_handle_t *ozhp = NULL;

	/*
	* Attempt to rename the dataset. If it fails with EACCES we have
	* attempted to rename the dataset outside of its encryption root.
	* Force the dataset to become an encryption root and try again.
	*/
	err = lzc_rename(name, newname);
	if (err == EACCES) {
	ozhp = recv_open_grand_origin(zhp);
	if (ozhp == NULL) {
	err = ENOENT;
	goto out;
	}

	err = lzc_change_key(ozhp->zfs_name, DCP_CMD_FORCE_NEW_KEY,
	NULL, NULL, 0);
	if (err != 0)
	goto out;

	err = lzc_rename(name, newname);
	}

	out:
	if (ozhp != NULL)
	zfs_close(ozhp);
	return (err);
	}

	static int
	recv_rename(libzfs_handle_t hdl, const char name, const char *tryname,
	int baselen, char newname, recvflags_t flags)
	{
	static int seq;
	int err;
	prop_changelist_t *clp = NULL;
	zfs_handle_t *zhp = NULL;

	zhp = zfs_open(hdl, name, ZFS_TYPE_DATASET);
	if (zhp == NULL) {
	err = -1;
	goto out;
	}
	clp = changelist_gather(zhp, ZFS_PROP_NAME, 0,
	flags->force ? MS_FORCE : 0);
	if (clp == NULL) {
	err = -1;
	goto out;
	}
	err = changelist_prefix(clp);
	if (err)
	goto out;

	if (tryname) {
	(void) strcpy(newname, tryname);
	if (flags->verbose) {
	(void) printf("attempting rename %s to %s\n",
	name, newname);
	}
	err = recv_rename_impl(zhp, name, newname);
	if (err == 0)
	changelist_rename(clp, name, tryname);
	} else {
	err = ENOENT;
	}

	if (err != 0 && strncmp(name + baselen, "recv-", 5) != 0) {
	seq++;

	(void) snprintf(newname, ZFS_MAX_DATASET_NAME_LEN,
	"%.*srecv-%u-%u", baselen, name, getpid(), seq);

	if (flags->verbose) {
	(void) printf("failed - trying rename %s to %s\n",
	name, newname);
	}
	err = recv_rename_impl(zhp, name, newname);
	if (err == 0)
	changelist_rename(clp, name, newname);
	if (err && flags->verbose) {
	(void) printf("failed (%u) - "
	"will try again on next pass\n", errno);
	}
	err = EAGAIN;
	} else if (flags->verbose) {
	if (err == 0)
	(void) printf("success\n");
	else
	(void) printf("failed (%u)\n", errno);
	}

	(void) changelist_postfix(clp);

	out:
	if (clp != NULL)
	changelist_free(clp);
	if (zhp != NULL)
	zfs_close(zhp);

	return (err);
	}

	static int
	recv_promote(libzfs_handle_t hdl, const char fsname,
	const char origin_fsname, recvflags_t flags)
	{
	int err;
	zfs_cmd_t zc = {"\0"};
	zfs_handle_t zhp = NULL, ozhp = NULL;

	if (flags->verbose)
	(void) printf("promoting %s\n", fsname);

	(void) strlcpy(zc.zc_value, origin_fsname, sizeof (zc.zc_value));
	(void) strlcpy(zc.zc_name, fsname, sizeof (zc.zc_name));

	/*
	* Attempt to promote the dataset. If it fails with EACCES the
	* promotion would cause this dataset to leave its encryption root.
	* Force the origin to become an encryption root and try again.
	*/
	err = zfs_ioctl(hdl, ZFS_IOC_PROMOTE, &zc);
	if (err == EACCES) {
	zhp = zfs_open(hdl, fsname, ZFS_TYPE_DATASET);
	if (zhp == NULL) {
	err = -1;
	goto out;
	}

	ozhp = recv_open_grand_origin(zhp);
	if (ozhp == NULL) {
	err = -1;
	goto out;
	}

	err = lzc_change_key(ozhp->zfs_name, DCP_CMD_FORCE_NEW_KEY,
	NULL, NULL, 0);
	if (err != 0)
	goto out;

	err = zfs_ioctl(hdl, ZFS_IOC_PROMOTE, &zc);
	}

	out:
	if (zhp != NULL)
	zfs_close(zhp);
	if (ozhp != NULL)
	zfs_close(ozhp);

	return (err);
	}

	static int
	recv_destroy(libzfs_handle_t hdl, const char name, int baselen,
	char newname, recvflags_t flags)
	{
	int err = 0;
	prop_changelist_t *clp;
	zfs_handle_t *zhp;
	boolean_t defer = B_FALSE;
	int spa_version;

	zhp = zfs_open(hdl, name, ZFS_TYPE_DATASET);
	if (zhp == NULL)
	return (-1);
	clp = changelist_gather(zhp, ZFS_PROP_NAME, 0,
	flags->force ? MS_FORCE : 0);
	if (zfs_get_type(zhp) == ZFS_TYPE_SNAPSHOT &&
	zfs_spa_version(zhp, &spa_version) == 0 &&
	spa_version >= SPA_VERSION_USERREFS)
	defer = B_TRUE;
	zfs_close(zhp);
	if (clp == NULL)
	return (-1);
	err = changelist_prefix(clp);
	if (err)
	return (err);

	if (flags->verbose)
	(void) printf("attempting destroy %s\n", name);
	if (zhp->zfs_type == ZFS_TYPE_SNAPSHOT) {
	nvlist_t *nv = fnvlist_alloc();
	fnvlist_add_boolean(nv, name);
	err = lzc_destroy_snaps(nv, defer, NULL);
	fnvlist_free(nv);
	} else {
	err = lzc_destroy(name);
	}
	if (err == 0) {
	if (flags->verbose)
	(void) printf("success\n");
	changelist_remove(clp, name);
	}

	(void) changelist_postfix(clp);
	changelist_free(clp);

	/*
	* Deferred destroy might destroy the snapshot or only mark it to be
	* destroyed later, and it returns success in either case.
	*/
	if (err != 0 \|\| (defer && zfs_dataset_exists(hdl, name,
	ZFS_TYPE_SNAPSHOT))) {
	err = recv_rename(hdl, name, NULL, baselen, newname, flags);
	}

	return (err);
	}

	typedef struct guid_to_name_data {
	uint64_t guid;
	boolean_t bookmark_ok;
	char *name;
	char *skip;
	uint64_t *redact_snap_guids;
	uint64_t num_redact_snaps;
	} guid_to_name_data_t;

	static boolean_t
	redact_snaps_match(zfs_handle_t zhp, guid_to_name_data_t gtnd)
	{
	uint64_t *bmark_snaps;
	uint_t bmark_num_snaps;
	nvlist_t *nvl;
	if (zhp->zfs_type != ZFS_TYPE_BOOKMARK)
	return (B_FALSE);

	nvl = fnvlist_lookup_nvlist(zhp->zfs_props,
	zfs_prop_to_name(ZFS_PROP_REDACT_SNAPS));
	bmark_snaps = fnvlist_lookup_uint64_array(nvl, ZPROP_VALUE,
	&bmark_num_snaps);
	if (bmark_num_snaps != gtnd->num_redact_snaps)
	return (B_FALSE);
	int i = 0;
	for (; i < bmark_num_snaps; i++) {
	int j = 0;
	for (; j < bmark_num_snaps; j++) {
	if (bmark_snaps[i] == gtnd->redact_snap_guids[j])
	break;
	}
	if (j == bmark_num_snaps)
	break;
	}
	return (i == bmark_num_snaps);
	}

	static int
	guid_to_name_cb(zfs_handle_t zhp, void arg)
	{
	guid_to_name_data_t *gtnd = arg;
	const char *slash;
	int err;

	if (gtnd->skip != NULL &&
	(slash = strrchr(zhp->zfs_name, '/')) != NULL &&
	strcmp(slash + 1, gtnd->skip) == 0) {
	zfs_close(zhp);
	return (0);
	}

	if (zfs_prop_get_int(zhp, ZFS_PROP_GUID) == gtnd->guid &&
	(gtnd->num_redact_snaps == -1 \|\| redact_snaps_match(zhp, gtnd))) {
	(void) strcpy(gtnd->name, zhp->zfs_name);
	zfs_close(zhp);
	return (EEXIST);
	}

	err = zfs_iter_children(zhp, guid_to_name_cb, gtnd);
	if (err != EEXIST && gtnd->bookmark_ok)
	err = zfs_iter_bookmarks(zhp, guid_to_name_cb, gtnd);
	zfs_close(zhp);
	return (err);
	}

	/*
	* Attempt to find the local dataset associated with this guid. In the case of
	* multiple matches, we attempt to find the "best" match by searching
	* progressively larger portions of the hierarchy. This allows one to send a
	* tree of datasets individually and guarantee that we will find the source
	* guid within that hierarchy, even if there are multiple matches elsewhere.
	*
	* If num_redact_snaps is not -1, we attempt to find a redaction bookmark with
	* the specified number of redaction snapshots. If num_redact_snaps isn't 0 or
	* -1, then redact_snap_guids will be an array of the guids of the snapshots the
	* redaction bookmark was created with. If num_redact_snaps is -1, then we will
	* attempt to find a snapshot or bookmark (if bookmark_ok is passed) with the
	* given guid. Note that a redaction bookmark can be returned if
	* num_redact_snaps == -1.
	*/
	static int
	guid_to_name_redact_snaps(libzfs_handle_t hdl, const char parent,
	uint64_t guid, boolean_t bookmark_ok, uint64_t *redact_snap_guids,
	uint64_t num_redact_snaps, char *name)
	{
	char pname[ZFS_MAX_DATASET_NAME_LEN];
	guid_to_name_data_t gtnd;

	gtnd.guid = guid;
	gtnd.bookmark_ok = bookmark_ok;
	gtnd.name = name;
	gtnd.skip = NULL;
	gtnd.redact_snap_guids = redact_snap_guids;
	gtnd.num_redact_snaps = num_redact_snaps;

	/*
	* Search progressively larger portions of the hierarchy, starting
	* with the filesystem specified by 'parent'. This will
	* select the "most local" version of the origin snapshot in the case
	* that there are multiple matching snapshots in the system.
	*/
	(void) strlcpy(pname, parent, sizeof (pname));
	char *cp = strrchr(pname, '@');
	if (cp == NULL)
	cp = strchr(pname, '\0');
	for (; cp != NULL; cp = strrchr(pname, '/')) {
	/* Chop off the last component and open the parent */
	*cp = '\0';
	zfs_handle_t *zhp = make_dataset_handle(hdl, pname);

	if (zhp == NULL)
	continue;
	int err = guid_to_name_cb(zfs_handle_dup(zhp), &gtnd);
	if (err != EEXIST)
	err = zfs_iter_children(zhp, guid_to_name_cb, &gtnd);
	if (err != EEXIST && bookmark_ok)
	err = zfs_iter_bookmarks(zhp, guid_to_name_cb, &gtnd);
	zfs_close(zhp);
	if (err == EEXIST)
	return (0);

	/*
	* Remember the last portion of the dataset so we skip it next
	* time through (as we've already searched that portion of the
	* hierarchy).
	*/
	gtnd.skip = strrchr(pname, '/') + 1;
	}

	return (ENOENT);
	}

	static int
	guid_to_name(libzfs_handle_t hdl, const char parent, uint64_t guid,
	boolean_t bookmark_ok, char *name)
	{
	return (guid_to_name_redact_snaps(hdl, parent, guid, bookmark_ok, NULL,
	-1, name));
	}

	/*
	* Return +1 if guid1 is before guid2, 0 if they are the same, and -1 if
	* guid1 is after guid2.
	*/
	static int
	created_before(libzfs_handle_t hdl, avl_tree_t avl,
	uint64_t guid1, uint64_t guid2)
	{
	nvlist_t *nvfs;
	char fsname = NULL, snapname = NULL;
	char buf[ZFS_MAX_DATASET_NAME_LEN];
	int rv;
	zfs_handle_t guid1hdl, guid2hdl;
	uint64_t create1, create2;

	if (guid2 == 0)
	return (0);
	if (guid1 == 0)
	return (1);

	nvfs = fsavl_find(avl, guid1, &snapname);
	fsname = fnvlist_lookup_string(nvfs, "name");
	(void) snprintf(buf, sizeof (buf), "%s@%s", fsname, snapname);
	guid1hdl = zfs_open(hdl, buf, ZFS_TYPE_SNAPSHOT);
	if (guid1hdl == NULL)
	return (-1);

	nvfs = fsavl_find(avl, guid2, &snapname);
	fsname = fnvlist_lookup_string(nvfs, "name");
	(void) snprintf(buf, sizeof (buf), "%s@%s", fsname, snapname);
	guid2hdl = zfs_open(hdl, buf, ZFS_TYPE_SNAPSHOT);
	if (guid2hdl == NULL) {
	zfs_close(guid1hdl);
	return (-1);
	}

	create1 = zfs_prop_get_int(guid1hdl, ZFS_PROP_CREATETXG);
	create2 = zfs_prop_get_int(guid2hdl, ZFS_PROP_CREATETXG);

	if (create1 < create2)
	rv = -1;
	else if (create1 > create2)
	rv = +1;
	else
	rv = 0;

	zfs_close(guid1hdl);
	zfs_close(guid2hdl);

	return (rv);
	}

	/*
	* This function reestablishes the hierarchy of encryption roots after a
	* recursive incremental receive has completed. This must be done after the
	* second call to recv_incremental_replication() has renamed and promoted all
	* sent datasets to their final locations in the dataset hierarchy.
	*/
	static int
	recv_fix_encryption_hierarchy(libzfs_handle_t hdl, const char top_zfs,
	nvlist_t stream_nv, avl_tree_t stream_avl)
	{
	int err;
	nvpair_t *fselem = NULL;
	nvlist_t *stream_fss;

	stream_fss = fnvlist_lookup_nvlist(stream_nv, "fss");

	while ((fselem = nvlist_next_nvpair(stream_fss, fselem)) != NULL) {
	zfs_handle_t *zhp = NULL;
	uint64_t crypt;
	nvlist_t snaps, props, *stream_nvfs = NULL;
	nvpair_t *snapel = NULL;
	boolean_t is_encroot, is_clone, stream_encroot;
	char *cp;
	char *stream_keylocation = NULL;
	char keylocation[MAXNAMELEN];
	char fsname[ZFS_MAX_DATASET_NAME_LEN];

	keylocation[0] = '\0';
	stream_nvfs = fnvpair_value_nvlist(fselem);
	snaps = fnvlist_lookup_nvlist(stream_nvfs, "snaps");
	props = fnvlist_lookup_nvlist(stream_nvfs, "props");
	stream_encroot = nvlist_exists(stream_nvfs, "is_encroot");

	/* find a snapshot from the stream that exists locally */
	err = ENOENT;
	while ((snapel = nvlist_next_nvpair(snaps, snapel)) != NULL) {
	uint64_t guid;

	guid = fnvpair_value_uint64(snapel);
	err = guid_to_name(hdl, top_zfs, guid, B_FALSE,
	fsname);
	if (err == 0)
	break;
	}

	if (err != 0)
	continue;

	cp = strchr(fsname, '@');
	if (cp != NULL)
	*cp = '\0';

	zhp = zfs_open(hdl, fsname, ZFS_TYPE_DATASET);
	if (zhp == NULL) {
	err = ENOENT;
	goto error;
	}

	crypt = zfs_prop_get_int(zhp, ZFS_PROP_ENCRYPTION);
	is_clone = zhp->zfs_dmustats.dds_origin[0] != '\0';
	(void) zfs_crypto_get_encryption_root(zhp, &is_encroot, NULL);

	/* we don't need to do anything for unencrypted datasets */
	if (crypt == ZIO_CRYPT_OFF) {
	zfs_close(zhp);
	continue;
	}

	/*
	* If the dataset is flagged as an encryption root, was not
	* received as a clone and is not currently an encryption root,
	* force it to become one. Fixup the keylocation if necessary.
	*/
	if (stream_encroot) {
	if (!is_clone && !is_encroot) {
	err = lzc_change_key(fsname,
	DCP_CMD_FORCE_NEW_KEY, NULL, NULL, 0);
	if (err != 0) {
	zfs_close(zhp);
	goto error;
	}
	}

	stream_keylocation = fnvlist_lookup_string(props,
	zfs_prop_to_name(ZFS_PROP_KEYLOCATION));

	/*
	* Refresh the properties in case the call to
	* lzc_change_key() changed the value.
	*/
	zfs_refresh_properties(zhp);
	err = zfs_prop_get(zhp, ZFS_PROP_KEYLOCATION,
	keylocation, sizeof (keylocation), NULL, NULL,
	0, B_TRUE);
	if (err != 0) {
	zfs_close(zhp);
	goto error;
	}

	if (strcmp(keylocation, stream_keylocation) != 0) {
	err = zfs_prop_set(zhp,
	zfs_prop_to_name(ZFS_PROP_KEYLOCATION),
	stream_keylocation);
	if (err != 0) {
	zfs_close(zhp);
	goto error;
	}
	}
	}

	/*
	* If the dataset is not flagged as an encryption root and is
	* currently an encryption root, force it to inherit from its
	* parent. The root of a raw send should never be
	* force-inherited.
	*/
	if (!stream_encroot && is_encroot &&
	strcmp(top_zfs, fsname) != 0) {
	err = lzc_change_key(fsname, DCP_CMD_FORCE_INHERIT,
	NULL, NULL, 0);
	if (err != 0) {
	zfs_close(zhp);
	goto error;
	}
	}

	zfs_close(zhp);
	}

	return (0);

	error:
	return (err);
	}

	static int
	recv_incremental_replication(libzfs_handle_t hdl, const char tofs,
	recvflags_t flags, nvlist_t stream_nv, avl_tree_t *stream_avl,
	nvlist_t *renamed)
	{
	nvlist_t local_nv, deleted = NULL;
	avl_tree_t *local_avl;
	nvpair_t fselem, nextfselem;
	char *fromsnap;
	char newname[ZFS_MAX_DATASET_NAME_LEN];
	char guidname[32];
	int error;
	boolean_t needagain, progress, recursive;
	char s1, s2;

	fromsnap = fnvlist_lookup_string(stream_nv, "fromsnap");

	recursive = (nvlist_lookup_boolean(stream_nv, "not_recursive") ==
	ENOENT);

	if (flags->dryrun)
	return (0);

	again:
	needagain = progress = B_FALSE;

	deleted = fnvlist_alloc();

	if ((error = gather_nvlist(hdl, tofs, fromsnap, NULL,
	- recursive, B_TRUE, B_FALSE, recursive, B_FALSE, B_FALSE,
	+ recursive, B_TRUE, B_FALSE, recursive, B_FALSE, B_FALSE, B_FALSE,
	B_FALSE, B_TRUE, &local_nv, &local_avl)) != 0)
	return (error);

	/*
	* Process deletes and renames
	*/
	for (fselem = nvlist_next_nvpair(local_nv, NULL);
	fselem; fselem = nextfselem) {
	nvlist_t nvfs, snaps;
	nvlist_t *stream_nvfs = NULL;
	nvpair_t snapelem, nextsnapelem;
	uint64_t fromguid = 0;
	uint64_t originguid = 0;
	uint64_t stream_originguid = 0;
	uint64_t parent_fromsnap_guid, stream_parent_fromsnap_guid;
	char fsname, stream_fsname;

	nextfselem = nvlist_next_nvpair(local_nv, fselem);

	nvfs = fnvpair_value_nvlist(fselem);
	snaps = fnvlist_lookup_nvlist(nvfs, "snaps");
	fsname = fnvlist_lookup_string(nvfs, "name");
	parent_fromsnap_guid = fnvlist_lookup_uint64(nvfs,
	"parentfromsnap");
	(void) nvlist_lookup_uint64(nvfs, "origin", &originguid);

	/*
	* First find the stream's fs, so we can check for
	* a different origin (due to "zfs promote")
	*/
	for (snapelem = nvlist_next_nvpair(snaps, NULL);
	snapelem; snapelem = nvlist_next_nvpair(snaps, snapelem)) {
	uint64_t thisguid;

	thisguid = fnvpair_value_uint64(snapelem);
	stream_nvfs = fsavl_find(stream_avl, thisguid, NULL);

	if (stream_nvfs != NULL)
	break;
	}

	/* check for promote */
	(void) nvlist_lookup_uint64(stream_nvfs, "origin",
	&stream_originguid);
	if (stream_nvfs && originguid != stream_originguid) {
	switch (created_before(hdl, local_avl,
	stream_originguid, originguid)) {
	case 1: {
	/* promote it! */
	nvlist_t *origin_nvfs;
	char *origin_fsname;

	origin_nvfs = fsavl_find(local_avl, originguid,
	NULL);
	origin_fsname = fnvlist_lookup_string(
	origin_nvfs, "name");
	error = recv_promote(hdl, fsname, origin_fsname,
	flags);
	if (error == 0)
	progress = B_TRUE;
	break;
	}
	default:
	break;
	case -1:
	fsavl_destroy(local_avl);
	fnvlist_free(local_nv);
	return (-1);
	}
	/*
	* We had/have the wrong origin, therefore our
	* list of snapshots is wrong. Need to handle
	* them on the next pass.
	*/
	needagain = B_TRUE;
	continue;
	}

	for (snapelem = nvlist_next_nvpair(snaps, NULL);
	snapelem; snapelem = nextsnapelem) {
	uint64_t thisguid;
	char *stream_snapname;
	nvlist_t found, props;

	nextsnapelem = nvlist_next_nvpair(snaps, snapelem);

	thisguid = fnvpair_value_uint64(snapelem);
	found = fsavl_find(stream_avl, thisguid,
	&stream_snapname);

	/* check for delete */
	if (found == NULL) {
	char name[ZFS_MAX_DATASET_NAME_LEN];

	if (!flags->force)
	continue;

	(void) snprintf(name, sizeof (name), "%s@%s",
	fsname, nvpair_name(snapelem));

	error = recv_destroy(hdl, name,
	strlen(fsname)+1, newname, flags);
	if (error)
	needagain = B_TRUE;
	else
	progress = B_TRUE;
	sprintf(guidname, "%llu",
	(u_longlong_t)thisguid);
	nvlist_add_boolean(deleted, guidname);
	continue;
	}

	stream_nvfs = found;

	if (0 == nvlist_lookup_nvlist(stream_nvfs, "snapprops",
	&props) && 0 == nvlist_lookup_nvlist(props,
	stream_snapname, &props)) {
	zfs_cmd_t zc = {"\0"};

	zc.zc_cookie = B_TRUE; /* received */
	(void) snprintf(zc.zc_name, sizeof (zc.zc_name),
	"%s@%s", fsname, nvpair_name(snapelem));
	if (zcmd_write_src_nvlist(hdl, &zc,
	props) == 0) {
	(void) zfs_ioctl(hdl,
	ZFS_IOC_SET_PROP, &zc);
	zcmd_free_nvlists(&zc);
	}
	}

	/* check for different snapname */
	if (strcmp(nvpair_name(snapelem),
	stream_snapname) != 0) {
	char name[ZFS_MAX_DATASET_NAME_LEN];
	char tryname[ZFS_MAX_DATASET_NAME_LEN];

	(void) snprintf(name, sizeof (name), "%s@%s",
	fsname, nvpair_name(snapelem));
	(void) snprintf(tryname, sizeof (name), "%s@%s",
	fsname, stream_snapname);

	error = recv_rename(hdl, name, tryname,
	strlen(fsname)+1, newname, flags);
	if (error)
	needagain = B_TRUE;
	else
	progress = B_TRUE;
	}

	if (strcmp(stream_snapname, fromsnap) == 0)
	fromguid = thisguid;
	}

	/* check for delete */
	if (stream_nvfs == NULL) {
	if (!flags->force)
	continue;

	error = recv_destroy(hdl, fsname, strlen(tofs)+1,
	newname, flags);
	if (error)
	needagain = B_TRUE;
	else
	progress = B_TRUE;
	sprintf(guidname, "%llu",
	(u_longlong_t)parent_fromsnap_guid);
	nvlist_add_boolean(deleted, guidname);
	continue;
	}

	if (fromguid == 0) {
	if (flags->verbose) {
	(void) printf("local fs %s does not have "
	"fromsnap (%s in stream); must have "
	"been deleted locally; ignoring\n",
	fsname, fromsnap);
	}
	continue;
	}

	stream_fsname = fnvlist_lookup_string(stream_nvfs, "name");
	stream_parent_fromsnap_guid = fnvlist_lookup_uint64(
	stream_nvfs, "parentfromsnap");

	s1 = strrchr(fsname, '/');
	s2 = strrchr(stream_fsname, '/');

	/*
	* Check if we're going to rename based on parent guid change
	* and the current parent guid was also deleted. If it was then
	* rename will fail and is likely unneeded, so avoid this and
	* force an early retry to determine the new
	* parent_fromsnap_guid.
	*/
	if (stream_parent_fromsnap_guid != 0 &&
	parent_fromsnap_guid != 0 &&
	stream_parent_fromsnap_guid != parent_fromsnap_guid) {
	sprintf(guidname, "%llu",
	(u_longlong_t)parent_fromsnap_guid);
	if (nvlist_exists(deleted, guidname)) {
	progress = B_TRUE;
	needagain = B_TRUE;
	goto doagain;
	}
	}

	/*
	* Check for rename. If the exact receive path is specified, it
	* does not count as a rename, but we still need to check the
	* datasets beneath it.
	*/
	if ((stream_parent_fromsnap_guid != 0 &&
	parent_fromsnap_guid != 0 &&
	stream_parent_fromsnap_guid != parent_fromsnap_guid) \|\|
	((flags->isprefix \|\| strcmp(tofs, fsname) != 0) &&
	(s1 != NULL) && (s2 != NULL) && strcmp(s1, s2) != 0)) {
	nvlist_t *parent;
	char tryname[ZFS_MAX_DATASET_NAME_LEN];

	parent = fsavl_find(local_avl,
	stream_parent_fromsnap_guid, NULL);
	/*
	* NB: parent might not be found if we used the
	* tosnap for stream_parent_fromsnap_guid,
	* because the parent is a newly-created fs;
	* we'll be able to rename it after we recv the
	* new fs.
	*/
	if (parent != NULL) {
	char *pname;

	pname = fnvlist_lookup_string(parent, "name");
	(void) snprintf(tryname, sizeof (tryname),
	"%s%s", pname, strrchr(stream_fsname, '/'));
	} else {
	tryname[0] = '\0';
	if (flags->verbose) {
	(void) printf("local fs %s new parent "
	"not found\n", fsname);
	}
	}

	newname[0] = '\0';

	error = recv_rename(hdl, fsname, tryname,
	strlen(tofs)+1, newname, flags);

	if (renamed != NULL && newname[0] != '\0') {
	fnvlist_add_boolean(renamed, newname);
	}

	if (error)
	needagain = B_TRUE;
	else
	progress = B_TRUE;
	}
	}

	doagain:
	fsavl_destroy(local_avl);
	fnvlist_free(local_nv);
	fnvlist_free(deleted);

	if (needagain && progress) {
	/* do another pass to fix up temporary names */
	if (flags->verbose)
	(void) printf("another pass:\n");
	goto again;
	}

	return (needagain \|\| error != 0);
	}

	static int
	zfs_receive_package(libzfs_handle_t hdl, int fd, const char destname,
	recvflags_t flags, dmu_replay_record_t drr, zio_cksum_t *zc,
	char *top_zfs, nvlist_t cmdprops)
	{
	nvlist_t *stream_nv = NULL;
	avl_tree_t *stream_avl = NULL;
	char *fromsnap = NULL;
	char *sendsnap = NULL;
	char *cp;
	char tofs[ZFS_MAX_DATASET_NAME_LEN];
	char sendfs[ZFS_MAX_DATASET_NAME_LEN];
	char errbuf[1024];
	dmu_replay_record_t drre;
	int error;
	boolean_t anyerr = B_FALSE;
	boolean_t softerr = B_FALSE;
	boolean_t recursive, raw;

	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
	"cannot receive"));

	assert(drr->drr_type == DRR_BEGIN);
	assert(drr->drr_u.drr_begin.drr_magic == DMU_BACKUP_MAGIC);
	assert(DMU_GET_STREAM_HDRTYPE(drr->drr_u.drr_begin.drr_versioninfo) ==
	DMU_COMPOUNDSTREAM);

	/*
	* Read in the nvlist from the stream.
	*/
	if (drr->drr_payloadlen != 0) {
	error = recv_read_nvlist(hdl, fd, drr->drr_payloadlen,
	&stream_nv, flags->byteswap, zc);
	if (error) {
	error = zfs_error(hdl, EZFS_BADSTREAM, errbuf);
	goto out;
	}
	}

	recursive = (nvlist_lookup_boolean(stream_nv, "not_recursive") ==
	ENOENT);
	raw = (nvlist_lookup_boolean(stream_nv, "raw") == 0);

	if (recursive && strchr(destname, '@')) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"cannot specify snapshot name for multi-snapshot stream"));
	error = zfs_error(hdl, EZFS_BADSTREAM, errbuf);
	goto out;
	}

	/*
	* Read in the end record and verify checksum.
	*/
	if (0 != (error = recv_read(hdl, fd, &drre, sizeof (drre),
	flags->byteswap, NULL)))
	goto out;
	if (flags->byteswap) {
	drre.drr_type = BSWAP_32(drre.drr_type);
	drre.drr_u.drr_end.drr_checksum.zc_word[0] =
	BSWAP_64(drre.drr_u.drr_end.drr_checksum.zc_word[0]);
	drre.drr_u.drr_end.drr_checksum.zc_word[1] =
	BSWAP_64(drre.drr_u.drr_end.drr_checksum.zc_word[1]);
	drre.drr_u.drr_end.drr_checksum.zc_word[2] =
	BSWAP_64(drre.drr_u.drr_end.drr_checksum.zc_word[2]);
	drre.drr_u.drr_end.drr_checksum.zc_word[3] =
	BSWAP_64(drre.drr_u.drr_end.drr_checksum.zc_word[3]);
	}
	if (drre.drr_type != DRR_END) {
	error = zfs_error(hdl, EZFS_BADSTREAM, errbuf);
	goto out;
	}
	if (!ZIO_CHECKSUM_EQUAL(drre.drr_u.drr_end.drr_checksum, *zc)) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"incorrect header checksum"));
	error = zfs_error(hdl, EZFS_BADSTREAM, errbuf);
	goto out;
	}

	(void) nvlist_lookup_string(stream_nv, "fromsnap", &fromsnap);

	if (drr->drr_payloadlen != 0) {
	nvlist_t *stream_fss;

	stream_fss = fnvlist_lookup_nvlist(stream_nv, "fss");
	if ((stream_avl = fsavl_create(stream_fss)) == NULL) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"couldn't allocate avl tree"));
	error = zfs_error(hdl, EZFS_NOMEM, errbuf);
	goto out;
	}

	if (fromsnap != NULL && recursive) {
	nvlist_t *renamed = NULL;
	nvpair_t *pair = NULL;

	(void) strlcpy(tofs, destname, sizeof (tofs));
	if (flags->isprefix) {
	struct drr_begin *drrb = &drr->drr_u.drr_begin;
	int i;

	if (flags->istail) {
	cp = strrchr(drrb->drr_toname, '/');
	if (cp == NULL) {
	(void) strlcat(tofs, "/",
	sizeof (tofs));
	i = 0;
	} else {
	i = (cp - drrb->drr_toname);
	}
	} else {
	i = strcspn(drrb->drr_toname, "/@");
	}
	/* zfs_receive_one() will create_parents() */
	(void) strlcat(tofs, &drrb->drr_toname[i],
	sizeof (tofs));
	*strchr(tofs, '@') = '\0';
	}

	if (!flags->dryrun && !flags->nomount) {
	renamed = fnvlist_alloc();
	}

	softerr = recv_incremental_replication(hdl, tofs, flags,
	stream_nv, stream_avl, renamed);

	/* Unmount renamed filesystems before receiving. */
	while ((pair = nvlist_next_nvpair(renamed,
	pair)) != NULL) {
	zfs_handle_t *zhp;
	prop_changelist_t *clp = NULL;

	zhp = zfs_open(hdl, nvpair_name(pair),
	ZFS_TYPE_FILESYSTEM);
	if (zhp != NULL) {
	clp = changelist_gather(zhp,
	ZFS_PROP_MOUNTPOINT, 0,
	flags->forceunmount ? MS_FORCE : 0);
	zfs_close(zhp);
	if (clp != NULL) {
	softerr \|=
	changelist_prefix(clp);
	changelist_free(clp);
	}
	}
	}

	fnvlist_free(renamed);
	}
	}

	/*
	* Get the fs specified by the first path in the stream (the top level
	* specified by 'zfs send') and pass it to each invocation of
	* zfs_receive_one().
	*/
	(void) strlcpy(sendfs, drr->drr_u.drr_begin.drr_toname,
	sizeof (sendfs));
	if ((cp = strchr(sendfs, '@')) != NULL) {
	*cp = '\0';
	/*
	* Find the "sendsnap", the final snapshot in a replication
	* stream. zfs_receive_one() handles certain errors
	* differently, depending on if the contained stream is the
	* last one or not.
	*/
	sendsnap = (cp + 1);
	}

	/* Finally, receive each contained stream */
	do {
	/*
	* we should figure out if it has a recoverable
	* error, in which case do a recv_skip() and drive on.
	* Note, if we fail due to already having this guid,
	* zfs_receive_one() will take care of it (ie,
	* recv_skip() and return 0).
	*/
	error = zfs_receive_impl(hdl, destname, NULL, flags, fd,
	sendfs, stream_nv, stream_avl, top_zfs, sendsnap, cmdprops);
	if (error == ENODATA) {
	error = 0;
	break;
	}
	anyerr \|= error;
	} while (error == 0);

	if (drr->drr_payloadlen != 0 && recursive && fromsnap != NULL) {
	/*
	* Now that we have the fs's they sent us, try the
	* renames again.
	*/
	softerr = recv_incremental_replication(hdl, tofs, flags,
	stream_nv, stream_avl, NULL);
	}

	if (raw && softerr == 0 && *top_zfs != NULL) {
	softerr = recv_fix_encryption_hierarchy(hdl, *top_zfs,
	stream_nv, stream_avl);
	}

	out:
	fsavl_destroy(stream_avl);
	fnvlist_free(stream_nv);
	if (softerr)
	error = -2;
	if (anyerr)
	error = -1;
	return (error);
	}

	static void
	trunc_prop_errs(int truncated)
	{
	ASSERT(truncated != 0);

	if (truncated == 1)
	(void) fprintf(stderr, dgettext(TEXT_DOMAIN,
	"1 more property could not be set\n"));
	else
	(void) fprintf(stderr, dgettext(TEXT_DOMAIN,
	"%d more properties could not be set\n"), truncated);
	}

	static int
	recv_skip(libzfs_handle_t *hdl, int fd, boolean_t byteswap)
	{
	dmu_replay_record_t *drr;
	void *buf = zfs_alloc(hdl, SPA_MAXBLOCKSIZE);
	uint64_t payload_size;
	char errbuf[1024];

	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
	"cannot receive"));

	/* XXX would be great to use lseek if possible... */
	drr = buf;

	while (recv_read(hdl, fd, drr, sizeof (dmu_replay_record_t),
	byteswap, NULL) == 0) {
	if (byteswap)
	drr->drr_type = BSWAP_32(drr->drr_type);

	switch (drr->drr_type) {
	case DRR_BEGIN:
	if (drr->drr_payloadlen != 0) {
	(void) recv_read(hdl, fd, buf,
	drr->drr_payloadlen, B_FALSE, NULL);
	}
	break;

	case DRR_END:
	free(buf);
	return (0);

	case DRR_OBJECT:
	if (byteswap) {
	drr->drr_u.drr_object.drr_bonuslen =
	BSWAP_32(drr->drr_u.drr_object.
	drr_bonuslen);
	drr->drr_u.drr_object.drr_raw_bonuslen =
	BSWAP_32(drr->drr_u.drr_object.
	drr_raw_bonuslen);
	}

	payload_size =
	DRR_OBJECT_PAYLOAD_SIZE(&drr->drr_u.drr_object);
	(void) recv_read(hdl, fd, buf, payload_size,
	B_FALSE, NULL);
	break;

	case DRR_WRITE:
	if (byteswap) {
	drr->drr_u.drr_write.drr_logical_size =
	BSWAP_64(
	drr->drr_u.drr_write.drr_logical_size);
	drr->drr_u.drr_write.drr_compressed_size =
	BSWAP_64(
	drr->drr_u.drr_write.drr_compressed_size);
	}
	payload_size =
	DRR_WRITE_PAYLOAD_SIZE(&drr->drr_u.drr_write);
	assert(payload_size <= SPA_MAXBLOCKSIZE);
	(void) recv_read(hdl, fd, buf,
	payload_size, B_FALSE, NULL);
	break;
	case DRR_SPILL:
	if (byteswap) {
	drr->drr_u.drr_spill.drr_length =
	BSWAP_64(drr->drr_u.drr_spill.drr_length);
	drr->drr_u.drr_spill.drr_compressed_size =
	BSWAP_64(drr->drr_u.drr_spill.
	drr_compressed_size);
	}

	payload_size =
	DRR_SPILL_PAYLOAD_SIZE(&drr->drr_u.drr_spill);
	(void) recv_read(hdl, fd, buf, payload_size,
	B_FALSE, NULL);
	break;
	case DRR_WRITE_EMBEDDED:
	if (byteswap) {
	drr->drr_u.drr_write_embedded.drr_psize =
	BSWAP_32(drr->drr_u.drr_write_embedded.
	drr_psize);
	}
	(void) recv_read(hdl, fd, buf,
	P2ROUNDUP(drr->drr_u.drr_write_embedded.drr_psize,
	8), B_FALSE, NULL);
	break;
	case DRR_OBJECT_RANGE:
	case DRR_WRITE_BYREF:
	case DRR_FREEOBJECTS:
	case DRR_FREE:
	break;

	default:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"invalid record type"));
	free(buf);
	return (zfs_error(hdl, EZFS_BADSTREAM, errbuf));
	}
	}

	free(buf);
	return (-1);
	}

	static void
	recv_ecksum_set_aux(libzfs_handle_t hdl, const char target_snap,
	boolean_t resumable, boolean_t checksum)
	{
	char target_fs[ZFS_MAX_DATASET_NAME_LEN];

	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, (checksum ?
	"checksum mismatch" : "incomplete stream")));

	if (!resumable)
	return;
	(void) strlcpy(target_fs, target_snap, sizeof (target_fs));
	*strchr(target_fs, '@') = '\0';
	zfs_handle_t *zhp = zfs_open(hdl, target_fs,
	ZFS_TYPE_FILESYSTEM \| ZFS_TYPE_VOLUME);
	if (zhp == NULL)
	return;

	char token_buf[ZFS_MAXPROPLEN];
	int error = zfs_prop_get(zhp, ZFS_PROP_RECEIVE_RESUME_TOKEN,
	token_buf, sizeof (token_buf),
	NULL, NULL, 0, B_TRUE);
	if (error == 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"checksum mismatch or incomplete stream.\n"
	"Partially received snapshot is saved.\n"
	"A resuming stream can be generated on the sending "
	"system by running:\n"
	" zfs send -t %s"),
	token_buf);
	}
	zfs_close(zhp);
	}

	/*
	* Prepare a new nvlist of properties that are to override (-o) or be excluded
	* (-x) from the received dataset
	* recvprops: received properties from the send stream
	* cmdprops: raw input properties from command line
	* origprops: properties, both locally-set and received, currently set on the
	* target dataset if it exists, NULL otherwise.
	* oxprops: valid output override (-o) and excluded (-x) properties
	*/
	static int
	zfs_setup_cmdline_props(libzfs_handle_t *hdl, zfs_type_t type,
	char *fsname, boolean_t zoned, boolean_t recursive, boolean_t newfs,
	boolean_t raw, boolean_t toplevel, nvlist_t recvprops, nvlist_t cmdprops,
	nvlist_t origprops, nvlist_t oxprops, uint8_t *wkeydata_out,
	uint_t wkeylen_out, const char errbuf)
	{
	nvpair_t *nvp;
	nvlist_t oprops, voprops;
	zfs_handle_t *zhp = NULL;
	zpool_handle_t *zpool_hdl = NULL;
	char *cp;
	int ret = 0;
	char namebuf[ZFS_MAX_DATASET_NAME_LEN];

	if (nvlist_empty(cmdprops))
	return (0); /* No properties to override or exclude */

	*oxprops = fnvlist_alloc();
	oprops = fnvlist_alloc();

	strlcpy(namebuf, fsname, ZFS_MAX_DATASET_NAME_LEN);

	/*
	* Get our dataset handle. The target dataset may not exist yet.
	*/
	if (zfs_dataset_exists(hdl, namebuf, ZFS_TYPE_DATASET)) {
	zhp = zfs_open(hdl, namebuf, ZFS_TYPE_DATASET);
	if (zhp == NULL) {
	ret = -1;
	goto error;
	}
	}

	/* open the zpool handle */
	cp = strchr(namebuf, '/');
	if (cp != NULL)
	*cp = '\0';
	zpool_hdl = zpool_open(hdl, namebuf);
	if (zpool_hdl == NULL) {
	ret = -1;
	goto error;
	}

	/* restore namebuf to match fsname for later use */
	if (cp != NULL)
	*cp = '/';

	/*
	* first iteration: process excluded (-x) properties now and gather
	* added (-o) properties to be later processed by zfs_valid_proplist()
	*/
	nvp = NULL;
	while ((nvp = nvlist_next_nvpair(cmdprops, nvp)) != NULL) {
	const char *name = nvpair_name(nvp);
	zfs_prop_t prop = zfs_name_to_prop(name);

	/* "origin" is processed separately, don't handle it here */
	if (prop == ZFS_PROP_ORIGIN)
	continue;

	- /*
	- * we're trying to override or exclude a property that does not
	- * make sense for this type of dataset, but we don't want to
	- * fail if the receive is recursive: this comes in handy when
	- * the send stream contains, for instance, a child ZVOL and
	- * we're trying to receive it with "-o atime=on"
	- */
	- if (!zfs_prop_valid_for_type(prop, type, B_FALSE) &&
	- !zfs_prop_user(name)) {
	- if (recursive)
	- continue;
	- zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	- "property '%s' does not apply to datasets of this "
	- "type"), name);
	- ret = zfs_error(hdl, EZFS_BADPROP, errbuf);
	- goto error;
	- }
	-
	/* raw streams can't override encryption properties */
	if ((zfs_prop_encryption_key_param(prop) \|\|
	prop == ZFS_PROP_ENCRYPTION) && raw) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"encryption property '%s' cannot "
	"be set or excluded for raw streams."), name);
	ret = zfs_error(hdl, EZFS_BADPROP, errbuf);
	goto error;
	}

	/* incremental streams can only exclude encryption properties */
	if ((zfs_prop_encryption_key_param(prop) \|\|
	prop == ZFS_PROP_ENCRYPTION) && !newfs &&
	nvpair_type(nvp) != DATA_TYPE_BOOLEAN) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"encryption property '%s' cannot "
	"be set for incremental streams."), name);
	ret = zfs_error(hdl, EZFS_BADPROP, errbuf);
	goto error;
	}

	switch (nvpair_type(nvp)) {
	case DATA_TYPE_BOOLEAN: /* -x property */
	/*
	* DATA_TYPE_BOOLEAN is the way we're asked to "exclude"
	* a property: this is done by forcing an explicit
	* inherit on the destination so the effective value is
	* not the one we received from the send stream.
	+ */
	+ if (!zfs_prop_valid_for_type(prop, type, B_FALSE) &&
	+ !zfs_prop_user(name)) {
	+ (void) fprintf(stderr, dgettext(TEXT_DOMAIN,
	+ "Warning: %s: property '%s' does not "
	+ "apply to datasets of this type\n"),
	+ fsname, name);
	+ continue;
	+ }
	+ /*
	* We do this only if the property is not already
	* locally-set, in which case its value will take
	* priority over the received anyway.
	*/
	if (nvlist_exists(origprops, name)) {
	nvlist_t *attrs;
	char *source = NULL;

	attrs = fnvlist_lookup_nvlist(origprops, name);
	if (nvlist_lookup_string(attrs,
	ZPROP_SOURCE, &source) == 0 &&
	strcmp(source, ZPROP_SOURCE_VAL_RECVD) != 0)
	continue;
	}
	/*
	* We can't force an explicit inherit on non-inheritable
	* properties: if we're asked to exclude this kind of
	* values we remove them from "recvprops" input nvlist.
	*/
	if (!zfs_prop_inheritable(prop) &&
	!zfs_prop_user(name) && /* can be inherited too */
	nvlist_exists(recvprops, name))
	fnvlist_remove(recvprops, name);
	else
	fnvlist_add_nvpair(*oxprops, nvp);
	break;
	case DATA_TYPE_STRING: /* -o property=value */
	+ /*
	+ * we're trying to override a property that does not
	+ * make sense for this type of dataset, but we don't
	+ * want to fail if the receive is recursive: this comes
	+ * in handy when the send stream contains, for
	+ * instance, a child ZVOL and we're trying to receive
	+ * it with "-o atime=on"
	+ */
	+ if (!zfs_prop_valid_for_type(prop, type, B_FALSE) &&
	+ !zfs_prop_user(name)) {
	+ if (recursive)
	+ continue;
	+ zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	+ "property '%s' does not apply to datasets "
	+ "of this type"), name);
	+ ret = zfs_error(hdl, EZFS_BADPROP, errbuf);
	+ goto error;
	+ }
	fnvlist_add_nvpair(oprops, nvp);
	break;
	default:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"property '%s' must be a string or boolean"), name);
	ret = zfs_error(hdl, EZFS_BADPROP, errbuf);
	goto error;
	}
	}

	if (toplevel) {
	/* convert override strings properties to native */
	if ((voprops = zfs_valid_proplist(hdl, ZFS_TYPE_DATASET,
	oprops, zoned, zhp, zpool_hdl, B_FALSE, errbuf)) == NULL) {
	ret = zfs_error(hdl, EZFS_BADPROP, errbuf);
	goto error;
	}

	/*
	* zfs_crypto_create() requires the parent name. Get it
	* by truncating the fsname copy stored in namebuf.
	*/
	cp = strrchr(namebuf, '/');
	if (cp != NULL)
	*cp = '\0';

	if (!raw && zfs_crypto_create(hdl, namebuf, voprops, NULL,
	B_FALSE, wkeydata_out, wkeylen_out) != 0) {
	fnvlist_free(voprops);
	ret = zfs_error(hdl, EZFS_CRYPTOFAILED, errbuf);
	goto error;
	}

	/* second pass: process "-o" properties */
	fnvlist_merge(*oxprops, voprops);
	fnvlist_free(voprops);
	} else {
	/* override props on child dataset are inherited */
	nvp = NULL;
	while ((nvp = nvlist_next_nvpair(oprops, nvp)) != NULL) {
	const char *name = nvpair_name(nvp);
	fnvlist_add_boolean(*oxprops, name);
	}
	}

	error:
	if (zhp != NULL)
	zfs_close(zhp);
	if (zpool_hdl != NULL)
	zpool_close(zpool_hdl);
	fnvlist_free(oprops);
	return (ret);
	}

	/*
	* Restores a backup of tosnap from the file descriptor specified by infd.
	*/
	static int
	zfs_receive_one(libzfs_handle_t hdl, int infd, const char tosnap,
	const char originsnap, recvflags_t flags, dmu_replay_record_t *drr,
	dmu_replay_record_t drr_noswap, const char sendfs, nvlist_t *stream_nv,
	avl_tree_t stream_avl, char *top_zfs,
	const char finalsnap, nvlist_t cmdprops)
	{
	time_t begin_time;
	int ioctl_err, ioctl_errno, err;
	char *cp;
	struct drr_begin *drrb = &drr->drr_u.drr_begin;
	char errbuf[1024];
	const char *chopprefix;
	boolean_t newfs = B_FALSE;
	boolean_t stream_wantsnewfs, stream_resumingnewfs;
	boolean_t newprops = B_FALSE;
	uint64_t read_bytes = 0;
	uint64_t errflags = 0;
	uint64_t parent_snapguid = 0;
	prop_changelist_t *clp = NULL;
	nvlist_t *snapprops_nvlist = NULL;
	nvlist_t *snapholds_nvlist = NULL;
	zprop_errflags_t prop_errflags;
	nvlist_t *prop_errors = NULL;
	boolean_t recursive;
	char *snapname = NULL;
	char destsnap[MAXPATHLEN * 2];
	char origin[MAXNAMELEN];
	char name[MAXPATHLEN];
	char tmp_keylocation[MAXNAMELEN];
	nvlist_t rcvprops = NULL; / props received from the send stream */
	nvlist_t oxprops = NULL; / override (-o) and exclude (-x) props */
	nvlist_t origprops = NULL; / original props (if destination exists) */
	zfs_type_t type;
	boolean_t toplevel = B_FALSE;
	boolean_t zoned = B_FALSE;
	boolean_t hastoken = B_FALSE;
	boolean_t redacted;
	uint8_t *wkeydata = NULL;
	uint_t wkeylen = 0;

	begin_time = time(NULL);
	bzero(origin, MAXNAMELEN);
	bzero(tmp_keylocation, MAXNAMELEN);

	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
	"cannot receive"));

	recursive = (nvlist_lookup_boolean(stream_nv, "not_recursive") ==
	ENOENT);

	/* Did the user request holds be skipped via zfs recv -k? */
	boolean_t holds = flags->holds && !flags->skipholds;

	if (stream_avl != NULL) {
	char *keylocation = NULL;
	nvlist_t *lookup = NULL;
	nvlist_t *fs = fsavl_find(stream_avl, drrb->drr_toguid,
	&snapname);

	(void) nvlist_lookup_uint64(fs, "parentfromsnap",
	&parent_snapguid);
	err = nvlist_lookup_nvlist(fs, "props", &rcvprops);
	if (err) {
	rcvprops = fnvlist_alloc();
	newprops = B_TRUE;
	}

	/*
	* The keylocation property may only be set on encryption roots,
	* but this dataset might not become an encryption root until
	* recv_fix_encryption_hierarchy() is called. That function
	* will fixup the keylocation anyway, so we temporarily unset
	* the keylocation for now to avoid any errors from the receive
	* ioctl.
	*/
	err = nvlist_lookup_string(rcvprops,
	zfs_prop_to_name(ZFS_PROP_KEYLOCATION), &keylocation);
	if (err == 0) {
	strcpy(tmp_keylocation, keylocation);
	(void) nvlist_remove_all(rcvprops,
	zfs_prop_to_name(ZFS_PROP_KEYLOCATION));
	}

	if (flags->canmountoff) {
	fnvlist_add_uint64(rcvprops,
	zfs_prop_to_name(ZFS_PROP_CANMOUNT), 0);
	} else if (newprops) { /* nothing in rcvprops, eliminate it */
	fnvlist_free(rcvprops);
	rcvprops = NULL;
	newprops = B_FALSE;
	}
	if (0 == nvlist_lookup_nvlist(fs, "snapprops", &lookup)) {
	snapprops_nvlist = fnvlist_lookup_nvlist(lookup,
	snapname);
	}
	if (holds) {
	if (0 == nvlist_lookup_nvlist(fs, "snapholds",
	&lookup)) {
	snapholds_nvlist = fnvlist_lookup_nvlist(
	lookup, snapname);
	}
	}
	}

	cp = NULL;

	/*
	* Determine how much of the snapshot name stored in the stream
	* we are going to tack on to the name they specified on the
	* command line, and how much we are going to chop off.
	*
	* If they specified a snapshot, chop the entire name stored in
	* the stream.
	*/
	if (flags->istail) {
	/*
	* A filesystem was specified with -e. We want to tack on only
	* the tail of the sent snapshot path.
	*/
	if (strchr(tosnap, '@')) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "invalid "
	"argument - snapshot not allowed with -e"));
	err = zfs_error(hdl, EZFS_INVALIDNAME, errbuf);
	goto out;
	}

	chopprefix = strrchr(sendfs, '/');

	if (chopprefix == NULL) {
	/*
	* The tail is the poolname, so we need to
	* prepend a path separator.
	*/
	int len = strlen(drrb->drr_toname);
	cp = malloc(len + 2);
	cp[0] = '/';
	(void) strcpy(&cp[1], drrb->drr_toname);
	chopprefix = cp;
	} else {
	chopprefix = drrb->drr_toname + (chopprefix - sendfs);
	}
	} else if (flags->isprefix) {
	/*
	* A filesystem was specified with -d. We want to tack on
	* everything but the first element of the sent snapshot path
	* (all but the pool name).
	*/
	if (strchr(tosnap, '@')) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "invalid "
	"argument - snapshot not allowed with -d"));
	err = zfs_error(hdl, EZFS_INVALIDNAME, errbuf);
	goto out;
	}

	chopprefix = strchr(drrb->drr_toname, '/');
	if (chopprefix == NULL)
	chopprefix = strchr(drrb->drr_toname, '@');
	} else if (strchr(tosnap, '@') == NULL) {
	/*
	* If a filesystem was specified without -d or -e, we want to
	* tack on everything after the fs specified by 'zfs send'.
	*/
	chopprefix = drrb->drr_toname + strlen(sendfs);
	} else {
	/* A snapshot was specified as an exact path (no -d or -e). */
	if (recursive) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"cannot specify snapshot name for multi-snapshot "
	"stream"));
	err = zfs_error(hdl, EZFS_BADSTREAM, errbuf);
	goto out;
	}
	chopprefix = drrb->drr_toname + strlen(drrb->drr_toname);
	}

	ASSERT(strstr(drrb->drr_toname, sendfs) == drrb->drr_toname);
	ASSERT(chopprefix > drrb->drr_toname \|\| strchr(sendfs, '/') == NULL);
	ASSERT(chopprefix <= drrb->drr_toname + strlen(drrb->drr_toname) \|\|
	strchr(sendfs, '/') == NULL);
	ASSERT(chopprefix[0] == '/' \|\| chopprefix[0] == '@' \|\|
	chopprefix[0] == '\0');

	/*
	* Determine name of destination snapshot.
	*/
	(void) strlcpy(destsnap, tosnap, sizeof (destsnap));
	(void) strlcat(destsnap, chopprefix, sizeof (destsnap));
	free(cp);
	if (!zfs_name_valid(destsnap, ZFS_TYPE_SNAPSHOT)) {
	err = zfs_error(hdl, EZFS_INVALIDNAME, errbuf);
	goto out;
	}

	/*
	* Determine the name of the origin snapshot.
	*/
	if (originsnap) {
	(void) strlcpy(origin, originsnap, sizeof (origin));
	if (flags->verbose)
	(void) printf("using provided clone origin %s\n",
	origin);
	} else if (drrb->drr_flags & DRR_FLAG_CLONE) {
	if (guid_to_name(hdl, destsnap,
	drrb->drr_fromguid, B_FALSE, origin) != 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"local origin for clone %s does not exist"),
	destsnap);
	err = zfs_error(hdl, EZFS_NOENT, errbuf);
	goto out;
	}
	if (flags->verbose)
	(void) printf("found clone origin %s\n", origin);
	}

	if ((DMU_GET_FEATUREFLAGS(drrb->drr_versioninfo) &
	DMU_BACKUP_FEATURE_DEDUP)) {
	(void) fprintf(stderr,
	gettext("ERROR: \"zfs receive\" no longer supports "
	"deduplicated send streams. Use\n"
	"the \"zstream redup\" command to convert this stream "
	"to a regular,\n"
	"non-deduplicated stream.\n"));
	err = zfs_error(hdl, EZFS_NOTSUP, errbuf);
	goto out;
	}

	boolean_t resuming = DMU_GET_FEATUREFLAGS(drrb->drr_versioninfo) &
	DMU_BACKUP_FEATURE_RESUMING;
	boolean_t raw = DMU_GET_FEATUREFLAGS(drrb->drr_versioninfo) &
	DMU_BACKUP_FEATURE_RAW;
	boolean_t embedded = DMU_GET_FEATUREFLAGS(drrb->drr_versioninfo) &
	DMU_BACKUP_FEATURE_EMBED_DATA;
	stream_wantsnewfs = (drrb->drr_fromguid == 0 \|\|
	(drrb->drr_flags & DRR_FLAG_CLONE) \|\| originsnap) && !resuming;
	stream_resumingnewfs = (drrb->drr_fromguid == 0 \|\|
	(drrb->drr_flags & DRR_FLAG_CLONE) \|\| originsnap) && resuming;

	if (stream_wantsnewfs) {
	/*
	* if the parent fs does not exist, look for it based on
	* the parent snap GUID
	*/
	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
	"cannot receive new filesystem stream"));

	(void) strcpy(name, destsnap);
	cp = strrchr(name, '/');
	if (cp)
	*cp = '\0';
	if (cp &&
	!zfs_dataset_exists(hdl, name, ZFS_TYPE_DATASET)) {
	char suffix[ZFS_MAX_DATASET_NAME_LEN];
	(void) strcpy(suffix, strrchr(destsnap, '/'));
	if (guid_to_name(hdl, name, parent_snapguid,
	B_FALSE, destsnap) == 0) {
	*strchr(destsnap, '@') = '\0';
	(void) strcat(destsnap, suffix);
	}
	}
	} else {
	/*
	* If the fs does not exist, look for it based on the
	* fromsnap GUID.
	*/
	if (resuming) {
	(void) snprintf(errbuf, sizeof (errbuf),
	dgettext(TEXT_DOMAIN,
	"cannot receive resume stream"));
	} else {
	(void) snprintf(errbuf, sizeof (errbuf),
	dgettext(TEXT_DOMAIN,
	"cannot receive incremental stream"));
	}

	(void) strcpy(name, destsnap);
	*strchr(name, '@') = '\0';

	/*
	* If the exact receive path was specified and this is the
	* topmost path in the stream, then if the fs does not exist we
	* should look no further.
	*/
	if ((flags->isprefix \|\| (*(chopprefix = drrb->drr_toname +
	strlen(sendfs)) != '\0' && *chopprefix != '@')) &&
	!zfs_dataset_exists(hdl, name, ZFS_TYPE_DATASET)) {
	char snap[ZFS_MAX_DATASET_NAME_LEN];
	(void) strcpy(snap, strchr(destsnap, '@'));
	if (guid_to_name(hdl, name, drrb->drr_fromguid,
	B_FALSE, destsnap) == 0) {
	*strchr(destsnap, '@') = '\0';
	(void) strcat(destsnap, snap);
	}
	}
	}

	(void) strcpy(name, destsnap);
	*strchr(name, '@') = '\0';

	redacted = DMU_GET_FEATUREFLAGS(drrb->drr_versioninfo) &
	DMU_BACKUP_FEATURE_REDACTED;

	if (zfs_dataset_exists(hdl, name, ZFS_TYPE_DATASET)) {
	zfs_cmd_t zc = {"\0"};
	zfs_handle_t *zhp;
	boolean_t encrypted;

	(void) strcpy(zc.zc_name, name);

	/*
	* Destination fs exists. It must be one of these cases:
	* - an incremental send stream
	* - the stream specifies a new fs (full stream or clone)
	* and they want us to blow away the existing fs (and
	* have therefore specified -F and removed any snapshots)
	* - we are resuming a failed receive.
	*/
	if (stream_wantsnewfs) {
	boolean_t is_volume = drrb->drr_type == DMU_OST_ZVOL;
	if (!flags->force) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"destination '%s' exists\n"
	"must specify -F to overwrite it"), name);
	err = zfs_error(hdl, EZFS_EXISTS, errbuf);
	goto out;
	}
	if (zfs_ioctl(hdl, ZFS_IOC_SNAPSHOT_LIST_NEXT,
	&zc) == 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"destination has snapshots (eg. %s)\n"
	"must destroy them to overwrite it"),
	zc.zc_name);
	err = zfs_error(hdl, EZFS_EXISTS, errbuf);
	goto out;
	}
	if (is_volume && strrchr(name, '/') == NULL) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"destination %s is the root dataset\n"
	"cannot overwrite with a ZVOL"),
	name);
	err = zfs_error(hdl, EZFS_EXISTS, errbuf);
	goto out;
	}
	if (is_volume &&
	zfs_ioctl(hdl, ZFS_IOC_DATASET_LIST_NEXT,
	&zc) == 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"destination has children (eg. %s)\n"
	"cannot overwrite with a ZVOL"),
	zc.zc_name);
	err = zfs_error(hdl, EZFS_WRONG_PARENT, errbuf);
	goto out;
	}
	}

	if ((zhp = zfs_open(hdl, name,
	ZFS_TYPE_FILESYSTEM \| ZFS_TYPE_VOLUME)) == NULL) {
	err = -1;
	goto out;
	}

	if (stream_wantsnewfs &&
	zhp->zfs_dmustats.dds_origin[0]) {
	zfs_close(zhp);
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"destination '%s' is a clone\n"
	"must destroy it to overwrite it"), name);
	err = zfs_error(hdl, EZFS_EXISTS, errbuf);
	goto out;
	}

	/*
	* Raw sends can not be performed as an incremental on top
	* of existing unencrypted datasets. zfs recv -F can't be
	* used to blow away an existing encrypted filesystem. This
	* is because it would require the dsl dir to point to the
	* new key (or lack of a key) and the old key at the same
	* time. The -F flag may still be used for deleting
	* intermediate snapshots that would otherwise prevent the
	* receive from working.
	*/
	encrypted = zfs_prop_get_int(zhp, ZFS_PROP_ENCRYPTION) !=
	ZIO_CRYPT_OFF;
	if (!stream_wantsnewfs && !encrypted && raw) {
	zfs_close(zhp);
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"cannot perform raw receive on top of "
	"existing unencrypted dataset"));
	err = zfs_error(hdl, EZFS_BADRESTORE, errbuf);
	goto out;
	}

	if (stream_wantsnewfs && flags->force &&
	((raw && !encrypted) \|\| encrypted)) {
	zfs_close(zhp);
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"zfs receive -F cannot be used to destroy an "
	"encrypted filesystem or overwrite an "
	"unencrypted one with an encrypted one"));
	err = zfs_error(hdl, EZFS_BADRESTORE, errbuf);
	goto out;
	}

	if (!flags->dryrun && zhp->zfs_type == ZFS_TYPE_FILESYSTEM &&
	(stream_wantsnewfs \|\| stream_resumingnewfs)) {
	/* We can't do online recv in this case */
	clp = changelist_gather(zhp, ZFS_PROP_NAME, 0,
	flags->forceunmount ? MS_FORCE : 0);
	if (clp == NULL) {
	zfs_close(zhp);
	err = -1;
	goto out;
	}
	if (changelist_prefix(clp) != 0) {
	changelist_free(clp);
	zfs_close(zhp);
	err = -1;
	goto out;
	}
	}

	/*
	* If we are resuming a newfs, set newfs here so that we will
	* mount it if the recv succeeds this time. We can tell
	* that it was a newfs on the first recv because the fs
	* itself will be inconsistent (if the fs existed when we
	* did the first recv, we would have received it into
	* .../%recv).
	*/
	if (resuming && zfs_prop_get_int(zhp, ZFS_PROP_INCONSISTENT))
	newfs = B_TRUE;

	/* we want to know if we're zoned when validating -o\|-x props */
	zoned = zfs_prop_get_int(zhp, ZFS_PROP_ZONED);

	/* may need this info later, get it now we have zhp around */
	if (zfs_prop_get(zhp, ZFS_PROP_RECEIVE_RESUME_TOKEN, NULL, 0,
	NULL, NULL, 0, B_TRUE) == 0)
	hastoken = B_TRUE;

	/* gather existing properties on destination */
	origprops = fnvlist_alloc();
	fnvlist_merge(origprops, zhp->zfs_props);
	fnvlist_merge(origprops, zhp->zfs_user_props);

	zfs_close(zhp);
	} else {
	zfs_handle_t *zhp;

	/*
	* Destination filesystem does not exist. Therefore we better
	* be creating a new filesystem (either from a full backup, or
	* a clone). It would therefore be invalid if the user
	* specified only the pool name (i.e. if the destination name
	* contained no slash character).
	*/
	cp = strrchr(name, '/');

	if (!stream_wantsnewfs \|\| cp == NULL) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"destination '%s' does not exist"), name);
	err = zfs_error(hdl, EZFS_NOENT, errbuf);
	goto out;
	}

	/*
	* Trim off the final dataset component so we perform the
	* recvbackup ioctl to the filesystems's parent.
	*/
	*cp = '\0';

	if (flags->isprefix && !flags->istail && !flags->dryrun &&
	create_parents(hdl, destsnap, strlen(tosnap)) != 0) {
	err = zfs_error(hdl, EZFS_BADRESTORE, errbuf);
	goto out;
	}

	/* validate parent */
	zhp = zfs_open(hdl, name, ZFS_TYPE_DATASET);
	if (zhp == NULL) {
	err = zfs_error(hdl, EZFS_BADRESTORE, errbuf);
	goto out;
	}
	if (zfs_get_type(zhp) != ZFS_TYPE_FILESYSTEM) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"parent '%s' is not a filesystem"), name);
	err = zfs_error(hdl, EZFS_WRONG_PARENT, errbuf);
	zfs_close(zhp);
	goto out;
	}

	zfs_close(zhp);

	newfs = B_TRUE;
	*cp = '/';
	}

	if (flags->verbose) {
	(void) printf("%s %s stream of %s into %s\n",
	flags->dryrun ? "would receive" : "receiving",
	drrb->drr_fromguid ? "incremental" : "full",
	drrb->drr_toname, destsnap);
	(void) fflush(stdout);
	}

	- if (flags->dryrun) {
	- void *buf = zfs_alloc(hdl, SPA_MAXBLOCKSIZE);
	-
	- /*
	- * We have read the DRR_BEGIN record, but we have
	- * not yet read the payload. For non-dryrun sends
	- * this will be done by the kernel, so we must
	- * emulate that here, before attempting to read
	- * more records.
	- */
	- err = recv_read(hdl, infd, buf, drr->drr_payloadlen,
	- flags->byteswap, NULL);
	- free(buf);
	- if (err != 0)
	- goto out;
	-
	- err = recv_skip(hdl, infd, flags->byteswap);
	- goto out;
	- }
	-
	/*
	* If this is the top-level dataset, record it so we can use it
	* for recursive operations later.
	*/
	if (top_zfs != NULL &&
	(top_zfs == NULL \|\| strcmp(top_zfs, name) == 0)) {
	toplevel = B_TRUE;
	if (*top_zfs == NULL)
	*top_zfs = zfs_strdup(hdl, name);
	}

	if (drrb->drr_type == DMU_OST_ZVOL) {
	type = ZFS_TYPE_VOLUME;
	} else if (drrb->drr_type == DMU_OST_ZFS) {
	type = ZFS_TYPE_FILESYSTEM;
	} else {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"invalid record type: 0x%d"), drrb->drr_type);
	err = zfs_error(hdl, EZFS_BADSTREAM, errbuf);
	goto out;
	}
	if ((err = zfs_setup_cmdline_props(hdl, type, name, zoned, recursive,
	stream_wantsnewfs, raw, toplevel, rcvprops, cmdprops, origprops,
	&oxprops, &wkeydata, &wkeylen, errbuf)) != 0)
	goto out;

	/*
	* When sending with properties (zfs send -p), the encryption property
	* is not included because it is a SETONCE property and therefore
	* treated as read only. However, we are always able to determine its
	* value because raw sends will include it in the DRR_BDEGIN payload
	* and non-raw sends with properties are not allowed for encrypted
	* datasets. Therefore, if this is a non-raw properties stream, we can
	* infer that the value should be ZIO_CRYPT_OFF and manually add that
	* to the received properties.
	*/
	if (stream_wantsnewfs && !raw && rcvprops != NULL &&
	!nvlist_exists(cmdprops, zfs_prop_to_name(ZFS_PROP_ENCRYPTION))) {
	if (oxprops == NULL)
	oxprops = fnvlist_alloc();
	fnvlist_add_uint64(oxprops,
	zfs_prop_to_name(ZFS_PROP_ENCRYPTION), ZIO_CRYPT_OFF);
	}

	+ if (flags->dryrun) {
	+ void *buf = zfs_alloc(hdl, SPA_MAXBLOCKSIZE);
	+
	+ /*
	+ * We have read the DRR_BEGIN record, but we have
	+ * not yet read the payload. For non-dryrun sends
	+ * this will be done by the kernel, so we must
	+ * emulate that here, before attempting to read
	+ * more records.
	+ */
	+ err = recv_read(hdl, infd, buf, drr->drr_payloadlen,
	+ flags->byteswap, NULL);
	+ free(buf);
	+ if (err != 0)
	+ goto out;
	+
	+ err = recv_skip(hdl, infd, flags->byteswap);
	+ goto out;
	+ }
	+
	err = ioctl_err = lzc_receive_with_cmdprops(destsnap, rcvprops,
	oxprops, wkeydata, wkeylen, origin, flags->force, flags->resumable,
	raw, infd, drr_noswap, -1, &read_bytes, &errflags,
	NULL, &prop_errors);
	ioctl_errno = ioctl_err;
	prop_errflags = errflags;

	if (err == 0) {
	nvpair_t *prop_err = NULL;

	while ((prop_err = nvlist_next_nvpair(prop_errors,
	prop_err)) != NULL) {
	char tbuf[1024];
	zfs_prop_t prop;
	int intval;

	prop = zfs_name_to_prop(nvpair_name(prop_err));
	(void) nvpair_value_int32(prop_err, &intval);
	if (strcmp(nvpair_name(prop_err),
	ZPROP_N_MORE_ERRORS) == 0) {
	trunc_prop_errs(intval);
	break;
	} else if (snapname == NULL \|\| finalsnap == NULL \|\|
	strcmp(finalsnap, snapname) == 0 \|\|
	strcmp(nvpair_name(prop_err),
	zfs_prop_to_name(ZFS_PROP_REFQUOTA)) != 0) {
	/*
	* Skip the special case of, for example,
	* "refquota", errors on intermediate
	* snapshots leading up to a final one.
	* That's why we have all of the checks above.
	*
	* See zfs_ioctl.c's extract_delay_props() for
	* a list of props which can fail on
	* intermediate snapshots, but shouldn't
	* affect the overall receive.
	*/
	(void) snprintf(tbuf, sizeof (tbuf),
	dgettext(TEXT_DOMAIN,
	"cannot receive %s property on %s"),
	nvpair_name(prop_err), name);
	zfs_setprop_error(hdl, prop, intval, tbuf);
	}
	}
	}

	if (err == 0 && snapprops_nvlist) {
	zfs_cmd_t zc = {"\0"};

	(void) strcpy(zc.zc_name, destsnap);
	zc.zc_cookie = B_TRUE; /* received */
	if (zcmd_write_src_nvlist(hdl, &zc, snapprops_nvlist) == 0) {
	(void) zfs_ioctl(hdl, ZFS_IOC_SET_PROP, &zc);
	zcmd_free_nvlists(&zc);
	}
	}
	if (err == 0 && snapholds_nvlist) {
	nvpair_t *pair;
	nvlist_t holds, errors = NULL;
	int cleanup_fd = -1;

	VERIFY(0 == nvlist_alloc(&holds, 0, KM_SLEEP));
	for (pair = nvlist_next_nvpair(snapholds_nvlist, NULL);
	pair != NULL;
	pair = nvlist_next_nvpair(snapholds_nvlist, pair)) {
	fnvlist_add_string(holds, destsnap, nvpair_name(pair));
	}
	(void) lzc_hold(holds, cleanup_fd, &errors);
	fnvlist_free(snapholds_nvlist);
	fnvlist_free(holds);
	}

	if (err && (ioctl_errno == ENOENT \|\| ioctl_errno == EEXIST)) {
	/*
	* It may be that this snapshot already exists,
	* in which case we want to consume & ignore it
	* rather than failing.
	*/
	avl_tree_t *local_avl;
	nvlist_t local_nv, fs;
	cp = strchr(destsnap, '@');

	/*
	* XXX Do this faster by just iterating over snaps in
	* this fs. Also if zc_value does not exist, we will
	* get a strange "does not exist" error message.
	*/
	*cp = '\0';
	if (gather_nvlist(hdl, destsnap, NULL, NULL, B_FALSE, B_TRUE,
	- B_FALSE, B_FALSE, B_FALSE, B_FALSE, B_FALSE, B_TRUE,
	- &local_nv, &local_avl) == 0) {
	+ B_FALSE, B_FALSE, B_FALSE, B_FALSE, B_FALSE, B_FALSE,
	+ B_TRUE, &local_nv, &local_avl) == 0) {
	*cp = '@';
	fs = fsavl_find(local_avl, drrb->drr_toguid, NULL);
	fsavl_destroy(local_avl);
	fnvlist_free(local_nv);

	if (fs != NULL) {
	if (flags->verbose) {
	(void) printf("snap %s already exists; "
	"ignoring\n", destsnap);
	}
	err = ioctl_err = recv_skip(hdl, infd,
	flags->byteswap);
	}
	}
	*cp = '@';
	}

	if (ioctl_err != 0) {
	switch (ioctl_errno) {
	case ENODEV:
	cp = strchr(destsnap, '@');
	*cp = '\0';
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"most recent snapshot of %s does not\n"
	"match incremental source"), destsnap);
	(void) zfs_error(hdl, EZFS_BADRESTORE, errbuf);
	*cp = '@';
	break;
	case ETXTBSY:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"destination %s has been modified\n"
	"since most recent snapshot"), name);
	(void) zfs_error(hdl, EZFS_BADRESTORE, errbuf);
	break;
	case EACCES:
	if (raw && stream_wantsnewfs) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"failed to create encryption key"));
	} else if (raw && !stream_wantsnewfs) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"encryption key does not match "
	"existing key"));
	} else {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"inherited key must be loaded"));
	}
	(void) zfs_error(hdl, EZFS_CRYPTOFAILED, errbuf);
	break;
	case EEXIST:
	cp = strchr(destsnap, '@');
	if (newfs) {
	/* it's the containing fs that exists */
	*cp = '\0';
	}
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"destination already exists"));
	(void) zfs_error_fmt(hdl, EZFS_EXISTS,
	dgettext(TEXT_DOMAIN, "cannot restore to %s"),
	destsnap);
	*cp = '@';
	break;
	case EINVAL:
	if (flags->resumable) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"kernel modules must be upgraded to "
	"receive this stream."));
	} else if (embedded && !raw) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"incompatible embedded data stream "
	"feature with encrypted receive."));
	}
	(void) zfs_error(hdl, EZFS_BADSTREAM, errbuf);
	break;
	case ECKSUM:
	case ZFS_ERR_STREAM_TRUNCATED:
	recv_ecksum_set_aux(hdl, destsnap, flags->resumable,
	ioctl_err == ECKSUM);
	(void) zfs_error(hdl, EZFS_BADSTREAM, errbuf);
	break;
	case ZFS_ERR_STREAM_LARGE_BLOCK_MISMATCH:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"incremental send stream requires -L "
	"(--large-block), to match previous receive."));
	(void) zfs_error(hdl, EZFS_BADSTREAM, errbuf);
	break;
	case ENOTSUP:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"pool must be upgraded to receive this stream."));
	(void) zfs_error(hdl, EZFS_BADVERSION, errbuf);
	break;
	case EDQUOT:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"destination %s space quota exceeded."), name);
	(void) zfs_error(hdl, EZFS_NOSPC, errbuf);
	break;
	case ZFS_ERR_FROM_IVSET_GUID_MISSING:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"IV set guid missing. See errata %u at "
	"https://openzfs.github.io/openzfs-docs/msg/"
	"ZFS-8000-ER."),
	ZPOOL_ERRATA_ZOL_8308_ENCRYPTION);
	(void) zfs_error(hdl, EZFS_BADSTREAM, errbuf);
	break;
	case ZFS_ERR_FROM_IVSET_GUID_MISMATCH:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"IV set guid mismatch. See the 'zfs receive' "
	"man page section\n discussing the limitations "
	"of raw encrypted send streams."));
	(void) zfs_error(hdl, EZFS_BADSTREAM, errbuf);
	break;
	case ZFS_ERR_SPILL_BLOCK_FLAG_MISSING:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"Spill block flag missing for raw send.\n"
	"The zfs software on the sending system must "
	"be updated."));
	(void) zfs_error(hdl, EZFS_BADSTREAM, errbuf);
	break;
	case EBUSY:
	if (hastoken) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"destination %s contains "
	"partially-complete state from "
	"\"zfs receive -s\"."), name);
	(void) zfs_error(hdl, EZFS_BUSY, errbuf);
	break;
	}
	/* fallthru */
	default:
	(void) zfs_standard_error(hdl, ioctl_errno, errbuf);
	}
	}

	/*
	* Mount the target filesystem (if created). Also mount any
	* children of the target filesystem if we did a replication
	* receive (indicated by stream_avl being non-NULL).
	*/
	if (clp) {
	if (!flags->nomount)
	err \|= changelist_postfix(clp);
	changelist_free(clp);
	}

	if ((newfs \|\| stream_avl) && type == ZFS_TYPE_FILESYSTEM && !redacted)
	flags->domount = B_TRUE;

	if (prop_errflags & ZPROP_ERR_NOCLEAR) {
	(void) fprintf(stderr, dgettext(TEXT_DOMAIN, "Warning: "
	"failed to clear unreceived properties on %s"), name);
	(void) fprintf(stderr, "\n");
	}
	if (prop_errflags & ZPROP_ERR_NORESTORE) {
	(void) fprintf(stderr, dgettext(TEXT_DOMAIN, "Warning: "
	"failed to restore original properties on %s"), name);
	(void) fprintf(stderr, "\n");
	}

	if (err \|\| ioctl_err) {
	err = -1;
	goto out;
	}

	if (flags->verbose) {
	char buf1[64];
	char buf2[64];
	uint64_t bytes = read_bytes;
	time_t delta = time(NULL) - begin_time;
	if (delta == 0)
	delta = 1;
	zfs_nicebytes(bytes, buf1, sizeof (buf1));
	zfs_nicebytes(bytes/delta, buf2, sizeof (buf1));

	(void) printf("received %s stream in %lld seconds (%s/sec)\n",
	buf1, (longlong_t)delta, buf2);
	}

	err = 0;
	out:
	if (prop_errors != NULL)
	fnvlist_free(prop_errors);

	if (tmp_keylocation[0] != '\0') {
	fnvlist_add_string(rcvprops,
	zfs_prop_to_name(ZFS_PROP_KEYLOCATION), tmp_keylocation);
	}

	if (newprops)
	fnvlist_free(rcvprops);

	fnvlist_free(oxprops);
	fnvlist_free(origprops);

	return (err);
	}

	/*
	* Check properties we were asked to override (both -o\|-x)
	*/
	static boolean_t
	zfs_receive_checkprops(libzfs_handle_t hdl, nvlist_t props,
	const char *errbuf)
	{
	nvpair_t *nvp;
	zfs_prop_t prop;
	const char *name;

	nvp = NULL;
	while ((nvp = nvlist_next_nvpair(props, nvp)) != NULL) {
	name = nvpair_name(nvp);
	prop = zfs_name_to_prop(name);

	if (prop == ZPROP_INVAL) {
	if (!zfs_prop_user(name)) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"invalid property '%s'"), name);
	return (B_FALSE);
	}
	continue;
	}
	/*
	* "origin" is readonly but is used to receive datasets as
	* clones so we don't raise an error here
	*/
	if (prop == ZFS_PROP_ORIGIN)
	continue;

	/* encryption params have their own verification later */
	if (prop == ZFS_PROP_ENCRYPTION \|\|
	zfs_prop_encryption_key_param(prop))
	continue;

	/*
	* cannot override readonly, set-once and other specific
	* settable properties
	*/
	if (zfs_prop_readonly(prop) \|\| prop == ZFS_PROP_VERSION \|\|
	prop == ZFS_PROP_VOLSIZE) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"invalid property '%s'"), name);
	return (B_FALSE);
	}
	}

	return (B_TRUE);
	}

	static int
	zfs_receive_impl(libzfs_handle_t hdl, const char tosnap,
	const char originsnap, recvflags_t flags, int infd, const char *sendfs,
	nvlist_t stream_nv, avl_tree_t stream_avl, char **top_zfs,
	const char finalsnap, nvlist_t cmdprops)
	{
	int err;
	dmu_replay_record_t drr, drr_noswap;
	struct drr_begin *drrb = &drr.drr_u.drr_begin;
	char errbuf[1024];
	zio_cksum_t zcksum = { { 0 } };
	uint64_t featureflags;
	int hdrtype;

	(void) snprintf(errbuf, sizeof (errbuf), dgettext(TEXT_DOMAIN,
	"cannot receive"));

	/* check cmdline props, raise an error if they cannot be received */
	if (!zfs_receive_checkprops(hdl, cmdprops, errbuf)) {
	return (zfs_error(hdl, EZFS_BADPROP, errbuf));
	}

	if (flags->isprefix &&
	!zfs_dataset_exists(hdl, tosnap, ZFS_TYPE_DATASET)) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "specified fs "
	"(%s) does not exist"), tosnap);
	return (zfs_error(hdl, EZFS_NOENT, errbuf));
	}
	if (originsnap &&
	!zfs_dataset_exists(hdl, originsnap, ZFS_TYPE_DATASET)) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "specified origin fs "
	"(%s) does not exist"), originsnap);
	return (zfs_error(hdl, EZFS_NOENT, errbuf));
	}

	/* read in the BEGIN record */
	if (0 != (err = recv_read(hdl, infd, &drr, sizeof (drr), B_FALSE,
	&zcksum)))
	return (err);

	if (drr.drr_type == DRR_END \|\| drr.drr_type == BSWAP_32(DRR_END)) {
	/* It's the double end record at the end of a package */
	return (ENODATA);
	}

	/* the kernel needs the non-byteswapped begin record */
	drr_noswap = drr;

	flags->byteswap = B_FALSE;
	if (drrb->drr_magic == BSWAP_64(DMU_BACKUP_MAGIC)) {
	/*
	* We computed the checksum in the wrong byteorder in
	* recv_read() above; do it again correctly.
	*/
	bzero(&zcksum, sizeof (zio_cksum_t));
	fletcher_4_incremental_byteswap(&drr, sizeof (drr), &zcksum);
	flags->byteswap = B_TRUE;

	drr.drr_type = BSWAP_32(drr.drr_type);
	drr.drr_payloadlen = BSWAP_32(drr.drr_payloadlen);
	drrb->drr_magic = BSWAP_64(drrb->drr_magic);
	drrb->drr_versioninfo = BSWAP_64(drrb->drr_versioninfo);
	drrb->drr_creation_time = BSWAP_64(drrb->drr_creation_time);
	drrb->drr_type = BSWAP_32(drrb->drr_type);
	drrb->drr_flags = BSWAP_32(drrb->drr_flags);
	drrb->drr_toguid = BSWAP_64(drrb->drr_toguid);
	drrb->drr_fromguid = BSWAP_64(drrb->drr_fromguid);
	}

	if (drrb->drr_magic != DMU_BACKUP_MAGIC \|\| drr.drr_type != DRR_BEGIN) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "invalid "
	"stream (bad magic number)"));
	return (zfs_error(hdl, EZFS_BADSTREAM, errbuf));
	}

	featureflags = DMU_GET_FEATUREFLAGS(drrb->drr_versioninfo);
	hdrtype = DMU_GET_STREAM_HDRTYPE(drrb->drr_versioninfo);

	if (!DMU_STREAM_SUPPORTED(featureflags) \|\|
	(hdrtype != DMU_SUBSTREAM && hdrtype != DMU_COMPOUNDSTREAM)) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"stream has unsupported feature, feature flags = %lx"),
	featureflags);
	return (zfs_error(hdl, EZFS_BADSTREAM, errbuf));
	}

	/* Holds feature is set once in the compound stream header. */
	if (featureflags & DMU_BACKUP_FEATURE_HOLDS)
	flags->holds = B_TRUE;

	if (strchr(drrb->drr_toname, '@') == NULL) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "invalid "
	"stream (bad snapshot name)"));
	return (zfs_error(hdl, EZFS_BADSTREAM, errbuf));
	}

	if (DMU_GET_STREAM_HDRTYPE(drrb->drr_versioninfo) == DMU_SUBSTREAM) {
	char nonpackage_sendfs[ZFS_MAX_DATASET_NAME_LEN];
	if (sendfs == NULL) {
	/*
	* We were not called from zfs_receive_package(). Get
	* the fs specified by 'zfs send'.
	*/
	char *cp;
	(void) strlcpy(nonpackage_sendfs,
	drr.drr_u.drr_begin.drr_toname,
	sizeof (nonpackage_sendfs));
	if ((cp = strchr(nonpackage_sendfs, '@')) != NULL)
	*cp = '\0';
	sendfs = nonpackage_sendfs;
	VERIFY(finalsnap == NULL);
	}
	return (zfs_receive_one(hdl, infd, tosnap, originsnap, flags,
	&drr, &drr_noswap, sendfs, stream_nv, stream_avl, top_zfs,
	finalsnap, cmdprops));
	} else {
	assert(DMU_GET_STREAM_HDRTYPE(drrb->drr_versioninfo) ==
	DMU_COMPOUNDSTREAM);
	return (zfs_receive_package(hdl, infd, tosnap, flags, &drr,
	&zcksum, top_zfs, cmdprops));
	}
	}

	/*
	* Restores a backup of tosnap from the file descriptor specified by infd.
	* Return 0 on total success, -2 if some things couldn't be
	* destroyed/renamed/promoted, -1 if some things couldn't be received.
	* (-1 will override -2, if -1 and the resumable flag was specified the
	* transfer can be resumed if the sending side supports it).
	*/
	int
	zfs_receive(libzfs_handle_t hdl, const char tosnap, nvlist_t *props,
	recvflags_t flags, int infd, avl_tree_t stream_avl)
	{
	char *top_zfs = NULL;
	int err;
	struct stat sb;
	char *originsnap = NULL;

	/*
	* The only way fstat can fail is if we do not have a valid file
	* descriptor.
	*/
	if (fstat(infd, &sb) == -1) {
	perror("fstat");
	return (-2);
	}

	/*
	* It is not uncommon for gigabytes to be processed in zfs receive.
	* Speculatively increase the buffer size if supported by the platform.
	*/
	if (S_ISFIFO(sb.st_mode))
	libzfs_set_pipe_max(infd);

	if (props) {
	err = nvlist_lookup_string(props, "origin", &originsnap);
	if (err && err != ENOENT)
	return (err);
	}

	err = zfs_receive_impl(hdl, tosnap, originsnap, flags, infd, NULL, NULL,
	stream_avl, &top_zfs, NULL, props);

	if (err == 0 && !flags->nomount && flags->domount && top_zfs) {
	zfs_handle_t *zhp = NULL;
	prop_changelist_t *clp = NULL;

	zhp = zfs_open(hdl, top_zfs,
	ZFS_TYPE_FILESYSTEM \| ZFS_TYPE_VOLUME);
	if (zhp == NULL) {
	err = -1;
	goto out;
	} else {
	if (zhp->zfs_type == ZFS_TYPE_VOLUME) {
	zfs_close(zhp);
	goto out;
	}

	clp = changelist_gather(zhp, ZFS_PROP_MOUNTPOINT,
	CL_GATHER_MOUNT_ALWAYS,
	flags->forceunmount ? MS_FORCE : 0);
	zfs_close(zhp);
	if (clp == NULL) {
	err = -1;
	goto out;
	}

	/* mount and share received datasets */
	err = changelist_postfix(clp);
	changelist_free(clp);
	if (err != 0)
	err = -1;
	}
	}

	out:
	if (top_zfs)
	free(top_zfs);

	return (err);
	}
	diff --git a/sys/contrib/openzfs/lib/libzfs/libzfs_status.c b/sys/contrib/openzfs/lib/libzfs/libzfs_status.c
	index 5e5cb5f5d440..33d6e1bfdf80 100644
	--- a/sys/contrib/openzfs/lib/libzfs/libzfs_status.c
	+++ b/sys/contrib/openzfs/lib/libzfs/libzfs_status.c
	@@ -1,531 +1,543 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2012 by Delphix. All rights reserved.
	* Copyright (c) 2013 Steven Hartland. All rights reserved.
	* Copyright (c) 2021, Colm Buckley <colm@tuatha.org>
	*/

	/*
	* This file contains the functions which analyze the status of a pool. This
	* include both the status of an active pool, as well as the status exported
	* pools. Returns one of the ZPOOL_STATUS_* defines describing the status of
	* the pool. This status is independent (to a certain degree) from the state of
	* the pool. A pool's state describes only whether or not it is capable of
	* providing the necessary fault tolerance for data. The status describes the
	* overall status of devices. A pool that is online can still have a device
	* that is experiencing errors.
	*
	* Only a subset of the possible faults can be detected using 'zpool status',
	* and not all possible errors correspond to a FMA message ID. The explanation
	* is left up to the caller, depending on whether it is a live pool or an
	* import.
	*/

	#include <libzfs.h>
	#include <libzutil.h>
	#include <stdlib.h>
	#include <string.h>
	#include <unistd.h>
	#include <sys/systeminfo.h>
	#include "libzfs_impl.h"
	#include "zfeature_common.h"

	/*
	* Message ID table. This must be kept in sync with the ZPOOL_STATUS_* defines
	* in include/libzfs.h. Note that there are some status results which go past
	* the end of this table, and hence have no associated message ID.
	*/
	static char *zfs_msgid_table[] = {
	"ZFS-8000-14", /* ZPOOL_STATUS_CORRUPT_CACHE */
	"ZFS-8000-2Q", /* ZPOOL_STATUS_MISSING_DEV_R */
	"ZFS-8000-3C", /* ZPOOL_STATUS_MISSING_DEV_NR */
	"ZFS-8000-4J", /* ZPOOL_STATUS_CORRUPT_LABEL_R */
	"ZFS-8000-5E", /* ZPOOL_STATUS_CORRUPT_LABEL_NR */
	"ZFS-8000-6X", /* ZPOOL_STATUS_BAD_GUID_SUM */
	"ZFS-8000-72", /* ZPOOL_STATUS_CORRUPT_POOL */
	"ZFS-8000-8A", /* ZPOOL_STATUS_CORRUPT_DATA */
	"ZFS-8000-9P", /* ZPOOL_STATUS_FAILING_DEV */
	"ZFS-8000-A5", /* ZPOOL_STATUS_VERSION_NEWER */
	"ZFS-8000-EY", /* ZPOOL_STATUS_HOSTID_MISMATCH */
	"ZFS-8000-EY", /* ZPOOL_STATUS_HOSTID_ACTIVE */
	"ZFS-8000-EY", /* ZPOOL_STATUS_HOSTID_REQUIRED */
	"ZFS-8000-HC", /* ZPOOL_STATUS_IO_FAILURE_WAIT */
	"ZFS-8000-JQ", /* ZPOOL_STATUS_IO_FAILURE_CONTINUE */
	"ZFS-8000-MM", /* ZPOOL_STATUS_IO_FAILURE_MMP */
	"ZFS-8000-K4", /* ZPOOL_STATUS_BAD_LOG */
	"ZFS-8000-ER", /* ZPOOL_STATUS_ERRATA */
	/*
	* The following results have no message ID.
	* ZPOOL_STATUS_UNSUP_FEAT_READ
	* ZPOOL_STATUS_UNSUP_FEAT_WRITE
	* ZPOOL_STATUS_FAULTED_DEV_R
	* ZPOOL_STATUS_FAULTED_DEV_NR
	* ZPOOL_STATUS_VERSION_OLDER
	* ZPOOL_STATUS_FEAT_DISABLED
	* ZPOOL_STATUS_RESILVERING
	* ZPOOL_STATUS_OFFLINE_DEV
	* ZPOOL_STATUS_REMOVED_DEV
	* ZPOOL_STATUS_REBUILDING
	* ZPOOL_STATUS_REBUILD_SCRUB
	* ZPOOL_STATUS_COMPATIBILITY_ERR
	+ * ZPOOL_STATUS_INCOMPATIBLE_FEAT
	* ZPOOL_STATUS_OK
	*/
	};

	#define NMSGID (sizeof (zfs_msgid_table) / sizeof (zfs_msgid_table[0]))

	/* ARGSUSED */
	static int
	vdev_missing(vdev_stat_t *vs, uint_t vsc)
	{
	return (vs->vs_state == VDEV_STATE_CANT_OPEN &&
	vs->vs_aux == VDEV_AUX_OPEN_FAILED);
	}

	/* ARGSUSED */
	static int
	vdev_faulted(vdev_stat_t *vs, uint_t vsc)
	{
	return (vs->vs_state == VDEV_STATE_FAULTED);
	}

	/* ARGSUSED */
	static int
	vdev_errors(vdev_stat_t *vs, uint_t vsc)
	{
	return (vs->vs_state == VDEV_STATE_DEGRADED \|\|
	vs->vs_read_errors != 0 \|\| vs->vs_write_errors != 0 \|\|
	vs->vs_checksum_errors != 0);
	}

	/* ARGSUSED */
	static int
	vdev_broken(vdev_stat_t *vs, uint_t vsc)
	{
	return (vs->vs_state == VDEV_STATE_CANT_OPEN);
	}

	/* ARGSUSED */
	static int
	vdev_offlined(vdev_stat_t *vs, uint_t vsc)
	{
	return (vs->vs_state == VDEV_STATE_OFFLINE);
	}

	/* ARGSUSED */
	static int
	vdev_removed(vdev_stat_t *vs, uint_t vsc)
	{
	return (vs->vs_state == VDEV_STATE_REMOVED);
	}

	static int
	vdev_non_native_ashift(vdev_stat_t *vs, uint_t vsc)
	{
	if (getenv("ZPOOL_STATUS_NON_NATIVE_ASHIFT_IGNORE") != NULL)
	return (0);

	return (VDEV_STAT_VALID(vs_physical_ashift, vsc) &&
	vs->vs_configured_ashift < vs->vs_physical_ashift);
	}

	/*
	* Detect if any leaf devices that have seen errors or could not be opened.
	*/
	static boolean_t
	find_vdev_problem(nvlist_t vdev, int (func)(vdev_stat_t *, uint_t),
	boolean_t ignore_replacing)
	{
	nvlist_t **child;
	vdev_stat_t *vs;
	uint_t c, vsc, children;

	/*
	* Ignore problems within a 'replacing' vdev, since we're presumably in
	* the process of repairing any such errors, and don't want to call them
	* out again. We'll pick up the fact that a resilver is happening
	* later.
	*/
	if (ignore_replacing == B_TRUE) {
	char *type;

	verify(nvlist_lookup_string(vdev, ZPOOL_CONFIG_TYPE,
	&type) == 0);
	if (strcmp(type, VDEV_TYPE_REPLACING) == 0)
	return (B_FALSE);
	}

	if (nvlist_lookup_nvlist_array(vdev, ZPOOL_CONFIG_CHILDREN, &child,
	&children) == 0) {
	for (c = 0; c < children; c++)
	if (find_vdev_problem(child[c], func, ignore_replacing))
	return (B_TRUE);
	} else {
	verify(nvlist_lookup_uint64_array(vdev, ZPOOL_CONFIG_VDEV_STATS,
	(uint64_t **)&vs, &vsc) == 0);

	if (func(vs, vsc) != 0)
	return (B_TRUE);
	}

	/*
	* Check any L2 cache devs
	*/
	if (nvlist_lookup_nvlist_array(vdev, ZPOOL_CONFIG_L2CACHE, &child,
	&children) == 0) {
	for (c = 0; c < children; c++)
	if (find_vdev_problem(child[c], func, ignore_replacing))
	return (B_TRUE);
	}

	return (B_FALSE);
	}

	/*
	* Active pool health status.
	*
	* To determine the status for a pool, we make several passes over the config,
	* picking the most egregious error we find. In order of importance, we do the
	* following:
	*
	* - Check for a complete and valid configuration
	* - Look for any faulted or missing devices in a non-replicated config
	* - Check for any data errors
	* - Check for any faulted or missing devices in a replicated config
	* - Look for any devices showing errors
	* - Check for any resilvering or rebuilding devices
	*
	* There can obviously be multiple errors within a single pool, so this routine
	* only picks the most damaging of all the current errors to report.
	*/
	static zpool_status_t
	check_status(nvlist_t *config, boolean_t isimport,
	zpool_errata_t erratap, const char compat)
	{
	nvlist_t *nvroot;
	vdev_stat_t *vs;
	pool_scan_stat_t *ps = NULL;
	uint_t vsc, psc;
	uint64_t nerr;
	uint64_t version;
	uint64_t stateval;
	uint64_t suspended;
	uint64_t hostid = 0;
	uint64_t errata = 0;
	unsigned long system_hostid = get_system_hostid();

	verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION,
	&version) == 0);
	verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
	&nvroot) == 0);
	verify(nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_VDEV_STATS,
	(uint64_t **)&vs, &vsc) == 0);
	verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE,
	&stateval) == 0);

	/*
	* Currently resilvering a vdev
	*/
	(void) nvlist_lookup_uint64_array(nvroot, ZPOOL_CONFIG_SCAN_STATS,
	(uint64_t **)&ps, &psc);
	if (ps != NULL && ps->pss_func == POOL_SCAN_RESILVER &&
	ps->pss_state == DSS_SCANNING)
	return (ZPOOL_STATUS_RESILVERING);

	/*
	* Currently rebuilding a vdev, check top-level vdevs.
	*/
	vdev_rebuild_stat_t *vrs = NULL;
	nvlist_t **child;
	uint_t c, i, children;
	uint64_t rebuild_end_time = 0;
	if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN,
	&child, &children) == 0) {
	for (c = 0; c < children; c++) {
	if ((nvlist_lookup_uint64_array(child[c],
	ZPOOL_CONFIG_REBUILD_STATS,
	(uint64_t **)&vrs, &i) == 0) && (vrs != NULL)) {
	uint64_t state = vrs->vrs_state;

	if (state == VDEV_REBUILD_ACTIVE) {
	return (ZPOOL_STATUS_REBUILDING);
	} else if (state == VDEV_REBUILD_COMPLETE &&
	vrs->vrs_end_time > rebuild_end_time) {
	rebuild_end_time = vrs->vrs_end_time;
	}
	}
	}

	/*
	* If we can determine when the last scrub was run, and it
	* was before the last rebuild completed, then recommend
	* that the pool be scrubbed to verify all checksums. When
	* ps is NULL we can infer the pool has never been scrubbed.
	*/
	if (rebuild_end_time > 0) {
	if (ps != NULL) {
	if ((ps->pss_state == DSS_FINISHED &&
	ps->pss_func == POOL_SCAN_SCRUB &&
	rebuild_end_time > ps->pss_end_time) \|\|
	ps->pss_state == DSS_NONE)
	return (ZPOOL_STATUS_REBUILD_SCRUB);
	} else {
	return (ZPOOL_STATUS_REBUILD_SCRUB);
	}
	}
	}

	/*
	* The multihost property is set and the pool may be active.
	*/
	if (vs->vs_state == VDEV_STATE_CANT_OPEN &&
	vs->vs_aux == VDEV_AUX_ACTIVE) {
	mmp_state_t mmp_state;
	nvlist_t *nvinfo;

	nvinfo = fnvlist_lookup_nvlist(config, ZPOOL_CONFIG_LOAD_INFO);
	mmp_state = fnvlist_lookup_uint64(nvinfo,
	ZPOOL_CONFIG_MMP_STATE);

	if (mmp_state == MMP_STATE_ACTIVE)
	return (ZPOOL_STATUS_HOSTID_ACTIVE);
	else if (mmp_state == MMP_STATE_NO_HOSTID)
	return (ZPOOL_STATUS_HOSTID_REQUIRED);
	else
	return (ZPOOL_STATUS_HOSTID_MISMATCH);
	}

	/*
	* Pool last accessed by another system.
	*/
	(void) nvlist_lookup_uint64(config, ZPOOL_CONFIG_HOSTID, &hostid);
	if (hostid != 0 && (unsigned long)hostid != system_hostid &&
	stateval == POOL_STATE_ACTIVE)
	return (ZPOOL_STATUS_HOSTID_MISMATCH);

	/*
	* Newer on-disk version.
	*/
	if (vs->vs_state == VDEV_STATE_CANT_OPEN &&
	vs->vs_aux == VDEV_AUX_VERSION_NEWER)
	return (ZPOOL_STATUS_VERSION_NEWER);

	/*
	* Unsupported feature(s).
	*/
	if (vs->vs_state == VDEV_STATE_CANT_OPEN &&
	vs->vs_aux == VDEV_AUX_UNSUP_FEAT) {
	nvlist_t *nvinfo;

	verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_LOAD_INFO,
	&nvinfo) == 0);
	if (nvlist_exists(nvinfo, ZPOOL_CONFIG_CAN_RDONLY))
	return (ZPOOL_STATUS_UNSUP_FEAT_WRITE);
	return (ZPOOL_STATUS_UNSUP_FEAT_READ);
	}

	/*
	* Check that the config is complete.
	*/
	if (vs->vs_state == VDEV_STATE_CANT_OPEN &&
	vs->vs_aux == VDEV_AUX_BAD_GUID_SUM)
	return (ZPOOL_STATUS_BAD_GUID_SUM);

	/*
	* Check whether the pool has suspended.
	*/
	if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_SUSPENDED,
	&suspended) == 0) {
	uint64_t reason;

	if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_SUSPENDED_REASON,
	&reason) == 0 && reason == ZIO_SUSPEND_MMP)
	return (ZPOOL_STATUS_IO_FAILURE_MMP);

	if (suspended == ZIO_FAILURE_MODE_CONTINUE)
	return (ZPOOL_STATUS_IO_FAILURE_CONTINUE);
	return (ZPOOL_STATUS_IO_FAILURE_WAIT);
	}

	/*
	* Could not read a log.
	*/
	if (vs->vs_state == VDEV_STATE_CANT_OPEN &&
	vs->vs_aux == VDEV_AUX_BAD_LOG) {
	return (ZPOOL_STATUS_BAD_LOG);
	}

	/*
	* Bad devices in non-replicated config.
	*/
	if (vs->vs_state == VDEV_STATE_CANT_OPEN &&
	find_vdev_problem(nvroot, vdev_faulted, B_TRUE))
	return (ZPOOL_STATUS_FAULTED_DEV_NR);

	if (vs->vs_state == VDEV_STATE_CANT_OPEN &&
	find_vdev_problem(nvroot, vdev_missing, B_TRUE))
	return (ZPOOL_STATUS_MISSING_DEV_NR);

	if (vs->vs_state == VDEV_STATE_CANT_OPEN &&
	find_vdev_problem(nvroot, vdev_broken, B_TRUE))
	return (ZPOOL_STATUS_CORRUPT_LABEL_NR);

	/*
	* Corrupted pool metadata
	*/
	if (vs->vs_state == VDEV_STATE_CANT_OPEN &&
	vs->vs_aux == VDEV_AUX_CORRUPT_DATA)
	return (ZPOOL_STATUS_CORRUPT_POOL);

	/*
	* Persistent data errors.
	*/
	if (!isimport) {
	if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_ERRCOUNT,
	&nerr) == 0 && nerr != 0)
	return (ZPOOL_STATUS_CORRUPT_DATA);
	}

	/*
	* Missing devices in a replicated config.
	*/
	if (find_vdev_problem(nvroot, vdev_faulted, B_TRUE))
	return (ZPOOL_STATUS_FAULTED_DEV_R);
	if (find_vdev_problem(nvroot, vdev_missing, B_TRUE))
	return (ZPOOL_STATUS_MISSING_DEV_R);
	if (find_vdev_problem(nvroot, vdev_broken, B_TRUE))
	return (ZPOOL_STATUS_CORRUPT_LABEL_R);

	/*
	* Devices with errors
	*/
	if (!isimport && find_vdev_problem(nvroot, vdev_errors, B_TRUE))
	return (ZPOOL_STATUS_FAILING_DEV);

	/*
	* Offlined devices
	*/
	if (find_vdev_problem(nvroot, vdev_offlined, B_TRUE))
	return (ZPOOL_STATUS_OFFLINE_DEV);

	/*
	* Removed device
	*/
	if (find_vdev_problem(nvroot, vdev_removed, B_TRUE))
	return (ZPOOL_STATUS_REMOVED_DEV);

	/*
	* Suboptimal, but usable, ashift configuration.
	*/
	if (find_vdev_problem(nvroot, vdev_non_native_ashift, B_FALSE))
	return (ZPOOL_STATUS_NON_NATIVE_ASHIFT);

	/*
	* Informational errata available.
	*/
	(void) nvlist_lookup_uint64(config, ZPOOL_CONFIG_ERRATA, &errata);
	if (errata) {
	*erratap = errata;
	return (ZPOOL_STATUS_ERRATA);
	}

	/*
	* Outdated, but usable, version
	*/
	- if (SPA_VERSION_IS_SUPPORTED(version) && version != SPA_VERSION)
	- return (ZPOOL_STATUS_VERSION_OLDER);
	+ if (SPA_VERSION_IS_SUPPORTED(version) && version != SPA_VERSION) {
	+ /* "legacy" compatibility disables old version reporting */
	+ if (compat != NULL && strcmp(compat, ZPOOL_COMPAT_LEGACY) == 0)
	+ return (ZPOOL_STATUS_OK);
	+ else
	+ return (ZPOOL_STATUS_VERSION_OLDER);
	+ }

	/*
	- * Usable pool with disabled features
	+ * Usable pool with disabled or superfluous features
	+ * (superfluous = beyond what's requested by 'compatibility')
	*/
	if (version >= SPA_VERSION_FEATURES) {
	int i;
	nvlist_t *feat;

	if (isimport) {
	feat = fnvlist_lookup_nvlist(config,
	ZPOOL_CONFIG_LOAD_INFO);
	if (nvlist_exists(feat, ZPOOL_CONFIG_ENABLED_FEAT))
	feat = fnvlist_lookup_nvlist(feat,
	ZPOOL_CONFIG_ENABLED_FEAT);
	} else {
	feat = fnvlist_lookup_nvlist(config,
	ZPOOL_CONFIG_FEATURE_STATS);
	}

	/* check against all features, or limited set? */
	- boolean_t pool_features[SPA_FEATURES];
	+ boolean_t c_features[SPA_FEATURES];

	- if (zpool_load_compat(compat, pool_features, NULL, NULL) !=
	- ZPOOL_COMPATIBILITY_OK)
	+ switch (zpool_load_compat(compat, c_features, NULL, 0)) {
	+ case ZPOOL_COMPATIBILITY_OK:
	+ case ZPOOL_COMPATIBILITY_WARNTOKEN:
	+ break;
	+ default:
	return (ZPOOL_STATUS_COMPATIBILITY_ERR);
	+ }
	for (i = 0; i < SPA_FEATURES; i++) {
	zfeature_info_t *fi = &spa_feature_table[i];
	if (!fi->fi_zfs_mod_supported)
	continue;
	- if (pool_features[i] &&
	- !nvlist_exists(feat, fi->fi_guid))
	+ if (c_features[i] && !nvlist_exists(feat, fi->fi_guid))
	return (ZPOOL_STATUS_FEAT_DISABLED);
	+ if (!c_features[i] && nvlist_exists(feat, fi->fi_guid))
	+ return (ZPOOL_STATUS_INCOMPATIBLE_FEAT);
	}
	}

	return (ZPOOL_STATUS_OK);
	}

	zpool_status_t
	zpool_get_status(zpool_handle_t zhp, char msgid, zpool_errata_t errata)
	{
	/*
	* pass in the desired feature set, as
	* it affects check for disabled features
	*/
	char compatibility[ZFS_MAXPROPLEN];
	if (zpool_get_prop(zhp, ZPOOL_PROP_COMPATIBILITY, compatibility,
	ZFS_MAXPROPLEN, NULL, B_FALSE) != 0)
	compatibility[0] = '\0';

	zpool_status_t ret = check_status(zhp->zpool_config, B_FALSE, errata,
	compatibility);

	if (msgid != NULL) {
	if (ret >= NMSGID)
	*msgid = NULL;
	else
	*msgid = zfs_msgid_table[ret];
	}
	return (ret);
	}

	zpool_status_t
	zpool_import_status(nvlist_t config, char msgid, zpool_errata_t errata)
	{
	zpool_status_t ret = check_status(config, B_TRUE, errata, NULL);

	if (ret >= NMSGID)
	*msgid = NULL;
	else
	*msgid = zfs_msgid_table[ret];

	return (ret);
	}
	diff --git a/sys/contrib/openzfs/lib/libzfs/libzfs_util.c b/sys/contrib/openzfs/lib/libzfs/libzfs_util.c
	index 95cb32957218..7a6e9269280b 100644
	--- a/sys/contrib/openzfs/lib/libzfs/libzfs_util.c
	+++ b/sys/contrib/openzfs/lib/libzfs/libzfs_util.c
	@@ -1,2104 +1,2102 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright 2020 Joyent, Inc. All rights reserved.
	* Copyright (c) 2011, 2020 by Delphix. All rights reserved.
	* Copyright 2016 Igor Kozhukhov <ikozhukhov@gmail.com>
	* Copyright (c) 2017 Datto Inc.
	* Copyright (c) 2020 The FreeBSD Foundation
	*
	* Portions of this software were developed by Allan Jude
	* under sponsorship from the FreeBSD Foundation.
	*/

	/*
	* Internal utility routines for the ZFS library.
	*/

	#include <errno.h>
	#include <fcntl.h>
	#include <libintl.h>
	#include <stdarg.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <strings.h>
	#include <unistd.h>
	#include <math.h>
	#include <sys/stat.h>
	#include <sys/mnttab.h>
	#include <sys/mntent.h>
	#include <sys/types.h>
	#include <sys/wait.h>

	#include <libzfs.h>
	#include <libzfs_core.h>

	#include "libzfs_impl.h"
	#include "zfs_prop.h"
	#include "zfeature_common.h"
	#include <zfs_fletcher.h>
	#include <libzutil.h>

	/*
	* We only care about the scheme in order to match the scheme
	* with the handler. Each handler should validate the full URI
	* as necessary.
	*/
	#define URI_REGEX "^\$[A-Za-z][A-Za-z0-9+.\\-]*\$:"

	int
	libzfs_errno(libzfs_handle_t *hdl)
	{
	return (hdl->libzfs_error);
	}

	const char *
	libzfs_error_action(libzfs_handle_t *hdl)
	{
	return (hdl->libzfs_action);
	}

	const char *
	libzfs_error_description(libzfs_handle_t *hdl)
	{
	if (hdl->libzfs_desc[0] != '\0')
	return (hdl->libzfs_desc);

	switch (hdl->libzfs_error) {
	case EZFS_NOMEM:
	return (dgettext(TEXT_DOMAIN, "out of memory"));
	case EZFS_BADPROP:
	return (dgettext(TEXT_DOMAIN, "invalid property value"));
	case EZFS_PROPREADONLY:
	return (dgettext(TEXT_DOMAIN, "read-only property"));
	case EZFS_PROPTYPE:
	return (dgettext(TEXT_DOMAIN, "property doesn't apply to "
	"datasets of this type"));
	case EZFS_PROPNONINHERIT:
	return (dgettext(TEXT_DOMAIN, "property cannot be inherited"));
	case EZFS_PROPSPACE:
	return (dgettext(TEXT_DOMAIN, "invalid quota or reservation"));
	case EZFS_BADTYPE:
	return (dgettext(TEXT_DOMAIN, "operation not applicable to "
	"datasets of this type"));
	case EZFS_BUSY:
	return (dgettext(TEXT_DOMAIN, "pool or dataset is busy"));
	case EZFS_EXISTS:
	return (dgettext(TEXT_DOMAIN, "pool or dataset exists"));
	case EZFS_NOENT:
	return (dgettext(TEXT_DOMAIN, "no such pool or dataset"));
	case EZFS_BADSTREAM:
	return (dgettext(TEXT_DOMAIN, "invalid backup stream"));
	case EZFS_DSREADONLY:
	return (dgettext(TEXT_DOMAIN, "dataset is read-only"));
	case EZFS_VOLTOOBIG:
	return (dgettext(TEXT_DOMAIN, "volume size exceeds limit for "
	"this system"));
	case EZFS_INVALIDNAME:
	return (dgettext(TEXT_DOMAIN, "invalid name"));
	case EZFS_BADRESTORE:
	return (dgettext(TEXT_DOMAIN, "unable to restore to "
	"destination"));
	case EZFS_BADBACKUP:
	return (dgettext(TEXT_DOMAIN, "backup failed"));
	case EZFS_BADTARGET:
	return (dgettext(TEXT_DOMAIN, "invalid target vdev"));
	case EZFS_NODEVICE:
	return (dgettext(TEXT_DOMAIN, "no such device in pool"));
	case EZFS_BADDEV:
	return (dgettext(TEXT_DOMAIN, "invalid device"));
	case EZFS_NOREPLICAS:
	return (dgettext(TEXT_DOMAIN, "no valid replicas"));
	case EZFS_RESILVERING:
	return (dgettext(TEXT_DOMAIN, "currently resilvering"));
	case EZFS_BADVERSION:
	return (dgettext(TEXT_DOMAIN, "unsupported version or "
	"feature"));
	case EZFS_POOLUNAVAIL:
	return (dgettext(TEXT_DOMAIN, "pool is unavailable"));
	case EZFS_DEVOVERFLOW:
	return (dgettext(TEXT_DOMAIN, "too many devices in one vdev"));
	case EZFS_BADPATH:
	return (dgettext(TEXT_DOMAIN, "must be an absolute path"));
	case EZFS_CROSSTARGET:
	return (dgettext(TEXT_DOMAIN, "operation crosses datasets or "
	"pools"));
	case EZFS_ZONED:
	return (dgettext(TEXT_DOMAIN, "dataset in use by local zone"));
	case EZFS_MOUNTFAILED:
	return (dgettext(TEXT_DOMAIN, "mount failed"));
	case EZFS_UMOUNTFAILED:
	return (dgettext(TEXT_DOMAIN, "unmount failed"));
	case EZFS_UNSHARENFSFAILED:
	return (dgettext(TEXT_DOMAIN, "NFS share removal failed"));
	case EZFS_SHARENFSFAILED:
	return (dgettext(TEXT_DOMAIN, "NFS share creation failed"));
	case EZFS_UNSHARESMBFAILED:
	return (dgettext(TEXT_DOMAIN, "SMB share removal failed"));
	case EZFS_SHARESMBFAILED:
	return (dgettext(TEXT_DOMAIN, "SMB share creation failed"));
	case EZFS_PERM:
	return (dgettext(TEXT_DOMAIN, "permission denied"));
	case EZFS_NOSPC:
	return (dgettext(TEXT_DOMAIN, "out of space"));
	case EZFS_FAULT:
	return (dgettext(TEXT_DOMAIN, "bad address"));
	case EZFS_IO:
	return (dgettext(TEXT_DOMAIN, "I/O error"));
	case EZFS_INTR:
	return (dgettext(TEXT_DOMAIN, "signal received"));
	case EZFS_ISSPARE:
	return (dgettext(TEXT_DOMAIN, "device is reserved as a hot "
	"spare"));
	case EZFS_INVALCONFIG:
	return (dgettext(TEXT_DOMAIN, "invalid vdev configuration"));
	case EZFS_RECURSIVE:
	return (dgettext(TEXT_DOMAIN, "recursive dataset dependency"));
	case EZFS_NOHISTORY:
	return (dgettext(TEXT_DOMAIN, "no history available"));
	case EZFS_POOLPROPS:
	return (dgettext(TEXT_DOMAIN, "failed to retrieve "
	"pool properties"));
	case EZFS_POOL_NOTSUP:
	return (dgettext(TEXT_DOMAIN, "operation not supported "
	"on this type of pool"));
	case EZFS_POOL_INVALARG:
	return (dgettext(TEXT_DOMAIN, "invalid argument for "
	"this pool operation"));
	case EZFS_NAMETOOLONG:
	return (dgettext(TEXT_DOMAIN, "dataset name is too long"));
	case EZFS_OPENFAILED:
	return (dgettext(TEXT_DOMAIN, "open failed"));
	case EZFS_NOCAP:
	return (dgettext(TEXT_DOMAIN,
	"disk capacity information could not be retrieved"));
	case EZFS_LABELFAILED:
	return (dgettext(TEXT_DOMAIN, "write of label failed"));
	case EZFS_BADWHO:
	return (dgettext(TEXT_DOMAIN, "invalid user/group"));
	case EZFS_BADPERM:
	return (dgettext(TEXT_DOMAIN, "invalid permission"));
	case EZFS_BADPERMSET:
	return (dgettext(TEXT_DOMAIN, "invalid permission set name"));
	case EZFS_NODELEGATION:
	return (dgettext(TEXT_DOMAIN, "delegated administration is "
	"disabled on pool"));
	case EZFS_BADCACHE:
	return (dgettext(TEXT_DOMAIN, "invalid or missing cache file"));
	case EZFS_ISL2CACHE:
	return (dgettext(TEXT_DOMAIN, "device is in use as a cache"));
	case EZFS_VDEVNOTSUP:
	return (dgettext(TEXT_DOMAIN, "vdev specification is not "
	"supported"));
	case EZFS_NOTSUP:
	return (dgettext(TEXT_DOMAIN, "operation not supported "
	"on this dataset"));
	case EZFS_IOC_NOTSUPPORTED:
	return (dgettext(TEXT_DOMAIN, "operation not supported by "
	"zfs kernel module"));
	case EZFS_ACTIVE_SPARE:
	return (dgettext(TEXT_DOMAIN, "pool has active shared spare "
	"device"));
	case EZFS_UNPLAYED_LOGS:
	return (dgettext(TEXT_DOMAIN, "log device has unplayed intent "
	"logs"));
	case EZFS_REFTAG_RELE:
	return (dgettext(TEXT_DOMAIN, "no such tag on this dataset"));
	case EZFS_REFTAG_HOLD:
	return (dgettext(TEXT_DOMAIN, "tag already exists on this "
	"dataset"));
	case EZFS_TAGTOOLONG:
	return (dgettext(TEXT_DOMAIN, "tag too long"));
	case EZFS_PIPEFAILED:
	return (dgettext(TEXT_DOMAIN, "pipe create failed"));
	case EZFS_THREADCREATEFAILED:
	return (dgettext(TEXT_DOMAIN, "thread create failed"));
	case EZFS_POSTSPLIT_ONLINE:
	return (dgettext(TEXT_DOMAIN, "disk was split from this pool "
	"into a new one"));
	case EZFS_SCRUB_PAUSED:
	return (dgettext(TEXT_DOMAIN, "scrub is paused; "
	"use 'zpool scrub' to resume"));
	case EZFS_SCRUBBING:
	return (dgettext(TEXT_DOMAIN, "currently scrubbing; "
	"use 'zpool scrub -s' to cancel current scrub"));
	case EZFS_NO_SCRUB:
	return (dgettext(TEXT_DOMAIN, "there is no active scrub"));
	case EZFS_DIFF:
	return (dgettext(TEXT_DOMAIN, "unable to generate diffs"));
	case EZFS_DIFFDATA:
	return (dgettext(TEXT_DOMAIN, "invalid diff data"));
	case EZFS_POOLREADONLY:
	return (dgettext(TEXT_DOMAIN, "pool is read-only"));
	case EZFS_NO_PENDING:
	return (dgettext(TEXT_DOMAIN, "operation is not "
	"in progress"));
	case EZFS_CHECKPOINT_EXISTS:
	return (dgettext(TEXT_DOMAIN, "checkpoint exists"));
	case EZFS_DISCARDING_CHECKPOINT:
	return (dgettext(TEXT_DOMAIN, "currently discarding "
	"checkpoint"));
	case EZFS_NO_CHECKPOINT:
	return (dgettext(TEXT_DOMAIN, "checkpoint does not exist"));
	case EZFS_DEVRM_IN_PROGRESS:
	return (dgettext(TEXT_DOMAIN, "device removal in progress"));
	case EZFS_VDEV_TOO_BIG:
	return (dgettext(TEXT_DOMAIN, "device exceeds supported size"));
	case EZFS_ACTIVE_POOL:
	return (dgettext(TEXT_DOMAIN, "pool is imported on a "
	"different host"));
	case EZFS_CRYPTOFAILED:
	return (dgettext(TEXT_DOMAIN, "encryption failure"));
	case EZFS_TOOMANY:
	return (dgettext(TEXT_DOMAIN, "argument list too long"));
	case EZFS_INITIALIZING:
	return (dgettext(TEXT_DOMAIN, "currently initializing"));
	case EZFS_NO_INITIALIZE:
	return (dgettext(TEXT_DOMAIN, "there is no active "
	"initialization"));
	case EZFS_WRONG_PARENT:
	return (dgettext(TEXT_DOMAIN, "invalid parent dataset"));
	case EZFS_TRIMMING:
	return (dgettext(TEXT_DOMAIN, "currently trimming"));
	case EZFS_NO_TRIM:
	return (dgettext(TEXT_DOMAIN, "there is no active trim"));
	case EZFS_TRIM_NOTSUP:
	return (dgettext(TEXT_DOMAIN, "trim operations are not "
	"supported by this device"));
	case EZFS_NO_RESILVER_DEFER:
	return (dgettext(TEXT_DOMAIN, "this action requires the "
	"resilver_defer feature"));
	case EZFS_EXPORT_IN_PROGRESS:
	return (dgettext(TEXT_DOMAIN, "pool export in progress"));
	case EZFS_REBUILDING:
	return (dgettext(TEXT_DOMAIN, "currently sequentially "
	"resilvering"));
	case EZFS_UNKNOWN:
	return (dgettext(TEXT_DOMAIN, "unknown error"));
	default:
	assert(hdl->libzfs_error == 0);
	return (dgettext(TEXT_DOMAIN, "no error"));
	}
	}

	/PRINTFLIKE2/
	void
	zfs_error_aux(libzfs_handle_t hdl, const char fmt, ...)
	{
	va_list ap;

	va_start(ap, fmt);

	(void) vsnprintf(hdl->libzfs_desc, sizeof (hdl->libzfs_desc),
	fmt, ap);
	hdl->libzfs_desc_active = 1;

	va_end(ap);
	}

	static void
	zfs_verror(libzfs_handle_t hdl, int error, const char fmt, va_list ap)
	{
	(void) vsnprintf(hdl->libzfs_action, sizeof (hdl->libzfs_action),
	fmt, ap);
	hdl->libzfs_error = error;

	if (hdl->libzfs_desc_active)
	hdl->libzfs_desc_active = 0;
	else
	hdl->libzfs_desc[0] = '\0';

	if (hdl->libzfs_printerr) {
	if (error == EZFS_UNKNOWN) {
	(void) fprintf(stderr, dgettext(TEXT_DOMAIN, "internal "
	"error: %s: %s\n"), hdl->libzfs_action,
	libzfs_error_description(hdl));
	abort();
	}

	(void) fprintf(stderr, "%s: %s\n", hdl->libzfs_action,
	libzfs_error_description(hdl));
	if (error == EZFS_NOMEM)
	exit(1);
	}
	}

	int
	zfs_error(libzfs_handle_t hdl, int error, const char msg)
	{
	return (zfs_error_fmt(hdl, error, "%s", msg));
	}

	/PRINTFLIKE3/
	int
	zfs_error_fmt(libzfs_handle_t hdl, int error, const char fmt, ...)
	{
	va_list ap;

	va_start(ap, fmt);

	zfs_verror(hdl, error, fmt, ap);

	va_end(ap);

	return (-1);
	}

	static int
	zfs_common_error(libzfs_handle_t hdl, int error, const char fmt,
	va_list ap)
	{
	switch (error) {
	case EPERM:
	case EACCES:
	zfs_verror(hdl, EZFS_PERM, fmt, ap);
	return (-1);

	case ECANCELED:
	zfs_verror(hdl, EZFS_NODELEGATION, fmt, ap);
	return (-1);

	case EIO:
	zfs_verror(hdl, EZFS_IO, fmt, ap);
	return (-1);

	case EFAULT:
	zfs_verror(hdl, EZFS_FAULT, fmt, ap);
	return (-1);

	case EINTR:
	zfs_verror(hdl, EZFS_INTR, fmt, ap);
	return (-1);
	}

	return (0);
	}

	int
	zfs_standard_error(libzfs_handle_t hdl, int error, const char msg)
	{
	return (zfs_standard_error_fmt(hdl, error, "%s", msg));
	}

	/PRINTFLIKE3/
	int
	zfs_standard_error_fmt(libzfs_handle_t hdl, int error, const char fmt, ...)
	{
	va_list ap;

	va_start(ap, fmt);

	if (zfs_common_error(hdl, error, fmt, ap) != 0) {
	va_end(ap);
	return (-1);
	}

	switch (error) {
	case ENXIO:
	case ENODEV:
	case EPIPE:
	zfs_verror(hdl, EZFS_IO, fmt, ap);
	break;

	case ENOENT:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"dataset does not exist"));
	zfs_verror(hdl, EZFS_NOENT, fmt, ap);
	break;

	case ENOSPC:
	case EDQUOT:
	zfs_verror(hdl, EZFS_NOSPC, fmt, ap);
	break;

	case EEXIST:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"dataset already exists"));
	zfs_verror(hdl, EZFS_EXISTS, fmt, ap);
	break;

	case EBUSY:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"dataset is busy"));
	zfs_verror(hdl, EZFS_BUSY, fmt, ap);
	break;
	case EROFS:
	zfs_verror(hdl, EZFS_POOLREADONLY, fmt, ap);
	break;
	case ENAMETOOLONG:
	zfs_verror(hdl, EZFS_NAMETOOLONG, fmt, ap);
	break;
	case ENOTSUP:
	zfs_verror(hdl, EZFS_BADVERSION, fmt, ap);
	break;
	case EAGAIN:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"pool I/O is currently suspended"));
	zfs_verror(hdl, EZFS_POOLUNAVAIL, fmt, ap);
	break;
	case EREMOTEIO:
	zfs_verror(hdl, EZFS_ACTIVE_POOL, fmt, ap);
	break;
	case ZFS_ERR_UNKNOWN_SEND_STREAM_FEATURE:
	case ZFS_ERR_IOC_CMD_UNAVAIL:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "the loaded zfs "
	"module does not support this operation. A reboot may "
	"be required to enable this operation."));
	zfs_verror(hdl, EZFS_IOC_NOTSUPPORTED, fmt, ap);
	break;
	case ZFS_ERR_IOC_ARG_UNAVAIL:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "the loaded zfs "
	"module does not support an option for this operation. "
	"A reboot may be required to enable this option."));
	zfs_verror(hdl, EZFS_IOC_NOTSUPPORTED, fmt, ap);
	break;
	case ZFS_ERR_IOC_ARG_REQUIRED:
	case ZFS_ERR_IOC_ARG_BADTYPE:
	zfs_verror(hdl, EZFS_IOC_NOTSUPPORTED, fmt, ap);
	break;
	case ZFS_ERR_WRONG_PARENT:
	zfs_verror(hdl, EZFS_WRONG_PARENT, fmt, ap);
	break;
	case ZFS_ERR_BADPROP:
	zfs_verror(hdl, EZFS_BADPROP, fmt, ap);
	break;
	default:
	zfs_error_aux(hdl, strerror(error));
	zfs_verror(hdl, EZFS_UNKNOWN, fmt, ap);
	break;
	}

	va_end(ap);
	return (-1);
	}

	void
	zfs_setprop_error(libzfs_handle_t *hdl, zfs_prop_t prop, int err,
	char *errbuf)
	{
	switch (err) {

	case ENOSPC:
	/*
	* For quotas and reservations, ENOSPC indicates
	* something different; setting a quota or reservation
	* doesn't use any disk space.
	*/
	switch (prop) {
	case ZFS_PROP_QUOTA:
	case ZFS_PROP_REFQUOTA:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"size is less than current used or "
	"reserved space"));
	(void) zfs_error(hdl, EZFS_PROPSPACE, errbuf);
	break;

	case ZFS_PROP_RESERVATION:
	case ZFS_PROP_REFRESERVATION:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"size is greater than available space"));
	(void) zfs_error(hdl, EZFS_PROPSPACE, errbuf);
	break;

	default:
	(void) zfs_standard_error(hdl, err, errbuf);
	break;
	}
	break;

	case EBUSY:
	(void) zfs_standard_error(hdl, EBUSY, errbuf);
	break;

	case EROFS:
	(void) zfs_error(hdl, EZFS_DSREADONLY, errbuf);
	break;

	case E2BIG:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"property value too long"));
	(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
	break;

	case ENOTSUP:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"pool and or dataset must be upgraded to set this "
	"property or value"));
	(void) zfs_error(hdl, EZFS_BADVERSION, errbuf);
	break;

	case ERANGE:
	if (prop == ZFS_PROP_COMPRESSION \|\|
	prop == ZFS_PROP_DNODESIZE \|\|
	prop == ZFS_PROP_RECORDSIZE) {
	(void) zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"property setting is not allowed on "
	"bootable datasets"));
	(void) zfs_error(hdl, EZFS_NOTSUP, errbuf);
	} else if (prop == ZFS_PROP_CHECKSUM \|\|
	prop == ZFS_PROP_DEDUP) {
	(void) zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"property setting is not allowed on "
	"root pools"));
	(void) zfs_error(hdl, EZFS_NOTSUP, errbuf);
	} else {
	(void) zfs_standard_error(hdl, err, errbuf);
	}
	break;

	case EINVAL:
	if (prop == ZPROP_INVAL) {
	(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
	} else {
	(void) zfs_standard_error(hdl, err, errbuf);
	}
	break;

	case ZFS_ERR_BADPROP:
	(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
	break;

	case EACCES:
	if (prop == ZFS_PROP_KEYLOCATION) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"keylocation may only be set on encryption roots"));
	(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
	} else {
	(void) zfs_standard_error(hdl, err, errbuf);
	}
	break;

	case EOVERFLOW:
	/*
	* This platform can't address a volume this big.
	*/
	#ifdef _ILP32
	if (prop == ZFS_PROP_VOLSIZE) {
	(void) zfs_error(hdl, EZFS_VOLTOOBIG, errbuf);
	break;
	}
	#endif
	/* FALLTHROUGH */
	default:
	(void) zfs_standard_error(hdl, err, errbuf);
	}
	}

	int
	zpool_standard_error(libzfs_handle_t hdl, int error, const char msg)
	{
	return (zpool_standard_error_fmt(hdl, error, "%s", msg));
	}

	/PRINTFLIKE3/
	int
	zpool_standard_error_fmt(libzfs_handle_t hdl, int error, const char fmt, ...)
	{
	va_list ap;

	va_start(ap, fmt);

	if (zfs_common_error(hdl, error, fmt, ap) != 0) {
	va_end(ap);
	return (-1);
	}

	switch (error) {
	case ENODEV:
	zfs_verror(hdl, EZFS_NODEVICE, fmt, ap);
	break;

	case ENOENT:
	zfs_error_aux(hdl,
	dgettext(TEXT_DOMAIN, "no such pool or dataset"));
	zfs_verror(hdl, EZFS_NOENT, fmt, ap);
	break;

	case EEXIST:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"pool already exists"));
	zfs_verror(hdl, EZFS_EXISTS, fmt, ap);
	break;

	case EBUSY:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "pool is busy"));
	zfs_verror(hdl, EZFS_BUSY, fmt, ap);
	break;

	/* There is no pending operation to cancel */
	case ENOTACTIVE:
	zfs_verror(hdl, EZFS_NO_PENDING, fmt, ap);
	break;

	case ENXIO:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"one or more devices is currently unavailable"));
	zfs_verror(hdl, EZFS_BADDEV, fmt, ap);
	break;

	case ENAMETOOLONG:
	zfs_verror(hdl, EZFS_DEVOVERFLOW, fmt, ap);
	break;

	case ENOTSUP:
	zfs_verror(hdl, EZFS_POOL_NOTSUP, fmt, ap);
	break;

	case EINVAL:
	zfs_verror(hdl, EZFS_POOL_INVALARG, fmt, ap);
	break;

	case ENOSPC:
	case EDQUOT:
	zfs_verror(hdl, EZFS_NOSPC, fmt, ap);
	return (-1);

	case EAGAIN:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"pool I/O is currently suspended"));
	zfs_verror(hdl, EZFS_POOLUNAVAIL, fmt, ap);
	break;

	case EROFS:
	zfs_verror(hdl, EZFS_POOLREADONLY, fmt, ap);
	break;
	case EDOM:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"block size out of range or does not match"));
	zfs_verror(hdl, EZFS_BADPROP, fmt, ap);
	break;
	case EREMOTEIO:
	zfs_verror(hdl, EZFS_ACTIVE_POOL, fmt, ap);
	break;
	case ZFS_ERR_CHECKPOINT_EXISTS:
	zfs_verror(hdl, EZFS_CHECKPOINT_EXISTS, fmt, ap);
	break;
	case ZFS_ERR_DISCARDING_CHECKPOINT:
	zfs_verror(hdl, EZFS_DISCARDING_CHECKPOINT, fmt, ap);
	break;
	case ZFS_ERR_NO_CHECKPOINT:
	zfs_verror(hdl, EZFS_NO_CHECKPOINT, fmt, ap);
	break;
	case ZFS_ERR_DEVRM_IN_PROGRESS:
	zfs_verror(hdl, EZFS_DEVRM_IN_PROGRESS, fmt, ap);
	break;
	case ZFS_ERR_VDEV_TOO_BIG:
	zfs_verror(hdl, EZFS_VDEV_TOO_BIG, fmt, ap);
	break;
	case ZFS_ERR_EXPORT_IN_PROGRESS:
	zfs_verror(hdl, EZFS_EXPORT_IN_PROGRESS, fmt, ap);
	break;
	case ZFS_ERR_RESILVER_IN_PROGRESS:
	zfs_verror(hdl, EZFS_RESILVERING, fmt, ap);
	break;
	case ZFS_ERR_REBUILD_IN_PROGRESS:
	zfs_verror(hdl, EZFS_REBUILDING, fmt, ap);
	break;
	case ZFS_ERR_BADPROP:
	zfs_verror(hdl, EZFS_BADPROP, fmt, ap);
	break;
	case ZFS_ERR_IOC_CMD_UNAVAIL:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "the loaded zfs "
	"module does not support this operation. A reboot may "
	"be required to enable this operation."));
	zfs_verror(hdl, EZFS_IOC_NOTSUPPORTED, fmt, ap);
	break;
	case ZFS_ERR_IOC_ARG_UNAVAIL:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "the loaded zfs "
	"module does not support an option for this operation. "
	"A reboot may be required to enable this option."));
	zfs_verror(hdl, EZFS_IOC_NOTSUPPORTED, fmt, ap);
	break;
	case ZFS_ERR_IOC_ARG_REQUIRED:
	case ZFS_ERR_IOC_ARG_BADTYPE:
	zfs_verror(hdl, EZFS_IOC_NOTSUPPORTED, fmt, ap);
	break;
	default:
	zfs_error_aux(hdl, strerror(error));
	zfs_verror(hdl, EZFS_UNKNOWN, fmt, ap);
	}

	va_end(ap);
	return (-1);
	}

	/*
	* Display an out of memory error message and abort the current program.
	*/
	int
	no_memory(libzfs_handle_t *hdl)
	{
	return (zfs_error(hdl, EZFS_NOMEM, "internal error"));
	}

	/*
	* A safe form of malloc() which will die if the allocation fails.
	*/
	void *
	zfs_alloc(libzfs_handle_t *hdl, size_t size)
	{
	void *data;

	if ((data = calloc(1, size)) == NULL)
	(void) no_memory(hdl);

	return (data);
	}

	/*
	* A safe form of asprintf() which will die if the allocation fails.
	*/
	/PRINTFLIKE2/
	char *
	zfs_asprintf(libzfs_handle_t hdl, const char fmt, ...)
	{
	va_list ap;
	char *ret;
	int err;

	va_start(ap, fmt);

	err = vasprintf(&ret, fmt, ap);

	va_end(ap);

	- if (err < 0)
	+ if (err < 0) {
	(void) no_memory(hdl);
	+ ret = NULL;
	+ }

	return (ret);
	}

	/*
	* A safe form of realloc(), which also zeroes newly allocated space.
	*/
	void *
	zfs_realloc(libzfs_handle_t hdl, void ptr, size_t oldsize, size_t newsize)
	{
	void *ret;

	if ((ret = realloc(ptr, newsize)) == NULL) {
	(void) no_memory(hdl);
	return (NULL);
	}

	bzero((char *)ret + oldsize, (newsize - oldsize));
	return (ret);
	}

	/*
	* A safe form of strdup() which will die if the allocation fails.
	*/
	char *
	zfs_strdup(libzfs_handle_t hdl, const char str)
	{
	char *ret;

	if ((ret = strdup(str)) == NULL)
	(void) no_memory(hdl);

	return (ret);
	}

	void
	libzfs_print_on_error(libzfs_handle_t *hdl, boolean_t printerr)
	{
	hdl->libzfs_printerr = printerr;
	}

	/*
	* Read lines from an open file descriptor and store them in an array of
	* strings until EOF. lines[] will be allocated and populated with all the
	* lines read. All newlines are replaced with NULL terminators for
	* convenience. lines[] must be freed after use with libzfs_free_str_array().
	*
	* Returns the number of lines read.
	*/
	static int
	libzfs_read_stdout_from_fd(int fd, char **lines[])
	{

	FILE *fp;
	int lines_cnt = 0;
	size_t len = 0;
	char *line = NULL;
	char tmp_lines = NULL, tmp;
	char *nl = NULL;
	int rc;

	fp = fdopen(fd, "r");
	if (fp == NULL)
	return (0);
	while (1) {
	rc = getline(&line, &len, fp);
	if (rc == -1)
	break;

	tmp = realloc(tmp_lines, sizeof (tmp_lines) (lines_cnt + 1));
	if (tmp == NULL) {
	/* Return the lines we were able to process */
	break;
	}
	tmp_lines = tmp;

	/* Terminate newlines */
	if ((nl = strchr(line, '\n')) != NULL)
	*nl = '\0';
	tmp_lines[lines_cnt] = line;
	lines_cnt++;
	line = NULL;
	}
	fclose(fp);
	*lines = tmp_lines;
	return (lines_cnt);
	}

	static int
	libzfs_run_process_impl(const char path, char argv[], char *env[], int flags,
	char *lines[], int lines_cnt)
	{
	pid_t pid;
	int error, devnull_fd;
	int link[2];

	/*
	* Setup a pipe between our child and parent process if we're
	* reading stdout.
	*/
	- if ((lines != NULL) && pipe(link) == -1)
	+ if ((lines != NULL) && pipe2(link, O_CLOEXEC) == -1)
	return (-EPIPE);

	pid = vfork();
	if (pid == 0) {
	/* Child process */
	- devnull_fd = open("/dev/null", O_WRONLY);
	+ devnull_fd = open("/dev/null", O_WRONLY \| O_CLOEXEC);

	if (devnull_fd < 0)
	_exit(-1);

	if (!(flags & STDOUT_VERBOSE) && (lines == NULL))
	(void) dup2(devnull_fd, STDOUT_FILENO);
	else if (lines != NULL) {
	/* Save the output to lines[] */
	dup2(link[1], STDOUT_FILENO);
	- close(link[0]);
	- close(link[1]);
	}

	if (!(flags & STDERR_VERBOSE))
	(void) dup2(devnull_fd, STDERR_FILENO);

	- close(devnull_fd);
	-
	if (flags & NO_DEFAULT_PATH) {
	if (env == NULL)
	execv(path, argv);
	else
	execve(path, argv, env);
	} else {
	if (env == NULL)
	execvp(path, argv);
	else
	execvpe(path, argv, env);
	}

	_exit(-1);
	} else if (pid > 0) {
	/* Parent process */
	int status;

	while ((error = waitpid(pid, &status, 0)) == -1 &&
	errno == EINTR) { }
	if (error < 0 \|\| !WIFEXITED(status))
	return (-1);

	if (lines != NULL) {
	close(link[1]);
	*lines_cnt = libzfs_read_stdout_from_fd(link[0], lines);
	}
	return (WEXITSTATUS(status));
	}

	return (-1);
	}

	int
	libzfs_run_process(const char path, char argv[], int flags)
	{
	return (libzfs_run_process_impl(path, argv, NULL, flags, NULL, NULL));
	}

	/*
	* Run a command and store its stdout lines in an array of strings (lines[]).
	* lines[] is allocated and populated for you, and the number of lines is set in
	* lines_cnt. lines[] must be freed after use with libzfs_free_str_array().
	* All newlines (\n) in lines[] are terminated for convenience.
	*/
	int
	libzfs_run_process_get_stdout(const char path, char argv[], char *env[],
	char *lines[], int lines_cnt)
	{
	return (libzfs_run_process_impl(path, argv, env, 0, lines, lines_cnt));
	}

	/*
	* Same as libzfs_run_process_get_stdout(), but run without $PATH set. This
	* means that *path needs to be the full path to the executable.
	*/
	int
	libzfs_run_process_get_stdout_nopath(const char path, char argv[],
	char env[], char lines[], int lines_cnt)
	{
	return (libzfs_run_process_impl(path, argv, env, NO_DEFAULT_PATH,
	lines, lines_cnt));
	}

	/*
	* Free an array of strings. Free both the strings contained in the array and
	* the array itself.
	*/
	void
	libzfs_free_str_array(char **strs, int count)
	{
	while (--count >= 0)
	free(strs[count]);

	free(strs);
	}

	/*
	* Returns 1 if environment variable is set to "YES", "yes", "ON", "on", or
	* a non-zero number.
	*
	* Returns 0 otherwise.
	*/
	int
	libzfs_envvar_is_set(char *envvar)
	{
	char *env = getenv(envvar);
	if (env && (strtoul(env, NULL, 0) > 0 \|\|
	(!strncasecmp(env, "YES", 3) && strnlen(env, 4) == 3) \|\|
	(!strncasecmp(env, "ON", 2) && strnlen(env, 3) == 2)))
	return (1);

	return (0);
	}

	libzfs_handle_t *
	libzfs_init(void)
	{
	libzfs_handle_t *hdl;
	int error;
	char *env;

	if ((error = libzfs_load_module()) != 0) {
	errno = error;
	return (NULL);
	}

	if ((hdl = calloc(1, sizeof (libzfs_handle_t))) == NULL) {
	return (NULL);
	}

	if (regcomp(&hdl->libzfs_urire, URI_REGEX, 0) != 0) {
	free(hdl);
	return (NULL);
	}

	- if ((hdl->libzfs_fd = open(ZFS_DEV, O_RDWR\|O_EXCL)) < 0) {
	+ if ((hdl->libzfs_fd = open(ZFS_DEV, O_RDWR\|O_EXCL\|O_CLOEXEC)) < 0) {
	free(hdl);
	return (NULL);
	}

	#ifdef HAVE_SETMNTENT
	- if ((hdl->libzfs_mnttab = setmntent(MNTTAB, "r")) == NULL) {
	+ if ((hdl->libzfs_mnttab = setmntent(MNTTAB, "re")) == NULL) {
	#else
	- if ((hdl->libzfs_mnttab = fopen(MNTTAB, "r")) == NULL) {
	+ if ((hdl->libzfs_mnttab = fopen(MNTTAB, "re")) == NULL) {
	#endif
	(void) close(hdl->libzfs_fd);
	free(hdl);
	return (NULL);
	}

	if (libzfs_core_init() != 0) {
	(void) close(hdl->libzfs_fd);
	(void) fclose(hdl->libzfs_mnttab);
	free(hdl);
	return (NULL);
	}

	zfs_prop_init();
	zpool_prop_init();
	zpool_feature_init();
	libzfs_mnttab_init(hdl);
	fletcher_4_init();

	if (getenv("ZFS_PROP_DEBUG") != NULL) {
	hdl->libzfs_prop_debug = B_TRUE;
	}
	if ((env = getenv("ZFS_SENDRECV_MAX_NVLIST")) != NULL) {
	if ((error = zfs_nicestrtonum(hdl, env,
	&hdl->libzfs_max_nvlist))) {
	errno = error;
	(void) close(hdl->libzfs_fd);
	(void) fclose(hdl->libzfs_mnttab);
	free(hdl);
	return (NULL);
	}
	} else {
	hdl->libzfs_max_nvlist = (SPA_MAXBLOCKSIZE * 4);
	}

	/*
	* For testing, remove some settable properties and features
	*/
	if (libzfs_envvar_is_set("ZFS_SYSFS_PROP_SUPPORT_TEST")) {
	zprop_desc_t *proptbl;

	proptbl = zpool_prop_get_table();
	proptbl[ZPOOL_PROP_COMMENT].pd_zfs_mod_supported = B_FALSE;

	proptbl = zfs_prop_get_table();
	proptbl[ZFS_PROP_DNODESIZE].pd_zfs_mod_supported = B_FALSE;

	zfeature_info_t *ftbl = spa_feature_table;
	ftbl[SPA_FEATURE_LARGE_BLOCKS].fi_zfs_mod_supported = B_FALSE;
	}

	return (hdl);
	}

	void
	libzfs_fini(libzfs_handle_t *hdl)
	{
	(void) close(hdl->libzfs_fd);
	if (hdl->libzfs_mnttab)
	#ifdef HAVE_SETMNTENT
	(void) endmntent(hdl->libzfs_mnttab);
	#else
	(void) fclose(hdl->libzfs_mnttab);
	#endif
	zpool_free_handles(hdl);
	namespace_clear(hdl);
	libzfs_mnttab_fini(hdl);
	libzfs_core_fini();
	regfree(&hdl->libzfs_urire);
	fletcher_4_fini();
	free(hdl);
	}

	libzfs_handle_t *
	zpool_get_handle(zpool_handle_t *zhp)
	{
	return (zhp->zpool_hdl);
	}

	libzfs_handle_t *
	zfs_get_handle(zfs_handle_t *zhp)
	{
	return (zhp->zfs_hdl);
	}

	zpool_handle_t *
	zfs_get_pool_handle(const zfs_handle_t *zhp)
	{
	return (zhp->zpool_hdl);
	}

	/*
	* Given a name, determine whether or not it's a valid path
	* (starts with '/' or "./"). If so, walk the mnttab trying
	* to match the device number. If not, treat the path as an
	* fs/vol/snap/bkmark name.
	*/
	zfs_handle_t *
	zfs_path_to_zhandle(libzfs_handle_t hdl, const char path, zfs_type_t argtype)
	{
	struct stat64 statbuf;
	struct extmnttab entry;

	if (path[0] != '/' && strncmp(path, "./", strlen("./")) != 0) {
	/*
	* It's not a valid path, assume it's a name of type 'argtype'.
	*/
	return (zfs_open(hdl, path, argtype));
	}

	/* Reopen MNTTAB to prevent reading stale data from open file */
	- if (freopen(MNTTAB, "r", hdl->libzfs_mnttab) == NULL)
	+ if (freopen(MNTTAB, "re", hdl->libzfs_mnttab) == NULL)
	return (NULL);

	if (getextmntent(path, &entry, &statbuf) != 0)
	return (NULL);

	if (strcmp(entry.mnt_fstype, MNTTYPE_ZFS) != 0) {
	(void) fprintf(stderr, gettext("'%s': not a ZFS filesystem\n"),
	path);
	return (NULL);
	}

	return (zfs_open(hdl, entry.mnt_special, ZFS_TYPE_FILESYSTEM));
	}

	/*
	* Initialize the zc_nvlist_dst member to prepare for receiving an nvlist from
	* an ioctl().
	*/
	int
	zcmd_alloc_dst_nvlist(libzfs_handle_t hdl, zfs_cmd_t zc, size_t len)
	{
	if (len == 0)
	len = 256 * 1024;
	zc->zc_nvlist_dst_size = len;
	zc->zc_nvlist_dst =
	(uint64_t)(uintptr_t)zfs_alloc(hdl, zc->zc_nvlist_dst_size);
	if (zc->zc_nvlist_dst == 0)
	return (-1);

	return (0);
	}

	/*
	* Called when an ioctl() which returns an nvlist fails with ENOMEM. This will
	* expand the nvlist to the size specified in 'zc_nvlist_dst_size', which was
	* filled in by the kernel to indicate the actual required size.
	*/
	int
	zcmd_expand_dst_nvlist(libzfs_handle_t hdl, zfs_cmd_t zc)
	{
	free((void *)(uintptr_t)zc->zc_nvlist_dst);
	zc->zc_nvlist_dst =
	(uint64_t)(uintptr_t)zfs_alloc(hdl, zc->zc_nvlist_dst_size);
	if (zc->zc_nvlist_dst == 0)
	return (-1);

	return (0);
	}

	/*
	* Called to free the src and dst nvlists stored in the command structure.
	*/
	void
	zcmd_free_nvlists(zfs_cmd_t *zc)
	{
	free((void *)(uintptr_t)zc->zc_nvlist_conf);
	free((void *)(uintptr_t)zc->zc_nvlist_src);
	free((void *)(uintptr_t)zc->zc_nvlist_dst);
	zc->zc_nvlist_conf = 0;
	zc->zc_nvlist_src = 0;
	zc->zc_nvlist_dst = 0;
	}

	static int
	zcmd_write_nvlist_com(libzfs_handle_t hdl, uint64_t outnv, uint64_t *outlen,
	nvlist_t *nvl)
	{
	char *packed;
	size_t len;

	verify(nvlist_size(nvl, &len, NV_ENCODE_NATIVE) == 0);

	if ((packed = zfs_alloc(hdl, len)) == NULL)
	return (-1);

	verify(nvlist_pack(nvl, &packed, &len, NV_ENCODE_NATIVE, 0) == 0);

	*outnv = (uint64_t)(uintptr_t)packed;
	*outlen = len;

	return (0);
	}

	int
	zcmd_write_conf_nvlist(libzfs_handle_t hdl, zfs_cmd_t zc, nvlist_t *nvl)
	{
	return (zcmd_write_nvlist_com(hdl, &zc->zc_nvlist_conf,
	&zc->zc_nvlist_conf_size, nvl));
	}

	int
	zcmd_write_src_nvlist(libzfs_handle_t hdl, zfs_cmd_t zc, nvlist_t *nvl)
	{
	return (zcmd_write_nvlist_com(hdl, &zc->zc_nvlist_src,
	&zc->zc_nvlist_src_size, nvl));
	}

	/*
	* Unpacks an nvlist from the ZFS ioctl command structure.
	*/
	int
	zcmd_read_dst_nvlist(libzfs_handle_t hdl, zfs_cmd_t zc, nvlist_t **nvlp)
	{
	if (nvlist_unpack((void *)(uintptr_t)zc->zc_nvlist_dst,
	zc->zc_nvlist_dst_size, nvlp, 0) != 0)
	return (no_memory(hdl));

	return (0);
	}

	/*
	* ================================================================
	* API shared by zfs and zpool property management
	* ================================================================
	*/

	static void
	zprop_print_headers(zprop_get_cbdata_t *cbp, zfs_type_t type)
	{
	zprop_list_t *pl = cbp->cb_proplist;
	int i;
	char *title;
	size_t len;

	cbp->cb_first = B_FALSE;
	if (cbp->cb_scripted)
	return;

	/*
	* Start with the length of the column headers.
	*/
	cbp->cb_colwidths[GET_COL_NAME] = strlen(dgettext(TEXT_DOMAIN, "NAME"));
	cbp->cb_colwidths[GET_COL_PROPERTY] = strlen(dgettext(TEXT_DOMAIN,
	"PROPERTY"));
	cbp->cb_colwidths[GET_COL_VALUE] = strlen(dgettext(TEXT_DOMAIN,
	"VALUE"));
	cbp->cb_colwidths[GET_COL_RECVD] = strlen(dgettext(TEXT_DOMAIN,
	"RECEIVED"));
	cbp->cb_colwidths[GET_COL_SOURCE] = strlen(dgettext(TEXT_DOMAIN,
	"SOURCE"));

	/* first property is always NAME */
	assert(cbp->cb_proplist->pl_prop ==
	((type == ZFS_TYPE_POOL) ? ZPOOL_PROP_NAME : ZFS_PROP_NAME));

	/*
	* Go through and calculate the widths for each column. For the
	* 'source' column, we kludge it up by taking the worst-case scenario of
	* inheriting from the longest name. This is acceptable because in the
	* majority of cases 'SOURCE' is the last column displayed, and we don't
	* use the width anyway. Note that the 'VALUE' column can be oversized,
	* if the name of the property is much longer than any values we find.
	*/
	for (pl = cbp->cb_proplist; pl != NULL; pl = pl->pl_next) {
	/*
	* 'PROPERTY' column
	*/
	if (pl->pl_prop != ZPROP_INVAL) {
	const char *propname = (type == ZFS_TYPE_POOL) ?
	zpool_prop_to_name(pl->pl_prop) :
	zfs_prop_to_name(pl->pl_prop);

	len = strlen(propname);
	if (len > cbp->cb_colwidths[GET_COL_PROPERTY])
	cbp->cb_colwidths[GET_COL_PROPERTY] = len;
	} else {
	len = strlen(pl->pl_user_prop);
	if (len > cbp->cb_colwidths[GET_COL_PROPERTY])
	cbp->cb_colwidths[GET_COL_PROPERTY] = len;
	}

	/*
	* 'VALUE' column. The first property is always the 'name'
	* property that was tacked on either by /sbin/zfs's
	* zfs_do_get() or when calling zprop_expand_list(), so we
	* ignore its width. If the user specified the name property
	* to display, then it will be later in the list in any case.
	*/
	if (pl != cbp->cb_proplist &&
	pl->pl_width > cbp->cb_colwidths[GET_COL_VALUE])
	cbp->cb_colwidths[GET_COL_VALUE] = pl->pl_width;

	/* 'RECEIVED' column. */
	if (pl != cbp->cb_proplist &&
	pl->pl_recvd_width > cbp->cb_colwidths[GET_COL_RECVD])
	cbp->cb_colwidths[GET_COL_RECVD] = pl->pl_recvd_width;

	/*
	* 'NAME' and 'SOURCE' columns
	*/
	if (pl->pl_prop == (type == ZFS_TYPE_POOL ? ZPOOL_PROP_NAME :
	ZFS_PROP_NAME) &&
	pl->pl_width > cbp->cb_colwidths[GET_COL_NAME]) {
	cbp->cb_colwidths[GET_COL_NAME] = pl->pl_width;
	cbp->cb_colwidths[GET_COL_SOURCE] = pl->pl_width +
	strlen(dgettext(TEXT_DOMAIN, "inherited from"));
	}
	}

	/*
	* Now go through and print the headers.
	*/
	for (i = 0; i < ZFS_GET_NCOLS; i++) {
	switch (cbp->cb_columns[i]) {
	case GET_COL_NAME:
	title = dgettext(TEXT_DOMAIN, "NAME");
	break;
	case GET_COL_PROPERTY:
	title = dgettext(TEXT_DOMAIN, "PROPERTY");
	break;
	case GET_COL_VALUE:
	title = dgettext(TEXT_DOMAIN, "VALUE");
	break;
	case GET_COL_RECVD:
	title = dgettext(TEXT_DOMAIN, "RECEIVED");
	break;
	case GET_COL_SOURCE:
	title = dgettext(TEXT_DOMAIN, "SOURCE");
	break;
	default:
	title = NULL;
	}

	if (title != NULL) {
	if (i == (ZFS_GET_NCOLS - 1) \|\|
	cbp->cb_columns[i + 1] == GET_COL_NONE)
	(void) printf("%s", title);
	else
	(void) printf("%-*s ",
	cbp->cb_colwidths[cbp->cb_columns[i]],
	title);
	}
	}
	(void) printf("\n");
	}

	/*
	* Display a single line of output, according to the settings in the callback
	* structure.
	*/
	void
	zprop_print_one_property(const char name, zprop_get_cbdata_t cbp,
	const char propname, const char value, zprop_source_t sourcetype,
	const char source, const char recvd_value)
	{
	int i;
	const char *str = NULL;
	char buf[128];

	/*
	* Ignore those source types that the user has chosen to ignore.
	*/
	if ((sourcetype & cbp->cb_sources) == 0)
	return;

	if (cbp->cb_first)
	zprop_print_headers(cbp, cbp->cb_type);

	for (i = 0; i < ZFS_GET_NCOLS; i++) {
	switch (cbp->cb_columns[i]) {
	case GET_COL_NAME:
	str = name;
	break;

	case GET_COL_PROPERTY:
	str = propname;
	break;

	case GET_COL_VALUE:
	str = value;
	break;

	case GET_COL_SOURCE:
	switch (sourcetype) {
	case ZPROP_SRC_NONE:
	str = "-";
	break;

	case ZPROP_SRC_DEFAULT:
	str = "default";
	break;

	case ZPROP_SRC_LOCAL:
	str = "local";
	break;

	case ZPROP_SRC_TEMPORARY:
	str = "temporary";
	break;

	case ZPROP_SRC_INHERITED:
	(void) snprintf(buf, sizeof (buf),
	"inherited from %s", source);
	str = buf;
	break;
	case ZPROP_SRC_RECEIVED:
	str = "received";
	break;

	default:
	str = NULL;
	assert(!"unhandled zprop_source_t");
	}
	break;

	case GET_COL_RECVD:
	str = (recvd_value == NULL ? "-" : recvd_value);
	break;

	default:
	continue;
	}

	if (i == (ZFS_GET_NCOLS - 1) \|\|
	cbp->cb_columns[i + 1] == GET_COL_NONE)
	(void) printf("%s", str);
	else if (cbp->cb_scripted)
	(void) printf("%s\t", str);
	else
	(void) printf("%-*s ",
	cbp->cb_colwidths[cbp->cb_columns[i]],
	str);
	}

	(void) printf("\n");
	}

	/*
	* Given a numeric suffix, convert the value into a number of bits that the
	* resulting value must be shifted.
	*/
	static int
	str2shift(libzfs_handle_t hdl, const char buf)
	{
	const char *ends = "BKMGTPEZ";
	int i;

	if (buf[0] == '\0')
	return (0);
	for (i = 0; i < strlen(ends); i++) {
	if (toupper(buf[0]) == ends[i])
	break;
	}
	if (i == strlen(ends)) {
	if (hdl)
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"invalid numeric suffix '%s'"), buf);
	return (-1);
	}

	/*
	* Allow 'G' = 'GB' = 'GiB', case-insensitively.
	* However, 'BB' and 'BiB' are disallowed.
	*/
	if (buf[1] == '\0' \|\|
	(toupper(buf[0]) != 'B' &&
	((toupper(buf[1]) == 'B' && buf[2] == '\0') \|\|
	(toupper(buf[1]) == 'I' && toupper(buf[2]) == 'B' &&
	buf[3] == '\0'))))
	return (10 * i);

	if (hdl)
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"invalid numeric suffix '%s'"), buf);
	return (-1);
	}

	/*
	* Convert a string of the form '100G' into a real number. Used when setting
	* properties or creating a volume. 'buf' is used to place an extended error
	* message for the caller to use.
	*/
	int
	zfs_nicestrtonum(libzfs_handle_t hdl, const char value, uint64_t *num)
	{
	char *end;
	int shift;

	*num = 0;

	/* Check to see if this looks like a number. */
	if ((value[0] < '0' \|\| value[0] > '9') && value[0] != '.') {
	if (hdl)
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"bad numeric value '%s'"), value);
	return (-1);
	}

	/* Rely on strtoull() to process the numeric portion. */
	errno = 0;
	*num = strtoull(value, &end, 10);

	/*
	* Check for ERANGE, which indicates that the value is too large to fit
	* in a 64-bit value.
	*/
	if (errno == ERANGE) {
	if (hdl)
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"numeric value is too large"));
	return (-1);
	}

	/*
	* If we have a decimal value, then do the computation with floating
	* point arithmetic. Otherwise, use standard arithmetic.
	*/
	if (*end == '.') {
	double fval = strtod(value, &end);

	if ((shift = str2shift(hdl, end)) == -1)
	return (-1);

	fval *= pow(2, shift);

	/*
	* UINT64_MAX is not exactly representable as a double.
	* The closest representation is UINT64_MAX + 1, so we
	* use a >= comparison instead of > for the bounds check.
	*/
	if (fval >= (double)UINT64_MAX) {
	if (hdl)
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"numeric value is too large"));
	return (-1);
	}

	*num = (uint64_t)fval;
	} else {
	if ((shift = str2shift(hdl, end)) == -1)
	return (-1);

	/* Check for overflow */
	if (shift >= 64 \|\| (num << shift) >> shift != num) {
	if (hdl)
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"numeric value is too large"));
	return (-1);
	}

	*num <<= shift;
	}

	return (0);
	}

	/*
	* Given a propname=value nvpair to set, parse any numeric properties
	* (index, boolean, etc) if they are specified as strings and add the
	* resulting nvpair to the returned nvlist.
	*
	* At the DSL layer, all properties are either 64-bit numbers or strings.
	* We want the user to be able to ignore this fact and specify properties
	* as native values (numbers, for example) or as strings (to simplify
	* command line utilities). This also handles converting index types
	* (compression, checksum, etc) from strings to their on-disk index.
	*/
	int
	zprop_parse_value(libzfs_handle_t hdl, nvpair_t elem, int prop,
	zfs_type_t type, nvlist_t ret, char svalp, uint64_t ivalp,
	const char *errbuf)
	{
	data_type_t datatype = nvpair_type(elem);
	zprop_type_t proptype;
	const char *propname;
	char *value;
	boolean_t isnone = B_FALSE;
	boolean_t isauto = B_FALSE;
	int err = 0;

	if (type == ZFS_TYPE_POOL) {
	proptype = zpool_prop_get_type(prop);
	propname = zpool_prop_to_name(prop);
	} else {
	proptype = zfs_prop_get_type(prop);
	propname = zfs_prop_to_name(prop);
	}

	/*
	* Convert any properties to the internal DSL value types.
	*/
	*svalp = NULL;
	*ivalp = 0;

	switch (proptype) {
	case PROP_TYPE_STRING:
	if (datatype != DATA_TYPE_STRING) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"'%s' must be a string"), nvpair_name(elem));
	goto error;
	}
	err = nvpair_value_string(elem, svalp);
	if (err != 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"'%s' is invalid"), nvpair_name(elem));
	goto error;
	}
	if (strlen(*svalp) >= ZFS_MAXPROPLEN) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"'%s' is too long"), nvpair_name(elem));
	goto error;
	}
	break;

	case PROP_TYPE_NUMBER:
	if (datatype == DATA_TYPE_STRING) {
	(void) nvpair_value_string(elem, &value);
	if (strcmp(value, "none") == 0) {
	isnone = B_TRUE;
	} else if (strcmp(value, "auto") == 0) {
	isauto = B_TRUE;
	} else if (zfs_nicestrtonum(hdl, value, ivalp) != 0) {
	goto error;
	}
	} else if (datatype == DATA_TYPE_UINT64) {
	(void) nvpair_value_uint64(elem, ivalp);
	} else {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"'%s' must be a number"), nvpair_name(elem));
	goto error;
	}

	/*
	* Quota special: force 'none' and don't allow 0.
	*/
	if ((type & ZFS_TYPE_DATASET) && *ivalp == 0 && !isnone &&
	(prop == ZFS_PROP_QUOTA \|\| prop == ZFS_PROP_REFQUOTA)) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"use 'none' to disable quota/refquota"));
	goto error;
	}

	/*
	* Special handling for "*_limit=none". In this case it's not
	* 0 but UINT64_MAX.
	*/
	if ((type & ZFS_TYPE_DATASET) && isnone &&
	(prop == ZFS_PROP_FILESYSTEM_LIMIT \|\|
	prop == ZFS_PROP_SNAPSHOT_LIMIT)) {
	*ivalp = UINT64_MAX;
	}

	/*
	* Special handling for setting 'refreservation' to 'auto'. Use
	* UINT64_MAX to tell the caller to use zfs_fix_auto_resv().
	* 'auto' is only allowed on volumes.
	*/
	if (isauto) {
	switch (prop) {
	case ZFS_PROP_REFRESERVATION:
	if ((type & ZFS_TYPE_VOLUME) == 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"'%s=auto' only allowed on "
	"volumes"), nvpair_name(elem));
	goto error;
	}
	*ivalp = UINT64_MAX;
	break;
	default:
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"'auto' is invalid value for '%s'"),
	nvpair_name(elem));
	goto error;
	}
	}

	break;

	case PROP_TYPE_INDEX:
	if (datatype != DATA_TYPE_STRING) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"'%s' must be a string"), nvpair_name(elem));
	goto error;
	}

	(void) nvpair_value_string(elem, &value);

	if (zprop_string_to_index(prop, value, ivalp, type) != 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"'%s' must be one of '%s'"), propname,
	zprop_values(prop, type));
	goto error;
	}
	break;

	default:
	abort();
	}

	/*
	* Add the result to our return set of properties.
	*/
	if (*svalp != NULL) {
	if (nvlist_add_string(ret, propname, *svalp) != 0) {
	(void) no_memory(hdl);
	return (-1);
	}
	} else {
	if (nvlist_add_uint64(ret, propname, *ivalp) != 0) {
	(void) no_memory(hdl);
	return (-1);
	}
	}

	return (0);
	error:
	(void) zfs_error(hdl, EZFS_BADPROP, errbuf);
	return (-1);
	}

	static int
	addlist(libzfs_handle_t hdl, char propname, zprop_list_t **listp,
	zfs_type_t type)
	{
	int prop;
	zprop_list_t *entry;

	prop = zprop_name_to_prop(propname, type);

	if (prop != ZPROP_INVAL && !zprop_valid_for_type(prop, type, B_FALSE))
	prop = ZPROP_INVAL;

	/*
	* When no property table entry can be found, return failure if
	* this is a pool property or if this isn't a user-defined
	* dataset property,
	*/
	if (prop == ZPROP_INVAL && ((type == ZFS_TYPE_POOL &&
	!zpool_prop_feature(propname) &&
	!zpool_prop_unsupported(propname)) \|\|
	(type == ZFS_TYPE_DATASET && !zfs_prop_user(propname) &&
	!zfs_prop_userquota(propname) && !zfs_prop_written(propname)))) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"invalid property '%s'"), propname);
	return (zfs_error(hdl, EZFS_BADPROP,
	dgettext(TEXT_DOMAIN, "bad property list")));
	}

	if ((entry = zfs_alloc(hdl, sizeof (zprop_list_t))) == NULL)
	return (-1);

	entry->pl_prop = prop;
	if (prop == ZPROP_INVAL) {
	if ((entry->pl_user_prop = zfs_strdup(hdl, propname)) ==
	NULL) {
	free(entry);
	return (-1);
	}
	entry->pl_width = strlen(propname);
	} else {
	entry->pl_width = zprop_width(prop, &entry->pl_fixed,
	type);
	}

	*listp = entry;

	return (0);
	}

	/*
	* Given a comma-separated list of properties, construct a property list
	* containing both user-defined and native properties. This function will
	* return a NULL list if 'all' is specified, which can later be expanded
	* by zprop_expand_list().
	*/
	int
	zprop_get_list(libzfs_handle_t hdl, char props, zprop_list_t **listp,
	zfs_type_t type)
	{
	*listp = NULL;

	/*
	* If 'all' is specified, return a NULL list.
	*/
	if (strcmp(props, "all") == 0)
	return (0);

	/*
	* If no props were specified, return an error.
	*/
	if (props[0] == '\0') {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"no properties specified"));
	return (zfs_error(hdl, EZFS_BADPROP, dgettext(TEXT_DOMAIN,
	"bad property list")));
	}

	/*
	* It would be nice to use getsubopt() here, but the inclusion of column
	* aliases makes this more effort than it's worth.
	*/
	while (*props != '\0') {
	size_t len;
	char *p;
	char c;

	if ((p = strchr(props, ',')) == NULL) {
	len = strlen(props);
	p = props + len;
	} else {
	len = p - props;
	}

	/*
	* Check for empty options.
	*/
	if (len == 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN,
	"empty property name"));
	return (zfs_error(hdl, EZFS_BADPROP,
	dgettext(TEXT_DOMAIN, "bad property list")));
	}

	/*
	* Check all regular property names.
	*/
	c = props[len];
	props[len] = '\0';

	if (strcmp(props, "space") == 0) {
	static char *spaceprops[] = {
	"name", "avail", "used", "usedbysnapshots",
	"usedbydataset", "usedbyrefreservation",
	"usedbychildren", NULL
	};
	int i;

	for (i = 0; spaceprops[i]; i++) {
	if (addlist(hdl, spaceprops[i], listp, type))
	return (-1);
	listp = &(*listp)->pl_next;
	}
	} else {
	if (addlist(hdl, props, listp, type))
	return (-1);
	listp = &(*listp)->pl_next;
	}

	props = p;
	if (c == ',')
	props++;
	}

	return (0);
	}

	void
	zprop_free_list(zprop_list_t *pl)
	{
	zprop_list_t *next;

	while (pl != NULL) {
	next = pl->pl_next;
	free(pl->pl_user_prop);
	free(pl);
	pl = next;
	}
	}

	typedef struct expand_data {
	zprop_list_t **last;
	libzfs_handle_t *hdl;
	zfs_type_t type;
	} expand_data_t;

	static int
	zprop_expand_list_cb(int prop, void *cb)
	{
	zprop_list_t *entry;
	expand_data_t *edp = cb;

	if ((entry = zfs_alloc(edp->hdl, sizeof (zprop_list_t))) == NULL)
	return (ZPROP_INVAL);

	entry->pl_prop = prop;
	entry->pl_width = zprop_width(prop, &entry->pl_fixed, edp->type);
	entry->pl_all = B_TRUE;

	*(edp->last) = entry;
	edp->last = &entry->pl_next;

	return (ZPROP_CONT);
	}

	int
	zprop_expand_list(libzfs_handle_t hdl, zprop_list_t *plp, zfs_type_t type)
	{
	zprop_list_t *entry;
	zprop_list_t **last;
	expand_data_t exp;

	if (*plp == NULL) {
	/*
	* If this is the very first time we've been called for an 'all'
	* specification, expand the list to include all native
	* properties.
	*/
	last = plp;

	exp.last = last;
	exp.hdl = hdl;
	exp.type = type;

	if (zprop_iter_common(zprop_expand_list_cb, &exp, B_FALSE,
	B_FALSE, type) == ZPROP_INVAL)
	return (-1);

	/*
	* Add 'name' to the beginning of the list, which is handled
	* specially.
	*/
	if ((entry = zfs_alloc(hdl, sizeof (zprop_list_t))) == NULL)
	return (-1);

	entry->pl_prop = (type == ZFS_TYPE_POOL) ? ZPOOL_PROP_NAME :
	ZFS_PROP_NAME;
	entry->pl_width = zprop_width(entry->pl_prop,
	&entry->pl_fixed, type);
	entry->pl_all = B_TRUE;
	entry->pl_next = *plp;
	*plp = entry;
	}
	return (0);
	}

	int
	zprop_iter(zprop_func func, void *cb, boolean_t show_all, boolean_t ordered,
	zfs_type_t type)
	{
	return (zprop_iter_common(func, cb, show_all, ordered, type));
	}

	/*
	* Fill given version buffer with zfs userland version
	*/
	void
	zfs_version_userland(char *version, int len)
	{
	(void) strlcpy(version, ZFS_META_ALIAS, len);
	}

	/*
	* Prints both zfs userland and kernel versions
	* Returns 0 on success, and -1 on error (with errno set)
	*/
	int
	zfs_version_print(void)
	{
	char zver_userland[128];
	char zver_kernel[128];

	zfs_version_userland(zver_userland, sizeof (zver_userland));

	(void) printf("%s\n", zver_userland);

	if (zfs_version_kernel(zver_kernel, sizeof (zver_kernel)) == -1) {
	fprintf(stderr, "zfs_version_kernel() failed: %s\n",
	strerror(errno));
	return (-1);
	}

	(void) printf("zfs-kmod-%s\n", zver_kernel);

	return (0);
	}

	/*
	* Return 1 if the user requested ANSI color output, and our terminal supports
	* it. Return 0 for no color.
	*/
	static int
	use_color(void)
	{
	static int use_color = -1;
	char *term;

	/*
	* Optimization:
	*
	* For each zpool invocation, we do a single check to see if we should
	* be using color or not, and cache that value for the lifetime of the
	* the zpool command. That makes it cheap to call use_color() when
	* we're printing with color. We assume that the settings are not going
	* to change during the invocation of a zpool command (the user isn't
	* going to change the ZFS_COLOR value while zpool is running, for
	* example).
	*/
	if (use_color != -1) {
	/*
	* We've already figured out if we should be using color or
	* not. Return the cached value.
	*/
	return (use_color);
	}

	term = getenv("TERM");
	/*
	* The user sets the ZFS_COLOR env var set to enable zpool ANSI color
	* output. However if NO_COLOR is set (https://no-color.org/) then
	* don't use it. Also, don't use color if terminal doesn't support
	* it.
	*/
	if (libzfs_envvar_is_set("ZFS_COLOR") &&
	!libzfs_envvar_is_set("NO_COLOR") &&
	isatty(STDOUT_FILENO) && term && strcmp("dumb", term) != 0 &&
	strcmp("unknown", term) != 0) {
	/* Color supported */
	use_color = 1;
	} else {
	use_color = 0;
	}

	return (use_color);
	}

	/*
	* color_start() and color_end() are used for when you want to colorize a block
	* of text. For example:
	*
	* color_start(ANSI_RED_FG)
	* printf("hello");
	* printf("world");
	* color_end();
	*/
	void
	color_start(char *color)
	{
	if (use_color())
	printf("%s", color);
	}

	void
	color_end(void)
	{
	if (use_color())
	printf(ANSI_RESET);
	}

	/* printf() with a color. If color is NULL, then do a normal printf. */
	int
	printf_color(char color, char format, ...)
	{
	va_list aptr;
	int rc;

	if (color)
	color_start(color);

	va_start(aptr, format);
	rc = vprintf(format, aptr);
	va_end(aptr);

	if (color)
	color_end();

	return (rc);
	}
	diff --git a/sys/contrib/openzfs/lib/libzfs/os/freebsd/libzfs_zmount.c b/sys/contrib/openzfs/lib/libzfs/os/freebsd/libzfs_zmount.c
	index e114b1e0ca6f..699d330ebdb4 100644
	--- a/sys/contrib/openzfs/lib/libzfs/os/freebsd/libzfs_zmount.c
	+++ b/sys/contrib/openzfs/lib/libzfs/os/freebsd/libzfs_zmount.c
	@@ -1,140 +1,135 @@
	/*
	* Copyright (c) 2006 Pawel Jakub Dawidek <pjd@FreeBSD.org>
	* 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.
	*/

	/*
	* This file implements Solaris compatible zmount() function.
	*/

	#include <sys/cdefs.h>
	__FBSDID("$FreeBSD$");

	#include <sys/param.h>
	#include <sys/mount.h>
	#include <sys/uio.h>
	#include <sys/mntent.h>
	#include <assert.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <sys/mnttab.h>
	#include <sys/errno.h>
	#include <libzfs.h>

	#include "libzfs_impl.h"

	static void
	build_iovec(struct iovec *iov, int iovlen, const char name, void val,
	size_t len)
	{
	int i;

	if (*iovlen < 0)
	return;
	i = *iovlen;
	iov = realloc(iov, sizeof (*iov) (i + 2));
	if (*iov == NULL) {
	*iovlen = -1;
	return;
	}
	(*iov)[i].iov_base = strdup(name);
	(*iov)[i].iov_len = strlen(name) + 1;
	i++;
	(*iov)[i].iov_base = val;
	if (len == (size_t)-1) {
	if (val != NULL)
	len = strlen(val) + 1;
	else
	len = 0;
	}
	(*iov)[i].iov_len = (int)len;
	*iovlen = ++i;
	}

	static int
	do_mount_(const char spec, const char dir, int mflag, char *fstype,
	char dataptr, int datalen, char optptr, int optlen)
	{
	struct iovec *iov;
	char optstr, p, *tofree;
	int iovlen, rv;

	assert(spec != NULL);
	assert(dir != NULL);
	assert(fstype != NULL);
	assert(strcmp(fstype, MNTTYPE_ZFS) == 0);
	assert(dataptr == NULL);
	assert(datalen == 0);
	assert(optptr != NULL);
	assert(optlen > 0);

	tofree = optstr = strdup(optptr);
	assert(optstr != NULL);

	iov = NULL;
	iovlen = 0;
	if (strstr(optstr, MNTOPT_REMOUNT) != NULL)
	build_iovec(&iov, &iovlen, "update", NULL, 0);
	- if (strstr(optstr, MNTOPT_NOXATTR) == NULL &&
	- strstr(optstr, MNTOPT_XATTR) == NULL &&
	- strstr(optstr, MNTOPT_SAXATTR) == NULL &&
	- strstr(optstr, MNTOPT_DIRXATTR) == NULL)
	- build_iovec(&iov, &iovlen, "xattr", NULL, 0);
	if (mflag & MS_RDONLY)
	build_iovec(&iov, &iovlen, "ro", NULL, 0);
	build_iovec(&iov, &iovlen, "fstype", fstype, (size_t)-1);
	build_iovec(&iov, &iovlen, "fspath", __DECONST(char *, dir),
	(size_t)-1);
	build_iovec(&iov, &iovlen, "from", __DECONST(char *, spec), (size_t)-1);
	while ((p = strsep(&optstr, ",/")) != NULL)
	build_iovec(&iov, &iovlen, p, NULL, (size_t)-1);
	rv = nmount(iov, iovlen, 0);
	free(tofree);
	if (rv < 0)
	return (errno);
	return (rv);
	}

	int
	do_mount(zfs_handle_t zhp, const char mntpt, char *opts, int flags)
	{

	return (do_mount_(zfs_get_name(zhp), mntpt, flags, MNTTYPE_ZFS, NULL, 0,
	opts, sizeof (mntpt)));
	}

	int
	do_unmount(const char *mntpt, int flags)
	{
	if (unmount(mntpt, flags) < 0)
	return (errno);
	return (0);
	}

	int
	zfs_mount_delegation_check(void)
	{
	return (0);
	}
	diff --git a/sys/contrib/openzfs/lib/libzfs/os/linux/libzfs_pool_os.c b/sys/contrib/openzfs/lib/libzfs/os/linux/libzfs_pool_os.c
	index e4f03aa43b4e..747b5652f7c0 100644
	--- a/sys/contrib/openzfs/lib/libzfs/os/linux/libzfs_pool_os.c
	+++ b/sys/contrib/openzfs/lib/libzfs/os/linux/libzfs_pool_os.c
	@@ -1,342 +1,342 @@
	/*
	* 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 2015 Nexenta Systems, Inc. All rights reserved.
	* Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2011, 2018 by Delphix. All rights reserved.
	* Copyright 2016 Igor Kozhukhov <ikozhukhov@gmail.com>
	* Copyright (c) 2018 Datto Inc.
	* Copyright (c) 2017 Open-E, Inc. All Rights Reserved.
	* Copyright (c) 2017, Intel Corporation.
	* Copyright (c) 2018, loli10K <ezomori.nozomu@gmail.com>
	*/

	#include <errno.h>
	#include <libintl.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <strings.h>
	#include <unistd.h>
	#include <libgen.h>
	#include <zone.h>
	#include <sys/stat.h>
	#include <sys/efi_partition.h>
	#include <sys/systeminfo.h>
	#include <sys/vtoc.h>
	#include <sys/zfs_ioctl.h>
	#include <sys/vdev_disk.h>
	#include <dlfcn.h>
	#include <libzutil.h>

	#include "zfs_namecheck.h"
	#include "zfs_prop.h"
	#include "libzfs_impl.h"
	#include "zfs_comutil.h"
	#include "zfeature_common.h"

	/*
	* If the device has being dynamically expanded then we need to relabel
	* the disk to use the new unallocated space.
	*/
	int
	zpool_relabel_disk(libzfs_handle_t hdl, const char path, const char *msg)
	{
	int fd, error;

	- if ((fd = open(path, O_RDWR\|O_DIRECT)) < 0) {
	+ if ((fd = open(path, O_RDWR\|O_DIRECT\|O_CLOEXEC)) < 0) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "cannot "
	"relabel '%s': unable to open device: %d"), path, errno);
	return (zfs_error(hdl, EZFS_OPENFAILED, msg));
	}

	/*
	* It's possible that we might encounter an error if the device
	* does not have any unallocated space left. If so, we simply
	* ignore that error and continue on.
	*/
	error = efi_use_whole_disk(fd);

	/* Flush the buffers to disk and invalidate the page cache. */
	(void) fsync(fd);
	(void) ioctl(fd, BLKFLSBUF);

	(void) close(fd);
	if (error && error != VT_ENOSPC) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "cannot "
	"relabel '%s': unable to read disk capacity"), path);
	return (zfs_error(hdl, EZFS_NOCAP, msg));
	}
	return (0);
	}

	/*
	* Read the EFI label from the config, if a label does not exist then
	* pass back the error to the caller. If the caller has passed a non-NULL
	* diskaddr argument then we set it to the starting address of the EFI
	* partition.
	*/
	static int
	read_efi_label(nvlist_t config, diskaddr_t sb)
	{
	char *path;
	int fd;
	char diskname[MAXPATHLEN];
	int err = -1;

	if (nvlist_lookup_string(config, ZPOOL_CONFIG_PATH, &path) != 0)
	return (err);

	(void) snprintf(diskname, sizeof (diskname), "%s%s", DISK_ROOT,
	strrchr(path, '/'));
	- if ((fd = open(diskname, O_RDONLY\|O_DIRECT)) >= 0) {
	+ if ((fd = open(diskname, O_RDONLY\|O_DIRECT\|O_CLOEXEC)) >= 0) {
	struct dk_gpt *vtoc;

	if ((err = efi_alloc_and_read(fd, &vtoc)) >= 0) {
	if (sb != NULL)
	*sb = vtoc->efi_parts[0].p_start;
	efi_free(vtoc);
	}
	(void) close(fd);
	}
	return (err);
	}

	/*
	* determine where a partition starts on a disk in the current
	* configuration
	*/
	static diskaddr_t
	find_start_block(nvlist_t *config)
	{
	nvlist_t **child;
	uint_t c, children;
	diskaddr_t sb = MAXOFFSET_T;
	uint64_t wholedisk;

	if (nvlist_lookup_nvlist_array(config,
	ZPOOL_CONFIG_CHILDREN, &child, &children) != 0) {
	if (nvlist_lookup_uint64(config,
	ZPOOL_CONFIG_WHOLE_DISK,
	&wholedisk) != 0 \|\| !wholedisk) {
	return (MAXOFFSET_T);
	}
	if (read_efi_label(config, &sb) < 0)
	sb = MAXOFFSET_T;
	return (sb);
	}

	for (c = 0; c < children; c++) {
	sb = find_start_block(child[c]);
	if (sb != MAXOFFSET_T) {
	return (sb);
	}
	}
	return (MAXOFFSET_T);
	}

	static int
	zpool_label_disk_check(char *path)
	{
	struct dk_gpt *vtoc;
	int fd, err;

	- if ((fd = open(path, O_RDONLY\|O_DIRECT)) < 0)
	+ if ((fd = open(path, O_RDONLY\|O_DIRECT\|O_CLOEXEC)) < 0)
	return (errno);

	if ((err = efi_alloc_and_read(fd, &vtoc)) != 0) {
	(void) close(fd);
	return (err);
	}

	if (vtoc->efi_flags & EFI_GPT_PRIMARY_CORRUPT) {
	efi_free(vtoc);
	(void) close(fd);
	return (EIDRM);
	}

	efi_free(vtoc);
	(void) close(fd);
	return (0);
	}

	/*
	* Generate a unique partition name for the ZFS member. Partitions must
	* have unique names to ensure udev will be able to create symlinks under
	* /dev/disk/by-partlabel/ for all pool members. The partition names are
	* of the form <pool>-<unique-id>.
	*/
	static void
	zpool_label_name(char *label_name, int label_size)
	{
	uint64_t id = 0;
	int fd;

	- fd = open("/dev/urandom", O_RDONLY);
	+ fd = open("/dev/urandom", O_RDONLY\|O_CLOEXEC);
	if (fd >= 0) {
	if (read(fd, &id, sizeof (id)) != sizeof (id))
	id = 0;

	close(fd);
	}

	if (id == 0)
	id = (((uint64_t)rand()) << 32) \| (uint64_t)rand();

	snprintf(label_name, label_size, "zfs-%016llx", (u_longlong_t)id);
	}

	/*
	* Label an individual disk. The name provided is the short name,
	* stripped of any leading /dev path.
	*/
	int
	zpool_label_disk(libzfs_handle_t hdl, zpool_handle_t zhp, const char *name)
	{
	char path[MAXPATHLEN];
	struct dk_gpt *vtoc;
	int rval, fd;
	size_t resv = EFI_MIN_RESV_SIZE;
	uint64_t slice_size;
	diskaddr_t start_block;
	char errbuf[1024];

	/* prepare an error message just in case */
	(void) snprintf(errbuf, sizeof (errbuf),
	dgettext(TEXT_DOMAIN, "cannot label '%s'"), name);

	if (zhp) {
	nvlist_t *nvroot;

	verify(nvlist_lookup_nvlist(zhp->zpool_config,
	ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0);

	if (zhp->zpool_start_block == 0)
	start_block = find_start_block(nvroot);
	else
	start_block = zhp->zpool_start_block;
	zhp->zpool_start_block = start_block;
	} else {
	/* new pool */
	start_block = NEW_START_BLOCK;
	}

	(void) snprintf(path, sizeof (path), "%s/%s", DISK_ROOT, name);

	- if ((fd = open(path, O_RDWR\|O_DIRECT\|O_EXCL)) < 0) {
	+ if ((fd = open(path, O_RDWR\|O_DIRECT\|O_EXCL\|O_CLOEXEC)) < 0) {
	/*
	* This shouldn't happen. We've long since verified that this
	* is a valid device.
	*/
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "cannot "
	"label '%s': unable to open device: %d"), path, errno);
	return (zfs_error(hdl, EZFS_OPENFAILED, errbuf));
	}

	if (efi_alloc_and_init(fd, EFI_NUMPAR, &vtoc) != 0) {
	/*
	* The only way this can fail is if we run out of memory, or we
	* were unable to read the disk's capacity
	*/
	if (errno == ENOMEM)
	(void) no_memory(hdl);

	(void) close(fd);
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "cannot "
	"label '%s': unable to read disk capacity"), path);

	return (zfs_error(hdl, EZFS_NOCAP, errbuf));
	}

	slice_size = vtoc->efi_last_u_lba + 1;
	slice_size -= EFI_MIN_RESV_SIZE;
	if (start_block == MAXOFFSET_T)
	start_block = NEW_START_BLOCK;
	slice_size -= start_block;
	slice_size = P2ALIGN(slice_size, PARTITION_END_ALIGNMENT);

	vtoc->efi_parts[0].p_start = start_block;
	vtoc->efi_parts[0].p_size = slice_size;

	/*
	* Why we use V_USR: V_BACKUP confuses users, and is considered
	* disposable by some EFI utilities (since EFI doesn't have a backup
	* slice). V_UNASSIGNED is supposed to be used only for zero size
	* partitions, and efi_write() will fail if we use it. V_ROOT, V_BOOT,
	* etc. were all pretty specific. V_USR is as close to reality as we
	* can get, in the absence of V_OTHER.
	*/
	vtoc->efi_parts[0].p_tag = V_USR;
	zpool_label_name(vtoc->efi_parts[0].p_name, EFI_PART_NAME_LEN);

	vtoc->efi_parts[8].p_start = slice_size + start_block;
	vtoc->efi_parts[8].p_size = resv;
	vtoc->efi_parts[8].p_tag = V_RESERVED;

	rval = efi_write(fd, vtoc);

	/* Flush the buffers to disk and invalidate the page cache. */
	(void) fsync(fd);
	(void) ioctl(fd, BLKFLSBUF);

	if (rval == 0)
	rval = efi_rescan(fd);

	/*
	* Some block drivers (like pcata) may not support EFI GPT labels.
	* Print out a helpful error message directing the user to manually
	* label the disk and give a specific slice.
	*/
	if (rval != 0) {
	(void) close(fd);
	efi_free(vtoc);

	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "try using "
	"parted(8) and then provide a specific slice: %d"), rval);
	return (zfs_error(hdl, EZFS_LABELFAILED, errbuf));
	}

	(void) close(fd);
	efi_free(vtoc);

	(void) snprintf(path, sizeof (path), "%s/%s", DISK_ROOT, name);
	(void) zfs_append_partition(path, MAXPATHLEN);

	/* Wait to udev to signal use the device has settled. */
	rval = zpool_label_disk_wait(path, DISK_LABEL_WAIT);
	if (rval) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "failed to "
	"detect device partitions on '%s': %d"), path, rval);
	return (zfs_error(hdl, EZFS_LABELFAILED, errbuf));
	}

	/* We can't be to paranoid. Read the label back and verify it. */
	(void) snprintf(path, sizeof (path), "%s/%s", DISK_ROOT, name);
	rval = zpool_label_disk_check(path);
	if (rval) {
	zfs_error_aux(hdl, dgettext(TEXT_DOMAIN, "freshly written "
	"EFI label on '%s' is damaged. Ensure\nthis device "
	"is not in use, and is functioning properly: %d"),
	path, rval);
	return (zfs_error(hdl, EZFS_LABELFAILED, errbuf));
	}
	return (0);
	}
	diff --git a/sys/contrib/openzfs/lib/libzfs/os/linux/libzfs_sendrecv_os.c b/sys/contrib/openzfs/lib/libzfs/os/linux/libzfs_sendrecv_os.c
	index eeb1f07f2dea..ac7ab95a39b6 100644
	--- a/sys/contrib/openzfs/lib/libzfs/os/linux/libzfs_sendrecv_os.c
	+++ b/sys/contrib/openzfs/lib/libzfs/os/linux/libzfs_sendrecv_os.c
	@@ -1,52 +1,52 @@
	/*
	* 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
	*/


	#include <libzfs.h>

	#include "libzfs_impl.h"

	#ifndef F_SETPIPE_SZ
	#define F_SETPIPE_SZ (F_SETLEASE + 7)
	#endif /* F_SETPIPE_SZ */

	#ifndef F_GETPIPE_SZ
	#define F_GETPIPE_SZ (F_GETLEASE + 7)
	#endif /* F_GETPIPE_SZ */

	void
	libzfs_set_pipe_max(int infd)
	{
	- FILE *procf = fopen("/proc/sys/fs/pipe-max-size", "r");
	+ FILE *procf = fopen("/proc/sys/fs/pipe-max-size", "re");

	if (procf != NULL) {
	unsigned long max_psize;
	long cur_psize;
	if (fscanf(procf, "%lu", &max_psize) > 0) {
	cur_psize = fcntl(infd, F_GETPIPE_SZ);
	if (cur_psize > 0 &&
	max_psize > (unsigned long) cur_psize)
	fcntl(infd, F_SETPIPE_SZ,
	max_psize);
	}
	fclose(procf);
	}
	}
	diff --git a/sys/contrib/openzfs/lib/libzfs/os/linux/libzfs_util_os.c b/sys/contrib/openzfs/lib/libzfs/os/linux/libzfs_util_os.c
	index 918a43f7d03d..e2482c57135a 100644
	--- a/sys/contrib/openzfs/lib/libzfs/os/linux/libzfs_util_os.c
	+++ b/sys/contrib/openzfs/lib/libzfs/os/linux/libzfs_util_os.c
	@@ -1,215 +1,215 @@
	/*
	* 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
	*/


	#include <errno.h>
	#include <fcntl.h>
	#include <libintl.h>
	#include <stdarg.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <strings.h>
	#include <unistd.h>
	#include <math.h>
	#include <sys/stat.h>
	#include <sys/mnttab.h>
	#include <sys/mntent.h>
	#include <sys/types.h>
	#include <sys/wait.h>

	#include <libzfs.h>
	#include <libzfs_core.h>

	#include "libzfs_impl.h"
	#include "zfs_prop.h"
	#include <libzutil.h>
	#include <sys/zfs_sysfs.h>

	#define ZDIFF_SHARESDIR "/.zfs/shares/"

	int
	zfs_ioctl(libzfs_handle_t hdl, int request, zfs_cmd_t zc)
	{
	return (ioctl(hdl->libzfs_fd, request, zc));
	}

	const char *
	libzfs_error_init(int error)
	{
	switch (error) {
	case ENXIO:
	return (dgettext(TEXT_DOMAIN, "The ZFS modules are not "
	"loaded.\nTry running '/sbin/modprobe zfs' as root "
	"to load them."));
	case ENOENT:
	return (dgettext(TEXT_DOMAIN, "/dev/zfs and /proc/self/mounts "
	"are required.\nTry running 'udevadm trigger' and 'mount "
	"-t proc proc /proc' as root."));
	case ENOEXEC:
	return (dgettext(TEXT_DOMAIN, "The ZFS modules cannot be "
	"auto-loaded.\nTry running '/sbin/modprobe zfs' as "
	"root to manually load them."));
	case EACCES:
	return (dgettext(TEXT_DOMAIN, "Permission denied the "
	"ZFS utilities must be run as root."));
	default:
	return (dgettext(TEXT_DOMAIN, "Failed to initialize the "
	"libzfs library."));
	}
	}

	static int
	libzfs_module_loaded(const char *module)
	{
	const char path_prefix[] = "/sys/module/";
	char path[256];

	memcpy(path, path_prefix, sizeof (path_prefix) - 1);
	strcpy(path + sizeof (path_prefix) - 1, module);

	return (access(path, F_OK) == 0);
	}

	/*
	* Verify the required ZFS_DEV device is available and optionally attempt
	* to load the ZFS modules. Under normal circumstances the modules
	* should already have been loaded by some external mechanism.
	*
	* Environment variables:
	* - ZFS_MODULE_LOADING="YES\|yes\|ON\|on" - Attempt to load modules.
	* - ZFS_MODULE_TIMEOUT="<seconds>" - Seconds to wait for ZFS_DEV
	*/
	static int
	libzfs_load_module_impl(const char *module)
	{
	char argv[4] = {"/sbin/modprobe", "-q", (char )module, (char *)0};
	char load_str, timeout_str;
	long timeout = 10; /* seconds */
	long busy_timeout = 10; /* milliseconds */
	int load = 0, fd;
	hrtime_t start;

	/* Optionally request module loading */
	if (!libzfs_module_loaded(module)) {
	load_str = getenv("ZFS_MODULE_LOADING");
	if (load_str) {
	if (!strncasecmp(load_str, "YES", strlen("YES")) \|\|
	!strncasecmp(load_str, "ON", strlen("ON")))
	load = 1;
	else
	load = 0;
	}

	if (load) {
	if (libzfs_run_process("/sbin/modprobe", argv, 0))
	return (ENOEXEC);
	}

	if (!libzfs_module_loaded(module))
	return (ENXIO);
	}

	/*
	* Device creation by udev is asynchronous and waiting may be
	* required. Busy wait for 10ms and then fall back to polling every
	* 10ms for the allowed timeout (default 10s, max 10m). This is
	* done to optimize for the common case where the device is
	* immediately available and to avoid penalizing the possible
	* case where udev is slow or unable to create the device.
	*/
	timeout_str = getenv("ZFS_MODULE_TIMEOUT");
	if (timeout_str) {
	timeout = strtol(timeout_str, NULL, 0);
	timeout = MAX(MIN(timeout, (10 * 60)), 0); /* 0 <= N <= 600 */
	}

	start = gethrtime();
	do {
	- fd = open(ZFS_DEV, O_RDWR);
	+ fd = open(ZFS_DEV, O_RDWR \| O_CLOEXEC);
	if (fd >= 0) {
	(void) close(fd);
	return (0);
	} else if (errno != ENOENT) {
	return (errno);
	} else if (NSEC2MSEC(gethrtime() - start) < busy_timeout) {
	sched_yield();
	} else {
	usleep(10 * MILLISEC);
	}
	} while (NSEC2MSEC(gethrtime() - start) < (timeout * MILLISEC));

	return (ENOENT);
	}

	int
	libzfs_load_module(void)
	{
	return (libzfs_load_module_impl(ZFS_DRIVER));
	}

	int
	find_shares_object(differ_info_t *di)
	{
	char fullpath[MAXPATHLEN];
	struct stat64 sb = { 0 };

	(void) strlcpy(fullpath, di->dsmnt, MAXPATHLEN);
	(void) strlcat(fullpath, ZDIFF_SHARESDIR, MAXPATHLEN);

	if (stat64(fullpath, &sb) != 0) {
	(void) snprintf(di->errbuf, sizeof (di->errbuf),
	dgettext(TEXT_DOMAIN, "Cannot stat %s"), fullpath);
	return (zfs_error(di->zhp->zfs_hdl, EZFS_DIFF, di->errbuf));
	}

	di->shares = (uint64_t)sb.st_ino;
	return (0);
	}

	/*
	* Fill given version buffer with zfs kernel version read from ZFS_SYSFS_DIR
	* Returns 0 on success, and -1 on error (with errno set)
	*/
	int
	zfs_version_kernel(char *version, int len)
	{
	int _errno;
	int fd;
	int rlen;

	- if ((fd = open(ZFS_SYSFS_DIR "/version", O_RDONLY)) == -1)
	+ if ((fd = open(ZFS_SYSFS_DIR "/version", O_RDONLY \| O_CLOEXEC)) == -1)
	return (-1);

	if ((rlen = read(fd, version, len)) == -1) {
	version[0] = '\0';
	_errno = errno;
	(void) close(fd);
	errno = _errno;
	return (-1);
	}

	version[rlen-1] = '\0'; /* discard '\n' */

	if (close(fd) == -1)
	return (-1);

	return (0);
	}
	diff --git a/sys/contrib/openzfs/lib/libzfs_core/libzfs_core.c b/sys/contrib/openzfs/lib/libzfs_core/libzfs_core.c
	index a3ba3b28427f..1e6bbcd561fa 100644
	--- a/sys/contrib/openzfs/lib/libzfs_core/libzfs_core.c
	+++ b/sys/contrib/openzfs/lib/libzfs_core/libzfs_core.c
	@@ -1,1640 +1,1640 @@
	/*
	* 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, 2020 by Delphix. All rights reserved.
	* Copyright (c) 2013 Steven Hartland. All rights reserved.
	* Copyright (c) 2017 Datto Inc.
	* Copyright 2017 RackTop Systems.
	* Copyright (c) 2017 Open-E, Inc. All Rights Reserved.
	* Copyright (c) 2019, 2020 by Christian Schwarz. All rights reserved.
	*/

	/*
	* LibZFS_Core (lzc) is intended to replace most functionality in libzfs.
	* It has the following characteristics:
	*
	* - Thread Safe. libzfs_core is accessible concurrently from multiple
	* threads. This is accomplished primarily by avoiding global data
	* (e.g. caching). Since it's thread-safe, there is no reason for a
	* process to have multiple libzfs "instances". Therefore, we store
	* our few pieces of data (e.g. the file descriptor) in global
	* variables. The fd is reference-counted so that the libzfs_core
	* library can be "initialized" multiple times (e.g. by different
	* consumers within the same process).
	*
	* - Committed Interface. The libzfs_core interface will be committed,
	* therefore consumers can compile against it and be confident that
	* their code will continue to work on future releases of this code.
	* Currently, the interface is Evolving (not Committed), but we intend
	* to commit to it once it is more complete and we determine that it
	* meets the needs of all consumers.
	*
	* - Programmatic Error Handling. libzfs_core communicates errors with
	* defined error numbers, and doesn't print anything to stdout/stderr.
	*
	* - Thin Layer. libzfs_core is a thin layer, marshaling arguments
	* to/from the kernel ioctls. There is generally a 1:1 correspondence
	* between libzfs_core functions and ioctls to ZFS_DEV.
	*
	* - Clear Atomicity. Because libzfs_core functions are generally 1:1
	* with kernel ioctls, and kernel ioctls are general atomic, each
	* libzfs_core function is atomic. For example, creating multiple
	* snapshots with a single call to lzc_snapshot() is atomic -- it
	* can't fail with only some of the requested snapshots created, even
	* in the event of power loss or system crash.
	*
	* - Continued libzfs Support. Some higher-level operations (e.g.
	* support for "zfs send -R") are too complicated to fit the scope of
	* libzfs_core. This functionality will continue to live in libzfs.
	* Where appropriate, libzfs will use the underlying atomic operations
	* of libzfs_core. For example, libzfs may implement "zfs send -R \|
	* zfs receive" by using individual "send one snapshot", rename,
	* destroy, and "receive one snapshot" operations in libzfs_core.
	* /sbin/zfs and /sbin/zpool will link with both libzfs and
	* libzfs_core. Other consumers should aim to use only libzfs_core,
	* since that will be the supported, stable interface going forwards.
	*/

	#include <libzfs_core.h>
	#include <ctype.h>
	#include <unistd.h>
	#include <stdlib.h>
	#include <string.h>
	#ifdef ZFS_DEBUG
	#include <stdio.h>
	#endif
	#include <errno.h>
	#include <fcntl.h>
	#include <pthread.h>
	#include <libzutil.h>
	#include <sys/nvpair.h>
	#include <sys/param.h>
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <sys/zfs_ioctl.h>

	static int g_fd = -1;
	static pthread_mutex_t g_lock = PTHREAD_MUTEX_INITIALIZER;
	static int g_refcount;

	#ifdef ZFS_DEBUG
	static zfs_ioc_t fail_ioc_cmd = ZFS_IOC_LAST;
	static zfs_errno_t fail_ioc_err;

	static void
	libzfs_core_debug_ioc(void)
	{
	/*
	* To test running newer user space binaries with kernel's
	* that don't yet support an ioctl or a new ioctl arg we
	* provide an override to intentionally fail an ioctl.
	*
	* USAGE:
	* The override variable, ZFS_IOC_TEST, is of the form "cmd:err"
	*
	* For example, to fail a ZFS_IOC_POOL_CHECKPOINT with a
	* ZFS_ERR_IOC_CMD_UNAVAIL, the string would be "0x5a4d:1029"
	*
	* $ sudo sh -c "ZFS_IOC_TEST=0x5a4d:1029 zpool checkpoint tank"
	* cannot checkpoint 'tank': the loaded zfs module does not support
	* this operation. A reboot may be required to enable this operation.
	*/
	if (fail_ioc_cmd == ZFS_IOC_LAST) {
	char *ioc_test = getenv("ZFS_IOC_TEST");
	unsigned int ioc_num = 0, ioc_err = 0;

	if (ioc_test != NULL &&
	sscanf(ioc_test, "%i:%i", &ioc_num, &ioc_err) == 2 &&
	ioc_num < ZFS_IOC_LAST) {
	fail_ioc_cmd = ioc_num;
	fail_ioc_err = ioc_err;
	}
	}
	}
	#endif

	int
	libzfs_core_init(void)
	{
	(void) pthread_mutex_lock(&g_lock);
	if (g_refcount == 0) {
	- g_fd = open(ZFS_DEV, O_RDWR);
	+ g_fd = open(ZFS_DEV, O_RDWR\|O_CLOEXEC);
	if (g_fd < 0) {
	(void) pthread_mutex_unlock(&g_lock);
	return (errno);
	}
	}
	g_refcount++;

	#ifdef ZFS_DEBUG
	libzfs_core_debug_ioc();
	#endif
	(void) pthread_mutex_unlock(&g_lock);
	return (0);
	}

	void
	libzfs_core_fini(void)
	{
	(void) pthread_mutex_lock(&g_lock);
	ASSERT3S(g_refcount, >, 0);

	if (g_refcount > 0)
	g_refcount--;

	if (g_refcount == 0 && g_fd != -1) {
	(void) close(g_fd);
	g_fd = -1;
	}
	(void) pthread_mutex_unlock(&g_lock);
	}

	static int
	lzc_ioctl(zfs_ioc_t ioc, const char *name,
	nvlist_t source, nvlist_t *resultp)
	{
	zfs_cmd_t zc = {"\0"};
	int error = 0;
	char *packed = NULL;
	size_t size = 0;

	ASSERT3S(g_refcount, >, 0);
	VERIFY3S(g_fd, !=, -1);

	#ifdef ZFS_DEBUG
	if (ioc == fail_ioc_cmd)
	return (fail_ioc_err);
	#endif

	if (name != NULL)
	(void) strlcpy(zc.zc_name, name, sizeof (zc.zc_name));

	if (source != NULL) {
	packed = fnvlist_pack(source, &size);
	zc.zc_nvlist_src = (uint64_t)(uintptr_t)packed;
	zc.zc_nvlist_src_size = size;
	}

	if (resultp != NULL) {
	*resultp = NULL;
	if (ioc == ZFS_IOC_CHANNEL_PROGRAM) {
	zc.zc_nvlist_dst_size = fnvlist_lookup_uint64(source,
	ZCP_ARG_MEMLIMIT);
	} else {
	zc.zc_nvlist_dst_size = MAX(size * 2, 128 * 1024);
	}
	zc.zc_nvlist_dst = (uint64_t)(uintptr_t)
	malloc(zc.zc_nvlist_dst_size);
	if (zc.zc_nvlist_dst == (uint64_t)0) {
	error = ENOMEM;
	goto out;
	}
	}

	while (zfs_ioctl_fd(g_fd, ioc, &zc) != 0) {
	/*
	* If ioctl exited with ENOMEM, we retry the ioctl after
	* increasing the size of the destination nvlist.
	*
	* Channel programs that exit with ENOMEM ran over the
	* lua memory sandbox; they should not be retried.
	*/
	if (errno == ENOMEM && resultp != NULL &&
	ioc != ZFS_IOC_CHANNEL_PROGRAM) {
	free((void *)(uintptr_t)zc.zc_nvlist_dst);
	zc.zc_nvlist_dst_size *= 2;
	zc.zc_nvlist_dst = (uint64_t)(uintptr_t)
	malloc(zc.zc_nvlist_dst_size);
	if (zc.zc_nvlist_dst == (uint64_t)0) {
	error = ENOMEM;
	goto out;
	}
	} else {
	error = errno;
	break;
	}
	}
	if (zc.zc_nvlist_dst_filled) {
	resultp = fnvlist_unpack((void )(uintptr_t)zc.zc_nvlist_dst,
	zc.zc_nvlist_dst_size);
	}

	out:
	if (packed != NULL)
	fnvlist_pack_free(packed, size);
	free((void *)(uintptr_t)zc.zc_nvlist_dst);
	return (error);
	}

	int
	lzc_create(const char fsname, enum lzc_dataset_type type, nvlist_t props,
	uint8_t *wkeydata, uint_t wkeylen)
	{
	int error;
	nvlist_t *hidden_args = NULL;
	nvlist_t *args = fnvlist_alloc();

	fnvlist_add_int32(args, "type", (dmu_objset_type_t)type);
	if (props != NULL)
	fnvlist_add_nvlist(args, "props", props);

	if (wkeydata != NULL) {
	hidden_args = fnvlist_alloc();
	fnvlist_add_uint8_array(hidden_args, "wkeydata", wkeydata,
	wkeylen);
	fnvlist_add_nvlist(args, ZPOOL_HIDDEN_ARGS, hidden_args);
	}

	error = lzc_ioctl(ZFS_IOC_CREATE, fsname, args, NULL);
	nvlist_free(hidden_args);
	nvlist_free(args);
	return (error);
	}

	int
	lzc_clone(const char fsname, const char origin, nvlist_t *props)
	{
	int error;
	nvlist_t *hidden_args = NULL;
	nvlist_t *args = fnvlist_alloc();

	fnvlist_add_string(args, "origin", origin);
	if (props != NULL)
	fnvlist_add_nvlist(args, "props", props);
	error = lzc_ioctl(ZFS_IOC_CLONE, fsname, args, NULL);
	nvlist_free(hidden_args);
	nvlist_free(args);
	return (error);
	}

	int
	lzc_promote(const char fsname, char snapnamebuf, int snapnamelen)
	{
	/*
	* The promote ioctl is still legacy, so we need to construct our
	* own zfs_cmd_t rather than using lzc_ioctl().
	*/
	zfs_cmd_t zc = {"\0"};

	ASSERT3S(g_refcount, >, 0);
	VERIFY3S(g_fd, !=, -1);

	(void) strlcpy(zc.zc_name, fsname, sizeof (zc.zc_name));
	if (zfs_ioctl_fd(g_fd, ZFS_IOC_PROMOTE, &zc) != 0) {
	int error = errno;
	if (error == EEXIST && snapnamebuf != NULL)
	(void) strlcpy(snapnamebuf, zc.zc_string, snapnamelen);
	return (error);
	}
	return (0);
	}

	int
	lzc_rename(const char source, const char target)
	{
	zfs_cmd_t zc = {"\0"};
	int error;

	ASSERT3S(g_refcount, >, 0);
	VERIFY3S(g_fd, !=, -1);
	(void) strlcpy(zc.zc_name, source, sizeof (zc.zc_name));
	(void) strlcpy(zc.zc_value, target, sizeof (zc.zc_value));
	error = zfs_ioctl_fd(g_fd, ZFS_IOC_RENAME, &zc);
	if (error != 0)
	error = errno;
	return (error);
	}
	int
	lzc_destroy(const char *fsname)
	{
	int error;
	nvlist_t *args = fnvlist_alloc();
	error = lzc_ioctl(ZFS_IOC_DESTROY, fsname, args, NULL);
	nvlist_free(args);
	return (error);
	}

	/*
	* Creates snapshots.
	*
	* The keys in the snaps nvlist are the snapshots to be created.
	* They must all be in the same pool.
	*
	* The props nvlist is properties to set. Currently only user properties
	* are supported. { user:prop_name -> string value }
	*
	* The returned results nvlist will have an entry for each snapshot that failed.
	* The value will be the (int32) error code.
	*
	* The return value will be 0 if all snapshots were created, otherwise it will
	* be the errno of a (unspecified) snapshot that failed.
	*/
	int
	lzc_snapshot(nvlist_t snaps, nvlist_t props, nvlist_t **errlist)
	{
	nvpair_t *elem;
	nvlist_t *args;
	int error;
	char pool[ZFS_MAX_DATASET_NAME_LEN];

	*errlist = NULL;

	/* determine the pool name */
	elem = nvlist_next_nvpair(snaps, NULL);
	if (elem == NULL)
	return (0);
	(void) strlcpy(pool, nvpair_name(elem), sizeof (pool));
	pool[strcspn(pool, "/@")] = '\0';

	args = fnvlist_alloc();
	fnvlist_add_nvlist(args, "snaps", snaps);
	if (props != NULL)
	fnvlist_add_nvlist(args, "props", props);

	error = lzc_ioctl(ZFS_IOC_SNAPSHOT, pool, args, errlist);
	nvlist_free(args);

	return (error);
	}

	/*
	* Destroys snapshots.
	*
	* The keys in the snaps nvlist are the snapshots to be destroyed.
	* They must all be in the same pool.
	*
	* Snapshots that do not exist will be silently ignored.
	*
	* If 'defer' is not set, and a snapshot has user holds or clones, the
	* destroy operation will fail and none of the snapshots will be
	* destroyed.
	*
	* If 'defer' is set, and a snapshot has user holds or clones, it will be
	* marked for deferred destruction, and will be destroyed when the last hold
	* or clone is removed/destroyed.
	*
	* The return value will be 0 if all snapshots were destroyed (or marked for
	* later destruction if 'defer' is set) or didn't exist to begin with.
	*
	* Otherwise the return value will be the errno of a (unspecified) snapshot
	* that failed, no snapshots will be destroyed, and the errlist will have an
	* entry for each snapshot that failed. The value in the errlist will be
	* the (int32) error code.
	*/
	int
	lzc_destroy_snaps(nvlist_t snaps, boolean_t defer, nvlist_t *errlist)
	{
	nvpair_t *elem;
	nvlist_t *args;
	int error;
	char pool[ZFS_MAX_DATASET_NAME_LEN];

	/* determine the pool name */
	elem = nvlist_next_nvpair(snaps, NULL);
	if (elem == NULL)
	return (0);
	(void) strlcpy(pool, nvpair_name(elem), sizeof (pool));
	pool[strcspn(pool, "/@")] = '\0';

	args = fnvlist_alloc();
	fnvlist_add_nvlist(args, "snaps", snaps);
	if (defer)
	fnvlist_add_boolean(args, "defer");

	error = lzc_ioctl(ZFS_IOC_DESTROY_SNAPS, pool, args, errlist);
	nvlist_free(args);

	return (error);
	}

	int
	lzc_snaprange_space(const char firstsnap, const char lastsnap,
	uint64_t *usedp)
	{
	nvlist_t *args;
	nvlist_t *result;
	int err;
	char fs[ZFS_MAX_DATASET_NAME_LEN];
	char *atp;

	/* determine the fs name */
	(void) strlcpy(fs, firstsnap, sizeof (fs));
	atp = strchr(fs, '@');
	if (atp == NULL)
	return (EINVAL);
	*atp = '\0';

	args = fnvlist_alloc();
	fnvlist_add_string(args, "firstsnap", firstsnap);

	err = lzc_ioctl(ZFS_IOC_SPACE_SNAPS, lastsnap, args, &result);
	nvlist_free(args);
	if (err == 0)
	*usedp = fnvlist_lookup_uint64(result, "used");
	fnvlist_free(result);

	return (err);
	}

	boolean_t
	lzc_exists(const char *dataset)
	{
	/*
	* The objset_stats ioctl is still legacy, so we need to construct our
	* own zfs_cmd_t rather than using lzc_ioctl().
	*/
	zfs_cmd_t zc = {"\0"};

	ASSERT3S(g_refcount, >, 0);
	VERIFY3S(g_fd, !=, -1);

	(void) strlcpy(zc.zc_name, dataset, sizeof (zc.zc_name));
	return (zfs_ioctl_fd(g_fd, ZFS_IOC_OBJSET_STATS, &zc) == 0);
	}

	/*
	* outnvl is unused.
	* It was added to preserve the function signature in case it is
	* needed in the future.
	*/
	/ARGSUSED/
	int
	lzc_sync(const char pool_name, nvlist_t innvl, nvlist_t **outnvl)
	{
	return (lzc_ioctl(ZFS_IOC_POOL_SYNC, pool_name, innvl, NULL));
	}

	/*
	* Create "user holds" on snapshots. If there is a hold on a snapshot,
	* the snapshot can not be destroyed. (However, it can be marked for deletion
	* by lzc_destroy_snaps(defer=B_TRUE).)
	*
	* The keys in the nvlist are snapshot names.
	* The snapshots must all be in the same pool.
	* The value is the name of the hold (string type).
	*
	* If cleanup_fd is not -1, it must be the result of open(ZFS_DEV, O_EXCL).
	* In this case, when the cleanup_fd is closed (including on process
	* termination), the holds will be released. If the system is shut down
	* uncleanly, the holds will be released when the pool is next opened
	* or imported.
	*
	* Holds for snapshots which don't exist will be skipped and have an entry
	* added to errlist, but will not cause an overall failure.
	*
	* The return value will be 0 if all holds, for snapshots that existed,
	* were successfully created.
	*
	* Otherwise the return value will be the errno of a (unspecified) hold that
	* failed and no holds will be created.
	*
	* In all cases the errlist will have an entry for each hold that failed
	* (name = snapshot), with its value being the error code (int32).
	*/
	int
	lzc_hold(nvlist_t holds, int cleanup_fd, nvlist_t *errlist)
	{
	char pool[ZFS_MAX_DATASET_NAME_LEN];
	nvlist_t *args;
	nvpair_t *elem;
	int error;

	/* determine the pool name */
	elem = nvlist_next_nvpair(holds, NULL);
	if (elem == NULL)
	return (0);
	(void) strlcpy(pool, nvpair_name(elem), sizeof (pool));
	pool[strcspn(pool, "/@")] = '\0';

	args = fnvlist_alloc();
	fnvlist_add_nvlist(args, "holds", holds);
	if (cleanup_fd != -1)
	fnvlist_add_int32(args, "cleanup_fd", cleanup_fd);

	error = lzc_ioctl(ZFS_IOC_HOLD, pool, args, errlist);
	nvlist_free(args);
	return (error);
	}

	/*
	* Release "user holds" on snapshots. If the snapshot has been marked for
	* deferred destroy (by lzc_destroy_snaps(defer=B_TRUE)), it does not have
	* any clones, and all the user holds are removed, then the snapshot will be
	* destroyed.
	*
	* The keys in the nvlist are snapshot names.
	* The snapshots must all be in the same pool.
	* The value is an nvlist whose keys are the holds to remove.
	*
	* Holds which failed to release because they didn't exist will have an entry
	* added to errlist, but will not cause an overall failure.
	*
	* The return value will be 0 if the nvl holds was empty or all holds that
	* existed, were successfully removed.
	*
	* Otherwise the return value will be the errno of a (unspecified) hold that
	* failed to release and no holds will be released.
	*
	* In all cases the errlist will have an entry for each hold that failed to
	* to release.
	*/
	int
	lzc_release(nvlist_t holds, nvlist_t *errlist)
	{
	char pool[ZFS_MAX_DATASET_NAME_LEN];
	nvpair_t *elem;

	/* determine the pool name */
	elem = nvlist_next_nvpair(holds, NULL);
	if (elem == NULL)
	return (0);
	(void) strlcpy(pool, nvpair_name(elem), sizeof (pool));
	pool[strcspn(pool, "/@")] = '\0';

	return (lzc_ioctl(ZFS_IOC_RELEASE, pool, holds, errlist));
	}

	/*
	* Retrieve list of user holds on the specified snapshot.
	*
	* On success, *holdsp will be set to an nvlist which the caller must free.
	* The keys are the names of the holds, and the value is the creation time
	* of the hold (uint64) in seconds since the epoch.
	*/
	int
	lzc_get_holds(const char snapname, nvlist_t *holdsp)
	{
	return (lzc_ioctl(ZFS_IOC_GET_HOLDS, snapname, NULL, holdsp));
	}

	/*
	* Generate a zfs send stream for the specified snapshot and write it to
	* the specified file descriptor.
	*
	* "snapname" is the full name of the snapshot to send (e.g. "pool/fs@snap")
	*
	* If "from" is NULL, a full (non-incremental) stream will be sent.
	* If "from" is non-NULL, it must be the full name of a snapshot or
	* bookmark to send an incremental from (e.g. "pool/fs@earlier_snap" or
	* "pool/fs#earlier_bmark"). If non-NULL, the specified snapshot or
	* bookmark must represent an earlier point in the history of "snapname").
	* It can be an earlier snapshot in the same filesystem or zvol as "snapname",
	* or it can be the origin of "snapname"'s filesystem, or an earlier
	* snapshot in the origin, etc.
	*
	* "fd" is the file descriptor to write the send stream to.
	*
	* If "flags" contains LZC_SEND_FLAG_LARGE_BLOCK, the stream is permitted
	* to contain DRR_WRITE records with drr_length > 128K, and DRR_OBJECT
	* records with drr_blksz > 128K.
	*
	* If "flags" contains LZC_SEND_FLAG_EMBED_DATA, the stream is permitted
	* to contain DRR_WRITE_EMBEDDED records with drr_etype==BP_EMBEDDED_TYPE_DATA,
	* which the receiving system must support (as indicated by support
	* for the "embedded_data" feature).
	*
	* If "flags" contains LZC_SEND_FLAG_COMPRESS, the stream is generated by using
	* compressed WRITE records for blocks which are compressed on disk and in
	* memory. If the lz4_compress feature is active on the sending system, then
	* the receiving system must have that feature enabled as well.
	*
	* If "flags" contains LZC_SEND_FLAG_RAW, the stream is generated, for encrypted
	* datasets, by sending data exactly as it exists on disk. This allows backups
	* to be taken even if encryption keys are not currently loaded.
	*/
	int
	lzc_send(const char snapname, const char from, int fd,
	enum lzc_send_flags flags)
	{
	return (lzc_send_resume_redacted(snapname, from, fd, flags, 0, 0,
	NULL));
	}

	int
	lzc_send_redacted(const char snapname, const char from, int fd,
	enum lzc_send_flags flags, const char *redactbook)
	{
	return (lzc_send_resume_redacted(snapname, from, fd, flags, 0, 0,
	redactbook));
	}

	int
	lzc_send_resume(const char snapname, const char from, int fd,
	enum lzc_send_flags flags, uint64_t resumeobj, uint64_t resumeoff)
	{
	return (lzc_send_resume_redacted(snapname, from, fd, flags, resumeobj,
	resumeoff, NULL));
	}

	/*
	* snapname: The name of the "tosnap", or the snapshot whose contents we are
	* sending.
	* from: The name of the "fromsnap", or the incremental source.
	* fd: File descriptor to write the stream to.
	* flags: flags that determine features to be used by the stream.
	* resumeobj: Object to resume from, for resuming send
	* resumeoff: Offset to resume from, for resuming send.
	* redactnv: nvlist of string -> boolean(ignored) containing the names of all
	* the snapshots that we should redact with respect to.
	* redactbook: Name of the redaction bookmark to create.
	*/
	int
	lzc_send_resume_redacted(const char snapname, const char from, int fd,
	enum lzc_send_flags flags, uint64_t resumeobj, uint64_t resumeoff,
	const char *redactbook)
	{
	nvlist_t *args;
	int err;

	args = fnvlist_alloc();
	fnvlist_add_int32(args, "fd", fd);
	if (from != NULL)
	fnvlist_add_string(args, "fromsnap", from);
	if (flags & LZC_SEND_FLAG_LARGE_BLOCK)
	fnvlist_add_boolean(args, "largeblockok");
	if (flags & LZC_SEND_FLAG_EMBED_DATA)
	fnvlist_add_boolean(args, "embedok");
	if (flags & LZC_SEND_FLAG_COMPRESS)
	fnvlist_add_boolean(args, "compressok");
	if (flags & LZC_SEND_FLAG_RAW)
	fnvlist_add_boolean(args, "rawok");
	if (flags & LZC_SEND_FLAG_SAVED)
	fnvlist_add_boolean(args, "savedok");
	if (resumeobj != 0 \|\| resumeoff != 0) {
	fnvlist_add_uint64(args, "resume_object", resumeobj);
	fnvlist_add_uint64(args, "resume_offset", resumeoff);
	}
	if (redactbook != NULL)
	fnvlist_add_string(args, "redactbook", redactbook);

	err = lzc_ioctl(ZFS_IOC_SEND_NEW, snapname, args, NULL);
	nvlist_free(args);
	return (err);
	}

	/*
	* "from" can be NULL, a snapshot, or a bookmark.
	*
	* If from is NULL, a full (non-incremental) stream will be estimated. This
	* is calculated very efficiently.
	*
	* If from is a snapshot, lzc_send_space uses the deadlists attached to
	* each snapshot to efficiently estimate the stream size.
	*
	* If from is a bookmark, the indirect blocks in the destination snapshot
	* are traversed, looking for blocks with a birth time since the creation TXG of
	* the snapshot this bookmark was created from. This will result in
	* significantly more I/O and be less efficient than a send space estimation on
	* an equivalent snapshot. This process is also used if redact_snaps is
	* non-null.
	*/
	int
	lzc_send_space_resume_redacted(const char snapname, const char from,
	enum lzc_send_flags flags, uint64_t resumeobj, uint64_t resumeoff,
	uint64_t resume_bytes, const char redactbook, int fd, uint64_t spacep)
	{
	nvlist_t *args;
	nvlist_t *result;
	int err;

	args = fnvlist_alloc();
	if (from != NULL)
	fnvlist_add_string(args, "from", from);
	if (flags & LZC_SEND_FLAG_LARGE_BLOCK)
	fnvlist_add_boolean(args, "largeblockok");
	if (flags & LZC_SEND_FLAG_EMBED_DATA)
	fnvlist_add_boolean(args, "embedok");
	if (flags & LZC_SEND_FLAG_COMPRESS)
	fnvlist_add_boolean(args, "compressok");
	if (flags & LZC_SEND_FLAG_RAW)
	fnvlist_add_boolean(args, "rawok");
	if (resumeobj != 0 \|\| resumeoff != 0) {
	fnvlist_add_uint64(args, "resume_object", resumeobj);
	fnvlist_add_uint64(args, "resume_offset", resumeoff);
	fnvlist_add_uint64(args, "bytes", resume_bytes);
	}
	if (redactbook != NULL)
	fnvlist_add_string(args, "redactbook", redactbook);
	if (fd != -1)
	fnvlist_add_int32(args, "fd", fd);

	err = lzc_ioctl(ZFS_IOC_SEND_SPACE, snapname, args, &result);
	nvlist_free(args);
	if (err == 0)
	*spacep = fnvlist_lookup_uint64(result, "space");
	nvlist_free(result);
	return (err);
	}

	int
	lzc_send_space(const char snapname, const char from,
	enum lzc_send_flags flags, uint64_t *spacep)
	{
	return (lzc_send_space_resume_redacted(snapname, from, flags, 0, 0, 0,
	NULL, -1, spacep));
	}

	static int
	recv_read(int fd, void *buf, int ilen)
	{
	char *cp = buf;
	int rv;
	int len = ilen;

	do {
	rv = read(fd, cp, len);
	cp += rv;
	len -= rv;
	} while (rv > 0);

	if (rv < 0 \|\| len != 0)
	return (EIO);

	return (0);
	}

	/*
	* Linux adds ZFS_IOC_RECV_NEW for resumable and raw streams and preserves the
	* legacy ZFS_IOC_RECV user/kernel interface. The new interface supports all
	* stream options but is currently only used for resumable streams. This way
	* updated user space utilities will interoperate with older kernel modules.
	*
	* Non-Linux OpenZFS platforms have opted to modify the legacy interface.
	*/
	static int
	recv_impl(const char snapname, nvlist_t recvdprops, nvlist_t *localprops,
	uint8_t wkeydata, uint_t wkeylen, const char origin, boolean_t force,
	boolean_t resumable, boolean_t raw, int input_fd,
	const dmu_replay_record_t begin_record, uint64_t read_bytes,
	uint64_t errflags, nvlist_t *errors)
	{
	dmu_replay_record_t drr;
	char fsname[MAXPATHLEN];
	char *atp;
	int error;
	boolean_t payload = B_FALSE;

	ASSERT3S(g_refcount, >, 0);
	VERIFY3S(g_fd, !=, -1);

	/* Set 'fsname' to the name of containing filesystem */
	(void) strlcpy(fsname, snapname, sizeof (fsname));
	atp = strchr(fsname, '@');
	if (atp == NULL)
	return (EINVAL);
	*atp = '\0';

	/* If the fs does not exist, try its parent. */
	if (!lzc_exists(fsname)) {
	char *slashp = strrchr(fsname, '/');
	if (slashp == NULL)
	return (ENOENT);
	*slashp = '\0';
	}

	/*
	* The begin_record is normally a non-byteswapped BEGIN record.
	* For resumable streams it may be set to any non-byteswapped
	* dmu_replay_record_t.
	*/
	if (begin_record == NULL) {
	error = recv_read(input_fd, &drr, sizeof (drr));
	if (error != 0)
	return (error);
	} else {
	drr = *begin_record;
	payload = (begin_record->drr_payloadlen != 0);
	}

	/*
	* All receives with a payload should use the new interface.
	*/
	if (resumable \|\| raw \|\| wkeydata != NULL \|\| payload) {
	nvlist_t *outnvl = NULL;
	nvlist_t *innvl = fnvlist_alloc();

	fnvlist_add_string(innvl, "snapname", snapname);

	if (recvdprops != NULL)
	fnvlist_add_nvlist(innvl, "props", recvdprops);

	if (localprops != NULL)
	fnvlist_add_nvlist(innvl, "localprops", localprops);

	if (wkeydata != NULL) {
	/*
	* wkeydata must be placed in the special
	* ZPOOL_HIDDEN_ARGS nvlist so that it
	* will not be printed to the zpool history.
	*/
	nvlist_t *hidden_args = fnvlist_alloc();
	fnvlist_add_uint8_array(hidden_args, "wkeydata",
	wkeydata, wkeylen);
	fnvlist_add_nvlist(innvl, ZPOOL_HIDDEN_ARGS,
	hidden_args);
	nvlist_free(hidden_args);
	}

	if (origin != NULL && strlen(origin))
	fnvlist_add_string(innvl, "origin", origin);

	fnvlist_add_byte_array(innvl, "begin_record",
	(uchar_t *)&drr, sizeof (drr));

	fnvlist_add_int32(innvl, "input_fd", input_fd);

	if (force)
	fnvlist_add_boolean(innvl, "force");

	if (resumable)
	fnvlist_add_boolean(innvl, "resumable");


	error = lzc_ioctl(ZFS_IOC_RECV_NEW, fsname, innvl, &outnvl);

	if (error == 0 && read_bytes != NULL)
	error = nvlist_lookup_uint64(outnvl, "read_bytes",
	read_bytes);

	if (error == 0 && errflags != NULL)
	error = nvlist_lookup_uint64(outnvl, "error_flags",
	errflags);

	if (error == 0 && errors != NULL) {
	nvlist_t *nvl;
	error = nvlist_lookup_nvlist(outnvl, "errors", &nvl);
	if (error == 0)
	*errors = fnvlist_dup(nvl);
	}

	fnvlist_free(innvl);
	fnvlist_free(outnvl);
	} else {
	zfs_cmd_t zc = {"\0"};
	char *packed = NULL;
	size_t size;

	ASSERT3S(g_refcount, >, 0);

	(void) strlcpy(zc.zc_name, fsname, sizeof (zc.zc_name));
	(void) strlcpy(zc.zc_value, snapname, sizeof (zc.zc_value));

	if (recvdprops != NULL) {
	packed = fnvlist_pack(recvdprops, &size);
	zc.zc_nvlist_src = (uint64_t)(uintptr_t)packed;
	zc.zc_nvlist_src_size = size;
	}

	if (localprops != NULL) {
	packed = fnvlist_pack(localprops, &size);
	zc.zc_nvlist_conf = (uint64_t)(uintptr_t)packed;
	zc.zc_nvlist_conf_size = size;
	}

	if (origin != NULL)
	(void) strlcpy(zc.zc_string, origin,
	sizeof (zc.zc_string));

	ASSERT3S(drr.drr_type, ==, DRR_BEGIN);
	zc.zc_begin_record = drr.drr_u.drr_begin;
	zc.zc_guid = force;
	zc.zc_cookie = input_fd;
	zc.zc_cleanup_fd = -1;
	zc.zc_action_handle = 0;

	zc.zc_nvlist_dst_size = 128 * 1024;
	zc.zc_nvlist_dst = (uint64_t)(uintptr_t)
	malloc(zc.zc_nvlist_dst_size);

	error = zfs_ioctl_fd(g_fd, ZFS_IOC_RECV, &zc);
	if (error != 0) {
	error = errno;
	} else {
	if (read_bytes != NULL)
	*read_bytes = zc.zc_cookie;

	if (errflags != NULL)
	*errflags = zc.zc_obj;

	if (errors != NULL)
	VERIFY0(nvlist_unpack(
	(void *)(uintptr_t)zc.zc_nvlist_dst,
	zc.zc_nvlist_dst_size, errors, KM_SLEEP));
	}

	if (packed != NULL)
	fnvlist_pack_free(packed, size);
	free((void *)(uintptr_t)zc.zc_nvlist_dst);
	}

	return (error);
	}

	/*
	* The simplest receive case: receive from the specified fd, creating the
	* specified snapshot. Apply the specified properties as "received" properties
	* (which can be overridden by locally-set properties). If the stream is a
	* clone, its origin snapshot must be specified by 'origin'. The 'force'
	* flag will cause the target filesystem to be rolled back or destroyed if
	* necessary to receive.
	*
	* Return 0 on success or an errno on failure.
	*
	* Note: this interface does not work on dedup'd streams
	* (those with DMU_BACKUP_FEATURE_DEDUP).
	*/
	int
	lzc_receive(const char snapname, nvlist_t props, const char *origin,
	boolean_t force, boolean_t raw, int fd)
	{
	return (recv_impl(snapname, props, NULL, NULL, 0, origin, force,
	B_FALSE, raw, fd, NULL, NULL, NULL, NULL));
	}

	/*
	* Like lzc_receive, but if the receive fails due to premature stream
	* termination, the intermediate state will be preserved on disk. In this
	* case, ECKSUM will be returned. The receive may subsequently be resumed
	* with a resuming send stream generated by lzc_send_resume().
	*/
	int
	lzc_receive_resumable(const char snapname, nvlist_t props, const char *origin,
	boolean_t force, boolean_t raw, int fd)
	{
	return (recv_impl(snapname, props, NULL, NULL, 0, origin, force,
	B_TRUE, raw, fd, NULL, NULL, NULL, NULL));
	}

	/*
	* Like lzc_receive, but allows the caller to read the begin record and then to
	* pass it in. That could be useful if the caller wants to derive, for example,
	* the snapname or the origin parameters based on the information contained in
	* the begin record.
	* The begin record must be in its original form as read from the stream,
	* in other words, it should not be byteswapped.
	*
	* The 'resumable' parameter allows to obtain the same behavior as with
	* lzc_receive_resumable.
	*/
	int
	lzc_receive_with_header(const char snapname, nvlist_t props,
	const char *origin, boolean_t force, boolean_t resumable, boolean_t raw,
	int fd, const dmu_replay_record_t *begin_record)
	{
	if (begin_record == NULL)
	return (EINVAL);

	return (recv_impl(snapname, props, NULL, NULL, 0, origin, force,
	resumable, raw, fd, begin_record, NULL, NULL, NULL));
	}

	/*
	* Like lzc_receive, but allows the caller to pass all supported arguments
	* and retrieve all values returned. The only additional input parameter
	* is 'cleanup_fd' which is used to set a cleanup-on-exit file descriptor.
	*
	* The following parameters all provide return values. Several may be set
	* in the failure case and will contain additional information.
	*
	* The 'read_bytes' value will be set to the total number of bytes read.
	*
	* The 'errflags' value will contain zprop_errflags_t flags which are
	* used to describe any failures.
	*
	* The 'action_handle' and 'cleanup_fd' are no longer used, and are ignored.
	*
	* The 'errors' nvlist contains an entry for each unapplied received
	* property. Callers are responsible for freeing this nvlist.
	*/
	int lzc_receive_one(const char snapname, nvlist_t props,
	const char *origin, boolean_t force, boolean_t resumable, boolean_t raw,
	int input_fd, const dmu_replay_record_t *begin_record, int cleanup_fd,
	uint64_t read_bytes, uint64_t errflags, uint64_t *action_handle,
	nvlist_t **errors)
	{
	return (recv_impl(snapname, props, NULL, NULL, 0, origin, force,
	resumable, raw, input_fd, begin_record,
	read_bytes, errflags, errors));
	}

	/*
	* Like lzc_receive_one, but allows the caller to pass an additional 'cmdprops'
	* argument.
	*
	* The 'cmdprops' nvlist contains both override ('zfs receive -o') and
	* exclude ('zfs receive -x') properties. Callers are responsible for freeing
	* this nvlist
	*/
	int lzc_receive_with_cmdprops(const char snapname, nvlist_t props,
	nvlist_t cmdprops, uint8_t wkeydata, uint_t wkeylen, const char *origin,
	boolean_t force, boolean_t resumable, boolean_t raw, int input_fd,
	const dmu_replay_record_t *begin_record, int cleanup_fd,
	uint64_t read_bytes, uint64_t errflags, uint64_t *action_handle,
	nvlist_t **errors)
	{
	return (recv_impl(snapname, props, cmdprops, wkeydata, wkeylen, origin,
	force, resumable, raw, input_fd, begin_record,
	read_bytes, errflags, errors));
	}

	/*
	* Roll back this filesystem or volume to its most recent snapshot.
	* If snapnamebuf is not NULL, it will be filled in with the name
	* of the most recent snapshot.
	* Note that the latest snapshot may change if a new one is concurrently
	* created or the current one is destroyed. lzc_rollback_to can be used
	* to roll back to a specific latest snapshot.
	*
	* Return 0 on success or an errno on failure.
	*/
	int
	lzc_rollback(const char fsname, char snapnamebuf, int snapnamelen)
	{
	nvlist_t *args;
	nvlist_t *result;
	int err;

	args = fnvlist_alloc();
	err = lzc_ioctl(ZFS_IOC_ROLLBACK, fsname, args, &result);
	nvlist_free(args);
	if (err == 0 && snapnamebuf != NULL) {
	const char *snapname = fnvlist_lookup_string(result, "target");
	(void) strlcpy(snapnamebuf, snapname, snapnamelen);
	}
	nvlist_free(result);

	return (err);
	}

	/*
	* Roll back this filesystem or volume to the specified snapshot,
	* if possible.
	*
	* Return 0 on success or an errno on failure.
	*/
	int
	lzc_rollback_to(const char fsname, const char snapname)
	{
	nvlist_t *args;
	nvlist_t *result;
	int err;

	args = fnvlist_alloc();
	fnvlist_add_string(args, "target", snapname);
	err = lzc_ioctl(ZFS_IOC_ROLLBACK, fsname, args, &result);
	nvlist_free(args);
	nvlist_free(result);
	return (err);
	}

	/*
	* Creates new bookmarks from existing snapshot or bookmark.
	*
	* The bookmarks nvlist maps from the full name of the new bookmark to
	* the full name of the source snapshot or bookmark.
	* All the bookmarks and snapshots must be in the same pool.
	* The new bookmarks names must be unique.
	* => see function dsl_bookmark_create_nvl_validate
	*
	* The returned results nvlist will have an entry for each bookmark that failed.
	* The value will be the (int32) error code.
	*
	* The return value will be 0 if all bookmarks were created, otherwise it will
	* be the errno of a (undetermined) bookmarks that failed.
	*/
	int
	lzc_bookmark(nvlist_t bookmarks, nvlist_t *errlist)
	{
	nvpair_t *elem;
	int error;
	char pool[ZFS_MAX_DATASET_NAME_LEN];

	/* determine pool name from first bookmark */
	elem = nvlist_next_nvpair(bookmarks, NULL);
	if (elem == NULL)
	return (0);
	(void) strlcpy(pool, nvpair_name(elem), sizeof (pool));
	pool[strcspn(pool, "/#")] = '\0';

	error = lzc_ioctl(ZFS_IOC_BOOKMARK, pool, bookmarks, errlist);

	return (error);
	}

	/*
	* Retrieve bookmarks.
	*
	* Retrieve the list of bookmarks for the given file system. The props
	* parameter is an nvlist of property names (with no values) that will be
	* returned for each bookmark.
	*
	* The following are valid properties on bookmarks, most of which are numbers
	* (represented as uint64 in the nvlist), except redact_snaps, which is a
	* uint64 array, and redact_complete, which is a boolean
	*
	* "guid" - globally unique identifier of the snapshot it refers to
	* "createtxg" - txg when the snapshot it refers to was created
	* "creation" - timestamp when the snapshot it refers to was created
	* "ivsetguid" - IVset guid for identifying encrypted snapshots
	* "redact_snaps" - list of guids of the redaction snapshots for the specified
	* bookmark. If the bookmark is not a redaction bookmark, the nvlist will
	* not contain an entry for this value. If it is redacted with respect to
	* no snapshots, it will contain value -> NULL uint64 array
	* "redact_complete" - boolean value; true if the redaction bookmark is
	* complete, false otherwise.
	*
	* The format of the returned nvlist as follows:
	* <short name of bookmark> -> {
	* <name of property> -> {
	* "value" -> uint64
	* }
	* ...
	* "redact_snaps" -> {
	* "value" -> uint64 array
	* }
	* "redact_complete" -> {
	* "value" -> boolean value
	* }
	* }
	*/
	int
	lzc_get_bookmarks(const char fsname, nvlist_t props, nvlist_t **bmarks)
	{
	return (lzc_ioctl(ZFS_IOC_GET_BOOKMARKS, fsname, props, bmarks));
	}

	/*
	* Get bookmark properties.
	*
	* Given a bookmark's full name, retrieve all properties for the bookmark.
	*
	* The format of the returned property list is as follows:
	* {
	* <name of property> -> {
	* "value" -> uint64
	* }
	* ...
	* "redact_snaps" -> {
	* "value" -> uint64 array
	* }
	*/
	int
	lzc_get_bookmark_props(const char bookmark, nvlist_t *props)
	{
	int error;

	nvlist_t *innvl = fnvlist_alloc();
	error = lzc_ioctl(ZFS_IOC_GET_BOOKMARK_PROPS, bookmark, innvl, props);
	fnvlist_free(innvl);

	return (error);
	}

	/*
	* Destroys bookmarks.
	*
	* The keys in the bmarks nvlist are the bookmarks to be destroyed.
	* They must all be in the same pool. Bookmarks are specified as
	* <fs>#<bmark>.
	*
	* Bookmarks that do not exist will be silently ignored.
	*
	* The return value will be 0 if all bookmarks that existed were destroyed.
	*
	* Otherwise the return value will be the errno of a (undetermined) bookmark
	* that failed, no bookmarks will be destroyed, and the errlist will have an
	* entry for each bookmarks that failed. The value in the errlist will be
	* the (int32) error code.
	*/
	int
	lzc_destroy_bookmarks(nvlist_t bmarks, nvlist_t *errlist)
	{
	nvpair_t *elem;
	int error;
	char pool[ZFS_MAX_DATASET_NAME_LEN];

	/* determine the pool name */
	elem = nvlist_next_nvpair(bmarks, NULL);
	if (elem == NULL)
	return (0);
	(void) strlcpy(pool, nvpair_name(elem), sizeof (pool));
	pool[strcspn(pool, "/#")] = '\0';

	error = lzc_ioctl(ZFS_IOC_DESTROY_BOOKMARKS, pool, bmarks, errlist);

	return (error);
	}

	static int
	lzc_channel_program_impl(const char pool, const char program, boolean_t sync,
	uint64_t instrlimit, uint64_t memlimit, nvlist_t argnvl, nvlist_t *outnvl)
	{
	int error;
	nvlist_t *args;

	args = fnvlist_alloc();
	fnvlist_add_string(args, ZCP_ARG_PROGRAM, program);
	fnvlist_add_nvlist(args, ZCP_ARG_ARGLIST, argnvl);
	fnvlist_add_boolean_value(args, ZCP_ARG_SYNC, sync);
	fnvlist_add_uint64(args, ZCP_ARG_INSTRLIMIT, instrlimit);
	fnvlist_add_uint64(args, ZCP_ARG_MEMLIMIT, memlimit);
	error = lzc_ioctl(ZFS_IOC_CHANNEL_PROGRAM, pool, args, outnvl);
	fnvlist_free(args);

	return (error);
	}

	/*
	* Executes a channel program.
	*
	* If this function returns 0 the channel program was successfully loaded and
	* ran without failing. Note that individual commands the channel program ran
	* may have failed and the channel program is responsible for reporting such
	* errors through outnvl if they are important.
	*
	* This method may also return:
	*
	* EINVAL The program contains syntax errors, or an invalid memory or time
	* limit was given. No part of the channel program was executed.
	* If caused by syntax errors, 'outnvl' contains information about the
	* errors.
	*
	* ECHRNG The program was executed, but encountered a runtime error, such as
	* calling a function with incorrect arguments, invoking the error()
	* function directly, failing an assert() command, etc. Some portion
	* of the channel program may have executed and committed changes.
	* Information about the failure can be found in 'outnvl'.
	*
	* ENOMEM The program fully executed, but the output buffer was not large
	* enough to store the returned value. No output is returned through
	* 'outnvl'.
	*
	* ENOSPC The program was terminated because it exceeded its memory usage
	* limit. Some portion of the channel program may have executed and
	* committed changes to disk. No output is returned through 'outnvl'.
	*
	* ETIME The program was terminated because it exceeded its Lua instruction
	* limit. Some portion of the channel program may have executed and
	* committed changes to disk. No output is returned through 'outnvl'.
	*/
	int
	lzc_channel_program(const char pool, const char program, uint64_t instrlimit,
	uint64_t memlimit, nvlist_t argnvl, nvlist_t *outnvl)
	{
	return (lzc_channel_program_impl(pool, program, B_TRUE, instrlimit,
	memlimit, argnvl, outnvl));
	}

	/*
	* Creates a checkpoint for the specified pool.
	*
	* If this function returns 0 the pool was successfully checkpointed.
	*
	* This method may also return:
	*
	* ZFS_ERR_CHECKPOINT_EXISTS
	* The pool already has a checkpoint. A pools can only have one
	* checkpoint at most, at any given time.
	*
	* ZFS_ERR_DISCARDING_CHECKPOINT
	* ZFS is in the middle of discarding a checkpoint for this pool.
	* The pool can be checkpointed again once the discard is done.
	*
	* ZFS_DEVRM_IN_PROGRESS
	* A vdev is currently being removed. The pool cannot be
	* checkpointed until the device removal is done.
	*
	* ZFS_VDEV_TOO_BIG
	* One or more top-level vdevs exceed the maximum vdev size
	* supported for this feature.
	*/
	int
	lzc_pool_checkpoint(const char *pool)
	{
	int error;

	nvlist_t *result = NULL;
	nvlist_t *args = fnvlist_alloc();

	error = lzc_ioctl(ZFS_IOC_POOL_CHECKPOINT, pool, args, &result);

	fnvlist_free(args);
	fnvlist_free(result);

	return (error);
	}

	/*
	* Discard the checkpoint from the specified pool.
	*
	* If this function returns 0 the checkpoint was successfully discarded.
	*
	* This method may also return:
	*
	* ZFS_ERR_NO_CHECKPOINT
	* The pool does not have a checkpoint.
	*
	* ZFS_ERR_DISCARDING_CHECKPOINT
	* ZFS is already in the middle of discarding the checkpoint.
	*/
	int
	lzc_pool_checkpoint_discard(const char *pool)
	{
	int error;

	nvlist_t *result = NULL;
	nvlist_t *args = fnvlist_alloc();

	error = lzc_ioctl(ZFS_IOC_POOL_DISCARD_CHECKPOINT, pool, args, &result);

	fnvlist_free(args);
	fnvlist_free(result);

	return (error);
	}

	/*
	* Executes a read-only channel program.
	*
	* A read-only channel program works programmatically the same way as a
	* normal channel program executed with lzc_channel_program(). The only
	* difference is it runs exclusively in open-context and therefore can
	* return faster. The downside to that, is that the program cannot change
	* on-disk state by calling functions from the zfs.sync submodule.
	*
	* The return values of this function (and their meaning) are exactly the
	* same as the ones described in lzc_channel_program().
	*/
	int
	lzc_channel_program_nosync(const char pool, const char program,
	uint64_t timeout, uint64_t memlimit, nvlist_t argnvl, nvlist_t *outnvl)
	{
	return (lzc_channel_program_impl(pool, program, B_FALSE, timeout,
	memlimit, argnvl, outnvl));
	}

	/*
	* Performs key management functions
	*
	* crypto_cmd should be a value from dcp_cmd_t. If the command specifies to
	* load or change a wrapping key, the key should be specified in the
	* hidden_args nvlist so that it is not logged.
	*/
	int
	lzc_load_key(const char fsname, boolean_t noop, uint8_t wkeydata,
	uint_t wkeylen)
	{
	int error;
	nvlist_t *ioc_args;
	nvlist_t *hidden_args;

	if (wkeydata == NULL)
	return (EINVAL);

	ioc_args = fnvlist_alloc();
	hidden_args = fnvlist_alloc();
	fnvlist_add_uint8_array(hidden_args, "wkeydata", wkeydata, wkeylen);
	fnvlist_add_nvlist(ioc_args, ZPOOL_HIDDEN_ARGS, hidden_args);
	if (noop)
	fnvlist_add_boolean(ioc_args, "noop");
	error = lzc_ioctl(ZFS_IOC_LOAD_KEY, fsname, ioc_args, NULL);
	nvlist_free(hidden_args);
	nvlist_free(ioc_args);

	return (error);
	}

	int
	lzc_unload_key(const char *fsname)
	{
	return (lzc_ioctl(ZFS_IOC_UNLOAD_KEY, fsname, NULL, NULL));
	}

	int
	lzc_change_key(const char fsname, uint64_t crypt_cmd, nvlist_t props,
	uint8_t *wkeydata, uint_t wkeylen)
	{
	int error;
	nvlist_t *ioc_args = fnvlist_alloc();
	nvlist_t *hidden_args = NULL;

	fnvlist_add_uint64(ioc_args, "crypt_cmd", crypt_cmd);

	if (wkeydata != NULL) {
	hidden_args = fnvlist_alloc();
	fnvlist_add_uint8_array(hidden_args, "wkeydata", wkeydata,
	wkeylen);
	fnvlist_add_nvlist(ioc_args, ZPOOL_HIDDEN_ARGS, hidden_args);
	}

	if (props != NULL)
	fnvlist_add_nvlist(ioc_args, "props", props);

	error = lzc_ioctl(ZFS_IOC_CHANGE_KEY, fsname, ioc_args, NULL);
	nvlist_free(hidden_args);
	nvlist_free(ioc_args);

	return (error);
	}

	int
	lzc_reopen(const char *pool_name, boolean_t scrub_restart)
	{
	nvlist_t *args = fnvlist_alloc();
	int error;

	fnvlist_add_boolean_value(args, "scrub_restart", scrub_restart);

	error = lzc_ioctl(ZFS_IOC_POOL_REOPEN, pool_name, args, NULL);
	nvlist_free(args);
	return (error);
	}

	/*
	* Changes initializing state.
	*
	* vdevs should be a list of (<key>, guid) where guid is a uint64 vdev GUID.
	* The key is ignored.
	*
	* If there are errors related to vdev arguments, per-vdev errors are returned
	* in an nvlist with the key "vdevs". Each error is a (guid, errno) pair where
	* guid is stringified with PRIu64, and errno is one of the following as
	* an int64_t:
	* - ENODEV if the device was not found
	* - EINVAL if the devices is not a leaf or is not concrete (e.g. missing)
	* - EROFS if the device is not writeable
	* - EBUSY start requested but the device is already being either
	* initialized or trimmed
	* - ESRCH cancel/suspend requested but device is not being initialized
	*
	* If the errlist is empty, then return value will be:
	* - EINVAL if one or more arguments was invalid
	* - Other spa_open failures
	* - 0 if the operation succeeded
	*/
	int
	lzc_initialize(const char *poolname, pool_initialize_func_t cmd_type,
	nvlist_t vdevs, nvlist_t *errlist)
	{
	int error;

	nvlist_t *args = fnvlist_alloc();
	fnvlist_add_uint64(args, ZPOOL_INITIALIZE_COMMAND, (uint64_t)cmd_type);
	fnvlist_add_nvlist(args, ZPOOL_INITIALIZE_VDEVS, vdevs);

	error = lzc_ioctl(ZFS_IOC_POOL_INITIALIZE, poolname, args, errlist);

	fnvlist_free(args);

	return (error);
	}

	/*
	* Changes TRIM state.
	*
	* vdevs should be a list of (<key>, guid) where guid is a uint64 vdev GUID.
	* The key is ignored.
	*
	* If there are errors related to vdev arguments, per-vdev errors are returned
	* in an nvlist with the key "vdevs". Each error is a (guid, errno) pair where
	* guid is stringified with PRIu64, and errno is one of the following as
	* an int64_t:
	* - ENODEV if the device was not found
	* - EINVAL if the devices is not a leaf or is not concrete (e.g. missing)
	* - EROFS if the device is not writeable
	* - EBUSY start requested but the device is already being either trimmed
	* or initialized
	* - ESRCH cancel/suspend requested but device is not being initialized
	* - EOPNOTSUPP if the device does not support TRIM (or secure TRIM)
	*
	* If the errlist is empty, then return value will be:
	* - EINVAL if one or more arguments was invalid
	* - Other spa_open failures
	* - 0 if the operation succeeded
	*/
	int
	lzc_trim(const char *poolname, pool_trim_func_t cmd_type, uint64_t rate,
	boolean_t secure, nvlist_t vdevs, nvlist_t *errlist)
	{
	int error;

	nvlist_t *args = fnvlist_alloc();
	fnvlist_add_uint64(args, ZPOOL_TRIM_COMMAND, (uint64_t)cmd_type);
	fnvlist_add_nvlist(args, ZPOOL_TRIM_VDEVS, vdevs);
	fnvlist_add_uint64(args, ZPOOL_TRIM_RATE, rate);
	fnvlist_add_boolean_value(args, ZPOOL_TRIM_SECURE, secure);

	error = lzc_ioctl(ZFS_IOC_POOL_TRIM, poolname, args, errlist);

	fnvlist_free(args);

	return (error);
	}

	/*
	* Create a redaction bookmark named bookname by redacting snapshot with respect
	* to all the snapshots in snapnv.
	*/
	int
	lzc_redact(const char snapshot, const char bookname, nvlist_t *snapnv)
	{
	nvlist_t *args = fnvlist_alloc();
	fnvlist_add_string(args, "bookname", bookname);
	fnvlist_add_nvlist(args, "snapnv", snapnv);
	int error = lzc_ioctl(ZFS_IOC_REDACT, snapshot, args, NULL);
	fnvlist_free(args);
	return (error);
	}

	static int
	wait_common(const char *pool, zpool_wait_activity_t activity, boolean_t use_tag,
	uint64_t tag, boolean_t *waited)
	{
	nvlist_t *args = fnvlist_alloc();
	nvlist_t *result = NULL;

	fnvlist_add_int32(args, ZPOOL_WAIT_ACTIVITY, activity);
	if (use_tag)
	fnvlist_add_uint64(args, ZPOOL_WAIT_TAG, tag);

	int error = lzc_ioctl(ZFS_IOC_WAIT, pool, args, &result);

	if (error == 0 && waited != NULL)
	*waited = fnvlist_lookup_boolean_value(result,
	ZPOOL_WAIT_WAITED);

	fnvlist_free(args);
	fnvlist_free(result);

	return (error);
	}

	int
	lzc_wait(const char pool, zpool_wait_activity_t activity, boolean_t waited)
	{
	return (wait_common(pool, activity, B_FALSE, 0, waited));
	}

	int
	lzc_wait_tag(const char *pool, zpool_wait_activity_t activity, uint64_t tag,
	boolean_t *waited)
	{
	return (wait_common(pool, activity, B_TRUE, tag, waited));
	}

	int
	lzc_wait_fs(const char fs, zfs_wait_activity_t activity, boolean_t waited)
	{
	nvlist_t *args = fnvlist_alloc();
	nvlist_t *result = NULL;

	fnvlist_add_int32(args, ZFS_WAIT_ACTIVITY, activity);

	int error = lzc_ioctl(ZFS_IOC_WAIT_FS, fs, args, &result);

	if (error == 0 && waited != NULL)
	*waited = fnvlist_lookup_boolean_value(result,
	ZFS_WAIT_WAITED);

	fnvlist_free(args);
	fnvlist_free(result);

	return (error);
	}

	/*
	* Set the bootenv contents for the given pool.
	*/
	int
	lzc_set_bootenv(const char pool, const nvlist_t env)
	{
	return (lzc_ioctl(ZFS_IOC_SET_BOOTENV, pool, (nvlist_t *)env, NULL));
	}

	/*
	* Get the contents of the bootenv of the given pool.
	*/
	int
	lzc_get_bootenv(const char pool, nvlist_t *outnvl)
	{
	return (lzc_ioctl(ZFS_IOC_GET_BOOTENV, pool, NULL, outnvl));
	}
	diff --git a/sys/contrib/openzfs/lib/libzfsbootenv/lzbe_device.c b/sys/contrib/openzfs/lib/libzfsbootenv/lzbe_device.c
	index 670efd8b0603..2d8833b4fff2 100644
	--- a/sys/contrib/openzfs/lib/libzfsbootenv/lzbe_device.c
	+++ b/sys/contrib/openzfs/lib/libzfsbootenv/lzbe_device.c
	@@ -1,164 +1,163 @@
	/*
	* This file and its contents are supplied under the terms of the
	* Common Development and Distribution License ("CDDL"), version 1.0.
	* You may only use this file in accordance with the terms of version
	* 1.0 of the CDDL.
	*
	* A full copy of the text of the CDDL should have accompanied this
	* source. A copy of the CDDL is also available via the Internet at
	* http://www.illumos.org/license/CDDL.
	*/
	/*
	* Copyright 2020 Toomas Soome <tsoome@me.com>
	*/

	#include <sys/types.h>
	#include <string.h>
	#include <libzfs.h>
	#include <libzfsbootenv.h>
	#include <sys/zfs_bootenv.h>
	#include <sys/vdev_impl.h>

	/*
	* Store device name to zpool label bootenv area.
	* This call will set bootenv version to VB_NVLIST, if bootenv currently
	* does contain other version, then old data will be replaced.
	*/
	int
	lzbe_set_boot_device(const char pool, lzbe_flags_t flag, const char device)
	{
	libzfs_handle_t *hdl;
	zpool_handle_t *zphdl;
	nvlist_t *nv;
	char *descriptor;
	uint64_t version;
	int rv = -1;

	if (pool == NULL \|\| *pool == '\0')
	return (rv);

	if ((hdl = libzfs_init()) == NULL)
	return (rv);

	zphdl = zpool_open(hdl, pool);
	if (zphdl == NULL) {
	libzfs_fini(hdl);
	return (rv);
	}

	switch (flag) {
	case lzbe_add:
	rv = zpool_get_bootenv(zphdl, &nv);
	if (rv == 0) {
	/*
	* We got the nvlist, check for version.
	* if version is missing or is not VB_NVLIST,
	* create new list.
	*/
	rv = nvlist_lookup_uint64(nv, BOOTENV_VERSION,
	&version);
	if (rv == 0 && version == VB_NVLIST)
	break;

	/* Drop this nvlist */
	fnvlist_free(nv);
	}
	/* FALLTHROUGH */
	case lzbe_replace:
	nv = fnvlist_alloc();
	break;
	default:
	return (rv);
	}

	/* version is mandatory */
	fnvlist_add_uint64(nv, BOOTENV_VERSION, VB_NVLIST);

	/*
	* If device name is empty, remove boot device configuration.
	*/
	if ((device == NULL \|\| *device == '\0')) {
	if (nvlist_exists(nv, OS_BOOTONCE))
	fnvlist_remove(nv, OS_BOOTONCE);
	} else {
	/*
	* Use device name directly if it does start with
	- * prefix "zfs:". Otherwise, add prefix and sufix.
	+ * prefix "zfs:". Otherwise, add prefix and suffix.
	*/
	if (strncmp(device, "zfs:", 4) == 0) {
	fnvlist_add_string(nv, OS_BOOTONCE, device);
	} else {
	- descriptor = NULL;
	- if (asprintf(&descriptor, "zfs:%s:", device) > 0)
	+ if (asprintf(&descriptor, "zfs:%s:", device) > 0) {
	fnvlist_add_string(nv, OS_BOOTONCE, descriptor);
	- else
	+ free(descriptor);
	+ } else
	rv = ENOMEM;
	- free(descriptor);
	}
	}

	rv = zpool_set_bootenv(zphdl, nv);
	if (rv != 0)
	fprintf(stderr, "%s\n", libzfs_error_description(hdl));

	fnvlist_free(nv);
	zpool_close(zphdl);
	libzfs_fini(hdl);
	return (rv);
	}

	/*
	* Return boot device name from bootenv, if set.
	*/
	int
	lzbe_get_boot_device(const char pool, char *device)
	{
	libzfs_handle_t *hdl;
	zpool_handle_t *zphdl;
	nvlist_t *nv;
	char *val;
	int rv = -1;

	if (pool == NULL \|\| *pool == '\0' \|\| device == NULL)
	return (rv);

	if ((hdl = libzfs_init()) == NULL)
	return (rv);

	zphdl = zpool_open(hdl, pool);
	if (zphdl == NULL) {
	libzfs_fini(hdl);
	return (rv);
	}

	rv = zpool_get_bootenv(zphdl, &nv);
	if (rv == 0) {
	rv = nvlist_lookup_string(nv, OS_BOOTONCE, &val);
	if (rv == 0) {
	/*
	* zfs device descriptor is in form of "zfs:dataset:",
	* we only do need dataset name.
	*/
	if (strncmp(val, "zfs:", 4) == 0) {
	val += 4;
	val = strdup(val);
	if (val != NULL) {
	size_t len = strlen(val);

	if (val[len - 1] == ':')
	val[len - 1] = '\0';
	*device = val;
	} else {
	rv = ENOMEM;
	}
	} else {
	rv = EINVAL;
	}
	}
	nvlist_free(nv);
	}

	zpool_close(zphdl);
	libzfs_fini(hdl);
	return (rv);
	}
	diff --git a/sys/contrib/openzfs/lib/libzpool/Makefile.am b/sys/contrib/openzfs/lib/libzpool/Makefile.am
	index 929f5bed8b2f..c9a55591e5ca 100644
	--- a/sys/contrib/openzfs/lib/libzpool/Makefile.am
	+++ b/sys/contrib/openzfs/lib/libzpool/Makefile.am
	@@ -1,240 +1,240 @@
	include $(top_srcdir)/config/Rules.am

	VPATH = \
	$(top_srcdir)/module/zfs \
	$(top_srcdir)/module/zcommon \
	$(top_srcdir)/module/lua \
	$(top_srcdir)/module/os/linux/zfs \
	$(top_srcdir)/lib/libzpool

	if BUILD_FREEBSD
	DEFAULT_INCLUDES += -I$(top_srcdir)/include/os/freebsd/zfs
	endif
	if BUILD_LINUX
	DEFAULT_INCLUDES += -I$(top_srcdir)/include/os/linux/zfs
	endif

	# Unconditionally enable debugging for libzpool
	AM_CPPFLAGS += -DDEBUG -UNDEBUG -DZFS_DEBUG

	# Suppress unused but set variable warnings often due to ASSERTs
	AM_CFLAGS += $(NO_UNUSED_BUT_SET_VARIABLE)

	# Includes kernel code generate warnings for large stack frames
	AM_CFLAGS += $(FRAME_LARGER_THAN)

	AM_CFLAGS += $(ZLIB_CFLAGS)

	AM_CFLAGS += -DLIB_ZPOOL_BUILD

	lib_LTLIBRARIES = libzpool.la

	USER_C = \
	kernel.c \
	taskq.c \
	util.c

	KERNEL_C = \
	zfeature_common.c \
	zfs_comutil.c \
	zfs_deleg.c \
	zfs_fletcher.c \
	zfs_fletcher_aarch64_neon.c \
	zfs_fletcher_avx512.c \
	zfs_fletcher_intel.c \
	zfs_fletcher_sse.c \
	zfs_fletcher_superscalar.c \
	zfs_fletcher_superscalar4.c \
	zfs_namecheck.c \
	zfs_prop.c \
	zpool_prop.c \
	zprop_common.c \
	abd.c \
	abd_os.c \
	aggsum.c \
	arc.c \
	arc_os.c \
	blkptr.c \
	bplist.c \
	bpobj.c \
	bptree.c \
	btree.c \
	bqueue.c \
	cityhash.c \
	dbuf.c \
	dbuf_stats.c \
	ddt.c \
	ddt_zap.c \
	dmu.c \
	dmu_diff.c \
	dmu_object.c \
	dmu_objset.c \
	dmu_recv.c \
	dmu_redact.c \
	dmu_send.c \
	dmu_traverse.c \
	dmu_tx.c \
	dmu_zfetch.c \
	dnode.c \
	dnode_sync.c \
	dsl_bookmark.c \
	dsl_dataset.c \
	dsl_deadlist.c \
	dsl_deleg.c \
	dsl_dir.c \
	dsl_crypt.c \
	dsl_pool.c \
	dsl_prop.c \
	dsl_scan.c \
	dsl_synctask.c \
	dsl_destroy.c \
	dsl_userhold.c \
	edonr_zfs.c \
	hkdf.c \
	fm.c \
	gzip.c \
	lzjb.c \
	lz4.c \
	metaslab.c \
	mmp.c \
	multilist.c \
	objlist.c \
	pathname.c \
	range_tree.c \
	refcount.c \
	rrwlock.c \
	sa.c \
	sha256.c \
	skein_zfs.c \
	spa.c \
	spa_boot.c \
	spa_checkpoint.c \
	spa_config.c \
	spa_errlog.c \
	spa_history.c \
	spa_log_spacemap.c \
	spa_misc.c \
	spa_stats.c \
	space_map.c \
	space_reftree.c \
	txg.c \
	trace.c \
	uberblock.c \
	unique.c \
	vdev.c \
	vdev_cache.c \
	vdev_draid.c \
	vdev_draid_rand.c \
	vdev_file.c \
	vdev_indirect_births.c \
	vdev_indirect.c \
	vdev_indirect_mapping.c \
	vdev_initialize.c \
	vdev_label.c \
	vdev_mirror.c \
	vdev_missing.c \
	vdev_queue.c \
	vdev_raidz.c \
	vdev_raidz_math_aarch64_neon.c \
	vdev_raidz_math_aarch64_neonx2.c \
	vdev_raidz_math_avx2.c \
	vdev_raidz_math_avx512bw.c \
	vdev_raidz_math_avx512f.c \
	vdev_raidz_math.c \
	vdev_raidz_math_scalar.c \
	vdev_raidz_math_sse2.c \
	vdev_raidz_math_ssse3.c \
	vdev_raidz_math_powerpc_altivec.c \
	vdev_rebuild.c \
	vdev_removal.c \
	vdev_root.c \
	vdev_trim.c \
	zap.c \
	zap_leaf.c \
	zap_micro.c \
	zcp.c \
	zcp_get.c \
	zcp_global.c \
	zcp_iter.c \
	zcp_set.c \
	zcp_synctask.c \
	zfeature.c \
	zfs_byteswap.c \
	zfs_debug.c \
	zfs_fm.c \
	zfs_fuid.c \
	zfs_racct.c \
	zfs_sa.c \
	zfs_znode.c \
	zfs_ratelimit.c \
	zfs_rlock.c \
	zil.c \
	zio.c \
	zio_checksum.c \
	zio_compress.c \
	zio_crypt.c \
	zio_inject.c \
	zle.c \
	zrlock.c \
	zthr.c

	LUA_C = \
	lapi.c \
	lauxlib.c \
	lbaselib.c \
	lcode.c \
	lcompat.c \
	lcorolib.c \
	lctype.c \
	ldebug.c \
	ldo.c \
	lfunc.c \
	lgc.c \
	llex.c \
	lmem.c \
	lobject.c \
	lopcodes.c \
	lparser.c \
	lstate.c \
	lstring.c \
	lstrlib.c \
	ltable.c \
	ltablib.c \
	ltm.c \
	lvm.c \
	lzio.c

	dist_libzpool_la_SOURCES = \
	$(USER_C)

	nodist_libzpool_la_SOURCES = \
	$(KERNEL_C) \
	$(LUA_C)

	libzpool_la_LIBADD = \
	$(abs_top_builddir)/lib/libicp/libicp.la \
	$(abs_top_builddir)/lib/libunicode/libunicode.la \
	$(abs_top_builddir)/lib/libzfs_core/libzfs_core.la \
	$(abs_top_builddir)/lib/libnvpair/libnvpair.la \
	$(abs_top_builddir)/lib/libzstd/libzstd.la

	libzpool_la_LIBADD += $(LIBCLOCK_GETTIME) $(ZLIB_LIBS) -ldl -lm

	libzpool_la_LDFLAGS = -pthread

	if !ASAN_ENABLED
	libzpool_la_LDFLAGS += -Wl,-z,defs
	endif

	if BUILD_FREEBSD
	libzpool_la_LIBADD += -lgeom
	endif

	-libzpool_la_LDFLAGS += -version-info 4:0:0
	+libzpool_la_LDFLAGS += -version-info 5:0:0

	if TARGET_CPU_POWERPC
	vdev_raidz_math_powerpc_altivec.$(OBJEXT): CFLAGS += -maltivec
	vdev_raidz_math_powerpc_altivec.l$(OBJEXT): CFLAGS += -maltivec
	endif

	include $(top_srcdir)/config/CppCheck.am
	diff --git a/sys/contrib/openzfs/lib/libzpool/kernel.c b/sys/contrib/openzfs/lib/libzpool/kernel.c
	index ca357899367a..e96a1d7521d9 100644
	--- a/sys/contrib/openzfs/lib/libzpool/kernel.c
	+++ b/sys/contrib/openzfs/lib/libzpool/kernel.c
	@@ -1,1417 +1,1417 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2012, 2018 by Delphix. All rights reserved.
	* Copyright (c) 2016 Actifio, Inc. All rights reserved.
	*/

	#include <assert.h>
	#include <fcntl.h>
	#include <libgen.h>
	#include <poll.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <sys/crypto/icp.h>
	#include <sys/processor.h>
	#include <sys/rrwlock.h>
	#include <sys/spa.h>
	#include <sys/stat.h>
	#include <sys/systeminfo.h>
	#include <sys/time.h>
	#include <sys/utsname.h>
	#include <sys/zfs_context.h>
	#include <sys/zfs_onexit.h>
	#include <sys/zfs_vfsops.h>
	#include <sys/zstd/zstd.h>
	#include <sys/zvol.h>
	#include <zfs_fletcher.h>
	#include <zlib.h>

	/*
	* Emulation of kernel services in userland.
	*/

	uint64_t physmem;
	char hw_serial[HW_HOSTID_LEN];
	struct utsname hw_utsname;

	/* If set, all blocks read will be copied to the specified directory. */
	char *vn_dumpdir = NULL;

	/* this only exists to have its address taken */
	struct proc p0;

	/*
	* =========================================================================
	* threads
	* =========================================================================
	*
	* TS_STACK_MIN is dictated by the minimum allowed pthread stack size. While
	* TS_STACK_MAX is somewhat arbitrary, it was selected to be large enough for
	* the expected stack depth while small enough to avoid exhausting address
	* space with high thread counts.
	*/
	#define TS_STACK_MIN MAX(PTHREAD_STACK_MIN, 32768)
	#define TS_STACK_MAX (256 * 1024)

	/ARGSUSED/
	kthread_t *
	zk_thread_create(void (func)(void ), void *arg, size_t stksize, int state)
	{
	pthread_attr_t attr;
	pthread_t tid;
	char *stkstr;
	int detachstate = PTHREAD_CREATE_DETACHED;

	VERIFY0(pthread_attr_init(&attr));

	if (state & TS_JOINABLE)
	detachstate = PTHREAD_CREATE_JOINABLE;

	VERIFY0(pthread_attr_setdetachstate(&attr, detachstate));

	/*
	* We allow the default stack size in user space to be specified by
	* setting the ZFS_STACK_SIZE environment variable. This allows us
	* the convenience of observing and debugging stack overruns in
	* user space. Explicitly specified stack sizes will be honored.
	* The usage of ZFS_STACK_SIZE is discussed further in the
	* ENVIRONMENT VARIABLES sections of the ztest(1) man page.
	*/
	if (stksize == 0) {
	stkstr = getenv("ZFS_STACK_SIZE");

	if (stkstr == NULL)
	stksize = TS_STACK_MAX;
	else
	stksize = MAX(atoi(stkstr), TS_STACK_MIN);
	}

	VERIFY3S(stksize, >, 0);
	stksize = P2ROUNDUP(MAX(stksize, TS_STACK_MIN), PAGESIZE);

	/*
	* If this ever fails, it may be because the stack size is not a
	* multiple of system page size.
	*/
	VERIFY0(pthread_attr_setstacksize(&attr, stksize));
	VERIFY0(pthread_attr_setguardsize(&attr, PAGESIZE));

	VERIFY0(pthread_create(&tid, &attr, (void ()(void *))func, arg));
	VERIFY0(pthread_attr_destroy(&attr));

	return ((void *)(uintptr_t)tid);
	}

	/*
	* =========================================================================
	* kstats
	* =========================================================================
	*/
	/ARGSUSED/
	kstat_t *
	kstat_create(const char module, int instance, const char name,
	const char *class, uchar_t type, ulong_t ndata, uchar_t ks_flag)
	{
	return (NULL);
	}

	/ARGSUSED/
	void
	kstat_install(kstat_t *ksp)
	{}

	/ARGSUSED/
	void
	kstat_delete(kstat_t *ksp)
	{}

	/ARGSUSED/
	void
	kstat_waitq_enter(kstat_io_t *kiop)
	{}

	/ARGSUSED/
	void
	kstat_waitq_exit(kstat_io_t *kiop)
	{}

	/ARGSUSED/
	void
	kstat_runq_enter(kstat_io_t *kiop)
	{}

	/ARGSUSED/
	void
	kstat_runq_exit(kstat_io_t *kiop)
	{}

	/ARGSUSED/
	void
	kstat_waitq_to_runq(kstat_io_t *kiop)
	{}

	/ARGSUSED/
	void
	kstat_runq_back_to_waitq(kstat_io_t *kiop)
	{}

	void
	kstat_set_raw_ops(kstat_t *ksp,
	int (headers)(char buf, size_t size),
	int (data)(char buf, size_t size, void *data),
	void (addr)(kstat_t *ksp, loff_t index))
	{}

	/*
	* =========================================================================
	* mutexes
	* =========================================================================
	*/

	void
	mutex_init(kmutex_t mp, char name, int type, void *cookie)
	{
	VERIFY0(pthread_mutex_init(&mp->m_lock, NULL));
	memset(&mp->m_owner, 0, sizeof (pthread_t));
	}

	void
	mutex_destroy(kmutex_t *mp)
	{
	VERIFY0(pthread_mutex_destroy(&mp->m_lock));
	}

	void
	mutex_enter(kmutex_t *mp)
	{
	VERIFY0(pthread_mutex_lock(&mp->m_lock));
	mp->m_owner = pthread_self();
	}

	int
	mutex_tryenter(kmutex_t *mp)
	{
	int error;

	error = pthread_mutex_trylock(&mp->m_lock);
	if (error == 0) {
	mp->m_owner = pthread_self();
	return (1);
	} else {
	VERIFY3S(error, ==, EBUSY);
	return (0);
	}
	}

	void
	mutex_exit(kmutex_t *mp)
	{
	memset(&mp->m_owner, 0, sizeof (pthread_t));
	VERIFY0(pthread_mutex_unlock(&mp->m_lock));
	}

	/*
	* =========================================================================
	* rwlocks
	* =========================================================================
	*/

	void
	rw_init(krwlock_t rwlp, char name, int type, void *arg)
	{
	VERIFY0(pthread_rwlock_init(&rwlp->rw_lock, NULL));
	rwlp->rw_readers = 0;
	rwlp->rw_owner = 0;
	}

	void
	rw_destroy(krwlock_t *rwlp)
	{
	VERIFY0(pthread_rwlock_destroy(&rwlp->rw_lock));
	}

	void
	rw_enter(krwlock_t *rwlp, krw_t rw)
	{
	if (rw == RW_READER) {
	VERIFY0(pthread_rwlock_rdlock(&rwlp->rw_lock));
	atomic_inc_uint(&rwlp->rw_readers);
	} else {
	VERIFY0(pthread_rwlock_wrlock(&rwlp->rw_lock));
	rwlp->rw_owner = pthread_self();
	}
	}

	void
	rw_exit(krwlock_t *rwlp)
	{
	if (RW_READ_HELD(rwlp))
	atomic_dec_uint(&rwlp->rw_readers);
	else
	rwlp->rw_owner = 0;

	VERIFY0(pthread_rwlock_unlock(&rwlp->rw_lock));
	}

	int
	rw_tryenter(krwlock_t *rwlp, krw_t rw)
	{
	int error;

	if (rw == RW_READER)
	error = pthread_rwlock_tryrdlock(&rwlp->rw_lock);
	else
	error = pthread_rwlock_trywrlock(&rwlp->rw_lock);

	if (error == 0) {
	if (rw == RW_READER)
	atomic_inc_uint(&rwlp->rw_readers);
	else
	rwlp->rw_owner = pthread_self();

	return (1);
	}

	VERIFY3S(error, ==, EBUSY);

	return (0);
	}

	/* ARGSUSED */
	uint32_t
	zone_get_hostid(void *zonep)
	{
	/*
	* We're emulating the system's hostid in userland.
	*/
	return (strtoul(hw_serial, NULL, 10));
	}

	int
	rw_tryupgrade(krwlock_t *rwlp)
	{
	return (0);
	}

	/*
	* =========================================================================
	* condition variables
	* =========================================================================
	*/

	void
	cv_init(kcondvar_t cv, char name, int type, void *arg)
	{
	VERIFY0(pthread_cond_init(cv, NULL));
	}

	void
	cv_destroy(kcondvar_t *cv)
	{
	VERIFY0(pthread_cond_destroy(cv));
	}

	void
	cv_wait(kcondvar_t cv, kmutex_t mp)
	{
	memset(&mp->m_owner, 0, sizeof (pthread_t));
	VERIFY0(pthread_cond_wait(cv, &mp->m_lock));
	mp->m_owner = pthread_self();
	}

	int
	cv_wait_sig(kcondvar_t cv, kmutex_t mp)
	{
	cv_wait(cv, mp);
	return (1);
	}

	int
	cv_timedwait(kcondvar_t cv, kmutex_t mp, clock_t abstime)
	{
	int error;
	struct timeval tv;
	struct timespec ts;
	clock_t delta;

	delta = abstime - ddi_get_lbolt();
	if (delta <= 0)
	return (-1);

	VERIFY(gettimeofday(&tv, NULL) == 0);

	ts.tv_sec = tv.tv_sec + delta / hz;
	ts.tv_nsec = tv.tv_usec * NSEC_PER_USEC + (delta % hz) * (NANOSEC / hz);
	if (ts.tv_nsec >= NANOSEC) {
	ts.tv_sec++;
	ts.tv_nsec -= NANOSEC;
	}

	memset(&mp->m_owner, 0, sizeof (pthread_t));
	error = pthread_cond_timedwait(cv, &mp->m_lock, &ts);
	mp->m_owner = pthread_self();

	if (error == ETIMEDOUT)
	return (-1);

	VERIFY0(error);

	return (1);
	}

	/ARGSUSED/
	int
	cv_timedwait_hires(kcondvar_t cv, kmutex_t mp, hrtime_t tim, hrtime_t res,
	int flag)
	{
	int error;
	struct timeval tv;
	struct timespec ts;
	hrtime_t delta;

	ASSERT(flag == 0 \|\| flag == CALLOUT_FLAG_ABSOLUTE);

	delta = tim;
	if (flag & CALLOUT_FLAG_ABSOLUTE)
	delta -= gethrtime();

	if (delta <= 0)
	return (-1);

	VERIFY0(gettimeofday(&tv, NULL));

	ts.tv_sec = tv.tv_sec + delta / NANOSEC;
	ts.tv_nsec = tv.tv_usec * NSEC_PER_USEC + (delta % NANOSEC);
	if (ts.tv_nsec >= NANOSEC) {
	ts.tv_sec++;
	ts.tv_nsec -= NANOSEC;
	}

	memset(&mp->m_owner, 0, sizeof (pthread_t));
	error = pthread_cond_timedwait(cv, &mp->m_lock, &ts);
	mp->m_owner = pthread_self();

	if (error == ETIMEDOUT)
	return (-1);

	VERIFY0(error);

	return (1);
	}

	void
	cv_signal(kcondvar_t *cv)
	{
	VERIFY0(pthread_cond_signal(cv));
	}

	void
	cv_broadcast(kcondvar_t *cv)
	{
	VERIFY0(pthread_cond_broadcast(cv));
	}

	/*
	* =========================================================================
	* procfs list
	* =========================================================================
	*/

	void
	seq_printf(struct seq_file m, const char fmt, ...)
	{}

	void
	procfs_list_install(const char *module,
	const char *submodule,
	const char *name,
	mode_t mode,
	procfs_list_t *procfs_list,
	int (show)(struct seq_file f, void *p),
	int (show_header)(struct seq_file f),
	int (clear)(procfs_list_t procfs_list),
	size_t procfs_list_node_off)
	{
	mutex_init(&procfs_list->pl_lock, NULL, MUTEX_DEFAULT, NULL);
	list_create(&procfs_list->pl_list,
	procfs_list_node_off + sizeof (procfs_list_node_t),
	procfs_list_node_off + offsetof(procfs_list_node_t, pln_link));
	procfs_list->pl_next_id = 1;
	procfs_list->pl_node_offset = procfs_list_node_off;
	}

	void
	procfs_list_uninstall(procfs_list_t *procfs_list)
	{}

	void
	procfs_list_destroy(procfs_list_t *procfs_list)
	{
	ASSERT(list_is_empty(&procfs_list->pl_list));
	list_destroy(&procfs_list->pl_list);
	mutex_destroy(&procfs_list->pl_lock);
	}

	#define NODE_ID(procfs_list, obj) \
	(((procfs_list_node_t )(((char )obj) + \
	(procfs_list)->pl_node_offset))->pln_id)

	void
	procfs_list_add(procfs_list_t procfs_list, void p)
	{
	ASSERT(MUTEX_HELD(&procfs_list->pl_lock));
	NODE_ID(procfs_list, p) = procfs_list->pl_next_id++;
	list_insert_tail(&procfs_list->pl_list, p);
	}

	/*
	* =========================================================================
	* vnode operations
	* =========================================================================
	*/

	/*
	* =========================================================================
	* Figure out which debugging statements to print
	* =========================================================================
	*/

	static char *dprintf_string;
	static int dprintf_print_all;

	int
	dprintf_find_string(const char *string)
	{
	char *tmp_str = dprintf_string;
	int len = strlen(string);

	/*
	* Find out if this is a string we want to print.
	* String format: file1.c,function_name1,file2.c,file3.c
	*/

	while (tmp_str != NULL) {
	if (strncmp(tmp_str, string, len) == 0 &&
	(tmp_str[len] == ',' \|\| tmp_str[len] == '\0'))
	return (1);
	tmp_str = strchr(tmp_str, ',');
	if (tmp_str != NULL)
	tmp_str++; /* Get rid of , */
	}
	return (0);
	}

	void
	dprintf_setup(int argc, char *argv)
	{
	int i, j;

	/*
	* Debugging can be specified two ways: by setting the
	* environment variable ZFS_DEBUG, or by including a
	* "debug=..." argument on the command line. The command
	* line setting overrides the environment variable.
	*/

	for (i = 1; i < *argc; i++) {
	int len = strlen("debug=");
	/* First look for a command line argument */
	if (strncmp("debug=", argv[i], len) == 0) {
	dprintf_string = argv[i] + len;
	/* Remove from args */
	for (j = i; j < *argc; j++)
	argv[j] = argv[j+1];
	argv[j] = NULL;
	(*argc)--;
	}
	}

	if (dprintf_string == NULL) {
	/* Look for ZFS_DEBUG environment variable */
	dprintf_string = getenv("ZFS_DEBUG");
	}

	/*
	* Are we just turning on all debugging?
	*/
	if (dprintf_find_string("on"))
	dprintf_print_all = 1;

	if (dprintf_string != NULL)
	zfs_flags \|= ZFS_DEBUG_DPRINTF;
	}

	/*
	* =========================================================================
	* debug printfs
	* =========================================================================
	*/
	void
	__dprintf(boolean_t dprint, const char file, const char func,
	int line, const char *fmt, ...)
	{
	const char *newfile;
	va_list adx;

	/*
	* Get rid of annoying "../common/" prefix to filename.
	*/
	newfile = strrchr(file, '/');
	if (newfile != NULL) {
	newfile = newfile + 1; /* Get rid of leading / */
	} else {
	newfile = file;
	}

	if (dprint) {
	/* dprintf messages are printed immediately */

	if (!dprintf_print_all &&
	!dprintf_find_string(newfile) &&
	!dprintf_find_string(func))
	return;

	/* Print out just the function name if requested */
	flockfile(stdout);
	if (dprintf_find_string("pid"))
	(void) printf("%d ", getpid());
	if (dprintf_find_string("tid"))
	(void) printf("%ju ",
	(uintmax_t)(uintptr_t)pthread_self());
	if (dprintf_find_string("cpu"))
	(void) printf("%u ", getcpuid());
	if (dprintf_find_string("time"))
	(void) printf("%llu ", gethrtime());
	if (dprintf_find_string("long"))
	(void) printf("%s, line %d: ", newfile, line);
	(void) printf("dprintf: %s: ", func);
	va_start(adx, fmt);
	(void) vprintf(fmt, adx);
	va_end(adx);
	funlockfile(stdout);
	} else {
	/* zfs_dbgmsg is logged for dumping later */
	size_t size;
	char *buf;
	int i;

	size = 1024;
	buf = umem_alloc(size, UMEM_NOFAIL);
	i = snprintf(buf, size, "%s:%d:%s(): ", newfile, line, func);

	if (i < size) {
	va_start(adx, fmt);
	(void) vsnprintf(buf + i, size - i, fmt, adx);
	va_end(adx);
	}

	__zfs_dbgmsg(buf);

	umem_free(buf, size);
	}
	}

	/*
	* =========================================================================
	* cmn_err() and panic()
	* =========================================================================
	*/
	static char ce_prefix[CE_IGNORE][10] = { "", "NOTICE: ", "WARNING: ", "" };
	static char ce_suffix[CE_IGNORE][2] = { "", "\n", "\n", "" };

	void
	vpanic(const char *fmt, va_list adx)
	{
	(void) fprintf(stderr, "error: ");
	(void) vfprintf(stderr, fmt, adx);
	(void) fprintf(stderr, "\n");

	abort(); /* think of it as a "user-level crash dump" */
	}

	void
	panic(const char *fmt, ...)
	{
	va_list adx;

	va_start(adx, fmt);
	vpanic(fmt, adx);
	va_end(adx);
	}

	void
	vcmn_err(int ce, const char *fmt, va_list adx)
	{
	if (ce == CE_PANIC)
	vpanic(fmt, adx);
	if (ce != CE_NOTE) { /* suppress noise in userland stress testing */
	(void) fprintf(stderr, "%s", ce_prefix[ce]);
	(void) vfprintf(stderr, fmt, adx);
	(void) fprintf(stderr, "%s", ce_suffix[ce]);
	}
	}

	/PRINTFLIKE2/
	void
	cmn_err(int ce, const char *fmt, ...)
	{
	va_list adx;

	va_start(adx, fmt);
	vcmn_err(ce, fmt, adx);
	va_end(adx);
	}

	/*
	* =========================================================================
	* misc routines
	* =========================================================================
	*/

	void
	delay(clock_t ticks)
	{
	(void) poll(0, 0, ticks * (1000 / hz));
	}

	/*
	* Find highest one bit set.
	* Returns bit number + 1 of highest bit that is set, otherwise returns 0.
	* The __builtin_clzll() function is supported by both GCC and Clang.
	*/
	int
	highbit64(uint64_t i)
	{
	if (i == 0)
	return (0);

	return (NBBY * sizeof (uint64_t) - __builtin_clzll(i));
	}

	/*
	* Find lowest one bit set.
	* Returns bit number + 1 of lowest bit that is set, otherwise returns 0.
	* The __builtin_ffsll() function is supported by both GCC and Clang.
	*/
	int
	lowbit64(uint64_t i)
	{
	if (i == 0)
	return (0);

	return (__builtin_ffsll(i));
	}

	-char *random_path = "/dev/random";
	-char *urandom_path = "/dev/urandom";
	+const char *random_path = "/dev/random";
	+const char *urandom_path = "/dev/urandom";
	static int random_fd = -1, urandom_fd = -1;

	void
	random_init(void)
	{
	- VERIFY((random_fd = open(random_path, O_RDONLY)) != -1);
	- VERIFY((urandom_fd = open(urandom_path, O_RDONLY)) != -1);
	+ VERIFY((random_fd = open(random_path, O_RDONLY \| O_CLOEXEC)) != -1);
	+ VERIFY((urandom_fd = open(urandom_path, O_RDONLY \| O_CLOEXEC)) != -1);
	}

	void
	random_fini(void)
	{
	close(random_fd);
	close(urandom_fd);

	random_fd = -1;
	urandom_fd = -1;
	}

	static int
	random_get_bytes_common(uint8_t *ptr, size_t len, int fd)
	{
	size_t resid = len;
	ssize_t bytes;

	ASSERT(fd != -1);

	while (resid != 0) {
	bytes = read(fd, ptr, resid);
	ASSERT3S(bytes, >=, 0);
	ptr += bytes;
	resid -= bytes;
	}

	return (0);
	}

	int
	random_get_bytes(uint8_t *ptr, size_t len)
	{
	return (random_get_bytes_common(ptr, len, random_fd));
	}

	int
	random_get_pseudo_bytes(uint8_t *ptr, size_t len)
	{
	return (random_get_bytes_common(ptr, len, urandom_fd));
	}

	int
	ddi_strtoul(const char hw_serial, char nptr, int base, unsigned long result)
	{
	char *end;

	*result = strtoul(hw_serial, &end, base);
	if (*result == 0)
	return (errno);
	return (0);
	}

	int
	ddi_strtoull(const char str, char nptr, int base, u_longlong_t result)
	{
	char *end;

	*result = strtoull(str, &end, base);
	if (*result == 0)
	return (errno);
	return (0);
	}

	utsname_t *
	utsname(void)
	{
	return (&hw_utsname);
	}

	/*
	* =========================================================================
	* kernel emulation setup & teardown
	* =========================================================================
	*/
	static int
	umem_out_of_memory(void)
	{
	char errmsg[] = "out of memory -- generating core dump\n";

	(void) fprintf(stderr, "%s", errmsg);
	abort();
	return (0);
	}

	void
	kernel_init(int mode)
	{
	extern uint_t rrw_tsd_key;

	umem_nofail_callback(umem_out_of_memory);

	physmem = sysconf(_SC_PHYS_PAGES);

	dprintf("physmem = %llu pages (%.2f GB)\n", physmem,
	(double)physmem * sysconf(_SC_PAGE_SIZE) / (1ULL << 30));

	(void) snprintf(hw_serial, sizeof (hw_serial), "%ld",
	(mode & SPA_MODE_WRITE) ? get_system_hostid() : 0);

	random_init();

	VERIFY0(uname(&hw_utsname));

	system_taskq_init();
	icp_init();

	zstd_init();

	spa_init((spa_mode_t)mode);

	fletcher_4_init();

	tsd_create(&rrw_tsd_key, rrw_tsd_destroy);
	}

	void
	kernel_fini(void)
	{
	fletcher_4_fini();
	spa_fini();

	zstd_fini();

	icp_fini();
	system_taskq_fini();

	random_fini();
	}

	uid_t
	crgetuid(cred_t *cr)
	{
	return (0);
	}

	uid_t
	crgetruid(cred_t *cr)
	{
	return (0);
	}

	gid_t
	crgetgid(cred_t *cr)
	{
	return (0);
	}

	int
	crgetngroups(cred_t *cr)
	{
	return (0);
	}

	gid_t *
	crgetgroups(cred_t *cr)
	{
	return (NULL);
	}

	int
	zfs_secpolicy_snapshot_perms(const char name, cred_t cr)
	{
	return (0);
	}

	int
	zfs_secpolicy_rename_perms(const char from, const char to, cred_t *cr)
	{
	return (0);
	}

	int
	zfs_secpolicy_destroy_perms(const char name, cred_t cr)
	{
	return (0);
	}

	int
	secpolicy_zfs(const cred_t *cr)
	{
	return (0);
	}

	int
	secpolicy_zfs_proc(const cred_t cr, proc_t proc)
	{
	return (0);
	}

	ksiddomain_t *
	ksid_lookupdomain(const char *dom)
	{
	ksiddomain_t *kd;

	kd = umem_zalloc(sizeof (ksiddomain_t), UMEM_NOFAIL);
	kd->kd_name = spa_strdup(dom);
	return (kd);
	}

	void
	ksiddomain_rele(ksiddomain_t *ksid)
	{
	spa_strfree(ksid->kd_name);
	umem_free(ksid, sizeof (ksiddomain_t));
	}

	char *
	kmem_vasprintf(const char *fmt, va_list adx)
	{
	char *buf = NULL;
	va_list adx_copy;

	va_copy(adx_copy, adx);
	VERIFY(vasprintf(&buf, fmt, adx_copy) != -1);
	va_end(adx_copy);

	return (buf);
	}

	char *
	kmem_asprintf(const char *fmt, ...)
	{
	char *buf = NULL;
	va_list adx;

	va_start(adx, fmt);
	VERIFY(vasprintf(&buf, fmt, adx) != -1);
	va_end(adx);

	return (buf);
	}

	/* ARGSUSED */
	int
	zfs_onexit_fd_hold(int fd, minor_t *minorp)
	{
	*minorp = 0;
	return (0);
	}

	/* ARGSUSED */
	void
	zfs_onexit_fd_rele(int fd)
	{
	}

	/* ARGSUSED */
	int
	zfs_onexit_add_cb(minor_t minor, void (func)(void ), void *data,
	uint64_t *action_handle)
	{
	return (0);
	}

	fstrans_cookie_t
	spl_fstrans_mark(void)
	{
	return ((fstrans_cookie_t)0);
	}

	void
	spl_fstrans_unmark(fstrans_cookie_t cookie)
	{
	}

	int
	__spl_pf_fstrans_check(void)
	{
	return (0);
	}

	int
	kmem_cache_reap_active(void)
	{
	return (0);
	}

	void *zvol_tag = "zvol_tag";

	void
	zvol_create_minor(const char *name)
	{
	}

	void
	zvol_create_minors_recursive(const char *name)
	{
	}

	void
	zvol_remove_minors(spa_t spa, const char name, boolean_t async)
	{
	}

	void
	zvol_rename_minors(spa_t spa, const char oldname, const char *newname,
	boolean_t async)
	{
	}

	/*
	* Open file
	*
	* path - fully qualified path to file
	* flags - file attributes O_READ / O_WRITE / O_EXCL
	* fpp - pointer to return file pointer
	*
	* Returns 0 on success underlying error on failure.
	*/
	int
	zfs_file_open(const char path, int flags, int mode, zfs_file_t *fpp)
	{
	int fd = -1;
	int dump_fd = -1;
	int err;
	int old_umask = 0;
	zfs_file_t *fp;
	struct stat64 st;

	if (!(flags & O_CREAT) && stat64(path, &st) == -1)
	return (errno);

	if (!(flags & O_CREAT) && S_ISBLK(st.st_mode))
	flags \|= O_DIRECT;

	if (flags & O_CREAT)
	old_umask = umask(0);

	fd = open64(path, flags, mode);
	if (fd == -1)
	return (errno);

	if (flags & O_CREAT)
	(void) umask(old_umask);

	if (vn_dumpdir != NULL) {
	char *dumppath = umem_zalloc(MAXPATHLEN, UMEM_NOFAIL);
	char inpath = basename((char )(uintptr_t)path);

	(void) snprintf(dumppath, MAXPATHLEN,
	"%s/%s", vn_dumpdir, inpath);
	dump_fd = open64(dumppath, O_CREAT \| O_WRONLY, 0666);
	umem_free(dumppath, MAXPATHLEN);
	if (dump_fd == -1) {
	err = errno;
	close(fd);
	return (err);
	}
	} else {
	dump_fd = -1;
	}

	(void) fcntl(fd, F_SETFD, FD_CLOEXEC);

	fp = umem_zalloc(sizeof (zfs_file_t), UMEM_NOFAIL);
	fp->f_fd = fd;
	fp->f_dump_fd = dump_fd;
	*fpp = fp;

	return (0);
	}

	void
	zfs_file_close(zfs_file_t *fp)
	{
	close(fp->f_fd);
	if (fp->f_dump_fd != -1)
	close(fp->f_dump_fd);

	umem_free(fp, sizeof (zfs_file_t));
	}

	/*
	* Stateful write - use os internal file pointer to determine where to
	* write and update on successful completion.
	*
	* fp - pointer to file (pipe, socket, etc) to write to
	* buf - buffer to write
	* count - # of bytes to write
	* resid - pointer to count of unwritten bytes (if short write)
	*
	* Returns 0 on success errno on failure.
	*/
	int
	zfs_file_write(zfs_file_t fp, const void buf, size_t count, ssize_t *resid)
	{
	ssize_t rc;

	rc = write(fp->f_fd, buf, count);
	if (rc < 0)
	return (errno);

	if (resid) {
	*resid = count - rc;
	} else if (rc != count) {
	return (EIO);
	}

	return (0);
	}

	/*
	* Stateless write - os internal file pointer is not updated.
	*
	* fp - pointer to file (pipe, socket, etc) to write to
	* buf - buffer to write
	* count - # of bytes to write
	* off - file offset to write to (only valid for seekable types)
	* resid - pointer to count of unwritten bytes
	*
	* Returns 0 on success errno on failure.
	*/
	int
	zfs_file_pwrite(zfs_file_t fp, const void buf,
	size_t count, loff_t pos, ssize_t *resid)
	{
	ssize_t rc, split, done;
	int sectors;

	/*
	* To simulate partial disk writes, we split writes into two
	* system calls so that the process can be killed in between.
	* This is used by ztest to simulate realistic failure modes.
	*/
	sectors = count >> SPA_MINBLOCKSHIFT;
	split = (sectors > 0 ? rand() % sectors : 0) << SPA_MINBLOCKSHIFT;
	rc = pwrite64(fp->f_fd, buf, split, pos);
	if (rc != -1) {
	done = rc;
	rc = pwrite64(fp->f_fd, (char *)buf + split,
	count - split, pos + split);
	}
	#ifdef __linux__
	if (rc == -1 && errno == EINVAL) {
	/*
	* Under Linux, this most likely means an alignment issue
	* (memory or disk) due to O_DIRECT, so we abort() in order
	* to catch the offender.
	*/
	abort();
	}
	#endif

	if (rc < 0)
	return (errno);

	done += rc;

	if (resid) {
	*resid = count - done;
	} else if (done != count) {
	return (EIO);
	}

	return (0);
	}

	/*
	* Stateful read - use os internal file pointer to determine where to
	* read and update on successful completion.
	*
	* fp - pointer to file (pipe, socket, etc) to read from
	* buf - buffer to write
	* count - # of bytes to read
	* resid - pointer to count of unread bytes (if short read)
	*
	* Returns 0 on success errno on failure.
	*/
	int
	zfs_file_read(zfs_file_t fp, void buf, size_t count, ssize_t *resid)
	{
	int rc;

	rc = read(fp->f_fd, buf, count);
	if (rc < 0)
	return (errno);

	if (resid) {
	*resid = count - rc;
	} else if (rc != count) {
	return (EIO);
	}

	return (0);
	}

	/*
	* Stateless read - os internal file pointer is not updated.
	*
	* fp - pointer to file (pipe, socket, etc) to read from
	* buf - buffer to write
	* count - # of bytes to write
	* off - file offset to read from (only valid for seekable types)
	* resid - pointer to count of unwritten bytes (if short write)
	*
	* Returns 0 on success errno on failure.
	*/
	int
	zfs_file_pread(zfs_file_t fp, void buf, size_t count, loff_t off,
	ssize_t *resid)
	{
	ssize_t rc;

	rc = pread64(fp->f_fd, buf, count, off);
	if (rc < 0) {
	#ifdef __linux__
	/*
	* Under Linux, this most likely means an alignment issue
	* (memory or disk) due to O_DIRECT, so we abort() in order to
	* catch the offender.
	*/
	if (errno == EINVAL)
	abort();
	#endif
	return (errno);
	}

	if (fp->f_dump_fd != -1) {
	int status;

	status = pwrite64(fp->f_dump_fd, buf, rc, off);
	ASSERT(status != -1);
	}

	if (resid) {
	*resid = count - rc;
	} else if (rc != count) {
	return (EIO);
	}

	return (0);
	}

	/*
	* lseek - set / get file pointer
	*
	* fp - pointer to file (pipe, socket, etc) to read from
	* offp - value to seek to, returns current value plus passed offset
	* whence - see man pages for standard lseek whence values
	*
	* Returns 0 on success errno on failure (ESPIPE for non seekable types)
	*/
	int
	zfs_file_seek(zfs_file_t fp, loff_t offp, int whence)
	{
	loff_t rc;

	rc = lseek(fp->f_fd, *offp, whence);
	if (rc < 0)
	return (errno);

	*offp = rc;

	return (0);
	}

	/*
	* Get file attributes
	*
	* filp - file pointer
	* zfattr - pointer to file attr structure
	*
	* Currently only used for fetching size and file mode
	*
	* Returns 0 on success or error code of underlying getattr call on failure.
	*/
	int
	zfs_file_getattr(zfs_file_t fp, zfs_file_attr_t zfattr)
	{
	struct stat64 st;

	if (fstat64_blk(fp->f_fd, &st) == -1)
	return (errno);

	zfattr->zfa_size = st.st_size;
	zfattr->zfa_mode = st.st_mode;

	return (0);
	}

	/*
	* Sync file to disk
	*
	* filp - file pointer
	* flags - O_SYNC and or O_DSYNC
	*
	* Returns 0 on success or error code of underlying sync call on failure.
	*/
	int
	zfs_file_fsync(zfs_file_t *fp, int flags)
	{
	int rc;

	rc = fsync(fp->f_fd);
	if (rc < 0)
	return (errno);

	return (0);
	}

	/*
	* fallocate - allocate or free space on disk
	*
	* fp - file pointer
	* mode (non-standard options for hole punching etc)
	* offset - offset to start allocating or freeing from
	* len - length to free / allocate
	*
	* OPTIONAL
	*/
	int
	zfs_file_fallocate(zfs_file_t *fp, int mode, loff_t offset, loff_t len)
	{
	#ifdef __linux__
	return (fallocate(fp->f_fd, mode, offset, len));
	#else
	return (EOPNOTSUPP);
	#endif
	}

	/*
	* Request current file pointer offset
	*
	* fp - pointer to file
	*
	* Returns current file offset.
	*/
	loff_t
	zfs_file_off(zfs_file_t *fp)
	{
	return (lseek(fp->f_fd, SEEK_CUR, 0));
	}

	/*
	* unlink file
	*
	* path - fully qualified file path
	*
	* Returns 0 on success.
	*
	* OPTIONAL
	*/
	int
	zfs_file_unlink(const char *path)
	{
	return (remove(path));
	}

	/*
	* Get reference to file pointer
	*
	* fd - input file descriptor
	* fpp - pointer to file pointer
	*
	* Returns 0 on success EBADF on failure.
	* Unsupported in user space.
	*/
	int
	zfs_file_get(int fd, zfs_file_t **fpp)
	{
	abort();

	return (EOPNOTSUPP);
	}

	/*
	* Drop reference to file pointer
	*
	* fd - input file descriptor
	*
	* Unsupported in user space.
	*/
	void
	zfs_file_put(int fd)
	{
	abort();
	}

	void
	zfsvfs_update_fromname(const char oldname, const char newname)
	{
	}
	diff --git a/sys/contrib/openzfs/lib/libzpool/util.c b/sys/contrib/openzfs/lib/libzpool/util.c
	index 2da2375a1d2d..20cabe7c2e29 100644
	--- a/sys/contrib/openzfs/lib/libzpool/util.c
	+++ b/sys/contrib/openzfs/lib/libzpool/util.c
	@@ -1,293 +1,293 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2016 by Delphix. All rights reserved.
	* Copyright 2017 Jason King
	* Copyright (c) 2017, Intel Corporation.
	*/

	#include <assert.h>
	#include <sys/zfs_context.h>
	#include <sys/avl.h>
	#include <string.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <sys/spa.h>
	#include <sys/fs/zfs.h>
	#include <sys/zfs_refcount.h>
	#include <sys/zfs_ioctl.h>
	#include <dlfcn.h>
	#include <libzutil.h>

	/*
	* Routines needed by more than one client of libzpool.
	*/

	static void
	show_vdev_stats(const char desc, const char ctype, nvlist_t *nv, int indent)
	{
	vdev_stat_t *vs;
	vdev_stat_t *v0 = { 0 };
	uint64_t sec;
	uint64_t is_log = 0;
	nvlist_t **child;
	uint_t c, children;
	char used[6], avail[6];
	char rops[6], wops[6], rbytes[6], wbytes[6], rerr[6], werr[6], cerr[6];

	v0 = umem_zalloc(sizeof (*v0), UMEM_NOFAIL);

	if (indent == 0 && desc != NULL) {
	(void) printf(" "
	" capacity operations bandwidth ---- errors ----\n");
	(void) printf("description "
	"used avail read write read write read write cksum\n");
	}

	if (desc != NULL) {
	char suffix = "", bias = NULL;
	char bias_suffix[32];

	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_IS_LOG, &is_log);
	(void) nvlist_lookup_string(nv, ZPOOL_CONFIG_ALLOCATION_BIAS,
	&bias);
	if (nvlist_lookup_uint64_array(nv, ZPOOL_CONFIG_VDEV_STATS,
	(uint64_t **)&vs, &c) != 0)
	vs = v0;

	if (bias != NULL) {
	(void) snprintf(bias_suffix, sizeof (bias_suffix),
	" (%s)", bias);
	suffix = bias_suffix;
	} else if (is_log) {
	suffix = " (log)";
	}

	sec = MAX(1, vs->vs_timestamp / NANOSEC);

	nicenum(vs->vs_alloc, used, sizeof (used));
	nicenum(vs->vs_space - vs->vs_alloc, avail, sizeof (avail));
	nicenum(vs->vs_ops[ZIO_TYPE_READ] / sec, rops, sizeof (rops));
	nicenum(vs->vs_ops[ZIO_TYPE_WRITE] / sec, wops, sizeof (wops));
	nicenum(vs->vs_bytes[ZIO_TYPE_READ] / sec, rbytes,
	sizeof (rbytes));
	nicenum(vs->vs_bytes[ZIO_TYPE_WRITE] / sec, wbytes,
	sizeof (wbytes));
	nicenum(vs->vs_read_errors, rerr, sizeof (rerr));
	nicenum(vs->vs_write_errors, werr, sizeof (werr));
	nicenum(vs->vs_checksum_errors, cerr, sizeof (cerr));

	(void) printf("%s%s%s%s%s %5s %5s %5s %5s %5s %5s %5s\n",
	indent, "",
	desc,
	(int)(indent+strlen(desc)-25-(vs->vs_space ? 0 : 12)),
	suffix,
	vs->vs_space ? 6 : 0, vs->vs_space ? used : "",
	vs->vs_space ? 6 : 0, vs->vs_space ? avail : "",
	rops, wops, rbytes, wbytes, rerr, werr, cerr);
	}
	umem_free(v0, sizeof (*v0));

	if (nvlist_lookup_nvlist_array(nv, ctype, &child, &children) != 0)
	return;

	for (c = 0; c < children; c++) {
	nvlist_t *cnv = child[c];
	char cname = NULL, tname;
	uint64_t np;
	int len;
	if (nvlist_lookup_string(cnv, ZPOOL_CONFIG_PATH, &cname) &&
	nvlist_lookup_string(cnv, ZPOOL_CONFIG_TYPE, &cname))
	cname = "<unknown>";
	len = strlen(cname) + 2;
	tname = umem_zalloc(len, UMEM_NOFAIL);
	(void) strlcpy(tname, cname, len);
	if (nvlist_lookup_uint64(cnv, ZPOOL_CONFIG_NPARITY, &np) == 0)
	tname[strlen(tname)] = '0' + np;
	show_vdev_stats(tname, ctype, cnv, indent + 2);
	umem_free(tname, len);
	}
	}

	void
	show_pool_stats(spa_t *spa)
	{
	nvlist_t config, nvroot;
	char *name;

	VERIFY(spa_get_stats(spa_name(spa), &config, NULL, 0) == 0);

	VERIFY(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
	&nvroot) == 0);
	VERIFY(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME,
	&name) == 0);

	show_vdev_stats(name, ZPOOL_CONFIG_CHILDREN, nvroot, 0);
	show_vdev_stats(NULL, ZPOOL_CONFIG_L2CACHE, nvroot, 0);
	show_vdev_stats(NULL, ZPOOL_CONFIG_SPARES, nvroot, 0);

	nvlist_free(config);
	}

	/* k_out must be freed by the caller /
	static int
	set_global_var_parse_kv(const char arg, char k_out, u_longlong_t v_out)
	{
	int err;
	VERIFY(arg);
	char *d = strdup(arg);

	char *save = NULL;
	char *k = strtok_r(d, "=", &save);
	char *v_str = strtok_r(NULL, "=", &save);
	char *follow = strtok_r(NULL, "=", &save);
	if (k == NULL \|\| v_str == NULL \|\| follow != NULL) {
	err = EINVAL;
	goto err_free;
	}

	u_longlong_t val = strtoull(v_str, NULL, 0);
	if (val > UINT32_MAX) {
	fprintf(stderr, "Value for global variable '%s' must "
	"be a 32-bit unsigned integer, got '%s'\n", k, v_str);
	err = EOVERFLOW;
	goto err_free;
	}

	*k_out = k;
	*v_out = val;
	return (0);

	err_free:
	free(k);

	return (err);
	}

	/*
	* Sets given global variable in libzpool to given unsigned 32-bit value.
	* arg: "<variable>=<value>"
	*/
	int
	set_global_var(char const *arg)
	{
	void *zpoolhdl;
	char *varname;
	u_longlong_t val;
	int ret;

	#ifndef _ZFS_LITTLE_ENDIAN
	/*
	* On big endian systems changing a 64-bit variable would set the high
	* 32 bits instead of the low 32 bits, which could cause unexpected
	* results.
	*/
	fprintf(stderr, "Setting global variables is only supported on "
	"little-endian systems\n");
	ret = ENOTSUP;
	goto out_ret;
	#endif

	if ((ret = set_global_var_parse_kv(arg, &varname, &val)) != 0) {
	goto out_ret;
	}

	zpoolhdl = dlopen("libzpool.so", RTLD_LAZY);
	if (zpoolhdl != NULL) {
	uint32_t *var;
	var = dlsym(zpoolhdl, varname);
	if (var == NULL) {
	fprintf(stderr, "Global variable '%s' does not exist "
	"in libzpool.so\n", varname);
	ret = EINVAL;
	goto out_dlclose;
	}
	*var = (uint32_t)val;

	} else {
	fprintf(stderr, "Failed to open libzpool.so to set global "
	"variable\n");
	ret = EIO;
	goto out_dlclose;
	}

	ret = 0;

	out_dlclose:
	dlclose(zpoolhdl);
	free(varname);
	out_ret:
	return (ret);
	}

	static nvlist_t *
	refresh_config(void unused, nvlist_t tryconfig)
	{
	return (spa_tryimport(tryconfig));
	}

	static int
	pool_active(void unused, const char name, uint64_t guid,
	boolean_t *isactive)
	{
	zfs_cmd_t *zcp;
	nvlist_t *innvl;
	char *packed = NULL;
	size_t size = 0;
	int fd, ret;

	/*
	* Use ZFS_IOC_POOL_SYNC to confirm if a pool is active
	*/

	- fd = open(ZFS_DEV, O_RDWR);
	+ fd = open(ZFS_DEV, O_RDWR \| O_CLOEXEC);
	if (fd < 0)
	return (-1);

	zcp = umem_zalloc(sizeof (zfs_cmd_t), UMEM_NOFAIL);

	innvl = fnvlist_alloc();
	fnvlist_add_boolean_value(innvl, "force", B_FALSE);

	(void) strlcpy(zcp->zc_name, name, sizeof (zcp->zc_name));
	packed = fnvlist_pack(innvl, &size);
	zcp->zc_nvlist_src = (uint64_t)(uintptr_t)packed;
	zcp->zc_nvlist_src_size = size;

	ret = zfs_ioctl_fd(fd, ZFS_IOC_POOL_SYNC, zcp);

	fnvlist_pack_free(packed, size);
	free((void *)(uintptr_t)zcp->zc_nvlist_dst);
	nvlist_free(innvl);
	umem_free(zcp, sizeof (zfs_cmd_t));

	(void) close(fd);

	*isactive = (ret == 0);

	return (0);
	}

	const pool_config_ops_t libzpool_config_ops = {
	.pco_refresh_config = refresh_config,
	.pco_pool_active = pool_active,
	};
	diff --git a/sys/contrib/openzfs/lib/libzutil/os/freebsd/zutil_import_os.c b/sys/contrib/openzfs/lib/libzutil/os/freebsd/zutil_import_os.c
	index ff2c0789b580..36c4d90aa4b9 100644
	--- a/sys/contrib/openzfs/lib/libzutil/os/freebsd/zutil_import_os.c
	+++ b/sys/contrib/openzfs/lib/libzutil/os/freebsd/zutil_import_os.c
	@@ -1,249 +1,249 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2012, 2017 by Delphix. All rights reserved.
	* Copyright 2015 RackTop Systems.
	* Copyright 2016 Nexenta Systems, Inc.
	*/

	/*
	* Pool import support functions.
	*
	* To import a pool, we rely on reading the configuration information from the
	* ZFS label of each device. If we successfully read the label, then we
	* organize the configuration information in the following hierarchy:
	*
	* pool guid -> toplevel vdev guid -> label txg
	*
	* Duplicate entries matching this same tuple will be discarded. Once we have
	* examined every device, we pick the best label txg config for each toplevel
	* vdev. We then arrange these toplevel vdevs into a complete pool config, and
	* update any paths that have changed. Finally, we attempt to import the pool
	* using our derived config, and record the results.
	*/

	#include <sys/types.h>
	#include <sys/disk.h>
	#include <sys/ioctl.h>
	#include <sys/stat.h>
	#include <sys/sysctl.h>

	#include <aio.h>
	#include <ctype.h>
	#include <dirent.h>
	#include <errno.h>
	#include <libintl.h>
	#include <libgen.h>
	#include <stddef.h>
	#include <stdlib.h>
	#include <string.h>
	#include <unistd.h>
	#include <fcntl.h>

	#include <sys/efi_partition.h>
	#include <thread_pool.h>
	#include <libgeom.h>

	#include <sys/vdev_impl.h>

	#include <libzutil.h>

	#include "zutil_import.h"

	/*
	* Update a leaf vdev's persistent device strings
	*
	* - only applies for a dedicated leaf vdev (aka whole disk)
	* - updated during pool create\|add\|attach\|import
	* - used for matching device matching during auto-{online,expand,replace}
	* - stored in a leaf disk config label (i.e. alongside 'path' NVP)
	* - these strings are currently not used in kernel (i.e. for vdev_disk_open)
	*
	* On FreeBSD we currently just strip devid and phys_path to avoid confusion.
	*/
	void
	update_vdev_config_dev_strs(nvlist_t *nv)
	{
	(void) nvlist_remove_all(nv, ZPOOL_CONFIG_DEVID);
	(void) nvlist_remove_all(nv, ZPOOL_CONFIG_PHYS_PATH);
	}

	/*
	* Do not even look at these devices.
	*/
	static const char * const excluded_devs[] = {
	"nfslock",
	"sequencer",
	"zfs",
	};
	#define EXCLUDED_DIR "/dev/"
	#define EXCLUDED_DIR_LEN 5

	void
	zpool_open_func(void *arg)
	{
	rdsk_node_t *rn = arg;
	struct stat64 statbuf;
	nvlist_t *config;
	size_t i;
	int num_labels;
	int fd;
	off_t mediasize = 0;

	/*
	* Do not even look at excluded devices.
	*/
	if (strncmp(rn->rn_name, EXCLUDED_DIR, EXCLUDED_DIR_LEN) == 0) {
	char *name = rn->rn_name + EXCLUDED_DIR_LEN;
	for (i = 0; i < nitems(excluded_devs); ++i) {
	const char *excluded_name = excluded_devs[i];
	size_t len = strlen(excluded_name);
	if (strncmp(name, excluded_name, len) == 0) {
	return;
	}
	}
	}

	/*
	* O_NONBLOCK so we don't hang trying to open things like serial ports.
	*/
	- if ((fd = open(rn->rn_name, O_RDONLY\|O_NONBLOCK)) < 0)
	+ if ((fd = open(rn->rn_name, O_RDONLY\|O_NONBLOCK\|O_CLOEXEC)) < 0)
	return;

	/*
	* Ignore failed stats.
	*/
	if (fstat64(fd, &statbuf) != 0)
	goto out;
	/*
	* We only want regular files, character devs and block devs.
	*/
	if (S_ISREG(statbuf.st_mode)) {
	/* Check if this file is too small to hold a zpool. */
	if (statbuf.st_size < SPA_MINDEVSIZE) {
	goto out;
	}
	} else if (S_ISCHR(statbuf.st_mode) \|\| S_ISBLK(statbuf.st_mode)) {
	/* Check if this device is too small to hold a zpool. */
	if (ioctl(fd, DIOCGMEDIASIZE, &mediasize) != 0 \|\|
	mediasize < SPA_MINDEVSIZE) {
	goto out;
	}
	} else {
	goto out;
	}

	if (zpool_read_label(fd, &config, &num_labels) != 0)
	goto out;
	if (num_labels == 0) {
	nvlist_free(config);
	goto out;
	}

	rn->rn_config = config;
	rn->rn_num_labels = num_labels;

	/* TODO: Reuse labelpaths logic from Linux? */
	out:
	(void) close(fd);
	}

	static const char *
	zpool_default_import_path[] = {
	"/dev"
	};

	const char * const *
	zpool_default_search_paths(size_t *count)
	{
	*count = nitems(zpool_default_import_path);
	return (zpool_default_import_path);
	}

	int
	zpool_find_import_blkid(libpc_handle_t hdl, pthread_mutex_t lock,
	avl_tree_t **slice_cache)
	{
	const char *oid = "vfs.zfs.vol.recursive";
	char *end, path[MAXPATHLEN];
	rdsk_node_t *slice;
	struct gmesh mesh;
	struct gclass *mp;
	struct ggeom *gp;
	struct gprovider *pp;
	avl_index_t where;
	int error, value;
	size_t pathleft, size = sizeof (value);
	boolean_t skip_zvols = B_FALSE;

	end = stpcpy(path, "/dev/");
	pathleft = &path[sizeof (path)] - end;

	error = geom_gettree(&mesh);
	if (error != 0)
	return (error);

	if (sysctlbyname(oid, &value, &size, NULL, 0) == 0 && value == 0)
	skip_zvols = B_TRUE;

	*slice_cache = zutil_alloc(hdl, sizeof (avl_tree_t));
	avl_create(*slice_cache, slice_cache_compare, sizeof (rdsk_node_t),
	offsetof(rdsk_node_t, rn_node));

	LIST_FOREACH(mp, &mesh.lg_class, lg_class) {
	if (skip_zvols && strcmp(mp->lg_name, "ZFS::ZVOL") == 0)
	continue;
	LIST_FOREACH(gp, &mp->lg_geom, lg_geom) {
	LIST_FOREACH(pp, &gp->lg_provider, lg_provider) {
	strlcpy(end, pp->lg_name, pathleft);
	slice = zutil_alloc(hdl, sizeof (rdsk_node_t));
	slice->rn_name = zutil_strdup(hdl, path);
	slice->rn_vdev_guid = 0;
	slice->rn_lock = lock;
	slice->rn_avl = *slice_cache;
	slice->rn_hdl = hdl;
	slice->rn_labelpaths = B_FALSE;
	slice->rn_order = IMPORT_ORDER_DEFAULT;

	pthread_mutex_lock(lock);
	if (avl_find(*slice_cache, slice, &where)) {
	free(slice->rn_name);
	free(slice);
	} else {
	avl_insert(*slice_cache, slice, where);
	}
	pthread_mutex_unlock(lock);
	}
	}
	}

	geom_deletetree(&mesh);

	return (0);
	}

	int
	zfs_dev_flush(int fd __unused)
	{
	return (0);
	}
	diff --git a/sys/contrib/openzfs/lib/libzutil/os/linux/zutil_device_path_os.c b/sys/contrib/openzfs/lib/libzutil/os/linux/zutil_device_path_os.c
	index 1f767bb7a6e7..2a6f4ae2a222 100644
	--- a/sys/contrib/openzfs/lib/libzutil/os/linux/zutil_device_path_os.c
	+++ b/sys/contrib/openzfs/lib/libzutil/os/linux/zutil_device_path_os.c
	@@ -1,538 +1,538 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	*/

	#include <ctype.h>
	#include <dirent.h>
	#include <fcntl.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>
	#include <sys/efi_partition.h>

	#ifdef HAVE_LIBUDEV
	#include <libudev.h>
	#endif

	#include <libzutil.h>

	/*
	* Append partition suffix to an otherwise fully qualified device path.
	* This is used to generate the name the full path as its stored in
	* ZPOOL_CONFIG_PATH for whole disk devices. On success the new length
	* of 'path' will be returned on error a negative value is returned.
	*/
	int
	zfs_append_partition(char *path, size_t max_len)
	{
	int len = strlen(path);

	if ((strncmp(path, UDISK_ROOT, strlen(UDISK_ROOT)) == 0) \|\|
	(strncmp(path, ZVOL_ROOT, strlen(ZVOL_ROOT)) == 0)) {
	if (len + 6 >= max_len)
	return (-1);

	(void) strcat(path, "-part1");
	len += 6;
	} else {
	if (len + 2 >= max_len)
	return (-1);

	if (isdigit(path[len-1])) {
	(void) strcat(path, "p1");
	len += 2;
	} else {
	(void) strcat(path, "1");
	len += 1;
	}
	}

	return (len);
	}

	/*
	* Remove partition suffix from a vdev path. Partition suffixes may take three
	* forms: "-partX", "pX", or "X", where X is a string of digits. The second
	* case only occurs when the suffix is preceded by a digit, i.e. "md0p0" The
	* third case only occurs when preceded by a string matching the regular
	* expression "^([hsv]\|xv)d[a-z]+", i.e. a scsi, ide, virtio or xen disk.
	*
	* caller must free the returned string
	*/
	char *
	zfs_strip_partition(char *path)
	{
	char *tmp = strdup(path);
	char part = NULL, d = NULL;
	if (!tmp)
	return (NULL);

	if ((part = strstr(tmp, "-part")) && part != tmp) {
	d = part + 5;
	} else if ((part = strrchr(tmp, 'p')) &&
	part > tmp + 1 && isdigit(*(part-1))) {
	d = part + 1;
	} else if ((tmp[0] == 'h' \|\| tmp[0] == 's' \|\| tmp[0] == 'v') &&
	tmp[1] == 'd') {
	for (d = &tmp[2]; isalpha(*d); part = ++d) { }
	} else if (strncmp("xvd", tmp, 3) == 0) {
	for (d = &tmp[3]; isalpha(*d); part = ++d) { }
	}
	if (part && d && *d != '\0') {
	for (; isdigit(*d); d++) { }
	if (*d == '\0')
	*part = '\0';
	}

	return (tmp);
	}

	/*
	* Same as zfs_strip_partition, but allows "/dev/" to be in the pathname
	*
	* path: /dev/sda1
	* returns: /dev/sda
	*
	* Returned string must be freed.
	*/
	static char *
	zfs_strip_partition_path(char *path)
	{
	char *newpath = strdup(path);
	char *sd_offset;
	char *new_sd;

	if (!newpath)
	return (NULL);

	/* Point to "sda1" part of "/dev/sda1" */
	sd_offset = strrchr(newpath, '/') + 1;

	/* Get our new name "sda" */
	new_sd = zfs_strip_partition(sd_offset);
	if (!new_sd) {
	free(newpath);
	return (NULL);
	}

	/* Paste the "sda" where "sda1" was */
	strlcpy(sd_offset, new_sd, strlen(sd_offset) + 1);

	/* Free temporary "sda" */
	free(new_sd);

	return (newpath);
	}

	/*
	* Strip the unwanted portion of a device path.
	*/
	char *
	zfs_strip_path(char *path)
	{
	return (strrchr(path, '/') + 1);
	}

	/*
	* Given a dev name like "sda", return the full enclosure sysfs path to
	* the disk. You can also pass in the name with "/dev" prepended
	* to it (like /dev/sda).
	*
	* For example, disk "sda" in enclosure slot 1:
	* dev: "sda"
	* returns: "/sys/class/enclosure/1:0:3:0/Slot 1"
	*
	* 'dev' must be a non-devicemapper device.
	*
	* Returned string must be freed.
	*/
	char *
	zfs_get_enclosure_sysfs_path(const char *dev_name)
	{
	DIR *dp = NULL;
	struct dirent *ep;
	char buf[MAXPATHLEN];
	char *tmp1 = NULL;
	char *tmp2 = NULL;
	char *tmp3 = NULL;
	char *path = NULL;
	size_t size;
	int tmpsize;

	if (dev_name == NULL)
	return (NULL);

	/* If they preface 'dev' with a path (like "/dev") then strip it off */
	tmp1 = strrchr(dev_name, '/');
	if (tmp1 != NULL)
	dev_name = tmp1 + 1; /* +1 since we want the chr after '/' */

	tmpsize = asprintf(&tmp1, "/sys/block/%s/device", dev_name);
	if (tmpsize == -1 \|\| tmp1 == NULL) {
	tmp1 = NULL;
	goto end;
	}

	dp = opendir(tmp1);
	- if (dp == NULL) {
	- tmp1 = NULL; /* To make free() at the end a NOP */
	+ if (dp == NULL)
	goto end;
	- }

	/*
	* Look though all sysfs entries in /sys/block/<dev>/device for
	* the enclosure symlink.
	*/
	while ((ep = readdir(dp))) {
	/* Ignore everything that's not our enclosure_device link */
	if (strstr(ep->d_name, "enclosure_device") == NULL)
	continue;

	- if (asprintf(&tmp2, "%s/%s", tmp1, ep->d_name) == -1 \|\|
	- tmp2 == NULL)
	+ if (asprintf(&tmp2, "%s/%s", tmp1, ep->d_name) == -1) {
	+ tmp2 = NULL;
	break;
	+ }

	size = readlink(tmp2, buf, sizeof (buf));

	/* Did readlink fail or crop the link name? */
	- if (size == -1 \|\| size >= sizeof (buf)) {
	- free(tmp2);
	- tmp2 = NULL; /* To make free() at the end a NOP */
	+ if (size == -1 \|\| size >= sizeof (buf))
	break;
	- }

	/*
	* We got a valid link. readlink() doesn't terminate strings
	* so we have to do it.
	*/
	buf[size] = '\0';

	/*
	* Our link will look like:
	*
	* "../../../../port-11:1:2/..STUFF../enclosure/1:0:3:0/SLOT 1"
	*
	* We want to grab the "enclosure/1:0:3:0/SLOT 1" part
	*/
	tmp3 = strstr(buf, "enclosure");
	if (tmp3 == NULL)
	break;

	if (asprintf(&path, "/sys/class/%s", tmp3) == -1) {
	/* If asprintf() fails, 'path' is undefined */
	path = NULL;
	break;
	}

	if (path == NULL)
	break;
	}

	end:
	free(tmp2);
	free(tmp1);

	if (dp != NULL)
	closedir(dp);

	return (path);
	}

	/*
	* Allocate and return the underlying device name for a device mapper device.
	*
	* For example, dm_name = "/dev/dm-0" could return "/dev/sda". Symlinks to a
	* DM device (like /dev/disk/by-vdev/A0) are also allowed.
	*
	* If the DM device has multiple underlying devices (like with multipath
	* DM devices), then favor underlying devices that have a symlink back to their
	* back to their enclosure device in sysfs. This will be useful for the
	* zedlet scripts that toggle the fault LED.
	*
	* Returns an underlying device name, or NULL on error or no match. If dm_name
	* is not a DM device then return NULL.
	*
	* NOTE: The returned name string must be freed.
	*/
	static char *
	dm_get_underlying_path(const char *dm_name)
	{
	DIR *dp = NULL;
	struct dirent *ep;
	char *realp;
	char *tmp = NULL;
	char *path = NULL;
	char *dev_str;
	int size;
	char *first_path = NULL;
	char *enclosure_path;

	if (dm_name == NULL)
	return (NULL);

	/* dm name may be a symlink (like /dev/disk/by-vdev/A0) */
	realp = realpath(dm_name, NULL);
	if (realp == NULL)
	return (NULL);

	/*
	* If they preface 'dev' with a path (like "/dev") then strip it off.
	* We just want the 'dm-N' part.
	*/
	tmp = strrchr(realp, '/');
	if (tmp != NULL)
	dev_str = tmp + 1; /* +1 since we want the chr after '/' */
	else
	dev_str = tmp;

	- size = asprintf(&tmp, "/sys/block/%s/slaves/", dev_str);
	- if (size == -1 \|\| !tmp)
	+ if ((size = asprintf(&tmp, "/sys/block/%s/slaves/", dev_str)) == -1) {
	+ tmp = NULL;
	goto end;
	+ }

	dp = opendir(tmp);
	if (dp == NULL)
	goto end;

	/*
	* A device-mapper device can have multiple paths to it (multipath).
	* Favor paths that have a symlink back to their enclosure device.
	* We have to do this since some enclosures may only provide a symlink
	* back for one underlying path to a disk and not the other.
	*
	* If no paths have links back to their enclosure, then just return the
	* first path.
	*/
	while ((ep = readdir(dp))) {
	if (ep->d_type != DT_DIR) { /* skip "." and ".." dirs */
	if (!first_path)
	first_path = strdup(ep->d_name);

	enclosure_path =
	zfs_get_enclosure_sysfs_path(ep->d_name);

	if (!enclosure_path)
	continue;

	- size = asprintf(&path, "/dev/%s", ep->d_name);
	+ if ((size = asprintf(
	+ &path, "/dev/%s", ep->d_name)) == -1)
	+ path = NULL;
	free(enclosure_path);
	break;
	}
	}

	end:
	if (dp != NULL)
	closedir(dp);
	free(tmp);
	free(realp);

	- if (!path) {
	+ if (!path && first_path) {
	/*
	* None of the underlying paths had a link back to their
	* enclosure devices. Throw up out hands and return the first
	* underlying path.
	*/
	- size = asprintf(&path, "/dev/%s", first_path);
	+ if ((size = asprintf(&path, "/dev/%s", first_path)) == -1)
	+ path = NULL;
	}

	free(first_path);
	return (path);
	}

	/*
	* Return B_TRUE if device is a device mapper or multipath device.
	* Return B_FALSE if not.
	*/
	boolean_t
	zfs_dev_is_dm(const char *dev_name)
	{

	char *tmp;
	tmp = dm_get_underlying_path(dev_name);
	if (tmp == NULL)
	return (B_FALSE);

	free(tmp);
	return (B_TRUE);
	}

	/*
	* By "whole disk" we mean an entire physical disk (something we can
	* label, toggle the write cache on, etc.) as opposed to the full
	* capacity of a pseudo-device such as lofi or did. We act as if we
	* are labeling the disk, which should be a pretty good test of whether
	* it's a viable device or not. Returns B_TRUE if it is and B_FALSE if
	* it isn't.
	*/
	boolean_t
	zfs_dev_is_whole_disk(const char *dev_name)
	{
	struct dk_gpt *label;
	int fd;

	- if ((fd = open(dev_name, O_RDONLY \| O_DIRECT)) < 0)
	+ if ((fd = open(dev_name, O_RDONLY \| O_DIRECT \| O_CLOEXEC)) < 0)
	return (B_FALSE);

	if (efi_alloc_and_init(fd, EFI_NUMPAR, &label) != 0) {
	(void) close(fd);
	return (B_FALSE);
	}

	efi_free(label);
	(void) close(fd);

	return (B_TRUE);
	}

	/*
	* Lookup the underlying device for a device name
	*
	* Often you'll have a symlink to a device, a partition device,
	* or a multipath device, and want to look up the underlying device.
	* This function returns the underlying device name. If the device
	* name is already the underlying device, then just return the same
	* name. If the device is a DM device with multiple underlying devices
	* then return the first one.
	*
	* For example:
	*
	* 1. /dev/disk/by-id/ata-QEMU_HARDDISK_QM00001 -> ../../sda
	* dev_name: /dev/disk/by-id/ata-QEMU_HARDDISK_QM00001
	* returns: /dev/sda
	*
	* 2. /dev/mapper/mpatha (made up of /dev/sda and /dev/sdb)
	* dev_name: /dev/mapper/mpatha
	* returns: /dev/sda (first device)
	*
	* 3. /dev/sda (already the underlying device)
	* dev_name: /dev/sda
	* returns: /dev/sda
	*
	* 4. /dev/dm-3 (mapped to /dev/sda)
	* dev_name: /dev/dm-3
	* returns: /dev/sda
	*
	* 5. /dev/disk/by-id/scsi-0QEMU_drive-scsi0-0-0-0-part9 -> ../../sdb9
	* dev_name: /dev/disk/by-id/scsi-0QEMU_drive-scsi0-0-0-0-part9
	* returns: /dev/sdb
	*
	* 6. /dev/disk/by-uuid/5df030cf-3cd9-46e4-8e99-3ccb462a4e9a -> ../dev/sda2
	* dev_name: /dev/disk/by-uuid/5df030cf-3cd9-46e4-8e99-3ccb462a4e9a
	* returns: /dev/sda
	*
	* Returns underlying device name, or NULL on error or no match.
	*
	* NOTE: The returned name string must be freed.
	*/
	char *
	zfs_get_underlying_path(const char *dev_name)
	{
	char *name = NULL;
	char *tmp;

	if (dev_name == NULL)
	return (NULL);

	tmp = dm_get_underlying_path(dev_name);

	/* dev_name not a DM device, so just un-symlinkize it */
	if (tmp == NULL)
	tmp = realpath(dev_name, NULL);

	if (tmp != NULL) {
	name = zfs_strip_partition_path(tmp);
	free(tmp);
	}

	return (name);
	}


	#ifdef HAVE_LIBUDEV

	/*
	* A disk is considered a multipath whole disk when:
	* DEVNAME key value has "dm-"
	* DM_NAME key value has "mpath" prefix
	* DM_UUID key exists
	* ID_PART_TABLE_TYPE key does not exist or is not gpt
	*/
	static boolean_t
	udev_mpath_whole_disk(struct udev_device *dev)
	{
	const char devname, type, *uuid;

	devname = udev_device_get_property_value(dev, "DEVNAME");
	type = udev_device_get_property_value(dev, "ID_PART_TABLE_TYPE");
	uuid = udev_device_get_property_value(dev, "DM_UUID");

	if ((devname != NULL && strncmp(devname, "/dev/dm-", 8) == 0) &&
	((type == NULL) \|\| (strcmp(type, "gpt") != 0)) &&
	(uuid != NULL)) {
	return (B_TRUE);
	}

	return (B_FALSE);
	}

	/*
	* Check if a disk is effectively a multipath whole disk
	*/
	boolean_t
	is_mpath_whole_disk(const char *path)
	{
	struct udev *udev;
	struct udev_device *dev = NULL;
	char nodepath[MAXPATHLEN];
	char *sysname;
	boolean_t wholedisk = B_FALSE;

	if (realpath(path, nodepath) == NULL)
	return (B_FALSE);
	sysname = strrchr(nodepath, '/') + 1;
	if (strncmp(sysname, "dm-", 3) != 0)
	return (B_FALSE);
	if ((udev = udev_new()) == NULL)
	return (B_FALSE);
	if ((dev = udev_device_new_from_subsystem_sysname(udev, "block",
	sysname)) == NULL) {
	udev_device_unref(dev);
	return (B_FALSE);
	}

	wholedisk = udev_mpath_whole_disk(dev);

	udev_device_unref(dev);
	return (wholedisk);
	}

	#else /* HAVE_LIBUDEV */

	/* ARGSUSED */
	boolean_t
	is_mpath_whole_disk(const char *path)
	{
	return (B_FALSE);
	}

	#endif /* HAVE_LIBUDEV */
	diff --git a/sys/contrib/openzfs/lib/libzutil/os/linux/zutil_import_os.c b/sys/contrib/openzfs/lib/libzutil/os/linux/zutil_import_os.c
	index 2e0baecb3bec..61c42cf2e3a2 100644
	--- a/sys/contrib/openzfs/lib/libzutil/os/linux/zutil_import_os.c
	+++ b/sys/contrib/openzfs/lib/libzutil/os/linux/zutil_import_os.c
	@@ -1,870 +1,870 @@
	/*
	* 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 2015 Nexenta Systems, Inc. All rights reserved.
	* Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2012, 2018 by Delphix. All rights reserved.
	* Copyright 2015 RackTop Systems.
	* Copyright (c) 2016, Intel Corporation.
	*/

	/*
	* Pool import support functions.
	*
	* Used by zpool, ztest, zdb, and zhack to locate importable configs. Since
	* these commands are expected to run in the global zone, we can assume
	* that the devices are all readable when called.
	*
	* To import a pool, we rely on reading the configuration information from the
	* ZFS label of each device. If we successfully read the label, then we
	* organize the configuration information in the following hierarchy:
	*
	* pool guid -> toplevel vdev guid -> label txg
	*
	* Duplicate entries matching this same tuple will be discarded. Once we have
	* examined every device, we pick the best label txg config for each toplevel
	* vdev. We then arrange these toplevel vdevs into a complete pool config, and
	* update any paths that have changed. Finally, we attempt to import the pool
	* using our derived config, and record the results.
	*/

	#include <ctype.h>
	#include <dirent.h>
	#include <errno.h>
	#include <libintl.h>
	#include <libgen.h>
	#include <stddef.h>
	#include <stdlib.h>
	#include <stdio.h>
	#include <string.h>
	#include <sys/stat.h>
	#include <unistd.h>
	#include <fcntl.h>
	#include <sys/dktp/fdisk.h>
	#include <sys/vdev_impl.h>
	#include <sys/fs/zfs.h>

	#include <thread_pool.h>
	#include <libzutil.h>
	#include <libnvpair.h>

	#include "zutil_import.h"

	#ifdef HAVE_LIBUDEV
	#include <libudev.h>
	#include <sched.h>
	#endif
	#include <blkid/blkid.h>

	#define DEFAULT_IMPORT_PATH_SIZE 9
	#define DEV_BYID_PATH "/dev/disk/by-id/"

	static boolean_t
	is_watchdog_dev(char *dev)
	{
	/* For 'watchdog' dev */
	if (strcmp(dev, "watchdog") == 0)
	return (B_TRUE);

	/* For 'watchdog<digit><whatever> */
	if (strstr(dev, "watchdog") == dev && isdigit(dev[8]))
	return (B_TRUE);

	return (B_FALSE);
	}

	int
	zfs_dev_flush(int fd)
	{
	return (ioctl(fd, BLKFLSBUF));
	}

	void
	zpool_open_func(void *arg)
	{
	rdsk_node_t *rn = arg;
	libpc_handle_t *hdl = rn->rn_hdl;
	struct stat64 statbuf;
	nvlist_t *config;
	char bname, dupname;
	uint64_t vdev_guid = 0;
	int error;
	int num_labels = 0;
	int fd;

	/*
	* Skip devices with well known prefixes there can be side effects
	* when opening devices which need to be avoided.
	*
	* hpet - High Precision Event Timer
	* watchdog - Watchdog must be closed in a special way.
	*/
	dupname = zutil_strdup(hdl, rn->rn_name);
	bname = basename(dupname);
	error = ((strcmp(bname, "hpet") == 0) \|\| is_watchdog_dev(bname));
	free(dupname);
	if (error)
	return;

	/*
	* Ignore failed stats. We only want regular files and block devices.
	*/
	if (stat64(rn->rn_name, &statbuf) != 0 \|\|
	(!S_ISREG(statbuf.st_mode) && !S_ISBLK(statbuf.st_mode)))
	return;

	/*
	* Preferentially open using O_DIRECT to bypass the block device
	* cache which may be stale for multipath devices. An EINVAL errno
	* indicates O_DIRECT is unsupported so fallback to just O_RDONLY.
	*/
	- fd = open(rn->rn_name, O_RDONLY \| O_DIRECT);
	+ fd = open(rn->rn_name, O_RDONLY \| O_DIRECT \| O_CLOEXEC);
	if ((fd < 0) && (errno == EINVAL))
	- fd = open(rn->rn_name, O_RDONLY);
	+ fd = open(rn->rn_name, O_RDONLY \| O_CLOEXEC);
	if ((fd < 0) && (errno == EACCES))
	hdl->lpc_open_access_error = B_TRUE;
	if (fd < 0)
	return;

	/*
	* This file is too small to hold a zpool
	*/
	if (S_ISREG(statbuf.st_mode) && statbuf.st_size < SPA_MINDEVSIZE) {
	(void) close(fd);
	return;
	}

	error = zpool_read_label(fd, &config, &num_labels);
	if (error != 0) {
	(void) close(fd);
	return;
	}

	if (num_labels == 0) {
	(void) close(fd);
	nvlist_free(config);
	return;
	}

	/*
	* Check that the vdev is for the expected guid. Additional entries
	* are speculatively added based on the paths stored in the labels.
	* Entries with valid paths but incorrect guids must be removed.
	*/
	error = nvlist_lookup_uint64(config, ZPOOL_CONFIG_GUID, &vdev_guid);
	if (error \|\| (rn->rn_vdev_guid && rn->rn_vdev_guid != vdev_guid)) {
	(void) close(fd);
	nvlist_free(config);
	return;
	}

	(void) close(fd);

	rn->rn_config = config;
	rn->rn_num_labels = num_labels;

	/*
	* Add additional entries for paths described by this label.
	*/
	if (rn->rn_labelpaths) {
	char *path = NULL;
	char *devid = NULL;
	char *env = NULL;
	rdsk_node_t *slice;
	avl_index_t where;
	int timeout;
	int error;

	if (label_paths(rn->rn_hdl, rn->rn_config, &path, &devid))
	return;

	env = getenv("ZPOOL_IMPORT_UDEV_TIMEOUT_MS");
	if ((env == NULL) \|\| sscanf(env, "%d", &timeout) != 1 \|\|
	timeout < 0) {
	timeout = DISK_LABEL_WAIT;
	}

	/*
	* Allow devlinks to stabilize so all paths are available.
	*/
	zpool_label_disk_wait(rn->rn_name, timeout);

	if (path != NULL) {
	slice = zutil_alloc(hdl, sizeof (rdsk_node_t));
	slice->rn_name = zutil_strdup(hdl, path);
	slice->rn_vdev_guid = vdev_guid;
	slice->rn_avl = rn->rn_avl;
	slice->rn_hdl = hdl;
	slice->rn_order = IMPORT_ORDER_PREFERRED_1;
	slice->rn_labelpaths = B_FALSE;
	pthread_mutex_lock(rn->rn_lock);
	if (avl_find(rn->rn_avl, slice, &where)) {
	pthread_mutex_unlock(rn->rn_lock);
	free(slice->rn_name);
	free(slice);
	} else {
	avl_insert(rn->rn_avl, slice, where);
	pthread_mutex_unlock(rn->rn_lock);
	zpool_open_func(slice);
	}
	}

	if (devid != NULL) {
	slice = zutil_alloc(hdl, sizeof (rdsk_node_t));
	error = asprintf(&slice->rn_name, "%s%s",
	DEV_BYID_PATH, devid);
	if (error == -1) {
	free(slice);
	return;
	}

	slice->rn_vdev_guid = vdev_guid;
	slice->rn_avl = rn->rn_avl;
	slice->rn_hdl = hdl;
	slice->rn_order = IMPORT_ORDER_PREFERRED_2;
	slice->rn_labelpaths = B_FALSE;
	pthread_mutex_lock(rn->rn_lock);
	if (avl_find(rn->rn_avl, slice, &where)) {
	pthread_mutex_unlock(rn->rn_lock);
	free(slice->rn_name);
	free(slice);
	} else {
	avl_insert(rn->rn_avl, slice, where);
	pthread_mutex_unlock(rn->rn_lock);
	zpool_open_func(slice);
	}
	}
	}
	}

	static char *
	zpool_default_import_path[DEFAULT_IMPORT_PATH_SIZE] = {
	"/dev/disk/by-vdev", /* Custom rules, use first if they exist */
	"/dev/mapper", /* Use multipath devices before components */
	"/dev/disk/by-partlabel", /* Single unique entry set by user */
	"/dev/disk/by-partuuid", /* Generated partition uuid */
	"/dev/disk/by-label", /* Custom persistent labels */
	"/dev/disk/by-uuid", /* Single unique entry and persistent */
	"/dev/disk/by-id", /* May be multiple entries and persistent */
	"/dev/disk/by-path", /* Encodes physical location and persistent */
	"/dev" /* UNSAFE device names will change */
	};

	const char * const *
	zpool_default_search_paths(size_t *count)
	{
	*count = DEFAULT_IMPORT_PATH_SIZE;
	return ((const char * const *)zpool_default_import_path);
	}

	/*
	* Given a full path to a device determine if that device appears in the
	* import search path. If it does return the first match and store the
	* index in the passed 'order' variable, otherwise return an error.
	*/
	static int
	zfs_path_order(char name, int order)
	{
	int i = 0, error = ENOENT;
	char dir, env, *envdup;

	env = getenv("ZPOOL_IMPORT_PATH");
	if (env) {
	envdup = strdup(env);
	dir = strtok(envdup, ":");
	while (dir) {
	if (strncmp(name, dir, strlen(dir)) == 0) {
	*order = i;
	error = 0;
	break;
	}
	dir = strtok(NULL, ":");
	i++;
	}
	free(envdup);
	} else {
	for (i = 0; i < DEFAULT_IMPORT_PATH_SIZE; i++) {
	if (strncmp(name, zpool_default_import_path[i],
	strlen(zpool_default_import_path[i])) == 0) {
	*order = i;
	error = 0;
	break;
	}
	}
	}

	return (error);
	}

	/*
	* Use libblkid to quickly enumerate all known zfs devices.
	*/
	int
	zpool_find_import_blkid(libpc_handle_t hdl, pthread_mutex_t lock,
	avl_tree_t **slice_cache)
	{
	rdsk_node_t *slice;
	blkid_cache cache;
	blkid_dev_iterate iter;
	blkid_dev dev;
	avl_index_t where;
	int error;

	*slice_cache = NULL;

	error = blkid_get_cache(&cache, NULL);
	if (error != 0)
	return (error);

	error = blkid_probe_all_new(cache);
	if (error != 0) {
	blkid_put_cache(cache);
	return (error);
	}

	iter = blkid_dev_iterate_begin(cache);
	if (iter == NULL) {
	blkid_put_cache(cache);
	return (EINVAL);
	}

	error = blkid_dev_set_search(iter, "TYPE", "zfs_member");
	if (error != 0) {
	blkid_dev_iterate_end(iter);
	blkid_put_cache(cache);
	return (error);
	}

	*slice_cache = zutil_alloc(hdl, sizeof (avl_tree_t));
	avl_create(*slice_cache, slice_cache_compare, sizeof (rdsk_node_t),
	offsetof(rdsk_node_t, rn_node));

	while (blkid_dev_next(iter, &dev) == 0) {
	slice = zutil_alloc(hdl, sizeof (rdsk_node_t));
	slice->rn_name = zutil_strdup(hdl, blkid_dev_devname(dev));
	slice->rn_vdev_guid = 0;
	slice->rn_lock = lock;
	slice->rn_avl = *slice_cache;
	slice->rn_hdl = hdl;
	slice->rn_labelpaths = B_TRUE;

	error = zfs_path_order(slice->rn_name, &slice->rn_order);
	if (error == 0)
	slice->rn_order += IMPORT_ORDER_SCAN_OFFSET;
	else
	slice->rn_order = IMPORT_ORDER_DEFAULT;

	pthread_mutex_lock(lock);
	if (avl_find(*slice_cache, slice, &where)) {
	free(slice->rn_name);
	free(slice);
	} else {
	avl_insert(*slice_cache, slice, where);
	}
	pthread_mutex_unlock(lock);
	}

	blkid_dev_iterate_end(iter);
	blkid_put_cache(cache);

	return (0);
	}

	/*
	* Linux persistent device strings for vdev labels
	*
	* based on libudev for consistency with libudev disk add/remove events
	*/

	typedef struct vdev_dev_strs {
	char vds_devid[128];
	char vds_devphys[128];
	} vdev_dev_strs_t;

	#ifdef HAVE_LIBUDEV

	/*
	* Obtain the persistent device id string (describes what)
	*
	* used by ZED vdev matching for auto-{online,expand,replace}
	*/
	int
	zfs_device_get_devid(struct udev_device dev, char bufptr, size_t buflen)
	{
	struct udev_list_entry *entry;
	const char *bus;
	char devbyid[MAXPATHLEN];

	/* The bus based by-id path is preferred */
	bus = udev_device_get_property_value(dev, "ID_BUS");

	if (bus == NULL) {
	const char *dm_uuid;

	/*
	* For multipath nodes use the persistent uuid based identifier
	*
	* Example: /dev/disk/by-id/dm-uuid-mpath-35000c5006304de3f
	*/
	dm_uuid = udev_device_get_property_value(dev, "DM_UUID");
	if (dm_uuid != NULL) {
	(void) snprintf(bufptr, buflen, "dm-uuid-%s", dm_uuid);
	return (0);
	}

	/*
	* For volumes use the persistent /dev/zvol/dataset identifier
	*/
	entry = udev_device_get_devlinks_list_entry(dev);
	while (entry != NULL) {
	const char *name;

	name = udev_list_entry_get_name(entry);
	if (strncmp(name, ZVOL_ROOT, strlen(ZVOL_ROOT)) == 0) {
	(void) strlcpy(bufptr, name, buflen);
	return (0);
	}
	entry = udev_list_entry_get_next(entry);
	}

	/*
	* NVME 'by-id' symlinks are similar to bus case
	*/
	struct udev_device *parent;

	parent = udev_device_get_parent_with_subsystem_devtype(dev,
	"nvme", NULL);
	if (parent != NULL)
	bus = "nvme"; /* continue with bus symlink search */
	else
	return (ENODATA);
	}

	/*
	* locate the bus specific by-id link
	*/
	(void) snprintf(devbyid, sizeof (devbyid), "%s%s-", DEV_BYID_PATH, bus);
	entry = udev_device_get_devlinks_list_entry(dev);
	while (entry != NULL) {
	const char *name;

	name = udev_list_entry_get_name(entry);
	if (strncmp(name, devbyid, strlen(devbyid)) == 0) {
	name += strlen(DEV_BYID_PATH);
	(void) strlcpy(bufptr, name, buflen);
	return (0);
	}
	entry = udev_list_entry_get_next(entry);
	}

	return (ENODATA);
	}

	/*
	* Obtain the persistent physical location string (describes where)
	*
	* used by ZED vdev matching for auto-{online,expand,replace}
	*/
	int
	zfs_device_get_physical(struct udev_device dev, char bufptr, size_t buflen)
	{
	const char *physpath = NULL;
	struct udev_list_entry *entry;

	/*
	* Normal disks use ID_PATH for their physical path.
	*/
	physpath = udev_device_get_property_value(dev, "ID_PATH");
	if (physpath != NULL && strlen(physpath) > 0) {
	(void) strlcpy(bufptr, physpath, buflen);
	return (0);
	}

	/*
	* Device mapper devices are virtual and don't have a physical
	* path. For them we use ID_VDEV instead, which is setup via the
	* /etc/vdev_id.conf file. ID_VDEV provides a persistent path
	* to a virtual device. If you don't have vdev_id.conf setup,
	* you cannot use multipath autoreplace with device mapper.
	*/
	physpath = udev_device_get_property_value(dev, "ID_VDEV");
	if (physpath != NULL && strlen(physpath) > 0) {
	(void) strlcpy(bufptr, physpath, buflen);
	return (0);
	}

	/*
	* For ZFS volumes use the persistent /dev/zvol/dataset identifier
	*/
	entry = udev_device_get_devlinks_list_entry(dev);
	while (entry != NULL) {
	physpath = udev_list_entry_get_name(entry);
	if (strncmp(physpath, ZVOL_ROOT, strlen(ZVOL_ROOT)) == 0) {
	(void) strlcpy(bufptr, physpath, buflen);
	return (0);
	}
	entry = udev_list_entry_get_next(entry);
	}

	/*
	* For all other devices fallback to using the by-uuid name.
	*/
	entry = udev_device_get_devlinks_list_entry(dev);
	while (entry != NULL) {
	physpath = udev_list_entry_get_name(entry);
	if (strncmp(physpath, "/dev/disk/by-uuid", 17) == 0) {
	(void) strlcpy(bufptr, physpath, buflen);
	return (0);
	}
	entry = udev_list_entry_get_next(entry);
	}

	return (ENODATA);
	}

	/*
	* A disk is considered a multipath whole disk when:
	* DEVNAME key value has "dm-"
	* DM_NAME key value has "mpath" prefix
	* DM_UUID key exists
	* ID_PART_TABLE_TYPE key does not exist or is not gpt
	*/
	static boolean_t
	udev_mpath_whole_disk(struct udev_device *dev)
	{
	const char devname, type, *uuid;

	devname = udev_device_get_property_value(dev, "DEVNAME");
	type = udev_device_get_property_value(dev, "ID_PART_TABLE_TYPE");
	uuid = udev_device_get_property_value(dev, "DM_UUID");

	if ((devname != NULL && strncmp(devname, "/dev/dm-", 8) == 0) &&
	((type == NULL) \|\| (strcmp(type, "gpt") != 0)) &&
	(uuid != NULL)) {
	return (B_TRUE);
	}

	return (B_FALSE);
	}

	static int
	udev_device_is_ready(struct udev_device *dev)
	{
	#ifdef HAVE_LIBUDEV_UDEV_DEVICE_GET_IS_INITIALIZED
	return (udev_device_get_is_initialized(dev));
	#else
	/* wait for DEVLINKS property to be initialized */
	return (udev_device_get_property_value(dev, "DEVLINKS") != NULL);
	#endif
	}

	#else

	/* ARGSUSED */
	int
	zfs_device_get_devid(struct udev_device dev, char bufptr, size_t buflen)
	{
	return (ENODATA);
	}

	/* ARGSUSED */
	int
	zfs_device_get_physical(struct udev_device dev, char bufptr, size_t buflen)
	{
	return (ENODATA);
	}

	#endif /* HAVE_LIBUDEV */

	/*
	* Wait up to timeout_ms for udev to set up the device node. The device is
	* considered ready when libudev determines it has been initialized, all of
	* the device links have been verified to exist, and it has been allowed to
	* settle. At this point the device the device can be accessed reliably.
	* Depending on the complexity of the udev rules this process could take
	* several seconds.
	*/
	int
	zpool_label_disk_wait(const char *path, int timeout_ms)
	{
	#ifdef HAVE_LIBUDEV
	struct udev *udev;
	struct udev_device *dev = NULL;
	char nodepath[MAXPATHLEN];
	char *sysname = NULL;
	int ret = ENODEV;
	int settle_ms = 50;
	long sleep_ms = 10;
	hrtime_t start, settle;

	if ((udev = udev_new()) == NULL)
	return (ENXIO);

	start = gethrtime();
	settle = 0;

	do {
	if (sysname == NULL) {
	if (realpath(path, nodepath) != NULL) {
	sysname = strrchr(nodepath, '/') + 1;
	} else {
	(void) usleep(sleep_ms * MILLISEC);
	continue;
	}
	}

	dev = udev_device_new_from_subsystem_sysname(udev,
	"block", sysname);
	if ((dev != NULL) && udev_device_is_ready(dev)) {
	struct udev_list_entry links, link = NULL;

	ret = 0;
	links = udev_device_get_devlinks_list_entry(dev);

	udev_list_entry_foreach(link, links) {
	struct stat64 statbuf;
	const char *name;

	name = udev_list_entry_get_name(link);
	errno = 0;
	if (stat64(name, &statbuf) == 0 && errno == 0)
	continue;

	settle = 0;
	ret = ENODEV;
	break;
	}

	if (ret == 0) {
	if (settle == 0) {
	settle = gethrtime();
	} else if (NSEC2MSEC(gethrtime() - settle) >=
	settle_ms) {
	udev_device_unref(dev);
	break;
	}
	}
	}

	udev_device_unref(dev);
	(void) usleep(sleep_ms * MILLISEC);

	} while (NSEC2MSEC(gethrtime() - start) < timeout_ms);

	udev_unref(udev);

	return (ret);
	#else
	int settle_ms = 50;
	long sleep_ms = 10;
	hrtime_t start, settle;
	struct stat64 statbuf;

	start = gethrtime();
	settle = 0;

	do {
	errno = 0;
	if ((stat64(path, &statbuf) == 0) && (errno == 0)) {
	if (settle == 0)
	settle = gethrtime();
	else if (NSEC2MSEC(gethrtime() - settle) >= settle_ms)
	return (0);
	} else if (errno != ENOENT) {
	return (errno);
	}

	usleep(sleep_ms * MILLISEC);
	} while (NSEC2MSEC(gethrtime() - start) < timeout_ms);

	return (ENODEV);
	#endif /* HAVE_LIBUDEV */
	}

	/*
	* Encode the persistent devices strings
	* used for the vdev disk label
	*/
	static int
	encode_device_strings(const char path, vdev_dev_strs_t ds,
	boolean_t wholedisk)
	{
	#ifdef HAVE_LIBUDEV
	struct udev *udev;
	struct udev_device *dev = NULL;
	char nodepath[MAXPATHLEN];
	char *sysname;
	int ret = ENODEV;
	hrtime_t start;

	if ((udev = udev_new()) == NULL)
	return (ENXIO);

	/* resolve path to a runtime device node instance */
	if (realpath(path, nodepath) == NULL)
	goto no_dev;

	sysname = strrchr(nodepath, '/') + 1;

	/*
	* Wait up to 3 seconds for udev to set up the device node context
	*/
	start = gethrtime();
	do {
	dev = udev_device_new_from_subsystem_sysname(udev, "block",
	sysname);
	if (dev == NULL)
	goto no_dev;
	if (udev_device_is_ready(dev))
	break; /* udev ready */

	udev_device_unref(dev);
	dev = NULL;

	if (NSEC2MSEC(gethrtime() - start) < 10)
	(void) sched_yield(); /* yield/busy wait up to 10ms */
	else
	(void) usleep(10 * MILLISEC);

	} while (NSEC2MSEC(gethrtime() - start) < (3 * MILLISEC));

	if (dev == NULL)
	goto no_dev;

	/*
	* Only whole disks require extra device strings
	*/
	if (!wholedisk && !udev_mpath_whole_disk(dev))
	goto no_dev;

	ret = zfs_device_get_devid(dev, ds->vds_devid, sizeof (ds->vds_devid));
	if (ret != 0)
	goto no_dev_ref;

	/* physical location string (optional) */
	if (zfs_device_get_physical(dev, ds->vds_devphys,
	sizeof (ds->vds_devphys)) != 0) {
	ds->vds_devphys[0] = '\0'; /* empty string --> not available */
	}

	no_dev_ref:
	udev_device_unref(dev);
	no_dev:
	udev_unref(udev);

	return (ret);
	#else
	return (ENOENT);
	#endif
	}

	/*
	* Update a leaf vdev's persistent device strings
	*
	* - only applies for a dedicated leaf vdev (aka whole disk)
	* - updated during pool create\|add\|attach\|import
	* - used for matching device matching during auto-{online,expand,replace}
	* - stored in a leaf disk config label (i.e. alongside 'path' NVP)
	* - these strings are currently not used in kernel (i.e. for vdev_disk_open)
	*
	* single device node example:
	* devid: 'scsi-MG03SCA300_350000494a8cb3d67-part1'
	* phys_path: 'pci-0000:04:00.0-sas-0x50000394a8cb3d67-lun-0'
	*
	* multipath device node example:
	* devid: 'dm-uuid-mpath-35000c5006304de3f'
	*
	* We also store the enclosure sysfs path for turning on enclosure LEDs
	* (if applicable):
	* vdev_enc_sysfs_path: '/sys/class/enclosure/11:0:1:0/SLOT 4'
	*/
	void
	update_vdev_config_dev_strs(nvlist_t *nv)
	{
	vdev_dev_strs_t vds;
	char env, type, *path;
	uint64_t wholedisk = 0;
	char upath, spath;

	/*
	* For the benefit of legacy ZFS implementations, allow
	* for opting out of devid strings in the vdev label.
	*
	* example use:
	* env ZFS_VDEV_DEVID_OPT_OUT=YES zpool import dozer
	*
	* explanation:
	* Older OpenZFS implementations had issues when attempting to
	* display pool config VDEV names if a "devid" NVP value is
	* present in the pool's config.
	*
	* For example, a pool that originated on illumos platform would
	* have a devid value in the config and "zpool status" would fail
	* when listing the config.
	*
	* A pool can be stripped of any "devid" values on import or
	* prevented from adding them on zpool create\|add by setting
	* ZFS_VDEV_DEVID_OPT_OUT.
	*/
	env = getenv("ZFS_VDEV_DEVID_OPT_OUT");
	if (env && (strtoul(env, NULL, 0) > 0 \|\|
	!strncasecmp(env, "YES", 3) \|\| !strncasecmp(env, "ON", 2))) {
	(void) nvlist_remove_all(nv, ZPOOL_CONFIG_DEVID);
	(void) nvlist_remove_all(nv, ZPOOL_CONFIG_PHYS_PATH);
	return;
	}

	if (nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &type) != 0 \|\|
	strcmp(type, VDEV_TYPE_DISK) != 0) {
	return;
	}
	if (nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path) != 0)
	return;
	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_WHOLE_DISK, &wholedisk);

	/*
	* Update device string values in the config nvlist.
	*/
	if (encode_device_strings(path, &vds, (boolean_t)wholedisk) == 0) {
	(void) nvlist_add_string(nv, ZPOOL_CONFIG_DEVID, vds.vds_devid);
	if (vds.vds_devphys[0] != '\0') {
	(void) nvlist_add_string(nv, ZPOOL_CONFIG_PHYS_PATH,
	vds.vds_devphys);
	}

	/* Add enclosure sysfs path (if disk is in an enclosure). */
	upath = zfs_get_underlying_path(path);
	spath = zfs_get_enclosure_sysfs_path(upath);
	if (spath)
	nvlist_add_string(nv, ZPOOL_CONFIG_VDEV_ENC_SYSFS_PATH,
	spath);
	else
	nvlist_remove_all(nv, ZPOOL_CONFIG_VDEV_ENC_SYSFS_PATH);

	free(upath);
	free(spath);
	} else {
	/* Clear out any stale entries. */
	(void) nvlist_remove_all(nv, ZPOOL_CONFIG_DEVID);
	(void) nvlist_remove_all(nv, ZPOOL_CONFIG_PHYS_PATH);
	(void) nvlist_remove_all(nv, ZPOOL_CONFIG_VDEV_ENC_SYSFS_PATH);
	}
	}
	diff --git a/sys/contrib/openzfs/lib/libzutil/zutil_import.c b/sys/contrib/openzfs/lib/libzutil/zutil_import.c
	index 93d05354f30f..0e59ec8c88c8 100644
	--- a/sys/contrib/openzfs/lib/libzutil/zutil_import.c
	+++ b/sys/contrib/openzfs/lib/libzutil/zutil_import.c
	@@ -1,1736 +1,1835 @@
	/*
	* 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 2015 Nexenta Systems, Inc. All rights reserved.
	* Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2012, 2018 by Delphix. All rights reserved.
	* Copyright 2015 RackTop Systems.
	* Copyright (c) 2016, Intel Corporation.
	* Copyright (c) 2021, Colm Buckley <colm@tuatha.org>
	*/

	/*
	* Pool import support functions.
	*
	* Used by zpool, ztest, zdb, and zhack to locate importable configs. Since
	* these commands are expected to run in the global zone, we can assume
	* that the devices are all readable when called.
	*
	* To import a pool, we rely on reading the configuration information from the
	* ZFS label of each device. If we successfully read the label, then we
	* organize the configuration information in the following hierarchy:
	*
	* pool guid -> toplevel vdev guid -> label txg
	*
	* Duplicate entries matching this same tuple will be discarded. Once we have
	* examined every device, we pick the best label txg config for each toplevel
	* vdev. We then arrange these toplevel vdevs into a complete pool config, and
	* update any paths that have changed. Finally, we attempt to import the pool
	* using our derived config, and record the results.
	*/

	#include <aio.h>
	#include <ctype.h>
	#include <dirent.h>
	#include <errno.h>
	#include <libintl.h>
	#include <libgen.h>
	#include <stddef.h>
	#include <stdlib.h>
	#include <string.h>
	#include <sys/stat.h>
	#include <unistd.h>
	#include <fcntl.h>
	#include <sys/dktp/fdisk.h>
	#include <sys/vdev_impl.h>
	#include <sys/fs/zfs.h>

	#include <thread_pool.h>
	#include <libzutil.h>
	#include <libnvpair.h>

	#include "zutil_import.h"

	/PRINTFLIKE2/
	static void
	zutil_error_aux(libpc_handle_t hdl, const char fmt, ...)
	{
	va_list ap;

	va_start(ap, fmt);

	(void) vsnprintf(hdl->lpc_desc, sizeof (hdl->lpc_desc), fmt, ap);
	hdl->lpc_desc_active = B_TRUE;

	va_end(ap);
	}

	static void
	zutil_verror(libpc_handle_t hdl, const char error, const char *fmt,
	va_list ap)
	{
	char action[1024];

	(void) vsnprintf(action, sizeof (action), fmt, ap);

	if (hdl->lpc_desc_active)
	hdl->lpc_desc_active = B_FALSE;
	else
	hdl->lpc_desc[0] = '\0';

	if (hdl->lpc_printerr) {
	if (hdl->lpc_desc[0] != '\0')
	error = hdl->lpc_desc;

	(void) fprintf(stderr, "%s: %s\n", action, error);
	}
	}

	/PRINTFLIKE3/
	static int
	zutil_error_fmt(libpc_handle_t hdl, const char error, const char *fmt, ...)
	{
	va_list ap;

	va_start(ap, fmt);

	zutil_verror(hdl, error, fmt, ap);

	va_end(ap);

	return (-1);
	}

	static int
	zutil_error(libpc_handle_t hdl, const char error, const char *msg)
	{
	return (zutil_error_fmt(hdl, error, "%s", msg));
	}

	static int
	zutil_no_memory(libpc_handle_t *hdl)
	{
	zutil_error(hdl, EZFS_NOMEM, "internal error");
	exit(1);
	}

	void *
	zutil_alloc(libpc_handle_t *hdl, size_t size)
	{
	void *data;

	if ((data = calloc(1, size)) == NULL)
	(void) zutil_no_memory(hdl);

	return (data);
	}

	char *
	zutil_strdup(libpc_handle_t hdl, const char str)
	{
	char *ret;

	if ((ret = strdup(str)) == NULL)
	(void) zutil_no_memory(hdl);

	return (ret);
	}

	/*
	* Intermediate structures used to gather configuration information.
	*/
	typedef struct config_entry {
	uint64_t ce_txg;
	nvlist_t *ce_config;
	struct config_entry *ce_next;
	} config_entry_t;

	typedef struct vdev_entry {
	uint64_t ve_guid;
	config_entry_t *ve_configs;
	struct vdev_entry *ve_next;
	} vdev_entry_t;

	typedef struct pool_entry {
	uint64_t pe_guid;
	vdev_entry_t *pe_vdevs;
	struct pool_entry *pe_next;
	} pool_entry_t;

	typedef struct name_entry {
	char *ne_name;
	uint64_t ne_guid;
	uint64_t ne_order;
	uint64_t ne_num_labels;
	struct name_entry *ne_next;
	} name_entry_t;

	typedef struct pool_list {
	pool_entry_t *pools;
	name_entry_t *names;
	} pool_list_t;

	/*
	* Go through and fix up any path and/or devid information for the given vdev
	* configuration.
	*/
	static int
	fix_paths(libpc_handle_t hdl, nvlist_t nv, name_entry_t *names)
	{
	nvlist_t **child;
	uint_t c, children;
	uint64_t guid;
	name_entry_t ne, best;
	char *path;

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
	&child, &children) == 0) {
	for (c = 0; c < children; c++)
	if (fix_paths(hdl, child[c], names) != 0)
	return (-1);
	return (0);
	}

	/*
	* This is a leaf (file or disk) vdev. In either case, go through
	* the name list and see if we find a matching guid. If so, replace
	* the path and see if we can calculate a new devid.
	*
	* There may be multiple names associated with a particular guid, in
	* which case we have overlapping partitions or multiple paths to the
	* same disk. In this case we prefer to use the path name which
	* matches the ZPOOL_CONFIG_PATH. If no matching entry is found we
	* use the lowest order device which corresponds to the first match
	* while traversing the ZPOOL_IMPORT_PATH search path.
	*/
	verify(nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &guid) == 0);
	if (nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path) != 0)
	path = NULL;

	best = NULL;
	for (ne = names; ne != NULL; ne = ne->ne_next) {
	if (ne->ne_guid == guid) {
	if (path == NULL) {
	best = ne;
	break;
	}

	if ((strlen(path) == strlen(ne->ne_name)) &&
	strncmp(path, ne->ne_name, strlen(path)) == 0) {
	best = ne;
	break;
	}

	if (best == NULL) {
	best = ne;
	continue;
	}

	/* Prefer paths with move vdev labels. */
	if (ne->ne_num_labels > best->ne_num_labels) {
	best = ne;
	continue;
	}

	/* Prefer paths earlier in the search order. */
	if (ne->ne_num_labels == best->ne_num_labels &&
	ne->ne_order < best->ne_order) {
	best = ne;
	continue;
	}
	}
	}

	if (best == NULL)
	return (0);

	if (nvlist_add_string(nv, ZPOOL_CONFIG_PATH, best->ne_name) != 0)
	return (-1);

	update_vdev_config_dev_strs(nv);

	return (0);
	}

	/*
	* Add the given configuration to the list of known devices.
	*/
	static int
	add_config(libpc_handle_t hdl, pool_list_t pl, const char *path,
	int order, int num_labels, nvlist_t *config)
	{
	uint64_t pool_guid, vdev_guid, top_guid, txg, state;
	pool_entry_t *pe;
	vdev_entry_t *ve;
	config_entry_t *ce;
	name_entry_t *ne;

	/*
	* If this is a hot spare not currently in use or level 2 cache
	* device, add it to the list of names to translate, but don't do
	* anything else.
	*/
	if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE,
	&state) == 0 &&
	(state == POOL_STATE_SPARE \|\| state == POOL_STATE_L2CACHE) &&
	nvlist_lookup_uint64(config, ZPOOL_CONFIG_GUID, &vdev_guid) == 0) {
	if ((ne = zutil_alloc(hdl, sizeof (name_entry_t))) == NULL)
	return (-1);

	if ((ne->ne_name = zutil_strdup(hdl, path)) == NULL) {
	free(ne);
	return (-1);
	}
	ne->ne_guid = vdev_guid;
	ne->ne_order = order;
	ne->ne_num_labels = num_labels;
	ne->ne_next = pl->names;
	pl->names = ne;

	return (0);
	}

	/*
	* If we have a valid config but cannot read any of these fields, then
	* it means we have a half-initialized label. In vdev_label_init()
	* we write a label with txg == 0 so that we can identify the device
	* in case the user refers to the same disk later on. If we fail to
	* create the pool, we'll be left with a label in this state
	* which should not be considered part of a valid pool.
	*/
	if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID,
	&pool_guid) != 0 \|\|
	nvlist_lookup_uint64(config, ZPOOL_CONFIG_GUID,
	&vdev_guid) != 0 \|\|
	nvlist_lookup_uint64(config, ZPOOL_CONFIG_TOP_GUID,
	&top_guid) != 0 \|\|
	nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_TXG,
	&txg) != 0 \|\| txg == 0) {
	return (0);
	}

	/*
	* First, see if we know about this pool. If not, then add it to the
	* list of known pools.
	*/
	for (pe = pl->pools; pe != NULL; pe = pe->pe_next) {
	if (pe->pe_guid == pool_guid)
	break;
	}

	if (pe == NULL) {
	if ((pe = zutil_alloc(hdl, sizeof (pool_entry_t))) == NULL) {
	return (-1);
	}
	pe->pe_guid = pool_guid;
	pe->pe_next = pl->pools;
	pl->pools = pe;
	}

	/*
	* Second, see if we know about this toplevel vdev. Add it if its
	* missing.
	*/
	for (ve = pe->pe_vdevs; ve != NULL; ve = ve->ve_next) {
	if (ve->ve_guid == top_guid)
	break;
	}

	if (ve == NULL) {
	if ((ve = zutil_alloc(hdl, sizeof (vdev_entry_t))) == NULL) {
	return (-1);
	}
	ve->ve_guid = top_guid;
	ve->ve_next = pe->pe_vdevs;
	pe->pe_vdevs = ve;
	}

	/*
	* Third, see if we have a config with a matching transaction group. If
	* so, then we do nothing. Otherwise, add it to the list of known
	* configs.
	*/
	for (ce = ve->ve_configs; ce != NULL; ce = ce->ce_next) {
	if (ce->ce_txg == txg)
	break;
	}

	if (ce == NULL) {
	if ((ce = zutil_alloc(hdl, sizeof (config_entry_t))) == NULL) {
	return (-1);
	}
	ce->ce_txg = txg;
	ce->ce_config = fnvlist_dup(config);
	ce->ce_next = ve->ve_configs;
	ve->ve_configs = ce;
	}

	/*
	* At this point we've successfully added our config to the list of
	* known configs. The last thing to do is add the vdev guid -> path
	* mappings so that we can fix up the configuration as necessary before
	* doing the import.
	*/
	if ((ne = zutil_alloc(hdl, sizeof (name_entry_t))) == NULL)
	return (-1);

	if ((ne->ne_name = zutil_strdup(hdl, path)) == NULL) {
	free(ne);
	return (-1);
	}

	ne->ne_guid = vdev_guid;
	ne->ne_order = order;
	ne->ne_num_labels = num_labels;
	ne->ne_next = pl->names;
	pl->names = ne;

	return (0);
	}

	static int
	zutil_pool_active(libpc_handle_t hdl, const char name, uint64_t guid,
	boolean_t *isactive)
	{
	ASSERT(hdl->lpc_ops->pco_pool_active != NULL);

	int error = hdl->lpc_ops->pco_pool_active(hdl->lpc_lib_handle, name,
	guid, isactive);

	return (error);
	}

	static nvlist_t *
	zutil_refresh_config(libpc_handle_t hdl, nvlist_t tryconfig)
	{
	ASSERT(hdl->lpc_ops->pco_refresh_config != NULL);

	return (hdl->lpc_ops->pco_refresh_config(hdl->lpc_lib_handle,
	tryconfig));
	}

	/*
	* Determine if the vdev id is a hole in the namespace.
	*/
	static boolean_t
	vdev_is_hole(uint64_t *hole_array, uint_t holes, uint_t id)
	{
	int c;

	for (c = 0; c < holes; c++) {

	/* Top-level is a hole */
	if (hole_array[c] == id)
	return (B_TRUE);
	}
	return (B_FALSE);
	}

	/*
	* Convert our list of pools into the definitive set of configurations. We
	* start by picking the best config for each toplevel vdev. Once that's done,
	* we assemble the toplevel vdevs into a full config for the pool. We make a
	* pass to fix up any incorrect paths, and then add it to the main list to
	* return to the user.
	*/
	static nvlist_t *
	get_configs(libpc_handle_t hdl, pool_list_t pl, boolean_t active_ok,
	nvlist_t *policy)
	{
	pool_entry_t *pe;
	vdev_entry_t *ve;
	config_entry_t *ce;
	nvlist_t ret = NULL, config = NULL, tmp = NULL, nvtop, *nvroot;
	nvlist_t spares, l2cache;
	uint_t i, nspares, nl2cache;
	boolean_t config_seen;
	uint64_t best_txg;
	char name, hostname = NULL;
	uint64_t guid;
	uint_t children = 0;
	nvlist_t **child = NULL;
	uint_t holes;
	uint64_t *hole_array, max_id;
	uint_t c;
	boolean_t isactive;
	uint64_t hostid;
	nvlist_t *nvl;
	boolean_t valid_top_config = B_FALSE;

	if (nvlist_alloc(&ret, 0, 0) != 0)
	goto nomem;

	for (pe = pl->pools; pe != NULL; pe = pe->pe_next) {
	uint64_t id, max_txg = 0;

	if (nvlist_alloc(&config, NV_UNIQUE_NAME, 0) != 0)
	goto nomem;
	config_seen = B_FALSE;

	/*
	* Iterate over all toplevel vdevs. Grab the pool configuration
	* from the first one we find, and then go through the rest and
	* add them as necessary to the 'vdevs' member of the config.
	*/
	for (ve = pe->pe_vdevs; ve != NULL; ve = ve->ve_next) {

	/*
	* Determine the best configuration for this vdev by
	* selecting the config with the latest transaction
	* group.
	*/
	best_txg = 0;
	for (ce = ve->ve_configs; ce != NULL;
	ce = ce->ce_next) {

	if (ce->ce_txg > best_txg) {
	tmp = ce->ce_config;
	best_txg = ce->ce_txg;
	}
	}

	/*
	* We rely on the fact that the max txg for the
	* pool will contain the most up-to-date information
	* about the valid top-levels in the vdev namespace.
	*/
	if (best_txg > max_txg) {
	(void) nvlist_remove(config,
	ZPOOL_CONFIG_VDEV_CHILDREN,
	DATA_TYPE_UINT64);
	(void) nvlist_remove(config,
	ZPOOL_CONFIG_HOLE_ARRAY,
	DATA_TYPE_UINT64_ARRAY);

	max_txg = best_txg;
	hole_array = NULL;
	holes = 0;
	max_id = 0;
	valid_top_config = B_FALSE;

	if (nvlist_lookup_uint64(tmp,
	ZPOOL_CONFIG_VDEV_CHILDREN, &max_id) == 0) {
	verify(nvlist_add_uint64(config,
	ZPOOL_CONFIG_VDEV_CHILDREN,
	max_id) == 0);
	valid_top_config = B_TRUE;
	}

	if (nvlist_lookup_uint64_array(tmp,
	ZPOOL_CONFIG_HOLE_ARRAY, &hole_array,
	&holes) == 0) {
	verify(nvlist_add_uint64_array(config,
	ZPOOL_CONFIG_HOLE_ARRAY,
	hole_array, holes) == 0);
	}
	}

	if (!config_seen) {
	/*
	* Copy the relevant pieces of data to the pool
	* configuration:
	*
	* version
	* pool guid
	* name
	* comment (if available)
	* compatibility features (if available)
	* pool state
	* hostid (if available)
	* hostname (if available)
	*/
	uint64_t state, version;
	char *comment = NULL;
	char *compatibility = NULL;

	version = fnvlist_lookup_uint64(tmp,
	ZPOOL_CONFIG_VERSION);
	fnvlist_add_uint64(config,
	ZPOOL_CONFIG_VERSION, version);
	guid = fnvlist_lookup_uint64(tmp,
	ZPOOL_CONFIG_POOL_GUID);
	fnvlist_add_uint64(config,
	ZPOOL_CONFIG_POOL_GUID, guid);
	name = fnvlist_lookup_string(tmp,
	ZPOOL_CONFIG_POOL_NAME);
	fnvlist_add_string(config,
	ZPOOL_CONFIG_POOL_NAME, name);

	if (nvlist_lookup_string(tmp,
	ZPOOL_CONFIG_COMMENT, &comment) == 0)
	fnvlist_add_string(config,
	ZPOOL_CONFIG_COMMENT, comment);

	if (nvlist_lookup_string(tmp,
	ZPOOL_CONFIG_COMPATIBILITY,
	&compatibility) == 0)
	fnvlist_add_string(config,
	ZPOOL_CONFIG_COMPATIBILITY,
	compatibility);

	state = fnvlist_lookup_uint64(tmp,
	ZPOOL_CONFIG_POOL_STATE);
	fnvlist_add_uint64(config,
	ZPOOL_CONFIG_POOL_STATE, state);

	hostid = 0;
	if (nvlist_lookup_uint64(tmp,
	ZPOOL_CONFIG_HOSTID, &hostid) == 0) {
	fnvlist_add_uint64(config,
	ZPOOL_CONFIG_HOSTID, hostid);
	hostname = fnvlist_lookup_string(tmp,
	ZPOOL_CONFIG_HOSTNAME);
	fnvlist_add_string(config,
	ZPOOL_CONFIG_HOSTNAME, hostname);
	}

	config_seen = B_TRUE;
	}

	/*
	* Add this top-level vdev to the child array.
	*/
	verify(nvlist_lookup_nvlist(tmp,
	ZPOOL_CONFIG_VDEV_TREE, &nvtop) == 0);
	verify(nvlist_lookup_uint64(nvtop, ZPOOL_CONFIG_ID,
	&id) == 0);

	if (id >= children) {
	nvlist_t **newchild;

	newchild = zutil_alloc(hdl, (id + 1) *
	sizeof (nvlist_t *));
	if (newchild == NULL)
	goto nomem;

	for (c = 0; c < children; c++)
	newchild[c] = child[c];

	free(child);
	child = newchild;
	children = id + 1;
	}
	if (nvlist_dup(nvtop, &child[id], 0) != 0)
	goto nomem;

	}

	/*
	* If we have information about all the top-levels then
	* clean up the nvlist which we've constructed. This
	* means removing any extraneous devices that are
	* beyond the valid range or adding devices to the end
	* of our array which appear to be missing.
	*/
	if (valid_top_config) {
	if (max_id < children) {
	for (c = max_id; c < children; c++)
	nvlist_free(child[c]);
	children = max_id;
	} else if (max_id > children) {
	nvlist_t **newchild;

	newchild = zutil_alloc(hdl, (max_id) *
	sizeof (nvlist_t *));
	if (newchild == NULL)
	goto nomem;

	for (c = 0; c < children; c++)
	newchild[c] = child[c];

	free(child);
	child = newchild;
	children = max_id;
	}
	}

	verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID,
	&guid) == 0);

	/*
	* The vdev namespace may contain holes as a result of
	* device removal. We must add them back into the vdev
	* tree before we process any missing devices.
	*/
	if (holes > 0) {
	ASSERT(valid_top_config);

	for (c = 0; c < children; c++) {
	nvlist_t *holey;

	if (child[c] != NULL \|\|
	!vdev_is_hole(hole_array, holes, c))
	continue;

	if (nvlist_alloc(&holey, NV_UNIQUE_NAME,
	0) != 0)
	goto nomem;

	/*
	* Holes in the namespace are treated as
	* "hole" top-level vdevs and have a
	* special flag set on them.
	*/
	if (nvlist_add_string(holey,
	ZPOOL_CONFIG_TYPE,
	VDEV_TYPE_HOLE) != 0 \|\|
	nvlist_add_uint64(holey,
	ZPOOL_CONFIG_ID, c) != 0 \|\|
	nvlist_add_uint64(holey,
	ZPOOL_CONFIG_GUID, 0ULL) != 0) {
	nvlist_free(holey);
	goto nomem;
	}
	child[c] = holey;
	}
	}

	/*
	* Look for any missing top-level vdevs. If this is the case,
	* create a faked up 'missing' vdev as a placeholder. We cannot
	* simply compress the child array, because the kernel performs
	* certain checks to make sure the vdev IDs match their location
	* in the configuration.
	*/
	for (c = 0; c < children; c++) {
	if (child[c] == NULL) {
	nvlist_t *missing;
	if (nvlist_alloc(&missing, NV_UNIQUE_NAME,
	0) != 0)
	goto nomem;
	if (nvlist_add_string(missing,
	ZPOOL_CONFIG_TYPE,
	VDEV_TYPE_MISSING) != 0 \|\|
	nvlist_add_uint64(missing,
	ZPOOL_CONFIG_ID, c) != 0 \|\|
	nvlist_add_uint64(missing,
	ZPOOL_CONFIG_GUID, 0ULL) != 0) {
	nvlist_free(missing);
	goto nomem;
	}
	child[c] = missing;
	}
	}

	/*
	* Put all of this pool's top-level vdevs into a root vdev.
	*/
	if (nvlist_alloc(&nvroot, NV_UNIQUE_NAME, 0) != 0)
	goto nomem;
	if (nvlist_add_string(nvroot, ZPOOL_CONFIG_TYPE,
	VDEV_TYPE_ROOT) != 0 \|\|
	nvlist_add_uint64(nvroot, ZPOOL_CONFIG_ID, 0ULL) != 0 \|\|
	nvlist_add_uint64(nvroot, ZPOOL_CONFIG_GUID, guid) != 0 \|\|
	nvlist_add_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN,
	child, children) != 0) {
	nvlist_free(nvroot);
	goto nomem;
	}

	for (c = 0; c < children; c++)
	nvlist_free(child[c]);
	free(child);
	children = 0;
	child = NULL;

	/*
	* Go through and fix up any paths and/or devids based on our
	* known list of vdev GUID -> path mappings.
	*/
	if (fix_paths(hdl, nvroot, pl->names) != 0) {
	nvlist_free(nvroot);
	goto nomem;
	}

	/*
	* Add the root vdev to this pool's configuration.
	*/
	if (nvlist_add_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
	nvroot) != 0) {
	nvlist_free(nvroot);
	goto nomem;
	}
	nvlist_free(nvroot);

	/*
	* zdb uses this path to report on active pools that were
	* imported or created using -R.
	*/
	if (active_ok)
	goto add_pool;

	/*
	* Determine if this pool is currently active, in which case we
	* can't actually import it.
	*/
	verify(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME,
	&name) == 0);
	verify(nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID,
	&guid) == 0);

	if (zutil_pool_active(hdl, name, guid, &isactive) != 0)
	goto error;

	if (isactive) {
	nvlist_free(config);
	config = NULL;
	continue;
	}

	if (policy != NULL) {
	if (nvlist_add_nvlist(config, ZPOOL_LOAD_POLICY,
	policy) != 0)
	goto nomem;
	}

	if ((nvl = zutil_refresh_config(hdl, config)) == NULL) {
	nvlist_free(config);
	config = NULL;
	continue;
	}

	nvlist_free(config);
	config = nvl;

	/*
	* Go through and update the paths for spares, now that we have
	* them.
	*/
	verify(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
	&nvroot) == 0);
	if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES,
	&spares, &nspares) == 0) {
	for (i = 0; i < nspares; i++) {
	if (fix_paths(hdl, spares[i], pl->names) != 0)
	goto nomem;
	}
	}

	/*
	* Update the paths for l2cache devices.
	*/
	if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE,
	&l2cache, &nl2cache) == 0) {
	for (i = 0; i < nl2cache; i++) {
	if (fix_paths(hdl, l2cache[i], pl->names) != 0)
	goto nomem;
	}
	}

	/*
	* Restore the original information read from the actual label.
	*/
	(void) nvlist_remove(config, ZPOOL_CONFIG_HOSTID,
	DATA_TYPE_UINT64);
	(void) nvlist_remove(config, ZPOOL_CONFIG_HOSTNAME,
	DATA_TYPE_STRING);
	if (hostid != 0) {
	verify(nvlist_add_uint64(config, ZPOOL_CONFIG_HOSTID,
	hostid) == 0);
	verify(nvlist_add_string(config, ZPOOL_CONFIG_HOSTNAME,
	hostname) == 0);
	}

	add_pool:
	/*
	* Add this pool to the list of configs.
	*/
	verify(nvlist_lookup_string(config, ZPOOL_CONFIG_POOL_NAME,
	&name) == 0);

	if (nvlist_add_nvlist(ret, name, config) != 0)
	goto nomem;

	nvlist_free(config);
	config = NULL;
	}

	return (ret);

	nomem:
	(void) zutil_no_memory(hdl);
	error:
	nvlist_free(config);
	nvlist_free(ret);
	for (c = 0; c < children; c++)
	nvlist_free(child[c]);
	free(child);

	return (NULL);
	}

	/*
	* Return the offset of the given label.
	*/
	static uint64_t
	label_offset(uint64_t size, int l)
	{
	ASSERT(P2PHASE_TYPED(size, sizeof (vdev_label_t), uint64_t) == 0);
	return (l * sizeof (vdev_label_t) + (l < VDEV_LABELS / 2 ?
	0 : size - VDEV_LABELS * sizeof (vdev_label_t)));
	}

	+/*
	+ * The same description applies as to zpool_read_label below,
	+ * except here we do it without aio, presumably because an aio call
	+ * errored out in a way we think not using it could circumvent.
	+ */
	+static int
	+zpool_read_label_slow(int fd, nvlist_t *config, int num_labels)
	+{
	+ struct stat64 statbuf;
	+ int l, count = 0;
	+ vdev_phys_t *label;
	+ nvlist_t *expected_config = NULL;
	+ uint64_t expected_guid = 0, size;
	+ int error;
	+
	+ *config = NULL;
	+
	+ if (fstat64_blk(fd, &statbuf) == -1)
	+ return (0);
	+ size = P2ALIGN_TYPED(statbuf.st_size, sizeof (vdev_label_t), uint64_t);
	+
	+ error = posix_memalign((void *)&label, PAGESIZE, sizeof (label));
	+ if (error)
	+ return (-1);
	+
	+ for (l = 0; l < VDEV_LABELS; l++) {
	+ uint64_t state, guid, txg;
	+ off_t offset = label_offset(size, l) + VDEV_SKIP_SIZE;
	+
	+ if (pread64(fd, label, sizeof (vdev_phys_t),
	+ offset) != sizeof (vdev_phys_t))
	+ continue;
	+
	+ if (nvlist_unpack(label->vp_nvlist,
	+ sizeof (label->vp_nvlist), config, 0) != 0)
	+ continue;
	+
	+ if (nvlist_lookup_uint64(*config, ZPOOL_CONFIG_GUID,
	+ &guid) != 0 \|\| guid == 0) {
	+ nvlist_free(*config);
	+ continue;
	+ }
	+
	+ if (nvlist_lookup_uint64(*config, ZPOOL_CONFIG_POOL_STATE,
	+ &state) != 0 \|\| state > POOL_STATE_L2CACHE) {
	+ nvlist_free(*config);
	+ continue;
	+ }
	+
	+ if (state != POOL_STATE_SPARE && state != POOL_STATE_L2CACHE &&
	+ (nvlist_lookup_uint64(*config, ZPOOL_CONFIG_POOL_TXG,
	+ &txg) != 0 \|\| txg == 0)) {
	+ nvlist_free(*config);
	+ continue;
	+ }
	+
	+ if (expected_guid) {
	+ if (expected_guid == guid)
	+ count++;
	+
	+ nvlist_free(*config);
	+ } else {
	+ expected_config = *config;
	+ expected_guid = guid;
	+ count++;
	+ }
	+ }
	+
	+ if (num_labels != NULL)
	+ *num_labels = count;
	+
	+ free(label);
	+ *config = expected_config;
	+
	+ return (0);
	+}
	+
	/*
	* Given a file descriptor, read the label information and return an nvlist
	* describing the configuration, if there is one. The number of valid
	* labels found will be returned in num_labels when non-NULL.
	*/
	int
	zpool_read_label(int fd, nvlist_t *config, int num_labels)
	{
	struct stat64 statbuf;
	struct aiocb aiocbs[VDEV_LABELS];
	struct aiocb *aiocbps[VDEV_LABELS];
	vdev_phys_t *labels;
	nvlist_t *expected_config = NULL;
	uint64_t expected_guid = 0, size;
	int error, l, count = 0;

	*config = NULL;

	if (fstat64_blk(fd, &statbuf) == -1)
	return (0);
	size = P2ALIGN_TYPED(statbuf.st_size, sizeof (vdev_label_t), uint64_t);

	error = posix_memalign((void **)&labels, PAGESIZE,
	VDEV_LABELS * sizeof (*labels));
	if (error)
	return (-1);

	memset(aiocbs, 0, sizeof (aiocbs));
	for (l = 0; l < VDEV_LABELS; l++) {
	off_t offset = label_offset(size, l) + VDEV_SKIP_SIZE;

	aiocbs[l].aio_fildes = fd;
	aiocbs[l].aio_offset = offset;
	aiocbs[l].aio_buf = &labels[l];
	aiocbs[l].aio_nbytes = sizeof (vdev_phys_t);
	aiocbs[l].aio_lio_opcode = LIO_READ;
	aiocbps[l] = &aiocbs[l];
	}

	if (lio_listio(LIO_WAIT, aiocbps, VDEV_LABELS, NULL) != 0) {
	int saved_errno = errno;
	+ boolean_t do_slow = B_FALSE;
	+ error = -1;

	if (errno == EAGAIN \|\| errno == EINTR \|\| errno == EIO) {
	/*
	* A portion of the requests may have been submitted.
	* Clean them up.
	*/
	for (l = 0; l < VDEV_LABELS; l++) {
	errno = 0;
	- int r = aio_error(&aiocbs[l]);
	- if (r != EINVAL)
	+ switch (aio_error(&aiocbs[l])) {
	+ case EINVAL:
	+ break;
	+ case EINPROGRESS:
	+ // This shouldn't be possible to
	+ // encounter, die if we do.
	+ ASSERT(B_FALSE);
	+ case EOPNOTSUPP:
	+ case ENOSYS:
	+ do_slow = B_TRUE;
	+ case 0:
	+ default:
	(void) aio_return(&aiocbs[l]);
	+ }
	}
	}
	+ if (do_slow) {
	+ /*
	+ * At least some IO involved access unsafe-for-AIO
	+ * files. Let's try again, without AIO this time.
	+ */
	+ error = zpool_read_label_slow(fd, config, num_labels);
	+ saved_errno = errno;
	+ }
	free(labels);
	errno = saved_errno;
	- return (-1);
	+ return (error);
	}

	for (l = 0; l < VDEV_LABELS; l++) {
	uint64_t state, guid, txg;

	if (aio_return(&aiocbs[l]) != sizeof (vdev_phys_t))
	continue;

	if (nvlist_unpack(labels[l].vp_nvlist,
	sizeof (labels[l].vp_nvlist), config, 0) != 0)
	continue;

	if (nvlist_lookup_uint64(*config, ZPOOL_CONFIG_GUID,
	&guid) != 0 \|\| guid == 0) {
	nvlist_free(*config);
	continue;
	}

	if (nvlist_lookup_uint64(*config, ZPOOL_CONFIG_POOL_STATE,
	&state) != 0 \|\| state > POOL_STATE_L2CACHE) {
	nvlist_free(*config);
	continue;
	}

	if (state != POOL_STATE_SPARE && state != POOL_STATE_L2CACHE &&
	(nvlist_lookup_uint64(*config, ZPOOL_CONFIG_POOL_TXG,
	&txg) != 0 \|\| txg == 0)) {
	nvlist_free(*config);
	continue;
	}

	if (expected_guid) {
	if (expected_guid == guid)
	count++;

	nvlist_free(*config);
	} else {
	expected_config = *config;
	expected_guid = guid;
	count++;
	}
	}

	if (num_labels != NULL)
	*num_labels = count;

	free(labels);
	*config = expected_config;

	return (0);
	}

	/*
	* Sorted by full path and then vdev guid to allow for multiple entries with
	* the same full path name. This is required because it's possible to
	* have multiple block devices with labels that refer to the same
	* ZPOOL_CONFIG_PATH yet have different vdev guids. In this case both
	* entries need to be added to the cache. Scenarios where this can occur
	* include overwritten pool labels, devices which are visible from multiple
	* hosts and multipath devices.
	*/
	int
	slice_cache_compare(const void arg1, const void arg2)
	{
	const char nm1 = ((rdsk_node_t )arg1)->rn_name;
	const char nm2 = ((rdsk_node_t )arg2)->rn_name;
	uint64_t guid1 = ((rdsk_node_t *)arg1)->rn_vdev_guid;
	uint64_t guid2 = ((rdsk_node_t *)arg2)->rn_vdev_guid;
	int rv;

	rv = TREE_ISIGN(strcmp(nm1, nm2));
	if (rv)
	return (rv);

	return (TREE_CMP(guid1, guid2));
	}

	static int
	label_paths_impl(libpc_handle_t hdl, nvlist_t nvroot, uint64_t pool_guid,
	uint64_t vdev_guid, char path, char devid)
	{
	nvlist_t **child;
	uint_t c, children;
	uint64_t guid;
	char *val;
	int error;

	if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_CHILDREN,
	&child, &children) == 0) {
	for (c = 0; c < children; c++) {
	error = label_paths_impl(hdl, child[c],
	pool_guid, vdev_guid, path, devid);
	if (error)
	return (error);
	}
	return (0);
	}

	if (nvroot == NULL)
	return (0);

	error = nvlist_lookup_uint64(nvroot, ZPOOL_CONFIG_GUID, &guid);
	if ((error != 0) \|\| (guid != vdev_guid))
	return (0);

	error = nvlist_lookup_string(nvroot, ZPOOL_CONFIG_PATH, &val);
	if (error == 0)
	*path = val;

	error = nvlist_lookup_string(nvroot, ZPOOL_CONFIG_DEVID, &val);
	if (error == 0)
	*devid = val;

	return (0);
	}

	/*
	* Given a disk label fetch the ZPOOL_CONFIG_PATH and ZPOOL_CONFIG_DEVID
	* and store these strings as config_path and devid_path respectively.
	* The returned pointers are only valid as long as label remains valid.
	*/
	int
	label_paths(libpc_handle_t hdl, nvlist_t label, char path, char devid)
	{
	nvlist_t *nvroot;
	uint64_t pool_guid;
	uint64_t vdev_guid;

	*path = NULL;
	*devid = NULL;

	if (nvlist_lookup_nvlist(label, ZPOOL_CONFIG_VDEV_TREE, &nvroot) \|\|
	nvlist_lookup_uint64(label, ZPOOL_CONFIG_POOL_GUID, &pool_guid) \|\|
	nvlist_lookup_uint64(label, ZPOOL_CONFIG_GUID, &vdev_guid))
	return (ENOENT);

	return (label_paths_impl(hdl, nvroot, pool_guid, vdev_guid, path,
	devid));
	}

	static void
	zpool_find_import_scan_add_slice(libpc_handle_t hdl, pthread_mutex_t lock,
	avl_tree_t cache, const char path, const char *name, int order)
	{
	avl_index_t where;
	rdsk_node_t *slice;

	slice = zutil_alloc(hdl, sizeof (rdsk_node_t));
	if (asprintf(&slice->rn_name, "%s/%s", path, name) == -1) {
	free(slice);
	return;
	}
	slice->rn_vdev_guid = 0;
	slice->rn_lock = lock;
	slice->rn_avl = cache;
	slice->rn_hdl = hdl;
	slice->rn_order = order + IMPORT_ORDER_SCAN_OFFSET;
	slice->rn_labelpaths = B_FALSE;

	pthread_mutex_lock(lock);
	if (avl_find(cache, slice, &where)) {
	free(slice->rn_name);
	free(slice);
	} else {
	avl_insert(cache, slice, where);
	}
	pthread_mutex_unlock(lock);
	}

	static int
	zpool_find_import_scan_dir(libpc_handle_t hdl, pthread_mutex_t lock,
	avl_tree_t cache, const char dir, int order)
	{
	int error;
	char path[MAXPATHLEN];
	struct dirent64 *dp;
	DIR *dirp;

	if (realpath(dir, path) == NULL) {
	error = errno;
	if (error == ENOENT)
	return (0);

	zutil_error_aux(hdl, strerror(error));
	(void) zutil_error_fmt(hdl, EZFS_BADPATH, dgettext(
	TEXT_DOMAIN, "cannot resolve path '%s'"), dir);
	return (error);
	}

	dirp = opendir(path);
	if (dirp == NULL) {
	error = errno;
	zutil_error_aux(hdl, strerror(error));
	(void) zutil_error_fmt(hdl, EZFS_BADPATH,
	dgettext(TEXT_DOMAIN, "cannot open '%s'"), path);
	return (error);
	}

	while ((dp = readdir64(dirp)) != NULL) {
	const char *name = dp->d_name;
	if (name[0] == '.' &&
	(name[1] == 0 \|\| (name[1] == '.' && name[2] == 0)))
	continue;

	zpool_find_import_scan_add_slice(hdl, lock, cache, path, name,
	order);
	}

	(void) closedir(dirp);
	return (0);
	}

	static int
	zpool_find_import_scan_path(libpc_handle_t hdl, pthread_mutex_t lock,
	avl_tree_t cache, const char dir, int order)
	{
	int error = 0;
	char path[MAXPATHLEN];
	char d, b;
	char dpath, name;

	/*
	* Separate the directory part and last part of the
	* path. We do this so that we can get the realpath of
	* the directory. We don't get the realpath on the
	* whole path because if it's a symlink, we want the
	* path of the symlink not where it points to.
	*/
	d = zutil_strdup(hdl, dir);
	b = zutil_strdup(hdl, dir);
	dpath = dirname(d);
	name = basename(b);

	if (realpath(dpath, path) == NULL) {
	error = errno;
	if (error == ENOENT) {
	error = 0;
	goto out;
	}

	zutil_error_aux(hdl, strerror(error));
	(void) zutil_error_fmt(hdl, EZFS_BADPATH, dgettext(
	TEXT_DOMAIN, "cannot resolve path '%s'"), dir);
	goto out;
	}

	zpool_find_import_scan_add_slice(hdl, lock, cache, path, name, order);

	out:
	free(b);
	free(d);
	return (error);
	}

	/*
	* Scan a list of directories for zfs devices.
	*/
	static int
	zpool_find_import_scan(libpc_handle_t hdl, pthread_mutex_t lock,
	avl_tree_t *slice_cache, const char const *dir, size_t dirs)
	{
	avl_tree_t *cache;
	rdsk_node_t *slice;
	void *cookie;
	int i, error;

	*slice_cache = NULL;
	cache = zutil_alloc(hdl, sizeof (avl_tree_t));
	avl_create(cache, slice_cache_compare, sizeof (rdsk_node_t),
	offsetof(rdsk_node_t, rn_node));

	for (i = 0; i < dirs; i++) {
	struct stat sbuf;

	if (stat(dir[i], &sbuf) != 0) {
	error = errno;
	if (error == ENOENT)
	continue;

	zutil_error_aux(hdl, strerror(error));
	(void) zutil_error_fmt(hdl, EZFS_BADPATH, dgettext(
	TEXT_DOMAIN, "cannot resolve path '%s'"), dir[i]);
	goto error;
	}

	/*
	* If dir[i] is a directory, we walk through it and add all
	* the entries to the cache. If it's not a directory, we just
	* add it to the cache.
	*/
	if (S_ISDIR(sbuf.st_mode)) {
	if ((error = zpool_find_import_scan_dir(hdl, lock,
	cache, dir[i], i)) != 0)
	goto error;
	} else {
	if ((error = zpool_find_import_scan_path(hdl, lock,
	cache, dir[i], i)) != 0)
	goto error;
	}
	}

	*slice_cache = cache;
	return (0);

	error:
	cookie = NULL;
	while ((slice = avl_destroy_nodes(cache, &cookie)) != NULL) {
	free(slice->rn_name);
	free(slice);
	}
	free(cache);

	return (error);
	}

	/*
	* Given a list of directories to search, find all pools stored on disk. This
	* includes partial pools which are not available to import. If no args are
	* given (argc is 0), then the default directory (/dev/dsk) is searched.
	* poolname or guid (but not both) are provided by the caller when trying
	* to import a specific pool.
	*/
	static nvlist_t *
	zpool_find_import_impl(libpc_handle_t hdl, importargs_t iarg,
	pthread_mutex_t lock, avl_tree_t cache)
	{
	nvlist_t *ret = NULL;
	pool_list_t pools = { 0 };
	pool_entry_t pe, penext;
	vdev_entry_t ve, venext;
	config_entry_t ce, cenext;
	name_entry_t ne, nenext;
	rdsk_node_t *slice;
	void *cookie;
	tpool_t *t;

	verify(iarg->poolname == NULL \|\| iarg->guid == 0);

	/*
	* Create a thread pool to parallelize the process of reading and
	* validating labels, a large number of threads can be used due to
	* minimal contention.
	*/
	t = tpool_create(1, 2 * sysconf(_SC_NPROCESSORS_ONLN), 0, NULL);
	for (slice = avl_first(cache); slice;
	(slice = avl_walk(cache, slice, AVL_AFTER)))
	(void) tpool_dispatch(t, zpool_open_func, slice);

	tpool_wait(t);
	tpool_destroy(t);

	/*
	* Process the cache, filtering out any entries which are not
	* for the specified pool then adding matching label configs.
	*/
	cookie = NULL;
	while ((slice = avl_destroy_nodes(cache, &cookie)) != NULL) {
	if (slice->rn_config != NULL) {
	nvlist_t *config = slice->rn_config;
	boolean_t matched = B_TRUE;
	boolean_t aux = B_FALSE;
	int fd;

	/*
	* Check if it's a spare or l2cache device. If it is,
	* we need to skip the name and guid check since they
	* don't exist on aux device label.
	*/
	if (iarg->poolname != NULL \|\| iarg->guid != 0) {
	uint64_t state;
	aux = nvlist_lookup_uint64(config,
	ZPOOL_CONFIG_POOL_STATE, &state) == 0 &&
	(state == POOL_STATE_SPARE \|\|
	state == POOL_STATE_L2CACHE);
	}

	if (iarg->poolname != NULL && !aux) {
	char *pname;

	matched = nvlist_lookup_string(config,
	ZPOOL_CONFIG_POOL_NAME, &pname) == 0 &&
	strcmp(iarg->poolname, pname) == 0;
	} else if (iarg->guid != 0 && !aux) {
	uint64_t this_guid;

	matched = nvlist_lookup_uint64(config,
	ZPOOL_CONFIG_POOL_GUID, &this_guid) == 0 &&
	iarg->guid == this_guid;
	}
	if (matched) {
	/*
	* Verify all remaining entries can be opened
	* exclusively. This will prune all underlying
	* multipath devices which otherwise could
	* result in the vdev appearing as UNAVAIL.
	*
	* Under zdb, this step isn't required and
	* would prevent a zdb -e of active pools with
	* no cachefile.
	*/
	- fd = open(slice->rn_name, O_RDONLY \| O_EXCL);
	+ fd = open(slice->rn_name,
	+ O_RDONLY \| O_EXCL \| O_CLOEXEC);
	if (fd >= 0 \|\| iarg->can_be_active) {
	if (fd >= 0)
	close(fd);
	add_config(hdl, &pools,
	slice->rn_name, slice->rn_order,
	slice->rn_num_labels, config);
	}
	}
	nvlist_free(config);
	}
	free(slice->rn_name);
	free(slice);
	}
	avl_destroy(cache);
	free(cache);

	ret = get_configs(hdl, &pools, iarg->can_be_active, iarg->policy);

	for (pe = pools.pools; pe != NULL; pe = penext) {
	penext = pe->pe_next;
	for (ve = pe->pe_vdevs; ve != NULL; ve = venext) {
	venext = ve->ve_next;
	for (ce = ve->ve_configs; ce != NULL; ce = cenext) {
	cenext = ce->ce_next;
	nvlist_free(ce->ce_config);
	free(ce);
	}
	free(ve);
	}
	free(pe);
	}

	for (ne = pools.names; ne != NULL; ne = nenext) {
	nenext = ne->ne_next;
	free(ne->ne_name);
	free(ne);
	}

	return (ret);
	}

	/*
	* Given a config, discover the paths for the devices which
	* exist in the config.
	*/
	static int
	discover_cached_paths(libpc_handle_t hdl, nvlist_t nv,
	avl_tree_t cache, pthread_mutex_t lock)
	{
	char *path = NULL;
	uint_t children;
	nvlist_t **child;

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
	&child, &children) == 0) {
	for (int c = 0; c < children; c++) {
	discover_cached_paths(hdl, child[c], cache, lock);
	}
	}

	/*
	* Once we have the path, we need to add the directory to
	- * our directoy cache.
	+ * our directory cache.
	*/
	if (nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &path) == 0) {
	return (zpool_find_import_scan_dir(hdl, lock, cache,
	dirname(path), 0));
	}
	return (0);
	}

	/*
	* Given a cache file, return the contents as a list of importable pools.
	* poolname or guid (but not both) are provided by the caller when trying
	* to import a specific pool.
	*/
	static nvlist_t *
	zpool_find_import_cached(libpc_handle_t hdl, importargs_t iarg)
	{
	char *buf;
	int fd;
	struct stat64 statbuf;
	nvlist_t raw, src, *dst;
	nvlist_t *pools;
	nvpair_t *elem;
	char *name;
	uint64_t this_guid;
	boolean_t active;

	verify(iarg->poolname == NULL \|\| iarg->guid == 0);

	- if ((fd = open(iarg->cachefile, O_RDONLY)) < 0) {
	+ if ((fd = open(iarg->cachefile, O_RDONLY \| O_CLOEXEC)) < 0) {
	zutil_error_aux(hdl, "%s", strerror(errno));
	(void) zutil_error(hdl, EZFS_BADCACHE,
	dgettext(TEXT_DOMAIN, "failed to open cache file"));
	return (NULL);
	}

	if (fstat64(fd, &statbuf) != 0) {
	zutil_error_aux(hdl, "%s", strerror(errno));
	(void) close(fd);
	(void) zutil_error(hdl, EZFS_BADCACHE,
	dgettext(TEXT_DOMAIN, "failed to get size of cache file"));
	return (NULL);
	}

	if ((buf = zutil_alloc(hdl, statbuf.st_size)) == NULL) {
	(void) close(fd);
	return (NULL);
	}

	if (read(fd, buf, statbuf.st_size) != statbuf.st_size) {
	(void) close(fd);
	free(buf);
	(void) zutil_error(hdl, EZFS_BADCACHE,
	dgettext(TEXT_DOMAIN,
	"failed to read cache file contents"));
	return (NULL);
	}

	(void) close(fd);

	if (nvlist_unpack(buf, statbuf.st_size, &raw, 0) != 0) {
	free(buf);
	(void) zutil_error(hdl, EZFS_BADCACHE,
	dgettext(TEXT_DOMAIN,
	"invalid or corrupt cache file contents"));
	return (NULL);
	}

	free(buf);

	/*
	* Go through and get the current state of the pools and refresh their
	* state.
	*/
	if (nvlist_alloc(&pools, 0, 0) != 0) {
	(void) zutil_no_memory(hdl);
	nvlist_free(raw);
	return (NULL);
	}

	elem = NULL;
	while ((elem = nvlist_next_nvpair(raw, elem)) != NULL) {
	src = fnvpair_value_nvlist(elem);

	name = fnvlist_lookup_string(src, ZPOOL_CONFIG_POOL_NAME);
	if (iarg->poolname != NULL && strcmp(iarg->poolname, name) != 0)
	continue;

	this_guid = fnvlist_lookup_uint64(src, ZPOOL_CONFIG_POOL_GUID);
	if (iarg->guid != 0 && iarg->guid != this_guid)
	continue;

	if (zutil_pool_active(hdl, name, this_guid, &active) != 0) {
	nvlist_free(raw);
	nvlist_free(pools);
	return (NULL);
	}

	if (active)
	continue;

	if (iarg->scan) {
	uint64_t saved_guid = iarg->guid;
	const char *saved_poolname = iarg->poolname;
	pthread_mutex_t lock;

	/*
	* Create the device cache that will hold the
	* devices we will scan based on the cachefile.
	* This will get destroyed and freed by
	* zpool_find_import_impl.
	*/
	avl_tree_t *cache = zutil_alloc(hdl,
	sizeof (avl_tree_t));
	avl_create(cache, slice_cache_compare,
	sizeof (rdsk_node_t),
	offsetof(rdsk_node_t, rn_node));
	nvlist_t *nvroot = fnvlist_lookup_nvlist(src,
	ZPOOL_CONFIG_VDEV_TREE);

	/*
	* We only want to find the pool with this_guid.
	* We will reset these values back later.
	*/
	iarg->guid = this_guid;
	iarg->poolname = NULL;

	/*
	* We need to build up a cache of devices that exists
	* in the paths pointed to by the cachefile. This allows
	* us to preserve the device namespace that was
	* originally specified by the user but also lets us
	* scan devices in those directories in case they had
	* been renamed.
	*/
	pthread_mutex_init(&lock, NULL);
	discover_cached_paths(hdl, nvroot, cache, &lock);
	nvlist_t *nv = zpool_find_import_impl(hdl, iarg,
	&lock, cache);
	pthread_mutex_destroy(&lock);

	/*
	* zpool_find_import_impl will return back
	* a list of pools that it found based on the
	* device cache. There should only be one pool
	* since we're looking for a specific guid.
	* We will use that pool to build up the final
	* pool nvlist which is returned back to the
	* caller.
	*/
	nvpair_t *pair = nvlist_next_nvpair(nv, NULL);
	fnvlist_add_nvlist(pools, nvpair_name(pair),
	fnvpair_value_nvlist(pair));

	VERIFY3P(nvlist_next_nvpair(nv, pair), ==, NULL);

	iarg->guid = saved_guid;
	iarg->poolname = saved_poolname;
	continue;
	}

	if (nvlist_add_string(src, ZPOOL_CONFIG_CACHEFILE,
	iarg->cachefile) != 0) {
	(void) zutil_no_memory(hdl);
	nvlist_free(raw);
	nvlist_free(pools);
	return (NULL);
	}

	if ((dst = zutil_refresh_config(hdl, src)) == NULL) {
	nvlist_free(raw);
	nvlist_free(pools);
	return (NULL);
	}

	if (nvlist_add_nvlist(pools, nvpair_name(elem), dst) != 0) {
	(void) zutil_no_memory(hdl);
	nvlist_free(dst);
	nvlist_free(raw);
	nvlist_free(pools);
	return (NULL);
	}
	nvlist_free(dst);
	}
	nvlist_free(raw);
	return (pools);
	}

	static nvlist_t *
	zpool_find_import(libpc_handle_t hdl, importargs_t iarg)
	{
	pthread_mutex_t lock;
	avl_tree_t *cache;
	nvlist_t *pools = NULL;

	verify(iarg->poolname == NULL \|\| iarg->guid == 0);
	pthread_mutex_init(&lock, NULL);

	/*
	* Locate pool member vdevs by blkid or by directory scanning.
	* On success a newly allocated AVL tree which is populated with an
	* entry for each discovered vdev will be returned in the cache.
	* It's the caller's responsibility to consume and destroy this tree.
	*/
	if (iarg->scan \|\| iarg->paths != 0) {
	size_t dirs = iarg->paths;
	const char * const dir = (const char const *)iarg->path;

	if (dirs == 0)
	dir = zpool_default_search_paths(&dirs);

	if (zpool_find_import_scan(hdl, &lock, &cache,
	dir, dirs) != 0) {
	pthread_mutex_destroy(&lock);
	return (NULL);
	}
	} else {
	if (zpool_find_import_blkid(hdl, &lock, &cache) != 0) {
	pthread_mutex_destroy(&lock);
	return (NULL);
	}
	}

	pools = zpool_find_import_impl(hdl, iarg, &lock, cache);
	pthread_mutex_destroy(&lock);
	return (pools);
	}


	nvlist_t *
	zpool_search_import(void hdl, importargs_t import,
	const pool_config_ops_t *pco)
	{
	libpc_handle_t handle = { 0 };
	nvlist_t *pools = NULL;

	handle.lpc_lib_handle = hdl;
	handle.lpc_ops = pco;
	handle.lpc_printerr = B_TRUE;

	verify(import->poolname == NULL \|\| import->guid == 0);

	if (import->cachefile != NULL)
	pools = zpool_find_import_cached(&handle, import);
	else
	pools = zpool_find_import(&handle, import);

	if ((pools == NULL \|\| nvlist_empty(pools)) &&
	handle.lpc_open_access_error && geteuid() != 0) {
	(void) zutil_error(&handle, EZFS_EACESS, dgettext(TEXT_DOMAIN,
	"no pools found"));
	}

	return (pools);
	}

	static boolean_t
	pool_match(nvlist_t cfg, char tgt)
	{
	uint64_t v, guid = strtoull(tgt, NULL, 0);
	char *s;

	if (guid != 0) {
	if (nvlist_lookup_uint64(cfg, ZPOOL_CONFIG_POOL_GUID, &v) == 0)
	return (v == guid);
	} else {
	if (nvlist_lookup_string(cfg, ZPOOL_CONFIG_POOL_NAME, &s) == 0)
	return (strcmp(s, tgt) == 0);
	}
	return (B_FALSE);
	}

	int
	zpool_find_config(void hdl, const char target, nvlist_t **configp,
	importargs_t args, const pool_config_ops_t pco)
	{
	nvlist_t *pools;
	nvlist_t *match = NULL;
	nvlist_t *config = NULL;
	char *sepp = NULL;
	char sep = '\0';
	int count = 0;
	char *targetdup = strdup(target);

	*configp = NULL;

	if ((sepp = strpbrk(targetdup, "/@")) != NULL) {
	sep = *sepp;
	*sepp = '\0';
	}

	pools = zpool_search_import(hdl, args, pco);

	if (pools != NULL) {
	nvpair_t *elem = NULL;
	while ((elem = nvlist_next_nvpair(pools, elem)) != NULL) {
	VERIFY0(nvpair_value_nvlist(elem, &config));
	if (pool_match(config, targetdup)) {
	count++;
	if (match != NULL) {
	/* multiple matches found */
	continue;
	} else {
	match = fnvlist_dup(config);
	}
	}
	}
	fnvlist_free(pools);
	}

	if (count == 0) {
	free(targetdup);
	return (ENOENT);
	}

	if (count > 1) {
	free(targetdup);
	fnvlist_free(match);
	return (EINVAL);
	}

	*configp = match;
	free(targetdup);

	return (0);
	}
	diff --git a/sys/contrib/openzfs/lib/libzutil/zutil_nicenum.c b/sys/contrib/openzfs/lib/libzutil/zutil_nicenum.c
	index 306cec3caddf..1a19db0dfebc 100644
	--- a/sys/contrib/openzfs/lib/libzutil/zutil_nicenum.c
	+++ b/sys/contrib/openzfs/lib/libzutil/zutil_nicenum.c
	@@ -1,172 +1,175 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	*/

	#include <ctype.h>
	#include <math.h>
	#include <stdio.h>
	#include <libzutil.h>

	/*
	* Return B_TRUE if "str" is a number string, B_FALSE otherwise.
	* Works for integer and floating point numbers.
	*/
	boolean_t
	zfs_isnumber(const char *str)
	{
	+ if (!*str)
	+ return (B_FALSE);
	+
	for (; *str; str++)
	if (!(isdigit(str) \|\| (str == '.')))
	return (B_FALSE);

	return (B_TRUE);
	}

	/*
	* Convert a number to an appropriately human-readable output.
	*/
	void
	zfs_nicenum_format(uint64_t num, char *buf, size_t buflen,
	enum zfs_nicenum_format format)
	{
	uint64_t n = num;
	int index = 0;
	const char *u;
	const char *units[3][7] = {
	[ZFS_NICENUM_1024] = {"", "K", "M", "G", "T", "P", "E"},
	[ZFS_NICENUM_BYTES] = {"B", "K", "M", "G", "T", "P", "E"},
	[ZFS_NICENUM_TIME] = {"ns", "us", "ms", "s", "?", "?", "?"}
	};

	const int units_len[] = {[ZFS_NICENUM_1024] = 6,
	[ZFS_NICENUM_BYTES] = 6,
	[ZFS_NICENUM_TIME] = 4};

	const int k_unit[] = { [ZFS_NICENUM_1024] = 1024,
	[ZFS_NICENUM_BYTES] = 1024,
	[ZFS_NICENUM_TIME] = 1000};

	double val;

	if (format == ZFS_NICENUM_RAW) {
	snprintf(buf, buflen, "%llu", (u_longlong_t)num);
	return;
	} else if (format == ZFS_NICENUM_RAWTIME && num > 0) {
	snprintf(buf, buflen, "%llu", (u_longlong_t)num);
	return;
	} else if (format == ZFS_NICENUM_RAWTIME && num == 0) {
	snprintf(buf, buflen, "%s", "-");
	return;
	}

	while (n >= k_unit[format] && index < units_len[format]) {
	n /= k_unit[format];
	index++;
	}

	u = units[format][index];

	/* Don't print zero latencies since they're invalid */
	if ((format == ZFS_NICENUM_TIME) && (num == 0)) {
	(void) snprintf(buf, buflen, "-");
	} else if ((index == 0) \|\| ((num %
	(uint64_t)powl(k_unit[format], index)) == 0)) {
	/*
	* If this is an even multiple of the base, always display
	* without any decimal precision.
	*/
	(void) snprintf(buf, buflen, "%llu%s", (u_longlong_t)n, u);

	} else {
	/*
	* We want to choose a precision that reflects the best choice
	* for fitting in 5 characters. This can get rather tricky when
	* we have numbers that are very close to an order of magnitude.
	* For example, when displaying 10239 (which is really 9.999K),
	* we want only a single place of precision for 10.0K. We could
	* develop some complex heuristics for this, but it's much
	* easier just to try each combination in turn.
	*/
	int i;
	for (i = 2; i >= 0; i--) {
	val = (double)num /
	(uint64_t)powl(k_unit[format], index);

	/*
	* Don't print floating point values for time. Note,
	* we use floor() instead of round() here, since
	* round can result in undesirable results. For
	* example, if "num" is in the range of
	* 999500-999999, it will print out "1000us". This
	* doesn't happen if we use floor().
	*/
	if (format == ZFS_NICENUM_TIME) {
	if (snprintf(buf, buflen, "%d%s",
	(unsigned int) floor(val), u) <= 5)
	break;

	} else {
	if (snprintf(buf, buflen, "%.*f%s", i,
	val, u) <= 5)
	break;
	}
	}
	}
	}

	/*
	* Convert a number to an appropriately human-readable output.
	*/
	void
	zfs_nicenum(uint64_t num, char *buf, size_t buflen)
	{
	zfs_nicenum_format(num, buf, buflen, ZFS_NICENUM_1024);
	}

	/*
	* Convert a time to an appropriately human-readable output.
	* @num: Time in nanoseconds
	*/
	void
	zfs_nicetime(uint64_t num, char *buf, size_t buflen)
	{
	zfs_nicenum_format(num, buf, buflen, ZFS_NICENUM_TIME);
	}

	/*
	* Print out a raw number with correct column spacing
	*/
	void
	zfs_niceraw(uint64_t num, char *buf, size_t buflen)
	{
	zfs_nicenum_format(num, buf, buflen, ZFS_NICENUM_RAW);
	}

	/*
	* Convert a number of bytes to an appropriately human-readable output.
	*/
	void
	zfs_nicebytes(uint64_t num, char *buf, size_t buflen)
	{
	zfs_nicenum_format(num, buf, buflen, ZFS_NICENUM_BYTES);
	}
	diff --git a/sys/contrib/openzfs/man/man5/zfs-module-parameters.5 b/sys/contrib/openzfs/man/man5/zfs-module-parameters.5
	index 672afefd2bc0..f4afe2525c89 100644
	--- a/sys/contrib/openzfs/man/man5/zfs-module-parameters.5
	+++ b/sys/contrib/openzfs/man/man5/zfs-module-parameters.5
	@@ -1,4333 +1,4354 @@
	'\" te
	.\" Copyright (c) 2013 by Turbo Fredriksson <turbo@bayour.com>. All rights reserved.
	.\" Copyright (c) 2019, 2021 by Delphix. All rights reserved.
	.\" Copyright (c) 2019 Datto Inc.
	.\" 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]
	-.TH ZFS-MODULE-PARAMETERS 5 "Aug 24, 2020" OpenZFS
	+.TH ZFS-MODULE-PARAMETERS 5 "May 5, 2021" OpenZFS
	.SH NAME
	zfs\-module\-parameters \- ZFS module parameters
	.SH DESCRIPTION
	.sp
	.LP
	Description of the different parameters to the ZFS module.

	.SS "Module parameters"
	.sp
	.LP

	.sp
	.ne 2
	.na
	\fBdbuf_cache_max_bytes\fR (ulong)
	.ad
	.RS 12n
	Maximum size in bytes of the dbuf cache. The target size is determined by the
	MIN versus \fB1/2^dbuf_cache_shift\fR (1/32) of the target ARC size. The
	behavior of the dbuf cache and its associated settings can be observed via the
	\fB/proc/spl/kstat/zfs/dbufstats\fR kstat.
	.sp
	Default value: \fBULONG_MAX\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBdbuf_metadata_cache_max_bytes\fR (ulong)
	.ad
	.RS 12n
	Maximum size in bytes of the metadata dbuf cache. The target size is
	determined by the MIN versus \fB1/2^dbuf_metadata_cache_shift\fR (1/64) of the
	target ARC size. The behavior of the metadata dbuf cache and its associated
	settings can be observed via the \fB/proc/spl/kstat/zfs/dbufstats\fR kstat.
	.sp
	Default value: \fBULONG_MAX\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBdbuf_cache_hiwater_pct\fR (uint)
	.ad
	.RS 12n
	The percentage over \fBdbuf_cache_max_bytes\fR when dbufs must be evicted
	directly.
	.sp
	Default value: \fB10\fR%.
	.RE

	.sp
	.ne 2
	.na
	\fBdbuf_cache_lowater_pct\fR (uint)
	.ad
	.RS 12n
	The percentage below \fBdbuf_cache_max_bytes\fR when the evict thread stops
	evicting dbufs.
	.sp
	Default value: \fB10\fR%.
	.RE

	.sp
	.ne 2
	.na
	\fBdbuf_cache_shift\fR (int)
	.ad
	.RS 12n
	Set the size of the dbuf cache, \fBdbuf_cache_max_bytes\fR, to a log2 fraction
	of the target ARC size.
	.sp
	Default value: \fB5\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBdbuf_metadata_cache_shift\fR (int)
	.ad
	.RS 12n
	Set the size of the dbuf metadata cache, \fBdbuf_metadata_cache_max_bytes\fR,
	to a log2 fraction of the target ARC size.
	.sp
	Default value: \fB6\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBdmu_object_alloc_chunk_shift\fR (int)
	.ad
	.RS 12n
	dnode slots allocated in a single operation as a power of 2. The default value
	minimizes lock contention for the bulk operation performed.
	.sp
	Default value: \fB7\fR (128).
	.RE

	.sp
	.ne 2
	.na
	\fBdmu_prefetch_max\fR (int)
	.ad
	.RS 12n
	Limit the amount we can prefetch with one call to this amount (in bytes).
	This helps to limit the amount of memory that can be used by prefetching.
	.sp
	Default value: \fB134,217,728\fR (128MB).
	.RE

	.sp
	.ne 2
	.na
	\fBignore_hole_birth\fR (int)
	.ad
	.RS 12n
	This is an alias for \fBsend_holes_without_birth_time\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBl2arc_feed_again\fR (int)
	.ad
	.RS 12n
	Turbo L2ARC warm-up. When the L2ARC is cold the fill interval will be set as
	fast as possible.
	.sp
	Use \fB1\fR for yes (default) and \fB0\fR to disable.
	.RE

	.sp
	.ne 2
	.na
	\fBl2arc_feed_min_ms\fR (ulong)
	.ad
	.RS 12n
	Min feed interval in milliseconds. Requires \fBl2arc_feed_again=1\fR and only
	applicable in related situations.
	.sp
	Default value: \fB200\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBl2arc_feed_secs\fR (ulong)
	.ad
	.RS 12n
	Seconds between L2ARC writing
	.sp
	Default value: \fB1\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBl2arc_headroom\fR (ulong)
	.ad
	.RS 12n
	How far through the ARC lists to search for L2ARC cacheable content, expressed
	as a multiplier of \fBl2arc_write_max\fR.
	ARC persistence across reboots can be achieved with persistent L2ARC by setting
	this parameter to \fB0\fR allowing the full length of ARC lists to be searched
	for cacheable content.
	.sp
	Default value: \fB2\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBl2arc_headroom_boost\fR (ulong)
	.ad
	.RS 12n
	Scales \fBl2arc_headroom\fR by this percentage when L2ARC contents are being
	successfully compressed before writing. A value of \fB100\fR disables this
	feature.
	.sp
	Default value: \fB200\fR%.
	.RE

	.sp
	.ne 2
	.na
	\fBl2arc_mfuonly\fR (int)
	.ad
	.RS 12n
	Controls whether only MFU metadata and data are cached from ARC into L2ARC.
	This may be desired to avoid wasting space on L2ARC when reading/writing large
	amounts of data that are not expected to be accessed more than once. The
	default is \fB0\fR, meaning both MRU and MFU data and metadata are cached.
	When turning off (\fB0\fR) this feature some MRU buffers will still be present
	in ARC and eventually cached on L2ARC. If \fBl2arc_noprefetch\fR is set to 0,
	some prefetched buffers will be cached to L2ARC, and those might later
	transition to MRU, in which case the \fBl2arc_mru_asize\fR arcstat will not
	be 0. Regardless of \fBl2arc_noprefetch\fR, some MFU buffers might be evicted
	from ARC, accessed later on as prefetches and transition to MRU as prefetches.
	If accessed again they are counted as MRU and the \fBl2arc_mru_asize\fR arcstat
	will not be 0. The ARC status of L2ARC buffers when they were first cached in
	L2ARC can be seen in the \fBl2arc_mru_asize\fR, \fBl2arc_mfu_asize\fR and
	\fBl2arc_prefetch_asize\fR arcstats when importing the pool or onlining a cache
	device if persistent L2ARC is enabled. The \fBevicted_l2_eligible_mru\fR
	arcstat does not take into account if this option is enabled as the information
	provided by the evicted_l2_eligible_* arcstats can be used to decide if
	toggling this option is appropriate for the current workload.
	.sp
	Use \fB0\fR for no (default) and \fB1\fR for yes.
	.RE

	.sp
	.ne 2
	.na
	\fBl2arc_meta_percent\fR (int)
	.ad
	.RS 12n
	Percent of ARC size allowed for L2ARC-only headers.
	Since L2ARC buffers are not evicted on memory pressure, too large amount of
	-headers on system with irrationaly large L2ARC can render it slow or unusable.
	+headers on system with irrationally large L2ARC can render it slow or unusable.
	This parameter limits L2ARC writes and rebuild to achieve it.
	.sp
	Default value: \fB33\fR%.
	.RE

	.sp
	.ne 2
	.na
	\fBl2arc_trim_ahead\fR (ulong)
	.ad
	.RS 12n
	Trims ahead of the current write size (\fBl2arc_write_max\fR) on L2ARC devices
	by this percentage of write size if we have filled the device. If set to
	\fB100\fR we TRIM twice the space required to accommodate upcoming writes. A
	minimum of 64MB will be trimmed. It also enables TRIM of the whole L2ARC device
	upon creation or addition to an existing pool or if the header of the device is
	invalid upon importing a pool or onlining a cache device. A value of \fB0\fR
	disables TRIM on L2ARC altogether and is the default as it can put significant
	stress on the underlying storage devices. This will vary depending of how well
	the specific device handles these commands.
	.sp
	Default value: \fB0\fR%.
	.RE

	.sp
	.ne 2
	.na
	\fBl2arc_noprefetch\fR (int)
	.ad
	.RS 12n
	Do not write buffers to L2ARC if they were prefetched but not used by
	applications. In case there are prefetched buffers in L2ARC and this option
	is later set to \fB1\fR, we do not read the prefetched buffers from L2ARC.
	Setting this option to \fB0\fR is useful for caching sequential reads from the
	disks to L2ARC and serve those reads from L2ARC later on. This may be beneficial
	in case the L2ARC device is significantly faster in sequential reads than the
	disks of the pool.
	.sp
	Use \fB1\fR to disable (default) and \fB0\fR to enable caching/reading
	prefetches to/from L2ARC..
	.RE

	.sp
	.ne 2
	.na
	\fBl2arc_norw\fR (int)
	.ad
	.RS 12n
	No reads during writes.
	.sp
	Use \fB1\fR for yes and \fB0\fR for no (default).
	.RE

	.sp
	.ne 2
	.na
	\fBl2arc_write_boost\fR (ulong)
	.ad
	.RS 12n
	Cold L2ARC devices will have \fBl2arc_write_max\fR increased by this amount
	while they remain cold.
	.sp
	Default value: \fB8,388,608\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBl2arc_write_max\fR (ulong)
	.ad
	.RS 12n
	Max write bytes per interval.
	.sp
	Default value: \fB8,388,608\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBl2arc_rebuild_enabled\fR (int)
	.ad
	.RS 12n
	Rebuild the L2ARC when importing a pool (persistent L2ARC). This can be
	disabled if there are problems importing a pool or attaching an L2ARC device
	(e.g. the L2ARC device is slow in reading stored log metadata, or the metadata
	has become somehow fragmented/unusable).
	.sp
	Use \fB1\fR for yes (default) and \fB0\fR for no.
	.RE

	.sp
	.ne 2
	.na
	\fBl2arc_rebuild_blocks_min_l2size\fR (ulong)
	.ad
	.RS 12n
	Min size (in bytes) of an L2ARC device required in order to write log blocks
	in it. The log blocks are used upon importing the pool to rebuild
	the L2ARC (persistent L2ARC). Rationale: for L2ARC devices less than 1GB, the
	amount of data l2arc_evict() evicts is significant compared to the amount of
	restored L2ARC data. In this case do not write log blocks in L2ARC in order not
	to waste space.
	.sp
	Default value: \fB1,073,741,824\fR (1GB).
	.RE

	.sp
	.ne 2
	.na
	\fBmetaslab_aliquot\fR (ulong)
	.ad
	.RS 12n
	Metaslab granularity, in bytes. This is roughly similar to what would be
	referred to as the "stripe size" in traditional RAID arrays. In normal
	operation, ZFS will try to write this amount of data to a top-level vdev
	before moving on to the next one.
	.sp
	Default value: \fB524,288\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBmetaslab_bias_enabled\fR (int)
	.ad
	.RS 12n
	Enable metaslab group biasing based on its vdev's over- or under-utilization
	relative to the pool.
	.sp
	Use \fB1\fR for yes (default) and \fB0\fR for no.
	.RE

	.sp
	.ne 2
	.na
	\fBmetaslab_force_ganging\fR (ulong)
	.ad
	.RS 12n
	Make some blocks above a certain size be gang blocks. This option is used
	by the test suite to facilitate testing.
	.sp
	Default value: \fB16,777,217\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_history_output_max\fR (int)
	.ad
	.RS 12n
	When attempting to log the output nvlist of an ioctl in the on-disk history, the
	output will not be stored if it is larger than size (in bytes). This must be
	-less then DMU_MAX_ACCESS (64MB). This applies primarily to
	+less than DMU_MAX_ACCESS (64MB). This applies primarily to
	zfs_ioc_channel_program().
	.sp
	Default value: \fB1MB\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_keep_log_spacemaps_at_export\fR (int)
	.ad
	.RS 12n
	Prevent log spacemaps from being destroyed during pool exports and destroys.
	.sp
	Use \fB1\fR for yes and \fB0\fR for no (default).
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_metaslab_segment_weight_enabled\fR (int)
	.ad
	.RS 12n
	Enable/disable segment-based metaslab selection.
	.sp
	Use \fB1\fR for yes (default) and \fB0\fR for no.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_metaslab_switch_threshold\fR (int)
	.ad
	.RS 12n
	When using segment-based metaslab selection, continue allocating
	from the active metaslab until \fBzfs_metaslab_switch_threshold\fR
	worth of buckets have been exhausted.
	.sp
	Default value: \fB2\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBmetaslab_debug_load\fR (int)
	.ad
	.RS 12n
	Load all metaslabs during pool import.
	.sp
	Use \fB1\fR for yes and \fB0\fR for no (default).
	.RE

	.sp
	.ne 2
	.na
	\fBmetaslab_debug_unload\fR (int)
	.ad
	.RS 12n
	Prevent metaslabs from being unloaded.
	.sp
	Use \fB1\fR for yes and \fB0\fR for no (default).
	.RE

	.sp
	.ne 2
	.na
	\fBmetaslab_fragmentation_factor_enabled\fR (int)
	.ad
	.RS 12n
	Enable use of the fragmentation metric in computing metaslab weights.
	.sp
	Use \fB1\fR for yes (default) and \fB0\fR for no.
	.RE

	.sp
	.ne 2
	.na
	\fBmetaslab_df_max_search\fR (int)
	.ad
	.RS 12n
	Maximum distance to search forward from the last offset. Without this limit,
	fragmented pools can see >100,000 iterations and metaslab_block_picker()
	becomes the performance limiting factor on high-performance storage.

	With the default setting of 16MB, we typically see less than 500 iterations,
	even with very fragmented, ashift=9 pools. The maximum number of iterations
	possible is: \fBmetaslab_df_max_search / (2 * (1<<ashift))\fR.
	With the default setting of 16MB this is 16*1024 (with ashift=9) or 2048
	(with ashift=12).
	.sp
	Default value: \fB16,777,216\fR (16MB)
	.RE

	.sp
	.ne 2
	.na
	\fBmetaslab_df_use_largest_segment\fR (int)
	.ad
	.RS 12n
	If we are not searching forward (due to metaslab_df_max_search,
	metaslab_df_free_pct, or metaslab_df_alloc_threshold), this tunable controls
	what segment is used. If it is set, we will use the largest free segment.
	If it is not set, we will use a segment of exactly the requested size (or
	larger).
	.sp
	Use \fB1\fR for yes and \fB0\fR for no (default).
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_metaslab_max_size_cache_sec\fR (ulong)
	.ad
	.RS 12n
	When we unload a metaslab, we cache the size of the largest free chunk. We use
	that cached size to determine whether or not to load a metaslab for a given
	allocation. As more frees accumulate in that metaslab while it's unloaded, the
	cached max size becomes less and less accurate. After a number of seconds
	controlled by this tunable, we stop considering the cached max size and start
	considering only the histogram instead.
	.sp
	Default value: \fB3600 seconds\fR (one hour)
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_metaslab_mem_limit\fR (int)
	.ad
	.RS 12n
	When we are loading a new metaslab, we check the amount of memory being used
	to store metaslab range trees. If it is over a threshold, we attempt to unload
	the least recently used metaslab to prevent the system from clogging all of
	its memory with range trees. This tunable sets the percentage of total system
	memory that is the threshold.
	.sp
	Default value: \fB25 percent\fR
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_metaslab_try_hard_before_gang\fR (int)
	.ad
	.RS 12n
	If not set (the default), we will first try normal allocation.
	If that fails then we will do a gang allocation.
	If that fails then we will do a "try hard" gang allocation.
	If that fails then we will have a multi-layer gang block.
	.sp
	If set, we will first try normal allocation.
	If that fails then we will do a "try hard" allocation.
	If that fails we will do a gang allocation.
	If that fails we will do a "try hard" gang allocation.
	If that fails then we will have a multi-layer gang block.
	.sp
	Default value: \fB0 (false)\fR
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_metaslab_find_max_tries\fR (int)
	.ad
	.RS 12n
	When not trying hard, we only consider this number of the best metaslabs.
	This improves performance, especially when there are many metaslabs per vdev
	and the allocation can't actually be satisfied (so we would otherwise iterate
	all the metaslabs).
	.sp
	Default value: \fB100\fR
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_default_ms_count\fR (int)
	.ad
	.RS 12n
	When a vdev is added target this number of metaslabs per top-level vdev.
	.sp
	Default value: \fB200\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_default_ms_shift\fR (int)
	.ad
	.RS 12n
	Default limit for metaslab size.
	.sp
	Default value: \fB29\fR [meaning (1 << 29) = 512MB].
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_max_auto_ashift\fR (ulong)
	.ad
	.RS 12n
	Maximum ashift used when optimizing for logical -> physical sector size on new
	top-level vdevs.
	.sp
	Default value: \fBASHIFT_MAX\fR (16).
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_min_auto_ashift\fR (ulong)
	.ad
	.RS 12n
	Minimum ashift used when creating new top-level vdevs.
	.sp
	Default value: \fBASHIFT_MIN\fR (9).
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_min_ms_count\fR (int)
	.ad
	.RS 12n
	Minimum number of metaslabs to create in a top-level vdev.
	.sp
	Default value: \fB16\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBvdev_validate_skip\fR (int)
	.ad
	.RS 12n
	Skip label validation steps during pool import. Changing is not recommended
	unless you know what you are doing and are recovering a damaged label.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_ms_count_limit\fR (int)
	.ad
	.RS 12n
	Practical upper limit of total metaslabs per top-level vdev.
	.sp
	Default value: \fB131,072\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBmetaslab_preload_enabled\fR (int)
	.ad
	.RS 12n
	Enable metaslab group preloading.
	.sp
	Use \fB1\fR for yes (default) and \fB0\fR for no.
	.RE

	.sp
	.ne 2
	.na
	\fBmetaslab_lba_weighting_enabled\fR (int)
	.ad
	.RS 12n
	Give more weight to metaslabs with lower LBAs, assuming they have
	greater bandwidth as is typically the case on a modern constant
	angular velocity disk drive.
	.sp
	Use \fB1\fR for yes (default) and \fB0\fR for no.
	.RE

	.sp
	.ne 2
	.na
	\fBmetaslab_unload_delay\fR (int)
	.ad
	.RS 12n
	After a metaslab is used, we keep it loaded for this many txgs, to attempt to
	reduce unnecessary reloading. Note that both this many txgs and
	\fBmetaslab_unload_delay_ms\fR milliseconds must pass before unloading will
	occur.
	.sp
	Default value: \fB32\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBmetaslab_unload_delay_ms\fR (int)
	.ad
	.RS 12n
	After a metaslab is used, we keep it loaded for this many milliseconds, to
	attempt to reduce unnecessary reloading. Note that both this many
	milliseconds and \fBmetaslab_unload_delay\fR txgs must pass before unloading
	will occur.
	.sp
	Default value: \fB600000\fR (ten minutes).
	.RE

	.sp
	.ne 2
	.na
	\fBreference_history\fR (int)
	.ad
	.RS 12n
	Maximum reference holders being tracked when reference_tracking_enable is
	active.
	.sp
	Default value: \fB3\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBreference_tracking_enable\fR (int)
	.ad
	.RS 12n
	Track reference holders to refcount_t objects (debug builds only).
	.sp
	Use \fB1\fR for yes and \fB0\fR for no (default).
	.RE

	.sp
	.ne 2
	.na
	\fBsend_holes_without_birth_time\fR (int)
	.ad
	.RS 12n
	When set, the hole_birth optimization will not be used, and all holes will
	always be sent on zfs send. This is useful if you suspect your datasets are
	affected by a bug in hole_birth.
	.sp
	Use \fB1\fR for on (default) and \fB0\fR for off.
	.RE

	.sp
	.ne 2
	.na
	\fBspa_config_path\fR (charp)
	.ad
	.RS 12n
	SPA config file
	.sp
	Default value: \fB/etc/zfs/zpool.cache\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBspa_asize_inflation\fR (int)
	.ad
	.RS 12n
	Multiplication factor used to estimate actual disk consumption from the
	size of data being written. The default value is a worst case estimate,
	but lower values may be valid for a given pool depending on its
	configuration. Pool administrators who understand the factors involved
	may wish to specify a more realistic inflation factor, particularly if
	they operate close to quota or capacity limits.
	.sp
	Default value: \fB24\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBspa_load_print_vdev_tree\fR (int)
	.ad
	.RS 12n
	Whether to print the vdev tree in the debugging message buffer during pool import.
	Use 0 to disable and 1 to enable.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBspa_load_verify_data\fR (int)
	.ad
	.RS 12n
	Whether to traverse data blocks during an "extreme rewind" (\fB-X\fR)
	import. Use 0 to disable and 1 to enable.

	An extreme rewind import normally performs a full traversal of all
	blocks in the pool for verification. If this parameter is set to 0,
	the traversal skips non-metadata blocks. It can be toggled once the
	import has started to stop or start the traversal of non-metadata blocks.
	.sp
	Default value: \fB1\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBspa_load_verify_metadata\fR (int)
	.ad
	.RS 12n
	Whether to traverse blocks during an "extreme rewind" (\fB-X\fR)
	pool import. Use 0 to disable and 1 to enable.

	An extreme rewind import normally performs a full traversal of all
	blocks in the pool for verification. If this parameter is set to 0,
	the traversal is not performed. It can be toggled once the import has
	started to stop or start the traversal.
	.sp
	Default value: \fB1\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBspa_load_verify_shift\fR (int)
	.ad
	.RS 12n
	Sets the maximum number of bytes to consume during pool import to the log2
	fraction of the target ARC size.
	.sp
	Default value: \fB4\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBspa_slop_shift\fR (int)
	.ad
	.RS 12n
	Normally, we don't allow the last 3.2% (1/(2^spa_slop_shift)) of space
	in the pool to be consumed. This ensures that we don't run the pool
	completely out of space, due to unaccounted changes (e.g. to the MOS).
	It also limits the worst-case time to allocate space. If we have
	less than this amount of free space, most ZPL operations (e.g. write,
	create) will return ENOSPC.
	.sp
	Default value: \fB5\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBvdev_removal_max_span\fR (int)
	.ad
	.RS 12n
	During top-level vdev removal, chunks of data are copied from the vdev
	which may include free space in order to trade bandwidth for IOPS.
	This parameter determines the maximum span of free space (in bytes)
	which will be included as "unnecessary" data in a chunk of copied data.

	The default value here was chosen to align with
	\fBzfs_vdev_read_gap_limit\fR, which is a similar concept when doing
	regular reads (but there's no reason it has to be the same).
	.sp
	Default value: \fB32,768\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBvdev_file_logical_ashift\fR (ulong)
	.ad
	.RS 12n
	Logical ashift for file-based devices.
	.sp
	Default value: \fB9\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBvdev_file_physical_ashift\fR (ulong)
	.ad
	.RS 12n
	Physical ashift for file-based devices.
	.sp
	Default value: \fB9\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzap_iterate_prefetch\fR (int)
	.ad
	.RS 12n
	If this is set, when we start iterating over a ZAP object, zfs will prefetch
	the entire object (all leaf blocks). However, this is limited by
	\fBdmu_prefetch_max\fR.
	.sp
	Use \fB1\fR for on (default) and \fB0\fR for off.
	.RE

	.sp
	.ne 2
	.na
	\fBzfetch_array_rd_sz\fR (ulong)
	.ad
	.RS 12n
	If prefetching is enabled, disable prefetching for reads larger than this size.
	.sp
	Default value: \fB1,048,576\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfetch_max_distance\fR (uint)
	.ad
	.RS 12n
	Max bytes to prefetch per stream.
	.sp
	Default value: \fB8,388,608\fR (8MB).
	.RE

	.sp
	.ne 2
	.na
	\fBzfetch_max_idistance\fR (uint)
	.ad
	.RS 12n
	Max bytes to prefetch indirects for per stream.
	.sp
	-Default vaule: \fB67,108,864\fR (64MB).
	+Default value: \fB67,108,864\fR (64MB).
	.RE

	.sp
	.ne 2
	.na
	\fBzfetch_max_streams\fR (uint)
	.ad
	.RS 12n
	Max number of streams per zfetch (prefetch streams per file).
	.sp
	Default value: \fB8\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfetch_min_sec_reap\fR (uint)
	.ad
	.RS 12n
	Min time before an active prefetch stream can be reclaimed
	.sp
	Default value: \fB2\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_abd_scatter_enabled\fR (int)
	.ad
	.RS 12n
	Enables ARC from using scatter/gather lists and forces all allocations to be
	linear in kernel memory. Disabling can improve performance in some code paths
	at the expense of fragmented kernel memory.
	.sp
	Default value: \fB1\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_abd_scatter_max_order\fR (iunt)
	.ad
	.RS 12n
	Maximum number of consecutive memory pages allocated in a single block for
	scatter/gather lists. Default value is specified by the kernel itself.
	.sp
	Default value: \fB10\fR at the time of this writing.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_abd_scatter_min_size\fR (uint)
	.ad
	.RS 12n
	This is the minimum allocation size that will use scatter (page-based)
	ABD's. Smaller allocations will use linear ABD's.
	.sp
	Default value: \fB1536\fR (512B and 1KB allocations will be linear).
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_arc_dnode_limit\fR (ulong)
	.ad
	.RS 12n
	When the number of bytes consumed by dnodes in the ARC exceeds this number of
	bytes, try to unpin some of it in response to demand for non-metadata. This
	value acts as a ceiling to the amount of dnode metadata, and defaults to 0 which
	indicates that a percent which is based on \fBzfs_arc_dnode_limit_percent\fR of
	the ARC meta buffers that may be used for dnodes.

	See also \fBzfs_arc_meta_prune\fR which serves a similar purpose but is used
	when the amount of metadata in the ARC exceeds \fBzfs_arc_meta_limit\fR rather
	than in response to overall demand for non-metadata.

	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_arc_dnode_limit_percent\fR (ulong)
	.ad
	.RS 12n
	Percentage that can be consumed by dnodes of ARC meta buffers.
	.sp
	See also \fBzfs_arc_dnode_limit\fR which serves a similar purpose but has a
	higher priority if set to nonzero value.
	.sp
	Default value: \fB10\fR%.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_arc_dnode_reduce_percent\fR (ulong)
	.ad
	.RS 12n
	Percentage of ARC dnodes to try to scan in response to demand for non-metadata
	when the number of bytes consumed by dnodes exceeds \fBzfs_arc_dnode_limit\fR.

	.sp
	Default value: \fB10\fR% of the number of dnodes in the ARC.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_arc_average_blocksize\fR (int)
	.ad
	.RS 12n
	The ARC's buffer hash table is sized based on the assumption of an average
	block size of \fBzfs_arc_average_blocksize\fR (default 8K). This works out
	to roughly 1MB of hash table per 1GB of physical memory with 8-byte pointers.
	For configurations with a known larger average block size this value can be
	increased to reduce the memory footprint.

	.sp
	Default value: \fB8192\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_arc_eviction_pct\fR (int)
	.ad
	.RS 12n
	When \fBarc_is_overflowing()\fR, \fBarc_get_data_impl()\fR waits for this
	percent of the requested amount of data to be evicted. For example, by
	default for every 2KB that's evicted, 1KB of it may be "reused" by a new
	allocation. Since this is above 100%, it ensures that progress is made
	towards getting \fBarc_size\fR under \fBarc_c\fR. Since this is finite, it
	ensures that allocations can still happen, even during the potentially long
	time that \fBarc_size\fR is more than \fBarc_c\fR.
	.sp
	Default value: \fB200\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_arc_evict_batch_limit\fR (int)
	.ad
	.RS 12n
	Number ARC headers to evict per sub-list before proceeding to another sub-list.
	This batch-style operation prevents entire sub-lists from being evicted at once
	but comes at a cost of additional unlocking and locking.
	.sp
	Default value: \fB10\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_arc_grow_retry\fR (int)
	.ad
	.RS 12n
	If set to a non zero value, it will replace the arc_grow_retry value with this value.
	The arc_grow_retry value (default 5) is the number of seconds the ARC will wait before
	trying to resume growth after a memory pressure event.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_arc_lotsfree_percent\fR (int)
	.ad
	.RS 12n
	Throttle I/O when free system memory drops below this percentage of total
	system memory. Setting this value to 0 will disable the throttle.
	.sp
	Default value: \fB10\fR%.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_arc_max\fR (ulong)
	.ad
	.RS 12n
	Max size of ARC in bytes. If set to 0 then the max size of ARC is determined
	by the amount of system memory installed. For Linux, 1/2 of system memory will
	be used as the limit. For FreeBSD, the larger of all system memory - 1GB or
	5/8 of system memory will be used as the limit. This value must be at least
	67108864 (64 megabytes).
	.sp
	This value can be changed dynamically with some caveats. It cannot be set back
	to 0 while running and reducing it below the current ARC size will not cause
	the ARC to shrink without memory pressure to induce shrinking.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_arc_meta_adjust_restarts\fR (ulong)
	.ad
	.RS 12n
	The number of restart passes to make while scanning the ARC attempting
	the free buffers in order to stay below the \fBzfs_arc_meta_limit\fR.
	This value should not need to be tuned but is available to facilitate
	performance analysis.
	.sp
	Default value: \fB4096\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_arc_meta_limit\fR (ulong)
	.ad
	.RS 12n
	The maximum allowed size in bytes that meta data buffers are allowed to
	consume in the ARC. When this limit is reached meta data buffers will
	be reclaimed even if the overall arc_c_max has not been reached. This
	value defaults to 0 which indicates that a percent which is based on
	\fBzfs_arc_meta_limit_percent\fR of the ARC may be used for meta data.
	.sp
	This value my be changed dynamically except that it cannot be set back to 0
	for a specific percent of the ARC; it must be set to an explicit value.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_arc_meta_limit_percent\fR (ulong)
	.ad
	.RS 12n
	Percentage of ARC buffers that can be used for meta data.

	See also \fBzfs_arc_meta_limit\fR which serves a similar purpose but has a
	higher priority if set to nonzero value.

	.sp
	Default value: \fB75\fR%.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_arc_meta_min\fR (ulong)
	.ad
	.RS 12n
	The minimum allowed size in bytes that meta data buffers may consume in
	the ARC. This value defaults to 0 which disables a floor on the amount
	of the ARC devoted meta data.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_arc_meta_prune\fR (int)
	.ad
	.RS 12n
	The number of dentries and inodes to be scanned looking for entries
	which can be dropped. This may be required when the ARC reaches the
	\fBzfs_arc_meta_limit\fR because dentries and inodes can pin buffers
	in the ARC. Increasing this value will cause to dentry and inode caches
	to be pruned more aggressively. Setting this value to 0 will disable
	pruning the inode and dentry caches.
	.sp
	Default value: \fB10,000\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_arc_meta_strategy\fR (int)
	.ad
	.RS 12n
	Define the strategy for ARC meta data buffer eviction (meta reclaim strategy).
	A value of 0 (META_ONLY) will evict only the ARC meta data buffers.
	A value of 1 (BALANCED) indicates that additional data buffers may be evicted if
	that is required to in order to evict the required number of meta data buffers.
	.sp
	Default value: \fB1\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_arc_min\fR (ulong)
	.ad
	.RS 12n
	Min size of ARC in bytes. If set to 0 then arc_c_min will default to
	consuming the larger of 32M or 1/32 of total system memory.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_arc_min_prefetch_ms\fR (int)
	.ad
	.RS 12n
	Minimum time prefetched blocks are locked in the ARC, specified in ms.
	A value of \fB0\fR will default to 1000 ms.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_arc_min_prescient_prefetch_ms\fR (int)
	.ad
	.RS 12n
	Minimum time "prescient prefetched" blocks are locked in the ARC, specified
	in ms. These blocks are meant to be prefetched fairly aggressively ahead of
	the code that may use them. A value of \fB0\fR will default to 6000 ms.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_max_missing_tvds\fR (int)
	.ad
	.RS 12n
	Number of missing top-level vdevs which will be allowed during
	pool import (only in read-only mode).
	.sp
	Default value: \fB0\fR
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_max_nvlist_src_size\fR (ulong)
	.ad
	.RS 12n
	Maximum size in bytes allowed to be passed as zc_nvlist_src_size for ioctls on
	/dev/zfs. This prevents a user from causing the kernel to allocate an excessive
	amount of memory. When the limit is exceeded, the ioctl fails with EINVAL and a
	description of the error is sent to the zfs-dbgmsg log. This parameter should
	not need to be touched under normal circumstances. On FreeBSD, the default is
	based on the system limit on user wired memory. On Linux, the default is
	\fB128MB\fR.
	.sp
	Default value: \fB0\fR (kernel decides)
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_multilist_num_sublists\fR (int)
	.ad
	.RS 12n
	To allow more fine-grained locking, each ARC state contains a series
	of lists for both data and meta data objects. Locking is performed at
	the level of these "sub-lists". This parameters controls the number of
	sub-lists per ARC state, and also applies to other uses of the
	multilist data structure.
	.sp
	Default value: \fB4\fR or the number of online CPUs, whichever is greater
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_arc_overflow_shift\fR (int)
	.ad
	.RS 12n
	The ARC size is considered to be overflowing if it exceeds the current
	ARC target size (arc_c) by a threshold determined by this parameter.
	The threshold is calculated as a fraction of arc_c using the formula
	"arc_c >> \fBzfs_arc_overflow_shift\fR".

	The default value of 8 causes the ARC to be considered to be overflowing
	if it exceeds the target size by 1/256th (0.3%) of the target size.

	When the ARC is overflowing, new buffer allocations are stalled until
	the reclaim thread catches up and the overflow condition no longer exists.
	.sp
	Default value: \fB8\fR.
	.RE

	.sp
	.ne 2
	.na

	\fBzfs_arc_p_min_shift\fR (int)
	.ad
	.RS 12n
	If set to a non zero value, this will update arc_p_min_shift (default 4)
	with the new value.
	arc_p_min_shift is used to shift of arc_c for calculating both min and max
	max arc_p
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_arc_p_dampener_disable\fR (int)
	.ad
	.RS 12n
	Disable arc_p adapt dampener
	.sp
	Use \fB1\fR for yes (default) and \fB0\fR to disable.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_arc_shrink_shift\fR (int)
	.ad
	.RS 12n
	If set to a non zero value, this will update arc_shrink_shift (default 7)
	with the new value.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_arc_pc_percent\fR (uint)
	.ad
	.RS 12n
	Percent of pagecache to reclaim arc to

	This tunable allows ZFS arc to play more nicely with the kernel's LRU
	pagecache. It can guarantee that the ARC size won't collapse under scanning
	pressure on the pagecache, yet still allows arc to be reclaimed down to
	zfs_arc_min if necessary. This value is specified as percent of pagecache
	size (as measured by NR_FILE_PAGES) where that percent may exceed 100. This
	only operates during memory pressure/reclaim.
	.sp
	Default value: \fB0\fR% (disabled).
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_arc_shrinker_limit\fR (int)
	.ad
	.RS 12n
	This is a limit on how many pages the ARC shrinker makes available for
	eviction in response to one page allocation attempt. Note that in
	practice, the kernel's shrinker can ask us to evict up to about 4x this
	for one allocation attempt.
	.sp
	The default limit of 10,000 (in practice, 160MB per allocation attempt with
	4K pages) limits the amount of time spent attempting to reclaim ARC memory to
	less than 100ms per allocation attempt, even with a small average compressed
	block size of ~8KB.
	.sp
	The parameter can be set to 0 (zero) to disable the limit.
	.sp
	This parameter only applies on Linux.
	.sp
	Default value: \fB10,000\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_arc_sys_free\fR (ulong)
	.ad
	.RS 12n
	The target number of bytes the ARC should leave as free memory on the system.
	Defaults to the larger of 1/64 of physical memory or 512K. Setting this
	option to a non-zero value will override the default.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_autoimport_disable\fR (int)
	.ad
	.RS 12n
	Disable pool import at module load by ignoring the cache file (typically \fB/etc/zfs/zpool.cache\fR).
	.sp
	Use \fB1\fR for yes (default) and \fB0\fR for no.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_checksum_events_per_second\fR (uint)
	.ad
	.RS 12n
	Rate limit checksum events to this many per second. Note that this should
	not be set below the zed thresholds (currently 10 checksums over 10 sec)
	or else zed may not trigger any action.
	.sp
	Default value: 20
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_commit_timeout_pct\fR (int)
	.ad
	.RS 12n
	This controls the amount of time that a ZIL block (lwb) will remain "open"
	when it isn't "full", and it has a thread waiting for it to be committed to
	stable storage. The timeout is scaled based on a percentage of the last lwb
	latency to avoid significantly impacting the latency of each individual
	transaction record (itx).
	.sp
	Default value: \fB5\fR%.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_condense_indirect_commit_entry_delay_ms\fR (int)
	.ad
	.RS 12n
	Vdev indirection layer (used for device removal) sleeps for this many
	milliseconds during mapping generation. Intended for use with the test suite
	to throttle vdev removal speed.
	.sp
	Default value: \fB0\fR (no throttle).
	.RE

	+.sp
	+.ne 2
	+.na
	+\fBzfs_condense_indirect_obsolete_pct\fR (int)
	+.ad
	+.RS 12n
	+Minimum percent of obsolete bytes in vdev mapping required to attempt to
	+condense (see \fBzfs_condense_indirect_vdevs_enable\fR). Intended for use
	+with the test suite to facilitate triggering condensing as needed.
	+.sp
	+Default value: \fB25\fR%.
	+.RE
	+
	.sp
	.ne 2
	.na
	\fBzfs_condense_indirect_vdevs_enable\fR (int)
	.ad
	.RS 12n
	Enable condensing indirect vdev mappings. When set to a non-zero value,
	attempt to condense indirect vdev mappings if the mapping uses more than
	\fBzfs_condense_min_mapping_bytes\fR bytes of memory and if the obsolete
	space map object uses more than \fBzfs_condense_max_obsolete_bytes\fR
	bytes on-disk. The condensing process is an attempt to save memory by
	removing obsolete mappings.
	.sp
	Default value: \fB1\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_condense_max_obsolete_bytes\fR (ulong)
	.ad
	.RS 12n
	Only attempt to condense indirect vdev mappings if the on-disk size
	of the obsolete space map object is greater than this number of bytes
	(see \fBfBzfs_condense_indirect_vdevs_enable\fR).
	.sp
	Default value: \fB1,073,741,824\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_condense_min_mapping_bytes\fR (ulong)
	.ad
	.RS 12n
	Minimum size vdev mapping to attempt to condense (see
	\fBzfs_condense_indirect_vdevs_enable\fR).
	.sp
	Default value: \fB131,072\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_dbgmsg_enable\fR (int)
	.ad
	.RS 12n
	Internally ZFS keeps a small log to facilitate debugging. By default the log
	-is disabled, to enable it set this option to 1. The contents of the log can
	+is enabled, to disable it set this option to 0. The contents of the log can
	be accessed by reading the /proc/spl/kstat/zfs/dbgmsg file. Writing 0 to
	this proc file clears the log.
	.sp
	-Default value: \fB0\fR.
	+This setting does not influence debug prints due to \fBzfs_flags\fR
	+settings.
	+.sp
	+Default value: \fB1\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_dbgmsg_maxsize\fR (int)
	.ad
	.RS 12n
	The maximum size in bytes of the internal ZFS debug log.
	.sp
	Default value: \fB4M\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_dbuf_state_index\fR (int)
	.ad
	.RS 12n
	This feature is currently unused. It is normally used for controlling what
	reporting is available under /proc/spl/kstat/zfs.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_deadman_enabled\fR (int)
	.ad
	.RS 12n
	When a pool sync operation takes longer than \fBzfs_deadman_synctime_ms\fR
	milliseconds, or when an individual I/O takes longer than
	\fBzfs_deadman_ziotime_ms\fR milliseconds, then the operation is considered to
	be "hung". If \fBzfs_deadman_enabled\fR is set then the deadman behavior is
	invoked as described by the \fBzfs_deadman_failmode\fR module option.
	By default the deadman is enabled and configured to \fBwait\fR which results
	in "hung" I/Os only being logged. The deadman is automatically disabled
	when a pool gets suspended.
	.sp
	Default value: \fB1\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_deadman_failmode\fR (charp)
	.ad
	.RS 12n
	Controls the failure behavior when the deadman detects a "hung" I/O. Valid
	values are \fBwait\fR, \fBcontinue\fR, and \fBpanic\fR.
	.sp
	\fBwait\fR - Wait for a "hung" I/O to complete. For each "hung" I/O a
	"deadman" event will be posted describing that I/O.
	.sp
	\fBcontinue\fR - Attempt to recover from a "hung" I/O by re-dispatching it
	to the I/O pipeline if possible.
	.sp
	\fBpanic\fR - Panic the system. This can be used to facilitate an automatic
	fail-over to a properly configured fail-over partner.
	.sp
	Default value: \fBwait\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_deadman_checktime_ms\fR (int)
	.ad
	.RS 12n
	Check time in milliseconds. This defines the frequency at which we check
	for hung I/O and potentially invoke the \fBzfs_deadman_failmode\fR behavior.
	.sp
	Default value: \fB60,000\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_deadman_synctime_ms\fR (ulong)
	.ad
	.RS 12n
	Interval in milliseconds after which the deadman is triggered and also
	the interval after which a pool sync operation is considered to be "hung".
	Once this limit is exceeded the deadman will be invoked every
	\fBzfs_deadman_checktime_ms\fR milliseconds until the pool sync completes.
	.sp
	Default value: \fB600,000\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_deadman_ziotime_ms\fR (ulong)
	.ad
	.RS 12n
	Interval in milliseconds after which the deadman is triggered and an
	individual I/O operation is considered to be "hung". As long as the I/O
	remains "hung" the deadman will be invoked every \fBzfs_deadman_checktime_ms\fR
	milliseconds until the I/O completes.
	.sp
	Default value: \fB300,000\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_dedup_prefetch\fR (int)
	.ad
	.RS 12n
	Enable prefetching dedup-ed blks
	.sp
	Use \fB1\fR for yes and \fB0\fR to disable (default).
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_delay_min_dirty_percent\fR (int)
	.ad
	.RS 12n
	Start to delay each transaction once there is this amount of dirty data,
	expressed as a percentage of \fBzfs_dirty_data_max\fR.
	This value should be >= zfs_vdev_async_write_active_max_dirty_percent.
	See the section "ZFS TRANSACTION DELAY".
	.sp
	Default value: \fB60\fR%.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_delay_scale\fR (int)
	.ad
	.RS 12n
	This controls how quickly the transaction delay approaches infinity.
	Larger values cause longer delays for a given amount of dirty data.
	.sp
	For the smoothest delay, this value should be about 1 billion divided
	by the maximum number of operations per second. This will smoothly
	handle between 10x and 1/10th this number.
	.sp
	See the section "ZFS TRANSACTION DELAY".
	.sp
	Note: \fBzfs_delay_scale\fR * \fBzfs_dirty_data_max\fR must be < 2^64.
	.sp
	Default value: \fB500,000\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_disable_ivset_guid_check\fR (int)
	.ad
	.RS 12n
	Disables requirement for IVset guids to be present and match when doing a raw
	receive of encrypted datasets. Intended for users whose pools were created with
	OpenZFS pre-release versions and now have compatibility issues.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_key_max_salt_uses\fR (ulong)
	.ad
	.RS 12n
	Maximum number of uses of a single salt value before generating a new one for
	encrypted datasets. The default value is also the maximum that will be
	accepted.
	.sp
	Default value: \fB400,000,000\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_object_mutex_size\fR (uint)
	.ad
	.RS 12n
	Size of the znode hashtable used for holds.

	Due to the need to hold locks on objects that may not exist yet, kernel mutexes
	are not created per-object and instead a hashtable is used where collisions
	will result in objects waiting when there is not actually contention on the
	same object.
	.sp
	Default value: \fB64\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_slow_io_events_per_second\fR (int)
	.ad
	.RS 12n
	-Rate limit delay zevents (which report slow I/Os) to this many per second.
	+Rate limit delay and deadman zevents (which report slow I/Os) to this many per
	+second.
	.sp
	Default value: 20
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_unflushed_max_mem_amt\fR (ulong)
	.ad
	.RS 12n
	Upper-bound limit for unflushed metadata changes to be held by the
	log spacemap in memory (in bytes).
	.sp
	Default value: \fB1,073,741,824\fR (1GB).
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_unflushed_max_mem_ppm\fR (ulong)
	.ad
	.RS 12n
	Percentage of the overall system memory that ZFS allows to be used
	for unflushed metadata changes by the log spacemap.
	(value is calculated over 1000000 for finer granularity).
	.sp
	Default value: \fB1000\fR (which is divided by 1000000, resulting in
	the limit to be \fB0.1\fR% of memory)
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_unflushed_log_block_max\fR (ulong)
	.ad
	.RS 12n
	Describes the maximum number of log spacemap blocks allowed for each pool.
	The default value of 262144 means that the space in all the log spacemaps
	can add up to no more than 262144 blocks (which means 32GB of logical
	space before compression and ditto blocks, assuming that blocksize is
	128k).
	.sp
	This tunable is important because it involves a trade-off between import
	time after an unclean export and the frequency of flushing metaslabs.
	The higher this number is, the more log blocks we allow when the pool is
	active which means that we flush metaslabs less often and thus decrease
	the number of I/Os for spacemap updates per TXG.
	At the same time though, that means that in the event of an unclean export,
	there will be more log spacemap blocks for us to read, inducing overhead
	in the import time of the pool.
	The lower the number, the amount of flushing increases destroying log
	blocks quicker as they become obsolete faster, which leaves less blocks
	to be read during import time after a crash.
	.sp
	Each log spacemap block existing during pool import leads to approximately
	one extra logical I/O issued.
	This is the reason why this tunable is exposed in terms of blocks rather
	than space used.
	.sp
	Default value: \fB262144\fR (256K).
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_unflushed_log_block_min\fR (ulong)
	.ad
	.RS 12n
	If the number of metaslabs is small and our incoming rate is high, we
	could get into a situation that we are flushing all our metaslabs every
	TXG.
	Thus we always allow at least this many log blocks.
	.sp
	Default value: \fB1000\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_unflushed_log_block_pct\fR (ulong)
	.ad
	.RS 12n
	Tunable used to determine the number of blocks that can be used for
	the spacemap log, expressed as a percentage of the total number of
	metaslabs in the pool.
	.sp
	Default value: \fB400\fR (read as \fB400\fR% - meaning that the number
	of log spacemap blocks are capped at 4 times the number of
	metaslabs in the pool).
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_unlink_suspend_progress\fR (uint)
	.ad
	.RS 12n
	When enabled, files will not be asynchronously removed from the list of pending
	unlinks and the space they consume will be leaked. Once this option has been
	disabled and the dataset is remounted, the pending unlinks will be processed
	and the freed space returned to the pool.
	This option is used by the test suite to facilitate testing.
	.sp
	Uses \fB0\fR (default) to allow progress and \fB1\fR to pause progress.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_delete_blocks\fR (ulong)
	.ad
	.RS 12n
	This is the used to define a large file for the purposes of delete. Files
	containing more than \fBzfs_delete_blocks\fR will be deleted asynchronously
	while smaller files are deleted synchronously. Decreasing this value will
	reduce the time spent in an unlink(2) system call at the expense of a longer
	delay before the freed space is available.
	.sp
	Default value: \fB20,480\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_dirty_data_max\fR (int)
	.ad
	.RS 12n
	Determines the dirty space limit in bytes. Once this limit is exceeded, new
	writes are halted until space frees up. This parameter takes precedence
	over \fBzfs_dirty_data_max_percent\fR.
	See the section "ZFS TRANSACTION DELAY".
	.sp
	Default value: \fB10\fR% of physical RAM, capped at \fBzfs_dirty_data_max_max\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_dirty_data_max_max\fR (int)
	.ad
	.RS 12n
	Maximum allowable value of \fBzfs_dirty_data_max\fR, expressed in bytes.
	This limit is only enforced at module load time, and will be ignored if
	\fBzfs_dirty_data_max\fR is later changed. This parameter takes
	precedence over \fBzfs_dirty_data_max_max_percent\fR. See the section
	"ZFS TRANSACTION DELAY".
	.sp
	Default value: \fB25\fR% of physical RAM.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_dirty_data_max_max_percent\fR (int)
	.ad
	.RS 12n
	Maximum allowable value of \fBzfs_dirty_data_max\fR, expressed as a
	percentage of physical RAM. This limit is only enforced at module load
	time, and will be ignored if \fBzfs_dirty_data_max\fR is later changed.
	The parameter \fBzfs_dirty_data_max_max\fR takes precedence over this
	one. See the section "ZFS TRANSACTION DELAY".
	.sp
	Default value: \fB25\fR%.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_dirty_data_max_percent\fR (int)
	.ad
	.RS 12n
	Determines the dirty space limit, expressed as a percentage of all
	memory. Once this limit is exceeded, new writes are halted until space frees
	up. The parameter \fBzfs_dirty_data_max\fR takes precedence over this
	one. See the section "ZFS TRANSACTION DELAY".
	.sp
	Default value: \fB10\fR%, subject to \fBzfs_dirty_data_max_max\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_dirty_data_sync_percent\fR (int)
	.ad
	.RS 12n
	Start syncing out a transaction group if there's at least this much dirty data
	as a percentage of \fBzfs_dirty_data_max\fR. This should be less than
	\fBzfs_vdev_async_write_active_min_dirty_percent\fR.
	.sp
	Default value: \fB20\fR% of \fBzfs_dirty_data_max\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_fallocate_reserve_percent\fR (uint)
	.ad
	.RS 12n
	Since ZFS is a copy-on-write filesystem with snapshots, blocks cannot be
	preallocated for a file in order to guarantee that later writes will not
	run out of space. Instead, fallocate() space preallocation only checks
	that sufficient space is currently available in the pool or the user's
	project quota allocation, and then creates a sparse file of the requested
	size. The requested space is multiplied by \fBzfs_fallocate_reserve_percent\fR
	to allow additional space for indirect blocks and other internal metadata.
	Setting this value to 0 disables support for fallocate(2) and returns
	EOPNOTSUPP for fallocate() space preallocation again.
	.sp
	Default value: \fB110\fR%
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_fletcher_4_impl\fR (string)
	.ad
	.RS 12n
	Select a fletcher 4 implementation.
	.sp
	Supported selectors are: \fBfastest\fR, \fBscalar\fR, \fBsse2\fR, \fBssse3\fR,
	\fBavx2\fR, \fBavx512f\fR, \fBavx512bw\fR, and \fBaarch64_neon\fR.
	All of the selectors except \fBfastest\fR and \fBscalar\fR require instruction
	set extensions to be available and will only appear if ZFS detects that they are
	present at runtime. If multiple implementations of fletcher 4 are available,
	the \fBfastest\fR will be chosen using a micro benchmark. Selecting \fBscalar\fR
	results in the original, CPU based calculation, being used. Selecting any option
	other than \fBfastest\fR and \fBscalar\fR results in vector instructions from
	the respective CPU instruction set being used.
	.sp
	Default value: \fBfastest\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_free_bpobj_enabled\fR (int)
	.ad
	.RS 12n
	Enable/disable the processing of the free_bpobj object.
	.sp
	Default value: \fB1\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_async_block_max_blocks\fR (ulong)
	.ad
	.RS 12n
	Maximum number of blocks freed in a single txg.
	.sp
	Default value: \fBULONG_MAX\fR (unlimited).
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_max_async_dedup_frees\fR (ulong)
	.ad
	.RS 12n
	Maximum number of dedup blocks freed in a single txg.
	.sp
	Default value: \fB100,000\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_override_estimate_recordsize\fR (ulong)
	.ad
	.RS 12n
	Record size calculation override for zfs send estimates.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_async_read_max_active\fR (int)
	.ad
	.RS 12n
	Maximum asynchronous read I/Os active to each device.
	See the section "ZFS I/O SCHEDULER".
	.sp
	Default value: \fB3\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_async_read_min_active\fR (int)
	.ad
	.RS 12n
	Minimum asynchronous read I/Os active to each device.
	See the section "ZFS I/O SCHEDULER".
	.sp
	Default value: \fB1\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_async_write_active_max_dirty_percent\fR (int)
	.ad
	.RS 12n
	When the pool has more than
	\fBzfs_vdev_async_write_active_max_dirty_percent\fR dirty data, use
	\fBzfs_vdev_async_write_max_active\fR to limit active async writes. If
	the dirty data is between min and max, the active I/O limit is linearly
	interpolated. See the section "ZFS I/O SCHEDULER".
	.sp
	Default value: \fB60\fR%.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_async_write_active_min_dirty_percent\fR (int)
	.ad
	.RS 12n
	When the pool has less than
	\fBzfs_vdev_async_write_active_min_dirty_percent\fR dirty data, use
	\fBzfs_vdev_async_write_min_active\fR to limit active async writes. If
	the dirty data is between min and max, the active I/O limit is linearly
	interpolated. See the section "ZFS I/O SCHEDULER".
	.sp
	Default value: \fB30\fR%.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_async_write_max_active\fR (int)
	.ad
	.RS 12n
	Maximum asynchronous write I/Os active to each device.
	See the section "ZFS I/O SCHEDULER".
	.sp
	Default value: \fB10\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_async_write_min_active\fR (int)
	.ad
	.RS 12n
	Minimum asynchronous write I/Os active to each device.
	See the section "ZFS I/O SCHEDULER".
	.sp
	Lower values are associated with better latency on rotational media but poorer
	resilver performance. The default value of 2 was chosen as a compromise. A
	value of 3 has been shown to improve resilver performance further at a cost of
	further increasing latency.
	.sp
	Default value: \fB2\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_initializing_max_active\fR (int)
	.ad
	.RS 12n
	Maximum initializing I/Os active to each device.
	See the section "ZFS I/O SCHEDULER".
	.sp
	Default value: \fB1\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_initializing_min_active\fR (int)
	.ad
	.RS 12n
	Minimum initializing I/Os active to each device.
	See the section "ZFS I/O SCHEDULER".
	.sp
	Default value: \fB1\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_max_active\fR (int)
	.ad
	.RS 12n
	The maximum number of I/Os active to each device. Ideally, this will be >=
	the sum of each queue's max_active. See the section "ZFS I/O SCHEDULER".
	.sp
	Default value: \fB1,000\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_rebuild_max_active\fR (int)
	.ad
	.RS 12n
	Maximum sequential resilver I/Os active to each device.
	See the section "ZFS I/O SCHEDULER".
	.sp
	Default value: \fB3\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_rebuild_min_active\fR (int)
	.ad
	.RS 12n
	Minimum sequential resilver I/Os active to each device.
	See the section "ZFS I/O SCHEDULER".
	.sp
	Default value: \fB1\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_removal_max_active\fR (int)
	.ad
	.RS 12n
	Maximum removal I/Os active to each device.
	See the section "ZFS I/O SCHEDULER".
	.sp
	Default value: \fB2\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_removal_min_active\fR (int)
	.ad
	.RS 12n
	Minimum removal I/Os active to each device.
	See the section "ZFS I/O SCHEDULER".
	.sp
	Default value: \fB1\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_scrub_max_active\fR (int)
	.ad
	.RS 12n
	Maximum scrub I/Os active to each device.
	See the section "ZFS I/O SCHEDULER".
	.sp
	Default value: \fB2\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_scrub_min_active\fR (int)
	.ad
	.RS 12n
	Minimum scrub I/Os active to each device.
	See the section "ZFS I/O SCHEDULER".
	.sp
	Default value: \fB1\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_sync_read_max_active\fR (int)
	.ad
	.RS 12n
	Maximum synchronous read I/Os active to each device.
	See the section "ZFS I/O SCHEDULER".
	.sp
	Default value: \fB10\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_sync_read_min_active\fR (int)
	.ad
	.RS 12n
	Minimum synchronous read I/Os active to each device.
	See the section "ZFS I/O SCHEDULER".
	.sp
	Default value: \fB10\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_sync_write_max_active\fR (int)
	.ad
	.RS 12n
	Maximum synchronous write I/Os active to each device.
	See the section "ZFS I/O SCHEDULER".
	.sp
	Default value: \fB10\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_sync_write_min_active\fR (int)
	.ad
	.RS 12n
	Minimum synchronous write I/Os active to each device.
	See the section "ZFS I/O SCHEDULER".
	.sp
	Default value: \fB10\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_trim_max_active\fR (int)
	.ad
	.RS 12n
	Maximum trim/discard I/Os active to each device.
	See the section "ZFS I/O SCHEDULER".
	.sp
	Default value: \fB2\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_trim_min_active\fR (int)
	.ad
	.RS 12n
	Minimum trim/discard I/Os active to each device.
	See the section "ZFS I/O SCHEDULER".
	.sp
	Default value: \fB1\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_nia_delay\fR (int)
	.ad
	.RS 12n
	For non-interactive I/O (scrub, resilver, removal, initialize and rebuild),
	the number of concurrently-active I/O's is limited to *_min_active, unless
	the vdev is "idle". When there are no interactive I/Os active (sync or
	async), and zfs_vdev_nia_delay I/Os have completed since the last
	interactive I/O, then the vdev is considered to be "idle", and the number
	of concurrently-active non-interactive I/O's is increased to *_max_active.
	See the section "ZFS I/O SCHEDULER".
	.sp
	Default value: \fB5\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_nia_credit\fR (int)
	.ad
	.RS 12n
	Some HDDs tend to prioritize sequential I/O so high, that concurrent
	random I/O latency reaches several seconds. On some HDDs it happens
	even if sequential I/Os are submitted one at a time, and so setting
	*_max_active to 1 does not help. To prevent non-interactive I/Os, like
	scrub, from monopolizing the device no more than zfs_vdev_nia_credit
	I/Os can be sent while there are outstanding incomplete interactive
	I/Os. This enforced wait ensures the HDD services the interactive I/O
	within a reasonable amount of time.
	See the section "ZFS I/O SCHEDULER".
	.sp
	Default value: \fB5\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_queue_depth_pct\fR (int)
	.ad
	.RS 12n
	Maximum number of queued allocations per top-level vdev expressed as
	a percentage of \fBzfs_vdev_async_write_max_active\fR which allows the
	system to detect devices that are more capable of handling allocations
	and to allocate more blocks to those devices. It allows for dynamic
	allocation distribution when devices are imbalanced as fuller devices
	will tend to be slower than empty devices.

	See also \fBzio_dva_throttle_enabled\fR.
	.sp
	Default value: \fB1000\fR%.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_expire_snapshot\fR (int)
	.ad
	.RS 12n
	Seconds to expire .zfs/snapshot
	.sp
	Default value: \fB300\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_admin_snapshot\fR (int)
	.ad
	.RS 12n
	Allow the creation, removal, or renaming of entries in the .zfs/snapshot
	directory to cause the creation, destruction, or renaming of snapshots.
	When enabled this functionality works both locally and over NFS exports
	which have the 'no_root_squash' option set. This functionality is disabled
	by default.
	.sp
	Use \fB1\fR for yes and \fB0\fR for no (default).
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_flags\fR (int)
	.ad
	.RS 12n
	Set additional debugging flags. The following flags may be bitwise-or'd
	together.
	.sp
	.TS
	box;
	rB lB
	lB lB
	r l.
	Value Symbolic Name
	Description
	_
	1 ZFS_DEBUG_DPRINTF
	Enable dprintf entries in the debug log.
	_
	2 ZFS_DEBUG_DBUF_VERIFY *
	Enable extra dbuf verifications.
	_
	4 ZFS_DEBUG_DNODE_VERIFY *
	Enable extra dnode verifications.
	_
	8 ZFS_DEBUG_SNAPNAMES
	Enable snapshot name verification.
	_
	16 ZFS_DEBUG_MODIFY
	Check for illegally modified ARC buffers.
	_
	64 ZFS_DEBUG_ZIO_FREE
	Enable verification of block frees.
	_
	128 ZFS_DEBUG_HISTOGRAM_VERIFY
	Enable extra spacemap histogram verifications.
	_
	256 ZFS_DEBUG_METASLAB_VERIFY
	Verify space accounting on disk matches in-core range_trees.
	_
	512 ZFS_DEBUG_SET_ERROR
	Enable SET_ERROR and dprintf entries in the debug log.
	_
	1024 ZFS_DEBUG_INDIRECT_REMAP
	Verify split blocks created by device removal.
	_
	2048 ZFS_DEBUG_TRIM
	Verify TRIM ranges are always within the allocatable range tree.
	_
	4096 ZFS_DEBUG_LOG_SPACEMAP
	Verify that the log summary is consistent with the spacemap log
	and enable zfs_dbgmsgs for metaslab loading and flushing.
	.TE
	.sp
	* Requires debug build.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_free_leak_on_eio\fR (int)
	.ad
	.RS 12n
	If destroy encounters an EIO while reading metadata (e.g. indirect
	blocks), space referenced by the missing metadata can not be freed.
	Normally this causes the background destroy to become "stalled", as
	it is unable to make forward progress. While in this stalled state,
	all remaining space to free from the error-encountering filesystem is
	"temporarily leaked". Set this flag to cause it to ignore the EIO,
	permanently leak the space from indirect blocks that can not be read,
	and continue to free everything else that it can.

	The default, "stalling" behavior is useful if the storage partially
	fails (i.e. some but not all i/os fail), and then later recovers. In
	this case, we will be able to continue pool operations while it is
	partially failed, and when it recovers, we can continue to free the
	space, with no leaks. However, note that this case is actually
	fairly rare.

	Typically pools either (a) fail completely (but perhaps temporarily,
	e.g. a top-level vdev going offline), or (b) have localized,
	permanent errors (e.g. disk returns the wrong data due to bit flip or
	firmware bug). In case (a), this setting does not matter because the
	pool will be suspended and the sync thread will not be able to make
	forward progress regardless. In case (b), because the error is
	permanent, the best we can do is leak the minimum amount of space,
	which is what setting this flag will do. Therefore, it is reasonable
	for this flag to normally be set, but we chose the more conservative
	approach of not setting it, so that there is no possibility of
	leaking space in the "partial temporary" failure case.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_free_min_time_ms\fR (int)
	.ad
	.RS 12n
	During a \fBzfs destroy\fR operation using \fBfeature@async_destroy\fR a minimum
	of this much time will be spent working on freeing blocks per txg.
	.sp
	Default value: \fB1,000\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_obsolete_min_time_ms\fR (int)
	.ad
	.RS 12n
	Similar to \fBzfs_free_min_time_ms\fR but for cleanup of old indirection records
	for removed vdevs.
	.sp
	Default value: \fB500\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_immediate_write_sz\fR (long)
	.ad
	.RS 12n
	Largest data block to write to zil. Larger blocks will be treated as if the
	dataset being written to had the property setting \fBlogbias=throughput\fR.
	.sp
	Default value: \fB32,768\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_initialize_value\fR (ulong)
	.ad
	.RS 12n
	Pattern written to vdev free space by \fBzpool initialize\fR.
	.sp
	Default value: \fB16,045,690,984,833,335,022\fR (0xdeadbeefdeadbeee).
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_initialize_chunk_size\fR (ulong)
	.ad
	.RS 12n
	Size of writes used by \fBzpool initialize\fR.
	This option is used by the test suite to facilitate testing.
	.sp
	Default value: \fB1,048,576\fR
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_livelist_max_entries\fR (ulong)
	.ad
	.RS 12n
	The threshold size (in block pointers) at which we create a new sub-livelist.
	Larger sublists are more costly from a memory perspective but the fewer
	sublists there are, the lower the cost of insertion.
	.sp
	Default value: \fB500,000\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_livelist_min_percent_shared\fR (int)
	.ad
	.RS 12n
	If the amount of shared space between a snapshot and its clone drops below
	this threshold, the clone turns off the livelist and reverts to the old deletion
	method. This is in place because once a clone has been overwritten enough
	livelists no long give us a benefit.
	.sp
	Default value: \fB75\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_livelist_condense_new_alloc\fR (int)
	.ad
	.RS 12n
	Incremented each time an extra ALLOC blkptr is added to a livelist entry while
	it is being condensed.
	This option is used by the test suite to track race conditions.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_livelist_condense_sync_cancel\fR (int)
	.ad
	.RS 12n
	Incremented each time livelist condensing is canceled while in
	spa_livelist_condense_sync.
	This option is used by the test suite to track race conditions.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_livelist_condense_sync_pause\fR (int)
	.ad
	.RS 12n
	When set, the livelist condense process pauses indefinitely before
	executing the synctask - spa_livelist_condense_sync.
	This option is used by the test suite to trigger race conditions.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_livelist_condense_zthr_cancel\fR (int)
	.ad
	.RS 12n
	Incremented each time livelist condensing is canceled while in
	spa_livelist_condense_cb.
	This option is used by the test suite to track race conditions.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_livelist_condense_zthr_pause\fR (int)
	.ad
	.RS 12n
	When set, the livelist condense process pauses indefinitely before
	executing the open context condensing work in spa_livelist_condense_cb.
	This option is used by the test suite to trigger race conditions.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_lua_max_instrlimit\fR (ulong)
	.ad
	.RS 12n
	The maximum execution time limit that can be set for a ZFS channel program,
	specified as a number of Lua instructions.
	.sp
	Default value: \fB100,000,000\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_lua_max_memlimit\fR (ulong)
	.ad
	.RS 12n
	The maximum memory limit that can be set for a ZFS channel program, specified
	in bytes.
	.sp
	Default value: \fB104,857,600\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_max_dataset_nesting\fR (int)
	.ad
	.RS 12n
	The maximum depth of nested datasets. This value can be tuned temporarily to
	fix existing datasets that exceed the predefined limit.
	.sp
	Default value: \fB50\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_max_log_walking\fR (ulong)
	.ad
	.RS 12n
	The number of past TXGs that the flushing algorithm of the log spacemap
	feature uses to estimate incoming log blocks.
	.sp
	Default value: \fB5\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_max_logsm_summary_length\fR (ulong)
	.ad
	.RS 12n
	Maximum number of rows allowed in the summary of the spacemap log.
	.sp
	Default value: \fB10\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_max_recordsize\fR (int)
	.ad
	.RS 12n
	We currently support block sizes from 512 bytes to 16MB. The benefits of
	larger blocks, and thus larger I/O, need to be weighed against the cost of
	COWing a giant block to modify one byte. Additionally, very large blocks
	can have an impact on i/o latency, and also potentially on the memory
	allocator. Therefore, we do not allow the recordsize to be set larger than
	zfs_max_recordsize (default 1MB). Larger blocks can be created by changing
	this tunable, and pools with larger blocks can always be imported and used,
	regardless of this setting.
	.sp
	Default value: \fB1,048,576\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_allow_redacted_dataset_mount\fR (int)
	.ad
	.RS 12n
	Allow datasets received with redacted send/receive to be mounted. Normally
	disabled because these datasets may be missing key data.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_min_metaslabs_to_flush\fR (ulong)
	.ad
	.RS 12n
	Minimum number of metaslabs to flush per dirty TXG
	.sp
	Default value: \fB1\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_metaslab_fragmentation_threshold\fR (int)
	.ad
	.RS 12n
	Allow metaslabs to keep their active state as long as their fragmentation
	percentage is less than or equal to this value. An active metaslab that
	exceeds this threshold will no longer keep its active status allowing
	better metaslabs to be selected.
	.sp
	Default value: \fB70\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_mg_fragmentation_threshold\fR (int)
	.ad
	.RS 12n
	Metaslab groups are considered eligible for allocations if their
	fragmentation metric (measured as a percentage) is less than or equal to
	this value. If a metaslab group exceeds this threshold then it will be
	skipped unless all metaslab groups within the metaslab class have also
	crossed this threshold.
	.sp
	Default value: \fB95\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_mg_noalloc_threshold\fR (int)
	.ad
	.RS 12n
	Defines a threshold at which metaslab groups should be eligible for
	allocations. The value is expressed as a percentage of free space
	beyond which a metaslab group is always eligible for allocations.
	If a metaslab group's free space is less than or equal to the
	threshold, the allocator will avoid allocating to that group
	unless all groups in the pool have reached the threshold. Once all
	groups have reached the threshold, all groups are allowed to accept
	allocations. The default value of 0 disables the feature and causes
	all metaslab groups to be eligible for allocations.

	This parameter allows one to deal with pools having heavily imbalanced
	vdevs such as would be the case when a new vdev has been added.
	Setting the threshold to a non-zero percentage will stop allocations
	from being made to vdevs that aren't filled to the specified percentage
	and allow lesser filled vdevs to acquire more allocations than they
	otherwise would under the old \fBzfs_mg_alloc_failures\fR facility.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_ddt_data_is_special\fR (int)
	.ad
	.RS 12n
	If enabled, ZFS will place DDT data into the special allocation class.
	.sp
	Default value: \fB1\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_user_indirect_is_special\fR (int)
	.ad
	.RS 12n
	If enabled, ZFS will place user data (both file and zvol) indirect blocks
	into the special allocation class.
	.sp
	Default value: \fB1\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_multihost_history\fR (int)
	.ad
	.RS 12n
	Historical statistics for the last N multihost updates will be available in
	\fB/proc/spl/kstat/zfs/<pool>/multihost\fR
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_multihost_interval\fR (ulong)
	.ad
	.RS 12n
	Used to control the frequency of multihost writes which are performed when the
	\fBmultihost\fR pool property is on. This is one factor used to determine the
	length of the activity check during import.
	.sp
	The multihost write period is \fBzfs_multihost_interval / leaf-vdevs\fR
	milliseconds. On average a multihost write will be issued for each leaf vdev
	every \fBzfs_multihost_interval\fR milliseconds. In practice, the observed
	period can vary with the I/O load and this observed value is the delay which is
	stored in the uberblock.
	.sp
	Default value: \fB1000\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_multihost_import_intervals\fR (uint)
	.ad
	.RS 12n
	Used to control the duration of the activity test on import. Smaller values of
	\fBzfs_multihost_import_intervals\fR will reduce the import time but increase
	the risk of failing to detect an active pool. The total activity check time is
	never allowed to drop below one second.
	.sp
	On import the activity check waits a minimum amount of time determined by
	\fBzfs_multihost_interval * zfs_multihost_import_intervals\fR, or the same
	product computed on the host which last had the pool imported (whichever is
	greater). The activity check time may be further extended if the value of mmp
	delay found in the best uberblock indicates actual multihost updates happened
	at longer intervals than \fBzfs_multihost_interval\fR. A minimum value of
	\fB100ms\fR is enforced.
	.sp
	A value of 0 is ignored and treated as if it was set to 1.
	.sp
	Default value: \fB20\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_multihost_fail_intervals\fR (uint)
	.ad
	.RS 12n
	Controls the behavior of the pool when multihost write failures or delays are
	detected.
	.sp
	When \fBzfs_multihost_fail_intervals = 0\fR, multihost write failures or delays
	are ignored. The failures will still be reported to the ZED which depending on
	its configuration may take action such as suspending the pool or offlining a
	device.

	.sp
	When \fBzfs_multihost_fail_intervals > 0\fR, the pool will be suspended if
	\fBzfs_multihost_fail_intervals * zfs_multihost_interval\fR milliseconds pass
	without a successful mmp write. This guarantees the activity test will see
	mmp writes if the pool is imported. A value of 1 is ignored and treated as
	if it was set to 2. This is necessary to prevent the pool from being suspended
	due to normal, small I/O latency variations.

	.sp
	Default value: \fB10\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_no_scrub_io\fR (int)
	.ad
	.RS 12n
	Set for no scrub I/O. This results in scrubs not actually scrubbing data and
	simply doing a metadata crawl of the pool instead.
	.sp
	Use \fB1\fR for yes and \fB0\fR for no (default).
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_no_scrub_prefetch\fR (int)
	.ad
	.RS 12n
	Set to disable block prefetching for scrubs.
	.sp
	Use \fB1\fR for yes and \fB0\fR for no (default).
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_nocacheflush\fR (int)
	.ad
	.RS 12n
	Disable cache flush operations on disks when writing. Setting this will
	cause pool corruption on power loss if a volatile out-of-order write cache
	is enabled.
	.sp
	Use \fB1\fR for yes and \fB0\fR for no (default).
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_nopwrite_enabled\fR (int)
	.ad
	.RS 12n
	Enable NOP writes
	.sp
	Use \fB1\fR for yes (default) and \fB0\fR to disable.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_dmu_offset_next_sync\fR (int)
	.ad
	.RS 12n
	Enable forcing txg sync to find holes. When enabled forces ZFS to act
	like prior versions when SEEK_HOLE or SEEK_DATA flags are used, which
	when a dnode is dirty causes txg's to be synced so that this data can be
	found.
	.sp
	Use \fB1\fR for yes and \fB0\fR to disable (default).
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_pd_bytes_max\fR (int)
	.ad
	.RS 12n
	The number of bytes which should be prefetched during a pool traversal
	(eg: \fBzfs send\fR or other data crawling operations)
	.sp
	Default value: \fB52,428,800\fR.
	.RE

	+.sp
	+.ne 2
	+.na
	+\fBzfs_traverse_indirect_prefetch_limit\fR (int)
	+.ad
	+.RS 12n
	+The number of blocks pointed by indirect (non-L0) block, which should be
	+prefetched during a pool traversal (eg: \fBzfs send\fR or other data
	+crawling operations)
	+.sp
	+Default value: \fB32\fR.
	+.RE
	+
	.sp
	.ne 2
	.na
	\fBzfs_per_txg_dirty_frees_percent \fR (ulong)
	.ad
	.RS 12n
	Tunable to control percentage of dirtied indirect blocks from frees allowed
	into one TXG. After this threshold is crossed, additional frees will wait until
	the next TXG.
	A value of zero will disable this throttle.
	.sp
	Default value: \fB5\fR, set to \fB0\fR to disable.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_prefetch_disable\fR (int)
	.ad
	.RS 12n
	This tunable disables predictive prefetch. Note that it leaves "prescient"
	prefetch (e.g. prefetch for zfs send) intact. Unlike predictive prefetch,
	prescient prefetch never issues i/os that end up not being needed, so it
	can't hurt performance.
	.sp
	Use \fB1\fR for yes and \fB0\fR for no (default).
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_qat_checksum_disable\fR (int)
	.ad
	.RS 12n
	This tunable disables qat hardware acceleration for sha256 checksums. It
	may be set after the zfs modules have been loaded to initialize the qat
	hardware as long as support is compiled in and the qat driver is present.
	.sp
	Use \fB1\fR for yes and \fB0\fR for no (default).
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_qat_compress_disable\fR (int)
	.ad
	.RS 12n
	This tunable disables qat hardware acceleration for gzip compression. It
	may be set after the zfs modules have been loaded to initialize the qat
	hardware as long as support is compiled in and the qat driver is present.
	.sp
	Use \fB1\fR for yes and \fB0\fR for no (default).
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_qat_encrypt_disable\fR (int)
	.ad
	.RS 12n
	This tunable disables qat hardware acceleration for AES-GCM encryption. It
	may be set after the zfs modules have been loaded to initialize the qat
	hardware as long as support is compiled in and the qat driver is present.
	.sp
	Use \fB1\fR for yes and \fB0\fR for no (default).
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_read_chunk_size\fR (long)
	.ad
	.RS 12n
	Bytes to read per chunk
	.sp
	Default value: \fB1,048,576\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_read_history\fR (int)
	.ad
	.RS 12n
	Historical statistics for the last N reads will be available in
	\fB/proc/spl/kstat/zfs/<pool>/reads\fR
	.sp
	Default value: \fB0\fR (no data is kept).
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_read_history_hits\fR (int)
	.ad
	.RS 12n
	Include cache hits in read history
	.sp
	Use \fB1\fR for yes and \fB0\fR for no (default).
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_rebuild_max_segment\fR (ulong)
	.ad
	.RS 12n
	Maximum read segment size to issue when sequentially resilvering a
	top-level vdev.
	.sp
	Default value: \fB1,048,576\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_rebuild_scrub_enabled\fR (int)
	.ad
	.RS 12n
	Automatically start a pool scrub when the last active sequential resilver
	completes in order to verify the checksums of all blocks which have been
	resilvered. This option is enabled by default and is strongly recommended.
	.sp
	Default value: \fB1\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_rebuild_vdev_limit\fR (ulong)
	.ad
	.RS 12n
	Maximum amount of i/o that can be concurrently issued for a sequential
	resilver per leaf device, given in bytes.
	.sp
	Default value: \fB33,554,432\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_reconstruct_indirect_combinations_max\fR (int)
	.ad
	.RS 12na
	If an indirect split block contains more than this many possible unique
	combinations when being reconstructed, consider it too computationally
	expensive to check them all. Instead, try at most
	\fBzfs_reconstruct_indirect_combinations_max\fR randomly-selected
	combinations each time the block is accessed. This allows all segment
	copies to participate fairly in the reconstruction when all combinations
	cannot be checked and prevents repeated use of one bad copy.
	.sp
	Default value: \fB4096\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_recover\fR (int)
	.ad
	.RS 12n
	Set to attempt to recover from fatal errors. This should only be used as a
	last resort, as it typically results in leaked space, or worse.
	.sp
	Use \fB1\fR for yes and \fB0\fR for no (default).
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_removal_ignore_errors\fR (int)
	.ad
	.RS 12n
	.sp
	Ignore hard IO errors during device removal. When set, if a device encounters
	a hard IO error during the removal process the removal will not be cancelled.
	This can result in a normally recoverable block becoming permanently damaged
	and is not recommended. This should only be used as a last resort when the
	pool cannot be returned to a healthy state prior to removing the device.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_removal_suspend_progress\fR (int)
	.ad
	.RS 12n
	.sp
	This is used by the test suite so that it can ensure that certain actions
	happen while in the middle of a removal.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_remove_max_segment\fR (int)
	.ad
	.RS 12n
	.sp
	The largest contiguous segment that we will attempt to allocate when removing
	a device. This can be no larger than 16MB. If there is a performance
	problem with attempting to allocate large blocks, consider decreasing this.
	.sp
	Default value: \fB16,777,216\fR (16MB).
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_resilver_disable_defer\fR (int)
	.ad
	.RS 12n
	Disables the \fBresilver_defer\fR feature, causing an operation that would
	start a resilver to restart one in progress immediately.
	.sp
	Default value: \fB0\fR (feature enabled).
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_resilver_min_time_ms\fR (int)
	.ad
	.RS 12n
	Resilvers are processed by the sync thread. While resilvering it will spend
	at least this much time working on a resilver between txg flushes.
	.sp
	Default value: \fB3,000\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_scan_ignore_errors\fR (int)
	.ad
	.RS 12n
	If set to a nonzero value, remove the DTL (dirty time list) upon
	completion of a pool scan (scrub) even if there were unrepairable
	errors. It is intended to be used during pool repair or recovery to
	stop resilvering when the pool is next imported.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_scrub_min_time_ms\fR (int)
	.ad
	.RS 12n
	Scrubs are processed by the sync thread. While scrubbing it will spend
	at least this much time working on a scrub between txg flushes.
	.sp
	Default value: \fB1,000\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_scan_checkpoint_intval\fR (int)
	.ad
	.RS 12n
	To preserve progress across reboots the sequential scan algorithm periodically
	needs to stop metadata scanning and issue all the verifications I/Os to disk.
	The frequency of this flushing is determined by the
	\fBzfs_scan_checkpoint_intval\fR tunable.
	.sp
	Default value: \fB7200\fR seconds (every 2 hours).
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_scan_fill_weight\fR (int)
	.ad
	.RS 12n
	This tunable affects how scrub and resilver I/O segments are ordered. A higher
	number indicates that we care more about how filled in a segment is, while a
	lower number indicates we care more about the size of the extent without
	considering the gaps within a segment. This value is only tunable upon module
	insertion. Changing the value afterwards will have no affect on scrub or
	resilver performance.
	.sp
	Default value: \fB3\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_scan_issue_strategy\fR (int)
	.ad
	.RS 12n
	Determines the order that data will be verified while scrubbing or resilvering.
	If set to \fB1\fR, data will be verified as sequentially as possible, given the
	amount of memory reserved for scrubbing (see \fBzfs_scan_mem_lim_fact\fR). This
	may improve scrub performance if the pool's data is very fragmented. If set to
	\fB2\fR, the largest mostly-contiguous chunk of found data will be verified
	first. By deferring scrubbing of small segments, we may later find adjacent data
	to coalesce and increase the segment size. If set to \fB0\fR, zfs will use
	strategy \fB1\fR during normal verification and strategy \fB2\fR while taking a
	checkpoint.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_scan_legacy\fR (int)
	.ad
	.RS 12n
	A value of 0 indicates that scrubs and resilvers will gather metadata in
	memory before issuing sequential I/O. A value of 1 indicates that the legacy
	algorithm will be used where I/O is initiated as soon as it is discovered.
	Changing this value to 0 will not affect scrubs or resilvers that are already
	in progress.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_scan_max_ext_gap\fR (int)
	.ad
	.RS 12n
	Indicates the largest gap in bytes between scrub / resilver I/Os that will still
	be considered sequential for sorting purposes. Changing this value will not
	affect scrubs or resilvers that are already in progress.
	.sp
	Default value: \fB2097152 (2 MB)\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_scan_mem_lim_fact\fR (int)
	.ad
	.RS 12n
	Maximum fraction of RAM used for I/O sorting by sequential scan algorithm.
	This tunable determines the hard limit for I/O sorting memory usage.
	When the hard limit is reached we stop scanning metadata and start issuing
	data verification I/O. This is done until we get below the soft limit.
	.sp
	Default value: \fB20\fR which is 5% of RAM (1/20).
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_scan_mem_lim_soft_fact\fR (int)
	.ad
	.RS 12n
	The fraction of the hard limit used to determined the soft limit for I/O sorting
	by the sequential scan algorithm. When we cross this limit from below no action
	is taken. When we cross this limit from above it is because we are issuing
	verification I/O. In this case (unless the metadata scan is done) we stop
	issuing verification I/O and start scanning metadata again until we get to the
	hard limit.
	.sp
	Default value: \fB20\fR which is 5% of the hard limit (1/20).
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_scan_strict_mem_lim\fR (int)
	.ad
	.RS 12n
	Enforces tight memory limits on pool scans when a sequential scan is in
	progress. When disabled the memory limit may be exceeded by fast disks.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_scan_suspend_progress\fR (int)
	.ad
	.RS 12n
	Freezes a scrub/resilver in progress without actually pausing it. Intended for
	testing/debugging.
	.sp
	Default value: \fB0\fR.
	.RE


	.sp
	.ne 2
	.na
	\fBzfs_scan_vdev_limit\fR (int)
	.ad
	.RS 12n
	Maximum amount of data that can be concurrently issued at once for scrubs and
	resilvers per leaf device, given in bytes.
	.sp
	Default value: \fB41943040\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_send_corrupt_data\fR (int)
	.ad
	.RS 12n
	Allow sending of corrupt data (ignore read/checksum errors when sending data)
	.sp
	Use \fB1\fR for yes and \fB0\fR for no (default).
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_send_unmodified_spill_blocks\fR (int)
	.ad
	.RS 12n
	Include unmodified spill blocks in the send stream. Under certain circumstances
	previous versions of ZFS could incorrectly remove the spill block from an
	existing object. Including unmodified copies of the spill blocks creates a
	backwards compatible stream which will recreate a spill block if it was
	incorrectly removed.
	.sp
	Use \fB1\fR for yes (default) and \fB0\fR for no.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_send_no_prefetch_queue_ff\fR (int)
	.ad
	.RS 12n
	The fill fraction of the \fBzfs send\fR internal queues. The fill fraction
	controls the timing with which internal threads are woken up.
	.sp
	Default value: \fB20\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_send_no_prefetch_queue_length\fR (int)
	.ad
	.RS 12n
	The maximum number of bytes allowed in \fBzfs send\fR's internal queues.
	.sp
	Default value: \fB1,048,576\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_send_queue_ff\fR (int)
	.ad
	.RS 12n
	The fill fraction of the \fBzfs send\fR prefetch queue. The fill fraction
	controls the timing with which internal threads are woken up.
	.sp
	Default value: \fB20\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_send_queue_length\fR (int)
	.ad
	.RS 12n
	The maximum number of bytes allowed that will be prefetched by \fBzfs send\fR.
	This value must be at least twice the maximum block size in use.
	.sp
	Default value: \fB16,777,216\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_recv_queue_ff\fR (int)
	.ad
	.RS 12n
	The fill fraction of the \fBzfs receive\fR queue. The fill fraction
	controls the timing with which internal threads are woken up.
	.sp
	Default value: \fB20\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_recv_queue_length\fR (int)
	.ad
	.RS 12n
	The maximum number of bytes allowed in the \fBzfs receive\fR queue. This value
	must be at least twice the maximum block size in use.
	.sp
	Default value: \fB16,777,216\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_recv_write_batch_size\fR (int)
	.ad
	.RS 12n
	The maximum amount of data (in bytes) that \fBzfs receive\fR will write in
	one DMU transaction. This is the uncompressed size, even when receiving a
	compressed send stream. This setting will not reduce the write size below
	a single block. Capped at a maximum of 32MB
	.sp
	Default value: \fB1MB\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_override_estimate_recordsize\fR (ulong)
	.ad
	.RS 12n
	Setting this variable overrides the default logic for estimating block
	sizes when doing a zfs send. The default heuristic is that the average
	block size will be the current recordsize. Override this value if most data
	in your dataset is not of that size and you require accurate zfs send size
	estimates.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_sync_pass_deferred_free\fR (int)
	.ad
	.RS 12n
	Flushing of data to disk is done in passes. Defer frees starting in this pass
	.sp
	Default value: \fB2\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_spa_discard_memory_limit\fR (int)
	.ad
	.RS 12n
	Maximum memory used for prefetching a checkpoint's space map on each
	vdev while discarding the checkpoint.
	.sp
	Default value: \fB16,777,216\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_special_class_metadata_reserve_pct\fR (int)
	.ad
	.RS 12n
	Only allow small data blocks to be allocated on the special and dedup vdev
	types when the available free space percentage on these vdevs exceeds this
	value. This ensures reserved space is available for pool meta data as the
	special vdevs approach capacity.
	.sp
	Default value: \fB25\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_sync_pass_dont_compress\fR (int)
	.ad
	.RS 12n
	Starting in this sync pass, we disable compression (including of metadata).
	With the default setting, in practice, we don't have this many sync passes,
	so this has no effect.
	.sp
	The original intent was that disabling compression would help the sync passes
	to converge. However, in practice disabling compression increases the average
	number of sync passes, because when we turn compression off, a lot of block's
	size will change and thus we have to re-allocate (not overwrite) them. It
	also increases the number of 128KB allocations (e.g. for indirect blocks and
	spacemaps) because these will not be compressed. The 128K allocations are
	especially detrimental to performance on highly fragmented systems, which may
	have very few free segments of this size, and may need to load new metaslabs
	to satisfy 128K allocations.
	.sp
	Default value: \fB8\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_sync_pass_rewrite\fR (int)
	.ad
	.RS 12n
	Rewrite new block pointers starting in this pass
	.sp
	Default value: \fB2\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_sync_taskq_batch_pct\fR (int)
	.ad
	.RS 12n
	This controls the number of threads used by the dp_sync_taskq. The default
	value of 75% will create a maximum of one thread per cpu.
	.sp
	Default value: \fB75\fR%.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_trim_extent_bytes_max\fR (uint)
	.ad
	.RS 12n
	Maximum size of TRIM command. Ranges larger than this will be split in to
	chunks no larger than \fBzfs_trim_extent_bytes_max\fR bytes before being
	issued to the device.
	.sp
	Default value: \fB134,217,728\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_trim_extent_bytes_min\fR (uint)
	.ad
	.RS 12n
	Minimum size of TRIM commands. TRIM ranges smaller than this will be skipped
	unless they're part of a larger range which was broken in to chunks. This is
	done because it's common for these small TRIMs to negatively impact overall
	performance. This value can be set to 0 to TRIM all unallocated space.
	.sp
	Default value: \fB32,768\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_trim_metaslab_skip\fR (uint)
	.ad
	.RS 12n
	Skip uninitialized metaslabs during the TRIM process. This option is useful
	for pools constructed from large thinly-provisioned devices where TRIM
	operations are slow. As a pool ages an increasing fraction of the pools
	metaslabs will be initialized progressively degrading the usefulness of
	this option. This setting is stored when starting a manual TRIM and will
	persist for the duration of the requested TRIM.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_trim_queue_limit\fR (uint)
	.ad
	.RS 12n
	Maximum number of queued TRIMs outstanding per leaf vdev. The number of
	concurrent TRIM commands issued to the device is controlled by the
	\fBzfs_vdev_trim_min_active\fR and \fBzfs_vdev_trim_max_active\fR module
	options.
	.sp
	Default value: \fB10\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_trim_txg_batch\fR (uint)
	.ad
	.RS 12n
	The number of transaction groups worth of frees which should be aggregated
	before TRIM operations are issued to the device. This setting represents a
	trade-off between issuing larger, more efficient TRIM operations and the
	delay before the recently trimmed space is available for use by the device.
	.sp
	Increasing this value will allow frees to be aggregated for a longer time.
	This will result is larger TRIM operations and potentially increased memory
	usage. Decreasing this value will have the opposite effect. The default
	value of 32 was determined to be a reasonable compromise.
	.sp
	Default value: \fB32\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_txg_history\fR (int)
	.ad
	.RS 12n
	Historical statistics for the last N txgs will be available in
	\fB/proc/spl/kstat/zfs/<pool>/txgs\fR
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_txg_timeout\fR (int)
	.ad
	.RS 12n
	Flush dirty data to disk at least every N seconds (maximum txg duration)
	.sp
	Default value: \fB5\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_aggregate_trim\fR (int)
	.ad
	.RS 12n
	Allow TRIM I/Os to be aggregated. This is normally not helpful because
	the extents to be trimmed will have been already been aggregated by the
	metaslab. This option is provided for debugging and performance analysis.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_aggregation_limit\fR (int)
	.ad
	.RS 12n
	Max vdev I/O aggregation size
	.sp
	Default value: \fB1,048,576\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_aggregation_limit_non_rotating\fR (int)
	.ad
	.RS 12n
	Max vdev I/O aggregation size for non-rotating media
	.sp
	Default value: \fB131,072\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_cache_bshift\fR (int)
	.ad
	.RS 12n
	Shift size to inflate reads too
	.sp
	Default value: \fB16\fR (effectively 65536).
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_cache_max\fR (int)
	.ad
	.RS 12n
	Inflate reads smaller than this value to meet the \fBzfs_vdev_cache_bshift\fR
	size (default 64k).
	.sp
	Default value: \fB16384\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_cache_size\fR (int)
	.ad
	.RS 12n
	Total size of the per-disk cache in bytes.
	.sp
	Currently this feature is disabled as it has been found to not be helpful
	for performance and in some cases harmful.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_mirror_rotating_inc\fR (int)
	.ad
	.RS 12n
	A number by which the balancing algorithm increments the load calculation for
	the purpose of selecting the least busy mirror member when an I/O immediately
	follows its predecessor on rotational vdevs for the purpose of making decisions
	based on load.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_mirror_rotating_seek_inc\fR (int)
	.ad
	.RS 12n
	A number by which the balancing algorithm increments the load calculation for
	the purpose of selecting the least busy mirror member when an I/O lacks
	locality as defined by the zfs_vdev_mirror_rotating_seek_offset. I/Os within
	this that are not immediately following the previous I/O are incremented by
	half.
	.sp
	Default value: \fB5\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_mirror_rotating_seek_offset\fR (int)
	.ad
	.RS 12n
	The maximum distance for the last queued I/O in which the balancing algorithm
	considers an I/O to have locality.
	See the section "ZFS I/O SCHEDULER".
	.sp
	Default value: \fB1048576\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_mirror_non_rotating_inc\fR (int)
	.ad
	.RS 12n
	A number by which the balancing algorithm increments the load calculation for
	the purpose of selecting the least busy mirror member on non-rotational vdevs
	when I/Os do not immediately follow one another.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_mirror_non_rotating_seek_inc\fR (int)
	.ad
	.RS 12n
	A number by which the balancing algorithm increments the load calculation for
	the purpose of selecting the least busy mirror member when an I/O lacks
	locality as defined by the zfs_vdev_mirror_rotating_seek_offset. I/Os within
	this that are not immediately following the previous I/O are incremented by
	half.
	.sp
	Default value: \fB1\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_read_gap_limit\fR (int)
	.ad
	.RS 12n
	Aggregate read I/O operations if the gap on-disk between them is within this
	threshold.
	.sp
	Default value: \fB32,768\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_write_gap_limit\fR (int)
	.ad
	.RS 12n
	Aggregate write I/O over gap
	.sp
	Default value: \fB4,096\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_raidz_impl\fR (string)
	.ad
	.RS 12n
	Parameter for selecting raidz parity implementation to use.

	Options marked (always) below may be selected on module load as they are
	supported on all systems.
	The remaining options may only be set after the module is loaded, as they
	are available only if the implementations are compiled in and supported
	on the running system.

	Once the module is loaded, the content of
	/sys/module/zfs/parameters/zfs_vdev_raidz_impl will show available options
	with the currently selected one enclosed in [].
	Possible options are:
	fastest - (always) implementation selected using built-in benchmark
	original - (always) original raidz implementation
	scalar - (always) scalar raidz implementation
	sse2 - implementation using SSE2 instruction set (64bit x86 only)
	ssse3 - implementation using SSSE3 instruction set (64bit x86 only)
	avx2 - implementation using AVX2 instruction set (64bit x86 only)
	avx512f - implementation using AVX512F instruction set (64bit x86 only)
	avx512bw - implementation using AVX512F & AVX512BW instruction sets (64bit x86 only)
	aarch64_neon - implementation using NEON (Aarch64/64 bit ARMv8 only)
	aarch64_neonx2 - implementation using NEON with more unrolling (Aarch64/64 bit ARMv8 only)
	powerpc_altivec - implementation using Altivec (PowerPC only)
	.sp
	Default value: \fBfastest\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_vdev_scheduler\fR (charp)
	.ad
	.RS 12n
	\fBDEPRECATED\fR: This option exists for compatibility with older user
	configurations. It does nothing except print a warning to the kernel log if
	set.
	.sp
	.RE

	-.sp
	-.ne 2
	-.na
	-\fBzfs_zevent_cols\fR (int)
	-.ad
	-.RS 12n
	-When zevents are logged to the console use this as the word wrap width.
	-.sp
	-Default value: \fB80\fR.
	-.RE
	-
	-.sp
	-.ne 2
	-.na
	-\fBzfs_zevent_console\fR (int)
	-.ad
	-.RS 12n
	-Log events to the console
	-.sp
	-Use \fB1\fR for yes and \fB0\fR for no (default).
	-.RE
	-
	.sp
	.ne 2
	.na
	\fBzfs_zevent_len_max\fR (int)
	.ad
	.RS 12n
	-Max event queue length. A value of 0 will result in a calculated value which
	-increases with the number of CPUs in the system (minimum 64 events). Events
	-in the queue can be viewed with the \fBzpool events\fR command.
	+Max event queue length.
	+Events in the queue can be viewed with the \fBzpool events\fR command.
	.sp
	-Default value: \fB0\fR.
	+Default value: \fB512\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_zevent_retain_max\fR (int)
	.ad
	.RS 12n
	Maximum recent zevent records to retain for duplicate checking. Setting
	this value to zero disables duplicate detection.
	.sp
	Default value: \fB2000\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_zevent_retain_expire_secs\fR (int)
	.ad
	.RS 12n
	Lifespan for a recent ereport that was retained for duplicate checking.
	.sp
	Default value: \fB900\fR.
	.RE

	.na
	\fBzfs_zil_clean_taskq_maxalloc\fR (int)
	.ad
	.RS 12n
	The maximum number of taskq entries that are allowed to be cached. When this
	limit is exceeded transaction records (itxs) will be cleaned synchronously.
	.sp
	Default value: \fB1048576\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_zil_clean_taskq_minalloc\fR (int)
	.ad
	.RS 12n
	The number of taskq entries that are pre-populated when the taskq is first
	created and are immediately available for use.
	.sp
	Default value: \fB1024\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_zil_clean_taskq_nthr_pct\fR (int)
	.ad
	.RS 12n
	This controls the number of threads used by the dp_zil_clean_taskq. The default
	value of 100% will create a maximum of one thread per cpu.
	.sp
	Default value: \fB100\fR%.
	.RE

	.sp
	.ne 2
	.na
	\fBzil_maxblocksize\fR (int)
	.ad
	.RS 12n
	This sets the maximum block size used by the ZIL. On very fragmented pools,
	lowering this (typically to 36KB) can improve performance.
	.sp
	Default value: \fB131072\fR (128KB).
	.RE

	.sp
	.ne 2
	.na
	\fBzil_nocacheflush\fR (int)
	.ad
	.RS 12n
	Disable the cache flush commands that are normally sent to the disk(s) by
	the ZIL after an LWB write has completed. Setting this will cause ZIL
	corruption on power loss if a volatile out-of-order write cache is enabled.
	.sp
	Use \fB1\fR for yes and \fB0\fR for no (default).
	.RE

	.sp
	.ne 2
	.na
	\fBzil_replay_disable\fR (int)
	.ad
	.RS 12n
	Disable intent logging replay. Can be disabled for recovery from corrupted
	ZIL
	.sp
	Use \fB1\fR for yes and \fB0\fR for no (default).
	.RE

	.sp
	.ne 2
	.na
	\fBzil_slog_bulk\fR (ulong)
	.ad
	.RS 12n
	Limit SLOG write size per commit executed with synchronous priority.
	Any writes above that will be executed with lower (asynchronous) priority
	to limit potential SLOG device abuse by single active ZIL writer.
	.sp
	Default value: \fB786,432\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzfs_embedded_slog_min_ms\fR (int)
	.ad
	.RS 12n
	Usually, one metaslab from each (normal-class) vdev is dedicated for use by
	the ZIL (to log synchronous writes).
	However, if there are fewer than zfs_embedded_slog_min_ms metaslabs in the
	vdev, this functionality is disabled.
	This ensures that we don't set aside an unreasonable amount of space for the
	ZIL.
	.sp
	Default value: \fB64\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzio_deadman_log_all\fR (int)
	.ad
	.RS 12n
	If non-zero, the zio deadman will produce debugging messages (see
	\fBzfs_dbgmsg_enable\fR) for all zios, rather than only for leaf
	zios possessing a vdev. This is meant to be used by developers to gain
	diagnostic information for hang conditions which don't involve a mutex
	or other locking primitive; typically conditions in which a thread in
	the zio pipeline is looping indefinitely.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzio_decompress_fail_fraction\fR (int)
	.ad
	.RS 12n
	If non-zero, this value represents the denominator of the probability that zfs
	should induce a decompression failure. For instance, for a 5% decompression
	failure rate, this value should be set to 20.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzio_slow_io_ms\fR (int)
	.ad
	.RS 12n
	When an I/O operation takes more than \fBzio_slow_io_ms\fR milliseconds to
	complete is marked as a slow I/O. Each slow I/O causes a delay zevent. Slow
	I/O counters can be seen with "zpool status -s".

	.sp
	Default value: \fB30,000\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzio_dva_throttle_enabled\fR (int)
	.ad
	.RS 12n
	Throttle block allocations in the I/O pipeline. This allows for
	dynamic allocation distribution when devices are imbalanced.
	When enabled, the maximum number of pending allocations per top-level vdev
	is limited by \fBzfs_vdev_queue_depth_pct\fR.
	.sp
	Default value: \fB1\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzio_requeue_io_start_cut_in_line\fR (int)
	.ad
	.RS 12n
	Prioritize requeued I/O
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzio_taskq_batch_pct\fR (uint)
	.ad
	.RS 12n
	Percentage of online CPUs (or CPU cores, etc) which will run a worker thread
	for I/O. These workers are responsible for I/O work such as compression and
	checksum calculations. Fractional number of CPUs will be rounded down.
	.sp
	-The default value of 75 was chosen to avoid using all CPUs which can result in
	-latency issues and inconsistent application performance, especially when high
	-compression is enabled.
	+The default value of 80 was chosen to avoid using all CPUs which can result in
	+latency issues and inconsistent application performance, especially when slower
	+compression and/or checksumming is enabled.
	.sp
	-Default value: \fB75\fR.
	+Default value: \fB80\fR.
	+.RE
	+
	+.sp
	+.ne 2
	+.na
	+\fBzio_taskq_batch_tpq\fR (uint)
	+.ad
	+.RS 12n
	+Number of worker threads per taskq. Lower value improves I/O ordering and
	+CPU utilization, while higher reduces lock contention.
	+.sp
	+By default about 6 worker threads per taskq, depending on system size.
	+.sp
	+Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzvol_inhibit_dev\fR (uint)
	.ad
	.RS 12n
	Do not create zvol device nodes. This may slightly improve startup time on
	systems with a very large number of zvols.
	.sp
	Use \fB1\fR for yes and \fB0\fR for no (default).
	.RE

	.sp
	.ne 2
	.na
	\fBzvol_major\fR (uint)
	.ad
	.RS 12n
	Major number for zvol block devices
	.sp
	Default value: \fB230\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzvol_max_discard_blocks\fR (ulong)
	.ad
	.RS 12n
	Discard (aka TRIM) operations done on zvols will be done in batches of this
	many blocks, where block size is determined by the \fBvolblocksize\fR property
	of a zvol.
	.sp
	Default value: \fB16,384\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzvol_prefetch_bytes\fR (uint)
	.ad
	.RS 12n
	When adding a zvol to the system prefetch \fBzvol_prefetch_bytes\fR
	from the start and end of the volume. Prefetching these regions
	of the volume is desirable because they are likely to be accessed
	immediately by \fBblkid(8)\fR or by the kernel scanning for a partition
	table.
	.sp
	Default value: \fB131,072\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzvol_request_sync\fR (uint)
	.ad
	.RS 12n
	When processing I/O requests for a zvol submit them synchronously. This
	effectively limits the queue depth to 1 for each I/O submitter. When set
	to 0 requests are handled asynchronously by a thread pool. The number of
	requests which can be handled concurrently is controller by \fBzvol_threads\fR.
	.sp
	Default value: \fB0\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzvol_threads\fR (uint)
	.ad
	.RS 12n
	Max number of threads which can handle zvol I/O requests concurrently.
	.sp
	Default value: \fB32\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBzvol_volmode\fR (uint)
	.ad
	.RS 12n
	Defines zvol block devices behaviour when \fBvolmode\fR is set to \fBdefault\fR.
	Valid values are \fB1\fR (full), \fB2\fR (dev) and \fB3\fR (none).
	.sp
	Default value: \fB1\fR.
	.RE

	.SH ZFS I/O SCHEDULER
	ZFS issues I/O operations to leaf vdevs to satisfy and complete I/Os.
	The I/O scheduler determines when and in what order those operations are
	issued. The I/O scheduler divides operations into five I/O classes
	prioritized in the following order: sync read, sync write, async read,
	async write, and scrub/resilver. Each queue defines the minimum and
	maximum number of concurrent operations that may be issued to the
	device. In addition, the device has an aggregate maximum,
	\fBzfs_vdev_max_active\fR. Note that the sum of the per-queue minimums
	must not exceed the aggregate maximum. If the sum of the per-queue
	maximums exceeds the aggregate maximum, then the number of active I/Os
	may reach \fBzfs_vdev_max_active\fR, in which case no further I/Os will
	be issued regardless of whether all per-queue minimums have been met.
	.sp
	For many physical devices, throughput increases with the number of
	concurrent operations, but latency typically suffers. Further, physical
	devices typically have a limit at which more concurrent operations have no
	effect on throughput or can actually cause it to decrease.
	.sp
	The scheduler selects the next operation to issue by first looking for an
	I/O class whose minimum has not been satisfied. Once all are satisfied and
	the aggregate maximum has not been hit, the scheduler looks for classes
	whose maximum has not been satisfied. Iteration through the I/O classes is
	done in the order specified above. No further operations are issued if the
	aggregate maximum number of concurrent operations has been hit or if there
	are no operations queued for an I/O class that has not hit its maximum.
	Every time an I/O is queued or an operation completes, the I/O scheduler
	looks for new operations to issue.
	.sp
	In general, smaller max_active's will lead to lower latency of synchronous
	operations. Larger max_active's may lead to higher overall throughput,
	depending on underlying storage.
	.sp
	The ratio of the queues' max_actives determines the balance of performance
	between reads, writes, and scrubs. E.g., increasing
	\fBzfs_vdev_scrub_max_active\fR will cause the scrub or resilver to complete
	more quickly, but reads and writes to have higher latency and lower throughput.
	.sp
	All I/O classes have a fixed maximum number of outstanding operations
	except for the async write class. Asynchronous writes represent the data
	that is committed to stable storage during the syncing stage for
	transaction groups. Transaction groups enter the syncing state
	periodically so the number of queued async writes will quickly burst up
	and then bleed down to zero. Rather than servicing them as quickly as
	possible, the I/O scheduler changes the maximum number of active async
	write I/Os according to the amount of dirty data in the pool. Since
	both throughput and latency typically increase with the number of
	concurrent operations issued to physical devices, reducing the
	burstiness in the number of concurrent operations also stabilizes the
	response time of operations from other -- and in particular synchronous
	-- queues. In broad strokes, the I/O scheduler will issue more
	concurrent operations from the async write queue as there's more dirty
	data in the pool.
	.sp
	Async Writes
	.sp
	The number of concurrent operations issued for the async write I/O class
	follows a piece-wise linear function defined by a few adjustable points.
	.nf

	\| o---------\| <-- zfs_vdev_async_write_max_active
	^ \| /^ \|
	\| \| / \| \|
	active \| / \| \|
	I/O \| / \| \|
	count \| / \| \|
	\| / \| \|
	\|-------o \| \| <-- zfs_vdev_async_write_min_active
	0\|_______^______\|_________\|
	0% \| \| 100% of zfs_dirty_data_max
	\| \|
	\| `-- zfs_vdev_async_write_active_max_dirty_percent
	`--------- zfs_vdev_async_write_active_min_dirty_percent

	.fi
	Until the amount of dirty data exceeds a minimum percentage of the dirty
	data allowed in the pool, the I/O scheduler will limit the number of
	concurrent operations to the minimum. As that threshold is crossed, the
	number of concurrent operations issued increases linearly to the maximum at
	the specified maximum percentage of the dirty data allowed in the pool.
	.sp
	Ideally, the amount of dirty data on a busy pool will stay in the sloped
	part of the function between \fBzfs_vdev_async_write_active_min_dirty_percent\fR
	and \fBzfs_vdev_async_write_active_max_dirty_percent\fR. If it exceeds the
	maximum percentage, this indicates that the rate of incoming data is
	greater than the rate that the backend storage can handle. In this case, we
	must further throttle incoming writes, as described in the next section.

	.SH ZFS TRANSACTION DELAY
	We delay transactions when we've determined that the backend storage
	isn't able to accommodate the rate of incoming writes.
	.sp
	If there is already a transaction waiting, we delay relative to when
	that transaction will finish waiting. This way the calculated delay time
	is independent of the number of threads concurrently executing
	transactions.
	.sp
	If we are the only waiter, wait relative to when the transaction
	started, rather than the current time. This credits the transaction for
	"time already served", e.g. reading indirect blocks.
	.sp
	The minimum time for a transaction to take is calculated as:
	.nf
	min_time = zfs_delay_scale * (dirty - min) / (max - dirty)
	min_time is then capped at 100 milliseconds.
	.fi
	.sp
	The delay has two degrees of freedom that can be adjusted via tunables. The
	percentage of dirty data at which we start to delay is defined by
	\fBzfs_delay_min_dirty_percent\fR. This should typically be at or above
	\fBzfs_vdev_async_write_active_max_dirty_percent\fR so that we only start to
	delay after writing at full speed has failed to keep up with the incoming write
	rate. The scale of the curve is defined by \fBzfs_delay_scale\fR. Roughly speaking,
	this variable determines the amount of delay at the midpoint of the curve.
	.sp
	.nf
	delay
	10ms +-------------------------------------------------------------*+
	\| *\|
	9ms + *+
	\| *\|
	8ms + *+
	\| * \|
	7ms + * +
	\| * \|
	6ms + * +
	\| * \|
	5ms + * +
	\| * \|
	4ms + * +
	\| * \|
	3ms + * +
	\| * \|
	2ms + (midpoint) * +
	\| \| ** \|
	1ms + v *** +
	\| zfs_delay_scale ----------> ******** \|
	0 +-------------------------------------*********----------------+
	0% <- zfs_dirty_data_max -> 100%
	.fi
	.sp
	Note that since the delay is added to the outstanding time remaining on the
	most recent transaction, the delay is effectively the inverse of IOPS.
	Here the midpoint of 500us translates to 2000 IOPS. The shape of the curve
	was chosen such that small changes in the amount of accumulated dirty data
	in the first 3/4 of the curve yield relatively small differences in the
	amount of delay.
	.sp
	The effects can be easier to understand when the amount of delay is
	represented on a log scale:
	.sp
	.nf
	delay
	100ms +-------------------------------------------------------------++
	+ +
	\| \|
	+ *+
	10ms + *+
	+ ** +
	\| (midpoint) ** \|
	+ \| ** +
	1ms + v **** +
	+ zfs_delay_scale ----------> ***** +
	\| **** \|
	+ **** +
	100us + ** +
	+ * +
	\| * \|
	+ * +
	10us + * +
	+ +
	\| \|
	+ +
	+--------------------------------------------------------------+
	0% <- zfs_dirty_data_max -> 100%
	.fi
	.sp
	Note here that only as the amount of dirty data approaches its limit does
	the delay start to increase rapidly. The goal of a properly tuned system
	should be to keep the amount of dirty data out of that range by first
	ensuring that the appropriate limits are set for the I/O scheduler to reach
	optimal throughput on the backend storage, and then by changing the value
	of \fBzfs_delay_scale\fR to increase the steepness of the curve.
	diff --git a/sys/contrib/openzfs/man/man5/zpool-features.5 b/sys/contrib/openzfs/man/man5/zpool-features.5
	index c56b31e2d715..c97870dbbe82 100644
	--- a/sys/contrib/openzfs/man/man5/zpool-features.5
	+++ b/sys/contrib/openzfs/man/man5/zpool-features.5
	@@ -1,1066 +1,1077 @@
	'\" te
	.\" Copyright (c) 2012, 2018 by Delphix. All rights reserved.
	.\" Copyright (c) 2013 by Saso Kiselkov. All rights reserved.
	.\" Copyright (c) 2014, Joyent, Inc. All rights reserved.
	.\" 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]
	.\" Copyright (c) 2019, Klara Inc.
	.\" Copyright (c) 2019, Allan Jude
	.\" Copyright (c) 2021, Colm Buckley <colm@tuatha.org>
	.TH ZPOOL-FEATURES 5 "Aug 24, 2020" OpenZFS
	.SH NAME
	zpool\-features \- ZFS pool feature descriptions
	.SH DESCRIPTION
	.sp
	.LP
	ZFS pool on\-disk format versions are specified via "features" which replace
	the old on\-disk format numbers (the last supported on\-disk format number is
	28). To enable a feature on a pool use the \fBupgrade\fR subcommand of the
	zpool(8) command, or set the \fBfeature@\fR\fIfeature_name\fR property
	to \fBenabled\fR. Please also see the \fB"Compatibility feature sets"\fR
	section for information on how sets of features may be enabled together.
	.sp
	.LP
	The pool format does not affect file system version compatibility or the ability
	to send file systems between pools.
	.sp
	.LP
	Since most features can be enabled independently of each other the on\-disk
	format of the pool is specified by the set of all features marked as
	\fBactive\fR on the pool. If the pool was created by another software version
	this set may include unsupported features.
	.SS "Identifying features"
	.sp
	.LP
	Every feature has a GUID of the form \fIcom.example:feature_name\fR. The
	reversed DNS name ensures that the feature's GUID is unique across all ZFS
	implementations. When unsupported features are encountered on a pool they will
	be identified by their GUIDs. Refer to the documentation for the ZFS
	implementation that created the pool for information about those features.
	.sp
	.LP
	Each supported feature also has a short name. By convention a feature's short
	name is the portion of its GUID which follows the ':' (e.g.
	\fIcom.example:feature_name\fR would have the short name \fIfeature_name\fR),
	however a feature's short name may differ across ZFS implementations if
	following the convention would result in name conflicts.
	.SS "Feature states"
	.sp
	.LP
	Features can be in one of three states:
	.sp
	.ne 2
	.na
	\fBactive\fR
	.ad
	.RS 12n
	This feature's on\-disk format changes are in effect on the pool. Support for
	this feature is required to import the pool in read\-write mode. If this
	feature is not read-only compatible, support is also required to import the pool
	in read\-only mode (see "Read\-only compatibility").
	.RE

	.sp
	.ne 2
	.na
	\fBenabled\fR
	.ad
	.RS 12n
	An administrator has marked this feature as enabled on the pool, but the
	feature's on\-disk format changes have not been made yet. The pool can still be
	imported by software that does not support this feature, but changes may be made
	to the on\-disk format at any time which will move the feature to the
	\fBactive\fR state. Some features may support returning to the \fBenabled\fR
	state after becoming \fBactive\fR. See feature\-specific documentation for
	details.
	.RE

	.sp
	.ne 2
	.na
	\fBdisabled\fR
	.ad
	.RS 12n
	This feature's on\-disk format changes have not been made and will not be made
	unless an administrator moves the feature to the \fBenabled\fR state. Features
	cannot be disabled once they have been enabled.
	.RE

	.sp
	.LP
	The state of supported features is exposed through pool properties of the form
	\fIfeature@short_name\fR.
	.SS "Read\-only compatibility"
	.sp
	.LP
	Some features may make on\-disk format changes that do not interfere with other
	software's ability to read from the pool. These features are referred to as
	"read\-only compatible". If all unsupported features on a pool are read\-only
	compatible, the pool can be imported in read\-only mode by setting the
	\fBreadonly\fR property during import (see zpool(8) for details on
	importing pools).
	.SS "Unsupported features"
	.sp
	.LP
	For each unsupported feature enabled on an imported pool a pool property
	named \fIunsupported@feature_name\fR will indicate why the import was allowed
	despite the unsupported feature. Possible values for this property are:

	.sp
	.ne 2
	.na
	\fBinactive\fR
	.ad
	.RS 12n
	The feature is in the \fBenabled\fR state and therefore the pool's on\-disk
	format is still compatible with software that does not support this feature.
	.RE

	.sp
	.ne 2
	.na
	\fBreadonly\fR
	.ad
	.RS 12n
	The feature is read\-only compatible and the pool has been imported in
	read\-only mode.
	.RE

	.SS "Feature dependencies"
	.sp
	.LP
	Some features depend on other features being enabled in order to function
	properly. Enabling a feature will automatically enable any features it
	depends on.

	.SS "Compatibility feature sets"
	.sp
	.LP
	It is sometimes necessary for a pool to maintain compatibility with a
	specific on\-disk format, by enabling and disabling particular features. The
	\fBcompatibility\fR feature facilitates this by allowing feature sets to
	be read from text files. When set to \fBoff\fR (the default); compatibility
	feature sets are disabled (ie: all features are enabled); when set to
	\fBlegacy\fR; no features are enabled. When set to a comma\-separated list
	of filenames (each filename may either be an absolute path, or relative to
	\fB/etc/zfs/compatibility.d\fR or \fB/usr/share/zfs/compatibility.d\fR)
	the lists of requested features are read from those files, separated by
	whitespace and/or commas. Only features present in all files are enabled.
	.LP
	Simple sanity checks are applied to the files; they must be between 1 and
	16,384 bytes in size, and must end with a newline character.
	.LP
	The requested features are applied when a pool is created using
	\fBzpool create \-o compatibility=...\fR and controls which features are
	enabled when using \fBzpool upgrade\fR. \fBzpool status\fR
	will not show a warning about disabled features which are not part
	of the requested feature set.
	.LP
	+The special value \fBlegacy\fR prevents any features from being enabled,
	+either via \fBzpool upgrade\fR or via \fBzpool set feature@XX=enabled\fR.
	+This setting also prevents pools from being upgraded to newer on-disk
	+versions. This is a safety measure to prevent new features from being
	+accidentally enabled, breaking compatibility.
	+.LP
	By convention, compatibility files in \fB/usr/share/zfs/compatibility.d\fR
	are provided by the distribution package, and include feature sets
	-supported by important versions of popular distribtions, and feature
	+supported by important versions of popular distributions, and feature
	sets commonly supported at the start of each year. Compatibility files
	in \fB/etc/zfs/compatibility.d\fR, if present, will take precedence over
	files with the same name in \fB/usr/share/zfs/compatibility.d\fR.
	.LP
	+If an unrecognized feature is found in these files, an error message will
	+be shown. If the unrecognized feature is in a file in
	+\fB/etc/zfs/compatibility.d\fR, this is treated as an error and processing
	+will stop. If the unrecognized feature is under
	+\fB/usr/share/zfs/compatibility.d\fR, this is treated as a warning and
	+processing will continue. This difference is to allow distributions to
	+include features which might not be recognized by the currently-installed
	+binaries.
	+.LP
	Compatibility files may include comments; any text from \fB#\fR to the end
	of the line is ignored.
	.LP
	\fBExample:\fR
	.EX
	# \fBcat /usr/share/zfs/compatibility.d/grub2\fR
	# Features which are supported by GRUB2
	async_destroy
	bookmarks
	embedded_data
	empty_bpobj
	enabled_txg
	extensible_dataset
	filesystem_limits
	hole_birth
	large_blocks
	lz4_compress
	spacemap_histogram

	# \fBzpool create \-o compatibility=grub2 bootpool vdev\fR
	.EE
	.LP
	See \fBzpool\-create(8)\fR and \fBzpool\-upgrade(8)\fR for more information
	on how these commands are affected by feature sets.
	.SH FEATURES
	.sp
	.LP
	The following features are supported on this system:

	.sp
	.ne 2
	.na
	\fBallocation_classes\fR
	.ad
	.RS 4n
	.TS
	l l .
	GUID org.zfsonlinux:allocation_classes
	READ\-ONLY COMPATIBLE yes
	DEPENDENCIES none
	.TE

	This feature enables support for separate allocation classes.

	This feature becomes \fBactive\fR when a dedicated allocation class vdev
	(dedup or special) is created with the \fBzpool create\fR or \fBzpool add\fR
	subcommands. With device removal, it can be returned to the \fBenabled\fR
	state if all the dedicated allocation class vdevs are removed.
	.RE

	.sp
	.ne 2
	.na
	\fBasync_destroy\fR
	.ad
	.RS 4n
	.TS
	l l .
	GUID com.delphix:async_destroy
	READ\-ONLY COMPATIBLE yes
	DEPENDENCIES none
	.TE

	Destroying a file system requires traversing all of its data in order to
	return its used space to the pool. Without \fBasync_destroy\fR the file system
	is not fully removed until all space has been reclaimed. If the destroy
	operation is interrupted by a reboot or power outage the next attempt to open
	the pool will need to complete the destroy operation synchronously.

	When \fBasync_destroy\fR is enabled the file system's data will be reclaimed
	by a background process, allowing the destroy operation to complete without
	traversing the entire file system. The background process is able to resume
	interrupted destroys after the pool has been opened, eliminating the need
	to finish interrupted destroys as part of the open operation. The amount
	of space remaining to be reclaimed by the background process is available
	through the \fBfreeing\fR property.

	This feature is only \fBactive\fR while \fBfreeing\fR is non\-zero.
	.RE

	.sp
	.ne 2
	.na
	\fBbookmarks\fR
	.ad
	.RS 4n
	.TS
	l l .
	GUID com.delphix:bookmarks
	READ\-ONLY COMPATIBLE yes
	DEPENDENCIES extensible_dataset
	.TE

	This feature enables use of the \fBzfs bookmark\fR subcommand.

	This feature is \fBactive\fR while any bookmarks exist in the pool.
	All bookmarks in the pool can be listed by running
	\fBzfs list -t bookmark -r \fIpoolname\fR\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBbookmark_v2\fR
	.ad
	.RS 4n
	.TS
	l l .
	GUID com.datto:bookmark_v2
	READ\-ONLY COMPATIBLE no
	DEPENDENCIES bookmark, extensible_dataset
	.TE

	This feature enables the creation and management of larger bookmarks which are
	needed for other features in ZFS.

	This feature becomes \fBactive\fR when a v2 bookmark is created and will be
	returned to the \fBenabled\fR state when all v2 bookmarks are destroyed.
	.RE

	.sp
	.ne 2
	.na
	\fBbookmark_written\fR
	.ad
	.RS 4n
	.TS
	l l .
	GUID com.delphix:bookmark_written
	READ\-ONLY COMPATIBLE no
	DEPENDENCIES bookmark, extensible_dataset, bookmark_v2
	.TE

	This feature enables additional bookmark accounting fields, enabling the
	written#<bookmark> property (space written since a bookmark) and estimates of
	send stream sizes for incrementals from bookmarks.

	This feature becomes \fBactive\fR when a bookmark is created and will be
	returned to the \fBenabled\fR state when all bookmarks with these fields are destroyed.
	.RE

	.sp
	.ne 2
	.na
	\fBdevice_rebuild\fR
	.ad
	.RS 4n
	.TS
	l l .
	GUID org.openzfs:device_rebuild
	READ\-ONLY COMPATIBLE yes
	DEPENDENCIES none
	.TE

	This feature enables the ability for the \fBzpool attach\fR and \fBzpool
	replace\fR subcommands to perform sequential reconstruction (instead of
	healing reconstruction) when resilvering.

	Sequential reconstruction resilvers a device in LBA order without immediately
	verifying the checksums. Once complete a scrub is started which then verifies
	the checksums. This approach allows full redundancy to be restored to the pool
	in the minimum amount of time. This two phase approach will take longer than a
	healing resilver when the time to verify the checksums is included. However,
	unless there is additional pool damage no checksum errors should be reported
	by the scrub. This feature is incompatible with raidz configurations.

	This feature becomes \fBactive\fR while a sequential resilver is in progress,
	and returns to \fBenabled\fR when the resilver completes.
	.RE

	.sp
	.ne 2
	.na
	\fBdevice_removal\fR
	.ad
	.RS 4n
	.TS
	l l .
	GUID com.delphix:device_removal
	READ\-ONLY COMPATIBLE no
	DEPENDENCIES none
	.TE

	This feature enables the \fBzpool remove\fR subcommand to remove top-level
	vdevs, evacuating them to reduce the total size of the pool.

	This feature becomes \fBactive\fR when the \fBzpool remove\fR subcommand is used
	on a top-level vdev, and will never return to being \fBenabled\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBdraid\fR
	.ad
	.RS 4n
	.TS
	l l .
	GUID org.openzfs:draid
	READ\-ONLY COMPATIBLE no
	DEPENDENCIES none
	.TE

	This feature enables use of the \fBdraid\fR vdev type. dRAID is a variant
	of raidz which provides integrated distributed hot spares that allow faster
	resilvering while retaining the benefits of raidz. Data, parity, and spare
	space are organized in redundancy groups and distributed evenly over all of
	the devices.

	This feature becomes \fBactive\fR when creating a pool which uses the
	\fBdraid\fR vdev type, or when adding a new \fBdraid\fR vdev to an
	existing pool.
	.RE

	.sp
	.ne 2
	.na
	\fBedonr\fR
	.ad
	.RS 4n
	.TS
	l l .
	GUID org.illumos:edonr
	READ\-ONLY COMPATIBLE no
	DEPENDENCIES extensible_dataset
	.TE

	This feature enables the use of the Edon-R hash algorithm for checksum,
	including for nopwrite (if compression is also enabled, an overwrite of
	a block whose checksum matches the data being written will be ignored).
	In an abundance of caution, Edon-R requires verification when used with
	dedup: \fBzfs set dedup=edonr,verify\fR. See \fBzfs\fR(8).

	Edon-R is a very high-performance hash algorithm that was part
	of the NIST SHA-3 competition. It provides extremely high hash
	performance (over 350% faster than SHA-256), but was not selected
	because of its unsuitability as a general purpose secure hash algorithm.
	This implementation utilizes the new salted checksumming functionality
	in ZFS, which means that the checksum is pre-seeded with a secret
	256-bit random key (stored on the pool) before being fed the data block
	to be checksummed. Thus the produced checksums are unique to a given
	pool.

	When the \fBedonr\fR feature is set to \fBenabled\fR, the administrator
	can turn on the \fBedonr\fR checksum on any dataset using the
	\fBzfs set checksum=edonr\fR. See zfs(8). This feature becomes
	\fBactive\fR once a \fBchecksum\fR property has been set to \fBedonr\fR,
	and will return to being \fBenabled\fR once all filesystems that have
	ever had their checksum set to \fBedonr\fR are destroyed.

	FreeBSD does not support the \fBedonr\fR feature.
	.RE

	.sp
	.ne 2
	.na
	\fBembedded_data\fR
	.ad
	.RS 4n
	.TS
	l l .
	GUID com.delphix:embedded_data
	READ\-ONLY COMPATIBLE no
	DEPENDENCIES none
	.TE

	This feature improves the performance and compression ratio of
	highly-compressible blocks. Blocks whose contents can compress to 112 bytes
	or smaller can take advantage of this feature.

	When this feature is enabled, the contents of highly-compressible blocks are
	stored in the block "pointer" itself (a misnomer in this case, as it contains
	the compressed data, rather than a pointer to its location on disk). Thus
	the space of the block (one sector, typically 512 bytes or 4KB) is saved,
	and no additional i/o is needed to read and write the data block.

	This feature becomes \fBactive\fR as soon as it is enabled and will
	never return to being \fBenabled\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBempty_bpobj\fR
	.ad
	.RS 4n
	.TS
	l l .
	GUID com.delphix:empty_bpobj
	READ\-ONLY COMPATIBLE yes
	DEPENDENCIES none
	.TE

	This feature increases the performance of creating and using a large
	number of snapshots of a single filesystem or volume, and also reduces
	the disk space required.

	When there are many snapshots, each snapshot uses many Block Pointer
	Objects (bpobj's) to track blocks associated with that snapshot.
	However, in common use cases, most of these bpobj's are empty. This
	feature allows us to create each bpobj on-demand, thus eliminating the
	empty bpobjs.

	This feature is \fBactive\fR while there are any filesystems, volumes,
	or snapshots which were created after enabling this feature.
	.RE

	.sp
	.ne 2
	.na
	\fBenabled_txg\fR
	.ad
	.RS 4n
	.TS
	l l .
	GUID com.delphix:enabled_txg
	READ\-ONLY COMPATIBLE yes
	DEPENDENCIES none
	.TE

	Once this feature is enabled ZFS records the transaction group number
	in which new features are enabled. This has no user-visible impact,
	but other features may depend on this feature.

	This feature becomes \fBactive\fR as soon as it is enabled and will
	never return to being \fBenabled\fB.
	.RE

	.sp
	.ne 2
	.na
	\fBencryption\fR
	.ad
	.RS 4n
	.TS
	l l .
	GUID com.datto:encryption
	READ\-ONLY COMPATIBLE no
	DEPENDENCIES bookmark_v2, extensible_dataset
	.TE

	This feature enables the creation and management of natively encrypted datasets.

	This feature becomes \fBactive\fR when an encrypted dataset is created and will
	be returned to the \fBenabled\fR state when all datasets that use this feature
	are destroyed.
	.RE

	.sp
	.ne 2
	.na
	\fBextensible_dataset\fR
	.ad
	.RS 4n
	.TS
	l l .
	GUID com.delphix:extensible_dataset
	READ\-ONLY COMPATIBLE no
	DEPENDENCIES none
	.TE

	This feature allows more flexible use of internal ZFS data structures,
	and exists for other features to depend on.

	This feature will be \fBactive\fR when the first dependent feature uses it,
	and will be returned to the \fBenabled\fR state when all datasets that use
	this feature are destroyed.
	.RE

	.sp
	.ne 2
	.na
	\fBfilesystem_limits\fR
	.ad
	.RS 4n
	.TS
	l l .
	GUID com.joyent:filesystem_limits
	READ\-ONLY COMPATIBLE yes
	DEPENDENCIES extensible_dataset
	.TE

	This feature enables filesystem and snapshot limits. These limits can be used
	to control how many filesystems and/or snapshots can be created at the point in
	the tree on which the limits are set.

	This feature is \fBactive\fR once either of the limit properties has been
	set on a dataset. Once activated the feature is never deactivated.
	.RE

	.sp
	.ne 2
	.na
	\fBhole_birth\fR
	.ad
	.RS 4n
	.TS
	l l .
	GUID com.delphix:hole_birth
	READ\-ONLY COMPATIBLE no
	DEPENDENCIES enabled_txg
	.TE

	This feature has/had bugs, the result of which is that, if you do a
	\fBzfs send -i\fR (or \fB-R\fR, since it uses \fB-i\fR) from an affected
	dataset, the receiver will not see any checksum or other errors, but the
	resulting destination snapshot will not match the source. Its use by
	\fBzfs send -i\fR has been disabled by default. See the
	\fBsend_holes_without_birth_time\fR module parameter in
	zfs-module-parameters(5).

	This feature improves performance of incremental sends (\fBzfs send -i\fR)
	and receives for objects with many holes. The most common case of
	hole-filled objects is zvols.

	An incremental send stream from snapshot \fBA\fR to snapshot \fBB\fR
	contains information about every block that changed between \fBA\fR and
	\fBB\fR. Blocks which did not change between those snapshots can be
	identified and omitted from the stream using a piece of metadata called
	the 'block birth time', but birth times are not recorded for holes (blocks
	filled only with zeroes). Since holes created after \fBA\fR cannot be
	distinguished from holes created before \fBA\fR, information about every
	hole in the entire filesystem or zvol is included in the send stream.

	For workloads where holes are rare this is not a problem. However, when
	incrementally replicating filesystems or zvols with many holes (for
	example a zvol formatted with another filesystem) a lot of time will
	be spent sending and receiving unnecessary information about holes that
	already exist on the receiving side.

	Once the \fBhole_birth\fR feature has been enabled the block birth times
	of all new holes will be recorded. Incremental sends between snapshots
	created after this feature is enabled will use this new metadata to avoid
	sending information about holes that already exist on the receiving side.

	This feature becomes \fBactive\fR as soon as it is enabled and will
	never return to being \fBenabled\fB.
	.RE

	.sp
	.ne 2
	.na
	\fBlarge_blocks\fR
	.ad
	.RS 4n
	.TS
	l l .
	GUID org.open-zfs:large_blocks
	READ\-ONLY COMPATIBLE no
	DEPENDENCIES extensible_dataset
	.TE

	The \fBlarge_block\fR feature allows the record size on a dataset to be
	set larger than 128KB.

	This feature becomes \fBactive\fR once a dataset contains a file with
	a block size larger than 128KB, and will return to being \fBenabled\fR once all
	filesystems that have ever had their recordsize larger than 128KB are destroyed.
	.RE

	.sp
	.ne 2
	.na
	\fBlarge_dnode\fR
	.ad
	.RS 4n
	.TS
	l l .
	GUID org.zfsonlinux:large_dnode
	READ\-ONLY COMPATIBLE no
	DEPENDENCIES extensible_dataset
	.TE

	The \fBlarge_dnode\fR feature allows the size of dnodes in a dataset to be
	set larger than 512B.

	This feature becomes \fBactive\fR once a dataset contains an object with
	a dnode larger than 512B, which occurs as a result of setting the
	\fBdnodesize\fR dataset property to a value other than \fBlegacy\fR. The
	feature will return to being \fBenabled\fR once all filesystems that
	have ever contained a dnode larger than 512B are destroyed. Large dnodes
	allow more data to be stored in the bonus buffer, thus potentially
	improving performance by avoiding the use of spill blocks.
	.RE

	.sp
	.ne 2
	.na
	\fB\fBlivelist\fR\fR
	.ad
	.RS 4n
	.TS
	l l .
	GUID com.delphix:livelist
	READ\-ONLY COMPATIBLE yes
	DEPENDENCIES none
	.TE
	This feature allows clones to be deleted faster than the traditional method
	when a large number of random/sparse writes have been made to the clone.
	All blocks allocated and freed after a clone is created are tracked by the
	the clone's livelist which is referenced during the deletion of the clone.
	The feature is activated when a clone is created and remains active until all
	clones have been destroyed.
	.RE

	.sp
	.ne 2
	.na
	\fBlog_spacemap\fR
	.ad
	.RS 4n
	.TS
	l l .
	GUID com.delphix:log_spacemap
	READ\-ONLY COMPATIBLE yes
	DEPENDENCIES com.delphix:spacemap_v2
	.TE

	This feature improves performance for heavily-fragmented pools,
	especially when workloads are heavy in random-writes. It does so by
	logging all the metaslab changes on a single spacemap every TXG
	instead of scattering multiple writes to all the metaslab spacemaps.

	This feature becomes \fBactive\fR as soon as it is enabled and will never
	return to being \fBenabled\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBlz4_compress\fR
	.ad
	.RS 4n
	.TS
	l l .
	GUID org.illumos:lz4_compress
	READ\-ONLY COMPATIBLE no
	DEPENDENCIES none
	.TE

	\fBlz4\fR is a high-performance real-time compression algorithm that
	features significantly faster compression and decompression as well as a
	higher compression ratio than the older \fBlzjb\fR compression.
	Typically, \fBlz4\fR compression is approximately 50% faster on
	compressible data and 200% faster on incompressible data than
	\fBlzjb\fR. It is also approximately 80% faster on decompression, while
	giving approximately 10% better compression ratio.

	When the \fBlz4_compress\fR feature is set to \fBenabled\fR, the
	administrator can turn on \fBlz4\fR compression on any dataset on the
	pool using the zfs(8) command. Please note that doing so will
	immediately activate the \fBlz4_compress\fR feature on the underlying
	pool using the zfs(8) command. Also, all newly written metadata
	will be compressed with \fBlz4\fR algorithm. Since this feature is not
	read-only compatible, this operation will render the pool unimportable
	on systems without support for the \fBlz4_compress\fR feature.

	-Booting off of \fBlz4\fR-compressed root pools is supported.
	-
	This feature becomes \fBactive\fR as soon as it is enabled and will
	never return to being \fBenabled\fB.
	.RE

	.sp
	.ne 2
	.na
	\fBmulti_vdev_crash_dump\fR
	.ad
	.RS 4n
	.TS
	l l .
	GUID com.joyent:multi_vdev_crash_dump
	READ\-ONLY COMPATIBLE no
	DEPENDENCIES none
	.TE

	This feature allows a dump device to be configured with a pool comprised
	of multiple vdevs. Those vdevs may be arranged in any mirrored or raidz
	configuration.

	When the \fBmulti_vdev_crash_dump\fR feature is set to \fBenabled\fR,
	the administrator can use the \fBdumpadm\fR(1M) command to configure a
	dump device on a pool comprised of multiple vdevs.

	Under FreeBSD and Linux this feature is registered for compatibility but not
	used. New pools created under FreeBSD and Linux will have the feature
	\fBenabled\fR but will never transition to \fB\fBactive\fR. This functionality
	is not required in order to support crash dumps under FreeBSD and Linux.
	Existing pools where this feature is \fB\fBactive\fR can be imported.
	.RE

	.sp
	.ne 2
	.na
	\fBobsolete_counts\fR
	.ad
	.RS 4n
	.TS
	l l .
	GUID com.delphix:obsolete_counts
	READ\-ONLY COMPATIBLE yes
	DEPENDENCIES device_removal
	.TE

	This feature is an enhancement of device_removal, which will over time
	reduce the memory used to track removed devices. When indirect blocks
	are freed or remapped, we note that their part of the indirect mapping
	is "obsolete", i.e. no longer needed.

	This feature becomes \fBactive\fR when the \fBzpool remove\fR subcommand is
	used on a top-level vdev, and will never return to being \fBenabled\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBproject_quota\fR
	.ad
	.RS 4n
	.TS
	l l .
	GUID org.zfsonlinux:project_quota
	READ\-ONLY COMPATIBLE yes
	DEPENDENCIES extensible_dataset
	.TE

	This feature allows administrators to account the spaces and objects usage
	information against the project identifier (ID).

	The project ID is new object-based attribute. When upgrading an existing
	filesystem, object without project ID attribute will be assigned a zero
	project ID. After this feature is enabled, newly created object will inherit
	its parent directory's project ID if the parent inherit flag is set (via
	\fBchattr +/-P\fR or \fBzfs project [-s\|-C]\fR). Otherwise, the new object's
	project ID will be set as zero. An object's project ID can be changed at
	anytime by the owner (or privileged user) via \fBchattr -p $prjid\fR or
	\fBzfs project -p $prjid\fR.

	This feature will become \fBactive\fR as soon as it is enabled and will never
	return to being \fBdisabled\fR. Each filesystem will be upgraded automatically
	when remounted or when new file is created under that filesystem. The upgrade
	can also be triggered on filesystems via `zfs set version=current <pool/fs>`.
	The upgrade process runs in the background and may take a while to complete
	for the filesystems containing a large number of files.
	.RE

	.sp
	.ne 2
	.na
	\fB\fBredaction_bookmarks\fR\fR
	.ad
	.RS 4n
	.TS
	l l .
	GUID com.delphix:redaction_bookmarks
	READ\-ONLY COMPATIBLE no
	DEPENDENCIES bookmarks, extensible_dataset
	.TE

	This feature enables the use of the redacted zfs send. Redacted \fBzfs send\fR
	creates redaction bookmarks, which store the list of blocks redacted by the
	send that created them. For more information about redacted send,
	see \fBzfs\fR(8).

	.RE

	.sp
	.ne 2
	.na
	\fB\fBredacted_datasets\fR\fR
	.ad
	.RS 4n
	.TS
	l l .
	GUID com.delphix:redacted_datasets
	READ\-ONLY COMPATIBLE no
	DEPENDENCIES extensible_dataset
	.TE

	This feature enables the receiving of redacted zfs send streams. Redacted zfs
	send streams create redacted datasets when received. These datasets are
	missing some of their blocks, and so cannot be safely mounted, and their
	contents cannot be safely read. For more information about redacted receive,
	see \fBzfs\fR(8).
	.RE

	.sp
	.ne 2
	.na
	\fBresilver_defer\fR
	.ad
	.RS 4n
	.TS
	l l .
	GUID com.datto:resilver_defer
	READ\-ONLY COMPATIBLE yes
	DEPENDENCIES none
	.TE

	This feature allows zfs to postpone new resilvers if an existing one is already
	in progress. Without this feature, any new resilvers will cause the currently
	running one to be immediately restarted from the beginning.

	This feature becomes \fBactive\fR once a resilver has been deferred, and
	returns to being \fBenabled\fR when the deferred resilver begins.
	.RE

	.sp
	.ne 2
	.na
	\fBsha512\fR
	.ad
	.RS 4n
	.TS
	l l .
	GUID org.illumos:sha512
	READ\-ONLY COMPATIBLE no
	DEPENDENCIES extensible_dataset
	.TE

	This feature enables the use of the SHA-512/256 truncated hash algorithm
	(FIPS 180-4) for checksum and dedup. The native 64-bit arithmetic of
	SHA-512 provides an approximate 50% performance boost over SHA-256 on
	64-bit hardware and is thus a good minimum-change replacement candidate
	for systems where hash performance is important, but these systems
	cannot for whatever reason utilize the faster \fBskein\fR and
	\fBedonr\fR algorithms.

	When the \fBsha512\fR feature is set to \fBenabled\fR, the administrator
	can turn on the \fBsha512\fR checksum on any dataset using
	\fBzfs set checksum=sha512\fR. See zfs(8). This feature becomes
	\fBactive\fR once a \fBchecksum\fR property has been set to \fBsha512\fR,
	and will return to being \fBenabled\fR once all filesystems that have
	ever had their checksum set to \fBsha512\fR are destroyed.
	.RE

	.sp
	.ne 2
	.na
	\fBskein\fR
	.ad
	.RS 4n
	.TS
	l l .
	GUID org.illumos:skein
	READ\-ONLY COMPATIBLE no
	DEPENDENCIES extensible_dataset
	.TE

	This feature enables the use of the Skein hash algorithm for checksum
	and dedup. Skein is a high-performance secure hash algorithm that was a
	finalist in the NIST SHA-3 competition. It provides a very high security
	margin and high performance on 64-bit hardware (80% faster than
	SHA-256). This implementation also utilizes the new salted checksumming
	functionality in ZFS, which means that the checksum is pre-seeded with a
	secret 256-bit random key (stored on the pool) before being fed the data
	block to be checksummed. Thus the produced checksums are unique to a
	given pool, preventing hash collision attacks on systems with dedup.

	When the \fBskein\fR feature is set to \fBenabled\fR, the administrator
	can turn on the \fBskein\fR checksum on any dataset using
	\fBzfs set checksum=skein\fR. See zfs(8). This feature becomes
	\fBactive\fR once a \fBchecksum\fR property has been set to \fBskein\fR,
	and will return to being \fBenabled\fR once all filesystems that have
	ever had their checksum set to \fBskein\fR are destroyed.
	.RE

	.sp
	.ne 2
	.na
	\fBspacemap_histogram\fR
	.ad
	.RS 4n
	.TS
	l l .
	GUID com.delphix:spacemap_histogram
	READ\-ONLY COMPATIBLE yes
	DEPENDENCIES none
	.TE

	This features allows ZFS to maintain more information about how free space
	is organized within the pool. If this feature is \fBenabled\fR, ZFS will
	set this feature to \fBactive\fR when a new space map object is created or
	an existing space map is upgraded to the new format. Once the feature is
	\fBactive\fR, it will remain in that state until the pool is destroyed.
	.RE

	.sp
	.ne 2
	.na
	\fBspacemap_v2\fR
	.ad
	.RS 4n
	.TS
	l l .
	GUID com.delphix:spacemap_v2
	READ\-ONLY COMPATIBLE yes
	DEPENDENCIES none
	.TE

	This feature enables the use of the new space map encoding which
	consists of two words (instead of one) whenever it is advantageous.
	The new encoding allows space maps to represent large regions of
	space more efficiently on-disk while also increasing their maximum
	addressable offset.

	This feature becomes \fBactive\fR once it is \fBenabled\fR, and never
	returns back to being \fBenabled\fR.
	.RE

	.sp
	.ne 2
	.na
	\fBuserobj_accounting\fR
	.ad
	.RS 4n
	.TS
	l l .
	GUID org.zfsonlinux:userobj_accounting
	READ\-ONLY COMPATIBLE yes
	DEPENDENCIES extensible_dataset
	.TE

	This feature allows administrators to account the object usage information
	by user and group.

	This feature becomes \fBactive\fR as soon as it is enabled and will never
	return to being \fBenabled\fR. Each filesystem will be upgraded automatically
	when remounted, or when new files are created under that filesystem.
	The upgrade can also be started manually on filesystems by running
	`zfs set version=current <pool/fs>`. The upgrade process runs in the background
	and may take a while to complete for filesystems containing a large number of
	files.
	.RE

	.sp
	.ne 2
	.na
	\fBzpool_checkpoint\fR
	.ad
	.RS 4n
	.TS
	l l .
	GUID com.delphix:zpool_checkpoint
	READ\-ONLY COMPATIBLE yes
	DEPENDENCIES none
	.TE

	This feature enables the \fBzpool checkpoint\fR subcommand that can
	checkpoint the state of the pool at the time it was issued and later
	rewind back to it or discard it.

	This feature becomes \fBactive\fR when the \fBzpool checkpoint\fR subcommand
	is used to checkpoint the pool.
	The feature will only return back to being \fBenabled\fR when the pool
	is rewound or the checkpoint has been discarded.
	.RE

	.sp
	.ne 2
	.na
	\fBzstd_compress\fR
	.ad
	.RS 4n
	.TS
	l l .
	GUID org.freebsd:zstd_compress
	READ\-ONLY COMPATIBLE no
	DEPENDENCIES extensible_dataset
	.TE

	\fBzstd\fR is a high-performance compression algorithm that features a
	combination of high compression ratios and high speed. Compared to \fBgzip\fR,
	-\fBzstd\fR offers slighty better compression at much higher speeds. Compared
	+\fBzstd\fR offers slightly better compression at much higher speeds. Compared
	to \fBlz4\fR, \fBzstd\fR offers much better compression while being only
	modestly slower. Typically, \fBzstd\fR compression speed ranges from 250 to 500
	MB/s per thread and decompression speed is over 1 GB/s per thread.

	When the \fBzstd\fR feature is set to \fBenabled\fR, the administrator can turn
	on \fBzstd\fR compression of any dataset by running
	`zfs set compress=zstd <pool/fs>`.

	This feature becomes \fBactive\fR once a \fBcompress\fR property has been set to
	\fBzstd\fR, and will return to being \fBenabled\fR once all filesystems that
	have ever had their compress property set to \fBzstd\fR are destroyed.
	-
	-Booting off of \fBzstd\fR-compressed root pools is not yet supported.
	.RE

	.SH "SEE ALSO"
	zpool(8)
	diff --git a/sys/contrib/openzfs/man/man8/fsck.zfs.8 b/sys/contrib/openzfs/man/man8/fsck.zfs.8
	index f681c2502ebe..934abc6772e8 100644
	--- a/sys/contrib/openzfs/man/man8/fsck.zfs.8
	+++ b/sys/contrib/openzfs/man/man8/fsck.zfs.8
	@@ -1,67 +1,71 @@
	'\" t
	.\"
	.\" 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 2013 Darik Horn <dajhorn@vanadac.com>. All rights reserved.
	.\"
	-.TH FSCK.ZFS 8 "Aug 24, 2020" OpenZFS
	+.TH FSCK.ZFS 8 "Mar 27, 2021" OpenZFS

	.SH NAME
	fsck.zfs \- Dummy ZFS filesystem checker.

	.SH SYNOPSIS
	.LP
	-.BI "fsck.zfs [" "options" "] <" "dataset" ">"
	+.BI "fsck.zfs [" "options" "] <" "dataset" ">…"

	.SH DESCRIPTION
	.LP
	-\fBfsck.zfs\fR is a shell stub that does nothing and always returns
	-true. It is installed by ZoL because some Linux distributions expect
	-a fsck helper for all filesystems.
	+\fBfsck.zfs\fR is a thin shell wrapper that at most checks the status of a
	+dataset's container pool. It is installed by OpenZFS because some Linux
	+distributions expect a fsck helper for all filesystems.
	+.LP
	+If more than one \fIdataset\fR is specified, each is checked in turn
	+and results binary ored.

	.SH OPTIONS
	.HP
	-All \fIoptions\fR and the \fIdataset\fR are ignored.
	+All \fIoptions\fR are ignored.

	.SH "NOTES"
	.LP
	ZFS datasets are checked by running \fBzpool scrub\fR on the
	containing pool. An individual ZFS dataset is never checked
	independently of its pool, which is unlike a regular filesystem.

	-.SH "BUGS"
	.LP
	-On some systems, if the \fIdataset\fR is in a degraded pool, then it
	-might be appropriate for \fBfsck.zfs\fR to return exit code 4 to
	-indicate an uncorrected filesystem error.
	+However, the
	+.BR fsck (8)
	+interface still allows it to communicate some errors:
	+if the \fIdataset\fR is in a degraded pool, then \fBfsck.zfs\fR will
	+return exit code 4 to indicate an uncorrected filesystem error.
	.LP
	Similarly, if the \fIdataset\fR is in a faulted pool and has a legacy
	-/etc/fstab record, then \fBfsck.zfs\fR should return exit code 8 to
	+/etc/fstab record, then \fBfsck.zfs\fR will return exit code 8 to
	indicate a fatal operational error.

	.SH "AUTHORS"
	.LP
	Darik Horn <dajhorn@vanadac.com>.

	.SH "SEE ALSO"
	.BR fsck (8),
	.BR fstab (5),
	.BR zpool-scrub (8)
	diff --git a/sys/contrib/openzfs/man/man8/mount.zfs.8 b/sys/contrib/openzfs/man/man8/mount.zfs.8
	index 016a909c26a0..dd04b3109bfc 100644
	--- a/sys/contrib/openzfs/man/man8/mount.zfs.8
	+++ b/sys/contrib/openzfs/man/man8/mount.zfs.8
	@@ -1,144 +1,92 @@
	-'\" t
	.\"
	.\" 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 2013 Darik Horn <dajhorn@vanadac.com>. All rights reserved.
	.\"
	-.TH MOUNT.ZFS 8 "Aug 24, 2020" OpenZFS
	-
	-.SH NAME
	-mount.zfs \- mount a ZFS filesystem
	-.SH SYNOPSIS
	-.LP
	-.BI "mount.zfs [\-sfnvh] [\-o " options "]" " dataset mountpoint
	-
	-.SH DESCRIPTION
	-.BR mount.zfs
	-is part of the zfsutils package for Linux. It is a helper program that
	-is usually invoked by the
	-.BR mount (8)
	-or
	-.BR zfs (8)
	-commands to mount a ZFS dataset.
	-
	-All
	-.I options
	-are handled according to the FILESYSTEM INDEPENDENT MOUNT OPTIONS
	-section in the
	-.BR mount (8)
	-manual, except for those described below.
	-
	-The
	-.I dataset
	-parameter is a ZFS filesystem name, as output by the
	-.B "zfs list -H -o name
	-command. This parameter never has a leading slash character and is
	-not a device name.
	-
	+.Dd May 24, 2021
	+.Dt MOUNT.ZFS 8
	+.Os
	+.
	+.Sh NAME
	+.Nm mount.zfs
	+.Nd mount a ZFS filesystem
	+.Sh SYNOPSIS
	+.Nm
	+.Op Fl sfnvh
	+.Op Fl o Ar options
	+.Ar dataset
	+.Ar mountpoint
	+.
	+.Sh DESCRIPTION
	The
	-.I mountpoint
	-parameter is the path name of a directory.
	-
	-
	-.SH OPTIONS
	-.TP
	-.BI "\-s"
	-Ignore bad or sloppy mount options.
	-.TP
	-.BI "\-f"
	-Do a fake mount; do not perform the mount operation.
	-.TP
	-.BI "\-n"
	-Do not update the /etc/mtab file.
	-.TP
	-.BI "\-v"
	-Increase verbosity.
	-.TP
	-.BI "\-h"
	+.Nm
	+helper is used by
	+.Xr mount 8
	+to mount filesystem snapshots and
	+.Sy mountpoint= Ns Ar legacy
	+ZFS filesystems, as well as by
	+.Xr zfs 8
	+when the
	+.Ev Em $ZFS_MOUNT_HELPER
	+environment variable is not set.
	+Users should should invoke either
	+.Xr mount 8
	+or
	+.Xr zfs 8
	+in most cases.
	+.Pp
	+.Ar options
	+are handled according to the
	+.Em Temporary Mount Point Properties
	+section in
	+.Xr zfsprops 8 ,
	+except for those described below.
	+.Pp
	+If
	+.Pa /etc/mtab
	+is a regular file and
	+.Fl n
	+was not specified, it will be updated via libmount.
	+.
	+.Sh OPTIONS
	+.Bl -tag -width "-o xa"
	+.It Fl s
	+Ignore unknown (sloppy) mount options.
	+.It Fl f
	+Do everything except actually executing the system call.
	+.It Fl n
	+Never update
	+.Pa /etc/mtab .
	+.It Fl v
	+Print resolved mount options and parser state.
	+.It Fl h
	Print the usage message.
	-.TP
	-.BI "\-o context"
	-This flag sets the SELinux context for all files in the filesystem
	-under that mountpoint.
	-.TP
	-.BI "\-o fscontext"
	-This flag sets the SELinux context for the filesystem being mounted.
	-.TP
	-.BI "\-o defcontext"
	-This flag sets the SELinux context for unlabeled files.
	-.TP
	-.BI "\-o rootcontext"
	-This flag sets the SELinux context for the root inode of the filesystem.
	-.TP
	-.BI "\-o legacy"
	-This private flag indicates that the
	-.I dataset
	-has an entry in the /etc/fstab file.
	-.TP
	-.BI "\-o noxattr"
	-This private flag disables extended attributes.
	-.TP
	-.BI "\-o xattr
	-This private flag enables directory-based extended attributes and, if
	-appropriate, adds a ZFS context to the selinux system policy.
	-.TP
	-.BI "\-o saxattr
	-This private flag enables system attributed-based extended attributes and, if
	-appropriate, adds a ZFS context to the selinux system policy.
	-.TP
	-.BI "\-o dirxattr
	-Equivalent to
	-.BR xattr .
	-.TP
	-.BI "\-o zfsutil"
	+.It Fl o Ar zfsutil
	This private flag indicates that
	-.BR mount (8)
	+.Xr mount 8
	is being called by the
	-.BR zfs (8)
	+.Xr zfs 8
	command.
	-
	-.SH NOTES
	-ZFS conventionally requires that the
	-.I mountpoint
	-be an empty directory, but the Linux implementation inconsistently
	-enforces the requirement.
	-
	-The
	-.BR mount.zfs
	-helper does not mount the contents of zvols.
	-
	-.SH FILES
	-.TP 18n
	-.I /etc/fstab
	-The static filesystem table.
	-.TP
	-.I /etc/mtab
	-The mounted filesystem table.
	-.SH "AUTHORS"
	-The primary author of
	-.BR mount.zfs
	-is Brian Behlendorf <behlendorf1@llnl.gov>.
	-
	-This man page was written by Darik Horn <dajhorn@vanadac.com>.
	-.SH "SEE ALSO"
	-.BR fstab (5),
	-.BR mount (8),
	-.BR zfs (8)
	+.El
	+.
	+.Sh SEE ALSO
	+.Xr fstab 5 ,
	+.Xr mount 8 ,
	+.Xr zfs-mount 8
	diff --git a/sys/contrib/openzfs/man/man8/zed.8.in b/sys/contrib/openzfs/man/man8/zed.8.in
	index e32a89de8a0f..38f8b663d38e 100644
	--- a/sys/contrib/openzfs/man/man8/zed.8.in
	+++ b/sys/contrib/openzfs/man/man8/zed.8.in
	@@ -1,267 +1,249 @@
	.\"
	.\" This file is part of the ZFS Event Daemon (ZED).
	.\" Developed at Lawrence Livermore National Laboratory (LLNL-CODE-403049).
	.\" Copyright (C) 2013-2014 Lawrence Livermore National Security, LLC.
	-.\" Refer to the ZoL git commit log for authoritative copyright attribution.
	+.\" Refer to the OpenZFS git commit log for authoritative copyright attribution.
	.\"
	.\" The contents of this file are subject to the terms of the
	.\" Common Development and Distribution License Version 1.0 (CDDL-1.0).
	.\" You can obtain a copy of the license from the top-level file
	.\" "OPENSOLARIS.LICENSE" or at <http://opensource.org/licenses/CDDL-1.0>.
	.\" You may not use this file except in compliance with the license.
	.\"
	.TH ZED 8 "Aug 24, 2020" OpenZFS

	.SH NAME
	ZED \- ZFS Event Daemon

	.SH SYNOPSIS
	.HP
	.B zed
	.\" [\fB\-c\fR \fIconfigfile\fR]
	[\fB\-d\fR \fIzedletdir\fR]
	[\fB\-f\fR]
	[\fB\-F\fR]
	[\fB\-h\fR]
	[\fB\-I\fR]
	[\fB\-L\fR]
	[\fB\-M\fR]
	[\fB\-p\fR \fIpidfile\fR]
	[\fB\-P\fR \fIpath\fR]
	[\fB\-s\fR \fIstatefile\fR]
	+[\fB\-j\fR \fIjobs\fR]
	[\fB\-v\fR]
	[\fB\-V\fR]
	[\fB\-Z\fR]

	.SH DESCRIPTION
	.PP
	\fBZED\fR (ZFS Event Daemon) monitors events generated by the ZFS kernel
	module. When a zevent (ZFS Event) is posted, \fBZED\fR will run any ZEDLETs
	(ZFS Event Daemon Linkage for Executable Tasks) that have been enabled for the
	corresponding zevent class.

	.SH OPTIONS
	.TP
	.BI \-h
	Display a summary of the command-line options.
	.TP
	.BI \-L
	Display license information.
	.TP
	.BI \-V
	Display version information.
	.TP
	.BI \-v
	Be verbose.
	.TP
	.BI \-f
	Force the daemon to run if at all possible, disabling security checks and
	throwing caution to the wind. Not recommended for use in production.
	.TP
	.BI \-F
	Run the daemon in the foreground.
	.TP
	.BI \-M
	Lock all current and future pages in the virtual memory address space.
	This may help the daemon remain responsive when the system is under heavy
	memory pressure.
	.TP
	.BI \-I
	Request that the daemon idle rather than exit when the kernel modules are
	not loaded. Processing of events will start, or resume, when the kernel
	modules are (re)loaded. Under Linux the kernel modules cannot be unloaded
	while the daemon is running.
	.TP
	.BI \-Z
	Zero the daemon's state, thereby allowing zevents still within the kernel
	to be reprocessed.
	-.\" .TP
	-.\" .BI \-c\ configfile
	-.\" Read the configuration from the specified file.
	.TP
	.BI \-d\ zedletdir
	Read the enabled ZEDLETs from the specified directory.
	.TP
	.BI \-p\ pidfile
	Write the daemon's process ID to the specified file.
	.TP
	.BI \-P\ path
	Custom $PATH for zedlets to use. Normally zedlets run in a locked-down
	environment, with hardcoded paths to the ZFS commands ($ZFS, $ZPOOL, $ZED, ...),
	and a hardcoded $PATH. This is done for security reasons. However, the
	ZFS test suite uses a custom PATH for its ZFS commands, and passes it to zed
	with -P. In short, -P is only to be used by the ZFS test suite; never use
	it in production!
	.TP
	.BI \-s\ statefile
	Write the daemon's state to the specified file.
	+.TP
	+.BI \-j\ jobs
	+Allow at most \fIjobs\fR ZEDLETs to run concurrently,
	+delaying execution of new ones until they finish.
	+Defaults to 16.
	.SH ZEVENTS
	.PP
	A zevent is comprised of a list of nvpairs (name/value pairs). Each zevent
	contains an EID (Event IDentifier) that uniquely identifies it throughout
	the lifetime of the loaded ZFS kernel module; this EID is a monotonically
	increasing integer that resets to 1 each time the kernel module is loaded.
	Each zevent also contains a class string that identifies the type of event.
	For brevity, a subclass string is defined that omits the leading components
	of the class string. Additional nvpairs exist to provide event details.
	.PP
	The kernel maintains a list of recent zevents that can be viewed (along with
	their associated lists of nvpairs) using the "\fBzpool events \-v\fR" command.

	.SH CONFIGURATION
	.PP
	ZEDLETs to be invoked in response to zevents are located in the
	\fIenabled-zedlets\fR directory. These can be symlinked or copied from the
	\fIinstalled-zedlets\fR directory; symlinks allow for automatic updates
	from the installed ZEDLETs, whereas copies preserve local modifications.
	-As a security measure, ZEDLETs must be owned by root. They must have
	-execute permissions for the user, but they must not have write permissions
	-for group or other. Dotfiles are ignored.
	+As a security measure, since ownership change is a privileged operation,
	+ZEDLETs must be owned by root. They must have execute permissions for the user,
	+but they must not have write permissions for group or other.
	+Dotfiles are ignored.
	.PP
	ZEDLETs are named after the zevent class for which they should be invoked.
	In particular, a ZEDLET will be invoked for a given zevent if either its
	class or subclass string is a prefix of its filename (and is followed by
	a non-alphabetic character). As a special case, the prefix "all" matches
	all zevents. Multiple ZEDLETs may be invoked for a given zevent.

	.SH ZEDLETS
	.PP
	ZEDLETs are executables invoked by the ZED in response to a given zevent.
	They should be written under the presumption they can be invoked concurrently,
	and they should use appropriate locking to access any shared resources.
	Common variables used by ZEDLETs can be stored in the default rc file which
	is sourced by scripts; these variables should be prefixed with "ZED_".
	.PP
	The zevent nvpairs are passed to ZEDLETs as environment variables.
	Each nvpair name is converted to an environment variable in the following
	manner: 1) it is prefixed with "ZEVENT_", 2) it is converted to uppercase,
	and 3) each non-alphanumeric character is converted to an underscore.
	Some additional environment variables have been defined to present certain
	nvpair values in a more convenient form. An incomplete list of zevent
	environment variables is as follows:
	.TP
	.B
	ZEVENT_EID
	The Event IDentifier.
	.TP
	.B
	ZEVENT_CLASS
	The zevent class string.
	.TP
	.B
	ZEVENT_SUBCLASS
	The zevent subclass string.
	.TP
	.B
	ZEVENT_TIME
	The time at which the zevent was posted as
	"\fIseconds\fR\ \fInanoseconds\fR" since the Epoch.
	.TP
	.B
	ZEVENT_TIME_SECS
	The \fIseconds\fR component of ZEVENT_TIME.
	.TP
	.B
	ZEVENT_TIME_NSECS
	The \fInanoseconds\fR component of ZEVENT_TIME.
	.TP
	.B
	ZEVENT_TIME_STRING
	An almost-RFC3339-compliant string for ZEVENT_TIME.
	.PP
	Additionally, the following ZED & ZFS variables are defined:
	.TP
	.B
	ZED_PID
	The daemon's process ID.
	.TP
	.B
	ZED_ZEDLET_DIR
	The daemon's current \fIenabled-zedlets\fR directory.
	.TP
	.B
	ZFS_ALIAS
	The ZFS alias (\fIname-version-release\fR) string used to build the daemon.
	.TP
	.B
	ZFS_VERSION
	The ZFS version used to build the daemon.
	.TP
	.B
	ZFS_RELEASE
	The ZFS release used to build the daemon.
	.PP
	ZEDLETs may need to call other ZFS commands. The installation paths of
	the following executables are defined: \fBZDB\fR, \fBZED\fR, \fBZFS\fR,
	\fBZINJECT\fR, and \fBZPOOL\fR. These variables can be overridden in the
	rc file if needed.

	.SH FILES
	-.\" .TP
	-.\" @sysconfdir@/zfs/zed.conf
	-.\" The default configuration file for the daemon.
	.TP
	.I @sysconfdir@/zfs/zed.d
	The default directory for enabled ZEDLETs.
	.TP
	.I @sysconfdir@/zfs/zed.d/zed.rc
	The default rc file for common variables used by ZEDLETs.
	.TP
	.I @zfsexecdir@/zed.d
	The default directory for installed ZEDLETs.
	.TP
	.I @runstatedir@/zed.pid
	The default file containing the daemon's process ID.
	.TP
	.I @runstatedir@/zed.state
	The default file containing the daemon's state.

	.SH SIGNALS
	.TP
	.B HUP
	Reconfigure the daemon and rescan the directory for enabled ZEDLETs.
	.TP
	.B TERM
	Terminate the daemon.

	.SH NOTES
	.PP
	\fBZED\fR requires root privileges.
	.\" Do not taunt zed.

	.SH BUGS
	.PP
	-Events are processed synchronously by a single thread. This can delay the
	-processing of simultaneous zevents.
	-.PP
	-ZEDLETs are killed after a maximum of ten seconds.
	-This can lead to a violation of a ZEDLET's atomicity assumptions.
	-.PP
	-The ownership and permissions of the \fIenabled-zedlets\fR directory (along
	-with all parent directories) are not checked. If any of these directories
	-are improperly owned or permissioned, an unprivileged user could insert a
	-ZEDLET to be executed as root. The requirement that ZEDLETs be owned by
	-root mitigates this to some extent.
	-.PP
	ZEDLETs are unable to return state/status information to the kernel.
	.PP
	-Some zevent nvpair types are not handled. These are denoted by zevent
	-environment variables having a "_NOT_IMPLEMENTED_" value.
	-.PP
	Internationalization support via gettext has not been added.
	-.PP
	-The configuration file is not yet implemented.
	-.PP
	-The diagnosis engine is not yet implemented.

	.SH LICENSE
	.PP
	\fBZED\fR (ZFS Event Daemon) is distributed under the terms of the
	Common Development and Distribution License Version 1.0 (CDDL\-1.0).
	.PP
	Developed at Lawrence Livermore National Laboratory (LLNL\-CODE\-403049).

	.SH SEE ALSO
	.BR zfs (8),
	.BR zpool (8)
	.BR zpool-events (8)
	diff --git a/sys/contrib/openzfs/man/man8/zfs-allow.8 b/sys/contrib/openzfs/man/man8/zfs-allow.8
	index 1925112256cc..2c0a2ca36d54 100644
	--- a/sys/contrib/openzfs/man/man8/zfs-allow.8
	+++ b/sys/contrib/openzfs/man/man8/zfs-allow.8
	@@ -1,375 +1,376 @@
	.\"
	.\" 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) 2009 Sun Microsystems, Inc. All Rights Reserved.
	.\" Copyright 2011 Joshua M. Clulow <josh@sysmgr.org>
	.\" Copyright (c) 2011, 2019 by Delphix. All rights reserved.
	.\" Copyright (c) 2013 by Saso Kiselkov. All rights reserved.
	.\" Copyright (c) 2014, Joyent, Inc. All rights reserved.
	.\" Copyright (c) 2014 by Adam Stevko. All rights reserved.
	.\" Copyright (c) 2014 Integros [integros.com]
	.\" Copyright 2019 Richard Laager. All rights reserved.
	.\" Copyright 2018 Nexenta Systems, Inc.
	.\" Copyright 2019 Joyent, Inc.
	.\"
	.Dd June 30, 2019
	.Dt ZFS-ALLOW 8
	.Os
	.Sh NAME
	.Nm zfs-allow
	.Nd Delegates ZFS administration permission for the file systems to non-privileged users.
	.Sh SYNOPSIS
	.Nm zfs
	.Cm allow
	.Op Fl dglu
	.Ar user Ns \| Ns Ar group Ns Oo , Ns Ar user Ns \| Ns Ar group Oc Ns ...
	.Ar perm Ns \| Ns @ Ns Ar setname Ns Oo , Ns Ar perm Ns \| Ns @ Ns
	.Ar setname Oc Ns ...
	.Ar filesystem Ns \| Ns Ar volume
	.Nm zfs
	.Cm allow
	.Op Fl dl
	.Fl e Ns \| Ns Sy everyone
	.Ar perm Ns \| Ns @ Ns Ar setname Ns Oo , Ns Ar perm Ns \| Ns @ Ns
	.Ar setname Oc Ns ...
	.Ar filesystem Ns \| Ns Ar volume
	.Nm zfs
	.Cm allow
	.Fl c
	.Ar perm Ns \| Ns @ Ns Ar setname Ns Oo , Ns Ar perm Ns \| Ns @ Ns
	.Ar setname Oc Ns ...
	.Ar filesystem Ns \| Ns Ar volume
	.Nm zfs
	.Cm allow
	.Fl s No @ Ns Ar setname
	.Ar perm Ns \| Ns @ Ns Ar setname Ns Oo , Ns Ar perm Ns \| Ns @ Ns
	.Ar setname Oc Ns ...
	.Ar filesystem Ns \| Ns Ar volume
	.Nm zfs
	.Cm unallow
	.Op Fl dglru
	.Ar user Ns \| Ns Ar group Ns Oo , Ns Ar user Ns \| Ns Ar group Oc Ns ...
	.Oo Ar perm Ns \| Ns @ Ns Ar setname Ns Oo , Ns Ar perm Ns \| Ns @ Ns
	.Ar setname Oc Ns ... Oc
	.Ar filesystem Ns \| Ns Ar volume
	.Nm zfs
	.Cm unallow
	.Op Fl dlr
	.Fl e Ns \| Ns Sy everyone
	.Oo Ar perm Ns \| Ns @ Ns Ar setname Ns Oo , Ns Ar perm Ns \| Ns @ Ns
	.Ar setname Oc Ns ... Oc
	.Ar filesystem Ns \| Ns Ar volume
	.Nm zfs
	.Cm unallow
	.Op Fl r
	.Fl c
	.Oo Ar perm Ns \| Ns @ Ns Ar setname Ns Oo , Ns Ar perm Ns \| Ns @ Ns
	.Ar setname Oc Ns ... Oc
	.Ar filesystem Ns \| Ns Ar volume
	.Nm zfs
	.Cm unallow
	.Op Fl r
	.Fl s No @ Ns Ar setname
	.Oo Ar perm Ns \| Ns @ Ns Ar setname Ns Oo , Ns Ar perm Ns \| Ns @ Ns
	.Ar setname Oc Ns ... Oc
	.Ar filesystem Ns \| Ns Ar volume
	.Sh DESCRIPTION
	.Bl -tag -width ""
	.It Xo
	.Nm zfs
	.Cm allow
	.Ar filesystem Ns \| Ns Ar volume
	.Xc
	Displays permissions that have been delegated on the specified filesystem or
	volume.
	See the other forms of
	.Nm zfs Cm allow
	for more information.
	.Pp
	Delegations are supported under Linux with the exception of
	.Sy mount ,
	.Sy unmount ,
	.Sy mountpoint ,
	.Sy canmount ,
	.Sy rename ,
	and
	.Sy share .
	These permissions cannot be delegated because the Linux
	.Xr mount 8
	command restricts modifications of the global namespace to the root user.
	.It Xo
	.Nm zfs
	.Cm allow
	.Op Fl dglu
	.Ar user Ns \| Ns Ar group Ns Oo , Ns Ar user Ns \| Ns Ar group Oc Ns ...
	.Ar perm Ns \| Ns @ Ns Ar setname Ns Oo , Ns Ar perm Ns \| Ns @ Ns
	.Ar setname Oc Ns ...
	.Ar filesystem Ns \| Ns Ar volume
	.Xc
	.It Xo
	.Nm zfs
	.Cm allow
	.Op Fl dl
	.Fl e Ns \| Ns Sy everyone
	.Ar perm Ns \| Ns @ Ns Ar setname Ns Oo , Ns Ar perm Ns \| Ns @ Ns
	.Ar setname Oc Ns ...
	.Ar filesystem Ns \| Ns Ar volume
	.Xc
	Delegates ZFS administration permission for the file systems to non-privileged
	users.
	.Bl -tag -width "-d"
	.It Fl d
	Allow only for the descendent file systems.
	.It Fl e Ns \| Ns Sy everyone
	Specifies that the permissions be delegated to everyone.
	.It Fl g Ar group Ns Oo , Ns Ar group Oc Ns ...
	Explicitly specify that permissions are delegated to the group.
	.It Fl l
	Allow
	.Qq locally
	only for the specified file system.
	.It Fl u Ar user Ns Oo , Ns Ar user Oc Ns ...
	Explicitly specify that permissions are delegated to the user.
	.It Ar user Ns \| Ns Ar group Ns Oo , Ns Ar user Ns \| Ns Ar group Oc Ns ...
	Specifies to whom the permissions are delegated.
	Multiple entities can be specified as a comma-separated list.
	If neither of the
	.Fl gu
	options are specified, then the argument is interpreted preferentially as the
	keyword
	.Sy everyone ,
	then as a user name, and lastly as a group name.
	To specify a user or group named
	.Qq everyone ,
	use the
	.Fl g
	or
	.Fl u
	options.
	To specify a group with the same name as a user, use the
	.Fl g
	options.
	.It Xo
	.Ar perm Ns \| Ns @ Ns Ar setname Ns Oo , Ns Ar perm Ns \| Ns @ Ns
	.Ar setname Oc Ns ...
	.Xc
	The permissions to delegate.
	Multiple permissions may be specified as a comma-separated list.
	Permission names are the same as ZFS subcommand and property names.
	See the property list below.
	Property set names, which begin with
	.Sy @ ,
	may be specified.
	See the
	.Fl s
	form below for details.
	.El
	.Pp
	If neither of the
	.Fl dl
	options are specified, or both are, then the permissions are allowed for the
	file system or volume, and all of its descendents.
	.Pp
	Permissions are generally the ability to use a ZFS subcommand or change a ZFS
	property.
	The following permissions are available:
	.Bd -literal
	NAME TYPE NOTES
	allow subcommand Must also have the permission that is
	being allowed
	+bookmark subcommand
	clone subcommand Must also have the 'create' ability and
	'mount' ability in the origin file system
	create subcommand Must also have the 'mount' ability.
	Must also have the 'refreservation' ability to
	create a non-sparse volume.
	destroy subcommand Must also have the 'mount' ability
	diff subcommand Allows lookup of paths within a dataset
	given an object number, and the ability
	to create snapshots necessary to
	'zfs diff'.
	hold subcommand Allows adding a user hold to a snapshot
	load-key subcommand Allows loading and unloading of encryption key
	(see 'zfs load-key' and 'zfs unload-key').
	change-key subcommand Allows changing an encryption key via
	'zfs change-key'.
	mount subcommand Allows mount/umount of ZFS datasets
	promote subcommand Must also have the 'mount' and 'promote'
	ability in the origin file system
	receive subcommand Must also have the 'mount' and 'create'
	ability
	release subcommand Allows releasing a user hold which might
	destroy the snapshot
	rename subcommand Must also have the 'mount' and 'create'
	ability in the new parent
	rollback subcommand Must also have the 'mount' ability
	send subcommand
	share subcommand Allows sharing file systems over NFS
	or SMB protocols
	snapshot subcommand Must also have the 'mount' ability

	groupquota other Allows accessing any groupquota@...
	property
	groupused other Allows reading any groupused@... property
	userprop other Allows changing any user property
	userquota other Allows accessing any userquota@...
	property
	userused other Allows reading any userused@... property
	projectobjquota other Allows accessing any projectobjquota@...
	property
	projectquota other Allows accessing any projectquota@... property
	projectobjused other Allows reading any projectobjused@... property
	projectused other Allows reading any projectused@... property

	aclinherit property
	acltype property
	atime property
	canmount property
	casesensitivity property
	checksum property
	compression property
	copies property
	devices property
	exec property
	filesystem_limit property
	mountpoint property
	nbmand property
	normalization property
	primarycache property
	quota property
	readonly property
	recordsize property
	refquota property
	refreservation property
	reservation property
	secondarycache property
	setuid property
	sharenfs property
	sharesmb property
	snapdir property
	snapshot_limit property
	utf8only property
	version property
	volblocksize property
	volsize property
	vscan property
	xattr property
	zoned property
	.Ed
	.It Xo
	.Nm zfs
	.Cm allow
	.Fl c
	.Ar perm Ns \| Ns @ Ns Ar setname Ns Oo , Ns Ar perm Ns \| Ns @ Ns
	.Ar setname Oc Ns ...
	.Ar filesystem Ns \| Ns Ar volume
	.Xc
	Sets
	.Qq create time
	permissions.
	These permissions are granted
	.Pq locally
	to the creator of any newly-created descendent file system.
	.It Xo
	.Nm zfs
	.Cm allow
	.Fl s No @ Ns Ar setname
	.Ar perm Ns \| Ns @ Ns Ar setname Ns Oo , Ns Ar perm Ns \| Ns @ Ns
	.Ar setname Oc Ns ...
	.Ar filesystem Ns \| Ns Ar volume
	.Xc
	Defines or adds permissions to a permission set.
	The set can be used by other
	.Nm zfs Cm allow
	commands for the specified file system and its descendents.
	Sets are evaluated dynamically, so changes to a set are immediately reflected.
	Permission sets follow the same naming restrictions as ZFS file systems, but the
	name must begin with
	.Sy @ ,
	and can be no more than 64 characters long.
	.It Xo
	.Nm zfs
	.Cm unallow
	.Op Fl dglru
	.Ar user Ns \| Ns Ar group Ns Oo , Ns Ar user Ns \| Ns Ar group Oc Ns ...
	.Oo Ar perm Ns \| Ns @ Ns Ar setname Ns Oo , Ns Ar perm Ns \| Ns @ Ns
	.Ar setname Oc Ns ... Oc
	.Ar filesystem Ns \| Ns Ar volume
	.Xc
	.It Xo
	.Nm zfs
	.Cm unallow
	.Op Fl dlr
	.Fl e Ns \| Ns Sy everyone
	.Oo Ar perm Ns \| Ns @ Ns Ar setname Ns Oo , Ns Ar perm Ns \| Ns @ Ns
	.Ar setname Oc Ns ... Oc
	.Ar filesystem Ns \| Ns Ar volume
	.Xc
	.It Xo
	.Nm zfs
	.Cm unallow
	.Op Fl r
	.Fl c
	.Oo Ar perm Ns \| Ns @ Ns Ar setname Ns Oo , Ns Ar perm Ns \| Ns @ Ns
	.Ar setname Oc Ns ... Oc
	.Ar filesystem Ns \| Ns Ar volume
	.Xc
	Removes permissions that were granted with the
	.Nm zfs Cm allow
	command.
	No permissions are explicitly denied, so other permissions granted are still in
	effect.
	For example, if the permission is granted by an ancestor.
	If no permissions are specified, then all permissions for the specified
	.Ar user ,
	.Ar group ,
	or
	.Sy everyone
	are removed.
	Specifying
	.Sy everyone
	.Po or using the
	.Fl e
	option
	.Pc
	only removes the permissions that were granted to everyone, not all permissions
	for every user and group.
	See the
	.Nm zfs Cm allow
	command for a description of the
	.Fl ldugec
	options.
	.Bl -tag -width "-r"
	.It Fl r
	Recursively remove the permissions from this file system and all descendents.
	.El
	.It Xo
	.Nm zfs
	.Cm unallow
	.Op Fl r
	.Fl s No @ Ns Ar setname
	.Oo Ar perm Ns \| Ns @ Ns Ar setname Ns Oo , Ns Ar perm Ns \| Ns @ Ns
	.Ar setname Oc Ns ... Oc
	.Ar filesystem Ns \| Ns Ar volume
	.Xc
	Removes permissions from a permission set.
	If no permissions are specified, then all permissions are removed, thus removing
	the set entirely.
	.El
	diff --git a/sys/contrib/openzfs/man/man8/zfs-jail.8 b/sys/contrib/openzfs/man/man8/zfs-jail.8
	index 4c439d53f0d6..ef621185e6a8 100644
	--- a/sys/contrib/openzfs/man/man8/zfs-jail.8
	+++ b/sys/contrib/openzfs/man/man8/zfs-jail.8
	@@ -1,119 +1,119 @@
	.\"
	.\" 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) 2009 Sun Microsystems, Inc. All Rights Reserved.
	.\" Copyright 2011 Joshua M. Clulow <josh@sysmgr.org>
	.\" Copyright (c) 2011, 2019 by Delphix. All rights reserved.
	.\" Copyright (c) 2011, Pawel Jakub Dawidek <pjd@FreeBSD.org>
	.\" Copyright (c) 2012, Glen Barber <gjb@FreeBSD.org>
	.\" Copyright (c) 2012, Bryan Drewery <bdrewery@FreeBSD.org>
	.\" Copyright (c) 2013, Steven Hartland <smh@FreeBSD.org>
	.\" Copyright (c) 2013 by Saso Kiselkov. All rights reserved.
	.\" Copyright (c) 2014, Joyent, Inc. All rights reserved.
	.\" Copyright (c) 2014 by Adam Stevko. All rights reserved.
	.\" Copyright (c) 2014 Integros [integros.com]
	.\" Copyright (c) 2014, Xin LI <delphij@FreeBSD.org>
	.\" Copyright (c) 2014-2015, The FreeBSD Foundation, All Rights Reserved.
	.\" Copyright (c) 2016 Nexenta Systems, Inc. All Rights Reserved.
	.\" Copyright 2019 Richard Laager. All rights reserved.
	.\" Copyright 2018 Nexenta Systems, Inc.
	.\" Copyright 2019 Joyent, Inc.
	.\"
	.Dd December 9, 2019
	.Dt ZFS-JAIL 8
	.Os FreeBSD
	.Sh NAME
	.Nm zfs-jail
	.Nd Attaches and detaches ZFS filesystems from FreeBSD jails.
	.No A Tn ZFS
	dataset can be attached to a jail by using the
	-.Qq Nm Cm jail
	+.Qq Nm zfs jail
	subcommand. You cannot attach a dataset to one jail and the children of the
	same dataset to another jail. You can also not attach the root file system
	of the jail or any dataset which needs to be mounted before the zfs rc script
	is run inside the jail, as it would be attached unmounted until it is
	mounted from the rc script inside the jail. To allow management of the
	dataset from within a jail, the
	.Sy jailed
	property has to be set and the jail needs access to the
	.Pa /dev/zfs
	device. The
	.Sy quota
	property cannot be changed from within a jail. See
	.Xr jail 8
	for information on how to allow mounting
	.Tn ZFS
	datasets from within a jail.
	.Pp
	.No A Tn ZFS
	dataset can be detached from a jail using the
	-.Qq Nm Cm unjail
	+.Qq Nm zfs unjail
	subcommand.
	.Pp
	After a dataset is attached to a jail and the jailed property is set, a jailed
	file system cannot be mounted outside the jail, since the jail administrator
	might have set the mount point to an unacceptable value.
	.Sh SYNOPSIS
	.Nm zfs
	.Cm jail
	.Ar jailid Ns \| Ns Ar jailname filesystem
	.Nm zfs
	.Cm unjail
	.Ar jailid Ns \| Ns Ar jailname filesystem
	.Sh DESCRIPTION
	.Bl -tag -width ""
	.It Xo
	.Nm zfs
	.Cm jail
	.Ar jailid filesystem
	.Xc
	.Pp
	Attaches the specified
	.Ar filesystem
	to the jail identified by JID
	.Ar jailid .
	From now on this file system tree can be managed from within a jail if the
	.Sy jailed
	property has been set. To use this functuinality, the jail needs the
	.Va allow.mount
	and
	.Va allow.mount.zfs
	parameters set to 1 and the
	.Va enforce_statfs
	parameter set to a value lower than 2.
	.Pp
	See
	.Xr jail 8
	for more information on managing jails and configuring the parameters above.
	.It Xo
	.Nm zfs
	.Cm unjail
	.Ar jailid filesystem
	.Xc
	.Pp
	Detaches the specified
	.Ar filesystem
	from the jail identified by JID
	.Ar jailid .
	.El
	.Sh SEE ALSO
	.Xr jail 8 ,
	.Xr zfsprops 8
	diff --git a/sys/contrib/openzfs/man/man8/zfs-mount-generator.8.in b/sys/contrib/openzfs/man/man8/zfs-mount-generator.8.in
	index 3b8c9c3ae246..96fee4291071 100644
	--- a/sys/contrib/openzfs/man/man8/zfs-mount-generator.8.in
	+++ b/sys/contrib/openzfs/man/man8/zfs-mount-generator.8.in
	@@ -1,248 +1,247 @@
	.\"
	.\" Copyright 2018 Antonio Russo <antonio.e.russo@gmail.com>
	.\" Copyright 2019 Kjeld Schouten-Lebbing <kjeld@schouten-lebbing.nl>
	.\" Copyright 2020 InsanePrawn <insane.prawny@gmail.com>
	.\"
	.\" Permission is hereby granted, free of charge, to any person obtaining
	.\" a copy of this software and associated documentation files (the
	.\" "Software"), to deal in the Software without restriction, including
	.\" without limitation the rights to use, copy, modify, merge, publish,
	.\" distribute, sublicense, and/or sell copies of the Software, and to
	.\" permit persons to whom the Software is furnished to do so, subject to
	.\" the following conditions:
	.\"
	.\" The above copyright notice and this permission notice shall be
	.\" included in all copies or substantial portions of the Software.
	.\"
	.\" THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	.\" EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	.\" MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	.\" NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
	.\" LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
	.\" OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
	.\" WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

	.TH ZFS-MOUNT-GENERATOR 8 "Aug 24, 2020" OpenZFS

	.SH "NAME"
	zfs\-mount\-generator \- generates systemd mount units for ZFS
	.SH SYNOPSIS
	.B @systemdgeneratordir@/zfs\-mount\-generator
	.sp
	.SH DESCRIPTION
	zfs\-mount\-generator implements the \fBGenerators Specification\fP
	of
	.BR systemd (1),
	and is called during early boot to generate
	.BR systemd.mount (5)
	units for automatically mounted datasets. Mount ordering and dependencies
	are created for all tracked pools (see below).

	.SS ENCRYPTION KEYS
	If the dataset is an encryption root, a service that loads the associated key (either from file or through a
	.BR systemd\-ask\-password (1)
	prompt) will be created. This service
	. BR RequiresMountsFor
	the path of the key (if file-based) and also copies the mount unit's
	.BR After ,
	.BR Before
	and
	.BR Requires .
	All mount units of encrypted datasets add the key\-load service for their encryption root to their
	.BR Wants
	and
	.BR After .
	The service will not be
	.BR Want ed
	or
	.BR Require d
	by
	.BR local-fs.target
	directly, and so will only be started manually or as a dependency of a started mount unit.

	.SS UNIT ORDERING AND DEPENDENCIES
	mount unit's
	.BR Before
	\->
	key\-load service (if any)
	\->
	mount unit
	\->
	mount unit's
	.BR After

	It is worth nothing that when a mount unit is activated, it activates all available mount units for parent paths to its mountpoint, i.e. activating the mount unit for /tmp/foo/1/2/3 automatically activates all available mount units for /tmp, /tmp/foo, /tmp/foo/1, and /tmp/foo/1/2. This is true for any combination of mount units from any sources, not just ZFS.

	.SS CACHE FILE
	Because ZFS pools may not be available very early in the boot process,
	information on ZFS mountpoints must be stored separately. The output of the command
	.PP
	.RS 4
	zfs list -H -o name,mountpoint,canmount,atime,relatime,devices,exec,readonly,setuid,nbmand,encroot,keylocation,org.openzfs.systemd:requires,org.openzfs.systemd:requires-mounts-for,org.openzfs.systemd:before,org.openzfs.systemd:after,org.openzfs.systemd:wanted-by,org.openzfs.systemd:required-by,org.openzfs.systemd:nofail,org.openzfs.systemd:ignore

	.RE
	.PP
	for datasets that should be mounted by systemd, should be kept
	separate from the pool, at
	.PP
	.RS 4
	.RI @sysconfdir@/zfs/zfs-list.cache/ POOLNAME
	.
	.RE
	.PP
	The cache file, if writeable, will be kept synchronized with the pool
	state by the ZEDLET
	.PP
	.RS 4
	history_event-zfs-list-cacher.sh .
	.RE
	.PP
	.sp
	.SS PROPERTIES
	The behavior of the generator script can be influenced by the following dataset properties:
	.sp
	.TP 4
	.BR canmount = on \| off \| noauto
	If a dataset has
	.BR mountpoint
	set and
	.BR canmount
	is not
	.BR off ,
	a mount unit will be generated.
	Additionally, if
	.BR canmount
	is
	.BR on ,
	.BR local-fs.target
	will gain a dependency on the mount unit.

	This behavior is equal to the
	.BR auto
	and
	.BR noauto
	legacy mount options, see
	.BR systemd.mount (5).

	Encryption roots always generate a key-load service, even for
	.BR canmount=off .
	.TP 4
	.BR org.openzfs.systemd:requires\-mounts\-for = \fIpath\fR...
	Space\-separated list of mountpoints to require to be mounted for this mount unit
	.TP 4
	.BR org.openzfs.systemd:before = \fIunit\fR...
	The mount unit and associated key\-load service will be ordered before this space\-separated list of units.
	.TP 4
	.BR org.openzfs.systemd:after = \fIunit\fR...
	The mount unit and associated key\-load service will be ordered after this space\-separated list of units.
	.TP 4
	.BR org.openzfs.systemd:wanted\-by = \fIunit\fR...
	Space-separated list of units that will gain a
	.BR Wants
	dependency on this mount unit.
	Setting this property implies
	.BR noauto .
	.TP 4
	.BR org.openzfs.systemd:required\-by = \fIunit\fR...
	Space-separated list of units that will gain a
	.BR Requires
	dependency on this mount unit.
	Setting this property implies
	.BR noauto .
	.TP 4
	.BR org.openzfs.systemd:nofail = unset \| on \| off
	Toggles between a
	.BR Wants
	and
	.BR Requires
	type of dependency between the mount unit and
	.BR local-fs.target ,
	if
	.BR noauto
	isn't set or implied.

	.BR on :
	Mount will be
	.BR WantedBy
	local-fs.target

	.BR off :
	Mount will be
	.BR Before
	and
	.BR RequiredBy
	local-fs.target

	.BR unset :
	Mount will be
	.BR Before
	and
	.BR WantedBy
	local-fs.target
	.TP 4
	.BR org.openzfs.systemd:ignore = on \| off
	If set to
	.BR on ,
	do not generate a mount unit for this dataset.

	-.RE
	See also
	.BR systemd.mount (5)

	.PP
	.SH EXAMPLE
	To begin, enable tracking for the pool:
	.PP
	.RS 4
	touch
	.RI @sysconfdir@/zfs/zfs-list.cache/ POOLNAME
	.RE
	.PP
	Then, enable the tracking ZEDLET:
	.PP
	.RS 4
	ln -s "@zfsexecdir@/zed.d/history_event-zfs-list-cacher.sh" "@sysconfdir@/zfs/zed.d"

	systemctl enable zfs-zed.service

	systemctl restart zfs-zed.service
	.RE
	.PP
	Force the running of the ZEDLET by setting a monitored property, e.g.
	.BR canmount ,
	for at least one dataset in the pool:
	.PP
	.RS 4
	zfs set canmount=on
	.I DATASET
	.RE
	.PP
	This forces an update to the stale cache file.

	To test the generator output, run
	.PP
	.RS 4
	@systemdgeneratordir@/zfs-mount-generator /tmp/zfs-mount-generator . .
	.RE
	.PP
	This will generate units and dependencies in
	.I /tmp/zfs-mount-generator
	for you to inspect them. The second and third argument are ignored.

	If you're satisfied with the generated units, instruct systemd to re-run all generators:
	.PP
	.RS 4
	systemctl daemon-reload
	.RE
	.PP

	.sp
	.SH SEE ALSO
	.BR zfs (5)
	.BR zfs-events (5)
	.BR zed (8)
	.BR zpool (5)
	.BR systemd (1)
	.BR systemd.target (5)
	.BR systemd.special (7)
	.BR systemd.mount (7)
	diff --git a/sys/contrib/openzfs/man/man8/zfs-program.8 b/sys/contrib/openzfs/man/man8/zfs-program.8
	index de708e12cec2..02251ae7cbad 100644
	--- a/sys/contrib/openzfs/man/man8/zfs-program.8
	+++ b/sys/contrib/openzfs/man/man8/zfs-program.8
	@@ -1,635 +1,636 @@
	.\" This file and its contents are supplied under the terms of the
	.\" Common Development and Distribution License ("CDDL"), version 1.0.
	.\" You may only use this file in accordance with the terms of version
	.\" 1.0 of the CDDL.
	.\"
	.\" A full copy of the text of the CDDL should have accompanied this
	.\" source. A copy of the CDDL is also available via the Internet at
	.\" http://www.illumos.org/license/CDDL.
	.\"
	.\"
	.\" Copyright (c) 2016, 2019 by Delphix. All Rights Reserved.
	.\" Copyright (c) 2019, 2020 by Christian Schwarz. All Rights Reserved.
	.\" Copyright 2020 Joyent, Inc.
	.\"
	.Dd January 26, 2021
	.Dt ZFS-PROGRAM 8
	.Os
	.Sh NAME
	.Nm zfs-program
	.Nd executes ZFS channel programs
	.Sh SYNOPSIS
	.Nm zfs
	.Cm program
	.Op Fl jn
	.Op Fl t Ar instruction-limit
	.Op Fl m Ar memory-limit
	.Ar pool
	.Ar script
	.\".Op Ar optional arguments to channel program
	.Sh DESCRIPTION
	The ZFS channel program interface allows ZFS administrative operations to be
	run programmatically as a Lua script.
	The entire script is executed atomically, with no other administrative
	operations taking effect concurrently.
	A library of ZFS calls is made available to channel program scripts.
	Channel programs may only be run with root privileges.
	.Pp
	A modified version of the Lua 5.2 interpreter is used to run channel program
	scripts.
	The Lua 5.2 manual can be found at:
	.Bd -centered -offset indent
	.Lk http://www.lua.org/manual/5.2/
	.Ed
	.Pp
	The channel program given by
	.Ar script
	will be run on
	.Ar pool ,
	and any attempts to access or modify other pools will cause an error.
	.Sh OPTIONS
	.Bl -tag -width "-t"
	.It Fl j
	Display channel program output in JSON format. When this flag is specified and
	standard output is empty - channel program encountered an error. The details of
	such an error will be printed to standard error in plain text.
	.It Fl n
	Executes a read-only channel program, which runs faster.
	The program cannot change on-disk state by calling functions from the
	zfs.sync submodule.
	The program can be used to gather information such as properties and
	determining if changes would succeed (zfs.check.*).
	Without this flag, all pending changes must be synced to disk before a
	channel program can complete.
	.It Fl t Ar instruction-limit
	Limit the number of Lua instructions to execute.
	If a channel program executes more than the specified number of instructions,
	it will be stopped and an error will be returned.
	The default limit is 10 million instructions, and it can be set to a maximum of
	100 million instructions.
	.It Fl m Ar memory-limit
	Memory limit, in bytes.
	If a channel program attempts to allocate more memory than the given limit, it
	will be stopped and an error returned.
	The default memory limit is 10 MB, and can be set to a maximum of 100 MB.
	.El
	.Pp
	All remaining argument strings will be passed directly to the Lua script as
	described in the
	.Sx LUA INTERFACE
	section below.
	.Sh LUA INTERFACE
	A channel program can be invoked either from the command line, or via a library
	call to
	.Fn lzc_channel_program .
	.Ss Arguments
	Arguments passed to the channel program are converted to a Lua table.
	If invoked from the command line, extra arguments to the Lua script will be
	accessible as an array stored in the argument table with the key 'argv':
	.Bd -literal -offset indent
	args = ...
	argv = args["argv"]
	-- argv == {1="arg1", 2="arg2", ...}
	.Ed
	.Pp
	If invoked from the libZFS interface, an arbitrary argument list can be
	passed to the channel program, which is accessible via the same
	"..." syntax in Lua:
	.Bd -literal -offset indent
	args = ...
	-- args == {"foo"="bar", "baz"={...}, ...}
	.Ed
	.Pp
	Note that because Lua arrays are 1-indexed, arrays passed to Lua from the
	libZFS interface will have their indices incremented by 1.
	That is, the element
	in
	.Va arr[0]
	in a C array passed to a channel program will be stored in
	.Va arr[1]
	when accessed from Lua.
	.Ss Return Values
	Lua return statements take the form:
	.Bd -literal -offset indent
	return ret0, ret1, ret2, ...
	.Ed
	.Pp
	Return statements returning multiple values are permitted internally in a
	channel program script, but attempting to return more than one value from the
	top level of the channel program is not permitted and will throw an error.
	However, tables containing multiple values can still be returned.
	If invoked from the command line, a return statement:
	.Bd -literal -offset indent
	a = {foo="bar", baz=2}
	return a
	.Ed
	.Pp
	Will be output formatted as:
	.Bd -literal -offset indent
	Channel program fully executed with return value:
	return:
	baz: 2
	foo: 'bar'
	.Ed
	.Ss Fatal Errors
	If the channel program encounters a fatal error while running, a non-zero exit
	status will be returned.
	If more information about the error is available, a singleton list will be
	returned detailing the error:
	.Bd -literal -offset indent
	error: "error string, including Lua stack trace"
	.Ed
	.Pp
	If a fatal error is returned, the channel program may have not executed at all,
	may have partially executed, or may have fully executed but failed to pass a
	return value back to userland.
	.Pp
	If the channel program exhausts an instruction or memory limit, a fatal error
	will be generated and the program will be stopped, leaving the program partially
	executed.
	No attempt is made to reverse or undo any operations already performed.
	Note that because both the instruction count and amount of memory used by a
	channel program are deterministic when run against the same inputs and
	filesystem state, as long as a channel program has run successfully once, you
	can guarantee that it will finish successfully against a similar size system.
	.Pp
	If a channel program attempts to return too large a value, the program will
	fully execute but exit with a nonzero status code and no return value.
	.Pp
	.Em Note :
	ZFS API functions do not generate Fatal Errors when correctly invoked, they
	return an error code and the channel program continues executing.
	See the
	.Sx ZFS API
	section below for function-specific details on error return codes.
	.Ss Lua to C Value Conversion
	When invoking a channel program via the libZFS interface, it is necessary to
	translate arguments and return values from Lua values to their C equivalents,
	and vice-versa.
	.Pp
	There is a correspondence between nvlist values in C and Lua tables.
	A Lua table which is returned from the channel program will be recursively
	converted to an nvlist, with table values converted to their natural
	equivalents:
	.Bd -literal -offset indent
	string -> string
	number -> int64
	boolean -> boolean_value
	nil -> boolean (no value)
	table -> nvlist
	.Ed
	.Pp
	Likewise, table keys are replaced by string equivalents as follows:
	.Bd -literal -offset indent
	string -> no change
	number -> signed decimal string ("%lld")
	boolean -> "true" \| "false"
	.Ed
	.Pp
	Any collision of table key strings (for example, the string "true" and a
	true boolean value) will cause a fatal error.
	.Pp
	Lua numbers are represented internally as signed 64-bit integers.
	.Sh LUA STANDARD LIBRARY
	The following Lua built-in base library functions are available:
	.Bd -literal -offset indent
	assert rawlen
	collectgarbage rawget
	error rawset
	getmetatable select
	ipairs setmetatable
	next tonumber
	pairs tostring
	rawequal type
	.Ed
	.Pp
	All functions in the
	.Em coroutine ,
	.Em string ,
	and
	.Em table
	built-in submodules are also available.
	A complete list and documentation of these modules is available in the Lua
	manual.
	.Pp
	The following functions base library functions have been disabled and are
	not available for use in channel programs:
	.Bd -literal -offset indent
	dofile
	loadfile
	load
	pcall
	print
	xpcall
	.Ed
	.Sh ZFS API
	.Ss Function Arguments
	Each API function takes a fixed set of required positional arguments and
	optional keyword arguments.
	For example, the destroy function takes a single positional string argument
	(the name of the dataset to destroy) and an optional "defer" keyword boolean
	argument.
	When using parentheses to specify the arguments to a Lua function, only
	positional arguments can be used:
	.Bd -literal -offset indent
	zfs.sync.destroy("rpool@snap")
	.Ed
	.Pp
	To use keyword arguments, functions must be called with a single argument that
	is a Lua table containing entries mapping integers to positional arguments and
	strings to keyword arguments:
	.Bd -literal -offset indent
	zfs.sync.destroy({1="rpool@snap", defer=true})
	.Ed
	.Pp
	The Lua language allows curly braces to be used in place of parenthesis as
	syntactic sugar for this calling convention:
	.Bd -literal -offset indent
	zfs.sync.snapshot{"rpool@snap", defer=true}
	.Ed
	.Ss Function Return Values
	If an API function succeeds, it returns 0.
	If it fails, it returns an error code and the channel program continues
	executing.
	API functions do not generate Fatal Errors except in the case of an
	unrecoverable internal file system error.
	.Pp
	In addition to returning an error code, some functions also return extra
	details describing what caused the error.
	This extra description is given as a second return value, and will always be a
	Lua table, or Nil if no error details were returned.
	Different keys will exist in the error details table depending on the function
	and error case.
	Any such function may be called expecting a single return value:
	.Bd -literal -offset indent
	errno = zfs.sync.promote(dataset)
	.Ed
	.Pp
	Or, the error details can be retrieved:
	.Bd -literal -offset indent
	errno, details = zfs.sync.promote(dataset)
	if (errno == EEXIST) then
	assert(details ~= Nil)
	list_of_conflicting_snapshots = details
	end
	.Ed
	.Pp
	The following global aliases for API function error return codes are defined
	for use in channel programs:
	.Bd -literal -offset indent
	EPERM ECHILD ENODEV ENOSPC
	ENOENT EAGAIN ENOTDIR ESPIPE
	ESRCH ENOMEM EISDIR EROFS
	EINTR EACCES EINVAL EMLINK
	EIO EFAULT ENFILE EPIPE
	ENXIO ENOTBLK EMFILE EDOM
	E2BIG EBUSY ENOTTY ERANGE
	ENOEXEC EEXIST ETXTBSY EDQUOT
	EBADF EXDEV EFBIG
	.Ed
	.Ss API Functions
	For detailed descriptions of the exact behavior of any zfs administrative
	operations, see the main
	.Xr zfs 8
	manual page.
	.Bl -tag -width "xx"
	.It Em zfs.debug(msg)
	Record a debug message in the zfs_dbgmsg log.
	A log of these messages can be printed via mdb's "::zfs_dbgmsg" command, or
	can be monitored live by running:
	.Bd -literal -offset indent
	dtrace -n 'zfs-dbgmsg{trace(stringof(arg0))}'
	.Ed
	.Pp
	msg (string)
	.Bd -ragged -compact -offset "xxxx"
	Debug message to be printed.
	.Ed
	.It Em zfs.exists(dataset)
	Returns true if the given dataset exists, or false if it doesn't.
	A fatal error will be thrown if the dataset is not in the target pool.
	That is, in a channel program running on rpool,
	zfs.exists("rpool/nonexistent_fs") returns false, but
	zfs.exists("somepool/fs_that_may_exist") will error.
	.Pp
	dataset (string)
	.Bd -ragged -compact -offset "xxxx"
	Dataset to check for existence.
	Must be in the target pool.
	.Ed
	.It Em zfs.get_prop(dataset, property)
	Returns two values.
	First, a string, number or table containing the property value for the given
	dataset.
	Second, a string containing the source of the property (i.e. the name of the
	dataset in which it was set or nil if it is readonly).
	Throws a Lua error if the dataset is invalid or the property doesn't exist.
	Note that Lua only supports int64 number types whereas ZFS number properties
	are uint64.
	This means very large values (like guid) may wrap around and appear negative.
	.Pp
	dataset (string)
	.Bd -ragged -compact -offset "xxxx"
	Filesystem or snapshot path to retrieve properties from.
	.Ed
	.Pp
	property (string)
	.Bd -ragged -compact -offset "xxxx"
	Name of property to retrieve.
	All filesystem, snapshot and volume properties are supported except
	for 'mounted' and 'iscsioptions.'
	Also supports the 'written@snap' and 'written#bookmark' properties and
	the '<user\|group><quota\|used>@id' properties, though the id must be in numeric
	form.
	.Ed
	.El
	.Bl -tag -width "xx"
	.It Sy zfs.sync submodule
	The sync submodule contains functions that modify the on-disk state.
	They are executed in "syncing context".
	.Pp
	The available sync submodule functions are as follows:
	.Bl -tag -width "xx"
	.It Em zfs.sync.destroy(dataset, [defer=true\|false])
	Destroy the given dataset.
	Returns 0 on successful destroy, or a nonzero error code if the dataset could
	not be destroyed (for example, if the dataset has any active children or
	clones).
	.Pp
	dataset (string)
	.Bd -ragged -compact -offset "xxxx"
	Filesystem or snapshot to be destroyed.
	.Ed
	.Pp
	[optional] defer (boolean)
	.Bd -ragged -compact -offset "xxxx"
	Valid only for destroying snapshots.
	If set to true, and the snapshot has holds or clones, allows the snapshot to be
	marked for deferred deletion rather than failing.
	.Ed
	.It Em zfs.sync.inherit(dataset, property)
	Clears the specified property in the given dataset, causing it to be inherited
	from an ancestor, or restored to the default if no ancestor property is set.
	The
	.Ql zfs inherit -S
	option has not been implemented.
	Returns 0 on success, or a nonzero error code if the property could not be
	cleared.
	.Pp
	dataset (string)
	.Bd -ragged -compact -offset "xxxx"
	Filesystem or snapshot containing the property to clear.
	.Ed
	.Pp
	property (string)
	.Bd -ragged -compact -offset "xxxx"
	The property to clear.
	Allowed properties are the same as those for the
	.Nm zfs Cm inherit
	command.
	.Ed
	.It Em zfs.sync.promote(dataset)
	Promote the given clone to a filesystem.
	Returns 0 on successful promotion, or a nonzero error code otherwise.
	If EEXIST is returned, the second return value will be an array of the clone's
	snapshots whose names collide with snapshots of the parent filesystem.
	.Pp
	dataset (string)
	.Bd -ragged -compact -offset "xxxx"
	Clone to be promoted.
	.Ed
	.It Em zfs.sync.rollback(filesystem)
	Rollback to the previous snapshot for a dataset.
	Returns 0 on successful rollback, or a nonzero error code otherwise.
	Rollbacks can be performed on filesystems or zvols, but not on snapshots
	or mounted datasets.
	EBUSY is returned in the case where the filesystem is mounted.
	.Pp
	filesystem (string)
	.Bd -ragged -compact -offset "xxxx"
	Filesystem to rollback.
	.Ed
	.It Em zfs.sync.set_prop(dataset, property, value)
	Sets the given property on a dataset.
	Currently only user properties are supported.
	Returns 0 if the property was set, or a nonzero error code otherwise.
	.Pp
	dataset (string)
	.Bd -ragged -compact -offset "xxxx"
	The dataset where the property will be set.
	.Ed
	.Pp
	property (string)
	.Bd -ragged -compact -offset "xxxx"
	The property to set.
	Only user properties are supported.
	.Ed
	.Pp
	value (string)
	.Bd -ragged -compact -offset "xxxx"
	The value of the property to be set.
	.Ed
	.It Em zfs.sync.snapshot(dataset)
	Create a snapshot of a filesystem.
	Returns 0 if the snapshot was successfully created,
	and a nonzero error code otherwise.
	.Pp
	Note: Taking a snapshot will fail on any pool older than legacy version 27.
	To enable taking snapshots from ZCP scripts, the pool must be upgraded.
	.Pp
	dataset (string)
	.Bd -ragged -compact -offset "xxxx"
	Name of snapshot to create.
	.Ed
	.It Em zfs.sync.bookmark(source, newbookmark)
	Create a bookmark of an existing source snapshot or bookmark.
	Returns 0 if the new bookmark was successfully created,
	and a nonzero error code otherwise.
	.Pp
	Note: Bookmarking requires the corresponding pool feature to be enabled.
	.Pp
	source (string)
	.Bd -ragged -compact -offset "xxxx"
	Full name of the existing snapshot or bookmark.
	.Ed
	.Pp
	newbookmark (string)
	.Bd -ragged -compact -offset "xxxx"
	Full name of the new bookmark.
	.El
	+.Ed
	.It Sy zfs.check submodule
	For each function in the zfs.sync submodule, there is a corresponding zfs.check
	function which performs a "dry run" of the same operation.
	Each takes the same arguments as its zfs.sync counterpart and returns 0 if the
	operation would succeed, or a non-zero error code if it would fail, along with
	any other error details.
	That is, each has the same behavior as the corresponding sync function except
	for actually executing the requested change.
	For example,
	.Em zfs.check.destroy("fs")
	returns 0 if
	.Em zfs.sync.destroy("fs")
	would successfully destroy the dataset.
	.Pp
	The available zfs.check functions are:
	.Bl -tag -width "xx"
	.It Em zfs.check.destroy(dataset, [defer=true\|false])
	.It Em zfs.check.promote(dataset)
	.It Em zfs.check.rollback(filesystem)
	.It Em zfs.check.set_property(dataset, property, value)
	.It Em zfs.check.snapshot(dataset)
	.El
	.It Sy zfs.list submodule
	The zfs.list submodule provides functions for iterating over datasets and
	properties.
	Rather than returning tables, these functions act as Lua iterators, and are
	generally used as follows:
	.Bd -literal -offset indent
	for child in zfs.list.children("rpool") do
	...
	end
	.Ed
	.Pp
	The available zfs.list functions are:
	.Bl -tag -width "xx"
	.It Em zfs.list.clones(snapshot)
	Iterate through all clones of the given snapshot.
	.Pp
	snapshot (string)
	.Bd -ragged -compact -offset "xxxx"
	Must be a valid snapshot path in the current pool.
	.Ed
	.It Em zfs.list.snapshots(dataset)
	Iterate through all snapshots of the given dataset.
	Each snapshot is returned as a string containing the full dataset name, e.g.
	"pool/fs@snap".
	.Pp
	dataset (string)
	.Bd -ragged -compact -offset "xxxx"
	Must be a valid filesystem or volume.
	.Ed
	.It Em zfs.list.children(dataset)
	Iterate through all direct children of the given dataset.
	Each child is returned as a string containing the full dataset name, e.g.
	"pool/fs/child".
	.Pp
	dataset (string)
	.Bd -ragged -compact -offset "xxxx"
	Must be a valid filesystem or volume.
	.Ed
	.It Em zfs.list.bookmarks(dataset)
	Iterate through all bookmarks of the given dataset. Each bookmark is returned
	as a string containing the full dataset name, e.g. "pool/fs#bookmark".
	.Pp
	dataset (string)
	.Bd -ragged -compact -offset "xxxx"
	Must be a valid filesystem or volume.
	.Ed
	.It Em zfs.list.holds(snapshot)
	Iterate through all user holds on the given snapshot. Each hold is returned
	as a pair of the hold's tag and the timestamp (in seconds since the epoch) at
	which it was created.
	.Pp
	snapshot (string)
	.Bd -ragged -compact -offset "xxxx"
	Must be a valid snapshot.
	.Ed
	.It Em zfs.list.properties(dataset)
	An alias for zfs.list.user_properties (see relevant entry).
	.Pp
	dataset (string)
	.Bd -ragged -compact -offset "xxxx"
	Must be a valid filesystem, snapshot, or volume.
	.Ed
	.It Em zfs.list.user_properties(dataset)
	Iterate through all user properties for the given dataset. For each
	step of the iteration, output the property name, its value, and its source.
	Throws a Lua error if the dataset is invalid.
	.Pp
	dataset (string)
	.Bd -ragged -compact -offset "xxxx"
	Must be a valid filesystem, snapshot, or volume.
	.Ed
	.It Em zfs.list.system_properties(dataset)
	Returns an array of strings, the names of the valid system (non-user defined)
	properties for the given dataset.
	Throws a Lua error if the dataset is invalid.
	.Pp
	dataset (string)
	.Bd -ragged -compact -offset "xxxx"
	Must be a valid filesystem, snapshot or volume.
	.Ed
	.El
	.El
	.Sh EXAMPLES
	.Ss Example 1
	The following channel program recursively destroys a filesystem and all its
	snapshots and children in a naive manner.
	Note that this does not involve any error handling or reporting.
	.Bd -literal -offset indent
	function destroy_recursive(root)
	for child in zfs.list.children(root) do
	destroy_recursive(child)
	end
	for snap in zfs.list.snapshots(root) do
	zfs.sync.destroy(snap)
	end
	zfs.sync.destroy(root)
	end
	destroy_recursive("pool/somefs")
	.Ed
	.Ss Example 2
	A more verbose and robust version of the same channel program, which
	properly detects and reports errors, and also takes the dataset to destroy
	as a command line argument, would be as follows:
	.Bd -literal -offset indent
	succeeded = {}
	failed = {}

	function destroy_recursive(root)
	for child in zfs.list.children(root) do
	destroy_recursive(child)
	end
	for snap in zfs.list.snapshots(root) do
	err = zfs.sync.destroy(snap)
	if (err ~= 0) then
	failed[snap] = err
	else
	succeeded[snap] = err
	end
	end
	err = zfs.sync.destroy(root)
	if (err ~= 0) then
	failed[root] = err
	else
	succeeded[root] = err
	end
	end

	args = ...
	argv = args["argv"]

	destroy_recursive(argv[1])

	results = {}
	results["succeeded"] = succeeded
	results["failed"] = failed
	return results
	.Ed
	.Ss Example 3
	The following function performs a forced promote operation by attempting to
	promote the given clone and destroying any conflicting snapshots.
	.Bd -literal -offset indent
	function force_promote(ds)
	errno, details = zfs.check.promote(ds)
	if (errno == EEXIST) then
	assert(details ~= Nil)
	for i, snap in ipairs(details) do
	zfs.sync.destroy(ds .. "@" .. snap)
	end
	elseif (errno ~= 0) then
	return errno
	end
	return zfs.sync.promote(ds)
	end
	.Ed
	diff --git a/sys/contrib/openzfs/man/man8/zfs-send.8 b/sys/contrib/openzfs/man/man8/zfs-send.8
	index 4156db4f6b47..5a072c18527a 100644
	--- a/sys/contrib/openzfs/man/man8/zfs-send.8
	+++ b/sys/contrib/openzfs/man/man8/zfs-send.8
	@@ -1,614 +1,620 @@
	.\"
	.\" 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) 2009 Sun Microsystems, Inc. All Rights Reserved.
	.\" Copyright 2011 Joshua M. Clulow <josh@sysmgr.org>
	.\" Copyright (c) 2011, 2019 by Delphix. All rights reserved.
	.\" Copyright (c) 2013 by Saso Kiselkov. All rights reserved.
	.\" Copyright (c) 2014, Joyent, Inc. All rights reserved.
	.\" Copyright (c) 2014 by Adam Stevko. All rights reserved.
	.\" Copyright (c) 2014 Integros [integros.com]
	.\" Copyright 2019 Richard Laager. All rights reserved.
	.\" Copyright 2018 Nexenta Systems, Inc.
	.\" Copyright 2019 Joyent, Inc.
	.\"
	-.Dd June 30, 2019
	+.Dd April 15, 2021
	.Dt ZFS-SEND 8
	.Os
	.Sh NAME
	.Nm zfs-send
	.Nd Generate a send stream, which may be of a filesystem, and may be incremental from a bookmark.
	.Sh SYNOPSIS
	.Nm zfs
	.Cm send
	-.Op Fl DLPRbcehnpvw
	+.Op Fl DLPRbcehnpsvw
	.Op Oo Fl I Ns \| Ns Fl i Oc Ar snapshot
	.Ar snapshot
	.Nm zfs
	.Cm send
	-.Op Fl DLPRcenpvw
	+.Op Fl DLPRcenpsvw
	.Op Fl i Ar snapshot Ns \| Ns Ar bookmark
	.Ar filesystem Ns \| Ns Ar volume Ns \| Ns Ar snapshot
	.Nm zfs
	.Cm send
	.Fl -redact Ar redaction_bookmark
	.Op Fl DLPcenpv
	.br
	.Op Fl i Ar snapshot Ns \| Ns Ar bookmark
	.Ar snapshot
	.Nm zfs
	.Cm send
	.Op Fl Penv
	.Fl t
	.Ar receive_resume_token
	.Nm zfs
	.Cm send
	.Op Fl Pnv
	.Fl S Ar filesystem
	.Nm zfs
	.Cm redact
	.Ar snapshot redaction_bookmark
	.Ar redaction_snapshot Ns ...
	.Sh DESCRIPTION
	.Bl -tag -width ""
	.It Xo
	.Nm zfs
	.Cm send
	.Op Fl DLPRbcehnpvw
	.Op Oo Fl I Ns \| Ns Fl i Oc Ar snapshot
	.Ar snapshot
	.Xc
	Creates a stream representation of the second
	.Ar snapshot ,
	which is written to standard output.
	The output can be redirected to a file or to a different system
	.Po for example, using
	.Xr ssh 1
	.Pc .
	By default, a full stream is generated.
	.Bl -tag -width "-D"
	.It Fl D, -dedup
	Deduplicated send is no longer supported.
	This flag is accepted for backwards compatibility, but a regular,
	non-deduplicated stream will be generated.
	.It Fl I Ar snapshot
	Generate a stream package that sends all intermediary snapshots from the first
	snapshot to the second snapshot.
	For example,
	.Fl I Em @a Em fs@d
	is similar to
	.Fl i Em @a Em fs@b Ns \&; Fl i Em @b Em fs@c Ns \&; Fl i Em @c Em fs@d .
	The incremental source may be specified as with the
	.Fl i
	option.
	.It Fl L, -large-block
	Generate a stream which may contain blocks larger than 128KB.
	This flag has no effect if the
	.Sy large_blocks
	pool feature is disabled, or if the
	.Sy recordsize
	property of this filesystem has never been set above 128KB.
	The receiving system must have the
	.Sy large_blocks
	pool feature enabled as well.
	See
	.Xr zpool-features 5
	for details on ZFS feature flags and the
	.Sy large_blocks
	feature.
	.It Fl P, -parsable
	Print machine-parsable verbose information about the stream package generated.
	.It Fl R, -replicate
	Generate a replication stream package, which will replicate the specified
	file system, and all descendent file systems, up to the named snapshot.
	When received, all properties, snapshots, descendent file systems, and clones
	are preserved.
	.Pp
	If the
	.Fl i
	or
	.Fl I
	flags are used in conjunction with the
	.Fl R
	flag, an incremental replication stream is generated.
	The current values of properties, and current snapshot and file system names are
	set when the stream is received.
	If the
	.Fl F
	flag is specified when this stream is received, snapshots and file systems that
	do not exist on the sending side are destroyed. If the
	.Fl R
	flag is used to send encrypted datasets, then
	.Fl w
	must also be specified.
	.It Fl e, -embed
	Generate a more compact stream by using
	.Sy WRITE_EMBEDDED
	records for blocks which are stored more compactly on disk by the
	.Sy embedded_data
	pool feature.
	This flag has no effect if the
	.Sy embedded_data
	feature is disabled.
	The receiving system must have the
	.Sy embedded_data
	feature enabled.
	If the
	.Sy lz4_compress
	feature is active on the sending system, then the receiving system must have
	that feature enabled as well. Datasets that are sent with this flag may not be
	received as an encrypted dataset, since encrypted datasets cannot use the
	.Sy embedded_data
	feature.
	See
	.Xr zpool-features 5
	for details on ZFS feature flags and the
	.Sy embedded_data
	feature.
	.It Fl b, -backup
	Sends only received property values whether or not they are overridden by local
	settings, but only if the dataset has ever been received. Use this option when
	you want
	.Nm zfs Cm receive
	to restore received properties backed up on the sent dataset and to avoid
	sending local settings that may have nothing to do with the source dataset,
	but only with how the data is backed up.
	.It Fl c, -compressed
	Generate a more compact stream by using compressed WRITE records for blocks
	which are compressed on disk and in memory
	.Po see the
	.Sy compression
	property for details
	.Pc .
	If the
	.Sy lz4_compress
	feature is active on the sending system, then the receiving system must have
	that feature enabled as well.
	If the
	.Sy large_blocks
	feature is enabled on the sending system but the
	.Fl L
	option is not supplied in conjunction with
	.Fl c ,
	then the data will be decompressed before sending so it can be split into
	smaller block sizes. Streams sent with
	.Fl c
	will not have their data recompressed on the receiver side using
	.Fl o compress=value.
	The data will stay compressed as it was from the sender. The new compression
	property will be set for future data.
	.It Fl w, -raw
	For encrypted datasets, send data exactly as it exists on disk. This allows
	backups to be taken even if encryption keys are not currently loaded. The
	backup may then be received on an untrusted machine since that machine will
	not have the encryption keys to read the protected data or alter it without
	being detected. Upon being received, the dataset will have the same encryption
	keys as it did on the send side, although the
	.Sy keylocation
	property will be defaulted to
	.Sy prompt
	if not otherwise provided. For unencrypted datasets, this flag will be
	equivalent to
	.Fl Lec .
	Note that if you do not use this flag for sending encrypted datasets, data will
	be sent unencrypted and may be re-encrypted with a different encryption key on
	the receiving system, which will disable the ability to do a raw send to that
	system for incrementals.
	.It Fl h, -holds
	Generate a stream package that includes any snapshot holds (created with the
	.Sy zfs hold
	command), and indicating to
	.Sy zfs receive
	that the holds be applied to the dataset on the receiving system.
	.It Fl i Ar snapshot
	Generate an incremental stream from the first
	.Ar snapshot
	.Pq the incremental source
	to the second
	.Ar snapshot
	.Pq the incremental target .
	The incremental source can be specified as the last component of the snapshot
	name
	.Po the
	.Sy @
	character and following
	.Pc
	and it is assumed to be from the same file system as the incremental target.
	.Pp
	If the destination is a clone, the source may be the origin snapshot, which must
	be fully specified
	.Po for example,
	.Em pool/fs@origin ,
	not just
	.Em @origin
	.Pc .
	.It Fl n, -dryrun
	Do a dry-run
	.Pq Qq No-op
	send.
	Do not generate any actual send data.
	This is useful in conjunction with the
	.Fl v
	or
	.Fl P
	flags to determine what data will be sent.
	In this case, the verbose output will be written to standard output
	.Po contrast with a non-dry-run, where the stream is written to standard output
	and the verbose output goes to standard error
	.Pc .
	.It Fl p, -props
	Include the dataset's properties in the stream.
	This flag is implicit when
	.Fl R
	is specified.
	The receiving system must also support this feature. Sends of encrypted datasets
	must use
	.Fl w
	when using this flag.
	+.It Fl s, -skip-missing
	+Allows sending a replication stream even when there are snapshots missing in the
	+hierarchy. When a snapshot is missing, instead of throwing an error and aborting
	+the send, a warning is printed to STDERR and the dataset to which it belongs
	+and its descendents are skipped. This flag can only be used in conjunction with
	+.Fl R .
	.It Fl v, -verbose
	Print verbose information about the stream package generated.
	This information includes a per-second report of how much data has been sent.
	.Pp
	The format of the stream is committed.
	You will be able to receive your streams on future versions of ZFS.
	.El
	.It Xo
	.Nm zfs
	.Cm send
	.Op Fl DLPRcenpvw
	.Op Fl i Ar snapshot Ns \| Ns Ar bookmark
	.Ar filesystem Ns \| Ns Ar volume Ns \| Ns Ar snapshot
	.Xc
	Generate a send stream, which may be of a filesystem, and may be incremental
	from a bookmark.
	If the destination is a filesystem or volume, the pool must be read-only, or the
	filesystem must not be mounted.
	When the stream generated from a filesystem or volume is received, the default
	snapshot name will be
	.Qq --head-- .
	.Bl -tag -width "-L"
	.It Fl L, -large-block
	Generate a stream which may contain blocks larger than 128KB.
	This flag has no effect if the
	.Sy large_blocks
	pool feature is disabled, or if the
	.Sy recordsize
	property of this filesystem has never been set above 128KB.
	The receiving system must have the
	.Sy large_blocks
	pool feature enabled as well.
	See
	.Xr zpool-features 5
	for details on ZFS feature flags and the
	.Sy large_blocks
	feature.
	.It Fl P, -parsable
	Print machine-parsable verbose information about the stream package generated.
	.It Fl c, -compressed
	Generate a more compact stream by using compressed WRITE records for blocks
	which are compressed on disk and in memory
	.Po see the
	.Sy compression
	property for details
	.Pc .
	If the
	.Sy lz4_compress
	feature is active on the sending system, then the receiving system must have
	that feature enabled as well.
	If the
	.Sy large_blocks
	feature is enabled on the sending system but the
	.Fl L
	option is not supplied in conjunction with
	.Fl c ,
	then the data will be decompressed before sending so it can be split into
	smaller block sizes.
	.It Fl w, -raw
	For encrypted datasets, send data exactly as it exists on disk. This allows
	backups to be taken even if encryption keys are not currently loaded. The
	backup may then be received on an untrusted machine since that machine will
	not have the encryption keys to read the protected data or alter it without
	being detected. Upon being received, the dataset will have the same encryption
	keys as it did on the send side, although the
	.Sy keylocation
	property will be defaulted to
	.Sy prompt
	if not otherwise provided. For unencrypted datasets, this flag will be
	equivalent to
	.Fl Lec .
	Note that if you do not use this flag for sending encrypted datasets, data will
	be sent unencrypted and may be re-encrypted with a different encryption key on
	the receiving system, which will disable the ability to do a raw send to that
	system for incrementals.
	.It Fl e, -embed
	Generate a more compact stream by using
	.Sy WRITE_EMBEDDED
	records for blocks which are stored more compactly on disk by the
	.Sy embedded_data
	pool feature.
	This flag has no effect if the
	.Sy embedded_data
	feature is disabled.
	The receiving system must have the
	.Sy embedded_data
	feature enabled.
	If the
	.Sy lz4_compress
	feature is active on the sending system, then the receiving system must have
	that feature enabled as well. Datasets that are sent with this flag may not be
	received as an encrypted dataset, since encrypted datasets cannot use the
	.Sy embedded_data
	feature.
	See
	.Xr zpool-features 5
	for details on ZFS feature flags and the
	.Sy embedded_data
	feature.
	.It Fl i Ar snapshot Ns \| Ns Ar bookmark
	Generate an incremental send stream.
	The incremental source must be an earlier snapshot in the destination's history.
	It will commonly be an earlier snapshot in the destination's file system, in
	which case it can be specified as the last component of the name
	.Po the
	.Sy #
	or
	.Sy @
	character and following
	.Pc .
	.Pp
	If the incremental target is a clone, the incremental source can be the origin
	snapshot, or an earlier snapshot in the origin's filesystem, or the origin's
	origin, etc.
	.It Fl n, -dryrun
	Do a dry-run
	.Pq Qq No-op
	send.
	Do not generate any actual send data.
	This is useful in conjunction with the
	.Fl v
	or
	.Fl P
	flags to determine what data will be sent.
	In this case, the verbose output will be written to standard output
	.Po contrast with a non-dry-run, where the stream is written to standard output
	and the verbose output goes to standard error
	.Pc .
	.It Fl v, -verbose
	Print verbose information about the stream package generated.
	This information includes a per-second report of how much data has been sent.
	.El
	.It Xo
	.Nm zfs
	.Cm send
	.Fl -redact Ar redaction_bookmark
	.Op Fl DLPcenpv
	.br
	.Op Fl i Ar snapshot Ns \| Ns Ar bookmark
	.Ar snapshot
	.Xc
	Generate a redacted send stream.
	This send stream contains all blocks from the snapshot being sent that aren't
	included in the redaction list contained in the bookmark specified by the
	.Fl -redact
	(or
	.Fl -d
	) flag.
	The resulting send stream is said to be redacted with respect to the snapshots
	the bookmark specified by the
	.Fl -redact No flag was created with.
	The bookmark must have been created by running
	.Sy zfs redact
	on the snapshot being sent.
	.sp
	This feature can be used to allow clones of a filesystem to be made available on
	a remote system, in the case where their parent need not (or needs to not) be
	usable.
	For example, if a filesystem contains sensitive data, and it has clones where
	that sensitive data has been secured or replaced with dummy data, redacted sends
	can be used to replicate the secured data without replicating the original
	sensitive data, while still sharing all possible blocks.
	A snapshot that has been redacted with respect to a set of snapshots will
	contain all blocks referenced by at least one snapshot in the set, but will
	contain none of the blocks referenced by none of the snapshots in the set.
	In other words, if all snapshots in the set have modified a given block in the
	parent, that block will not be sent; but if one or more snapshots have not
	modified a block in the parent, they will still reference the parent's block, so
	that block will be sent.
	Note that only user data will be redacted.
	.sp
	When the redacted send stream is received, we will generate a redacted
	snapshot.
	Due to the nature of redaction, a redacted dataset can only be used in the
	following ways:
	.sp
	1. To receive, as a clone, an incremental send from the original snapshot to one
	of the snapshots it was redacted with respect to.
	In this case, the stream will produce a valid dataset when received because all
	blocks that were redacted in the parent are guaranteed to be present in the
	child's send stream.
	This use case will produce a normal snapshot, which can be used just like other
	snapshots.
	.sp
	2. To receive an incremental send from the original snapshot to something
	redacted with respect to a subset of the set of snapshots the initial snapshot
	was redacted with respect to.
	In this case, each block that was redacted in the original is still redacted
	(redacting with respect to additional snapshots causes less data to be redacted
	(because the snapshots define what is permitted, and everything else is
	redacted)).
	This use case will produce a new redacted snapshot.
	.sp
	3. To receive an incremental send from a redaction bookmark of the original
	snapshot that was created when redacting with respect to a subset of the set of
	snapshots the initial snapshot was created with respect to
	anything else.
	A send stream from such a redaction bookmark will contain all of the blocks
	necessary to fill in any redacted data, should it be needed, because the sending
	system is aware of what blocks were originally redacted.
	This will either produce a normal snapshot or a redacted one, depending on
	whether the new send stream is redacted.
	.sp
	4. To receive an incremental send from a redacted version of the initial
	snapshot that is redacted with respect to a subject of the set of snapshots the
	initial snapshot was created with respect to.
	A send stream from a compatible redacted dataset will contain all of the blocks
	necessary to fill in any redacted data.
	This will either produce a normal snapshot or a redacted one, depending on
	whether the new send stream is redacted.
	.sp
	5. To receive a full send as a clone of the redacted snapshot.
	Since the stream is a full send, it definitionally contains all the data needed
	to create a new dataset.
	This use case will either produce a normal snapshot or a redacted one, depending
	on whether the full send stream was redacted.
	.sp
	These restrictions are detected and enforced by \fBzfs receive\fR; a
	redacted send stream will contain the list of snapshots that the stream is
	redacted with respect to.
	These are stored with the redacted snapshot, and are used to detect and
	correctly handle the cases above. Note that for technical reasons, raw sends
	and redacted sends cannot be combined at this time.
	.It Xo
	.Nm zfs
	.Cm send
	.Op Fl Penv
	.Fl t
	.Ar receive_resume_token
	.Xc
	Creates a send stream which resumes an interrupted receive.
	The
	.Ar receive_resume_token
	is the value of this property on the filesystem or volume that was being
	received into.
	See the documentation for
	.Sy zfs receive -s
	for more details.
	.It Xo
	.Nm zfs
	.Cm send
	.Op Fl Pnv
	.Op Fl i Ar snapshot Ns \| Ns Ar bookmark
	.Fl S
	.Ar filesystem
	.Xc
	Generate a send stream from a dataset that has been partially received.
	.Bl -tag -width "-L"
	.It Fl S, -saved
	This flag requires that the specified filesystem previously received a resumable
	send that did not finish and was interrupted. In such scenarios this flag
	enables the user to send this partially received state. Using this flag will
	always use the last fully received snapshot as the incremental source if it
	exists.
	.El
	.It Xo
	.Nm zfs
	.Cm redact
	.Ar snapshot redaction_bookmark
	.Ar redaction_snapshot Ns ...
	.Xc
	Generate a new redaction bookmark.
	In addition to the typical bookmark information, a redaction bookmark contains
	the list of redacted blocks and the list of redaction snapshots specified.
	The redacted blocks are blocks in the snapshot which are not referenced by any
	of the redaction snapshots.
	These blocks are found by iterating over the metadata in each redaction snapshot
	to determine what has been changed since the target snapshot.
	Redaction is designed to support redacted zfs sends; see the entry for
	.Sy zfs send
	for more information on the purpose of this operation.
	If a redact operation fails partway through (due to an error or a system
	failure), the redaction can be resumed by rerunning the same command.
	.El
	.Ss Redaction
	ZFS has support for a limited version of data subsetting, in the form of
	redaction. Using the
	.Sy zfs redact
	command, a
	.Sy redaction bookmark
	can be created that stores a list of blocks containing sensitive information. When
	provided to
	.Sy zfs
	.Sy send ,
	this causes a
	.Sy redacted send
	to occur. Redacted sends omit the blocks containing sensitive information,
	replacing them with REDACT records. When these send streams are received, a
	.Sy redacted dataset
	is created. A redacted dataset cannot be mounted by default, since it is
	incomplete. It can be used to receive other send streams. In this way datasets
	can be used for data backup and replication, with all the benefits that zfs send
	and receive have to offer, while protecting sensitive information from being
	stored on less-trusted machines or services.
	.Pp
	For the purposes of redaction, there are two steps to the process. A redact
	step, and a send/receive step. First, a redaction bookmark is created. This is
	done by providing the
	.Sy zfs redact
	command with a parent snapshot, a bookmark to be created, and a number of
	redaction snapshots. These redaction snapshots must be descendants of the
	parent snapshot, and they should modify data that is considered sensitive in
	some way. Any blocks of data modified by all of the redaction snapshots will
	be listed in the redaction bookmark, because it represents the truly sensitive
	information. When it comes to the send step, the send process will not send
	the blocks listed in the redaction bookmark, instead replacing them with
	REDACT records. When received on the target system, this will create a
	redacted dataset, missing the data that corresponds to the blocks in the
	redaction bookmark on the sending system. The incremental send streams from
	the original parent to the redaction snapshots can then also be received on
	the target system, and this will produce a complete snapshot that can be used
	normally. Incrementals from one snapshot on the parent filesystem and another
	can also be done by sending from the redaction bookmark, rather than the
	snapshots themselves.
	.Pp
	In order to make the purpose of the feature more clear, an example is
	provided. Consider a zfs filesystem containing four files. These files
	represent information for an online shopping service. One file contains a list
	of usernames and passwords, another contains purchase histories, a third
	contains click tracking data, and a fourth contains user preferences. The
	owner of this data wants to make it available for their development teams to
	test against, and their market research teams to do analysis on. The
	development teams need information about user preferences and the click
	tracking data, while the market research teams need information about purchase
	histories and user preferences. Neither needs access to the usernames and
	passwords. However, because all of this data is stored in one ZFS filesystem,
	it must all be sent and received together. In addition, the owner of the data
	wants to take advantage of features like compression, checksumming, and
	snapshots, so they do want to continue to use ZFS to store and transmit their
	data. Redaction can help them do so. First, they would make two clones of a
	snapshot of the data on the source. In one clone, they create the setup they
	want their market research team to see; they delete the usernames and
	passwords file, and overwrite the click tracking data with dummy
	information. In another, they create the setup they want the development teams
	to see, by replacing the passwords with fake information and replacing the
	purchase histories with randomly generated ones. They would then create a
	redaction bookmark on the parent snapshot, using snapshots on the two clones
	as redaction snapshots. The parent can then be sent, redacted, to the target
	server where the research and development teams have access. Finally,
	incremental sends from the parent snapshot to each of the clones can be send
	to and received on the target server; these snapshots are identical to the
	ones on the source, and are ready to be used, while the parent snapshot on the
	target contains none of the username and password data present on the source,
	because it was removed by the redacted send operation.
	.Sh SEE ALSO
	.Xr zfs-bookmark 8 ,
	.Xr zfs-receive 8 ,
	.Xr zfs-redact 8 ,
	.Xr zfs-snapshot 8
	diff --git a/sys/contrib/openzfs/man/man8/zfs-wait.8 b/sys/contrib/openzfs/man/man8/zfs-wait.8
	index c3a85e29c6c0..9213fa20f1ff 100644
	--- a/sys/contrib/openzfs/man/man8/zfs-wait.8
	+++ b/sys/contrib/openzfs/man/man8/zfs-wait.8
	@@ -1,71 +1,70 @@
	.\"
	.\" 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) 2007, Sun Microsystems, Inc. All Rights Reserved.
	.\" Copyright (c) 2012, 2018 by Delphix. All rights reserved.
	.\" Copyright (c) 2012 Cyril Plisko. All Rights Reserved.
	.\" Copyright (c) 2017 Datto Inc.
	.\" Copyright (c) 2018 George Melikov. All Rights Reserved.
	.\" Copyright 2017 Nexenta Systems, Inc.
	.\" Copyright (c) 2017 Open-E, Inc. All Rights Reserved.
	.\"
	.Dd August 9, 2019
	.Dt ZFS-WAIT 8
	.Os
	.Sh NAME
	.Nm zfs-wait
	.Nd Wait for background activity to stop in a ZFS filesystem
	.Sh SYNOPSIS
	.Nm zfs
	.Cm wait
	.Op Fl t Ar activity Ns Oo , Ns Ar activity Ns Oc Ns ...
	.Ar fs
	.Sh DESCRIPTION
	.Bl -tag -width Ds
	.It Xo
	.Nm zfs
	.Cm wait
	.Op Fl t Ar activity Ns Oo , Ns Ar activity Ns Oc Ns ...
	.Ar fs
	.Xc
	Waits until all background activity of the given types has ceased in the given
	filesystem.
	The activity could cease because it has completed or because the filesystem has
	been destroyed or unmounted.
	If no activities are specified, the command waits until background activity of
	every type listed below has ceased.
	If there is no activity of the given types in progress, the command returns
	immediately.
	.Pp
	These are the possible values for
	.Ar activity ,
	along with what each one waits for:
	.Bd -literal
	deleteq The filesystem's internal delete queue to empty
	.Ed
	.Pp
	Note that the internal delete queue does not finish draining until
	all large files have had time to be fully destroyed and all open file
	handles to unlinked files are closed.
	.El
	-.El
	.Sh SEE ALSO
	-.Xr lsof 8
	+.Xr lsof 8
	diff --git a/sys/contrib/openzfs/man/man8/zfs.8 b/sys/contrib/openzfs/man/man8/zfs.8
	index 4cff97792a9f..52000f29b463 100644
	--- a/sys/contrib/openzfs/man/man8/zfs.8
	+++ b/sys/contrib/openzfs/man/man8/zfs.8
	@@ -1,777 +1,777 @@
	.\"
	.\" 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) 2009 Sun Microsystems, Inc. All Rights Reserved.
	.\" Copyright 2011 Joshua M. Clulow <josh@sysmgr.org>
	.\" Copyright (c) 2011, 2019 by Delphix. All rights reserved.
	.\" Copyright (c) 2011, Pawel Jakub Dawidek <pjd@FreeBSD.org>
	.\" Copyright (c) 2012, Glen Barber <gjb@FreeBSD.org>
	.\" Copyright (c) 2012, Bryan Drewery <bdrewery@FreeBSD.org>
	.\" Copyright (c) 2013, Steven Hartland <smh@FreeBSD.org>
	.\" Copyright (c) 2013 by Saso Kiselkov. All rights reserved.
	.\" Copyright (c) 2014, Joyent, Inc. All rights reserved.
	.\" Copyright (c) 2014 by Adam Stevko. All rights reserved.
	.\" Copyright (c) 2014 Integros [integros.com]
	.\" Copyright (c) 2014, Xin LI <delphij@FreeBSD.org>
	.\" Copyright (c) 2014-2015, The FreeBSD Foundation, All Rights Reserved.
	.\" Copyright (c) 2016 Nexenta Systems, Inc. All Rights Reserved.
	.\" Copyright 2019 Richard Laager. All rights reserved.
	.\" Copyright 2018 Nexenta Systems, Inc.
	.\" Copyright 2019 Joyent, Inc.
	.\"
	.Dd June 30, 2019
	.Dt ZFS 8
	.Os
	.Sh NAME
	.Nm zfs
	.Nd configures ZFS file systems
	.Sh SYNOPSIS
	.Nm
	.Fl ?V
	.Nm
	.Cm version
	.Nm
	.Cm <subcommand>
	.Op Ar <args>
	.Sh DESCRIPTION
	The
	.Nm
	command configures ZFS datasets within a ZFS storage pool, as described in
	.Xr zpool 8 .
	A dataset is identified by a unique path within the ZFS namespace.
	For example:
	.Bd -literal
	pool/{filesystem,volume,snapshot}
	.Ed
	.Pp
	where the maximum length of a dataset name is
	.Dv MAXNAMELEN
	.Pq 256 bytes
	and the maximum amount of nesting allowed in a path is 50 levels deep.
	.Pp
	A dataset can be one of the following:
	.Bl -tag -width "file system"
	.It Sy file system
	A ZFS dataset of type
	.Sy filesystem
	can be mounted within the standard system namespace and behaves like other file
	systems.
	While ZFS file systems are designed to be POSIX compliant, known issues exist
	that prevent compliance in some cases.
	Applications that depend on standards conformance might fail due to non-standard
	behavior when checking file system free space.
	.It Sy volume
	A logical volume exported as a raw or block device.
	This type of dataset should only be used when a block device is required.
	File systems are typically used in most environments.
	.It Sy snapshot
	A read-only version of a file system or volume at a given point in time.
	It is specified as
	.Ar filesystem Ns @ Ns Ar name
	or
	.Ar volume Ns @ Ns Ar name .
	.It Sy bookmark
	Much like a
	.Sy snapshot ,
	but without the hold on on-disk data.
	It can be used as the source of a send (but not for a receive). It is specified as
	.Ar filesystem Ns # Ns Ar name
	or
	.Ar volume Ns # Ns Ar name .
	.El
	.Pp
	For details see
	.Xr zfsconcepts 8 .
	.Ss Properties
	Properties are divided into two types, native properties and user-defined
	.Po or
	.Qq user
	.Pc
	properties.
	Native properties either export internal statistics or control ZFS behavior.
	In addition, native properties are either editable or read-only.
	User properties have no effect on ZFS behavior, but you can use them to annotate
	datasets in a way that is meaningful in your environment.
	For more information about properties, see the
	.Xr zfsprops 8 man page.
	.Ss Encryption
	Enabling the
	.Sy encryption
	feature allows for the creation of encrypted filesystems and volumes.
	ZFS will encrypt file and zvol data, file attributes, ACLs, permission bits,
	directory listings, FUID mappings, and
	.Sy userused
	/
	.Sy groupused
	data.
	For an overview of encryption see the
	.Xr zfs-load-key 8 command manual.
	.Sh SUBCOMMANDS
	All subcommands that modify state are logged persistently to the pool in their
	original form.
	.Bl -tag -width ""
	.It Nm Fl ?
	Displays a help message.
	.It Xo
	.Nm
	.Fl V , -version
	.Xc
	An alias for the
	.Nm zfs Cm version
	subcommand.
	.It Xo
	.Nm
	.Cm version
	.Xc
	Displays the software version of the
	.Nm
	userland utility and the zfs kernel module.
	.El
	.Ss Dataset Management
	.Bl -tag -width ""
	.It Xr zfs-list 8
	Lists the property information for the given datasets in tabular form.
	.It Xr zfs-create 8
	Creates a new ZFS file system or volume.
	.It Xr zfs-destroy 8
	Destroys the given dataset(s), snapshot(s), or bookmark.
	.It Xr zfs-rename 8
	Renames the given dataset (filesystem or snapshot).
	.It Xr zfs-upgrade 8
	Manage upgrading the on-disk version of filesystems.
	.El
	.Ss Snapshots
	.Bl -tag -width ""
	.It Xr zfs-snapshot 8
	Creates snapshots with the given names.
	.It Xr zfs-rollback 8
	Roll back the given dataset to a previous snapshot.
	.It Xo
	.Xr zfs-hold 8 /
	.Xr zfs-release 8
	.Xc
	Add or remove a hold reference to the specified snapshot or snapshots.
	If a hold exists on a snapshot, attempts to destroy that snapshot by using the
	.Nm zfs Cm destroy
	command return
	.Er EBUSY .
	.It Xr zfs-diff 8
	Display the difference between a snapshot of a given filesystem and another
	snapshot of that filesystem from a later time or the current contents of the
	filesystem.
	.El
	.Ss Clones
	.Bl -tag -width ""
	.It Xr zfs-clone 8
	Creates a clone of the given snapshot.
	.It Xr zfs-promote 8
	Promotes a clone file system to no longer be dependent on its
	.Qq origin
	snapshot.
	.El
	.Ss Send & Receive
	.Bl -tag -width ""
	.It Xr zfs-send 8
	Generate a send stream, which may be of a filesystem, and may be incremental
	from a bookmark.
	.It Xr zfs-receive 8
	Creates a snapshot whose contents are as specified in the stream provided on
	standard input.
	If a full stream is received, then a new file system is created as well.
	Streams are created using the
	.Xr zfs-send 8
	subcommand, which by default creates a full stream.
	.It Xr zfs-bookmark 8
	Creates a new bookmark of the given snapshot or bookmark.
	Bookmarks mark the point in time when the snapshot was created, and can be used
	as the incremental source for a
	.Nm zfs Cm send
	command.
	.It Xr zfs-redact 8
	Generate a new redaction bookmark.
	This feature can be used to allow clones of a filesystem to be made available on
	a remote system, in the case where their parent need not (or needs to not) be
	usable.
	.El
	.Ss Properties
	.Bl -tag -width ""
	.It Xr zfs-get 8
	Displays properties for the given datasets.
	.It Xr zfs-set 8
	Sets the property or list of properties to the given value(s) for each dataset.
	.It Xr zfs-inherit 8
	Clears the specified property, causing it to be inherited from an ancestor,
	restored to default if no ancestor has the property set, or with the
	.Fl S
	option reverted to the received value if one exists.
	.El
	.Ss Quotas
	.Bl -tag -width ""
	.It Xo
	.Xr zfs-userspace 8 /
	.Xr zfs-groupspace 8 /
	.Xr zfs-projectspace 8
	.Xc
	Displays space consumed by, and quotas on, each user, group, or project
	in the specified filesystem or snapshot.
	.It Xr zfs-project 8
	List, set, or clear project ID and/or inherit flag on the file(s) or directories.
	.El
	.Ss Mountpoints
	.Bl -tag -width ""
	.It Xr zfs-mount 8
	Displays all ZFS file systems currently mounted, or mount ZFS filesystem
	on a path described by its
	.Sy mountpoint
	property.
	.It Xr zfs-unmount 8
	Unmounts currently mounted ZFS file systems.
	.El
	.Ss Shares
	.Bl -tag -width ""
	.It Xr zfs-share 8
	Shares available ZFS file systems.
	.It Xr zfs-unshare 8
	Unshares currently shared ZFS file systems.
	.El
	.Ss Delegated Administration
	.Bl -tag -width ""
	.It Xr zfs-allow 8
	Delegate permissions on the specified filesystem or volume.
	.It Xr zfs-unallow 8
	Remove delegated permissions on the specified filesystem or volume.
	.El
	.Ss Encryption
	.Bl -tag -width ""
	.It Xr zfs-change-key 8
	Add or change an encryption key on the specified dataset.
	.It Xr zfs-load-key 8
	Load the key for the specified encrypted dataset, enabling access.
	.It Xr zfs-unload-key 8
	Unload a key for the specified dataset, removing the ability to access the dataset.
	.El
	.Ss Channel Programs
	.Bl -tag -width ""
	.It Xr zfs-program 8
	Execute ZFS administrative operations
	programmatically via a Lua script-language channel program.
	.El
	.Ss Jails
	.Bl -tag -width ""
	.It Xr zfs-jail 8
	Attaches a filesystem to a jail.
	.It Xr zfs-unjail 8
	Detaches a filesystem from a jail.
	.El
	.Ss Waiting
	.Bl -tag -width ""
	.It Xr zfs-wait 8
	Wait for background activity in a filesystem to complete.
	.El
	.Sh EXIT STATUS
	The
	.Nm
	utility exits 0 on success, 1 if an error occurs, and 2 if invalid command line
	options were specified.
	.Sh EXAMPLES
	.Bl -tag -width ""
	.It Sy Example 1 No Creating a ZFS File System Hierarchy
	The following commands create a file system named
	.Em pool/home
	and a file system named
	.Em pool/home/bob .
	The mount point
	.Pa /export/home
	is set for the parent file system, and is automatically inherited by the child
	file system.
	.Bd -literal
	# zfs create pool/home
	# zfs set mountpoint=/export/home pool/home
	# zfs create pool/home/bob
	.Ed
	.It Sy Example 2 No Creating a ZFS Snapshot
	The following command creates a snapshot named
	.Sy yesterday .
	This snapshot is mounted on demand in the
	.Pa .zfs/snapshot
	directory at the root of the
	.Em pool/home/bob
	file system.
	.Bd -literal
	# zfs snapshot pool/home/bob@yesterday
	.Ed
	.It Sy Example 3 No Creating and Destroying Multiple Snapshots
	The following command creates snapshots named
	.Sy yesterday
	of
	.Em pool/home
	and all of its descendent file systems.
	Each snapshot is mounted on demand in the
	.Pa .zfs/snapshot
	directory at the root of its file system.
	The second command destroys the newly created snapshots.
	.Bd -literal
	# zfs snapshot -r pool/home@yesterday
	# zfs destroy -r pool/home@yesterday
	.Ed
	.It Sy Example 4 No Disabling and Enabling File System Compression
	The following command disables the
	.Sy compression
	property for all file systems under
	.Em pool/home .
	The next command explicitly enables
	.Sy compression
	for
	.Em pool/home/anne .
	.Bd -literal
	# zfs set compression=off pool/home
	# zfs set compression=on pool/home/anne
	.Ed
	.It Sy Example 5 No Listing ZFS Datasets
	The following command lists all active file systems and volumes in the system.
	Snapshots are displayed if the
	.Sy listsnaps
	property is
	.Sy on .
	The default is
	.Sy off .
	See
	.Xr zpool 8
	for more information on pool properties.
	.Bd -literal
	# zfs list
	NAME USED AVAIL REFER MOUNTPOINT
	pool 450K 457G 18K /pool
	pool/home 315K 457G 21K /export/home
	pool/home/anne 18K 457G 18K /export/home/anne
	pool/home/bob 276K 457G 276K /export/home/bob
	.Ed
	.It Sy Example 6 No Setting a Quota on a ZFS File System
	The following command sets a quota of 50 Gbytes for
	.Em pool/home/bob .
	.Bd -literal
	# zfs set quota=50G pool/home/bob
	.Ed
	.It Sy Example 7 No Listing ZFS Properties
	The following command lists all properties for
	.Em pool/home/bob .
	.Bd -literal
	# zfs get all pool/home/bob
	NAME PROPERTY VALUE SOURCE
	pool/home/bob type filesystem -
	pool/home/bob creation Tue Jul 21 15:53 2009 -
	pool/home/bob used 21K -
	pool/home/bob available 20.0G -
	pool/home/bob referenced 21K -
	pool/home/bob compressratio 1.00x -
	pool/home/bob mounted yes -
	pool/home/bob quota 20G local
	pool/home/bob reservation none default
	pool/home/bob recordsize 128K default
	pool/home/bob mountpoint /pool/home/bob default
	pool/home/bob sharenfs off default
	pool/home/bob checksum on default
	pool/home/bob compression on local
	pool/home/bob atime on default
	pool/home/bob devices on default
	pool/home/bob exec on default
	pool/home/bob setuid on default
	pool/home/bob readonly off default
	pool/home/bob zoned off default
	pool/home/bob snapdir hidden default
	pool/home/bob acltype off default
	pool/home/bob aclmode discard default
	pool/home/bob aclinherit restricted default
	pool/home/bob canmount on default
	pool/home/bob xattr on default
	pool/home/bob copies 1 default
	pool/home/bob version 4 -
	pool/home/bob utf8only off -
	pool/home/bob normalization none -
	pool/home/bob casesensitivity sensitive -
	pool/home/bob vscan off default
	pool/home/bob nbmand off default
	pool/home/bob sharesmb off default
	pool/home/bob refquota none default
	pool/home/bob refreservation none default
	pool/home/bob primarycache all default
	pool/home/bob secondarycache all default
	pool/home/bob usedbysnapshots 0 -
	pool/home/bob usedbydataset 21K -
	pool/home/bob usedbychildren 0 -
	pool/home/bob usedbyrefreservation 0 -
	.Ed
	.Pp
	The following command gets a single property value.
	.Bd -literal
	# zfs get -H -o value compression pool/home/bob
	on
	.Ed
	The following command lists all properties with local settings for
	.Em pool/home/bob .
	.Bd -literal
	# zfs get -r -s local -o name,property,value all pool/home/bob
	NAME PROPERTY VALUE
	pool/home/bob quota 20G
	pool/home/bob compression on
	.Ed
	.It Sy Example 8 No Rolling Back a ZFS File System
	The following command reverts the contents of
	.Em pool/home/anne
	to the snapshot named
	.Sy yesterday ,
	deleting all intermediate snapshots.
	.Bd -literal
	# zfs rollback -r pool/home/anne@yesterday
	.Ed
	.It Sy Example 9 No Creating a ZFS Clone
	The following command creates a writable file system whose initial contents are
	the same as
	.Em pool/home/bob@yesterday .
	.Bd -literal
	# zfs clone pool/home/bob@yesterday pool/clone
	.Ed
	.It Sy Example 10 No Promoting a ZFS Clone
	The following commands illustrate how to test out changes to a file system, and
	then replace the original file system with the changed one, using clones, clone
	promotion, and renaming:
	.Bd -literal
	# zfs create pool/project/production
	populate /pool/project/production with data
	# zfs snapshot pool/project/production@today
	# zfs clone pool/project/production@today pool/project/beta
	make changes to /pool/project/beta and test them
	# zfs promote pool/project/beta
	# zfs rename pool/project/production pool/project/legacy
	# zfs rename pool/project/beta pool/project/production
	once the legacy version is no longer needed, it can be destroyed
	# zfs destroy pool/project/legacy
	.Ed
	.It Sy Example 11 No Inheriting ZFS Properties
	The following command causes
	.Em pool/home/bob
	and
	.Em pool/home/anne
	to inherit the
	.Sy checksum
	property from their parent.
	.Bd -literal
	# zfs inherit checksum pool/home/bob pool/home/anne
	.Ed
	.It Sy Example 12 No Remotely Replicating ZFS Data
	The following commands send a full stream and then an incremental stream to a
	remote machine, restoring them into
	.Em poolB/received/fs@a
	and
	.Em poolB/received/fs@b ,
	respectively.
	.Em poolB
	must contain the file system
	.Em poolB/received ,
	and must not initially contain
	.Em poolB/received/fs .
	.Bd -literal
	# zfs send pool/fs@a \| \e
	ssh host zfs receive poolB/received/fs@a
	# zfs send -i a pool/fs@b \| \e
	ssh host zfs receive poolB/received/fs
	.Ed
	.It Sy Example 13 No Using the zfs receive -d Option
	The following command sends a full stream of
	.Em poolA/fsA/fsB@snap
	to a remote machine, receiving it into
	.Em poolB/received/fsA/fsB@snap .
	The
	.Em fsA/fsB@snap
	portion of the received snapshot's name is determined from the name of the sent
	snapshot.
	.Em poolB
	must contain the file system
	.Em poolB/received .
	If
	.Em poolB/received/fsA
	does not exist, it is created as an empty file system.
	.Bd -literal
	# zfs send poolA/fsA/fsB@snap \| \e
	ssh host zfs receive -d poolB/received
	.Ed
	.It Sy Example 14 No Setting User Properties
	The following example sets the user-defined
	.Sy com.example:department
	property for a dataset.
	.Bd -literal
	# zfs set com.example:department=12345 tank/accounting
	.Ed
	.It Sy Example 15 No Performing a Rolling Snapshot
	The following example shows how to maintain a history of snapshots with a
	consistent naming scheme.
	To keep a week's worth of snapshots, the user destroys the oldest snapshot,
	renames the remaining snapshots, and then creates a new snapshot, as follows:
	.Bd -literal
	# zfs destroy -r pool/users@7daysago
	# zfs rename -r pool/users@6daysago @7daysago
	# zfs rename -r pool/users@5daysago @6daysago
	# zfs rename -r pool/users@4daysago @5daysago
	# zfs rename -r pool/users@3daysago @4daysago
	# zfs rename -r pool/users@2daysago @3daysago
	# zfs rename -r pool/users@yesterday @2daysago
	# zfs rename -r pool/users@today @yesterday
	# zfs snapshot -r pool/users@today
	.Ed
	.It Sy Example 16 No Setting sharenfs Property Options on a ZFS File System
	The following commands show how to set
	.Sy sharenfs
	property options to enable
	.Sy rw
	access for a set of
	.Sy IP
	addresses and to enable root access for system
	.Sy neo
	on the
	.Em tank/home
	file system.
	.Bd -literal
	# zfs set sharenfs='rw=@123.123.0.0/16,root=neo' tank/home
	.Ed
	.Pp
	If you are using
	.Sy DNS
	for host name resolution, specify the fully qualified hostname.
	.It Sy Example 17 No Delegating ZFS Administration Permissions on a ZFS Dataset
	The following example shows how to set permissions so that user
	.Sy cindys
	can create, destroy, mount, and take snapshots on
	.Em tank/cindys .
	The permissions on
	.Em tank/cindys
	are also displayed.
	.Bd -literal
	# zfs allow cindys create,destroy,mount,snapshot tank/cindys
	# zfs allow tank/cindys
	---- Permissions on tank/cindys --------------------------------------
	Local+Descendent permissions:
	user cindys create,destroy,mount,snapshot
	.Ed
	.Pp
	Because the
	.Em tank/cindys
	mount point permission is set to 755 by default, user
	.Sy cindys
	will be unable to mount file systems under
	.Em tank/cindys .
	Add an ACE similar to the following syntax to provide mount point access:
	.Bd -literal
	# chmod A+user:cindys:add_subdirectory:allow /tank/cindys
	.Ed
	.It Sy Example 18 No Delegating Create Time Permissions on a ZFS Dataset
	The following example shows how to grant anyone in the group
	.Sy staff
	to create file systems in
	.Em tank/users .
	This syntax also allows staff members to destroy their own file systems, but not
	destroy anyone else's file system.
	The permissions on
	.Em tank/users
	are also displayed.
	.Bd -literal
	# zfs allow staff create,mount tank/users
	# zfs allow -c destroy tank/users
	# zfs allow tank/users
	---- Permissions on tank/users ---------------------------------------
	Permission sets:
	destroy
	Local+Descendent permissions:
	group staff create,mount
	.Ed
	.It Sy Example 19 No Defining and Granting a Permission Set on a ZFS Dataset
	The following example shows how to define and grant a permission set on the
	.Em tank/users
	file system.
	The permissions on
	.Em tank/users
	are also displayed.
	.Bd -literal
	# zfs allow -s @pset create,destroy,snapshot,mount tank/users
	# zfs allow staff @pset tank/users
	# zfs allow tank/users
	---- Permissions on tank/users ---------------------------------------
	Permission sets:
	@pset create,destroy,mount,snapshot
	Local+Descendent permissions:
	group staff @pset
	.Ed
	.It Sy Example 20 No Delegating Property Permissions on a ZFS Dataset
	The following example shows to grant the ability to set quotas and reservations
	on the
	.Em users/home
	file system.
	The permissions on
	.Em users/home
	are also displayed.
	.Bd -literal
	# zfs allow cindys quota,reservation users/home
	# zfs allow users/home
	---- Permissions on users/home ---------------------------------------
	Local+Descendent permissions:
	user cindys quota,reservation
	cindys% zfs set quota=10G users/home/marks
	cindys% zfs get quota users/home/marks
	NAME PROPERTY VALUE SOURCE
	users/home/marks quota 10G local
	.Ed
	.It Sy Example 21 No Removing ZFS Delegated Permissions on a ZFS Dataset
	The following example shows how to remove the snapshot permission from the
	.Sy staff
	group on the
	.Em tank/users
	file system.
	The permissions on
	.Em tank/users
	are also displayed.
	.Bd -literal
	# zfs unallow staff snapshot tank/users
	# zfs allow tank/users
	---- Permissions on tank/users ---------------------------------------
	Permission sets:
	@pset create,destroy,mount,snapshot
	Local+Descendent permissions:
	group staff @pset
	.Ed
	.It Sy Example 22 No Showing the differences between a snapshot and a ZFS Dataset
	The following example shows how to see what has changed between a prior
	snapshot of a ZFS dataset and its current state.
	The
	.Fl F
	option is used to indicate type information for the files affected.
	.Bd -literal
	# zfs diff -F tank/test@before tank/test
	M / /tank/test/
	M F /tank/test/linked (+1)
	R F /tank/test/oldname -> /tank/test/newname
	- F /tank/test/deleted
	+ F /tank/test/created
	M F /tank/test/modified
	.Ed
	.It Sy Example 23 No Creating a bookmark
	The following example create a bookmark to a snapshot.
	This bookmark can then be used instead of snapshot in send streams.
	.Bd -literal
	# zfs bookmark rpool@snapshot rpool#bookmark
	.Ed
	.It Sy Example 24 No Setting sharesmb Property Options on a ZFS File System
	The following example show how to share SMB filesystem through ZFS.
	-Note that that a user and his/her password must be given.
	+Note that a user and his/her password must be given.
	.Bd -literal
	# smbmount //127.0.0.1/share_tmp /mnt/tmp \\
	-o user=workgroup/turbo,password=obrut,uid=1000
	.Ed
	.Pp
	Minimal
	.Em /etc/samba/smb.conf
	configuration required:
	.Pp
	Samba will need to listen to 'localhost' (127.0.0.1) for the ZFS utilities to
	communicate with Samba.
	This is the default behavior for most Linux distributions.
	.Pp
	Samba must be able to authenticate a user.
	This can be done in a number of ways, depending on if using the system password file, LDAP or the Samba
	specific smbpasswd file.
	How to do this is outside the scope of this manual.
	Please refer to the
	.Xr smb.conf 5
	man page for more information.
	.Pp
	See the
	.Sy USERSHARE section
	of the
	.Xr smb.conf 5
	man page for all configuration options in case you need to modify any options
	to the share afterwards.
	Do note that any changes done with the
	.Xr net 8
	command will be undone if the share is ever unshared (such as at a reboot etc).
	.El
	.Sh ENVIRONMENT VARIABLES
	.Bl -tag -width "ZFS_MOUNT_HELPER"
	.It Ev ZFS_MOUNT_HELPER
	Cause
	.Nm zfs mount
	to use
	.Em /bin/mount
	to mount zfs datasets. This option is provided for backwards compatibility with older zfs versions.
	.El
	.Sh INTERFACE STABILITY
	.Sy Committed .
	.Sh SEE ALSO
	.Xr attr 1 ,
	.Xr gzip 1 ,
	.Xr ssh 1 ,
	.Xr chmod 2 ,
	.Xr fsync 2 ,
	.Xr stat 2 ,
	.Xr write 2 ,
	.Xr acl 5 ,
	.Xr attributes 5 ,
	.Xr exports 5 ,
	.Xr exportfs 8 ,
	.Xr mount 8 ,
	.Xr net 8 ,
	.Xr selinux 8 ,
	.Xr zfs-allow 8 ,
	.Xr zfs-bookmark 8 ,
	.Xr zfs-change-key 8 ,
	.Xr zfs-clone 8 ,
	.Xr zfs-create 8 ,
	.Xr zfs-destroy 8 ,
	.Xr zfs-diff 8 ,
	.Xr zfs-get 8 ,
	.Xr zfs-groupspace 8 ,
	.Xr zfs-hold 8 ,
	.Xr zfs-inherit 8 ,
	.Xr zfs-jail 8 ,
	.Xr zfs-list 8 ,
	.Xr zfs-load-key 8 ,
	.Xr zfs-mount 8 ,
	.Xr zfs-program 8 ,
	.Xr zfs-project 8 ,
	.Xr zfs-projectspace 8 ,
	.Xr zfs-promote 8 ,
	.Xr zfs-receive 8 ,
	.Xr zfs-redact 8 ,
	.Xr zfs-release 8 ,
	.Xr zfs-rename 8 ,
	.Xr zfs-rollback 8 ,
	.Xr zfs-send 8 ,
	.Xr zfs-set 8 ,
	.Xr zfs-share 8 ,
	.Xr zfs-snapshot 8 ,
	.Xr zfs-unallow 8 ,
	.Xr zfs-unjail 8 ,
	.Xr zfs-unload-key 8 ,
	.Xr zfs-unmount 8 ,
	.Xr zfs-unshare 8 ,
	.Xr zfs-upgrade 8 ,
	.Xr zfs-userspace 8 ,
	.Xr zfs-wait 8 ,
	.Xr zfsconcepts 8 ,
	.Xr zfsprops 8 ,
	.Xr zpool 8
	diff --git a/sys/contrib/openzfs/man/man8/zfs_ids_to_path.8 b/sys/contrib/openzfs/man/man8/zfs_ids_to_path.8
	index 9d6a4976efa2..4f7b8429e411 100644
	--- a/sys/contrib/openzfs/man/man8/zfs_ids_to_path.8
	+++ b/sys/contrib/openzfs/man/man8/zfs_ids_to_path.8
	@@ -1,50 +1,50 @@
	.\"
	.\" 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) 2020 by Delphix. All rights reserved.
	.Dd April 17, 2020
	.Dt ZFS_IDS_TO_PATH 8
	.Os
	.Sh NAME
	.Nm zfs_ids_to_path
	.Nd convert objset and object ids to names and paths
	.Sh SYNOPSIS
	.Nm
	.Op Fl v
	.Ar pool
	.Ar objset id
	.Ar object id
	.Nm
	.Sh DESCRIPTION
	.Pp
	-.LP
	The
	.Sy zfs_ids_to_path
	utility converts a provided objset and object id into a path to the file that
	those ids refer to.
	.Bl -tag -width "-D"
	.It Fl v
	Verbose.
	Print the dataset name and the file path within the dataset separately. This
	will work correctly even if the dataset is not mounted.
	+.El
	.Sh SEE ALSO
	.Xr zfs 8 ,
	.Xr zdb 8
	diff --git a/sys/contrib/openzfs/man/man8/zfsprops.8 b/sys/contrib/openzfs/man/man8/zfsprops.8
	index 0255ac5c6077..29a3cd41d585 100644
	--- a/sys/contrib/openzfs/man/man8/zfsprops.8
	+++ b/sys/contrib/openzfs/man/man8/zfsprops.8
	@@ -1,2003 +1,2003 @@
	.\"
	.\" 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) 2009 Sun Microsystems, Inc. All Rights Reserved.
	.\" Copyright 2011 Joshua M. Clulow <josh@sysmgr.org>
	.\" Copyright (c) 2011, 2019 by Delphix. All rights reserved.
	.\" Copyright (c) 2011, Pawel Jakub Dawidek <pjd@FreeBSD.org>
	.\" Copyright (c) 2012, Glen Barber <gjb@FreeBSD.org>
	.\" Copyright (c) 2012, Bryan Drewery <bdrewery@FreeBSD.org>
	.\" Copyright (c) 2013, Steven Hartland <smh@FreeBSD.org>
	.\" Copyright (c) 2013 by Saso Kiselkov. All rights reserved.
	.\" Copyright (c) 2014, Joyent, Inc. All rights reserved.
	.\" Copyright (c) 2014 by Adam Stevko. All rights reserved.
	.\" Copyright (c) 2014 Integros [integros.com]
	.\" Copyright (c) 2016 Nexenta Systems, Inc. All Rights Reserved.
	.\" Copyright (c) 2014, Xin LI <delphij@FreeBSD.org>
	.\" Copyright (c) 2014-2015, The FreeBSD Foundation, All Rights Reserved.
	.\" Copyright 2019 Richard Laager. All rights reserved.
	.\" Copyright 2018 Nexenta Systems, Inc.
	.\" Copyright 2019 Joyent, Inc.
	.\" Copyright (c) 2019, Kjeld Schouten-Lebbing
	.\"
	-.Dd September 1, 2020
	+.Dd May 24, 2021
	.Dt ZFSPROPS 8
	.Os
	.Sh NAME
	.Nm zfsprops
	.Nd Native properties and user-defined of ZFS datasets.
	.Sh DESCRIPTION
	Properties are divided into two types, native properties and user-defined
	.Po or
	.Qq user
	.Pc
	properties.
	Native properties either export internal statistics or control ZFS behavior.
	In addition, native properties are either editable or read-only.
	User properties have no effect on ZFS behavior, but you can use them to annotate
	datasets in a way that is meaningful in your environment.
	For more information about user properties, see the
	.Sx User Properties
	section, below.
	.Ss Native Properties
	Every dataset has a set of properties that export statistics about the dataset
	as well as control various behaviors.
	Properties are inherited from the parent unless overridden by the child.
	Some properties apply only to certain types of datasets
	.Pq file systems, volumes, or snapshots .
	.Pp
	The values of numeric properties can be specified using human-readable suffixes
	.Po for example,
	.Sy k ,
	.Sy KB ,
	.Sy M ,
	.Sy Gb ,
	and so forth, up to
	.Sy Z
	for zettabyte
	.Pc .
	The following are all valid
	.Pq and equal
	specifications:
	.Li 1536M, 1.5g, 1.50GB .
	.Pp
	The values of non-numeric properties are case sensitive and must be lowercase,
	except for
	.Sy mountpoint ,
	.Sy sharenfs ,
	and
	.Sy sharesmb .
	.Pp
	The following native properties consist of read-only statistics about the
	dataset.
	These properties can be neither set, nor inherited.
	Native properties apply to all dataset types unless otherwise noted.
	.Bl -tag -width "usedbyrefreservation"
	.It Sy available
	The amount of space available to the dataset and all its children, assuming that
	there is no other activity in the pool.
	Because space is shared within a pool, availability can be limited by any number
	of factors, including physical pool size, quotas, reservations, or other
	datasets within the pool.
	.Pp
	This property can also be referred to by its shortened column name,
	.Sy avail .
	.It Sy compressratio
	For non-snapshots, the compression ratio achieved for the
	.Sy used
	space of this dataset, expressed as a multiplier.
	The
	.Sy used
	property includes descendant datasets, and, for clones, does not include the
	space shared with the origin snapshot.
	For snapshots, the
	.Sy compressratio
	is the same as the
	.Sy refcompressratio
	property.
	Compression can be turned on by running:
	.Nm zfs Cm set Sy compression Ns = Ns Sy on Ar dataset .
	The default value is
	.Sy off .
	.It Sy createtxg
	The transaction group (txg) in which the dataset was created. Bookmarks have
	the same
	.Sy createtxg
	as the snapshot they are initially tied to. This property is suitable for
	ordering a list of snapshots, e.g. for incremental send and receive.
	.It Sy creation
	The time this dataset was created.
	.It Sy clones
	For snapshots, this property is a comma-separated list of filesystems or volumes
	which are clones of this snapshot.
	The clones'
	.Sy origin
	property is this snapshot.
	If the
	.Sy clones
	property is not empty, then this snapshot can not be destroyed
	.Po even with the
	.Fl r
	or
	.Fl f
	options
	.Pc .
	The roles of origin and clone can be swapped by promoting the clone with the
	.Nm zfs Cm promote
	command.
	.It Sy defer_destroy
	This property is
	.Sy on
	if the snapshot has been marked for deferred destroy by using the
	.Nm zfs Cm destroy Fl d
	command.
	Otherwise, the property is
	.Sy off .
	.It Sy encryptionroot
	For encrypted datasets, indicates where the dataset is currently inheriting its
	encryption key from. Loading or unloading a key for the
	.Sy encryptionroot
	will implicitly load / unload the key for any inheriting datasets (see
	.Nm zfs Cm load-key
	and
	.Nm zfs Cm unload-key
	for details).
	Clones will always share an
	encryption key with their origin. See the
	.Em Encryption
	section of
	.Xr zfs-load-key 8
	for details.
	.It Sy filesystem_count
	The total number of filesystems and volumes that exist under this location in
	the dataset tree.
	This value is only available when a
	.Sy filesystem_limit
	has been set somewhere in the tree under which the dataset resides.
	.It Sy keystatus
	Indicates if an encryption key is currently loaded into ZFS. The possible
	values are
	.Sy none ,
	.Sy available ,
	and
	.Sy unavailable .
	See
	.Nm zfs Cm load-key
	and
	.Nm zfs Cm unload-key .
	.It Sy guid
	The 64 bit GUID of this dataset or bookmark which does not change over its
	entire lifetime. When a snapshot is sent to another pool, the received
	snapshot has the same GUID. Thus, the
	.Sy guid
	is suitable to identify a snapshot across pools.
	.It Sy logicalreferenced
	The amount of space that is
	.Qq logically
	accessible by this dataset.
	See the
	.Sy referenced
	property.
	The logical space ignores the effect of the
	.Sy compression
	and
	.Sy copies
	properties, giving a quantity closer to the amount of data that applications
	see.
	However, it does include space consumed by metadata.
	.Pp
	This property can also be referred to by its shortened column name,
	.Sy lrefer .
	.It Sy logicalused
	The amount of space that is
	.Qq logically
	consumed by this dataset and all its descendents.
	See the
	.Sy used
	property.
	The logical space ignores the effect of the
	.Sy compression
	and
	.Sy copies
	properties, giving a quantity closer to the amount of data that applications
	see.
	However, it does include space consumed by metadata.
	.Pp
	This property can also be referred to by its shortened column name,
	.Sy lused .
	.It Sy mounted
	For file systems, indicates whether the file system is currently mounted.
	This property can be either
	.Sy yes
	or
	.Sy no .
	.It Sy objsetid
	A unique identifier for this dataset within the pool. Unlike the dataset's
	.Sy guid
	, the
	.Sy objsetid
	of a dataset is not transferred to other pools when the snapshot is copied
	with a send/receive operation.
	The
	.Sy objsetid
	can be reused (for a new dataset) after the dataset is deleted.
	.It Sy origin
	For cloned file systems or volumes, the snapshot from which the clone was
	created.
	See also the
	.Sy clones
	property.
	.It Sy receive_resume_token
	For filesystems or volumes which have saved partially-completed state from
	.Sy zfs receive -s ,
	this opaque token can be provided to
	.Sy zfs send -t
	to resume and complete the
	.Sy zfs receive .
	.It Sy redact_snaps
	For bookmarks, this is the list of snapshot guids the bookmark contains a redaction
	list for.
	For snapshots, this is the list of snapshot guids the snapshot is redacted with
	respect to.
	.It Sy referenced
	The amount of data that is accessible by this dataset, which may or may not be
	shared with other datasets in the pool.
	When a snapshot or clone is created, it initially references the same amount of
	space as the file system or snapshot it was created from, since its contents are
	identical.
	.Pp
	This property can also be referred to by its shortened column name,
	.Sy refer .
	.It Sy refcompressratio
	The compression ratio achieved for the
	.Sy referenced
	space of this dataset, expressed as a multiplier.
	See also the
	.Sy compressratio
	property.
	.It Sy snapshot_count
	The total number of snapshots that exist under this location in the dataset
	tree.
	This value is only available when a
	.Sy snapshot_limit
	has been set somewhere in the tree under which the dataset resides.
	.It Sy type
	The type of dataset:
	.Sy filesystem ,
	.Sy volume ,
	.Sy snapshot ,
	or
	.Sy bookmark .
	.It Sy used
	The amount of space consumed by this dataset and all its descendents.
	This is the value that is checked against this dataset's quota and reservation.
	The space used does not include this dataset's reservation, but does take into
	account the reservations of any descendent datasets.
	The amount of space that a dataset consumes from its parent, as well as the
	amount of space that is freed if this dataset is recursively destroyed, is the
	greater of its space used and its reservation.
	.Pp
	The used space of a snapshot
	.Po see the
	.Em Snapshots
	section of
	.Xr zfsconcepts 8
	.Pc
	is space that is referenced exclusively by this snapshot.
	If this snapshot is destroyed, the amount of
	.Sy used
	space will be freed.
	Space that is shared by multiple snapshots isn't accounted for in this metric.
	When a snapshot is destroyed, space that was previously shared with this
	snapshot can become unique to snapshots adjacent to it, thus changing the used
	space of those snapshots.
	The used space of the latest snapshot can also be affected by changes in the
	file system.
	Note that the
	.Sy used
	space of a snapshot is a subset of the
	.Sy written
	space of the snapshot.
	.Pp
	The amount of space used, available, or referenced does not take into account
	pending changes.
	Pending changes are generally accounted for within a few seconds.
	Committing a change to a disk using
	.Xr fsync 2
	or
	.Dv O_SYNC
	does not necessarily guarantee that the space usage information is updated
	immediately.
	.It Sy usedby*
	The
	.Sy usedby*
	properties decompose the
	.Sy used
	properties into the various reasons that space is used.
	Specifically,
	.Sy used No =
	.Sy usedbychildren No +
	.Sy usedbydataset No +
	.Sy usedbyrefreservation No +
	.Sy usedbysnapshots .
	These properties are only available for datasets created on
	.Nm zpool
	.Qo version 13 Qc
	pools.
	.It Sy usedbychildren
	The amount of space used by children of this dataset, which would be freed if
	all the dataset's children were destroyed.
	.It Sy usedbydataset
	The amount of space used by this dataset itself, which would be freed if the
	dataset were destroyed
	.Po after first removing any
	.Sy refreservation
	and destroying any necessary snapshots or descendents
	.Pc .
	.It Sy usedbyrefreservation
	The amount of space used by a
	.Sy refreservation
	set on this dataset, which would be freed if the
	.Sy refreservation
	was removed.
	.It Sy usedbysnapshots
	The amount of space consumed by snapshots of this dataset.
	In particular, it is the amount of space that would be freed if all of this
	dataset's snapshots were destroyed.
	Note that this is not simply the sum of the snapshots'
	.Sy used
	properties because space can be shared by multiple snapshots.
	.It Sy userused Ns @ Ns Em user
	The amount of space consumed by the specified user in this dataset.
	Space is charged to the owner of each file, as displayed by
	.Nm ls Fl l .
	The amount of space charged is displayed by
	.Nm du
	and
	.Nm ls Fl s .
	See the
	.Nm zfs Cm userspace
	subcommand for more information.
	.Pp
	Unprivileged users can access only their own space usage.
	The root user, or a user who has been granted the
	.Sy userused
	privilege with
	.Nm zfs Cm allow ,
	can access everyone's usage.
	.Pp
	The
	.Sy userused Ns @ Ns Em ...
	properties are not displayed by
	.Nm zfs Cm get Sy all .
	The user's name must be appended after the @ symbol, using one of the following
	forms:
	.Bl -bullet -width ""
	.It
	.Em POSIX name
	.Po for example,
	.Sy joe
	.Pc
	.It
	.Em POSIX numeric ID
	.Po for example,
	.Sy 789
	.Pc
	.It
	.Em SID name
	.Po for example,
	.Sy joe.smith@mydomain
	.Pc
	.It
	.Em SID numeric ID
	.Po for example,
	.Sy S-1-123-456-789
	.Pc
	.El
	.Pp
	Files created on Linux always have POSIX owners.
	.It Sy userobjused Ns @ Ns Em user
	The
	.Sy userobjused
	property is similar to
	.Sy userused
	but instead it counts the number of objects consumed by a user. This property
	counts all objects allocated on behalf of the user, it may differ from the
	results of system tools such as
	.Nm df Fl i .
	.Pp
	When the property
	.Sy xattr=on
	is set on a file system additional objects will be created per-file to store
	extended attributes. These additional objects are reflected in the
	.Sy userobjused
	value and are counted against the user's
	.Sy userobjquota .
	When a file system is configured to use
	.Sy xattr=sa
	no additional internal objects are normally required.
	.It Sy userrefs
	This property is set to the number of user holds on this snapshot.
	User holds are set by using the
	.Nm zfs Cm hold
	command.
	.It Sy groupused Ns @ Ns Em group
	The amount of space consumed by the specified group in this dataset.
	Space is charged to the group of each file, as displayed by
	.Nm ls Fl l .
	See the
	.Sy userused Ns @ Ns Em user
	property for more information.
	.Pp
	Unprivileged users can only access their own groups' space usage.
	The root user, or a user who has been granted the
	.Sy groupused
	privilege with
	.Nm zfs Cm allow ,
	can access all groups' usage.
	.It Sy groupobjused Ns @ Ns Em group
	The number of objects consumed by the specified group in this dataset.
	Multiple objects may be charged to the group for each file when extended
	attributes are in use. See the
	.Sy userobjused Ns @ Ns Em user
	property for more information.
	.Pp
	Unprivileged users can only access their own groups' space usage.
	The root user, or a user who has been granted the
	.Sy groupobjused
	privilege with
	.Nm zfs Cm allow ,
	can access all groups' usage.
	.It Sy projectused Ns @ Ns Em project
	The amount of space consumed by the specified project in this dataset. Project
	is identified via the project identifier (ID) that is object-based numeral
	attribute. An object can inherit the project ID from its parent object (if the
	parent has the flag of inherit project ID that can be set and changed via
	.Nm chattr Fl /+P
	or
	.Nm zfs project Fl s )
	when being created. The privileged user can set and change object's project
	ID via
	.Nm chattr Fl p
	or
	.Nm zfs project Fl s
	anytime. Space is charged to the project of each file, as displayed by
	.Nm lsattr Fl p
	or
	.Nm zfs project .
	See the
	.Sy userused Ns @ Ns Em user
	property for more information.
	.Pp
	The root user, or a user who has been granted the
	.Sy projectused
	privilege with
	.Nm zfs allow ,
	can access all projects' usage.
	.It Sy projectobjused Ns @ Ns Em project
	The
	.Sy projectobjused
	is similar to
	.Sy projectused
	but instead it counts the number of objects consumed by project. When the
	property
	.Sy xattr=on
	is set on a fileset, ZFS will create additional objects per-file to store
	extended attributes. These additional objects are reflected in the
	.Sy projectobjused
	value and are counted against the project's
	.Sy projectobjquota .
	When a filesystem is configured to use
	.Sy xattr=sa
	no additional internal objects are required. See the
	.Sy userobjused Ns @ Ns Em user
	property for more information.
	.Pp
	The root user, or a user who has been granted the
	.Sy projectobjused
	privilege with
	.Nm zfs allow ,
	can access all projects' objects usage.
	.It Sy volblocksize
	For volumes, specifies the block size of the volume.
	The
	.Sy blocksize
	cannot be changed once the volume has been written, so it should be set at
	volume creation time.
	The default
	.Sy blocksize
	for volumes is 8 Kbytes.
	Any power of 2 from 512 bytes to 128 Kbytes is valid.
	.Pp
	This property can also be referred to by its shortened column name,
	.Sy volblock .
	.It Sy written
	The amount of space
	.Sy referenced
	by this dataset, that was written since the previous snapshot
	.Pq i.e. that is not referenced by the previous snapshot .
	.It Sy written Ns @ Ns Em snapshot
	The amount of
	.Sy referenced
	space written to this dataset since the specified snapshot.
	This is the space that is referenced by this dataset but was not referenced by
	the specified snapshot.
	.Pp
	The
	.Em snapshot
	may be specified as a short snapshot name
	.Po just the part after the
	.Sy @
	.Pc ,
	in which case it will be interpreted as a snapshot in the same filesystem as
	this dataset.
	The
	.Em snapshot
	may be a full snapshot name
	.Po Em filesystem Ns @ Ns Em snapshot Pc ,
	which for clones may be a snapshot in the origin's filesystem
	.Pq or the origin of the origin's filesystem, etc.
	.El
	.Pp
	The following native properties can be used to change the behavior of a ZFS
	dataset.
	.Bl -tag -width ""
	.It Xo
	.Sy aclinherit Ns = Ns Sy discard Ns \| Ns Sy noallow Ns \| Ns
	.Sy restricted Ns \| Ns Sy passthrough Ns \| Ns Sy passthrough-x
	.Xc
	Controls how ACEs are inherited when files and directories are created.
	.Bl -tag -width "passthrough-x"
	.It Sy discard
	does not inherit any ACEs.
	.It Sy noallow
	only inherits inheritable ACEs that specify
	.Qq deny
	permissions.
	.It Sy restricted
	default, removes the
	.Sy write_acl
	and
	.Sy write_owner
	permissions when the ACE is inherited.
	.It Sy passthrough
	inherits all inheritable ACEs without any modifications.
	.It Sy passthrough-x
	same meaning as
	.Sy passthrough ,
	except that the
	.Sy owner@ ,
	.Sy group@ ,
	and
	.Sy everyone@
	ACEs inherit the execute permission only if the file creation mode also requests
	the execute bit.
	.El
	.Pp
	When the property value is set to
	.Sy passthrough ,
	files are created with a mode determined by the inheritable ACEs.
	If no inheritable ACEs exist that affect the mode, then the mode is set in
	accordance to the requested mode from the application.
	.Pp
	The
	.Sy aclinherit
	property does not apply to POSIX ACLs.
	.It Xo
	.Sy aclmode Ns = Ns Sy discard Ns \| Ns Sy groupmask Ns \| Ns
	.Sy passthrough Ns \| Ns Sy restricted Ns
	.Xc
	Controls how an ACL is modified during chmod(2) and how inherited ACEs
	are modified by the file creation mode.
	.Bl -tag -width "passthrough"
	.It Sy discard
	default, deletes all
	.Sy ACEs
	except for those representing
	the mode of the file or directory requested by
	.Xr chmod 2 .
	.It Sy groupmask
	reduces permissions granted in all
	.Sy ALLOW
	entries found in the
	.Sy ACL
	such that they are no greater than the group permissions specified by
	.Xr chmod 2 .
	.It Sy passthrough
	indicates that no changes are made to the
	.Tn ACL
	other than creating or updating the necessary
	.Tn ACL
	entries to represent the new mode of the file or directory.
	.It Sy restricted
	will cause the
	.Xr chmod 2
	operation to return an error when used on any file or directory which has
	a non-trivial
	.Tn ACL
	whose entries can not be represented by a mode.
	.Xr chmod 2
	is required to change the set user ID, set group ID, or sticky bits on a file
	or directory, as they do not have equivalent
	.Tn ACL
	entries.
	In order to use
	.Xr chmod 2
	on a file or directory with a non-trivial
	.Tn ACL
	when
	.Sy aclmode
	is set to
	.Sy restricted ,
	you must first remove all
	.Tn ACL
	entries which do not represent the current mode.
	.El
	.It Sy acltype Ns = Ns Sy off Ns \| Ns Sy nfsv4 Ns \| Ns Sy posix
	Controls whether ACLs are enabled and if so what type of ACL to use.
	When this property is set to a type of ACL not supported by the current
	platform, the behavior is the same as if it were set to
	.Sy off .
	.Bl -tag -width "posixacl"
	.It Sy off
	default on Linux, when a file system has the
	.Sy acltype
	property set to off then ACLs are disabled.
	.It Sy noacl
	an alias for
	.Sy off
	.It Sy nfsv4
	default on FreeBSD, indicates that NFSv4-style ZFS ACLs should be used.
	These ACLs can be managed with the
	.Xr getfacl 1
	and
	.Xr setfacl 1
	commands on FreeBSD. The
	.Sy nfsv4
	ZFS ACL type is not yet supported on Linux.
	.It Sy posix
	indicates POSIX ACLs should be used. POSIX ACLs are specific to Linux and are
	not functional on other platforms. POSIX ACLs are stored as an extended
	attribute and therefore will not overwrite any existing NFSv4 ACLs which
	may be set.
	.It Sy posixacl
	an alias for
	.Sy posix
	.El
	.Pp
	To obtain the best performance when setting
	.Sy posix
	users are strongly encouraged to set the
	.Sy xattr=sa
	property. This will result in the POSIX ACL being stored more efficiently on
	disk. But as a consequence, all new extended attributes will only be
	accessible from OpenZFS implementations which support the
	.Sy xattr=sa
	property. See the
	.Sy xattr
	property for more details.
	.It Sy atime Ns = Ns Sy on Ns \| Ns Sy off
	Controls whether the access time for files is updated when they are read.
	Turning this property off avoids producing write traffic when reading files and
	can result in significant performance gains, though it might confuse mailers
	and other similar utilities. The values
	.Sy on
	and
	.Sy off
	are equivalent to the
	.Sy atime
	and
	.Sy noatime
	mount options. The default value is
	.Sy on .
	See also
	.Sy relatime
	below.
	.It Sy canmount Ns = Ns Sy on Ns \| Ns Sy off Ns \| Ns Sy noauto
	If this property is set to
	.Sy off ,
	the file system cannot be mounted, and is ignored by
	.Nm zfs Cm mount Fl a .
	Setting this property to
	.Sy off
	is similar to setting the
	.Sy mountpoint
	property to
	.Sy none ,
	except that the dataset still has a normal
	.Sy mountpoint
	property, which can be inherited.
	Setting this property to
	.Sy off
	allows datasets to be used solely as a mechanism to inherit properties.
	One example of setting
	.Sy canmount Ns = Ns Sy off
	is to have two datasets with the same
	.Sy mountpoint ,
	so that the children of both datasets appear in the same directory, but might
	have different inherited characteristics.
	.Pp
	When set to
	.Sy noauto ,
	a dataset can only be mounted and unmounted explicitly.
	The dataset is not mounted automatically when the dataset is created or
	imported, nor is it mounted by the
	.Nm zfs Cm mount Fl a
	command or unmounted by the
	.Nm zfs Cm unmount Fl a
	command.
	.Pp
	This property is not inherited.
	.It Xo
	.Sy checksum Ns = Ns Sy on Ns \| Ns Sy off Ns \| Ns Sy fletcher2 Ns \| Ns
	.Sy fletcher4 Ns \| Ns Sy sha256 Ns \| Ns Sy noparity Ns \| Ns
	.Sy sha512 Ns \| Ns Sy skein Ns \| Ns Sy edonr
	.Xc
	Controls the checksum used to verify data integrity.
	The default value is
	.Sy on ,
	which automatically selects an appropriate algorithm
	.Po currently,
	.Sy fletcher4 ,
	but this may change in future releases
	.Pc .
	The value
	.Sy off
	disables integrity checking on user data.
	The value
	.Sy noparity
	not only disables integrity but also disables maintaining parity for user data.
	This setting is used internally by a dump device residing on a RAID-Z pool and
	should not be used by any other dataset.
	Disabling checksums is
	.Sy NOT
	a recommended practice.
	.Pp
	The
	.Sy sha512 ,
	.Sy skein ,
	and
	.Sy edonr
	checksum algorithms require enabling the appropriate features on the pool.
	FreeBSD does not support the
	.Sy edonr
	algorithm.
	.Pp
	Please see
	.Xr zpool-features 5
	for more information on these algorithms.
	.Pp
	Changing this property affects only newly-written data.
	.It Xo
	.Sy compression Ns = Ns Sy on Ns \| Ns Sy off Ns \| Ns Sy gzip Ns \| Ns
	.Sy gzip- Ns Em N Ns \| Ns Sy lz4 Ns \| Ns Sy lzjb Ns \| Ns Sy zle Ns \| Ns Sy zstd Ns \| Ns
	.Sy zstd- Ns Em N Ns \| Ns Sy zstd-fast Ns \| Ns Sy zstd-fast- Ns Em N
	.Xc
	Controls the compression algorithm used for this dataset.
	.Pp
	Setting compression to
	.Sy on
	indicates that the current default compression algorithm should be used.
	The default balances compression and decompression speed, with compression ratio
	and is expected to work well on a wide variety of workloads.
	Unlike all other settings for this property,
	.Sy on
	does not select a fixed compression type.
	As new compression algorithms are added to ZFS and enabled on a pool, the
	default compression algorithm may change.
	The current default compression algorithm is either
	.Sy lzjb
	or, if the
	.Sy lz4_compress
	feature is enabled,
	.Sy lz4 .
	.Pp
	The
	.Sy lz4
	compression algorithm is a high-performance replacement for the
	.Sy lzjb
	algorithm.
	It features significantly faster compression and decompression, as well as a
	moderately higher compression ratio than
	.Sy lzjb ,
	but can only be used on pools with the
	.Sy lz4_compress
	feature set to
	.Sy enabled .
	See
	.Xr zpool-features 5
	for details on ZFS feature flags and the
	.Sy lz4_compress
	feature.
	.Pp
	The
	.Sy lzjb
	compression algorithm is optimized for performance while providing decent data
	compression.
	.Pp
	The
	.Sy gzip
	compression algorithm uses the same compression as the
	.Xr gzip 1
	command.
	You can specify the
	.Sy gzip
	level by using the value
	.Sy gzip- Ns Em N ,
	where
	.Em N
	is an integer from 1
	.Pq fastest
	to 9
	.Pq best compression ratio .
	Currently,
	.Sy gzip
	is equivalent to
	.Sy gzip-6
	.Po which is also the default for
	.Xr gzip 1
	.Pc .
	.Pp
	The
	.Sy zstd
	compression algorithm provides both high compression ratios and good
	performance. You can specify the
	.Sy zstd
	level by using the value
	.Sy zstd- Ns Em N ,
	where
	.Em N
	is an integer from 1
	.Pq fastest
	to 19
	.Pq best compression ratio .
	.Sy zstd
	is equivalent to
	.Sy zstd-3 .
	.Pp
	Faster speeds at the cost of the compression ratio can be requested by
	setting a negative
	.Sy zstd
	level. This is done using
	.Sy zstd-fast- Ns Em N ,
	where
	.Em N
	is an integer in [1-9,10,20,30,...,100,500,1000] which maps to a negative
	.Sy zstd
	level. The lower the level the faster the compression - 1000 provides
	the fastest compression and lowest compression ratio.
	.Sy zstd-fast
	is equivalent to
	.Sy zstd-fast-1 .
	.Pp
	The
	.Sy zle
	compression algorithm compresses runs of zeros.
	.Pp
	This property can also be referred to by its shortened column name
	.Sy compress .
	Changing this property affects only newly-written data.
	.Pp
	When any setting except
	.Sy off
	is selected, compression will explicitly check for blocks consisting of only
	zeroes (the NUL byte). When a zero-filled block is detected, it is stored as
	a hole and not compressed using the indicated compression algorithm.
	.Pp
	Any block being compressed must be no larger than 7/8 of its original size
	after compression, otherwise the compression will not be considered worthwhile
	and the block saved uncompressed. Note that when the logical block is less than
	8 times the disk sector size this effectively reduces the necessary compression
	ratio; for example 8k blocks on disks with 4k disk sectors must compress to 1/2
	or less of their original size.
	.It Xo
	.Sy context Ns = Ns Sy none Ns \| Ns
	.Em SELinux_User:SElinux_Role:Selinux_Type:Sensitivity_Level
	.Xc
	This flag sets the SELinux context for all files in the file system under
	a mount point for that file system. See
	.Xr selinux 8
	for more information.
	.It Xo
	.Sy fscontext Ns = Ns Sy none Ns \| Ns
	.Em SELinux_User:SElinux_Role:Selinux_Type:Sensitivity_Level
	.Xc
	This flag sets the SELinux context for the file system file system being
	mounted. See
	.Xr selinux 8
	for more information.
	.It Xo
	.Sy defcontext Ns = Ns Sy none Ns \| Ns
	.Em SELinux_User:SElinux_Role:Selinux_Type:Sensitivity_Level
	.Xc
	This flag sets the SELinux default context for unlabeled files. See
	.Xr selinux 8
	for more information.
	.It Xo
	.Sy rootcontext Ns = Ns Sy none Ns \| Ns
	.Em SELinux_User:SElinux_Role:Selinux_Type:Sensitivity_Level
	.Xc
	This flag sets the SELinux context for the root inode of the file system. See
	.Xr selinux 8
	for more information.
	.It Sy copies Ns = Ns Sy 1 Ns \| Ns Sy 2 Ns \| Ns Sy 3
	Controls the number of copies of data stored for this dataset.
	These copies are in addition to any redundancy provided by the pool, for
	example, mirroring or RAID-Z.
	The copies are stored on different disks, if possible.
	The space used by multiple copies is charged to the associated file and dataset,
	changing the
	.Sy used
	property and counting against quotas and reservations.
	.Pp
	Changing this property only affects newly-written data.
	Therefore, set this property at file system creation time by using the
	.Fl o Sy copies Ns = Ns Ar N
	option.
	.Pp
	Remember that ZFS will not import a pool with a missing top-level vdev. Do
	.Sy NOT
	create, for example a two-disk striped pool and set
	.Sy copies=2
	on some datasets thinking you have setup redundancy for them. When a disk
	fails you will not be able to import the pool and will have lost all of your
	data.
	.Pp
	Encrypted datasets may not have
	.Sy copies Ns = Ns Em 3
	since the implementation stores some encryption metadata where the third copy
	would normally be.
	.It Sy devices Ns = Ns Sy on Ns \| Ns Sy off
	Controls whether device nodes can be opened on this file system.
	The default value is
	.Sy on .
	The values
	.Sy on
	and
	.Sy off
	are equivalent to the
	.Sy dev
	and
	.Sy nodev
	mount options.
	.It Xo
	.Sy dedup Ns = Ns Sy off Ns \| Ns Sy on Ns \| Ns Sy verify Ns \| Ns
	.Sy sha256[,verify] Ns \| Ns Sy sha512[,verify] Ns \| Ns Sy skein[,verify] Ns \| Ns
	.Sy edonr,verify
	.Xc
	Configures deduplication for a dataset. The default value is
	.Sy off .
	The default deduplication checksum is
	.Sy sha256
	(this may change in the future). When
	.Sy dedup
	is enabled, the checksum defined here overrides the
	.Sy checksum
	property. Setting the value to
	.Sy verify
	has the same effect as the setting
	.Sy sha256,verify.
	.Pp
	If set to
	.Sy verify ,
	ZFS will do a byte-to-byte comparison in case of two blocks having the same
	signature to make sure the block contents are identical. Specifying
	.Sy verify
	is mandatory for the
	.Sy edonr
	algorithm.
	.Pp
	Unless necessary, deduplication should NOT be enabled on a system. See the
	.Em Deduplication
	section of
	.Xr zfsconcepts 8 .
	.It Xo
	.Sy dnodesize Ns = Ns Sy legacy Ns \| Ns Sy auto Ns \| Ns Sy 1k Ns \| Ns
	.Sy 2k Ns \| Ns Sy 4k Ns \| Ns Sy 8k Ns \| Ns Sy 16k
	.Xc
	Specifies a compatibility mode or literal value for the size of dnodes in the
	file system. The default value is
	.Sy legacy .
	Setting this property to a value other than
	.Sy legacy
	requires the large_dnode pool feature to be enabled.
	.Pp
	Consider setting
	.Sy dnodesize
	to
	.Sy auto
	if the dataset uses the
	.Sy xattr=sa
	property setting and the workload makes heavy use of extended attributes. This
	may be applicable to SELinux-enabled systems, Lustre servers, and Samba
	servers, for example. Literal values are supported for cases where the optimal
	size is known in advance and for performance testing.
	.Pp
	Leave
	.Sy dnodesize
	set to
	.Sy legacy
	if you need to receive a send stream of this dataset on a pool that doesn't
	enable the large_dnode feature, or if you need to import this pool on a system
	that doesn't support the large_dnode feature.
	.Pp
	This property can also be referred to by its shortened column name,
	.Sy dnsize .
	.It Xo
	.Sy encryption Ns = Ns Sy off Ns \| Ns Sy on Ns \| Ns Sy aes-128-ccm Ns \| Ns
	.Sy aes-192-ccm Ns \| Ns Sy aes-256-ccm Ns \| Ns Sy aes-128-gcm Ns \| Ns
	.Sy aes-192-gcm Ns \| Ns Sy aes-256-gcm
	.Xc
	Controls the encryption cipher suite (block cipher, key length, and mode) used
	for this dataset. Requires the
	.Sy encryption
	feature to be enabled on the pool.
	Requires a
	.Sy keyformat
	to be set at dataset creation time.
	.Pp
	Selecting
	.Sy encryption Ns = Ns Sy on
	when creating a dataset indicates that the default encryption suite will be
	selected, which is currently
	.Sy aes-256-gcm .
	In order to provide consistent data protection, encryption must be specified at
	dataset creation time and it cannot be changed afterwards.
	.Pp
	For more details and caveats about encryption see the
	.Em Encryption
	section of
	.Xr zfs-load-key 8 .
	.It Sy keyformat Ns = Ns Sy raw Ns \| Ns Sy hex Ns \| Ns Sy passphrase
	Controls what format the user's encryption key will be provided as. This
	property is only set when the dataset is encrypted.
	.Pp
	Raw keys and hex keys must be 32 bytes long (regardless of the chosen
	encryption suite) and must be randomly generated. A raw key can be generated
	with the following command:
	.Bd -literal
	# dd if=/dev/urandom of=/path/to/output/key bs=32 count=1
	.Ed
	.Pp
	Passphrases must be between 8 and 512 bytes long and will be processed through
	PBKDF2 before being used (see the
	.Sy pbkdf2iters
	property). Even though the
	encryption suite cannot be changed after dataset creation, the keyformat can be
	with
	.Nm zfs Cm change-key .
	.It Xo
	.Sy keylocation Ns = Ns Sy prompt Ns \| Ns Sy file:// Ns Em </absolute/file/path>
	.Xc
	Controls where the user's encryption key will be loaded from by default for
	commands such as
	.Nm zfs Cm load-key
	and
	.Nm zfs Cm mount Cm -l .
	This property is only set for encrypted datasets which are encryption roots. If
	unspecified, the default is
	.Sy prompt.
	.Pp
	Even though the encryption suite cannot be changed after dataset creation, the
	keylocation can be with either
	.Nm zfs Cm set
	or
	.Nm zfs Cm change-key .
	If
	.Sy prompt
	is selected ZFS will ask for the key at the command prompt when it is required
	to access the encrypted data (see
	.Nm zfs Cm load-key
	for details). This setting will also allow the key to be passed in via STDIN,
	but users should be careful not to place keys which should be kept secret on
	the command line. If a file URI is selected, the key will be loaded from the
	specified absolute file path.
	.It Sy pbkdf2iters Ns = Ns Ar iterations
	Controls the number of PBKDF2 iterations that a
	.Sy passphrase
	encryption key should be run through when processing it into an encryption key.
	This property is only defined when encryption is enabled and a keyformat of
	.Sy passphrase
	is selected. The goal of PBKDF2 is to significantly increase the
	computational difficulty needed to brute force a user's passphrase. This is
	accomplished by forcing the attacker to run each passphrase through a
	computationally expensive hashing function many times before they arrive at the
	resulting key. A user who actually knows the passphrase will only have to pay
	this cost once. As CPUs become better at processing, this number should be
	raised to ensure that a brute force attack is still not possible. The current
	default is
	.Sy 350000
	and the minimum is
	.Sy 100000 .
	This property may be changed with
	.Nm zfs Cm change-key .
	.It Sy exec Ns = Ns Sy on Ns \| Ns Sy off
	Controls whether processes can be executed from within this file system.
	The default value is
	.Sy on .
	The values
	.Sy on
	and
	.Sy off
	are equivalent to the
	.Sy exec
	and
	.Sy noexec
	mount options.
	.It Sy filesystem_limit Ns = Ns Em count Ns \| Ns Sy none
	Limits the number of filesystems and volumes that can exist under this point in
	the dataset tree.
	The limit is not enforced if the user is allowed to change the limit.
	Setting a
	.Sy filesystem_limit
	to
	.Sy on
	a descendent of a filesystem that already has a
	.Sy filesystem_limit
	does not override the ancestor's
	.Sy filesystem_limit ,
	but rather imposes an additional limit.
	This feature must be enabled to be used
	.Po see
	.Xr zpool-features 5
	.Pc .
	.It Sy special_small_blocks Ns = Ns Em size
	This value represents the threshold block size for including small file
	blocks into the special allocation class. Blocks smaller than or equal to this
	value will be assigned to the special allocation class while greater blocks
	will be assigned to the regular class. Valid values are zero or a power of two
	from 512B up to 1M. The default size is 0 which means no small file blocks
	will be allocated in the special class.
	.Pp
	Before setting this property, a special class vdev must be added to the
	pool. See
	-.Xr zpool 8
	+.Xr zpoolconcepts 8
	for more details on the special allocation class.
	.It Sy mountpoint Ns = Ns Pa path Ns \| Ns Sy none Ns \| Ns Sy legacy
	Controls the mount point used for this file system.
	See the
	.Em Mount Points
	section of
	.Xr zfsconcepts 8
	for more information on how this property is used.
	.Pp
	When the
	.Sy mountpoint
	property is changed for a file system, the file system and any children that
	inherit the mount point are unmounted.
	If the new value is
	.Sy legacy ,
	then they remain unmounted.
	Otherwise, they are automatically remounted in the new location if the property
	was previously
	.Sy legacy
	or
	.Sy none ,
	or if they were mounted before the property was changed.
	In addition, any shared file systems are unshared and shared in the new
	location.
	.It Sy nbmand Ns = Ns Sy on Ns \| Ns Sy off
	Controls whether the file system should be mounted with
	.Sy nbmand
	-.Pq Non Blocking mandatory locks .
	+.Pq Non-blocking mandatory locks .
	This is used for SMB clients.
	Changes to this property only take effect when the file system is umounted and
	-remounted.
	-See
	-.Xr mount 8
	-for more information on
	-.Sy nbmand
	-mounts. This property is not used on Linux.
	+remounted. Support for these locks is scarce and not described by POSIX.
	.It Sy overlay Ns = Ns Sy on Ns \| Ns Sy off
	Allow mounting on a busy directory or a directory which already contains
	files or directories.
	This is the default mount behavior for Linux and FreeBSD file systems.
	On these platforms the property is
	.Sy on
	by default.
	Set to
	.Sy off
	to disable overlay mounts for consistency with OpenZFS on other platforms.
	.It Sy primarycache Ns = Ns Sy all Ns \| Ns Sy none Ns \| Ns Sy metadata
	Controls what is cached in the primary cache
	.Pq ARC .
	If this property is set to
	.Sy all ,
	then both user data and metadata is cached.
	If this property is set to
	.Sy none ,
	then neither user data nor metadata is cached.
	If this property is set to
	.Sy metadata ,
	then only metadata is cached.
	The default value is
	.Sy all .
	.It Sy quota Ns = Ns Em size Ns \| Ns Sy none
	Limits the amount of space a dataset and its descendents can consume.
	This property enforces a hard limit on the amount of space used.
	This includes all space consumed by descendents, including file systems and
	snapshots.
	Setting a quota on a descendent of a dataset that already has a quota does not
	override the ancestor's quota, but rather imposes an additional limit.
	.Pp
	Quotas cannot be set on volumes, as the
	.Sy volsize
	property acts as an implicit quota.
	.It Sy snapshot_limit Ns = Ns Em count Ns \| Ns Sy none
	Limits the number of snapshots that can be created on a dataset and its
	descendents.
	Setting a
	.Sy snapshot_limit
	on a descendent of a dataset that already has a
	.Sy snapshot_limit
	does not override the ancestor's
	.Sy snapshot_limit ,
	but rather imposes an additional limit.
	The limit is not enforced if the user is allowed to change the limit.
	For example, this means that recursive snapshots taken from the global zone are
	counted against each delegated dataset within a zone.
	This feature must be enabled to be used
	.Po see
	.Xr zpool-features 5
	.Pc .
	.It Sy userquota@ Ns Em user Ns = Ns Em size Ns \| Ns Sy none
	Limits the amount of space consumed by the specified user.
	User space consumption is identified by the
	.Sy userspace@ Ns Em user
	property.
	.Pp
	Enforcement of user quotas may be delayed by several seconds.
	This delay means that a user might exceed their quota before the system notices
	that they are over quota and begins to refuse additional writes with the
	.Er EDQUOT
	error message.
	See the
	.Nm zfs Cm userspace
	subcommand for more information.
	.Pp
	Unprivileged users can only access their own groups' space usage.
	The root user, or a user who has been granted the
	.Sy userquota
	privilege with
	.Nm zfs Cm allow ,
	can get and set everyone's quota.
	.Pp
	This property is not available on volumes, on file systems before version 4, or
	on pools before version 15.
	The
	.Sy userquota@ Ns Em ...
	properties are not displayed by
	.Nm zfs Cm get Sy all .
	The user's name must be appended after the
	.Sy @
	symbol, using one of the following forms:
	.Bl -bullet
	.It
	.Em POSIX name
	.Po for example,
	.Sy joe
	.Pc
	.It
	.Em POSIX numeric ID
	.Po for example,
	.Sy 789
	.Pc
	.It
	.Em SID name
	.Po for example,
	.Sy joe.smith@mydomain
	.Pc
	.It
	.Em SID numeric ID
	.Po for example,
	.Sy S-1-123-456-789
	.Pc
	.El
	.Pp
	Files created on Linux always have POSIX owners.
	.It Sy userobjquota@ Ns Em user Ns = Ns Em size Ns \| Ns Sy none
	The
	.Sy userobjquota
	is similar to
	.Sy userquota
	but it limits the number of objects a user can create. Please refer to
	.Sy userobjused
	for more information about how objects are counted.
	.It Sy groupquota@ Ns Em group Ns = Ns Em size Ns \| Ns Sy none
	Limits the amount of space consumed by the specified group.
	Group space consumption is identified by the
	.Sy groupused@ Ns Em group
	property.
	.Pp
	Unprivileged users can access only their own groups' space usage.
	The root user, or a user who has been granted the
	.Sy groupquota
	privilege with
	.Nm zfs Cm allow ,
	can get and set all groups' quotas.
	.It Sy groupobjquota@ Ns Em group Ns = Ns Em size Ns \| Ns Sy none
	The
	.Sy groupobjquota
	is similar to
	.Sy groupquota
	but it limits number of objects a group can consume. Please refer to
	.Sy userobjused
	for more information about how objects are counted.
	.It Sy projectquota@ Ns Em project Ns = Ns Em size Ns \| Ns Sy none
	Limits the amount of space consumed by the specified project. Project
	space consumption is identified by the
	.Sy projectused@ Ns Em project
	property. Please refer to
	.Sy projectused
	for more information about how project is identified and set/changed.
	.Pp
	The root user, or a user who has been granted the
	.Sy projectquota
	privilege with
	.Nm zfs allow ,
	can access all projects' quota.
	.It Sy projectobjquota@ Ns Em project Ns = Ns Em size Ns \| Ns Sy none
	The
	.Sy projectobjquota
	is similar to
	.Sy projectquota
	but it limits number of objects a project can consume. Please refer to
	.Sy userobjused
	for more information about how objects are counted.
	.It Sy readonly Ns = Ns Sy on Ns \| Ns Sy off
	Controls whether this dataset can be modified.
	The default value is
	.Sy off .
	The values
	.Sy on
	and
	.Sy off
	are equivalent to the
	.Sy ro
	and
	.Sy rw
	mount options.
	.Pp
	This property can also be referred to by its shortened column name,
	.Sy rdonly .
	.It Sy recordsize Ns = Ns Em size
	Specifies a suggested block size for files in the file system.
	This property is designed solely for use with database workloads that access
	files in fixed-size records.
	ZFS automatically tunes block sizes according to internal algorithms optimized
	for typical access patterns.
	.Pp
	For databases that create very large files but access them in small random
	chunks, these algorithms may be suboptimal.
	Specifying a
	.Sy recordsize
	greater than or equal to the record size of the database can result in
	significant performance gains.
	Use of this property for general purpose file systems is strongly discouraged,
	and may adversely affect performance.
	.Pp
	The size specified must be a power of two greater than or equal to 512 and less
	than or equal to 128 Kbytes.
	If the
	.Sy large_blocks
	feature is enabled on the pool, the size may be up to 1 Mbyte.
	See
	.Xr zpool-features 5
	for details on ZFS feature flags.
	.Pp
	Changing the file system's
	.Sy recordsize
	affects only files created afterward; existing files are unaffected.
	.Pp
	This property can also be referred to by its shortened column name,
	.Sy recsize .
	.It Sy redundant_metadata Ns = Ns Sy all Ns \| Ns Sy most
	Controls what types of metadata are stored redundantly.
	ZFS stores an extra copy of metadata, so that if a single block is corrupted,
	the amount of user data lost is limited.
	This extra copy is in addition to any redundancy provided at the pool level
	.Pq e.g. by mirroring or RAID-Z ,
	and is in addition to an extra copy specified by the
	.Sy copies
	property
	.Pq up to a total of 3 copies .
	For example if the pool is mirrored,
	.Sy copies Ns = Ns 2 ,
	and
	.Sy redundant_metadata Ns = Ns Sy most ,
	then ZFS stores 6 copies of most metadata, and 4 copies of data and some
	metadata.
	.Pp
	When set to
	.Sy all ,
	ZFS stores an extra copy of all metadata.
	If a single on-disk block is corrupt, at worst a single block of user data
	.Po which is
	.Sy recordsize
	bytes long
	.Pc
	can be lost.
	.Pp
	When set to
	.Sy most ,
	ZFS stores an extra copy of most types of metadata.
	This can improve performance of random writes, because less metadata must be
	written.
	In practice, at worst about 100 blocks
	.Po of
	.Sy recordsize
	bytes each
	.Pc
	of user data can be lost if a single on-disk block is corrupt.
	The exact behavior of which metadata blocks are stored redundantly may change in
	future releases.
	.Pp
	The default value is
	.Sy all .
	.It Sy refquota Ns = Ns Em size Ns \| Ns Sy none
	Limits the amount of space a dataset can consume.
	This property enforces a hard limit on the amount of space used.
	This hard limit does not include space used by descendents, including file
	systems and snapshots.
	.It Sy refreservation Ns = Ns Em size Ns \| Ns Sy none Ns \| Ns Sy auto
	The minimum amount of space guaranteed to a dataset, not including its
	descendents.
	When the amount of space used is below this value, the dataset is treated as if
	it were taking up the amount of space specified by
	.Sy refreservation .
	The
	.Sy refreservation
	reservation is accounted for in the parent datasets' space used, and counts
	against the parent datasets' quotas and reservations.
	.Pp
	If
	.Sy refreservation
	is set, a snapshot is only allowed if there is enough free pool space outside of
	this reservation to accommodate the current number of
	.Qq referenced
	bytes in the dataset.
	.Pp
	If
	.Sy refreservation
	is set to
	.Sy auto ,
	a volume is thick provisioned
	.Po or
	.Qq not sparse
	.Pc .
	.Sy refreservation Ns = Ns Sy auto
	is only supported on volumes.
	See
	.Sy volsize
	in the
	.Sx Native Properties
	section for more information about sparse volumes.
	.Pp
	This property can also be referred to by its shortened column name,
	.Sy refreserv .
	.It Sy relatime Ns = Ns Sy on Ns \| Ns Sy off
	Controls the manner in which the access time is updated when
	.Sy atime=on
	is set. Turning this property on causes the access time to be updated relative
	to the modify or change time. Access time is only updated if the previous
	access time was earlier than the current modify or change time or if the
	existing access time hasn't been updated within the past 24 hours. The default
	value is
	.Sy off .
	The values
	.Sy on
	and
	.Sy off
	are equivalent to the
	.Sy relatime
	and
	.Sy norelatime
	mount options.
	.It Sy reservation Ns = Ns Em size Ns \| Ns Sy none
	The minimum amount of space guaranteed to a dataset and its descendants.
	When the amount of space used is below this value, the dataset is treated as if
	it were taking up the amount of space specified by its reservation.
	Reservations are accounted for in the parent datasets' space used, and count
	against the parent datasets' quotas and reservations.
	.Pp
	This property can also be referred to by its shortened column name,
	.Sy reserv .
	.It Sy secondarycache Ns = Ns Sy all Ns \| Ns Sy none Ns \| Ns Sy metadata
	Controls what is cached in the secondary cache
	.Pq L2ARC .
	If this property is set to
	.Sy all ,
	then both user data and metadata is cached.
	If this property is set to
	.Sy none ,
	then neither user data nor metadata is cached.
	If this property is set to
	.Sy metadata ,
	then only metadata is cached.
	The default value is
	.Sy all .
	.It Sy setuid Ns = Ns Sy on Ns \| Ns Sy off
	Controls whether the setuid bit is respected for the file system.
	The default value is
	.Sy on .
	The values
	.Sy on
	and
	.Sy off
	are equivalent to the
	.Sy suid
	and
	.Sy nosuid
	mount options.
	.It Sy sharesmb Ns = Ns Sy on Ns \| Ns Sy off Ns \| Ns Em opts
	Controls whether the file system is shared by using
	.Sy Samba USERSHARES
	and what options are to be used. Otherwise, the file system is automatically
	shared and unshared with the
	.Nm zfs Cm share
	and
	.Nm zfs Cm unshare
	commands. If the property is set to on, the
	.Xr net 8
	command is invoked to create a
	.Sy USERSHARE .
	.Pp
	Because SMB shares requires a resource name, a unique resource name is
	constructed from the dataset name. The constructed name is a copy of the
	dataset name except that the characters in the dataset name, which would be
	invalid in the resource name, are replaced with underscore (_) characters.
	Linux does not currently support additional options which might be available
	on Solaris.
	.Pp
	If the
	.Sy sharesmb
	property is set to
	.Sy off ,
	the file systems are unshared.
	.Pp
	The share is created with the ACL (Access Control List) "Everyone:F" ("F"
	stands for "full permissions", ie. read and write permissions) and no guest
	access (which means Samba must be able to authenticate a real user, system
	passwd/shadow, LDAP or smbpasswd based) by default. This means that any
	additional access control (disallow specific user specific access etc) must
	be done on the underlying file system.
	.It Sy sharenfs Ns = Ns Sy on Ns \| Ns Sy off Ns \| Ns Em opts
	Controls whether the file system is shared via NFS, and what options are to be
	used.
	A file system with a
	.Sy sharenfs
	property of
	.Sy off
	is managed with the
	.Xr exportfs 8
	command and entries in the
	.Em /etc/exports
	file.
	Otherwise, the file system is automatically shared and unshared with the
	.Nm zfs Cm share
	and
	.Nm zfs Cm unshare
	commands.
	If the property is set to
	.Sy on ,
	the dataset is shared using the default options:
	.Pp
	.Em sec=sys,rw,crossmnt,no_subtree_check
	.Pp
	See
	.Xr exports 5
	for the meaning of the default options. Otherwise, the
	.Xr exportfs 8
	command is invoked with options equivalent to the contents of this property.
	.Pp
	When the
	.Sy sharenfs
	property is changed for a dataset, the dataset and any children inheriting the
	property are re-shared with the new options, only if the property was previously
	.Sy off ,
	or if they were shared before the property was changed.
	If the new property is
	.Sy off ,
	the file systems are unshared.
	.It Sy logbias Ns = Ns Sy latency Ns \| Ns Sy throughput
	Provide a hint to ZFS about handling of synchronous requests in this dataset.
	If
	.Sy logbias
	is set to
	.Sy latency
	.Pq the default ,
	ZFS will use pool log devices
	.Pq if configured
	to handle the requests at low latency.
	If
	.Sy logbias
	is set to
	.Sy throughput ,
	ZFS will not use configured pool log devices.
	ZFS will instead optimize synchronous operations for global pool throughput and
	efficient use of resources.
	.It Sy snapdev Ns = Ns Sy hidden Ns \| Ns Sy visible
	Controls whether the volume snapshot devices under
	.Em /dev/zvol/<pool>
	are hidden or visible. The default value is
	.Sy hidden .
	.It Sy snapdir Ns = Ns Sy hidden Ns \| Ns Sy visible
	Controls whether the
	.Pa .zfs
	directory is hidden or visible in the root of the file system as discussed in
	the
	.Em Snapshots
	section of
	.Xr zfsconcepts 8 .
	The default value is
	.Sy hidden .
	.It Sy sync Ns = Ns Sy standard Ns \| Ns Sy always Ns \| Ns Sy disabled
	Controls the behavior of synchronous requests
	.Pq e.g. fsync, O_DSYNC .
	.Sy standard
	is the
	.Tn POSIX
	specified behavior of ensuring all synchronous requests are written to stable
	storage and all devices are flushed to ensure data is not cached by device
	controllers
	.Pq this is the default .
	.Sy always
	causes every file system transaction to be written and flushed before its
	system call returns.
	This has a large performance penalty.
	.Sy disabled
	disables synchronous requests.
	File system transactions are only committed to stable storage periodically.
	This option will give the highest performance.
	However, it is very dangerous as ZFS would be ignoring the synchronous
	transaction demands of applications such as databases or NFS.
	Administrators should only use this option when the risks are understood.
	.It Sy version Ns = Ns Em N Ns \| Ns Sy current
	The on-disk version of this file system, which is independent of the pool
	version.
	This property can only be set to later supported versions.
	See the
	.Nm zfs Cm upgrade
	command.
	.It Sy volsize Ns = Ns Em size
	For volumes, specifies the logical size of the volume.
	By default, creating a volume establishes a reservation of equal size.
	For storage pools with a version number of 9 or higher, a
	.Sy refreservation
	is set instead.
	Any changes to
	.Sy volsize
	are reflected in an equivalent change to the reservation
	.Po or
	.Sy refreservation
	.Pc .
	The
	.Sy volsize
	can only be set to a multiple of
	.Sy volblocksize ,
	and cannot be zero.
	.Pp
	The reservation is kept equal to the volume's logical size to prevent unexpected
	behavior for consumers.
	Without the reservation, the volume could run out of space, resulting in
	undefined behavior or data corruption, depending on how the volume is used.
	These effects can also occur when the volume size is changed while it is in use
	.Pq particularly when shrinking the size .
	Extreme care should be used when adjusting the volume size.
	.Pp
	Though not recommended, a
	.Qq sparse volume
	.Po also known as
	.Qq thin provisioned
	.Pc
	can be created by specifying the
	.Fl s
	option to the
	.Nm zfs Cm create Fl V
	command, or by changing the value of the
	.Sy refreservation
	property
	.Po or
	.Sy reservation
	property on pool version 8 or earlier
	.Pc
	after the volume has been created.
	A
	.Qq sparse volume
	is a volume where the value of
	.Sy refreservation
	is less than the size of the volume plus the space required to store its
	metadata.
	Consequently, writes to a sparse volume can fail with
	.Er ENOSPC
	when the pool is low on space.
	For a sparse volume, changes to
	.Sy volsize
	are not reflected in the
	.Sy refreservation.
	A volume that is not sparse is said to be
	.Qq thick provisioned .
	A sparse volume can become thick provisioned by setting
	.Sy refreservation
	to
	.Sy auto .
	.It Sy volmode Ns = Ns Cm default \| full \| geom \| dev \| none
	This property specifies how volumes should be exposed to the OS.
	Setting it to
	.Sy full
	exposes volumes as fully fledged block devices, providing maximal
	functionality. The value
	.Sy geom
	is just an alias for
	.Sy full
	and is kept for compatibility.
	Setting it to
	.Sy dev
	hides its partitions.
	Volumes with property set to
	.Sy none
	are not exposed outside ZFS, but can be snapshotted, cloned, replicated, etc,
	that can be suitable for backup purposes.
	Value
	.Sy default
	means that volumes exposition is controlled by system-wide tunable
	.Va zvol_volmode ,
	where
	.Sy full ,
	.Sy dev
	and
	.Sy none
	are encoded as 1, 2 and 3 respectively.
	The default value is
	.Sy full .
	.It Sy vscan Ns = Ns Sy on Ns \| Ns Sy off
	Controls whether regular files should be scanned for viruses when a file is
	opened and closed.
	In addition to enabling this property, the virus scan service must also be
	enabled for virus scanning to occur.
	The default value is
	.Sy off .
	This property is not used on Linux.
	.It Sy xattr Ns = Ns Sy on Ns \| Ns Sy off Ns \| Ns Sy sa
	Controls whether extended attributes are enabled for this file system. Two
	styles of extended attributes are supported either directory based or system
	attribute based.
	.Pp
	The default value of
	.Sy on
	enables directory based extended attributes. This style of extended attribute
	imposes no practical limit on either the size or number of attributes which
	can be set on a file. Although under Linux the
	.Xr getxattr 2
	and
	.Xr setxattr 2
	system calls limit the maximum size to 64K. This is the most compatible
	style of extended attribute and is supported by all OpenZFS implementations.
	.Pp
	System attribute based xattrs can be enabled by setting the value to
	.Sy sa .
	The key advantage of this type of xattr is improved performance. Storing
	extended attributes as system attributes significantly decreases the amount of
	disk IO required. Up to 64K of data may be stored per-file in the space
	reserved for system attributes. If there is not enough space available for
	an extended attribute then it will be automatically written as a directory
	based xattr. System attribute based extended attributes are not accessible
	on platforms which do not support the
	.Sy xattr=sa
	feature.
	.Pp
	The use of system attribute based xattrs is strongly encouraged for users of
	SELinux or POSIX ACLs. Both of these features heavily rely on extended
	attributes and benefit significantly from the reduced access time.
	.Pp
	The values
	.Sy on
	and
	.Sy off
	are equivalent to the
	.Sy xattr
	and
	.Sy noxattr
	mount options.
	-.It Sy jailed Ns = Ns Cm off \| on
	+.It Sy jailed Ns = Ns Sy off Ns \| Ns Sy on
	Controls whether the dataset is managed from a jail. See the
	.Qq Sx Jails
	section in
	.Xr zfs 8
	for more information. Jails are a FreeBSD feature and are not relevant on
	other platforms. The default value is
	.Cm off .
	.It Sy zoned Ns = Ns Sy on Ns \| Ns Sy off
	Controls whether the dataset is managed from a non-global zone. Zones are a
	Solaris feature and are not relevant on other platforms. The default value is
	.Sy off .
	.El
	.Pp
	The following three properties cannot be changed after the file system is
	created, and therefore, should be set when the file system is created.
	If the properties are not set with the
	.Nm zfs Cm create
	or
	.Nm zpool Cm create
	commands, these properties are inherited from the parent dataset.
	If the parent dataset lacks these properties due to having been created prior to
	these features being supported, the new file system will have the default values
	for these properties.
	.Bl -tag -width ""
	.It Xo
	.Sy casesensitivity Ns = Ns Sy sensitive Ns \| Ns
	.Sy insensitive Ns \| Ns Sy mixed
	.Xc
	Indicates whether the file name matching algorithm used by the file system
	should be case-sensitive, case-insensitive, or allow a combination of both
	styles of matching.
	The default value for the
	.Sy casesensitivity
	property is
	.Sy sensitive .
	Traditionally,
	.Ux
	and
	.Tn POSIX
	file systems have case-sensitive file names.
	.Pp
	The
	.Sy mixed
	value for the
	.Sy casesensitivity
	property indicates that the file system can support requests for both
	case-sensitive and case-insensitive matching behavior.
	Currently, case-insensitive matching behavior on a file system that supports
	mixed behavior is limited to the SMB server product.
	For more information about the
	.Sy mixed
	value behavior, see the "ZFS Administration Guide".
	.It Xo
	.Sy normalization Ns = Ns Sy none Ns \| Ns Sy formC Ns \| Ns
	.Sy formD Ns \| Ns Sy formKC Ns \| Ns Sy formKD
	.Xc
	Indicates whether the file system should perform a
	.Sy unicode
	normalization of file names whenever two file names are compared, and which
	normalization algorithm should be used.
	File names are always stored unmodified, names are normalized as part of any
	comparison process.
	If this property is set to a legal value other than
	.Sy none ,
	and the
	.Sy utf8only
	property was left unspecified, the
	.Sy utf8only
	property is automatically set to
	.Sy on .
	The default value of the
	.Sy normalization
	property is
	.Sy none .
	This property cannot be changed after the file system is created.
	.It Sy utf8only Ns = Ns Sy on Ns \| Ns Sy off
	Indicates whether the file system should reject file names that include
	characters that are not present in the
	.Sy UTF-8
	character code set.
	If this property is explicitly set to
	.Sy off ,
	the normalization property must either not be explicitly set or be set to
	.Sy none .
	The default value for the
	.Sy utf8only
	property is
	.Sy off .
	This property cannot be changed after the file system is created.
	.El
	.Pp
	The
	.Sy casesensitivity ,
	.Sy normalization ,
	and
	.Sy utf8only
	properties are also new permissions that can be assigned to non-privileged users
	by using the ZFS delegated administration feature.
	.Ss "Temporary Mount Point Properties"
	When a file system is mounted, either through
	.Xr mount 8
	for legacy mounts or the
	.Nm zfs Cm mount
	command for normal file systems, its mount options are set according to its
	properties.
	The correlation between properties and mount options is as follows:
	.Bd -literal
	PROPERTY MOUNT OPTION
	atime atime/noatime
	canmount auto/noauto
	devices dev/nodev
	exec exec/noexec
	readonly ro/rw
	relatime relatime/norelatime
	setuid suid/nosuid
	xattr xattr/noxattr
	+ nbmand mand/nomand
	+ context context=
	+ fscontext fscontext=
	+ defcontext defcontext=
	+ rootcontext rootcontext=
	.Ed
	.Pp
	In addition, these options can be set on a per-mount basis using the
	.Fl o
	option, without affecting the property that is stored on disk.
	The values specified on the command line override the values stored in the
	dataset.
	The
	.Sy nosuid
	option is an alias for
	.Sy nodevices Ns \&, Ns Sy nosetuid .
	These properties are reported as
	.Qq temporary
	by the
	.Nm zfs Cm get
	command.
	If the properties are changed while the dataset is mounted, the new setting
	overrides any temporary settings.
	.Ss "User Properties"
	In addition to the standard native properties, ZFS supports arbitrary user
	properties.
	User properties have no effect on ZFS behavior, but applications or
	administrators can use them to annotate datasets
	.Pq file systems, volumes, and snapshots .
	.Pp
	User property names must contain a colon
	.Pq Qq Sy \&:
	character to distinguish them from native properties.
	They may contain lowercase letters, numbers, and the following punctuation
	characters: colon
	.Pq Qq Sy \&: ,
	dash
	.Pq Qq Sy - ,
	period
	.Pq Qq Sy \&. ,
	and underscore
	.Pq Qq Sy _ .
	The expected convention is that the property name is divided into two portions
	such as
	.Em module Ns \&: Ns Em property ,
	but this namespace is not enforced by ZFS.
	User property names can be at most 256 characters, and cannot begin with a dash
	.Pq Qq Sy - .
	.Pp
	When making programmatic use of user properties, it is strongly suggested to use
	a reversed
	.Sy DNS
	domain name for the
	.Em module
	component of property names to reduce the chance that two
	independently-developed packages use the same property name for different
	purposes.
	.Pp
	The values of user properties are arbitrary strings, are always inherited, and
	are never validated.
	All of the commands that operate on properties
	.Po Nm zfs Cm list ,
	.Nm zfs Cm get ,
	.Nm zfs Cm set ,
	and so forth
	.Pc
	can be used to manipulate both native properties and user properties.
	Use the
	.Nm zfs Cm inherit
	command to clear a user property.
	If the property is not defined in any parent dataset, it is removed entirely.
	Property values are limited to 8192 bytes.
	diff --git a/sys/contrib/openzfs/man/man8/zpool-create.8 b/sys/contrib/openzfs/man/man8/zpool-create.8
	index fe35ab8db3ea..d8cb61c45170 100644
	--- a/sys/contrib/openzfs/man/man8/zpool-create.8
	+++ b/sys/contrib/openzfs/man/man8/zpool-create.8
	@@ -1,221 +1,221 @@
	.\"
	.\" 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) 2007, Sun Microsystems, Inc. All Rights Reserved.
	.\" Copyright (c) 2012, 2018 by Delphix. All rights reserved.
	.\" Copyright (c) 2012 Cyril Plisko. All Rights Reserved.
	.\" Copyright (c) 2017 Datto Inc.
	.\" Copyright (c) 2018 George Melikov. All Rights Reserved.
	.\" Copyright 2017 Nexenta Systems, Inc.
	.\" Copyright (c) 2017 Open-E, Inc. All Rights Reserved.
	.\" Copyright (c) 2021, Colm Buckley <colm@tuatha.org>
	.\"
	.Dd August 9, 2019
	.Dt ZPOOL-CREATE 8
	.Os
	.Sh NAME
	.Nm zpool-create
	.Nd Creates a new ZFS storage pool
	.Sh SYNOPSIS
	.Nm zpool
	.Cm create
	.Op Fl dfn
	.Op Fl m Ar mountpoint
	.Oo Fl o Ar property Ns = Ns Ar value Oc Ns ...
	.Oo Fl o Ar feature@feature Ns = Ns Ar value Oc
	.Op Fl o Ar compatibility Ns = Ns Ar off \| legacy \| file Bq , Ns Ar file Ns ...
	.Oo Fl O Ar file-system-property Ns = Ns Ar value Oc Ns ...
	.Op Fl R Ar root
	.Ar pool vdev Ns ...
	.Sh DESCRIPTION
	.Bl -tag -width Ds
	.It Xo
	.Nm zpool
	.Cm create
	.Op Fl dfn
	.Op Fl m Ar mountpoint
	.Oo Fl o Ar property Ns = Ns Ar value Oc Ns ...
	.Oo Fl o Ar feature@feature Ns = Ns Ar value Oc Ns ...
	.Op Fl o Ar compatibility Ns = Ns Ar off \| legacy \| file Bq , Ns Ar file Ns ...
	.Oo Fl O Ar file-system-property Ns = Ns Ar value Oc Ns ...
	.Op Fl R Ar root
	.Op Fl t Ar tname
	.Ar pool vdev Ns ...
	.Xc
	Creates a new storage pool containing the virtual devices specified on the
	command line.
	The pool name must begin with a letter, and can only contain
	alphanumeric characters as well as underscore
	.Pq Qq Sy _ ,
	dash
	.Pq Qq Sy \&- ,
	colon
	.Pq Qq Sy \&: ,
	space
	.Pq Qq Sy \&\ ,
	and period
	.Pq Qq Sy \&. .
	The pool names
	.Sy mirror ,
	.Sy raidz ,
	.Sy draid ,
	.Sy spare
	and
	.Sy log
	are reserved, as are names beginning with
	.Sy mirror ,
	.Sy raidz ,
	.Sy draid ,
	.Sy spare ,
	and the pattern
	.Sy c[0-9] .
	The
	.Ar vdev
	specification is described in the
	.Em Virtual Devices
	section of
	-.Xr zpoolconcepts.
	+.Xr zpoolconcepts 8 .
	.Pp
	The command attempts to verify that each device specified is accessible and not
	currently in use by another subsystem. However this check is not robust enough
	to detect simultaneous attempts to use a new device in different pools, even if
	.Sy multihost
	is
	.Sy enabled.
	The
	administrator must ensure that simultaneous invocations of any combination of
	.Sy zpool replace ,
	.Sy zpool create ,
	.Sy zpool add ,
	or
	.Sy zpool labelclear ,
	do not refer to the same device. Using the same device in two pools will
	result in pool corruption.
	.Pp
	There are some uses, such as being currently mounted, or specified as the
	dedicated dump device, that prevents a device from ever being used by ZFS.
	Other uses, such as having a preexisting UFS file system, can be overridden with
	the
	.Fl f
	option.
	.Pp
	The command also checks that the replication strategy for the pool is
	consistent.
	An attempt to combine redundant and non-redundant storage in a single pool, or
	to mix disks and files, results in an error unless
	.Fl f
	is specified.
	The use of differently sized devices within a single raidz or mirror group is
	also flagged as an error unless
	.Fl f
	is specified.
	.Pp
	Unless the
	.Fl R
	option is specified, the default mount point is
	.Pa / Ns Ar pool .
	The mount point must not exist or must be empty, or else the root dataset
	cannot be mounted.
	This can be overridden with the
	.Fl m
	option.
	.Pp
	By default all supported features are enabled on the new pool. The
	.Fl d
	option or the
	.Fl o Ar compatibility
	property (eg:
	.Fl o Ar compatibility=2020
	) can be used to restrict the features that are enabled, so that the
	pool can be imported on other releases of the ZFS software.
	.Bl -tag -width Ds
	.It Fl d
	Do not enable any features on the new pool.
	Individual features can be enabled by setting their corresponding properties to
	.Sy enabled
	with the
	.Fl o
	option.
	See
	.Xr zpool-features 5
	for details about feature properties.
	.It Fl f
	Forces use of
	.Ar vdev Ns s ,
	even if they appear in use or specify a conflicting replication level.
	Not all devices can be overridden in this manner.
	.It Fl m Ar mountpoint
	Sets the mount point for the root dataset.
	The default mount point is
	.Pa /pool
	or
	.Pa altroot/pool
	if
	.Ar altroot
	is specified.
	The mount point must be an absolute path,
	.Sy legacy ,
	or
	.Sy none .
	For more information on dataset mount points, see
	.Xr zfs 8 .
	.It Fl n
	Displays the configuration that would be used without actually creating the
	pool.
	The actual pool creation can still fail due to insufficient privileges or
	device sharing.
	.It Fl o Ar property Ns = Ns Ar value
	Sets the given pool properties.
	See the
	-.Xr zpoolprops
	+.Xr zpoolprops 8
	manual page for a list of valid properties that can be set.
	.It Fl o Ar compatibility Ns = Ns Ar off \| legacy \| file Bq , Ns Ar file Ns ...
	Specifies compatibility feature sets. See
	.Xr zpool-features 5
	for more information about compatibility feature sets.
	.It Fl o Ar feature@feature Ns = Ns Ar value
	Sets the given pool feature. See the
	.Xr zpool-features 5
	section for a list of valid features that can be set.
	Value can be either disabled or enabled.
	.It Fl O Ar file-system-property Ns = Ns Ar value
	Sets the given file system properties in the root file system of the pool.
	See the
	.Xr zfsprops 8
	manual page for a list of valid properties that can be set.
	.It Fl R Ar root
	Equivalent to
	.Fl o Sy cachefile Ns = Ns Sy none Fl o Sy altroot Ns = Ns Ar root
	.It Fl t Ar tname
	Sets the in-core pool name to
	.Sy tname
	while the on-disk name will be the name specified as the pool name
	.Sy pool .
	This will set the default cachefile property to none. This is intended
	to handle name space collisions when creating pools for other systems,
	such as virtual machines or physical machines whose pools live on network
	block devices.
	.El
	.El
	.Sh SEE ALSO
	.Xr zpool-destroy 8 ,
	.Xr zpool-export 8 ,
	.Xr zpool-import 8
	diff --git a/sys/contrib/openzfs/man/man8/zpool-get.8 b/sys/contrib/openzfs/man/man8/zpool-get.8
	index c514bb0c5e8c..118743080095 100644
	--- a/sys/contrib/openzfs/man/man8/zpool-get.8
	+++ b/sys/contrib/openzfs/man/man8/zpool-get.8
	@@ -1,102 +1,102 @@
	.\"
	.\" 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) 2007, Sun Microsystems, Inc. All Rights Reserved.
	.\" Copyright (c) 2012, 2018 by Delphix. All rights reserved.
	.\" Copyright (c) 2012 Cyril Plisko. All Rights Reserved.
	.\" Copyright (c) 2017 Datto Inc.
	.\" Copyright (c) 2018 George Melikov. All Rights Reserved.
	.\" Copyright 2017 Nexenta Systems, Inc.
	.\" Copyright (c) 2017 Open-E, Inc. All Rights Reserved.
	.\"
	.Dd August 9, 2019
	.Dt ZPOOL-GET 8
	.Os
	.Sh NAME
	.Nm zpool-get
	.Nd Retrieves properties for the specified ZFS storage pool(s)
	.Sh SYNOPSIS
	.Nm zpool
	.Cm get
	.Op Fl Hp
	.Op Fl o Ar field Ns Oo , Ns Ar field Oc Ns ...
	.Sy all Ns \| Ns Ar property Ns Oo , Ns Ar property Oc Ns ...
	.Oo Ar pool Oc Ns ...
	.Nm zpool
	.Cm set
	.Ar property Ns = Ns Ar value
	.Ar pool
	.Sh DESCRIPTION
	.Bl -tag -width Ds
	.It Xo
	.Nm zpool
	.Cm get
	.Op Fl Hp
	.Op Fl o Ar field Ns Oo , Ns Ar field Oc Ns ...
	.Sy all Ns \| Ns Ar property Ns Oo , Ns Ar property Oc Ns ...
	.Oo Ar pool Oc Ns ...
	.Xc
	Retrieves the given list of properties
	.Po
	or all properties if
	.Sy all
	is used
	.Pc
	for the specified storage pool(s).
	These properties are displayed with the following fields:
	.Bd -literal
	name Name of storage pool
	property Property name
	value Property value
	source Property source, either 'default' or 'local'.
	.Ed
	.Pp
	See the
	-.Xr zpoolprops
	+.Xr zpoolprops 8
	manual page for more information on the available pool properties.
	.Bl -tag -width Ds
	.It Fl H
	Scripted mode.
	Do not display headers, and separate fields by a single tab instead of arbitrary
	space.
	.It Fl o Ar field
	A comma-separated list of columns to display.
	.Sy name Ns \&, Ns Sy property Ns \&, Ns Sy value Ns \&, Ns Sy source
	is the default value.
	.It Fl p
	Display numbers in parsable (exact) values.
	.El
	.It Xo
	.Nm zpool
	.Cm set
	.Ar property Ns = Ns Ar value
	.Ar pool
	.Xc
	Sets the given property on the specified pool.
	See the
	-.Xr zpoolprops
	+.Xr zpoolprops 8
	manual page for more information on what properties can be set and acceptable
	values.
	.El
	.Sh SEE ALSO
	.Xr zpoolprops 8 ,
	.Xr zpool-list 8 ,
	.Xr zpool-features 5
	diff --git a/sys/contrib/openzfs/man/man8/zpool-import.8 b/sys/contrib/openzfs/man/man8/zpool-import.8
	index ac349574309e..66a8d94d6de6 100644
	--- a/sys/contrib/openzfs/man/man8/zpool-import.8
	+++ b/sys/contrib/openzfs/man/man8/zpool-import.8
	@@ -1,388 +1,388 @@
	.\"
	.\" 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) 2007, Sun Microsystems, Inc. All Rights Reserved.
	.\" Copyright (c) 2012, 2018 by Delphix. All rights reserved.
	.\" Copyright (c) 2012 Cyril Plisko. All Rights Reserved.
	.\" Copyright (c) 2017 Datto Inc.
	.\" Copyright (c) 2018 George Melikov. All Rights Reserved.
	.\" Copyright 2017 Nexenta Systems, Inc.
	.\" Copyright (c) 2017 Open-E, Inc. All Rights Reserved.
	.\"
	.Dd August 9, 2019
	.Dt ZPOOL-IMPORT 8
	.Os
	.Sh NAME
	.Nm zpool-import
	.Nd Lists ZFS storage pools available to import or import the specified pools
	.Sh SYNOPSIS
	.Nm zpool
	.Cm import
	.Op Fl D
	.Op Fl d Ar dir Ns \| Ns device
	.Nm zpool
	.Cm import
	.Fl a
	.Op Fl DflmN
	.Op Fl F Oo Fl n Oc Oo Fl T Oc Oo Fl X Oc
	.Op Fl -rewind-to-checkpoint
	.Op Fl c Ar cachefile Ns \| Ns Fl d Ar dir Ns \| Ns device
	.Op Fl o Ar mntopts
	.Oo Fl o Ar property Ns = Ns Ar value Oc Ns ...
	.Op Fl R Ar root
	.Nm zpool
	.Cm import
	.Op Fl Dflm
	.Op Fl F Oo Fl n Oc Oo Fl T Oc Oo Fl X Oc
	.Op Fl -rewind-to-checkpoint
	.Op Fl c Ar cachefile Ns \| Ns Fl d Ar dir Ns \| Ns device
	.Op Fl o Ar mntopts
	.Oo Fl o Ar property Ns = Ns Ar value Oc Ns ...
	.Op Fl R Ar root
	.Op Fl s
	.Ar pool Ns \| Ns Ar id
	.Op Ar newpool Oo Fl t Oc
	.Sh DESCRIPTION
	.Bl -tag -width Ds
	.It Xo
	.Nm zpool
	.Cm import
	.Op Fl D
	.Op Fl d Ar dir Ns \| Ns device
	.Xc
	Lists pools available to import.
	If the
	.Fl d or
	.Fl c
	options are not specified, this command searches for devices using libblkid
	on Linux and geom on FreeBSD.
	The
	.Fl d
	option can be specified multiple times, and all directories are searched.
	If the device appears to be part of an exported pool, this command displays a
	summary of the pool with the name of the pool, a numeric identifier, as well as
	the vdev layout and current health of the device for each device or file.
	Destroyed pools, pools that were previously destroyed with the
	.Nm zpool Cm destroy
	command, are not listed unless the
	.Fl D
	option is specified.
	.Pp
	The numeric identifier is unique, and can be used instead of the pool name when
	multiple exported pools of the same name are available.
	.Bl -tag -width Ds
	.It Fl c Ar cachefile
	Reads configuration from the given
	.Ar cachefile
	that was created with the
	.Sy cachefile
	pool property.
	This
	.Ar cachefile
	is used instead of searching for devices.
	.It Fl d Ar dir Ns \| Ns Ar device
	Uses
	.Ar device
	or searches for devices or files in
	.Ar dir .
	The
	.Fl d
	option can be specified multiple times.
	.It Fl D
	Lists destroyed pools only.
	.El
	.It Xo
	.Nm zpool
	.Cm import
	.Fl a
	.Op Fl DflmN
	.Op Fl F Oo Fl n Oc Oo Fl T Oc Oo Fl X Oc
	.Op Fl c Ar cachefile Ns \| Ns Fl d Ar dir Ns \| Ns device
	.Op Fl o Ar mntopts
	.Oo Fl o Ar property Ns = Ns Ar value Oc Ns ...
	.Op Fl R Ar root
	.Op Fl s
	.Xc
	Imports all pools found in the search directories.
	Identical to the previous command, except that all pools with a sufficient
	number of devices available are imported.
	Destroyed pools, pools that were previously destroyed with the
	.Nm zpool Cm destroy
	command, will not be imported unless the
	.Fl D
	option is specified.
	.Bl -tag -width Ds
	.It Fl a
	Searches for and imports all pools found.
	.It Fl c Ar cachefile
	Reads configuration from the given
	.Ar cachefile
	that was created with the
	.Sy cachefile
	pool property.
	This
	.Ar cachefile
	is used instead of searching for devices.
	.It Fl d Ar dir Ns \| Ns Ar device
	Uses
	.Ar device
	or searches for devices or files in
	.Ar dir .
	The
	.Fl d
	option can be specified multiple times.
	This option is incompatible with the
	.Fl c
	option.
	.It Fl D
	Imports destroyed pools only.
	The
	.Fl f
	option is also required.
	.It Fl f
	Forces import, even if the pool appears to be potentially active.
	.It Fl F
	Recovery mode for a non-importable pool.
	Attempt to return the pool to an importable state by discarding the last few
	transactions.
	Not all damaged pools can be recovered by using this option.
	If successful, the data from the discarded transactions is irretrievably lost.
	This option is ignored if the pool is importable or already imported.
	.It Fl l
	Indicates that this command will request encryption keys for all encrypted
	datasets it attempts to mount as it is bringing the pool online. Note that if
	any datasets have a
	.Sy keylocation
	of
	.Sy prompt
	this command will block waiting for the keys to be entered. Without this flag
	encrypted datasets will be left unavailable until the keys are loaded.
	.It Fl m
	Allows a pool to import when there is a missing log device.
	Recent transactions can be lost because the log device will be discarded.
	.It Fl n
	Used with the
	.Fl F
	recovery option.
	Determines whether a non-importable pool can be made importable again, but does
	not actually perform the pool recovery.
	For more details about pool recovery mode, see the
	.Fl F
	option, above.
	.It Fl N
	Import the pool without mounting any file systems.
	.It Fl o Ar mntopts
	Comma-separated list of mount options to use when mounting datasets within the
	pool.
	See
	.Xr zfs 8
	for a description of dataset properties and mount options.
	.It Fl o Ar property Ns = Ns Ar value
	Sets the specified property on the imported pool.
	See the
	-.Xr zpoolprops
	+.Xr zpoolprops 8
	manual page for more information on the available pool properties.
	.It Fl R Ar root
	Sets the
	.Sy cachefile
	property to
	.Sy none
	and the
	.Sy altroot
	property to
	.Ar root .
	.It Fl -rewind-to-checkpoint
	Rewinds pool to the checkpointed state.
	Once the pool is imported with this flag there is no way to undo the rewind.
	All changes and data that were written after the checkpoint are lost!
	The only exception is when the
	.Sy readonly
	mounting option is enabled.
	In this case, the checkpointed state of the pool is opened and an
	administrator can see how the pool would look like if they were
	to fully rewind.
	.It Fl s
	Scan using the default search path, the libblkid cache will not be
	consulted. A custom search path may be specified by setting the
	ZPOOL_IMPORT_PATH environment variable.
	.It Fl X
	Used with the
	.Fl F
	recovery option. Determines whether extreme
	measures to find a valid txg should take place. This allows the pool to
	be rolled back to a txg which is no longer guaranteed to be consistent.
	Pools imported at an inconsistent txg may contain uncorrectable
	checksum errors. For more details about pool recovery mode, see the
	.Fl F
	option, above. WARNING: This option can be extremely hazardous to the
	health of your pool and should only be used as a last resort.
	.It Fl T
	Specify the txg to use for rollback. Implies
	.Fl FX .
	For more details
	about pool recovery mode, see the
	.Fl X
	option, above. WARNING: This option can be extremely hazardous to the
	health of your pool and should only be used as a last resort.
	.El
	.It Xo
	.Nm zpool
	.Cm import
	.Op Fl Dflm
	.Op Fl F Oo Fl n Oc Oo Fl t Oc Oo Fl T Oc Oo Fl X Oc
	.Op Fl c Ar cachefile Ns \| Ns Fl d Ar dir Ns \| Ns device
	.Op Fl o Ar mntopts
	.Oo Fl o Ar property Ns = Ns Ar value Oc Ns ...
	.Op Fl R Ar root
	.Op Fl s
	.Ar pool Ns \| Ns Ar id
	.Op Ar newpool
	.Xc
	Imports a specific pool.
	A pool can be identified by its name or the numeric identifier.
	If
	.Ar newpool
	is specified, the pool is imported using the name
	.Ar newpool .
	Otherwise, it is imported with the same name as its exported name.
	.Pp
	If a device is removed from a system without running
	.Nm zpool Cm export
	first, the device appears as potentially active.
	It cannot be determined if this was a failed export, or whether the device is
	really in use from another host.
	To import a pool in this state, the
	.Fl f
	option is required.
	.Bl -tag -width Ds
	.It Fl c Ar cachefile
	Reads configuration from the given
	.Ar cachefile
	that was created with the
	.Sy cachefile
	pool property.
	This
	.Ar cachefile
	is used instead of searching for devices.
	.It Fl d Ar dir Ns \| Ns Ar device
	Uses
	.Ar device
	or searches for devices or files in
	.Ar dir .
	The
	.Fl d
	option can be specified multiple times.
	This option is incompatible with the
	.Fl c
	option.
	.It Fl D
	Imports destroyed pool.
	The
	.Fl f
	option is also required.
	.It Fl f
	Forces import, even if the pool appears to be potentially active.
	.It Fl F
	Recovery mode for a non-importable pool.
	Attempt to return the pool to an importable state by discarding the last few
	transactions.
	Not all damaged pools can be recovered by using this option.
	If successful, the data from the discarded transactions is irretrievably lost.
	This option is ignored if the pool is importable or already imported.
	.It Fl l
	Indicates that this command will request encryption keys for all encrypted
	datasets it attempts to mount as it is bringing the pool online. Note that if
	any datasets have a
	.Sy keylocation
	of
	.Sy prompt
	this command will block waiting for the keys to be entered. Without this flag
	encrypted datasets will be left unavailable until the keys are loaded.
	.It Fl m
	Allows a pool to import when there is a missing log device.
	Recent transactions can be lost because the log device will be discarded.
	.It Fl n
	Used with the
	.Fl F
	recovery option.
	Determines whether a non-importable pool can be made importable again, but does
	not actually perform the pool recovery.
	For more details about pool recovery mode, see the
	.Fl F
	option, above.
	.It Fl o Ar mntopts
	Comma-separated list of mount options to use when mounting datasets within the
	pool.
	See
	.Xr zfs 8
	for a description of dataset properties and mount options.
	.It Fl o Ar property Ns = Ns Ar value
	Sets the specified property on the imported pool.
	See the
	-.Xr zpoolprops
	+.Xr zpoolprops 8
	manual page for more information on the available pool properties.
	.It Fl R Ar root
	Sets the
	.Sy cachefile
	property to
	.Sy none
	and the
	.Sy altroot
	property to
	.Ar root .
	.It Fl s
	Scan using the default search path, the libblkid cache will not be
	consulted. A custom search path may be specified by setting the
	ZPOOL_IMPORT_PATH environment variable.
	.It Fl X
	Used with the
	.Fl F
	recovery option. Determines whether extreme
	measures to find a valid txg should take place. This allows the pool to
	be rolled back to a txg which is no longer guaranteed to be consistent.
	Pools imported at an inconsistent txg may contain uncorrectable
	checksum errors. For more details about pool recovery mode, see the
	.Fl F
	option, above. WARNING: This option can be extremely hazardous to the
	health of your pool and should only be used as a last resort.
	.It Fl T
	Specify the txg to use for rollback. Implies
	.Fl FX .
	For more details
	about pool recovery mode, see the
	.Fl X
	option, above. WARNING: This option can be extremely hazardous to the
	health of your pool and should only be used as a last resort.
	.It Fl t
	Used with
	.Sy newpool .
	Specifies that
	.Sy newpool
	is temporary. Temporary pool names last until export. Ensures that
	the original pool name will be used in all label updates and therefore
	is retained upon export.
	Will also set -o cachefile=none when not explicitly specified.
	.El
	.El
	.Sh SEE ALSO
	.Xr zpool-export 8 ,
	.Xr zpool-list 8 ,
	.Xr zpool-status 8
	diff --git a/sys/contrib/openzfs/man/man8/zpool-list.8 b/sys/contrib/openzfs/man/man8/zpool-list.8
	index 068a68893463..4b3aae74cac1 100644
	--- a/sys/contrib/openzfs/man/man8/zpool-list.8
	+++ b/sys/contrib/openzfs/man/man8/zpool-list.8
	@@ -1,119 +1,119 @@
	.\"
	.\" 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) 2007, Sun Microsystems, Inc. All Rights Reserved.
	.\" Copyright (c) 2012, 2018 by Delphix. All rights reserved.
	.\" Copyright (c) 2012 Cyril Plisko. All Rights Reserved.
	.\" Copyright (c) 2017 Datto Inc.
	.\" Copyright (c) 2018 George Melikov. All Rights Reserved.
	.\" Copyright 2017 Nexenta Systems, Inc.
	.\" Copyright (c) 2017 Open-E, Inc. All Rights Reserved.
	.\"
	.Dd August 9, 2019
	.Dt ZPOOL-LIST 8
	.Os
	.Sh NAME
	.Nm zpool-list
	.Nd Lists ZFS storage pools along with a health status and space usage
	.Sh SYNOPSIS
	.Nm zpool
	.Cm list
	.Op Fl HgLpPv
	.Op Fl o Ar property Ns Oo , Ns Ar property Oc Ns ...
	.Op Fl T Sy u Ns \| Ns Sy d
	.Oo Ar pool Oc Ns ...
	.Op Ar interval Op Ar count
	.Sh DESCRIPTION
	.Bl -tag -width Ds
	.It Xo
	.Nm zpool
	.Cm list
	.Op Fl HgLpPv
	.Op Fl o Ar property Ns Oo , Ns Ar property Oc Ns ...
	.Op Fl T Sy u Ns \| Ns Sy d
	.Oo Ar pool Oc Ns ...
	.Op Ar interval Op Ar count
	.Xc
	Lists the given pools along with a health status and space usage.
	If no
	.Ar pool Ns s
	are specified, all pools in the system are listed.
	When given an
	.Ar interval ,
	the information is printed every
	.Ar interval
	seconds until ^C is pressed.
	If
	.Ar count
	is specified, the command exits after
	.Ar count
	reports are printed.
	.Bl -tag -width Ds
	.It Fl g
	Display vdev GUIDs instead of the normal device names. These GUIDs
	can be used in place of device names for the zpool
	detach/offline/remove/replace commands.
	.It Fl H
	Scripted mode.
	Do not display headers, and separate fields by a single tab instead of arbitrary
	space.
	.It Fl o Ar property
	Comma-separated list of properties to display.
	See the
	-.Xr zpoolprops
	+.Xr zpoolprops 8
	manual page for a list of valid properties.
	The default list is
	.Cm name , size , allocated , free , checkpoint, expandsize , fragmentation ,
	.Cm capacity , dedupratio , health , altroot .
	.It Fl L
	Display real paths for vdevs resolving all symbolic links. This can
	be used to look up the current block device name regardless of the
	/dev/disk/ path used to open it.
	.It Fl p
	Display numbers in parsable
	.Pq exact
	values.
	.It Fl P
	Display full paths for vdevs instead of only the last component of
	the path. This can be used in conjunction with the
	.Fl L
	flag.
	.It Fl T Sy u Ns \| Ns Sy d
	Display a time stamp.
	Specify
	.Sy u
	for a printed representation of the internal representation of time.
	See
	.Xr time 2 .
	Specify
	.Sy d
	for standard date format.
	See
	.Xr date 1 .
	.It Fl v
	Verbose statistics.
	Reports usage statistics for individual vdevs within the pool, in addition to
	the pool-wide statistics.
	.El
	.El
	.Sh SEE ALSO
	.Xr zpool-import 8 ,
	.Xr zpool-status 8
	diff --git a/sys/contrib/openzfs/man/man8/zpool-replace.8 b/sys/contrib/openzfs/man/man8/zpool-replace.8
	index b8527a3862c5..ae2e66344870 100644
	--- a/sys/contrib/openzfs/man/man8/zpool-replace.8
	+++ b/sys/contrib/openzfs/man/man8/zpool-replace.8
	@@ -1,105 +1,105 @@
	.\"
	.\" 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) 2007, Sun Microsystems, Inc. All Rights Reserved.
	.\" Copyright (c) 2012, 2018 by Delphix. All rights reserved.
	.\" Copyright (c) 2012 Cyril Plisko. All Rights Reserved.
	.\" Copyright (c) 2017 Datto Inc.
	.\" Copyright (c) 2018 George Melikov. All Rights Reserved.
	.\" Copyright 2017 Nexenta Systems, Inc.
	.\" Copyright (c) 2017 Open-E, Inc. All Rights Reserved.
	.\"
	.Dd May 15, 2020
	.Dt ZPOOL-REPLACE 8
	.Os
	.Sh NAME
	.Nm zpool-replace
	.Nd Replace one device with another in a ZFS storage pool
	.Sh SYNOPSIS
	.Nm zpool
	.Cm replace
	.Op Fl fsw
	.Oo Fl o Ar property Ns = Ns Ar value Oc
	.Ar pool Ar device Op Ar new_device
	.Sh DESCRIPTION
	.Bl -tag -width Ds
	.It Xo
	.Nm zpool
	.Cm replace
	.Op Fl fsw
	.Op Fl o Ar property Ns = Ns Ar value
	.Ar pool Ar device Op Ar new_device
	.Xc
	Replaces
	.Ar old_device
	with
	.Ar new_device .
	This is equivalent to attaching
	.Ar new_device ,
	waiting for it to resilver, and then detaching
	.Ar old_device .
	Any in progress scrub will be cancelled.
	.Pp
	The size of
	.Ar new_device
	must be greater than or equal to the minimum size of all the devices in a mirror
	or raidz configuration.
	.Pp
	.Ar new_device
	is required if the pool is not redundant.
	If
	.Ar new_device
	is not specified, it defaults to
	.Ar old_device .
	This form of replacement is useful after an existing disk has failed and has
	been physically replaced.
	In this case, the new disk may have the same
	.Pa /dev
	path as the old device, even though it is actually a different disk.
	ZFS recognizes this.
	.Bl -tag -width Ds
	.It Fl f
	Forces use of
	.Ar new_device ,
	even if it appears to be in use.
	Not all devices can be overridden in this manner.
	.It Fl o Ar property Ns = Ns Ar value
	Sets the given pool properties. See the
	-.Xr zpoolprops
	+.Xr zpoolprops 8
	manual page for a list of valid properties that can be set.
	The only property supported at the moment is
	.Sy ashift .
	.It Fl s
	The
	.Ar new_device
	is reconstructed sequentially to restore redundancy as quickly as possible.
	Checksums are not verfied during sequential reconstruction so a scrub is
	started when the resilver completes.
	Sequential reconstruction is not supported for raidz configurations.
	.It Fl w
	Waits until the replacement has completed before returning.
	.El
	.El
	.Sh SEE ALSO
	.Xr zpool-detach 8 ,
	.Xr zpool-initialize 8 ,
	.Xr zpool-online 8 ,
	.Xr zpool-resilver 8
	diff --git a/sys/contrib/openzfs/man/man8/zpool-split.8 b/sys/contrib/openzfs/man/man8/zpool-split.8
	index 609cbe6bad29..54cb8aa7de1c 100644
	--- a/sys/contrib/openzfs/man/man8/zpool-split.8
	+++ b/sys/contrib/openzfs/man/man8/zpool-split.8
	@@ -1,124 +1,124 @@
	.\"
	.\" 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) 2007, Sun Microsystems, Inc. All Rights Reserved.
	.\" Copyright (c) 2012, 2018 by Delphix. All rights reserved.
	.\" Copyright (c) 2012 Cyril Plisko. All Rights Reserved.
	.\" Copyright (c) 2017 Datto Inc.
	.\" Copyright (c) 2018 George Melikov. All Rights Reserved.
	.\" Copyright 2017 Nexenta Systems, Inc.
	.\" Copyright (c) 2017 Open-E, Inc. All Rights Reserved.
	.\"
	.Dd August 9, 2019
	.Dt ZPOOL-SPLIT 8
	.Os
	.Sh NAME
	.Nm zpool-split
	.Nd Split devices off a ZFS storage pool creating a new pool
	.Sh SYNOPSIS
	.Nm zpool
	.Cm split
	.Op Fl gLlnP
	.Oo Fl o Ar property Ns = Ns Ar value Oc Ns ...
	.Op Fl R Ar root
	.Ar pool newpool
	.Oo Ar device Oc Ns ...
	.Sh DESCRIPTION
	.Bl -tag -width Ds
	.It Xo
	.Nm zpool
	.Cm split
	.Op Fl gLlnP
	.Oo Fl o Ar property Ns = Ns Ar value Oc Ns ...
	.Op Fl R Ar root
	.Ar pool newpool
	.Op Ar device ...
	.Xc
	Splits devices off
	.Ar pool
	creating
	.Ar newpool .
	All vdevs in
	.Ar pool
	must be mirrors and the pool must not be in the process of resilvering.
	At the time of the split,
	.Ar newpool
	will be a replica of
	.Ar pool .
	By default, the
	last device in each mirror is split from
	.Ar pool
	to create
	.Ar newpool .
	.Pp
	The optional device specification causes the specified device(s) to be
	included in the new
	.Ar pool
	and, should any devices remain unspecified,
	the last device in each mirror is used as would be by default.
	.Bl -tag -width Ds
	.It Fl g
	Display vdev GUIDs instead of the normal device names. These GUIDs
	can be used in place of device names for the zpool
	detach/offline/remove/replace commands.
	.It Fl L
	Display real paths for vdevs resolving all symbolic links. This can
	be used to look up the current block device name regardless of the
	.Pa /dev/disk/
	path used to open it.
	.It Fl l
	Indicates that this command will request encryption keys for all encrypted
	datasets it attempts to mount as it is bringing the new pool online. Note that
	if any datasets have a
	.Sy keylocation
	of
	.Sy prompt
	this command will block waiting for the keys to be entered. Without this flag
	encrypted datasets will be left unavailable until the keys are loaded.
	.It Fl n
	Do dry run, do not actually perform the split.
	Print out the expected configuration of
	.Ar newpool .
	.It Fl P
	Display full paths for vdevs instead of only the last component of
	the path. This can be used in conjunction with the
	.Fl L
	flag.
	.It Fl o Ar property Ns = Ns Ar value
	Sets the specified property for
	.Ar newpool .
	See the
	-.Xr zpoolprops
	+.Xr zpoolprops 8
	manual page for more information on the available pool properties.
	.It Fl R Ar root
	Set
	.Sy altroot
	for
	.Ar newpool
	to
	.Ar root
	and automatically import it.
	.El
	.El
	.Sh SEE ALSO
	.Xr zpool-import 8 ,
	.Xr zpool-list 8 ,
	.Xr zpool-remove 8
	diff --git a/sys/contrib/openzfs/man/man8/zpool-upgrade.8 b/sys/contrib/openzfs/man/man8/zpool-upgrade.8
	index face5b138ff3..15baf8a52fba 100644
	--- a/sys/contrib/openzfs/man/man8/zpool-upgrade.8
	+++ b/sys/contrib/openzfs/man/man8/zpool-upgrade.8
	@@ -1,106 +1,108 @@
	.\"
	.\" 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) 2007, Sun Microsystems, Inc. All Rights Reserved.
	.\" Copyright (c) 2012, 2018 by Delphix. All rights reserved.
	.\" Copyright (c) 2012 Cyril Plisko. All Rights Reserved.
	.\" Copyright (c) 2017 Datto Inc.
	.\" Copyright (c) 2018 George Melikov. All Rights Reserved.
	.\" Copyright 2017 Nexenta Systems, Inc.
	.\" Copyright (c) 2017 Open-E, Inc. All Rights Reserved.
	.\" Copyright (c) 2021, Colm Buckley <colm@tuatha.org>
	.\"
	.Dd August 9, 2019
	.Dt ZPOOL-UPGRADE 8
	.Os
	.Sh NAME
	.Nm zpool-upgrade
	.Nd Manage version and feature flags of ZFS storage pools
	.Sh SYNOPSIS
	.Nm zpool
	.Cm upgrade
	.Nm zpool
	.Cm upgrade
	.Fl v
	.Nm zpool
	.Cm upgrade
	.Op Fl V Ar version
	.Fl a Ns \| Ns Ar pool Ns ...
	.Sh DESCRIPTION
	.Bl -tag -width Ds
	.It Xo
	.Nm zpool
	.Cm upgrade
	.Xc
	Displays pools which do not have all supported features enabled and pools
	formatted using a legacy ZFS version number.
	These pools can continue to be used, but some features may not be available.
	Use
	.Nm zpool Cm upgrade Fl a
	-to enable all features on all pools. (If a pool has specified compatibility
	-feature sets using the
	+to enable all features on all pools (subject to the
	.Fl o Ar compatibility
	-property, only the features present in all requested compatibility sets will
	-be enabled on that pool.)
	+property).
	.It Xo
	.Nm zpool
	.Cm upgrade
	.Fl v
	.Xc
	Displays legacy ZFS versions supported by the current software.
	See
	.Xr zpool-features 5
	for a description of feature flags features supported by the current software.
	.It Xo
	.Nm zpool
	.Cm upgrade
	.Op Fl V Ar version
	.Fl a Ns \| Ns Ar pool Ns ...
	.Xc
	-Enables all supported features on the given pool. (If the pool has specified
	-compatibility feature sets using the
	+Enables all supported features on the given pool.
	+.Pp
	+If the pool has specified compatibility feature sets using the
	.Fl o Ar compatibility
	property, only the features present in all requested compatibility sets will be
	-enabled.)
	+enabled. If this property is set to
	+.Ar legacy
	+then no upgrade will take place.
	+.Pp
	Once this is done, the pool will no longer be accessible on systems that do not
	support feature flags.
	See
	.Xr zpool-features 5
	for details on compatibility with systems that support feature flags, but do not
	support all features enabled on the pool.
	.Bl -tag -width Ds
	.It Fl a
	Enables all supported features (from specified compatibility sets, if any) on all
	pools.
	.It Fl V Ar version
	Upgrade to the specified legacy version.
	If the
	.Fl V
	flag is specified, no features will be enabled on the pool.
	This option can only be used to increase the version number up to the last
	supported legacy version number.
	.El
	.El
	.Sh SEE ALSO
	.Xr zpool-features 5 ,
	.Xr zpoolconcepts 8 ,
	.Xr zpoolprops 8 ,
	.Xr zpool-history 8
	diff --git a/sys/contrib/openzfs/man/man8/zstream.8 b/sys/contrib/openzfs/man/man8/zstream.8
	index 6056e097b0ef..2912f10c6913 100644
	--- a/sys/contrib/openzfs/man/man8/zstream.8
	+++ b/sys/contrib/openzfs/man/man8/zstream.8
	@@ -1,110 +1,111 @@
	.\"
	.\" 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) 2020 by Delphix. All rights reserved.
	.Dd March 25, 2020
	.Dt ZSTREAM 8
	.Os
	.Sh NAME
	.Nm zstream
	.Nd manipulate zfs send streams
	.Sh SYNOPSIS
	.Nm
	.Cm dump
	.Op Fl Cvd
	.Op Ar file
	.Nm
	.Cm redup
	.Op Fl v
	.Ar file
	.Nm
	.Cm token
	.Ar resume_token
	.Sh DESCRIPTION
	.sp
	-.LP
	The
	.Sy zstream
	utility manipulates zfs send streams, which are the output of the
	.Sy zfs send
	command.
	.Bl -tag -width ""
	.It Xo
	.Nm
	.Cm dump
	.Op Fl Cvd
	.Op Ar file
	.Xc
	Print information about the specified send stream, including headers and
	record counts.
	The send stream may either be in the specified
	.Ar file ,
	or provided on standard input.
	.Bl -tag -width "-D"
	.It Fl C
	Suppress the validation of checksums.
	.It Fl v
	Verbose.
	Print metadata for each record.
	.It Fl d
	Dump data contained in each record.
	Implies verbose.
	.El
	.It Xo
	.Nm
	.Cm token
	.Ar resume_token
	.Xc
	Dumps zfs resume token information
	.It Xo
	.Nm
	.Cm redup
	.Op Fl v
	.Ar file
	.Xc
	Deduplicated send streams can be generated by using the
	.Nm zfs Cm send Fl D
	command.
	The ability to send deduplicated send streams is deprecated.
	In the future, the ability to receive a deduplicated send stream with
	.Nm zfs Cm receive
	will be removed.
	However, deduplicated send streams can still be received by utilizing
	.Nm zstream Cm redup .
	.Pp
	The
	.Nm zstream Cm redup
	command is provided a
	.Ar file
	containing a deduplicated send stream, and outputs an equivalent
	non-deduplicated send stream on standard output.
	Therefore, a deduplicated send stream can be received by running:
	.Bd -literal
	# zstream redup DEDUP_STREAM_FILE \| zfs receive ...
	.Ed
	.Bl -tag -width "-D"
	.It Fl v
	Verbose.
	Print summary of converted records.
	+.El
	+.El
	.Sh SEE ALSO
	.Xr zfs 8 ,
	.Xr zfs-send 8 ,
	.Xr zfs-receive 8
	diff --git a/sys/contrib/openzfs/module/avl/avl.c b/sys/contrib/openzfs/module/avl/avl.c
	index d0473d883b3d..1a95092bc2b6 100644
	--- a/sys/contrib/openzfs/module/avl/avl.c
	+++ b/sys/contrib/openzfs/module/avl/avl.c
	@@ -1,1093 +1,1093 @@
	/*
	* 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 2009 Sun Microsystems, Inc. All rights reserved.
	* Use is subject to license terms.
	*/

	/*
	* Copyright 2015 Nexenta Systems, Inc. All rights reserved.
	* Copyright (c) 2015 by Delphix. All rights reserved.
	*/

	/*
	* AVL - generic AVL tree implementation for kernel use
	*
	* A complete description of AVL trees can be found in many CS textbooks.
	*
	* Here is a very brief overview. An AVL tree is a binary search tree that is
	* almost perfectly balanced. By "almost" perfectly balanced, we mean that at
	* any given node, the left and right subtrees are allowed to differ in height
	* by at most 1 level.
	*
	* This relaxation from a perfectly balanced binary tree allows doing
	* insertion and deletion relatively efficiently. Searching the tree is
	* still a fast operation, roughly O(log(N)).
	*
	* The key to insertion and deletion is a set of tree manipulations called
	* rotations, which bring unbalanced subtrees back into the semi-balanced state.
	*
	* This implementation of AVL trees has the following peculiarities:
	*
	* - The AVL specific data structures are physically embedded as fields
	* in the "using" data structures. To maintain generality the code
	* must constantly translate between "avl_node_t *" and containing
	* data structure "void *"s by adding/subtracting the avl_offset.
	*
	* - Since the AVL data is always embedded in other structures, there is
	* no locking or memory allocation in the AVL routines. This must be
	* provided for by the enclosing data structure's semantics. Typically,
	* avl_insert()/_add()/_remove()/avl_insert_here() require some kind of
	* exclusive write lock. Other operations require a read lock.
	*
	* - The implementation uses iteration instead of explicit recursion,
	* since it is intended to run on limited size kernel stacks. Since
	* there is no recursion stack present to move "up" in the tree,
	* there is an explicit "parent" link in the avl_node_t.
	*
	* - The left/right children pointers of a node are in an array.
	* In the code, variables (instead of constants) are used to represent
	* left and right indices. The implementation is written as if it only
	* dealt with left handed manipulations. By changing the value assigned
	* to "left", the code also works for right handed trees. The
	* following variables/terms are frequently used:
	*
	* int left; // 0 when dealing with left children,
	* // 1 for dealing with right children
	*
	* int left_heavy; // -1 when left subtree is taller at some node,
	* // +1 when right subtree is taller
	*
	* int right; // will be the opposite of left (0 or 1)
	* int right_heavy;// will be the opposite of left_heavy (-1 or 1)
	*
	* int direction; // 0 for "<" (ie. left child); 1 for ">" (right)
	*
	* Though it is a little more confusing to read the code, the approach
	* allows using half as much code (and hence cache footprint) for tree
	* manipulations and eliminates many conditional branches.
	*
	* - The avl_index_t is an opaque "cookie" used to find nodes at or
	* adjacent to where a new value would be inserted in the tree. The value
	* is a modified "avl_node_t *". The bottom bit (normally 0 for a
	* pointer) is set to indicate if that the new node has a value greater
	* than the value of the indicated "avl_node_t *".
	*
	* Note - in addition to userland (e.g. libavl and libutil) and the kernel
	* (e.g. genunix), avl.c is compiled into ld.so and kmdb's genunix module,
	* which each have their own compilation environments and subsequent
	* requirements. Each of these environments must be considered when adding
	* dependencies from avl.c.
	*
	* Link to Illumos.org for more information on avl function:
	* [1] https://illumos.org/man/9f/avl
	*/

	#include <sys/types.h>
	#include <sys/param.h>
	#include <sys/debug.h>
	#include <sys/avl.h>
	#include <sys/cmn_err.h>
	#include <sys/mod.h>

	/*
	* Small arrays to translate between balance (or diff) values and child indices.
	*
	* Code that deals with binary tree data structures will randomly use
	* left and right children when examining a tree. C "if()" statements
	* which evaluate randomly suffer from very poor hardware branch prediction.
	* In this code we avoid some of the branch mispredictions by using the
	* following translation arrays. They replace random branches with an
	* additional memory reference. Since the translation arrays are both very
	* small the data should remain efficiently in cache.
	*/
	static const int avl_child2balance[2] = {-1, 1};
	static const int avl_balance2child[] = {0, 0, 1};


	/*
	* Walk from one node to the previous valued node (ie. an infix walk
	* towards the left). At any given node we do one of 2 things:
	*
	* - If there is a left child, go to it, then to it's rightmost descendant.
	*
	* - otherwise we return through parent nodes until we've come from a right
	* child.
	*
	* Return Value:
	* NULL - if at the end of the nodes
	* otherwise next node
	*/
	void *
	avl_walk(avl_tree_t tree, void oldnode, int left)
	{
	size_t off = tree->avl_offset;
	avl_node_t *node = AVL_DATA2NODE(oldnode, off);
	int right = 1 - left;
	int was_child;


	/*
	* nowhere to walk to if tree is empty
	*/
	if (node == NULL)
	return (NULL);

	/*
	* Visit the previous valued node. There are two possibilities:
	*
	* If this node has a left child, go down one left, then all
	* the way right.
	*/
	if (node->avl_child[left] != NULL) {
	for (node = node->avl_child[left];
	node->avl_child[right] != NULL;
	node = node->avl_child[right])
	;
	/*
	* Otherwise, return through left children as far as we can.
	*/
	} else {
	for (;;) {
	was_child = AVL_XCHILD(node);
	node = AVL_XPARENT(node);
	if (node == NULL)
	return (NULL);
	if (was_child == right)
	break;
	}
	}

	return (AVL_NODE2DATA(node, off));
	}

	/*
	* Return the lowest valued node in a tree or NULL.
	* (leftmost child from root of tree)
	*/
	void *
	avl_first(avl_tree_t *tree)
	{
	avl_node_t *node;
	avl_node_t *prev = NULL;
	size_t off = tree->avl_offset;

	for (node = tree->avl_root; node != NULL; node = node->avl_child[0])
	prev = node;

	if (prev != NULL)
	return (AVL_NODE2DATA(prev, off));
	return (NULL);
	}

	/*
	* Return the highest valued node in a tree or NULL.
	* (rightmost child from root of tree)
	*/
	void *
	avl_last(avl_tree_t *tree)
	{
	avl_node_t *node;
	avl_node_t *prev = NULL;
	size_t off = tree->avl_offset;

	for (node = tree->avl_root; node != NULL; node = node->avl_child[1])
	prev = node;

	if (prev != NULL)
	return (AVL_NODE2DATA(prev, off));
	return (NULL);
	}

	/*
	* Access the node immediately before or after an insertion point.
	*
	* "avl_index_t" is a (avl_node_t *) with the bottom bit indicating a child
	*
	* Return value:
	* NULL: no node in the given direction
	* "void *" of the found tree node
	*/
	void *
	avl_nearest(avl_tree_t *tree, avl_index_t where, int direction)
	{
	int child = AVL_INDEX2CHILD(where);
	avl_node_t *node = AVL_INDEX2NODE(where);
	void *data;
	size_t off = tree->avl_offset;

	if (node == NULL) {
	ASSERT(tree->avl_root == NULL);
	return (NULL);
	}
	data = AVL_NODE2DATA(node, off);
	if (child != direction)
	return (data);

	return (avl_walk(tree, data, direction));
	}


	/*
	* Search for the node which contains "value". The algorithm is a
	* simple binary tree search.
	*
	* return value:
	* NULL: the value is not in the AVL tree
	* *where (if not NULL) is set to indicate the insertion point
	* "void *" of the found tree node
	*/
	void *
	avl_find(avl_tree_t tree, const void value, avl_index_t *where)
	{
	avl_node_t *node;
	avl_node_t *prev = NULL;
	int child = 0;
	int diff;
	size_t off = tree->avl_offset;

	for (node = tree->avl_root; node != NULL;
	node = node->avl_child[child]) {

	prev = node;

	diff = tree->avl_compar(value, AVL_NODE2DATA(node, off));
	ASSERT(-1 <= diff && diff <= 1);
	if (diff == 0) {
	#ifdef ZFS_DEBUG
	if (where != NULL)
	*where = 0;
	#endif
	return (AVL_NODE2DATA(node, off));
	}
	child = avl_balance2child[1 + diff];

	}

	if (where != NULL)
	*where = AVL_MKINDEX(prev, child);

	return (NULL);
	}


	/*
	* Perform a rotation to restore balance at the subtree given by depth.
	*
	* This routine is used by both insertion and deletion. The return value
	* indicates:
	* 0 : subtree did not change height
	* !0 : subtree was reduced in height
	*
	* The code is written as if handling left rotations, right rotations are
	* symmetric and handled by swapping values of variables right/left[_heavy]
	*
	* On input balance is the "new" balance at "node". This value is either
	* -2 or +2.
	*/
	static int
	avl_rotation(avl_tree_t tree, avl_node_t node, int balance)
	{
	int left = !(balance < 0); /* when balance = -2, left will be 0 */
	int right = 1 - left;
	int left_heavy = balance >> 1;
	int right_heavy = -left_heavy;
	avl_node_t *parent = AVL_XPARENT(node);
	avl_node_t *child = node->avl_child[left];
	avl_node_t *cright;
	avl_node_t *gchild;
	avl_node_t *gright;
	avl_node_t *gleft;
	int which_child = AVL_XCHILD(node);
	int child_bal = AVL_XBALANCE(child);

	/* BEGIN CSTYLED */
	/*
	* case 1 : node is overly left heavy, the left child is balanced or
	* also left heavy. This requires the following rotation.
	*
	* (node bal:-2)
	* / \
	* / \
	* (child bal:0 or -1)
	* / \
	* / \
	* cright
	*
	* becomes:
	*
	* (child bal:1 or 0)
	* / \
	* / \
	* (node bal:-1 or 0)
	* / \
	* / \
	* cright
	*
	* we detect this situation by noting that child's balance is not
	* right_heavy.
	*/
	/* END CSTYLED */
	if (child_bal != right_heavy) {

	/*
	* compute new balance of nodes
	*
	* If child used to be left heavy (now balanced) we reduced
	* the height of this sub-tree -- used in "return...;" below
	*/
	child_bal += right_heavy; /* adjust towards right */

	/*
	* move "cright" to be node's left child
	*/
	cright = child->avl_child[right];
	node->avl_child[left] = cright;
	if (cright != NULL) {
	AVL_SETPARENT(cright, node);
	AVL_SETCHILD(cright, left);
	}

	/*
	* move node to be child's right child
	*/
	child->avl_child[right] = node;
	AVL_SETBALANCE(node, -child_bal);
	AVL_SETCHILD(node, right);
	AVL_SETPARENT(node, child);

	/*
	* update the pointer into this subtree
	*/
	AVL_SETBALANCE(child, child_bal);
	AVL_SETCHILD(child, which_child);
	AVL_SETPARENT(child, parent);
	if (parent != NULL)
	parent->avl_child[which_child] = child;
	else
	tree->avl_root = child;

	return (child_bal == 0);
	}

	/* BEGIN CSTYLED */
	/*
	* case 2 : When node is left heavy, but child is right heavy we use
	* a different rotation.
	*
	* (node b:-2)
	* / \
	* / \
	* / \
	* (child b:+1)
	* / \
	* / \
	* (gchild b: != 0)
	* / \
	* / \
	* gleft gright
	*
	* becomes:
	*
	* (gchild b:0)
	* / \
	* / \
	* / \
	* (child b:?) (node b:?)
	* / \ / \
	* / \ / \
	* gleft gright
	*
	* computing the new balances is more complicated. As an example:
	* if gchild was right_heavy, then child is now left heavy
	* else it is balanced
	*/
	/* END CSTYLED */
	gchild = child->avl_child[right];
	gleft = gchild->avl_child[left];
	gright = gchild->avl_child[right];

	/*
	* move gright to left child of node and
	*
	* move gleft to right child of node
	*/
	node->avl_child[left] = gright;
	if (gright != NULL) {
	AVL_SETPARENT(gright, node);
	AVL_SETCHILD(gright, left);
	}

	child->avl_child[right] = gleft;
	if (gleft != NULL) {
	AVL_SETPARENT(gleft, child);
	AVL_SETCHILD(gleft, right);
	}

	/*
	* move child to left child of gchild and
	*
	* move node to right child of gchild and
	*
	* fixup parent of all this to point to gchild
	*/
	balance = AVL_XBALANCE(gchild);
	gchild->avl_child[left] = child;
	AVL_SETBALANCE(child, (balance == right_heavy ? left_heavy : 0));
	AVL_SETPARENT(child, gchild);
	AVL_SETCHILD(child, left);

	gchild->avl_child[right] = node;
	AVL_SETBALANCE(node, (balance == left_heavy ? right_heavy : 0));
	AVL_SETPARENT(node, gchild);
	AVL_SETCHILD(node, right);

	AVL_SETBALANCE(gchild, 0);
	AVL_SETPARENT(gchild, parent);
	AVL_SETCHILD(gchild, which_child);
	if (parent != NULL)
	parent->avl_child[which_child] = gchild;
	else
	tree->avl_root = gchild;

	return (1); /* the new tree is always shorter */
	}


	/*
	* Insert a new node into an AVL tree at the specified (from avl_find()) place.
	*
	* Newly inserted nodes are always leaf nodes in the tree, since avl_find()
	* searches out to the leaf positions. The avl_index_t indicates the node
	* which will be the parent of the new node.
	*
	* After the node is inserted, a single rotation further up the tree may
	* be necessary to maintain an acceptable AVL balance.
	*/
	void
	avl_insert(avl_tree_t tree, void new_data, avl_index_t where)
	{
	avl_node_t *node;
	avl_node_t *parent = AVL_INDEX2NODE(where);
	int old_balance;
	int new_balance;
	int which_child = AVL_INDEX2CHILD(where);
	size_t off = tree->avl_offset;

	#ifdef _LP64
	ASSERT(((uintptr_t)new_data & 0x7) == 0);
	#endif

	node = AVL_DATA2NODE(new_data, off);

	/*
	* First, add the node to the tree at the indicated position.
	*/
	++tree->avl_numnodes;

	node->avl_child[0] = NULL;
	node->avl_child[1] = NULL;

	AVL_SETCHILD(node, which_child);
	AVL_SETBALANCE(node, 0);
	AVL_SETPARENT(node, parent);
	if (parent != NULL) {
	ASSERT(parent->avl_child[which_child] == NULL);
	parent->avl_child[which_child] = node;
	} else {
	ASSERT(tree->avl_root == NULL);
	tree->avl_root = node;
	}
	/*
	* Now, back up the tree modifying the balance of all nodes above the
	* insertion point. If we get to a highly unbalanced ancestor, we
	* need to do a rotation. If we back out of the tree we are done.
	* If we brought any subtree into perfect balance (0), we are also done.
	*/
	for (;;) {
	node = parent;
	if (node == NULL)
	return;

	/*
	* Compute the new balance
	*/
	old_balance = AVL_XBALANCE(node);
	new_balance = old_balance + avl_child2balance[which_child];

	/*
	* If we introduced equal balance, then we are done immediately
	*/
	if (new_balance == 0) {
	AVL_SETBALANCE(node, 0);
	return;
	}

	/*
	* If both old and new are not zero we went
	* from -1 to -2 balance, do a rotation.
	*/
	if (old_balance != 0)
	break;

	AVL_SETBALANCE(node, new_balance);
	parent = AVL_XPARENT(node);
	which_child = AVL_XCHILD(node);
	}

	/*
	* perform a rotation to fix the tree and return
	*/
	(void) avl_rotation(tree, node, new_balance);
	}

	/*
	* Insert "new_data" in "tree" in the given "direction" either after or
	* before (AVL_AFTER, AVL_BEFORE) the data "here".
	*
	* Insertions can only be done at empty leaf points in the tree, therefore
	* if the given child of the node is already present we move to either
	* the AVL_PREV or AVL_NEXT and reverse the insertion direction. Since
	* every other node in the tree is a leaf, this always works.
	*
	* To help developers using this interface, we assert that the new node
	* is correctly ordered at every step of the way in DEBUG kernels.
	*/
	void
	avl_insert_here(
	avl_tree_t *tree,
	void *new_data,
	void *here,
	int direction)
	{
	avl_node_t *node;
	int child = direction; /* rely on AVL_BEFORE == 0, AVL_AFTER == 1 */
	#ifdef ZFS_DEBUG
	int diff;
	#endif

	ASSERT(tree != NULL);
	ASSERT(new_data != NULL);
	ASSERT(here != NULL);
	ASSERT(direction == AVL_BEFORE \|\| direction == AVL_AFTER);

	/*
	* If corresponding child of node is not NULL, go to the neighboring
	* node and reverse the insertion direction.
	*/
	node = AVL_DATA2NODE(here, tree->avl_offset);

	#ifdef ZFS_DEBUG
	diff = tree->avl_compar(new_data, here);
	ASSERT(-1 <= diff && diff <= 1);
	ASSERT(diff != 0);
	ASSERT(diff > 0 ? child == 1 : child == 0);
	#endif

	if (node->avl_child[child] != NULL) {
	node = node->avl_child[child];
	child = 1 - child;
	while (node->avl_child[child] != NULL) {
	#ifdef ZFS_DEBUG
	diff = tree->avl_compar(new_data,
	AVL_NODE2DATA(node, tree->avl_offset));
	ASSERT(-1 <= diff && diff <= 1);
	ASSERT(diff != 0);
	ASSERT(diff > 0 ? child == 1 : child == 0);
	#endif
	node = node->avl_child[child];
	}
	#ifdef ZFS_DEBUG
	diff = tree->avl_compar(new_data,
	AVL_NODE2DATA(node, tree->avl_offset));
	ASSERT(-1 <= diff && diff <= 1);
	ASSERT(diff != 0);
	ASSERT(diff > 0 ? child == 1 : child == 0);
	#endif
	}
	ASSERT(node->avl_child[child] == NULL);

	avl_insert(tree, new_data, AVL_MKINDEX(node, child));
	}

	/*
	* Add a new node to an AVL tree. Strictly enforce that no duplicates can
	* be added to the tree with a VERIFY which is enabled for non-DEBUG builds.
	*/
	void
	avl_add(avl_tree_t tree, void new_node)
	{
	avl_index_t where = 0;

	VERIFY(avl_find(tree, new_node, &where) == NULL);

	avl_insert(tree, new_node, where);
	}

	/*
	* Delete a node from the AVL tree. Deletion is similar to insertion, but
	* with 2 complications.
	*
	* First, we may be deleting an interior node. Consider the following subtree:
	*
	* d c c
	* / \ / \ / \
	* b e b e b e
	* / \ / \ /
	* a c a a
	*
	* When we are deleting node (d), we find and bring up an adjacent valued leaf
	* node, say (c), to take the interior node's place. In the code this is
	* handled by temporarily swapping (d) and (c) in the tree and then using
	* common code to delete (d) from the leaf position.
	*
	* Secondly, an interior deletion from a deep tree may require more than one
	* rotation to fix the balance. This is handled by moving up the tree through
	* parents and applying rotations as needed. The return value from
	* avl_rotation() is used to detect when a subtree did not change overall
	* height due to a rotation.
	*/
	void
	avl_remove(avl_tree_t tree, void data)
	{
	avl_node_t *delete;
	avl_node_t *parent;
	avl_node_t *node;
	avl_node_t tmp;
	int old_balance;
	int new_balance;
	int left;
	int right;
	int which_child;
	size_t off = tree->avl_offset;

	delete = AVL_DATA2NODE(data, off);

	/*
	* Deletion is easiest with a node that has at most 1 child.
	* We swap a node with 2 children with a sequentially valued
	* neighbor node. That node will have at most 1 child. Note this
	* has no effect on the ordering of the remaining nodes.
	*
	* As an optimization, we choose the greater neighbor if the tree
	* is right heavy, otherwise the left neighbor. This reduces the
	* number of rotations needed.
	*/
	if (delete->avl_child[0] != NULL && delete->avl_child[1] != NULL) {

	/*
	* choose node to swap from whichever side is taller
	*/
	old_balance = AVL_XBALANCE(delete);
	left = avl_balance2child[old_balance + 1];
	right = 1 - left;

	/*
	* get to the previous value'd node
	* (down 1 left, as far as possible right)
	*/
	for (node = delete->avl_child[left];
	node->avl_child[right] != NULL;
	node = node->avl_child[right])
	;

	/*
	* create a temp placeholder for 'node'
	* move 'node' to delete's spot in the tree
	*/
	tmp = *node;

	node = delete;
	if (node->avl_child[left] == node)
	node->avl_child[left] = &tmp;

	parent = AVL_XPARENT(node);
	if (parent != NULL)
	parent->avl_child[AVL_XCHILD(node)] = node;
	else
	tree->avl_root = node;
	AVL_SETPARENT(node->avl_child[left], node);
	AVL_SETPARENT(node->avl_child[right], node);

	/*
	* Put tmp where node used to be (just temporary).
	* It always has a parent and at most 1 child.
	*/
	delete = &tmp;
	parent = AVL_XPARENT(delete);
	parent->avl_child[AVL_XCHILD(delete)] = delete;
	which_child = (delete->avl_child[1] != 0);
	if (delete->avl_child[which_child] != NULL)
	AVL_SETPARENT(delete->avl_child[which_child], delete);
	}


	/*
	* Here we know "delete" is at least partially a leaf node. It can
	* be easily removed from the tree.
	*/
	ASSERT(tree->avl_numnodes > 0);
	--tree->avl_numnodes;
	parent = AVL_XPARENT(delete);
	which_child = AVL_XCHILD(delete);
	if (delete->avl_child[0] != NULL)
	node = delete->avl_child[0];
	else
	node = delete->avl_child[1];

	/*
	* Connect parent directly to node (leaving out delete).
	*/
	if (node != NULL) {
	AVL_SETPARENT(node, parent);
	AVL_SETCHILD(node, which_child);
	}
	if (parent == NULL) {
	tree->avl_root = node;
	return;
	}
	parent->avl_child[which_child] = node;


	/*
	* Since the subtree is now shorter, begin adjusting parent balances
	* and performing any needed rotations.
	*/
	do {

	/*
	* Move up the tree and adjust the balance
	*
	* Capture the parent and which_child values for the next
	* iteration before any rotations occur.
	*/
	node = parent;
	old_balance = AVL_XBALANCE(node);
	new_balance = old_balance - avl_child2balance[which_child];
	parent = AVL_XPARENT(node);
	which_child = AVL_XCHILD(node);

	/*
	* If a node was in perfect balance but isn't anymore then
	* we can stop, since the height didn't change above this point
	* due to a deletion.
	*/
	if (old_balance == 0) {
	AVL_SETBALANCE(node, new_balance);
	break;
	}

	/*
	* If the new balance is zero, we don't need to rotate
	* else
	* need a rotation to fix the balance.
	* If the rotation doesn't change the height
	* of the sub-tree we have finished adjusting.
	*/
	if (new_balance == 0)
	AVL_SETBALANCE(node, new_balance);
	else if (!avl_rotation(tree, node, new_balance))
	break;
	} while (parent != NULL);
	}

	#define AVL_REINSERT(tree, obj) \
	avl_remove((tree), (obj)); \
	avl_add((tree), (obj))

	boolean_t
	avl_update_lt(avl_tree_t t, void obj)
	{
	void *neighbor;

	ASSERT(((neighbor = AVL_NEXT(t, obj)) == NULL) \|\|
	(t->avl_compar(obj, neighbor) <= 0));

	neighbor = AVL_PREV(t, obj);
	if ((neighbor != NULL) && (t->avl_compar(obj, neighbor) < 0)) {
	AVL_REINSERT(t, obj);
	return (B_TRUE);
	}

	return (B_FALSE);
	}

	boolean_t
	avl_update_gt(avl_tree_t t, void obj)
	{
	void *neighbor;

	ASSERT(((neighbor = AVL_PREV(t, obj)) == NULL) \|\|
	(t->avl_compar(obj, neighbor) >= 0));

	neighbor = AVL_NEXT(t, obj);
	if ((neighbor != NULL) && (t->avl_compar(obj, neighbor) > 0)) {
	AVL_REINSERT(t, obj);
	return (B_TRUE);
	}

	return (B_FALSE);
	}

	boolean_t
	avl_update(avl_tree_t t, void obj)
	{
	void *neighbor;

	neighbor = AVL_PREV(t, obj);
	if ((neighbor != NULL) && (t->avl_compar(obj, neighbor) < 0)) {
	AVL_REINSERT(t, obj);
	return (B_TRUE);
	}

	neighbor = AVL_NEXT(t, obj);
	if ((neighbor != NULL) && (t->avl_compar(obj, neighbor) > 0)) {
	AVL_REINSERT(t, obj);
	return (B_TRUE);
	}

	return (B_FALSE);
	}

	void
	avl_swap(avl_tree_t tree1, avl_tree_t tree2)
	{
	avl_node_t *temp_node;
	ulong_t temp_numnodes;

	ASSERT3P(tree1->avl_compar, ==, tree2->avl_compar);
	ASSERT3U(tree1->avl_offset, ==, tree2->avl_offset);
	ASSERT3U(tree1->avl_size, ==, tree2->avl_size);

	temp_node = tree1->avl_root;
	temp_numnodes = tree1->avl_numnodes;
	tree1->avl_root = tree2->avl_root;
	tree1->avl_numnodes = tree2->avl_numnodes;
	tree2->avl_root = temp_node;
	tree2->avl_numnodes = temp_numnodes;
	}

	/*
	* initialize a new AVL tree
	*/
	void
	avl_create(avl_tree_t tree, int (compar) (const void , const void ),
	size_t size, size_t offset)
	{
	ASSERT(tree);
	ASSERT(compar);
	ASSERT(size > 0);
	ASSERT(size >= offset + sizeof (avl_node_t));
	#ifdef _LP64
	ASSERT((offset & 0x7) == 0);
	#endif

	tree->avl_compar = compar;
	tree->avl_root = NULL;
	tree->avl_numnodes = 0;
	tree->avl_size = size;
	tree->avl_offset = offset;
	}

	/*
	* Delete a tree.
	*/
	/* ARGSUSED */
	void
	avl_destroy(avl_tree_t *tree)
	{
	ASSERT(tree);
	ASSERT(tree->avl_numnodes == 0);
	ASSERT(tree->avl_root == NULL);
	}


	/*
	* Return the number of nodes in an AVL tree.
	*/
	ulong_t
	avl_numnodes(avl_tree_t *tree)
	{
	ASSERT(tree);
	return (tree->avl_numnodes);
	}

	boolean_t
	avl_is_empty(avl_tree_t *tree)
	{
	ASSERT(tree);
	return (tree->avl_numnodes == 0);
	}

	#define CHILDBIT (1L)

	/*
	* Post-order tree walk used to visit all tree nodes and destroy the tree
	* in post order. This is used for removing all the nodes from a tree without
	* paying any cost for rebalancing it.
	*
	* example:
	*
	* void *cookie = NULL;
	* my_data_t *node;
	*
	* while ((node = avl_destroy_nodes(tree, &cookie)) != NULL)
	* free(node);
	* avl_destroy(tree);
	*
	* The cookie is really an avl_node_t to the current node's parent and
	* an indication of which child you looked at last.
	*
	* On input, a cookie value of CHILDBIT indicates the tree is done.
	*/
	void *
	avl_destroy_nodes(avl_tree_t tree, void *cookie)
	{
	avl_node_t *node;
	avl_node_t *parent;
	int child;
	void *first;
	size_t off = tree->avl_offset;

	/*
	* Initial calls go to the first node or it's right descendant.
	*/
	if (*cookie == NULL) {
	first = avl_first(tree);

	/*
	* deal with an empty tree
	*/
	if (first == NULL) {
	cookie = (void )CHILDBIT;
	return (NULL);
	}

	node = AVL_DATA2NODE(first, off);
	parent = AVL_XPARENT(node);
	goto check_right_side;
	}

	/*
	* If there is no parent to return to we are done.
	*/
	parent = (avl_node_t )((uintptr_t)(cookie) & ~CHILDBIT);
	if (parent == NULL) {
	if (tree->avl_root != NULL) {
	ASSERT(tree->avl_numnodes == 1);
	tree->avl_root = NULL;
	tree->avl_numnodes = 0;
	}
	return (NULL);
	}

	/*
	* Remove the child pointer we just visited from the parent and tree.
	*/
	child = (uintptr_t)(*cookie) & CHILDBIT;
	parent->avl_child[child] = NULL;
	ASSERT(tree->avl_numnodes > 1);
	--tree->avl_numnodes;

	/*
	- * If we just did a right child or there isn't one, go up to parent.
	+ * If we just removed a right child or there isn't one, go up to parent.
	*/
	if (child == 1 \|\| parent->avl_child[1] == NULL) {
	node = parent;
	parent = AVL_XPARENT(parent);
	goto done;
	}

	/*
	* Do parent's right child, then leftmost descendent.
	*/
	node = parent->avl_child[1];
	while (node->avl_child[0] != NULL) {
	parent = node;
	node = node->avl_child[0];
	}

	/*
	* If here, we moved to a left child. It may have one
	* child on the right (when balance == +1).
	*/
	check_right_side:
	if (node->avl_child[1] != NULL) {
	ASSERT(AVL_XBALANCE(node) == 1);
	parent = node;
	node = node->avl_child[1];
	ASSERT(node->avl_child[0] == NULL &&
	node->avl_child[1] == NULL);
	} else {
	ASSERT(AVL_XBALANCE(node) <= 0);
	}

	done:
	if (parent == NULL) {
	cookie = (void )CHILDBIT;
	ASSERT(node == tree->avl_root);
	} else {
	cookie = (void )((uintptr_t)parent \| AVL_XCHILD(node));
	}

	return (AVL_NODE2DATA(node, off));
	}

	#if defined(_KERNEL)

	static int __init
	avl_init(void)
	{
	return (0);
	}

	static void __exit
	avl_fini(void)
	{
	}

	module_init(avl_init);
	module_exit(avl_fini);
	#endif

	ZFS_MODULE_DESCRIPTION("Generic AVL tree implementation");
	ZFS_MODULE_AUTHOR(ZFS_META_AUTHOR);
	ZFS_MODULE_LICENSE(ZFS_META_LICENSE);
	ZFS_MODULE_VERSION(ZFS_META_VERSION "-" ZFS_META_RELEASE);

	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_swap);
	EXPORT_SYMBOL(avl_is_empty);
	EXPORT_SYMBOL(avl_remove);
	EXPORT_SYMBOL(avl_numnodes);
	EXPORT_SYMBOL(avl_destroy_nodes);
	EXPORT_SYMBOL(avl_destroy);
	EXPORT_SYMBOL(avl_update_lt);
	EXPORT_SYMBOL(avl_update_gt);
	EXPORT_SYMBOL(avl_update);
	diff --git a/sys/contrib/openzfs/module/icp/Makefile.in b/sys/contrib/openzfs/module/icp/Makefile.in
	index 7a01b2f08b8e..858c5a610c26 100644
	--- a/sys/contrib/openzfs/module/icp/Makefile.in
	+++ b/sys/contrib/openzfs/module/icp/Makefile.in
	@@ -1,96 +1,101 @@
	ifneq ($(KBUILD_EXTMOD),)
	src = @abs_srcdir@
	obj = @abs_builddir@
	icp_include = $(src)/include
	else
	icp_include = $(srctree)/$(src)/include
	endif

	MODULE := icp

	obj-$(CONFIG_ZFS) := $(MODULE).o

	asflags-y := -I$(icp_include)
	ccflags-y := -I$(icp_include)

	$(MODULE)-objs += illumos-crypto.o
	$(MODULE)-objs += api/kcf_cipher.o
	$(MODULE)-objs += api/kcf_digest.o
	$(MODULE)-objs += api/kcf_mac.o
	$(MODULE)-objs += api/kcf_miscapi.o
	$(MODULE)-objs += api/kcf_ctxops.o
	$(MODULE)-objs += core/kcf_callprov.o
	$(MODULE)-objs += core/kcf_prov_tabs.o
	$(MODULE)-objs += core/kcf_sched.o
	$(MODULE)-objs += core/kcf_mech_tabs.o
	$(MODULE)-objs += core/kcf_prov_lib.o
	$(MODULE)-objs += spi/kcf_spi.o
	$(MODULE)-objs += io/aes.o
	$(MODULE)-objs += io/edonr_mod.o
	$(MODULE)-objs += io/sha1_mod.o
	$(MODULE)-objs += io/sha2_mod.o
	$(MODULE)-objs += io/skein_mod.o
	$(MODULE)-objs += os/modhash.o
	$(MODULE)-objs += os/modconf.o
	$(MODULE)-objs += algs/modes/cbc.o
	$(MODULE)-objs += algs/modes/ccm.o
	$(MODULE)-objs += algs/modes/ctr.o
	$(MODULE)-objs += algs/modes/ecb.o
	$(MODULE)-objs += algs/modes/gcm_generic.o
	$(MODULE)-objs += algs/modes/gcm.o
	$(MODULE)-objs += algs/modes/modes.o
	$(MODULE)-objs += algs/aes/aes_impl_generic.o
	$(MODULE)-objs += algs/aes/aes_impl.o
	$(MODULE)-objs += algs/aes/aes_modes.o
	$(MODULE)-objs += algs/edonr/edonr.o
	$(MODULE)-objs += algs/sha1/sha1.o
	$(MODULE)-objs += algs/sha2/sha2.o
	-$(MODULE)-objs += algs/sha1/sha1.o
	$(MODULE)-objs += algs/skein/skein.o
	$(MODULE)-objs += algs/skein/skein_block.o
	$(MODULE)-objs += algs/skein/skein_iv.o

	$(MODULE)-$(CONFIG_X86_64) += asm-x86_64/aes/aeskey.o
	$(MODULE)-$(CONFIG_X86_64) += asm-x86_64/aes/aes_amd64.o
	$(MODULE)-$(CONFIG_X86_64) += asm-x86_64/aes/aes_aesni.o
	$(MODULE)-$(CONFIG_X86_64) += asm-x86_64/modes/gcm_pclmulqdq.o
	$(MODULE)-$(CONFIG_X86_64) += asm-x86_64/modes/aesni-gcm-x86_64.o
	$(MODULE)-$(CONFIG_X86_64) += asm-x86_64/modes/ghash-x86_64.o
	$(MODULE)-$(CONFIG_X86_64) += asm-x86_64/sha1/sha1-x86_64.o
	$(MODULE)-$(CONFIG_X86_64) += asm-x86_64/sha2/sha256_impl.o
	$(MODULE)-$(CONFIG_X86_64) += asm-x86_64/sha2/sha512_impl.o

	$(MODULE)-$(CONFIG_X86) += algs/modes/gcm_pclmulqdq.o
	$(MODULE)-$(CONFIG_X86) += algs/aes/aes_impl_aesni.o
	$(MODULE)-$(CONFIG_X86) += algs/aes/aes_impl_x86-64.o

	# Suppress objtool "can't find jump dest instruction at" warnings. They
	# are caused by the constants which are defined in the text section of the
	# assembly file using .byte instructions (e.g. bswap_mask). The objtool
	# utility tries to interpret them as opcodes and obviously fails doing so.
	OBJECT_FILES_NON_STANDARD_aesni-gcm-x86_64.o := y
	OBJECT_FILES_NON_STANDARD_ghash-x86_64.o := y
	+# Suppress objtool "unsupported stack pointer realignment" warnings. We are
	+# not using a DRAP register while aligning the stack to a 64 byte boundary.
	+# See #6950 for the reasoning.
	+OBJECT_FILES_NON_STANDARD_sha1-x86_64.o := y
	+OBJECT_FILES_NON_STANDARD_sha256_impl.o := y
	+OBJECT_FILES_NON_STANDARD_sha512_impl.o := y

	ICP_DIRS = \
	api \
	core \
	spi \
	io \
	os \
	algs \
	algs/aes \
	algs/edonr \
	algs/modes \
	algs/sha1 \
	algs/sha2 \
	algs/skein \
	asm-x86_64 \
	asm-x86_64/aes \
	asm-x86_64/modes \
	asm-x86_64/sha1 \
	asm-x86_64/sha2 \
	asm-i386 \
	asm-generic

	all:
	mkdir -p $(ICP_DIRS)
	diff --git a/sys/contrib/openzfs/module/icp/algs/edonr/edonr.c b/sys/contrib/openzfs/module/icp/algs/edonr/edonr.c
	index 7c677095f1ef..ee96e692ef00 100644
	--- a/sys/contrib/openzfs/module/icp/algs/edonr/edonr.c
	+++ b/sys/contrib/openzfs/module/icp/algs/edonr/edonr.c
	@@ -1,746 +1,746 @@
	/*
	* IDI,NTNU
	*
	* 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://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) 2009, 2010, Jorn Amundsen <jorn.amundsen@ntnu.no>
	* Tweaked Edon-R implementation for SUPERCOP, based on NIST API.
	*
	* $Id: edonr.c 517 2013-02-17 20:34:39Z joern $
	*/
	/*
	* Portions copyright (c) 2013, Saso Kiselkov, All rights reserved
	*/

	#include <sys/strings.h>
	#include <sys/edonr.h>
	#include <sys/debug.h>

	/* big endian support, provides no-op's if run on little endian hosts */
	#include "edonr_byteorder.h"

	#define hashState224(x) ((x)->pipe->p256)
	#define hashState256(x) ((x)->pipe->p256)
	#define hashState384(x) ((x)->pipe->p512)
	#define hashState512(x) ((x)->pipe->p512)

	/* shift and rotate shortcuts */
	#define shl(x, n) ((x) << n)
	#define shr(x, n) ((x) >> n)

	#define rotl32(x, n) (((x) << (n)) \| ((x) >> (32 - (n))))
	#define rotr32(x, n) (((x) >> (n)) \| ((x) << (32 - (n))))

	#define rotl64(x, n) (((x) << (n)) \| ((x) >> (64 - (n))))
	#define rotr64(x, n) (((x) >> (n)) \| ((x) << (64 - (n))))

	#if !defined(__C99_RESTRICT)
	#define restrict /* restrict */
	#endif

	#define EDONR_VALID_HASHBITLEN(x) \
	((x) == 512 \|\| (x) == 384 \|\| (x) == 256 \|\| (x) == 224)

	/* EdonR224 initial double chaining pipe */
	static const uint32_t i224p2[16] = {
	0x00010203ul, 0x04050607ul, 0x08090a0bul, 0x0c0d0e0ful,
	0x10111213ul, 0x14151617ul, 0x18191a1bul, 0x1c1d1e1ful,
	0x20212223ul, 0x24252627ul, 0x28292a2bul, 0x2c2d2e2ful,
	0x30313233ul, 0x34353637ul, 0x38393a3bul, 0x3c3d3e3ful,
	};

	/* EdonR256 initial double chaining pipe */
	static const uint32_t i256p2[16] = {
	0x40414243ul, 0x44454647ul, 0x48494a4bul, 0x4c4d4e4ful,
	0x50515253ul, 0x54555657ul, 0x58595a5bul, 0x5c5d5e5ful,
	0x60616263ul, 0x64656667ul, 0x68696a6bul, 0x6c6d6e6ful,
	0x70717273ul, 0x74757677ul, 0x78797a7bul, 0x7c7d7e7ful,
	};

	/* EdonR384 initial double chaining pipe */
	static const uint64_t i384p2[16] = {
	0x0001020304050607ull, 0x08090a0b0c0d0e0full,
	0x1011121314151617ull, 0x18191a1b1c1d1e1full,
	0x2021222324252627ull, 0x28292a2b2c2d2e2full,
	0x3031323334353637ull, 0x38393a3b3c3d3e3full,
	0x4041424344454647ull, 0x48494a4b4c4d4e4full,
	0x5051525354555657ull, 0x58595a5b5c5d5e5full,
	0x6061626364656667ull, 0x68696a6b6c6d6e6full,
	0x7071727374757677ull, 0x78797a7b7c7d7e7full
	};

	/* EdonR512 initial double chaining pipe */
	static const uint64_t i512p2[16] = {
	0x8081828384858687ull, 0x88898a8b8c8d8e8full,
	0x9091929394959697ull, 0x98999a9b9c9d9e9full,
	0xa0a1a2a3a4a5a6a7ull, 0xa8a9aaabacadaeafull,
	0xb0b1b2b3b4b5b6b7ull, 0xb8b9babbbcbdbebfull,
	0xc0c1c2c3c4c5c6c7ull, 0xc8c9cacbcccdcecfull,
	0xd0d1d2d3d4d5d6d7ull, 0xd8d9dadbdcdddedfull,
	0xe0e1e2e3e4e5e6e7ull, 0xe8e9eaebecedeeefull,
	0xf0f1f2f3f4f5f6f7ull, 0xf8f9fafbfcfdfeffull
	};

	/*
	* First Latin Square
	* 0 7 1 3 2 4 6 5
	* 4 1 7 6 3 0 5 2
	* 7 0 4 2 5 3 1 6
	* 1 4 0 5 6 2 7 3
	* 2 3 6 7 1 5 0 4
	* 5 2 3 1 7 6 4 0
	* 3 6 5 0 4 7 2 1
	* 6 5 2 4 0 1 3 7
	*/
	#define LS1_256(c, x0, x1, x2, x3, x4, x5, x6, x7) \
	{ \
	uint32_t x04, x17, x23, x56, x07, x26; \
	x04 = x0+x4, x17 = x1+x7, x07 = x04+x17; \
	s0 = c + x07 + x2; \
	s1 = rotl32(x07 + x3, 4); \
	s2 = rotl32(x07 + x6, 8); \
	x23 = x2 + x3; \
	s5 = rotl32(x04 + x23 + x5, 22); \
	x56 = x5 + x6; \
	s6 = rotl32(x17 + x56 + x0, 24); \
	x26 = x23+x56; \
	s3 = rotl32(x26 + x7, 13); \
	s4 = rotl32(x26 + x1, 17); \
	s7 = rotl32(x26 + x4, 29); \
	}

	#define LS1_512(c, x0, x1, x2, x3, x4, x5, x6, x7) \
	{ \
	uint64_t x04, x17, x23, x56, x07, x26; \
	x04 = x0+x4, x17 = x1+x7, x07 = x04+x17; \
	s0 = c + x07 + x2; \
	s1 = rotl64(x07 + x3, 5); \
	s2 = rotl64(x07 + x6, 15); \
	x23 = x2 + x3; \
	s5 = rotl64(x04 + x23 + x5, 40); \
	x56 = x5 + x6; \
	s6 = rotl64(x17 + x56 + x0, 50); \
	x26 = x23+x56; \
	s3 = rotl64(x26 + x7, 22); \
	s4 = rotl64(x26 + x1, 31); \
	s7 = rotl64(x26 + x4, 59); \
	}

	/*
	* Second Orthogonal Latin Square
	* 0 4 2 3 1 6 5 7
	* 7 6 3 2 5 4 1 0
	* 5 3 1 6 0 2 7 4
	* 1 0 5 4 3 7 2 6
	* 2 1 0 7 4 5 6 3
	* 3 5 7 0 6 1 4 2
	* 4 7 6 1 2 0 3 5
	* 6 2 4 5 7 3 0 1
	*/
	#define LS2_256(c, y0, y1, y2, y3, y4, y5, y6, y7) \
	{ \
	uint32_t y01, y25, y34, y67, y04, y05, y27, y37; \
	y01 = y0+y1, y25 = y2+y5, y05 = y01+y25; \
	t0 = ~c + y05 + y7; \
	t2 = rotl32(y05 + y3, 9); \
	y34 = y3+y4, y04 = y01+y34; \
	t1 = rotl32(y04 + y6, 5); \
	t4 = rotl32(y04 + y5, 15); \
	y67 = y6+y7, y37 = y34+y67; \
	t3 = rotl32(y37 + y2, 11); \
	t7 = rotl32(y37 + y0, 27); \
	y27 = y25+y67; \
	t5 = rotl32(y27 + y4, 20); \
	t6 = rotl32(y27 + y1, 25); \
	}

	#define LS2_512(c, y0, y1, y2, y3, y4, y5, y6, y7) \
	{ \
	uint64_t y01, y25, y34, y67, y04, y05, y27, y37; \
	y01 = y0+y1, y25 = y2+y5, y05 = y01+y25; \
	t0 = ~c + y05 + y7; \
	t2 = rotl64(y05 + y3, 19); \
	y34 = y3+y4, y04 = y01+y34; \
	t1 = rotl64(y04 + y6, 10); \
	t4 = rotl64(y04 + y5, 36); \
	y67 = y6+y7, y37 = y34+y67; \
	t3 = rotl64(y37 + y2, 29); \
	t7 = rotl64(y37 + y0, 55); \
	y27 = y25+y67; \
	t5 = rotl64(y27 + y4, 44); \
	t6 = rotl64(y27 + y1, 48); \
	}

	#define quasi_exform256(r0, r1, r2, r3, r4, r5, r6, r7) \
	{ \
	uint32_t s04, s17, s23, s56, t01, t25, t34, t67; \
	s04 = s0 ^ s4, t01 = t0 ^ t1; \
	r0 = (s04 ^ s1) + (t01 ^ t5); \
	t67 = t6 ^ t7; \
	r1 = (s04 ^ s7) + (t2 ^ t67); \
	s23 = s2 ^ s3; \
	r7 = (s23 ^ s5) + (t4 ^ t67); \
	t34 = t3 ^ t4; \
	r3 = (s23 ^ s4) + (t0 ^ t34); \
	s56 = s5 ^ s6; \
	r5 = (s3 ^ s56) + (t34 ^ t6); \
	t25 = t2 ^ t5; \
	r6 = (s2 ^ s56) + (t25 ^ t7); \
	s17 = s1 ^ s7; \
	r4 = (s0 ^ s17) + (t1 ^ t25); \
	r2 = (s17 ^ s6) + (t01 ^ t3); \
	}

	#define quasi_exform512(r0, r1, r2, r3, r4, r5, r6, r7) \
	{ \
	uint64_t s04, s17, s23, s56, t01, t25, t34, t67; \
	s04 = s0 ^ s4, t01 = t0 ^ t1; \
	r0 = (s04 ^ s1) + (t01 ^ t5); \
	t67 = t6 ^ t7; \
	r1 = (s04 ^ s7) + (t2 ^ t67); \
	s23 = s2 ^ s3; \
	r7 = (s23 ^ s5) + (t4 ^ t67); \
	t34 = t3 ^ t4; \
	r3 = (s23 ^ s4) + (t0 ^ t34); \
	s56 = s5 ^ s6; \
	r5 = (s3 ^ s56) + (t34 ^ t6); \
	t25 = t2 ^ t5; \
	r6 = (s2 ^ s56) + (t25 ^ t7); \
	s17 = s1 ^ s7; \
	r4 = (s0 ^ s17) + (t1 ^ t25); \
	r2 = (s17 ^ s6) + (t01 ^ t3); \
	}

	static size_t
	Q256(size_t bitlen, const uint32_t data, uint32_t restrict p)
	{
	size_t bl;

	for (bl = bitlen; bl >= EdonR256_BLOCK_BITSIZE;
	bl -= EdonR256_BLOCK_BITSIZE, data += 16) {
	uint32_t s0, s1, s2, s3, s4, s5, s6, s7, t0, t1, t2, t3, t4,
	t5, t6, t7;
	uint32_t p0, p1, p2, p3, p4, p5, p6, p7, q0, q1, q2, q3, q4,
	q5, q6, q7;
	const uint32_t defix = 0xaaaaaaaa;
	#if defined(MACHINE_IS_BIG_ENDIAN)
	uint32_t swp0, swp1, swp2, swp3, swp4, swp5, swp6, swp7, swp8,
	swp9, swp10, swp11, swp12, swp13, swp14, swp15;
	#define d(j) swp ## j
	#define s32(j) ld_swap32((uint32_t *)data + j, swp ## j)
	#else
	#define d(j) data[j]
	#endif

	/* First row of quasigroup e-transformations */
	#if defined(MACHINE_IS_BIG_ENDIAN)
	s32(8);
	s32(9);
	s32(10);
	s32(11);
	s32(12);
	s32(13);
	s32(14);
	s32(15);
	#endif
	LS1_256(defix, d(15), d(14), d(13), d(12), d(11), d(10), d(9),
	d(8));
	#if defined(MACHINE_IS_BIG_ENDIAN)
	s32(0);
	s32(1);
	s32(2);
	s32(3);
	s32(4);
	s32(5);
	s32(6);
	s32(7);
	#undef s32
	#endif
	LS2_256(defix, d(0), d(1), d(2), d(3), d(4), d(5), d(6), d(7));
	quasi_exform256(p0, p1, p2, p3, p4, p5, p6, p7);

	LS1_256(defix, p0, p1, p2, p3, p4, p5, p6, p7);
	LS2_256(defix, d(8), d(9), d(10), d(11), d(12), d(13), d(14),
	d(15));
	quasi_exform256(q0, q1, q2, q3, q4, q5, q6, q7);

	/* Second row of quasigroup e-transformations */
	LS1_256(defix, p[8], p[9], p[10], p[11], p[12], p[13], p[14],
	p[15]);
	LS2_256(defix, p0, p1, p2, p3, p4, p5, p6, p7);
	quasi_exform256(p0, p1, p2, p3, p4, p5, p6, p7);

	LS1_256(defix, p0, p1, p2, p3, p4, p5, p6, p7);
	LS2_256(defix, q0, q1, q2, q3, q4, q5, q6, q7);
	quasi_exform256(q0, q1, q2, q3, q4, q5, q6, q7);

	/* Third row of quasigroup e-transformations */
	LS1_256(defix, p0, p1, p2, p3, p4, p5, p6, p7);
	LS2_256(defix, p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
	quasi_exform256(p0, p1, p2, p3, p4, p5, p6, p7);

	LS1_256(defix, q0, q1, q2, q3, q4, q5, q6, q7);
	LS2_256(defix, p0, p1, p2, p3, p4, p5, p6, p7);
	quasi_exform256(q0, q1, q2, q3, q4, q5, q6, q7);

	/* Fourth row of quasigroup e-transformations */
	LS1_256(defix, d(7), d(6), d(5), d(4), d(3), d(2), d(1), d(0));
	LS2_256(defix, p0, p1, p2, p3, p4, p5, p6, p7);
	quasi_exform256(p0, p1, p2, p3, p4, p5, p6, p7);

	LS1_256(defix, p0, p1, p2, p3, p4, p5, p6, p7);
	LS2_256(defix, q0, q1, q2, q3, q4, q5, q6, q7);
	quasi_exform256(q0, q1, q2, q3, q4, q5, q6, q7);

	/* Edon-R tweak on the original SHA-3 Edon-R submission. */
	p[0] ^= d(8) ^ p0;
	p[1] ^= d(9) ^ p1;
	p[2] ^= d(10) ^ p2;
	p[3] ^= d(11) ^ p3;
	p[4] ^= d(12) ^ p4;
	p[5] ^= d(13) ^ p5;
	p[6] ^= d(14) ^ p6;
	p[7] ^= d(15) ^ p7;
	p[8] ^= d(0) ^ q0;
	p[9] ^= d(1) ^ q1;
	p[10] ^= d(2) ^ q2;
	p[11] ^= d(3) ^ q3;
	p[12] ^= d(4) ^ q4;
	p[13] ^= d(5) ^ q5;
	p[14] ^= d(6) ^ q6;
	p[15] ^= d(7) ^ q7;
	}

	#undef d
	return (bitlen - bl);
	}

	/*
	* Why is this #pragma here?
	*
	* Checksum functions like this one can go over the stack frame size check
	* Linux imposes on 32-bit platforms (-Wframe-larger-than=1024). We can
	- * safely ignore the compiler error since we know that in ZoL, that
	+ * safely ignore the compiler error since we know that in OpenZFS, that
	* the function will be called from a worker thread that won't be using
	* much stack. The only function that goes over the 1k limit is Q512(),
	* which only goes over it by a hair (1248 bytes on ARM32).
	*/
	#include <sys/isa_defs.h> /* for _ILP32 */
	#ifdef _ILP32 /* We're 32-bit, assume small stack frames */
	#pragma GCC diagnostic ignored "-Wframe-larger-than="
	#endif

	#if defined(__IBMC__) && defined(_AIX) && defined(__64BIT__)
	static inline size_t
	#else
	static size_t
	#endif
	Q512(size_t bitlen, const uint64_t data, uint64_t restrict p)
	{
	size_t bl;

	for (bl = bitlen; bl >= EdonR512_BLOCK_BITSIZE;
	bl -= EdonR512_BLOCK_BITSIZE, data += 16) {
	uint64_t s0, s1, s2, s3, s4, s5, s6, s7, t0, t1, t2, t3, t4,
	t5, t6, t7;
	uint64_t p0, p1, p2, p3, p4, p5, p6, p7, q0, q1, q2, q3, q4,
	q5, q6, q7;
	const uint64_t defix = 0xaaaaaaaaaaaaaaaaull;
	#if defined(MACHINE_IS_BIG_ENDIAN)
	uint64_t swp0, swp1, swp2, swp3, swp4, swp5, swp6, swp7, swp8,
	swp9, swp10, swp11, swp12, swp13, swp14, swp15;
	#define d(j) swp##j
	#define s64(j) ld_swap64((uint64_t *)data+j, swp##j)
	#else
	#define d(j) data[j]
	#endif

	/* First row of quasigroup e-transformations */
	#if defined(MACHINE_IS_BIG_ENDIAN)
	s64(8);
	s64(9);
	s64(10);
	s64(11);
	s64(12);
	s64(13);
	s64(14);
	s64(15);
	#endif
	LS1_512(defix, d(15), d(14), d(13), d(12), d(11), d(10), d(9),
	d(8));
	#if defined(MACHINE_IS_BIG_ENDIAN)
	s64(0);
	s64(1);
	s64(2);
	s64(3);
	s64(4);
	s64(5);
	s64(6);
	s64(7);
	#undef s64
	#endif
	LS2_512(defix, d(0), d(1), d(2), d(3), d(4), d(5), d(6), d(7));
	quasi_exform512(p0, p1, p2, p3, p4, p5, p6, p7);

	LS1_512(defix, p0, p1, p2, p3, p4, p5, p6, p7);
	LS2_512(defix, d(8), d(9), d(10), d(11), d(12), d(13), d(14),
	d(15));
	quasi_exform512(q0, q1, q2, q3, q4, q5, q6, q7);

	/* Second row of quasigroup e-transformations */
	LS1_512(defix, p[8], p[9], p[10], p[11], p[12], p[13], p[14],
	p[15]);
	LS2_512(defix, p0, p1, p2, p3, p4, p5, p6, p7);
	quasi_exform512(p0, p1, p2, p3, p4, p5, p6, p7);

	LS1_512(defix, p0, p1, p2, p3, p4, p5, p6, p7);
	LS2_512(defix, q0, q1, q2, q3, q4, q5, q6, q7);
	quasi_exform512(q0, q1, q2, q3, q4, q5, q6, q7);

	/* Third row of quasigroup e-transformations */
	LS1_512(defix, p0, p1, p2, p3, p4, p5, p6, p7);
	LS2_512(defix, p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
	quasi_exform512(p0, p1, p2, p3, p4, p5, p6, p7);

	LS1_512(defix, q0, q1, q2, q3, q4, q5, q6, q7);
	LS2_512(defix, p0, p1, p2, p3, p4, p5, p6, p7);
	quasi_exform512(q0, q1, q2, q3, q4, q5, q6, q7);

	/* Fourth row of quasigroup e-transformations */
	LS1_512(defix, d(7), d(6), d(5), d(4), d(3), d(2), d(1), d(0));
	LS2_512(defix, p0, p1, p2, p3, p4, p5, p6, p7);
	quasi_exform512(p0, p1, p2, p3, p4, p5, p6, p7);

	LS1_512(defix, p0, p1, p2, p3, p4, p5, p6, p7);
	LS2_512(defix, q0, q1, q2, q3, q4, q5, q6, q7);
	quasi_exform512(q0, q1, q2, q3, q4, q5, q6, q7);

	/* Edon-R tweak on the original SHA-3 Edon-R submission. */
	p[0] ^= d(8) ^ p0;
	p[1] ^= d(9) ^ p1;
	p[2] ^= d(10) ^ p2;
	p[3] ^= d(11) ^ p3;
	p[4] ^= d(12) ^ p4;
	p[5] ^= d(13) ^ p5;
	p[6] ^= d(14) ^ p6;
	p[7] ^= d(15) ^ p7;
	p[8] ^= d(0) ^ q0;
	p[9] ^= d(1) ^ q1;
	p[10] ^= d(2) ^ q2;
	p[11] ^= d(3) ^ q3;
	p[12] ^= d(4) ^ q4;
	p[13] ^= d(5) ^ q5;
	p[14] ^= d(6) ^ q6;
	p[15] ^= d(7) ^ q7;
	}

	#undef d
	return (bitlen - bl);
	}

	void
	EdonRInit(EdonRState *state, size_t hashbitlen)
	{
	ASSERT(EDONR_VALID_HASHBITLEN(hashbitlen));
	switch (hashbitlen) {
	case 224:
	state->hashbitlen = 224;
	state->bits_processed = 0;
	state->unprocessed_bits = 0;
	bcopy(i224p2, hashState224(state)->DoublePipe,
	16 * sizeof (uint32_t));
	break;

	case 256:
	state->hashbitlen = 256;
	state->bits_processed = 0;
	state->unprocessed_bits = 0;
	bcopy(i256p2, hashState256(state)->DoublePipe,
	16 * sizeof (uint32_t));
	break;

	case 384:
	state->hashbitlen = 384;
	state->bits_processed = 0;
	state->unprocessed_bits = 0;
	bcopy(i384p2, hashState384(state)->DoublePipe,
	16 * sizeof (uint64_t));
	break;

	case 512:
	state->hashbitlen = 512;
	state->bits_processed = 0;
	state->unprocessed_bits = 0;
	bcopy(i512p2, hashState224(state)->DoublePipe,
	16 * sizeof (uint64_t));
	break;
	}
	}


	void
	EdonRUpdate(EdonRState state, const uint8_t data, size_t databitlen)
	{
	uint32_t *data32;
	uint64_t *data64;

	size_t bits_processed;

	ASSERT(EDONR_VALID_HASHBITLEN(state->hashbitlen));
	switch (state->hashbitlen) {
	case 224:
	case 256:
	if (state->unprocessed_bits > 0) {
	/* LastBytes = databitlen / 8 */
	int LastBytes = (int)databitlen >> 3;

	ASSERT(state->unprocessed_bits + databitlen <=
	EdonR256_BLOCK_SIZE * 8);

	bcopy(data, hashState256(state)->LastPart
	+ (state->unprocessed_bits >> 3), LastBytes);
	state->unprocessed_bits += (int)databitlen;
	databitlen = state->unprocessed_bits;
	/* LINTED E_BAD_PTR_CAST_ALIGN */
	data32 = (uint32_t *)hashState256(state)->LastPart;
	} else
	/* LINTED E_BAD_PTR_CAST_ALIGN */
	data32 = (uint32_t *)data;

	bits_processed = Q256(databitlen, data32,
	hashState256(state)->DoublePipe);
	state->bits_processed += bits_processed;
	databitlen -= bits_processed;
	state->unprocessed_bits = (int)databitlen;
	if (databitlen > 0) {
	/* LastBytes = Ceil(databitlen / 8) */
	int LastBytes =
	((~(((-(int)databitlen) >> 3) & 0x01ff)) +
	1) & 0x01ff;

	data32 += bits_processed >> 5; /* byte size update */
	bcopy(data32, hashState256(state)->LastPart, LastBytes);
	}
	break;

	case 384:
	case 512:
	if (state->unprocessed_bits > 0) {
	/* LastBytes = databitlen / 8 */
	int LastBytes = (int)databitlen >> 3;

	ASSERT(state->unprocessed_bits + databitlen <=
	EdonR512_BLOCK_SIZE * 8);

	bcopy(data, hashState512(state)->LastPart
	+ (state->unprocessed_bits >> 3), LastBytes);
	state->unprocessed_bits += (int)databitlen;
	databitlen = state->unprocessed_bits;
	/* LINTED E_BAD_PTR_CAST_ALIGN */
	data64 = (uint64_t *)hashState512(state)->LastPart;
	} else
	/* LINTED E_BAD_PTR_CAST_ALIGN */
	data64 = (uint64_t *)data;

	bits_processed = Q512(databitlen, data64,
	hashState512(state)->DoublePipe);
	state->bits_processed += bits_processed;
	databitlen -= bits_processed;
	state->unprocessed_bits = (int)databitlen;
	if (databitlen > 0) {
	/* LastBytes = Ceil(databitlen / 8) */
	int LastBytes =
	((~(((-(int)databitlen) >> 3) & 0x03ff)) +
	1) & 0x03ff;

	data64 += bits_processed >> 6; /* byte size update */
	bcopy(data64, hashState512(state)->LastPart, LastBytes);
	}
	break;
	}
	}

	void
	EdonRFinal(EdonRState state, uint8_t hashval)
	{
	uint32_t *data32;
	uint64_t *data64, num_bits;

	size_t databitlen;
	int LastByte, PadOnePosition;

	num_bits = state->bits_processed + state->unprocessed_bits;
	ASSERT(EDONR_VALID_HASHBITLEN(state->hashbitlen));
	switch (state->hashbitlen) {
	case 224:
	case 256:
	LastByte = (int)state->unprocessed_bits >> 3;
	PadOnePosition = 7 - (state->unprocessed_bits & 0x07);
	hashState256(state)->LastPart[LastByte] =
	(hashState256(state)->LastPart[LastByte]
	& (0xff << (PadOnePosition + 1))) ^
	(0x01 << PadOnePosition);
	/* LINTED E_BAD_PTR_CAST_ALIGN */
	data64 = (uint64_t *)hashState256(state)->LastPart;

	if (state->unprocessed_bits < 448) {
	(void) memset((hashState256(state)->LastPart) +
	LastByte + 1, 0x00,
	EdonR256_BLOCK_SIZE - LastByte - 9);
	databitlen = EdonR256_BLOCK_SIZE * 8;
	#if defined(MACHINE_IS_BIG_ENDIAN)
	st_swap64(num_bits, data64 + 7);
	#else
	data64[7] = num_bits;
	#endif
	} else {
	(void) memset((hashState256(state)->LastPart) +
	LastByte + 1, 0x00,
	EdonR256_BLOCK_SIZE * 2 - LastByte - 9);
	databitlen = EdonR256_BLOCK_SIZE * 16;
	#if defined(MACHINE_IS_BIG_ENDIAN)
	st_swap64(num_bits, data64 + 15);
	#else
	data64[15] = num_bits;
	#endif
	}

	/* LINTED E_BAD_PTR_CAST_ALIGN */
	data32 = (uint32_t *)hashState256(state)->LastPart;
	state->bits_processed += Q256(databitlen, data32,
	hashState256(state)->DoublePipe);
	break;

	case 384:
	case 512:
	LastByte = (int)state->unprocessed_bits >> 3;
	PadOnePosition = 7 - (state->unprocessed_bits & 0x07);
	hashState512(state)->LastPart[LastByte] =
	(hashState512(state)->LastPart[LastByte]
	& (0xff << (PadOnePosition + 1))) ^
	(0x01 << PadOnePosition);
	/* LINTED E_BAD_PTR_CAST_ALIGN */
	data64 = (uint64_t *)hashState512(state)->LastPart;

	if (state->unprocessed_bits < 960) {
	(void) memset((hashState512(state)->LastPart) +
	LastByte + 1, 0x00,
	EdonR512_BLOCK_SIZE - LastByte - 9);
	databitlen = EdonR512_BLOCK_SIZE * 8;
	#if defined(MACHINE_IS_BIG_ENDIAN)
	st_swap64(num_bits, data64 + 15);
	#else
	data64[15] = num_bits;
	#endif
	} else {
	(void) memset((hashState512(state)->LastPart) +
	LastByte + 1, 0x00,
	EdonR512_BLOCK_SIZE * 2 - LastByte - 9);
	databitlen = EdonR512_BLOCK_SIZE * 16;
	#if defined(MACHINE_IS_BIG_ENDIAN)
	st_swap64(num_bits, data64 + 31);
	#else
	data64[31] = num_bits;
	#endif
	}

	state->bits_processed += Q512(databitlen, data64,
	hashState512(state)->DoublePipe);
	break;
	}

	switch (state->hashbitlen) {
	case 224: {
	#if defined(MACHINE_IS_BIG_ENDIAN)
	uint32_t d32 = (uint32_t )hashval;
	uint32_t *s32 = hashState224(state)->DoublePipe + 9;
	int j;

	for (j = 0; j < EdonR224_DIGEST_SIZE >> 2; j++)
	st_swap32(s32[j], d32 + j);
	#else
	bcopy(hashState256(state)->DoublePipe + 9, hashval,
	EdonR224_DIGEST_SIZE);
	#endif
	break;
	}
	case 256: {
	#if defined(MACHINE_IS_BIG_ENDIAN)
	uint32_t d32 = (uint32_t )hashval;
	uint32_t *s32 = hashState224(state)->DoublePipe + 8;
	int j;

	for (j = 0; j < EdonR256_DIGEST_SIZE >> 2; j++)
	st_swap32(s32[j], d32 + j);
	#else
	bcopy(hashState256(state)->DoublePipe + 8, hashval,
	EdonR256_DIGEST_SIZE);
	#endif
	break;
	}
	case 384: {
	#if defined(MACHINE_IS_BIG_ENDIAN)
	uint64_t d64 = (uint64_t )hashval;
	uint64_t *s64 = hashState384(state)->DoublePipe + 10;
	int j;

	for (j = 0; j < EdonR384_DIGEST_SIZE >> 3; j++)
	st_swap64(s64[j], d64 + j);
	#else
	bcopy(hashState384(state)->DoublePipe + 10, hashval,
	EdonR384_DIGEST_SIZE);
	#endif
	break;
	}
	case 512: {
	#if defined(MACHINE_IS_BIG_ENDIAN)
	uint64_t d64 = (uint64_t )hashval;
	uint64_t *s64 = hashState512(state)->DoublePipe + 8;
	int j;

	for (j = 0; j < EdonR512_DIGEST_SIZE >> 3; j++)
	st_swap64(s64[j], d64 + j);
	#else
	bcopy(hashState512(state)->DoublePipe + 8, hashval,
	EdonR512_DIGEST_SIZE);
	#endif
	break;
	}
	}
	}


	void
	EdonRHash(size_t hashbitlen, const uint8_t *data, size_t databitlen,
	uint8_t *hashval)
	{
	EdonRState state;

	EdonRInit(&state, hashbitlen);
	EdonRUpdate(&state, data, databitlen);
	EdonRFinal(&state, hashval);
	}

	#ifdef _KERNEL
	EXPORT_SYMBOL(EdonRInit);
	EXPORT_SYMBOL(EdonRUpdate);
	EXPORT_SYMBOL(EdonRHash);
	EXPORT_SYMBOL(EdonRFinal);
	#endif
	diff --git a/sys/contrib/openzfs/module/icp/algs/modes/gcm.c b/sys/contrib/openzfs/module/icp/algs/modes/gcm.c
	index 23686c59e8ce..7332834cbe37 100644
	--- a/sys/contrib/openzfs/module/icp/algs/modes/gcm.c
	+++ b/sys/contrib/openzfs/module/icp/algs/modes/gcm.c
	@@ -1,1587 +1,1587 @@
	/*
	* 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) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
	*/

	#include <sys/zfs_context.h>
	#include <modes/modes.h>
	#include <sys/crypto/common.h>
	#include <sys/crypto/icp.h>
	#include <sys/crypto/impl.h>
	#include <sys/byteorder.h>
	#include <sys/simd.h>
	#include <modes/gcm_impl.h>
	#ifdef CAN_USE_GCM_ASM
	#include <aes/aes_impl.h>
	#endif

	#define GHASH(c, d, t, o) \
	xor_block((uint8_t )(d), (uint8_t )(c)->gcm_ghash); \
	(o)->mul((uint64_t )(void )(c)->gcm_ghash, (c)->gcm_H, \
	(uint64_t )(void )(t));

	/* Select GCM implementation */
	#define IMPL_FASTEST (UINT32_MAX)
	#define IMPL_CYCLE (UINT32_MAX-1)
	#ifdef CAN_USE_GCM_ASM
	#define IMPL_AVX (UINT32_MAX-2)
	#endif
	#define GCM_IMPL_READ(i) ((volatile uint32_t ) &(i))
	static uint32_t icp_gcm_impl = IMPL_FASTEST;
	static uint32_t user_sel_impl = IMPL_FASTEST;

	#ifdef CAN_USE_GCM_ASM
	/* Does the architecture we run on support the MOVBE instruction? */
	boolean_t gcm_avx_can_use_movbe = B_FALSE;
	/*
	* Whether to use the optimized openssl gcm and ghash implementations.
	* Set to true if module parameter icp_gcm_impl == "avx".
	*/
	static boolean_t gcm_use_avx = B_FALSE;
	#define GCM_IMPL_USE_AVX ((volatile boolean_t )&gcm_use_avx)

	extern boolean_t atomic_toggle_boolean_nv(volatile boolean_t *);

	static inline boolean_t gcm_avx_will_work(void);
	static inline void gcm_set_avx(boolean_t);
	static inline boolean_t gcm_toggle_avx(void);
	static inline size_t gcm_simd_get_htab_size(boolean_t);

	static int gcm_mode_encrypt_contiguous_blocks_avx(gcm_ctx_t , char , size_t,
	crypto_data_t *, size_t);

	static int gcm_encrypt_final_avx(gcm_ctx_t , crypto_data_t , size_t);
	static int gcm_decrypt_final_avx(gcm_ctx_t , crypto_data_t , size_t);
	static int gcm_init_avx(gcm_ctx_t , unsigned char , size_t, unsigned char *,
	size_t, size_t);
	#endif /* ifdef CAN_USE_GCM_ASM */

	/*
	* Encrypt multiple blocks of data in GCM mode. Decrypt for GCM mode
	* is done in another function.
	*/
	int
	gcm_mode_encrypt_contiguous_blocks(gcm_ctx_t ctx, char data, size_t length,
	crypto_data_t *out, size_t block_size,
	int (encrypt_block)(const void , const uint8_t , uint8_t ),
	void (copy_block)(uint8_t , uint8_t *),
	void (xor_block)(uint8_t , uint8_t *))
	{
	#ifdef CAN_USE_GCM_ASM
	if (ctx->gcm_use_avx == B_TRUE)
	return (gcm_mode_encrypt_contiguous_blocks_avx(
	ctx, data, length, out, block_size));
	#endif

	const gcm_impl_ops_t *gops;
	size_t remainder = length;
	size_t need = 0;
	uint8_t datap = (uint8_t )data;
	uint8_t *blockp;
	uint8_t *lastp;
	void *iov_or_mp;
	offset_t offset;
	uint8_t *out_data_1;
	uint8_t *out_data_2;
	size_t out_data_1_len;
	uint64_t counter;
	uint64_t counter_mask = ntohll(0x00000000ffffffffULL);

	if (length + ctx->gcm_remainder_len < block_size) {
	/* accumulate bytes here and return */
	bcopy(datap,
	(uint8_t *)ctx->gcm_remainder + ctx->gcm_remainder_len,
	length);
	ctx->gcm_remainder_len += length;
	if (ctx->gcm_copy_to == NULL) {
	ctx->gcm_copy_to = datap;
	}
	return (CRYPTO_SUCCESS);
	}

	lastp = (uint8_t *)ctx->gcm_cb;
	crypto_init_ptrs(out, &iov_or_mp, &offset);

	gops = gcm_impl_get_ops();
	do {
	/* Unprocessed data from last call. */
	if (ctx->gcm_remainder_len > 0) {
	need = block_size - ctx->gcm_remainder_len;

	if (need > remainder)
	return (CRYPTO_DATA_LEN_RANGE);

	bcopy(datap, &((uint8_t *)ctx->gcm_remainder)
	[ctx->gcm_remainder_len], need);

	blockp = (uint8_t *)ctx->gcm_remainder;
	} else {
	blockp = datap;
	}

	/*
	* Increment counter. Counter bits are confined
	* to the bottom 32 bits of the counter block.
	*/
	counter = ntohll(ctx->gcm_cb[1] & counter_mask);
	counter = htonll(counter + 1);
	counter &= counter_mask;
	ctx->gcm_cb[1] = (ctx->gcm_cb[1] & ~counter_mask) \| counter;

	encrypt_block(ctx->gcm_keysched, (uint8_t *)ctx->gcm_cb,
	(uint8_t *)ctx->gcm_tmp);
	xor_block(blockp, (uint8_t *)ctx->gcm_tmp);

	lastp = (uint8_t *)ctx->gcm_tmp;

	ctx->gcm_processed_data_len += block_size;

	crypto_get_ptrs(out, &iov_or_mp, &offset, &out_data_1,
	&out_data_1_len, &out_data_2, block_size);

	/* copy block to where it belongs */
	if (out_data_1_len == block_size) {
	copy_block(lastp, out_data_1);
	} else {
	bcopy(lastp, out_data_1, out_data_1_len);
	if (out_data_2 != NULL) {
	bcopy(lastp + out_data_1_len,
	out_data_2,
	block_size - out_data_1_len);
	}
	}
	/* update offset */
	out->cd_offset += block_size;

	/* add ciphertext to the hash */
	GHASH(ctx, ctx->gcm_tmp, ctx->gcm_ghash, gops);

	/* Update pointer to next block of data to be processed. */
	if (ctx->gcm_remainder_len != 0) {
	datap += need;
	ctx->gcm_remainder_len = 0;
	} else {
	datap += block_size;
	}

	remainder = (size_t)&data[length] - (size_t)datap;

	/* Incomplete last block. */
	if (remainder > 0 && remainder < block_size) {
	bcopy(datap, ctx->gcm_remainder, remainder);
	ctx->gcm_remainder_len = remainder;
	ctx->gcm_copy_to = datap;
	goto out;
	}
	ctx->gcm_copy_to = NULL;

	} while (remainder > 0);
	out:
	return (CRYPTO_SUCCESS);
	}

	/* ARGSUSED */
	int
	gcm_encrypt_final(gcm_ctx_t ctx, crypto_data_t out, size_t block_size,
	int (encrypt_block)(const void , const uint8_t , uint8_t ),
	void (copy_block)(uint8_t , uint8_t *),
	void (xor_block)(uint8_t , uint8_t *))
	{
	#ifdef CAN_USE_GCM_ASM
	if (ctx->gcm_use_avx == B_TRUE)
	return (gcm_encrypt_final_avx(ctx, out, block_size));
	#endif

	const gcm_impl_ops_t *gops;
	uint64_t counter_mask = ntohll(0x00000000ffffffffULL);
	uint8_t ghash, macp = NULL;
	int i, rv;

	if (out->cd_length <
	(ctx->gcm_remainder_len + ctx->gcm_tag_len)) {
	return (CRYPTO_DATA_LEN_RANGE);
	}

	gops = gcm_impl_get_ops();
	ghash = (uint8_t *)ctx->gcm_ghash;

	if (ctx->gcm_remainder_len > 0) {
	uint64_t counter;
	uint8_t tmpp = (uint8_t )ctx->gcm_tmp;

	/*
	* Here is where we deal with data that is not a
	* multiple of the block size.
	*/

	/*
	* Increment counter.
	*/
	counter = ntohll(ctx->gcm_cb[1] & counter_mask);
	counter = htonll(counter + 1);
	counter &= counter_mask;
	ctx->gcm_cb[1] = (ctx->gcm_cb[1] & ~counter_mask) \| counter;

	encrypt_block(ctx->gcm_keysched, (uint8_t *)ctx->gcm_cb,
	(uint8_t *)ctx->gcm_tmp);

	macp = (uint8_t *)ctx->gcm_remainder;
	bzero(macp + ctx->gcm_remainder_len,
	block_size - ctx->gcm_remainder_len);

	/* XOR with counter block */
	for (i = 0; i < ctx->gcm_remainder_len; i++) {
	macp[i] ^= tmpp[i];
	}

	/* add ciphertext to the hash */
	GHASH(ctx, macp, ghash, gops);

	ctx->gcm_processed_data_len += ctx->gcm_remainder_len;
	}

	ctx->gcm_len_a_len_c[1] =
	htonll(CRYPTO_BYTES2BITS(ctx->gcm_processed_data_len));
	GHASH(ctx, ctx->gcm_len_a_len_c, ghash, gops);
	encrypt_block(ctx->gcm_keysched, (uint8_t *)ctx->gcm_J0,
	(uint8_t *)ctx->gcm_J0);
	xor_block((uint8_t *)ctx->gcm_J0, ghash);

	if (ctx->gcm_remainder_len > 0) {
	rv = crypto_put_output_data(macp, out, ctx->gcm_remainder_len);
	if (rv != CRYPTO_SUCCESS)
	return (rv);
	}
	out->cd_offset += ctx->gcm_remainder_len;
	ctx->gcm_remainder_len = 0;
	rv = crypto_put_output_data(ghash, out, ctx->gcm_tag_len);
	if (rv != CRYPTO_SUCCESS)
	return (rv);
	out->cd_offset += ctx->gcm_tag_len;

	return (CRYPTO_SUCCESS);
	}

	/*
	* This will only deal with decrypting the last block of the input that
	* might not be a multiple of block length.
	*/
	static void
	gcm_decrypt_incomplete_block(gcm_ctx_t *ctx, size_t block_size, size_t index,
	int (encrypt_block)(const void , const uint8_t , uint8_t ),
	void (xor_block)(uint8_t , uint8_t *))
	{
	uint8_t datap, outp, *counterp;
	uint64_t counter;
	uint64_t counter_mask = ntohll(0x00000000ffffffffULL);
	int i;

	/*
	* Increment counter.
	* Counter bits are confined to the bottom 32 bits
	*/
	counter = ntohll(ctx->gcm_cb[1] & counter_mask);
	counter = htonll(counter + 1);
	counter &= counter_mask;
	ctx->gcm_cb[1] = (ctx->gcm_cb[1] & ~counter_mask) \| counter;

	datap = (uint8_t *)ctx->gcm_remainder;
	outp = &((ctx->gcm_pt_buf)[index]);
	counterp = (uint8_t *)ctx->gcm_tmp;

	/* authentication tag */
	bzero((uint8_t *)ctx->gcm_tmp, block_size);
	bcopy(datap, (uint8_t *)ctx->gcm_tmp, ctx->gcm_remainder_len);

	/* add ciphertext to the hash */
	GHASH(ctx, ctx->gcm_tmp, ctx->gcm_ghash, gcm_impl_get_ops());

	/* decrypt remaining ciphertext */
	encrypt_block(ctx->gcm_keysched, (uint8_t *)ctx->gcm_cb, counterp);

	/* XOR with counter block */
	for (i = 0; i < ctx->gcm_remainder_len; i++) {
	outp[i] = datap[i] ^ counterp[i];
	}
	}

	/* ARGSUSED */
	int
	gcm_mode_decrypt_contiguous_blocks(gcm_ctx_t ctx, char data, size_t length,
	crypto_data_t *out, size_t block_size,
	int (encrypt_block)(const void , const uint8_t , uint8_t ),
	void (copy_block)(uint8_t , uint8_t *),
	void (xor_block)(uint8_t , uint8_t *))
	{
	size_t new_len;
	uint8_t *new;

	/*
	* Copy contiguous ciphertext input blocks to plaintext buffer.
	* Ciphertext will be decrypted in the final.
	*/
	if (length > 0) {
	new_len = ctx->gcm_pt_buf_len + length;
	new = vmem_alloc(new_len, ctx->gcm_kmflag);
	if (new == NULL) {
	vmem_free(ctx->gcm_pt_buf, ctx->gcm_pt_buf_len);
	ctx->gcm_pt_buf = NULL;
	return (CRYPTO_HOST_MEMORY);
	}
	bcopy(ctx->gcm_pt_buf, new, ctx->gcm_pt_buf_len);
	vmem_free(ctx->gcm_pt_buf, ctx->gcm_pt_buf_len);
	ctx->gcm_pt_buf = new;
	ctx->gcm_pt_buf_len = new_len;
	bcopy(data, &ctx->gcm_pt_buf[ctx->gcm_processed_data_len],
	length);
	ctx->gcm_processed_data_len += length;
	}

	ctx->gcm_remainder_len = 0;
	return (CRYPTO_SUCCESS);
	}

	int
	gcm_decrypt_final(gcm_ctx_t ctx, crypto_data_t out, size_t block_size,
	int (encrypt_block)(const void , const uint8_t , uint8_t ),
	void (xor_block)(uint8_t , uint8_t *))
	{
	#ifdef CAN_USE_GCM_ASM
	if (ctx->gcm_use_avx == B_TRUE)
	return (gcm_decrypt_final_avx(ctx, out, block_size));
	#endif

	const gcm_impl_ops_t *gops;
	size_t pt_len;
	size_t remainder;
	uint8_t *ghash;
	uint8_t *blockp;
	uint8_t *cbp;
	uint64_t counter;
	uint64_t counter_mask = ntohll(0x00000000ffffffffULL);
	int processed = 0, rv;

	ASSERT(ctx->gcm_processed_data_len == ctx->gcm_pt_buf_len);

	gops = gcm_impl_get_ops();
	pt_len = ctx->gcm_processed_data_len - ctx->gcm_tag_len;
	ghash = (uint8_t *)ctx->gcm_ghash;
	blockp = ctx->gcm_pt_buf;
	remainder = pt_len;
	while (remainder > 0) {
	/* Incomplete last block */
	if (remainder < block_size) {
	bcopy(blockp, ctx->gcm_remainder, remainder);
	ctx->gcm_remainder_len = remainder;
	/*
	* not expecting anymore ciphertext, just
	* compute plaintext for the remaining input
	*/
	gcm_decrypt_incomplete_block(ctx, block_size,
	processed, encrypt_block, xor_block);
	ctx->gcm_remainder_len = 0;
	goto out;
	}
	/* add ciphertext to the hash */
	GHASH(ctx, blockp, ghash, gops);

	/*
	* Increment counter.
	* Counter bits are confined to the bottom 32 bits
	*/
	counter = ntohll(ctx->gcm_cb[1] & counter_mask);
	counter = htonll(counter + 1);
	counter &= counter_mask;
	ctx->gcm_cb[1] = (ctx->gcm_cb[1] & ~counter_mask) \| counter;

	cbp = (uint8_t *)ctx->gcm_tmp;
	encrypt_block(ctx->gcm_keysched, (uint8_t *)ctx->gcm_cb, cbp);

	/* XOR with ciphertext */
	xor_block(cbp, blockp);

	processed += block_size;
	blockp += block_size;
	remainder -= block_size;
	}
	out:
	ctx->gcm_len_a_len_c[1] = htonll(CRYPTO_BYTES2BITS(pt_len));
	GHASH(ctx, ctx->gcm_len_a_len_c, ghash, gops);
	encrypt_block(ctx->gcm_keysched, (uint8_t *)ctx->gcm_J0,
	(uint8_t *)ctx->gcm_J0);
	xor_block((uint8_t *)ctx->gcm_J0, ghash);

	/* compare the input authentication tag with what we calculated */
	if (bcmp(&ctx->gcm_pt_buf[pt_len], ghash, ctx->gcm_tag_len)) {
	/* They don't match */
	return (CRYPTO_INVALID_MAC);
	} else {
	rv = crypto_put_output_data(ctx->gcm_pt_buf, out, pt_len);
	if (rv != CRYPTO_SUCCESS)
	return (rv);
	out->cd_offset += pt_len;
	}
	return (CRYPTO_SUCCESS);
	}

	static int
	gcm_validate_args(CK_AES_GCM_PARAMS *gcm_param)
	{
	size_t tag_len;

	/*
	* Check the length of the authentication tag (in bits).
	*/
	tag_len = gcm_param->ulTagBits;
	switch (tag_len) {
	case 32:
	case 64:
	case 96:
	case 104:
	case 112:
	case 120:
	case 128:
	break;
	default:
	return (CRYPTO_MECHANISM_PARAM_INVALID);
	}

	if (gcm_param->ulIvLen == 0)
	return (CRYPTO_MECHANISM_PARAM_INVALID);

	return (CRYPTO_SUCCESS);
	}

	static void
	gcm_format_initial_blocks(uchar_t *iv, ulong_t iv_len,
	gcm_ctx_t *ctx, size_t block_size,
	void (copy_block)(uint8_t , uint8_t *),
	void (xor_block)(uint8_t , uint8_t *))
	{
	const gcm_impl_ops_t *gops;
	uint8_t *cb;
	ulong_t remainder = iv_len;
	ulong_t processed = 0;
	uint8_t datap, ghash;
	uint64_t len_a_len_c[2];

	gops = gcm_impl_get_ops();
	ghash = (uint8_t *)ctx->gcm_ghash;
	cb = (uint8_t *)ctx->gcm_cb;
	if (iv_len == 12) {
	bcopy(iv, cb, 12);
	cb[12] = 0;
	cb[13] = 0;
	cb[14] = 0;
	cb[15] = 1;
	/* J0 will be used again in the final */
	copy_block(cb, (uint8_t *)ctx->gcm_J0);
	} else {
	/* GHASH the IV */
	do {
	if (remainder < block_size) {
	bzero(cb, block_size);
	bcopy(&(iv[processed]), cb, remainder);
	datap = (uint8_t *)cb;
	remainder = 0;
	} else {
	datap = (uint8_t *)(&(iv[processed]));
	processed += block_size;
	remainder -= block_size;
	}
	GHASH(ctx, datap, ghash, gops);
	} while (remainder > 0);

	len_a_len_c[0] = 0;
	len_a_len_c[1] = htonll(CRYPTO_BYTES2BITS(iv_len));
	GHASH(ctx, len_a_len_c, ctx->gcm_J0, gops);

	/* J0 will be used again in the final */
	copy_block((uint8_t )ctx->gcm_J0, (uint8_t )cb);
	}
	}

	static int
	gcm_init(gcm_ctx_t ctx, unsigned char iv, size_t iv_len,
	unsigned char *auth_data, size_t auth_data_len, size_t block_size,
	int (encrypt_block)(const void , const uint8_t , uint8_t ),
	void (copy_block)(uint8_t , uint8_t *),
	void (xor_block)(uint8_t , uint8_t *))
	{
	const gcm_impl_ops_t *gops;
	uint8_t ghash, datap, *authp;
	size_t remainder, processed;

	/* encrypt zero block to get subkey H */
	bzero(ctx->gcm_H, sizeof (ctx->gcm_H));
	encrypt_block(ctx->gcm_keysched, (uint8_t *)ctx->gcm_H,
	(uint8_t *)ctx->gcm_H);

	gcm_format_initial_blocks(iv, iv_len, ctx, block_size,
	copy_block, xor_block);

	gops = gcm_impl_get_ops();
	authp = (uint8_t *)ctx->gcm_tmp;
	ghash = (uint8_t *)ctx->gcm_ghash;
	bzero(authp, block_size);
	bzero(ghash, block_size);

	processed = 0;
	remainder = auth_data_len;
	do {
	if (remainder < block_size) {
	/*
	* There's not a block full of data, pad rest of
	* buffer with zero
	*/
	bzero(authp, block_size);
	bcopy(&(auth_data[processed]), authp, remainder);
	datap = (uint8_t *)authp;
	remainder = 0;
	} else {
	datap = (uint8_t *)(&(auth_data[processed]));
	processed += block_size;
	remainder -= block_size;
	}

	/* add auth data to the hash */
	GHASH(ctx, datap, ghash, gops);

	} while (remainder > 0);

	return (CRYPTO_SUCCESS);
	}

	/*
	* The following function is called at encrypt or decrypt init time
	* for AES GCM mode.
	*
	* Init the GCM context struct. Handle the cycle and avx implementations here.
	*/
	int
	gcm_init_ctx(gcm_ctx_t gcm_ctx, char param, size_t block_size,
	int (encrypt_block)(const void , const uint8_t , uint8_t ),
	void (copy_block)(uint8_t , uint8_t *),
	void (xor_block)(uint8_t , uint8_t *))
	{
	int rv;
	CK_AES_GCM_PARAMS *gcm_param;

	if (param != NULL) {
	gcm_param = (CK_AES_GCM_PARAMS )(void )param;

	if ((rv = gcm_validate_args(gcm_param)) != 0) {
	return (rv);
	}

	gcm_ctx->gcm_tag_len = gcm_param->ulTagBits;
	gcm_ctx->gcm_tag_len >>= 3;
	gcm_ctx->gcm_processed_data_len = 0;

	/* these values are in bits */
	gcm_ctx->gcm_len_a_len_c[0]
	= htonll(CRYPTO_BYTES2BITS(gcm_param->ulAADLen));

	rv = CRYPTO_SUCCESS;
	gcm_ctx->gcm_flags \|= GCM_MODE;
	} else {
	return (CRYPTO_MECHANISM_PARAM_INVALID);
	}

	#ifdef CAN_USE_GCM_ASM
	if (GCM_IMPL_READ(icp_gcm_impl) != IMPL_CYCLE) {
	gcm_ctx->gcm_use_avx = GCM_IMPL_USE_AVX;
	} else {
	/*
	* Handle the "cycle" implementation by creating avx and
	* non-avx contexts alternately.
	*/
	gcm_ctx->gcm_use_avx = gcm_toggle_avx();
	/*
	* We don't handle byte swapped key schedules in the avx
	* code path.
	*/
	aes_key_t ks = (aes_key_t )gcm_ctx->gcm_keysched;
	if (ks->ops->needs_byteswap == B_TRUE) {
	gcm_ctx->gcm_use_avx = B_FALSE;
	}
	/* Use the MOVBE and the BSWAP variants alternately. */
	if (gcm_ctx->gcm_use_avx == B_TRUE &&
	zfs_movbe_available() == B_TRUE) {
	(void) atomic_toggle_boolean_nv(
	(volatile boolean_t *)&gcm_avx_can_use_movbe);
	}
	}
	/* Allocate Htab memory as needed. */
	if (gcm_ctx->gcm_use_avx == B_TRUE) {
	size_t htab_len = gcm_simd_get_htab_size(gcm_ctx->gcm_use_avx);

	if (htab_len == 0) {
	return (CRYPTO_MECHANISM_PARAM_INVALID);
	}
	gcm_ctx->gcm_htab_len = htab_len;
	gcm_ctx->gcm_Htable =
	(uint64_t *)kmem_alloc(htab_len, gcm_ctx->gcm_kmflag);

	if (gcm_ctx->gcm_Htable == NULL) {
	return (CRYPTO_HOST_MEMORY);
	}
	}
	/* Avx and non avx context initialization differs from here on. */
	if (gcm_ctx->gcm_use_avx == B_FALSE) {
	#endif /* ifdef CAN_USE_GCM_ASM */
	if (gcm_init(gcm_ctx, gcm_param->pIv, gcm_param->ulIvLen,
	gcm_param->pAAD, gcm_param->ulAADLen, block_size,
	encrypt_block, copy_block, xor_block) != 0) {
	rv = CRYPTO_MECHANISM_PARAM_INVALID;
	}
	#ifdef CAN_USE_GCM_ASM
	} else {
	if (gcm_init_avx(gcm_ctx, gcm_param->pIv, gcm_param->ulIvLen,
	gcm_param->pAAD, gcm_param->ulAADLen, block_size) != 0) {
	rv = CRYPTO_MECHANISM_PARAM_INVALID;
	}
	}
	#endif /* ifdef CAN_USE_GCM_ASM */

	return (rv);
	}

	int
	gmac_init_ctx(gcm_ctx_t gcm_ctx, char param, size_t block_size,
	int (encrypt_block)(const void , const uint8_t , uint8_t ),
	void (copy_block)(uint8_t , uint8_t *),
	void (xor_block)(uint8_t , uint8_t *))
	{
	int rv;
	CK_AES_GMAC_PARAMS *gmac_param;

	if (param != NULL) {
	gmac_param = (CK_AES_GMAC_PARAMS )(void )param;

	gcm_ctx->gcm_tag_len = CRYPTO_BITS2BYTES(AES_GMAC_TAG_BITS);
	gcm_ctx->gcm_processed_data_len = 0;

	/* these values are in bits */
	gcm_ctx->gcm_len_a_len_c[0]
	= htonll(CRYPTO_BYTES2BITS(gmac_param->ulAADLen));

	rv = CRYPTO_SUCCESS;
	gcm_ctx->gcm_flags \|= GMAC_MODE;
	} else {
	return (CRYPTO_MECHANISM_PARAM_INVALID);
	}

	#ifdef CAN_USE_GCM_ASM
	/*
	* Handle the "cycle" implementation by creating avx and non avx
	* contexts alternately.
	*/
	if (GCM_IMPL_READ(icp_gcm_impl) != IMPL_CYCLE) {
	gcm_ctx->gcm_use_avx = GCM_IMPL_USE_AVX;
	} else {
	gcm_ctx->gcm_use_avx = gcm_toggle_avx();
	}
	/* We don't handle byte swapped key schedules in the avx code path. */
	aes_key_t ks = (aes_key_t )gcm_ctx->gcm_keysched;
	if (ks->ops->needs_byteswap == B_TRUE) {
	gcm_ctx->gcm_use_avx = B_FALSE;
	}
	/* Allocate Htab memory as needed. */
	if (gcm_ctx->gcm_use_avx == B_TRUE) {
	size_t htab_len = gcm_simd_get_htab_size(gcm_ctx->gcm_use_avx);

	if (htab_len == 0) {
	return (CRYPTO_MECHANISM_PARAM_INVALID);
	}
	gcm_ctx->gcm_htab_len = htab_len;
	gcm_ctx->gcm_Htable =
	(uint64_t *)kmem_alloc(htab_len, gcm_ctx->gcm_kmflag);

	if (gcm_ctx->gcm_Htable == NULL) {
	return (CRYPTO_HOST_MEMORY);
	}
	}

	/* Avx and non avx context initialization differs from here on. */
	if (gcm_ctx->gcm_use_avx == B_FALSE) {
	#endif /* ifdef CAN_USE_GCM_ASM */
	if (gcm_init(gcm_ctx, gmac_param->pIv, AES_GMAC_IV_LEN,
	gmac_param->pAAD, gmac_param->ulAADLen, block_size,
	encrypt_block, copy_block, xor_block) != 0) {
	rv = CRYPTO_MECHANISM_PARAM_INVALID;
	}
	#ifdef CAN_USE_GCM_ASM
	} else {
	if (gcm_init_avx(gcm_ctx, gmac_param->pIv, AES_GMAC_IV_LEN,
	gmac_param->pAAD, gmac_param->ulAADLen, block_size) != 0) {
	rv = CRYPTO_MECHANISM_PARAM_INVALID;
	}
	}
	#endif /* ifdef CAN_USE_GCM_ASM */

	return (rv);
	}

	void *
	gcm_alloc_ctx(int kmflag)
	{
	gcm_ctx_t *gcm_ctx;

	if ((gcm_ctx = kmem_zalloc(sizeof (gcm_ctx_t), kmflag)) == NULL)
	return (NULL);

	gcm_ctx->gcm_flags = GCM_MODE;
	return (gcm_ctx);
	}

	void *
	gmac_alloc_ctx(int kmflag)
	{
	gcm_ctx_t *gcm_ctx;

	if ((gcm_ctx = kmem_zalloc(sizeof (gcm_ctx_t), kmflag)) == NULL)
	return (NULL);

	gcm_ctx->gcm_flags = GMAC_MODE;
	return (gcm_ctx);
	}

	void
	gcm_set_kmflag(gcm_ctx_t *ctx, int kmflag)
	{
	ctx->gcm_kmflag = kmflag;
	}

	/* GCM implementation that contains the fastest methods */
	static gcm_impl_ops_t gcm_fastest_impl = {
	.name = "fastest"
	};

	/* All compiled in implementations */
	const gcm_impl_ops_t *gcm_all_impl[] = {
	&gcm_generic_impl,
	#if defined(__x86_64) && defined(HAVE_PCLMULQDQ)
	&gcm_pclmulqdq_impl,
	#endif
	};

	/* Indicate that benchmark has been completed */
	static boolean_t gcm_impl_initialized = B_FALSE;

	/* Hold all supported implementations */
	static size_t gcm_supp_impl_cnt = 0;
	static gcm_impl_ops_t *gcm_supp_impl[ARRAY_SIZE(gcm_all_impl)];

	/*
	* Returns the GCM operations for encrypt/decrypt/key setup. When a
	* SIMD implementation is not allowed in the current context, then
	* fallback to the fastest generic implementation.
	*/
	const gcm_impl_ops_t *
	gcm_impl_get_ops()
	{
	if (!kfpu_allowed())
	return (&gcm_generic_impl);

	const gcm_impl_ops_t *ops = NULL;
	const uint32_t impl = GCM_IMPL_READ(icp_gcm_impl);

	switch (impl) {
	case IMPL_FASTEST:
	ASSERT(gcm_impl_initialized);
	ops = &gcm_fastest_impl;
	break;
	case IMPL_CYCLE:
	/* Cycle through supported implementations */
	ASSERT(gcm_impl_initialized);
	ASSERT3U(gcm_supp_impl_cnt, >, 0);
	static size_t cycle_impl_idx = 0;
	size_t idx = (++cycle_impl_idx) % gcm_supp_impl_cnt;
	ops = gcm_supp_impl[idx];
	break;
	#ifdef CAN_USE_GCM_ASM
	case IMPL_AVX:
	/*
	* Make sure that we return a valid implementation while
	* switching to the avx implementation since there still
	* may be unfinished non-avx contexts around.
	*/
	ops = &gcm_generic_impl;
	break;
	#endif
	default:
	ASSERT3U(impl, <, gcm_supp_impl_cnt);
	ASSERT3U(gcm_supp_impl_cnt, >, 0);
	if (impl < ARRAY_SIZE(gcm_all_impl))
	ops = gcm_supp_impl[impl];
	break;
	}

	ASSERT3P(ops, !=, NULL);

	return (ops);
	}

	/*
	* Initialize all supported implementations.
	*/
	void
	gcm_impl_init(void)
	{
	gcm_impl_ops_t *curr_impl;
	int i, c;

	/* Move supported implementations into gcm_supp_impls */
	for (i = 0, c = 0; i < ARRAY_SIZE(gcm_all_impl); i++) {
	curr_impl = (gcm_impl_ops_t *)gcm_all_impl[i];

	if (curr_impl->is_supported())
	gcm_supp_impl[c++] = (gcm_impl_ops_t *)curr_impl;
	}
	gcm_supp_impl_cnt = c;

	/*
	* Set the fastest implementation given the assumption that the
	* hardware accelerated version is the fastest.
	*/
	#if defined(__x86_64) && defined(HAVE_PCLMULQDQ)
	if (gcm_pclmulqdq_impl.is_supported()) {
	memcpy(&gcm_fastest_impl, &gcm_pclmulqdq_impl,
	sizeof (gcm_fastest_impl));
	} else
	#endif
	{
	memcpy(&gcm_fastest_impl, &gcm_generic_impl,
	sizeof (gcm_fastest_impl));
	}

	strlcpy(gcm_fastest_impl.name, "fastest", GCM_IMPL_NAME_MAX);

	#ifdef CAN_USE_GCM_ASM
	/*
	* Use the avx implementation if it's available and the implementation
	* hasn't changed from its default value of fastest on module load.
	*/
	if (gcm_avx_will_work()) {
	#ifdef HAVE_MOVBE
	if (zfs_movbe_available() == B_TRUE) {
	atomic_swap_32(&gcm_avx_can_use_movbe, B_TRUE);
	}
	#endif
	if (GCM_IMPL_READ(user_sel_impl) == IMPL_FASTEST) {
	gcm_set_avx(B_TRUE);
	}
	}
	#endif
	/* Finish initialization */
	atomic_swap_32(&icp_gcm_impl, user_sel_impl);
	gcm_impl_initialized = B_TRUE;
	}

	static const struct {
	char *name;
	uint32_t sel;
	} gcm_impl_opts[] = {
	{ "cycle", IMPL_CYCLE },
	{ "fastest", IMPL_FASTEST },
	#ifdef CAN_USE_GCM_ASM
	{ "avx", IMPL_AVX },
	#endif
	};

	/*
	* Function sets desired gcm implementation.
	*
	* If we are called before init(), user preference will be saved in
	* user_sel_impl, and applied in later init() call. This occurs when module
	* parameter is specified on module load. Otherwise, directly update
	* icp_gcm_impl.
	*
	* @val Name of gcm implementation to use
	* @param Unused.
	*/
	int
	gcm_impl_set(const char *val)
	{
	int err = -EINVAL;
	char req_name[GCM_IMPL_NAME_MAX];
	uint32_t impl = GCM_IMPL_READ(user_sel_impl);
	size_t i;

	/* sanitize input */
	i = strnlen(val, GCM_IMPL_NAME_MAX);
	if (i == 0 \|\| i >= GCM_IMPL_NAME_MAX)
	return (err);

	strlcpy(req_name, val, GCM_IMPL_NAME_MAX);
	while (i > 0 && isspace(req_name[i-1]))
	i--;
	req_name[i] = '\0';

	/* Check mandatory options */
	for (i = 0; i < ARRAY_SIZE(gcm_impl_opts); i++) {
	#ifdef CAN_USE_GCM_ASM
	/* Ignore avx implementation if it won't work. */
	if (gcm_impl_opts[i].sel == IMPL_AVX && !gcm_avx_will_work()) {
	continue;
	}
	#endif
	if (strcmp(req_name, gcm_impl_opts[i].name) == 0) {
	impl = gcm_impl_opts[i].sel;
	err = 0;
	break;
	}
	}

	/* check all supported impl if init() was already called */
	if (err != 0 && gcm_impl_initialized) {
	/* check all supported implementations */
	for (i = 0; i < gcm_supp_impl_cnt; i++) {
	if (strcmp(req_name, gcm_supp_impl[i]->name) == 0) {
	impl = i;
	err = 0;
	break;
	}
	}
	}
	#ifdef CAN_USE_GCM_ASM
	/*
	* Use the avx implementation if available and the requested one is
	* avx or fastest.
	*/
	if (gcm_avx_will_work() == B_TRUE &&
	(impl == IMPL_AVX \|\| impl == IMPL_FASTEST)) {
	gcm_set_avx(B_TRUE);
	} else {
	gcm_set_avx(B_FALSE);
	}
	#endif

	if (err == 0) {
	if (gcm_impl_initialized)
	atomic_swap_32(&icp_gcm_impl, impl);
	else
	atomic_swap_32(&user_sel_impl, impl);
	}

	return (err);
	}

	#if defined(_KERNEL) && defined(__linux__)

	static int
	icp_gcm_impl_set(const char val, zfs_kernel_param_t kp)
	{
	return (gcm_impl_set(val));
	}

	static int
	icp_gcm_impl_get(char buffer, zfs_kernel_param_t kp)
	{
	int i, cnt = 0;
	char *fmt;
	const uint32_t impl = GCM_IMPL_READ(icp_gcm_impl);

	ASSERT(gcm_impl_initialized);

	/* list mandatory options */
	for (i = 0; i < ARRAY_SIZE(gcm_impl_opts); i++) {
	#ifdef CAN_USE_GCM_ASM
	/* Ignore avx implementation if it won't work. */
	if (gcm_impl_opts[i].sel == IMPL_AVX && !gcm_avx_will_work()) {
	continue;
	}
	#endif
	fmt = (impl == gcm_impl_opts[i].sel) ? "[%s] " : "%s ";
	cnt += sprintf(buffer + cnt, fmt, gcm_impl_opts[i].name);
	}

	/* list all supported implementations */
	for (i = 0; i < gcm_supp_impl_cnt; i++) {
	fmt = (i == impl) ? "[%s] " : "%s ";
	cnt += sprintf(buffer + cnt, fmt, gcm_supp_impl[i]->name);
	}

	return (cnt);
	}

	module_param_call(icp_gcm_impl, icp_gcm_impl_set, icp_gcm_impl_get,
	NULL, 0644);
	MODULE_PARM_DESC(icp_gcm_impl, "Select gcm implementation.");
	#endif /* defined(__KERNEL) */

	#ifdef CAN_USE_GCM_ASM
	#define GCM_BLOCK_LEN 16
	/*
	* The openssl asm routines are 6x aggregated and need that many bytes
	* at minimum.
	*/
	#define GCM_AVX_MIN_DECRYPT_BYTES (GCM_BLOCK_LEN * 6)
	#define GCM_AVX_MIN_ENCRYPT_BYTES (GCM_BLOCK_LEN * 6 * 3)
	/*
	* Ensure the chunk size is reasonable since we are allocating a
	* GCM_AVX_MAX_CHUNK_SIZEd buffer and disabling preemption and interrupts.
	*/
	#define GCM_AVX_MAX_CHUNK_SIZE \
	(((1281024)/GCM_AVX_MIN_DECRYPT_BYTES) GCM_AVX_MIN_DECRYPT_BYTES)

	/* Get the chunk size module parameter. */
	#define GCM_CHUNK_SIZE_READ (volatile uint32_t ) &gcm_avx_chunk_size

	/* Clear the FPU registers since they hold sensitive internal state. */
	#define clear_fpu_regs() clear_fpu_regs_avx()
	#define GHASH_AVX(ctx, in, len) \
	gcm_ghash_avx((ctx)->gcm_ghash, (const uint64_t *)(ctx)->gcm_Htable, \
	in, len)

	#define gcm_incr_counter_block(ctx) gcm_incr_counter_block_by(ctx, 1)

	/*
	* Module parameter: number of bytes to process at once while owning the FPU.
	* Rounded down to the next GCM_AVX_MIN_DECRYPT_BYTES byte boundary and is
	* ensured to be greater or equal than GCM_AVX_MIN_DECRYPT_BYTES.
	*/
	static uint32_t gcm_avx_chunk_size =
	((32 * 1024) / GCM_AVX_MIN_DECRYPT_BYTES) * GCM_AVX_MIN_DECRYPT_BYTES;

	extern void clear_fpu_regs_avx(void);
	extern void gcm_xor_avx(const uint8_t src, uint8_t dst);
	extern void aes_encrypt_intel(const uint32_t rk[], int nr,
	const uint32_t pt[4], uint32_t ct[4]);

	extern void gcm_init_htab_avx(uint64_t *Htable, const uint64_t H[2]);
	extern void gcm_ghash_avx(uint64_t ghash[2], const uint64_t *Htable,
	const uint8_t *in, size_t len);

	extern size_t aesni_gcm_encrypt(const uint8_t , uint8_t , size_t,
	const void , uint64_t , uint64_t *);

	extern size_t aesni_gcm_decrypt(const uint8_t , uint8_t , size_t,
	const void , uint64_t , uint64_t *);

	static inline boolean_t
	gcm_avx_will_work(void)
	{
	/* Avx should imply aes-ni and pclmulqdq, but make sure anyhow. */
	return (kfpu_allowed() &&
	zfs_avx_available() && zfs_aes_available() &&
	zfs_pclmulqdq_available());
	}

	static inline void
	gcm_set_avx(boolean_t val)
	{
	if (gcm_avx_will_work() == B_TRUE) {
	atomic_swap_32(&gcm_use_avx, val);
	}
	}

	static inline boolean_t
	gcm_toggle_avx(void)
	{
	if (gcm_avx_will_work() == B_TRUE) {
	return (atomic_toggle_boolean_nv(&GCM_IMPL_USE_AVX));
	} else {
	return (B_FALSE);
	}
	}

	static inline size_t
	gcm_simd_get_htab_size(boolean_t simd_mode)
	{
	switch (simd_mode) {
	case B_TRUE:
	return (2 * 6 * 2 * sizeof (uint64_t));

	default:
	return (0);
	}
	}

	/*
	* Clear sensitive data in the context.
	*
	* ctx->gcm_remainder may contain a plaintext remainder. ctx->gcm_H and
	* ctx->gcm_Htable contain the hash sub key which protects authentication.
	*
	* Although extremely unlikely, ctx->gcm_J0 and ctx->gcm_tmp could be used for
	* a known plaintext attack, they consists of the IV and the first and last
	* counter respectively. If they should be cleared is debatable.
	*/
	static inline void
	gcm_clear_ctx(gcm_ctx_t *ctx)
	{
	bzero(ctx->gcm_remainder, sizeof (ctx->gcm_remainder));
	bzero(ctx->gcm_H, sizeof (ctx->gcm_H));
	bzero(ctx->gcm_J0, sizeof (ctx->gcm_J0));
	bzero(ctx->gcm_tmp, sizeof (ctx->gcm_tmp));
	}

	/* Increment the GCM counter block by n. */
	static inline void
	gcm_incr_counter_block_by(gcm_ctx_t *ctx, int n)
	{
	uint64_t counter_mask = ntohll(0x00000000ffffffffULL);
	uint64_t counter = ntohll(ctx->gcm_cb[1] & counter_mask);

	counter = htonll(counter + n);
	counter &= counter_mask;
	ctx->gcm_cb[1] = (ctx->gcm_cb[1] & ~counter_mask) \| counter;
	}

	/*
	* Encrypt multiple blocks of data in GCM mode.
	* This is done in gcm_avx_chunk_size chunks, utilizing AVX assembler routines
	* if possible. While processing a chunk the FPU is "locked".
	*/
	static int
	gcm_mode_encrypt_contiguous_blocks_avx(gcm_ctx_t ctx, char data,
	size_t length, crypto_data_t *out, size_t block_size)
	{
	size_t bleft = length;
	size_t need = 0;
	size_t done = 0;
	uint8_t datap = (uint8_t )data;
	size_t chunk_size = (size_t)GCM_CHUNK_SIZE_READ;
	const aes_key_t key = ((aes_key_t )ctx->gcm_keysched);
	uint64_t *ghash = ctx->gcm_ghash;
	uint64_t *cb = ctx->gcm_cb;
	uint8_t *ct_buf = NULL;
	uint8_t tmp = (uint8_t )ctx->gcm_tmp;
	int rv = CRYPTO_SUCCESS;

	ASSERT(block_size == GCM_BLOCK_LEN);
	/*
	* If the last call left an incomplete block, try to fill
	* it first.
	*/
	if (ctx->gcm_remainder_len > 0) {
	need = block_size - ctx->gcm_remainder_len;
	if (length < need) {
	/* Accumulate bytes here and return. */
	bcopy(datap, (uint8_t *)ctx->gcm_remainder +
	ctx->gcm_remainder_len, length);

	ctx->gcm_remainder_len += length;
	if (ctx->gcm_copy_to == NULL) {
	ctx->gcm_copy_to = datap;
	}
	return (CRYPTO_SUCCESS);
	} else {
	/* Complete incomplete block. */
	bcopy(datap, (uint8_t *)ctx->gcm_remainder +
	ctx->gcm_remainder_len, need);

	ctx->gcm_copy_to = NULL;
	}
	}

	/* Allocate a buffer to encrypt to if there is enough input. */
	if (bleft >= GCM_AVX_MIN_ENCRYPT_BYTES) {
	ct_buf = vmem_alloc(chunk_size, ctx->gcm_kmflag);
	if (ct_buf == NULL) {
	return (CRYPTO_HOST_MEMORY);
	}
	}

	/* If we completed an incomplete block, encrypt and write it out. */
	if (ctx->gcm_remainder_len > 0) {
	kfpu_begin();
	aes_encrypt_intel(key->encr_ks.ks32, key->nr,
	(const uint32_t )cb, (uint32_t )tmp);

	gcm_xor_avx((const uint8_t *) ctx->gcm_remainder, tmp);
	GHASH_AVX(ctx, tmp, block_size);
	clear_fpu_regs();
	kfpu_end();
	rv = crypto_put_output_data(tmp, out, block_size);
	out->cd_offset += block_size;
	gcm_incr_counter_block(ctx);
	ctx->gcm_processed_data_len += block_size;
	bleft -= need;
	datap += need;
	ctx->gcm_remainder_len = 0;
	}

	/* Do the bulk encryption in chunk_size blocks. */
	for (; bleft >= chunk_size; bleft -= chunk_size) {
	kfpu_begin();
	done = aesni_gcm_encrypt(
	datap, ct_buf, chunk_size, key, cb, ghash);

	clear_fpu_regs();
	kfpu_end();
	if (done != chunk_size) {
	rv = CRYPTO_FAILED;
	goto out_nofpu;
	}
	rv = crypto_put_output_data(ct_buf, out, chunk_size);
	if (rv != CRYPTO_SUCCESS) {
	goto out_nofpu;
	}
	out->cd_offset += chunk_size;
	datap += chunk_size;
	ctx->gcm_processed_data_len += chunk_size;
	}
	/* Check if we are already done. */
	if (bleft == 0) {
	goto out_nofpu;
	}
	/* Bulk encrypt the remaining data. */
	kfpu_begin();
	if (bleft >= GCM_AVX_MIN_ENCRYPT_BYTES) {
	done = aesni_gcm_encrypt(datap, ct_buf, bleft, key, cb, ghash);
	if (done == 0) {
	rv = CRYPTO_FAILED;
	goto out;
	}
	rv = crypto_put_output_data(ct_buf, out, done);
	if (rv != CRYPTO_SUCCESS) {
	goto out;
	}
	out->cd_offset += done;
	ctx->gcm_processed_data_len += done;
	datap += done;
	bleft -= done;

	}
	/* Less than GCM_AVX_MIN_ENCRYPT_BYTES remain, operate on blocks. */
	while (bleft > 0) {
	if (bleft < block_size) {
	bcopy(datap, ctx->gcm_remainder, bleft);
	ctx->gcm_remainder_len = bleft;
	ctx->gcm_copy_to = datap;
	goto out;
	}
	/* Encrypt, hash and write out. */
	aes_encrypt_intel(key->encr_ks.ks32, key->nr,
	(const uint32_t )cb, (uint32_t )tmp);

	gcm_xor_avx(datap, tmp);
	GHASH_AVX(ctx, tmp, block_size);
	rv = crypto_put_output_data(tmp, out, block_size);
	if (rv != CRYPTO_SUCCESS) {
	goto out;
	}
	out->cd_offset += block_size;
	gcm_incr_counter_block(ctx);
	ctx->gcm_processed_data_len += block_size;
	datap += block_size;
	bleft -= block_size;
	}
	out:
	clear_fpu_regs();
	kfpu_end();
	out_nofpu:
	if (ct_buf != NULL) {
	vmem_free(ct_buf, chunk_size);
	}
	return (rv);
	}

	/*
	* Finalize the encryption: Zero fill, encrypt, hash and write out an eventual
	* incomplete last block. Encrypt the ICB. Calculate the tag and write it out.
	*/
	static int
	gcm_encrypt_final_avx(gcm_ctx_t ctx, crypto_data_t out, size_t block_size)
	{
	uint8_t ghash = (uint8_t )ctx->gcm_ghash;
	uint32_t J0 = (uint32_t )ctx->gcm_J0;
	uint8_t remainder = (uint8_t )ctx->gcm_remainder;
	size_t rem_len = ctx->gcm_remainder_len;
	const void keysched = ((aes_key_t )ctx->gcm_keysched)->encr_ks.ks32;
	int aes_rounds = ((aes_key_t *)keysched)->nr;
	int rv;

	ASSERT(block_size == GCM_BLOCK_LEN);

	if (out->cd_length < (rem_len + ctx->gcm_tag_len)) {
	return (CRYPTO_DATA_LEN_RANGE);
	}

	kfpu_begin();
	/* Pad last incomplete block with zeros, encrypt and hash. */
	if (rem_len > 0) {
	uint8_t tmp = (uint8_t )ctx->gcm_tmp;
	const uint32_t cb = (uint32_t )ctx->gcm_cb;

	aes_encrypt_intel(keysched, aes_rounds, cb, (uint32_t *)tmp);
	bzero(remainder + rem_len, block_size - rem_len);
	for (int i = 0; i < rem_len; i++) {
	remainder[i] ^= tmp[i];
	}
	GHASH_AVX(ctx, remainder, block_size);
	ctx->gcm_processed_data_len += rem_len;
	/* No need to increment counter_block, it's the last block. */
	}
	/* Finish tag. */
	ctx->gcm_len_a_len_c[1] =
	htonll(CRYPTO_BYTES2BITS(ctx->gcm_processed_data_len));
	GHASH_AVX(ctx, (const uint8_t *)ctx->gcm_len_a_len_c, block_size);
	aes_encrypt_intel(keysched, aes_rounds, J0, J0);

	gcm_xor_avx((uint8_t *)J0, ghash);
	clear_fpu_regs();
	kfpu_end();

	/* Output remainder. */
	if (rem_len > 0) {
	rv = crypto_put_output_data(remainder, out, rem_len);
	if (rv != CRYPTO_SUCCESS)
	return (rv);
	}
	out->cd_offset += rem_len;
	ctx->gcm_remainder_len = 0;
	rv = crypto_put_output_data(ghash, out, ctx->gcm_tag_len);
	if (rv != CRYPTO_SUCCESS)
	return (rv);

	out->cd_offset += ctx->gcm_tag_len;
	/* Clear sensitive data in the context before returning. */
	gcm_clear_ctx(ctx);
	return (CRYPTO_SUCCESS);
	}

	/*
	* Finalize decryption: We just have accumulated crypto text, so now we
	* decrypt it here inplace.
	*/
	static int
	gcm_decrypt_final_avx(gcm_ctx_t ctx, crypto_data_t out, size_t block_size)
	{
	ASSERT3U(ctx->gcm_processed_data_len, ==, ctx->gcm_pt_buf_len);
	ASSERT3U(block_size, ==, 16);

	size_t chunk_size = (size_t)GCM_CHUNK_SIZE_READ;
	size_t pt_len = ctx->gcm_processed_data_len - ctx->gcm_tag_len;
	uint8_t *datap = ctx->gcm_pt_buf;
	const aes_key_t key = ((aes_key_t )ctx->gcm_keysched);
	uint32_t cb = (uint32_t )ctx->gcm_cb;
	uint64_t *ghash = ctx->gcm_ghash;
	uint32_t tmp = (uint32_t )ctx->gcm_tmp;
	int rv = CRYPTO_SUCCESS;
	size_t bleft, done;

	/*
	* Decrypt in chunks of gcm_avx_chunk_size, which is asserted to be
	* greater or equal than GCM_AVX_MIN_ENCRYPT_BYTES, and a multiple of
	* GCM_AVX_MIN_DECRYPT_BYTES.
	*/
	for (bleft = pt_len; bleft >= chunk_size; bleft -= chunk_size) {
	kfpu_begin();
	done = aesni_gcm_decrypt(datap, datap, chunk_size,
	(const void *)key, ctx->gcm_cb, ghash);
	clear_fpu_regs();
	kfpu_end();
	if (done != chunk_size) {
	return (CRYPTO_FAILED);
	}
	datap += done;
	}
	- /* Decrypt remainder, which is less then chunk size, in one go. */
	+ /* Decrypt remainder, which is less than chunk size, in one go. */
	kfpu_begin();
	if (bleft >= GCM_AVX_MIN_DECRYPT_BYTES) {
	done = aesni_gcm_decrypt(datap, datap, bleft,
	(const void *)key, ctx->gcm_cb, ghash);
	if (done == 0) {
	clear_fpu_regs();
	kfpu_end();
	return (CRYPTO_FAILED);
	}
	datap += done;
	bleft -= done;
	}
	ASSERT(bleft < GCM_AVX_MIN_DECRYPT_BYTES);

	/*
	- * Now less then GCM_AVX_MIN_DECRYPT_BYTES bytes remain,
	+ * Now less than GCM_AVX_MIN_DECRYPT_BYTES bytes remain,
	* decrypt them block by block.
	*/
	while (bleft > 0) {
	/* Incomplete last block. */
	if (bleft < block_size) {
	uint8_t lastb = (uint8_t )ctx->gcm_remainder;

	bzero(lastb, block_size);
	bcopy(datap, lastb, bleft);
	/* The GCM processing. */
	GHASH_AVX(ctx, lastb, block_size);
	aes_encrypt_intel(key->encr_ks.ks32, key->nr, cb, tmp);
	for (size_t i = 0; i < bleft; i++) {
	datap[i] = lastb[i] ^ ((uint8_t *)tmp)[i];
	}
	break;
	}
	/* The GCM processing. */
	GHASH_AVX(ctx, datap, block_size);
	aes_encrypt_intel(key->encr_ks.ks32, key->nr, cb, tmp);
	gcm_xor_avx((uint8_t *)tmp, datap);
	gcm_incr_counter_block(ctx);

	datap += block_size;
	bleft -= block_size;
	}
	if (rv != CRYPTO_SUCCESS) {
	clear_fpu_regs();
	kfpu_end();
	return (rv);
	}
	/* Decryption done, finish the tag. */
	ctx->gcm_len_a_len_c[1] = htonll(CRYPTO_BYTES2BITS(pt_len));
	GHASH_AVX(ctx, (uint8_t *)ctx->gcm_len_a_len_c, block_size);
	aes_encrypt_intel(key->encr_ks.ks32, key->nr, (uint32_t *)ctx->gcm_J0,
	(uint32_t *)ctx->gcm_J0);

	gcm_xor_avx((uint8_t )ctx->gcm_J0, (uint8_t )ghash);

	/* We are done with the FPU, restore its state. */
	clear_fpu_regs();
	kfpu_end();

	/* Compare the input authentication tag with what we calculated. */
	if (bcmp(&ctx->gcm_pt_buf[pt_len], ghash, ctx->gcm_tag_len)) {
	/* They don't match. */
	return (CRYPTO_INVALID_MAC);
	}
	rv = crypto_put_output_data(ctx->gcm_pt_buf, out, pt_len);
	if (rv != CRYPTO_SUCCESS) {
	return (rv);
	}
	out->cd_offset += pt_len;
	gcm_clear_ctx(ctx);
	return (CRYPTO_SUCCESS);
	}

	/*
	* Initialize the GCM params H, Htabtle and the counter block. Save the
	* initial counter block.
	*/
	static int
	gcm_init_avx(gcm_ctx_t ctx, unsigned char iv, size_t iv_len,
	unsigned char *auth_data, size_t auth_data_len, size_t block_size)
	{
	uint8_t cb = (uint8_t )ctx->gcm_cb;
	uint64_t *H = ctx->gcm_H;
	const void keysched = ((aes_key_t )ctx->gcm_keysched)->encr_ks.ks32;
	int aes_rounds = ((aes_key_t *)ctx->gcm_keysched)->nr;
	uint8_t *datap = auth_data;
	size_t chunk_size = (size_t)GCM_CHUNK_SIZE_READ;
	size_t bleft;

	ASSERT(block_size == GCM_BLOCK_LEN);

	/* Init H (encrypt zero block) and create the initial counter block. */
	bzero(ctx->gcm_ghash, sizeof (ctx->gcm_ghash));
	bzero(H, sizeof (ctx->gcm_H));
	kfpu_begin();
	aes_encrypt_intel(keysched, aes_rounds,
	(const uint32_t )H, (uint32_t )H);

	gcm_init_htab_avx(ctx->gcm_Htable, H);

	if (iv_len == 12) {
	bcopy(iv, cb, 12);
	cb[12] = 0;
	cb[13] = 0;
	cb[14] = 0;
	cb[15] = 1;
	/* We need the ICB later. */
	bcopy(cb, ctx->gcm_J0, sizeof (ctx->gcm_J0));
	} else {
	/*
	* Most consumers use 12 byte IVs, so it's OK to use the
	* original routines for other IV sizes, just avoid nesting
	* kfpu_begin calls.
	*/
	clear_fpu_regs();
	kfpu_end();
	gcm_format_initial_blocks(iv, iv_len, ctx, block_size,
	aes_copy_block, aes_xor_block);
	kfpu_begin();
	}

	/* Openssl post increments the counter, adjust for that. */
	gcm_incr_counter_block(ctx);

	/* Ghash AAD in chunk_size blocks. */
	for (bleft = auth_data_len; bleft >= chunk_size; bleft -= chunk_size) {
	GHASH_AVX(ctx, datap, chunk_size);
	datap += chunk_size;
	clear_fpu_regs();
	kfpu_end();
	kfpu_begin();
	}
	/* Ghash the remainder and handle possible incomplete GCM block. */
	if (bleft > 0) {
	size_t incomp = bleft % block_size;

	bleft -= incomp;
	if (bleft > 0) {
	GHASH_AVX(ctx, datap, bleft);
	datap += bleft;
	}
	if (incomp > 0) {
	/* Zero pad and hash incomplete last block. */
	uint8_t authp = (uint8_t )ctx->gcm_tmp;

	bzero(authp, block_size);
	bcopy(datap, authp, incomp);
	GHASH_AVX(ctx, authp, block_size);
	}
	}
	clear_fpu_regs();
	kfpu_end();
	return (CRYPTO_SUCCESS);
	}

	#if defined(_KERNEL)
	static int
	icp_gcm_avx_set_chunk_size(const char buf, zfs_kernel_param_t kp)
	{
	unsigned long val;
	char val_rounded[16];
	int error = 0;

	error = kstrtoul(buf, 0, &val);
	if (error)
	return (error);

	val = (val / GCM_AVX_MIN_DECRYPT_BYTES) * GCM_AVX_MIN_DECRYPT_BYTES;

	if (val < GCM_AVX_MIN_ENCRYPT_BYTES \|\| val > GCM_AVX_MAX_CHUNK_SIZE)
	return (-EINVAL);

	snprintf(val_rounded, 16, "%u", (uint32_t)val);
	error = param_set_uint(val_rounded, kp);
	return (error);
	}

	module_param_call(icp_gcm_avx_chunk_size, icp_gcm_avx_set_chunk_size,
	param_get_uint, &gcm_avx_chunk_size, 0644);

	MODULE_PARM_DESC(icp_gcm_avx_chunk_size,
	"How many bytes to process while owning the FPU");

	#endif /* defined(__KERNEL) */
	#endif /* ifdef CAN_USE_GCM_ASM */
	diff --git a/sys/contrib/openzfs/module/os/freebsd/spl/spl_vfs.c b/sys/contrib/openzfs/module/os/freebsd/spl/spl_vfs.c
	index 09c8401267df..54d3dce316d6 100644
	--- a/sys/contrib/openzfs/module/os/freebsd/spl/spl_vfs.c
	+++ b/sys/contrib/openzfs/module/os/freebsd/spl/spl_vfs.c
	@@ -1,287 +1,287 @@
	/*
	* Copyright (c) 2006-2007 Pawel Jakub Dawidek <pjd@FreeBSD.org>
	* 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/types.h>
	#include <sys/param.h>
	#include <sys/kernel.h>
	#include <sys/systm.h>
	#include <sys/malloc.h>
	#include <sys/mount.h>
	#include <sys/cred.h>
	#include <sys/vfs.h>
	#include <sys/priv.h>
	#include <sys/libkern.h>

	#include <sys/mutex.h>
	#include <sys/vnode.h>
	#include <sys/taskq.h>

	#include <sys/ccompat.h>

	MALLOC_DECLARE(M_MOUNT);

	void
	vfs_setmntopt(vfs_t vfsp, const char name, const char *arg,
	int flags __unused)
	{
	struct vfsopt *opt;
	size_t namesize;
	int locked;

	if (!(locked = mtx_owned(MNT_MTX(vfsp))))
	MNT_ILOCK(vfsp);

	if (vfsp->mnt_opt == NULL) {
	void *opts;

	MNT_IUNLOCK(vfsp);
	opts = malloc(sizeof (*vfsp->mnt_opt), M_MOUNT, M_WAITOK);
	MNT_ILOCK(vfsp);
	if (vfsp->mnt_opt == NULL) {
	vfsp->mnt_opt = opts;
	TAILQ_INIT(vfsp->mnt_opt);
	} else {
	free(opts, M_MOUNT);
	}
	}

	MNT_IUNLOCK(vfsp);

	opt = malloc(sizeof (*opt), M_MOUNT, M_WAITOK);
	namesize = strlen(name) + 1;
	opt->name = malloc(namesize, M_MOUNT, M_WAITOK);
	strlcpy(opt->name, name, namesize);
	opt->pos = -1;
	opt->seen = 1;
	if (arg == NULL) {
	opt->value = NULL;
	opt->len = 0;
	} else {
	opt->len = strlen(arg) + 1;
	opt->value = malloc(opt->len, M_MOUNT, M_WAITOK);
	bcopy(arg, opt->value, opt->len);
	}

	MNT_ILOCK(vfsp);
	TAILQ_INSERT_TAIL(vfsp->mnt_opt, opt, link);
	if (!locked)
	MNT_IUNLOCK(vfsp);
	}

	void
	vfs_clearmntopt(vfs_t vfsp, const char name)
	{
	int locked;

	if (!(locked = mtx_owned(MNT_MTX(vfsp))))
	MNT_ILOCK(vfsp);
	vfs_deleteopt(vfsp->mnt_opt, name);
	if (!locked)
	MNT_IUNLOCK(vfsp);
	}

	int
	vfs_optionisset(const vfs_t vfsp, const char opt, char **argp)
	{
	struct vfsoptlist *opts = vfsp->mnt_optnew;
	int error;

	if (opts == NULL)
	return (0);
	error = vfs_getopt(opts, opt, (void **)argp, NULL);
	return (error != 0 ? 0 : 1);
	}

	int
	mount_snapshot(kthread_t td, vnode_t vpp, const char fstype, char *fspath,
	char *fspec, int fsflags)
	{
	struct vfsconf *vfsp;
	struct mount *mp;
	vnode_t vp, mvp;
	struct ucred *cr;
	int error;

	ASSERT_VOP_ELOCKED(*vpp, "mount_snapshot");

	vp = *vpp;
	*vpp = NULL;
	error = 0;

	/*
	* Be ultra-paranoid about making sure the type and fspath
	* variables will fit in our mp buffers, including the
	* terminating NUL.
	*/
	if (strlen(fstype) >= MFSNAMELEN \|\| strlen(fspath) >= MNAMELEN)
	error = ENAMETOOLONG;
	if (error == 0 && (vfsp = vfs_byname_kld(fstype, td, &error)) == NULL)
	error = ENODEV;
	if (error == 0 && vp->v_type != VDIR)
	error = ENOTDIR;
	/*
	* We need vnode lock to protect v_mountedhere and vnode interlock
	* to protect v_iflag.
	*/
	if (error == 0) {
	VI_LOCK(vp);
	if ((vp->v_iflag & VI_MOUNT) == 0 && vp->v_mountedhere == NULL)
	vp->v_iflag \|= VI_MOUNT;
	else
	error = EBUSY;
	VI_UNLOCK(vp);
	}
	if (error != 0) {
	vput(vp);
	return (error);
	}
	vn_seqc_write_begin(vp);
	VOP_UNLOCK1(vp);

	/*
	* Allocate and initialize the filesystem.
	* We don't want regular user that triggered snapshot mount to be able
	* to unmount it, so pass credentials of the parent mount.
	*/
	mp = vfs_mount_alloc(vp, vfsp, fspath, vp->v_mount->mnt_cred);

	mp->mnt_optnew = NULL;
	vfs_setmntopt(mp, "from", fspec, 0);
	mp->mnt_optnew = mp->mnt_opt;
	mp->mnt_opt = NULL;

	/*
	* Set the mount level flags.
	*/
	mp->mnt_flag = fsflags & MNT_UPDATEMASK;
	/*
	* Snapshots are always read-only.
	*/
	mp->mnt_flag \|= MNT_RDONLY;
	/*
	* We don't want snapshots to allow access to vulnerable setuid
	* programs, so we turn off setuid when mounting snapshots.
	*/
	mp->mnt_flag \|= MNT_NOSUID;
	/*
	* We don't want snapshots to be visible in regular
	* mount(8) and df(1) output.
	*/
	mp->mnt_flag \|= MNT_IGNORE;
	/*
	* XXX: This is evil, but we can't mount a snapshot as a regular user.
	* XXX: Is is safe when snapshot is mounted from within a jail?
	*/
	cr = td->td_ucred;
	td->td_ucred = kcred;
	error = VFS_MOUNT(mp);
	td->td_ucred = cr;

	if (error != 0) {
	/*
	* Clear VI_MOUNT and decrement the use count "atomically",
	* under the vnode lock. This is not strictly required,
	* but makes it easier to reason about the life-cycle and
	* ownership of the covered vnode.
	*/
	vn_lock(vp, LK_EXCLUSIVE \| LK_RETRY);
	VI_LOCK(vp);
	vp->v_iflag &= ~VI_MOUNT;
	VI_UNLOCK(vp);
	vn_seqc_write_end(vp);
	vput(vp);
	vfs_unbusy(mp);
	vfs_freeopts(mp->mnt_optnew);
	mp->mnt_vnodecovered = NULL;
	vfs_mount_destroy(mp);
	return (error);
	}

	if (mp->mnt_opt != NULL)
	vfs_freeopts(mp->mnt_opt);
	mp->mnt_opt = mp->mnt_optnew;
	(void) VFS_STATFS(mp, &mp->mnt_stat);

	/*
	* Prevent external consumers of mount options from reading
	* mnt_optnew.
	*/
	mp->mnt_optnew = NULL;

	vn_lock(vp, LK_EXCLUSIVE \| LK_RETRY);
	#ifdef FREEBSD_NAMECACHE
	cache_purge(vp);
	#endif
	VI_LOCK(vp);
	vp->v_iflag &= ~VI_MOUNT;
	#ifdef VIRF_MOUNTPOINT
	vn_irflag_set_locked(vp, VIRF_MOUNTPOINT);
	#endif
	vp->v_mountedhere = mp;
	VI_UNLOCK(vp);
	/* Put the new filesystem on the mount list. */
	mtx_lock(&mountlist_mtx);
	TAILQ_INSERT_TAIL(&mountlist, mp, mnt_list);
	mtx_unlock(&mountlist_mtx);
	vfs_event_signal(NULL, VQ_MOUNT, 0);
	if (VFS_ROOT(mp, LK_EXCLUSIVE, &mvp))
	panic("mount: lost mount");
	vn_seqc_write_end(vp);
	VOP_UNLOCK1(vp);
	#if __FreeBSD_version >= 1300048
	vfs_op_exit(mp);
	#endif
	vfs_unbusy(mp);
	*vpp = mvp;
	return (0);
	}

	/*
	* Like vn_rele() except if we are going to call VOP_INACTIVE() then do it
	* asynchronously using a taskq. This can avoid deadlocks caused by re-entering
	* the file system as a result of releasing the vnode. Note, file systems
	* already have to handle the race where the vnode is incremented before the
	* inactive routine is called and does its locking.
	*
	* Warning: Excessive use of this routine can lead to performance problems.
	* This is because taskqs throttle back allocation if too many are created.
	*/
	void
	vn_rele_async(vnode_t vp, taskq_t taskq)
	{
	- VERIFY(vp->v_count > 0);
	+ VERIFY(vp->v_usecount > 0);
	if (refcount_release_if_not_last(&vp->v_usecount)) {
	#if __FreeBSD_version < 1300045
	vdrop(vp);
	#endif
	return;
	}
	VERIFY(taskq_dispatch((taskq_t *)taskq,
	(task_func_t *)vrele, vp, TQ_SLEEP) != 0);
	}
	diff --git a/sys/contrib/openzfs/module/os/freebsd/zfs/abd_os.c b/sys/contrib/openzfs/module/os/freebsd/zfs/abd_os.c
	index ff4d80ef1dfd..cb37fb362f8c 100644
	--- a/sys/contrib/openzfs/module/os/freebsd/zfs/abd_os.c
	+++ b/sys/contrib/openzfs/module/os/freebsd/zfs/abd_os.c
	@@ -1,487 +1,487 @@
	/*
	* This file and its contents are supplied under the terms of the
	* Common Development and Distribution License ("CDDL"), version 1.0.
	* You may only use this file in accordance with the terms of version
	* 1.0 of the CDDL.
	*
	* A full copy of the text of the CDDL should have accompanied this
	* source. A copy of the CDDL is also available via the Internet at
	* http://www.illumos.org/license/CDDL.
	*/

	/*
	* Copyright (c) 2014 by Chunwei Chen. All rights reserved.
	* Copyright (c) 2016 by Delphix. All rights reserved.
	*/

	/*
	* See abd.c for a general overview of the arc buffered data (ABD).
	*
	* Using a large proportion of scattered ABDs decreases ARC fragmentation since
	* when we are at the limit of allocatable space, using equal-size chunks will
	* allow us to quickly reclaim enough space for a new large allocation (assuming
	* it is also scattered).
	*
	* ABDs are allocated scattered by default unless the caller uses
	* abd_alloc_linear() or zfs_abd_scatter_enabled is disabled.
	*/

	#include <sys/abd_impl.h>
	#include <sys/param.h>
	#include <sys/types.h>
	#include <sys/zio.h>
	#include <sys/zfs_context.h>
	#include <sys/zfs_znode.h>

	typedef struct abd_stats {
	kstat_named_t abdstat_struct_size;
	kstat_named_t abdstat_scatter_cnt;
	kstat_named_t abdstat_scatter_data_size;
	kstat_named_t abdstat_scatter_chunk_waste;
	kstat_named_t abdstat_linear_cnt;
	kstat_named_t abdstat_linear_data_size;
	} abd_stats_t;

	static abd_stats_t abd_stats = {
	/* Amount of memory occupied by all of the abd_t struct allocations */
	{ "struct_size", KSTAT_DATA_UINT64 },
	/*
	* The number of scatter ABDs which are currently allocated, excluding
	* ABDs which don't own their data (for instance the ones which were
	* allocated through abd_get_offset()).
	*/
	{ "scatter_cnt", KSTAT_DATA_UINT64 },
	/* Amount of data stored in all scatter ABDs tracked by scatter_cnt */
	{ "scatter_data_size", KSTAT_DATA_UINT64 },
	/*
	* The amount of space wasted at the end of the last chunk across all
	* scatter ABDs tracked by scatter_cnt.
	*/
	{ "scatter_chunk_waste", KSTAT_DATA_UINT64 },
	/*
	* The number of linear ABDs which are currently allocated, excluding
	* ABDs which don't own their data (for instance the ones which were
	* allocated through abd_get_offset() and abd_get_from_buf()). If an
	* ABD takes ownership of its buf then it will become tracked.
	*/
	{ "linear_cnt", KSTAT_DATA_UINT64 },
	/* Amount of data stored in all linear ABDs tracked by linear_cnt */
	{ "linear_data_size", KSTAT_DATA_UINT64 },
	};

	/*
	* The size of the chunks ABD allocates. Because the sizes allocated from the
	* kmem_cache can't change, this tunable can only be modified at boot. Changing
	* it at runtime would cause ABD iteration to work incorrectly for ABDs which
	* were allocated with the old size, so a safeguard has been put in place which
	* will cause the machine to panic if you change it and try to access the data
	* within a scattered ABD.
	*/
	size_t zfs_abd_chunk_size = 4096;

	#if defined(_KERNEL)
	SYSCTL_DECL(_vfs_zfs);

	SYSCTL_INT(_vfs_zfs, OID_AUTO, abd_scatter_enabled, CTLFLAG_RWTUN,
	&zfs_abd_scatter_enabled, 0, "Enable scattered ARC data buffers");
	SYSCTL_ULONG(_vfs_zfs, OID_AUTO, abd_chunk_size, CTLFLAG_RDTUN,
	&zfs_abd_chunk_size, 0, "The size of the chunks ABD allocates");
	#endif

	kmem_cache_t *abd_chunk_cache;
	static kstat_t *abd_ksp;

	/*
	* We use a scattered SPA_MAXBLOCKSIZE sized ABD whose chunks are
	* just a single zero'd sized zfs_abd_chunk_size buffer. This
	* allows us to conserve memory by only using a single zero buffer
	* for the scatter chunks.
	*/
	abd_t *abd_zero_scatter = NULL;
	static char *abd_zero_buf = NULL;

	static void
	abd_free_chunk(void *c)
	{
	kmem_cache_free(abd_chunk_cache, c);
	}

	static uint_t
	abd_chunkcnt_for_bytes(size_t size)
	{
	return (P2ROUNDUP(size, zfs_abd_chunk_size) / zfs_abd_chunk_size);
	}

	static inline uint_t
	abd_scatter_chunkcnt(abd_t *abd)
	{
	ASSERT(!abd_is_linear(abd));
	return (abd_chunkcnt_for_bytes(
	ABD_SCATTER(abd).abd_offset + abd->abd_size));
	}

	boolean_t
	abd_size_alloc_linear(size_t size)
	{
	return (size <= zfs_abd_chunk_size ? B_TRUE : B_FALSE);
	}

	void
	abd_update_scatter_stats(abd_t *abd, abd_stats_op_t op)
	{
	uint_t n = abd_scatter_chunkcnt(abd);
	ASSERT(op == ABDSTAT_INCR \|\| op == ABDSTAT_DECR);
	int waste = n * zfs_abd_chunk_size - abd->abd_size;
	if (op == ABDSTAT_INCR) {
	ABDSTAT_BUMP(abdstat_scatter_cnt);
	ABDSTAT_INCR(abdstat_scatter_data_size, abd->abd_size);
	ABDSTAT_INCR(abdstat_scatter_chunk_waste, waste);
	arc_space_consume(waste, ARC_SPACE_ABD_CHUNK_WASTE);
	} else {
	ABDSTAT_BUMPDOWN(abdstat_scatter_cnt);
	ABDSTAT_INCR(abdstat_scatter_data_size, -(int)abd->abd_size);
	ABDSTAT_INCR(abdstat_scatter_chunk_waste, -waste);
	arc_space_return(waste, ARC_SPACE_ABD_CHUNK_WASTE);
	}
	}

	void
	abd_update_linear_stats(abd_t *abd, abd_stats_op_t op)
	{
	ASSERT(op == ABDSTAT_INCR \|\| op == ABDSTAT_DECR);
	if (op == ABDSTAT_INCR) {
	ABDSTAT_BUMP(abdstat_linear_cnt);
	ABDSTAT_INCR(abdstat_linear_data_size, abd->abd_size);
	} else {
	ABDSTAT_BUMPDOWN(abdstat_linear_cnt);
	ABDSTAT_INCR(abdstat_linear_data_size, -(int)abd->abd_size);
	}
	}

	void
	abd_verify_scatter(abd_t *abd)
	{
	uint_t i, n;

	/*
	* There is no scatter linear pages in FreeBSD so there is an
	* if an error if the ABD has been marked as a linear page.
	*/
	ASSERT(!abd_is_linear_page(abd));
	ASSERT3U(ABD_SCATTER(abd).abd_offset, <,
	zfs_abd_chunk_size);
	n = abd_scatter_chunkcnt(abd);
	for (i = 0; i < n; i++) {
	ASSERT3P(ABD_SCATTER(abd).abd_chunks[i], !=, NULL);
	}
	}

	void
	abd_alloc_chunks(abd_t *abd, size_t size)
	{
	uint_t i, n;

	n = abd_chunkcnt_for_bytes(size);
	for (i = 0; i < n; i++) {
	void *c = kmem_cache_alloc(abd_chunk_cache, KM_PUSHPAGE);
	ASSERT3P(c, !=, NULL);
	ABD_SCATTER(abd).abd_chunks[i] = c;
	}
	ABD_SCATTER(abd).abd_chunk_size = zfs_abd_chunk_size;
	}

	void
	abd_free_chunks(abd_t *abd)
	{
	uint_t i, n;

	n = abd_scatter_chunkcnt(abd);
	for (i = 0; i < n; i++) {
	abd_free_chunk(ABD_SCATTER(abd).abd_chunks[i]);
	}
	}

	abd_t *
	abd_alloc_struct_impl(size_t size)
	{
	uint_t chunkcnt = abd_chunkcnt_for_bytes(size);
	/*
	* In the event we are allocating a gang ABD, the size passed in
	* will be 0. We must make sure to set abd_size to the size of an
	* ABD struct as opposed to an ABD scatter with 0 chunks. The gang
	* ABD struct allocation accounts for an additional 24 bytes over
	* a scatter ABD with 0 chunks.
	*/
	size_t abd_size = MAX(sizeof (abd_t),
	offsetof(abd_t, abd_u.abd_scatter.abd_chunks[chunkcnt]));
	abd_t *abd = kmem_alloc(abd_size, KM_PUSHPAGE);
	ASSERT3P(abd, !=, NULL);
	ABDSTAT_INCR(abdstat_struct_size, abd_size);

	return (abd);
	}

	void
	abd_free_struct_impl(abd_t *abd)
	{
	uint_t chunkcnt = abd_is_linear(abd) \|\| abd_is_gang(abd) ? 0 :
	abd_scatter_chunkcnt(abd);
	ssize_t size = MAX(sizeof (abd_t),
	offsetof(abd_t, abd_u.abd_scatter.abd_chunks[chunkcnt]));
	kmem_free(abd, size);
	ABDSTAT_INCR(abdstat_struct_size, -size);
	}

	/*
	* Allocate scatter ABD of size SPA_MAXBLOCKSIZE, where
	* each chunk in the scatterlist will be set to abd_zero_buf.
	*/
	static void
	abd_alloc_zero_scatter(void)
	{
	uint_t i, n;

	n = abd_chunkcnt_for_bytes(SPA_MAXBLOCKSIZE);
	abd_zero_buf = kmem_zalloc(zfs_abd_chunk_size, KM_SLEEP);
	abd_zero_scatter = abd_alloc_struct(SPA_MAXBLOCKSIZE);

	abd_zero_scatter->abd_flags \|= ABD_FLAG_OWNER \| ABD_FLAG_ZEROS;
	abd_zero_scatter->abd_size = SPA_MAXBLOCKSIZE;

	ABD_SCATTER(abd_zero_scatter).abd_offset = 0;
	ABD_SCATTER(abd_zero_scatter).abd_chunk_size =
	zfs_abd_chunk_size;

	for (i = 0; i < n; i++) {
	ABD_SCATTER(abd_zero_scatter).abd_chunks[i] =
	abd_zero_buf;
	}

	ABDSTAT_BUMP(abdstat_scatter_cnt);
	ABDSTAT_INCR(abdstat_scatter_data_size, zfs_abd_chunk_size);
	}

	static void
	abd_free_zero_scatter(void)
	{
	ABDSTAT_BUMPDOWN(abdstat_scatter_cnt);
	ABDSTAT_INCR(abdstat_scatter_data_size, -(int)zfs_abd_chunk_size);

	abd_free_struct(abd_zero_scatter);
	abd_zero_scatter = NULL;
	kmem_free(abd_zero_buf, zfs_abd_chunk_size);
	}

	void
	abd_init(void)
	{
	abd_chunk_cache = kmem_cache_create("abd_chunk", zfs_abd_chunk_size, 0,
	NULL, NULL, NULL, NULL, 0, KMC_NODEBUG);

	abd_ksp = kstat_create("zfs", 0, "abdstats", "misc", KSTAT_TYPE_NAMED,
	sizeof (abd_stats) / sizeof (kstat_named_t), KSTAT_FLAG_VIRTUAL);
	if (abd_ksp != NULL) {
	abd_ksp->ks_data = &abd_stats;
	kstat_install(abd_ksp);
	}

	abd_alloc_zero_scatter();
	}

	void
	abd_fini(void)
	{
	abd_free_zero_scatter();

	if (abd_ksp != NULL) {
	kstat_delete(abd_ksp);
	abd_ksp = NULL;
	}

	kmem_cache_destroy(abd_chunk_cache);
	abd_chunk_cache = NULL;
	}

	void
	abd_free_linear_page(abd_t *abd)
	{
	/*
	- * FreeBSD does not have have scatter linear pages
	+ * FreeBSD does not have scatter linear pages
	* so there is an error.
	*/
	VERIFY(0);
	}

	/*
	* If we're going to use this ABD for doing I/O using the block layer, the
	* consumer of the ABD data doesn't care if it's scattered or not, and we don't
	* plan to store this ABD in memory for a long period of time, we should
	* allocate the ABD type that requires the least data copying to do the I/O.
	*
	* Currently this is linear ABDs, however if ldi_strategy() can ever issue I/Os
	* using a scatter/gather list we should switch to that and replace this call
	* with vanilla abd_alloc().
	*/
	abd_t *
	abd_alloc_for_io(size_t size, boolean_t is_metadata)
	{
	return (abd_alloc_linear(size, is_metadata));
	}

	abd_t *
	abd_get_offset_scatter(abd_t abd, abd_t sabd, size_t off)
	{
	abd_verify(sabd);
	ASSERT3U(off, <=, sabd->abd_size);

	size_t new_offset = ABD_SCATTER(sabd).abd_offset + off;
	uint_t chunkcnt = abd_scatter_chunkcnt(sabd) -
	(new_offset / zfs_abd_chunk_size);

	/*
	* If an abd struct is provided, it is only the minimum size. If we
	* need additional chunks, we need to allocate a new struct.
	*/
	if (abd != NULL &&
	offsetof(abd_t, abd_u.abd_scatter.abd_chunks[chunkcnt]) >
	sizeof (abd_t)) {
	abd = NULL;
	}

	if (abd == NULL)
	abd = abd_alloc_struct(chunkcnt * zfs_abd_chunk_size);

	/*
	* Even if this buf is filesystem metadata, we only track that
	* if we own the underlying data buffer, which is not true in
	* this case. Therefore, we don't ever use ABD_FLAG_META here.
	*/

	ABD_SCATTER(abd).abd_offset = new_offset % zfs_abd_chunk_size;
	ABD_SCATTER(abd).abd_chunk_size = zfs_abd_chunk_size;

	/* Copy the scatterlist starting at the correct offset */
	(void) memcpy(&ABD_SCATTER(abd).abd_chunks,
	&ABD_SCATTER(sabd).abd_chunks[new_offset /
	zfs_abd_chunk_size],
	chunkcnt * sizeof (void *));

	return (abd);
	}

	static inline size_t
	abd_iter_scatter_chunk_offset(struct abd_iter *aiter)
	{
	ASSERT(!abd_is_linear(aiter->iter_abd));
	return ((ABD_SCATTER(aiter->iter_abd).abd_offset +
	aiter->iter_pos) % zfs_abd_chunk_size);
	}

	static inline size_t
	abd_iter_scatter_chunk_index(struct abd_iter *aiter)
	{
	ASSERT(!abd_is_linear(aiter->iter_abd));
	return ((ABD_SCATTER(aiter->iter_abd).abd_offset +
	aiter->iter_pos) / zfs_abd_chunk_size);
	}

	/*
	* Initialize the abd_iter.
	*/
	void
	abd_iter_init(struct abd_iter aiter, abd_t abd)
	{
	ASSERT(!abd_is_gang(abd));
	abd_verify(abd);
	aiter->iter_abd = abd;
	aiter->iter_pos = 0;
	aiter->iter_mapaddr = NULL;
	aiter->iter_mapsize = 0;
	}

	/*
	* This is just a helper function to see if we have exhausted the
	* abd_iter and reached the end.
	*/
	boolean_t
	abd_iter_at_end(struct abd_iter *aiter)
	{
	return (aiter->iter_pos == aiter->iter_abd->abd_size);
	}

	/*
	* Advance the iterator by a certain amount. Cannot be called when a chunk is
	* in use. This can be safely called when the aiter has already exhausted, in
	* which case this does nothing.
	*/
	void
	abd_iter_advance(struct abd_iter *aiter, size_t amount)
	{
	ASSERT3P(aiter->iter_mapaddr, ==, NULL);
	ASSERT0(aiter->iter_mapsize);

	/* There's nothing left to advance to, so do nothing */
	if (abd_iter_at_end(aiter))
	return;

	aiter->iter_pos += amount;
	}

	/*
	* Map the current chunk into aiter. This can be safely called when the aiter
	* has already exhausted, in which case this does nothing.
	*/
	void
	abd_iter_map(struct abd_iter *aiter)
	{
	void *paddr;
	size_t offset = 0;

	ASSERT3P(aiter->iter_mapaddr, ==, NULL);
	ASSERT0(aiter->iter_mapsize);

	/* Panic if someone has changed zfs_abd_chunk_size */
	IMPLY(!abd_is_linear(aiter->iter_abd), zfs_abd_chunk_size ==
	ABD_SCATTER(aiter->iter_abd).abd_chunk_size);

	/* There's nothing left to iterate over, so do nothing */
	if (abd_iter_at_end(aiter))
	return;

	if (abd_is_linear(aiter->iter_abd)) {
	offset = aiter->iter_pos;
	aiter->iter_mapsize = aiter->iter_abd->abd_size - offset;
	paddr = ABD_LINEAR_BUF(aiter->iter_abd);
	} else {
	size_t index = abd_iter_scatter_chunk_index(aiter);
	offset = abd_iter_scatter_chunk_offset(aiter);
	aiter->iter_mapsize = MIN(zfs_abd_chunk_size - offset,
	aiter->iter_abd->abd_size - aiter->iter_pos);
	paddr = ABD_SCATTER(aiter->iter_abd).abd_chunks[index];
	}
	aiter->iter_mapaddr = (char *)paddr + offset;
	}

	/*
	* Unmap the current chunk from aiter. This can be safely called when the aiter
	* has already exhausted, in which case this does nothing.
	*/
	void
	abd_iter_unmap(struct abd_iter *aiter)
	{
	/* There's nothing left to unmap, so do nothing */
	if (abd_iter_at_end(aiter))
	return;

	ASSERT3P(aiter->iter_mapaddr, !=, NULL);
	ASSERT3U(aiter->iter_mapsize, >, 0);

	aiter->iter_mapaddr = NULL;
	aiter->iter_mapsize = 0;
	}

	void
	abd_cache_reap_now(void)
	{
	kmem_cache_reap_soon(abd_chunk_cache);
	}
	diff --git a/sys/contrib/openzfs/module/os/freebsd/zfs/arc_os.c b/sys/contrib/openzfs/module/os/freebsd/zfs/arc_os.c
	index e73efd810e53..05377bb7ed98 100644
	--- a/sys/contrib/openzfs/module/os/freebsd/zfs/arc_os.c
	+++ b/sys/contrib/openzfs/module/os/freebsd/zfs/arc_os.c
	@@ -1,279 +1,273 @@
	/*
	* 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
	*/

	#include <sys/spa.h>
	#include <sys/zio.h>
	#include <sys/spa_impl.h>
	#include <sys/counter.h>
	#include <sys/zio_compress.h>
	#include <sys/zio_checksum.h>
	#include <sys/zfs_context.h>
	#include <sys/arc.h>
	#include <sys/zfs_refcount.h>
	#include <sys/vdev.h>
	#include <sys/vdev_trim.h>
	#include <sys/vdev_impl.h>
	#include <sys/dsl_pool.h>
	#include <sys/zio_checksum.h>
	#include <sys/multilist.h>
	#include <sys/abd.h>
	#include <sys/zil.h>
	#include <sys/fm/fs/zfs.h>
	#include <sys/eventhandler.h>
	#include <sys/callb.h>
	#include <sys/kstat.h>
	#include <sys/zthr.h>
	#include <zfs_fletcher.h>
	#include <sys/arc_impl.h>
	#include <sys/sdt.h>
	#include <sys/aggsum.h>
	#include <sys/vnode.h>
	#include <cityhash.h>
	#include <machine/vmparam.h>
	#include <sys/vm.h>
	#include <sys/vmmeter.h>

	#if __FreeBSD_version >= 1300139
	static struct sx arc_vnlru_lock;
	static struct vnode *arc_vnlru_marker;
	#endif

	extern struct vfsops zfs_vfsops;

	uint_t zfs_arc_free_target = 0;

	static void
	arc_free_target_init(void *unused __unused)
	{
	zfs_arc_free_target = vm_cnt.v_free_target;
	}
	SYSINIT(arc_free_target_init, SI_SUB_KTHREAD_PAGE, SI_ORDER_ANY,
	arc_free_target_init, NULL);

	/*
	* We don't have a tunable for arc_free_target due to the dependency on
	* pagedaemon initialisation.
	*/
	static int
	sysctl_vfs_zfs_arc_free_target(SYSCTL_HANDLER_ARGS)
	{
	uint_t val;
	int err;

	val = zfs_arc_free_target;
	err = sysctl_handle_int(oidp, &val, 0, req);
	if (err != 0 \|\| req->newptr == NULL)
	return (err);

	if (val < minfree)
	return (EINVAL);
	if (val > vm_cnt.v_page_count)
	return (EINVAL);

	zfs_arc_free_target = val;

	return (0);
	}
	SYSCTL_DECL(_vfs_zfs);
	/* BEGIN CSTYLED */
	SYSCTL_PROC(_vfs_zfs, OID_AUTO, arc_free_target,
	CTLTYPE_UINT \| CTLFLAG_MPSAFE \| CTLFLAG_RW, 0, sizeof (uint_t),
	sysctl_vfs_zfs_arc_free_target, "IU",
	"Desired number of free pages below which ARC triggers reclaim");
	/* END CSTYLED */

	int64_t
	arc_available_memory(void)
	{
	int64_t lowest = INT64_MAX;
	int64_t n __unused;

	/*
	* Cooperate with pagedaemon when it's time for it to scan
	* and reclaim some pages.
	*/
	n = PAGESIZE * ((int64_t)freemem - zfs_arc_free_target);
	if (n < lowest) {
	lowest = n;
	}
	#if defined(__i386) \|\| !defined(UMA_MD_SMALL_ALLOC)
	/*
	* If we're on an i386 platform, it's possible that we'll exhaust the
	* kernel heap space before we ever run out of available physical
	* memory. Most checks of the size of the heap_area compare against
	* tune.t_minarmem, which is the minimum available real memory that we
	* can have in the system. However, this is generally fixed at 25 pages
	* which is so low that it's useless. In this comparison, we seek to
	* calculate the total heap-size, and reclaim if more than 3/4ths of the
	* heap is allocated. (Or, in the calculation, if less than 1/4th is
	* free)
	*/
	n = uma_avail() - (long)(uma_limit() / 4);
	if (n < lowest) {
	lowest = n;
	}
	#endif

	DTRACE_PROBE1(arc__available_memory, int64_t, lowest);
	return (lowest);
	}

	/*
	* Return a default max arc size based on the amount of physical memory.
	*/
	uint64_t
	arc_default_max(uint64_t min, uint64_t allmem)
	{
	uint64_t size;

	if (allmem >= 1 << 30)
	size = allmem - (1 << 30);
	else
	size = min;
	return (MAX(allmem * 5 / 8, size));
	}

	/*
	* Helper function for arc_prune_async() it is responsible for safely
	* handling the execution of a registered arc_prune_func_t.
	*/
	static void
	arc_prune_task(void *arg)
	{
	-#ifdef __LP64__
	- int64_t nr_scan = (int64_t)arg;
	-#else
	- int64_t nr_scan = (int32_t)arg;
	-#endif
	+ int64_t nr_scan = (intptr_t)arg;

	arc_reduce_target_size(ptob(nr_scan));
	#if __FreeBSD_version >= 1300139
	sx_xlock(&arc_vnlru_lock);
	vnlru_free_vfsops(nr_scan, &zfs_vfsops, arc_vnlru_marker);
	sx_xunlock(&arc_vnlru_lock);
	#else
	vnlru_free(nr_scan, &zfs_vfsops);
	#endif
	}

	/*
	* Notify registered consumers they must drop holds on a portion of the ARC
	* buffered they reference. This provides a mechanism to ensure the ARC can
	* honor the arc_meta_limit and reclaim otherwise pinned ARC buffers. This
	* is analogous to dnlc_reduce_cache() but more generic.
	*
	* This operation is performed asynchronously so it may be safely called
	* in the context of the arc_reclaim_thread(). A reference is taken here
	* for each registered arc_prune_t and the arc_prune_task() is responsible
	* for releasing it once the registered arc_prune_func_t has completed.
	*/
	void
	arc_prune_async(int64_t adjust)
	{
	- int64_t *adjustptr;

	#ifndef __LP64__
	- if (adjust > __LONG_MAX)
	- adjust = __LONG_MAX;
	+ if (adjust > INTPTR_MAX)
	+ adjust = INTPTR_MAX;
	#endif
	-
	- adjustptr = (void *)adjust;
	- taskq_dispatch(arc_prune_taskq, arc_prune_task, adjustptr, TQ_SLEEP);
	+ taskq_dispatch(arc_prune_taskq, arc_prune_task,
	+ (void *)(intptr_t)adjust, TQ_SLEEP);
	ARCSTAT_BUMP(arcstat_prune);
	}

	uint64_t
	arc_all_memory(void)
	{
	return (ptob(physmem));
	}

	int
	arc_memory_throttle(spa_t *spa, uint64_t reserve, uint64_t txg)
	{
	return (0);
	}

	uint64_t
	arc_free_memory(void)
	{
	return (ptob(freemem));
	}

	static eventhandler_tag arc_event_lowmem = NULL;

	static void
	arc_lowmem(void *arg __unused, int howto __unused)
	{
	int64_t free_memory, to_free;

	arc_no_grow = B_TRUE;
	arc_warm = B_TRUE;
	arc_growtime = gethrtime() + SEC2NSEC(arc_grow_retry);
	free_memory = arc_available_memory();
	to_free = (arc_c >> arc_shrink_shift) - MIN(free_memory, 0);
	DTRACE_PROBE2(arc__needfree, int64_t, free_memory, int64_t, to_free);
	arc_reduce_target_size(to_free);

	/*
	* It is unsafe to block here in arbitrary threads, because we can come
	* here from ARC itself and may hold ARC locks and thus risk a deadlock
	* with ARC reclaim thread.
	*/
	if (curproc == pageproc)
	arc_wait_for_eviction(to_free);
	else
	arc_wait_for_eviction(0);
	}

	void
	arc_lowmem_init(void)
	{
	arc_event_lowmem = EVENTHANDLER_REGISTER(vm_lowmem, arc_lowmem, NULL,
	EVENTHANDLER_PRI_FIRST);
	#if __FreeBSD_version >= 1300139
	arc_vnlru_marker = vnlru_alloc_marker();
	sx_init(&arc_vnlru_lock, "arc vnlru lock");
	#endif
	}

	void
	arc_lowmem_fini(void)
	{
	if (arc_event_lowmem != NULL)
	EVENTHANDLER_DEREGISTER(vm_lowmem, arc_event_lowmem);
	#if __FreeBSD_version >= 1300139
	if (arc_vnlru_marker != NULL) {
	vnlru_free_marker(arc_vnlru_marker);
	sx_destroy(&arc_vnlru_lock);
	}
	#endif
	}

	void
	arc_register_hotplug(void)
	{
	}

	void
	arc_unregister_hotplug(void)
	{
	}
	diff --git a/sys/contrib/openzfs/module/os/freebsd/zfs/crypto_os.c b/sys/contrib/openzfs/module/os/freebsd/zfs/crypto_os.c
	index 03d14ed7cf5c..6a67dbc9f616 100644
	--- a/sys/contrib/openzfs/module/os/freebsd/zfs/crypto_os.c
	+++ b/sys/contrib/openzfs/module/os/freebsd/zfs/crypto_os.c
	@@ -1,622 +1,624 @@
	/*
	* Copyright (c) 2005-2010 Pawel Jakub Dawidek <pjd@FreeBSD.org>
	* Copyright (c) 2018 Sean Eric Fagan <sef@ixsystems.com>
	* 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.
	*
	* Portions of this file are derived from sys/geom/eli/g_eli_hmac.c
	*/

	#include <sys/cdefs.h>
	__FBSDID("$FreeBSD$");

	#include <sys/types.h>
	#include <sys/errno.h>

	#ifdef _KERNEL
	#include <sys/libkern.h>
	#include <sys/malloc.h>
	#include <sys/sysctl.h>
	#include <opencrypto/cryptodev.h>
	#include <opencrypto/xform.h>
	#else
	#include <strings.h>
	#endif

	#include <sys/zio_crypt.h>
	#include <sys/fs/zfs.h>
	#include <sys/zio.h>

	#include <sys/freebsd_crypto.h>

	#define SHA512_HMAC_BLOCK_SIZE 128

	static int crypt_sessions = 0;
	SYSCTL_DECL(_vfs_zfs);
	SYSCTL_INT(_vfs_zfs, OID_AUTO, crypt_sessions, CTLFLAG_RD,
	&crypt_sessions, 0, "Number of cryptographic sessions created");

	void
	crypto_mac_init(struct hmac_ctx ctx, const crypto_key_t c_key)
	{
	uint8_t k_ipad[SHA512_HMAC_BLOCK_SIZE],
	k_opad[SHA512_HMAC_BLOCK_SIZE],
	key[SHA512_HMAC_BLOCK_SIZE];
	SHA512_CTX lctx;
	int i;
	size_t cl_bytes = CRYPTO_BITS2BYTES(c_key->ck_length);

	/*
	* This code is based on the similar code in geom/eli/g_eli_hmac.c
	*/
	explicit_bzero(key, sizeof (key));
	if (c_key->ck_length == 0)
	/* do nothing */;
	else if (cl_bytes <= SHA512_HMAC_BLOCK_SIZE)
	bcopy(c_key->ck_data, key, cl_bytes);
	else {
	/*
	* If key is longer than 128 bytes reset it to
	* key = SHA512(key).
	*/
	SHA512_Init(&lctx);
	SHA512_Update(&lctx, c_key->ck_data, cl_bytes);
	SHA512_Final(key, &lctx);
	}

	/* XOR key with ipad and opad values. */
	for (i = 0; i < sizeof (key); i++) {
	k_ipad[i] = key[i] ^ 0x36;
	k_opad[i] = key[i] ^ 0x5c;
	}
	explicit_bzero(key, sizeof (key));

	/* Start inner SHA512. */
	SHA512_Init(&ctx->innerctx);
	SHA512_Update(&ctx->innerctx, k_ipad, sizeof (k_ipad));
	explicit_bzero(k_ipad, sizeof (k_ipad));
	/* Start outer SHA512. */
	SHA512_Init(&ctx->outerctx);
	SHA512_Update(&ctx->outerctx, k_opad, sizeof (k_opad));
	explicit_bzero(k_opad, sizeof (k_opad));
	}

	void
	crypto_mac_update(struct hmac_ctx ctx, const void data, size_t datasize)
	{
	SHA512_Update(&ctx->innerctx, data, datasize);
	}

	void
	crypto_mac_final(struct hmac_ctx ctx, void md, size_t mdsize)
	{
	uint8_t digest[SHA512_DIGEST_LENGTH];

	/* Complete inner hash */
	SHA512_Final(digest, &ctx->innerctx);

	/* Complete outer hash */
	SHA512_Update(&ctx->outerctx, digest, sizeof (digest));
	SHA512_Final(digest, &ctx->outerctx);

	explicit_bzero(ctx, sizeof (*ctx));
	/* mdsize == 0 means "Give me the whole hash!" */
	if (mdsize == 0)
	mdsize = SHA512_DIGEST_LENGTH;
	bcopy(digest, md, mdsize);
	explicit_bzero(digest, sizeof (digest));
	}

	void
	crypto_mac(const crypto_key_t key, const void in_data, size_t in_data_size,
	void *out_data, size_t out_data_size)
	{
	struct hmac_ctx ctx;

	crypto_mac_init(&ctx, key);
	crypto_mac_update(&ctx, in_data, in_data_size);
	crypto_mac_final(&ctx, out_data, out_data_size);
	}

	static int
	freebsd_zfs_crypt_done(struct cryptop *crp)
	{
	freebsd_crypt_session_t *ses;

	ses = crp->crp_opaque;
	mtx_lock(&ses->fs_lock);
	ses->fs_done = true;
	mtx_unlock(&ses->fs_lock);
	wakeup(crp);
	return (0);
	}

	void
	freebsd_crypt_freesession(freebsd_crypt_session_t *sess)
	{
	mtx_destroy(&sess->fs_lock);
	crypto_freesession(sess->fs_sid);
	explicit_bzero(sess, sizeof (*sess));
	}

	static int
	zfs_crypto_dispatch(freebsd_crypt_session_t session, struct cryptop crp)
	{
	int error;

	crp->crp_opaque = session;
	crp->crp_callback = freebsd_zfs_crypt_done;
	for (;;) {
	error = crypto_dispatch(crp);
	if (error)
	break;
	mtx_lock(&session->fs_lock);
	while (session->fs_done == false)
	- msleep(crp, &session->fs_lock, PRIBIO,
	- "zfs_crypto", hz/5);
	+ msleep(crp, &session->fs_lock, 0,
	+ "zfs_crypto", 0);
	mtx_unlock(&session->fs_lock);

	- if (crp->crp_etype != EAGAIN) {
	+ if (crp->crp_etype == ENOMEM) {
	+ pause("zcrnomem", 1);
	+ } else if (crp->crp_etype != EAGAIN) {
	error = crp->crp_etype;
	break;
	}
	crp->crp_etype = 0;
	crp->crp_flags &= ~CRYPTO_F_DONE;
	session->fs_done = false;
	#if __FreeBSD_version < 1300087
	/*
	* Session ID changed, so we should record that,
	* and try again
	*/
	session->fs_sid = crp->crp_session;
	#endif
	}
	return (error);
	}
	static void
	freebsd_crypt_uio_debug_log(boolean_t encrypt,
	freebsd_crypt_session_t *input_sessionp,
	struct zio_crypt_info *c_info,
	zfs_uio_t *data_uio,
	crypto_key_t *key,
	uint8_t *ivbuf,
	size_t datalen,
	size_t auth_len)
	{
	#ifdef FCRYPTO_DEBUG
	struct cryptodesc *crd;
	uint8_t *p = NULL;
	size_t total = 0;

	printf("%s(%s, %p, { %s, %d, %d, %s }, %p, { %d, %p, %u }, "
	"%p, %u, %u)\n",
	__FUNCTION__, encrypt ? "encrypt" : "decrypt", input_sessionp,
	c_info->ci_algname, c_info->ci_crypt_type,
	(unsigned int)c_info->ci_keylen, c_info->ci_name,
	data_uio, key->ck_format, key->ck_data,
	(unsigned int)key->ck_length,
	ivbuf, (unsigned int)datalen, (unsigned int)auth_len);
	printf("\tkey = { ");
	for (int i = 0; i < key->ck_length / 8; i++) {
	uint8_t b = (uint8_t )key->ck_data;
	printf("%02x ", b[i]);
	}
	printf("}\n");
	for (int i = 0; i < zfs_uio_iovcnt(data_uio); i++) {
	printf("\tiovec #%d: <%p, %u>\n", i,
	zfs_uio_iovbase(data_uio, i),
	(unsigned int)zfs_uio_iovlen(data_uio, i));
	total += zfs_uio_iovlen(data_uio, i);
	}
	zfs_uio_resid(data_uio) = total;
	#endif
	}
	/*
	* Create a new cryptographic session. This should
	* happen every time the key changes (including when
	* it's first loaded).
	*/
	#if __FreeBSD_version >= 1300087
	int
	freebsd_crypt_newsession(freebsd_crypt_session_t *sessp,
	struct zio_crypt_info c_info, crypto_key_t key)
	{
	struct crypto_session_params csp;
	int error = 0;

	#ifdef FCRYPTO_DEBUG
	printf("%s(%p, { %s, %d, %d, %s }, { %d, %p, %u })\n",
	__FUNCTION__, sessp,
	c_info->ci_algname, c_info->ci_crypt_type,
	(unsigned int)c_info->ci_keylen, c_info->ci_name,
	key->ck_format, key->ck_data, (unsigned int)key->ck_length);
	printf("\tkey = { ");
	for (int i = 0; i < key->ck_length / 8; i++) {
	uint8_t b = (uint8_t )key->ck_data;
	printf("%02x ", b[i]);
	}
	printf("}\n");
	#endif
	bzero(&csp, sizeof (csp));
	csp.csp_mode = CSP_MODE_AEAD;
	csp.csp_cipher_key = key->ck_data;
	csp.csp_cipher_klen = key->ck_length / 8;
	switch (c_info->ci_crypt_type) {
	case ZC_TYPE_GCM:
	csp.csp_cipher_alg = CRYPTO_AES_NIST_GCM_16;
	csp.csp_ivlen = AES_GCM_IV_LEN;
	switch (key->ck_length/8) {
	case AES_128_GMAC_KEY_LEN:
	case AES_192_GMAC_KEY_LEN:
	case AES_256_GMAC_KEY_LEN:
	break;
	default:
	error = EINVAL;
	goto bad;
	}
	break;
	case ZC_TYPE_CCM:
	csp.csp_cipher_alg = CRYPTO_AES_CCM_16;
	csp.csp_ivlen = AES_CCM_IV_LEN;
	switch (key->ck_length/8) {
	case AES_128_CBC_MAC_KEY_LEN:
	case AES_192_CBC_MAC_KEY_LEN:
	case AES_256_CBC_MAC_KEY_LEN:
	break;
	default:
	error = EINVAL;
	goto bad;
	break;
	}
	break;
	default:
	error = ENOTSUP;
	goto bad;
	}

	/*
	* Disable the use of hardware drivers on FreeBSD 13 and later since
	* common crypto offload drivers impose constraints on AES-GCM AAD
	* lengths that make them unusable for ZFS, and we currently do not have
	* a mechanism to fall back to a software driver for requests not
	* handled by a hardware driver.
	*
	* On 12 we continue to permit the use of hardware drivers since
	* CPU-accelerated drivers such as aesni(4) register themselves as
	* hardware drivers.
	*/
	error = crypto_newsession(&sessp->fs_sid, &csp, CRYPTOCAP_F_SOFTWARE);
	mtx_init(&sessp->fs_lock, "FreeBSD Cryptographic Session Lock",
	NULL, MTX_DEF);
	crypt_sessions++;
	bad:
	#ifdef FCRYPTO_DEBUG
	if (error)
	printf("%s: returning error %d\n", __FUNCTION__, error);
	#endif
	return (error);
	}

	int
	freebsd_crypt_uio(boolean_t encrypt,
	freebsd_crypt_session_t *input_sessionp,
	struct zio_crypt_info *c_info,
	zfs_uio_t *data_uio,
	crypto_key_t *key,
	uint8_t *ivbuf,
	size_t datalen,
	size_t auth_len)
	{
	struct cryptop *crp;
	freebsd_crypt_session_t *session = NULL;
	int error = 0;
	size_t total = 0;

	freebsd_crypt_uio_debug_log(encrypt, input_sessionp, c_info, data_uio,
	key, ivbuf, datalen, auth_len);
	for (int i = 0; i < zfs_uio_iovcnt(data_uio); i++)
	total += zfs_uio_iovlen(data_uio, i);
	zfs_uio_resid(data_uio) = total;
	if (input_sessionp == NULL) {
	session = kmem_zalloc(sizeof (*session), KM_SLEEP);
	error = freebsd_crypt_newsession(session, c_info, key);
	if (error)
	goto out;
	} else
	session = input_sessionp;

	crp = crypto_getreq(session->fs_sid, M_WAITOK);
	if (encrypt) {
	crp->crp_op = CRYPTO_OP_ENCRYPT \|
	CRYPTO_OP_COMPUTE_DIGEST;
	} else {
	crp->crp_op = CRYPTO_OP_DECRYPT \|
	CRYPTO_OP_VERIFY_DIGEST;
	}
	crp->crp_flags = CRYPTO_F_CBIFSYNC \| CRYPTO_F_IV_SEPARATE;
	crypto_use_uio(crp, GET_UIO_STRUCT(data_uio));

	crp->crp_aad_start = 0;
	crp->crp_aad_length = auth_len;
	crp->crp_payload_start = auth_len;
	crp->crp_payload_length = datalen;
	crp->crp_digest_start = auth_len + datalen;

	bcopy(ivbuf, crp->crp_iv, ZIO_DATA_IV_LEN);
	error = zfs_crypto_dispatch(session, crp);
	crypto_freereq(crp);
	out:
	#ifdef FCRYPTO_DEBUG
	if (error)
	printf("%s: returning error %d\n", __FUNCTION__, error);
	#endif
	if (input_sessionp == NULL) {
	freebsd_crypt_freesession(session);
	kmem_free(session, sizeof (*session));
	}
	return (error);
	}

	#else
	int
	freebsd_crypt_newsession(freebsd_crypt_session_t *sessp,
	struct zio_crypt_info c_info, crypto_key_t key)
	{
	struct cryptoini cria, crie, *crip;
	struct enc_xform *xform;
	struct auth_hash *xauth;
	int error = 0;
	crypto_session_t sid;

	#ifdef FCRYPTO_DEBUG
	printf("%s(%p, { %s, %d, %d, %s }, { %d, %p, %u })\n",
	__FUNCTION__, sessp,
	c_info->ci_algname, c_info->ci_crypt_type,
	(unsigned int)c_info->ci_keylen, c_info->ci_name,
	key->ck_format, key->ck_data, (unsigned int)key->ck_length);
	printf("\tkey = { ");
	for (int i = 0; i < key->ck_length / 8; i++) {
	uint8_t b = (uint8_t )key->ck_data;
	printf("%02x ", b[i]);
	}
	printf("}\n");
	#endif
	switch (c_info->ci_crypt_type) {
	case ZC_TYPE_GCM:
	xform = &enc_xform_aes_nist_gcm;
	switch (key->ck_length/8) {
	case AES_128_GMAC_KEY_LEN:
	xauth = &auth_hash_nist_gmac_aes_128;
	break;
	case AES_192_GMAC_KEY_LEN:
	xauth = &auth_hash_nist_gmac_aes_192;
	break;
	case AES_256_GMAC_KEY_LEN:
	xauth = &auth_hash_nist_gmac_aes_256;
	break;
	default:
	error = EINVAL;
	goto bad;
	}
	break;
	case ZC_TYPE_CCM:
	xform = &enc_xform_ccm;
	switch (key->ck_length/8) {
	case AES_128_CBC_MAC_KEY_LEN:
	xauth = &auth_hash_ccm_cbc_mac_128;
	break;
	case AES_192_CBC_MAC_KEY_LEN:
	xauth = &auth_hash_ccm_cbc_mac_192;
	break;
	case AES_256_CBC_MAC_KEY_LEN:
	xauth = &auth_hash_ccm_cbc_mac_256;
	break;
	default:
	error = EINVAL;
	goto bad;
	break;
	}
	break;
	default:
	error = ENOTSUP;
	goto bad;
	}
	#ifdef FCRYPTO_DEBUG
	printf("%s(%d): Using crypt %s (key length %u [%u bytes]), "
	"auth %s (key length %d)\n",
	__FUNCTION__, __LINE__,
	xform->name, (unsigned int)key->ck_length,
	(unsigned int)key->ck_length/8,
	xauth->name, xauth->keysize);
	#endif

	bzero(&crie, sizeof (crie));
	bzero(&cria, sizeof (cria));

	crie.cri_alg = xform->type;
	crie.cri_key = key->ck_data;
	crie.cri_klen = key->ck_length;

	cria.cri_alg = xauth->type;
	cria.cri_key = key->ck_data;
	cria.cri_klen = key->ck_length;

	cria.cri_next = &crie;
	crie.cri_next = NULL;
	crip = &cria;
	// Everything else is bzero'd

	error = crypto_newsession(&sid, crip,
	CRYPTOCAP_F_HARDWARE \| CRYPTOCAP_F_SOFTWARE);
	if (error != 0) {
	printf("%s(%d): crypto_newsession failed with %d\n",
	__FUNCTION__, __LINE__, error);
	goto bad;
	}
	sessp->fs_sid = sid;
	mtx_init(&sessp->fs_lock, "FreeBSD Cryptographic Session Lock",
	NULL, MTX_DEF);
	crypt_sessions++;
	bad:
	return (error);
	}

	/*
	* The meat of encryption/decryption.
	* If sessp is NULL, then it will create a
	* temporary cryptographic session, and release
	* it when done.
	*/
	int
	freebsd_crypt_uio(boolean_t encrypt,
	freebsd_crypt_session_t *input_sessionp,
	struct zio_crypt_info *c_info,
	zfs_uio_t *data_uio,
	crypto_key_t *key,
	uint8_t *ivbuf,
	size_t datalen,
	size_t auth_len)
	{
	struct cryptop *crp;
	struct cryptodesc enc_desc, auth_desc;
	struct enc_xform *xform;
	struct auth_hash *xauth;
	freebsd_crypt_session_t *session = NULL;
	int error;

	freebsd_crypt_uio_debug_log(encrypt, input_sessionp, c_info, data_uio,
	key, ivbuf, datalen, auth_len);
	switch (c_info->ci_crypt_type) {
	case ZC_TYPE_GCM:
	xform = &enc_xform_aes_nist_gcm;
	switch (key->ck_length/8) {
	case AES_128_GMAC_KEY_LEN:
	xauth = &auth_hash_nist_gmac_aes_128;
	break;
	case AES_192_GMAC_KEY_LEN:
	xauth = &auth_hash_nist_gmac_aes_192;
	break;
	case AES_256_GMAC_KEY_LEN:
	xauth = &auth_hash_nist_gmac_aes_256;
	break;
	default:
	error = EINVAL;
	goto bad;
	}
	break;
	case ZC_TYPE_CCM:
	xform = &enc_xform_ccm;
	switch (key->ck_length/8) {
	case AES_128_CBC_MAC_KEY_LEN:
	xauth = &auth_hash_ccm_cbc_mac_128;
	break;
	case AES_192_CBC_MAC_KEY_LEN:
	xauth = &auth_hash_ccm_cbc_mac_192;
	break;
	case AES_256_CBC_MAC_KEY_LEN:
	xauth = &auth_hash_ccm_cbc_mac_256;
	break;
	default:
	error = EINVAL;
	goto bad;
	break;
	}
	break;
	default:
	error = ENOTSUP;
	goto bad;
	}

	#ifdef FCRYPTO_DEBUG
	printf("%s(%d): Using crypt %s (key length %u [%u bytes]), "
	"auth %s (key length %d)\n",
	__FUNCTION__, __LINE__,
	xform->name, (unsigned int)key->ck_length,
	(unsigned int)key->ck_length/8,
	xauth->name, xauth->keysize);
	#endif

	if (input_sessionp == NULL) {
	session = kmem_zalloc(sizeof (*session), KM_SLEEP);
	error = freebsd_crypt_newsession(session, c_info, key);
	if (error)
	goto out;
	} else
	session = input_sessionp;

	crp = crypto_getreq(2);
	if (crp == NULL) {
	error = ENOMEM;
	goto bad;
	}

	auth_desc = crp->crp_desc;
	enc_desc = auth_desc->crd_next;

	crp->crp_session = session->fs_sid;
	crp->crp_ilen = auth_len + datalen;
	crp->crp_buf = (void*)GET_UIO_STRUCT(data_uio);
	crp->crp_flags = CRYPTO_F_IOV \| CRYPTO_F_CBIFSYNC;

	auth_desc->crd_skip = 0;
	auth_desc->crd_len = auth_len;
	auth_desc->crd_inject = auth_len + datalen;
	auth_desc->crd_alg = xauth->type;
	#ifdef FCRYPTO_DEBUG
	printf("%s: auth: skip = %u, len = %u, inject = %u\n",
	__FUNCTION__, auth_desc->crd_skip, auth_desc->crd_len,
	auth_desc->crd_inject);
	#endif

	enc_desc->crd_skip = auth_len;
	enc_desc->crd_len = datalen;
	enc_desc->crd_inject = auth_len;
	enc_desc->crd_alg = xform->type;
	enc_desc->crd_flags = CRD_F_IV_EXPLICIT \| CRD_F_IV_PRESENT;
	bcopy(ivbuf, enc_desc->crd_iv, ZIO_DATA_IV_LEN);
	enc_desc->crd_next = NULL;

	#ifdef FCRYPTO_DEBUG
	printf("%s: enc: skip = %u, len = %u, inject = %u\n",
	__FUNCTION__, enc_desc->crd_skip, enc_desc->crd_len,
	enc_desc->crd_inject);
	#endif

	if (encrypt)
	enc_desc->crd_flags \|= CRD_F_ENCRYPT;

	error = zfs_crypto_dispatch(session, crp);
	crypto_freereq(crp);
	out:
	if (input_sessionp == NULL) {
	freebsd_crypt_freesession(session);
	kmem_free(session, sizeof (*session));
	}
	bad:
	#ifdef FCRYPTO_DEBUG
	if (error)
	printf("%s: returning error %d\n", __FUNCTION__, error);
	#endif
	return (error);
	}
	#endif
	diff --git a/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_acl.c b/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_acl.c
	index 7089d0e0e887..6921014e9b16 100644
	--- a/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_acl.c
	+++ b/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_acl.c
	@@ -1,2703 +1,2669 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2013 by Delphix. All rights reserved.
	* Copyright 2017 Nexenta Systems, Inc. All rights reserved.
	*/

	#include <sys/types.h>
	#include <sys/param.h>
	#include <sys/time.h>
	#include <sys/systm.h>
	#include <sys/sysmacros.h>
	#include <sys/resource.h>
	#include <sys/vfs.h>
	#include <sys/vnode.h>
	#include <sys/file.h>
	#include <sys/stat.h>
	#include <sys/kmem.h>
	#include <sys/cmn_err.h>
	#include <sys/errno.h>
	#include <sys/unistd.h>
	#include <sys/sdt.h>
	#include <sys/fs/zfs.h>
	#include <sys/policy.h>
	#include <sys/zfs_znode.h>
	#include <sys/zfs_fuid.h>
	#include <sys/zfs_acl.h>
	#include <sys/zfs_dir.h>
	#include <sys/zfs_quota.h>
	#include <sys/zfs_vfsops.h>
	#include <sys/dmu.h>
	#include <sys/dnode.h>
	#include <sys/zap.h>
	#include <sys/sa.h>
	#include <acl/acl_common.h>


	#define ALLOW ACE_ACCESS_ALLOWED_ACE_TYPE
	#define DENY ACE_ACCESS_DENIED_ACE_TYPE
	#define MAX_ACE_TYPE ACE_SYSTEM_ALARM_CALLBACK_OBJECT_ACE_TYPE
	#define MIN_ACE_TYPE ALLOW

	#define OWNING_GROUP (ACE_GROUP\|ACE_IDENTIFIER_GROUP)
	#define EVERYONE_ALLOW_MASK (ACE_READ_ACL\|ACE_READ_ATTRIBUTES \| \
	ACE_READ_NAMED_ATTRS\|ACE_SYNCHRONIZE)
	#define EVERYONE_DENY_MASK (ACE_WRITE_ACL\|ACE_WRITE_OWNER \| \
	ACE_WRITE_ATTRIBUTES\|ACE_WRITE_NAMED_ATTRS)
	#define OWNER_ALLOW_MASK (ACE_WRITE_ACL \| ACE_WRITE_OWNER \| \
	ACE_WRITE_ATTRIBUTES\|ACE_WRITE_NAMED_ATTRS)

	#define ZFS_CHECKED_MASKS (ACE_READ_ACL\|ACE_READ_ATTRIBUTES\|ACE_READ_DATA\| \
	ACE_READ_NAMED_ATTRS\|ACE_WRITE_DATA\|ACE_WRITE_ATTRIBUTES\| \
	ACE_WRITE_NAMED_ATTRS\|ACE_APPEND_DATA\|ACE_EXECUTE\|ACE_WRITE_OWNER\| \
	ACE_WRITE_ACL\|ACE_DELETE\|ACE_DELETE_CHILD\|ACE_SYNCHRONIZE)

	#define WRITE_MASK_DATA (ACE_WRITE_DATA\|ACE_APPEND_DATA\|ACE_WRITE_NAMED_ATTRS)
	#define WRITE_MASK_ATTRS (ACE_WRITE_ACL\|ACE_WRITE_OWNER\|ACE_WRITE_ATTRIBUTES\| \
	ACE_DELETE\|ACE_DELETE_CHILD)
	#define WRITE_MASK (WRITE_MASK_DATA\|WRITE_MASK_ATTRS)

	#define OGE_CLEAR (ACE_READ_DATA\|ACE_LIST_DIRECTORY\|ACE_WRITE_DATA\| \
	ACE_ADD_FILE\|ACE_APPEND_DATA\|ACE_ADD_SUBDIRECTORY\|ACE_EXECUTE)

	#define OKAY_MASK_BITS (ACE_READ_DATA\|ACE_LIST_DIRECTORY\|ACE_WRITE_DATA\| \
	ACE_ADD_FILE\|ACE_APPEND_DATA\|ACE_ADD_SUBDIRECTORY\|ACE_EXECUTE)

	#define ALL_INHERIT (ACE_FILE_INHERIT_ACE\|ACE_DIRECTORY_INHERIT_ACE \| \
	ACE_NO_PROPAGATE_INHERIT_ACE\|ACE_INHERIT_ONLY_ACE\|ACE_INHERITED_ACE)

	#define RESTRICTED_CLEAR (ACE_WRITE_ACL\|ACE_WRITE_OWNER)

	#define V4_ACL_WIDE_FLAGS (ZFS_ACL_AUTO_INHERIT\|ZFS_ACL_DEFAULTED\|\
	ZFS_ACL_PROTECTED)

	#define ZFS_ACL_WIDE_FLAGS (V4_ACL_WIDE_FLAGS\|ZFS_ACL_TRIVIAL\|ZFS_INHERIT_ACE\|\
	ZFS_ACL_OBJ_ACE)

	#define ALL_MODE_EXECS (S_IXUSR \| S_IXGRP \| S_IXOTH)

	static uint16_t
	zfs_ace_v0_get_type(void *acep)
	{
	return (((zfs_oldace_t *)acep)->z_type);
	}

	static uint16_t
	zfs_ace_v0_get_flags(void *acep)
	{
	return (((zfs_oldace_t *)acep)->z_flags);
	}

	static uint32_t
	zfs_ace_v0_get_mask(void *acep)
	{
	return (((zfs_oldace_t *)acep)->z_access_mask);
	}

	static uint64_t
	zfs_ace_v0_get_who(void *acep)
	{
	return (((zfs_oldace_t *)acep)->z_fuid);
	}

	static void
	zfs_ace_v0_set_type(void *acep, uint16_t type)
	{
	((zfs_oldace_t *)acep)->z_type = type;
	}

	static void
	zfs_ace_v0_set_flags(void *acep, uint16_t flags)
	{
	((zfs_oldace_t *)acep)->z_flags = flags;
	}

	static void
	zfs_ace_v0_set_mask(void *acep, uint32_t mask)
	{
	((zfs_oldace_t *)acep)->z_access_mask = mask;
	}

	static void
	zfs_ace_v0_set_who(void *acep, uint64_t who)
	{
	((zfs_oldace_t *)acep)->z_fuid = who;
	}

	/ARGSUSED/
	static size_t
	zfs_ace_v0_size(void *acep)
	{
	return (sizeof (zfs_oldace_t));
	}

	static size_t
	zfs_ace_v0_abstract_size(void)
	{
	return (sizeof (zfs_oldace_t));
	}

	static int
	zfs_ace_v0_mask_off(void)
	{
	return (offsetof(zfs_oldace_t, z_access_mask));
	}

	/ARGSUSED/
	static int
	zfs_ace_v0_data(void acep, void *datap)
	{
	*datap = NULL;
	return (0);
	}

	static acl_ops_t zfs_acl_v0_ops = {
	zfs_ace_v0_get_mask,
	zfs_ace_v0_set_mask,
	zfs_ace_v0_get_flags,
	zfs_ace_v0_set_flags,
	zfs_ace_v0_get_type,
	zfs_ace_v0_set_type,
	zfs_ace_v0_get_who,
	zfs_ace_v0_set_who,
	zfs_ace_v0_size,
	zfs_ace_v0_abstract_size,
	zfs_ace_v0_mask_off,
	zfs_ace_v0_data
	};

	static uint16_t
	zfs_ace_fuid_get_type(void *acep)
	{
	return (((zfs_ace_hdr_t *)acep)->z_type);
	}

	static uint16_t
	zfs_ace_fuid_get_flags(void *acep)
	{
	return (((zfs_ace_hdr_t *)acep)->z_flags);
	}

	static uint32_t
	zfs_ace_fuid_get_mask(void *acep)
	{
	return (((zfs_ace_hdr_t *)acep)->z_access_mask);
	}

	static uint64_t
	zfs_ace_fuid_get_who(void *args)
	{
	uint16_t entry_type;
	zfs_ace_t *acep = args;

	entry_type = acep->z_hdr.z_flags & ACE_TYPE_FLAGS;

	if (entry_type == ACE_OWNER \|\| entry_type == OWNING_GROUP \|\|
	entry_type == ACE_EVERYONE)
	return (-1);
	return (((zfs_ace_t *)acep)->z_fuid);
	}

	static void
	zfs_ace_fuid_set_type(void *acep, uint16_t type)
	{
	((zfs_ace_hdr_t *)acep)->z_type = type;
	}

	static void
	zfs_ace_fuid_set_flags(void *acep, uint16_t flags)
	{
	((zfs_ace_hdr_t *)acep)->z_flags = flags;
	}

	static void
	zfs_ace_fuid_set_mask(void *acep, uint32_t mask)
	{
	((zfs_ace_hdr_t *)acep)->z_access_mask = mask;
	}

	static void
	zfs_ace_fuid_set_who(void *arg, uint64_t who)
	{
	zfs_ace_t *acep = arg;

	uint16_t entry_type = acep->z_hdr.z_flags & ACE_TYPE_FLAGS;

	if (entry_type == ACE_OWNER \|\| entry_type == OWNING_GROUP \|\|
	entry_type == ACE_EVERYONE)
	return;
	acep->z_fuid = who;
	}

	static size_t
	zfs_ace_fuid_size(void *acep)
	{
	zfs_ace_hdr_t *zacep = acep;
	uint16_t entry_type;

	switch (zacep->z_type) {
	case ACE_ACCESS_ALLOWED_OBJECT_ACE_TYPE:
	case ACE_ACCESS_DENIED_OBJECT_ACE_TYPE:
	case ACE_SYSTEM_AUDIT_OBJECT_ACE_TYPE:
	case ACE_SYSTEM_ALARM_OBJECT_ACE_TYPE:
	return (sizeof (zfs_object_ace_t));
	case ALLOW:
	case DENY:
	entry_type =
	(((zfs_ace_hdr_t *)acep)->z_flags & ACE_TYPE_FLAGS);
	if (entry_type == ACE_OWNER \|\|
	entry_type == OWNING_GROUP \|\|
	entry_type == ACE_EVERYONE)
	return (sizeof (zfs_ace_hdr_t));
	/FALLTHROUGH/
	default:
	return (sizeof (zfs_ace_t));
	}
	}

	static size_t
	zfs_ace_fuid_abstract_size(void)
	{
	return (sizeof (zfs_ace_hdr_t));
	}

	static int
	zfs_ace_fuid_mask_off(void)
	{
	return (offsetof(zfs_ace_hdr_t, z_access_mask));
	}

	static int
	zfs_ace_fuid_data(void acep, void *datap)
	{
	zfs_ace_t *zacep = acep;
	zfs_object_ace_t *zobjp;

	switch (zacep->z_hdr.z_type) {
	case ACE_ACCESS_ALLOWED_OBJECT_ACE_TYPE:
	case ACE_ACCESS_DENIED_OBJECT_ACE_TYPE:
	case ACE_SYSTEM_AUDIT_OBJECT_ACE_TYPE:
	case ACE_SYSTEM_ALARM_OBJECT_ACE_TYPE:
	zobjp = acep;
	*datap = (caddr_t)zobjp + sizeof (zfs_ace_t);
	return (sizeof (zfs_object_ace_t) - sizeof (zfs_ace_t));
	default:
	*datap = NULL;
	return (0);
	}
	}

	static acl_ops_t zfs_acl_fuid_ops = {
	zfs_ace_fuid_get_mask,
	zfs_ace_fuid_set_mask,
	zfs_ace_fuid_get_flags,
	zfs_ace_fuid_set_flags,
	zfs_ace_fuid_get_type,
	zfs_ace_fuid_set_type,
	zfs_ace_fuid_get_who,
	zfs_ace_fuid_set_who,
	zfs_ace_fuid_size,
	zfs_ace_fuid_abstract_size,
	zfs_ace_fuid_mask_off,
	zfs_ace_fuid_data
	};

	/*
	* The following three functions are provided for compatibility with
	* older ZPL version in order to determine if the file use to have
	* an external ACL and what version of ACL previously existed on the
	* file. Would really be nice to not need this, sigh.
	*/
	uint64_t
	zfs_external_acl(znode_t *zp)
	{
	zfs_acl_phys_t acl_phys;
	int error;

	if (zp->z_is_sa)
	return (0);

	/*
	* Need to deal with a potential
	* race where zfs_sa_upgrade could cause
	* z_isa_sa to change.
	*
	* If the lookup fails then the state of z_is_sa should have
	* changed.
	*/

	if ((error = sa_lookup(zp->z_sa_hdl, SA_ZPL_ZNODE_ACL(zp->z_zfsvfs),
	&acl_phys, sizeof (acl_phys))) == 0)
	return (acl_phys.z_acl_extern_obj);
	else {
	/*
	* after upgrade the SA_ZPL_ZNODE_ACL should have been
	* removed
	*/
	VERIFY(zp->z_is_sa && error == ENOENT);
	return (0);
	}
	}

	/*
	* Determine size of ACL in bytes
	*
	* This is more complicated than it should be since we have to deal
	* with old external ACLs.
	*/
	static int
	zfs_acl_znode_info(znode_t zp, int aclsize, int *aclcount,
	zfs_acl_phys_t *aclphys)
	{
	zfsvfs_t *zfsvfs = zp->z_zfsvfs;
	uint64_t acl_count;
	int size;
	int error;

	ASSERT(MUTEX_HELD(&zp->z_acl_lock));
	if (zp->z_is_sa) {
	if ((error = sa_size(zp->z_sa_hdl, SA_ZPL_DACL_ACES(zfsvfs),
	&size)) != 0)
	return (error);
	*aclsize = size;
	if ((error = sa_lookup(zp->z_sa_hdl, SA_ZPL_DACL_COUNT(zfsvfs),
	&acl_count, sizeof (acl_count))) != 0)
	return (error);
	*aclcount = acl_count;
	} else {
	if ((error = sa_lookup(zp->z_sa_hdl, SA_ZPL_ZNODE_ACL(zfsvfs),
	aclphys, sizeof (*aclphys))) != 0)
	return (error);

	if (aclphys->z_acl_version == ZFS_ACL_VERSION_INITIAL) {
	*aclsize = ZFS_ACL_SIZE(aclphys->z_acl_size);
	*aclcount = aclphys->z_acl_size;
	} else {
	*aclsize = aclphys->z_acl_size;
	*aclcount = aclphys->z_acl_count;
	}
	}
	return (0);
	}

	int
	zfs_znode_acl_version(znode_t *zp)
	{
	zfs_acl_phys_t acl_phys;

	if (zp->z_is_sa)
	return (ZFS_ACL_VERSION_FUID);
	else {
	int error;

	/*
	* Need to deal with a potential
	* race where zfs_sa_upgrade could cause
	* z_isa_sa to change.
	*
	* If the lookup fails then the state of z_is_sa should have
	* changed.
	*/
	if ((error = sa_lookup(zp->z_sa_hdl,
	SA_ZPL_ZNODE_ACL(zp->z_zfsvfs),
	&acl_phys, sizeof (acl_phys))) == 0)
	return (acl_phys.z_acl_version);
	else {
	/*
	* After upgrade SA_ZPL_ZNODE_ACL should have
	* been removed.
	*/
	VERIFY(zp->z_is_sa && error == ENOENT);
	return (ZFS_ACL_VERSION_FUID);
	}
	}
	}

	static int
	zfs_acl_version(int version)
	{
	if (version < ZPL_VERSION_FUID)
	return (ZFS_ACL_VERSION_INITIAL);
	else
	return (ZFS_ACL_VERSION_FUID);
	}

	static int
	zfs_acl_version_zp(znode_t *zp)
	{
	return (zfs_acl_version(zp->z_zfsvfs->z_version));
	}

	zfs_acl_t *
	zfs_acl_alloc(int vers)
	{
	zfs_acl_t *aclp;

	aclp = kmem_zalloc(sizeof (zfs_acl_t), KM_SLEEP);
	list_create(&aclp->z_acl, sizeof (zfs_acl_node_t),
	offsetof(zfs_acl_node_t, z_next));
	aclp->z_version = vers;
	if (vers == ZFS_ACL_VERSION_FUID)
	aclp->z_ops = &zfs_acl_fuid_ops;
	else
	aclp->z_ops = &zfs_acl_v0_ops;
	return (aclp);
	}

	zfs_acl_node_t *
	zfs_acl_node_alloc(size_t bytes)
	{
	zfs_acl_node_t *aclnode;

	aclnode = kmem_zalloc(sizeof (zfs_acl_node_t), KM_SLEEP);
	if (bytes) {
	aclnode->z_acldata = kmem_alloc(bytes, KM_SLEEP);
	aclnode->z_allocdata = aclnode->z_acldata;
	aclnode->z_allocsize = bytes;
	aclnode->z_size = bytes;
	}

	return (aclnode);
	}

	static void
	zfs_acl_node_free(zfs_acl_node_t *aclnode)
	{
	if (aclnode->z_allocsize)
	kmem_free(aclnode->z_allocdata, aclnode->z_allocsize);
	kmem_free(aclnode, sizeof (zfs_acl_node_t));
	}

	static void
	zfs_acl_release_nodes(zfs_acl_t *aclp)
	{
	zfs_acl_node_t *aclnode;

	while ((aclnode = list_head(&aclp->z_acl))) {
	list_remove(&aclp->z_acl, aclnode);
	zfs_acl_node_free(aclnode);
	}
	aclp->z_acl_count = 0;
	aclp->z_acl_bytes = 0;
	}

	void
	zfs_acl_free(zfs_acl_t *aclp)
	{
	zfs_acl_release_nodes(aclp);
	list_destroy(&aclp->z_acl);
	kmem_free(aclp, sizeof (zfs_acl_t));
	}

	static boolean_t
	zfs_acl_valid_ace_type(uint_t type, uint_t flags)
	{
	uint16_t entry_type;

	switch (type) {
	case ALLOW:
	case DENY:
	case ACE_SYSTEM_AUDIT_ACE_TYPE:
	case ACE_SYSTEM_ALARM_ACE_TYPE:
	entry_type = flags & ACE_TYPE_FLAGS;
	return (entry_type == ACE_OWNER \|\|
	entry_type == OWNING_GROUP \|\|
	entry_type == ACE_EVERYONE \|\| entry_type == 0 \|\|
	entry_type == ACE_IDENTIFIER_GROUP);
	default:
	if (type >= MIN_ACE_TYPE && type <= MAX_ACE_TYPE)
	return (B_TRUE);
	}
	return (B_FALSE);
	}

	static boolean_t
	zfs_ace_valid(vtype_t obj_type, zfs_acl_t *aclp, uint16_t type, uint16_t iflags)
	{
	/*
	* first check type of entry
	*/

	if (!zfs_acl_valid_ace_type(type, iflags))
	return (B_FALSE);

	switch (type) {
	case ACE_ACCESS_ALLOWED_OBJECT_ACE_TYPE:
	case ACE_ACCESS_DENIED_OBJECT_ACE_TYPE:
	case ACE_SYSTEM_AUDIT_OBJECT_ACE_TYPE:
	case ACE_SYSTEM_ALARM_OBJECT_ACE_TYPE:
	if (aclp->z_version < ZFS_ACL_VERSION_FUID)
	return (B_FALSE);
	aclp->z_hints \|= ZFS_ACL_OBJ_ACE;
	}

	/*
	* next check inheritance level flags
	*/

	if (obj_type == VDIR &&
	(iflags & (ACE_FILE_INHERIT_ACE\|ACE_DIRECTORY_INHERIT_ACE)))
	aclp->z_hints \|= ZFS_INHERIT_ACE;

	if (iflags & (ACE_INHERIT_ONLY_ACE\|ACE_NO_PROPAGATE_INHERIT_ACE)) {
	if ((iflags & (ACE_FILE_INHERIT_ACE\|
	ACE_DIRECTORY_INHERIT_ACE)) == 0) {
	return (B_FALSE);
	}
	}

	return (B_TRUE);
	}

	static void *
	zfs_acl_next_ace(zfs_acl_t aclp, void start, uint64_t *who,
	uint32_t access_mask, uint16_t iflags, uint16_t *type)
	{
	zfs_acl_node_t *aclnode;

	ASSERT(aclp);

	if (start == NULL) {
	aclnode = list_head(&aclp->z_acl);
	if (aclnode == NULL)
	return (NULL);

	aclp->z_next_ace = aclnode->z_acldata;
	aclp->z_curr_node = aclnode;
	aclnode->z_ace_idx = 0;
	}

	aclnode = aclp->z_curr_node;

	if (aclnode == NULL)
	return (NULL);

	if (aclnode->z_ace_idx >= aclnode->z_ace_count) {
	aclnode = list_next(&aclp->z_acl, aclnode);
	if (aclnode == NULL)
	return (NULL);
	else {
	aclp->z_curr_node = aclnode;
	aclnode->z_ace_idx = 0;
	aclp->z_next_ace = aclnode->z_acldata;
	}
	}

	if (aclnode->z_ace_idx < aclnode->z_ace_count) {
	void *acep = aclp->z_next_ace;
	size_t ace_size;

	/*
	* Make sure we don't overstep our bounds
	*/
	ace_size = aclp->z_ops->ace_size(acep);

	if (((caddr_t)acep + ace_size) >
	((caddr_t)aclnode->z_acldata + aclnode->z_size)) {
	return (NULL);
	}

	*iflags = aclp->z_ops->ace_flags_get(acep);
	*type = aclp->z_ops->ace_type_get(acep);
	*access_mask = aclp->z_ops->ace_mask_get(acep);
	*who = aclp->z_ops->ace_who_get(acep);
	aclp->z_next_ace = (caddr_t)aclp->z_next_ace + ace_size;
	aclnode->z_ace_idx++;

	return ((void *)acep);
	}
	return (NULL);
	}

	/ARGSUSED/
	static uint64_t
	zfs_ace_walk(void *datap, uint64_t cookie, int aclcnt,
	uint16_t flags, uint16_t type, uint32_t *mask)
	{
	zfs_acl_t *aclp = datap;
	zfs_ace_hdr_t acep = (zfs_ace_hdr_t )(uintptr_t)cookie;
	uint64_t who;

	acep = zfs_acl_next_ace(aclp, acep, &who, mask,
	flags, type);
	return ((uint64_t)(uintptr_t)acep);
	}

	/*
	* Copy ACE to internal ZFS format.
	* While processing the ACL each ACE will be validated for correctness.
	* ACE FUIDs will be created later.
	*/
	static int
	zfs_copy_ace_2_fuid(zfsvfs_t zfsvfs, vtype_t obj_type, zfs_acl_t aclp,
	void datap, zfs_ace_t z_acl, uint64_t aclcnt, size_t *size,
	zfs_fuid_info_t *fuidp, cred_t cr)
	{
	int i;
	uint16_t entry_type;
	zfs_ace_t *aceptr = z_acl;
	ace_t *acep = datap;
	zfs_object_ace_t *zobjacep;
	ace_object_t *aceobjp;

	for (i = 0; i != aclcnt; i++) {
	aceptr->z_hdr.z_access_mask = acep->a_access_mask;
	aceptr->z_hdr.z_flags = acep->a_flags;
	aceptr->z_hdr.z_type = acep->a_type;
	entry_type = aceptr->z_hdr.z_flags & ACE_TYPE_FLAGS;
	if (entry_type != ACE_OWNER && entry_type != OWNING_GROUP &&
	entry_type != ACE_EVERYONE) {
	aceptr->z_fuid = zfs_fuid_create(zfsvfs, acep->a_who,
	cr, (entry_type == 0) ?
	ZFS_ACE_USER : ZFS_ACE_GROUP, fuidp);
	}

	/*
	* Make sure ACE is valid
	*/
	if (zfs_ace_valid(obj_type, aclp, aceptr->z_hdr.z_type,
	aceptr->z_hdr.z_flags) != B_TRUE)
	return (SET_ERROR(EINVAL));

	switch (acep->a_type) {
	case ACE_ACCESS_ALLOWED_OBJECT_ACE_TYPE:
	case ACE_ACCESS_DENIED_OBJECT_ACE_TYPE:
	case ACE_SYSTEM_AUDIT_OBJECT_ACE_TYPE:
	case ACE_SYSTEM_ALARM_OBJECT_ACE_TYPE:
	zobjacep = (zfs_object_ace_t *)aceptr;
	aceobjp = (ace_object_t *)acep;

	bcopy(aceobjp->a_obj_type, zobjacep->z_object_type,
	sizeof (aceobjp->a_obj_type));
	bcopy(aceobjp->a_inherit_obj_type,
	zobjacep->z_inherit_type,
	sizeof (aceobjp->a_inherit_obj_type));
	acep = (ace_t *)((caddr_t)acep + sizeof (ace_object_t));
	break;
	default:
	acep = (ace_t *)((caddr_t)acep + sizeof (ace_t));
	}

	aceptr = (zfs_ace_t *)((caddr_t)aceptr +
	aclp->z_ops->ace_size(aceptr));
	}

	*size = (caddr_t)aceptr - (caddr_t)z_acl;

	return (0);
	}

	/*
	* Copy ZFS ACEs to fixed size ace_t layout
	*/
	static void
	zfs_copy_fuid_2_ace(zfsvfs_t zfsvfs, zfs_acl_t aclp, cred_t *cr,
	void *datap, int filter)
	{
	uint64_t who;
	uint32_t access_mask;
	uint16_t iflags, type;
	zfs_ace_hdr_t *zacep = NULL;
	ace_t *acep = datap;
	ace_object_t *objacep;
	zfs_object_ace_t *zobjacep;
	size_t ace_size;
	uint16_t entry_type;

	while ((zacep = zfs_acl_next_ace(aclp, zacep,
	&who, &access_mask, &iflags, &type))) {

	switch (type) {
	case ACE_ACCESS_ALLOWED_OBJECT_ACE_TYPE:
	case ACE_ACCESS_DENIED_OBJECT_ACE_TYPE:
	case ACE_SYSTEM_AUDIT_OBJECT_ACE_TYPE:
	case ACE_SYSTEM_ALARM_OBJECT_ACE_TYPE:
	if (filter) {
	continue;
	}
	zobjacep = (zfs_object_ace_t *)zacep;
	objacep = (ace_object_t *)acep;
	bcopy(zobjacep->z_object_type,
	objacep->a_obj_type,
	sizeof (zobjacep->z_object_type));
	bcopy(zobjacep->z_inherit_type,
	objacep->a_inherit_obj_type,
	sizeof (zobjacep->z_inherit_type));
	ace_size = sizeof (ace_object_t);
	break;
	default:
	ace_size = sizeof (ace_t);
	break;
	}

	entry_type = (iflags & ACE_TYPE_FLAGS);
	if ((entry_type != ACE_OWNER &&
	entry_type != OWNING_GROUP &&
	entry_type != ACE_EVERYONE)) {
	acep->a_who = zfs_fuid_map_id(zfsvfs, who,
	cr, (entry_type & ACE_IDENTIFIER_GROUP) ?
	ZFS_ACE_GROUP : ZFS_ACE_USER);
	} else {
	acep->a_who = (uid_t)(int64_t)who;
	}
	acep->a_access_mask = access_mask;
	acep->a_flags = iflags;
	acep->a_type = type;
	acep = (ace_t *)((caddr_t)acep + ace_size);
	}
	}

	static int
	zfs_copy_ace_2_oldace(vtype_t obj_type, zfs_acl_t aclp, ace_t acep,
	zfs_oldace_t z_acl, int aclcnt, size_t size)
	{
	int i;
	zfs_oldace_t *aceptr = z_acl;

	for (i = 0; i != aclcnt; i++, aceptr++) {
	aceptr->z_access_mask = acep[i].a_access_mask;
	aceptr->z_type = acep[i].a_type;
	aceptr->z_flags = acep[i].a_flags;
	aceptr->z_fuid = acep[i].a_who;
	/*
	* Make sure ACE is valid
	*/
	if (zfs_ace_valid(obj_type, aclp, aceptr->z_type,
	aceptr->z_flags) != B_TRUE)
	return (SET_ERROR(EINVAL));
	}
	*size = (caddr_t)aceptr - (caddr_t)z_acl;
	return (0);
	}

	/*
	* convert old ACL format to new
	*/
	void
	zfs_acl_xform(znode_t zp, zfs_acl_t aclp, cred_t *cr)
	{
	zfs_oldace_t *oldaclp;
	int i;
	uint16_t type, iflags;
	uint32_t access_mask;
	uint64_t who;
	void *cookie = NULL;
	zfs_acl_node_t *newaclnode;

	ASSERT(aclp->z_version == ZFS_ACL_VERSION_INITIAL);
	/*
	* First create the ACE in a contiguous piece of memory
	* for zfs_copy_ace_2_fuid().
	*
	* We only convert an ACL once, so this won't happen
	* everytime.
	*/
	oldaclp = kmem_alloc(sizeof (zfs_oldace_t) * aclp->z_acl_count,
	KM_SLEEP);
	i = 0;
	while ((cookie = zfs_acl_next_ace(aclp, cookie, &who,
	&access_mask, &iflags, &type))) {
	oldaclp[i].z_flags = iflags;
	oldaclp[i].z_type = type;
	oldaclp[i].z_fuid = who;
	oldaclp[i++].z_access_mask = access_mask;
	}

	newaclnode = zfs_acl_node_alloc(aclp->z_acl_count *
	sizeof (zfs_object_ace_t));
	aclp->z_ops = &zfs_acl_fuid_ops;
	VERIFY(zfs_copy_ace_2_fuid(zp->z_zfsvfs, ZTOV(zp)->v_type, aclp,
	oldaclp, newaclnode->z_acldata, aclp->z_acl_count,
	&newaclnode->z_size, NULL, cr) == 0);
	newaclnode->z_ace_count = aclp->z_acl_count;
	aclp->z_version = ZFS_ACL_VERSION;
	kmem_free(oldaclp, aclp->z_acl_count * sizeof (zfs_oldace_t));

	/*
	* Release all previous ACL nodes
	*/

	zfs_acl_release_nodes(aclp);

	list_insert_head(&aclp->z_acl, newaclnode);

	aclp->z_acl_bytes = newaclnode->z_size;
	aclp->z_acl_count = newaclnode->z_ace_count;

	}

	/*
	* Convert unix access mask to v4 access mask
	*/
	static uint32_t
	zfs_unix_to_v4(uint32_t access_mask)
	{
	uint32_t new_mask = 0;

	if (access_mask & S_IXOTH)
	new_mask \|= ACE_EXECUTE;
	if (access_mask & S_IWOTH)
	new_mask \|= ACE_WRITE_DATA;
	if (access_mask & S_IROTH)
	new_mask \|= ACE_READ_DATA;
	return (new_mask);
	}

	static void
	zfs_set_ace(zfs_acl_t aclp, void acep, uint32_t access_mask,
	uint16_t access_type, uint64_t fuid, uint16_t entry_type)
	{
	uint16_t type = entry_type & ACE_TYPE_FLAGS;

	aclp->z_ops->ace_mask_set(acep, access_mask);
	aclp->z_ops->ace_type_set(acep, access_type);
	aclp->z_ops->ace_flags_set(acep, entry_type);
	if ((type != ACE_OWNER && type != OWNING_GROUP &&
	type != ACE_EVERYONE))
	aclp->z_ops->ace_who_set(acep, fuid);
	}

	/*
	* Determine mode of file based on ACL.
	*/
	uint64_t
	zfs_mode_compute(uint64_t fmode, zfs_acl_t *aclp,
	uint64_t *pflags, uint64_t fuid, uint64_t fgid)
	{
	int entry_type;
	mode_t mode;
	mode_t seen = 0;
	zfs_ace_hdr_t *acep = NULL;
	uint64_t who;
	uint16_t iflags, type;
	uint32_t access_mask;
	boolean_t an_exec_denied = B_FALSE;

	mode = (fmode & (S_IFMT \| S_ISUID \| S_ISGID \| S_ISVTX));

	while ((acep = zfs_acl_next_ace(aclp, acep, &who,
	&access_mask, &iflags, &type))) {

	if (!zfs_acl_valid_ace_type(type, iflags))
	continue;

	entry_type = (iflags & ACE_TYPE_FLAGS);

	/*
	* Skip over any inherit_only ACEs
	*/
	if (iflags & ACE_INHERIT_ONLY_ACE)
	continue;

	if (entry_type == ACE_OWNER \|\| (entry_type == 0 &&
	who == fuid)) {
	if ((access_mask & ACE_READ_DATA) &&
	(!(seen & S_IRUSR))) {
	seen \|= S_IRUSR;
	if (type == ALLOW) {
	mode \|= S_IRUSR;
	}
	}
	if ((access_mask & ACE_WRITE_DATA) &&
	(!(seen & S_IWUSR))) {
	seen \|= S_IWUSR;
	if (type == ALLOW) {
	mode \|= S_IWUSR;
	}
	}
	if ((access_mask & ACE_EXECUTE) &&
	(!(seen & S_IXUSR))) {
	seen \|= S_IXUSR;
	if (type == ALLOW) {
	mode \|= S_IXUSR;
	}
	}
	} else if (entry_type == OWNING_GROUP \|\|
	(entry_type == ACE_IDENTIFIER_GROUP && who == fgid)) {
	if ((access_mask & ACE_READ_DATA) &&
	(!(seen & S_IRGRP))) {
	seen \|= S_IRGRP;
	if (type == ALLOW) {
	mode \|= S_IRGRP;
	}
	}
	if ((access_mask & ACE_WRITE_DATA) &&
	(!(seen & S_IWGRP))) {
	seen \|= S_IWGRP;
	if (type == ALLOW) {
	mode \|= S_IWGRP;
	}
	}
	if ((access_mask & ACE_EXECUTE) &&
	(!(seen & S_IXGRP))) {
	seen \|= S_IXGRP;
	if (type == ALLOW) {
	mode \|= S_IXGRP;
	}
	}
	} else if (entry_type == ACE_EVERYONE) {
	if ((access_mask & ACE_READ_DATA)) {
	if (!(seen & S_IRUSR)) {
	seen \|= S_IRUSR;
	if (type == ALLOW) {
	mode \|= S_IRUSR;
	}
	}
	if (!(seen & S_IRGRP)) {
	seen \|= S_IRGRP;
	if (type == ALLOW) {
	mode \|= S_IRGRP;
	}
	}
	if (!(seen & S_IROTH)) {
	seen \|= S_IROTH;
	if (type == ALLOW) {
	mode \|= S_IROTH;
	}
	}
	}
	if ((access_mask & ACE_WRITE_DATA)) {
	if (!(seen & S_IWUSR)) {
	seen \|= S_IWUSR;
	if (type == ALLOW) {
	mode \|= S_IWUSR;
	}
	}
	if (!(seen & S_IWGRP)) {
	seen \|= S_IWGRP;
	if (type == ALLOW) {
	mode \|= S_IWGRP;
	}
	}
	if (!(seen & S_IWOTH)) {
	seen \|= S_IWOTH;
	if (type == ALLOW) {
	mode \|= S_IWOTH;
	}
	}
	}
	if ((access_mask & ACE_EXECUTE)) {
	if (!(seen & S_IXUSR)) {
	seen \|= S_IXUSR;
	if (type == ALLOW) {
	mode \|= S_IXUSR;
	}
	}
	if (!(seen & S_IXGRP)) {
	seen \|= S_IXGRP;
	if (type == ALLOW) {
	mode \|= S_IXGRP;
	}
	}
	if (!(seen & S_IXOTH)) {
	seen \|= S_IXOTH;
	if (type == ALLOW) {
	mode \|= S_IXOTH;
	}
	}
	}
	} else {
	/*
	* Only care if this IDENTIFIER_GROUP or
	* USER ACE denies execute access to someone,
	* mode is not affected
	*/
	if ((access_mask & ACE_EXECUTE) && type == DENY)
	an_exec_denied = B_TRUE;
	}
	}

	/*
	* Failure to allow is effectively a deny, so execute permission
	* is denied if it was never mentioned or if we explicitly
	* weren't allowed it.
	*/
	if (!an_exec_denied &&
	((seen & ALL_MODE_EXECS) != ALL_MODE_EXECS \|\|
	(mode & ALL_MODE_EXECS) != ALL_MODE_EXECS))
	an_exec_denied = B_TRUE;

	if (an_exec_denied)
	*pflags &= ~ZFS_NO_EXECS_DENIED;
	else
	*pflags \|= ZFS_NO_EXECS_DENIED;

	return (mode);
	}

	/*
	* Read an external acl object. If the intent is to modify, always
	* create a new acl and leave any cached acl in place.
	*/
	int
	zfs_acl_node_read(znode_t zp, boolean_t have_lock, zfs_acl_t *aclpp,
	boolean_t will_modify)
	{
	zfs_acl_t *aclp;
	int aclsize;
	int acl_count;
	zfs_acl_node_t *aclnode;
	zfs_acl_phys_t znode_acl;
	int version;
	int error;

	ASSERT(MUTEX_HELD(&zp->z_acl_lock));
	if (zp->z_zfsvfs->z_replay == B_FALSE)
	ASSERT_VOP_LOCKED(ZTOV(zp), __func__);

	if (zp->z_acl_cached && !will_modify) {
	*aclpp = zp->z_acl_cached;
	return (0);
	}

	version = zfs_znode_acl_version(zp);

	if ((error = zfs_acl_znode_info(zp, &aclsize,
	&acl_count, &znode_acl)) != 0) {
	goto done;
	}

	aclp = zfs_acl_alloc(version);

	aclp->z_acl_count = acl_count;
	aclp->z_acl_bytes = aclsize;

	aclnode = zfs_acl_node_alloc(aclsize);
	aclnode->z_ace_count = aclp->z_acl_count;
	aclnode->z_size = aclsize;

	if (!zp->z_is_sa) {
	if (znode_acl.z_acl_extern_obj) {
	error = dmu_read(zp->z_zfsvfs->z_os,
	znode_acl.z_acl_extern_obj, 0, aclnode->z_size,
	aclnode->z_acldata, DMU_READ_PREFETCH);
	} else {
	bcopy(znode_acl.z_ace_data, aclnode->z_acldata,
	aclnode->z_size);
	}
	} else {
	error = sa_lookup(zp->z_sa_hdl, SA_ZPL_DACL_ACES(zp->z_zfsvfs),
	aclnode->z_acldata, aclnode->z_size);
	}

	if (error != 0) {
	zfs_acl_free(aclp);
	zfs_acl_node_free(aclnode);
	/* convert checksum errors into IO errors */
	if (error == ECKSUM)
	error = SET_ERROR(EIO);
	goto done;
	}

	list_insert_head(&aclp->z_acl, aclnode);

	*aclpp = aclp;
	if (!will_modify)
	zp->z_acl_cached = aclp;
	done:
	return (error);
	}

	/ARGSUSED/
	void
	zfs_acl_data_locator(void *dataptr, uint32_t length, uint32_t buflen,
	boolean_t start, void *userdata)
	{
	zfs_acl_locator_cb_t cb = (zfs_acl_locator_cb_t )userdata;

	if (start) {
	cb->cb_acl_node = list_head(&cb->cb_aclp->z_acl);
	} else {
	cb->cb_acl_node = list_next(&cb->cb_aclp->z_acl,
	cb->cb_acl_node);
	}
	*dataptr = cb->cb_acl_node->z_acldata;
	*length = cb->cb_acl_node->z_size;
	}

	int
	zfs_acl_chown_setattr(znode_t *zp)
	{
	int error;
	zfs_acl_t *aclp;

	if (zp->z_zfsvfs->z_replay == B_FALSE) {
	ASSERT_VOP_ELOCKED(ZTOV(zp), __func__);
	ASSERT_VOP_IN_SEQC(ZTOV(zp));
	}
	ASSERT(MUTEX_HELD(&zp->z_acl_lock));

	if ((error = zfs_acl_node_read(zp, B_TRUE, &aclp, B_FALSE)) == 0)
	zp->z_mode = zfs_mode_compute(zp->z_mode, aclp,
	&zp->z_pflags, zp->z_uid, zp->z_gid);
	return (error);
	}

	/*
	* common code for setting ACLs.
	*
	* This function is called from zfs_mode_update, zfs_perm_init, and zfs_setacl.
	* zfs_setacl passes a non-NULL inherit pointer (ihp) to indicate that it's
	* already checked the acl and knows whether to inherit.
	*/
	int
	zfs_aclset_common(znode_t zp, zfs_acl_t aclp, cred_t cr, dmu_tx_t tx)
	{
	int error;
	zfsvfs_t *zfsvfs = zp->z_zfsvfs;
	dmu_object_type_t otype;
	zfs_acl_locator_cb_t locate = { 0 };
	uint64_t mode;
	sa_bulk_attr_t bulk[5];
	uint64_t ctime[2];
	int count = 0;
	zfs_acl_phys_t acl_phys;

	if (zp->z_zfsvfs->z_replay == B_FALSE) {
	ASSERT_VOP_IN_SEQC(ZTOV(zp));
	}

	mode = zp->z_mode;

	mode = zfs_mode_compute(mode, aclp, &zp->z_pflags,
	zp->z_uid, zp->z_gid);

	zp->z_mode = mode;
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MODE(zfsvfs), NULL,
	&mode, sizeof (mode));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zfsvfs), NULL,
	&zp->z_pflags, sizeof (zp->z_pflags));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs), NULL,
	&ctime, sizeof (ctime));

	if (zp->z_acl_cached) {
	zfs_acl_free(zp->z_acl_cached);
	zp->z_acl_cached = NULL;
	}

	/*
	* Upgrade needed?
	*/
	if (!zfsvfs->z_use_fuids) {
	otype = DMU_OT_OLDACL;
	} else {
	if ((aclp->z_version == ZFS_ACL_VERSION_INITIAL) &&
	(zfsvfs->z_version >= ZPL_VERSION_FUID))
	zfs_acl_xform(zp, aclp, cr);
	ASSERT(aclp->z_version >= ZFS_ACL_VERSION_FUID);
	otype = DMU_OT_ACL;
	}

	/*
	* Arrgh, we have to handle old on disk format
	* as well as newer (preferred) SA format.
	*/

	if (zp->z_is_sa) { /* the easy case, just update the ACL attribute */
	locate.cb_aclp = aclp;
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_DACL_ACES(zfsvfs),
	zfs_acl_data_locator, &locate, aclp->z_acl_bytes);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_DACL_COUNT(zfsvfs),
	NULL, &aclp->z_acl_count, sizeof (uint64_t));
	} else { /* Painful legacy way */
	zfs_acl_node_t *aclnode;
	uint64_t off = 0;
	uint64_t aoid;

	if ((error = sa_lookup(zp->z_sa_hdl, SA_ZPL_ZNODE_ACL(zfsvfs),
	&acl_phys, sizeof (acl_phys))) != 0)
	return (error);

	aoid = acl_phys.z_acl_extern_obj;

	if (aclp->z_acl_bytes > ZFS_ACE_SPACE) {
	/*
	* If ACL was previously external and we are now
	* converting to new ACL format then release old
	* ACL object and create a new one.
	*/
	if (aoid &&
	aclp->z_version != acl_phys.z_acl_version) {
	error = dmu_object_free(zfsvfs->z_os, aoid, tx);
	if (error)
	return (error);
	aoid = 0;
	}
	if (aoid == 0) {
	aoid = dmu_object_alloc(zfsvfs->z_os,
	otype, aclp->z_acl_bytes,
	otype == DMU_OT_ACL ?
	DMU_OT_SYSACL : DMU_OT_NONE,
	otype == DMU_OT_ACL ?
	DN_OLD_MAX_BONUSLEN : 0, tx);
	} else {
	(void) dmu_object_set_blocksize(zfsvfs->z_os,
	aoid, aclp->z_acl_bytes, 0, tx);
	}
	acl_phys.z_acl_extern_obj = aoid;
	for (aclnode = list_head(&aclp->z_acl); aclnode;
	aclnode = list_next(&aclp->z_acl, aclnode)) {
	if (aclnode->z_ace_count == 0)
	continue;
	dmu_write(zfsvfs->z_os, aoid, off,
	aclnode->z_size, aclnode->z_acldata, tx);
	off += aclnode->z_size;
	}
	} else {
	void *start = acl_phys.z_ace_data;
	/*
	* Migrating back embedded?
	*/
	if (acl_phys.z_acl_extern_obj) {
	error = dmu_object_free(zfsvfs->z_os,
	acl_phys.z_acl_extern_obj, tx);
	if (error)
	return (error);
	acl_phys.z_acl_extern_obj = 0;
	}

	for (aclnode = list_head(&aclp->z_acl); aclnode;
	aclnode = list_next(&aclp->z_acl, aclnode)) {
	if (aclnode->z_ace_count == 0)
	continue;
	bcopy(aclnode->z_acldata, start,
	aclnode->z_size);
	start = (caddr_t)start + aclnode->z_size;
	}
	}
	/*
	* If Old version then swap count/bytes to match old
	* layout of znode_acl_phys_t.
	*/
	if (aclp->z_version == ZFS_ACL_VERSION_INITIAL) {
	acl_phys.z_acl_size = aclp->z_acl_count;
	acl_phys.z_acl_count = aclp->z_acl_bytes;
	} else {
	acl_phys.z_acl_size = aclp->z_acl_bytes;
	acl_phys.z_acl_count = aclp->z_acl_count;
	}
	acl_phys.z_acl_version = aclp->z_version;

	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_ZNODE_ACL(zfsvfs), NULL,
	&acl_phys, sizeof (acl_phys));
	}

	/*
	* Replace ACL wide bits, but first clear them.
	*/
	zp->z_pflags &= ~ZFS_ACL_WIDE_FLAGS;

	zp->z_pflags \|= aclp->z_hints;

	if (ace_trivial_common(aclp, 0, zfs_ace_walk) == 0)
	zp->z_pflags \|= ZFS_ACL_TRIVIAL;

	zfs_tstamp_update_setup(zp, STATE_CHANGED, NULL, ctime);
	return (sa_bulk_update(zp->z_sa_hdl, bulk, count, tx));
	}

	static void
	zfs_acl_chmod(vtype_t vtype, uint64_t mode, boolean_t split, boolean_t trim,
	zfs_acl_t *aclp)
	{
	void *acep = NULL;
	uint64_t who;
	int new_count, new_bytes;
	int ace_size;
	int entry_type;
	uint16_t iflags, type;
	uint32_t access_mask;
	zfs_acl_node_t *newnode;
	size_t abstract_size = aclp->z_ops->ace_abstract_size();
	void *zacep;
	boolean_t isdir;
	trivial_acl_t masks;

	new_count = new_bytes = 0;

	isdir = (vtype == VDIR);

	acl_trivial_access_masks((mode_t)mode, isdir, &masks);

	newnode = zfs_acl_node_alloc((abstract_size * 6) + aclp->z_acl_bytes);

	zacep = newnode->z_acldata;
	if (masks.allow0) {
	zfs_set_ace(aclp, zacep, masks.allow0, ALLOW, -1, ACE_OWNER);
	zacep = (void *)((uintptr_t)zacep + abstract_size);
	new_count++;
	new_bytes += abstract_size;
	}
	if (masks.deny1) {
	zfs_set_ace(aclp, zacep, masks.deny1, DENY, -1, ACE_OWNER);
	zacep = (void *)((uintptr_t)zacep + abstract_size);
	new_count++;
	new_bytes += abstract_size;
	}
	if (masks.deny2) {
	zfs_set_ace(aclp, zacep, masks.deny2, DENY, -1, OWNING_GROUP);
	zacep = (void *)((uintptr_t)zacep + abstract_size);
	new_count++;
	new_bytes += abstract_size;
	}

	while ((acep = zfs_acl_next_ace(aclp, acep, &who, &access_mask,
	&iflags, &type))) {
	entry_type = (iflags & ACE_TYPE_FLAGS);
	/*
	* ACEs used to represent the file mode may be divided
	* into an equivalent pair of inherit-only and regular
	* ACEs, if they are inheritable.
	* Skip regular ACEs, which are replaced by the new mode.
	*/
	if (split && (entry_type == ACE_OWNER \|\|
	entry_type == OWNING_GROUP \|\|
	entry_type == ACE_EVERYONE)) {
	if (!isdir \|\| !(iflags &
	(ACE_FILE_INHERIT_ACE\|ACE_DIRECTORY_INHERIT_ACE)))
	continue;
	/*
	* We preserve owner@, group@, or @everyone
	* permissions, if they are inheritable, by
	* copying them to inherit_only ACEs. This
	* prevents inheritable permissions from being
	* altered along with the file mode.
	*/
	iflags \|= ACE_INHERIT_ONLY_ACE;
	}

	/*
	* If this ACL has any inheritable ACEs, mark that in
	* the hints (which are later masked into the pflags)
	* so create knows to do inheritance.
	*/
	if (isdir && (iflags &
	(ACE_FILE_INHERIT_ACE\|ACE_DIRECTORY_INHERIT_ACE)))
	aclp->z_hints \|= ZFS_INHERIT_ACE;

	if ((type != ALLOW && type != DENY) \|\|
	(iflags & ACE_INHERIT_ONLY_ACE)) {
	switch (type) {
	case ACE_ACCESS_ALLOWED_OBJECT_ACE_TYPE:
	case ACE_ACCESS_DENIED_OBJECT_ACE_TYPE:
	case ACE_SYSTEM_AUDIT_OBJECT_ACE_TYPE:
	case ACE_SYSTEM_ALARM_OBJECT_ACE_TYPE:
	aclp->z_hints \|= ZFS_ACL_OBJ_ACE;
	break;
	}
	} else {
	/*
	* Limit permissions granted by ACEs to be no greater
	* than permissions of the requested group mode.
	* Applies when the "aclmode" property is set to
	* "groupmask".
	*/
	if ((type == ALLOW) && trim)
	access_mask &= masks.group;
	}
	zfs_set_ace(aclp, zacep, access_mask, type, who, iflags);
	ace_size = aclp->z_ops->ace_size(acep);
	zacep = (void *)((uintptr_t)zacep + ace_size);
	new_count++;
	new_bytes += ace_size;
	}
	zfs_set_ace(aclp, zacep, masks.owner, ALLOW, -1, ACE_OWNER);
	zacep = (void *)((uintptr_t)zacep + abstract_size);
	zfs_set_ace(aclp, zacep, masks.group, ALLOW, -1, OWNING_GROUP);
	zacep = (void *)((uintptr_t)zacep + abstract_size);
	zfs_set_ace(aclp, zacep, masks.everyone, ALLOW, -1, ACE_EVERYONE);

	new_count += 3;
	new_bytes += abstract_size * 3;
	zfs_acl_release_nodes(aclp);
	aclp->z_acl_count = new_count;
	aclp->z_acl_bytes = new_bytes;
	newnode->z_ace_count = new_count;
	newnode->z_size = new_bytes;
	list_insert_tail(&aclp->z_acl, newnode);
	}

	int
	zfs_acl_chmod_setattr(znode_t zp, zfs_acl_t *aclp, uint64_t mode)
	{
	int error = 0;

	mutex_enter(&zp->z_acl_lock);
	if (zp->z_zfsvfs->z_replay == B_FALSE)
	ASSERT_VOP_ELOCKED(ZTOV(zp), __func__);
	if (zp->z_zfsvfs->z_acl_mode == ZFS_ACL_DISCARD)
	*aclp = zfs_acl_alloc(zfs_acl_version_zp(zp));
	else
	error = zfs_acl_node_read(zp, B_TRUE, aclp, B_TRUE);

	if (error == 0) {
	(*aclp)->z_hints = zp->z_pflags & V4_ACL_WIDE_FLAGS;
	zfs_acl_chmod(ZTOV(zp)->v_type, mode, B_TRUE,
	(zp->z_zfsvfs->z_acl_mode == ZFS_ACL_GROUPMASK), *aclp);
	}
	mutex_exit(&zp->z_acl_lock);

	return (error);
	}

	/*
	* Should ACE be inherited?
	*/
	static int
	zfs_ace_can_use(vtype_t vtype, uint16_t acep_flags)
	{
	int iflags = (acep_flags & 0xf);

	if ((vtype == VDIR) && (iflags & ACE_DIRECTORY_INHERIT_ACE))
	return (1);
	else if (iflags & ACE_FILE_INHERIT_ACE)
	return (!((vtype == VDIR) &&
	(iflags & ACE_NO_PROPAGATE_INHERIT_ACE)));
	return (0);
	}

	/*
	* inherit inheritable ACEs from parent
	*/
	static zfs_acl_t *
	zfs_acl_inherit(zfsvfs_t zfsvfs, vtype_t vtype, zfs_acl_t paclp,
	uint64_t mode, boolean_t *need_chmod)
	{
	void *pacep = NULL;
	void *acep;
	zfs_acl_node_t *aclnode;
	zfs_acl_t *aclp = NULL;
	uint64_t who;
	uint32_t access_mask;
	uint16_t iflags, newflags, type;
	size_t ace_size;
	void data1, data2;
	size_t data1sz, data2sz;
	uint_t aclinherit;
	boolean_t isdir = (vtype == VDIR);
	boolean_t isreg = (vtype == VREG);

	*need_chmod = B_TRUE;

	aclp = zfs_acl_alloc(paclp->z_version);
	aclinherit = zfsvfs->z_acl_inherit;
	if (aclinherit == ZFS_ACL_DISCARD \|\| vtype == VLNK)
	return (aclp);

	while ((pacep = zfs_acl_next_ace(paclp, pacep, &who,
	&access_mask, &iflags, &type))) {

	/*
	* don't inherit bogus ACEs
	*/
	if (!zfs_acl_valid_ace_type(type, iflags))
	continue;

	/*
	* Check if ACE is inheritable by this vnode
	*/
	if ((aclinherit == ZFS_ACL_NOALLOW && type == ALLOW) \|\|
	!zfs_ace_can_use(vtype, iflags))
	continue;

	/*
	* If owner@, group@, or everyone@ inheritable
	* then zfs_acl_chmod() isn't needed.
	*/
	if ((aclinherit == ZFS_ACL_PASSTHROUGH \|\|
	aclinherit == ZFS_ACL_PASSTHROUGH_X) &&
	((iflags & (ACE_OWNER\|ACE_EVERYONE)) \|\|
	((iflags & OWNING_GROUP) == OWNING_GROUP)) &&
	(isreg \|\| (isdir && (iflags & ACE_DIRECTORY_INHERIT_ACE))))
	*need_chmod = B_FALSE;

	/*
	* Strip inherited execute permission from file if
	* not in mode
	*/
	if (aclinherit == ZFS_ACL_PASSTHROUGH_X && type == ALLOW &&
	!isdir && ((mode & (S_IXUSR\|S_IXGRP\|S_IXOTH)) == 0)) {
	access_mask &= ~ACE_EXECUTE;
	}

	/*
	* Strip write_acl and write_owner from permissions
	* when inheriting an ACE
	*/
	if (aclinherit == ZFS_ACL_RESTRICTED && type == ALLOW) {
	access_mask &= ~RESTRICTED_CLEAR;
	}

	ace_size = aclp->z_ops->ace_size(pacep);
	aclnode = zfs_acl_node_alloc(ace_size);
	list_insert_tail(&aclp->z_acl, aclnode);
	acep = aclnode->z_acldata;

	zfs_set_ace(aclp, acep, access_mask, type,
	who, iflags\|ACE_INHERITED_ACE);

	/*
	* Copy special opaque data if any
	*/
	if ((data1sz = paclp->z_ops->ace_data(pacep, &data1)) != 0) {
	VERIFY((data2sz = aclp->z_ops->ace_data(acep,
	&data2)) == data1sz);
	bcopy(data1, data2, data2sz);
	}

	aclp->z_acl_count++;
	aclnode->z_ace_count++;
	aclp->z_acl_bytes += aclnode->z_size;
	newflags = aclp->z_ops->ace_flags_get(acep);

	/*
	* If ACE is not to be inherited further, or if the vnode is
	* not a directory, remove all inheritance flags
	*/
	if (!isdir \|\| (iflags & ACE_NO_PROPAGATE_INHERIT_ACE)) {
	newflags &= ~ALL_INHERIT;
	aclp->z_ops->ace_flags_set(acep,
	newflags\|ACE_INHERITED_ACE);
	continue;
	}

	/*
	* This directory has an inheritable ACE
	*/
	aclp->z_hints \|= ZFS_INHERIT_ACE;

	/*
	* If only FILE_INHERIT is set then turn on
	* inherit_only
	*/
	if ((iflags & (ACE_FILE_INHERIT_ACE \|
	ACE_DIRECTORY_INHERIT_ACE)) == ACE_FILE_INHERIT_ACE) {
	newflags \|= ACE_INHERIT_ONLY_ACE;
	aclp->z_ops->ace_flags_set(acep,
	newflags\|ACE_INHERITED_ACE);
	} else {
	newflags &= ~ACE_INHERIT_ONLY_ACE;
	aclp->z_ops->ace_flags_set(acep,
	newflags\|ACE_INHERITED_ACE);
	}
	}
	if (zfsvfs->z_acl_mode == ZFS_ACL_RESTRICTED &&
	aclp->z_acl_count != 0) {
	*need_chmod = B_FALSE;
	}

	return (aclp);
	}

	/*
	* Create file system object initial permissions
	* including inheritable ACEs.
	* Also, create FUIDs for owner and group.
	*/
	int
	zfs_acl_ids_create(znode_t dzp, int flag, vattr_t vap, cred_t *cr,
	vsecattr_t vsecp, zfs_acl_ids_t acl_ids)
	{
	int error;
	zfsvfs_t *zfsvfs = dzp->z_zfsvfs;
	zfs_acl_t *paclp;
	gid_t gid;
	boolean_t need_chmod = B_TRUE;
	boolean_t trim = B_FALSE;
	boolean_t inherited = B_FALSE;

	if ((flag & IS_ROOT_NODE) == 0) {
	if (zfsvfs->z_replay == B_FALSE)
	ASSERT_VOP_ELOCKED(ZTOV(dzp), __func__);
	} else
	ASSERT(dzp->z_vnode == NULL);
	bzero(acl_ids, sizeof (zfs_acl_ids_t));
	acl_ids->z_mode = MAKEIMODE(vap->va_type, vap->va_mode);

	if (vsecp)
	if ((error = zfs_vsec_2_aclp(zfsvfs, vap->va_type, vsecp, cr,
	&acl_ids->z_fuidp, &acl_ids->z_aclp)) != 0)
	return (error);
	/*
	* Determine uid and gid.
	*/
	if ((flag & IS_ROOT_NODE) \|\| zfsvfs->z_replay \|\|
	((flag & IS_XATTR) && (vap->va_type == VDIR))) {
	acl_ids->z_fuid = zfs_fuid_create(zfsvfs,
	(uint64_t)vap->va_uid, cr,
	ZFS_OWNER, &acl_ids->z_fuidp);
	acl_ids->z_fgid = zfs_fuid_create(zfsvfs,
	(uint64_t)vap->va_gid, cr,
	ZFS_GROUP, &acl_ids->z_fuidp);
	gid = vap->va_gid;
	} else {
	acl_ids->z_fuid = zfs_fuid_create_cred(zfsvfs, ZFS_OWNER,
	cr, &acl_ids->z_fuidp);
	acl_ids->z_fgid = 0;
	if (vap->va_mask & AT_GID) {
	acl_ids->z_fgid = zfs_fuid_create(zfsvfs,
	(uint64_t)vap->va_gid,
	cr, ZFS_GROUP, &acl_ids->z_fuidp);
	gid = vap->va_gid;
	if (acl_ids->z_fgid != dzp->z_gid &&
	!groupmember(vap->va_gid, cr) &&
	secpolicy_vnode_create_gid(cr) != 0)
	acl_ids->z_fgid = 0;
	}
	if (acl_ids->z_fgid == 0) {
	char *domain;
	uint32_t rid;

	acl_ids->z_fgid = dzp->z_gid;
	gid = zfs_fuid_map_id(zfsvfs, acl_ids->z_fgid,
	cr, ZFS_GROUP);

	if (zfsvfs->z_use_fuids &&
	IS_EPHEMERAL(acl_ids->z_fgid)) {
	domain =
	zfs_fuid_idx_domain(&zfsvfs->z_fuid_idx,
	FUID_INDEX(acl_ids->z_fgid));
	rid = FUID_RID(acl_ids->z_fgid);
	zfs_fuid_node_add(&acl_ids->z_fuidp,
	domain, rid, FUID_INDEX(acl_ids->z_fgid),
	acl_ids->z_fgid, ZFS_GROUP);
	}
	}
	}

	/*
	* If we're creating a directory, and the parent directory has the
	* set-GID bit set, set in on the new directory.
	* Otherwise, if the user is neither privileged nor a member of the
	* file's new group, clear the file's set-GID bit.
	*/

	if (!(flag & IS_ROOT_NODE) && (dzp->z_mode & S_ISGID) &&
	(vap->va_type == VDIR)) {
	acl_ids->z_mode \|= S_ISGID;
	} else {
	if ((acl_ids->z_mode & S_ISGID) &&
	secpolicy_vnode_setids_setgids(ZTOV(dzp), cr, gid) != 0)
	acl_ids->z_mode &= ~S_ISGID;
	}

	if (acl_ids->z_aclp == NULL) {
	mutex_enter(&dzp->z_acl_lock);
	if (!(flag & IS_ROOT_NODE) &&
	(dzp->z_pflags & ZFS_INHERIT_ACE) &&
	!(dzp->z_pflags & ZFS_XATTR)) {
	VERIFY0(zfs_acl_node_read(dzp, B_TRUE,
	&paclp, B_FALSE));
	acl_ids->z_aclp = zfs_acl_inherit(zfsvfs,
	vap->va_type, paclp, acl_ids->z_mode, &need_chmod);
	inherited = B_TRUE;
	} else {
	acl_ids->z_aclp =
	zfs_acl_alloc(zfs_acl_version_zp(dzp));
	acl_ids->z_aclp->z_hints \|= ZFS_ACL_TRIVIAL;
	}
	mutex_exit(&dzp->z_acl_lock);

	if (need_chmod) {
	if (vap->va_type == VDIR)
	acl_ids->z_aclp->z_hints \|=
	ZFS_ACL_AUTO_INHERIT;

	if (zfsvfs->z_acl_mode == ZFS_ACL_GROUPMASK &&
	zfsvfs->z_acl_inherit != ZFS_ACL_PASSTHROUGH &&
	zfsvfs->z_acl_inherit != ZFS_ACL_PASSTHROUGH_X)
	trim = B_TRUE;
	zfs_acl_chmod(vap->va_type, acl_ids->z_mode, B_FALSE,
	trim, acl_ids->z_aclp);
	}
	}

	if (inherited \|\| vsecp) {
	acl_ids->z_mode = zfs_mode_compute(acl_ids->z_mode,
	acl_ids->z_aclp, &acl_ids->z_aclp->z_hints,
	acl_ids->z_fuid, acl_ids->z_fgid);
	if (ace_trivial_common(acl_ids->z_aclp, 0, zfs_ace_walk) == 0)
	acl_ids->z_aclp->z_hints \|= ZFS_ACL_TRIVIAL;
	}

	return (0);
	}

	/*
	* Free ACL and fuid_infop, but not the acl_ids structure
	*/
	void
	zfs_acl_ids_free(zfs_acl_ids_t *acl_ids)
	{
	if (acl_ids->z_aclp)
	zfs_acl_free(acl_ids->z_aclp);
	if (acl_ids->z_fuidp)
	zfs_fuid_info_free(acl_ids->z_fuidp);
	acl_ids->z_aclp = NULL;
	acl_ids->z_fuidp = NULL;
	}

	boolean_t
	zfs_acl_ids_overquota(zfsvfs_t zv, zfs_acl_ids_t acl_ids, uint64_t projid)
	{
	return (zfs_id_overquota(zv, DMU_USERUSED_OBJECT, acl_ids->z_fuid) \|\|
	zfs_id_overquota(zv, DMU_GROUPUSED_OBJECT, acl_ids->z_fgid) \|\|
	(projid != ZFS_DEFAULT_PROJID && projid != ZFS_INVALID_PROJID &&
	zfs_id_overquota(zv, DMU_PROJECTUSED_OBJECT, projid)));
	}

	/*
	* Retrieve a file's ACL
	*/
	int
	zfs_getacl(znode_t zp, vsecattr_t vsecp, boolean_t skipaclchk, cred_t *cr)
	{
	zfs_acl_t *aclp;
	ulong_t mask;
	int error;
	int count = 0;
	int largeace = 0;

	mask = vsecp->vsa_mask & (VSA_ACE \| VSA_ACECNT \|
	VSA_ACE_ACLFLAGS \| VSA_ACE_ALLTYPES);

	if (mask == 0)
	return (SET_ERROR(ENOSYS));

	if ((error = zfs_zaccess(zp, ACE_READ_ACL, 0, skipaclchk, cr)))
	return (error);

	mutex_enter(&zp->z_acl_lock);

	if (zp->z_zfsvfs->z_replay == B_FALSE)
	ASSERT_VOP_LOCKED(ZTOV(zp), __func__);
	error = zfs_acl_node_read(zp, B_TRUE, &aclp, B_FALSE);
	if (error != 0) {
	mutex_exit(&zp->z_acl_lock);
	return (error);
	}

	/*
	* Scan ACL to determine number of ACEs
	*/
	if ((zp->z_pflags & ZFS_ACL_OBJ_ACE) && !(mask & VSA_ACE_ALLTYPES)) {
	void *zacep = NULL;
	uint64_t who;
	uint32_t access_mask;
	uint16_t type, iflags;

	while ((zacep = zfs_acl_next_ace(aclp, zacep,
	&who, &access_mask, &iflags, &type))) {
	switch (type) {
	case ACE_ACCESS_ALLOWED_OBJECT_ACE_TYPE:
	case ACE_ACCESS_DENIED_OBJECT_ACE_TYPE:
	case ACE_SYSTEM_AUDIT_OBJECT_ACE_TYPE:
	case ACE_SYSTEM_ALARM_OBJECT_ACE_TYPE:
	largeace++;
	continue;
	default:
	count++;
	}
	}
	vsecp->vsa_aclcnt = count;
	} else
	count = (int)aclp->z_acl_count;

	if (mask & VSA_ACECNT) {
	vsecp->vsa_aclcnt = count;
	}

	if (mask & VSA_ACE) {
	size_t aclsz;

	aclsz = count * sizeof (ace_t) +
	sizeof (ace_object_t) * largeace;

	vsecp->vsa_aclentp = kmem_alloc(aclsz, KM_SLEEP);
	vsecp->vsa_aclentsz = aclsz;

	if (aclp->z_version == ZFS_ACL_VERSION_FUID)
	zfs_copy_fuid_2_ace(zp->z_zfsvfs, aclp, cr,
	vsecp->vsa_aclentp, !(mask & VSA_ACE_ALLTYPES));
	else {
	zfs_acl_node_t *aclnode;
	void *start = vsecp->vsa_aclentp;

	for (aclnode = list_head(&aclp->z_acl); aclnode;
	aclnode = list_next(&aclp->z_acl, aclnode)) {
	bcopy(aclnode->z_acldata, start,
	aclnode->z_size);
	start = (caddr_t)start + aclnode->z_size;
	}
	ASSERT((caddr_t)start - (caddr_t)vsecp->vsa_aclentp ==
	aclp->z_acl_bytes);
	}
	}
	if (mask & VSA_ACE_ACLFLAGS) {
	vsecp->vsa_aclflags = 0;
	if (zp->z_pflags & ZFS_ACL_DEFAULTED)
	vsecp->vsa_aclflags \|= ACL_DEFAULTED;
	if (zp->z_pflags & ZFS_ACL_PROTECTED)
	vsecp->vsa_aclflags \|= ACL_PROTECTED;
	if (zp->z_pflags & ZFS_ACL_AUTO_INHERIT)
	vsecp->vsa_aclflags \|= ACL_AUTO_INHERIT;
	}

	mutex_exit(&zp->z_acl_lock);

	return (0);
	}

	int
	zfs_vsec_2_aclp(zfsvfs_t *zfsvfs, umode_t obj_type,
	vsecattr_t vsecp, cred_t cr, zfs_fuid_info_t fuidp, zfs_acl_t zaclp)
	{
	zfs_acl_t *aclp;
	zfs_acl_node_t *aclnode;
	int aclcnt = vsecp->vsa_aclcnt;
	int error;

	if (vsecp->vsa_aclcnt > MAX_ACL_ENTRIES \|\| vsecp->vsa_aclcnt <= 0)
	return (SET_ERROR(EINVAL));

	aclp = zfs_acl_alloc(zfs_acl_version(zfsvfs->z_version));

	aclp->z_hints = 0;
	aclnode = zfs_acl_node_alloc(aclcnt * sizeof (zfs_object_ace_t));
	if (aclp->z_version == ZFS_ACL_VERSION_INITIAL) {
	if ((error = zfs_copy_ace_2_oldace(obj_type, aclp,
	(ace_t *)vsecp->vsa_aclentp, aclnode->z_acldata,
	aclcnt, &aclnode->z_size)) != 0) {
	zfs_acl_free(aclp);
	zfs_acl_node_free(aclnode);
	return (error);
	}
	} else {
	if ((error = zfs_copy_ace_2_fuid(zfsvfs, obj_type, aclp,
	vsecp->vsa_aclentp, aclnode->z_acldata, aclcnt,
	&aclnode->z_size, fuidp, cr)) != 0) {
	zfs_acl_free(aclp);
	zfs_acl_node_free(aclnode);
	return (error);
	}
	}
	aclp->z_acl_bytes = aclnode->z_size;
	aclnode->z_ace_count = aclcnt;
	aclp->z_acl_count = aclcnt;
	list_insert_head(&aclp->z_acl, aclnode);

	/*
	* If flags are being set then add them to z_hints
	*/
	if (vsecp->vsa_mask & VSA_ACE_ACLFLAGS) {
	if (vsecp->vsa_aclflags & ACL_PROTECTED)
	aclp->z_hints \|= ZFS_ACL_PROTECTED;
	if (vsecp->vsa_aclflags & ACL_DEFAULTED)
	aclp->z_hints \|= ZFS_ACL_DEFAULTED;
	if (vsecp->vsa_aclflags & ACL_AUTO_INHERIT)
	aclp->z_hints \|= ZFS_ACL_AUTO_INHERIT;
	}

	*zaclp = aclp;

	return (0);
	}

	/*
	* Set a file's ACL
	*/
	int
	zfs_setacl(znode_t zp, vsecattr_t vsecp, boolean_t skipaclchk, cred_t *cr)
	{
	zfsvfs_t *zfsvfs = zp->z_zfsvfs;
	zilog_t *zilog = zfsvfs->z_log;
	ulong_t mask = vsecp->vsa_mask & (VSA_ACE \| VSA_ACECNT);
	dmu_tx_t *tx;
	int error;
	zfs_acl_t *aclp;
	zfs_fuid_info_t *fuidp = NULL;
	boolean_t fuid_dirtied;
	uint64_t acl_obj;

	if (zp->z_zfsvfs->z_replay == B_FALSE)
	ASSERT_VOP_ELOCKED(ZTOV(zp), __func__);
	if (mask == 0)
	return (SET_ERROR(ENOSYS));

	if (zp->z_pflags & ZFS_IMMUTABLE)
	return (SET_ERROR(EPERM));

	if ((error = zfs_zaccess(zp, ACE_WRITE_ACL, 0, skipaclchk, cr)))
	return (error);

	error = zfs_vsec_2_aclp(zfsvfs, ZTOV(zp)->v_type, vsecp, cr, &fuidp,
	&aclp);
	if (error)
	return (error);

	/*
	* If ACL wide flags aren't being set then preserve any
	* existing flags.
	*/
	if (!(vsecp->vsa_mask & VSA_ACE_ACLFLAGS)) {
	aclp->z_hints \|=
	(zp->z_pflags & V4_ACL_WIDE_FLAGS);
	}
	top:
	mutex_enter(&zp->z_acl_lock);

	tx = dmu_tx_create(zfsvfs->z_os);

	dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_TRUE);

	fuid_dirtied = zfsvfs->z_fuid_dirty;
	if (fuid_dirtied)
	zfs_fuid_txhold(zfsvfs, tx);

	/*
	* If old version and ACL won't fit in bonus and we aren't
	* upgrading then take out necessary DMU holds
	*/

	if ((acl_obj = zfs_external_acl(zp)) != 0) {
	if (zfsvfs->z_version >= ZPL_VERSION_FUID &&
	zfs_znode_acl_version(zp) <= ZFS_ACL_VERSION_INITIAL) {
	dmu_tx_hold_free(tx, acl_obj, 0,
	DMU_OBJECT_END);
	dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0,
	aclp->z_acl_bytes);
	} else {
	dmu_tx_hold_write(tx, acl_obj, 0, aclp->z_acl_bytes);
	}
	} else if (!zp->z_is_sa && aclp->z_acl_bytes > ZFS_ACE_SPACE) {
	dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0, aclp->z_acl_bytes);
	}

	zfs_sa_upgrade_txholds(tx, zp);
	error = dmu_tx_assign(tx, TXG_NOWAIT);
	if (error) {
	mutex_exit(&zp->z_acl_lock);

	if (error == ERESTART) {
	dmu_tx_wait(tx);
	dmu_tx_abort(tx);
	goto top;
	}
	dmu_tx_abort(tx);
	zfs_acl_free(aclp);
	return (error);
	}

	error = zfs_aclset_common(zp, aclp, cr, tx);
	ASSERT(error == 0);
	ASSERT(zp->z_acl_cached == NULL);
	zp->z_acl_cached = aclp;

	if (fuid_dirtied)
	zfs_fuid_sync(zfsvfs, tx);

	zfs_log_acl(zilog, tx, zp, vsecp, fuidp);

	if (fuidp)
	zfs_fuid_info_free(fuidp);
	dmu_tx_commit(tx);
	mutex_exit(&zp->z_acl_lock);

	return (error);
	}

	/*
	* Check accesses of interest (AoI) against attributes of the dataset
	* such as read-only. Returns zero if no AoI conflict with dataset
	* attributes, otherwise an appropriate errno is returned.
	*/
	static int
	zfs_zaccess_dataset_check(znode_t *zp, uint32_t v4_mode)
	{
	if ((v4_mode & WRITE_MASK) &&
	(zp->z_zfsvfs->z_vfs->vfs_flag & VFS_RDONLY) &&
	(!IS_DEVVP(ZTOV(zp)) \|\|
	(IS_DEVVP(ZTOV(zp)) && (v4_mode & WRITE_MASK_ATTRS)))) {
	return (SET_ERROR(EROFS));
	}

	/*
	* Intentionally allow ZFS_READONLY through here.
	* See zfs_zaccess_common().
	*/
	if ((v4_mode & WRITE_MASK_DATA) &&
	(zp->z_pflags & ZFS_IMMUTABLE)) {
	return (SET_ERROR(EPERM));
	}

	/*
	* In FreeBSD we allow to modify directory's content is ZFS_NOUNLINK
	* (sunlnk) is set. We just don't allow directory removal, which is
	* handled in zfs_zaccess_delete().
	*/
	if ((v4_mode & ACE_DELETE) &&
	(zp->z_pflags & ZFS_NOUNLINK)) {
	return (EPERM);
	}

	if (((v4_mode & (ACE_READ_DATA\|ACE_EXECUTE)) &&
	(zp->z_pflags & ZFS_AV_QUARANTINED))) {
	return (SET_ERROR(EACCES));
	}

	return (0);
	}

	/*
	* The primary usage of this function is to loop through all of the
	* ACEs in the znode, determining what accesses of interest (AoI) to
	* the caller are allowed or denied. The AoI are expressed as bits in
	* the working_mode parameter. As each ACE is processed, bits covered
	* by that ACE are removed from the working_mode. This removal
	* facilitates two things. The first is that when the working mode is
	* empty (= 0), we know we've looked at all the AoI. The second is
	* that the ACE interpretation rules don't allow a later ACE to undo
	* something granted or denied by an earlier ACE. Removing the
	* discovered access or denial enforces this rule. At the end of
	* processing the ACEs, all AoI that were found to be denied are
	* placed into the working_mode, giving the caller a mask of denied
	* accesses. Returns:
	* 0 if all AoI granted
	* EACCESS if the denied mask is non-zero
	* other error if abnormal failure (e.g., IO error)
	*
	* A secondary usage of the function is to determine if any of the
	* AoI are granted. If an ACE grants any access in
	* the working_mode, we immediately short circuit out of the function.
	* This mode is chosen by setting anyaccess to B_TRUE. The
	* working_mode is not a denied access mask upon exit if the function
	* is used in this manner.
	*/
	static int
	zfs_zaccess_aces_check(znode_t zp, uint32_t working_mode,
	boolean_t anyaccess, cred_t *cr)
	{
	zfsvfs_t *zfsvfs = zp->z_zfsvfs;
	zfs_acl_t *aclp;
	int error;
	uid_t uid = crgetuid(cr);
	uint64_t who;
	uint16_t type, iflags;
	uint16_t entry_type;
	uint32_t access_mask;
	uint32_t deny_mask = 0;
	zfs_ace_hdr_t *acep = NULL;
	boolean_t checkit;
	uid_t gowner;
	uid_t fowner;

	zfs_fuid_map_ids(zp, cr, &fowner, &gowner);

	mutex_enter(&zp->z_acl_lock);

	if (zp->z_zfsvfs->z_replay == B_FALSE)
	ASSERT_VOP_LOCKED(ZTOV(zp), __func__);
	error = zfs_acl_node_read(zp, B_TRUE, &aclp, B_FALSE);
	if (error != 0) {
	mutex_exit(&zp->z_acl_lock);
	return (error);
	}

	ASSERT(zp->z_acl_cached);

	while ((acep = zfs_acl_next_ace(aclp, acep, &who, &access_mask,
	&iflags, &type))) {
	uint32_t mask_matched;

	if (!zfs_acl_valid_ace_type(type, iflags))
	continue;

	if (ZTOV(zp)->v_type == VDIR && (iflags & ACE_INHERIT_ONLY_ACE))
	continue;

	/* Skip ACE if it does not affect any AoI */
	mask_matched = (access_mask & *working_mode);
	if (!mask_matched)
	continue;

	entry_type = (iflags & ACE_TYPE_FLAGS);

	checkit = B_FALSE;

	switch (entry_type) {
	case ACE_OWNER:
	if (uid == fowner)
	checkit = B_TRUE;
	break;
	case OWNING_GROUP:
	who = gowner;
	/FALLTHROUGH/
	case ACE_IDENTIFIER_GROUP:
	checkit = zfs_groupmember(zfsvfs, who, cr);
	break;
	case ACE_EVERYONE:
	checkit = B_TRUE;
	break;

	/* USER Entry */
	default:
	if (entry_type == 0) {
	uid_t newid;

	newid = zfs_fuid_map_id(zfsvfs, who, cr,
	ZFS_ACE_USER);
	if (newid != UID_NOBODY &&
	uid == newid)
	checkit = B_TRUE;
	break;
	} else {
	mutex_exit(&zp->z_acl_lock);
	return (SET_ERROR(EIO));
	}
	}

	if (checkit) {
	if (type == DENY) {
	DTRACE_PROBE3(zfs__ace__denies,
	znode_t *, zp,
	zfs_ace_hdr_t *, acep,
	uint32_t, mask_matched);
	deny_mask \|= mask_matched;
	} else {
	DTRACE_PROBE3(zfs__ace__allows,
	znode_t *, zp,
	zfs_ace_hdr_t *, acep,
	uint32_t, mask_matched);
	if (anyaccess) {
	mutex_exit(&zp->z_acl_lock);
	return (0);
	}
	}
	*working_mode &= ~mask_matched;
	}

	/* Are we done? */
	if (*working_mode == 0)
	break;
	}

	mutex_exit(&zp->z_acl_lock);

	/* Put the found 'denies' back on the working mode */
	if (deny_mask) {
	*working_mode \|= deny_mask;
	return (SET_ERROR(EACCES));
	} else if (*working_mode) {
	return (-1);
	}

	return (0);
	}

	/*
	* Return true if any access whatsoever granted, we don't actually
	* care what access is granted.
	*/
	boolean_t
	zfs_has_access(znode_t zp, cred_t cr)
	{
	uint32_t have = ACE_ALL_PERMS;

	if (zfs_zaccess_aces_check(zp, &have, B_TRUE, cr) != 0) {
	uid_t owner;

	owner = zfs_fuid_map_id(zp->z_zfsvfs, zp->z_uid, cr, ZFS_OWNER);
	return (secpolicy_vnode_any_access(cr, ZTOV(zp), owner) == 0);
	}
	return (B_TRUE);
	}

	static int
	zfs_zaccess_common(znode_t zp, uint32_t v4_mode, uint32_t working_mode,
	boolean_t check_privs, boolean_t skipaclchk, cred_t cr)
	{
	zfsvfs_t *zfsvfs = zp->z_zfsvfs;
	int err;

	*working_mode = v4_mode;
	*check_privs = B_TRUE;

	/*
	* Short circuit empty requests
	*/
	if (v4_mode == 0 \|\| zfsvfs->z_replay) {
	*working_mode = 0;
	return (0);
	}

	if ((err = zfs_zaccess_dataset_check(zp, v4_mode)) != 0) {
	*check_privs = B_FALSE;
	return (err);
	}

	/*
	* The caller requested that the ACL check be skipped. This
	* would only happen if the caller checked VOP_ACCESS() with a
	* 32 bit ACE mask and already had the appropriate permissions.
	*/
	if (skipaclchk) {
	*working_mode = 0;
	return (0);
	}

	/*
	* Note: ZFS_READONLY represents the "DOS R/O" attribute.
	* When that flag is set, we should behave as if write access
	* were not granted by anything in the ACL. In particular:
	* We _must_ allow writes after opening the file r/w, then
	* setting the DOS R/O attribute, and writing some more.
	* (Similar to how you can write after fchmod(fd, 0444).)
	*
	* Therefore ZFS_READONLY is ignored in the dataset check
	* above, and checked here as if part of the ACL check.
	* Also note: DOS R/O is ignored for directories.
	*/
	if ((v4_mode & WRITE_MASK_DATA) &&
	(ZTOV(zp)->v_type != VDIR) &&
	(zp->z_pflags & ZFS_READONLY)) {
	return (SET_ERROR(EPERM));
	}

	return (zfs_zaccess_aces_check(zp, working_mode, B_FALSE, cr));
	}

	static int
	zfs_zaccess_append(znode_t zp, uint32_t working_mode, boolean_t *check_privs,
	cred_t *cr)
	{
	if (*working_mode != ACE_WRITE_DATA)
	return (SET_ERROR(EACCES));

	return (zfs_zaccess_common(zp, ACE_APPEND_DATA, working_mode,
	check_privs, B_FALSE, cr));
	}

	/*
	* Check if VEXEC is allowed.
	*
	* This routine is based on zfs_fastaccesschk_execute which has slowpath
	* calling zfs_zaccess. This would be incorrect on FreeBSD (see
	* zfs_freebsd_access for the difference). Thus this variant let's the
	* caller handle the slowpath (if necessary).
	*
	* On top of that we perform a lockless check for ZFS_NO_EXECS_DENIED.
	*
	* Safe access to znode_t is provided by the vnode lock.
	*/
	int
	zfs_fastaccesschk_execute(znode_t zdp, cred_t cr)
	{
	boolean_t is_attr;

	if (zdp->z_pflags & ZFS_AV_QUARANTINED)
	return (1);

	is_attr = ((zdp->z_pflags & ZFS_XATTR) &&
	(ZTOV(zdp)->v_type == VDIR));
	if (is_attr)
	return (1);

	if (zdp->z_pflags & ZFS_NO_EXECS_DENIED)
	return (0);

	return (1);
	}


	/*
	* Determine whether Access should be granted/denied.
	*
	* The least priv subsystem is always consulted as a basic privilege
	* can define any form of access.
	*/
	int
	zfs_zaccess(znode_t zp, int mode, int flags, boolean_t skipaclchk, cred_t cr)
	{
	uint32_t working_mode;
	int error;
	int is_attr;
	boolean_t check_privs;
	znode_t *xzp = NULL;
	znode_t *check_zp = zp;
	mode_t needed_bits;
	uid_t owner;

	is_attr = ((zp->z_pflags & ZFS_XATTR) && (ZTOV(zp)->v_type == VDIR));

	-#ifdef __FreeBSD_kernel__
	/*
	* In FreeBSD, we don't care about permissions of individual ADS.
	* Note that not checking them is not just an optimization - without
	* this shortcut, EA operations may bogusly fail with EACCES.
	*/
	if (zp->z_pflags & ZFS_XATTR)
	return (0);
	-#else
	- /*
	- * If attribute then validate against base file
	- */
	- if (is_attr) {
	- uint64_t parent;
	-
	- if ((error = sa_lookup(zp->z_sa_hdl,
	- SA_ZPL_PARENT(zp->z_zfsvfs), &parent,
	- sizeof (parent))) != 0)
	- return (error);
	-
	- if ((error = zfs_zget(zp->z_zfsvfs,
	- parent, &xzp)) != 0) {
	- return (error);
	- }
	-
	- check_zp = xzp;
	-
	- /*
	- * fixup mode to map to xattr perms
	- */
	-
	- if (mode & (ACE_WRITE_DATA\|ACE_APPEND_DATA)) {
	- mode &= ~(ACE_WRITE_DATA\|ACE_APPEND_DATA);
	- mode \|= ACE_WRITE_NAMED_ATTRS;
	- }
	-
	- if (mode & (ACE_READ_DATA\|ACE_EXECUTE)) {
	- mode &= ~(ACE_READ_DATA\|ACE_EXECUTE);
	- mode \|= ACE_READ_NAMED_ATTRS;
	- }
	- }
	-#endif

	owner = zfs_fuid_map_id(zp->z_zfsvfs, zp->z_uid, cr, ZFS_OWNER);
	+
	/*
	* Map the bits required to the standard vnode flags VREAD\|VWRITE\|VEXEC
	* in needed_bits. Map the bits mapped by working_mode (currently
	* missing) in missing_bits.
	* Call secpolicy_vnode_access2() with (needed_bits & ~checkmode),
	* needed_bits.
	*/
	needed_bits = 0;

	working_mode = mode;
	if ((working_mode & (ACE_READ_ACL\|ACE_READ_ATTRIBUTES)) &&
	owner == crgetuid(cr))
	working_mode &= ~(ACE_READ_ACL\|ACE_READ_ATTRIBUTES);

	if (working_mode & (ACE_READ_DATA\|ACE_READ_NAMED_ATTRS\|
	ACE_READ_ACL\|ACE_READ_ATTRIBUTES\|ACE_SYNCHRONIZE))
	needed_bits \|= VREAD;
	if (working_mode & (ACE_WRITE_DATA\|ACE_WRITE_NAMED_ATTRS\|
	ACE_APPEND_DATA\|ACE_WRITE_ATTRIBUTES\|ACE_SYNCHRONIZE))
	needed_bits \|= VWRITE;
	if (working_mode & ACE_EXECUTE)
	needed_bits \|= VEXEC;

	if ((error = zfs_zaccess_common(check_zp, mode, &working_mode,
	&check_privs, skipaclchk, cr)) == 0) {
	if (is_attr)
	VN_RELE(ZTOV(xzp));
	return (secpolicy_vnode_access2(cr, ZTOV(zp), owner,
	needed_bits, needed_bits));
	}

	if (error && !check_privs) {
	if (is_attr)
	VN_RELE(ZTOV(xzp));
	return (error);
	}

	if (error && (flags & V_APPEND)) {
	error = zfs_zaccess_append(zp, &working_mode, &check_privs, cr);
	}

	if (error && check_privs) {
	mode_t checkmode = 0;
	vnode_t *check_vp = ZTOV(check_zp);

	/*
	* First check for implicit owner permission on
	* read_acl/read_attributes
	*/

	error = 0;
	ASSERT(working_mode != 0);

	if ((working_mode & (ACE_READ_ACL\|ACE_READ_ATTRIBUTES) &&
	owner == crgetuid(cr)))
	working_mode &= ~(ACE_READ_ACL\|ACE_READ_ATTRIBUTES);

	if (working_mode & (ACE_READ_DATA\|ACE_READ_NAMED_ATTRS\|
	ACE_READ_ACL\|ACE_READ_ATTRIBUTES\|ACE_SYNCHRONIZE))
	checkmode \|= VREAD;
	if (working_mode & (ACE_WRITE_DATA\|ACE_WRITE_NAMED_ATTRS\|
	ACE_APPEND_DATA\|ACE_WRITE_ATTRIBUTES\|ACE_SYNCHRONIZE))
	checkmode \|= VWRITE;
	if (working_mode & ACE_EXECUTE)
	checkmode \|= VEXEC;

	error = secpolicy_vnode_access2(cr, check_vp, owner,
	needed_bits & ~checkmode, needed_bits);

	if (error == 0 && (working_mode & ACE_WRITE_OWNER))
	error = secpolicy_vnode_chown(check_vp, cr, owner);
	if (error == 0 && (working_mode & ACE_WRITE_ACL))
	error = secpolicy_vnode_setdac(check_vp, cr, owner);

	if (error == 0 && (working_mode &
	(ACE_DELETE\|ACE_DELETE_CHILD)))
	error = secpolicy_vnode_remove(check_vp, cr);

	if (error == 0 && (working_mode & ACE_SYNCHRONIZE)) {
	error = secpolicy_vnode_chown(check_vp, cr, owner);
	}
	if (error == 0) {
	/*
	* See if any bits other than those already checked
	* for are still present. If so then return EACCES
	*/
	if (working_mode & ~(ZFS_CHECKED_MASKS)) {
	error = SET_ERROR(EACCES);
	}
	}
	} else if (error == 0) {
	error = secpolicy_vnode_access2(cr, ZTOV(zp), owner,
	needed_bits, needed_bits);
	}


	if (is_attr)
	VN_RELE(ZTOV(xzp));

	return (error);
	}

	/*
	* Translate traditional unix VREAD/VWRITE/VEXEC mode into
	* NFSv4-style ZFS ACL format and call zfs_zaccess()
	*/
	int
	zfs_zaccess_rwx(znode_t zp, mode_t mode, int flags, cred_t cr)
	{
	return (zfs_zaccess(zp, zfs_unix_to_v4(mode >> 6), flags, B_FALSE, cr));
	}

	/*
	* Access function for secpolicy_vnode_setattr
	*/
	int
	zfs_zaccess_unix(znode_t zp, mode_t mode, cred_t cr)
	{
	int v4_mode = zfs_unix_to_v4(mode >> 6);

	return (zfs_zaccess(zp, v4_mode, 0, B_FALSE, cr));
	}

	static int
	zfs_delete_final_check(znode_t zp, znode_t dzp,
	mode_t available_perms, cred_t *cr)
	{
	int error;
	uid_t downer;

	downer = zfs_fuid_map_id(dzp->z_zfsvfs, dzp->z_uid, cr, ZFS_OWNER);

	error = secpolicy_vnode_access2(cr, ZTOV(dzp),
	downer, available_perms, VWRITE\|VEXEC);

	if (error == 0)
	error = zfs_sticky_remove_access(dzp, zp, cr);

	return (error);
	}

	/*
	* Determine whether Access should be granted/deny, without
	* consulting least priv subsystem.
	*
	* The following chart is the recommended NFSv4 enforcement for
	* ability to delete an object.
	*
	* -------------------------------------------------------
	* \| Parent Dir \| Target Object Permissions \|
	* \| permissions \| \|
	* -------------------------------------------------------
	* \| \| ACL Allows \| ACL Denies\| Delete \|
	* \| \| Delete \| Delete \| unspecified\|
	* -------------------------------------------------------
	* \| ACL Allows \| Permit \| Permit \| Permit \|
	* \| DELETE_CHILD \| \|
	* -------------------------------------------------------
	* \| ACL Denies \| Permit \| Deny \| Deny \|
	* \| DELETE_CHILD \| \| \| \|
	* -------------------------------------------------------
	* \| ACL specifies \| \| \| \|
	* \| only allow \| Permit \| Permit \| Permit \|
	* \| write and \| \| \| \|
	* \| execute \| \| \| \|
	* -------------------------------------------------------
	* \| ACL denies \| \| \| \|
	* \| write and \| Permit \| Deny \| Deny \|
	* \| execute \| \| \| \|
	* -------------------------------------------------------
	* ^
	* \|
	* No search privilege, can't even look up file?
	*
	*/
	int
	zfs_zaccess_delete(znode_t dzp, znode_t zp, cred_t *cr)
	{
	uint32_t dzp_working_mode = 0;
	uint32_t zp_working_mode = 0;
	int dzp_error, zp_error;
	mode_t available_perms;
	boolean_t dzpcheck_privs = B_TRUE;
	boolean_t zpcheck_privs = B_TRUE;

	/*
	* We want specific DELETE permissions to
	* take precedence over WRITE/EXECUTE. We don't
	* want an ACL such as this to mess us up.
	* user:joe:write_data:deny,user:joe:delete:allow
	*
	* However, deny permissions may ultimately be overridden
	* by secpolicy_vnode_access().
	*
	* We will ask for all of the necessary permissions and then
	* look at the working modes from the directory and target object
	* to determine what was found.
	*/

	if (zp->z_pflags & (ZFS_IMMUTABLE \| ZFS_NOUNLINK))
	return (SET_ERROR(EPERM));

	/*
	* First row
	* If the directory permissions allow the delete, we are done.
	*/
	if ((dzp_error = zfs_zaccess_common(dzp, ACE_DELETE_CHILD,
	&dzp_working_mode, &dzpcheck_privs, B_FALSE, cr)) == 0)
	return (0);

	/*
	* If target object has delete permission then we are done
	*/
	if ((zp_error = zfs_zaccess_common(zp, ACE_DELETE, &zp_working_mode,
	&zpcheck_privs, B_FALSE, cr)) == 0)
	return (0);

	ASSERT(dzp_error && zp_error);

	if (!dzpcheck_privs)
	return (dzp_error);
	if (!zpcheck_privs)
	return (zp_error);

	/*
	* Second row
	*
	* If directory returns EACCES then delete_child was denied
	* due to deny delete_child. In this case send the request through
	* secpolicy_vnode_remove(). We don't use zfs_delete_final_check()
	* since that could allow the delete based on write/execute permission
	* and we want delete permissions to override write/execute.
	*/

	if (dzp_error == EACCES) {
	/* XXXPJD: s/dzp/zp/ ? */
	return (secpolicy_vnode_remove(ZTOV(dzp), cr));
	}
	/*
	* Third Row
	* only need to see if we have write/execute on directory.
	*/

	dzp_error = zfs_zaccess_common(dzp, ACE_EXECUTE\|ACE_WRITE_DATA,
	&dzp_working_mode, &dzpcheck_privs, B_FALSE, cr);

	if (dzp_error != 0 && !dzpcheck_privs)
	return (dzp_error);

	/*
	* Fourth row
	*/

	available_perms = (dzp_working_mode & ACE_WRITE_DATA) ? 0 : VWRITE;
	available_perms \|= (dzp_working_mode & ACE_EXECUTE) ? 0 : VEXEC;

	return (zfs_delete_final_check(zp, dzp, available_perms, cr));

	}

	int
	zfs_zaccess_rename(znode_t sdzp, znode_t szp, znode_t *tdzp,
	znode_t tzp, cred_t cr)
	{
	int add_perm;
	int error;

	if (szp->z_pflags & ZFS_AV_QUARANTINED)
	return (SET_ERROR(EACCES));

	add_perm = (ZTOV(szp)->v_type == VDIR) ?
	ACE_ADD_SUBDIRECTORY : ACE_ADD_FILE;

	/*
	* Rename permissions are combination of delete permission +
	* add file/subdir permission.
	*
	* BSD operating systems also require write permission
	* on the directory being moved from one parent directory
	* to another.
	*/
	if (ZTOV(szp)->v_type == VDIR && ZTOV(sdzp) != ZTOV(tdzp)) {
	if ((error = zfs_zaccess(szp, ACE_WRITE_DATA, 0, B_FALSE, cr)))
	return (error);
	}

	/*
	* first make sure we do the delete portion.
	*
	* If that succeeds then check for add_file/add_subdir permissions
	*/

	if ((error = zfs_zaccess_delete(sdzp, szp, cr)))
	return (error);

	/*
	* If we have a tzp, see if we can delete it?
	*/
	if (tzp && (error = zfs_zaccess_delete(tdzp, tzp, cr)))
	return (error);

	/*
	* Now check for add permissions
	*/
	error = zfs_zaccess(tdzp, add_perm, 0, B_FALSE, cr);

	return (error);
	}
	diff --git a/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_debug.c b/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_debug.c
	index 74742ad3669f..7239db80851c 100644
	--- a/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_debug.c
	+++ b/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_debug.c
	@@ -1,251 +1,254 @@
	/*
	* 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) 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2012, 2014 by Delphix. All rights reserved.
	*/

	#include <sys/zfs_context.h>
	#include <sys/kstat.h>

	typedef struct zfs_dbgmsg {
	list_node_t zdm_node;
	time_t zdm_timestamp;
	int zdm_size;
	char zdm_msg[1]; /* variable length allocation */
	} zfs_dbgmsg_t;

	list_t zfs_dbgmsgs;
	int zfs_dbgmsg_size = 0;
	kmutex_t zfs_dbgmsgs_lock;
	int zfs_dbgmsg_maxsize = 4<<20; /* 4MB */
	kstat_t *zfs_dbgmsg_kstat;

	/*
	* Internal ZFS debug messages are enabled by default.
	*
	- * # Print debug messages
	+ * # Print debug messages as they're logged
	* dtrace -n 'zfs-dbgmsg { print(stringof(arg0)); }'
	*
	+ * # Print all logged dbgmsg entries
	+ * sysctl kstat.zfs.misc.dbgmsg
	+ *
	* # Disable the kernel debug message log.
	* sysctl vfs.zfs.dbgmsg_enable=0
	*/
	int zfs_dbgmsg_enable = 1;

	static int
	zfs_dbgmsg_headers(char *buf, size_t size)
	{
	(void) snprintf(buf, size, "%-12s %-8s\n", "timestamp", "message");

	return (0);
	}

	static int
	zfs_dbgmsg_data(char buf, size_t size, void data)
	{
	zfs_dbgmsg_t zdm = (zfs_dbgmsg_t )data;

	(void) snprintf(buf, size, "%-12llu %-s\n",
	(u_longlong_t)zdm->zdm_timestamp, zdm->zdm_msg);

	return (0);
	}

	static void *
	zfs_dbgmsg_addr(kstat_t *ksp, loff_t n)
	{
	zfs_dbgmsg_t zdm = (zfs_dbgmsg_t )ksp->ks_private;

	ASSERT(MUTEX_HELD(&zfs_dbgmsgs_lock));

	if (n == 0)
	ksp->ks_private = list_head(&zfs_dbgmsgs);
	else if (zdm)
	ksp->ks_private = list_next(&zfs_dbgmsgs, zdm);

	return (ksp->ks_private);
	}

	static void
	zfs_dbgmsg_purge(int max_size)
	{
	zfs_dbgmsg_t *zdm;
	int size;

	ASSERT(MUTEX_HELD(&zfs_dbgmsgs_lock));

	while (zfs_dbgmsg_size > max_size) {
	zdm = list_remove_head(&zfs_dbgmsgs);
	if (zdm == NULL)
	return;

	size = zdm->zdm_size;
	kmem_free(zdm, size);
	zfs_dbgmsg_size -= size;
	}
	}

	static int
	zfs_dbgmsg_update(kstat_t *ksp, int rw)
	{
	if (rw == KSTAT_WRITE)
	zfs_dbgmsg_purge(0);

	return (0);
	}

	void
	zfs_dbgmsg_init(void)
	{
	list_create(&zfs_dbgmsgs, sizeof (zfs_dbgmsg_t),
	offsetof(zfs_dbgmsg_t, zdm_node));
	mutex_init(&zfs_dbgmsgs_lock, NULL, MUTEX_DEFAULT, NULL);

	zfs_dbgmsg_kstat = kstat_create("zfs", 0, "dbgmsg", "misc",
	KSTAT_TYPE_RAW, 0, KSTAT_FLAG_VIRTUAL);
	if (zfs_dbgmsg_kstat) {
	zfs_dbgmsg_kstat->ks_lock = &zfs_dbgmsgs_lock;
	zfs_dbgmsg_kstat->ks_ndata = UINT32_MAX;
	zfs_dbgmsg_kstat->ks_private = NULL;
	zfs_dbgmsg_kstat->ks_update = zfs_dbgmsg_update;
	kstat_set_raw_ops(zfs_dbgmsg_kstat, zfs_dbgmsg_headers,
	zfs_dbgmsg_data, zfs_dbgmsg_addr);
	kstat_install(zfs_dbgmsg_kstat);
	}
	}

	void
	zfs_dbgmsg_fini(void)
	{
	if (zfs_dbgmsg_kstat)
	kstat_delete(zfs_dbgmsg_kstat);
	/*
	* TODO - decide how to make this permanent
	*/
	#ifdef _KERNEL
	mutex_enter(&zfs_dbgmsgs_lock);
	zfs_dbgmsg_purge(0);
	mutex_exit(&zfs_dbgmsgs_lock);
	mutex_destroy(&zfs_dbgmsgs_lock);
	#endif
	}

	void
	__zfs_dbgmsg(char *buf)
	{
	zfs_dbgmsg_t *zdm;
	int size;

	DTRACE_PROBE1(zfs__dbgmsg, char *, buf);

	size = sizeof (zfs_dbgmsg_t) + strlen(buf);
	zdm = kmem_zalloc(size, KM_SLEEP);
	zdm->zdm_size = size;
	zdm->zdm_timestamp = gethrestime_sec();
	strcpy(zdm->zdm_msg, buf);

	mutex_enter(&zfs_dbgmsgs_lock);
	list_insert_tail(&zfs_dbgmsgs, zdm);
	zfs_dbgmsg_size += size;
	zfs_dbgmsg_purge(MAX(zfs_dbgmsg_maxsize, 0));
	mutex_exit(&zfs_dbgmsgs_lock);
	}

	void
	__set_error(const char file, const char func, int line, int err)
	{
	/*
	* To enable this:
	*
	* $ echo 512 >/sys/module/zfs/parameters/zfs_flags
	*/
	if (zfs_flags & ZFS_DEBUG_SET_ERROR)
	__dprintf(B_FALSE, file, func, line, "error %lu", err);
	}

	#ifdef _KERNEL
	void
	__dprintf(boolean_t dprint, const char file, const char func,
	int line, const char *fmt, ...)
	{
	const char *newfile;
	va_list adx;
	size_t size;
	char *buf;
	char *nl;
	int i;

	size = 1024;
	buf = kmem_alloc(size, KM_SLEEP);

	/*
	* Get rid of annoying prefix to filename.
	*/
	newfile = strrchr(file, '/');
	if (newfile != NULL) {
	newfile = newfile + 1; /* Get rid of leading / */
	} else {
	newfile = file;
	}

	i = snprintf(buf, size, "%s:%d:%s(): ", newfile, line, func);

	if (i < size) {
	va_start(adx, fmt);
	(void) vsnprintf(buf + i, size - i, fmt, adx);
	va_end(adx);
	}

	/*
	* Get rid of trailing newline.
	*/
	nl = strrchr(buf, '\n');
	if (nl != NULL)
	*nl = '\0';

	__zfs_dbgmsg(buf);

	kmem_free(buf, size);
	}

	#else

	void
	zfs_dbgmsg_print(const char *tag)
	{
	zfs_dbgmsg_t *zdm;

	(void) printf("ZFS_DBGMSG(%s):\n", tag);
	mutex_enter(&zfs_dbgmsgs_lock);
	for (zdm = list_head(&zfs_dbgmsgs); zdm;
	zdm = list_next(&zfs_dbgmsgs, zdm))
	(void) printf("%s\n", zdm->zdm_msg);
	mutex_exit(&zfs_dbgmsgs_lock);
	}
	#endif /* _KERNEL */

	/* BEGIN CSTYLED */
	ZFS_MODULE_PARAM(zfs, zfs_, dbgmsg_enable, INT, ZMOD_RW,
	"Enable ZFS debug message log");

	ZFS_MODULE_PARAM(zfs, zfs_, dbgmsg_maxsize, INT, ZMOD_RW,
	"Maximum ZFS debug log size");
	/* END CSTYLED */
	diff --git a/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_dir.c b/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_dir.c
	index de145a677600..899f2473f62a 100644
	--- a/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_dir.c
	+++ b/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_dir.c
	@@ -1,966 +1,966 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2013, 2016 by Delphix. All rights reserved.
	* Copyright 2017 Nexenta Systems, Inc.
	*/

	#include <sys/types.h>
	#include <sys/param.h>
	#include <sys/time.h>
	#include <sys/systm.h>
	#include <sys/sysmacros.h>
	#include <sys/resource.h>
	#include <sys/vfs.h>
	#include <sys/vnode.h>
	#include <sys/extdirent.h>
	#include <sys/file.h>
	#include <sys/kmem.h>
	#include <sys/uio.h>
	#include <sys/cmn_err.h>
	#include <sys/errno.h>
	#include <sys/stat.h>
	#include <sys/unistd.h>
	#include <sys/sunddi.h>
	#include <sys/random.h>
	#include <sys/policy.h>
	#include <sys/condvar.h>
	#include <sys/callb.h>
	#include <sys/smp.h>
	#include <sys/zfs_dir.h>
	#include <sys/zfs_acl.h>
	#include <sys/fs/zfs.h>
	#include <sys/zap.h>
	#include <sys/dmu.h>
	#include <sys/atomic.h>
	#include <sys/zfs_ctldir.h>
	#include <sys/zfs_fuid.h>
	#include <sys/sa.h>
	#include <sys/zfs_sa.h>
	#include <sys/dmu_objset.h>
	#include <sys/dsl_dir.h>

	#include <sys/ccompat.h>

	/*
	* zfs_match_find() is used by zfs_dirent_lookup() to perform zap lookups
	* of names after deciding which is the appropriate lookup interface.
	*/
	static int
	zfs_match_find(zfsvfs_t zfsvfs, znode_t dzp, const char *name,
	matchtype_t mt, uint64_t *zoid)
	{
	int error;

	if (zfsvfs->z_norm) {

	/*
	* In the non-mixed case we only expect there would ever
	* be one match, but we need to use the normalizing lookup.
	*/
	error = zap_lookup_norm(zfsvfs->z_os, dzp->z_id, name, 8, 1,
	zoid, mt, NULL, 0, NULL);
	} else {
	error = zap_lookup(zfsvfs->z_os, dzp->z_id, name, 8, 1, zoid);
	}
	zoid = ZFS_DIRENT_OBJ(zoid);

	return (error);
	}

	/*
	* Look up a directory entry under a locked vnode.
	* dvp being locked gives us a guarantee that there are no concurrent
	* modification of the directory and, thus, if a node can be found in
	* the directory, then it must not be unlinked.
	*
	* Input arguments:
	* dzp - znode for directory
	* name - name of entry to lock
	* flag - ZNEW: if the entry already exists, fail with EEXIST.
	* ZEXISTS: if the entry does not exist, fail with ENOENT.
	* ZXATTR: we want dzp's xattr directory
	*
	* Output arguments:
	* zpp - pointer to the znode for the entry (NULL if there isn't one)
	*
	* Return value: 0 on success or errno on failure.
	*
	* NOTE: Always checks for, and rejects, '.' and '..'.
	*/
	int
	zfs_dirent_lookup(znode_t dzp, const char name, znode_t **zpp, int flag)
	{
	zfsvfs_t *zfsvfs = dzp->z_zfsvfs;
	znode_t *zp;
	matchtype_t mt = 0;
	uint64_t zoid;
	int error = 0;

	if (zfsvfs->z_replay == B_FALSE)
	ASSERT_VOP_LOCKED(ZTOV(dzp), __func__);

	*zpp = NULL;

	/*
	* Verify that we are not trying to lock '.', '..', or '.zfs'
	*/
	if (name[0] == '.' &&
	(((name[1] == '\0') \|\| (name[1] == '.' && name[2] == '\0')) \|\|
	(zfs_has_ctldir(dzp) && strcmp(name, ZFS_CTLDIR_NAME) == 0)))
	return (SET_ERROR(EEXIST));

	/*
	* Case sensitivity and normalization preferences are set when
	* the file system is created. These are stored in the
	* zfsvfs->z_case and zfsvfs->z_norm fields. These choices
	* affect how we perform zap lookups.
	*
	* When matching we may need to normalize & change case according to
	* FS settings.
	*
	* Note that a normalized match is necessary for a case insensitive
	* filesystem when the lookup request is not exact because normalization
	* can fold case independent of normalizing code point sequences.
	*
	* See the table above zfs_dropname().
	*/
	if (zfsvfs->z_norm != 0) {
	mt = MT_NORMALIZE;

	/*
	* Determine if the match needs to honor the case specified in
	* lookup, and if so keep track of that so that during
	* normalization we don't fold case.
	*/
	if (zfsvfs->z_case == ZFS_CASE_MIXED) {
	mt \|= MT_MATCH_CASE;
	}
	}

	/*
	* Only look in or update the DNLC if we are looking for the
	* name on a file system that does not require normalization
	* or case folding. We can also look there if we happen to be
	* on a non-normalizing, mixed sensitivity file system IF we
	* are looking for the exact name.
	*
	* NB: we do not need to worry about this flag for ZFS_CASE_SENSITIVE
	* because in that case MT_EXACT and MT_FIRST should produce exactly
	* the same result.
	*/

	if (dzp->z_unlinked && !(flag & ZXATTR))
	return (ENOENT);
	if (flag & ZXATTR) {
	error = sa_lookup(dzp->z_sa_hdl, SA_ZPL_XATTR(zfsvfs), &zoid,
	sizeof (zoid));
	if (error == 0)
	error = (zoid == 0 ? ENOENT : 0);
	} else {
	error = zfs_match_find(zfsvfs, dzp, name, mt, &zoid);
	}
	if (error) {
	if (error != ENOENT \|\| (flag & ZEXISTS)) {
	return (error);
	}
	} else {
	if (flag & ZNEW) {
	return (SET_ERROR(EEXIST));
	}
	error = zfs_zget(zfsvfs, zoid, &zp);
	if (error)
	return (error);
	ASSERT(!zp->z_unlinked);
	*zpp = zp;
	}

	return (0);
	}

	static int
	zfs_dd_lookup(znode_t dzp, znode_t *zpp)
	{
	zfsvfs_t *zfsvfs = dzp->z_zfsvfs;
	znode_t *zp;
	uint64_t parent;
	int error;

	#ifdef ZFS_DEBUG
	if (zfsvfs->z_replay == B_FALSE)
	ASSERT_VOP_LOCKED(ZTOV(dzp), __func__);
	#endif
	if (dzp->z_unlinked)
	return (ENOENT);

	if ((error = sa_lookup(dzp->z_sa_hdl,
	SA_ZPL_PARENT(zfsvfs), &parent, sizeof (parent))) != 0)
	return (error);

	error = zfs_zget(zfsvfs, parent, &zp);
	if (error == 0)
	*zpp = zp;
	return (error);
	}

	int
	zfs_dirlook(znode_t dzp, const char name, znode_t **zpp)
	{
	zfsvfs_t *zfsvfs __unused = dzp->z_zfsvfs;
	znode_t *zp = NULL;
	int error = 0;

	#ifdef ZFS_DEBUG
	if (zfsvfs->z_replay == B_FALSE)
	ASSERT_VOP_LOCKED(ZTOV(dzp), __func__);
	#endif
	if (dzp->z_unlinked)
	return (SET_ERROR(ENOENT));

	if (name[0] == 0 \|\| (name[0] == '.' && name[1] == 0)) {
	*zpp = dzp;
	} else if (name[0] == '.' && name[1] == '.' && name[2] == 0) {
	error = zfs_dd_lookup(dzp, &zp);
	if (error == 0)
	*zpp = zp;
	} else {
	error = zfs_dirent_lookup(dzp, name, &zp, ZEXISTS);
	if (error == 0) {
	dzp->z_zn_prefetch = B_TRUE; /* enable prefetching */
	*zpp = zp;
	}
	}
	return (error);
	}

	/*
	* unlinked Set (formerly known as the "delete queue") Error Handling
	*
	* When dealing with the unlinked set, we dmu_tx_hold_zap(), but we
	* don't specify the name of the entry that we will be manipulating. We
	* also fib and say that we won't be adding any new entries to the
	* unlinked set, even though we might (this is to lower the minimum file
	* size that can be deleted in a full filesystem). So on the small
	* chance that the nlink list is using a fat zap (ie. has more than
	* 2000 entries), we may not pre-read a block that's needed.
	* Therefore it is remotely possible for some of the assertions
	* regarding the unlinked set below to fail due to i/o error. On a
	* nondebug system, this will result in the space being leaked.
	*/
	void
	zfs_unlinked_add(znode_t zp, dmu_tx_t tx)
	{
	zfsvfs_t *zfsvfs = zp->z_zfsvfs;

	ASSERT(zp->z_unlinked);
	ASSERT(zp->z_links == 0);

	VERIFY3U(0, ==,
	zap_add_int(zfsvfs->z_os, zfsvfs->z_unlinkedobj, zp->z_id, tx));

	dataset_kstats_update_nunlinks_kstat(&zfsvfs->z_kstat, 1);
	}

	/*
	* Clean up any znodes that had no links when we either crashed or
	* (force) umounted the file system.
	*/
	void
	zfs_unlinked_drain(zfsvfs_t *zfsvfs)
	{
	zap_cursor_t zc;
	zap_attribute_t zap;
	dmu_object_info_t doi;
	znode_t *zp;
	dmu_tx_t *tx;
	int error;

	/*
	* Iterate over the contents of the unlinked set.
	*/
	for (zap_cursor_init(&zc, zfsvfs->z_os, zfsvfs->z_unlinkedobj);
	zap_cursor_retrieve(&zc, &zap) == 0;
	zap_cursor_advance(&zc)) {

	/*
	* See what kind of object we have in list
	*/

	error = dmu_object_info(zfsvfs->z_os,
	zap.za_first_integer, &doi);
	if (error != 0)
	continue;

	ASSERT((doi.doi_type == DMU_OT_PLAIN_FILE_CONTENTS) \|\|
	(doi.doi_type == DMU_OT_DIRECTORY_CONTENTS));
	/*
	* We need to re-mark these list entries for deletion,
	* so we pull them back into core and set zp->z_unlinked.
	*/
	error = zfs_zget(zfsvfs, zap.za_first_integer, &zp);

	/*
	* We may pick up znodes that are already marked for deletion.
	* This could happen during the purge of an extended attribute
	* directory. All we need to do is skip over them, since they
	* are already in the system marked z_unlinked.
	*/
	if (error != 0)
	continue;

	vn_lock(ZTOV(zp), LK_EXCLUSIVE \| LK_RETRY);

	/*
	* Due to changes in zfs_rmnode we need to make sure the
	* link count is set to zero here.
	*/
	if (zp->z_links != 0) {
	tx = dmu_tx_create(zfsvfs->z_os);
	dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
	error = dmu_tx_assign(tx, TXG_WAIT);
	if (error != 0) {
	dmu_tx_abort(tx);
	vput(ZTOV(zp));
	continue;
	}
	zp->z_links = 0;
	VERIFY0(sa_update(zp->z_sa_hdl, SA_ZPL_LINKS(zfsvfs),
	&zp->z_links, sizeof (zp->z_links), tx));
	dmu_tx_commit(tx);
	}

	zp->z_unlinked = B_TRUE;
	vput(ZTOV(zp));
	}
	zap_cursor_fini(&zc);
	}

	/*
	* Delete the entire contents of a directory. Return a count
	* of the number of entries that could not be deleted. If we encounter
	* an error, return a count of at least one so that the directory stays
	* in the unlinked set.
	*
	* NOTE: this function assumes that the directory is inactive,
	* so there is no need to lock its entries before deletion.
	* Also, it assumes the directory contents is only regular
	* files.
	*/
	static int
	zfs_purgedir(znode_t *dzp)
	{
	zap_cursor_t zc;
	zap_attribute_t zap;
	znode_t *xzp;
	dmu_tx_t *tx;
	zfsvfs_t *zfsvfs = dzp->z_zfsvfs;
	int skipped = 0;
	int error;

	for (zap_cursor_init(&zc, zfsvfs->z_os, dzp->z_id);
	(error = zap_cursor_retrieve(&zc, &zap)) == 0;
	zap_cursor_advance(&zc)) {
	error = zfs_zget(zfsvfs,
	ZFS_DIRENT_OBJ(zap.za_first_integer), &xzp);
	if (error) {
	skipped += 1;
	continue;
	}

	vn_lock(ZTOV(xzp), LK_EXCLUSIVE \| LK_RETRY);
	ASSERT((ZTOV(xzp)->v_type == VREG) \|\|
	(ZTOV(xzp)->v_type == VLNK));

	tx = dmu_tx_create(zfsvfs->z_os);
	dmu_tx_hold_sa(tx, dzp->z_sa_hdl, B_FALSE);
	dmu_tx_hold_zap(tx, dzp->z_id, FALSE, zap.za_name);
	dmu_tx_hold_sa(tx, xzp->z_sa_hdl, B_FALSE);
	dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, FALSE, NULL);
	/* Is this really needed ? */
	zfs_sa_upgrade_txholds(tx, xzp);
	dmu_tx_mark_netfree(tx);
	error = dmu_tx_assign(tx, TXG_WAIT);
	if (error) {
	dmu_tx_abort(tx);
	vput(ZTOV(xzp));
	skipped += 1;
	continue;
	}

	error = zfs_link_destroy(dzp, zap.za_name, xzp, tx, 0, NULL);
	if (error)
	skipped += 1;
	dmu_tx_commit(tx);

	vput(ZTOV(xzp));
	}
	zap_cursor_fini(&zc);
	if (error != ENOENT)
	skipped += 1;
	return (skipped);
	}

	extern taskq_t *zfsvfs_taskq;

	void
	zfs_rmnode(znode_t *zp)
	{
	zfsvfs_t *zfsvfs = zp->z_zfsvfs;
	objset_t *os = zfsvfs->z_os;
	dmu_tx_t *tx;
	uint64_t acl_obj;
	uint64_t xattr_obj;
	uint64_t count;
	int error;

	ASSERT(zp->z_links == 0);
	if (zfsvfs->z_replay == B_FALSE)
	ASSERT_VOP_ELOCKED(ZTOV(zp), __func__);

	/*
	* If this is an attribute directory, purge its contents.
	*/
	if (ZTOV(zp) != NULL && ZTOV(zp)->v_type == VDIR &&
	(zp->z_pflags & ZFS_XATTR)) {
	if (zfs_purgedir(zp) != 0) {
	/*
	* Not enough space to delete some xattrs.
	* Leave it in the unlinked set.
	*/
	zfs_znode_dmu_fini(zp);
	zfs_znode_free(zp);
	return;
	}
	} else {
	/*
	* Free up all the data in the file. We don't do this for
	* XATTR directories because we need truncate and remove to be
	* in the same tx, like in zfs_znode_delete(). Otherwise, if
	* we crash here we'll end up with an inconsistent truncated
	* zap object in the delete queue. Note a truncated file is
	* harmless since it only contains user data.
	*/
	error = dmu_free_long_range(os, zp->z_id, 0, DMU_OBJECT_END);
	if (error) {
	/*
	* Not enough space or we were interrupted by unmount.
	* Leave the file in the unlinked set.
	*/
	zfs_znode_dmu_fini(zp);
	zfs_znode_free(zp);
	return;
	}
	}

	/*
	* If the file has extended attributes, we're going to unlink
	* the xattr dir.
	*/
	error = sa_lookup(zp->z_sa_hdl, SA_ZPL_XATTR(zfsvfs),
	&xattr_obj, sizeof (xattr_obj));
	if (error)
	xattr_obj = 0;

	acl_obj = zfs_external_acl(zp);

	/*
	* Set up the final transaction.
	*/
	tx = dmu_tx_create(os);
	dmu_tx_hold_free(tx, zp->z_id, 0, DMU_OBJECT_END);
	dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, FALSE, NULL);
	if (xattr_obj)
	dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, TRUE, NULL);
	if (acl_obj)
	dmu_tx_hold_free(tx, acl_obj, 0, DMU_OBJECT_END);

	zfs_sa_upgrade_txholds(tx, zp);
	error = dmu_tx_assign(tx, TXG_WAIT);
	if (error) {
	/*
	* Not enough space to delete the file. Leave it in the
	* unlinked set, leaking it until the fs is remounted (at
	* which point we'll call zfs_unlinked_drain() to process it).
	*/
	dmu_tx_abort(tx);
	zfs_znode_dmu_fini(zp);
	zfs_znode_free(zp);
	return;
	}

	/*
	* FreeBSD's implementation of zfs_zget requires a vnode to back it.
	* This means that we could end up calling into getnewvnode while
	* calling zfs_rmnode as a result of a prior call to getnewvnode
	* trying to clear vnodes out of the cache. If this repeats we can
	* recurse enough that we overflow our stack. To avoid this, we
	* avoid calling zfs_zget on the xattr znode and instead simply add
	* it to the unlinked set and schedule a call to zfs_unlinked_drain.
	*/
	if (xattr_obj) {
	/* Add extended attribute directory to the unlinked set. */
	VERIFY3U(0, ==,
	zap_add_int(os, zfsvfs->z_unlinkedobj, xattr_obj, tx));
	}

	mutex_enter(&os->os_dsl_dataset->ds_dir->dd_activity_lock);

	/* Remove this znode from the unlinked set */
	VERIFY3U(0, ==,
	zap_remove_int(os, zfsvfs->z_unlinkedobj, zp->z_id, tx));

	if (zap_count(os, zfsvfs->z_unlinkedobj, &count) == 0 && count == 0) {
	cv_broadcast(&os->os_dsl_dataset->ds_dir->dd_activity_cv);
	}

	mutex_exit(&os->os_dsl_dataset->ds_dir->dd_activity_lock);

	dataset_kstats_update_nunlinked_kstat(&zfsvfs->z_kstat, 1);

	zfs_znode_delete(zp, tx);

	dmu_tx_commit(tx);

	if (xattr_obj) {
	/*
	* We're using the FreeBSD taskqueue API here instead of
	* the Solaris taskq API since the FreeBSD API allows for a
	* task to be enqueued multiple times but executed once.
	*/
	taskqueue_enqueue(zfsvfs_taskq->tq_queue,
	&zfsvfs->z_unlinked_drain_task);
	}
	}

	static uint64_t
	zfs_dirent(znode_t *zp, uint64_t mode)
	{
	uint64_t de = zp->z_id;

	if (zp->z_zfsvfs->z_version >= ZPL_VERSION_DIRENT_TYPE)
	de \|= IFTODT(mode) << 60;
	return (de);
	}

	/*
	* Link zp into dzp. Can only fail if zp has been unlinked.
	*/
	int
	zfs_link_create(znode_t dzp, const char name, znode_t zp, dmu_tx_t tx,
	int flag)
	{
	zfsvfs_t *zfsvfs = zp->z_zfsvfs;
	vnode_t *vp = ZTOV(zp);
	uint64_t value;
	int zp_is_dir = (vp->v_type == VDIR);
	sa_bulk_attr_t bulk[5];
	uint64_t mtime[2], ctime[2];
	int count = 0;
	int error;

	if (zfsvfs->z_replay == B_FALSE) {
	ASSERT_VOP_ELOCKED(ZTOV(dzp), __func__);
	ASSERT_VOP_ELOCKED(ZTOV(zp), __func__);
	}
	if (zp_is_dir) {
	if (dzp->z_links >= ZFS_LINK_MAX)
	return (SET_ERROR(EMLINK));
	}
	if (!(flag & ZRENAMING)) {
	if (zp->z_unlinked) { /* no new links to unlinked zp */
	ASSERT(!(flag & (ZNEW \| ZEXISTS)));
	return (SET_ERROR(ENOENT));
	}
	if (zp->z_links >= ZFS_LINK_MAX - zp_is_dir) {
	return (SET_ERROR(EMLINK));
	}
	zp->z_links++;
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_LINKS(zfsvfs), NULL,
	&zp->z_links, sizeof (zp->z_links));

	} else {
	ASSERT(zp->z_unlinked == 0);
	}
	value = zfs_dirent(zp, zp->z_mode);
	error = zap_add(zp->z_zfsvfs->z_os, dzp->z_id, name,
	8, 1, &value, tx);

	/*
	* zap_add could fail to add the entry if it exceeds the capacity of the
	* leaf-block and zap_leaf_split() failed to help.
	* The caller of this routine is responsible for failing the transaction
	* which will rollback the SA updates done above.
	*/
	if (error != 0) {
	if (!(flag & ZRENAMING) && !(flag & ZNEW))
	zp->z_links--;
	return (error);
	}

	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_PARENT(zfsvfs), NULL,
	&dzp->z_id, sizeof (dzp->z_id));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zfsvfs), NULL,
	&zp->z_pflags, sizeof (zp->z_pflags));

	if (!(flag & ZNEW)) {
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs), NULL,
	ctime, sizeof (ctime));
	zfs_tstamp_update_setup(zp, STATE_CHANGED, mtime,
	ctime);
	}
	error = sa_bulk_update(zp->z_sa_hdl, bulk, count, tx);
	ASSERT0(error);

	dzp->z_size++;
	dzp->z_links += zp_is_dir;
	count = 0;
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_SIZE(zfsvfs), NULL,
	&dzp->z_size, sizeof (dzp->z_size));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_LINKS(zfsvfs), NULL,
	&dzp->z_links, sizeof (dzp->z_links));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zfsvfs), NULL,
	mtime, sizeof (mtime));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs), NULL,
	ctime, sizeof (ctime));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zfsvfs), NULL,
	&dzp->z_pflags, sizeof (dzp->z_pflags));
	zfs_tstamp_update_setup(dzp, CONTENT_MODIFIED, mtime, ctime);
	error = sa_bulk_update(dzp->z_sa_hdl, bulk, count, tx);
	ASSERT0(error);
	return (0);
	}

	/*
	* The match type in the code for this function should conform to:
	*
	* ------------------------------------------------------------------------
	* fs type \| z_norm \| lookup type \| match type
	* ---------\|-------------\|-------------\|----------------------------------
	* CS !norm \| 0 \| 0 \| 0 (exact)
	* CS norm \| formX \| 0 \| MT_NORMALIZE
	* CI !norm \| upper \| !ZCIEXACT \| MT_NORMALIZE
	* CI !norm \| upper \| ZCIEXACT \| MT_NORMALIZE \| MT_MATCH_CASE
	* CI norm \| upper\|formX \| !ZCIEXACT \| MT_NORMALIZE
	* CI norm \| upper\|formX \| ZCIEXACT \| MT_NORMALIZE \| MT_MATCH_CASE
	* CM !norm \| upper \| !ZCILOOK \| MT_NORMALIZE \| MT_MATCH_CASE
	* CM !norm \| upper \| ZCILOOK \| MT_NORMALIZE
	* CM norm \| upper\|formX \| !ZCILOOK \| MT_NORMALIZE \| MT_MATCH_CASE
	* CM norm \| upper\|formX \| ZCILOOK \| MT_NORMALIZE
	*
	* Abbreviations:
	* CS = Case Sensitive, CI = Case Insensitive, CM = Case Mixed
	* upper = case folding set by fs type on creation (U8_TEXTPREP_TOUPPER)
	* formX = unicode normalization form set on fs creation
	*/
	static int
	zfs_dropname(znode_t dzp, const char name, znode_t zp, dmu_tx_t tx,
	int flag)
	{
	int error;

	if (zp->z_zfsvfs->z_norm) {
	matchtype_t mt = MT_NORMALIZE;

	if (zp->z_zfsvfs->z_case == ZFS_CASE_MIXED) {
	mt \|= MT_MATCH_CASE;
	}

	error = zap_remove_norm(zp->z_zfsvfs->z_os, dzp->z_id,
	name, mt, tx);
	} else {
	error = zap_remove(zp->z_zfsvfs->z_os, dzp->z_id, name, tx);
	}

	return (error);
	}

	/*
	* Unlink zp from dzp, and mark zp for deletion if this was the last link.
	* Can fail if zp is a mount point (EBUSY) or a non-empty directory (EEXIST).
	* If 'unlinkedp' is NULL, we put unlinked znodes on the unlinked list.
	* If it's non-NULL, we use it to indicate whether the znode needs deletion,
	* and it's the caller's job to do it.
	*/
	int
	zfs_link_destroy(znode_t dzp, const char name, znode_t zp, dmu_tx_t tx,
	int flag, boolean_t *unlinkedp)
	{
	zfsvfs_t *zfsvfs = dzp->z_zfsvfs;
	vnode_t *vp = ZTOV(zp);
	int zp_is_dir = (vp->v_type == VDIR);
	boolean_t unlinked = B_FALSE;
	sa_bulk_attr_t bulk[5];
	uint64_t mtime[2], ctime[2];
	int count = 0;
	int error;

	if (zfsvfs->z_replay == B_FALSE) {
	ASSERT_VOP_ELOCKED(ZTOV(dzp), __func__);
	ASSERT_VOP_ELOCKED(ZTOV(zp), __func__);
	}
	if (!(flag & ZRENAMING)) {

	if (zp_is_dir && !zfs_dirempty(zp))
	return (SET_ERROR(ENOTEMPTY));

	/*
	* If we get here, we are going to try to remove the object.
	* First try removing the name from the directory; if that
	* fails, return the error.
	*/
	error = zfs_dropname(dzp, name, zp, tx, flag);
	if (error != 0) {
	return (error);
	}

	if (zp->z_links <= zp_is_dir) {
	zfs_panic_recover("zfs: link count on vnode %p is %u, "
	"should be at least %u", zp->z_vnode,
	(int)zp->z_links,
	zp_is_dir + 1);
	zp->z_links = zp_is_dir + 1;
	}
	if (--zp->z_links == zp_is_dir) {
	zp->z_unlinked = B_TRUE;
	zp->z_links = 0;
	unlinked = B_TRUE;
	} else {
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs),
	NULL, &ctime, sizeof (ctime));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zfsvfs),
	NULL, &zp->z_pflags, sizeof (zp->z_pflags));
	zfs_tstamp_update_setup(zp, STATE_CHANGED, mtime,
	ctime);
	}
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_LINKS(zfsvfs),
	NULL, &zp->z_links, sizeof (zp->z_links));
	error = sa_bulk_update(zp->z_sa_hdl, bulk, count, tx);
	count = 0;
	ASSERT0(error);
	} else {
	ASSERT(zp->z_unlinked == 0);
	error = zfs_dropname(dzp, name, zp, tx, flag);
	if (error != 0)
	return (error);
	}

	dzp->z_size--; /* one dirent removed */
	dzp->z_links -= zp_is_dir; /* ".." link from zp */
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_LINKS(zfsvfs),
	NULL, &dzp->z_links, sizeof (dzp->z_links));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_SIZE(zfsvfs),
	NULL, &dzp->z_size, sizeof (dzp->z_size));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs),
	NULL, ctime, sizeof (ctime));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zfsvfs),
	NULL, mtime, sizeof (mtime));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zfsvfs),
	NULL, &dzp->z_pflags, sizeof (dzp->z_pflags));
	zfs_tstamp_update_setup(dzp, CONTENT_MODIFIED, mtime, ctime);
	error = sa_bulk_update(dzp->z_sa_hdl, bulk, count, tx);
	ASSERT0(error);

	if (unlinkedp != NULL)
	*unlinkedp = unlinked;
	else if (unlinked)
	zfs_unlinked_add(zp, tx);

	return (0);
	}

	/*
	* Indicate whether the directory is empty.
	*/
	boolean_t
	zfs_dirempty(znode_t *dzp)
	{
	return (dzp->z_size == 2);
	}

	int
	zfs_make_xattrdir(znode_t zp, vattr_t vap, znode_t *xvpp, cred_t cr)
	{
	zfsvfs_t *zfsvfs = zp->z_zfsvfs;
	znode_t *xzp;
	dmu_tx_t *tx;
	int error;
	zfs_acl_ids_t acl_ids;
	boolean_t fuid_dirtied;
	uint64_t parent __unused;

	*xvpp = NULL;

	if ((error = zfs_acl_ids_create(zp, IS_XATTR, vap, cr, NULL,
	&acl_ids)) != 0)
	return (error);
	if (zfs_acl_ids_overquota(zfsvfs, &acl_ids, 0)) {
	zfs_acl_ids_free(&acl_ids);
	return (SET_ERROR(EDQUOT));
	}

	getnewvnode_reserve_();

	tx = dmu_tx_create(zfsvfs->z_os);
	dmu_tx_hold_sa_create(tx, acl_ids.z_aclp->z_acl_bytes +
	ZFS_SA_BASE_ATTR_SIZE);
	dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_TRUE);
	dmu_tx_hold_zap(tx, DMU_NEW_OBJECT, FALSE, NULL);
	fuid_dirtied = zfsvfs->z_fuid_dirty;
	if (fuid_dirtied)
	zfs_fuid_txhold(zfsvfs, tx);
	error = dmu_tx_assign(tx, TXG_WAIT);
	if (error) {
	zfs_acl_ids_free(&acl_ids);
	dmu_tx_abort(tx);
	getnewvnode_drop_reserve();
	return (error);
	}
	zfs_mknode(zp, vap, tx, cr, IS_XATTR, &xzp, &acl_ids);

	if (fuid_dirtied)
	zfs_fuid_sync(zfsvfs, tx);

	#ifdef ZFS_DEBUG
	error = sa_lookup(xzp->z_sa_hdl, SA_ZPL_PARENT(zfsvfs),
	&parent, sizeof (parent));
	ASSERT(error == 0 && parent == zp->z_id);
	#endif

	VERIFY(0 == sa_update(zp->z_sa_hdl, SA_ZPL_XATTR(zfsvfs), &xzp->z_id,
	sizeof (xzp->z_id), tx));

	- (void) zfs_log_create(zfsvfs->z_log, tx, TX_MKXATTR, zp,
	- xzp, "", NULL, acl_ids.z_fuidp, vap);
	+ zfs_log_create(zfsvfs->z_log, tx, TX_MKXATTR, zp, xzp, "", NULL,
	+ acl_ids.z_fuidp, vap);

	zfs_acl_ids_free(&acl_ids);
	dmu_tx_commit(tx);

	getnewvnode_drop_reserve();

	*xvpp = xzp;

	return (0);
	}

	/*
	* Return a znode for the extended attribute directory for zp.
	* If the directory does not already exist, it is created
	*
	* IN: zp - znode to obtain attribute directory from
	* cr - credentials of caller
	* flags - flags from the VOP_LOOKUP call
	*
	* OUT: xzpp - pointer to extended attribute znode
	*
	* RETURN: 0 on success
	* error number on failure
	*/
	int
	zfs_get_xattrdir(znode_t zp, znode_t xzpp, cred_t cr, int flags)
	{
	zfsvfs_t *zfsvfs = zp->z_zfsvfs;
	znode_t *xzp;
	vattr_t va;
	int error;
	top:
	error = zfs_dirent_lookup(zp, "", &xzp, ZXATTR);
	if (error)
	return (error);

	if (xzp != NULL) {
	*xzpp = xzp;
	return (0);
	}


	if (!(flags & CREATE_XATTR_DIR))
	return (SET_ERROR(ENOATTR));

	if (zfsvfs->z_vfs->vfs_flag & VFS_RDONLY) {
	return (SET_ERROR(EROFS));
	}

	/*
	* The ability to 'create' files in an attribute
	* directory comes from the write_xattr permission on the base file.
	*
	* The ability to 'search' an attribute directory requires
	* read_xattr permission on the base file.
	*
	* Once in a directory the ability to read/write attributes
	* is controlled by the permissions on the attribute file.
	*/
	va.va_mask = AT_MODE \| AT_UID \| AT_GID;
	va.va_type = VDIR;
	va.va_mode = S_IFDIR \| S_ISVTX \| 0777;
	zfs_fuid_map_ids(zp, cr, &va.va_uid, &va.va_gid);

	error = zfs_make_xattrdir(zp, &va, xzpp, cr);

	if (error == ERESTART) {
	/* NB: we already did dmu_tx_wait() if necessary */
	goto top;
	}
	if (error == 0)
	VOP_UNLOCK1(ZTOV(*xzpp));

	return (error);
	}

	/*
	* Decide whether it is okay to remove within a sticky directory.
	*
	* In sticky directories, write access is not sufficient;
	* you can remove entries from a directory only if:
	*
	* you own the directory,
	* you own the entry,
	* the entry is a plain file and you have write access,
	* or you are privileged (checked in secpolicy...).
	*
	* The function returns 0 if remove access is granted.
	*/
	int
	zfs_sticky_remove_access(znode_t zdp, znode_t zp, cred_t *cr)
	{
	uid_t uid;
	uid_t downer;
	uid_t fowner;
	zfsvfs_t *zfsvfs = zdp->z_zfsvfs;

	if (zdp->z_zfsvfs->z_replay)
	return (0);

	if ((zdp->z_mode & S_ISVTX) == 0)
	return (0);

	downer = zfs_fuid_map_id(zfsvfs, zdp->z_uid, cr, ZFS_OWNER);
	fowner = zfs_fuid_map_id(zfsvfs, zp->z_uid, cr, ZFS_OWNER);

	if ((uid = crgetuid(cr)) == downer \|\| uid == fowner \|\|
	(ZTOV(zp)->v_type == VREG &&
	zfs_zaccess(zp, ACE_WRITE_DATA, 0, B_FALSE, cr) == 0))
	return (0);
	else
	return (secpolicy_vnode_remove(ZTOV(zp), cr));
	}
	diff --git a/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_file_os.c b/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_file_os.c
	index 06546c12e420..908cff6810eb 100644
	--- a/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_file_os.c
	+++ b/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_file_os.c
	@@ -1,308 +1,306 @@
	/*
	* 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/dmu.h>
	#include <sys/dmu_impl.h>
	#include <sys/dmu_recv.h>
	#include <sys/dmu_tx.h>
	#include <sys/dbuf.h>
	#include <sys/dnode.h>
	#include <sys/zfs_context.h>
	#include <sys/dmu_objset.h>
	#include <sys/dmu_traverse.h>
	#include <sys/dsl_dataset.h>
	#include <sys/dsl_dir.h>
	#include <sys/dsl_pool.h>
	#include <sys/dsl_synctask.h>
	#include <sys/zfs_ioctl.h>
	#include <sys/zap.h>
	#include <sys/zio_checksum.h>
	#include <sys/zfs_znode.h>
	#include <sys/zfs_file.h>
	#include <sys/buf.h>
	#include <sys/stat.h>

	int
	zfs_file_open(const char path, int flags, int mode, zfs_file_t *fpp)
	{
	struct thread *td;
	int rc, fd;

	td = curthread;
	pwd_ensure_dirs();
	/* 12.x doesn't take a const char * */
	rc = kern_openat(td, AT_FDCWD, __DECONST(char *, path),
	UIO_SYSSPACE, flags, mode);
	if (rc)
	return (SET_ERROR(rc));
	fd = td->td_retval[0];
	td->td_retval[0] = 0;
	if (fget(curthread, fd, &cap_no_rights, fpp))
	kern_close(td, fd);
	return (0);
	}

	void
	zfs_file_close(zfs_file_t *fp)
	{
	fo_close(fp, curthread);
	}

	static int
	zfs_file_write_impl(zfs_file_t fp, const void buf, size_t count, loff_t *offp,
	ssize_t *resid)
	{
	ssize_t rc;
	struct uio auio;
	struct thread *td;
	struct iovec aiov;

	td = curthread;
	aiov.iov_base = (void *)(uintptr_t)buf;
	aiov.iov_len = count;
	auio.uio_iov = &aiov;
	auio.uio_iovcnt = 1;
	auio.uio_segflg = UIO_SYSSPACE;
	auio.uio_resid = count;
	auio.uio_rw = UIO_WRITE;
	auio.uio_td = td;
	auio.uio_offset = *offp;

	if ((fp->f_flag & FWRITE) == 0)
	return (SET_ERROR(EBADF));

	if (fp->f_type == DTYPE_VNODE)
	bwillwrite();

	rc = fo_write(fp, &auio, td->td_ucred, FOF_OFFSET, td);
	if (rc)
	return (SET_ERROR(rc));
	if (resid)
	*resid = auio.uio_resid;
	else if (auio.uio_resid)
	return (SET_ERROR(EIO));
	*offp += count - auio.uio_resid;
	return (rc);
	}

	int
	zfs_file_write(zfs_file_t fp, const void buf, size_t count, ssize_t *resid)
	{
	loff_t off = fp->f_offset;
	ssize_t rc;

	rc = zfs_file_write_impl(fp, buf, count, &off, resid);
	if (rc == 0)
	fp->f_offset = off;

	return (SET_ERROR(rc));
	}

	int
	zfs_file_pwrite(zfs_file_t fp, const void buf, size_t count, loff_t off,
	ssize_t *resid)
	{
	return (zfs_file_write_impl(fp, buf, count, &off, resid));
	}

	static int
	zfs_file_read_impl(zfs_file_t fp, void buf, size_t count, loff_t *offp,
	ssize_t *resid)
	{
	ssize_t rc;
	struct uio auio;
	struct thread *td;
	struct iovec aiov;

	td = curthread;
	aiov.iov_base = (void *)(uintptr_t)buf;
	aiov.iov_len = count;
	auio.uio_iov = &aiov;
	auio.uio_iovcnt = 1;
	auio.uio_segflg = UIO_SYSSPACE;
	auio.uio_resid = count;
	auio.uio_rw = UIO_READ;
	auio.uio_td = td;
	auio.uio_offset = *offp;

	if ((fp->f_flag & FREAD) == 0)
	return (SET_ERROR(EBADF));

	rc = fo_read(fp, &auio, td->td_ucred, FOF_OFFSET, td);
	if (rc)
	return (SET_ERROR(rc));
	if (resid)
	*resid = auio.uio_resid;
	*offp += count - auio.uio_resid;
	return (SET_ERROR(0));
	}

	int
	zfs_file_read(zfs_file_t fp, void buf, size_t count, ssize_t *resid)
	{
	loff_t off = fp->f_offset;
	ssize_t rc;

	rc = zfs_file_read_impl(fp, buf, count, &off, resid);
	if (rc == 0)
	fp->f_offset = off;
	return (rc);
	}

	int
	zfs_file_pread(zfs_file_t fp, void buf, size_t count, loff_t off,
	ssize_t *resid)
	{
	return (zfs_file_read_impl(fp, buf, count, &off, resid));
	}

	int
	zfs_file_seek(zfs_file_t fp, loff_t offp, int whence)
	{
	int rc;
	struct thread *td;

	td = curthread;
	if ((fp->f_ops->fo_flags & DFLAG_SEEKABLE) == 0)
	return (SET_ERROR(ESPIPE));
	rc = fo_seek(fp, *offp, whence, td);
	if (rc == 0)
	*offp = td->td_uretoff.tdu_off;
	return (SET_ERROR(rc));
	}

	int
	zfs_file_getattr(zfs_file_t fp, zfs_file_attr_t zfattr)
	{
	struct thread *td;
	struct stat sb;
	int rc;

	td = curthread;

	rc = fo_stat(fp, &sb, td->td_ucred, td);
	if (rc)
	return (SET_ERROR(rc));
	zfattr->zfa_size = sb.st_size;
	zfattr->zfa_mode = sb.st_mode;

	return (0);
	}

	static __inline int
	zfs_vop_fsync(vnode_t *vp)
	{
	struct mount *mp;
	int error;

	if ((error = vn_start_write(vp, &mp, V_WAIT \| PCATCH)) != 0)
	goto drop;
	vn_lock(vp, LK_EXCLUSIVE \| LK_RETRY);
	error = VOP_FSYNC(vp, MNT_WAIT, curthread);
	VOP_UNLOCK1(vp);
	vn_finished_write(mp);
	drop:
	return (SET_ERROR(error));
	}

	int
	zfs_file_fsync(zfs_file_t *fp, int flags)
	{
	if (fp->f_type != DTYPE_VNODE)
	return (EINVAL);

	return (zfs_vop_fsync(fp->f_vnode));
	}

	int
	zfs_file_get(int fd, zfs_file_t **fpp)
	{
	struct file *fp;

	if (fget(curthread, fd, &cap_no_rights, &fp))
	return (SET_ERROR(EBADF));

	*fpp = fp;
	return (0);
	}

	void
	zfs_file_put(int fd)
	{
	struct file *fp;

	/* No CAP_ rights required, as we're only releasing. */
	if (fget(curthread, fd, &cap_no_rights, &fp) == 0) {
	fdrop(fp, curthread);
	fdrop(fp, curthread);
	}
	}

	loff_t
	zfs_file_off(zfs_file_t *fp)
	{
	return (fp->f_offset);
	}

	void *
	zfs_file_private(zfs_file_t *fp)
	{
	file_t *tmpfp;
	void *data;
	int error;

	tmpfp = curthread->td_fpop;
	curthread->td_fpop = fp;
	error = devfs_get_cdevpriv(&data);
	curthread->td_fpop = tmpfp;
	if (error != 0)
	return (NULL);
	return (data);
	}

	int
	zfs_file_unlink(const char *fnamep)
	{
	zfs_uio_seg_t seg = UIO_SYSSPACE;
	int rc;

	#if __FreeBSD_version >= 1300018
	rc = kern_funlinkat(curthread, AT_FDCWD, fnamep, FD_NONE, seg, 0, 0);
	-#else
	-#ifdef AT_BENEATH
	+#elif __FreeBSD_version >= 1202504 \|\| defined(AT_BENEATH)
	rc = kern_unlinkat(curthread, AT_FDCWD, __DECONST(char *, fnamep),
	seg, 0, 0);
	#else
	rc = kern_unlinkat(curthread, AT_FDCWD, __DECONST(char *, fnamep),
	seg, 0);
	-#endif
	#endif
	return (SET_ERROR(rc));
	}
	diff --git a/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_vfsops.c b/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_vfsops.c
	index a537342f9678..79beddea8193 100644
	--- a/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_vfsops.c
	+++ b/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_vfsops.c
	@@ -1,2316 +1,2316 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2011 Pawel Jakub Dawidek <pawel@dawidek.net>.
	* All rights reserved.
	* Copyright (c) 2012, 2015 by Delphix. All rights reserved.
	* Copyright (c) 2014 Integros [integros.com]
	* Copyright 2016 Nexenta Systems, Inc. All rights reserved.
	*/

	/* Portions Copyright 2010 Robert Milkowski */

	#include <sys/types.h>
	#include <sys/param.h>
	#include <sys/systm.h>
	#include <sys/kernel.h>
	#include <sys/sysmacros.h>
	#include <sys/kmem.h>
	#include <sys/acl.h>
	#include <sys/vnode.h>
	#include <sys/vfs.h>
	#include <sys/mntent.h>
	#include <sys/mount.h>
	#include <sys/cmn_err.h>
	#include <sys/zfs_znode.h>
	#include <sys/zfs_vnops.h>
	#include <sys/zfs_dir.h>
	#include <sys/zil.h>
	#include <sys/fs/zfs.h>
	#include <sys/dmu.h>
	#include <sys/dsl_prop.h>
	#include <sys/dsl_dataset.h>
	#include <sys/dsl_deleg.h>
	#include <sys/spa.h>
	#include <sys/zap.h>
	#include <sys/sa.h>
	#include <sys/sa_impl.h>
	#include <sys/policy.h>
	#include <sys/atomic.h>
	#include <sys/zfs_ioctl.h>
	#include <sys/zfs_ctldir.h>
	#include <sys/zfs_fuid.h>
	#include <sys/sunddi.h>
	#include <sys/dmu_objset.h>
	#include <sys/dsl_dir.h>
	#include <sys/spa_boot.h>
	#include <sys/jail.h>
	#include <ufs/ufs/quota.h>
	#include <sys/zfs_quota.h>

	#include "zfs_comutil.h"

	#ifndef MNTK_VMSETSIZE_BUG
	#define MNTK_VMSETSIZE_BUG 0
	#endif
	#ifndef MNTK_NOMSYNC
	#define MNTK_NOMSYNC 8
	#endif

	/* BEGIN CSTYLED */
	struct mtx zfs_debug_mtx;
	MTX_SYSINIT(zfs_debug_mtx, &zfs_debug_mtx, "zfs_debug", MTX_DEF);

	SYSCTL_NODE(_vfs, OID_AUTO, zfs, CTLFLAG_RW, 0, "ZFS file system");

	int zfs_super_owner;
	SYSCTL_INT(_vfs_zfs, OID_AUTO, super_owner, CTLFLAG_RW, &zfs_super_owner, 0,
	"File system owner can perform privileged operation on his file systems");

	int zfs_debug_level;
	SYSCTL_INT(_vfs_zfs, OID_AUTO, debug, CTLFLAG_RWTUN, &zfs_debug_level, 0,
	"Debug level");

	SYSCTL_NODE(_vfs_zfs, OID_AUTO, version, CTLFLAG_RD, 0, "ZFS versions");
	static int zfs_version_acl = ZFS_ACL_VERSION;
	SYSCTL_INT(_vfs_zfs_version, OID_AUTO, acl, CTLFLAG_RD, &zfs_version_acl, 0,
	"ZFS_ACL_VERSION");
	static int zfs_version_spa = SPA_VERSION;
	SYSCTL_INT(_vfs_zfs_version, OID_AUTO, spa, CTLFLAG_RD, &zfs_version_spa, 0,
	"SPA_VERSION");
	static int zfs_version_zpl = ZPL_VERSION;
	SYSCTL_INT(_vfs_zfs_version, OID_AUTO, zpl, CTLFLAG_RD, &zfs_version_zpl, 0,
	"ZPL_VERSION");
	/* END CSTYLED */

	static int zfs_quotactl(vfs_t vfsp, int cmds, uid_t id, void arg);
	static int zfs_mount(vfs_t *vfsp);
	static int zfs_umount(vfs_t *vfsp, int fflag);
	static int zfs_root(vfs_t vfsp, int flags, vnode_t *vpp);
	static int zfs_statfs(vfs_t vfsp, struct statfs statp);
	static int zfs_vget(vfs_t vfsp, ino_t ino, int flags, vnode_t *vpp);
	static int zfs_sync(vfs_t *vfsp, int waitfor);
	#if __FreeBSD_version >= 1300098
	static int zfs_checkexp(vfs_t vfsp, struct sockaddr nam, uint64_t *extflagsp,
	struct ucred *credanonp, int numsecflavors, int *secflavors);
	#else
	static int zfs_checkexp(vfs_t vfsp, struct sockaddr nam, int *extflagsp,
	struct ucred *credanonp, int numsecflavors, int **secflavors);
	#endif
	static int zfs_fhtovp(vfs_t vfsp, fid_t fidp, int flags, vnode_t **vpp);
	static void zfs_freevfs(vfs_t *vfsp);

	struct vfsops zfs_vfsops = {
	.vfs_mount = zfs_mount,
	.vfs_unmount = zfs_umount,
	#if __FreeBSD_version >= 1300049
	.vfs_root = vfs_cache_root,
	.vfs_cachedroot = zfs_root,
	#else
	.vfs_root = zfs_root,
	#endif
	.vfs_statfs = zfs_statfs,
	.vfs_vget = zfs_vget,
	.vfs_sync = zfs_sync,
	.vfs_checkexp = zfs_checkexp,
	.vfs_fhtovp = zfs_fhtovp,
	.vfs_quotactl = zfs_quotactl,
	};

	VFS_SET(zfs_vfsops, zfs, VFCF_JAIL \| VFCF_DELEGADMIN);

	/*
	* We need to keep a count of active fs's.
	* This is necessary to prevent our module
	* from being unloaded after a umount -f
	*/
	static uint32_t zfs_active_fs_count = 0;

	int
	zfs_get_temporary_prop(dsl_dataset_t ds, zfs_prop_t zfs_prop, uint64_t val,
	char *setpoint)
	{
	int error;
	zfsvfs_t *zfvp;
	vfs_t *vfsp;
	objset_t *os;
	uint64_t tmp = *val;

	error = dmu_objset_from_ds(ds, &os);
	if (error != 0)
	return (error);

	error = getzfsvfs_impl(os, &zfvp);
	if (error != 0)
	return (error);
	if (zfvp == NULL)
	return (ENOENT);
	vfsp = zfvp->z_vfs;
	switch (zfs_prop) {
	case ZFS_PROP_ATIME:
	if (vfs_optionisset(vfsp, MNTOPT_NOATIME, NULL))
	tmp = 0;
	if (vfs_optionisset(vfsp, MNTOPT_ATIME, NULL))
	tmp = 1;
	break;
	case ZFS_PROP_DEVICES:
	if (vfs_optionisset(vfsp, MNTOPT_NODEVICES, NULL))
	tmp = 0;
	if (vfs_optionisset(vfsp, MNTOPT_DEVICES, NULL))
	tmp = 1;
	break;
	case ZFS_PROP_EXEC:
	if (vfs_optionisset(vfsp, MNTOPT_NOEXEC, NULL))
	tmp = 0;
	if (vfs_optionisset(vfsp, MNTOPT_EXEC, NULL))
	tmp = 1;
	break;
	case ZFS_PROP_SETUID:
	if (vfs_optionisset(vfsp, MNTOPT_NOSETUID, NULL))
	tmp = 0;
	if (vfs_optionisset(vfsp, MNTOPT_SETUID, NULL))
	tmp = 1;
	break;
	case ZFS_PROP_READONLY:
	if (vfs_optionisset(vfsp, MNTOPT_RW, NULL))
	tmp = 0;
	if (vfs_optionisset(vfsp, MNTOPT_RO, NULL))
	tmp = 1;
	break;
	case ZFS_PROP_XATTR:
	if (zfvp->z_flags & ZSB_XATTR)
	tmp = zfvp->z_xattr;
	break;
	case ZFS_PROP_NBMAND:
	if (vfs_optionisset(vfsp, MNTOPT_NONBMAND, NULL))
	tmp = 0;
	if (vfs_optionisset(vfsp, MNTOPT_NBMAND, NULL))
	tmp = 1;
	break;
	default:
	vfs_unbusy(vfsp);
	return (ENOENT);
	}

	vfs_unbusy(vfsp);
	if (tmp != *val) {
	(void) strcpy(setpoint, "temporary");
	*val = tmp;
	}
	return (0);
	}

	static int
	zfs_getquota(zfsvfs_t zfsvfs, uid_t id, int isgroup, struct dqblk64 dqp)
	{
	int error = 0;
	char buf[32];
	uint64_t usedobj, quotaobj;
	uint64_t quota, used = 0;
	timespec_t now;

	usedobj = isgroup ? DMU_GROUPUSED_OBJECT : DMU_USERUSED_OBJECT;
	quotaobj = isgroup ? zfsvfs->z_groupquota_obj : zfsvfs->z_userquota_obj;

	if (quotaobj == 0 \|\| zfsvfs->z_replay) {
	error = ENOENT;
	goto done;
	}
	(void) sprintf(buf, "%llx", (longlong_t)id);
	if ((error = zap_lookup(zfsvfs->z_os, quotaobj,
	buf, sizeof (quota), 1, &quota)) != 0) {
	dprintf("%s(%d): quotaobj lookup failed\n",
	__FUNCTION__, __LINE__);
	goto done;
	}
	/*
	* quota(8) uses bsoftlimit as "quoota", and hardlimit as "limit".
	* So we set them to be the same.
	*/
	dqp->dqb_bsoftlimit = dqp->dqb_bhardlimit = btodb(quota);
	error = zap_lookup(zfsvfs->z_os, usedobj, buf, sizeof (used), 1, &used);
	if (error && error != ENOENT) {
	dprintf("%s(%d): usedobj failed; %d\n",
	__FUNCTION__, __LINE__, error);
	goto done;
	}
	dqp->dqb_curblocks = btodb(used);
	dqp->dqb_ihardlimit = dqp->dqb_isoftlimit = 0;
	vfs_timestamp(&now);
	/*
	* Setting this to 0 causes FreeBSD quota(8) to print
	* the number of days since the epoch, which isn't
	* particularly useful.
	*/
	dqp->dqb_btime = dqp->dqb_itime = now.tv_sec;
	done:
	return (error);
	}

	static int
	zfs_quotactl(vfs_t vfsp, int cmds, uid_t id, void arg)
	{
	zfsvfs_t *zfsvfs = vfsp->vfs_data;
	struct thread *td;
	int cmd, type, error = 0;
	int bitsize;
	zfs_userquota_prop_t quota_type;
	struct dqblk64 dqblk = { 0 };

	td = curthread;
	cmd = cmds >> SUBCMDSHIFT;
	type = cmds & SUBCMDMASK;

	ZFS_ENTER(zfsvfs);
	if (id == -1) {
	switch (type) {
	case USRQUOTA:
	id = td->td_ucred->cr_ruid;
	break;
	case GRPQUOTA:
	id = td->td_ucred->cr_rgid;
	break;
	default:
	error = EINVAL;
	if (cmd == Q_QUOTAON \|\| cmd == Q_QUOTAOFF)
	vfs_unbusy(vfsp);
	goto done;
	}
	}
	/*
	* Map BSD type to:
	* ZFS_PROP_USERUSED,
	* ZFS_PROP_USERQUOTA,
	* ZFS_PROP_GROUPUSED,
	* ZFS_PROP_GROUPQUOTA
	*/
	switch (cmd) {
	case Q_SETQUOTA:
	case Q_SETQUOTA32:
	if (type == USRQUOTA)
	quota_type = ZFS_PROP_USERQUOTA;
	else if (type == GRPQUOTA)
	quota_type = ZFS_PROP_GROUPQUOTA;
	else
	error = EINVAL;
	break;
	case Q_GETQUOTA:
	case Q_GETQUOTA32:
	if (type == USRQUOTA)
	quota_type = ZFS_PROP_USERUSED;
	else if (type == GRPQUOTA)
	quota_type = ZFS_PROP_GROUPUSED;
	else
	error = EINVAL;
	break;
	}

	/*
	* Depending on the cmd, we may need to get
	* the ruid and domain (see fuidstr_to_sid?),
	* the fuid (how?), or other information.
	* Create fuid using zfs_fuid_create(zfsvfs, id,
	* ZFS_OWNER or ZFS_GROUP, cr, &fuidp)?
	* I think I can use just the id?
	*
	* Look at zfs_id_overquota() to look up a quota.
	* zap_lookup(something, quotaobj, fuidstring,
	* sizeof (long long), 1, &quota)
	*
	* See zfs_set_userquota() to set a quota.
	*/
	if ((uint32_t)type >= MAXQUOTAS) {
	error = EINVAL;
	goto done;
	}

	switch (cmd) {
	case Q_GETQUOTASIZE:
	bitsize = 64;
	error = copyout(&bitsize, arg, sizeof (int));
	break;
	case Q_QUOTAON:
	// As far as I can tell, you can't turn quotas on or off on zfs
	error = 0;
	vfs_unbusy(vfsp);
	break;
	case Q_QUOTAOFF:
	error = ENOTSUP;
	vfs_unbusy(vfsp);
	break;
	case Q_SETQUOTA:
	error = copyin(arg, &dqblk, sizeof (dqblk));
	if (error == 0)
	error = zfs_set_userquota(zfsvfs, quota_type,
	"", id, dbtob(dqblk.dqb_bhardlimit));
	break;
	case Q_GETQUOTA:
	error = zfs_getquota(zfsvfs, id, type == GRPQUOTA, &dqblk);
	if (error == 0)
	error = copyout(&dqblk, arg, sizeof (dqblk));
	break;
	default:
	error = EINVAL;
	break;
	}
	done:
	ZFS_EXIT(zfsvfs);
	return (error);
	}


	boolean_t
	zfs_is_readonly(zfsvfs_t *zfsvfs)
	{
	return (!!(zfsvfs->z_vfs->vfs_flag & VFS_RDONLY));
	}

	/ARGSUSED/
	static int
	zfs_sync(vfs_t *vfsp, int waitfor)
	{

	/*
	* Data integrity is job one. We don't want a compromised kernel
	* writing to the storage pool, so we never sync during panic.
	*/
	if (panicstr)
	return (0);

	/*
	* Ignore the system syncher. ZFS already commits async data
	* at zfs_txg_timeout intervals.
	*/
	if (waitfor == MNT_LAZY)
	return (0);

	if (vfsp != NULL) {
	/*
	* Sync a specific filesystem.
	*/
	zfsvfs_t *zfsvfs = vfsp->vfs_data;
	dsl_pool_t *dp;
	int error;

	error = vfs_stdsync(vfsp, waitfor);
	if (error != 0)
	return (error);

	ZFS_ENTER(zfsvfs);
	dp = dmu_objset_pool(zfsvfs->z_os);

	/*
	* If the system is shutting down, then skip any
	* filesystems which may exist on a suspended pool.
	*/
	if (rebooting && spa_suspended(dp->dp_spa)) {
	ZFS_EXIT(zfsvfs);
	return (0);
	}

	if (zfsvfs->z_log != NULL)
	zil_commit(zfsvfs->z_log, 0);

	ZFS_EXIT(zfsvfs);
	} else {
	/*
	* Sync all ZFS filesystems. This is what happens when you
	* run sync(8). Unlike other filesystems, ZFS honors the
	* request by waiting for all pools to commit all dirty data.
	*/
	spa_sync_allpools();
	}

	return (0);
	}

	static void
	atime_changed_cb(void *arg, uint64_t newval)
	{
	zfsvfs_t *zfsvfs = arg;

	if (newval == TRUE) {
	zfsvfs->z_atime = TRUE;
	zfsvfs->z_vfs->vfs_flag &= ~MNT_NOATIME;
	vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOATIME);
	vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_ATIME, NULL, 0);
	} else {
	zfsvfs->z_atime = FALSE;
	zfsvfs->z_vfs->vfs_flag \|= MNT_NOATIME;
	vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_ATIME);
	vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOATIME, NULL, 0);
	}
	}

	static void
	xattr_changed_cb(void *arg, uint64_t newval)
	{
	zfsvfs_t *zfsvfs = arg;

	if (newval == ZFS_XATTR_OFF) {
	zfsvfs->z_flags &= ~ZSB_XATTR;
	} else {
	zfsvfs->z_flags \|= ZSB_XATTR;

	if (newval == ZFS_XATTR_SA)
	zfsvfs->z_xattr_sa = B_TRUE;
	else
	zfsvfs->z_xattr_sa = B_FALSE;
	}
	}

	static void
	blksz_changed_cb(void *arg, uint64_t newval)
	{
	zfsvfs_t *zfsvfs = arg;
	ASSERT3U(newval, <=, spa_maxblocksize(dmu_objset_spa(zfsvfs->z_os)));
	ASSERT3U(newval, >=, SPA_MINBLOCKSIZE);
	ASSERT(ISP2(newval));

	zfsvfs->z_max_blksz = newval;
	zfsvfs->z_vfs->mnt_stat.f_iosize = newval;
	}

	static void
	readonly_changed_cb(void *arg, uint64_t newval)
	{
	zfsvfs_t *zfsvfs = arg;

	if (newval) {
	/* XXX locking on vfs_flag? */
	zfsvfs->z_vfs->vfs_flag \|= VFS_RDONLY;
	vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_RW);
	vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_RO, NULL, 0);
	} else {
	/* XXX locking on vfs_flag? */
	zfsvfs->z_vfs->vfs_flag &= ~VFS_RDONLY;
	vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_RO);
	vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_RW, NULL, 0);
	}
	}

	static void
	setuid_changed_cb(void *arg, uint64_t newval)
	{
	zfsvfs_t *zfsvfs = arg;

	if (newval == FALSE) {
	zfsvfs->z_vfs->vfs_flag \|= VFS_NOSETUID;
	vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_SETUID);
	vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOSETUID, NULL, 0);
	} else {
	zfsvfs->z_vfs->vfs_flag &= ~VFS_NOSETUID;
	vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOSETUID);
	vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_SETUID, NULL, 0);
	}
	}

	static void
	exec_changed_cb(void *arg, uint64_t newval)
	{
	zfsvfs_t *zfsvfs = arg;

	if (newval == FALSE) {
	zfsvfs->z_vfs->vfs_flag \|= VFS_NOEXEC;
	vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_EXEC);
	vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NOEXEC, NULL, 0);
	} else {
	zfsvfs->z_vfs->vfs_flag &= ~VFS_NOEXEC;
	vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NOEXEC);
	vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_EXEC, NULL, 0);
	}
	}

	/*
	* The nbmand mount option can be changed at mount time.
	* We can't allow it to be toggled on live file systems or incorrect
	* behavior may be seen from cifs clients
	*
	* This property isn't registered via dsl_prop_register(), but this callback
	* will be called when a file system is first mounted
	*/
	static void
	nbmand_changed_cb(void *arg, uint64_t newval)
	{
	zfsvfs_t *zfsvfs = arg;
	if (newval == FALSE) {
	vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NBMAND);
	vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NONBMAND, NULL, 0);
	} else {
	vfs_clearmntopt(zfsvfs->z_vfs, MNTOPT_NONBMAND);
	vfs_setmntopt(zfsvfs->z_vfs, MNTOPT_NBMAND, NULL, 0);
	}
	}

	static void
	snapdir_changed_cb(void *arg, uint64_t newval)
	{
	zfsvfs_t *zfsvfs = arg;

	zfsvfs->z_show_ctldir = newval;
	}

	static void
	vscan_changed_cb(void *arg, uint64_t newval)
	{
	zfsvfs_t *zfsvfs = arg;

	zfsvfs->z_vscan = newval;
	}

	static void
	acl_mode_changed_cb(void *arg, uint64_t newval)
	{
	zfsvfs_t *zfsvfs = arg;

	zfsvfs->z_acl_mode = newval;
	}

	static void
	acl_inherit_changed_cb(void *arg, uint64_t newval)
	{
	zfsvfs_t *zfsvfs = arg;

	zfsvfs->z_acl_inherit = newval;
	}

	static void
	acl_type_changed_cb(void *arg, uint64_t newval)
	{
	zfsvfs_t *zfsvfs = arg;

	zfsvfs->z_acl_type = newval;
	}

	static int
	zfs_register_callbacks(vfs_t *vfsp)
	{
	struct dsl_dataset *ds = NULL;
	objset_t *os = NULL;
	zfsvfs_t *zfsvfs = NULL;
	uint64_t nbmand;
	boolean_t readonly = B_FALSE;
	boolean_t do_readonly = B_FALSE;
	boolean_t setuid = B_FALSE;
	boolean_t do_setuid = B_FALSE;
	boolean_t exec = B_FALSE;
	boolean_t do_exec = B_FALSE;
	boolean_t xattr = B_FALSE;
	boolean_t atime = B_FALSE;
	boolean_t do_atime = B_FALSE;
	boolean_t do_xattr = B_FALSE;
	int error = 0;

	ASSERT(vfsp);
	zfsvfs = vfsp->vfs_data;
	ASSERT(zfsvfs);
	os = zfsvfs->z_os;

	/*
	* This function can be called for a snapshot when we update snapshot's
	* mount point, which isn't really supported.
	*/
	if (dmu_objset_is_snapshot(os))
	return (EOPNOTSUPP);

	/*
	* The act of registering our callbacks will destroy any mount
	* options we may have. In order to enable temporary overrides
	* of mount options, we stash away the current values and
	* restore them after we register the callbacks.
	*/
	if (vfs_optionisset(vfsp, MNTOPT_RO, NULL) \|\|
	!spa_writeable(dmu_objset_spa(os))) {
	readonly = B_TRUE;
	do_readonly = B_TRUE;
	} else if (vfs_optionisset(vfsp, MNTOPT_RW, NULL)) {
	readonly = B_FALSE;
	do_readonly = B_TRUE;
	}
	if (vfs_optionisset(vfsp, MNTOPT_NOSETUID, NULL)) {
	setuid = B_FALSE;
	do_setuid = B_TRUE;
	} else if (vfs_optionisset(vfsp, MNTOPT_SETUID, NULL)) {
	setuid = B_TRUE;
	do_setuid = B_TRUE;
	}
	if (vfs_optionisset(vfsp, MNTOPT_NOEXEC, NULL)) {
	exec = B_FALSE;
	do_exec = B_TRUE;
	} else if (vfs_optionisset(vfsp, MNTOPT_EXEC, NULL)) {
	exec = B_TRUE;
	do_exec = B_TRUE;
	}
	if (vfs_optionisset(vfsp, MNTOPT_NOXATTR, NULL)) {
	zfsvfs->z_xattr = xattr = ZFS_XATTR_OFF;
	do_xattr = B_TRUE;
	} else if (vfs_optionisset(vfsp, MNTOPT_XATTR, NULL)) {
	zfsvfs->z_xattr = xattr = ZFS_XATTR_DIR;
	do_xattr = B_TRUE;
	} else if (vfs_optionisset(vfsp, MNTOPT_DIRXATTR, NULL)) {
	zfsvfs->z_xattr = xattr = ZFS_XATTR_DIR;
	do_xattr = B_TRUE;
	} else if (vfs_optionisset(vfsp, MNTOPT_SAXATTR, NULL)) {
	zfsvfs->z_xattr = xattr = ZFS_XATTR_SA;
	do_xattr = B_TRUE;
	}
	if (vfs_optionisset(vfsp, MNTOPT_NOATIME, NULL)) {
	atime = B_FALSE;
	do_atime = B_TRUE;
	} else if (vfs_optionisset(vfsp, MNTOPT_ATIME, NULL)) {
	atime = B_TRUE;
	do_atime = B_TRUE;
	}

	/*
	* We need to enter pool configuration here, so that we can use
	* dsl_prop_get_int_ds() to handle the special nbmand property below.
	* dsl_prop_get_integer() can not be used, because it has to acquire
	* spa_namespace_lock and we can not do that because we already hold
	* z_teardown_lock. The problem is that spa_write_cachefile() is called
	* with spa_namespace_lock held and the function calls ZFS vnode
	* operations to write the cache file and thus z_teardown_lock is
	* acquired after spa_namespace_lock.
	*/
	ds = dmu_objset_ds(os);
	dsl_pool_config_enter(dmu_objset_pool(os), FTAG);

	/*
	* nbmand is a special property. It can only be changed at
	* mount time.
	*
	* This is weird, but it is documented to only be changeable
	* at mount time.
	*/
	if (vfs_optionisset(vfsp, MNTOPT_NONBMAND, NULL)) {
	nbmand = B_FALSE;
	} else if (vfs_optionisset(vfsp, MNTOPT_NBMAND, NULL)) {
	nbmand = B_TRUE;
	} else if ((error = dsl_prop_get_int_ds(ds, "nbmand", &nbmand) != 0)) {
	dsl_pool_config_exit(dmu_objset_pool(os), FTAG);
	return (error);
	}

	/*
	* Register property callbacks.
	*
	* It would probably be fine to just check for i/o error from
	* the first prop_register(), but I guess I like to go
	* overboard...
	*/
	error = dsl_prop_register(ds,
	zfs_prop_to_name(ZFS_PROP_ATIME), atime_changed_cb, zfsvfs);
	error = error ? error : dsl_prop_register(ds,
	zfs_prop_to_name(ZFS_PROP_XATTR), xattr_changed_cb, zfsvfs);
	error = error ? error : dsl_prop_register(ds,
	zfs_prop_to_name(ZFS_PROP_RECORDSIZE), blksz_changed_cb, zfsvfs);
	error = error ? error : dsl_prop_register(ds,
	zfs_prop_to_name(ZFS_PROP_READONLY), readonly_changed_cb, zfsvfs);
	error = error ? error : dsl_prop_register(ds,
	zfs_prop_to_name(ZFS_PROP_SETUID), setuid_changed_cb, zfsvfs);
	error = error ? error : dsl_prop_register(ds,
	zfs_prop_to_name(ZFS_PROP_EXEC), exec_changed_cb, zfsvfs);
	error = error ? error : dsl_prop_register(ds,
	zfs_prop_to_name(ZFS_PROP_SNAPDIR), snapdir_changed_cb, zfsvfs);
	error = error ? error : dsl_prop_register(ds,
	zfs_prop_to_name(ZFS_PROP_ACLTYPE), acl_type_changed_cb, zfsvfs);
	error = error ? error : dsl_prop_register(ds,
	zfs_prop_to_name(ZFS_PROP_ACLMODE), acl_mode_changed_cb, zfsvfs);
	error = error ? error : dsl_prop_register(ds,
	zfs_prop_to_name(ZFS_PROP_ACLINHERIT), acl_inherit_changed_cb,
	zfsvfs);
	error = error ? error : dsl_prop_register(ds,
	zfs_prop_to_name(ZFS_PROP_VSCAN), vscan_changed_cb, zfsvfs);
	dsl_pool_config_exit(dmu_objset_pool(os), FTAG);
	if (error)
	goto unregister;

	/*
	* Invoke our callbacks to restore temporary mount options.
	*/
	if (do_readonly)
	readonly_changed_cb(zfsvfs, readonly);
	if (do_setuid)
	setuid_changed_cb(zfsvfs, setuid);
	if (do_exec)
	exec_changed_cb(zfsvfs, exec);
	if (do_xattr)
	xattr_changed_cb(zfsvfs, xattr);
	if (do_atime)
	atime_changed_cb(zfsvfs, atime);

	nbmand_changed_cb(zfsvfs, nbmand);

	return (0);

	unregister:
	dsl_prop_unregister_all(ds, zfsvfs);
	return (error);
	}

	/*
	* Associate this zfsvfs with the given objset, which must be owned.
	* This will cache a bunch of on-disk state from the objset in the
	* zfsvfs.
	*/
	static int
	zfsvfs_init(zfsvfs_t zfsvfs, objset_t os)
	{
	int error;
	uint64_t val;

	zfsvfs->z_max_blksz = SPA_OLD_MAXBLOCKSIZE;
	zfsvfs->z_show_ctldir = ZFS_SNAPDIR_VISIBLE;
	zfsvfs->z_os = os;

	error = zfs_get_zplprop(os, ZFS_PROP_VERSION, &zfsvfs->z_version);
	if (error != 0)
	return (error);
	if (zfsvfs->z_version >
	zfs_zpl_version_map(spa_version(dmu_objset_spa(os)))) {
	(void) printf("Can't mount a version %lld file system "
	"on a version %lld pool\n. Pool must be upgraded to mount "
	"this file system.", (u_longlong_t)zfsvfs->z_version,
	(u_longlong_t)spa_version(dmu_objset_spa(os)));
	return (SET_ERROR(ENOTSUP));
	}
	error = zfs_get_zplprop(os, ZFS_PROP_NORMALIZE, &val);
	if (error != 0)
	return (error);
	zfsvfs->z_norm = (int)val;

	error = zfs_get_zplprop(os, ZFS_PROP_UTF8ONLY, &val);
	if (error != 0)
	return (error);
	zfsvfs->z_utf8 = (val != 0);

	error = zfs_get_zplprop(os, ZFS_PROP_CASE, &val);
	if (error != 0)
	return (error);
	zfsvfs->z_case = (uint_t)val;

	error = zfs_get_zplprop(os, ZFS_PROP_ACLTYPE, &val);
	if (error != 0)
	return (error);
	zfsvfs->z_acl_type = (uint_t)val;

	/*
	* Fold case on file systems that are always or sometimes case
	* insensitive.
	*/
	if (zfsvfs->z_case == ZFS_CASE_INSENSITIVE \|\|
	zfsvfs->z_case == ZFS_CASE_MIXED)
	zfsvfs->z_norm \|= U8_TEXTPREP_TOUPPER;

	zfsvfs->z_use_fuids = USE_FUIDS(zfsvfs->z_version, zfsvfs->z_os);
	zfsvfs->z_use_sa = USE_SA(zfsvfs->z_version, zfsvfs->z_os);

	uint64_t sa_obj = 0;
	if (zfsvfs->z_use_sa) {
	/* should either have both of these objects or none */
	error = zap_lookup(os, MASTER_NODE_OBJ, ZFS_SA_ATTRS, 8, 1,
	&sa_obj);
	if (error != 0)
	return (error);
	}

	error = sa_setup(os, sa_obj, zfs_attr_table, ZPL_END,
	&zfsvfs->z_attr_table);
	if (error != 0)
	return (error);

	if (zfsvfs->z_version >= ZPL_VERSION_SA)
	sa_register_update_callback(os, zfs_sa_upgrade);

	error = zap_lookup(os, MASTER_NODE_OBJ, ZFS_ROOT_OBJ, 8, 1,
	&zfsvfs->z_root);
	if (error != 0)
	return (error);
	ASSERT(zfsvfs->z_root != 0);

	error = zap_lookup(os, MASTER_NODE_OBJ, ZFS_UNLINKED_SET, 8, 1,
	&zfsvfs->z_unlinkedobj);
	if (error != 0)
	return (error);

	error = zap_lookup(os, MASTER_NODE_OBJ,
	zfs_userquota_prop_prefixes[ZFS_PROP_USERQUOTA],
	8, 1, &zfsvfs->z_userquota_obj);
	if (error == ENOENT)
	zfsvfs->z_userquota_obj = 0;
	else if (error != 0)
	return (error);

	error = zap_lookup(os, MASTER_NODE_OBJ,
	zfs_userquota_prop_prefixes[ZFS_PROP_GROUPQUOTA],
	8, 1, &zfsvfs->z_groupquota_obj);
	if (error == ENOENT)
	zfsvfs->z_groupquota_obj = 0;
	else if (error != 0)
	return (error);

	error = zap_lookup(os, MASTER_NODE_OBJ,
	zfs_userquota_prop_prefixes[ZFS_PROP_PROJECTQUOTA],
	8, 1, &zfsvfs->z_projectquota_obj);
	if (error == ENOENT)
	zfsvfs->z_projectquota_obj = 0;
	else if (error != 0)
	return (error);

	error = zap_lookup(os, MASTER_NODE_OBJ,
	zfs_userquota_prop_prefixes[ZFS_PROP_USEROBJQUOTA],
	8, 1, &zfsvfs->z_userobjquota_obj);
	if (error == ENOENT)
	zfsvfs->z_userobjquota_obj = 0;
	else if (error != 0)
	return (error);

	error = zap_lookup(os, MASTER_NODE_OBJ,
	zfs_userquota_prop_prefixes[ZFS_PROP_GROUPOBJQUOTA],
	8, 1, &zfsvfs->z_groupobjquota_obj);
	if (error == ENOENT)
	zfsvfs->z_groupobjquota_obj = 0;
	else if (error != 0)
	return (error);

	error = zap_lookup(os, MASTER_NODE_OBJ,
	zfs_userquota_prop_prefixes[ZFS_PROP_PROJECTOBJQUOTA],
	8, 1, &zfsvfs->z_projectobjquota_obj);
	if (error == ENOENT)
	zfsvfs->z_projectobjquota_obj = 0;
	else if (error != 0)
	return (error);

	error = zap_lookup(os, MASTER_NODE_OBJ, ZFS_FUID_TABLES, 8, 1,
	&zfsvfs->z_fuid_obj);
	if (error == ENOENT)
	zfsvfs->z_fuid_obj = 0;
	else if (error != 0)
	return (error);

	error = zap_lookup(os, MASTER_NODE_OBJ, ZFS_SHARES_DIR, 8, 1,
	&zfsvfs->z_shares_dir);
	if (error == ENOENT)
	zfsvfs->z_shares_dir = 0;
	else if (error != 0)
	return (error);

	/*
	* Only use the name cache if we are looking for a
	* name on a file system that does not require normalization
	* or case folding. We can also look there if we happen to be
	* on a non-normalizing, mixed sensitivity file system IF we
	* are looking for the exact name (which is always the case on
	* FreeBSD).
	*/
	zfsvfs->z_use_namecache = !zfsvfs->z_norm \|\|
	((zfsvfs->z_case == ZFS_CASE_MIXED) &&
	!(zfsvfs->z_norm & ~U8_TEXTPREP_TOUPPER));

	return (0);
	}

	taskq_t *zfsvfs_taskq;

	static void
	zfsvfs_task_unlinked_drain(void *context, int pending __unused)
	{

	zfs_unlinked_drain((zfsvfs_t *)context);
	}

	int
	zfsvfs_create(const char osname, boolean_t readonly, zfsvfs_t *zfvp)
	{
	objset_t *os;
	zfsvfs_t *zfsvfs;
	int error;
	boolean_t ro = (readonly \|\| (strchr(osname, '@') != NULL));

	/*
	* XXX: Fix struct statfs so this isn't necessary!
	*
	* The 'osname' is used as the filesystem's special node, which means
	* it must fit in statfs.f_mntfromname, or else it can't be
	* enumerated, so libzfs_mnttab_find() returns NULL, which causes
	* 'zfs unmount' to think it's not mounted when it is.
	*/
	if (strlen(osname) >= MNAMELEN)
	return (SET_ERROR(ENAMETOOLONG));

	zfsvfs = kmem_zalloc(sizeof (zfsvfs_t), KM_SLEEP);

	error = dmu_objset_own(osname, DMU_OST_ZFS, ro, B_TRUE, zfsvfs,
	&os);
	if (error != 0) {
	kmem_free(zfsvfs, sizeof (zfsvfs_t));
	return (error);
	}

	error = zfsvfs_create_impl(zfvp, zfsvfs, os);

	return (error);
	}


	int
	zfsvfs_create_impl(zfsvfs_t *zfvp, zfsvfs_t zfsvfs, objset_t *os)
	{
	int error;

	zfsvfs->z_vfs = NULL;
	zfsvfs->z_parent = zfsvfs;

	mutex_init(&zfsvfs->z_znodes_lock, NULL, MUTEX_DEFAULT, NULL);
	mutex_init(&zfsvfs->z_lock, NULL, MUTEX_DEFAULT, NULL);
	list_create(&zfsvfs->z_all_znodes, sizeof (znode_t),
	offsetof(znode_t, z_link_node));
	TASK_INIT(&zfsvfs->z_unlinked_drain_task, 0,
	zfsvfs_task_unlinked_drain, zfsvfs);
	ZFS_TEARDOWN_INIT(zfsvfs);
	ZFS_TEARDOWN_INACTIVE_INIT(zfsvfs);
	rw_init(&zfsvfs->z_fuid_lock, NULL, RW_DEFAULT, NULL);
	for (int i = 0; i != ZFS_OBJ_MTX_SZ; i++)
	mutex_init(&zfsvfs->z_hold_mtx[i], NULL, MUTEX_DEFAULT, NULL);

	error = zfsvfs_init(zfsvfs, os);
	if (error != 0) {
	dmu_objset_disown(os, B_TRUE, zfsvfs);
	*zfvp = NULL;
	kmem_free(zfsvfs, sizeof (zfsvfs_t));
	return (error);
	}

	*zfvp = zfsvfs;
	return (0);
	}

	static int
	zfsvfs_setup(zfsvfs_t *zfsvfs, boolean_t mounting)
	{
	int error;

	/*
	* Check for a bad on-disk format version now since we
	* lied about owning the dataset readonly before.
	*/
	if (!(zfsvfs->z_vfs->vfs_flag & VFS_RDONLY) &&
	dmu_objset_incompatible_encryption_version(zfsvfs->z_os))
	return (SET_ERROR(EROFS));

	error = zfs_register_callbacks(zfsvfs->z_vfs);
	if (error)
	return (error);

	zfsvfs->z_log = zil_open(zfsvfs->z_os, zfs_get_data);

	/*
	* If we are not mounting (ie: online recv), then we don't
	* have to worry about replaying the log as we blocked all
	* operations out since we closed the ZIL.
	*/
	if (mounting) {
	boolean_t readonly;

	ASSERT3P(zfsvfs->z_kstat.dk_kstats, ==, NULL);
	dataset_kstats_create(&zfsvfs->z_kstat, zfsvfs->z_os);

	/*
	* During replay we remove the read only flag to
	* allow replays to succeed.
	*/
	readonly = zfsvfs->z_vfs->vfs_flag & VFS_RDONLY;
	if (readonly != 0) {
	zfsvfs->z_vfs->vfs_flag &= ~VFS_RDONLY;
	} else {
	dsl_dir_t *dd;
	zap_stats_t zs;

	if (zap_get_stats(zfsvfs->z_os, zfsvfs->z_unlinkedobj,
	&zs) == 0) {
	dataset_kstats_update_nunlinks_kstat(
	&zfsvfs->z_kstat, zs.zs_num_entries);
	dprintf_ds(zfsvfs->z_os->os_dsl_dataset,
	"num_entries in unlinked set: %llu",
	zs.zs_num_entries);
	}

	zfs_unlinked_drain(zfsvfs);
	dd = zfsvfs->z_os->os_dsl_dataset->ds_dir;
	dd->dd_activity_cancelled = B_FALSE;
	}

	/*
	* Parse and replay the intent log.
	*
	* Because of ziltest, this must be done after
	* zfs_unlinked_drain(). (Further note: ziltest
	* doesn't use readonly mounts, where
	* zfs_unlinked_drain() isn't called.) This is because
	* ziltest causes spa_sync() to think it's committed,
	* but actually it is not, so the intent log contains
	* many txg's worth of changes.
	*
	* In particular, if object N is in the unlinked set in
	* the last txg to actually sync, then it could be
	* actually freed in a later txg and then reallocated
	* in a yet later txg. This would write a "create
	* object N" record to the intent log. Normally, this
	* would be fine because the spa_sync() would have
	* written out the fact that object N is free, before
	* we could write the "create object N" intent log
	* record.
	*
	* But when we are in ziltest mode, we advance the "open
	* txg" without actually spa_sync()-ing the changes to
	* disk. So we would see that object N is still
	* allocated and in the unlinked set, and there is an
	* intent log record saying to allocate it.
	*/
	if (spa_writeable(dmu_objset_spa(zfsvfs->z_os))) {
	if (zil_replay_disable) {
	zil_destroy(zfsvfs->z_log, B_FALSE);
	} else {
	boolean_t use_nc = zfsvfs->z_use_namecache;
	zfsvfs->z_use_namecache = B_FALSE;
	zfsvfs->z_replay = B_TRUE;
	zil_replay(zfsvfs->z_os, zfsvfs,
	zfs_replay_vector);
	zfsvfs->z_replay = B_FALSE;
	zfsvfs->z_use_namecache = use_nc;
	}
	}

	/* restore readonly bit */
	if (readonly != 0)
	zfsvfs->z_vfs->vfs_flag \|= VFS_RDONLY;
	}

	/*
	* Set the objset user_ptr to track its zfsvfs.
	*/
	mutex_enter(&zfsvfs->z_os->os_user_ptr_lock);
	dmu_objset_set_user(zfsvfs->z_os, zfsvfs);
	mutex_exit(&zfsvfs->z_os->os_user_ptr_lock);

	return (0);
	}

	void
	zfsvfs_free(zfsvfs_t *zfsvfs)
	{
	int i;

	zfs_fuid_destroy(zfsvfs);

	mutex_destroy(&zfsvfs->z_znodes_lock);
	mutex_destroy(&zfsvfs->z_lock);
	ASSERT(zfsvfs->z_nr_znodes == 0);
	list_destroy(&zfsvfs->z_all_znodes);
	ZFS_TEARDOWN_DESTROY(zfsvfs);
	ZFS_TEARDOWN_INACTIVE_DESTROY(zfsvfs);
	rw_destroy(&zfsvfs->z_fuid_lock);
	for (i = 0; i != ZFS_OBJ_MTX_SZ; i++)
	mutex_destroy(&zfsvfs->z_hold_mtx[i]);
	dataset_kstats_destroy(&zfsvfs->z_kstat);
	kmem_free(zfsvfs, sizeof (zfsvfs_t));
	}

	static void
	zfs_set_fuid_feature(zfsvfs_t *zfsvfs)
	{
	zfsvfs->z_use_fuids = USE_FUIDS(zfsvfs->z_version, zfsvfs->z_os);
	if (zfsvfs->z_vfs) {
	if (zfsvfs->z_use_fuids) {
	vfs_set_feature(zfsvfs->z_vfs, VFSFT_XVATTR);
	vfs_set_feature(zfsvfs->z_vfs, VFSFT_SYSATTR_VIEWS);
	vfs_set_feature(zfsvfs->z_vfs, VFSFT_ACEMASKONACCESS);
	vfs_set_feature(zfsvfs->z_vfs, VFSFT_ACLONCREATE);
	vfs_set_feature(zfsvfs->z_vfs, VFSFT_ACCESS_FILTER);
	vfs_set_feature(zfsvfs->z_vfs, VFSFT_REPARSE);
	} else {
	vfs_clear_feature(zfsvfs->z_vfs, VFSFT_XVATTR);
	vfs_clear_feature(zfsvfs->z_vfs, VFSFT_SYSATTR_VIEWS);
	vfs_clear_feature(zfsvfs->z_vfs, VFSFT_ACEMASKONACCESS);
	vfs_clear_feature(zfsvfs->z_vfs, VFSFT_ACLONCREATE);
	vfs_clear_feature(zfsvfs->z_vfs, VFSFT_ACCESS_FILTER);
	vfs_clear_feature(zfsvfs->z_vfs, VFSFT_REPARSE);
	}
	}
	zfsvfs->z_use_sa = USE_SA(zfsvfs->z_version, zfsvfs->z_os);
	}

	static int
	zfs_domount(vfs_t vfsp, char osname)
	{
	uint64_t recordsize, fsid_guid;
	int error = 0;
	zfsvfs_t *zfsvfs;

	ASSERT(vfsp);
	ASSERT(osname);

	error = zfsvfs_create(osname, vfsp->mnt_flag & MNT_RDONLY, &zfsvfs);
	if (error)
	return (error);
	zfsvfs->z_vfs = vfsp;

	if ((error = dsl_prop_get_integer(osname,
	"recordsize", &recordsize, NULL)))
	goto out;
	zfsvfs->z_vfs->vfs_bsize = SPA_MINBLOCKSIZE;
	zfsvfs->z_vfs->mnt_stat.f_iosize = recordsize;

	vfsp->vfs_data = zfsvfs;
	vfsp->mnt_flag \|= MNT_LOCAL;
	vfsp->mnt_kern_flag \|= MNTK_LOOKUP_SHARED;
	vfsp->mnt_kern_flag \|= MNTK_SHARED_WRITES;
	vfsp->mnt_kern_flag \|= MNTK_EXTENDED_SHARED;
	/*
	* This can cause a loss of coherence between ARC and page cache
	* on ZoF - unclear if the problem is in FreeBSD or ZoF
	*/
	vfsp->mnt_kern_flag \|= MNTK_NO_IOPF; /* vn_io_fault can be used */
	vfsp->mnt_kern_flag \|= MNTK_NOMSYNC;
	vfsp->mnt_kern_flag \|= MNTK_VMSETSIZE_BUG;

	#if defined(_KERNEL) && !defined(KMEM_DEBUG)
	vfsp->mnt_kern_flag \|= MNTK_FPLOOKUP;
	#endif
	/*
	* The fsid is 64 bits, composed of an 8-bit fs type, which
	* separates our fsid from any other filesystem types, and a
	* 56-bit objset unique ID. The objset unique ID is unique to
	* all objsets open on this system, provided by unique_create().
	* The 8-bit fs type must be put in the low bits of fsid[1]
	* because that's where other Solaris filesystems put it.
	*/
	fsid_guid = dmu_objset_fsid_guid(zfsvfs->z_os);
	ASSERT((fsid_guid & ~((1ULL<<56)-1)) == 0);
	vfsp->vfs_fsid.val[0] = fsid_guid;
	vfsp->vfs_fsid.val[1] = ((fsid_guid>>32) << 8) \|
	(vfsp->mnt_vfc->vfc_typenum & 0xFF);

	/*
	* Set features for file system.
	*/
	zfs_set_fuid_feature(zfsvfs);
	if (zfsvfs->z_case == ZFS_CASE_INSENSITIVE) {
	vfs_set_feature(vfsp, VFSFT_DIRENTFLAGS);
	vfs_set_feature(vfsp, VFSFT_CASEINSENSITIVE);
	vfs_set_feature(vfsp, VFSFT_NOCASESENSITIVE);
	} else if (zfsvfs->z_case == ZFS_CASE_MIXED) {
	vfs_set_feature(vfsp, VFSFT_DIRENTFLAGS);
	vfs_set_feature(vfsp, VFSFT_CASEINSENSITIVE);
	}
	vfs_set_feature(vfsp, VFSFT_ZEROCOPY_SUPPORTED);

	if (dmu_objset_is_snapshot(zfsvfs->z_os)) {
	uint64_t pval;

	atime_changed_cb(zfsvfs, B_FALSE);
	readonly_changed_cb(zfsvfs, B_TRUE);
	if ((error = dsl_prop_get_integer(osname,
	"xattr", &pval, NULL)))
	goto out;
	xattr_changed_cb(zfsvfs, pval);
	if ((error = dsl_prop_get_integer(osname,
	"acltype", &pval, NULL)))
	goto out;
	acl_type_changed_cb(zfsvfs, pval);
	zfsvfs->z_issnap = B_TRUE;
	zfsvfs->z_os->os_sync = ZFS_SYNC_DISABLED;

	mutex_enter(&zfsvfs->z_os->os_user_ptr_lock);
	dmu_objset_set_user(zfsvfs->z_os, zfsvfs);
	mutex_exit(&zfsvfs->z_os->os_user_ptr_lock);
	} else {
	if ((error = zfsvfs_setup(zfsvfs, B_TRUE)))
	goto out;
	}

	vfs_mountedfrom(vfsp, osname);

	if (!zfsvfs->z_issnap)
	zfsctl_create(zfsvfs);
	out:
	if (error) {
	dmu_objset_disown(zfsvfs->z_os, B_TRUE, zfsvfs);
	zfsvfs_free(zfsvfs);
	} else {
	atomic_inc_32(&zfs_active_fs_count);
	}

	return (error);
	}

	static void
	zfs_unregister_callbacks(zfsvfs_t *zfsvfs)
	{
	objset_t *os = zfsvfs->z_os;

	if (!dmu_objset_is_snapshot(os))
	dsl_prop_unregister_all(dmu_objset_ds(os), zfsvfs);
	}

	static int
	getpoolname(const char osname, char poolname)
	{
	char *p;

	p = strchr(osname, '/');
	if (p == NULL) {
	if (strlen(osname) >= MAXNAMELEN)
	return (ENAMETOOLONG);
	(void) strcpy(poolname, osname);
	} else {
	if (p - osname >= MAXNAMELEN)
	return (ENAMETOOLONG);
	(void) strncpy(poolname, osname, p - osname);
	poolname[p - osname] = '\0';
	}
	return (0);
	}

	static void
	fetch_osname_options(char name, bool checkpointrewind)
	{

	if (name[0] == '!') {
	*checkpointrewind = true;
	memmove(name, name + 1, strlen(name));
	} else {
	*checkpointrewind = false;
	}
	}

	/ARGSUSED/
	static int
	zfs_mount(vfs_t *vfsp)
	{
	kthread_t *td = curthread;
	vnode_t *mvp = vfsp->mnt_vnodecovered;
	cred_t *cr = td->td_ucred;
	char *osname;
	int error = 0;
	int canwrite;
	bool checkpointrewind;

	if (vfs_getopt(vfsp->mnt_optnew, "from", (void **)&osname, NULL))
	return (SET_ERROR(EINVAL));

	/*
	* If full-owner-access is enabled and delegated administration is
	* turned on, we must set nosuid.
	*/
	if (zfs_super_owner &&
	dsl_deleg_access(osname, ZFS_DELEG_PERM_MOUNT, cr) != ECANCELED) {
	secpolicy_fs_mount_clearopts(cr, vfsp);
	}

	fetch_osname_options(osname, &checkpointrewind);

	/*
	* Check for mount privilege?
	*
	* If we don't have privilege then see if
	* we have local permission to allow it
	*/
	error = secpolicy_fs_mount(cr, mvp, vfsp);
	if (error) {
	if (dsl_deleg_access(osname, ZFS_DELEG_PERM_MOUNT, cr) != 0)
	goto out;

	if (!(vfsp->vfs_flag & MS_REMOUNT)) {
	vattr_t vattr;

	/*
	* Make sure user is the owner of the mount point
	* or has sufficient privileges.
	*/

	vattr.va_mask = AT_UID;

	vn_lock(mvp, LK_SHARED \| LK_RETRY);
	if (VOP_GETATTR(mvp, &vattr, cr)) {
	VOP_UNLOCK1(mvp);
	goto out;
	}

	if (secpolicy_vnode_owner(mvp, cr, vattr.va_uid) != 0 &&
	VOP_ACCESS(mvp, VWRITE, cr, td) != 0) {
	VOP_UNLOCK1(mvp);
	goto out;
	}
	VOP_UNLOCK1(mvp);
	}

	secpolicy_fs_mount_clearopts(cr, vfsp);
	}

	/*
	* Refuse to mount a filesystem if we are in a local zone and the
	* dataset is not visible.
	*/
	if (!INGLOBALZONE(curproc) &&
	(!zone_dataset_visible(osname, &canwrite) \|\| !canwrite)) {
	error = SET_ERROR(EPERM);
	goto out;
	}

	vfsp->vfs_flag \|= MNT_NFS4ACLS;

	/*
	* When doing a remount, we simply refresh our temporary properties
	* according to those options set in the current VFS options.
	*/
	if (vfsp->vfs_flag & MS_REMOUNT) {
	zfsvfs_t *zfsvfs = vfsp->vfs_data;

	/*
	* Refresh mount options with z_teardown_lock blocking I/O while
	* the filesystem is in an inconsistent state.
	* The lock also serializes this code with filesystem
	* manipulations between entry to zfs_suspend_fs() and return
	* from zfs_resume_fs().
	*/
	ZFS_TEARDOWN_ENTER_WRITE(zfsvfs, FTAG);
	zfs_unregister_callbacks(zfsvfs);
	error = zfs_register_callbacks(vfsp);
	ZFS_TEARDOWN_EXIT(zfsvfs, FTAG);
	goto out;
	}

	/* Initial root mount: try hard to import the requested root pool. */
	if ((vfsp->vfs_flag & MNT_ROOTFS) != 0 &&
	(vfsp->vfs_flag & MNT_UPDATE) == 0) {
	char pname[MAXNAMELEN];

	error = getpoolname(osname, pname);
	if (error == 0)
	error = spa_import_rootpool(pname, checkpointrewind);
	if (error)
	goto out;
	}
	DROP_GIANT();
	error = zfs_domount(vfsp, osname);
	PICKUP_GIANT();

	out:
	return (error);
	}

	static int
	zfs_statfs(vfs_t vfsp, struct statfs statp)
	{
	zfsvfs_t *zfsvfs = vfsp->vfs_data;
	uint64_t refdbytes, availbytes, usedobjs, availobjs;

	statp->f_version = STATFS_VERSION;

	ZFS_ENTER(zfsvfs);

	dmu_objset_space(zfsvfs->z_os,
	&refdbytes, &availbytes, &usedobjs, &availobjs);

	/*
	* The underlying storage pool actually uses multiple block sizes.
	* We report the fragsize as the smallest block size we support,
	* and we report our blocksize as the filesystem's maximum blocksize.
	*/
	statp->f_bsize = SPA_MINBLOCKSIZE;
	statp->f_iosize = zfsvfs->z_vfs->mnt_stat.f_iosize;

	/*
	* The following report "total" blocks of various kinds in the
	* file system, but reported in terms of f_frsize - the
	* "fragment" size.
	*/

	statp->f_blocks = (refdbytes + availbytes) >> SPA_MINBLOCKSHIFT;
	statp->f_bfree = availbytes / statp->f_bsize;
	statp->f_bavail = statp->f_bfree; /* no root reservation */

	/*
	* statvfs() should really be called statufs(), because it assumes
	* static metadata. ZFS doesn't preallocate files, so the best
	* we can do is report the max that could possibly fit in f_files,
	* and that minus the number actually used in f_ffree.
	* For f_ffree, report the smaller of the number of object available
	* and the number of blocks (each object will take at least a block).
	*/
	statp->f_ffree = MIN(availobjs, statp->f_bfree);
	statp->f_files = statp->f_ffree + usedobjs;

	/*
	* We're a zfs filesystem.
	*/
	strlcpy(statp->f_fstypename, "zfs",
	sizeof (statp->f_fstypename));

	strlcpy(statp->f_mntfromname, vfsp->mnt_stat.f_mntfromname,
	sizeof (statp->f_mntfromname));
	strlcpy(statp->f_mntonname, vfsp->mnt_stat.f_mntonname,
	sizeof (statp->f_mntonname));

	statp->f_namemax = MAXNAMELEN - 1;

	ZFS_EXIT(zfsvfs);
	return (0);
	}

	static int
	zfs_root(vfs_t vfsp, int flags, vnode_t *vpp)
	{
	zfsvfs_t *zfsvfs = vfsp->vfs_data;
	znode_t *rootzp;
	int error;

	ZFS_ENTER(zfsvfs);

	error = zfs_zget(zfsvfs, zfsvfs->z_root, &rootzp);
	if (error == 0)
	*vpp = ZTOV(rootzp);

	ZFS_EXIT(zfsvfs);

	if (error == 0) {
	error = vn_lock(*vpp, flags);
	if (error != 0) {
	VN_RELE(*vpp);
	*vpp = NULL;
	}
	}
	return (error);
	}

	/*
	* Teardown the zfsvfs::z_os.
	*
	* Note, if 'unmounting' is FALSE, we return with the 'z_teardown_lock'
	* and 'z_teardown_inactive_lock' held.
	*/
	static int
	zfsvfs_teardown(zfsvfs_t *zfsvfs, boolean_t unmounting)
	{
	znode_t *zp;
	dsl_dir_t *dd;

	/*
	* If someone has not already unmounted this file system,
	* drain the zrele_taskq to ensure all active references to the
	* zfsvfs_t have been handled only then can it be safely destroyed.
	*/
	if (zfsvfs->z_os) {
	/*
	* If we're unmounting we have to wait for the list to
	* drain completely.
	*
	* If we're not unmounting there's no guarantee the list
	* will drain completely, but zreles run from the taskq
	* may add the parents of dir-based xattrs to the taskq
	* so we want to wait for these.
	*
	* We can safely read z_nr_znodes without locking because the
	* VFS has already blocked operations which add to the
	* z_all_znodes list and thus increment z_nr_znodes.
	*/
	int round = 0;
	while (zfsvfs->z_nr_znodes > 0) {
	taskq_wait_outstanding(dsl_pool_zrele_taskq(
	dmu_objset_pool(zfsvfs->z_os)), 0);
	if (++round > 1 && !unmounting)
	break;
	}
	}
	ZFS_TEARDOWN_ENTER_WRITE(zfsvfs, FTAG);

	if (!unmounting) {
	/*
	* We purge the parent filesystem's vfsp as the parent
	* filesystem and all of its snapshots have their vnode's
	* v_vfsp set to the parent's filesystem's vfsp. Note,
	* 'z_parent' is self referential for non-snapshots.
	*/
	#ifdef FREEBSD_NAMECACHE
	#if __FreeBSD_version >= 1300117
	cache_purgevfs(zfsvfs->z_parent->z_vfs);
	#else
	cache_purgevfs(zfsvfs->z_parent->z_vfs, true);
	#endif
	#endif
	}

	/*
	* Close the zil. NB: Can't close the zil while zfs_inactive
	* threads are blocked as zil_close can call zfs_inactive.
	*/
	if (zfsvfs->z_log) {
	zil_close(zfsvfs->z_log);
	zfsvfs->z_log = NULL;
	}

	ZFS_TEARDOWN_INACTIVE_ENTER_WRITE(zfsvfs);

	/*
	* If we are not unmounting (ie: online recv) and someone already
	* unmounted this file system while we were doing the switcheroo,
	* or a reopen of z_os failed then just bail out now.
	*/
	if (!unmounting && (zfsvfs->z_unmounted \|\| zfsvfs->z_os == NULL)) {
	ZFS_TEARDOWN_INACTIVE_EXIT_WRITE(zfsvfs);
	ZFS_TEARDOWN_EXIT(zfsvfs, FTAG);
	return (SET_ERROR(EIO));
	}

	/*
	* At this point there are no vops active, and any new vops will
	* fail with EIO since we have z_teardown_lock for writer (only
	* relevant for forced unmount).
	*
	* Release all holds on dbufs.
	*/
	mutex_enter(&zfsvfs->z_znodes_lock);
	for (zp = list_head(&zfsvfs->z_all_znodes); zp != NULL;
	zp = list_next(&zfsvfs->z_all_znodes, zp))
	if (zp->z_sa_hdl) {
	- ASSERT(ZTOV(zp)->v_count >= 0);
	+ ASSERT(ZTOV(zp)->v_usecount >= 0);
	zfs_znode_dmu_fini(zp);
	}
	mutex_exit(&zfsvfs->z_znodes_lock);

	/*
	* If we are unmounting, set the unmounted flag and let new vops
	* unblock. zfs_inactive will have the unmounted behavior, and all
	* other vops will fail with EIO.
	*/
	if (unmounting) {
	zfsvfs->z_unmounted = B_TRUE;
	ZFS_TEARDOWN_INACTIVE_EXIT_WRITE(zfsvfs);
	ZFS_TEARDOWN_EXIT(zfsvfs, FTAG);
	}

	/*
	* z_os will be NULL if there was an error in attempting to reopen
	* zfsvfs, so just return as the properties had already been
	* unregistered and cached data had been evicted before.
	*/
	if (zfsvfs->z_os == NULL)
	return (0);

	/*
	* Unregister properties.
	*/
	zfs_unregister_callbacks(zfsvfs);

	/*
	* Evict cached data
	*/
	if (!zfs_is_readonly(zfsvfs))
	txg_wait_synced(dmu_objset_pool(zfsvfs->z_os), 0);
	dmu_objset_evict_dbufs(zfsvfs->z_os);
	dd = zfsvfs->z_os->os_dsl_dataset->ds_dir;
	dsl_dir_cancel_waiters(dd);

	return (0);
	}

	/ARGSUSED/
	static int
	zfs_umount(vfs_t *vfsp, int fflag)
	{
	kthread_t *td = curthread;
	zfsvfs_t *zfsvfs = vfsp->vfs_data;
	objset_t *os;
	cred_t *cr = td->td_ucred;
	int ret;

	ret = secpolicy_fs_unmount(cr, vfsp);
	if (ret) {
	if (dsl_deleg_access((char *)vfsp->vfs_resource,
	ZFS_DELEG_PERM_MOUNT, cr))
	return (ret);
	}

	/*
	* Unmount any snapshots mounted under .zfs before unmounting the
	* dataset itself.
	*/
	if (zfsvfs->z_ctldir != NULL) {
	if ((ret = zfsctl_umount_snapshots(vfsp, fflag, cr)) != 0)
	return (ret);
	}

	if (fflag & MS_FORCE) {
	/*
	* Mark file system as unmounted before calling
	* vflush(FORCECLOSE). This way we ensure no future vnops
	* will be called and risk operating on DOOMED vnodes.
	*/
	ZFS_TEARDOWN_ENTER_WRITE(zfsvfs, FTAG);
	zfsvfs->z_unmounted = B_TRUE;
	ZFS_TEARDOWN_EXIT(zfsvfs, FTAG);
	}

	/*
	* Flush all the files.
	*/
	ret = vflush(vfsp, 0, (fflag & MS_FORCE) ? FORCECLOSE : 0, td);
	if (ret != 0)
	return (ret);
	while (taskqueue_cancel(zfsvfs_taskq->tq_queue,
	&zfsvfs->z_unlinked_drain_task, NULL) != 0)
	taskqueue_drain(zfsvfs_taskq->tq_queue,
	&zfsvfs->z_unlinked_drain_task);

	VERIFY(zfsvfs_teardown(zfsvfs, B_TRUE) == 0);
	os = zfsvfs->z_os;

	/*
	* z_os will be NULL if there was an error in
	* attempting to reopen zfsvfs.
	*/
	if (os != NULL) {
	/*
	* Unset the objset user_ptr.
	*/
	mutex_enter(&os->os_user_ptr_lock);
	dmu_objset_set_user(os, NULL);
	mutex_exit(&os->os_user_ptr_lock);

	/*
	* Finally release the objset
	*/
	dmu_objset_disown(os, B_TRUE, zfsvfs);
	}

	/*
	* We can now safely destroy the '.zfs' directory node.
	*/
	if (zfsvfs->z_ctldir != NULL)
	zfsctl_destroy(zfsvfs);
	zfs_freevfs(vfsp);

	return (0);
	}

	static int
	zfs_vget(vfs_t vfsp, ino_t ino, int flags, vnode_t *vpp)
	{
	zfsvfs_t *zfsvfs = vfsp->vfs_data;
	znode_t *zp;
	int err;

	/*
	* zfs_zget() can't operate on virtual entries like .zfs/ or
	* .zfs/snapshot/ directories, that's why we return EOPNOTSUPP.
	* This will make NFS to switch to LOOKUP instead of using VGET.
	*/
	if (ino == ZFSCTL_INO_ROOT \|\| ino == ZFSCTL_INO_SNAPDIR \|\|
	(zfsvfs->z_shares_dir != 0 && ino == zfsvfs->z_shares_dir))
	return (EOPNOTSUPP);

	ZFS_ENTER(zfsvfs);
	err = zfs_zget(zfsvfs, ino, &zp);
	if (err == 0 && zp->z_unlinked) {
	vrele(ZTOV(zp));
	err = EINVAL;
	}
	if (err == 0)
	*vpp = ZTOV(zp);
	ZFS_EXIT(zfsvfs);
	if (err == 0) {
	err = vn_lock(*vpp, flags);
	if (err != 0)
	vrele(*vpp);
	}
	if (err != 0)
	*vpp = NULL;
	return (err);
	}

	static int
	#if __FreeBSD_version >= 1300098
	zfs_checkexp(vfs_t vfsp, struct sockaddr nam, uint64_t *extflagsp,
	struct ucred *credanonp, int numsecflavors, int *secflavors)
	#else
	zfs_checkexp(vfs_t vfsp, struct sockaddr nam, int *extflagsp,
	struct ucred *credanonp, int numsecflavors, int **secflavors)
	#endif
	{
	zfsvfs_t *zfsvfs = vfsp->vfs_data;

	/*
	* If this is regular file system vfsp is the same as
	* zfsvfs->z_parent->z_vfs, but if it is snapshot,
	* zfsvfs->z_parent->z_vfs represents parent file system
	* which we have to use here, because only this file system
	* has mnt_export configured.
	*/
	return (vfs_stdcheckexp(zfsvfs->z_parent->z_vfs, nam, extflagsp,
	credanonp, numsecflavors, secflavors));
	}

	CTASSERT(SHORT_FID_LEN <= sizeof (struct fid));
	CTASSERT(LONG_FID_LEN <= sizeof (struct fid));

	static int
	zfs_fhtovp(vfs_t vfsp, fid_t fidp, int flags, vnode_t **vpp)
	{
	struct componentname cn;
	zfsvfs_t *zfsvfs = vfsp->vfs_data;
	znode_t *zp;
	vnode_t *dvp;
	uint64_t object = 0;
	uint64_t fid_gen = 0;
	uint64_t gen_mask;
	uint64_t zp_gen;
	int i, err;

	*vpp = NULL;

	ZFS_ENTER(zfsvfs);

	/*
	* On FreeBSD we can get snapshot's mount point or its parent file
	* system mount point depending if snapshot is already mounted or not.
	*/
	if (zfsvfs->z_parent == zfsvfs && fidp->fid_len == LONG_FID_LEN) {
	zfid_long_t zlfid = (zfid_long_t )fidp;
	uint64_t objsetid = 0;
	uint64_t setgen = 0;

	for (i = 0; i < sizeof (zlfid->zf_setid); i++)
	objsetid \|= ((uint64_t)zlfid->zf_setid[i]) << (8 * i);

	for (i = 0; i < sizeof (zlfid->zf_setgen); i++)
	setgen \|= ((uint64_t)zlfid->zf_setgen[i]) << (8 * i);

	ZFS_EXIT(zfsvfs);

	err = zfsctl_lookup_objset(vfsp, objsetid, &zfsvfs);
	if (err)
	return (SET_ERROR(EINVAL));
	ZFS_ENTER(zfsvfs);
	}

	if (fidp->fid_len == SHORT_FID_LEN \|\| fidp->fid_len == LONG_FID_LEN) {
	zfid_short_t zfid = (zfid_short_t )fidp;

	for (i = 0; i < sizeof (zfid->zf_object); i++)
	object \|= ((uint64_t)zfid->zf_object[i]) << (8 * i);

	for (i = 0; i < sizeof (zfid->zf_gen); i++)
	fid_gen \|= ((uint64_t)zfid->zf_gen[i]) << (8 * i);
	} else {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EINVAL));
	}

	/*
	* A zero fid_gen means we are in .zfs or the .zfs/snapshot
	* directory tree. If the object == zfsvfs->z_shares_dir, then
	* we are in the .zfs/shares directory tree.
	*/
	if ((fid_gen == 0 &&
	(object == ZFSCTL_INO_ROOT \|\| object == ZFSCTL_INO_SNAPDIR)) \|\|
	(zfsvfs->z_shares_dir != 0 && object == zfsvfs->z_shares_dir)) {
	ZFS_EXIT(zfsvfs);
	VERIFY0(zfsctl_root(zfsvfs, LK_SHARED, &dvp));
	if (object == ZFSCTL_INO_SNAPDIR) {
	cn.cn_nameptr = "snapshot";
	cn.cn_namelen = strlen(cn.cn_nameptr);
	cn.cn_nameiop = LOOKUP;
	cn.cn_flags = ISLASTCN \| LOCKLEAF;
	cn.cn_lkflags = flags;
	VERIFY0(VOP_LOOKUP(dvp, vpp, &cn));
	vput(dvp);
	} else if (object == zfsvfs->z_shares_dir) {
	/*
	* XXX This branch must not be taken,
	* if it is, then the lookup below will
	* explode.
	*/
	cn.cn_nameptr = "shares";
	cn.cn_namelen = strlen(cn.cn_nameptr);
	cn.cn_nameiop = LOOKUP;
	cn.cn_flags = ISLASTCN;
	cn.cn_lkflags = flags;
	VERIFY0(VOP_LOOKUP(dvp, vpp, &cn));
	vput(dvp);
	} else {
	*vpp = dvp;
	}
	return (err);
	}

	gen_mask = -1ULL >> (64 - 8 * i);

	dprintf("getting %llu [%u mask %llx]\n", object, fid_gen, gen_mask);
	if ((err = zfs_zget(zfsvfs, object, &zp))) {
	ZFS_EXIT(zfsvfs);
	return (err);
	}
	(void) sa_lookup(zp->z_sa_hdl, SA_ZPL_GEN(zfsvfs), &zp_gen,
	sizeof (uint64_t));
	zp_gen = zp_gen & gen_mask;
	if (zp_gen == 0)
	zp_gen = 1;
	if (zp->z_unlinked \|\| zp_gen != fid_gen) {
	dprintf("znode gen (%u) != fid gen (%u)\n", zp_gen, fid_gen);
	vrele(ZTOV(zp));
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EINVAL));
	}

	*vpp = ZTOV(zp);
	ZFS_EXIT(zfsvfs);
	err = vn_lock(*vpp, flags);
	if (err == 0)
	vnode_create_vobject(*vpp, zp->z_size, curthread);
	else
	*vpp = NULL;
	return (err);
	}

	/*
	* Block out VOPs and close zfsvfs_t::z_os
	*
	* Note, if successful, then we return with the 'z_teardown_lock' and
	* 'z_teardown_inactive_lock' write held. We leave ownership of the underlying
	* dataset and objset intact so that they can be atomically handed off during
	* a subsequent rollback or recv operation and the resume thereafter.
	*/
	int
	zfs_suspend_fs(zfsvfs_t *zfsvfs)
	{
	int error;

	if ((error = zfsvfs_teardown(zfsvfs, B_FALSE)) != 0)
	return (error);

	return (0);
	}

	/*
	* Rebuild SA and release VOPs. Note that ownership of the underlying dataset
	* is an invariant across any of the operations that can be performed while the
	* filesystem was suspended. Whether it succeeded or failed, the preconditions
	* are the same: the relevant objset and associated dataset are owned by
	* zfsvfs, held, and long held on entry.
	*/
	int
	zfs_resume_fs(zfsvfs_t zfsvfs, dsl_dataset_t ds)
	{
	int err;
	znode_t *zp;

	ASSERT(ZFS_TEARDOWN_WRITE_HELD(zfsvfs));
	ASSERT(ZFS_TEARDOWN_INACTIVE_WRITE_HELD(zfsvfs));

	/*
	* We already own this, so just update the objset_t, as the one we
	* had before may have been evicted.
	*/
	objset_t *os;
	VERIFY3P(ds->ds_owner, ==, zfsvfs);
	VERIFY(dsl_dataset_long_held(ds));
	dsl_pool_t *dp = spa_get_dsl(dsl_dataset_get_spa(ds));
	dsl_pool_config_enter(dp, FTAG);
	VERIFY0(dmu_objset_from_ds(ds, &os));
	dsl_pool_config_exit(dp, FTAG);

	err = zfsvfs_init(zfsvfs, os);
	if (err != 0)
	goto bail;

	ds->ds_dir->dd_activity_cancelled = B_FALSE;
	VERIFY(zfsvfs_setup(zfsvfs, B_FALSE) == 0);

	zfs_set_fuid_feature(zfsvfs);

	/*
	* Attempt to re-establish all the active znodes with
	* their dbufs. If a zfs_rezget() fails, then we'll let
	* any potential callers discover that via ZFS_ENTER_VERIFY_VP
	* when they try to use their znode.
	*/
	mutex_enter(&zfsvfs->z_znodes_lock);
	for (zp = list_head(&zfsvfs->z_all_znodes); zp;
	zp = list_next(&zfsvfs->z_all_znodes, zp)) {
	(void) zfs_rezget(zp);
	}
	mutex_exit(&zfsvfs->z_znodes_lock);

	bail:
	/* release the VOPs */
	ZFS_TEARDOWN_INACTIVE_EXIT_WRITE(zfsvfs);
	ZFS_TEARDOWN_EXIT(zfsvfs, FTAG);

	if (err) {
	/*
	* Since we couldn't setup the sa framework, try to force
	* unmount this file system.
	*/
	if (vn_vfswlock(zfsvfs->z_vfs->vfs_vnodecovered) == 0) {
	vfs_ref(zfsvfs->z_vfs);
	(void) dounmount(zfsvfs->z_vfs, MS_FORCE, curthread);
	}
	}
	return (err);
	}

	static void
	zfs_freevfs(vfs_t *vfsp)
	{
	zfsvfs_t *zfsvfs = vfsp->vfs_data;

	zfsvfs_free(zfsvfs);

	atomic_dec_32(&zfs_active_fs_count);
	}

	#ifdef __i386__
	static int desiredvnodes_backup;
	#include <sys/vmmeter.h>


	#include <vm/vm_page.h>
	#include <vm/vm_object.h>
	#include <vm/vm_kern.h>
	#include <vm/vm_map.h>
	#endif

	static void
	zfs_vnodes_adjust(void)
	{
	#ifdef __i386__
	int newdesiredvnodes;

	desiredvnodes_backup = desiredvnodes;

	/*
	* We calculate newdesiredvnodes the same way it is done in
	* vntblinit(). If it is equal to desiredvnodes, it means that
	* it wasn't tuned by the administrator and we can tune it down.
	*/
	newdesiredvnodes = min(maxproc + vm_cnt.v_page_count / 4, 2 *
	vm_kmem_size / (5 * (sizeof (struct vm_object) +
	sizeof (struct vnode))));
	if (newdesiredvnodes == desiredvnodes)
	desiredvnodes = (3 * newdesiredvnodes) / 4;
	#endif
	}

	static void
	zfs_vnodes_adjust_back(void)
	{

	#ifdef __i386__
	desiredvnodes = desiredvnodes_backup;
	#endif
	}

	void
	zfs_init(void)
	{

	printf("ZFS filesystem version: " ZPL_VERSION_STRING "\n");

	/*
	* Initialize .zfs directory structures
	*/
	zfsctl_init();

	/*
	* Initialize znode cache, vnode ops, etc...
	*/
	zfs_znode_init();

	/*
	* Reduce number of vnodes. Originally number of vnodes is calculated
	* with UFS inode in mind. We reduce it here, because it's too big for
	* ZFS/i386.
	*/
	zfs_vnodes_adjust();

	dmu_objset_register_type(DMU_OST_ZFS, zpl_get_file_info);

	zfsvfs_taskq = taskq_create("zfsvfs", 1, minclsyspri, 0, 0, 0);
	}

	void
	zfs_fini(void)
	{
	taskq_destroy(zfsvfs_taskq);
	zfsctl_fini();
	zfs_znode_fini();
	zfs_vnodes_adjust_back();
	}

	int
	zfs_busy(void)
	{
	return (zfs_active_fs_count != 0);
	}

	/*
	* Release VOPs and unmount a suspended filesystem.
	*/
	int
	zfs_end_fs(zfsvfs_t zfsvfs, dsl_dataset_t ds)
	{
	ASSERT(ZFS_TEARDOWN_WRITE_HELD(zfsvfs));
	ASSERT(ZFS_TEARDOWN_INACTIVE_WRITE_HELD(zfsvfs));

	/*
	* We already own this, so just hold and rele it to update the
	* objset_t, as the one we had before may have been evicted.
	*/
	objset_t *os;
	VERIFY3P(ds->ds_owner, ==, zfsvfs);
	VERIFY(dsl_dataset_long_held(ds));
	dsl_pool_t *dp = spa_get_dsl(dsl_dataset_get_spa(ds));
	dsl_pool_config_enter(dp, FTAG);
	VERIFY0(dmu_objset_from_ds(ds, &os));
	dsl_pool_config_exit(dp, FTAG);
	zfsvfs->z_os = os;

	/* release the VOPs */
	ZFS_TEARDOWN_INACTIVE_EXIT_WRITE(zfsvfs);
	ZFS_TEARDOWN_EXIT(zfsvfs, FTAG);

	/*
	* Try to force unmount this file system.
	*/
	(void) zfs_umount(zfsvfs->z_vfs, 0);
	zfsvfs->z_unmounted = B_TRUE;
	return (0);
	}

	int
	zfs_set_version(zfsvfs_t *zfsvfs, uint64_t newvers)
	{
	int error;
	objset_t *os = zfsvfs->z_os;
	dmu_tx_t *tx;

	if (newvers < ZPL_VERSION_INITIAL \|\| newvers > ZPL_VERSION)
	return (SET_ERROR(EINVAL));

	if (newvers < zfsvfs->z_version)
	return (SET_ERROR(EINVAL));

	if (zfs_spa_version_map(newvers) >
	spa_version(dmu_objset_spa(zfsvfs->z_os)))
	return (SET_ERROR(ENOTSUP));

	tx = dmu_tx_create(os);
	dmu_tx_hold_zap(tx, MASTER_NODE_OBJ, B_FALSE, ZPL_VERSION_STR);
	if (newvers >= ZPL_VERSION_SA && !zfsvfs->z_use_sa) {
	dmu_tx_hold_zap(tx, MASTER_NODE_OBJ, B_TRUE,
	ZFS_SA_ATTRS);
	dmu_tx_hold_zap(tx, DMU_NEW_OBJECT, FALSE, NULL);
	}
	error = dmu_tx_assign(tx, TXG_WAIT);
	if (error) {
	dmu_tx_abort(tx);
	return (error);
	}

	error = zap_update(os, MASTER_NODE_OBJ, ZPL_VERSION_STR,
	8, 1, &newvers, tx);

	if (error) {
	dmu_tx_commit(tx);
	return (error);
	}

	if (newvers >= ZPL_VERSION_SA && !zfsvfs->z_use_sa) {
	uint64_t sa_obj;

	ASSERT3U(spa_version(dmu_objset_spa(zfsvfs->z_os)), >=,
	SPA_VERSION_SA);
	sa_obj = zap_create(os, DMU_OT_SA_MASTER_NODE,
	DMU_OT_NONE, 0, tx);

	error = zap_add(os, MASTER_NODE_OBJ,
	ZFS_SA_ATTRS, 8, 1, &sa_obj, tx);
	ASSERT0(error);

	VERIFY(0 == sa_set_sa_object(os, sa_obj));
	sa_register_update_callback(os, zfs_sa_upgrade);
	}

	spa_history_log_internal_ds(dmu_objset_ds(os), "upgrade", tx,
	"from %ju to %ju", (uintmax_t)zfsvfs->z_version,
	(uintmax_t)newvers);
	dmu_tx_commit(tx);

	zfsvfs->z_version = newvers;
	os->os_version = newvers;

	zfs_set_fuid_feature(zfsvfs);

	return (0);
	}

	/*
	* Read a property stored within the master node.
	*/
	int
	zfs_get_zplprop(objset_t os, zfs_prop_t prop, uint64_t value)
	{
	uint64_t *cached_copy = NULL;

	/*
	* Figure out where in the objset_t the cached copy would live, if it
	* is available for the requested property.
	*/
	if (os != NULL) {
	switch (prop) {
	case ZFS_PROP_VERSION:
	cached_copy = &os->os_version;
	break;
	case ZFS_PROP_NORMALIZE:
	cached_copy = &os->os_normalization;
	break;
	case ZFS_PROP_UTF8ONLY:
	cached_copy = &os->os_utf8only;
	break;
	case ZFS_PROP_CASE:
	cached_copy = &os->os_casesensitivity;
	break;
	default:
	break;
	}
	}
	if (cached_copy != NULL && *cached_copy != OBJSET_PROP_UNINITIALIZED) {
	value = cached_copy;
	return (0);
	}

	/*
	* If the property wasn't cached, look up the file system's value for
	* the property. For the version property, we look up a slightly
	* different string.
	*/
	const char *pname;
	int error = ENOENT;
	if (prop == ZFS_PROP_VERSION) {
	pname = ZPL_VERSION_STR;
	} else {
	pname = zfs_prop_to_name(prop);
	}

	if (os != NULL) {
	ASSERT3U(os->os_phys->os_type, ==, DMU_OST_ZFS);
	error = zap_lookup(os, MASTER_NODE_OBJ, pname, 8, 1, value);
	}

	if (error == ENOENT) {
	/* No value set, use the default value */
	switch (prop) {
	case ZFS_PROP_VERSION:
	*value = ZPL_VERSION;
	break;
	case ZFS_PROP_NORMALIZE:
	case ZFS_PROP_UTF8ONLY:
	*value = 0;
	break;
	case ZFS_PROP_CASE:
	*value = ZFS_CASE_SENSITIVE;
	break;
	case ZFS_PROP_ACLTYPE:
	*value = ZFS_ACLTYPE_NFSV4;
	break;
	default:
	return (error);
	}
	error = 0;
	}

	/*
	* If one of the methods for getting the property value above worked,
	* copy it into the objset_t's cache.
	*/
	if (error == 0 && cached_copy != NULL) {
	cached_copy = value;
	}

	return (error);
	}

	/*
	* Return true if the corresponding vfs's unmounted flag is set.
	* Otherwise return false.
	* If this function returns true we know VFS unmount has been initiated.
	*/
	boolean_t
	zfs_get_vfs_flag_unmounted(objset_t *os)
	{
	zfsvfs_t *zfvp;
	boolean_t unmounted = B_FALSE;

	ASSERT(dmu_objset_type(os) == DMU_OST_ZFS);

	mutex_enter(&os->os_user_ptr_lock);
	zfvp = dmu_objset_get_user(os);
	if (zfvp != NULL && zfvp->z_vfs != NULL &&
	(zfvp->z_vfs->mnt_kern_flag & MNTK_UNMOUNT))
	unmounted = B_TRUE;
	mutex_exit(&os->os_user_ptr_lock);

	return (unmounted);
	}

	#ifdef _KERNEL
	void
	zfsvfs_update_fromname(const char oldname, const char newname)
	{
	char tmpbuf[MAXPATHLEN];
	struct mount *mp;
	char *fromname;
	size_t oldlen;

	oldlen = strlen(oldname);

	mtx_lock(&mountlist_mtx);
	TAILQ_FOREACH(mp, &mountlist, mnt_list) {
	fromname = mp->mnt_stat.f_mntfromname;
	if (strcmp(fromname, oldname) == 0) {
	(void) strlcpy(fromname, newname,
	sizeof (mp->mnt_stat.f_mntfromname));
	continue;
	}
	if (strncmp(fromname, oldname, oldlen) == 0 &&
	(fromname[oldlen] == '/' \|\| fromname[oldlen] == '@')) {
	(void) snprintf(tmpbuf, sizeof (tmpbuf), "%s%s",
	newname, fromname + oldlen);
	(void) strlcpy(fromname, tmpbuf,
	sizeof (mp->mnt_stat.f_mntfromname));
	continue;
	}
	}
	mtx_unlock(&mountlist_mtx);
	}
	#endif
	diff --git a/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_vnops_os.c b/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_vnops_os.c
	index f915b0ab1f03..6caca2992149 100644
	--- a/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_vnops_os.c
	+++ b/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_vnops_os.c
	@@ -1,5912 +1,5936 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2012, 2015 by Delphix. All rights reserved.
	* Copyright (c) 2014 Integros [integros.com]
	* Copyright 2017 Nexenta Systems, Inc.
	*/

	/* Portions Copyright 2007 Jeremy Teo */
	/* Portions Copyright 2010 Robert Milkowski */


	#include <sys/types.h>
	#include <sys/param.h>
	#include <sys/time.h>
	#include <sys/systm.h>
	#include <sys/sysmacros.h>
	#include <sys/resource.h>
	#include <sys/vfs.h>
	#include <sys/endian.h>
	#include <sys/vm.h>
	#include <sys/vnode.h>
	#if __FreeBSD_version >= 1300102
	#include <sys/smr.h>
	#endif
	#include <sys/dirent.h>
	#include <sys/file.h>
	#include <sys/stat.h>
	#include <sys/kmem.h>
	#include <sys/taskq.h>
	#include <sys/uio.h>
	#include <sys/atomic.h>
	#include <sys/namei.h>
	#include <sys/mman.h>
	#include <sys/cmn_err.h>
	#include <sys/kdb.h>
	#include <sys/sysproto.h>
	#include <sys/errno.h>
	#include <sys/unistd.h>
	#include <sys/zfs_dir.h>
	#include <sys/zfs_ioctl.h>
	#include <sys/fs/zfs.h>
	#include <sys/dmu.h>
	#include <sys/dmu_objset.h>
	#include <sys/spa.h>
	#include <sys/txg.h>
	#include <sys/dbuf.h>
	#include <sys/zap.h>
	#include <sys/sa.h>
	#include <sys/policy.h>
	#include <sys/sunddi.h>
	#include <sys/filio.h>
	#include <sys/sid.h>
	#include <sys/zfs_ctldir.h>
	#include <sys/zfs_fuid.h>
	#include <sys/zfs_quota.h>
	#include <sys/zfs_sa.h>
	#include <sys/zfs_rlock.h>
	#include <sys/extdirent.h>
	#include <sys/bio.h>
	#include <sys/buf.h>
	#include <sys/sched.h>
	#include <sys/acl.h>
	#include <sys/vmmeter.h>
	#include <vm/vm_param.h>
	#include <sys/zil.h>
	#include <sys/zfs_vnops.h>

	#include <vm/vm_object.h>

	#include <sys/extattr.h>
	#include <sys/priv.h>

	#ifndef VN_OPEN_INVFS
	#define VN_OPEN_INVFS 0x0
	#endif

	VFS_SMR_DECLARE;

	#if __FreeBSD_version >= 1300047
	#define vm_page_wire_lock(pp)
	#define vm_page_wire_unlock(pp)
	#else
	#define vm_page_wire_lock(pp) vm_page_lock(pp)
	#define vm_page_wire_unlock(pp) vm_page_unlock(pp)
	#endif

	#ifdef DEBUG_VFS_LOCKS
	#define VNCHECKREF(vp) \
	VNASSERT((vp)->v_holdcnt > 0 && (vp)->v_usecount > 0, vp, \
	("%s: wrong ref counts", __func__));
	#else
	#define VNCHECKREF(vp)
	#endif

	/*
	* Programming rules.
	*
	* Each vnode op performs some logical unit of work. To do this, the ZPL must
	* properly lock its in-core state, create a DMU transaction, do the work,
	* record this work in the intent log (ZIL), commit the DMU transaction,
	* and wait for the intent log to commit if it is a synchronous operation.
	* Moreover, the vnode ops must work in both normal and log replay context.
	* The ordering of events is important to avoid deadlocks and references
	* to freed memory. The example below illustrates the following Big Rules:
	*
	* (1) A check must be made in each zfs thread for a mounted file system.
	* This is done avoiding races using ZFS_ENTER(zfsvfs).
	* A ZFS_EXIT(zfsvfs) is needed before all returns. Any znodes
	* must be checked with ZFS_VERIFY_ZP(zp). Both of these macros
	* can return EIO from the calling function.
	*
	* (2) VN_RELE() should always be the last thing except for zil_commit()
	* (if necessary) and ZFS_EXIT(). This is for 3 reasons:
	* First, if it's the last reference, the vnode/znode
	* can be freed, so the zp may point to freed memory. Second, the last
	* reference will call zfs_zinactive(), which may induce a lot of work --
	* pushing cached pages (which acquires range locks) and syncing out
	* cached atime changes. Third, zfs_zinactive() may require a new tx,
	* which could deadlock the system if you were already holding one.
	* If you must call VN_RELE() within a tx then use VN_RELE_ASYNC().
	*
	* (3) All range locks must be grabbed before calling dmu_tx_assign(),
	* as they can span dmu_tx_assign() calls.
	*
	* (4) If ZPL locks are held, pass TXG_NOWAIT as the second argument to
	* dmu_tx_assign(). This is critical because we don't want to block
	* while holding locks.
	*
	* If no ZPL locks are held (aside from ZFS_ENTER()), use TXG_WAIT. This
	* reduces lock contention and CPU usage when we must wait (note that if
	* throughput is constrained by the storage, nearly every transaction
	* must wait).
	*
	* Note, in particular, that if a lock is sometimes acquired before
	* the tx assigns, and sometimes after (e.g. z_lock), then failing
	* to use a non-blocking assign can deadlock the system. The scenario:
	*
	* Thread A has grabbed a lock before calling dmu_tx_assign().
	* Thread B is in an already-assigned tx, and blocks for this lock.
	* Thread A calls dmu_tx_assign(TXG_WAIT) and blocks in txg_wait_open()
	* forever, because the previous txg can't quiesce until B's tx commits.
	*
	* If dmu_tx_assign() returns ERESTART and zfsvfs->z_assign is TXG_NOWAIT,
	* then drop all locks, call dmu_tx_wait(), and try again. On subsequent
	* calls to dmu_tx_assign(), pass TXG_NOTHROTTLE in addition to TXG_NOWAIT,
	* to indicate that this operation has already called dmu_tx_wait().
	* This will ensure that we don't retry forever, waiting a short bit
	* each time.
	*
	* (5) If the operation succeeded, generate the intent log entry for it
	* before dropping locks. This ensures that the ordering of events
	* in the intent log matches the order in which they actually occurred.
	* During ZIL replay the zfs_log_* functions will update the sequence
	* number to indicate the zil transaction has replayed.
	*
	* (6) At the end of each vnode op, the DMU tx must always commit,
	* regardless of whether there were any errors.
	*
	* (7) After dropping all locks, invoke zil_commit(zilog, foid)
	* to ensure that synchronous semantics are provided when necessary.
	*
	* In general, this is how things should be ordered in each vnode op:
	*
	* ZFS_ENTER(zfsvfs); // exit if unmounted
	* top:
	* zfs_dirent_lookup(&dl, ...) // lock directory entry (may VN_HOLD())
	* rw_enter(...); // grab any other locks you need
	* tx = dmu_tx_create(...); // get DMU tx
	* dmu_tx_hold_*(); // hold each object you might modify
	* error = dmu_tx_assign(tx, (waited ? TXG_NOTHROTTLE : 0) \| TXG_NOWAIT);
	* if (error) {
	* rw_exit(...); // drop locks
	* zfs_dirent_unlock(dl); // unlock directory entry
	* VN_RELE(...); // release held vnodes
	* if (error == ERESTART) {
	* waited = B_TRUE;
	* dmu_tx_wait(tx);
	* dmu_tx_abort(tx);
	* goto top;
	* }
	* dmu_tx_abort(tx); // abort DMU tx
	* ZFS_EXIT(zfsvfs); // finished in zfs
	* return (error); // really out of space
	* }
	* error = do_real_work(); // do whatever this VOP does
	* if (error == 0)
	* zfs_log_*(...); // on success, make ZIL entry
	* dmu_tx_commit(tx); // commit DMU tx -- error or not
	* rw_exit(...); // drop locks
	* zfs_dirent_unlock(dl); // unlock directory entry
	* VN_RELE(...); // release held vnodes
	* zil_commit(zilog, foid); // synchronous when necessary
	* ZFS_EXIT(zfsvfs); // finished in zfs
	* return (error); // done, report error
	*/

	/* ARGSUSED */
	static int
	zfs_open(vnode_t *vpp, int flag, cred_t cr)
	{
	znode_t zp = VTOZ(vpp);
	zfsvfs_t *zfsvfs = zp->z_zfsvfs;

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zp);

	if ((flag & FWRITE) && (zp->z_pflags & ZFS_APPENDONLY) &&
	((flag & FAPPEND) == 0)) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EPERM));
	}

	if (!zfs_has_ctldir(zp) && zp->z_zfsvfs->z_vscan &&
	ZTOV(zp)->v_type == VREG &&
	!(zp->z_pflags & ZFS_AV_QUARANTINED) && zp->z_size > 0) {
	if (fs_vscan(*vpp, cr, 0) != 0) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EACCES));
	}
	}

	/* Keep a count of the synchronous opens in the znode */
	if (flag & (FSYNC \| FDSYNC))
	atomic_inc_32(&zp->z_sync_cnt);

	ZFS_EXIT(zfsvfs);
	return (0);
	}

	/* ARGSUSED */
	static int
	zfs_close(vnode_t vp, int flag, int count, offset_t offset, cred_t cr)
	{
	znode_t *zp = VTOZ(vp);
	zfsvfs_t *zfsvfs = zp->z_zfsvfs;

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zp);

	/* Decrement the synchronous opens in the znode */
	if ((flag & (FSYNC \| FDSYNC)) && (count == 1))
	atomic_dec_32(&zp->z_sync_cnt);

	if (!zfs_has_ctldir(zp) && zp->z_zfsvfs->z_vscan &&
	ZTOV(zp)->v_type == VREG &&
	!(zp->z_pflags & ZFS_AV_QUARANTINED) && zp->z_size > 0)
	VERIFY(fs_vscan(vp, cr, 1) == 0);

	ZFS_EXIT(zfsvfs);
	return (0);
	}

	/* ARGSUSED */
	static int
	zfs_ioctl(vnode_t vp, ulong_t com, intptr_t data, int flag, cred_t cred,
	int *rvalp)
	{
	loff_t off;
	int error;

	switch (com) {
	case _FIOFFS:
	{
	return (0);

	/*
	* The following two ioctls are used by bfu. Faking out,
	* necessary to avoid bfu errors.
	*/
	}
	case _FIOGDIO:
	case _FIOSDIO:
	{
	return (0);
	}

	case F_SEEK_DATA:
	case F_SEEK_HOLE:
	{
	off = (offset_t )data;
	/* offset parameter is in/out */
	error = zfs_holey(VTOZ(vp), com, &off);
	if (error)
	return (error);
	(offset_t )data = off;
	return (0);
	}
	}
	return (SET_ERROR(ENOTTY));
	}

	static vm_page_t
	page_busy(vnode_t *vp, int64_t start, int64_t off, int64_t nbytes)
	{
	vm_object_t obj;
	vm_page_t pp;
	int64_t end;

	/*
	* At present vm_page_clear_dirty extends the cleared range to DEV_BSIZE
	* aligned boundaries, if the range is not aligned. As a result a
	* DEV_BSIZE subrange with partially dirty data may get marked as clean.
	* It may happen that all DEV_BSIZE subranges are marked clean and thus
	* the whole page would be considered clean despite have some
	* dirty data.
	* For this reason we should shrink the range to DEV_BSIZE aligned
	* boundaries before calling vm_page_clear_dirty.
	*/
	end = rounddown2(off + nbytes, DEV_BSIZE);
	off = roundup2(off, DEV_BSIZE);
	nbytes = end - off;

	obj = vp->v_object;
	zfs_vmobject_assert_wlocked_12(obj);
	#if __FreeBSD_version < 1300050
	for (;;) {
	if ((pp = vm_page_lookup(obj, OFF_TO_IDX(start))) != NULL &&
	pp->valid) {
	if (vm_page_xbusied(pp)) {
	/*
	* Reference the page before unlocking and
	* sleeping so that the page daemon is less
	* likely to reclaim it.
	*/
	vm_page_reference(pp);
	vm_page_lock(pp);
	zfs_vmobject_wunlock(obj);
	vm_page_busy_sleep(pp, "zfsmwb", true);
	zfs_vmobject_wlock(obj);
	continue;
	}
	vm_page_sbusy(pp);
	} else if (pp != NULL) {
	ASSERT(!pp->valid);
	pp = NULL;
	}
	if (pp != NULL) {
	ASSERT3U(pp->valid, ==, VM_PAGE_BITS_ALL);
	vm_object_pip_add(obj, 1);
	pmap_remove_write(pp);
	if (nbytes != 0)
	vm_page_clear_dirty(pp, off, nbytes);
	}
	break;
	}
	#else
	vm_page_grab_valid_unlocked(&pp, obj, OFF_TO_IDX(start),
	VM_ALLOC_NOCREAT \| VM_ALLOC_SBUSY \| VM_ALLOC_NORMAL \|
	VM_ALLOC_IGN_SBUSY);
	if (pp != NULL) {
	ASSERT3U(pp->valid, ==, VM_PAGE_BITS_ALL);
	vm_object_pip_add(obj, 1);
	pmap_remove_write(pp);
	if (nbytes != 0)
	vm_page_clear_dirty(pp, off, nbytes);
	}
	#endif
	return (pp);
	}

	static void
	page_unbusy(vm_page_t pp)
	{

	vm_page_sunbusy(pp);
	#if __FreeBSD_version >= 1300041
	vm_object_pip_wakeup(pp->object);
	#else
	vm_object_pip_subtract(pp->object, 1);
	#endif
	}

	#if __FreeBSD_version > 1300051
	static vm_page_t
	page_hold(vnode_t *vp, int64_t start)
	{
	vm_object_t obj;
	vm_page_t m;

	obj = vp->v_object;
	vm_page_grab_valid_unlocked(&m, obj, OFF_TO_IDX(start),
	VM_ALLOC_NOCREAT \| VM_ALLOC_WIRED \| VM_ALLOC_IGN_SBUSY \|
	VM_ALLOC_NOBUSY);
	return (m);
	}
	#else
	static vm_page_t
	page_hold(vnode_t *vp, int64_t start)
	{
	vm_object_t obj;
	vm_page_t pp;

	obj = vp->v_object;
	zfs_vmobject_assert_wlocked(obj);

	for (;;) {
	if ((pp = vm_page_lookup(obj, OFF_TO_IDX(start))) != NULL &&
	pp->valid) {
	if (vm_page_xbusied(pp)) {
	/*
	* Reference the page before unlocking and
	* sleeping so that the page daemon is less
	* likely to reclaim it.
	*/
	vm_page_reference(pp);
	vm_page_lock(pp);
	zfs_vmobject_wunlock(obj);
	vm_page_busy_sleep(pp, "zfsmwb", true);
	zfs_vmobject_wlock(obj);
	continue;
	}

	ASSERT3U(pp->valid, ==, VM_PAGE_BITS_ALL);
	vm_page_wire_lock(pp);
	vm_page_hold(pp);
	vm_page_wire_unlock(pp);

	} else
	pp = NULL;
	break;
	}
	return (pp);
	}
	#endif

	static void
	page_unhold(vm_page_t pp)
	{

	vm_page_wire_lock(pp);
	#if __FreeBSD_version >= 1300035
	vm_page_unwire(pp, PQ_ACTIVE);
	#else
	vm_page_unhold(pp);
	#endif
	vm_page_wire_unlock(pp);
	}

	/*
	* When a file is memory mapped, we must keep the IO data synchronized
	* between the DMU cache and the memory mapped pages. What this means:
	*
	* On Write: If we find a memory mapped page, we write to both
	* the page and the dmu buffer.
	*/
	void
	update_pages(znode_t zp, int64_t start, int len, objset_t os)
	{
	vm_object_t obj;
	struct sf_buf *sf;
	vnode_t *vp = ZTOV(zp);
	caddr_t va;
	int off;

	ASSERT(vp->v_mount != NULL);
	obj = vp->v_object;
	ASSERT(obj != NULL);

	off = start & PAGEOFFSET;
	zfs_vmobject_wlock_12(obj);
	#if __FreeBSD_version >= 1300041
	vm_object_pip_add(obj, 1);
	#endif
	for (start &= PAGEMASK; len > 0; start += PAGESIZE) {
	vm_page_t pp;
	int nbytes = imin(PAGESIZE - off, len);

	if ((pp = page_busy(vp, start, off, nbytes)) != NULL) {
	zfs_vmobject_wunlock_12(obj);

	va = zfs_map_page(pp, &sf);
	(void) dmu_read(os, zp->z_id, start + off, nbytes,
	va + off, DMU_READ_PREFETCH);
	zfs_unmap_page(sf);

	zfs_vmobject_wlock_12(obj);
	page_unbusy(pp);
	}
	len -= nbytes;
	off = 0;
	}
	#if __FreeBSD_version >= 1300041
	vm_object_pip_wakeup(obj);
	#else
	vm_object_pip_wakeupn(obj, 0);
	#endif
	zfs_vmobject_wunlock_12(obj);
	}

	/*
	* Read with UIO_NOCOPY flag means that sendfile(2) requests
	* ZFS to populate a range of page cache pages with data.
	*
	* NOTE: this function could be optimized to pre-allocate
	* all pages in advance, drain exclusive busy on all of them,
	* map them into contiguous KVA region and populate them
	* in one single dmu_read() call.
	*/
	int
	mappedread_sf(znode_t zp, int nbytes, zfs_uio_t uio)
	{
	vnode_t *vp = ZTOV(zp);
	objset_t *os = zp->z_zfsvfs->z_os;
	struct sf_buf *sf;
	vm_object_t obj;
	vm_page_t pp;
	int64_t start;
	caddr_t va;
	int len = nbytes;
	int error = 0;

	ASSERT(zfs_uio_segflg(uio) == UIO_NOCOPY);
	ASSERT(vp->v_mount != NULL);
	obj = vp->v_object;
	ASSERT(obj != NULL);
	ASSERT((zfs_uio_offset(uio) & PAGEOFFSET) == 0);

	zfs_vmobject_wlock_12(obj);
	for (start = zfs_uio_offset(uio); len > 0; start += PAGESIZE) {
	int bytes = MIN(PAGESIZE, len);

	pp = vm_page_grab_unlocked(obj, OFF_TO_IDX(start),
	VM_ALLOC_SBUSY \| VM_ALLOC_NORMAL \| VM_ALLOC_IGN_SBUSY);
	if (vm_page_none_valid(pp)) {
	zfs_vmobject_wunlock_12(obj);
	va = zfs_map_page(pp, &sf);
	error = dmu_read(os, zp->z_id, start, bytes, va,
	DMU_READ_PREFETCH);
	if (bytes != PAGESIZE && error == 0)
	bzero(va + bytes, PAGESIZE - bytes);
	zfs_unmap_page(sf);
	zfs_vmobject_wlock_12(obj);
	#if __FreeBSD_version >= 1300081
	if (error == 0) {
	vm_page_valid(pp);
	vm_page_activate(pp);
	vm_page_do_sunbusy(pp);
	} else {
	zfs_vmobject_wlock(obj);
	if (!vm_page_wired(pp) && pp->valid == 0 &&
	vm_page_busy_tryupgrade(pp))
	vm_page_free(pp);
	else
	vm_page_sunbusy(pp);
	zfs_vmobject_wunlock(obj);
	}
	#else
	vm_page_do_sunbusy(pp);
	vm_page_lock(pp);
	if (error) {
	if (pp->wire_count == 0 && pp->valid == 0 &&
	!vm_page_busied(pp))
	vm_page_free(pp);
	} else {
	pp->valid = VM_PAGE_BITS_ALL;
	vm_page_activate(pp);
	}
	vm_page_unlock(pp);
	#endif
	} else {
	ASSERT3U(pp->valid, ==, VM_PAGE_BITS_ALL);
	vm_page_do_sunbusy(pp);
	}
	if (error)
	break;
	zfs_uio_advance(uio, bytes);
	len -= bytes;
	}
	zfs_vmobject_wunlock_12(obj);
	return (error);
	}

	/*
	* When a file is memory mapped, we must keep the IO data synchronized
	* between the DMU cache and the memory mapped pages. What this means:
	*
	* On Read: We "read" preferentially from memory mapped pages,
	* else we default from the dmu buffer.
	*
	* NOTE: We will always "break up" the IO into PAGESIZE uiomoves when
	* the file is memory mapped.
	*/
	int
	mappedread(znode_t zp, int nbytes, zfs_uio_t uio)
	{
	vnode_t *vp = ZTOV(zp);
	vm_object_t obj;
	int64_t start;
	int len = nbytes;
	int off;
	int error = 0;

	ASSERT(vp->v_mount != NULL);
	obj = vp->v_object;
	ASSERT(obj != NULL);

	start = zfs_uio_offset(uio);
	off = start & PAGEOFFSET;
	zfs_vmobject_wlock_12(obj);
	for (start &= PAGEMASK; len > 0; start += PAGESIZE) {
	vm_page_t pp;
	uint64_t bytes = MIN(PAGESIZE - off, len);

	if ((pp = page_hold(vp, start))) {
	struct sf_buf *sf;
	caddr_t va;

	zfs_vmobject_wunlock_12(obj);
	va = zfs_map_page(pp, &sf);
	error = vn_io_fault_uiomove(va + off, bytes,
	GET_UIO_STRUCT(uio));
	zfs_unmap_page(sf);
	zfs_vmobject_wlock_12(obj);
	page_unhold(pp);
	} else {
	zfs_vmobject_wunlock_12(obj);
	error = dmu_read_uio_dbuf(sa_get_db(zp->z_sa_hdl),
	uio, bytes);
	zfs_vmobject_wlock_12(obj);
	}
	len -= bytes;
	off = 0;
	if (error)
	break;
	}
	zfs_vmobject_wunlock_12(obj);
	return (error);
	}

	int
	zfs_write_simple(znode_t zp, const void data, size_t len,
	loff_t pos, size_t *presid)
	{
	int error = 0;
	ssize_t resid;

	error = vn_rdwr(UIO_WRITE, ZTOV(zp), __DECONST(void *, data), len, pos,
	UIO_SYSSPACE, IO_SYNC, kcred, NOCRED, &resid, curthread);

	if (error) {
	return (SET_ERROR(error));
	} else if (presid == NULL) {
	if (resid != 0) {
	error = SET_ERROR(EIO);
	}
	} else {
	*presid = resid;
	}
	return (error);
	}

	void
	zfs_zrele_async(znode_t *zp)
	{
	vnode_t *vp = ZTOV(zp);
	objset_t *os = ITOZSB(vp)->z_os;

	VN_RELE_ASYNC(vp, dsl_pool_zrele_taskq(dmu_objset_pool(os)));
	}

	static int
	zfs_dd_callback(struct mount mp, void arg, int lkflags, struct vnode **vpp)
	{
	int error;

	*vpp = arg;
	error = vn_lock(*vpp, lkflags);
	if (error != 0)
	vrele(*vpp);
	return (error);
	}

	static int
	zfs_lookup_lock(vnode_t dvp, vnode_t vp, const char *name, int lkflags)
	{
	znode_t *zdp = VTOZ(dvp);
	zfsvfs_t *zfsvfs __unused = zdp->z_zfsvfs;
	int error;
	int ltype;

	if (zfsvfs->z_replay == B_FALSE)
	ASSERT_VOP_LOCKED(dvp, __func__);

	if (name[0] == 0 \|\| (name[0] == '.' && name[1] == 0)) {
	ASSERT3P(dvp, ==, vp);
	vref(dvp);
	ltype = lkflags & LK_TYPE_MASK;
	if (ltype != VOP_ISLOCKED(dvp)) {
	if (ltype == LK_EXCLUSIVE)
	vn_lock(dvp, LK_UPGRADE \| LK_RETRY);
	else /* if (ltype == LK_SHARED) */
	vn_lock(dvp, LK_DOWNGRADE \| LK_RETRY);

	/*
	* Relock for the "." case could leave us with
	* reclaimed vnode.
	*/
	if (VN_IS_DOOMED(dvp)) {
	vrele(dvp);
	return (SET_ERROR(ENOENT));
	}
	}
	return (0);
	} else if (name[0] == '.' && name[1] == '.' && name[2] == 0) {
	/*
	* Note that in this case, dvp is the child vnode, and we
	* are looking up the parent vnode - exactly reverse from
	* normal operation. Unlocking dvp requires some rather
	* tricky unlock/relock dance to prevent mp from being freed;
	* use vn_vget_ino_gen() which takes care of all that.
	*
	* XXX Note that there is a time window when both vnodes are
	* unlocked. It is possible, although highly unlikely, that
	* during that window the parent-child relationship between
	* the vnodes may change, for example, get reversed.
	* In that case we would have a wrong lock order for the vnodes.
	* All other filesystems seem to ignore this problem, so we
	* do the same here.
	* A potential solution could be implemented as follows:
	* - using LK_NOWAIT when locking the second vnode and retrying
	* if necessary
	* - checking that the parent-child relationship still holds
	* after locking both vnodes and retrying if it doesn't
	*/
	error = vn_vget_ino_gen(dvp, zfs_dd_callback, vp, lkflags, &vp);
	return (error);
	} else {
	error = vn_lock(vp, lkflags);
	if (error != 0)
	vrele(vp);
	return (error);
	}
	}

	/*
	* Lookup an entry in a directory, or an extended attribute directory.
	* If it exists, return a held vnode reference for it.
	*
	* IN: dvp - vnode of directory to search.
	* nm - name of entry to lookup.
	* pnp - full pathname to lookup [UNUSED].
	* flags - LOOKUP_XATTR set if looking for an attribute.
	* rdir - root directory vnode [UNUSED].
	* cr - credentials of caller.
	* ct - caller context
	*
	* OUT: vpp - vnode of located entry, NULL if not found.
	*
	* RETURN: 0 on success, error code on failure.
	*
	* Timestamps:
	* NA
	*/
	/* ARGSUSED */
	static int
	zfs_lookup(vnode_t dvp, const char nm, vnode_t **vpp,
	struct componentname cnp, int nameiop, cred_t cr, kthread_t *td,
	int flags, boolean_t cached)
	{
	znode_t *zdp = VTOZ(dvp);
	znode_t *zp;
	zfsvfs_t *zfsvfs = zdp->z_zfsvfs;
	+#if __FreeBSD_version > 1300124
	seqc_t dvp_seqc;
	+#endif
	int error = 0;

	/*
	* Fast path lookup, however we must skip DNLC lookup
	* for case folding or normalizing lookups because the
	* DNLC code only stores the passed in name. This means
	* creating 'a' and removing 'A' on a case insensitive
	* file system would work, but DNLC still thinks 'a'
	* exists and won't let you create it again on the next
	* pass through fast path.
	*/
	if (!(flags & LOOKUP_XATTR)) {
	if (dvp->v_type != VDIR) {
	return (SET_ERROR(ENOTDIR));
	} else if (zdp->z_sa_hdl == NULL) {
	return (SET_ERROR(EIO));
	}
	}

	DTRACE_PROBE2(zfs__fastpath__lookup__miss, vnode_t *, dvp,
	const char *, nm);

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zdp);

	+#if __FreeBSD_version > 1300124
	dvp_seqc = vn_seqc_read_notmodify(dvp);
	+#endif

	*vpp = NULL;

	if (flags & LOOKUP_XATTR) {
	/*
	* If the xattr property is off, refuse the lookup request.
	*/
	if (!(zfsvfs->z_flags & ZSB_XATTR)) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EOPNOTSUPP));
	}

	/*
	* We don't allow recursive attributes..
	* Maybe someday we will.
	*/
	if (zdp->z_pflags & ZFS_XATTR) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EINVAL));
	}

	if ((error = zfs_get_xattrdir(VTOZ(dvp), &zp, cr, flags))) {
	ZFS_EXIT(zfsvfs);
	return (error);
	}
	*vpp = ZTOV(zp);

	/*
	* Do we have permission to get into attribute directory?
	*/
	error = zfs_zaccess(zp, ACE_EXECUTE, 0, B_FALSE, cr);
	if (error) {
	vrele(ZTOV(zp));
	}

	ZFS_EXIT(zfsvfs);
	return (error);
	}

	/*
	* Check accessibility of directory if we're not coming in via
	* VOP_CACHEDLOOKUP.
	*/
	if (!cached) {
	#ifdef NOEXECCHECK
	if ((cnp->cn_flags & NOEXECCHECK) != 0) {
	cnp->cn_flags &= ~NOEXECCHECK;
	} else
	#endif
	if ((error = zfs_zaccess(zdp, ACE_EXECUTE, 0, B_FALSE, cr))) {
	ZFS_EXIT(zfsvfs);
	return (error);
	}
	}

	if (zfsvfs->z_utf8 && u8_validate(nm, strlen(nm),
	NULL, U8_VALIDATE_ENTIRE, &error) < 0) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EILSEQ));
	}


	/*
	* First handle the special cases.
	*/
	if ((cnp->cn_flags & ISDOTDOT) != 0) {
	/*
	* If we are a snapshot mounted under .zfs, return
	* the vp for the snapshot directory.
	*/
	if (zdp->z_id == zfsvfs->z_root && zfsvfs->z_parent != zfsvfs) {
	struct componentname cn;
	vnode_t *zfsctl_vp;
	int ltype;

	ZFS_EXIT(zfsvfs);
	ltype = VOP_ISLOCKED(dvp);
	VOP_UNLOCK1(dvp);
	error = zfsctl_root(zfsvfs->z_parent, LK_SHARED,
	&zfsctl_vp);
	if (error == 0) {
	cn.cn_nameptr = "snapshot";
	cn.cn_namelen = strlen(cn.cn_nameptr);
	cn.cn_nameiop = cnp->cn_nameiop;
	cn.cn_flags = cnp->cn_flags & ~ISDOTDOT;
	cn.cn_lkflags = cnp->cn_lkflags;
	error = VOP_LOOKUP(zfsctl_vp, vpp, &cn);
	vput(zfsctl_vp);
	}
	vn_lock(dvp, ltype \| LK_RETRY);
	return (error);
	}
	}
	if (zfs_has_ctldir(zdp) && strcmp(nm, ZFS_CTLDIR_NAME) == 0) {
	ZFS_EXIT(zfsvfs);
	if ((cnp->cn_flags & ISLASTCN) != 0 && nameiop != LOOKUP)
	return (SET_ERROR(ENOTSUP));
	error = zfsctl_root(zfsvfs, cnp->cn_lkflags, vpp);
	return (error);
	}

	/*
	* The loop is retry the lookup if the parent-child relationship
	* changes during the dot-dot locking complexities.
	*/
	for (;;) {
	uint64_t parent;

	error = zfs_dirlook(zdp, nm, &zp);
	if (error == 0)
	*vpp = ZTOV(zp);

	ZFS_EXIT(zfsvfs);
	if (error != 0)
	break;

	error = zfs_lookup_lock(dvp, *vpp, nm, cnp->cn_lkflags);
	if (error != 0) {
	/*
	* If we've got a locking error, then the vnode
	* got reclaimed because of a force unmount.
	* We never enter doomed vnodes into the name cache.
	*/
	*vpp = NULL;
	return (error);
	}

	if ((cnp->cn_flags & ISDOTDOT) == 0)
	break;

	ZFS_ENTER(zfsvfs);
	if (zdp->z_sa_hdl == NULL) {
	error = SET_ERROR(EIO);
	} else {
	error = sa_lookup(zdp->z_sa_hdl, SA_ZPL_PARENT(zfsvfs),
	&parent, sizeof (parent));
	}
	if (error != 0) {
	ZFS_EXIT(zfsvfs);
	vput(ZTOV(zp));
	break;
	}
	if (zp->z_id == parent) {
	ZFS_EXIT(zfsvfs);
	break;
	}
	vput(ZTOV(zp));
	}

	if (error != 0)
	*vpp = NULL;

	/* Translate errors and add SAVENAME when needed. */
	if (cnp->cn_flags & ISLASTCN) {
	switch (nameiop) {
	case CREATE:
	case RENAME:
	if (error == ENOENT) {
	error = EJUSTRETURN;
	cnp->cn_flags \|= SAVENAME;
	break;
	}
	/* FALLTHROUGH */
	case DELETE:
	if (error == 0)
	cnp->cn_flags \|= SAVENAME;
	break;
	}
	}

	+#if __FreeBSD_version > 1300124
	if ((cnp->cn_flags & ISDOTDOT) != 0) {
	/*
	* FIXME: zfs_lookup_lock relocks vnodes and does nothing to
	* handle races. In particular different callers may end up
	* with different vnodes and will try to add conflicting
	* entries to the namecache.
	*
	* While finding different result may be acceptable in face
	* of concurrent modification, adding conflicting entries
	* trips over an assert in the namecache.
	*
	* Ultimately let an entry through once everything settles.
	*/
	if (!vn_seqc_consistent(dvp, dvp_seqc)) {
	cnp->cn_flags &= ~MAKEENTRY;
	}
	}
	+#endif

	/* Insert name into cache (as non-existent) if appropriate. */
	if (zfsvfs->z_use_namecache && !zfsvfs->z_replay &&
	error == ENOENT && (cnp->cn_flags & MAKEENTRY) != 0)
	cache_enter(dvp, NULL, cnp);

	/* Insert name into cache if appropriate. */
	if (zfsvfs->z_use_namecache && !zfsvfs->z_replay &&
	error == 0 && (cnp->cn_flags & MAKEENTRY)) {
	if (!(cnp->cn_flags & ISLASTCN) \|\|
	(nameiop != DELETE && nameiop != RENAME)) {
	cache_enter(dvp, *vpp, cnp);
	}
	}

	return (error);
	}

	/*
	* Attempt to create a new entry in a directory. If the entry
	* already exists, truncate the file if permissible, else return
	* an error. Return the vp of the created or trunc'd file.
	*
	* IN: dvp - vnode of directory to put new file entry in.
	* name - name of new file entry.
	* vap - attributes of new file.
	* excl - flag indicating exclusive or non-exclusive mode.
	* mode - mode to open file with.
	* cr - credentials of caller.
	* flag - large file flag [UNUSED].
	* ct - caller context
	* vsecp - ACL to be set
	*
	* OUT: vpp - vnode of created or trunc'd entry.
	*
	* RETURN: 0 on success, error code on failure.
	*
	* Timestamps:
	* dvp - ctime\|mtime updated if new entry created
	* vp - ctime\|mtime always, atime if new
	*/

	/* ARGSUSED */
	int
	zfs_create(znode_t dzp, const char name, vattr_t *vap, int excl, int mode,
	znode_t *zpp, cred_t cr, int flag, vsecattr_t *vsecp)
	{
	znode_t *zp;
	zfsvfs_t *zfsvfs = dzp->z_zfsvfs;
	zilog_t *zilog;
	objset_t *os;
	dmu_tx_t *tx;
	int error;
	ksid_t *ksid;
	uid_t uid;
	gid_t gid = crgetgid(cr);
	uint64_t projid = ZFS_DEFAULT_PROJID;
	zfs_acl_ids_t acl_ids;
	boolean_t fuid_dirtied;
	uint64_t txtype;
	#ifdef DEBUG_VFS_LOCKS
	vnode_t *dvp = ZTOV(dzp);
	#endif

	/*
	* If we have an ephemeral id, ACL, or XVATTR then
	* make sure file system is at proper version
	*/

	ksid = crgetsid(cr, KSID_OWNER);
	if (ksid)
	uid = ksid_getid(ksid);
	else
	uid = crgetuid(cr);

	if (zfsvfs->z_use_fuids == B_FALSE &&
	(vsecp \|\| (vap->va_mask & AT_XVATTR) \|\|
	IS_EPHEMERAL(uid) \|\| IS_EPHEMERAL(gid)))
	return (SET_ERROR(EINVAL));

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(dzp);
	os = zfsvfs->z_os;
	zilog = zfsvfs->z_log;

	if (zfsvfs->z_utf8 && u8_validate(name, strlen(name),
	NULL, U8_VALIDATE_ENTIRE, &error) < 0) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EILSEQ));
	}

	if (vap->va_mask & AT_XVATTR) {
	if ((error = secpolicy_xvattr(ZTOV(dzp), (xvattr_t *)vap,
	crgetuid(cr), cr, vap->va_type)) != 0) {
	ZFS_EXIT(zfsvfs);
	return (error);
	}
	}

	*zpp = NULL;

	if ((vap->va_mode & S_ISVTX) && secpolicy_vnode_stky_modify(cr))
	vap->va_mode &= ~S_ISVTX;

	error = zfs_dirent_lookup(dzp, name, &zp, ZNEW);
	if (error) {
	ZFS_EXIT(zfsvfs);
	return (error);
	}
	ASSERT3P(zp, ==, NULL);

	/*
	* Create a new file object and update the directory
	* to reference it.
	*/
	if ((error = zfs_zaccess(dzp, ACE_ADD_FILE, 0, B_FALSE, cr))) {
	goto out;
	}

	/*
	* We only support the creation of regular files in
	* extended attribute directories.
	*/

	if ((dzp->z_pflags & ZFS_XATTR) &&
	(vap->va_type != VREG)) {
	error = SET_ERROR(EINVAL);
	goto out;
	}

	if ((error = zfs_acl_ids_create(dzp, 0, vap,
	cr, vsecp, &acl_ids)) != 0)
	goto out;

	if (S_ISREG(vap->va_mode) \|\| S_ISDIR(vap->va_mode))
	projid = zfs_inherit_projid(dzp);
	if (zfs_acl_ids_overquota(zfsvfs, &acl_ids, projid)) {
	zfs_acl_ids_free(&acl_ids);
	error = SET_ERROR(EDQUOT);
	goto out;
	}

	getnewvnode_reserve_();

	tx = dmu_tx_create(os);

	dmu_tx_hold_sa_create(tx, acl_ids.z_aclp->z_acl_bytes +
	ZFS_SA_BASE_ATTR_SIZE);

	fuid_dirtied = zfsvfs->z_fuid_dirty;
	if (fuid_dirtied)
	zfs_fuid_txhold(zfsvfs, tx);
	dmu_tx_hold_zap(tx, dzp->z_id, TRUE, name);
	dmu_tx_hold_sa(tx, dzp->z_sa_hdl, B_FALSE);
	if (!zfsvfs->z_use_sa &&
	acl_ids.z_aclp->z_acl_bytes > ZFS_ACE_SPACE) {
	dmu_tx_hold_write(tx, DMU_NEW_OBJECT,
	0, acl_ids.z_aclp->z_acl_bytes);
	}
	error = dmu_tx_assign(tx, TXG_WAIT);
	if (error) {
	zfs_acl_ids_free(&acl_ids);
	dmu_tx_abort(tx);
	getnewvnode_drop_reserve();
	ZFS_EXIT(zfsvfs);
	return (error);
	}
	zfs_mknode(dzp, vap, tx, cr, 0, &zp, &acl_ids);
	if (fuid_dirtied)
	zfs_fuid_sync(zfsvfs, tx);

	(void) zfs_link_create(dzp, name, zp, tx, ZNEW);
	txtype = zfs_log_create_txtype(Z_FILE, vsecp, vap);
	zfs_log_create(zilog, tx, txtype, dzp, zp, name,
	vsecp, acl_ids.z_fuidp, vap);
	zfs_acl_ids_free(&acl_ids);
	dmu_tx_commit(tx);

	getnewvnode_drop_reserve();

	out:
	VNCHECKREF(dvp);
	if (error == 0) {
	*zpp = zp;
	}

	if (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS)
	zil_commit(zilog, 0);

	ZFS_EXIT(zfsvfs);
	return (error);
	}

	/*
	* Remove an entry from a directory.
	*
	* IN: dvp - vnode of directory to remove entry from.
	* name - name of entry to remove.
	* cr - credentials of caller.
	* ct - caller context
	* flags - case flags
	*
	* RETURN: 0 on success, error code on failure.
	*
	* Timestamps:
	* dvp - ctime\|mtime
	* vp - ctime (if nlink > 0)
	*/

	/ARGSUSED/
	static int
	zfs_remove_(vnode_t dvp, vnode_t vp, const char name, cred_t cr)
	{
	znode_t *dzp = VTOZ(dvp);
	znode_t *zp;
	znode_t *xzp;
	zfsvfs_t *zfsvfs = dzp->z_zfsvfs;
	zilog_t *zilog;
	uint64_t xattr_obj;
	uint64_t obj = 0;
	dmu_tx_t *tx;
	boolean_t unlinked;
	uint64_t txtype;
	int error;


	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(dzp);
	zp = VTOZ(vp);
	ZFS_VERIFY_ZP(zp);
	zilog = zfsvfs->z_log;

	xattr_obj = 0;
	xzp = NULL;

	if ((error = zfs_zaccess_delete(dzp, zp, cr))) {
	goto out;
	}

	/*
	* Need to use rmdir for removing directories.
	*/
	if (vp->v_type == VDIR) {
	error = SET_ERROR(EPERM);
	goto out;
	}

	vnevent_remove(vp, dvp, name, ct);

	obj = zp->z_id;

	/* are there any extended attributes? */
	error = sa_lookup(zp->z_sa_hdl, SA_ZPL_XATTR(zfsvfs),
	&xattr_obj, sizeof (xattr_obj));
	if (error == 0 && xattr_obj) {
	error = zfs_zget(zfsvfs, xattr_obj, &xzp);
	ASSERT0(error);
	}

	/*
	* We may delete the znode now, or we may put it in the unlinked set;
	* it depends on whether we're the last link, and on whether there are
	* other holds on the vnode. So we dmu_tx_hold() the right things to
	* allow for either case.
	*/
	tx = dmu_tx_create(zfsvfs->z_os);
	dmu_tx_hold_zap(tx, dzp->z_id, FALSE, name);
	dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
	zfs_sa_upgrade_txholds(tx, zp);
	zfs_sa_upgrade_txholds(tx, dzp);

	if (xzp) {
	dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_TRUE);
	dmu_tx_hold_sa(tx, xzp->z_sa_hdl, B_FALSE);
	}

	/* charge as an update -- would be nice not to charge at all */
	dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, FALSE, NULL);

	/*
	* Mark this transaction as typically resulting in a net free of space
	*/
	dmu_tx_mark_netfree(tx);

	error = dmu_tx_assign(tx, TXG_WAIT);
	if (error) {
	dmu_tx_abort(tx);
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	/*
	* Remove the directory entry.
	*/
	error = zfs_link_destroy(dzp, name, zp, tx, ZEXISTS, &unlinked);

	if (error) {
	dmu_tx_commit(tx);
	goto out;
	}

	if (unlinked) {
	zfs_unlinked_add(zp, tx);
	vp->v_vflag \|= VV_NOSYNC;
	}
	/* XXX check changes to linux vnops */
	txtype = TX_REMOVE;
	zfs_log_remove(zilog, tx, txtype, dzp, name, obj, unlinked);

	dmu_tx_commit(tx);
	out:

	if (xzp)
	vrele(ZTOV(xzp));

	if (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS)
	zil_commit(zilog, 0);


	ZFS_EXIT(zfsvfs);
	return (error);
	}


	static int
	zfs_lookup_internal(znode_t dzp, const char name, vnode_t **vpp,
	struct componentname *cnp, int nameiop)
	{
	zfsvfs_t *zfsvfs = dzp->z_zfsvfs;
	int error;

	cnp->cn_nameptr = __DECONST(char *, name);
	cnp->cn_namelen = strlen(name);
	cnp->cn_nameiop = nameiop;
	cnp->cn_flags = ISLASTCN \| SAVENAME;
	cnp->cn_lkflags = LK_EXCLUSIVE \| LK_RETRY;
	cnp->cn_cred = kcred;
	cnp->cn_thread = curthread;

	if (zfsvfs->z_use_namecache && !zfsvfs->z_replay) {
	struct vop_lookup_args a;

	a.a_gen.a_desc = &vop_lookup_desc;
	a.a_dvp = ZTOV(dzp);
	a.a_vpp = vpp;
	a.a_cnp = cnp;
	error = vfs_cache_lookup(&a);
	} else {
	error = zfs_lookup(ZTOV(dzp), name, vpp, cnp, nameiop, kcred,
	curthread, 0, B_FALSE);
	}
	#ifdef ZFS_DEBUG
	if (error) {
	printf("got error %d on name %s on op %d\n", error, name,
	nameiop);
	kdb_backtrace();
	}
	#endif
	return (error);
	}

	int
	zfs_remove(znode_t dzp, const char name, cred_t *cr, int flags)
	{
	vnode_t *vp;
	int error;
	struct componentname cn;

	if ((error = zfs_lookup_internal(dzp, name, &vp, &cn, DELETE)))
	return (error);

	error = zfs_remove_(ZTOV(dzp), vp, name, cr);
	vput(vp);
	return (error);
	}
	/*
	* Create a new directory and insert it into dvp using the name
	* provided. Return a pointer to the inserted directory.
	*
	* IN: dvp - vnode of directory to add subdir to.
	* dirname - name of new directory.
	* vap - attributes of new directory.
	* cr - credentials of caller.
	* ct - caller context
	* flags - case flags
	* vsecp - ACL to be set
	*
	* OUT: vpp - vnode of created directory.
	*
	* RETURN: 0 on success, error code on failure.
	*
	* Timestamps:
	* dvp - ctime\|mtime updated
	* vp - ctime\|mtime\|atime updated
	*/
	/ARGSUSED/
	int
	zfs_mkdir(znode_t dzp, const char dirname, vattr_t vap, znode_t *zpp,
	cred_t cr, int flags, vsecattr_t vsecp)
	{
	znode_t *zp;
	zfsvfs_t *zfsvfs = dzp->z_zfsvfs;
	zilog_t *zilog;
	uint64_t txtype;
	dmu_tx_t *tx;
	int error;
	ksid_t *ksid;
	uid_t uid;
	gid_t gid = crgetgid(cr);
	zfs_acl_ids_t acl_ids;
	boolean_t fuid_dirtied;

	ASSERT(vap->va_type == VDIR);

	/*
	* If we have an ephemeral id, ACL, or XVATTR then
	* make sure file system is at proper version
	*/

	ksid = crgetsid(cr, KSID_OWNER);
	if (ksid)
	uid = ksid_getid(ksid);
	else
	uid = crgetuid(cr);
	if (zfsvfs->z_use_fuids == B_FALSE &&
	((vap->va_mask & AT_XVATTR) \|\|
	IS_EPHEMERAL(uid) \|\| IS_EPHEMERAL(gid)))
	return (SET_ERROR(EINVAL));

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(dzp);
	zilog = zfsvfs->z_log;

	if (dzp->z_pflags & ZFS_XATTR) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EINVAL));
	}

	if (zfsvfs->z_utf8 && u8_validate(dirname,
	strlen(dirname), NULL, U8_VALIDATE_ENTIRE, &error) < 0) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EILSEQ));
	}

	if (vap->va_mask & AT_XVATTR) {
	if ((error = secpolicy_xvattr(ZTOV(dzp), (xvattr_t *)vap,
	crgetuid(cr), cr, vap->va_type)) != 0) {
	ZFS_EXIT(zfsvfs);
	return (error);
	}
	}

	if ((error = zfs_acl_ids_create(dzp, 0, vap, cr,
	NULL, &acl_ids)) != 0) {
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	/*
	* First make sure the new directory doesn't exist.
	*
	* Existence is checked first to make sure we don't return
	* EACCES instead of EEXIST which can cause some applications
	* to fail.
	*/
	*zpp = NULL;

	if ((error = zfs_dirent_lookup(dzp, dirname, &zp, ZNEW))) {
	zfs_acl_ids_free(&acl_ids);
	ZFS_EXIT(zfsvfs);
	return (error);
	}
	ASSERT3P(zp, ==, NULL);

	if ((error = zfs_zaccess(dzp, ACE_ADD_SUBDIRECTORY, 0, B_FALSE, cr))) {
	zfs_acl_ids_free(&acl_ids);
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	if (zfs_acl_ids_overquota(zfsvfs, &acl_ids, zfs_inherit_projid(dzp))) {
	zfs_acl_ids_free(&acl_ids);
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EDQUOT));
	}

	/*
	* Add a new entry to the directory.
	*/
	getnewvnode_reserve_();
	tx = dmu_tx_create(zfsvfs->z_os);
	dmu_tx_hold_zap(tx, dzp->z_id, TRUE, dirname);
	dmu_tx_hold_zap(tx, DMU_NEW_OBJECT, FALSE, NULL);
	fuid_dirtied = zfsvfs->z_fuid_dirty;
	if (fuid_dirtied)
	zfs_fuid_txhold(zfsvfs, tx);
	if (!zfsvfs->z_use_sa && acl_ids.z_aclp->z_acl_bytes > ZFS_ACE_SPACE) {
	dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0,
	acl_ids.z_aclp->z_acl_bytes);
	}

	dmu_tx_hold_sa_create(tx, acl_ids.z_aclp->z_acl_bytes +
	ZFS_SA_BASE_ATTR_SIZE);

	error = dmu_tx_assign(tx, TXG_WAIT);
	if (error) {
	zfs_acl_ids_free(&acl_ids);
	dmu_tx_abort(tx);
	getnewvnode_drop_reserve();
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	/*
	* Create new node.
	*/
	zfs_mknode(dzp, vap, tx, cr, 0, &zp, &acl_ids);

	if (fuid_dirtied)
	zfs_fuid_sync(zfsvfs, tx);

	/*
	* Now put new name in parent dir.
	*/
	(void) zfs_link_create(dzp, dirname, zp, tx, ZNEW);

	*zpp = zp;

	txtype = zfs_log_create_txtype(Z_DIR, NULL, vap);
	zfs_log_create(zilog, tx, txtype, dzp, zp, dirname, NULL,
	acl_ids.z_fuidp, vap);

	zfs_acl_ids_free(&acl_ids);

	dmu_tx_commit(tx);

	getnewvnode_drop_reserve();

	if (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS)
	zil_commit(zilog, 0);

	ZFS_EXIT(zfsvfs);
	return (0);
	}

	#if __FreeBSD_version < 1300124
	static void
	cache_vop_rmdir(struct vnode dvp, struct vnode vp)
	{

	cache_purge(dvp);
	cache_purge(vp);
	}
	#endif

	/*
	* Remove a directory subdir entry. If the current working
	* directory is the same as the subdir to be removed, the
	* remove will fail.
	*
	* IN: dvp - vnode of directory to remove from.
	* name - name of directory to be removed.
	* cwd - vnode of current working directory.
	* cr - credentials of caller.
	* ct - caller context
	* flags - case flags
	*
	* RETURN: 0 on success, error code on failure.
	*
	* Timestamps:
	* dvp - ctime\|mtime updated
	*/
	/ARGSUSED/
	static int
	zfs_rmdir_(vnode_t dvp, vnode_t vp, const char name, cred_t cr)
	{
	znode_t *dzp = VTOZ(dvp);
	znode_t *zp = VTOZ(vp);
	zfsvfs_t *zfsvfs = dzp->z_zfsvfs;
	zilog_t *zilog;
	dmu_tx_t *tx;
	int error;

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(dzp);
	ZFS_VERIFY_ZP(zp);
	zilog = zfsvfs->z_log;


	if ((error = zfs_zaccess_delete(dzp, zp, cr))) {
	goto out;
	}

	if (vp->v_type != VDIR) {
	error = SET_ERROR(ENOTDIR);
	goto out;
	}

	vnevent_rmdir(vp, dvp, name, ct);

	tx = dmu_tx_create(zfsvfs->z_os);
	dmu_tx_hold_zap(tx, dzp->z_id, FALSE, name);
	dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
	dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, FALSE, NULL);
	zfs_sa_upgrade_txholds(tx, zp);
	zfs_sa_upgrade_txholds(tx, dzp);
	dmu_tx_mark_netfree(tx);
	error = dmu_tx_assign(tx, TXG_WAIT);
	if (error) {
	dmu_tx_abort(tx);
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	error = zfs_link_destroy(dzp, name, zp, tx, ZEXISTS, NULL);

	if (error == 0) {
	uint64_t txtype = TX_RMDIR;
	zfs_log_remove(zilog, tx, txtype, dzp, name,
	ZFS_NO_OBJECT, B_FALSE);
	}

	dmu_tx_commit(tx);

	cache_vop_rmdir(dvp, vp);
	out:
	if (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS)
	zil_commit(zilog, 0);

	ZFS_EXIT(zfsvfs);
	return (error);
	}

	int
	zfs_rmdir(znode_t dzp, const char name, znode_t cwd, cred_t cr, int flags)
	{
	struct componentname cn;
	vnode_t *vp;
	int error;

	if ((error = zfs_lookup_internal(dzp, name, &vp, &cn, DELETE)))
	return (error);

	error = zfs_rmdir_(ZTOV(dzp), vp, name, cr);
	vput(vp);
	return (error);
	}

	/*
	* Read as many directory entries as will fit into the provided
	* buffer from the given directory cursor position (specified in
	* the uio structure).
	*
	* IN: vp - vnode of directory to read.
	* uio - structure supplying read location, range info,
	* and return buffer.
	* cr - credentials of caller.
	* ct - caller context
	* flags - case flags
	*
	* OUT: uio - updated offset and range, buffer filled.
	* eofp - set to true if end-of-file detected.
	*
	* RETURN: 0 on success, error code on failure.
	*
	* Timestamps:
	* vp - atime updated
	*
	* Note that the low 4 bits of the cookie returned by zap is always zero.
	* This allows us to use the low range for "special" directory entries:
	* We use 0 for '.', and 1 for '..'. If this is the root of the filesystem,
	* we use the offset 2 for the '.zfs' directory.
	*/
	/* ARGSUSED */
	static int
	zfs_readdir(vnode_t vp, zfs_uio_t uio, cred_t cr, int eofp,
	int ncookies, ulong_t *cookies)
	{
	znode_t *zp = VTOZ(vp);
	iovec_t *iovp;
	edirent_t *eodp;
	dirent64_t *odp;
	zfsvfs_t *zfsvfs = zp->z_zfsvfs;
	objset_t *os;
	caddr_t outbuf;
	size_t bufsize;
	zap_cursor_t zc;
	zap_attribute_t zap;
	uint_t bytes_wanted;
	uint64_t offset; /* must be unsigned; checks for < 1 */
	uint64_t parent;
	int local_eof;
	int outcount;
	int error;
	uint8_t prefetch;
	boolean_t check_sysattrs;
	uint8_t type;
	int ncooks;
	ulong_t *cooks = NULL;
	int flags = 0;

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zp);

	if ((error = sa_lookup(zp->z_sa_hdl, SA_ZPL_PARENT(zfsvfs),
	&parent, sizeof (parent))) != 0) {
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	/*
	* If we are not given an eof variable,
	* use a local one.
	*/
	if (eofp == NULL)
	eofp = &local_eof;

	/*
	* Check for valid iov_len.
	*/
	if (GET_UIO_STRUCT(uio)->uio_iov->iov_len <= 0) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EINVAL));
	}

	/*
	* Quit if directory has been removed (posix)
	*/
	if ((*eofp = zp->z_unlinked) != 0) {
	ZFS_EXIT(zfsvfs);
	return (0);
	}

	error = 0;
	os = zfsvfs->z_os;
	offset = zfs_uio_offset(uio);
	prefetch = zp->z_zn_prefetch;

	/*
	* Initialize the iterator cursor.
	*/
	if (offset <= 3) {
	/*
	* Start iteration from the beginning of the directory.
	*/
	zap_cursor_init(&zc, os, zp->z_id);
	} else {
	/*
	* The offset is a serialized cursor.
	*/
	zap_cursor_init_serialized(&zc, os, zp->z_id, offset);
	}

	/*
	* Get space to change directory entries into fs independent format.
	*/
	iovp = GET_UIO_STRUCT(uio)->uio_iov;
	bytes_wanted = iovp->iov_len;
	if (zfs_uio_segflg(uio) != UIO_SYSSPACE \|\| zfs_uio_iovcnt(uio) != 1) {
	bufsize = bytes_wanted;
	outbuf = kmem_alloc(bufsize, KM_SLEEP);
	odp = (struct dirent64 *)outbuf;
	} else {
	bufsize = bytes_wanted;
	outbuf = NULL;
	odp = (struct dirent64 *)iovp->iov_base;
	}
	eodp = (struct edirent *)odp;

	if (ncookies != NULL) {
	/*
	* Minimum entry size is dirent size and 1 byte for a file name.
	*/
	ncooks = zfs_uio_resid(uio) / (sizeof (struct dirent) -
	sizeof (((struct dirent *)NULL)->d_name) + 1);
	cooks = malloc(ncooks * sizeof (ulong_t), M_TEMP, M_WAITOK);
	*cookies = cooks;
	*ncookies = ncooks;
	}
	/*
	* If this VFS supports the system attribute view interface; and
	* we're looking at an extended attribute directory; and we care
	* about normalization conflicts on this vfs; then we must check
	* for normalization conflicts with the sysattr name space.
	*/
	#ifdef TODO
	check_sysattrs = vfs_has_feature(vp->v_vfsp, VFSFT_SYSATTR_VIEWS) &&
	(vp->v_flag & V_XATTRDIR) && zfsvfs->z_norm &&
	(flags & V_RDDIR_ENTFLAGS);
	#else
	check_sysattrs = 0;
	#endif

	/*
	* Transform to file-system independent format
	*/
	outcount = 0;
	while (outcount < bytes_wanted) {
	ino64_t objnum;
	ushort_t reclen;
	off64_t *next = NULL;

	/*
	* Special case `.', `..', and `.zfs'.
	*/
	if (offset == 0) {
	(void) strcpy(zap.za_name, ".");
	zap.za_normalization_conflict = 0;
	objnum = zp->z_id;
	type = DT_DIR;
	} else if (offset == 1) {
	(void) strcpy(zap.za_name, "..");
	zap.za_normalization_conflict = 0;
	objnum = parent;
	type = DT_DIR;
	} else if (offset == 2 && zfs_show_ctldir(zp)) {
	(void) strcpy(zap.za_name, ZFS_CTLDIR_NAME);
	zap.za_normalization_conflict = 0;
	objnum = ZFSCTL_INO_ROOT;
	type = DT_DIR;
	} else {
	/*
	* Grab next entry.
	*/
	if ((error = zap_cursor_retrieve(&zc, &zap))) {
	if ((*eofp = (error == ENOENT)) != 0)
	break;
	else
	goto update;
	}

	if (zap.za_integer_length != 8 \|\|
	zap.za_num_integers != 1) {
	cmn_err(CE_WARN, "zap_readdir: bad directory "
	"entry, obj = %lld, offset = %lld\n",
	(u_longlong_t)zp->z_id,
	(u_longlong_t)offset);
	error = SET_ERROR(ENXIO);
	goto update;
	}

	objnum = ZFS_DIRENT_OBJ(zap.za_first_integer);
	/*
	* MacOS X can extract the object type here such as:
	* uint8_t type = ZFS_DIRENT_TYPE(zap.za_first_integer);
	*/
	type = ZFS_DIRENT_TYPE(zap.za_first_integer);

	if (check_sysattrs && !zap.za_normalization_conflict) {
	#ifdef TODO
	zap.za_normalization_conflict =
	xattr_sysattr_casechk(zap.za_name);
	#else
	panic("%s:%u: TODO", __func__, __LINE__);
	#endif
	}
	}

	if (flags & V_RDDIR_ACCFILTER) {
	/*
	* If we have no access at all, don't include
	* this entry in the returned information
	*/
	znode_t *ezp;
	if (zfs_zget(zp->z_zfsvfs, objnum, &ezp) != 0)
	goto skip_entry;
	if (!zfs_has_access(ezp, cr)) {
	vrele(ZTOV(ezp));
	goto skip_entry;
	}
	vrele(ZTOV(ezp));
	}

	if (flags & V_RDDIR_ENTFLAGS)
	reclen = EDIRENT_RECLEN(strlen(zap.za_name));
	else
	reclen = DIRENT64_RECLEN(strlen(zap.za_name));

	/*
	* Will this entry fit in the buffer?
	*/
	if (outcount + reclen > bufsize) {
	/*
	* Did we manage to fit anything in the buffer?
	*/
	if (!outcount) {
	error = SET_ERROR(EINVAL);
	goto update;
	}
	break;
	}
	if (flags & V_RDDIR_ENTFLAGS) {
	/*
	* Add extended flag entry:
	*/
	eodp->ed_ino = objnum;
	eodp->ed_reclen = reclen;
	/* NOTE: ed_off is the offset for the next entry */
	next = &(eodp->ed_off);
	eodp->ed_eflags = zap.za_normalization_conflict ?
	ED_CASE_CONFLICT : 0;
	(void) strncpy(eodp->ed_name, zap.za_name,
	EDIRENT_NAMELEN(reclen));
	eodp = (edirent_t *)((intptr_t)eodp + reclen);
	} else {
	/*
	* Add normal entry:
	*/
	odp->d_ino = objnum;
	odp->d_reclen = reclen;
	odp->d_namlen = strlen(zap.za_name);
	/* NOTE: d_off is the offset for the next entry. */
	next = &odp->d_off;
	strlcpy(odp->d_name, zap.za_name, odp->d_namlen + 1);
	odp->d_type = type;
	dirent_terminate(odp);
	odp = (dirent64_t *)((intptr_t)odp + reclen);
	}
	outcount += reclen;

	ASSERT(outcount <= bufsize);

	/* Prefetch znode */
	if (prefetch)
	dmu_prefetch(os, objnum, 0, 0, 0,
	ZIO_PRIORITY_SYNC_READ);

	skip_entry:
	/*
	* Move to the next entry, fill in the previous offset.
	*/
	if (offset > 2 \|\| (offset == 2 && !zfs_show_ctldir(zp))) {
	zap_cursor_advance(&zc);
	offset = zap_cursor_serialize(&zc);
	} else {
	offset += 1;
	}

	/* Fill the offset right after advancing the cursor. */
	if (next != NULL)
	*next = offset;
	if (cooks != NULL) {
	*cooks++ = offset;
	ncooks--;
	KASSERT(ncooks >= 0, ("ncookies=%d", ncooks));
	}
	}
	zp->z_zn_prefetch = B_FALSE; /* a lookup will re-enable pre-fetching */

	/* Subtract unused cookies */
	if (ncookies != NULL)
	*ncookies -= ncooks;

	if (zfs_uio_segflg(uio) == UIO_SYSSPACE && zfs_uio_iovcnt(uio) == 1) {
	iovp->iov_base += outcount;
	iovp->iov_len -= outcount;
	zfs_uio_resid(uio) -= outcount;
	} else if ((error =
	zfs_uiomove(outbuf, (long)outcount, UIO_READ, uio))) {
	/*
	* Reset the pointer.
	*/
	offset = zfs_uio_offset(uio);
	}

	update:
	zap_cursor_fini(&zc);
	if (zfs_uio_segflg(uio) != UIO_SYSSPACE \|\| zfs_uio_iovcnt(uio) != 1)
	kmem_free(outbuf, bufsize);

	if (error == ENOENT)
	error = 0;

	ZFS_ACCESSTIME_STAMP(zfsvfs, zp);

	zfs_uio_setoffset(uio, offset);
	ZFS_EXIT(zfsvfs);
	if (error != 0 && cookies != NULL) {
	free(*cookies, M_TEMP);
	*cookies = NULL;
	*ncookies = 0;
	}
	return (error);
	}

	/*
	* Get the requested file attributes and place them in the provided
	* vattr structure.
	*
	* IN: vp - vnode of file.
	* vap - va_mask identifies requested attributes.
	* If AT_XVATTR set, then optional attrs are requested
	* flags - ATTR_NOACLCHECK (CIFS server context)
	* cr - credentials of caller.
	*
	* OUT: vap - attribute values.
	*
	* RETURN: 0 (always succeeds).
	*/
	/* ARGSUSED */
	static int
	zfs_getattr(vnode_t vp, vattr_t vap, int flags, cred_t *cr)
	{
	znode_t *zp = VTOZ(vp);
	zfsvfs_t *zfsvfs = zp->z_zfsvfs;
	int error = 0;
	uint32_t blksize;
	u_longlong_t nblocks;
	uint64_t mtime[2], ctime[2], crtime[2], rdev;
	xvattr_t xvap = (xvattr_t )vap; /* vap may be an xvattr_t * */
	xoptattr_t *xoap = NULL;
	boolean_t skipaclchk = (flags & ATTR_NOACLCHECK) ? B_TRUE : B_FALSE;
	sa_bulk_attr_t bulk[4];
	int count = 0;

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zp);

	zfs_fuid_map_ids(zp, cr, &vap->va_uid, &vap->va_gid);

	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zfsvfs), NULL, &mtime, 16);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs), NULL, &ctime, 16);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CRTIME(zfsvfs), NULL, &crtime, 16);
	if (vp->v_type == VBLK \|\| vp->v_type == VCHR)
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_RDEV(zfsvfs), NULL,
	&rdev, 8);

	if ((error = sa_bulk_lookup(zp->z_sa_hdl, bulk, count)) != 0) {
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	/*
	* If ACL is trivial don't bother looking for ACE_READ_ATTRIBUTES.
	* Also, if we are the owner don't bother, since owner should
	* always be allowed to read basic attributes of file.
	*/
	if (!(zp->z_pflags & ZFS_ACL_TRIVIAL) &&
	(vap->va_uid != crgetuid(cr))) {
	if ((error = zfs_zaccess(zp, ACE_READ_ATTRIBUTES, 0,
	skipaclchk, cr))) {
	ZFS_EXIT(zfsvfs);
	return (error);
	}
	}

	/*
	* Return all attributes. It's cheaper to provide the answer
	* than to determine whether we were asked the question.
	*/

	vap->va_type = IFTOVT(zp->z_mode);
	vap->va_mode = zp->z_mode & ~S_IFMT;
	vn_fsid(vp, vap);
	vap->va_nodeid = zp->z_id;
	vap->va_nlink = zp->z_links;
	if ((vp->v_flag & VROOT) && zfs_show_ctldir(zp) &&
	zp->z_links < ZFS_LINK_MAX)
	vap->va_nlink++;
	vap->va_size = zp->z_size;
	if (vp->v_type == VBLK \|\| vp->v_type == VCHR)
	vap->va_rdev = zfs_cmpldev(rdev);
	vap->va_seq = zp->z_seq;
	vap->va_flags = 0; /* FreeBSD: Reset chflags(2) flags. */
	vap->va_filerev = zp->z_seq;

	/*
	* Add in any requested optional attributes and the create time.
	* Also set the corresponding bits in the returned attribute bitmap.
	*/
	if ((xoap = xva_getxoptattr(xvap)) != NULL && zfsvfs->z_use_fuids) {
	if (XVA_ISSET_REQ(xvap, XAT_ARCHIVE)) {
	xoap->xoa_archive =
	((zp->z_pflags & ZFS_ARCHIVE) != 0);
	XVA_SET_RTN(xvap, XAT_ARCHIVE);
	}

	if (XVA_ISSET_REQ(xvap, XAT_READONLY)) {
	xoap->xoa_readonly =
	((zp->z_pflags & ZFS_READONLY) != 0);
	XVA_SET_RTN(xvap, XAT_READONLY);
	}

	if (XVA_ISSET_REQ(xvap, XAT_SYSTEM)) {
	xoap->xoa_system =
	((zp->z_pflags & ZFS_SYSTEM) != 0);
	XVA_SET_RTN(xvap, XAT_SYSTEM);
	}

	if (XVA_ISSET_REQ(xvap, XAT_HIDDEN)) {
	xoap->xoa_hidden =
	((zp->z_pflags & ZFS_HIDDEN) != 0);
	XVA_SET_RTN(xvap, XAT_HIDDEN);
	}

	if (XVA_ISSET_REQ(xvap, XAT_NOUNLINK)) {
	xoap->xoa_nounlink =
	((zp->z_pflags & ZFS_NOUNLINK) != 0);
	XVA_SET_RTN(xvap, XAT_NOUNLINK);
	}

	if (XVA_ISSET_REQ(xvap, XAT_IMMUTABLE)) {
	xoap->xoa_immutable =
	((zp->z_pflags & ZFS_IMMUTABLE) != 0);
	XVA_SET_RTN(xvap, XAT_IMMUTABLE);
	}

	if (XVA_ISSET_REQ(xvap, XAT_APPENDONLY)) {
	xoap->xoa_appendonly =
	((zp->z_pflags & ZFS_APPENDONLY) != 0);
	XVA_SET_RTN(xvap, XAT_APPENDONLY);
	}

	if (XVA_ISSET_REQ(xvap, XAT_NODUMP)) {
	xoap->xoa_nodump =
	((zp->z_pflags & ZFS_NODUMP) != 0);
	XVA_SET_RTN(xvap, XAT_NODUMP);
	}

	if (XVA_ISSET_REQ(xvap, XAT_OPAQUE)) {
	xoap->xoa_opaque =
	((zp->z_pflags & ZFS_OPAQUE) != 0);
	XVA_SET_RTN(xvap, XAT_OPAQUE);
	}

	if (XVA_ISSET_REQ(xvap, XAT_AV_QUARANTINED)) {
	xoap->xoa_av_quarantined =
	((zp->z_pflags & ZFS_AV_QUARANTINED) != 0);
	XVA_SET_RTN(xvap, XAT_AV_QUARANTINED);
	}

	if (XVA_ISSET_REQ(xvap, XAT_AV_MODIFIED)) {
	xoap->xoa_av_modified =
	((zp->z_pflags & ZFS_AV_MODIFIED) != 0);
	XVA_SET_RTN(xvap, XAT_AV_MODIFIED);
	}

	if (XVA_ISSET_REQ(xvap, XAT_AV_SCANSTAMP) &&
	vp->v_type == VREG) {
	zfs_sa_get_scanstamp(zp, xvap);
	}

	if (XVA_ISSET_REQ(xvap, XAT_REPARSE)) {
	xoap->xoa_reparse = ((zp->z_pflags & ZFS_REPARSE) != 0);
	XVA_SET_RTN(xvap, XAT_REPARSE);
	}
	if (XVA_ISSET_REQ(xvap, XAT_GEN)) {
	xoap->xoa_generation = zp->z_gen;
	XVA_SET_RTN(xvap, XAT_GEN);
	}

	if (XVA_ISSET_REQ(xvap, XAT_OFFLINE)) {
	xoap->xoa_offline =
	((zp->z_pflags & ZFS_OFFLINE) != 0);
	XVA_SET_RTN(xvap, XAT_OFFLINE);
	}

	if (XVA_ISSET_REQ(xvap, XAT_SPARSE)) {
	xoap->xoa_sparse =
	((zp->z_pflags & ZFS_SPARSE) != 0);
	XVA_SET_RTN(xvap, XAT_SPARSE);
	}

	if (XVA_ISSET_REQ(xvap, XAT_PROJINHERIT)) {
	xoap->xoa_projinherit =
	((zp->z_pflags & ZFS_PROJINHERIT) != 0);
	XVA_SET_RTN(xvap, XAT_PROJINHERIT);
	}

	if (XVA_ISSET_REQ(xvap, XAT_PROJID)) {
	xoap->xoa_projid = zp->z_projid;
	XVA_SET_RTN(xvap, XAT_PROJID);
	}
	}

	ZFS_TIME_DECODE(&vap->va_atime, zp->z_atime);
	ZFS_TIME_DECODE(&vap->va_mtime, mtime);
	ZFS_TIME_DECODE(&vap->va_ctime, ctime);
	ZFS_TIME_DECODE(&vap->va_birthtime, crtime);


	sa_object_size(zp->z_sa_hdl, &blksize, &nblocks);
	vap->va_blksize = blksize;
	vap->va_bytes = nblocks << 9; /* nblocks * 512 */

	if (zp->z_blksz == 0) {
	/*
	* Block size hasn't been set; suggest maximal I/O transfers.
	*/
	vap->va_blksize = zfsvfs->z_max_blksz;
	}

	ZFS_EXIT(zfsvfs);
	return (0);
	}

	/*
	* Set the file attributes to the values contained in the
	* vattr structure.
	*
	* IN: zp - znode of file to be modified.
	* vap - new attribute values.
	* If AT_XVATTR set, then optional attrs are being set
	* flags - ATTR_UTIME set if non-default time values provided.
	* - ATTR_NOACLCHECK (CIFS context only).
	* cr - credentials of caller.
	* ct - caller context
	*
	* RETURN: 0 on success, error code on failure.
	*
	* Timestamps:
	* vp - ctime updated, mtime updated if size changed.
	*/
	/* ARGSUSED */
	int
	zfs_setattr(znode_t zp, vattr_t vap, int flags, cred_t *cr)
	{
	vnode_t *vp = ZTOV(zp);
	zfsvfs_t *zfsvfs = zp->z_zfsvfs;
	objset_t *os = zfsvfs->z_os;
	zilog_t *zilog;
	dmu_tx_t *tx;
	vattr_t oldva;
	xvattr_t tmpxvattr;
	uint_t mask = vap->va_mask;
	uint_t saved_mask = 0;
	uint64_t saved_mode;
	int trim_mask = 0;
	uint64_t new_mode;
	uint64_t new_uid, new_gid;
	uint64_t xattr_obj;
	uint64_t mtime[2], ctime[2];
	uint64_t projid = ZFS_INVALID_PROJID;
	znode_t *attrzp;
	int need_policy = FALSE;
	int err, err2;
	zfs_fuid_info_t *fuidp = NULL;
	xvattr_t xvap = (xvattr_t )vap; /* vap may be an xvattr_t * */
	xoptattr_t *xoap;
	zfs_acl_t *aclp;
	boolean_t skipaclchk = (flags & ATTR_NOACLCHECK) ? B_TRUE : B_FALSE;
	boolean_t fuid_dirtied = B_FALSE;
	sa_bulk_attr_t bulk[7], xattr_bulk[7];
	int count = 0, xattr_count = 0;

	if (mask == 0)
	return (0);

	if (mask & AT_NOSET)
	return (SET_ERROR(EINVAL));

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zp);

	zilog = zfsvfs->z_log;

	/*
	* Make sure that if we have ephemeral uid/gid or xvattr specified
	* that file system is at proper version level
	*/

	if (zfsvfs->z_use_fuids == B_FALSE &&
	(((mask & AT_UID) && IS_EPHEMERAL(vap->va_uid)) \|\|
	((mask & AT_GID) && IS_EPHEMERAL(vap->va_gid)) \|\|
	(mask & AT_XVATTR))) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EINVAL));
	}

	if (mask & AT_SIZE && vp->v_type == VDIR) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EISDIR));
	}

	if (mask & AT_SIZE && vp->v_type != VREG && vp->v_type != VFIFO) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EINVAL));
	}

	/*
	* If this is an xvattr_t, then get a pointer to the structure of
	* optional attributes. If this is NULL, then we have a vattr_t.
	*/
	xoap = xva_getxoptattr(xvap);

	xva_init(&tmpxvattr);

	/*
	* Immutable files can only alter immutable bit and atime
	*/
	if ((zp->z_pflags & ZFS_IMMUTABLE) &&
	((mask & (AT_SIZE\|AT_UID\|AT_GID\|AT_MTIME\|AT_MODE)) \|\|
	((mask & AT_XVATTR) && XVA_ISSET_REQ(xvap, XAT_CREATETIME)))) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EPERM));
	}

	/*
	* Note: ZFS_READONLY is handled in zfs_zaccess_common.
	*/

	/*
	* Verify timestamps doesn't overflow 32 bits.
	* ZFS can handle large timestamps, but 32bit syscalls can't
	* handle times greater than 2039. This check should be removed
	* once large timestamps are fully supported.
	*/
	if (mask & (AT_ATIME \| AT_MTIME)) {
	if (((mask & AT_ATIME) && TIMESPEC_OVERFLOW(&vap->va_atime)) \|\|
	((mask & AT_MTIME) && TIMESPEC_OVERFLOW(&vap->va_mtime))) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EOVERFLOW));
	}
	}
	if (xoap != NULL && (mask & AT_XVATTR)) {
	if (XVA_ISSET_REQ(xvap, XAT_CREATETIME) &&
	TIMESPEC_OVERFLOW(&vap->va_birthtime)) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EOVERFLOW));
	}

	if (XVA_ISSET_REQ(xvap, XAT_PROJID)) {
	if (!dmu_objset_projectquota_enabled(os) \|\|
	(!S_ISREG(zp->z_mode) && !S_ISDIR(zp->z_mode))) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EOPNOTSUPP));
	}

	projid = xoap->xoa_projid;
	if (unlikely(projid == ZFS_INVALID_PROJID)) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EINVAL));
	}

	if (projid == zp->z_projid && zp->z_pflags & ZFS_PROJID)
	projid = ZFS_INVALID_PROJID;
	else
	need_policy = TRUE;
	}

	if (XVA_ISSET_REQ(xvap, XAT_PROJINHERIT) &&
	(xoap->xoa_projinherit !=
	((zp->z_pflags & ZFS_PROJINHERIT) != 0)) &&
	(!dmu_objset_projectquota_enabled(os) \|\|
	(!S_ISREG(zp->z_mode) && !S_ISDIR(zp->z_mode)))) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EOPNOTSUPP));
	}
	}

	attrzp = NULL;
	aclp = NULL;

	if (zfsvfs->z_vfs->vfs_flag & VFS_RDONLY) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EROFS));
	}

	/*
	* First validate permissions
	*/

	if (mask & AT_SIZE) {
	/*
	* XXX - Note, we are not providing any open
	* mode flags here (like FNDELAY), so we may
	* block if there are locks present... this
	* should be addressed in openat().
	*/
	/* XXX - would it be OK to generate a log record here? */
	err = zfs_freesp(zp, vap->va_size, 0, 0, FALSE);
	if (err) {
	ZFS_EXIT(zfsvfs);
	return (err);
	}
	}

	if (mask & (AT_ATIME\|AT_MTIME) \|\|
	((mask & AT_XVATTR) && (XVA_ISSET_REQ(xvap, XAT_HIDDEN) \|\|
	XVA_ISSET_REQ(xvap, XAT_READONLY) \|\|
	XVA_ISSET_REQ(xvap, XAT_ARCHIVE) \|\|
	XVA_ISSET_REQ(xvap, XAT_OFFLINE) \|\|
	XVA_ISSET_REQ(xvap, XAT_SPARSE) \|\|
	XVA_ISSET_REQ(xvap, XAT_CREATETIME) \|\|
	XVA_ISSET_REQ(xvap, XAT_SYSTEM)))) {
	need_policy = zfs_zaccess(zp, ACE_WRITE_ATTRIBUTES, 0,
	skipaclchk, cr);
	}

	if (mask & (AT_UID\|AT_GID)) {
	int idmask = (mask & (AT_UID\|AT_GID));
	int take_owner;
	int take_group;

	/*
	* NOTE: even if a new mode is being set,
	* we may clear S_ISUID/S_ISGID bits.
	*/

	if (!(mask & AT_MODE))
	vap->va_mode = zp->z_mode;

	/*
	* Take ownership or chgrp to group we are a member of
	*/

	take_owner = (mask & AT_UID) && (vap->va_uid == crgetuid(cr));
	take_group = (mask & AT_GID) &&
	zfs_groupmember(zfsvfs, vap->va_gid, cr);

	/*
	* If both AT_UID and AT_GID are set then take_owner and
	* take_group must both be set in order to allow taking
	* ownership.
	*
	* Otherwise, send the check through secpolicy_vnode_setattr()
	*
	*/

	if (((idmask == (AT_UID\|AT_GID)) && take_owner && take_group) \|\|
	((idmask == AT_UID) && take_owner) \|\|
	((idmask == AT_GID) && take_group)) {
	if (zfs_zaccess(zp, ACE_WRITE_OWNER, 0,
	skipaclchk, cr) == 0) {
	/*
	* Remove setuid/setgid for non-privileged users
	*/
	secpolicy_setid_clear(vap, vp, cr);
	trim_mask = (mask & (AT_UID\|AT_GID));
	} else {
	need_policy = TRUE;
	}
	} else {
	need_policy = TRUE;
	}
	}

	oldva.va_mode = zp->z_mode;
	zfs_fuid_map_ids(zp, cr, &oldva.va_uid, &oldva.va_gid);
	if (mask & AT_XVATTR) {
	/*
	* Update xvattr mask to include only those attributes
	* that are actually changing.
	*
	* the bits will be restored prior to actually setting
	* the attributes so the caller thinks they were set.
	*/
	if (XVA_ISSET_REQ(xvap, XAT_APPENDONLY)) {
	if (xoap->xoa_appendonly !=
	((zp->z_pflags & ZFS_APPENDONLY) != 0)) {
	need_policy = TRUE;
	} else {
	XVA_CLR_REQ(xvap, XAT_APPENDONLY);
	XVA_SET_REQ(&tmpxvattr, XAT_APPENDONLY);
	}
	}

	if (XVA_ISSET_REQ(xvap, XAT_PROJINHERIT)) {
	if (xoap->xoa_projinherit !=
	((zp->z_pflags & ZFS_PROJINHERIT) != 0)) {
	need_policy = TRUE;
	} else {
	XVA_CLR_REQ(xvap, XAT_PROJINHERIT);
	XVA_SET_REQ(&tmpxvattr, XAT_PROJINHERIT);
	}
	}

	if (XVA_ISSET_REQ(xvap, XAT_NOUNLINK)) {
	if (xoap->xoa_nounlink !=
	((zp->z_pflags & ZFS_NOUNLINK) != 0)) {
	need_policy = TRUE;
	} else {
	XVA_CLR_REQ(xvap, XAT_NOUNLINK);
	XVA_SET_REQ(&tmpxvattr, XAT_NOUNLINK);
	}
	}

	if (XVA_ISSET_REQ(xvap, XAT_IMMUTABLE)) {
	if (xoap->xoa_immutable !=
	((zp->z_pflags & ZFS_IMMUTABLE) != 0)) {
	need_policy = TRUE;
	} else {
	XVA_CLR_REQ(xvap, XAT_IMMUTABLE);
	XVA_SET_REQ(&tmpxvattr, XAT_IMMUTABLE);
	}
	}

	if (XVA_ISSET_REQ(xvap, XAT_NODUMP)) {
	if (xoap->xoa_nodump !=
	((zp->z_pflags & ZFS_NODUMP) != 0)) {
	need_policy = TRUE;
	} else {
	XVA_CLR_REQ(xvap, XAT_NODUMP);
	XVA_SET_REQ(&tmpxvattr, XAT_NODUMP);
	}
	}

	if (XVA_ISSET_REQ(xvap, XAT_AV_MODIFIED)) {
	if (xoap->xoa_av_modified !=
	((zp->z_pflags & ZFS_AV_MODIFIED) != 0)) {
	need_policy = TRUE;
	} else {
	XVA_CLR_REQ(xvap, XAT_AV_MODIFIED);
	XVA_SET_REQ(&tmpxvattr, XAT_AV_MODIFIED);
	}
	}

	if (XVA_ISSET_REQ(xvap, XAT_AV_QUARANTINED)) {
	if ((vp->v_type != VREG &&
	xoap->xoa_av_quarantined) \|\|
	xoap->xoa_av_quarantined !=
	((zp->z_pflags & ZFS_AV_QUARANTINED) != 0)) {
	need_policy = TRUE;
	} else {
	XVA_CLR_REQ(xvap, XAT_AV_QUARANTINED);
	XVA_SET_REQ(&tmpxvattr, XAT_AV_QUARANTINED);
	}
	}

	if (XVA_ISSET_REQ(xvap, XAT_REPARSE)) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EPERM));
	}

	if (need_policy == FALSE &&
	(XVA_ISSET_REQ(xvap, XAT_AV_SCANSTAMP) \|\|
	XVA_ISSET_REQ(xvap, XAT_OPAQUE))) {
	need_policy = TRUE;
	}
	}

	if (mask & AT_MODE) {
	if (zfs_zaccess(zp, ACE_WRITE_ACL, 0, skipaclchk, cr) == 0) {
	err = secpolicy_setid_setsticky_clear(vp, vap,
	&oldva, cr);
	if (err) {
	ZFS_EXIT(zfsvfs);
	return (err);
	}
	trim_mask \|= AT_MODE;
	} else {
	need_policy = TRUE;
	}
	}

	if (need_policy) {
	/*
	* If trim_mask is set then take ownership
	* has been granted or write_acl is present and user
	* has the ability to modify mode. In that case remove
	* UID\|GID and or MODE from mask so that
	* secpolicy_vnode_setattr() doesn't revoke it.
	*/

	if (trim_mask) {
	saved_mask = vap->va_mask;
	vap->va_mask &= ~trim_mask;
	if (trim_mask & AT_MODE) {
	/*
	* Save the mode, as secpolicy_vnode_setattr()
	* will overwrite it with ova.va_mode.
	*/
	saved_mode = vap->va_mode;
	}
	}
	err = secpolicy_vnode_setattr(cr, vp, vap, &oldva, flags,
	(int ()(void , int, cred_t *))zfs_zaccess_unix, zp);
	if (err) {
	ZFS_EXIT(zfsvfs);
	return (err);
	}

	if (trim_mask) {
	vap->va_mask \|= saved_mask;
	if (trim_mask & AT_MODE) {
	/*
	* Recover the mode after
	* secpolicy_vnode_setattr().
	*/
	vap->va_mode = saved_mode;
	}
	}
	}

	/*
	* secpolicy_vnode_setattr, or take ownership may have
	* changed va_mask
	*/
	mask = vap->va_mask;

	if ((mask & (AT_UID \| AT_GID)) \|\| projid != ZFS_INVALID_PROJID) {
	err = sa_lookup(zp->z_sa_hdl, SA_ZPL_XATTR(zfsvfs),
	&xattr_obj, sizeof (xattr_obj));

	if (err == 0 && xattr_obj) {
	err = zfs_zget(zp->z_zfsvfs, xattr_obj, &attrzp);
	if (err == 0) {
	err = vn_lock(ZTOV(attrzp), LK_EXCLUSIVE);
	if (err != 0)
	vrele(ZTOV(attrzp));
	}
	if (err)
	goto out2;
	}
	if (mask & AT_UID) {
	new_uid = zfs_fuid_create(zfsvfs,
	(uint64_t)vap->va_uid, cr, ZFS_OWNER, &fuidp);
	if (new_uid != zp->z_uid &&
	zfs_id_overquota(zfsvfs, DMU_USERUSED_OBJECT,
	new_uid)) {
	if (attrzp)
	vput(ZTOV(attrzp));
	err = SET_ERROR(EDQUOT);
	goto out2;
	}
	}

	if (mask & AT_GID) {
	new_gid = zfs_fuid_create(zfsvfs, (uint64_t)vap->va_gid,
	cr, ZFS_GROUP, &fuidp);
	if (new_gid != zp->z_gid &&
	zfs_id_overquota(zfsvfs, DMU_GROUPUSED_OBJECT,
	new_gid)) {
	if (attrzp)
	vput(ZTOV(attrzp));
	err = SET_ERROR(EDQUOT);
	goto out2;
	}
	}

	if (projid != ZFS_INVALID_PROJID &&
	zfs_id_overquota(zfsvfs, DMU_PROJECTUSED_OBJECT, projid)) {
	if (attrzp)
	vput(ZTOV(attrzp));
	err = SET_ERROR(EDQUOT);
	goto out2;
	}
	}
	tx = dmu_tx_create(os);

	if (mask & AT_MODE) {
	uint64_t pmode = zp->z_mode;
	uint64_t acl_obj;
	new_mode = (pmode & S_IFMT) \| (vap->va_mode & ~S_IFMT);

	if (zp->z_zfsvfs->z_acl_mode == ZFS_ACL_RESTRICTED &&
	!(zp->z_pflags & ZFS_ACL_TRIVIAL)) {
	err = SET_ERROR(EPERM);
	goto out;
	}

	if ((err = zfs_acl_chmod_setattr(zp, &aclp, new_mode)))
	goto out;

	if (!zp->z_is_sa && ((acl_obj = zfs_external_acl(zp)) != 0)) {
	/*
	* Are we upgrading ACL from old V0 format
	* to V1 format?
	*/
	if (zfsvfs->z_version >= ZPL_VERSION_FUID &&
	zfs_znode_acl_version(zp) ==
	ZFS_ACL_VERSION_INITIAL) {
	dmu_tx_hold_free(tx, acl_obj, 0,
	DMU_OBJECT_END);
	dmu_tx_hold_write(tx, DMU_NEW_OBJECT,
	0, aclp->z_acl_bytes);
	} else {
	dmu_tx_hold_write(tx, acl_obj, 0,
	aclp->z_acl_bytes);
	}
	} else if (!zp->z_is_sa && aclp->z_acl_bytes > ZFS_ACE_SPACE) {
	dmu_tx_hold_write(tx, DMU_NEW_OBJECT,
	0, aclp->z_acl_bytes);
	}
	dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_TRUE);
	} else {
	if (((mask & AT_XVATTR) &&
	XVA_ISSET_REQ(xvap, XAT_AV_SCANSTAMP)) \|\|
	(projid != ZFS_INVALID_PROJID &&
	!(zp->z_pflags & ZFS_PROJID)))
	dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_TRUE);
	else
	dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
	}

	if (attrzp) {
	dmu_tx_hold_sa(tx, attrzp->z_sa_hdl, B_FALSE);
	}

	fuid_dirtied = zfsvfs->z_fuid_dirty;
	if (fuid_dirtied)
	zfs_fuid_txhold(zfsvfs, tx);

	zfs_sa_upgrade_txholds(tx, zp);

	err = dmu_tx_assign(tx, TXG_WAIT);
	if (err)
	goto out;

	count = 0;
	/*
	* Set each attribute requested.
	* We group settings according to the locks they need to acquire.
	*
	* Note: you cannot set ctime directly, although it will be
	* updated as a side-effect of calling this function.
	*/

	if (projid != ZFS_INVALID_PROJID && !(zp->z_pflags & ZFS_PROJID)) {
	/*
	* For the existed object that is upgraded from old system,
	* its on-disk layout has no slot for the project ID attribute.
	* But quota accounting logic needs to access related slots by
	* offset directly. So we need to adjust old objects' layout
	* to make the project ID to some unified and fixed offset.
	*/
	if (attrzp)
	err = sa_add_projid(attrzp->z_sa_hdl, tx, projid);
	if (err == 0)
	err = sa_add_projid(zp->z_sa_hdl, tx, projid);

	if (unlikely(err == EEXIST))
	err = 0;
	else if (err != 0)
	goto out;
	else
	projid = ZFS_INVALID_PROJID;
	}

	if (mask & (AT_UID\|AT_GID\|AT_MODE))
	mutex_enter(&zp->z_acl_lock);

	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zfsvfs), NULL,
	&zp->z_pflags, sizeof (zp->z_pflags));

	if (attrzp) {
	if (mask & (AT_UID\|AT_GID\|AT_MODE))
	mutex_enter(&attrzp->z_acl_lock);
	SA_ADD_BULK_ATTR(xattr_bulk, xattr_count,
	SA_ZPL_FLAGS(zfsvfs), NULL, &attrzp->z_pflags,
	sizeof (attrzp->z_pflags));
	if (projid != ZFS_INVALID_PROJID) {
	attrzp->z_projid = projid;
	SA_ADD_BULK_ATTR(xattr_bulk, xattr_count,
	SA_ZPL_PROJID(zfsvfs), NULL, &attrzp->z_projid,
	sizeof (attrzp->z_projid));
	}
	}

	if (mask & (AT_UID\|AT_GID)) {

	if (mask & AT_UID) {
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_UID(zfsvfs), NULL,
	&new_uid, sizeof (new_uid));
	zp->z_uid = new_uid;
	if (attrzp) {
	SA_ADD_BULK_ATTR(xattr_bulk, xattr_count,
	SA_ZPL_UID(zfsvfs), NULL, &new_uid,
	sizeof (new_uid));
	attrzp->z_uid = new_uid;
	}
	}

	if (mask & AT_GID) {
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_GID(zfsvfs),
	NULL, &new_gid, sizeof (new_gid));
	zp->z_gid = new_gid;
	if (attrzp) {
	SA_ADD_BULK_ATTR(xattr_bulk, xattr_count,
	SA_ZPL_GID(zfsvfs), NULL, &new_gid,
	sizeof (new_gid));
	attrzp->z_gid = new_gid;
	}
	}
	if (!(mask & AT_MODE)) {
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MODE(zfsvfs),
	NULL, &new_mode, sizeof (new_mode));
	new_mode = zp->z_mode;
	}
	err = zfs_acl_chown_setattr(zp);
	ASSERT(err == 0);
	if (attrzp) {
	vn_seqc_write_begin(ZTOV(attrzp));
	err = zfs_acl_chown_setattr(attrzp);
	vn_seqc_write_end(ZTOV(attrzp));
	ASSERT(err == 0);
	}
	}

	if (mask & AT_MODE) {
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MODE(zfsvfs), NULL,
	&new_mode, sizeof (new_mode));
	zp->z_mode = new_mode;
	ASSERT3U((uintptr_t)aclp, !=, 0);
	err = zfs_aclset_common(zp, aclp, cr, tx);
	ASSERT0(err);
	if (zp->z_acl_cached)
	zfs_acl_free(zp->z_acl_cached);
	zp->z_acl_cached = aclp;
	aclp = NULL;
	}


	if (mask & AT_ATIME) {
	ZFS_TIME_ENCODE(&vap->va_atime, zp->z_atime);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_ATIME(zfsvfs), NULL,
	&zp->z_atime, sizeof (zp->z_atime));
	}

	if (mask & AT_MTIME) {
	ZFS_TIME_ENCODE(&vap->va_mtime, mtime);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zfsvfs), NULL,
	mtime, sizeof (mtime));
	}

	if (projid != ZFS_INVALID_PROJID) {
	zp->z_projid = projid;
	SA_ADD_BULK_ATTR(bulk, count,
	SA_ZPL_PROJID(zfsvfs), NULL, &zp->z_projid,
	sizeof (zp->z_projid));
	}

	/* XXX - shouldn't this be done before the ATIME/MTIME checks? */
	if (mask & AT_SIZE && !(mask & AT_MTIME)) {
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zfsvfs),
	NULL, mtime, sizeof (mtime));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs), NULL,
	&ctime, sizeof (ctime));
	zfs_tstamp_update_setup(zp, CONTENT_MODIFIED, mtime, ctime);
	} else if (mask != 0) {
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs), NULL,
	&ctime, sizeof (ctime));
	zfs_tstamp_update_setup(zp, STATE_CHANGED, mtime, ctime);
	if (attrzp) {
	SA_ADD_BULK_ATTR(xattr_bulk, xattr_count,
	SA_ZPL_CTIME(zfsvfs), NULL,
	&ctime, sizeof (ctime));
	zfs_tstamp_update_setup(attrzp, STATE_CHANGED,
	mtime, ctime);
	}
	}

	/*
	* Do this after setting timestamps to prevent timestamp
	* update from toggling bit
	*/

	if (xoap && (mask & AT_XVATTR)) {

	if (XVA_ISSET_REQ(xvap, XAT_CREATETIME))
	xoap->xoa_createtime = vap->va_birthtime;
	/*
	* restore trimmed off masks
	* so that return masks can be set for caller.
	*/

	if (XVA_ISSET_REQ(&tmpxvattr, XAT_APPENDONLY)) {
	XVA_SET_REQ(xvap, XAT_APPENDONLY);
	}
	if (XVA_ISSET_REQ(&tmpxvattr, XAT_NOUNLINK)) {
	XVA_SET_REQ(xvap, XAT_NOUNLINK);
	}
	if (XVA_ISSET_REQ(&tmpxvattr, XAT_IMMUTABLE)) {
	XVA_SET_REQ(xvap, XAT_IMMUTABLE);
	}
	if (XVA_ISSET_REQ(&tmpxvattr, XAT_NODUMP)) {
	XVA_SET_REQ(xvap, XAT_NODUMP);
	}
	if (XVA_ISSET_REQ(&tmpxvattr, XAT_AV_MODIFIED)) {
	XVA_SET_REQ(xvap, XAT_AV_MODIFIED);
	}
	if (XVA_ISSET_REQ(&tmpxvattr, XAT_AV_QUARANTINED)) {
	XVA_SET_REQ(xvap, XAT_AV_QUARANTINED);
	}
	if (XVA_ISSET_REQ(&tmpxvattr, XAT_PROJINHERIT)) {
	XVA_SET_REQ(xvap, XAT_PROJINHERIT);
	}

	if (XVA_ISSET_REQ(xvap, XAT_AV_SCANSTAMP))
	ASSERT(vp->v_type == VREG);

	zfs_xvattr_set(zp, xvap, tx);
	}

	if (fuid_dirtied)
	zfs_fuid_sync(zfsvfs, tx);

	if (mask != 0)
	zfs_log_setattr(zilog, tx, TX_SETATTR, zp, vap, mask, fuidp);

	if (mask & (AT_UID\|AT_GID\|AT_MODE))
	mutex_exit(&zp->z_acl_lock);

	if (attrzp) {
	if (mask & (AT_UID\|AT_GID\|AT_MODE))
	mutex_exit(&attrzp->z_acl_lock);
	}
	out:
	if (err == 0 && attrzp) {
	err2 = sa_bulk_update(attrzp->z_sa_hdl, xattr_bulk,
	xattr_count, tx);
	ASSERT(err2 == 0);
	}

	if (attrzp)
	vput(ZTOV(attrzp));

	if (aclp)
	zfs_acl_free(aclp);

	if (fuidp) {
	zfs_fuid_info_free(fuidp);
	fuidp = NULL;
	}

	if (err) {
	dmu_tx_abort(tx);
	} else {
	err2 = sa_bulk_update(zp->z_sa_hdl, bulk, count, tx);
	dmu_tx_commit(tx);
	}

	out2:
	if (os->os_sync == ZFS_SYNC_ALWAYS)
	zil_commit(zilog, 0);

	ZFS_EXIT(zfsvfs);
	return (err);
	}

	/*
	* We acquire all but fdvp locks using non-blocking acquisitions. If we
	* fail to acquire any lock in the path we will drop all held locks,
	* acquire the new lock in a blocking fashion, and then release it and
	* restart the rename. This acquire/release step ensures that we do not
	* spin on a lock waiting for release. On error release all vnode locks
	* and decrement references the way tmpfs_rename() would do.
	*/
	static int
	zfs_rename_relock(struct vnode sdvp, struct vnode *svpp,
	struct vnode tdvp, struct vnode *tvpp,
	const struct componentname scnp, const struct componentname tcnp)
	{
	zfsvfs_t *zfsvfs;
	struct vnode nvp, svp, *tvp;
	znode_t sdzp, tdzp, szp, tzp;
	const char *snm = scnp->cn_nameptr;
	const char *tnm = tcnp->cn_nameptr;
	int error;

	VOP_UNLOCK1(tdvp);
	if (tvpp != NULL && tvpp != tdvp)
	VOP_UNLOCK1(*tvpp);

	relock:
	error = vn_lock(sdvp, LK_EXCLUSIVE);
	if (error)
	goto out;
	sdzp = VTOZ(sdvp);

	error = vn_lock(tdvp, LK_EXCLUSIVE \| LK_NOWAIT);
	if (error != 0) {
	VOP_UNLOCK1(sdvp);
	if (error != EBUSY)
	goto out;
	error = vn_lock(tdvp, LK_EXCLUSIVE);
	if (error)
	goto out;
	VOP_UNLOCK1(tdvp);
	goto relock;
	}
	tdzp = VTOZ(tdvp);

	/*
	* Before using sdzp and tdzp we must ensure that they are live.
	* As a porting legacy from illumos we have two things to worry
	* about. One is typical for FreeBSD and it is that the vnode is
	* not reclaimed (doomed). The other is that the znode is live.
	* The current code can invalidate the znode without acquiring the
	* corresponding vnode lock if the object represented by the znode
	* and vnode is no longer valid after a rollback or receive operation.
	* z_teardown_lock hidden behind ZFS_ENTER and ZFS_EXIT is the lock
	* that protects the znodes from the invalidation.
	*/
	zfsvfs = sdzp->z_zfsvfs;
	ASSERT3P(zfsvfs, ==, tdzp->z_zfsvfs);
	ZFS_ENTER(zfsvfs);

	/*
	* We can not use ZFS_VERIFY_ZP() here because it could directly return
	* bypassing the cleanup code in the case of an error.
	*/
	if (tdzp->z_sa_hdl == NULL \|\| sdzp->z_sa_hdl == NULL) {
	ZFS_EXIT(zfsvfs);
	VOP_UNLOCK1(sdvp);
	VOP_UNLOCK1(tdvp);
	error = SET_ERROR(EIO);
	goto out;
	}

	/*
	* Re-resolve svp to be certain it still exists and fetch the
	* correct vnode.
	*/
	error = zfs_dirent_lookup(sdzp, snm, &szp, ZEXISTS);
	if (error != 0) {
	/* Source entry invalid or not there. */
	ZFS_EXIT(zfsvfs);
	VOP_UNLOCK1(sdvp);
	VOP_UNLOCK1(tdvp);
	if ((scnp->cn_flags & ISDOTDOT) != 0 \|\|
	(scnp->cn_namelen == 1 && scnp->cn_nameptr[0] == '.'))
	error = SET_ERROR(EINVAL);
	goto out;
	}
	svp = ZTOV(szp);

	/*
	* Re-resolve tvp, if it disappeared we just carry on.
	*/
	error = zfs_dirent_lookup(tdzp, tnm, &tzp, 0);
	if (error != 0) {
	ZFS_EXIT(zfsvfs);
	VOP_UNLOCK1(sdvp);
	VOP_UNLOCK1(tdvp);
	vrele(svp);
	if ((tcnp->cn_flags & ISDOTDOT) != 0)
	error = SET_ERROR(EINVAL);
	goto out;
	}
	if (tzp != NULL)
	tvp = ZTOV(tzp);
	else
	tvp = NULL;

	/*
	* At present the vnode locks must be acquired before z_teardown_lock,
	* although it would be more logical to use the opposite order.
	*/
	ZFS_EXIT(zfsvfs);

	/*
	* Now try acquire locks on svp and tvp.
	*/
	nvp = svp;
	error = vn_lock(nvp, LK_EXCLUSIVE \| LK_NOWAIT);
	if (error != 0) {
	VOP_UNLOCK1(sdvp);
	VOP_UNLOCK1(tdvp);
	if (tvp != NULL)
	vrele(tvp);
	if (error != EBUSY) {
	vrele(nvp);
	goto out;
	}
	error = vn_lock(nvp, LK_EXCLUSIVE);
	if (error != 0) {
	vrele(nvp);
	goto out;
	}
	VOP_UNLOCK1(nvp);
	/*
	* Concurrent rename race.
	* XXX ?
	*/
	if (nvp == tdvp) {
	vrele(nvp);
	error = SET_ERROR(EINVAL);
	goto out;
	}
	vrele(*svpp);
	*svpp = nvp;
	goto relock;
	}
	vrele(*svpp);
	*svpp = nvp;

	if (*tvpp != NULL)
	vrele(*tvpp);
	*tvpp = NULL;
	if (tvp != NULL) {
	nvp = tvp;
	error = vn_lock(nvp, LK_EXCLUSIVE \| LK_NOWAIT);
	if (error != 0) {
	VOP_UNLOCK1(sdvp);
	VOP_UNLOCK1(tdvp);
	VOP_UNLOCK1(*svpp);
	if (error != EBUSY) {
	vrele(nvp);
	goto out;
	}
	error = vn_lock(nvp, LK_EXCLUSIVE);
	if (error != 0) {
	vrele(nvp);
	goto out;
	}
	vput(nvp);
	goto relock;
	}
	*tvpp = nvp;
	}

	return (0);

	out:
	return (error);
	}

	/*
	* Note that we must use VRELE_ASYNC in this function as it walks
	* up the directory tree and vrele may need to acquire an exclusive
	* lock if a last reference to a vnode is dropped.
	*/
	static int
	zfs_rename_check(znode_t szp, znode_t sdzp, znode_t *tdzp)
	{
	zfsvfs_t *zfsvfs;
	znode_t zp, zp1;
	uint64_t parent;
	int error;

	zfsvfs = tdzp->z_zfsvfs;
	if (tdzp == szp)
	return (SET_ERROR(EINVAL));
	if (tdzp == sdzp)
	return (0);
	if (tdzp->z_id == zfsvfs->z_root)
	return (0);
	zp = tdzp;
	for (;;) {
	ASSERT(!zp->z_unlinked);
	if ((error = sa_lookup(zp->z_sa_hdl,
	SA_ZPL_PARENT(zfsvfs), &parent, sizeof (parent))) != 0)
	break;

	if (parent == szp->z_id) {
	error = SET_ERROR(EINVAL);
	break;
	}
	if (parent == zfsvfs->z_root)
	break;
	if (parent == sdzp->z_id)
	break;

	error = zfs_zget(zfsvfs, parent, &zp1);
	if (error != 0)
	break;

	if (zp != tdzp)
	VN_RELE_ASYNC(ZTOV(zp),
	dsl_pool_zrele_taskq(
	dmu_objset_pool(zfsvfs->z_os)));
	zp = zp1;
	}

	if (error == ENOTDIR)
	panic("checkpath: .. not a directory\n");
	if (zp != tdzp)
	VN_RELE_ASYNC(ZTOV(zp),
	dsl_pool_zrele_taskq(dmu_objset_pool(zfsvfs->z_os)));
	return (error);
	}

	#if __FreeBSD_version < 1300124
	static void
	cache_vop_rename(struct vnode fdvp, struct vnode fvp, struct vnode *tdvp,
	struct vnode tvp, struct componentname fcnp, struct componentname *tcnp)
	{

	cache_purge(fvp);
	if (tvp != NULL)
	cache_purge(tvp);
	cache_purge_negative(tdvp);
	}
	#endif

	/*
	* Move an entry from the provided source directory to the target
	* directory. Change the entry name as indicated.
	*
	* IN: sdvp - Source directory containing the "old entry".
	* snm - Old entry name.
	* tdvp - Target directory to contain the "new entry".
	* tnm - New entry name.
	* cr - credentials of caller.
	* ct - caller context
	* flags - case flags
	*
	* RETURN: 0 on success, error code on failure.
	*
	* Timestamps:
	* sdvp,tdvp - ctime\|mtime updated
	*/
	/ARGSUSED/
	static int
	zfs_rename_(vnode_t sdvp, vnode_t svpp, struct componentname scnp,
	vnode_t tdvp, vnode_t tvpp, struct componentname tcnp,
	cred_t *cr, int log)
	{
	zfsvfs_t *zfsvfs;
	znode_t sdzp, tdzp, szp, tzp;
	zilog_t *zilog = NULL;
	dmu_tx_t *tx;
	const char *snm = scnp->cn_nameptr;
	const char *tnm = tcnp->cn_nameptr;
	int error = 0;
	bool want_seqc_end __maybe_unused = false;

	/* Reject renames across filesystems. */
	if ((*svpp)->v_mount != tdvp->v_mount \|\|
	((tvpp) != NULL && (svpp)->v_mount != (*tvpp)->v_mount)) {
	error = SET_ERROR(EXDEV);
	goto out;
	}

	if (zfsctl_is_node(tdvp)) {
	error = SET_ERROR(EXDEV);
	goto out;
	}

	/*
	* Lock all four vnodes to ensure safety and semantics of renaming.
	*/
	error = zfs_rename_relock(sdvp, svpp, tdvp, tvpp, scnp, tcnp);
	if (error != 0) {
	/* no vnodes are locked in the case of error here */
	return (error);
	}

	tdzp = VTOZ(tdvp);
	sdzp = VTOZ(sdvp);
	zfsvfs = tdzp->z_zfsvfs;
	zilog = zfsvfs->z_log;

	/*
	* After we re-enter ZFS_ENTER() we will have to revalidate all
	* znodes involved.
	*/
	ZFS_ENTER(zfsvfs);

	if (zfsvfs->z_utf8 && u8_validate(tnm,
	strlen(tnm), NULL, U8_VALIDATE_ENTIRE, &error) < 0) {
	error = SET_ERROR(EILSEQ);
	goto unlockout;
	}

	/* If source and target are the same file, there is nothing to do. */
	if ((svpp) == (tvpp)) {
	error = 0;
	goto unlockout;
	}

	if (((svpp)->v_type == VDIR && (svpp)->v_mountedhere != NULL) \|\|
	((tvpp) != NULL && (tvpp)->v_type == VDIR &&
	(*tvpp)->v_mountedhere != NULL)) {
	error = SET_ERROR(EXDEV);
	goto unlockout;
	}

	/*
	* We can not use ZFS_VERIFY_ZP() here because it could directly return
	* bypassing the cleanup code in the case of an error.
	*/
	if (tdzp->z_sa_hdl == NULL \|\| sdzp->z_sa_hdl == NULL) {
	error = SET_ERROR(EIO);
	goto unlockout;
	}

	szp = VTOZ(*svpp);
	tzp = tvpp == NULL ? NULL : VTOZ(tvpp);
	if (szp->z_sa_hdl == NULL \|\| (tzp != NULL && tzp->z_sa_hdl == NULL)) {
	error = SET_ERROR(EIO);
	goto unlockout;
	}

	/*
	* This is to prevent the creation of links into attribute space
	* by renaming a linked file into/outof an attribute directory.
	* See the comment in zfs_link() for why this is considered bad.
	*/
	if ((tdzp->z_pflags & ZFS_XATTR) != (sdzp->z_pflags & ZFS_XATTR)) {
	error = SET_ERROR(EINVAL);
	goto unlockout;
	}

	/*
	* If we are using project inheritance, means if the directory has
	* ZFS_PROJINHERIT set, then its descendant directories will inherit
	* not only the project ID, but also the ZFS_PROJINHERIT flag. Under
	* such case, we only allow renames into our tree when the project
	* IDs are the same.
	*/
	if (tdzp->z_pflags & ZFS_PROJINHERIT &&
	tdzp->z_projid != szp->z_projid) {
	error = SET_ERROR(EXDEV);
	goto unlockout;
	}

	/*
	* Must have write access at the source to remove the old entry
	* and write access at the target to create the new entry.
	* Note that if target and source are the same, this can be
	* done in a single check.
	*/
	if ((error = zfs_zaccess_rename(sdzp, szp, tdzp, tzp, cr)))
	goto unlockout;

	if ((*svpp)->v_type == VDIR) {
	/*
	* Avoid ".", "..", and aliases of "." for obvious reasons.
	*/
	if ((scnp->cn_namelen == 1 && scnp->cn_nameptr[0] == '.') \|\|
	sdzp == szp \|\|
	(scnp->cn_flags \| tcnp->cn_flags) & ISDOTDOT) {
	error = EINVAL;
	goto unlockout;
	}

	/*
	* Check to make sure rename is valid.
	* Can't do a move like this: /usr/a/b to /usr/a/b/c/d
	*/
	if ((error = zfs_rename_check(szp, sdzp, tdzp)))
	goto unlockout;
	}

	/*
	* Does target exist?
	*/
	if (tzp) {
	/*
	* Source and target must be the same type.
	*/
	if ((*svpp)->v_type == VDIR) {
	if ((*tvpp)->v_type != VDIR) {
	error = SET_ERROR(ENOTDIR);
	goto unlockout;
	} else {
	cache_purge(tdvp);
	if (sdvp != tdvp)
	cache_purge(sdvp);
	}
	} else {
	if ((*tvpp)->v_type == VDIR) {
	error = SET_ERROR(EISDIR);
	goto unlockout;
	}
	}
	}

	vn_seqc_write_begin(*svpp);
	vn_seqc_write_begin(sdvp);
	if (*tvpp != NULL)
	vn_seqc_write_begin(*tvpp);
	if (tdvp != *tvpp)
	vn_seqc_write_begin(tdvp);
	#if __FreeBSD_version >= 1300102
	want_seqc_end = true;
	#endif
	vnevent_rename_src(*svpp, sdvp, scnp->cn_nameptr, ct);
	if (tzp)
	vnevent_rename_dest(*tvpp, tdvp, tnm, ct);

	/*
	* notify the target directory if it is not the same
	* as source directory.
	*/
	if (tdvp != sdvp) {
	vnevent_rename_dest_dir(tdvp, ct);
	}

	tx = dmu_tx_create(zfsvfs->z_os);
	dmu_tx_hold_sa(tx, szp->z_sa_hdl, B_FALSE);
	dmu_tx_hold_sa(tx, sdzp->z_sa_hdl, B_FALSE);
	dmu_tx_hold_zap(tx, sdzp->z_id, FALSE, snm);
	dmu_tx_hold_zap(tx, tdzp->z_id, TRUE, tnm);
	if (sdzp != tdzp) {
	dmu_tx_hold_sa(tx, tdzp->z_sa_hdl, B_FALSE);
	zfs_sa_upgrade_txholds(tx, tdzp);
	}
	if (tzp) {
	dmu_tx_hold_sa(tx, tzp->z_sa_hdl, B_FALSE);
	zfs_sa_upgrade_txholds(tx, tzp);
	}

	zfs_sa_upgrade_txholds(tx, szp);
	dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, FALSE, NULL);
	error = dmu_tx_assign(tx, TXG_WAIT);
	if (error) {
	dmu_tx_abort(tx);
	goto unlockout;
	}


	if (tzp) /* Attempt to remove the existing target */
	error = zfs_link_destroy(tdzp, tnm, tzp, tx, 0, NULL);

	if (error == 0) {
	error = zfs_link_create(tdzp, tnm, szp, tx, ZRENAMING);
	if (error == 0) {
	szp->z_pflags \|= ZFS_AV_MODIFIED;

	error = sa_update(szp->z_sa_hdl, SA_ZPL_FLAGS(zfsvfs),
	(void *)&szp->z_pflags, sizeof (uint64_t), tx);
	ASSERT0(error);

	error = zfs_link_destroy(sdzp, snm, szp, tx, ZRENAMING,
	NULL);
	if (error == 0) {
	zfs_log_rename(zilog, tx, TX_RENAME, sdzp,
	snm, tdzp, tnm, szp);

	/*
	* Update path information for the target vnode
	*/
	vn_renamepath(tdvp, *svpp, tnm, strlen(tnm));
	} else {
	/*
	* At this point, we have successfully created
	* the target name, but have failed to remove
	* the source name. Since the create was done
	* with the ZRENAMING flag, there are
	* complications; for one, the link count is
	* wrong. The easiest way to deal with this
	* is to remove the newly created target, and
	* return the original error. This must
	* succeed; fortunately, it is very unlikely to
	* fail, since we just created it.
	*/
	VERIFY3U(zfs_link_destroy(tdzp, tnm, szp, tx,
	ZRENAMING, NULL), ==, 0);
	}
	}
	if (error == 0) {
	cache_vop_rename(sdvp, svpp, tdvp, tvpp, scnp, tcnp);
	}
	}

	dmu_tx_commit(tx);

	unlockout: /* all 4 vnodes are locked, ZFS_ENTER called */
	ZFS_EXIT(zfsvfs);
	if (want_seqc_end) {
	vn_seqc_write_end(*svpp);
	vn_seqc_write_end(sdvp);
	if (*tvpp != NULL)
	vn_seqc_write_end(*tvpp);
	if (tdvp != *tvpp)
	vn_seqc_write_end(tdvp);
	want_seqc_end = false;
	}
	VOP_UNLOCK1(*svpp);
	VOP_UNLOCK1(sdvp);

	out: /* original two vnodes are locked */
	MPASS(!want_seqc_end);
	if (error == 0 && zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS)
	zil_commit(zilog, 0);

	if (*tvpp != NULL)
	VOP_UNLOCK1(*tvpp);
	if (tdvp != *tvpp)
	VOP_UNLOCK1(tdvp);
	return (error);
	}

	int
	zfs_rename(znode_t sdzp, const char sname, znode_t tdzp, const char tname,
	cred_t *cr, int flags)
	{
	struct componentname scn, tcn;
	vnode_t sdvp, tdvp;
	vnode_t svp, tvp;
	int error;
	svp = tvp = NULL;

	sdvp = ZTOV(sdzp);
	tdvp = ZTOV(tdzp);
	error = zfs_lookup_internal(sdzp, sname, &svp, &scn, DELETE);
	if (sdzp->z_zfsvfs->z_replay == B_FALSE)
	VOP_UNLOCK1(sdvp);
	if (error != 0)
	goto fail;
	VOP_UNLOCK1(svp);

	vn_lock(tdvp, LK_EXCLUSIVE \| LK_RETRY);
	error = zfs_lookup_internal(tdzp, tname, &tvp, &tcn, RENAME);
	if (error == EJUSTRETURN)
	tvp = NULL;
	else if (error != 0) {
	VOP_UNLOCK1(tdvp);
	goto fail;
	}

	error = zfs_rename_(sdvp, &svp, &scn, tdvp, &tvp, &tcn, cr, 0);
	fail:
	if (svp != NULL)
	vrele(svp);
	if (tvp != NULL)
	vrele(tvp);

	return (error);
	}

	/*
	* Insert the indicated symbolic reference entry into the directory.
	*
	* IN: dvp - Directory to contain new symbolic link.
	* link - Name for new symlink entry.
	* vap - Attributes of new entry.
	* cr - credentials of caller.
	* ct - caller context
	* flags - case flags
	*
	* RETURN: 0 on success, error code on failure.
	*
	* Timestamps:
	* dvp - ctime\|mtime updated
	*/
	/ARGSUSED/
	int
	zfs_symlink(znode_t dzp, const char name, vattr_t *vap,
	const char link, znode_t zpp, cred_t cr, int flags)
	{
	znode_t *zp;
	dmu_tx_t *tx;
	zfsvfs_t *zfsvfs = dzp->z_zfsvfs;
	zilog_t *zilog;
	uint64_t len = strlen(link);
	int error;
	zfs_acl_ids_t acl_ids;
	boolean_t fuid_dirtied;
	uint64_t txtype = TX_SYMLINK;

	ASSERT(vap->va_type == VLNK);

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(dzp);
	zilog = zfsvfs->z_log;

	if (zfsvfs->z_utf8 && u8_validate(name, strlen(name),
	NULL, U8_VALIDATE_ENTIRE, &error) < 0) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EILSEQ));
	}

	if (len > MAXPATHLEN) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(ENAMETOOLONG));
	}

	if ((error = zfs_acl_ids_create(dzp, 0,
	vap, cr, NULL, &acl_ids)) != 0) {
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	/*
	* Attempt to lock directory; fail if entry already exists.
	*/
	error = zfs_dirent_lookup(dzp, name, &zp, ZNEW);
	if (error) {
	zfs_acl_ids_free(&acl_ids);
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	if ((error = zfs_zaccess(dzp, ACE_ADD_FILE, 0, B_FALSE, cr))) {
	zfs_acl_ids_free(&acl_ids);
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	if (zfs_acl_ids_overquota(zfsvfs, &acl_ids,
	0 /* projid */)) {
	zfs_acl_ids_free(&acl_ids);
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EDQUOT));
	}

	getnewvnode_reserve_();
	tx = dmu_tx_create(zfsvfs->z_os);
	fuid_dirtied = zfsvfs->z_fuid_dirty;
	dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0, MAX(1, len));
	dmu_tx_hold_zap(tx, dzp->z_id, TRUE, name);
	dmu_tx_hold_sa_create(tx, acl_ids.z_aclp->z_acl_bytes +
	ZFS_SA_BASE_ATTR_SIZE + len);
	dmu_tx_hold_sa(tx, dzp->z_sa_hdl, B_FALSE);
	if (!zfsvfs->z_use_sa && acl_ids.z_aclp->z_acl_bytes > ZFS_ACE_SPACE) {
	dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0,
	acl_ids.z_aclp->z_acl_bytes);
	}
	if (fuid_dirtied)
	zfs_fuid_txhold(zfsvfs, tx);
	error = dmu_tx_assign(tx, TXG_WAIT);
	if (error) {
	zfs_acl_ids_free(&acl_ids);
	dmu_tx_abort(tx);
	getnewvnode_drop_reserve();
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	/*
	* Create a new object for the symlink.
	- * for version 4 ZPL datsets the symlink will be an SA attribute
	+ * for version 4 ZPL datasets the symlink will be an SA attribute
	*/
	zfs_mknode(dzp, vap, tx, cr, 0, &zp, &acl_ids);

	if (fuid_dirtied)
	zfs_fuid_sync(zfsvfs, tx);

	if (zp->z_is_sa)
	error = sa_update(zp->z_sa_hdl, SA_ZPL_SYMLINK(zfsvfs),
	__DECONST(void *, link), len, tx);
	else
	zfs_sa_symlink(zp, __DECONST(char *, link), len, tx);

	zp->z_size = len;
	(void) sa_update(zp->z_sa_hdl, SA_ZPL_SIZE(zfsvfs),
	&zp->z_size, sizeof (zp->z_size), tx);
	/*
	* Insert the new object into the directory.
	*/
	(void) zfs_link_create(dzp, name, zp, tx, ZNEW);

	zfs_log_symlink(zilog, tx, txtype, dzp, zp, name, link);
	*zpp = zp;

	zfs_acl_ids_free(&acl_ids);

	dmu_tx_commit(tx);

	getnewvnode_drop_reserve();

	if (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS)
	zil_commit(zilog, 0);

	ZFS_EXIT(zfsvfs);
	return (error);
	}

	/*
	* Return, in the buffer contained in the provided uio structure,
	* the symbolic path referred to by vp.
	*
	* IN: vp - vnode of symbolic link.
	* uio - structure to contain the link path.
	* cr - credentials of caller.
	* ct - caller context
	*
	* OUT: uio - structure containing the link path.
	*
	* RETURN: 0 on success, error code on failure.
	*
	* Timestamps:
	* vp - atime updated
	*/
	/* ARGSUSED */
	static int
	zfs_readlink(vnode_t vp, zfs_uio_t uio, cred_t cr, caller_context_t ct)
	{
	znode_t *zp = VTOZ(vp);
	zfsvfs_t *zfsvfs = zp->z_zfsvfs;
	int error;

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zp);

	if (zp->z_is_sa)
	error = sa_lookup_uio(zp->z_sa_hdl,
	SA_ZPL_SYMLINK(zfsvfs), uio);
	else
	error = zfs_sa_readlink(zp, uio);

	ZFS_ACCESSTIME_STAMP(zfsvfs, zp);

	ZFS_EXIT(zfsvfs);
	return (error);
	}

	/*
	* Insert a new entry into directory tdvp referencing svp.
	*
	* IN: tdvp - Directory to contain new entry.
	* svp - vnode of new entry.
	* name - name of new entry.
	* cr - credentials of caller.
	*
	* RETURN: 0 on success, error code on failure.
	*
	* Timestamps:
	* tdvp - ctime\|mtime updated
	* svp - ctime updated
	*/
	/* ARGSUSED */
	int
	zfs_link(znode_t tdzp, znode_t szp, const char name, cred_t cr,
	int flags)
	{
	znode_t *tzp;
	zfsvfs_t *zfsvfs = tdzp->z_zfsvfs;
	zilog_t *zilog;
	dmu_tx_t *tx;
	int error;
	uint64_t parent;
	uid_t owner;

	ASSERT(ZTOV(tdzp)->v_type == VDIR);

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(tdzp);
	zilog = zfsvfs->z_log;

	/*
	* POSIX dictates that we return EPERM here.
	* Better choices include ENOTSUP or EISDIR.
	*/
	if (ZTOV(szp)->v_type == VDIR) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EPERM));
	}

	ZFS_VERIFY_ZP(szp);

	/*
	* If we are using project inheritance, means if the directory has
	* ZFS_PROJINHERIT set, then its descendant directories will inherit
	* not only the project ID, but also the ZFS_PROJINHERIT flag. Under
	* such case, we only allow hard link creation in our tree when the
	* project IDs are the same.
	*/
	if (tdzp->z_pflags & ZFS_PROJINHERIT &&
	tdzp->z_projid != szp->z_projid) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EXDEV));
	}

	if (szp->z_pflags & (ZFS_APPENDONLY \|
	ZFS_IMMUTABLE \| ZFS_READONLY)) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EPERM));
	}

	/* Prevent links to .zfs/shares files */

	if ((error = sa_lookup(szp->z_sa_hdl, SA_ZPL_PARENT(zfsvfs),
	&parent, sizeof (uint64_t))) != 0) {
	ZFS_EXIT(zfsvfs);
	return (error);
	}
	if (parent == zfsvfs->z_shares_dir) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EPERM));
	}

	if (zfsvfs->z_utf8 && u8_validate(name,
	strlen(name), NULL, U8_VALIDATE_ENTIRE, &error) < 0) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EILSEQ));
	}

	/*
	* We do not support links between attributes and non-attributes
	* because of the potential security risk of creating links
	* into "normal" file space in order to circumvent restrictions
	* imposed in attribute space.
	*/
	if ((szp->z_pflags & ZFS_XATTR) != (tdzp->z_pflags & ZFS_XATTR)) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EINVAL));
	}


	owner = zfs_fuid_map_id(zfsvfs, szp->z_uid, cr, ZFS_OWNER);
	if (owner != crgetuid(cr) && secpolicy_basic_link(ZTOV(szp), cr) != 0) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EPERM));
	}

	if ((error = zfs_zaccess(tdzp, ACE_ADD_FILE, 0, B_FALSE, cr))) {
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	/*
	* Attempt to lock directory; fail if entry already exists.
	*/
	error = zfs_dirent_lookup(tdzp, name, &tzp, ZNEW);
	if (error) {
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	tx = dmu_tx_create(zfsvfs->z_os);
	dmu_tx_hold_sa(tx, szp->z_sa_hdl, B_FALSE);
	dmu_tx_hold_zap(tx, tdzp->z_id, TRUE, name);
	zfs_sa_upgrade_txholds(tx, szp);
	zfs_sa_upgrade_txholds(tx, tdzp);
	error = dmu_tx_assign(tx, TXG_WAIT);
	if (error) {
	dmu_tx_abort(tx);
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	error = zfs_link_create(tdzp, name, szp, tx, 0);

	if (error == 0) {
	uint64_t txtype = TX_LINK;
	zfs_log_link(zilog, tx, txtype, tdzp, szp, name);
	}

	dmu_tx_commit(tx);

	if (error == 0) {
	vnevent_link(ZTOV(szp), ct);
	}

	if (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS)
	zil_commit(zilog, 0);

	ZFS_EXIT(zfsvfs);
	return (error);
	}

	/*
	* Free or allocate space in a file. Currently, this function only
	* supports the `F_FREESP' command. However, this command is somewhat
	* misnamed, as its functionality includes the ability to allocate as
	* well as free space.
	*
	* IN: ip - inode of file to free data in.
	* cmd - action to take (only F_FREESP supported).
	* bfp - section of file to free/alloc.
	* flag - current file open mode flags.
	* offset - current file offset.
	* cr - credentials of caller.
	*
	* RETURN: 0 on success, error code on failure.
	*
	* Timestamps:
	* ip - ctime\|mtime updated
	*/
	/* ARGSUSED */
	int
	zfs_space(znode_t zp, int cmd, flock64_t bfp, int flag,
	offset_t offset, cred_t *cr)
	{
	zfsvfs_t *zfsvfs = ZTOZSB(zp);
	uint64_t off, len;
	int error;

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zp);

	if (cmd != F_FREESP) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EINVAL));
	}

	/*
	* Callers might not be able to detect properly that we are read-only,
	* so check it explicitly here.
	*/
	if (zfs_is_readonly(zfsvfs)) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EROFS));
	}

	if (bfp->l_len < 0) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EINVAL));
	}

	/*
	* Permissions aren't checked on Solaris because on this OS
	* zfs_space() can only be called with an opened file handle.
	* On Linux we can get here through truncate_range() which
	* operates directly on inodes, so we need to check access rights.
	*/
	if ((error = zfs_zaccess(zp, ACE_WRITE_DATA, 0, B_FALSE, cr))) {
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	off = bfp->l_start;
	len = bfp->l_len; /* 0 means from off to end of file */

	error = zfs_freesp(zp, off, len, flag, TRUE);

	ZFS_EXIT(zfsvfs);
	return (error);
	}

	/ARGSUSED/
	static void
	zfs_inactive(vnode_t vp, cred_t cr, caller_context_t *ct)
	{
	znode_t *zp = VTOZ(vp);
	zfsvfs_t *zfsvfs = zp->z_zfsvfs;
	int error;

	ZFS_TEARDOWN_INACTIVE_ENTER_READ(zfsvfs);
	if (zp->z_sa_hdl == NULL) {
	/*
	* The fs has been unmounted, or we did a
	* suspend/resume and this file no longer exists.
	*/
	ZFS_TEARDOWN_INACTIVE_EXIT_READ(zfsvfs);
	vrecycle(vp);
	return;
	}

	if (zp->z_unlinked) {
	/*
	* Fast path to recycle a vnode of a removed file.
	*/
	ZFS_TEARDOWN_INACTIVE_EXIT_READ(zfsvfs);
	vrecycle(vp);
	return;
	}

	if (zp->z_atime_dirty && zp->z_unlinked == 0) {
	dmu_tx_t *tx = dmu_tx_create(zfsvfs->z_os);

	dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
	zfs_sa_upgrade_txholds(tx, zp);
	error = dmu_tx_assign(tx, TXG_WAIT);
	if (error) {
	dmu_tx_abort(tx);
	} else {
	(void) sa_update(zp->z_sa_hdl, SA_ZPL_ATIME(zfsvfs),
	(void *)&zp->z_atime, sizeof (zp->z_atime), tx);
	zp->z_atime_dirty = 0;
	dmu_tx_commit(tx);
	}
	}
	ZFS_TEARDOWN_INACTIVE_EXIT_READ(zfsvfs);
	}


	CTASSERT(sizeof (struct zfid_short) <= sizeof (struct fid));
	CTASSERT(sizeof (struct zfid_long) <= sizeof (struct fid));

	/ARGSUSED/
	static int
	zfs_fid(vnode_t vp, fid_t fidp, caller_context_t *ct)
	{
	znode_t *zp = VTOZ(vp);
	zfsvfs_t *zfsvfs = zp->z_zfsvfs;
	uint32_t gen;
	uint64_t gen64;
	uint64_t object = zp->z_id;
	zfid_short_t *zfid;
	int size, i, error;

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zp);

	if ((error = sa_lookup(zp->z_sa_hdl, SA_ZPL_GEN(zfsvfs),
	&gen64, sizeof (uint64_t))) != 0) {
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	gen = (uint32_t)gen64;

	size = (zfsvfs->z_parent != zfsvfs) ? LONG_FID_LEN : SHORT_FID_LEN;
	fidp->fid_len = size;

	zfid = (zfid_short_t *)fidp;

	zfid->zf_len = size;

	for (i = 0; i < sizeof (zfid->zf_object); i++)
	zfid->zf_object[i] = (uint8_t)(object >> (8 * i));

	/* Must have a non-zero generation number to distinguish from .zfs */
	if (gen == 0)
	gen = 1;
	for (i = 0; i < sizeof (zfid->zf_gen); i++)
	zfid->zf_gen[i] = (uint8_t)(gen >> (8 * i));

	if (size == LONG_FID_LEN) {
	uint64_t objsetid = dmu_objset_id(zfsvfs->z_os);
	zfid_long_t *zlfid;

	zlfid = (zfid_long_t *)fidp;

	for (i = 0; i < sizeof (zlfid->zf_setid); i++)
	zlfid->zf_setid[i] = (uint8_t)(objsetid >> (8 * i));

	/* XXX - this should be the generation number for the objset */
	for (i = 0; i < sizeof (zlfid->zf_setgen); i++)
	zlfid->zf_setgen[i] = 0;
	}

	ZFS_EXIT(zfsvfs);
	return (0);
	}

	static int
	zfs_pathconf(vnode_t vp, int cmd, ulong_t valp, cred_t *cr,
	caller_context_t *ct)
	{
	znode_t *zp;
	zfsvfs_t *zfsvfs;

	switch (cmd) {
	case _PC_LINK_MAX:
	*valp = MIN(LONG_MAX, ZFS_LINK_MAX);
	return (0);

	case _PC_FILESIZEBITS:
	*valp = 64;
	return (0);
	case _PC_MIN_HOLE_SIZE:
	*valp = (int)SPA_MINBLOCKSIZE;
	return (0);
	case _PC_ACL_EXTENDED:
	#if 0 /* POSIX ACLs are not implemented for ZFS on FreeBSD yet. */
	zp = VTOZ(vp);
	zfsvfs = zp->z_zfsvfs;
	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zp);
	*valp = zfsvfs->z_acl_type == ZFSACLTYPE_POSIX ? 1 : 0;
	ZFS_EXIT(zfsvfs);
	#else
	*valp = 0;
	#endif
	return (0);

	case _PC_ACL_NFS4:
	zp = VTOZ(vp);
	zfsvfs = zp->z_zfsvfs;
	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zp);
	*valp = zfsvfs->z_acl_type == ZFS_ACLTYPE_NFSV4 ? 1 : 0;
	ZFS_EXIT(zfsvfs);
	return (0);

	case _PC_ACL_PATH_MAX:
	*valp = ACL_MAX_ENTRIES;
	return (0);

	default:
	return (EOPNOTSUPP);
	}
	}

	static int
	zfs_getpages(struct vnode vp, vm_page_t ma, int count, int *rbehind,
	int *rahead)
	{
	znode_t *zp = VTOZ(vp);
	zfsvfs_t *zfsvfs = zp->z_zfsvfs;
	objset_t *os = zp->z_zfsvfs->z_os;
	zfs_locked_range_t *lr;
	vm_object_t object;
	off_t start, end, obj_size;
	uint_t blksz;
	int pgsin_b, pgsin_a;
	int error;

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zp);

	start = IDX_TO_OFF(ma[0]->pindex);
	end = IDX_TO_OFF(ma[count - 1]->pindex + 1);

	/*
	* Lock a range covering all required and optional pages.
	* Note that we need to handle the case of the block size growing.
	*/
	for (;;) {
	blksz = zp->z_blksz;
	lr = zfs_rangelock_tryenter(&zp->z_rangelock,
	rounddown(start, blksz),
	roundup(end, blksz) - rounddown(start, blksz), RL_READER);
	if (lr == NULL) {
	if (rahead != NULL) {
	*rahead = 0;
	rahead = NULL;
	}
	if (rbehind != NULL) {
	*rbehind = 0;
	rbehind = NULL;
	}
	break;
	}
	if (blksz == zp->z_blksz)
	break;
	zfs_rangelock_exit(lr);
	}

	object = ma[0]->object;
	zfs_vmobject_wlock(object);
	obj_size = object->un_pager.vnp.vnp_size;
	zfs_vmobject_wunlock(object);
	if (IDX_TO_OFF(ma[count - 1]->pindex) >= obj_size) {
	if (lr != NULL)
	zfs_rangelock_exit(lr);
	ZFS_EXIT(zfsvfs);
	return (zfs_vm_pagerret_bad);
	}

	pgsin_b = 0;
	if (rbehind != NULL) {
	pgsin_b = OFF_TO_IDX(start - rounddown(start, blksz));
	pgsin_b = MIN(*rbehind, pgsin_b);
	}

	pgsin_a = 0;
	if (rahead != NULL) {
	pgsin_a = OFF_TO_IDX(roundup(end, blksz) - end);
	if (end + IDX_TO_OFF(pgsin_a) >= obj_size)
	pgsin_a = OFF_TO_IDX(round_page(obj_size) - end);
	pgsin_a = MIN(*rahead, pgsin_a);
	}

	/*
	* NB: we need to pass the exact byte size of the data that we expect
	* to read after accounting for the file size. This is required because
	* ZFS will panic if we request DMU to read beyond the end of the last
	* allocated block.
	*/
	error = dmu_read_pages(os, zp->z_id, ma, count, &pgsin_b, &pgsin_a,
	MIN(end, obj_size) - (end - PAGE_SIZE));

	if (lr != NULL)
	zfs_rangelock_exit(lr);
	ZFS_ACCESSTIME_STAMP(zfsvfs, zp);
	ZFS_EXIT(zfsvfs);

	if (error != 0)
	return (zfs_vm_pagerret_error);

	VM_CNT_INC(v_vnodein);
	VM_CNT_ADD(v_vnodepgsin, count + pgsin_b + pgsin_a);
	if (rbehind != NULL)
	*rbehind = pgsin_b;
	if (rahead != NULL)
	*rahead = pgsin_a;
	return (zfs_vm_pagerret_ok);
	}

	#ifndef _SYS_SYSPROTO_H_
	struct vop_getpages_args {
	struct vnode *a_vp;
	vm_page_t *a_m;
	int a_count;
	int *a_rbehind;
	int *a_rahead;
	};
	#endif

	static int
	zfs_freebsd_getpages(struct vop_getpages_args *ap)
	{

	return (zfs_getpages(ap->a_vp, ap->a_m, ap->a_count, ap->a_rbehind,
	ap->a_rahead));
	}

	static int
	zfs_putpages(struct vnode vp, vm_page_t ma, size_t len, int flags,
	int *rtvals)
	{
	znode_t *zp = VTOZ(vp);
	zfsvfs_t *zfsvfs = zp->z_zfsvfs;
	zfs_locked_range_t *lr;
	dmu_tx_t *tx;
	struct sf_buf *sf;
	vm_object_t object;
	vm_page_t m;
	caddr_t va;
	size_t tocopy;
	size_t lo_len;
	vm_ooffset_t lo_off;
	vm_ooffset_t off;
	uint_t blksz;
	int ncount;
	int pcount;
	int err;
	int i;

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zp);

	object = vp->v_object;
	pcount = btoc(len);
	ncount = pcount;

	KASSERT(ma[0]->object == object, ("mismatching object"));
	KASSERT(len > 0 && (len & PAGE_MASK) == 0, ("unexpected length"));

	for (i = 0; i < pcount; i++)
	rtvals[i] = zfs_vm_pagerret_error;

	off = IDX_TO_OFF(ma[0]->pindex);
	blksz = zp->z_blksz;
	lo_off = rounddown(off, blksz);
	lo_len = roundup(len + (off - lo_off), blksz);
	lr = zfs_rangelock_enter(&zp->z_rangelock, lo_off, lo_len, RL_WRITER);

	zfs_vmobject_wlock(object);
	if (len + off > object->un_pager.vnp.vnp_size) {
	if (object->un_pager.vnp.vnp_size > off) {
	int pgoff;

	len = object->un_pager.vnp.vnp_size - off;
	ncount = btoc(len);
	if ((pgoff = (int)len & PAGE_MASK) != 0) {
	/*
	* If the object is locked and the following
	* conditions hold, then the page's dirty
	* field cannot be concurrently changed by a
	* pmap operation.
	*/
	m = ma[ncount - 1];
	vm_page_assert_sbusied(m);
	KASSERT(!pmap_page_is_write_mapped(m),
	("zfs_putpages: page %p is not read-only",
	m));
	vm_page_clear_dirty(m, pgoff, PAGE_SIZE -
	pgoff);
	}
	} else {
	len = 0;
	ncount = 0;
	}
	if (ncount < pcount) {
	for (i = ncount; i < pcount; i++) {
	rtvals[i] = zfs_vm_pagerret_bad;
	}
	}
	}
	zfs_vmobject_wunlock(object);

	if (ncount == 0)
	goto out;

	if (zfs_id_overblockquota(zfsvfs, DMU_USERUSED_OBJECT, zp->z_uid) \|\|
	zfs_id_overblockquota(zfsvfs, DMU_GROUPUSED_OBJECT, zp->z_gid) \|\|
	(zp->z_projid != ZFS_DEFAULT_PROJID &&
	zfs_id_overblockquota(zfsvfs, DMU_PROJECTUSED_OBJECT,
	zp->z_projid))) {
	goto out;
	}

	tx = dmu_tx_create(zfsvfs->z_os);
	dmu_tx_hold_write(tx, zp->z_id, off, len);

	dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
	zfs_sa_upgrade_txholds(tx, zp);
	err = dmu_tx_assign(tx, TXG_WAIT);
	if (err != 0) {
	dmu_tx_abort(tx);
	goto out;
	}

	if (zp->z_blksz < PAGE_SIZE) {
	for (i = 0; len > 0; off += tocopy, len -= tocopy, i++) {
	tocopy = len > PAGE_SIZE ? PAGE_SIZE : len;
	va = zfs_map_page(ma[i], &sf);
	dmu_write(zfsvfs->z_os, zp->z_id, off, tocopy, va, tx);
	zfs_unmap_page(sf);
	}
	} else {
	err = dmu_write_pages(zfsvfs->z_os, zp->z_id, off, len, ma, tx);
	}

	if (err == 0) {
	uint64_t mtime[2], ctime[2];
	sa_bulk_attr_t bulk[3];
	int count = 0;

	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zfsvfs), NULL,
	&mtime, 16);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs), NULL,
	&ctime, 16);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zfsvfs), NULL,
	&zp->z_pflags, 8);
	zfs_tstamp_update_setup(zp, CONTENT_MODIFIED, mtime, ctime);
	err = sa_bulk_update(zp->z_sa_hdl, bulk, count, tx);
	ASSERT0(err);
	/*
	* XXX we should be passing a callback to undirty
	* but that would make the locking messier
	*/
	zfs_log_write(zfsvfs->z_log, tx, TX_WRITE, zp, off,
	len, 0, NULL, NULL);

	zfs_vmobject_wlock(object);
	for (i = 0; i < ncount; i++) {
	rtvals[i] = zfs_vm_pagerret_ok;
	vm_page_undirty(ma[i]);
	}
	zfs_vmobject_wunlock(object);
	VM_CNT_INC(v_vnodeout);
	VM_CNT_ADD(v_vnodepgsout, ncount);
	}
	dmu_tx_commit(tx);

	out:
	zfs_rangelock_exit(lr);
	if ((flags & (zfs_vm_pagerput_sync \| zfs_vm_pagerput_inval)) != 0 \|\|
	zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS)
	zil_commit(zfsvfs->z_log, zp->z_id);
	ZFS_EXIT(zfsvfs);
	return (rtvals[0]);
	}

	#ifndef _SYS_SYSPROTO_H_
	struct vop_putpages_args {
	struct vnode *a_vp;
	vm_page_t *a_m;
	int a_count;
	int a_sync;
	int *a_rtvals;
	};
	#endif

	static int
	zfs_freebsd_putpages(struct vop_putpages_args *ap)
	{

	return (zfs_putpages(ap->a_vp, ap->a_m, ap->a_count, ap->a_sync,
	ap->a_rtvals));
	}

	#ifndef _SYS_SYSPROTO_H_
	struct vop_bmap_args {
	struct vnode *a_vp;
	daddr_t a_bn;
	struct bufobj **a_bop;
	daddr_t *a_bnp;
	int *a_runp;
	int *a_runb;
	};
	#endif

	static int
	zfs_freebsd_bmap(struct vop_bmap_args *ap)
	{

	if (ap->a_bop != NULL)
	*ap->a_bop = &ap->a_vp->v_bufobj;
	if (ap->a_bnp != NULL)
	*ap->a_bnp = ap->a_bn;
	if (ap->a_runp != NULL)
	*ap->a_runp = 0;
	if (ap->a_runb != NULL)
	*ap->a_runb = 0;

	return (0);
	}

	#ifndef _SYS_SYSPROTO_H_
	struct vop_open_args {
	struct vnode *a_vp;
	int a_mode;
	struct ucred *a_cred;
	struct thread *a_td;
	};
	#endif

	static int
	zfs_freebsd_open(struct vop_open_args *ap)
	{
	vnode_t *vp = ap->a_vp;
	znode_t *zp = VTOZ(vp);
	int error;

	error = zfs_open(&vp, ap->a_mode, ap->a_cred);
	if (error == 0)
	vnode_create_vobject(vp, zp->z_size, ap->a_td);
	return (error);
	}

	#ifndef _SYS_SYSPROTO_H_
	struct vop_close_args {
	struct vnode *a_vp;
	int a_fflag;
	struct ucred *a_cred;
	struct thread *a_td;
	};
	#endif

	static int
	zfs_freebsd_close(struct vop_close_args *ap)
	{

	return (zfs_close(ap->a_vp, ap->a_fflag, 1, 0, ap->a_cred));
	}

	#ifndef _SYS_SYSPROTO_H_
	struct vop_ioctl_args {
	struct vnode *a_vp;
	ulong_t a_command;
	caddr_t a_data;
	int a_fflag;
	struct ucred *cred;
	struct thread *td;
	};
	#endif

	static int
	zfs_freebsd_ioctl(struct vop_ioctl_args *ap)
	{

	return (zfs_ioctl(ap->a_vp, ap->a_command, (intptr_t)ap->a_data,
	ap->a_fflag, ap->a_cred, NULL));
	}

	static int
	ioflags(int ioflags)
	{
	int flags = 0;

	if (ioflags & IO_APPEND)
	flags \|= FAPPEND;
	if (ioflags & IO_NDELAY)
	flags \|= FNONBLOCK;
	if (ioflags & IO_SYNC)
	flags \|= (FSYNC \| FDSYNC \| FRSYNC);

	return (flags);
	}

	#ifndef _SYS_SYSPROTO_H_
	struct vop_read_args {
	struct vnode *a_vp;
	struct uio *a_uio;
	int a_ioflag;
	struct ucred *a_cred;
	};
	#endif

	static int
	zfs_freebsd_read(struct vop_read_args *ap)
	{
	zfs_uio_t uio;
	zfs_uio_init(&uio, ap->a_uio);
	return (zfs_read(VTOZ(ap->a_vp), &uio, ioflags(ap->a_ioflag),
	ap->a_cred));
	}

	#ifndef _SYS_SYSPROTO_H_
	struct vop_write_args {
	struct vnode *a_vp;
	struct uio *a_uio;
	int a_ioflag;
	struct ucred *a_cred;
	};
	#endif

	static int
	zfs_freebsd_write(struct vop_write_args *ap)
	{
	zfs_uio_t uio;
	zfs_uio_init(&uio, ap->a_uio);
	return (zfs_write(VTOZ(ap->a_vp), &uio, ioflags(ap->a_ioflag),
	ap->a_cred));
	}

	#if __FreeBSD_version >= 1300102
	/*
	* VOP_FPLOOKUP_VEXEC routines are subject to special circumstances, see
	* the comment above cache_fplookup for details.
	*/
	static int
	zfs_freebsd_fplookup_vexec(struct vop_fplookup_vexec_args *v)
	{
	vnode_t *vp;
	znode_t *zp;
	uint64_t pflags;

	vp = v->a_vp;
	zp = VTOZ_SMR(vp);
	if (__predict_false(zp == NULL))
	return (EAGAIN);
	pflags = atomic_load_64(&zp->z_pflags);
	if (pflags & ZFS_AV_QUARANTINED)
	return (EAGAIN);
	if (pflags & ZFS_XATTR)
	return (EAGAIN);
	if ((pflags & ZFS_NO_EXECS_DENIED) == 0)
	return (EAGAIN);
	return (0);
	}
	#endif

	+#if __FreeBSD_version >= 1300139
	static int
	zfs_freebsd_fplookup_symlink(struct vop_fplookup_symlink_args *v)
	{
	vnode_t *vp;
	znode_t *zp;
	char *target;

	vp = v->a_vp;
	zp = VTOZ_SMR(vp);
	if (__predict_false(zp == NULL)) {
	return (EAGAIN);
	}

	target = atomic_load_consume_ptr(&zp->z_cached_symlink);
	if (target == NULL) {
	return (EAGAIN);
	}
	return (cache_symlink_resolve(v->a_fpl, target, strlen(target)));
	}
	+#endif

	#ifndef _SYS_SYSPROTO_H_
	struct vop_access_args {
	struct vnode *a_vp;
	accmode_t a_accmode;
	struct ucred *a_cred;
	struct thread *a_td;
	};
	#endif

	static int
	zfs_freebsd_access(struct vop_access_args *ap)
	{
	vnode_t *vp = ap->a_vp;
	znode_t *zp = VTOZ(vp);
	accmode_t accmode;
	int error = 0;


	if (ap->a_accmode == VEXEC) {
	if (zfs_fastaccesschk_execute(zp, ap->a_cred) == 0)
	return (0);
	}

	/*
	* ZFS itself only knowns about VREAD, VWRITE, VEXEC and VAPPEND,
	*/
	accmode = ap->a_accmode & (VREAD\|VWRITE\|VEXEC\|VAPPEND);
	if (accmode != 0)
	error = zfs_access(zp, accmode, 0, ap->a_cred);

	/*
	* VADMIN has to be handled by vaccess().
	*/
	if (error == 0) {
	accmode = ap->a_accmode & ~(VREAD\|VWRITE\|VEXEC\|VAPPEND);
	if (accmode != 0) {
	#if __FreeBSD_version >= 1300105
	error = vaccess(vp->v_type, zp->z_mode, zp->z_uid,
	zp->z_gid, accmode, ap->a_cred);
	#else
	error = vaccess(vp->v_type, zp->z_mode, zp->z_uid,
	zp->z_gid, accmode, ap->a_cred, NULL);
	#endif
	}
	}

	/*
	* For VEXEC, ensure that at least one execute bit is set for
	* non-directories.
	*/
	if (error == 0 && (ap->a_accmode & VEXEC) != 0 && vp->v_type != VDIR &&
	(zp->z_mode & (S_IXUSR \| S_IXGRP \| S_IXOTH)) == 0) {
	error = EACCES;
	}

	return (error);
	}

	#ifndef _SYS_SYSPROTO_H_
	struct vop_lookup_args {
	struct vnode *a_dvp;
	struct vnode **a_vpp;
	struct componentname *a_cnp;
	};
	#endif

	static int
	zfs_freebsd_lookup(struct vop_lookup_args *ap, boolean_t cached)
	{
	struct componentname *cnp = ap->a_cnp;
	char nm[NAME_MAX + 1];

	ASSERT(cnp->cn_namelen < sizeof (nm));
	strlcpy(nm, cnp->cn_nameptr, MIN(cnp->cn_namelen + 1, sizeof (nm)));

	return (zfs_lookup(ap->a_dvp, nm, ap->a_vpp, cnp, cnp->cn_nameiop,
	cnp->cn_cred, cnp->cn_thread, 0, cached));
	}

	static int
	zfs_freebsd_cachedlookup(struct vop_cachedlookup_args *ap)
	{

	return (zfs_freebsd_lookup((struct vop_lookup_args *)ap, B_TRUE));
	}

	#ifndef _SYS_SYSPROTO_H_
	struct vop_lookup_args {
	struct vnode *a_dvp;
	struct vnode **a_vpp;
	struct componentname *a_cnp;
	};
	#endif

	static int
	zfs_cache_lookup(struct vop_lookup_args *ap)
	{
	zfsvfs_t *zfsvfs;

	zfsvfs = ap->a_dvp->v_mount->mnt_data;
	if (zfsvfs->z_use_namecache)
	return (vfs_cache_lookup(ap));
	else
	return (zfs_freebsd_lookup(ap, B_FALSE));
	}

	#ifndef _SYS_SYSPROTO_H_
	struct vop_create_args {
	struct vnode *a_dvp;
	struct vnode **a_vpp;
	struct componentname *a_cnp;
	struct vattr *a_vap;
	};
	#endif

	static int
	zfs_freebsd_create(struct vop_create_args *ap)
	{
	zfsvfs_t *zfsvfs;
	struct componentname *cnp = ap->a_cnp;
	vattr_t *vap = ap->a_vap;
	znode_t *zp = NULL;
	int rc, mode;

	ASSERT(cnp->cn_flags & SAVENAME);

	vattr_init_mask(vap);
	mode = vap->va_mode & ALLPERMS;
	zfsvfs = ap->a_dvp->v_mount->mnt_data;
	*ap->a_vpp = NULL;

	rc = zfs_create(VTOZ(ap->a_dvp), cnp->cn_nameptr, vap, !EXCL, mode,
	&zp, cnp->cn_cred, 0 /* flag /, NULL / vsecattr */);
	if (rc == 0)
	*ap->a_vpp = ZTOV(zp);
	if (zfsvfs->z_use_namecache &&
	rc == 0 && (cnp->cn_flags & MAKEENTRY) != 0)
	cache_enter(ap->a_dvp, *ap->a_vpp, cnp);

	return (rc);
	}

	#ifndef _SYS_SYSPROTO_H_
	struct vop_remove_args {
	struct vnode *a_dvp;
	struct vnode *a_vp;
	struct componentname *a_cnp;
	};
	#endif

	static int
	zfs_freebsd_remove(struct vop_remove_args *ap)
	{

	ASSERT(ap->a_cnp->cn_flags & SAVENAME);

	return (zfs_remove_(ap->a_dvp, ap->a_vp, ap->a_cnp->cn_nameptr,
	ap->a_cnp->cn_cred));
	}

	#ifndef _SYS_SYSPROTO_H_
	struct vop_mkdir_args {
	struct vnode *a_dvp;
	struct vnode **a_vpp;
	struct componentname *a_cnp;
	struct vattr *a_vap;
	};
	#endif

	static int
	zfs_freebsd_mkdir(struct vop_mkdir_args *ap)
	{
	vattr_t *vap = ap->a_vap;
	znode_t *zp = NULL;
	int rc;

	ASSERT(ap->a_cnp->cn_flags & SAVENAME);

	vattr_init_mask(vap);
	*ap->a_vpp = NULL;

	rc = zfs_mkdir(VTOZ(ap->a_dvp), ap->a_cnp->cn_nameptr, vap, &zp,
	ap->a_cnp->cn_cred, 0, NULL);

	if (rc == 0)
	*ap->a_vpp = ZTOV(zp);
	return (rc);
	}

	#ifndef _SYS_SYSPROTO_H_
	struct vop_rmdir_args {
	struct vnode *a_dvp;
	struct vnode *a_vp;
	struct componentname *a_cnp;
	};
	#endif

	static int
	zfs_freebsd_rmdir(struct vop_rmdir_args *ap)
	{
	struct componentname *cnp = ap->a_cnp;

	ASSERT(cnp->cn_flags & SAVENAME);

	return (zfs_rmdir_(ap->a_dvp, ap->a_vp, cnp->cn_nameptr, cnp->cn_cred));
	}

	#ifndef _SYS_SYSPROTO_H_
	struct vop_readdir_args {
	struct vnode *a_vp;
	struct uio *a_uio;
	struct ucred *a_cred;
	int *a_eofflag;
	int *a_ncookies;
	ulong_t **a_cookies;
	};
	#endif

	static int
	zfs_freebsd_readdir(struct vop_readdir_args *ap)
	{
	zfs_uio_t uio;
	zfs_uio_init(&uio, ap->a_uio);
	return (zfs_readdir(ap->a_vp, &uio, ap->a_cred, ap->a_eofflag,
	ap->a_ncookies, ap->a_cookies));
	}

	#ifndef _SYS_SYSPROTO_H_
	struct vop_fsync_args {
	struct vnode *a_vp;
	int a_waitfor;
	struct thread *a_td;
	};
	#endif

	static int
	zfs_freebsd_fsync(struct vop_fsync_args *ap)
	{

	vop_stdfsync(ap);
	return (zfs_fsync(VTOZ(ap->a_vp), 0, ap->a_td->td_ucred));
	}

	#ifndef _SYS_SYSPROTO_H_
	struct vop_getattr_args {
	struct vnode *a_vp;
	struct vattr *a_vap;
	struct ucred *a_cred;
	};
	#endif

	static int
	zfs_freebsd_getattr(struct vop_getattr_args *ap)
	{
	vattr_t *vap = ap->a_vap;
	xvattr_t xvap;
	ulong_t fflags = 0;
	int error;

	xva_init(&xvap);
	xvap.xva_vattr = *vap;
	xvap.xva_vattr.va_mask \|= AT_XVATTR;

	/* Convert chflags into ZFS-type flags. */
	/* XXX: what about SF_SETTABLE?. */
	XVA_SET_REQ(&xvap, XAT_IMMUTABLE);
	XVA_SET_REQ(&xvap, XAT_APPENDONLY);
	XVA_SET_REQ(&xvap, XAT_NOUNLINK);
	XVA_SET_REQ(&xvap, XAT_NODUMP);
	XVA_SET_REQ(&xvap, XAT_READONLY);
	XVA_SET_REQ(&xvap, XAT_ARCHIVE);
	XVA_SET_REQ(&xvap, XAT_SYSTEM);
	XVA_SET_REQ(&xvap, XAT_HIDDEN);
	XVA_SET_REQ(&xvap, XAT_REPARSE);
	XVA_SET_REQ(&xvap, XAT_OFFLINE);
	XVA_SET_REQ(&xvap, XAT_SPARSE);

	error = zfs_getattr(ap->a_vp, (vattr_t *)&xvap, 0, ap->a_cred);
	if (error != 0)
	return (error);

	/* Convert ZFS xattr into chflags. */
	#define FLAG_CHECK(fflag, xflag, xfield) do { \
	if (XVA_ISSET_RTN(&xvap, (xflag)) && (xfield) != 0) \
	fflags \|= (fflag); \
	} while (0)
	FLAG_CHECK(SF_IMMUTABLE, XAT_IMMUTABLE,
	xvap.xva_xoptattrs.xoa_immutable);
	FLAG_CHECK(SF_APPEND, XAT_APPENDONLY,
	xvap.xva_xoptattrs.xoa_appendonly);
	FLAG_CHECK(SF_NOUNLINK, XAT_NOUNLINK,
	xvap.xva_xoptattrs.xoa_nounlink);
	FLAG_CHECK(UF_ARCHIVE, XAT_ARCHIVE,
	xvap.xva_xoptattrs.xoa_archive);
	FLAG_CHECK(UF_NODUMP, XAT_NODUMP,
	xvap.xva_xoptattrs.xoa_nodump);
	FLAG_CHECK(UF_READONLY, XAT_READONLY,
	xvap.xva_xoptattrs.xoa_readonly);
	FLAG_CHECK(UF_SYSTEM, XAT_SYSTEM,
	xvap.xva_xoptattrs.xoa_system);
	FLAG_CHECK(UF_HIDDEN, XAT_HIDDEN,
	xvap.xva_xoptattrs.xoa_hidden);
	FLAG_CHECK(UF_REPARSE, XAT_REPARSE,
	xvap.xva_xoptattrs.xoa_reparse);
	FLAG_CHECK(UF_OFFLINE, XAT_OFFLINE,
	xvap.xva_xoptattrs.xoa_offline);
	FLAG_CHECK(UF_SPARSE, XAT_SPARSE,
	xvap.xva_xoptattrs.xoa_sparse);

	#undef FLAG_CHECK
	*vap = xvap.xva_vattr;
	vap->va_flags = fflags;
	return (0);
	}

	#ifndef _SYS_SYSPROTO_H_
	struct vop_setattr_args {
	struct vnode *a_vp;
	struct vattr *a_vap;
	struct ucred *a_cred;
	};
	#endif

	static int
	zfs_freebsd_setattr(struct vop_setattr_args *ap)
	{
	vnode_t *vp = ap->a_vp;
	vattr_t *vap = ap->a_vap;
	cred_t *cred = ap->a_cred;
	xvattr_t xvap;
	ulong_t fflags;
	uint64_t zflags;

	vattr_init_mask(vap);
	vap->va_mask &= ~AT_NOSET;

	xva_init(&xvap);
	xvap.xva_vattr = *vap;

	zflags = VTOZ(vp)->z_pflags;

	if (vap->va_flags != VNOVAL) {
	zfsvfs_t *zfsvfs = VTOZ(vp)->z_zfsvfs;
	int error;

	if (zfsvfs->z_use_fuids == B_FALSE)
	return (EOPNOTSUPP);

	fflags = vap->va_flags;
	/*
	* XXX KDM
	* We need to figure out whether it makes sense to allow
	* UF_REPARSE through, since we don't really have other
	* facilities to handle reparse points and zfs_setattr()
	* doesn't currently allow setting that attribute anyway.
	*/
	if ((fflags & ~(SF_IMMUTABLE\|SF_APPEND\|SF_NOUNLINK\|UF_ARCHIVE\|
	UF_NODUMP\|UF_SYSTEM\|UF_HIDDEN\|UF_READONLY\|UF_REPARSE\|
	UF_OFFLINE\|UF_SPARSE)) != 0)
	return (EOPNOTSUPP);
	/*
	* Unprivileged processes are not permitted to unset system
	* flags, or modify flags if any system flags are set.
	* Privileged non-jail processes may not modify system flags
	* if securelevel > 0 and any existing system flags are set.
	* Privileged jail processes behave like privileged non-jail
	* processes if the PR_ALLOW_CHFLAGS permission bit is set;
	* otherwise, they behave like unprivileged processes.
	*/
	if (secpolicy_fs_owner(vp->v_mount, cred) == 0 \|\|
	spl_priv_check_cred(cred, PRIV_VFS_SYSFLAGS) == 0) {
	if (zflags &
	(ZFS_IMMUTABLE \| ZFS_APPENDONLY \| ZFS_NOUNLINK)) {
	error = securelevel_gt(cred, 0);
	if (error != 0)
	return (error);
	}
	} else {
	/*
	* Callers may only modify the file flags on
	* objects they have VADMIN rights for.
	*/
	if ((error = VOP_ACCESS(vp, VADMIN, cred,
	curthread)) != 0)
	return (error);
	if (zflags &
	(ZFS_IMMUTABLE \| ZFS_APPENDONLY \|
	ZFS_NOUNLINK)) {
	return (EPERM);
	}
	if (fflags &
	(SF_IMMUTABLE \| SF_APPEND \| SF_NOUNLINK)) {
	return (EPERM);
	}
	}

	#define FLAG_CHANGE(fflag, zflag, xflag, xfield) do { \
	if (((fflags & (fflag)) && !(zflags & (zflag))) \|\| \
	((zflags & (zflag)) && !(fflags & (fflag)))) { \
	XVA_SET_REQ(&xvap, (xflag)); \
	(xfield) = ((fflags & (fflag)) != 0); \
	} \
	} while (0)
	/* Convert chflags into ZFS-type flags. */
	/* XXX: what about SF_SETTABLE?. */
	FLAG_CHANGE(SF_IMMUTABLE, ZFS_IMMUTABLE, XAT_IMMUTABLE,
	xvap.xva_xoptattrs.xoa_immutable);
	FLAG_CHANGE(SF_APPEND, ZFS_APPENDONLY, XAT_APPENDONLY,
	xvap.xva_xoptattrs.xoa_appendonly);
	FLAG_CHANGE(SF_NOUNLINK, ZFS_NOUNLINK, XAT_NOUNLINK,
	xvap.xva_xoptattrs.xoa_nounlink);
	FLAG_CHANGE(UF_ARCHIVE, ZFS_ARCHIVE, XAT_ARCHIVE,
	xvap.xva_xoptattrs.xoa_archive);
	FLAG_CHANGE(UF_NODUMP, ZFS_NODUMP, XAT_NODUMP,
	xvap.xva_xoptattrs.xoa_nodump);
	FLAG_CHANGE(UF_READONLY, ZFS_READONLY, XAT_READONLY,
	xvap.xva_xoptattrs.xoa_readonly);
	FLAG_CHANGE(UF_SYSTEM, ZFS_SYSTEM, XAT_SYSTEM,
	xvap.xva_xoptattrs.xoa_system);
	FLAG_CHANGE(UF_HIDDEN, ZFS_HIDDEN, XAT_HIDDEN,
	xvap.xva_xoptattrs.xoa_hidden);
	FLAG_CHANGE(UF_REPARSE, ZFS_REPARSE, XAT_REPARSE,
	xvap.xva_xoptattrs.xoa_reparse);
	FLAG_CHANGE(UF_OFFLINE, ZFS_OFFLINE, XAT_OFFLINE,
	xvap.xva_xoptattrs.xoa_offline);
	FLAG_CHANGE(UF_SPARSE, ZFS_SPARSE, XAT_SPARSE,
	xvap.xva_xoptattrs.xoa_sparse);
	#undef FLAG_CHANGE
	}
	if (vap->va_birthtime.tv_sec != VNOVAL) {
	xvap.xva_vattr.va_mask \|= AT_XVATTR;
	XVA_SET_REQ(&xvap, XAT_CREATETIME);
	}
	return (zfs_setattr(VTOZ(vp), (vattr_t *)&xvap, 0, cred));
	}

	#ifndef _SYS_SYSPROTO_H_
	struct vop_rename_args {
	struct vnode *a_fdvp;
	struct vnode *a_fvp;
	struct componentname *a_fcnp;
	struct vnode *a_tdvp;
	struct vnode *a_tvp;
	struct componentname *a_tcnp;
	};
	#endif

	static int
	zfs_freebsd_rename(struct vop_rename_args *ap)
	{
	vnode_t *fdvp = ap->a_fdvp;
	vnode_t *fvp = ap->a_fvp;
	vnode_t *tdvp = ap->a_tdvp;
	vnode_t *tvp = ap->a_tvp;
	int error;

	ASSERT(ap->a_fcnp->cn_flags & (SAVENAME\|SAVESTART));
	ASSERT(ap->a_tcnp->cn_flags & (SAVENAME\|SAVESTART));

	error = zfs_rename_(fdvp, &fvp, ap->a_fcnp, tdvp, &tvp,
	ap->a_tcnp, ap->a_fcnp->cn_cred, 1);

	vrele(fdvp);
	vrele(fvp);
	vrele(tdvp);
	if (tvp != NULL)
	vrele(tvp);

	return (error);
	}

	#ifndef _SYS_SYSPROTO_H_
	struct vop_symlink_args {
	struct vnode *a_dvp;
	struct vnode **a_vpp;
	struct componentname *a_cnp;
	struct vattr *a_vap;
	char *a_target;
	};
	#endif

	static int
	zfs_freebsd_symlink(struct vop_symlink_args *ap)
	{
	struct componentname *cnp = ap->a_cnp;
	vattr_t *vap = ap->a_vap;
	znode_t *zp = NULL;
	+#if __FreeBSD_version >= 1300139
	char *symlink;
	size_t symlink_len;
	+#endif
	int rc;

	ASSERT(cnp->cn_flags & SAVENAME);

	vap->va_type = VLNK; /* FreeBSD: Syscall only sets va_mode. */
	vattr_init_mask(vap);
	*ap->a_vpp = NULL;

	rc = zfs_symlink(VTOZ(ap->a_dvp), cnp->cn_nameptr, vap,
	ap->a_target, &zp, cnp->cn_cred, 0 /* flags */);
	if (rc == 0) {
	*ap->a_vpp = ZTOV(zp);
	ASSERT_VOP_ELOCKED(ZTOV(zp), __func__);
	+#if __FreeBSD_version >= 1300139
	MPASS(zp->z_cached_symlink == NULL);
	symlink_len = strlen(ap->a_target);
	symlink = cache_symlink_alloc(symlink_len + 1, M_WAITOK);
	if (symlink != NULL) {
	memcpy(symlink, ap->a_target, symlink_len);
	symlink[symlink_len] = '\0';
	atomic_store_rel_ptr((uintptr_t *)&zp->z_cached_symlink,
	(uintptr_t)symlink);
	}
	+#endif
	}
	return (rc);
	}

	#ifndef _SYS_SYSPROTO_H_
	struct vop_readlink_args {
	struct vnode *a_vp;
	struct uio *a_uio;
	struct ucred *a_cred;
	};
	#endif

	static int
	zfs_freebsd_readlink(struct vop_readlink_args *ap)
	{
	zfs_uio_t uio;
	+ int error;
	+#if __FreeBSD_version >= 1300139
	znode_t *zp = VTOZ(ap->a_vp);
	char symlink, base;
	size_t symlink_len;
	- int error;
	bool trycache;
	+#endif

	zfs_uio_init(&uio, ap->a_uio);
	+#if __FreeBSD_version >= 1300139
	trycache = false;
	if (zfs_uio_segflg(&uio) == UIO_SYSSPACE &&
	zfs_uio_iovcnt(&uio) == 1) {
	base = zfs_uio_iovbase(&uio, 0);
	symlink_len = zfs_uio_iovlen(&uio, 0);
	trycache = true;
	}
	+#endif
	error = zfs_readlink(ap->a_vp, &uio, ap->a_cred, NULL);
	+#if __FreeBSD_version >= 1300139
	if (atomic_load_ptr(&zp->z_cached_symlink) != NULL \|\|
	error != 0 \|\| !trycache) {
	return (error);
	}
	symlink_len -= zfs_uio_resid(&uio);
	symlink = cache_symlink_alloc(symlink_len + 1, M_WAITOK);
	if (symlink != NULL) {
	memcpy(symlink, base, symlink_len);
	symlink[symlink_len] = '\0';
	if (!atomic_cmpset_rel_ptr((uintptr_t *)&zp->z_cached_symlink,
	(uintptr_t)NULL, (uintptr_t)symlink)) {
	cache_symlink_free(symlink, symlink_len + 1);
	}
	}
	+#endif
	return (error);
	}

	#ifndef _SYS_SYSPROTO_H_
	struct vop_link_args {
	struct vnode *a_tdvp;
	struct vnode *a_vp;
	struct componentname *a_cnp;
	};
	#endif

	static int
	zfs_freebsd_link(struct vop_link_args *ap)
	{
	struct componentname *cnp = ap->a_cnp;
	vnode_t *vp = ap->a_vp;
	vnode_t *tdvp = ap->a_tdvp;

	if (tdvp->v_mount != vp->v_mount)
	return (EXDEV);

	ASSERT(cnp->cn_flags & SAVENAME);

	return (zfs_link(VTOZ(tdvp), VTOZ(vp),
	cnp->cn_nameptr, cnp->cn_cred, 0));
	}

	#ifndef _SYS_SYSPROTO_H_
	struct vop_inactive_args {
	struct vnode *a_vp;
	struct thread *a_td;
	};
	#endif

	static int
	zfs_freebsd_inactive(struct vop_inactive_args *ap)
	{
	vnode_t *vp = ap->a_vp;

	#if __FreeBSD_version >= 1300123
	zfs_inactive(vp, curthread->td_ucred, NULL);
	#else
	zfs_inactive(vp, ap->a_td->td_ucred, NULL);
	#endif
	return (0);
	}

	#if __FreeBSD_version >= 1300042
	#ifndef _SYS_SYSPROTO_H_
	struct vop_need_inactive_args {
	struct vnode *a_vp;
	struct thread *a_td;
	};
	#endif

	static int
	zfs_freebsd_need_inactive(struct vop_need_inactive_args *ap)
	{
	vnode_t *vp = ap->a_vp;
	znode_t *zp = VTOZ(vp);
	zfsvfs_t *zfsvfs = zp->z_zfsvfs;
	int need;

	if (vn_need_pageq_flush(vp))
	return (1);

	if (!ZFS_TEARDOWN_INACTIVE_TRY_ENTER_READ(zfsvfs))
	return (1);
	need = (zp->z_sa_hdl == NULL \|\| zp->z_unlinked \|\| zp->z_atime_dirty);
	ZFS_TEARDOWN_INACTIVE_EXIT_READ(zfsvfs);

	return (need);
	}
	#endif

	#ifndef _SYS_SYSPROTO_H_
	struct vop_reclaim_args {
	struct vnode *a_vp;
	struct thread *a_td;
	};
	#endif

	static int
	zfs_freebsd_reclaim(struct vop_reclaim_args *ap)
	{
	vnode_t *vp = ap->a_vp;
	znode_t *zp = VTOZ(vp);
	zfsvfs_t *zfsvfs = zp->z_zfsvfs;

	ASSERT(zp != NULL);

	#if __FreeBSD_version < 1300042
	/* Destroy the vm object and flush associated pages. */
	vnode_destroy_vobject(vp);
	#endif
	/*
	* z_teardown_inactive_lock protects from a race with
	* zfs_znode_dmu_fini in zfsvfs_teardown during
	* force unmount.
	*/
	ZFS_TEARDOWN_INACTIVE_ENTER_READ(zfsvfs);
	if (zp->z_sa_hdl == NULL)
	zfs_znode_free(zp);
	else
	zfs_zinactive(zp);
	ZFS_TEARDOWN_INACTIVE_EXIT_READ(zfsvfs);

	vp->v_data = NULL;
	return (0);
	}

	#ifndef _SYS_SYSPROTO_H_
	struct vop_fid_args {
	struct vnode *a_vp;
	struct fid *a_fid;
	};
	#endif

	static int
	zfs_freebsd_fid(struct vop_fid_args *ap)
	{

	return (zfs_fid(ap->a_vp, (void *)ap->a_fid, NULL));
	}


	#ifndef _SYS_SYSPROTO_H_
	struct vop_pathconf_args {
	struct vnode *a_vp;
	int a_name;
	register_t *a_retval;
	} *ap;
	#endif

	static int
	zfs_freebsd_pathconf(struct vop_pathconf_args *ap)
	{
	ulong_t val;
	int error;

	error = zfs_pathconf(ap->a_vp, ap->a_name, &val,
	curthread->td_ucred, NULL);
	if (error == 0) {
	*ap->a_retval = val;
	return (error);
	}
	if (error != EOPNOTSUPP)
	return (error);

	switch (ap->a_name) {
	case _PC_NAME_MAX:
	*ap->a_retval = NAME_MAX;
	return (0);
	case _PC_PIPE_BUF:
	if (ap->a_vp->v_type == VDIR \|\| ap->a_vp->v_type == VFIFO) {
	*ap->a_retval = PIPE_BUF;
	return (0);
	}
	return (EINVAL);
	default:
	return (vop_stdpathconf(ap));
	}
	}

	/*
	* FreeBSD's extended attributes namespace defines file name prefix for ZFS'
	* extended attribute name:
	*
	* NAMESPACE PREFIX
	* system freebsd:system:
	* user (none, can be used to access ZFS fsattr(5) attributes
	* created on Solaris)
	*/
	static int
	zfs_create_attrname(int attrnamespace, const char name, char attrname,
	size_t size)
	{
	const char namespace, prefix, *suffix;

	/* We don't allow '/' character in attribute name. */
	if (strchr(name, '/') != NULL)
	- return (EINVAL);
	+ return (SET_ERROR(EINVAL));
	/* We don't allow attribute names that start with "freebsd:" string. */
	if (strncmp(name, "freebsd:", 8) == 0)
	- return (EINVAL);
	+ return (SET_ERROR(EINVAL));

	bzero(attrname, size);

	switch (attrnamespace) {
	case EXTATTR_NAMESPACE_USER:
	#if 0
	prefix = "freebsd:";
	namespace = EXTATTR_NAMESPACE_USER_STRING;
	suffix = ":";
	#else
	/*
	* This is the default namespace by which we can access all
	* attributes created on Solaris.
	*/
	prefix = namespace = suffix = "";
	#endif
	break;
	case EXTATTR_NAMESPACE_SYSTEM:
	prefix = "freebsd:";
	namespace = EXTATTR_NAMESPACE_SYSTEM_STRING;
	suffix = ":";
	break;
	case EXTATTR_NAMESPACE_EMPTY:
	default:
	- return (EINVAL);
	+ return (SET_ERROR(EINVAL));
	}
	if (snprintf(attrname, size, "%s%s%s%s", prefix, namespace, suffix,
	name) >= size) {
	- return (ENAMETOOLONG);
	+ return (SET_ERROR(ENAMETOOLONG));
	}
	return (0);
	}

	#ifndef _SYS_SYSPROTO_H_
	struct vop_getextattr {
	IN struct vnode *a_vp;
	IN int a_attrnamespace;
	IN const char *a_name;
	INOUT struct uio *a_uio;
	OUT size_t *a_size;
	IN struct ucred *a_cred;
	IN struct thread *a_td;
	};
	#endif

	/*
	* Vnode operating to retrieve a named extended attribute.
	*/
	static int
	zfs_getextattr(struct vop_getextattr_args *ap)
	{
	zfsvfs_t *zfsvfs = VTOZ(ap->a_vp)->z_zfsvfs;
	struct thread *td = ap->a_td;
	struct nameidata nd;
	char attrname[255];
	struct vattr va;
	vnode_t xvp = NULL, vp;
	int error, flags;

	/*
	* If the xattr property is off, refuse the request.
	*/
	if (!(zfsvfs->z_flags & ZSB_XATTR)) {
	return (SET_ERROR(EOPNOTSUPP));
	}

	error = extattr_check_cred(ap->a_vp, ap->a_attrnamespace,
	ap->a_cred, ap->a_td, VREAD);
	if (error != 0)
	return (error);

	error = zfs_create_attrname(ap->a_attrnamespace, ap->a_name, attrname,
	sizeof (attrname));
	if (error != 0)
	return (error);

	ZFS_ENTER(zfsvfs);

	error = zfs_lookup(ap->a_vp, NULL, &xvp, NULL, 0, ap->a_cred, td,
	LOOKUP_XATTR, B_FALSE);
	if (error != 0) {
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	flags = FREAD;
	NDINIT_ATVP(&nd, LOOKUP, NOFOLLOW, UIO_SYSSPACE, attrname,
	xvp, td);
	error = vn_open_cred(&nd, &flags, 0, VN_OPEN_INVFS, ap->a_cred, NULL);
	vp = nd.ni_vp;
	NDFREE(&nd, NDF_ONLY_PNBUF);
	if (error != 0) {
	ZFS_EXIT(zfsvfs);
	if (error == ENOENT)
	error = ENOATTR;
	return (error);
	}

	if (ap->a_size != NULL) {
	error = VOP_GETATTR(vp, &va, ap->a_cred);
	if (error == 0)
	*ap->a_size = (size_t)va.va_size;
	} else if (ap->a_uio != NULL)
	error = VOP_READ(vp, ap->a_uio, IO_UNIT, ap->a_cred);

	VOP_UNLOCK1(vp);
	vn_close(vp, flags, ap->a_cred, td);
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	#ifndef _SYS_SYSPROTO_H_
	struct vop_deleteextattr {
	IN struct vnode *a_vp;
	IN int a_attrnamespace;
	IN const char *a_name;
	IN struct ucred *a_cred;
	IN struct thread *a_td;
	};
	#endif

	/*
	* Vnode operation to remove a named attribute.
	*/
	static int
	zfs_deleteextattr(struct vop_deleteextattr_args *ap)
	{
	zfsvfs_t *zfsvfs = VTOZ(ap->a_vp)->z_zfsvfs;
	struct thread *td = ap->a_td;
	struct nameidata nd;
	char attrname[255];
	vnode_t xvp = NULL, vp;
	int error;

	/*
	* If the xattr property is off, refuse the request.
	*/
	if (!(zfsvfs->z_flags & ZSB_XATTR)) {
	return (SET_ERROR(EOPNOTSUPP));
	}

	error = extattr_check_cred(ap->a_vp, ap->a_attrnamespace,
	ap->a_cred, ap->a_td, VWRITE);
	if (error != 0)
	return (error);

	error = zfs_create_attrname(ap->a_attrnamespace, ap->a_name, attrname,
	sizeof (attrname));
	if (error != 0)
	return (error);

	ZFS_ENTER(zfsvfs);

	error = zfs_lookup(ap->a_vp, NULL, &xvp, NULL, 0, ap->a_cred, td,
	LOOKUP_XATTR, B_FALSE);
	if (error != 0) {
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	NDINIT_ATVP(&nd, DELETE, NOFOLLOW \| LOCKPARENT \| LOCKLEAF,
	UIO_SYSSPACE, attrname, xvp, td);
	error = namei(&nd);
	vp = nd.ni_vp;
	if (error != 0) {
	ZFS_EXIT(zfsvfs);
	NDFREE(&nd, NDF_ONLY_PNBUF);
	if (error == ENOENT)
	error = ENOATTR;
	return (error);
	}

	error = VOP_REMOVE(nd.ni_dvp, vp, &nd.ni_cnd);
	NDFREE(&nd, NDF_ONLY_PNBUF);

	vput(nd.ni_dvp);
	if (vp == nd.ni_dvp)
	vrele(vp);
	else
	vput(vp);
	ZFS_EXIT(zfsvfs);

	return (error);
	}

	#ifndef _SYS_SYSPROTO_H_
	struct vop_setextattr {
	IN struct vnode *a_vp;
	IN int a_attrnamespace;
	IN const char *a_name;
	INOUT struct uio *a_uio;
	IN struct ucred *a_cred;
	IN struct thread *a_td;
	};
	#endif

	/*
	* Vnode operation to set a named attribute.
	*/
	static int
	zfs_setextattr(struct vop_setextattr_args *ap)
	{
	zfsvfs_t *zfsvfs = VTOZ(ap->a_vp)->z_zfsvfs;
	struct thread *td = ap->a_td;
	struct nameidata nd;
	char attrname[255];
	struct vattr va;
	vnode_t xvp = NULL, vp;
	int error, flags;

	/*
	* If the xattr property is off, refuse the request.
	*/
	if (!(zfsvfs->z_flags & ZSB_XATTR)) {
	return (SET_ERROR(EOPNOTSUPP));
	}

	error = extattr_check_cred(ap->a_vp, ap->a_attrnamespace,
	ap->a_cred, ap->a_td, VWRITE);
	if (error != 0)
	return (error);
	error = zfs_create_attrname(ap->a_attrnamespace, ap->a_name, attrname,
	sizeof (attrname));
	if (error != 0)
	return (error);

	ZFS_ENTER(zfsvfs);

	error = zfs_lookup(ap->a_vp, NULL, &xvp, NULL, 0, ap->a_cred, td,
	LOOKUP_XATTR \| CREATE_XATTR_DIR, B_FALSE);
	if (error != 0) {
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	flags = FFLAGS(O_WRONLY \| O_CREAT);
	NDINIT_ATVP(&nd, LOOKUP, NOFOLLOW, UIO_SYSSPACE, attrname,
	xvp, td);
	error = vn_open_cred(&nd, &flags, 0600, VN_OPEN_INVFS, ap->a_cred,
	NULL);
	vp = nd.ni_vp;
	NDFREE(&nd, NDF_ONLY_PNBUF);
	if (error != 0) {
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	VATTR_NULL(&va);
	va.va_size = 0;
	error = VOP_SETATTR(vp, &va, ap->a_cred);
	if (error == 0)
	VOP_WRITE(vp, ap->a_uio, IO_UNIT, ap->a_cred);

	VOP_UNLOCK1(vp);
	vn_close(vp, flags, ap->a_cred, td);
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	#ifndef _SYS_SYSPROTO_H_
	struct vop_listextattr {
	IN struct vnode *a_vp;
	IN int a_attrnamespace;
	INOUT struct uio *a_uio;
	OUT size_t *a_size;
	IN struct ucred *a_cred;
	IN struct thread *a_td;
	};
	#endif

	/*
	* Vnode operation to retrieve extended attributes on a vnode.
	*/
	static int
	zfs_listextattr(struct vop_listextattr_args *ap)
	{
	zfsvfs_t *zfsvfs = VTOZ(ap->a_vp)->z_zfsvfs;
	struct thread *td = ap->a_td;
	struct nameidata nd;
	char attrprefix[16];
	uint8_t dirbuf[sizeof (struct dirent)];
	struct dirent *dp;
	struct iovec aiov;
	struct uio auio;
	size_t *sizep = ap->a_size;
	size_t plen;
	vnode_t xvp = NULL, vp;
	int done, error, eof, pos;
	zfs_uio_t uio;

	zfs_uio_init(&uio, ap->a_uio);

	/*
	* If the xattr property is off, refuse the request.
	*/
	if (!(zfsvfs->z_flags & ZSB_XATTR)) {
	return (SET_ERROR(EOPNOTSUPP));
	}

	error = extattr_check_cred(ap->a_vp, ap->a_attrnamespace,
	ap->a_cred, ap->a_td, VREAD);
	if (error != 0)
	return (error);

	error = zfs_create_attrname(ap->a_attrnamespace, "", attrprefix,
	sizeof (attrprefix));
	if (error != 0)
	return (error);
	plen = strlen(attrprefix);

	ZFS_ENTER(zfsvfs);

	if (sizep != NULL)
	*sizep = 0;

	error = zfs_lookup(ap->a_vp, NULL, &xvp, NULL, 0, ap->a_cred, td,
	LOOKUP_XATTR, B_FALSE);
	if (error != 0) {
	ZFS_EXIT(zfsvfs);
	/*
	* ENOATTR means that the EA directory does not yet exist,
	* i.e. there are no extended attributes there.
	*/
	if (error == ENOATTR)
	error = 0;
	return (error);
	}

	NDINIT_ATVP(&nd, LOOKUP, NOFOLLOW \| LOCKLEAF \| LOCKSHARED,
	UIO_SYSSPACE, ".", xvp, td);
	error = namei(&nd);
	vp = nd.ni_vp;
	NDFREE(&nd, NDF_ONLY_PNBUF);
	if (error != 0) {
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	auio.uio_iov = &aiov;
	auio.uio_iovcnt = 1;
	auio.uio_segflg = UIO_SYSSPACE;
	auio.uio_td = td;
	auio.uio_rw = UIO_READ;
	auio.uio_offset = 0;

	do {
	uint8_t nlen;

	aiov.iov_base = (void *)dirbuf;
	aiov.iov_len = sizeof (dirbuf);
	auio.uio_resid = sizeof (dirbuf);
	error = VOP_READDIR(vp, &auio, ap->a_cred, &eof, NULL, NULL);
	done = sizeof (dirbuf) - auio.uio_resid;
	if (error != 0)
	break;
	for (pos = 0; pos < done; ) {
	dp = (struct dirent *)(dirbuf + pos);
	pos += dp->d_reclen;
	/*
	* XXX: Temporarily we also accept DT_UNKNOWN, as this
	* is what we get when attribute was created on Solaris.
	*/
	if (dp->d_type != DT_REG && dp->d_type != DT_UNKNOWN)
	continue;
	if (plen == 0 &&
	strncmp(dp->d_name, "freebsd:", 8) == 0)
	continue;
	else if (strncmp(dp->d_name, attrprefix, plen) != 0)
	continue;
	nlen = dp->d_namlen - plen;
	if (sizep != NULL)
	*sizep += 1 + nlen;
	else if (GET_UIO_STRUCT(&uio) != NULL) {
	/*
	* Format of extattr name entry is one byte for
	* length and the rest for name.
	*/
	error = zfs_uiomove(&nlen, 1, zfs_uio_rw(&uio),
	&uio);
	if (error == 0) {
	error = zfs_uiomove(dp->d_name + plen,
	nlen, zfs_uio_rw(&uio), &uio);
	}
	if (error != 0)
	break;
	}
	}
	} while (!eof && error == 0);

	vput(vp);
	ZFS_EXIT(zfsvfs);

	return (error);
	}

	#ifndef _SYS_SYSPROTO_H_
	struct vop_getacl_args {
	struct vnode *vp;
	acl_type_t type;
	struct acl *aclp;
	struct ucred *cred;
	struct thread *td;
	};
	#endif

	static int
	zfs_freebsd_getacl(struct vop_getacl_args *ap)
	{
	int error;
	vsecattr_t vsecattr;

	if (ap->a_type != ACL_TYPE_NFS4)
	return (EINVAL);

	vsecattr.vsa_mask = VSA_ACE \| VSA_ACECNT;
	if ((error = zfs_getsecattr(VTOZ(ap->a_vp),
	&vsecattr, 0, ap->a_cred)))
	return (error);

	error = acl_from_aces(ap->a_aclp, vsecattr.vsa_aclentp,
	vsecattr.vsa_aclcnt);
	if (vsecattr.vsa_aclentp != NULL)
	kmem_free(vsecattr.vsa_aclentp, vsecattr.vsa_aclentsz);

	return (error);
	}

	#ifndef _SYS_SYSPROTO_H_
	struct vop_setacl_args {
	struct vnode *vp;
	acl_type_t type;
	struct acl *aclp;
	struct ucred *cred;
	struct thread *td;
	};
	#endif

	static int
	zfs_freebsd_setacl(struct vop_setacl_args *ap)
	{
	int error;
	vsecattr_t vsecattr;
	int aclbsize; /* size of acl list in bytes */
	aclent_t *aaclp;

	if (ap->a_type != ACL_TYPE_NFS4)
	return (EINVAL);

	if (ap->a_aclp == NULL)
	return (EINVAL);

	if (ap->a_aclp->acl_cnt < 1 \|\| ap->a_aclp->acl_cnt > MAX_ACL_ENTRIES)
	return (EINVAL);

	/*
	* With NFSv4 ACLs, chmod(2) may need to add additional entries,
	* splitting every entry into two and appending "canonical six"
	* entries at the end. Don't allow for setting an ACL that would
	* cause chmod(2) to run out of ACL entries.
	*/
	if (ap->a_aclp->acl_cnt * 2 + 6 > ACL_MAX_ENTRIES)
	return (ENOSPC);

	error = acl_nfs4_check(ap->a_aclp, ap->a_vp->v_type == VDIR);
	if (error != 0)
	return (error);

	vsecattr.vsa_mask = VSA_ACE;
	aclbsize = ap->a_aclp->acl_cnt * sizeof (ace_t);
	vsecattr.vsa_aclentp = kmem_alloc(aclbsize, KM_SLEEP);
	aaclp = vsecattr.vsa_aclentp;
	vsecattr.vsa_aclentsz = aclbsize;

	aces_from_acl(vsecattr.vsa_aclentp, &vsecattr.vsa_aclcnt, ap->a_aclp);
	error = zfs_setsecattr(VTOZ(ap->a_vp), &vsecattr, 0, ap->a_cred);
	kmem_free(aaclp, aclbsize);

	return (error);
	}

	#ifndef _SYS_SYSPROTO_H_
	struct vop_aclcheck_args {
	struct vnode *vp;
	acl_type_t type;
	struct acl *aclp;
	struct ucred *cred;
	struct thread *td;
	};
	#endif

	static int
	zfs_freebsd_aclcheck(struct vop_aclcheck_args *ap)
	{

	return (EOPNOTSUPP);
	}

	static int
	zfs_vptocnp(struct vop_vptocnp_args *ap)
	{
	vnode_t *covered_vp;
	vnode_t *vp = ap->a_vp;
	zfsvfs_t *zfsvfs = vp->v_vfsp->vfs_data;
	znode_t *zp = VTOZ(vp);
	int ltype;
	int error;

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zp);

	/*
	* If we are a snapshot mounted under .zfs, run the operation
	* on the covered vnode.
	*/
	if (zp->z_id != zfsvfs->z_root \|\| zfsvfs->z_parent == zfsvfs) {
	char name[MAXNAMLEN + 1];
	znode_t *dzp;
	size_t len;

	error = zfs_znode_parent_and_name(zp, &dzp, name);
	if (error == 0) {
	len = strlen(name);
	if (*ap->a_buflen < len)
	error = SET_ERROR(ENOMEM);
	}
	if (error == 0) {
	*ap->a_buflen -= len;
	bcopy(name, ap->a_buf + *ap->a_buflen, len);
	*ap->a_vpp = ZTOV(dzp);
	}
	ZFS_EXIT(zfsvfs);
	return (error);
	}
	ZFS_EXIT(zfsvfs);

	covered_vp = vp->v_mount->mnt_vnodecovered;
	#if __FreeBSD_version >= 1300045
	enum vgetstate vs = vget_prep(covered_vp);
	#else
	vhold(covered_vp);
	#endif
	ltype = VOP_ISLOCKED(vp);
	VOP_UNLOCK1(vp);
	#if __FreeBSD_version >= 1300045
	error = vget_finish(covered_vp, LK_SHARED, vs);
	#else
	error = vget(covered_vp, LK_SHARED \| LK_VNHELD, curthread);
	#endif
	if (error == 0) {
	#if __FreeBSD_version >= 1300123
	error = VOP_VPTOCNP(covered_vp, ap->a_vpp, ap->a_buf,
	ap->a_buflen);
	#else
	error = VOP_VPTOCNP(covered_vp, ap->a_vpp, ap->a_cred,
	ap->a_buf, ap->a_buflen);
	#endif
	vput(covered_vp);
	}
	vn_lock(vp, ltype \| LK_RETRY);
	if (VN_IS_DOOMED(vp))
	error = SET_ERROR(ENOENT);
	return (error);
	}

	struct vop_vector zfs_vnodeops;
	struct vop_vector zfs_fifoops;
	struct vop_vector zfs_shareops;

	struct vop_vector zfs_vnodeops = {
	.vop_default = &default_vnodeops,
	.vop_inactive = zfs_freebsd_inactive,
	#if __FreeBSD_version >= 1300042
	.vop_need_inactive = zfs_freebsd_need_inactive,
	#endif
	.vop_reclaim = zfs_freebsd_reclaim,
	#if __FreeBSD_version >= 1300102
	.vop_fplookup_vexec = zfs_freebsd_fplookup_vexec,
	#endif
	+#if __FreeBSD_version >= 1300139
	.vop_fplookup_symlink = zfs_freebsd_fplookup_symlink,
	+#endif
	.vop_access = zfs_freebsd_access,
	.vop_allocate = VOP_EINVAL,
	.vop_lookup = zfs_cache_lookup,
	.vop_cachedlookup = zfs_freebsd_cachedlookup,
	.vop_getattr = zfs_freebsd_getattr,
	.vop_setattr = zfs_freebsd_setattr,
	.vop_create = zfs_freebsd_create,
	.vop_mknod = (vop_mknod_t *)zfs_freebsd_create,
	.vop_mkdir = zfs_freebsd_mkdir,
	.vop_readdir = zfs_freebsd_readdir,
	.vop_fsync = zfs_freebsd_fsync,
	.vop_open = zfs_freebsd_open,
	.vop_close = zfs_freebsd_close,
	.vop_rmdir = zfs_freebsd_rmdir,
	.vop_ioctl = zfs_freebsd_ioctl,
	.vop_link = zfs_freebsd_link,
	.vop_symlink = zfs_freebsd_symlink,
	.vop_readlink = zfs_freebsd_readlink,
	.vop_read = zfs_freebsd_read,
	.vop_write = zfs_freebsd_write,
	.vop_remove = zfs_freebsd_remove,
	.vop_rename = zfs_freebsd_rename,
	.vop_pathconf = zfs_freebsd_pathconf,
	.vop_bmap = zfs_freebsd_bmap,
	.vop_fid = zfs_freebsd_fid,
	.vop_getextattr = zfs_getextattr,
	.vop_deleteextattr = zfs_deleteextattr,
	.vop_setextattr = zfs_setextattr,
	.vop_listextattr = zfs_listextattr,
	.vop_getacl = zfs_freebsd_getacl,
	.vop_setacl = zfs_freebsd_setacl,
	.vop_aclcheck = zfs_freebsd_aclcheck,
	.vop_getpages = zfs_freebsd_getpages,
	.vop_putpages = zfs_freebsd_putpages,
	.vop_vptocnp = zfs_vptocnp,
	#if __FreeBSD_version >= 1300064
	.vop_lock1 = vop_lock,
	.vop_unlock = vop_unlock,
	.vop_islocked = vop_islocked,
	#endif
	};
	VFS_VOP_VECTOR_REGISTER(zfs_vnodeops);

	struct vop_vector zfs_fifoops = {
	.vop_default = &fifo_specops,
	.vop_fsync = zfs_freebsd_fsync,
	#if __FreeBSD_version >= 1300102
	.vop_fplookup_vexec = zfs_freebsd_fplookup_vexec,
	#endif
	+#if __FreeBSD_version >= 1300139
	.vop_fplookup_symlink = zfs_freebsd_fplookup_symlink,
	+#endif
	.vop_access = zfs_freebsd_access,
	.vop_getattr = zfs_freebsd_getattr,
	.vop_inactive = zfs_freebsd_inactive,
	.vop_read = VOP_PANIC,
	.vop_reclaim = zfs_freebsd_reclaim,
	.vop_setattr = zfs_freebsd_setattr,
	.vop_write = VOP_PANIC,
	.vop_pathconf = zfs_freebsd_pathconf,
	.vop_fid = zfs_freebsd_fid,
	.vop_getacl = zfs_freebsd_getacl,
	.vop_setacl = zfs_freebsd_setacl,
	.vop_aclcheck = zfs_freebsd_aclcheck,
	};
	VFS_VOP_VECTOR_REGISTER(zfs_fifoops);

	/*
	* special share hidden files vnode operations template
	*/
	struct vop_vector zfs_shareops = {
	.vop_default = &default_vnodeops,
	#if __FreeBSD_version >= 1300121
	.vop_fplookup_vexec = VOP_EAGAIN,
	#endif
	+#if __FreeBSD_version >= 1300139
	.vop_fplookup_symlink = VOP_EAGAIN,
	+#endif
	.vop_access = zfs_freebsd_access,
	.vop_inactive = zfs_freebsd_inactive,
	.vop_reclaim = zfs_freebsd_reclaim,
	.vop_fid = zfs_freebsd_fid,
	.vop_pathconf = zfs_freebsd_pathconf,
	};
	VFS_VOP_VECTOR_REGISTER(zfs_shareops);
	diff --git a/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_znode.c b/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_znode.c
	index 0491b2ff3e28..dace3ec345fa 100644
	--- a/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_znode.c
	+++ b/sys/contrib/openzfs/module/os/freebsd/zfs/zfs_znode.c
	@@ -1,2067 +1,2082 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2012, 2014 by Delphix. All rights reserved.
	* Copyright (c) 2014 Integros [integros.com]
	*/

	/* Portions Copyright 2007 Jeremy Teo */
	/* Portions Copyright 2011 Martin Matuska <mm@FreeBSD.org> */

	#ifdef _KERNEL
	#include <sys/types.h>
	#include <sys/param.h>
	#include <sys/time.h>
	#include <sys/systm.h>
	#include <sys/sysmacros.h>
	#include <sys/resource.h>
	#include <sys/mntent.h>
	#include <sys/u8_textprep.h>
	#include <sys/dsl_dataset.h>
	#include <sys/vfs.h>
	#include <sys/vnode.h>
	#include <sys/file.h>
	#include <sys/kmem.h>
	#include <sys/errno.h>
	#include <sys/unistd.h>
	#include <sys/atomic.h>
	#include <sys/zfs_dir.h>
	#include <sys/zfs_acl.h>
	#include <sys/zfs_ioctl.h>
	#include <sys/zfs_rlock.h>
	#include <sys/zfs_fuid.h>
	#include <sys/dnode.h>
	#include <sys/fs/zfs.h>
	#endif /* _KERNEL */

	#include <sys/dmu.h>
	#include <sys/dmu_objset.h>
	#include <sys/dmu_tx.h>
	#include <sys/zfs_refcount.h>
	#include <sys/stat.h>
	#include <sys/zap.h>
	#include <sys/zfs_znode.h>
	#include <sys/sa.h>
	#include <sys/zfs_sa.h>
	#include <sys/zfs_stat.h>

	#include "zfs_prop.h"
	#include "zfs_comutil.h"

	/* Used by fstat(1). */
	SYSCTL_INT(_debug_sizeof, OID_AUTO, znode, CTLFLAG_RD,
	SYSCTL_NULL_INT_PTR, sizeof (znode_t), "sizeof(znode_t)");

	/*
	* Define ZNODE_STATS to turn on statistic gathering. By default, it is only
	* turned on when DEBUG is also defined.
	*/
	#ifdef ZFS_DEBUG
	#define ZNODE_STATS
	#endif /* DEBUG */

	#ifdef ZNODE_STATS
	#define ZNODE_STAT_ADD(stat) ((stat)++)
	#else
	#define ZNODE_STAT_ADD(stat) /* nothing */
	#endif /* ZNODE_STATS */

	/*
	* Functions needed for userland (ie: libzpool) are not put under
	* #ifdef_KERNEL; the rest of the functions have dependencies
	* (such as VFS logic) that will not compile easily in userland.
	*/
	#ifdef _KERNEL
	#if !defined(KMEM_DEBUG) && __FreeBSD_version >= 1300102
	#define _ZFS_USE_SMR
	static uma_zone_t znode_uma_zone;
	#else
	static kmem_cache_t *znode_cache = NULL;
	#endif

	extern struct vop_vector zfs_vnodeops;
	extern struct vop_vector zfs_fifoops;
	extern struct vop_vector zfs_shareops;


	/*
	* This callback is invoked when acquiring a RL_WRITER or RL_APPEND lock on
	* z_rangelock. It will modify the offset and length of the lock to reflect
	* znode-specific information, and convert RL_APPEND to RL_WRITER. This is
	* called with the rangelock_t's rl_lock held, which avoids races.
	*/
	static void
	zfs_rangelock_cb(zfs_locked_range_t new, void arg)
	{
	znode_t *zp = arg;

	/*
	* If in append mode, convert to writer and lock starting at the
	* current end of file.
	*/
	if (new->lr_type == RL_APPEND) {
	new->lr_offset = zp->z_size;
	new->lr_type = RL_WRITER;
	}

	/*
	* If we need to grow the block size then lock the whole file range.
	*/
	uint64_t end_size = MAX(zp->z_size, new->lr_offset + new->lr_length);
	if (end_size > zp->z_blksz && (!ISP2(zp->z_blksz) \|\|
	zp->z_blksz < ZTOZSB(zp)->z_max_blksz)) {
	new->lr_offset = 0;
	new->lr_length = UINT64_MAX;
	}
	}

	static int
	zfs_znode_cache_constructor(void buf, void arg, int kmflags)
	{
	znode_t *zp = buf;

	POINTER_INVALIDATE(&zp->z_zfsvfs);

	list_link_init(&zp->z_link_node);

	+ mutex_init(&zp->z_lock, NULL, MUTEX_DEFAULT, NULL);
	mutex_init(&zp->z_acl_lock, NULL, MUTEX_DEFAULT, NULL);

	zfs_rangelock_init(&zp->z_rangelock, zfs_rangelock_cb, zp);

	zp->z_acl_cached = NULL;
	zp->z_vnode = NULL;
	return (0);
	}

	/ARGSUSED/
	static void
	zfs_znode_cache_destructor(void buf, void arg)
	{
	znode_t *zp = buf;

	ASSERT(!POINTER_IS_VALID(zp->z_zfsvfs));
	ASSERT3P(zp->z_vnode, ==, NULL);
	ASSERT(!list_link_active(&zp->z_link_node));
	+ mutex_destroy(&zp->z_lock);
	mutex_destroy(&zp->z_acl_lock);
	zfs_rangelock_fini(&zp->z_rangelock);

	ASSERT(zp->z_acl_cached == NULL);
	}


	#ifdef _ZFS_USE_SMR
	VFS_SMR_DECLARE;

	static int
	zfs_znode_cache_constructor_smr(void mem, int size __unused, void private,
	int flags)
	{

	return (zfs_znode_cache_constructor(mem, private, flags));
	}

	static void
	zfs_znode_cache_destructor_smr(void mem, int size __unused, void private)
	{

	zfs_znode_cache_destructor(mem, private);
	}

	void
	zfs_znode_init(void)
	{
	/*
	* Initialize zcache
	*/
	ASSERT(znode_uma_zone == NULL);
	znode_uma_zone = uma_zcreate("zfs_znode_cache",
	sizeof (znode_t), zfs_znode_cache_constructor_smr,
	zfs_znode_cache_destructor_smr, NULL, NULL, 0, 0);
	VFS_SMR_ZONE_SET(znode_uma_zone);
	}

	static znode_t *
	zfs_znode_alloc_kmem(int flags)
	{

	return (uma_zalloc_smr(znode_uma_zone, flags));
	}

	static void
	zfs_znode_free_kmem(znode_t *zp)
	{

	uma_zfree_smr(znode_uma_zone, zp);
	}
	#else
	void
	zfs_znode_init(void)
	{
	/*
	* Initialize zcache
	*/
	ASSERT(znode_cache == NULL);
	znode_cache = kmem_cache_create("zfs_znode_cache",
	sizeof (znode_t), 0, zfs_znode_cache_constructor,
	zfs_znode_cache_destructor, NULL, NULL, NULL, 0);
	}

	static znode_t *
	zfs_znode_alloc_kmem(int flags)
	{

	return (kmem_cache_alloc(znode_cache, flags));
	}

	static void
	zfs_znode_free_kmem(znode_t *zp)
	{

	kmem_cache_free(znode_cache, zp);
	}
	#endif

	void
	zfs_znode_fini(void)
	{
	/*
	* Cleanup zcache
	*/
	#ifdef _ZFS_USE_SMR
	if (znode_uma_zone) {
	uma_zdestroy(znode_uma_zone);
	znode_uma_zone = NULL;
	}
	#else
	if (znode_cache) {
	kmem_cache_destroy(znode_cache);
	znode_cache = NULL;
	}
	#endif
	}


	static int
	zfs_create_share_dir(zfsvfs_t zfsvfs, dmu_tx_t tx)
	{
	zfs_acl_ids_t acl_ids;
	vattr_t vattr;
	znode_t *sharezp;
	znode_t *zp;
	int error;

	vattr.va_mask = AT_MODE\|AT_UID\|AT_GID;
	vattr.va_type = VDIR;
	vattr.va_mode = S_IFDIR\|0555;
	vattr.va_uid = crgetuid(kcred);
	vattr.va_gid = crgetgid(kcred);

	sharezp = zfs_znode_alloc_kmem(KM_SLEEP);
	ASSERT(!POINTER_IS_VALID(sharezp->z_zfsvfs));
	sharezp->z_unlinked = 0;
	sharezp->z_atime_dirty = 0;
	sharezp->z_zfsvfs = zfsvfs;
	sharezp->z_is_sa = zfsvfs->z_use_sa;

	VERIFY(0 == zfs_acl_ids_create(sharezp, IS_ROOT_NODE, &vattr,
	kcred, NULL, &acl_ids));
	zfs_mknode(sharezp, &vattr, tx, kcred, IS_ROOT_NODE, &zp, &acl_ids);
	ASSERT3P(zp, ==, sharezp);
	POINTER_INVALIDATE(&sharezp->z_zfsvfs);
	error = zap_add(zfsvfs->z_os, MASTER_NODE_OBJ,
	ZFS_SHARES_DIR, 8, 1, &sharezp->z_id, tx);
	zfsvfs->z_shares_dir = sharezp->z_id;

	zfs_acl_ids_free(&acl_ids);
	sa_handle_destroy(sharezp->z_sa_hdl);
	zfs_znode_free_kmem(sharezp);

	return (error);
	}

	/*
	* define a couple of values we need available
	* for both 64 and 32 bit environments.
	*/
	#ifndef NBITSMINOR64
	#define NBITSMINOR64 32
	#endif
	#ifndef MAXMAJ64
	#define MAXMAJ64 0xffffffffUL
	#endif
	#ifndef MAXMIN64
	#define MAXMIN64 0xffffffffUL
	#endif

	/*
	* Create special expldev for ZFS private use.
	* Can't use standard expldev since it doesn't do
	* what we want. The standard expldev() takes a
	* dev32_t in LP64 and expands it to a long dev_t.
	* We need an interface that takes a dev32_t in ILP32
	* and expands it to a long dev_t.
	*/
	static uint64_t
	zfs_expldev(dev_t dev)
	{
	return (((uint64_t)major(dev) << NBITSMINOR64) \| minor(dev));
	}
	/*
	* Special cmpldev for ZFS private use.
	* Can't use standard cmpldev since it takes
	* a long dev_t and compresses it to dev32_t in
	* LP64. We need to do a compaction of a long dev_t
	* to a dev32_t in ILP32.
	*/
	dev_t
	zfs_cmpldev(uint64_t dev)
	{
	return (makedev((dev >> NBITSMINOR64), (dev & MAXMIN64)));
	}

	static void
	zfs_znode_sa_init(zfsvfs_t zfsvfs, znode_t zp,
	dmu_buf_t db, dmu_object_type_t obj_type, sa_handle_t sa_hdl)
	{
	ASSERT(!POINTER_IS_VALID(zp->z_zfsvfs) \|\| (zfsvfs == zp->z_zfsvfs));
	ASSERT(MUTEX_HELD(ZFS_OBJ_MUTEX(zfsvfs, zp->z_id)));

	ASSERT(zp->z_sa_hdl == NULL);
	ASSERT(zp->z_acl_cached == NULL);
	if (sa_hdl == NULL) {
	VERIFY(0 == sa_handle_get_from_db(zfsvfs->z_os, db, zp,
	SA_HDL_SHARED, &zp->z_sa_hdl));
	} else {
	zp->z_sa_hdl = sa_hdl;
	sa_set_userp(sa_hdl, zp);
	}

	zp->z_is_sa = (obj_type == DMU_OT_SA) ? B_TRUE : B_FALSE;

	/*
	* Slap on VROOT if we are the root znode unless we are the root
	* node of a snapshot mounted under .zfs.
	*/
	if (zp->z_id == zfsvfs->z_root && zfsvfs->z_parent == zfsvfs)
	ZTOV(zp)->v_flag \|= VROOT;

	vn_exists(ZTOV(zp));
	}

	void
	zfs_znode_dmu_fini(znode_t *zp)
	{
	ASSERT(MUTEX_HELD(ZFS_OBJ_MUTEX(zp->z_zfsvfs, zp->z_id)) \|\|
	zp->z_unlinked \|\|
	ZFS_TEARDOWN_INACTIVE_WRITE_HELD(zp->z_zfsvfs));

	sa_handle_destroy(zp->z_sa_hdl);
	zp->z_sa_hdl = NULL;
	}

	static void
	zfs_vnode_forget(vnode_t *vp)
	{

	/* copied from insmntque_stddtr */
	vp->v_data = NULL;
	vp->v_op = &dead_vnodeops;
	vgone(vp);
	vput(vp);
	}

	/*
	* Construct a new znode/vnode and initialize.
	*
	* This does not do a call to dmu_set_user() that is
	* up to the caller to do, in case you don't want to
	* return the znode
	*/
	static znode_t *
	zfs_znode_alloc(zfsvfs_t zfsvfs, dmu_buf_t db, int blksz,
	dmu_object_type_t obj_type, sa_handle_t *hdl)
	{
	znode_t *zp;
	vnode_t *vp;
	uint64_t mode;
	uint64_t parent;
	#ifdef notyet
	uint64_t mtime[2], ctime[2];
	#endif
	uint64_t projid = ZFS_DEFAULT_PROJID;
	sa_bulk_attr_t bulk[9];
	int count = 0;
	int error;

	zp = zfs_znode_alloc_kmem(KM_SLEEP);

	#ifndef _ZFS_USE_SMR
	KASSERT((zfsvfs->z_parent->z_vfs->mnt_kern_flag & MNTK_FPLOOKUP) == 0,
	("%s: fast path lookup enabled without smr", __func__));
	#endif

	#if __FreeBSD_version >= 1300076
	KASSERT(curthread->td_vp_reserved != NULL,
	("zfs_znode_alloc: getnewvnode without any vnodes reserved"));
	#else
	KASSERT(curthread->td_vp_reserv > 0,
	("zfs_znode_alloc: getnewvnode without any vnodes reserved"));
	#endif
	error = getnewvnode("zfs", zfsvfs->z_parent->z_vfs, &zfs_vnodeops, &vp);
	if (error != 0) {
	zfs_znode_free_kmem(zp);
	return (NULL);
	}
	zp->z_vnode = vp;
	vp->v_data = zp;

	ASSERT(!POINTER_IS_VALID(zp->z_zfsvfs));

	zp->z_sa_hdl = NULL;
	zp->z_unlinked = 0;
	zp->z_atime_dirty = 0;
	zp->z_mapcnt = 0;
	zp->z_id = db->db_object;
	zp->z_blksz = blksz;
	zp->z_seq = 0x7A4653;
	zp->z_sync_cnt = 0;
	+#if __FreeBSD_version >= 1300139
	atomic_store_ptr(&zp->z_cached_symlink, NULL);
	+#endif

	vp = ZTOV(zp);

	zfs_znode_sa_init(zfsvfs, zp, db, obj_type, hdl);

	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MODE(zfsvfs), NULL, &mode, 8);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_GEN(zfsvfs), NULL, &zp->z_gen, 8);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_SIZE(zfsvfs), NULL,
	&zp->z_size, 8);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_LINKS(zfsvfs), NULL,
	&zp->z_links, 8);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zfsvfs), NULL,
	&zp->z_pflags, 8);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_PARENT(zfsvfs), NULL, &parent, 8);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_ATIME(zfsvfs), NULL,
	&zp->z_atime, 16);
	#ifdef notyet
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zfsvfs), NULL,
	&mtime, 16);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs), NULL,
	&ctime, 16);
	#endif
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_UID(zfsvfs), NULL,
	&zp->z_uid, 8);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_GID(zfsvfs), NULL,
	&zp->z_gid, 8);

	if (sa_bulk_lookup(zp->z_sa_hdl, bulk, count) != 0 \|\| zp->z_gen == 0 \|\|
	(dmu_objset_projectquota_enabled(zfsvfs->z_os) &&
	(zp->z_pflags & ZFS_PROJID) &&
	sa_lookup(zp->z_sa_hdl, SA_ZPL_PROJID(zfsvfs), &projid, 8) != 0)) {
	if (hdl == NULL)
	sa_handle_destroy(zp->z_sa_hdl);
	zfs_vnode_forget(vp);
	zp->z_vnode = NULL;
	zfs_znode_free_kmem(zp);
	return (NULL);
	}

	zp->z_projid = projid;
	zp->z_mode = mode;

	/* Cache the xattr parent id */
	if (zp->z_pflags & ZFS_XATTR)
	zp->z_xattr_parent = parent;

	vp->v_type = IFTOVT((mode_t)mode);

	switch (vp->v_type) {
	case VDIR:
	zp->z_zn_prefetch = B_TRUE; /* z_prefetch default is enabled */
	break;
	case VFIFO:
	vp->v_op = &zfs_fifoops;
	break;
	case VREG:
	if (parent == zfsvfs->z_shares_dir) {
	ASSERT(zp->z_uid == 0 && zp->z_gid == 0);
	vp->v_op = &zfs_shareops;
	}
	break;
	default:
	break;
	}

	mutex_enter(&zfsvfs->z_znodes_lock);
	list_insert_tail(&zfsvfs->z_all_znodes, zp);
	zfsvfs->z_nr_znodes++;
	zp->z_zfsvfs = zfsvfs;
	mutex_exit(&zfsvfs->z_znodes_lock);

	/*
	* Acquire vnode lock before making it available to the world.
	*/
	vn_lock(vp, LK_EXCLUSIVE \| LK_RETRY);
	VN_LOCK_AREC(vp);
	if (vp->v_type != VFIFO)
	VN_LOCK_ASHARE(vp);

	return (zp);
	}

	static uint64_t empty_xattr;
	static uint64_t pad[4];
	static zfs_acl_phys_t acl_phys;
	/*
	* Create a new DMU object to hold a zfs znode.
	*
	* IN: dzp - parent directory for new znode
	* vap - file attributes for new znode
	* tx - dmu transaction id for zap operations
	* cr - credentials of caller
	* flag - flags:
	* IS_ROOT_NODE - new object will be root
	* IS_XATTR - new object is an attribute
	* bonuslen - length of bonus buffer
	* setaclp - File/Dir initial ACL
	* fuidp - Tracks fuid allocation.
	*
	* OUT: zpp - allocated znode
	*
	*/
	void
	zfs_mknode(znode_t dzp, vattr_t vap, dmu_tx_t tx, cred_t cr,
	uint_t flag, znode_t *zpp, zfs_acl_ids_t acl_ids)
	{
	uint64_t crtime[2], atime[2], mtime[2], ctime[2];
	uint64_t mode, size, links, parent, pflags;
	uint64_t dzp_pflags = 0;
	uint64_t rdev = 0;
	zfsvfs_t *zfsvfs = dzp->z_zfsvfs;
	dmu_buf_t *db;
	timestruc_t now;
	uint64_t gen, obj;
	int err;
	int bonuslen;
	int dnodesize;
	sa_handle_t *sa_hdl;
	dmu_object_type_t obj_type;
	sa_bulk_attr_t *sa_attrs;
	int cnt = 0;
	zfs_acl_locator_cb_t locate = { 0 };

	ASSERT(vap && ((vap->va_mask & AT_MODE) == AT_MODE));

	if (zfsvfs->z_replay) {
	obj = vap->va_nodeid;
	now = vap->va_ctime; /* see zfs_replay_create() */
	gen = vap->va_nblocks; /* ditto */
	dnodesize = vap->va_fsid; /* ditto */
	} else {
	obj = 0;
	vfs_timestamp(&now);
	gen = dmu_tx_get_txg(tx);
	dnodesize = dmu_objset_dnodesize(zfsvfs->z_os);
	}

	if (dnodesize == 0)
	dnodesize = DNODE_MIN_SIZE;

	obj_type = zfsvfs->z_use_sa ? DMU_OT_SA : DMU_OT_ZNODE;
	bonuslen = (obj_type == DMU_OT_SA) ?
	DN_BONUS_SIZE(dnodesize) : ZFS_OLD_ZNODE_PHYS_SIZE;

	/*
	* Create a new DMU object.
	*/
	/*
	* There's currently no mechanism for pre-reading the blocks that will
	* be needed to allocate a new object, so we accept the small chance
	* that there will be an i/o error and we will fail one of the
	* assertions below.
	*/
	if (vap->va_type == VDIR) {
	if (zfsvfs->z_replay) {
	VERIFY0(zap_create_claim_norm_dnsize(zfsvfs->z_os, obj,
	zfsvfs->z_norm, DMU_OT_DIRECTORY_CONTENTS,
	obj_type, bonuslen, dnodesize, tx));
	} else {
	obj = zap_create_norm_dnsize(zfsvfs->z_os,
	zfsvfs->z_norm, DMU_OT_DIRECTORY_CONTENTS,
	obj_type, bonuslen, dnodesize, tx);
	}
	} else {
	if (zfsvfs->z_replay) {
	VERIFY0(dmu_object_claim_dnsize(zfsvfs->z_os, obj,
	DMU_OT_PLAIN_FILE_CONTENTS, 0,
	obj_type, bonuslen, dnodesize, tx));
	} else {
	obj = dmu_object_alloc_dnsize(zfsvfs->z_os,
	DMU_OT_PLAIN_FILE_CONTENTS, 0,
	obj_type, bonuslen, dnodesize, tx);
	}
	}

	ZFS_OBJ_HOLD_ENTER(zfsvfs, obj);
	VERIFY(0 == sa_buf_hold(zfsvfs->z_os, obj, NULL, &db));

	/*
	* If this is the root, fix up the half-initialized parent pointer
	* to reference the just-allocated physical data area.
	*/
	if (flag & IS_ROOT_NODE) {
	dzp->z_id = obj;
	} else {
	dzp_pflags = dzp->z_pflags;
	}

	/*
	* If parent is an xattr, so am I.
	*/
	if (dzp_pflags & ZFS_XATTR) {
	flag \|= IS_XATTR;
	}

	if (zfsvfs->z_use_fuids)
	pflags = ZFS_ARCHIVE \| ZFS_AV_MODIFIED;
	else
	pflags = 0;

	if (vap->va_type == VDIR) {
	size = 2; /* contents ("." and "..") */
	links = (flag & (IS_ROOT_NODE \| IS_XATTR)) ? 2 : 1;
	} else {
	size = links = 0;
	}

	if (vap->va_type == VBLK \|\| vap->va_type == VCHR) {
	rdev = zfs_expldev(vap->va_rdev);
	}

	parent = dzp->z_id;
	mode = acl_ids->z_mode;
	if (flag & IS_XATTR)
	pflags \|= ZFS_XATTR;

	/*
	* No execs denied will be determined when zfs_mode_compute() is called.
	*/
	pflags \|= acl_ids->z_aclp->z_hints &
	(ZFS_ACL_TRIVIAL\|ZFS_INHERIT_ACE\|ZFS_ACL_AUTO_INHERIT\|
	ZFS_ACL_DEFAULTED\|ZFS_ACL_PROTECTED);

	ZFS_TIME_ENCODE(&now, crtime);
	ZFS_TIME_ENCODE(&now, ctime);

	if (vap->va_mask & AT_ATIME) {
	ZFS_TIME_ENCODE(&vap->va_atime, atime);
	} else {
	ZFS_TIME_ENCODE(&now, atime);
	}

	if (vap->va_mask & AT_MTIME) {
	ZFS_TIME_ENCODE(&vap->va_mtime, mtime);
	} else {
	ZFS_TIME_ENCODE(&now, mtime);
	}

	/* Now add in all of the "SA" attributes */
	VERIFY(0 == sa_handle_get_from_db(zfsvfs->z_os, db, NULL, SA_HDL_SHARED,
	&sa_hdl));

	/*
	* Setup the array of attributes to be replaced/set on the new file
	*
	* order for DMU_OT_ZNODE is critical since it needs to be constructed
	* in the old znode_phys_t format. Don't change this ordering
	*/
	sa_attrs = kmem_alloc(sizeof (sa_bulk_attr_t) * ZPL_END, KM_SLEEP);

	if (obj_type == DMU_OT_ZNODE) {
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_ATIME(zfsvfs),
	NULL, &atime, 16);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_MTIME(zfsvfs),
	NULL, &mtime, 16);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_CTIME(zfsvfs),
	NULL, &ctime, 16);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_CRTIME(zfsvfs),
	NULL, &crtime, 16);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_GEN(zfsvfs),
	NULL, &gen, 8);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_MODE(zfsvfs),
	NULL, &mode, 8);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_SIZE(zfsvfs),
	NULL, &size, 8);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_PARENT(zfsvfs),
	NULL, &parent, 8);
	} else {
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_MODE(zfsvfs),
	NULL, &mode, 8);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_SIZE(zfsvfs),
	NULL, &size, 8);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_GEN(zfsvfs),
	NULL, &gen, 8);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_UID(zfsvfs),
	NULL, &acl_ids->z_fuid, 8);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_GID(zfsvfs),
	NULL, &acl_ids->z_fgid, 8);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_PARENT(zfsvfs),
	NULL, &parent, 8);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_FLAGS(zfsvfs),
	NULL, &pflags, 8);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_ATIME(zfsvfs),
	NULL, &atime, 16);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_MTIME(zfsvfs),
	NULL, &mtime, 16);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_CTIME(zfsvfs),
	NULL, &ctime, 16);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_CRTIME(zfsvfs),
	NULL, &crtime, 16);
	}

	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_LINKS(zfsvfs), NULL, &links, 8);

	if (obj_type == DMU_OT_ZNODE) {
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_XATTR(zfsvfs), NULL,
	&empty_xattr, 8);
	}
	if (obj_type == DMU_OT_ZNODE \|\|
	(vap->va_type == VBLK \|\| vap->va_type == VCHR)) {
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_RDEV(zfsvfs),
	NULL, &rdev, 8);

	}
	if (obj_type == DMU_OT_ZNODE) {
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_FLAGS(zfsvfs),
	NULL, &pflags, 8);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_UID(zfsvfs), NULL,
	&acl_ids->z_fuid, 8);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_GID(zfsvfs), NULL,
	&acl_ids->z_fgid, 8);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_PAD(zfsvfs), NULL, pad,
	sizeof (uint64_t) * 4);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_ZNODE_ACL(zfsvfs), NULL,
	&acl_phys, sizeof (zfs_acl_phys_t));
	} else if (acl_ids->z_aclp->z_version >= ZFS_ACL_VERSION_FUID) {
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_DACL_COUNT(zfsvfs), NULL,
	&acl_ids->z_aclp->z_acl_count, 8);
	locate.cb_aclp = acl_ids->z_aclp;
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_DACL_ACES(zfsvfs),
	zfs_acl_data_locator, &locate,
	acl_ids->z_aclp->z_acl_bytes);
	mode = zfs_mode_compute(mode, acl_ids->z_aclp, &pflags,
	acl_ids->z_fuid, acl_ids->z_fgid);
	}

	VERIFY(sa_replace_all_by_template(sa_hdl, sa_attrs, cnt, tx) == 0);

	if (!(flag & IS_ROOT_NODE)) {
	*zpp = zfs_znode_alloc(zfsvfs, db, 0, obj_type, sa_hdl);
	ASSERT(*zpp != NULL);
	} else {
	/*
	* If we are creating the root node, the "parent" we
	* passed in is the znode for the root.
	*/
	*zpp = dzp;

	(*zpp)->z_sa_hdl = sa_hdl;
	}

	(*zpp)->z_pflags = pflags;
	(*zpp)->z_mode = mode;
	(*zpp)->z_dnodesize = dnodesize;

	if (vap->va_mask & AT_XVATTR)
	zfs_xvattr_set(zpp, (xvattr_t )vap, tx);

	if (obj_type == DMU_OT_ZNODE \|\|
	acl_ids->z_aclp->z_version < ZFS_ACL_VERSION_FUID) {
	VERIFY0(zfs_aclset_common(*zpp, acl_ids->z_aclp, cr, tx));
	}
	if (!(flag & IS_ROOT_NODE)) {
	vnode_t *vp;

	vp = ZTOV(*zpp);
	vp->v_vflag \|= VV_FORCEINSMQ;
	err = insmntque(vp, zfsvfs->z_vfs);
	vp->v_vflag &= ~VV_FORCEINSMQ;
	KASSERT(err == 0, ("insmntque() failed: error %d", err));
	}
	kmem_free(sa_attrs, sizeof (sa_bulk_attr_t) * ZPL_END);
	ZFS_OBJ_HOLD_EXIT(zfsvfs, obj);
	}

	/*
	* Update in-core attributes. It is assumed the caller will be doing an
	* sa_bulk_update to push the changes out.
	*/
	void
	zfs_xvattr_set(znode_t zp, xvattr_t xvap, dmu_tx_t *tx)
	{
	xoptattr_t *xoap;

	xoap = xva_getxoptattr(xvap);
	ASSERT(xoap);

	ASSERT_VOP_IN_SEQC(ZTOV(zp));

	if (XVA_ISSET_REQ(xvap, XAT_CREATETIME)) {
	uint64_t times[2];
	ZFS_TIME_ENCODE(&xoap->xoa_createtime, times);
	(void) sa_update(zp->z_sa_hdl, SA_ZPL_CRTIME(zp->z_zfsvfs),
	&times, sizeof (times), tx);
	XVA_SET_RTN(xvap, XAT_CREATETIME);
	}
	if (XVA_ISSET_REQ(xvap, XAT_READONLY)) {
	ZFS_ATTR_SET(zp, ZFS_READONLY, xoap->xoa_readonly,
	zp->z_pflags, tx);
	XVA_SET_RTN(xvap, XAT_READONLY);
	}
	if (XVA_ISSET_REQ(xvap, XAT_HIDDEN)) {
	ZFS_ATTR_SET(zp, ZFS_HIDDEN, xoap->xoa_hidden,
	zp->z_pflags, tx);
	XVA_SET_RTN(xvap, XAT_HIDDEN);
	}
	if (XVA_ISSET_REQ(xvap, XAT_SYSTEM)) {
	ZFS_ATTR_SET(zp, ZFS_SYSTEM, xoap->xoa_system,
	zp->z_pflags, tx);
	XVA_SET_RTN(xvap, XAT_SYSTEM);
	}
	if (XVA_ISSET_REQ(xvap, XAT_ARCHIVE)) {
	ZFS_ATTR_SET(zp, ZFS_ARCHIVE, xoap->xoa_archive,
	zp->z_pflags, tx);
	XVA_SET_RTN(xvap, XAT_ARCHIVE);
	}
	if (XVA_ISSET_REQ(xvap, XAT_IMMUTABLE)) {
	ZFS_ATTR_SET(zp, ZFS_IMMUTABLE, xoap->xoa_immutable,
	zp->z_pflags, tx);
	XVA_SET_RTN(xvap, XAT_IMMUTABLE);
	}
	if (XVA_ISSET_REQ(xvap, XAT_NOUNLINK)) {
	ZFS_ATTR_SET(zp, ZFS_NOUNLINK, xoap->xoa_nounlink,
	zp->z_pflags, tx);
	XVA_SET_RTN(xvap, XAT_NOUNLINK);
	}
	if (XVA_ISSET_REQ(xvap, XAT_APPENDONLY)) {
	ZFS_ATTR_SET(zp, ZFS_APPENDONLY, xoap->xoa_appendonly,
	zp->z_pflags, tx);
	XVA_SET_RTN(xvap, XAT_APPENDONLY);
	}
	if (XVA_ISSET_REQ(xvap, XAT_NODUMP)) {
	ZFS_ATTR_SET(zp, ZFS_NODUMP, xoap->xoa_nodump,
	zp->z_pflags, tx);
	XVA_SET_RTN(xvap, XAT_NODUMP);
	}
	if (XVA_ISSET_REQ(xvap, XAT_OPAQUE)) {
	ZFS_ATTR_SET(zp, ZFS_OPAQUE, xoap->xoa_opaque,
	zp->z_pflags, tx);
	XVA_SET_RTN(xvap, XAT_OPAQUE);
	}
	if (XVA_ISSET_REQ(xvap, XAT_AV_QUARANTINED)) {
	ZFS_ATTR_SET(zp, ZFS_AV_QUARANTINED,
	xoap->xoa_av_quarantined, zp->z_pflags, tx);
	XVA_SET_RTN(xvap, XAT_AV_QUARANTINED);
	}
	if (XVA_ISSET_REQ(xvap, XAT_AV_MODIFIED)) {
	ZFS_ATTR_SET(zp, ZFS_AV_MODIFIED, xoap->xoa_av_modified,
	zp->z_pflags, tx);
	XVA_SET_RTN(xvap, XAT_AV_MODIFIED);
	}
	if (XVA_ISSET_REQ(xvap, XAT_AV_SCANSTAMP)) {
	zfs_sa_set_scanstamp(zp, xvap, tx);
	XVA_SET_RTN(xvap, XAT_AV_SCANSTAMP);
	}
	if (XVA_ISSET_REQ(xvap, XAT_REPARSE)) {
	ZFS_ATTR_SET(zp, ZFS_REPARSE, xoap->xoa_reparse,
	zp->z_pflags, tx);
	XVA_SET_RTN(xvap, XAT_REPARSE);
	}
	if (XVA_ISSET_REQ(xvap, XAT_OFFLINE)) {
	ZFS_ATTR_SET(zp, ZFS_OFFLINE, xoap->xoa_offline,
	zp->z_pflags, tx);
	XVA_SET_RTN(xvap, XAT_OFFLINE);
	}
	if (XVA_ISSET_REQ(xvap, XAT_SPARSE)) {
	ZFS_ATTR_SET(zp, ZFS_SPARSE, xoap->xoa_sparse,
	zp->z_pflags, tx);
	XVA_SET_RTN(xvap, XAT_SPARSE);
	}
	}

	int
	zfs_zget(zfsvfs_t zfsvfs, uint64_t obj_num, znode_t *zpp)
	{
	dmu_object_info_t doi;
	dmu_buf_t *db;
	znode_t *zp;
	vnode_t *vp;
	sa_handle_t *hdl;
	struct thread *td;
	int locked;
	int err;

	td = curthread;
	getnewvnode_reserve_();
	again:
	*zpp = NULL;
	ZFS_OBJ_HOLD_ENTER(zfsvfs, obj_num);

	err = sa_buf_hold(zfsvfs->z_os, obj_num, NULL, &db);
	if (err) {
	ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num);
	getnewvnode_drop_reserve();
	return (err);
	}

	dmu_object_info_from_db(db, &doi);
	if (doi.doi_bonus_type != DMU_OT_SA &&
	(doi.doi_bonus_type != DMU_OT_ZNODE \|\|
	(doi.doi_bonus_type == DMU_OT_ZNODE &&
	doi.doi_bonus_size < sizeof (znode_phys_t)))) {
	sa_buf_rele(db, NULL);
	ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num);
	getnewvnode_drop_reserve();
	return (SET_ERROR(EINVAL));
	}

	hdl = dmu_buf_get_user(db);
	if (hdl != NULL) {
	zp = sa_get_userdata(hdl);

	/*
	* Since "SA" does immediate eviction we
	* should never find a sa handle that doesn't
	* know about the znode.
	*/
	ASSERT3P(zp, !=, NULL);
	ASSERT3U(zp->z_id, ==, obj_num);
	if (zp->z_unlinked) {
	err = SET_ERROR(ENOENT);
	} else {
	vp = ZTOV(zp);
	/*
	* Don't let the vnode disappear after
	* ZFS_OBJ_HOLD_EXIT.
	*/
	VN_HOLD(vp);
	*zpp = zp;
	err = 0;
	}

	sa_buf_rele(db, NULL);
	ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num);

	if (err) {
	getnewvnode_drop_reserve();
	return (err);
	}

	locked = VOP_ISLOCKED(vp);
	VI_LOCK(vp);
	if (VN_IS_DOOMED(vp) && locked != LK_EXCLUSIVE) {
	/*
	* The vnode is doomed and this thread doesn't
	* hold the exclusive lock on it, so the vnode
	* must be being reclaimed by another thread.
	* Otherwise the doomed vnode is being reclaimed
	* by this thread and zfs_zget is called from
	* ZIL internals.
	*/
	VI_UNLOCK(vp);

	/*
	* XXX vrele() locks the vnode when the last reference
	* is dropped. Although in this case the vnode is
	* doomed / dead and so no inactivation is required,
	* the vnode lock is still acquired. That could result
	* in a LOR with z_teardown_lock if another thread holds
	* the vnode's lock and tries to take z_teardown_lock.
	* But that is only possible if the other thread peforms
	* a ZFS vnode operation on the vnode. That either
	* should not happen if the vnode is dead or the thread
	* should also have a reference to the vnode and thus
	* our reference is not last.
	*/
	VN_RELE(vp);
	goto again;
	}
	VI_UNLOCK(vp);
	getnewvnode_drop_reserve();
	return (err);
	}

	/*
	* Not found create new znode/vnode
	* but only if file exists.
	*
	* There is a small window where zfs_vget() could
	* find this object while a file create is still in
	* progress. This is checked for in zfs_znode_alloc()
	*
	* if zfs_znode_alloc() fails it will drop the hold on the
	* bonus buffer.
	*/
	zp = zfs_znode_alloc(zfsvfs, db, doi.doi_data_block_size,
	doi.doi_bonus_type, NULL);
	if (zp == NULL) {
	err = SET_ERROR(ENOENT);
	} else {
	*zpp = zp;
	}
	if (err == 0) {
	vnode_t *vp = ZTOV(zp);

	err = insmntque(vp, zfsvfs->z_vfs);
	if (err == 0) {
	vp->v_hash = obj_num;
	VOP_UNLOCK1(vp);
	} else {
	zp->z_vnode = NULL;
	zfs_znode_dmu_fini(zp);
	zfs_znode_free(zp);
	*zpp = NULL;
	}
	}
	ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num);
	getnewvnode_drop_reserve();
	return (err);
	}

	int
	zfs_rezget(znode_t *zp)
	{
	zfsvfs_t *zfsvfs = zp->z_zfsvfs;
	dmu_object_info_t doi;
	dmu_buf_t *db;
	vnode_t *vp;
	uint64_t obj_num = zp->z_id;
	uint64_t mode, size;
	sa_bulk_attr_t bulk[8];
	int err;
	int count = 0;
	uint64_t gen;

	/*
	* Remove cached pages before reloading the znode, so that they are not
	* lingering after we run into any error. Ideally, we should vgone()
	* the vnode in case of error, but currently we cannot do that
	* because of the LOR between the vnode lock and z_teardown_lock.
	* So, instead, we have to "doom" the znode in the illumos style.
	*/
	vp = ZTOV(zp);
	vn_pages_remove(vp, 0, 0);

	ZFS_OBJ_HOLD_ENTER(zfsvfs, obj_num);

	mutex_enter(&zp->z_acl_lock);
	if (zp->z_acl_cached) {
	zfs_acl_free(zp->z_acl_cached);
	zp->z_acl_cached = NULL;
	}

	mutex_exit(&zp->z_acl_lock);
	ASSERT(zp->z_sa_hdl == NULL);
	err = sa_buf_hold(zfsvfs->z_os, obj_num, NULL, &db);
	if (err) {
	ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num);
	return (err);
	}

	dmu_object_info_from_db(db, &doi);
	if (doi.doi_bonus_type != DMU_OT_SA &&
	(doi.doi_bonus_type != DMU_OT_ZNODE \|\|
	(doi.doi_bonus_type == DMU_OT_ZNODE &&
	doi.doi_bonus_size < sizeof (znode_phys_t)))) {
	sa_buf_rele(db, NULL);
	ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num);
	return (SET_ERROR(EINVAL));
	}

	zfs_znode_sa_init(zfsvfs, zp, db, doi.doi_bonus_type, NULL);
	size = zp->z_size;

	/* reload cached values */
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_GEN(zfsvfs), NULL,
	&gen, sizeof (gen));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_SIZE(zfsvfs), NULL,
	&zp->z_size, sizeof (zp->z_size));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_LINKS(zfsvfs), NULL,
	&zp->z_links, sizeof (zp->z_links));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zfsvfs), NULL,
	&zp->z_pflags, sizeof (zp->z_pflags));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_ATIME(zfsvfs), NULL,
	&zp->z_atime, sizeof (zp->z_atime));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_UID(zfsvfs), NULL,
	&zp->z_uid, sizeof (zp->z_uid));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_GID(zfsvfs), NULL,
	&zp->z_gid, sizeof (zp->z_gid));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MODE(zfsvfs), NULL,
	&mode, sizeof (mode));

	if (sa_bulk_lookup(zp->z_sa_hdl, bulk, count)) {
	zfs_znode_dmu_fini(zp);
	ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num);
	return (SET_ERROR(EIO));
	}

	zp->z_mode = mode;

	if (gen != zp->z_gen) {
	zfs_znode_dmu_fini(zp);
	ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num);
	return (SET_ERROR(EIO));
	}

	/*
	* It is highly improbable but still quite possible that two
	* objects in different datasets are created with the same
	* object numbers and in transaction groups with the same
	* numbers. znodes corresponding to those objects would
	* have the same z_id and z_gen, but their other attributes
	* may be different.
	* zfs recv -F may replace one of such objects with the other.
	* As a result file properties recorded in the replaced
	* object's vnode may no longer match the received object's
	* properties. At present the only cached property is the
	* files type recorded in v_type.
	* So, handle this case by leaving the old vnode and znode
	* disassociated from the actual object. A new vnode and a
	* znode will be created if the object is accessed
	* (e.g. via a look-up). The old vnode and znode will be
	* recycled when the last vnode reference is dropped.
	*/
	if (vp->v_type != IFTOVT((mode_t)zp->z_mode)) {
	zfs_znode_dmu_fini(zp);
	ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num);
	return (SET_ERROR(EIO));
	}

	/*
	* If the file has zero links, then it has been unlinked on the send
	* side and it must be in the received unlinked set.
	* We call zfs_znode_dmu_fini() now to prevent any accesses to the
	* stale data and to prevent automatically removal of the file in
	* zfs_zinactive(). The file will be removed either when it is removed
	* on the send side and the next incremental stream is received or
	* when the unlinked set gets processed.
	*/
	zp->z_unlinked = (zp->z_links == 0);
	if (zp->z_unlinked) {
	zfs_znode_dmu_fini(zp);
	ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num);
	return (0);
	}

	zp->z_blksz = doi.doi_data_block_size;
	if (zp->z_size != size)
	vnode_pager_setsize(vp, zp->z_size);

	ZFS_OBJ_HOLD_EXIT(zfsvfs, obj_num);

	return (0);
	}

	void
	zfs_znode_delete(znode_t zp, dmu_tx_t tx)
	{
	zfsvfs_t *zfsvfs = zp->z_zfsvfs;
	objset_t *os = zfsvfs->z_os;
	uint64_t obj = zp->z_id;
	uint64_t acl_obj = zfs_external_acl(zp);

	ZFS_OBJ_HOLD_ENTER(zfsvfs, obj);
	if (acl_obj) {
	VERIFY(!zp->z_is_sa);
	VERIFY(0 == dmu_object_free(os, acl_obj, tx));
	}
	VERIFY(0 == dmu_object_free(os, obj, tx));
	zfs_znode_dmu_fini(zp);
	ZFS_OBJ_HOLD_EXIT(zfsvfs, obj);
	zfs_znode_free(zp);
	}

	void
	zfs_zinactive(znode_t *zp)
	{
	zfsvfs_t *zfsvfs = zp->z_zfsvfs;
	uint64_t z_id = zp->z_id;

	ASSERT(zp->z_sa_hdl);

	/*
	* Don't allow a zfs_zget() while were trying to release this znode
	*/
	ZFS_OBJ_HOLD_ENTER(zfsvfs, z_id);

	/*
	* If this was the last reference to a file with no links, remove
	* the file from the file system unless the file system is mounted
	* read-only. That can happen, for example, if the file system was
	* originally read-write, the file was opened, then unlinked and
	* the file system was made read-only before the file was finally
	* closed. The file will remain in the unlinked set.
	*/
	if (zp->z_unlinked) {
	ASSERT(!zfsvfs->z_issnap);
	if ((zfsvfs->z_vfs->vfs_flag & VFS_RDONLY) == 0) {
	ZFS_OBJ_HOLD_EXIT(zfsvfs, z_id);
	zfs_rmnode(zp);
	return;
	}
	}

	zfs_znode_dmu_fini(zp);
	ZFS_OBJ_HOLD_EXIT(zfsvfs, z_id);
	zfs_znode_free(zp);
	}

	void
	zfs_znode_free(znode_t *zp)
	{
	zfsvfs_t *zfsvfs = zp->z_zfsvfs;
	+#if __FreeBSD_version >= 1300139
	char *symlink;
	+#endif

	ASSERT(zp->z_sa_hdl == NULL);
	zp->z_vnode = NULL;
	mutex_enter(&zfsvfs->z_znodes_lock);
	POINTER_INVALIDATE(&zp->z_zfsvfs);
	list_remove(&zfsvfs->z_all_znodes, zp);
	zfsvfs->z_nr_znodes--;
	mutex_exit(&zfsvfs->z_znodes_lock);
	symlink = atomic_load_ptr(&zp->z_cached_symlink);
	if (symlink != NULL) {
	atomic_store_rel_ptr((uintptr_t *)&zp->z_cached_symlink, (uintptr_t)NULL);
	cache_symlink_free(symlink, strlen(symlink) + 1);
	}

	+#if __FreeBSD_version >= 1300139
	+ symlink = atomic_load_ptr(&zp->z_cached_symlink);
	+ if (symlink != NULL) {
	+ atomic_store_rel_ptr((uintptr_t *)&zp->z_cached_symlink,
	+ (uintptr_t)NULL);
	+ cache_symlink_free(symlink, strlen(symlink) + 1);
	+ }
	+#endif
	+
	if (zp->z_acl_cached) {
	zfs_acl_free(zp->z_acl_cached);
	zp->z_acl_cached = NULL;
	}

	zfs_znode_free_kmem(zp);
	}

	void
	zfs_tstamp_update_setup_ext(znode_t *zp, uint_t flag, uint64_t mtime[2],
	uint64_t ctime[2], boolean_t have_tx)
	{
	timestruc_t now;

	vfs_timestamp(&now);

	if (have_tx) { /* will sa_bulk_update happen really soon? */
	zp->z_atime_dirty = 0;
	zp->z_seq++;
	} else {
	zp->z_atime_dirty = 1;
	}

	if (flag & AT_ATIME) {
	ZFS_TIME_ENCODE(&now, zp->z_atime);
	}

	if (flag & AT_MTIME) {
	ZFS_TIME_ENCODE(&now, mtime);
	if (zp->z_zfsvfs->z_use_fuids) {
	zp->z_pflags \|= (ZFS_ARCHIVE \|
	ZFS_AV_MODIFIED);
	}
	}

	if (flag & AT_CTIME) {
	ZFS_TIME_ENCODE(&now, ctime);
	if (zp->z_zfsvfs->z_use_fuids)
	zp->z_pflags \|= ZFS_ARCHIVE;
	}
	}


	void
	zfs_tstamp_update_setup(znode_t *zp, uint_t flag, uint64_t mtime[2],
	uint64_t ctime[2])
	{
	zfs_tstamp_update_setup_ext(zp, flag, mtime, ctime, B_TRUE);
	}
	/*
	* Grow the block size for a file.
	*
	* IN: zp - znode of file to free data in.
	* size - requested block size
	* tx - open transaction.
	*
	* NOTE: this function assumes that the znode is write locked.
	*/
	void
	zfs_grow_blocksize(znode_t zp, uint64_t size, dmu_tx_t tx)
	{
	int error;
	u_longlong_t dummy;

	if (size <= zp->z_blksz)
	return;
	/*
	* If the file size is already greater than the current blocksize,
	* we will not grow. If there is more than one block in a file,
	* the blocksize cannot change.
	*/
	if (zp->z_blksz && zp->z_size > zp->z_blksz)
	return;

	error = dmu_object_set_blocksize(zp->z_zfsvfs->z_os, zp->z_id,
	size, 0, tx);

	if (error == ENOTSUP)
	return;
	ASSERT0(error);

	/* What blocksize did we actually get? */
	dmu_object_size_from_db(sa_get_db(zp->z_sa_hdl), &zp->z_blksz, &dummy);
	}

	/*
	* Increase the file length
	*
	* IN: zp - znode of file to free data in.
	* end - new end-of-file
	*
	* RETURN: 0 on success, error code on failure
	*/
	static int
	zfs_extend(znode_t *zp, uint64_t end)
	{
	zfsvfs_t *zfsvfs = zp->z_zfsvfs;
	dmu_tx_t *tx;
	zfs_locked_range_t *lr;
	uint64_t newblksz;
	int error;

	/*
	* We will change zp_size, lock the whole file.
	*/
	lr = zfs_rangelock_enter(&zp->z_rangelock, 0, UINT64_MAX, RL_WRITER);

	/*
	* Nothing to do if file already at desired length.
	*/
	if (end <= zp->z_size) {
	zfs_rangelock_exit(lr);
	return (0);
	}
	tx = dmu_tx_create(zfsvfs->z_os);
	dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
	zfs_sa_upgrade_txholds(tx, zp);
	if (end > zp->z_blksz &&
	(!ISP2(zp->z_blksz) \|\| zp->z_blksz < zfsvfs->z_max_blksz)) {
	/*
	* We are growing the file past the current block size.
	*/
	if (zp->z_blksz > zp->z_zfsvfs->z_max_blksz) {
	/*
	* File's blocksize is already larger than the
	* "recordsize" property. Only let it grow to
	* the next power of 2.
	*/
	ASSERT(!ISP2(zp->z_blksz));
	newblksz = MIN(end, 1 << highbit64(zp->z_blksz));
	} else {
	newblksz = MIN(end, zp->z_zfsvfs->z_max_blksz);
	}
	dmu_tx_hold_write(tx, zp->z_id, 0, newblksz);
	} else {
	newblksz = 0;
	}

	error = dmu_tx_assign(tx, TXG_WAIT);
	if (error) {
	dmu_tx_abort(tx);
	zfs_rangelock_exit(lr);
	return (error);
	}

	if (newblksz)
	zfs_grow_blocksize(zp, newblksz, tx);

	zp->z_size = end;

	VERIFY(0 == sa_update(zp->z_sa_hdl, SA_ZPL_SIZE(zp->z_zfsvfs),
	&zp->z_size, sizeof (zp->z_size), tx));

	vnode_pager_setsize(ZTOV(zp), end);

	zfs_rangelock_exit(lr);

	dmu_tx_commit(tx);

	return (0);
	}

	/*
	* Free space in a file.
	*
	* IN: zp - znode of file to free data in.
	* off - start of section to free.
	* len - length of section to free.
	*
	* RETURN: 0 on success, error code on failure
	*/
	static int
	zfs_free_range(znode_t *zp, uint64_t off, uint64_t len)
	{
	zfsvfs_t *zfsvfs = zp->z_zfsvfs;
	zfs_locked_range_t *lr;
	int error;

	/*
	* Lock the range being freed.
	*/
	lr = zfs_rangelock_enter(&zp->z_rangelock, off, len, RL_WRITER);

	/*
	* Nothing to do if file already at desired length.
	*/
	if (off >= zp->z_size) {
	zfs_rangelock_exit(lr);
	return (0);
	}

	if (off + len > zp->z_size)
	len = zp->z_size - off;

	error = dmu_free_long_range(zfsvfs->z_os, zp->z_id, off, len);

	if (error == 0) {
	/*
	* In FreeBSD we cannot free block in the middle of a file,
	* but only at the end of a file, so this code path should
	* never happen.
	*/
	vnode_pager_setsize(ZTOV(zp), off);
	}

	zfs_rangelock_exit(lr);

	return (error);
	}

	/*
	* Truncate a file
	*
	* IN: zp - znode of file to free data in.
	* end - new end-of-file.
	*
	* RETURN: 0 on success, error code on failure
	*/
	static int
	zfs_trunc(znode_t *zp, uint64_t end)
	{
	zfsvfs_t *zfsvfs = zp->z_zfsvfs;
	vnode_t *vp = ZTOV(zp);
	dmu_tx_t *tx;
	zfs_locked_range_t *lr;
	int error;
	sa_bulk_attr_t bulk[2];
	int count = 0;

	/*
	* We will change zp_size, lock the whole file.
	*/
	lr = zfs_rangelock_enter(&zp->z_rangelock, 0, UINT64_MAX, RL_WRITER);

	/*
	* Nothing to do if file already at desired length.
	*/
	if (end >= zp->z_size) {
	zfs_rangelock_exit(lr);
	return (0);
	}

	error = dmu_free_long_range(zfsvfs->z_os, zp->z_id, end,
	DMU_OBJECT_END);
	if (error) {
	zfs_rangelock_exit(lr);
	return (error);
	}
	tx = dmu_tx_create(zfsvfs->z_os);
	dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
	zfs_sa_upgrade_txholds(tx, zp);
	dmu_tx_mark_netfree(tx);
	error = dmu_tx_assign(tx, TXG_WAIT);
	if (error) {
	dmu_tx_abort(tx);
	zfs_rangelock_exit(lr);
	return (error);
	}

	zp->z_size = end;
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_SIZE(zfsvfs),
	NULL, &zp->z_size, sizeof (zp->z_size));

	if (end == 0) {
	zp->z_pflags &= ~ZFS_SPARSE;
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zfsvfs),
	NULL, &zp->z_pflags, 8);
	}
	VERIFY(sa_bulk_update(zp->z_sa_hdl, bulk, count, tx) == 0);

	dmu_tx_commit(tx);

	/*
	* Clear any mapped pages in the truncated region. This has to
	* happen outside of the transaction to avoid the possibility of
	* a deadlock with someone trying to push a page that we are
	* about to invalidate.
	*/
	vnode_pager_setsize(vp, end);

	zfs_rangelock_exit(lr);

	return (0);
	}

	/*
	* Free space in a file
	*
	* IN: zp - znode of file to free data in.
	* off - start of range
	* len - end of range (0 => EOF)
	* flag - current file open mode flags.
	* log - TRUE if this action should be logged
	*
	* RETURN: 0 on success, error code on failure
	*/
	int
	zfs_freesp(znode_t *zp, uint64_t off, uint64_t len, int flag, boolean_t log)
	{
	dmu_tx_t *tx;
	zfsvfs_t *zfsvfs = zp->z_zfsvfs;
	zilog_t *zilog = zfsvfs->z_log;
	uint64_t mode;
	uint64_t mtime[2], ctime[2];
	sa_bulk_attr_t bulk[3];
	int count = 0;
	int error;

	if ((error = sa_lookup(zp->z_sa_hdl, SA_ZPL_MODE(zfsvfs), &mode,
	sizeof (mode))) != 0)
	return (error);

	if (off > zp->z_size) {
	error = zfs_extend(zp, off+len);
	if (error == 0 && log)
	goto log;
	else
	return (error);
	}

	if (len == 0) {
	error = zfs_trunc(zp, off);
	} else {
	if ((error = zfs_free_range(zp, off, len)) == 0 &&
	off + len > zp->z_size)
	error = zfs_extend(zp, off+len);
	}
	if (error \|\| !log)
	return (error);
	log:
	tx = dmu_tx_create(zfsvfs->z_os);
	dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
	zfs_sa_upgrade_txholds(tx, zp);
	error = dmu_tx_assign(tx, TXG_WAIT);
	if (error) {
	dmu_tx_abort(tx);
	return (error);
	}

	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zfsvfs), NULL, mtime, 16);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs), NULL, ctime, 16);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zfsvfs),
	NULL, &zp->z_pflags, 8);
	zfs_tstamp_update_setup(zp, CONTENT_MODIFIED, mtime, ctime);
	error = sa_bulk_update(zp->z_sa_hdl, bulk, count, tx);
	ASSERT(error == 0);

	zfs_log_truncate(zilog, tx, TX_TRUNCATE, zp, off, len);

	dmu_tx_commit(tx);
	return (0);
	}

	void
	zfs_create_fs(objset_t os, cred_t cr, nvlist_t zplprops, dmu_tx_t tx)
	{
	uint64_t moid, obj, sa_obj, version;
	uint64_t sense = ZFS_CASE_SENSITIVE;
	uint64_t norm = 0;
	nvpair_t *elem;
	int error;
	int i;
	znode_t *rootzp = NULL;
	zfsvfs_t *zfsvfs;
	vattr_t vattr;
	znode_t *zp;
	zfs_acl_ids_t acl_ids;

	/*
	* First attempt to create master node.
	*/
	/*
	* In an empty objset, there are no blocks to read and thus
	* there can be no i/o errors (which we assert below).
	*/
	moid = MASTER_NODE_OBJ;
	error = zap_create_claim(os, moid, DMU_OT_MASTER_NODE,
	DMU_OT_NONE, 0, tx);
	ASSERT(error == 0);

	/*
	* Set starting attributes.
	*/
	version = zfs_zpl_version_map(spa_version(dmu_objset_spa(os)));
	elem = NULL;
	while ((elem = nvlist_next_nvpair(zplprops, elem)) != NULL) {
	/* For the moment we expect all zpl props to be uint64_ts */
	uint64_t val;
	char *name;

	ASSERT(nvpair_type(elem) == DATA_TYPE_UINT64);
	VERIFY(nvpair_value_uint64(elem, &val) == 0);
	name = nvpair_name(elem);
	if (strcmp(name, zfs_prop_to_name(ZFS_PROP_VERSION)) == 0) {
	if (val < version)
	version = val;
	} else {
	error = zap_update(os, moid, name, 8, 1, &val, tx);
	}
	ASSERT(error == 0);
	if (strcmp(name, zfs_prop_to_name(ZFS_PROP_NORMALIZE)) == 0)
	norm = val;
	else if (strcmp(name, zfs_prop_to_name(ZFS_PROP_CASE)) == 0)
	sense = val;
	}
	ASSERT(version != 0);
	error = zap_update(os, moid, ZPL_VERSION_STR, 8, 1, &version, tx);

	/*
	* Create zap object used for SA attribute registration
	*/

	if (version >= ZPL_VERSION_SA) {
	sa_obj = zap_create(os, DMU_OT_SA_MASTER_NODE,
	DMU_OT_NONE, 0, tx);
	error = zap_add(os, moid, ZFS_SA_ATTRS, 8, 1, &sa_obj, tx);
	ASSERT(error == 0);
	} else {
	sa_obj = 0;
	}
	/*
	* Create a delete queue.
	*/
	obj = zap_create(os, DMU_OT_UNLINKED_SET, DMU_OT_NONE, 0, tx);

	error = zap_add(os, moid, ZFS_UNLINKED_SET, 8, 1, &obj, tx);
	ASSERT(error == 0);

	/*
	* Create root znode. Create minimal znode/vnode/zfsvfs
	* to allow zfs_mknode to work.
	*/
	VATTR_NULL(&vattr);
	vattr.va_mask = AT_MODE\|AT_UID\|AT_GID;
	vattr.va_type = VDIR;
	vattr.va_mode = S_IFDIR\|0755;
	vattr.va_uid = crgetuid(cr);
	vattr.va_gid = crgetgid(cr);

	zfsvfs = kmem_zalloc(sizeof (zfsvfs_t), KM_SLEEP);

	rootzp = zfs_znode_alloc_kmem(KM_SLEEP);
	ASSERT(!POINTER_IS_VALID(rootzp->z_zfsvfs));
	rootzp->z_unlinked = 0;
	rootzp->z_atime_dirty = 0;
	rootzp->z_is_sa = USE_SA(version, os);

	zfsvfs->z_os = os;
	zfsvfs->z_parent = zfsvfs;
	zfsvfs->z_version = version;
	zfsvfs->z_use_fuids = USE_FUIDS(version, os);
	zfsvfs->z_use_sa = USE_SA(version, os);
	zfsvfs->z_norm = norm;

	error = sa_setup(os, sa_obj, zfs_attr_table, ZPL_END,
	&zfsvfs->z_attr_table);

	ASSERT(error == 0);

	/*
	* Fold case on file systems that are always or sometimes case
	* insensitive.
	*/
	if (sense == ZFS_CASE_INSENSITIVE \|\| sense == ZFS_CASE_MIXED)
	zfsvfs->z_norm \|= U8_TEXTPREP_TOUPPER;

	mutex_init(&zfsvfs->z_znodes_lock, NULL, MUTEX_DEFAULT, NULL);
	list_create(&zfsvfs->z_all_znodes, sizeof (znode_t),
	offsetof(znode_t, z_link_node));

	for (i = 0; i != ZFS_OBJ_MTX_SZ; i++)
	mutex_init(&zfsvfs->z_hold_mtx[i], NULL, MUTEX_DEFAULT, NULL);

	rootzp->z_zfsvfs = zfsvfs;
	VERIFY(0 == zfs_acl_ids_create(rootzp, IS_ROOT_NODE, &vattr,
	cr, NULL, &acl_ids));
	zfs_mknode(rootzp, &vattr, tx, cr, IS_ROOT_NODE, &zp, &acl_ids);
	ASSERT3P(zp, ==, rootzp);
	error = zap_add(os, moid, ZFS_ROOT_OBJ, 8, 1, &rootzp->z_id, tx);
	ASSERT(error == 0);
	zfs_acl_ids_free(&acl_ids);
	POINTER_INVALIDATE(&rootzp->z_zfsvfs);

	sa_handle_destroy(rootzp->z_sa_hdl);
	zfs_znode_free_kmem(rootzp);

	/*
	* Create shares directory
	*/

	error = zfs_create_share_dir(zfsvfs, tx);

	ASSERT(error == 0);

	for (i = 0; i != ZFS_OBJ_MTX_SZ; i++)
	mutex_destroy(&zfsvfs->z_hold_mtx[i]);
	kmem_free(zfsvfs, sizeof (zfsvfs_t));
	}
	#endif /* _KERNEL */

	static int
	zfs_sa_setup(objset_t osp, sa_attr_type_t *sa_table)
	{
	uint64_t sa_obj = 0;
	int error;

	error = zap_lookup(osp, MASTER_NODE_OBJ, ZFS_SA_ATTRS, 8, 1, &sa_obj);
	if (error != 0 && error != ENOENT)
	return (error);

	error = sa_setup(osp, sa_obj, zfs_attr_table, ZPL_END, sa_table);
	return (error);
	}

	static int
	zfs_grab_sa_handle(objset_t osp, uint64_t obj, sa_handle_t *hdlp,
	dmu_buf_t *db, void tag)
	{
	dmu_object_info_t doi;
	int error;

	if ((error = sa_buf_hold(osp, obj, tag, db)) != 0)
	return (error);

	dmu_object_info_from_db(*db, &doi);
	if ((doi.doi_bonus_type != DMU_OT_SA &&
	doi.doi_bonus_type != DMU_OT_ZNODE) \|\|
	(doi.doi_bonus_type == DMU_OT_ZNODE &&
	doi.doi_bonus_size < sizeof (znode_phys_t))) {
	sa_buf_rele(*db, tag);
	return (SET_ERROR(ENOTSUP));
	}

	error = sa_handle_get(osp, obj, NULL, SA_HDL_PRIVATE, hdlp);
	if (error != 0) {
	sa_buf_rele(*db, tag);
	return (error);
	}

	return (0);
	}

	static void
	zfs_release_sa_handle(sa_handle_t hdl, dmu_buf_t db, void *tag)
	{
	sa_handle_destroy(hdl);
	sa_buf_rele(db, tag);
	}

	/*
	* Given an object number, return its parent object number and whether
	* or not the object is an extended attribute directory.
	*/
	static int
	zfs_obj_to_pobj(objset_t osp, sa_handle_t hdl, sa_attr_type_t *sa_table,
	uint64_t pobjp, int is_xattrdir)
	{
	uint64_t parent;
	uint64_t pflags;
	uint64_t mode;
	uint64_t parent_mode;
	sa_bulk_attr_t bulk[3];
	sa_handle_t *sa_hdl;
	dmu_buf_t *sa_db;
	int count = 0;
	int error;

	SA_ADD_BULK_ATTR(bulk, count, sa_table[ZPL_PARENT], NULL,
	&parent, sizeof (parent));
	SA_ADD_BULK_ATTR(bulk, count, sa_table[ZPL_FLAGS], NULL,
	&pflags, sizeof (pflags));
	SA_ADD_BULK_ATTR(bulk, count, sa_table[ZPL_MODE], NULL,
	&mode, sizeof (mode));

	if ((error = sa_bulk_lookup(hdl, bulk, count)) != 0)
	return (error);

	/*
	* When a link is removed its parent pointer is not changed and will
	* be invalid. There are two cases where a link is removed but the
	* file stays around, when it goes to the delete queue and when there
	* are additional links.
	*/
	error = zfs_grab_sa_handle(osp, parent, &sa_hdl, &sa_db, FTAG);
	if (error != 0)
	return (error);

	error = sa_lookup(sa_hdl, ZPL_MODE, &parent_mode, sizeof (parent_mode));
	zfs_release_sa_handle(sa_hdl, sa_db, FTAG);
	if (error != 0)
	return (error);

	*is_xattrdir = ((pflags & ZFS_XATTR) != 0) && S_ISDIR(mode);

	/*
	* Extended attributes can be applied to files, directories, etc.
	* Otherwise the parent must be a directory.
	*/
	if (!*is_xattrdir && !S_ISDIR(parent_mode))
	return (SET_ERROR(EINVAL));

	*pobjp = parent;

	return (0);
	}

	/*
	* Given an object number, return some zpl level statistics
	*/
	static int
	zfs_obj_to_stats_impl(sa_handle_t hdl, sa_attr_type_t sa_table,
	zfs_stat_t *sb)
	{
	sa_bulk_attr_t bulk[4];
	int count = 0;

	SA_ADD_BULK_ATTR(bulk, count, sa_table[ZPL_MODE], NULL,
	&sb->zs_mode, sizeof (sb->zs_mode));
	SA_ADD_BULK_ATTR(bulk, count, sa_table[ZPL_GEN], NULL,
	&sb->zs_gen, sizeof (sb->zs_gen));
	SA_ADD_BULK_ATTR(bulk, count, sa_table[ZPL_LINKS], NULL,
	&sb->zs_links, sizeof (sb->zs_links));
	SA_ADD_BULK_ATTR(bulk, count, sa_table[ZPL_CTIME], NULL,
	&sb->zs_ctime, sizeof (sb->zs_ctime));

	return (sa_bulk_lookup(hdl, bulk, count));
	}

	static int
	zfs_obj_to_path_impl(objset_t osp, uint64_t obj, sa_handle_t hdl,
	sa_attr_type_t sa_table, char buf, int len)
	{
	sa_handle_t *sa_hdl;
	sa_handle_t *prevhdl = NULL;
	dmu_buf_t *prevdb = NULL;
	dmu_buf_t *sa_db = NULL;
	char *path = buf + len - 1;
	int error;

	*path = '\0';
	sa_hdl = hdl;

	uint64_t deleteq_obj;
	VERIFY0(zap_lookup(osp, MASTER_NODE_OBJ,
	ZFS_UNLINKED_SET, sizeof (uint64_t), 1, &deleteq_obj));
	error = zap_lookup_int(osp, deleteq_obj, obj);
	if (error == 0) {
	return (ESTALE);
	} else if (error != ENOENT) {
	return (error);
	}
	error = 0;

	for (;;) {
	uint64_t pobj;
	char component[MAXNAMELEN + 2];
	size_t complen;
	int is_xattrdir;

	if (prevdb) {
	ASSERT(prevhdl != NULL);
	zfs_release_sa_handle(prevhdl, prevdb, FTAG);
	}

	if ((error = zfs_obj_to_pobj(osp, sa_hdl, sa_table, &pobj,
	&is_xattrdir)) != 0)
	break;

	if (pobj == obj) {
	if (path[0] != '/')
	*--path = '/';
	break;
	}

	component[0] = '/';
	if (is_xattrdir) {
	(void) sprintf(component + 1, "<xattrdir>");
	} else {
	error = zap_value_search(osp, pobj, obj,
	ZFS_DIRENT_OBJ(-1ULL), component + 1);
	if (error != 0)
	break;
	}

	complen = strlen(component);
	path -= complen;
	ASSERT(path >= buf);
	bcopy(component, path, complen);
	obj = pobj;

	if (sa_hdl != hdl) {
	prevhdl = sa_hdl;
	prevdb = sa_db;
	}
	error = zfs_grab_sa_handle(osp, obj, &sa_hdl, &sa_db, FTAG);
	if (error != 0) {
	sa_hdl = prevhdl;
	sa_db = prevdb;
	break;
	}
	}

	if (sa_hdl != NULL && sa_hdl != hdl) {
	ASSERT(sa_db != NULL);
	zfs_release_sa_handle(sa_hdl, sa_db, FTAG);
	}

	if (error == 0)
	(void) memmove(buf, path, buf + len - path);

	return (error);
	}

	int
	zfs_obj_to_path(objset_t osp, uint64_t obj, char buf, int len)
	{
	sa_attr_type_t *sa_table;
	sa_handle_t *hdl;
	dmu_buf_t *db;
	int error;

	error = zfs_sa_setup(osp, &sa_table);
	if (error != 0)
	return (error);

	error = zfs_grab_sa_handle(osp, obj, &hdl, &db, FTAG);
	if (error != 0)
	return (error);

	error = zfs_obj_to_path_impl(osp, obj, hdl, sa_table, buf, len);

	zfs_release_sa_handle(hdl, db, FTAG);
	return (error);
	}

	int
	zfs_obj_to_stats(objset_t osp, uint64_t obj, zfs_stat_t sb,
	char *buf, int len)
	{
	char *path = buf + len - 1;
	sa_attr_type_t *sa_table;
	sa_handle_t *hdl;
	dmu_buf_t *db;
	int error;

	*path = '\0';

	error = zfs_sa_setup(osp, &sa_table);
	if (error != 0)
	return (error);

	error = zfs_grab_sa_handle(osp, obj, &hdl, &db, FTAG);
	if (error != 0)
	return (error);

	error = zfs_obj_to_stats_impl(hdl, sa_table, sb);
	if (error != 0) {
	zfs_release_sa_handle(hdl, db, FTAG);
	return (error);
	}

	error = zfs_obj_to_path_impl(osp, obj, hdl, sa_table, buf, len);

	zfs_release_sa_handle(hdl, db, FTAG);
	return (error);
	}


	void
	zfs_znode_update_vfs(znode_t *zp)
	{
	vm_object_t object;

	if ((object = ZTOV(zp)->v_object) == NULL \|\|
	zp->z_size == object->un_pager.vnp.vnp_size)
	return;

	vnode_pager_setsize(ZTOV(zp), zp->z_size);
	}


	#ifdef _KERNEL
	int
	zfs_znode_parent_and_name(znode_t zp, znode_t dzpp, char buf)
	{
	zfsvfs_t *zfsvfs = zp->z_zfsvfs;
	uint64_t parent;
	int is_xattrdir;
	int err;

	/* Extended attributes should not be visible as regular files. */
	if ((zp->z_pflags & ZFS_XATTR) != 0)
	return (SET_ERROR(EINVAL));

	err = zfs_obj_to_pobj(zfsvfs->z_os, zp->z_sa_hdl, zfsvfs->z_attr_table,
	&parent, &is_xattrdir);
	if (err != 0)
	return (err);
	ASSERT0(is_xattrdir);

	/* No name as this is a root object. */
	if (parent == zp->z_id)
	return (SET_ERROR(EINVAL));

	err = zap_value_search(zfsvfs->z_os, parent, zp->z_id,
	ZFS_DIRENT_OBJ(-1ULL), buf);
	if (err != 0)
	return (err);
	err = zfs_zget(zfsvfs, parent, dzpp);
	return (err);
	}
	#endif /* _KERNEL */
	diff --git a/sys/contrib/openzfs/module/os/freebsd/zfs/zio_crypt.c b/sys/contrib/openzfs/module/os/freebsd/zfs/zio_crypt.c
	index 9fe678d2574f..fb714d399296 100644
	--- a/sys/contrib/openzfs/module/os/freebsd/zfs/zio_crypt.c
	+++ b/sys/contrib/openzfs/module/os/freebsd/zfs/zio_crypt.c
	@@ -1,1839 +1,1826 @@
	/*
	* CDDL HEADER START
	*
	* This file and its contents are supplied under the terms of the
	* Common Development and Distribution License ("CDDL"), version 1.0.
	* You may only use this file in accordance with the terms of version
	* 1.0 of the CDDL.
	*
	* A full copy of the text of the CDDL should have accompanied this
	* source. A copy of the CDDL is also available via the Internet at
	* http://www.illumos.org/license/CDDL.
	*
	* CDDL HEADER END
	*/

	/*
	* Copyright (c) 2017, Datto, Inc. All rights reserved.
	*/

	#include <sys/zio_crypt.h>
	#include <sys/dmu.h>
	#include <sys/dmu_objset.h>
	#include <sys/dnode.h>
	#include <sys/fs/zfs.h>
	#include <sys/zio.h>
	#include <sys/zil.h>
	#include <sys/sha2.h>
	#include <sys/hkdf.h>

	/*
	* This file is responsible for handling all of the details of generating
	* encryption parameters and performing encryption and authentication.
	*
	* BLOCK ENCRYPTION PARAMETERS:
	* Encryption /Authentication Algorithm Suite (crypt):
	* The encryption algorithm, mode, and key length we are going to use. We
	* currently support AES in either GCM or CCM modes with 128, 192, and 256 bit
	* keys. All authentication is currently done with SHA512-HMAC.
	*
	* Plaintext:
	* The unencrypted data that we want to encrypt.
	*
	* Initialization Vector (IV):
	* An initialization vector for the encryption algorithms. This is used to
	* "tweak" the encryption algorithms so that two blocks of the same data are
	* encrypted into different ciphertext outputs, thus obfuscating block patterns.
	* The supported encryption modes (AES-GCM and AES-CCM) require that an IV is
	* never reused with the same encryption key. This value is stored unencrypted
	* and must simply be provided to the decryption function. We use a 96 bit IV
	* (as recommended by NIST) for all block encryption. For non-dedup blocks we
	* derive the IV randomly. The first 64 bits of the IV are stored in the second
	* word of DVA[2] and the remaining 32 bits are stored in the upper 32 bits of
	* blk_fill. This is safe because encrypted blocks can't use the upper 32 bits
	* of blk_fill. We only encrypt level 0 blocks, which normally have a fill count
	* of 1. The only exception is for DMU_OT_DNODE objects, where the fill count of
	* level 0 blocks is the number of allocated dnodes in that block. The on-disk
	* format supports at most 2^15 slots per L0 dnode block, because the maximum
	* block size is 16MB (2^24). In either case, for level 0 blocks this number
	* will still be smaller than UINT32_MAX so it is safe to store the IV in the
	* top 32 bits of blk_fill, while leaving the bottom 32 bits of the fill count
	* for the dnode code.
	*
	* Master key:
	* This is the most important secret data of an encrypted dataset. It is used
	* along with the salt to generate that actual encryption keys via HKDF. We
	* do not use the master key to directly encrypt any data because there are
	* theoretical limits on how much data can actually be safely encrypted with
	* any encryption mode. The master key is stored encrypted on disk with the
	* user's wrapping key. Its length is determined by the encryption algorithm.
	* For details on how this is stored see the block comment in dsl_crypt.c
	*
	* Salt:
	* Used as an input to the HKDF function, along with the master key. We use a
	* 64 bit salt, stored unencrypted in the first word of DVA[2]. Any given salt
	* can be used for encrypting many blocks, so we cache the current salt and the
	* associated derived key in zio_crypt_t so we do not need to derive it again
	* needlessly.
	*
	* Encryption Key:
	* A secret binary key, generated from an HKDF function used to encrypt and
	* decrypt data.
	*
	* Message Authentication Code (MAC)
	* The MAC is an output of authenticated encryption modes such as AES-GCM and
	* AES-CCM. Its purpose is to ensure that an attacker cannot modify encrypted
	* data on disk and return garbage to the application. Effectively, it is a
	* checksum that can not be reproduced by an attacker. We store the MAC in the
	* second 128 bits of blk_cksum, leaving the first 128 bits for a truncated
	* regular checksum of the ciphertext which can be used for scrubbing.
	*
	* OBJECT AUTHENTICATION:
	* Some object types, such as DMU_OT_MASTER_NODE cannot be encrypted because
	* they contain some info that always needs to be readable. To prevent this
	* data from being altered, we authenticate this data using SHA512-HMAC. This
	* will produce a MAC (similar to the one produced via encryption) which can
	* be used to verify the object was not modified. HMACs do not require key
	* rotation or IVs, so we can keep up to the full 3 copies of authenticated
	* data.
	*
	* ZIL ENCRYPTION:
	* ZIL blocks have their bp written to disk ahead of the associated data, so we
	* cannot store the MAC there as we normally do. For these blocks the MAC is
	* stored in the embedded checksum within the zil_chain_t header. The salt and
	* IV are generated for the block on bp allocation instead of at encryption
	* time. In addition, ZIL blocks have some pieces that must be left in plaintext
	* for claiming even though all of the sensitive user data still needs to be
	* encrypted. The function zio_crypt_init_uios_zil() handles parsing which
	* pieces of the block need to be encrypted. All data that is not encrypted is
	* authenticated using the AAD mechanisms that the supported encryption modes
	* provide for. In order to preserve the semantics of the ZIL for encrypted
	* datasets, the ZIL is not protected at the objset level as described below.
	*
	* DNODE ENCRYPTION:
	* Similarly to ZIL blocks, the core part of each dnode_phys_t needs to be left
	* in plaintext for scrubbing and claiming, but the bonus buffers might contain
	* sensitive user data. The function zio_crypt_init_uios_dnode() handles parsing
	- * which which pieces of the block need to be encrypted. For more details about
	+ * which pieces of the block need to be encrypted. For more details about
	* dnode authentication and encryption, see zio_crypt_init_uios_dnode().
	*
	* OBJECT SET AUTHENTICATION:
	* Up to this point, everything we have encrypted and authenticated has been
	* at level 0 (or -2 for the ZIL). If we did not do any further work the
	* on-disk format would be susceptible to attacks that deleted or rearranged
	* the order of level 0 blocks. Ideally, the cleanest solution would be to
	* maintain a tree of authentication MACs going up the bp tree. However, this
	* presents a problem for raw sends. Send files do not send information about
	* indirect blocks so there would be no convenient way to transfer the MACs and
	* they cannot be recalculated on the receive side without the master key which
	* would defeat one of the purposes of raw sends in the first place. Instead,
	* for the indirect levels of the bp tree, we use a regular SHA512 of the MACs
	* from the level below. We also include some portable fields from blk_prop such
	* as the lsize and compression algorithm to prevent the data from being
	* misinterpreted.
	*
	* At the objset level, we maintain 2 separate 256 bit MACs in the
	* objset_phys_t. The first one is "portable" and is the logical root of the
	* MAC tree maintained in the metadnode's bps. The second, is "local" and is
	* used as the root MAC for the user accounting objects, which are also not
	* transferred via "zfs send". The portable MAC is sent in the DRR_BEGIN payload
	* of the send file. The useraccounting code ensures that the useraccounting
	* info is not present upon a receive, so the local MAC can simply be cleared
	* out at that time. For more info about objset_phys_t authentication, see
	* zio_crypt_do_objset_hmacs().
	*
	* CONSIDERATIONS FOR DEDUP:
	* In order for dedup to work, blocks that we want to dedup with one another
	* need to use the same IV and encryption key, so that they will have the same
	* ciphertext. Normally, one should never reuse an IV with the same encryption
	* key or else AES-GCM and AES-CCM can both actually leak the plaintext of both
	* blocks. In this case, however, since we are using the same plaintext as
	* well all that we end up with is a duplicate of the original ciphertext we
	* already had. As a result, an attacker with read access to the raw disk will
	* be able to tell which blocks are the same but this information is given away
	* by dedup anyway. In order to get the same IVs and encryption keys for
	* equivalent blocks of data we use an HMAC of the plaintext. We use an HMAC
	* here so that a reproducible checksum of the plaintext is never available to
	* the attacker. The HMAC key is kept alongside the master key, encrypted on
	* disk. The first 64 bits of the HMAC are used in place of the random salt, and
	* the next 96 bits are used as the IV. As a result of this mechanism, dedup
	* will only work within a clone family since encrypted dedup requires use of
	* the same master and HMAC keys.
	*/

	/*
	* After encrypting many blocks with the same key we may start to run up
	* against the theoretical limits of how much data can securely be encrypted
	* with a single key using the supported encryption modes. The most obvious
	* limitation is that our risk of generating 2 equivalent 96 bit IVs increases
	* the more IVs we generate (which both GCM and CCM modes strictly forbid).
	* This risk actually grows surprisingly quickly over time according to the
	* Birthday Problem. With a total IV space of 2^(96 bits), and assuming we have
	* generated n IVs with a cryptographically secure RNG, the approximate
	* probability p(n) of a collision is given as:
	*
	* p(n) ~= e^(-n(n-1)/(2(2^96)))
	*
	* [http://www.math.cornell.edu/~mec/2008-2009/TianyiZheng/Birthday.html]
	*
	* Assuming that we want to ensure that p(n) never goes over 1 / 1 trillion
	* we must not write more than 398,065,730 blocks with the same encryption key.
	* Therefore, we rotate our keys after 400,000,000 blocks have been written by
	* generating a new random 64 bit salt for our HKDF encryption key generation
	* function.
	*/
	#define ZFS_KEY_MAX_SALT_USES_DEFAULT 400000000
	#define ZFS_CURRENT_MAX_SALT_USES \
	(MIN(zfs_key_max_salt_uses, ZFS_KEY_MAX_SALT_USES_DEFAULT))
	unsigned long zfs_key_max_salt_uses = ZFS_KEY_MAX_SALT_USES_DEFAULT;

	/*
	* Set to a nonzero value to cause zio_do_crypt_uio() to fail 1/this many
	* calls, to test decryption error handling code paths.
	*/
	uint64_t zio_decrypt_fail_fraction = 0;

	typedef struct blkptr_auth_buf {
	uint64_t bab_prop; /* blk_prop - portable mask */
	uint8_t bab_mac[ZIO_DATA_MAC_LEN]; /* MAC from blk_cksum */
	uint64_t bab_pad; /* reserved for future use */
	} blkptr_auth_buf_t;

	zio_crypt_info_t zio_crypt_table[ZIO_CRYPT_FUNCTIONS] = {
	{"", ZC_TYPE_NONE, 0, "inherit"},
	{"", ZC_TYPE_NONE, 0, "on"},
	{"", ZC_TYPE_NONE, 0, "off"},
	{SUN_CKM_AES_CCM, ZC_TYPE_CCM, 16, "aes-128-ccm"},
	{SUN_CKM_AES_CCM, ZC_TYPE_CCM, 24, "aes-192-ccm"},
	{SUN_CKM_AES_CCM, ZC_TYPE_CCM, 32, "aes-256-ccm"},
	{SUN_CKM_AES_GCM, ZC_TYPE_GCM, 16, "aes-128-gcm"},
	{SUN_CKM_AES_GCM, ZC_TYPE_GCM, 24, "aes-192-gcm"},
	{SUN_CKM_AES_GCM, ZC_TYPE_GCM, 32, "aes-256-gcm"}
	};

	static void
	zio_crypt_key_destroy_early(zio_crypt_key_t *key)
	{
	rw_destroy(&key->zk_salt_lock);

	/* free crypto templates */
	bzero(&key->zk_session, sizeof (key->zk_session));

	/* zero out sensitive data */
	bzero(key, sizeof (zio_crypt_key_t));
	}

	void
	zio_crypt_key_destroy(zio_crypt_key_t *key)
	{

	freebsd_crypt_freesession(&key->zk_session);
	zio_crypt_key_destroy_early(key);
	}

	int
	zio_crypt_key_init(uint64_t crypt, zio_crypt_key_t *key)
	{
	int ret;
	crypto_mechanism_t mech __unused;
	uint_t keydata_len;
	zio_crypt_info_t *ci = NULL;

	ASSERT(key != NULL);
	ASSERT3U(crypt, <, ZIO_CRYPT_FUNCTIONS);

	ci = &zio_crypt_table[crypt];
	if (ci->ci_crypt_type != ZC_TYPE_GCM &&
	ci->ci_crypt_type != ZC_TYPE_CCM)
	return (ENOTSUP);

	keydata_len = zio_crypt_table[crypt].ci_keylen;
	bzero(key, sizeof (zio_crypt_key_t));
	rw_init(&key->zk_salt_lock, NULL, RW_DEFAULT, NULL);

	/* fill keydata buffers and salt with random data */
	ret = random_get_bytes((uint8_t *)&key->zk_guid, sizeof (uint64_t));
	if (ret != 0)
	goto error;

	ret = random_get_bytes(key->zk_master_keydata, keydata_len);
	if (ret != 0)
	goto error;

	ret = random_get_bytes(key->zk_hmac_keydata, SHA512_HMAC_KEYLEN);
	if (ret != 0)
	goto error;

	ret = random_get_bytes(key->zk_salt, ZIO_DATA_SALT_LEN);
	if (ret != 0)
	goto error;

	/* derive the current key from the master key */
	ret = hkdf_sha512(key->zk_master_keydata, keydata_len, NULL, 0,
	key->zk_salt, ZIO_DATA_SALT_LEN, key->zk_current_keydata,
	keydata_len);
	if (ret != 0)
	goto error;

	/* initialize keys for the ICP */
	key->zk_current_key.ck_format = CRYPTO_KEY_RAW;
	key->zk_current_key.ck_data = key->zk_current_keydata;
	key->zk_current_key.ck_length = CRYPTO_BYTES2BITS(keydata_len);

	key->zk_hmac_key.ck_format = CRYPTO_KEY_RAW;
	key->zk_hmac_key.ck_data = &key->zk_hmac_key;
	key->zk_hmac_key.ck_length = CRYPTO_BYTES2BITS(SHA512_HMAC_KEYLEN);

	ci = &zio_crypt_table[crypt];
	if (ci->ci_crypt_type != ZC_TYPE_GCM &&
	ci->ci_crypt_type != ZC_TYPE_CCM)
	return (ENOTSUP);

	ret = freebsd_crypt_newsession(&key->zk_session, ci,
	&key->zk_current_key);
	if (ret)
	goto error;

	key->zk_crypt = crypt;
	key->zk_version = ZIO_CRYPT_KEY_CURRENT_VERSION;
	key->zk_salt_count = 0;

	return (0);

	error:
	zio_crypt_key_destroy_early(key);
	return (ret);
	}

	static int
	zio_crypt_key_change_salt(zio_crypt_key_t *key)
	{
	int ret = 0;
	uint8_t salt[ZIO_DATA_SALT_LEN];
	crypto_mechanism_t mech __unused;

	uint_t keydata_len = zio_crypt_table[key->zk_crypt].ci_keylen;

	/* generate a new salt */
	ret = random_get_bytes(salt, ZIO_DATA_SALT_LEN);
	if (ret != 0)
	goto error;

	rw_enter(&key->zk_salt_lock, RW_WRITER);

	/* someone beat us to the salt rotation, just unlock and return */
	if (key->zk_salt_count < ZFS_CURRENT_MAX_SALT_USES)
	goto out_unlock;

	/* derive the current key from the master key and the new salt */
	ret = hkdf_sha512(key->zk_master_keydata, keydata_len, NULL, 0,
	salt, ZIO_DATA_SALT_LEN, key->zk_current_keydata, keydata_len);
	if (ret != 0)
	goto out_unlock;

	/* assign the salt and reset the usage count */
	bcopy(salt, key->zk_salt, ZIO_DATA_SALT_LEN);
	key->zk_salt_count = 0;

	freebsd_crypt_freesession(&key->zk_session);
	ret = freebsd_crypt_newsession(&key->zk_session,
	&zio_crypt_table[key->zk_crypt], &key->zk_current_key);
	if (ret != 0)
	goto out_unlock;

	rw_exit(&key->zk_salt_lock);

	return (0);

	out_unlock:
	rw_exit(&key->zk_salt_lock);
	error:
	return (ret);
	}

	/* See comment above zfs_key_max_salt_uses definition for details */
	int
	zio_crypt_key_get_salt(zio_crypt_key_t key, uint8_t salt)
	{
	int ret;
	boolean_t salt_change;

	rw_enter(&key->zk_salt_lock, RW_READER);

	bcopy(key->zk_salt, salt, ZIO_DATA_SALT_LEN);
	salt_change = (atomic_inc_64_nv(&key->zk_salt_count) >=
	ZFS_CURRENT_MAX_SALT_USES);

	rw_exit(&key->zk_salt_lock);

	if (salt_change) {
	ret = zio_crypt_key_change_salt(key);
	if (ret != 0)
	goto error;
	}

	return (0);

	error:
	return (ret);
	}

	void *failed_decrypt_buf;
	int failed_decrypt_size;

	/*
	* This function handles all encryption and decryption in zfs. When
	* encrypting it expects puio to reference the plaintext and cuio to
	* reference the ciphertext. cuio must have enough space for the
	* ciphertext + room for a MAC. datalen should be the length of the
	* plaintext / ciphertext alone.
	*/
	/*
	* The implementation for FreeBSD's OpenCrypto.
	*
	* The big difference between ICP and FOC is that FOC uses a single
	* buffer for input and output. This means that (for AES-GCM, the
	* only one supported right now) the source must be copied into the
	* destination, and the destination must have the AAD, and the tag/MAC,
	* already associated with it. (Both implementations can use a uio.)
	*
	* Since the auth data is part of the iovec array, all we need to know
	* is the length: 0 means there's no AAD.
	*
	*/
	static int
	zio_do_crypt_uio_opencrypto(boolean_t encrypt, freebsd_crypt_session_t *sess,
	uint64_t crypt, crypto_key_t key, uint8_t ivbuf, uint_t datalen,
	zfs_uio_t *uio, uint_t auth_len)
	{
	zio_crypt_info_t *ci;
	int ret;

	ci = &zio_crypt_table[crypt];
	if (ci->ci_crypt_type != ZC_TYPE_GCM &&
	ci->ci_crypt_type != ZC_TYPE_CCM)
	return (ENOTSUP);


	ret = freebsd_crypt_uio(encrypt, sess, ci, uio, key, ivbuf,
	datalen, auth_len);
	if (ret != 0) {
	#ifdef FCRYPTO_DEBUG
	printf("%s(%d): Returning error %s\n",
	__FUNCTION__, __LINE__, encrypt ? "EIO" : "ECKSUM");
	#endif
	ret = SET_ERROR(encrypt ? EIO : ECKSUM);
	}

	return (ret);
	}

	int
	zio_crypt_key_wrap(crypto_key_t cwkey, zio_crypt_key_t key, uint8_t *iv,
	uint8_t mac, uint8_t keydata_out, uint8_t *hmac_keydata_out)
	{
	int ret;
	uint64_t aad[3];
	/*
	* With OpenCrypto in FreeBSD, the same buffer is used for
	* input and output. Also, the AAD (for AES-GMC at least)
	* needs to logically go in front.
	*/
	zfs_uio_t cuio;
	struct uio cuio_s;
	iovec_t iovecs[4];
	uint64_t crypt = key->zk_crypt;
	uint_t enc_len, keydata_len, aad_len;

	ASSERT3U(crypt, <, ZIO_CRYPT_FUNCTIONS);
	ASSERT3U(cwkey->ck_format, ==, CRYPTO_KEY_RAW);

	zfs_uio_init(&cuio, &cuio_s);

	keydata_len = zio_crypt_table[crypt].ci_keylen;

	/* generate iv for wrapping the master and hmac key */
	ret = random_get_pseudo_bytes(iv, WRAPPING_IV_LEN);
	if (ret != 0)
	goto error;

	/*
	* Since we only support one buffer, we need to copy
	* the plain text (source) to the cipher buffer (dest).
	* We set iovecs[0] -- the authentication data -- below.
	*/
	bcopy((void*)key->zk_master_keydata, keydata_out, keydata_len);
	bcopy((void*)key->zk_hmac_keydata, hmac_keydata_out,
	SHA512_HMAC_KEYLEN);
	iovecs[1].iov_base = keydata_out;
	iovecs[1].iov_len = keydata_len;
	iovecs[2].iov_base = hmac_keydata_out;
	iovecs[2].iov_len = SHA512_HMAC_KEYLEN;
	iovecs[3].iov_base = mac;
	iovecs[3].iov_len = WRAPPING_MAC_LEN;

	/*
	* Although we don't support writing to the old format, we do
	* support rewrapping the key so that the user can move and
	* quarantine datasets on the old format.
	*/
	if (key->zk_version == 0) {
	aad_len = sizeof (uint64_t);
	aad[0] = LE_64(key->zk_guid);
	} else {
	ASSERT3U(key->zk_version, ==, ZIO_CRYPT_KEY_CURRENT_VERSION);
	aad_len = sizeof (uint64_t) * 3;
	aad[0] = LE_64(key->zk_guid);
	aad[1] = LE_64(crypt);
	aad[2] = LE_64(key->zk_version);
	}

	iovecs[0].iov_base = aad;
	iovecs[0].iov_len = aad_len;
	enc_len = zio_crypt_table[crypt].ci_keylen + SHA512_HMAC_KEYLEN;

	GET_UIO_STRUCT(&cuio)->uio_iov = iovecs;
	zfs_uio_iovcnt(&cuio) = 4;
	zfs_uio_segflg(&cuio) = UIO_SYSSPACE;

	/* encrypt the keys and store the resulting ciphertext and mac */
	ret = zio_do_crypt_uio_opencrypto(B_TRUE, NULL, crypt, cwkey,
	iv, enc_len, &cuio, aad_len);
	if (ret != 0)
	goto error;

	return (0);

	error:
	return (ret);
	}

	int
	zio_crypt_key_unwrap(crypto_key_t *cwkey, uint64_t crypt, uint64_t version,
	uint64_t guid, uint8_t keydata, uint8_t hmac_keydata, uint8_t *iv,
	uint8_t mac, zio_crypt_key_t key)
	{
	int ret;
	uint64_t aad[3];
	/*
	* With OpenCrypto in FreeBSD, the same buffer is used for
	* input and output. Also, the AAD (for AES-GMC at least)
	* needs to logically go in front.
	*/
	zfs_uio_t cuio;
	struct uio cuio_s;
	iovec_t iovecs[4];
	void src, dst;
	uint_t enc_len, keydata_len, aad_len;

	ASSERT3U(crypt, <, ZIO_CRYPT_FUNCTIONS);
	ASSERT3U(cwkey->ck_format, ==, CRYPTO_KEY_RAW);

	keydata_len = zio_crypt_table[crypt].ci_keylen;
	rw_init(&key->zk_salt_lock, NULL, RW_DEFAULT, NULL);

	zfs_uio_init(&cuio, &cuio_s);

	/*
	* Since we only support one buffer, we need to copy
	* the encrypted buffer (source) to the plain buffer
	* (dest). We set iovecs[0] -- the authentication data --
	* below.
	*/
	dst = key->zk_master_keydata;
	src = keydata;

	bcopy(src, dst, keydata_len);

	dst = key->zk_hmac_keydata;
	src = hmac_keydata;
	bcopy(src, dst, SHA512_HMAC_KEYLEN);

	iovecs[1].iov_base = key->zk_master_keydata;
	iovecs[1].iov_len = keydata_len;
	iovecs[2].iov_base = key->zk_hmac_keydata;
	iovecs[2].iov_len = SHA512_HMAC_KEYLEN;
	iovecs[3].iov_base = mac;
	iovecs[3].iov_len = WRAPPING_MAC_LEN;

	if (version == 0) {
	aad_len = sizeof (uint64_t);
	aad[0] = LE_64(guid);
	} else {
	ASSERT3U(version, ==, ZIO_CRYPT_KEY_CURRENT_VERSION);
	aad_len = sizeof (uint64_t) * 3;
	aad[0] = LE_64(guid);
	aad[1] = LE_64(crypt);
	aad[2] = LE_64(version);
	}

	enc_len = keydata_len + SHA512_HMAC_KEYLEN;
	iovecs[0].iov_base = aad;
	iovecs[0].iov_len = aad_len;

	GET_UIO_STRUCT(&cuio)->uio_iov = iovecs;
	zfs_uio_iovcnt(&cuio) = 4;
	zfs_uio_segflg(&cuio) = UIO_SYSSPACE;

	/* decrypt the keys and store the result in the output buffers */
	ret = zio_do_crypt_uio_opencrypto(B_FALSE, NULL, crypt, cwkey,
	iv, enc_len, &cuio, aad_len);

	if (ret != 0)
	goto error;

	/* generate a fresh salt */
	ret = random_get_bytes(key->zk_salt, ZIO_DATA_SALT_LEN);
	if (ret != 0)
	goto error;

	/* derive the current key from the master key */
	ret = hkdf_sha512(key->zk_master_keydata, keydata_len, NULL, 0,
	key->zk_salt, ZIO_DATA_SALT_LEN, key->zk_current_keydata,
	keydata_len);
	if (ret != 0)
	goto error;

	/* initialize keys for ICP */
	key->zk_current_key.ck_format = CRYPTO_KEY_RAW;
	key->zk_current_key.ck_data = key->zk_current_keydata;
	key->zk_current_key.ck_length = CRYPTO_BYTES2BITS(keydata_len);

	key->zk_hmac_key.ck_format = CRYPTO_KEY_RAW;
	key->zk_hmac_key.ck_data = key->zk_hmac_keydata;
	key->zk_hmac_key.ck_length = CRYPTO_BYTES2BITS(SHA512_HMAC_KEYLEN);

	ret = freebsd_crypt_newsession(&key->zk_session,
	&zio_crypt_table[crypt], &key->zk_current_key);
	if (ret != 0)
	goto error;

	key->zk_crypt = crypt;
	key->zk_version = version;
	key->zk_guid = guid;
	key->zk_salt_count = 0;

	return (0);

	error:
	zio_crypt_key_destroy_early(key);
	return (ret);
	}

	int
	zio_crypt_generate_iv(uint8_t *ivbuf)
	{
	int ret;

	/* randomly generate the IV */
	ret = random_get_pseudo_bytes(ivbuf, ZIO_DATA_IV_LEN);
	if (ret != 0)
	goto error;

	return (0);

	error:
	bzero(ivbuf, ZIO_DATA_IV_LEN);
	return (ret);
	}

	int
	zio_crypt_do_hmac(zio_crypt_key_t key, uint8_t data, uint_t datalen,
	uint8_t *digestbuf, uint_t digestlen)
	{
	uint8_t raw_digestbuf[SHA512_DIGEST_LENGTH];

	ASSERT3U(digestlen, <=, SHA512_DIGEST_LENGTH);

	crypto_mac(&key->zk_hmac_key, data, datalen,
	raw_digestbuf, SHA512_DIGEST_LENGTH);

	bcopy(raw_digestbuf, digestbuf, digestlen);

	return (0);
	}

	int
	zio_crypt_generate_iv_salt_dedup(zio_crypt_key_t key, uint8_t data,
	uint_t datalen, uint8_t ivbuf, uint8_t salt)
	{
	int ret;
	uint8_t digestbuf[SHA512_DIGEST_LENGTH];

	ret = zio_crypt_do_hmac(key, data, datalen,
	digestbuf, SHA512_DIGEST_LENGTH);
	if (ret != 0)
	return (ret);

	bcopy(digestbuf, salt, ZIO_DATA_SALT_LEN);
	bcopy(digestbuf + ZIO_DATA_SALT_LEN, ivbuf, ZIO_DATA_IV_LEN);

	return (0);
	}

	/*
	* The following functions are used to encode and decode encryption parameters
	* into blkptr_t and zil_header_t. The ICP wants to use these parameters as
	* byte strings, which normally means that these strings would not need to deal
	* with byteswapping at all. However, both blkptr_t and zil_header_t may be
	* byteswapped by lower layers and so we must "undo" that byteswap here upon
	* decoding and encoding in a non-native byteorder. These functions require
	* that the byteorder bit is correct before being called.
	*/
	void
	zio_crypt_encode_params_bp(blkptr_t bp, uint8_t salt, uint8_t *iv)
	{
	uint64_t val64;
	uint32_t val32;

	ASSERT(BP_IS_ENCRYPTED(bp));

	if (!BP_SHOULD_BYTESWAP(bp)) {
	bcopy(salt, &bp->blk_dva[2].dva_word[0], sizeof (uint64_t));
	bcopy(iv, &bp->blk_dva[2].dva_word[1], sizeof (uint64_t));
	bcopy(iv + sizeof (uint64_t), &val32, sizeof (uint32_t));
	BP_SET_IV2(bp, val32);
	} else {
	bcopy(salt, &val64, sizeof (uint64_t));
	bp->blk_dva[2].dva_word[0] = BSWAP_64(val64);

	bcopy(iv, &val64, sizeof (uint64_t));
	bp->blk_dva[2].dva_word[1] = BSWAP_64(val64);

	bcopy(iv + sizeof (uint64_t), &val32, sizeof (uint32_t));
	BP_SET_IV2(bp, BSWAP_32(val32));
	}
	}

	void
	zio_crypt_decode_params_bp(const blkptr_t bp, uint8_t salt, uint8_t *iv)
	{
	uint64_t val64;
	uint32_t val32;

	ASSERT(BP_IS_PROTECTED(bp));

	/* for convenience, so callers don't need to check */
	if (BP_IS_AUTHENTICATED(bp)) {
	bzero(salt, ZIO_DATA_SALT_LEN);
	bzero(iv, ZIO_DATA_IV_LEN);
	return;
	}

	if (!BP_SHOULD_BYTESWAP(bp)) {
	bcopy(&bp->blk_dva[2].dva_word[0], salt, sizeof (uint64_t));
	bcopy(&bp->blk_dva[2].dva_word[1], iv, sizeof (uint64_t));

	val32 = (uint32_t)BP_GET_IV2(bp);
	bcopy(&val32, iv + sizeof (uint64_t), sizeof (uint32_t));
	} else {
	val64 = BSWAP_64(bp->blk_dva[2].dva_word[0]);
	bcopy(&val64, salt, sizeof (uint64_t));

	val64 = BSWAP_64(bp->blk_dva[2].dva_word[1]);
	bcopy(&val64, iv, sizeof (uint64_t));

	val32 = BSWAP_32((uint32_t)BP_GET_IV2(bp));
	bcopy(&val32, iv + sizeof (uint64_t), sizeof (uint32_t));
	}
	}

	void
	zio_crypt_encode_mac_bp(blkptr_t bp, uint8_t mac)
	{
	uint64_t val64;

	ASSERT(BP_USES_CRYPT(bp));
	ASSERT3U(BP_GET_TYPE(bp), !=, DMU_OT_OBJSET);

	if (!BP_SHOULD_BYTESWAP(bp)) {
	bcopy(mac, &bp->blk_cksum.zc_word[2], sizeof (uint64_t));
	bcopy(mac + sizeof (uint64_t), &bp->blk_cksum.zc_word[3],
	sizeof (uint64_t));
	} else {
	bcopy(mac, &val64, sizeof (uint64_t));
	bp->blk_cksum.zc_word[2] = BSWAP_64(val64);

	bcopy(mac + sizeof (uint64_t), &val64, sizeof (uint64_t));
	bp->blk_cksum.zc_word[3] = BSWAP_64(val64);
	}
	}

	void
	zio_crypt_decode_mac_bp(const blkptr_t bp, uint8_t mac)
	{
	uint64_t val64;

	ASSERT(BP_USES_CRYPT(bp) \|\| BP_IS_HOLE(bp));

	/* for convenience, so callers don't need to check */
	if (BP_GET_TYPE(bp) == DMU_OT_OBJSET) {
	bzero(mac, ZIO_DATA_MAC_LEN);
	return;
	}

	if (!BP_SHOULD_BYTESWAP(bp)) {
	bcopy(&bp->blk_cksum.zc_word[2], mac, sizeof (uint64_t));
	bcopy(&bp->blk_cksum.zc_word[3], mac + sizeof (uint64_t),
	sizeof (uint64_t));
	} else {
	val64 = BSWAP_64(bp->blk_cksum.zc_word[2]);
	bcopy(&val64, mac, sizeof (uint64_t));

	val64 = BSWAP_64(bp->blk_cksum.zc_word[3]);
	bcopy(&val64, mac + sizeof (uint64_t), sizeof (uint64_t));
	}
	}

	void
	zio_crypt_encode_mac_zil(void data, uint8_t mac)
	{
	zil_chain_t *zilc = data;

	bcopy(mac, &zilc->zc_eck.zec_cksum.zc_word[2], sizeof (uint64_t));
	bcopy(mac + sizeof (uint64_t), &zilc->zc_eck.zec_cksum.zc_word[3],
	sizeof (uint64_t));
	}

	void
	zio_crypt_decode_mac_zil(const void data, uint8_t mac)
	{
	/*
	* The ZIL MAC is embedded in the block it protects, which will
	* not have been byteswapped by the time this function has been called.
	* As a result, we don't need to worry about byteswapping the MAC.
	*/
	const zil_chain_t *zilc = data;

	bcopy(&zilc->zc_eck.zec_cksum.zc_word[2], mac, sizeof (uint64_t));
	bcopy(&zilc->zc_eck.zec_cksum.zc_word[3], mac + sizeof (uint64_t),
	sizeof (uint64_t));
	}

	/*
	* This routine takes a block of dnodes (src_abd) and copies only the bonus
	* buffers to the same offsets in the dst buffer. datalen should be the size
	* of both the src_abd and the dst buffer (not just the length of the bonus
	* buffers).
	*/
	void
	zio_crypt_copy_dnode_bonus(abd_t src_abd, uint8_t dst, uint_t datalen)
	{
	uint_t i, max_dnp = datalen >> DNODE_SHIFT;
	uint8_t *src;
	dnode_phys_t dnp, sdnp, *ddnp;

	src = abd_borrow_buf_copy(src_abd, datalen);

	sdnp = (dnode_phys_t *)src;
	ddnp = (dnode_phys_t *)dst;

	for (i = 0; i < max_dnp; i += sdnp[i].dn_extra_slots + 1) {
	dnp = &sdnp[i];
	if (dnp->dn_type != DMU_OT_NONE &&
	DMU_OT_IS_ENCRYPTED(dnp->dn_bonustype) &&
	dnp->dn_bonuslen != 0) {
	bcopy(DN_BONUS(dnp), DN_BONUS(&ddnp[i]),
	DN_MAX_BONUS_LEN(dnp));
	}
	}

	abd_return_buf(src_abd, src, datalen);
	}

	/*
	* This function decides what fields from blk_prop are included in
	* the on-disk various MAC algorithms.
	*/
	static void
	zio_crypt_bp_zero_nonportable_blkprop(blkptr_t *bp, uint64_t version)
	{
	int avoidlint = SPA_MINBLOCKSIZE;
	/*
	* Version 0 did not properly zero out all non-portable fields
	* as it should have done. We maintain this code so that we can
	* do read-only imports of pools on this version.
	*/
	if (version == 0) {
	BP_SET_DEDUP(bp, 0);
	BP_SET_CHECKSUM(bp, 0);
	BP_SET_PSIZE(bp, avoidlint);
	return;
	}

	ASSERT3U(version, ==, ZIO_CRYPT_KEY_CURRENT_VERSION);

	/*
	* The hole_birth feature might set these fields even if this bp
	* is a hole. We zero them out here to guarantee that raw sends
	* will function with or without the feature.
	*/
	if (BP_IS_HOLE(bp)) {
	bp->blk_prop = 0ULL;
	return;
	}

	/*
	* At L0 we want to verify these fields to ensure that data blocks
	* can not be reinterpreted. For instance, we do not want an attacker
	* to trick us into returning raw lz4 compressed data to the user
	* by modifying the compression bits. At higher levels, we cannot
	* enforce this policy since raw sends do not convey any information
	* about indirect blocks, so these values might be different on the
	* receive side. Fortunately, this does not open any new attack
	* vectors, since any alterations that can be made to a higher level
	* bp must still verify the correct order of the layer below it.
	*/
	if (BP_GET_LEVEL(bp) != 0) {
	BP_SET_BYTEORDER(bp, 0);
	BP_SET_COMPRESS(bp, 0);

	/*
	* psize cannot be set to zero or it will trigger
	* asserts, but the value doesn't really matter as
	* long as it is constant.
	*/
	BP_SET_PSIZE(bp, avoidlint);
	}

	BP_SET_DEDUP(bp, 0);
	BP_SET_CHECKSUM(bp, 0);
	}

	static void
	zio_crypt_bp_auth_init(uint64_t version, boolean_t should_bswap, blkptr_t *bp,
	blkptr_auth_buf_t bab, uint_t bab_len)
	{
	blkptr_t tmpbp = *bp;

	if (should_bswap)
	byteswap_uint64_array(&tmpbp, sizeof (blkptr_t));

	ASSERT(BP_USES_CRYPT(&tmpbp) \|\| BP_IS_HOLE(&tmpbp));
	ASSERT0(BP_IS_EMBEDDED(&tmpbp));

	zio_crypt_decode_mac_bp(&tmpbp, bab->bab_mac);

	/*
	* We always MAC blk_prop in LE to ensure portability. This
	* must be done after decoding the mac, since the endianness
	* will get zero'd out here.
	*/
	zio_crypt_bp_zero_nonportable_blkprop(&tmpbp, version);
	bab->bab_prop = LE_64(tmpbp.blk_prop);
	bab->bab_pad = 0ULL;

	/* version 0 did not include the padding */
	*bab_len = sizeof (blkptr_auth_buf_t);
	if (version == 0)
	*bab_len -= sizeof (uint64_t);
	}

	static int
	zio_crypt_bp_do_hmac_updates(crypto_context_t ctx, uint64_t version,
	boolean_t should_bswap, blkptr_t *bp)
	{
	uint_t bab_len;
	blkptr_auth_buf_t bab;

	zio_crypt_bp_auth_init(version, should_bswap, bp, &bab, &bab_len);
	crypto_mac_update(ctx, &bab, bab_len);

	return (0);
	}

	static void
	zio_crypt_bp_do_indrect_checksum_updates(SHA2_CTX *ctx, uint64_t version,
	boolean_t should_bswap, blkptr_t *bp)
	{
	uint_t bab_len;
	blkptr_auth_buf_t bab;

	zio_crypt_bp_auth_init(version, should_bswap, bp, &bab, &bab_len);
	SHA2Update(ctx, &bab, bab_len);
	}

	static void
	zio_crypt_bp_do_aad_updates(uint8_t *aadp, uint_t aad_len, uint64_t version,
	boolean_t should_bswap, blkptr_t *bp)
	{
	uint_t bab_len;
	blkptr_auth_buf_t bab;

	zio_crypt_bp_auth_init(version, should_bswap, bp, &bab, &bab_len);
	bcopy(&bab, *aadp, bab_len);
	*aadp += bab_len;
	*aad_len += bab_len;
	}

	static int
	zio_crypt_do_dnode_hmac_updates(crypto_context_t ctx, uint64_t version,
	boolean_t should_bswap, dnode_phys_t *dnp)
	{
	int ret, i;
	dnode_phys_t *adnp;
	boolean_t le_bswap = (should_bswap == ZFS_HOST_BYTEORDER);
	uint8_t tmp_dncore[offsetof(dnode_phys_t, dn_blkptr)];

	/* authenticate the core dnode (masking out non-portable bits) */
	bcopy(dnp, tmp_dncore, sizeof (tmp_dncore));
	adnp = (dnode_phys_t *)tmp_dncore;
	if (le_bswap) {
	adnp->dn_datablkszsec = BSWAP_16(adnp->dn_datablkszsec);
	adnp->dn_bonuslen = BSWAP_16(adnp->dn_bonuslen);
	adnp->dn_maxblkid = BSWAP_64(adnp->dn_maxblkid);
	adnp->dn_used = BSWAP_64(adnp->dn_used);
	}
	adnp->dn_flags &= DNODE_CRYPT_PORTABLE_FLAGS_MASK;
	adnp->dn_used = 0;

	crypto_mac_update(ctx, adnp, sizeof (tmp_dncore));

	for (i = 0; i < dnp->dn_nblkptr; i++) {
	ret = zio_crypt_bp_do_hmac_updates(ctx, version,
	should_bswap, &dnp->dn_blkptr[i]);
	if (ret != 0)
	goto error;
	}

	if (dnp->dn_flags & DNODE_FLAG_SPILL_BLKPTR) {
	ret = zio_crypt_bp_do_hmac_updates(ctx, version,
	should_bswap, DN_SPILL_BLKPTR(dnp));
	if (ret != 0)
	goto error;
	}

	return (0);

	error:
	return (ret);
	}

	/*
	* objset_phys_t blocks introduce a number of exceptions to the normal
	* authentication process. objset_phys_t's contain 2 separate HMACS for
	* protecting the integrity of their data. The portable_mac protects the
	* metadnode. This MAC can be sent with a raw send and protects against
	* reordering of data within the metadnode. The local_mac protects the user
	* accounting objects which are not sent from one system to another.
	*
	* In addition, objset blocks are the only blocks that can be modified and
	* written to disk without the key loaded under certain circumstances. During
	* zil_claim() we need to be able to update the zil_header_t to complete
	* claiming log blocks and during raw receives we need to write out the
	* portable_mac from the send file. Both of these actions are possible
	* because these fields are not protected by either MAC so neither one will
	* need to modify the MACs without the key. However, when the modified blocks
	* are written out they will be byteswapped into the host machine's native
	* endianness which will modify fields protected by the MAC. As a result, MAC
	* calculation for objset blocks works slightly differently from other block
	* types. Where other block types MAC the data in whatever endianness is
	* written to disk, objset blocks always MAC little endian version of their
	* values. In the code, should_bswap is the value from BP_SHOULD_BYTESWAP()
	* and le_bswap indicates whether a byteswap is needed to get this block
	* into little endian format.
	*/
	/* ARGSUSED */
	int
	zio_crypt_do_objset_hmacs(zio_crypt_key_t key, void data, uint_t datalen,
	boolean_t should_bswap, uint8_t portable_mac, uint8_t local_mac)
	{
	int ret;
	struct hmac_ctx hash_ctx;
	struct hmac_ctx *ctx = &hash_ctx;
	objset_phys_t *osp = data;
	uint64_t intval;
	boolean_t le_bswap = (should_bswap == ZFS_HOST_BYTEORDER);
	uint8_t raw_portable_mac[SHA512_DIGEST_LENGTH];
	uint8_t raw_local_mac[SHA512_DIGEST_LENGTH];


	/* calculate the portable MAC from the portable fields and metadnode */
	crypto_mac_init(ctx, &key->zk_hmac_key);

	/* add in the os_type */
	intval = (le_bswap) ? osp->os_type : BSWAP_64(osp->os_type);
	crypto_mac_update(ctx, &intval, sizeof (uint64_t));

	/* add in the portable os_flags */
	intval = osp->os_flags;
	if (should_bswap)
	intval = BSWAP_64(intval);
	intval &= OBJSET_CRYPT_PORTABLE_FLAGS_MASK;
	/* CONSTCOND */
	if (!ZFS_HOST_BYTEORDER)
	intval = BSWAP_64(intval);

	crypto_mac_update(ctx, &intval, sizeof (uint64_t));

	/* add in fields from the metadnode */
	ret = zio_crypt_do_dnode_hmac_updates(ctx, key->zk_version,
	should_bswap, &osp->os_meta_dnode);
	if (ret)
	goto error;

	crypto_mac_final(ctx, raw_portable_mac, SHA512_DIGEST_LENGTH);

	bcopy(raw_portable_mac, portable_mac, ZIO_OBJSET_MAC_LEN);

	- /*
	- * This is necessary here as we check next whether
	- * OBJSET_FLAG_USERACCOUNTING_COMPLETE or
	- * OBJSET_FLAG_USEROBJACCOUNTING are set in order to
	- * decide if the local_mac should be zeroed out.
	- */
	- intval = osp->os_flags;
	- if (should_bswap)
	- intval = BSWAP_64(intval);
	-
	/*
	* The local MAC protects the user, group and project accounting.
	* If these objects are not present, the local MAC is zeroed out.
	*/
	if ((datalen >= OBJSET_PHYS_SIZE_V3 &&
	osp->os_userused_dnode.dn_type == DMU_OT_NONE &&
	osp->os_groupused_dnode.dn_type == DMU_OT_NONE &&
	osp->os_projectused_dnode.dn_type == DMU_OT_NONE) \|\|
	(datalen >= OBJSET_PHYS_SIZE_V2 &&
	osp->os_userused_dnode.dn_type == DMU_OT_NONE &&
	osp->os_groupused_dnode.dn_type == DMU_OT_NONE) \|\|
	- (datalen <= OBJSET_PHYS_SIZE_V1) \|\|
	- (((intval & OBJSET_FLAG_USERACCOUNTING_COMPLETE) == 0 \|\|
	- (intval & OBJSET_FLAG_USEROBJACCOUNTING_COMPLETE) == 0) &&
	- key->zk_version > 0)) {
	+ (datalen <= OBJSET_PHYS_SIZE_V1)) {
	bzero(local_mac, ZIO_OBJSET_MAC_LEN);
	return (0);
	}

	/* calculate the local MAC from the userused and groupused dnodes */
	crypto_mac_init(ctx, &key->zk_hmac_key);

	/* add in the non-portable os_flags */
	intval = osp->os_flags;
	if (should_bswap)
	intval = BSWAP_64(intval);
	intval &= ~OBJSET_CRYPT_PORTABLE_FLAGS_MASK;
	/* CONSTCOND */
	if (!ZFS_HOST_BYTEORDER)
	intval = BSWAP_64(intval);

	crypto_mac_update(ctx, &intval, sizeof (uint64_t));

	/* XXX check dnode type ... */
	/* add in fields from the user accounting dnodes */
	if (osp->os_userused_dnode.dn_type != DMU_OT_NONE) {
	ret = zio_crypt_do_dnode_hmac_updates(ctx, key->zk_version,
	should_bswap, &osp->os_userused_dnode);
	if (ret)
	goto error;
	}

	if (osp->os_groupused_dnode.dn_type != DMU_OT_NONE) {
	ret = zio_crypt_do_dnode_hmac_updates(ctx, key->zk_version,
	should_bswap, &osp->os_groupused_dnode);
	if (ret)
	goto error;
	}

	if (osp->os_projectused_dnode.dn_type != DMU_OT_NONE &&
	datalen >= OBJSET_PHYS_SIZE_V3) {
	ret = zio_crypt_do_dnode_hmac_updates(ctx, key->zk_version,
	should_bswap, &osp->os_projectused_dnode);
	if (ret)
	goto error;
	}

	crypto_mac_final(ctx, raw_local_mac, SHA512_DIGEST_LENGTH);

	bcopy(raw_local_mac, local_mac, ZIO_OBJSET_MAC_LEN);

	return (0);

	error:
	bzero(portable_mac, ZIO_OBJSET_MAC_LEN);
	bzero(local_mac, ZIO_OBJSET_MAC_LEN);
	return (ret);
	}

	static void
	zio_crypt_destroy_uio(zfs_uio_t *uio)
	{
	if (GET_UIO_STRUCT(uio)->uio_iov)
	kmem_free(GET_UIO_STRUCT(uio)->uio_iov,
	zfs_uio_iovcnt(uio) * sizeof (iovec_t));
	}

	/*
	* This function parses an uncompressed indirect block and returns a checksum
	* of all the portable fields from all of the contained bps. The portable
	* fields are the MAC and all of the fields from blk_prop except for the dedup,
	* checksum, and psize bits. For an explanation of the purpose of this, see
	* the comment block on object set authentication.
	*/
	static int
	zio_crypt_do_indirect_mac_checksum_impl(boolean_t generate, void *buf,
	uint_t datalen, uint64_t version, boolean_t byteswap, uint8_t *cksum)
	{
	blkptr_t *bp;
	int i, epb = datalen >> SPA_BLKPTRSHIFT;
	SHA2_CTX ctx;
	uint8_t digestbuf[SHA512_DIGEST_LENGTH];

	/* checksum all of the MACs from the layer below */
	SHA2Init(SHA512, &ctx);
	for (i = 0, bp = buf; i < epb; i++, bp++) {
	zio_crypt_bp_do_indrect_checksum_updates(&ctx, version,
	byteswap, bp);
	}
	SHA2Final(digestbuf, &ctx);

	if (generate) {
	bcopy(digestbuf, cksum, ZIO_DATA_MAC_LEN);
	return (0);
	}

	if (bcmp(digestbuf, cksum, ZIO_DATA_MAC_LEN) != 0) {
	#ifdef FCRYPTO_DEBUG
	printf("%s(%d): Setting ECKSUM\n", __FUNCTION__, __LINE__);
	#endif
	return (SET_ERROR(ECKSUM));
	}
	return (0);
	}

	int
	zio_crypt_do_indirect_mac_checksum(boolean_t generate, void *buf,
	uint_t datalen, boolean_t byteswap, uint8_t *cksum)
	{
	int ret;

	/*
	* Unfortunately, callers of this function will not always have
	* easy access to the on-disk format version. This info is
	* normally found in the DSL Crypto Key, but the checksum-of-MACs
	* is expected to be verifiable even when the key isn't loaded.
	* Here, instead of doing a ZAP lookup for the version for each
	* zio, we simply try both existing formats.
	*/
	ret = zio_crypt_do_indirect_mac_checksum_impl(generate, buf,
	datalen, ZIO_CRYPT_KEY_CURRENT_VERSION, byteswap, cksum);
	if (ret == ECKSUM) {
	ASSERT(!generate);
	ret = zio_crypt_do_indirect_mac_checksum_impl(generate,
	buf, datalen, 0, byteswap, cksum);
	}

	return (ret);
	}

	int
	zio_crypt_do_indirect_mac_checksum_abd(boolean_t generate, abd_t *abd,
	uint_t datalen, boolean_t byteswap, uint8_t *cksum)
	{
	int ret;
	void *buf;

	buf = abd_borrow_buf_copy(abd, datalen);
	ret = zio_crypt_do_indirect_mac_checksum(generate, buf, datalen,
	byteswap, cksum);
	abd_return_buf(abd, buf, datalen);

	return (ret);
	}

	/*
	* Special case handling routine for encrypting / decrypting ZIL blocks.
	* We do not check for the older ZIL chain because the encryption feature
	* was not available before the newer ZIL chain was introduced. The goal
	* here is to encrypt everything except the blkptr_t of a lr_write_t and
	* the zil_chain_t header. Everything that is not encrypted is authenticated.
	*/
	/*
	* The OpenCrypto used in FreeBSD does not use separate source and
	* destination buffers; instead, the same buffer is used. Further, to
	* accommodate some of the drivers, the authbuf needs to be logically before
	* the data. This means that we need to copy the source to the destination,
	* and set up an extra iovec_t at the beginning to handle the authbuf.
	* It also means we'll only return one zfs_uio_t.
	*/

	/* ARGSUSED */
	static int
	zio_crypt_init_uios_zil(boolean_t encrypt, uint8_t *plainbuf,
	uint8_t cipherbuf, uint_t datalen, boolean_t byteswap, zfs_uio_t puio,
	zfs_uio_t out_uio, uint_t enc_len, uint8_t *authbuf, uint_t auth_len,
	boolean_t *no_crypt)
	{
	uint8_t *aadbuf = zio_buf_alloc(datalen);
	uint8_t src, dst, slrp, dlrp, blkend, aadp;
	iovec_t *dst_iovecs;
	zil_chain_t *zilc;
	lr_t *lr;
	uint64_t txtype, lr_len;
	uint_t crypt_len, nr_iovecs, vec;
	uint_t aad_len = 0, total_len = 0;

	if (encrypt) {
	src = plainbuf;
	dst = cipherbuf;
	} else {
	src = cipherbuf;
	dst = plainbuf;
	}
	bcopy(src, dst, datalen);

	/* Find the start and end record of the log block. */
	zilc = (zil_chain_t *)src;
	slrp = src + sizeof (zil_chain_t);
	aadp = aadbuf;
	blkend = src + ((byteswap) ? BSWAP_64(zilc->zc_nused) : zilc->zc_nused);

	/*
	* Calculate the number of encrypted iovecs we will need.
	*/

	/* We need at least two iovecs -- one for the AAD, one for the MAC. */
	nr_iovecs = 2;

	for (; slrp < blkend; slrp += lr_len) {
	lr = (lr_t *)slrp;

	if (byteswap) {
	txtype = BSWAP_64(lr->lrc_txtype);
	lr_len = BSWAP_64(lr->lrc_reclen);
	} else {
	txtype = lr->lrc_txtype;
	lr_len = lr->lrc_reclen;
	}

	nr_iovecs++;
	if (txtype == TX_WRITE && lr_len != sizeof (lr_write_t))
	nr_iovecs++;
	}

	dst_iovecs = kmem_alloc(nr_iovecs * sizeof (iovec_t), KM_SLEEP);

	/*
	* Copy the plain zil header over and authenticate everything except
	* the checksum that will store our MAC. If we are writing the data
	* the embedded checksum will not have been calculated yet, so we don't
	* authenticate that.
	*/
	bcopy(src, aadp, sizeof (zil_chain_t) - sizeof (zio_eck_t));
	aadp += sizeof (zil_chain_t) - sizeof (zio_eck_t);
	aad_len += sizeof (zil_chain_t) - sizeof (zio_eck_t);

	slrp = src + sizeof (zil_chain_t);
	dlrp = dst + sizeof (zil_chain_t);

	/*
	* Loop over records again, filling in iovecs.
	*/

	/* The first iovec will contain the authbuf. */
	vec = 1;

	for (; slrp < blkend; slrp += lr_len, dlrp += lr_len) {
	lr = (lr_t *)slrp;

	if (!byteswap) {
	txtype = lr->lrc_txtype;
	lr_len = lr->lrc_reclen;
	} else {
	txtype = BSWAP_64(lr->lrc_txtype);
	lr_len = BSWAP_64(lr->lrc_reclen);
	}

	/* copy the common lr_t */
	bcopy(slrp, dlrp, sizeof (lr_t));
	bcopy(slrp, aadp, sizeof (lr_t));
	aadp += sizeof (lr_t);
	aad_len += sizeof (lr_t);

	/*
	* If this is a TX_WRITE record we want to encrypt everything
	* except the bp if exists. If the bp does exist we want to
	* authenticate it.
	*/
	if (txtype == TX_WRITE) {
	crypt_len = sizeof (lr_write_t) -
	sizeof (lr_t) - sizeof (blkptr_t);
	dst_iovecs[vec].iov_base = (char *)dlrp +
	sizeof (lr_t);
	dst_iovecs[vec].iov_len = crypt_len;

	/* copy the bp now since it will not be encrypted */
	bcopy(slrp + sizeof (lr_write_t) - sizeof (blkptr_t),
	dlrp + sizeof (lr_write_t) - sizeof (blkptr_t),
	sizeof (blkptr_t));
	bcopy(slrp + sizeof (lr_write_t) - sizeof (blkptr_t),
	aadp, sizeof (blkptr_t));
	aadp += sizeof (blkptr_t);
	aad_len += sizeof (blkptr_t);
	vec++;
	total_len += crypt_len;

	if (lr_len != sizeof (lr_write_t)) {
	crypt_len = lr_len - sizeof (lr_write_t);
	dst_iovecs[vec].iov_base = (char *)
	dlrp + sizeof (lr_write_t);
	dst_iovecs[vec].iov_len = crypt_len;
	vec++;
	total_len += crypt_len;
	}
	} else {
	crypt_len = lr_len - sizeof (lr_t);
	dst_iovecs[vec].iov_base = (char *)dlrp +
	sizeof (lr_t);
	dst_iovecs[vec].iov_len = crypt_len;
	vec++;
	total_len += crypt_len;
	}
	}

	/* The last iovec will contain the MAC. */
	ASSERT3U(vec, ==, nr_iovecs - 1);

	/* AAD */
	dst_iovecs[0].iov_base = aadbuf;
	dst_iovecs[0].iov_len = aad_len;
	/* MAC */
	dst_iovecs[vec].iov_base = 0;
	dst_iovecs[vec].iov_len = 0;

	*no_crypt = (vec == 1);
	*enc_len = total_len;
	*authbuf = aadbuf;
	*auth_len = aad_len;
	GET_UIO_STRUCT(out_uio)->uio_iov = dst_iovecs;
	zfs_uio_iovcnt(out_uio) = nr_iovecs;

	return (0);
	}

	/*
	* Special case handling routine for encrypting / decrypting dnode blocks.
	*/
	static int
	zio_crypt_init_uios_dnode(boolean_t encrypt, uint64_t version,
	uint8_t plainbuf, uint8_t cipherbuf, uint_t datalen, boolean_t byteswap,
	zfs_uio_t puio, zfs_uio_t out_uio, uint_t enc_len, uint8_t *authbuf,
	uint_t auth_len, boolean_t no_crypt)
	{
	uint8_t *aadbuf = zio_buf_alloc(datalen);
	uint8_t src, dst, *aadp;
	dnode_phys_t dnp, adnp, sdnp, ddnp;
	iovec_t *dst_iovecs;
	uint_t nr_iovecs, crypt_len, vec;
	uint_t aad_len = 0, total_len = 0;
	uint_t i, j, max_dnp = datalen >> DNODE_SHIFT;

	if (encrypt) {
	src = plainbuf;
	dst = cipherbuf;
	} else {
	src = cipherbuf;
	dst = plainbuf;
	}
	bcopy(src, dst, datalen);

	sdnp = (dnode_phys_t *)src;
	ddnp = (dnode_phys_t *)dst;
	aadp = aadbuf;

	/*
	* Count the number of iovecs we will need to do the encryption by
	* counting the number of bonus buffers that need to be encrypted.
	*/

	/* We need at least two iovecs -- one for the AAD, one for the MAC. */
	nr_iovecs = 2;

	for (i = 0; i < max_dnp; i += sdnp[i].dn_extra_slots + 1) {
	/*
	* This block may still be byteswapped. However, all of the
	* values we use are either uint8_t's (for which byteswapping
	* is a noop) or a * != 0 check, which will work regardless
	* of whether or not we byteswap.
	*/
	if (sdnp[i].dn_type != DMU_OT_NONE &&
	DMU_OT_IS_ENCRYPTED(sdnp[i].dn_bonustype) &&
	sdnp[i].dn_bonuslen != 0) {
	nr_iovecs++;
	}
	}

	dst_iovecs = kmem_alloc(nr_iovecs * sizeof (iovec_t), KM_SLEEP);

	/*
	* Iterate through the dnodes again, this time filling in the uios
	* we allocated earlier. We also concatenate any data we want to
	* authenticate onto aadbuf.
	*/

	/* The first iovec will contain the authbuf. */
	vec = 1;

	for (i = 0; i < max_dnp; i += sdnp[i].dn_extra_slots + 1) {
	dnp = &sdnp[i];

	/* copy over the core fields and blkptrs (kept as plaintext) */
	bcopy(dnp, &ddnp[i], (uint8_t )DN_BONUS(dnp) - (uint8_t )dnp);

	if (dnp->dn_flags & DNODE_FLAG_SPILL_BLKPTR) {
	bcopy(DN_SPILL_BLKPTR(dnp), DN_SPILL_BLKPTR(&ddnp[i]),
	sizeof (blkptr_t));
	}

	/*
	* Handle authenticated data. We authenticate everything in
	* the dnode that can be brought over when we do a raw send.
	* This includes all of the core fields as well as the MACs
	* stored in the bp checksums and all of the portable bits
	* from blk_prop. We include the dnode padding here in case it
	* ever gets used in the future. Some dn_flags and dn_used are
	* not portable so we mask those out values out of the
	* authenticated data.
	*/
	crypt_len = offsetof(dnode_phys_t, dn_blkptr);
	bcopy(dnp, aadp, crypt_len);
	adnp = (dnode_phys_t *)aadp;
	adnp->dn_flags &= DNODE_CRYPT_PORTABLE_FLAGS_MASK;
	adnp->dn_used = 0;
	aadp += crypt_len;
	aad_len += crypt_len;

	for (j = 0; j < dnp->dn_nblkptr; j++) {
	zio_crypt_bp_do_aad_updates(&aadp, &aad_len,
	version, byteswap, &dnp->dn_blkptr[j]);
	}

	if (dnp->dn_flags & DNODE_FLAG_SPILL_BLKPTR) {
	zio_crypt_bp_do_aad_updates(&aadp, &aad_len,
	version, byteswap, DN_SPILL_BLKPTR(dnp));
	}

	/*
	* If this bonus buffer needs to be encrypted, we prepare an
	* iovec_t. The encryption / decryption functions will fill
	* this in for us with the encrypted or decrypted data.
	* Otherwise we add the bonus buffer to the authenticated
	* data buffer and copy it over to the destination. The
	* encrypted iovec extends to DN_MAX_BONUS_LEN(dnp) so that
	* we can guarantee alignment with the AES block size
	* (128 bits).
	*/
	crypt_len = DN_MAX_BONUS_LEN(dnp);
	if (dnp->dn_type != DMU_OT_NONE &&
	DMU_OT_IS_ENCRYPTED(dnp->dn_bonustype) &&
	dnp->dn_bonuslen != 0) {
	dst_iovecs[vec].iov_base = DN_BONUS(&ddnp[i]);
	dst_iovecs[vec].iov_len = crypt_len;

	vec++;
	total_len += crypt_len;
	} else {
	bcopy(DN_BONUS(dnp), DN_BONUS(&ddnp[i]), crypt_len);
	bcopy(DN_BONUS(dnp), aadp, crypt_len);
	aadp += crypt_len;
	aad_len += crypt_len;
	}
	}

	/* The last iovec will contain the MAC. */
	ASSERT3U(vec, ==, nr_iovecs - 1);

	/* AAD */
	dst_iovecs[0].iov_base = aadbuf;
	dst_iovecs[0].iov_len = aad_len;
	/* MAC */
	dst_iovecs[vec].iov_base = 0;
	dst_iovecs[vec].iov_len = 0;

	*no_crypt = (vec == 1);
	*enc_len = total_len;
	*authbuf = aadbuf;
	*auth_len = aad_len;
	GET_UIO_STRUCT(out_uio)->uio_iov = dst_iovecs;
	zfs_uio_iovcnt(out_uio) = nr_iovecs;

	return (0);
	}

	/* ARGSUSED */
	static int
	zio_crypt_init_uios_normal(boolean_t encrypt, uint8_t *plainbuf,
	uint8_t cipherbuf, uint_t datalen, zfs_uio_t puio, zfs_uio_t *out_uio,
	uint_t *enc_len)
	{
	int ret;
	uint_t nr_plain = 1, nr_cipher = 2;
	iovec_t plain_iovecs = NULL, cipher_iovecs = NULL;
	void src, dst;

	cipher_iovecs = kmem_alloc(nr_cipher * sizeof (iovec_t),
	KM_SLEEP);
	if (!cipher_iovecs) {
	ret = SET_ERROR(ENOMEM);
	goto error;
	}
	bzero(cipher_iovecs, nr_cipher * sizeof (iovec_t));

	if (encrypt) {
	src = plainbuf;
	dst = cipherbuf;
	} else {
	src = cipherbuf;
	dst = plainbuf;
	}
	bcopy(src, dst, datalen);
	cipher_iovecs[0].iov_base = dst;
	cipher_iovecs[0].iov_len = datalen;

	*enc_len = datalen;
	GET_UIO_STRUCT(out_uio)->uio_iov = cipher_iovecs;
	zfs_uio_iovcnt(out_uio) = nr_cipher;

	return (0);

	error:
	if (plain_iovecs != NULL)
	kmem_free(plain_iovecs, nr_plain * sizeof (iovec_t));
	if (cipher_iovecs != NULL)
	kmem_free(cipher_iovecs, nr_cipher * sizeof (iovec_t));

	*enc_len = 0;
	GET_UIO_STRUCT(out_uio)->uio_iov = NULL;
	zfs_uio_iovcnt(out_uio) = 0;

	return (ret);
	}

	/*
	* This function builds up the plaintext (puio) and ciphertext (cuio) uios so
	* that they can be used for encryption and decryption by zio_do_crypt_uio().
	* Most blocks will use zio_crypt_init_uios_normal(), with ZIL and dnode blocks
	* requiring special handling to parse out pieces that are to be encrypted. The
	* authbuf is used by these special cases to store additional authenticated
	* data (AAD) for the encryption modes.
	*/
	static int
	zio_crypt_init_uios(boolean_t encrypt, uint64_t version, dmu_object_type_t ot,
	uint8_t plainbuf, uint8_t cipherbuf, uint_t datalen, boolean_t byteswap,
	uint8_t mac, zfs_uio_t puio, zfs_uio_t cuio, uint_t enc_len,
	uint8_t *authbuf, uint_t auth_len, boolean_t *no_crypt)
	{
	int ret;
	iovec_t *mac_iov;

	ASSERT(DMU_OT_IS_ENCRYPTED(ot) \|\| ot == DMU_OT_NONE);

	/* route to handler */
	switch (ot) {
	case DMU_OT_INTENT_LOG:
	ret = zio_crypt_init_uios_zil(encrypt, plainbuf, cipherbuf,
	datalen, byteswap, puio, cuio, enc_len, authbuf, auth_len,
	no_crypt);
	break;
	case DMU_OT_DNODE:
	ret = zio_crypt_init_uios_dnode(encrypt, version, plainbuf,
	cipherbuf, datalen, byteswap, puio, cuio, enc_len, authbuf,
	auth_len, no_crypt);
	break;
	default:
	ret = zio_crypt_init_uios_normal(encrypt, plainbuf, cipherbuf,
	datalen, puio, cuio, enc_len);
	*authbuf = NULL;
	*auth_len = 0;
	*no_crypt = B_FALSE;
	break;
	}

	if (ret != 0)
	goto error;

	/* populate the uios */
	zfs_uio_segflg(cuio) = UIO_SYSSPACE;

	mac_iov =
	((iovec_t *)&(GET_UIO_STRUCT(cuio)->
	uio_iov[zfs_uio_iovcnt(cuio) - 1]));
	mac_iov->iov_base = (void *)mac;
	mac_iov->iov_len = ZIO_DATA_MAC_LEN;

	return (0);

	error:
	return (ret);
	}

	void *failed_decrypt_buf;
	int faile_decrypt_size;

	/*
	* Primary encryption / decryption entrypoint for zio data.
	*/
	int
	zio_do_crypt_data(boolean_t encrypt, zio_crypt_key_t *key,
	dmu_object_type_t ot, boolean_t byteswap, uint8_t salt, uint8_t iv,
	uint8_t mac, uint_t datalen, uint8_t plainbuf, uint8_t *cipherbuf,
	boolean_t *no_crypt)
	{
	int ret;
	boolean_t locked = B_FALSE;
	uint64_t crypt = key->zk_crypt;
	uint_t keydata_len = zio_crypt_table[crypt].ci_keylen;
	uint_t enc_len, auth_len;
	zfs_uio_t puio, cuio;
	struct uio puio_s, cuio_s;
	uint8_t enc_keydata[MASTER_KEY_MAX_LEN];
	crypto_key_t tmp_ckey, *ckey = NULL;
	freebsd_crypt_session_t *tmpl = NULL;
	uint8_t *authbuf = NULL;


	zfs_uio_init(&puio, &puio_s);
	zfs_uio_init(&cuio, &cuio_s);
	bzero(GET_UIO_STRUCT(&puio), sizeof (struct uio));
	bzero(GET_UIO_STRUCT(&cuio), sizeof (struct uio));

	#ifdef FCRYPTO_DEBUG
	printf("%s(%s, %p, %p, %d, %p, %p, %u, %s, %p, %p, %p)\n",
	__FUNCTION__,
	encrypt ? "encrypt" : "decrypt",
	key, salt, ot, iv, mac, datalen,
	byteswap ? "byteswap" : "native_endian", plainbuf,
	cipherbuf, no_crypt);

	printf("\tkey = {");
	for (int i = 0; i < key->zk_current_key.ck_length/8; i++)
	printf("%02x ", ((uint8_t *)key->zk_current_key.ck_data)[i]);
	printf("}\n");
	#endif
	/* create uios for encryption */
	ret = zio_crypt_init_uios(encrypt, key->zk_version, ot, plainbuf,
	cipherbuf, datalen, byteswap, mac, &puio, &cuio, &enc_len,
	&authbuf, &auth_len, no_crypt);
	if (ret != 0)
	return (ret);

	/*
	* If the needed key is the current one, just use it. Otherwise we
	* need to generate a temporary one from the given salt + master key.
	* If we are encrypting, we must return a copy of the current salt
	* so that it can be stored in the blkptr_t.
	*/
	rw_enter(&key->zk_salt_lock, RW_READER);
	locked = B_TRUE;

	if (bcmp(salt, key->zk_salt, ZIO_DATA_SALT_LEN) == 0) {
	ckey = &key->zk_current_key;
	tmpl = &key->zk_session;
	} else {
	rw_exit(&key->zk_salt_lock);
	locked = B_FALSE;

	ret = hkdf_sha512(key->zk_master_keydata, keydata_len, NULL, 0,
	salt, ZIO_DATA_SALT_LEN, enc_keydata, keydata_len);
	if (ret != 0)
	goto error;
	tmp_ckey.ck_format = CRYPTO_KEY_RAW;
	tmp_ckey.ck_data = enc_keydata;
	tmp_ckey.ck_length = CRYPTO_BYTES2BITS(keydata_len);

	ckey = &tmp_ckey;
	tmpl = NULL;
	}

	/* perform the encryption / decryption */
	ret = zio_do_crypt_uio_opencrypto(encrypt, tmpl, key->zk_crypt,
	ckey, iv, enc_len, &cuio, auth_len);
	if (ret != 0)
	goto error;
	if (locked) {
	rw_exit(&key->zk_salt_lock);
	locked = B_FALSE;
	}

	if (authbuf != NULL)
	zio_buf_free(authbuf, datalen);
	if (ckey == &tmp_ckey)
	bzero(enc_keydata, keydata_len);
	zio_crypt_destroy_uio(&puio);
	zio_crypt_destroy_uio(&cuio);

	return (0);

	error:
	if (!encrypt) {
	if (failed_decrypt_buf != NULL)
	kmem_free(failed_decrypt_buf, failed_decrypt_size);
	failed_decrypt_buf = kmem_alloc(datalen, KM_SLEEP);
	failed_decrypt_size = datalen;
	bcopy(cipherbuf, failed_decrypt_buf, datalen);
	}
	if (locked)
	rw_exit(&key->zk_salt_lock);
	if (authbuf != NULL)
	zio_buf_free(authbuf, datalen);
	if (ckey == &tmp_ckey)
	bzero(enc_keydata, keydata_len);
	zio_crypt_destroy_uio(&puio);
	zio_crypt_destroy_uio(&cuio);
	return (SET_ERROR(ret));
	}

	/*
	* Simple wrapper around zio_do_crypt_data() to work with abd's instead of
	* linear buffers.
	*/
	int
	zio_do_crypt_abd(boolean_t encrypt, zio_crypt_key_t *key, dmu_object_type_t ot,
	boolean_t byteswap, uint8_t salt, uint8_t iv, uint8_t *mac,
	uint_t datalen, abd_t pabd, abd_t cabd, boolean_t *no_crypt)
	{
	int ret;
	void ptmp, ctmp;

	if (encrypt) {
	ptmp = abd_borrow_buf_copy(pabd, datalen);
	ctmp = abd_borrow_buf(cabd, datalen);
	} else {
	ptmp = abd_borrow_buf(pabd, datalen);
	ctmp = abd_borrow_buf_copy(cabd, datalen);
	}

	ret = zio_do_crypt_data(encrypt, key, ot, byteswap, salt, iv, mac,
	datalen, ptmp, ctmp, no_crypt);
	if (ret != 0)
	goto error;

	if (encrypt) {
	abd_return_buf(pabd, ptmp, datalen);
	abd_return_buf_copy(cabd, ctmp, datalen);
	} else {
	abd_return_buf_copy(pabd, ptmp, datalen);
	abd_return_buf(cabd, ctmp, datalen);
	}

	return (0);

	error:
	if (encrypt) {
	abd_return_buf(pabd, ptmp, datalen);
	abd_return_buf_copy(cabd, ctmp, datalen);
	} else {
	abd_return_buf_copy(pabd, ptmp, datalen);
	abd_return_buf(cabd, ctmp, datalen);
	}

	return (SET_ERROR(ret));
	}

	#if defined(_KERNEL) && defined(HAVE_SPL)
	/* BEGIN CSTYLED */
	module_param(zfs_key_max_salt_uses, ulong, 0644);
	MODULE_PARM_DESC(zfs_key_max_salt_uses, "Max number of times a salt value "
	"can be used for generating encryption keys before it is rotated");
	/* END CSTYLED */
	#endif
	diff --git a/sys/contrib/openzfs/module/os/freebsd/zfs/zvol_os.c b/sys/contrib/openzfs/module/os/freebsd/zfs/zvol_os.c
	index ba315f104738..4d889962be2e 100644
	--- a/sys/contrib/openzfs/module/os/freebsd/zfs/zvol_os.c
	+++ b/sys/contrib/openzfs/module/os/freebsd/zfs/zvol_os.c
	@@ -1,1532 +1,1538 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	*
	* Copyright (c) 2006-2010 Pawel Jakub Dawidek <pjd@FreeBSD.org>
	* All rights reserved.
	*
	* Portions Copyright 2010 Robert Milkowski
	*
	* Copyright 2011 Nexenta Systems, Inc. All rights reserved.
	* Copyright (c) 2012, 2017 by Delphix. All rights reserved.
	* Copyright (c) 2013, Joyent, Inc. All rights reserved.
	* Copyright (c) 2014 Integros [integros.com]
	*/

	/* Portions Copyright 2011 Martin Matuska <mm@FreeBSD.org> */

	/*
	* ZFS volume emulation driver.
	*
	* Makes a DMU object look like a volume of arbitrary size, up to 2^64 bytes.
	* Volumes are accessed through the symbolic links named:
	*
	* /dev/zvol/<pool_name>/<dataset_name>
	*
	* Volumes are persistent through reboot. No user command needs to be
	* run before opening and using a device.
	*
	* On FreeBSD ZVOLs are simply GEOM providers like any other storage device
	* in the system. Except when they're simply character devices (volmode=dev).
	*/

	#include <sys/types.h>
	#include <sys/param.h>
	#include <sys/kernel.h>
	#include <sys/errno.h>
	#include <sys/uio.h>
	#include <sys/bio.h>
	#include <sys/buf.h>
	#include <sys/kmem.h>
	#include <sys/conf.h>
	#include <sys/cmn_err.h>
	#include <sys/stat.h>
	#include <sys/proc.h>
	#include <sys/zap.h>
	#include <sys/spa.h>
	#include <sys/spa_impl.h>
	#include <sys/zio.h>
	#include <sys/disk.h>
	#include <sys/dmu_traverse.h>
	#include <sys/dnode.h>
	#include <sys/dsl_dataset.h>
	#include <sys/dsl_prop.h>
	#include <sys/dsl_dir.h>
	#include <sys/byteorder.h>
	#include <sys/sunddi.h>
	#include <sys/dirent.h>
	#include <sys/policy.h>
	#include <sys/queue.h>
	#include <sys/fs/zfs.h>
	#include <sys/zfs_ioctl.h>
	#include <sys/zil.h>
	#include <sys/zfs_znode.h>
	#include <sys/zfs_rlock.h>
	#include <sys/vdev_impl.h>
	#include <sys/vdev_raidz.h>
	#include <sys/zvol.h>
	#include <sys/zil_impl.h>
	#include <sys/dataset_kstats.h>
	#include <sys/dbuf.h>
	#include <sys/dmu_tx.h>
	#include <sys/zfeature.h>
	#include <sys/zio_checksum.h>
	#include <sys/zil_impl.h>
	#include <sys/filio.h>

	#include <geom/geom.h>
	#include <sys/zvol.h>
	#include <sys/zvol_impl.h>

	#include "zfs_namecheck.h"

	#define ZVOL_DUMPSIZE "dumpsize"

	#ifdef ZVOL_LOCK_DEBUG
	#define ZVOL_RW_READER RW_WRITER
	#define ZVOL_RW_READ_HELD RW_WRITE_HELD
	#else
	#define ZVOL_RW_READER RW_READER
	#define ZVOL_RW_READ_HELD RW_READ_HELD
	#endif

	enum zvol_geom_state {
	ZVOL_GEOM_UNINIT,
	ZVOL_GEOM_STOPPED,
	ZVOL_GEOM_RUNNING,
	};

	struct zvol_state_os {
	#define zso_dev _zso_state._zso_dev
	#define zso_geom _zso_state._zso_geom
	union {
	/* volmode=dev */
	struct zvol_state_dev {
	struct cdev *zsd_cdev;
	uint64_t zsd_sync_cnt;
	} _zso_dev;

	/* volmode=geom */
	struct zvol_state_geom {
	struct g_provider *zsg_provider;
	struct bio_queue_head zsg_queue;
	struct mtx zsg_queue_mtx;
	enum zvol_geom_state zsg_state;
	} _zso_geom;
	} _zso_state;
	int zso_dying;
	};

	static uint32_t zvol_minors;

	SYSCTL_DECL(_vfs_zfs);
	SYSCTL_NODE(_vfs_zfs, OID_AUTO, vol, CTLFLAG_RW, 0, "ZFS VOLUME");
	SYSCTL_INT(_vfs_zfs_vol, OID_AUTO, mode, CTLFLAG_RWTUN, &zvol_volmode, 0,
	"Expose as GEOM providers (1), device files (2) or neither");
	static boolean_t zpool_on_zvol = B_FALSE;
	SYSCTL_INT(_vfs_zfs_vol, OID_AUTO, recursive, CTLFLAG_RWTUN, &zpool_on_zvol, 0,
	"Allow zpools to use zvols as vdevs (DANGEROUS)");

	/*
	* Toggle unmap functionality.
	*/
	boolean_t zvol_unmap_enabled = B_TRUE;

	SYSCTL_INT(_vfs_zfs_vol, OID_AUTO, unmap_enabled, CTLFLAG_RWTUN,
	&zvol_unmap_enabled, 0, "Enable UNMAP functionality");

	/*
	* zvol maximum transfer in one DMU tx.
	*/
	int zvol_maxphys = DMU_MAX_ACCESS / 2;

	static void zvol_ensure_zilog(zvol_state_t *zv);

	static d_open_t zvol_cdev_open;
	static d_close_t zvol_cdev_close;
	static d_ioctl_t zvol_cdev_ioctl;
	static d_read_t zvol_cdev_read;
	static d_write_t zvol_cdev_write;
	static d_strategy_t zvol_geom_bio_strategy;

	static struct cdevsw zvol_cdevsw = {
	.d_name = "zvol",
	.d_version = D_VERSION,
	.d_flags = D_DISK \| D_TRACKCLOSE,
	.d_open = zvol_cdev_open,
	.d_close = zvol_cdev_close,
	.d_ioctl = zvol_cdev_ioctl,
	.d_read = zvol_cdev_read,
	.d_write = zvol_cdev_write,
	.d_strategy = zvol_geom_bio_strategy,
	};

	extern uint_t zfs_geom_probe_vdev_key;

	struct g_class zfs_zvol_class = {
	.name = "ZFS::ZVOL",
	.version = G_VERSION,
	};

	DECLARE_GEOM_CLASS(zfs_zvol_class, zfs_zvol);

	static int zvol_geom_open(struct g_provider *pp, int flag, int count);
	static int zvol_geom_close(struct g_provider *pp, int flag, int count);
	static void zvol_geom_run(zvol_state_t *zv);
	static void zvol_geom_destroy(zvol_state_t *zv);
	static int zvol_geom_access(struct g_provider *pp, int acr, int acw, int ace);
	static void zvol_geom_worker(void *arg);
	static void zvol_geom_bio_start(struct bio *bp);
	static int zvol_geom_bio_getattr(struct bio *bp);
	/* static d_strategy_t zvol_geom_bio_strategy; (declared elsewhere) */

	/*
	* GEOM mode implementation
	*/

	/ARGSUSED/
	static int
	zvol_geom_open(struct g_provider *pp, int flag, int count)
	{
	zvol_state_t *zv;
	int err = 0;
	boolean_t drop_suspend = B_FALSE;
	boolean_t drop_namespace = B_FALSE;

	if (!zpool_on_zvol && tsd_get(zfs_geom_probe_vdev_key) != NULL) {
	/*
	* if zfs_geom_probe_vdev_key is set, that means that zfs is
	* attempting to probe geom providers while looking for a
	* replacement for a missing VDEV. In this case, the
	* spa_namespace_lock will not be held, but it is still illegal
	* to use a zvol as a vdev. Deadlocks can result if another
	* thread has spa_namespace_lock
	*/
	return (SET_ERROR(EOPNOTSUPP));
	}

	retry:
	rw_enter(&zvol_state_lock, ZVOL_RW_READER);
	zv = pp->private;
	if (zv == NULL) {
	rw_exit(&zvol_state_lock);
	err = SET_ERROR(ENXIO);
	goto out_locked;
	}

	if (zv->zv_open_count == 0 && !mutex_owned(&spa_namespace_lock)) {
	/*
	* We need to guarantee that the namespace lock is held
	* to avoid spurious failures in zvol_first_open.
	*/
	drop_namespace = B_TRUE;
	if (!mutex_tryenter(&spa_namespace_lock)) {
	rw_exit(&zvol_state_lock);
	mutex_enter(&spa_namespace_lock);
	goto retry;
	}
	}
	mutex_enter(&zv->zv_state_lock);
	if (zv->zv_zso->zso_dying) {
	rw_exit(&zvol_state_lock);
	err = SET_ERROR(ENXIO);
	goto out_zv_locked;
	}
	ASSERT3S(zv->zv_volmode, ==, ZFS_VOLMODE_GEOM);

	/*
	* make sure zvol is not suspended during first open
	* (hold zv_suspend_lock) and respect proper lock acquisition
	* ordering - zv_suspend_lock before zv_state_lock
	*/
	if (zv->zv_open_count == 0) {
	drop_suspend = B_TRUE;
	if (!rw_tryenter(&zv->zv_suspend_lock, ZVOL_RW_READER)) {
	mutex_exit(&zv->zv_state_lock);
	rw_enter(&zv->zv_suspend_lock, ZVOL_RW_READER);
	mutex_enter(&zv->zv_state_lock);
	/* check to see if zv_suspend_lock is needed */
	if (zv->zv_open_count != 0) {
	rw_exit(&zv->zv_suspend_lock);
	drop_suspend = B_FALSE;
	}
	}
	}
	rw_exit(&zvol_state_lock);

	ASSERT(MUTEX_HELD(&zv->zv_state_lock));

	if (zv->zv_open_count == 0) {
	ASSERT(ZVOL_RW_READ_HELD(&zv->zv_suspend_lock));
	err = zvol_first_open(zv, !(flag & FWRITE));
	if (err)
	goto out_zv_locked;
	pp->mediasize = zv->zv_volsize;
	pp->stripeoffset = 0;
	pp->stripesize = zv->zv_volblocksize;
	}

	/*
	* Check for a bad on-disk format version now since we
	* lied about owning the dataset readonly before.
	*/
	if ((flag & FWRITE) && ((zv->zv_flags & ZVOL_RDONLY) \|\|
	dmu_objset_incompatible_encryption_version(zv->zv_objset))) {
	err = SET_ERROR(EROFS);
	goto out_opened;
	}
	if (zv->zv_flags & ZVOL_EXCL) {
	err = SET_ERROR(EBUSY);
	goto out_opened;
	}
	#ifdef FEXCL
	if (flag & FEXCL) {
	if (zv->zv_open_count != 0) {
	err = SET_ERROR(EBUSY);
	goto out_opened;
	}
	zv->zv_flags \|= ZVOL_EXCL;
	}
	#endif

	zv->zv_open_count += count;
	out_opened:
	if (zv->zv_open_count == 0) {
	zvol_last_close(zv);
	wakeup(zv);
	}
	out_zv_locked:
	mutex_exit(&zv->zv_state_lock);
	out_locked:
	if (drop_namespace)
	mutex_exit(&spa_namespace_lock);
	if (drop_suspend)
	rw_exit(&zv->zv_suspend_lock);
	return (err);
	}

	/ARGSUSED/
	static int
	zvol_geom_close(struct g_provider *pp, int flag, int count)
	{
	zvol_state_t *zv;
	boolean_t drop_suspend = B_TRUE;
	int new_open_count;

	rw_enter(&zvol_state_lock, ZVOL_RW_READER);
	zv = pp->private;
	if (zv == NULL) {
	rw_exit(&zvol_state_lock);
	return (SET_ERROR(ENXIO));
	}

	mutex_enter(&zv->zv_state_lock);
	if (zv->zv_flags & ZVOL_EXCL) {
	ASSERT3U(zv->zv_open_count, ==, 1);
	zv->zv_flags &= ~ZVOL_EXCL;
	}

	ASSERT3S(zv->zv_volmode, ==, ZFS_VOLMODE_GEOM);

	/*
	* If the open count is zero, this is a spurious close.
	* That indicates a bug in the kernel / DDI framework.
	*/
	ASSERT3U(zv->zv_open_count, >, 0);

	/*
	* make sure zvol is not suspended during last close
	* (hold zv_suspend_lock) and respect proper lock acquisition
	* ordering - zv_suspend_lock before zv_state_lock
	*/
	new_open_count = zv->zv_open_count - count;
	if (new_open_count == 0) {
	if (!rw_tryenter(&zv->zv_suspend_lock, ZVOL_RW_READER)) {
	mutex_exit(&zv->zv_state_lock);
	rw_enter(&zv->zv_suspend_lock, ZVOL_RW_READER);
	mutex_enter(&zv->zv_state_lock);
	/* check to see if zv_suspend_lock is needed */
	new_open_count = zv->zv_open_count - count;
	if (new_open_count != 0) {
	rw_exit(&zv->zv_suspend_lock);
	drop_suspend = B_FALSE;
	}
	}
	} else {
	drop_suspend = B_FALSE;
	}
	rw_exit(&zvol_state_lock);

	ASSERT(MUTEX_HELD(&zv->zv_state_lock));

	/*
	* You may get multiple opens, but only one close.
	*/
	zv->zv_open_count = new_open_count;
	if (zv->zv_open_count == 0) {
	ASSERT(ZVOL_RW_READ_HELD(&zv->zv_suspend_lock));
	zvol_last_close(zv);
	wakeup(zv);
	}

	mutex_exit(&zv->zv_state_lock);

	if (drop_suspend)
	rw_exit(&zv->zv_suspend_lock);
	return (0);
	}

	static void
	zvol_geom_run(zvol_state_t *zv)
	{
	struct zvol_state_geom *zsg = &zv->zv_zso->zso_geom;
	struct g_provider *pp = zsg->zsg_provider;

	ASSERT3S(zv->zv_volmode, ==, ZFS_VOLMODE_GEOM);

	g_error_provider(pp, 0);

	kproc_kthread_add(zvol_geom_worker, zv, &system_proc, NULL, 0, 0,
	"zfskern", "zvol %s", pp->name + sizeof (ZVOL_DRIVER));
	}

	static void
	zvol_geom_destroy(zvol_state_t *zv)
	{
	struct zvol_state_geom *zsg = &zv->zv_zso->zso_geom;
	struct g_provider *pp = zsg->zsg_provider;

	ASSERT3S(zv->zv_volmode, ==, ZFS_VOLMODE_GEOM);

	g_topology_assert();

	mutex_enter(&zv->zv_state_lock);
	VERIFY(zsg->zsg_state == ZVOL_GEOM_RUNNING);
	mutex_exit(&zv->zv_state_lock);
	zsg->zsg_provider = NULL;
	g_wither_geom(pp->geom, ENXIO);
	}

	void
	zvol_wait_close(zvol_state_t *zv)
	{

	if (zv->zv_volmode != ZFS_VOLMODE_GEOM)
	return;
	mutex_enter(&zv->zv_state_lock);
	zv->zv_zso->zso_dying = B_TRUE;

	if (zv->zv_open_count)
	msleep(zv, &zv->zv_state_lock,
	PRIBIO, "zvol:dying", 10*hz);
	mutex_exit(&zv->zv_state_lock);
	}


	static int
	zvol_geom_access(struct g_provider *pp, int acr, int acw, int ace)
	{
	int count, error, flags;

	g_topology_assert();

	/*
	* To make it easier we expect either open or close, but not both
	* at the same time.
	*/
	KASSERT((acr >= 0 && acw >= 0 && ace >= 0) \|\|
	(acr <= 0 && acw <= 0 && ace <= 0),
	("Unsupported access request to %s (acr=%d, acw=%d, ace=%d).",
	pp->name, acr, acw, ace));

	if (pp->private == NULL) {
	if (acr <= 0 && acw <= 0 && ace <= 0)
	return (0);
	return (pp->error);
	}

	/*
	* We don't pass FEXCL flag to zvol_geom_open()/zvol_geom_close() if
	* ace != 0, because GEOM already handles that and handles it a bit
	* differently. GEOM allows for multiple read/exclusive consumers and
	* ZFS allows only one exclusive consumer, no matter if it is reader or
	* writer. I like better the way GEOM works so I'll leave it for GEOM
	* to decide what to do.
	*/

	count = acr + acw + ace;
	if (count == 0)
	return (0);

	flags = 0;
	if (acr != 0 \|\| ace != 0)
	flags \|= FREAD;
	if (acw != 0)
	flags \|= FWRITE;

	g_topology_unlock();
	if (count > 0)
	error = zvol_geom_open(pp, flags, count);
	else
	error = zvol_geom_close(pp, flags, -count);
	g_topology_lock();
	return (error);
	}

	static void
	zvol_geom_worker(void *arg)
	{
	zvol_state_t *zv = arg;
	struct zvol_state_geom *zsg = &zv->zv_zso->zso_geom;
	struct bio *bp;

	ASSERT3S(zv->zv_volmode, ==, ZFS_VOLMODE_GEOM);

	thread_lock(curthread);
	sched_prio(curthread, PRIBIO);
	thread_unlock(curthread);

	for (;;) {
	mtx_lock(&zsg->zsg_queue_mtx);
	bp = bioq_takefirst(&zsg->zsg_queue);
	if (bp == NULL) {
	if (zsg->zsg_state == ZVOL_GEOM_STOPPED) {
	zsg->zsg_state = ZVOL_GEOM_RUNNING;
	wakeup(&zsg->zsg_state);
	mtx_unlock(&zsg->zsg_queue_mtx);
	kthread_exit();
	}
	msleep(&zsg->zsg_queue, &zsg->zsg_queue_mtx,
	PRIBIO \| PDROP, "zvol:io", 0);
	continue;
	}
	mtx_unlock(&zsg->zsg_queue_mtx);
	zvol_geom_bio_strategy(bp);
	}
	}

	static void
	zvol_geom_bio_start(struct bio *bp)
	{
	zvol_state_t *zv = bp->bio_to->private;
	struct zvol_state_geom *zsg;
	boolean_t first;

	if (zv == NULL) {
	g_io_deliver(bp, ENXIO);
	return;
	}
	if (bp->bio_cmd == BIO_GETATTR) {
	if (zvol_geom_bio_getattr(bp))
	g_io_deliver(bp, EOPNOTSUPP);
	return;
	}

	if (!THREAD_CAN_SLEEP()) {
	zsg = &zv->zv_zso->zso_geom;
	mtx_lock(&zsg->zsg_queue_mtx);
	first = (bioq_first(&zsg->zsg_queue) == NULL);
	bioq_insert_tail(&zsg->zsg_queue, bp);
	mtx_unlock(&zsg->zsg_queue_mtx);
	if (first)
	wakeup_one(&zsg->zsg_queue);
	return;
	}

	zvol_geom_bio_strategy(bp);
	}

	static int
	zvol_geom_bio_getattr(struct bio *bp)
	{
	zvol_state_t *zv;

	zv = bp->bio_to->private;
	ASSERT3P(zv, !=, NULL);

	spa_t *spa = dmu_objset_spa(zv->zv_objset);
	uint64_t refd, avail, usedobjs, availobjs;

	if (g_handleattr_int(bp, "GEOM::candelete", 1))
	return (0);
	if (strcmp(bp->bio_attribute, "blocksavail") == 0) {
	dmu_objset_space(zv->zv_objset, &refd, &avail,
	&usedobjs, &availobjs);
	if (g_handleattr_off_t(bp, "blocksavail", avail / DEV_BSIZE))
	return (0);
	} else if (strcmp(bp->bio_attribute, "blocksused") == 0) {
	dmu_objset_space(zv->zv_objset, &refd, &avail,
	&usedobjs, &availobjs);
	if (g_handleattr_off_t(bp, "blocksused", refd / DEV_BSIZE))
	return (0);
	} else if (strcmp(bp->bio_attribute, "poolblocksavail") == 0) {
	avail = metaslab_class_get_space(spa_normal_class(spa));
	avail -= metaslab_class_get_alloc(spa_normal_class(spa));
	if (g_handleattr_off_t(bp, "poolblocksavail",
	avail / DEV_BSIZE))
	return (0);
	} else if (strcmp(bp->bio_attribute, "poolblocksused") == 0) {
	refd = metaslab_class_get_alloc(spa_normal_class(spa));
	if (g_handleattr_off_t(bp, "poolblocksused", refd / DEV_BSIZE))
	return (0);
	}
	return (1);
	}

	static void
	zvol_geom_bio_strategy(struct bio *bp)
	{
	zvol_state_t *zv;
	uint64_t off, volsize;
	size_t resid;
	char *addr;
	objset_t *os;
	zfs_locked_range_t *lr;
	int error = 0;
	boolean_t doread = B_FALSE;
	boolean_t is_dumpified;
	boolean_t sync;

	if (bp->bio_to)
	zv = bp->bio_to->private;
	else
	zv = bp->bio_dev->si_drv2;

	if (zv == NULL) {
	error = SET_ERROR(ENXIO);
	goto out;
	}

	rw_enter(&zv->zv_suspend_lock, ZVOL_RW_READER);

	switch (bp->bio_cmd) {
	case BIO_READ:
	doread = B_TRUE;
	break;
	case BIO_WRITE:
	case BIO_FLUSH:
	case BIO_DELETE:
	if (zv->zv_flags & ZVOL_RDONLY) {
	error = SET_ERROR(EROFS);
	goto resume;
	}
	zvol_ensure_zilog(zv);
	if (bp->bio_cmd == BIO_FLUSH)
	goto sync;
	break;
	default:
	error = SET_ERROR(EOPNOTSUPP);
	goto resume;
	}

	off = bp->bio_offset;
	volsize = zv->zv_volsize;

	os = zv->zv_objset;
	ASSERT3P(os, !=, NULL);

	addr = bp->bio_data;
	resid = bp->bio_length;

	if (resid > 0 && off >= volsize) {
	error = SET_ERROR(EIO);
	goto resume;
	}

	is_dumpified = B_FALSE;
	sync = !doread && !is_dumpified &&
	zv->zv_objset->os_sync == ZFS_SYNC_ALWAYS;

	/*
	* There must be no buffer changes when doing a dmu_sync() because
	* we can't change the data whilst calculating the checksum.
	*/
	lr = zfs_rangelock_enter(&zv->zv_rangelock, off, resid,
	doread ? RL_READER : RL_WRITER);

	if (bp->bio_cmd == BIO_DELETE) {
	dmu_tx_t *tx = dmu_tx_create(zv->zv_objset);
	error = dmu_tx_assign(tx, TXG_WAIT);
	if (error != 0) {
	dmu_tx_abort(tx);
	} else {
	zvol_log_truncate(zv, tx, off, resid, sync);
	dmu_tx_commit(tx);
	error = dmu_free_long_range(zv->zv_objset, ZVOL_OBJ,
	off, resid);
	resid = 0;
	}
	goto unlock;
	}
	while (resid != 0 && off < volsize) {
	size_t size = MIN(resid, zvol_maxphys);
	if (doread) {
	error = dmu_read(os, ZVOL_OBJ, off, size, addr,
	DMU_READ_PREFETCH);
	} else {
	dmu_tx_t *tx = dmu_tx_create(os);
	dmu_tx_hold_write_by_dnode(tx, zv->zv_dn, off, size);
	error = dmu_tx_assign(tx, TXG_WAIT);
	if (error) {
	dmu_tx_abort(tx);
	} else {
	dmu_write(os, ZVOL_OBJ, off, size, addr, tx);
	zvol_log_write(zv, tx, off, size, sync);
	dmu_tx_commit(tx);
	}
	}
	if (error) {
	/* convert checksum errors into IO errors */
	if (error == ECKSUM)
	error = SET_ERROR(EIO);
	break;
	}
	off += size;
	addr += size;
	resid -= size;
	}
	unlock:
	zfs_rangelock_exit(lr);

	bp->bio_completed = bp->bio_length - resid;
	if (bp->bio_completed < bp->bio_length && off > volsize)
	error = SET_ERROR(EINVAL);

	switch (bp->bio_cmd) {
	case BIO_FLUSH:
	break;
	case BIO_READ:
	dataset_kstats_update_read_kstats(&zv->zv_kstat,
	bp->bio_completed);
	break;
	case BIO_WRITE:
	dataset_kstats_update_write_kstats(&zv->zv_kstat,
	bp->bio_completed);
	break;
	case BIO_DELETE:
	break;
	default:
	break;
	}

	if (sync) {
	sync:
	zil_commit(zv->zv_zilog, ZVOL_OBJ);
	}
	resume:
	rw_exit(&zv->zv_suspend_lock);
	out:
	if (bp->bio_to)
	g_io_deliver(bp, error);
	else
	biofinish(bp, NULL, error);
	}

	/*
	* Character device mode implementation
	*/

	static int
	zvol_cdev_read(struct cdev dev, struct uio uio_s, int ioflag)
	{
	zvol_state_t *zv;
	uint64_t volsize;
	zfs_locked_range_t *lr;
	int error = 0;
	zfs_uio_t uio;

	zfs_uio_init(&uio, uio_s);

	zv = dev->si_drv2;

	volsize = zv->zv_volsize;
	/*
	* uio_loffset == volsize isn't an error as
	- * its required for EOF processing.
	+ * it's required for EOF processing.
	*/
	if (zfs_uio_resid(&uio) > 0 &&
	(zfs_uio_offset(&uio) < 0 \|\| zfs_uio_offset(&uio) > volsize))
	return (SET_ERROR(EIO));

	+ ssize_t start_resid = zfs_uio_resid(&uio);
	lr = zfs_rangelock_enter(&zv->zv_rangelock, zfs_uio_offset(&uio),
	zfs_uio_resid(&uio), RL_READER);
	while (zfs_uio_resid(&uio) > 0 && zfs_uio_offset(&uio) < volsize) {
	uint64_t bytes = MIN(zfs_uio_resid(&uio), DMU_MAX_ACCESS >> 1);

	/* don't read past the end */
	if (bytes > volsize - zfs_uio_offset(&uio))
	bytes = volsize - zfs_uio_offset(&uio);

	error = dmu_read_uio_dnode(zv->zv_dn, &uio, bytes);
	if (error) {
	/* convert checksum errors into IO errors */
	if (error == ECKSUM)
	error = SET_ERROR(EIO);
	break;
	}
	}
	zfs_rangelock_exit(lr);
	+ int64_t nread = start_resid - zfs_uio_resid(&uio);
	+ dataset_kstats_update_read_kstats(&zv->zv_kstat, nread);

	return (error);
	}

	static int
	zvol_cdev_write(struct cdev dev, struct uio uio_s, int ioflag)
	{
	zvol_state_t *zv;
	uint64_t volsize;
	zfs_locked_range_t *lr;
	int error = 0;
	boolean_t sync;
	zfs_uio_t uio;

	zv = dev->si_drv2;

	volsize = zv->zv_volsize;

	zfs_uio_init(&uio, uio_s);

	if (zfs_uio_resid(&uio) > 0 &&
	(zfs_uio_offset(&uio) < 0 \|\| zfs_uio_offset(&uio) > volsize))
	return (SET_ERROR(EIO));

	+ ssize_t start_resid = zfs_uio_resid(&uio);
	sync = (ioflag & IO_SYNC) \|\|
	(zv->zv_objset->os_sync == ZFS_SYNC_ALWAYS);

	rw_enter(&zv->zv_suspend_lock, ZVOL_RW_READER);
	zvol_ensure_zilog(zv);

	lr = zfs_rangelock_enter(&zv->zv_rangelock, zfs_uio_offset(&uio),
	zfs_uio_resid(&uio), RL_WRITER);
	while (zfs_uio_resid(&uio) > 0 && zfs_uio_offset(&uio) < volsize) {
	uint64_t bytes = MIN(zfs_uio_resid(&uio), DMU_MAX_ACCESS >> 1);
	uint64_t off = zfs_uio_offset(&uio);
	dmu_tx_t *tx = dmu_tx_create(zv->zv_objset);

	if (bytes > volsize - off) /* don't write past the end */
	bytes = volsize - off;

	dmu_tx_hold_write_by_dnode(tx, zv->zv_dn, off, bytes);
	error = dmu_tx_assign(tx, TXG_WAIT);
	if (error) {
	dmu_tx_abort(tx);
	break;
	}
	error = dmu_write_uio_dnode(zv->zv_dn, &uio, bytes, tx);
	if (error == 0)
	zvol_log_write(zv, tx, off, bytes, sync);
	dmu_tx_commit(tx);

	if (error)
	break;
	}
	zfs_rangelock_exit(lr);
	+ int64_t nwritten = start_resid - zfs_uio_resid(&uio);
	+ dataset_kstats_update_write_kstats(&zv->zv_kstat, nwritten);
	if (sync)
	zil_commit(zv->zv_zilog, ZVOL_OBJ);
	rw_exit(&zv->zv_suspend_lock);
	return (error);
	}

	static int
	zvol_cdev_open(struct cdev dev, int flags, int fmt, struct thread td)
	{
	zvol_state_t *zv;
	struct zvol_state_dev *zsd;
	int err = 0;
	boolean_t drop_suspend = B_FALSE;
	boolean_t drop_namespace = B_FALSE;

	retry:
	rw_enter(&zvol_state_lock, ZVOL_RW_READER);
	zv = dev->si_drv2;
	if (zv == NULL) {
	rw_exit(&zvol_state_lock);
	err = SET_ERROR(ENXIO);
	goto out_locked;
	}

	if (zv->zv_open_count == 0 && !mutex_owned(&spa_namespace_lock)) {
	/*
	* We need to guarantee that the namespace lock is held
	* to avoid spurious failures in zvol_first_open.
	*/
	drop_namespace = B_TRUE;
	if (!mutex_tryenter(&spa_namespace_lock)) {
	rw_exit(&zvol_state_lock);
	mutex_enter(&spa_namespace_lock);
	goto retry;
	}
	}
	mutex_enter(&zv->zv_state_lock);

	ASSERT3S(zv->zv_volmode, ==, ZFS_VOLMODE_DEV);

	/*
	* make sure zvol is not suspended during first open
	* (hold zv_suspend_lock) and respect proper lock acquisition
	* ordering - zv_suspend_lock before zv_state_lock
	*/
	if (zv->zv_open_count == 0) {
	drop_suspend = B_TRUE;
	if (!rw_tryenter(&zv->zv_suspend_lock, ZVOL_RW_READER)) {
	mutex_exit(&zv->zv_state_lock);
	rw_enter(&zv->zv_suspend_lock, ZVOL_RW_READER);
	mutex_enter(&zv->zv_state_lock);
	/* check to see if zv_suspend_lock is needed */
	if (zv->zv_open_count != 0) {
	rw_exit(&zv->zv_suspend_lock);
	drop_suspend = B_FALSE;
	}
	}
	}
	rw_exit(&zvol_state_lock);

	ASSERT(MUTEX_HELD(&zv->zv_state_lock));

	if (zv->zv_open_count == 0) {
	ASSERT(ZVOL_RW_READ_HELD(&zv->zv_suspend_lock));
	err = zvol_first_open(zv, !(flags & FWRITE));
	if (err)
	goto out_zv_locked;
	}

	if ((flags & FWRITE) && (zv->zv_flags & ZVOL_RDONLY)) {
	err = SET_ERROR(EROFS);
	goto out_opened;
	}
	if (zv->zv_flags & ZVOL_EXCL) {
	err = SET_ERROR(EBUSY);
	goto out_opened;
	}
	#ifdef FEXCL
	if (flags & FEXCL) {
	if (zv->zv_open_count != 0) {
	err = SET_ERROR(EBUSY);
	goto out_opened;
	}
	zv->zv_flags \|= ZVOL_EXCL;
	}
	#endif

	zv->zv_open_count++;
	if (flags & (FSYNC \| FDSYNC)) {
	zsd = &zv->zv_zso->zso_dev;
	zsd->zsd_sync_cnt++;
	if (zsd->zsd_sync_cnt == 1 &&
	(zv->zv_flags & ZVOL_WRITTEN_TO) != 0)
	zil_async_to_sync(zv->zv_zilog, ZVOL_OBJ);
	}
	out_opened:
	if (zv->zv_open_count == 0) {
	zvol_last_close(zv);
	wakeup(zv);
	}
	out_zv_locked:
	mutex_exit(&zv->zv_state_lock);
	out_locked:
	if (drop_namespace)
	mutex_exit(&spa_namespace_lock);
	if (drop_suspend)
	rw_exit(&zv->zv_suspend_lock);
	return (err);
	}

	static int
	zvol_cdev_close(struct cdev dev, int flags, int fmt, struct thread td)
	{
	zvol_state_t *zv;
	struct zvol_state_dev *zsd;
	boolean_t drop_suspend = B_TRUE;

	rw_enter(&zvol_state_lock, ZVOL_RW_READER);
	zv = dev->si_drv2;
	if (zv == NULL) {
	rw_exit(&zvol_state_lock);
	return (SET_ERROR(ENXIO));
	}

	mutex_enter(&zv->zv_state_lock);
	if (zv->zv_flags & ZVOL_EXCL) {
	ASSERT3U(zv->zv_open_count, ==, 1);
	zv->zv_flags &= ~ZVOL_EXCL;
	}

	ASSERT3S(zv->zv_volmode, ==, ZFS_VOLMODE_DEV);

	/*
	* If the open count is zero, this is a spurious close.
	* That indicates a bug in the kernel / DDI framework.
	*/
	ASSERT3U(zv->zv_open_count, >, 0);
	/*
	* make sure zvol is not suspended during last close
	* (hold zv_suspend_lock) and respect proper lock acquisition
	* ordering - zv_suspend_lock before zv_state_lock
	*/
	if (zv->zv_open_count == 1) {
	if (!rw_tryenter(&zv->zv_suspend_lock, ZVOL_RW_READER)) {
	mutex_exit(&zv->zv_state_lock);
	rw_enter(&zv->zv_suspend_lock, ZVOL_RW_READER);
	mutex_enter(&zv->zv_state_lock);
	/* check to see if zv_suspend_lock is needed */
	if (zv->zv_open_count != 1) {
	rw_exit(&zv->zv_suspend_lock);
	drop_suspend = B_FALSE;
	}
	}
	} else {
	drop_suspend = B_FALSE;
	}
	rw_exit(&zvol_state_lock);

	ASSERT(MUTEX_HELD(&zv->zv_state_lock));

	/*
	* You may get multiple opens, but only one close.
	*/
	zv->zv_open_count--;
	if (flags & (FSYNC \| FDSYNC)) {
	zsd = &zv->zv_zso->zso_dev;
	zsd->zsd_sync_cnt--;
	}

	if (zv->zv_open_count == 0) {
	ASSERT(ZVOL_RW_READ_HELD(&zv->zv_suspend_lock));
	zvol_last_close(zv);
	wakeup(zv);
	}

	mutex_exit(&zv->zv_state_lock);

	if (drop_suspend)
	rw_exit(&zv->zv_suspend_lock);
	return (0);
	}

	static int
	zvol_cdev_ioctl(struct cdev *dev, ulong_t cmd, caddr_t data,
	int fflag, struct thread *td)
	{
	zvol_state_t *zv;
	zfs_locked_range_t *lr;
	off_t offset, length;
	int i, error;
	boolean_t sync;

	zv = dev->si_drv2;

	error = 0;
	KASSERT(zv->zv_open_count > 0,
	("Device with zero access count in %s", __func__));

	i = IOCPARM_LEN(cmd);
	switch (cmd) {
	case DIOCGSECTORSIZE:
	(uint32_t )data = DEV_BSIZE;
	break;
	case DIOCGMEDIASIZE:
	(off_t )data = zv->zv_volsize;
	break;
	case DIOCGFLUSH:
	rw_enter(&zv->zv_suspend_lock, ZVOL_RW_READER);
	if (zv->zv_zilog != NULL)
	zil_commit(zv->zv_zilog, ZVOL_OBJ);
	rw_exit(&zv->zv_suspend_lock);
	break;
	case DIOCGDELETE:
	if (!zvol_unmap_enabled)
	break;

	offset = ((off_t *)data)[0];
	length = ((off_t *)data)[1];
	if ((offset % DEV_BSIZE) != 0 \|\| (length % DEV_BSIZE) != 0 \|\|
	offset < 0 \|\| offset >= zv->zv_volsize \|\|
	length <= 0) {
	printf("%s: offset=%jd length=%jd\n", __func__, offset,
	length);
	error = SET_ERROR(EINVAL);
	break;
	}
	rw_enter(&zv->zv_suspend_lock, ZVOL_RW_READER);
	zvol_ensure_zilog(zv);
	lr = zfs_rangelock_enter(&zv->zv_rangelock, offset, length,
	RL_WRITER);
	dmu_tx_t *tx = dmu_tx_create(zv->zv_objset);
	error = dmu_tx_assign(tx, TXG_WAIT);
	if (error != 0) {
	sync = FALSE;
	dmu_tx_abort(tx);
	} else {
	sync = (zv->zv_objset->os_sync == ZFS_SYNC_ALWAYS);
	zvol_log_truncate(zv, tx, offset, length, sync);
	dmu_tx_commit(tx);
	error = dmu_free_long_range(zv->zv_objset, ZVOL_OBJ,
	offset, length);
	}
	zfs_rangelock_exit(lr);
	if (sync)
	zil_commit(zv->zv_zilog, ZVOL_OBJ);
	rw_exit(&zv->zv_suspend_lock);
	break;
	case DIOCGSTRIPESIZE:
	(off_t )data = zv->zv_volblocksize;
	break;
	case DIOCGSTRIPEOFFSET:
	(off_t )data = 0;
	break;
	case DIOCGATTR: {
	spa_t *spa = dmu_objset_spa(zv->zv_objset);
	struct diocgattr_arg arg = (struct diocgattr_arg )data;
	uint64_t refd, avail, usedobjs, availobjs;

	if (strcmp(arg->name, "GEOM::candelete") == 0)
	arg->value.i = 1;
	else if (strcmp(arg->name, "blocksavail") == 0) {
	dmu_objset_space(zv->zv_objset, &refd, &avail,
	&usedobjs, &availobjs);
	arg->value.off = avail / DEV_BSIZE;
	} else if (strcmp(arg->name, "blocksused") == 0) {
	dmu_objset_space(zv->zv_objset, &refd, &avail,
	&usedobjs, &availobjs);
	arg->value.off = refd / DEV_BSIZE;
	} else if (strcmp(arg->name, "poolblocksavail") == 0) {
	avail = metaslab_class_get_space(spa_normal_class(spa));
	avail -= metaslab_class_get_alloc(
	spa_normal_class(spa));
	arg->value.off = avail / DEV_BSIZE;
	} else if (strcmp(arg->name, "poolblocksused") == 0) {
	refd = metaslab_class_get_alloc(spa_normal_class(spa));
	arg->value.off = refd / DEV_BSIZE;
	} else
	error = SET_ERROR(ENOIOCTL);
	break;
	}
	case FIOSEEKHOLE:
	case FIOSEEKDATA: {
	off_t off = (off_t )data;
	uint64_t noff;
	boolean_t hole;

	hole = (cmd == FIOSEEKHOLE);
	noff = *off;
	error = dmu_offset_next(zv->zv_objset, ZVOL_OBJ, hole, &noff);
	*off = noff;
	break;
	}
	default:
	error = SET_ERROR(ENOIOCTL);
	}

	return (error);
	}

	/*
	* Misc. helpers
	*/

	static void
	zvol_ensure_zilog(zvol_state_t *zv)
	{
	ASSERT(ZVOL_RW_READ_HELD(&zv->zv_suspend_lock));

	/*
	* Open a ZIL if this is the first time we have written to this
	* zvol. We protect zv->zv_zilog with zv_suspend_lock rather
	* than zv_state_lock so that we don't need to acquire an
	* additional lock in this path.
	*/
	if (zv->zv_zilog == NULL) {
	if (!rw_tryupgrade(&zv->zv_suspend_lock)) {
	rw_exit(&zv->zv_suspend_lock);
	rw_enter(&zv->zv_suspend_lock, RW_WRITER);
	}
	if (zv->zv_zilog == NULL) {
	zv->zv_zilog = zil_open(zv->zv_objset,
	zvol_get_data);
	zv->zv_flags \|= ZVOL_WRITTEN_TO;
	/* replay / destroy done in zvol_create_minor_impl() */
	VERIFY0((zv->zv_zilog->zl_header->zh_flags &
	ZIL_REPLAY_NEEDED));
	}
	rw_downgrade(&zv->zv_suspend_lock);
	}
	}

	static boolean_t
	zvol_is_zvol_impl(const char *device)
	{
	return (device && strncmp(device, ZVOL_DIR, strlen(ZVOL_DIR)) == 0);
	}

	static void
	zvol_rename_minor(zvol_state_t zv, const char newname)
	{
	ASSERT(RW_LOCK_HELD(&zvol_state_lock));
	ASSERT(MUTEX_HELD(&zv->zv_state_lock));

	/* move to new hashtable entry */
	zv->zv_hash = zvol_name_hash(zv->zv_name);
	hlist_del(&zv->zv_hlink);
	hlist_add_head(&zv->zv_hlink, ZVOL_HT_HEAD(zv->zv_hash));

	if (zv->zv_volmode == ZFS_VOLMODE_GEOM) {
	struct zvol_state_geom *zsg = &zv->zv_zso->zso_geom;
	struct g_provider *pp = zsg->zsg_provider;
	struct g_geom *gp;

	g_topology_lock();
	gp = pp->geom;
	ASSERT3P(gp, !=, NULL);

	zsg->zsg_provider = NULL;
	g_wither_provider(pp, ENXIO);

	pp = g_new_providerf(gp, "%s/%s", ZVOL_DRIVER, newname);
	pp->flags \|= G_PF_DIRECT_RECEIVE \| G_PF_DIRECT_SEND;
	pp->sectorsize = DEV_BSIZE;
	pp->mediasize = zv->zv_volsize;
	pp->private = zv;
	zsg->zsg_provider = pp;
	g_error_provider(pp, 0);
	g_topology_unlock();
	} else if (zv->zv_volmode == ZFS_VOLMODE_DEV) {
	struct zvol_state_dev *zsd = &zv->zv_zso->zso_dev;
	struct cdev *dev;
	struct make_dev_args args;

	dev = zsd->zsd_cdev;
	if (dev != NULL) {
	destroy_dev(dev);
	dev = zsd->zsd_cdev = NULL;
	if (zv->zv_open_count > 0) {
	zv->zv_flags &= ~ZVOL_EXCL;
	zv->zv_open_count = 0;
	/* XXX need suspend lock but lock order */
	zvol_last_close(zv);
	}
	}

	make_dev_args_init(&args);
	args.mda_flags = MAKEDEV_CHECKNAME \| MAKEDEV_WAITOK;
	args.mda_devsw = &zvol_cdevsw;
	args.mda_cr = NULL;
	args.mda_uid = UID_ROOT;
	args.mda_gid = GID_OPERATOR;
	args.mda_mode = 0640;
	args.mda_si_drv2 = zv;
	if (make_dev_s(&args, &dev, "%s/%s", ZVOL_DRIVER, newname)
	== 0) {
	dev->si_iosize_max = maxphys;
	zsd->zsd_cdev = dev;
	}
	}
	strlcpy(zv->zv_name, newname, sizeof (zv->zv_name));
	}

	/*
	* Remove minor node for the specified volume.
	*/
	static void
	zvol_free(zvol_state_t *zv)
	{
	ASSERT(!RW_LOCK_HELD(&zv->zv_suspend_lock));
	ASSERT(!MUTEX_HELD(&zv->zv_state_lock));
	ASSERT0(zv->zv_open_count);

	ZFS_LOG(1, "ZVOL %s destroyed.", zv->zv_name);

	rw_destroy(&zv->zv_suspend_lock);
	zfs_rangelock_fini(&zv->zv_rangelock);

	if (zv->zv_volmode == ZFS_VOLMODE_GEOM) {
	struct zvol_state_geom *zsg = &zv->zv_zso->zso_geom;
	struct g_provider *pp __maybe_unused = zsg->zsg_provider;

	ASSERT3P(pp->private, ==, NULL);

	g_topology_lock();
	zvol_geom_destroy(zv);
	g_topology_unlock();
	mtx_destroy(&zsg->zsg_queue_mtx);
	} else if (zv->zv_volmode == ZFS_VOLMODE_DEV) {
	struct zvol_state_dev *zsd = &zv->zv_zso->zso_dev;
	struct cdev *dev = zsd->zsd_cdev;

	ASSERT3P(dev->si_drv2, ==, NULL);

	destroy_dev(dev);
	}

	mutex_destroy(&zv->zv_state_lock);
	dataset_kstats_destroy(&zv->zv_kstat);
	kmem_free(zv->zv_zso, sizeof (struct zvol_state_os));
	kmem_free(zv, sizeof (zvol_state_t));
	zvol_minors--;
	}

	/*
	* Create a minor node (plus a whole lot more) for the specified volume.
	*/
	static int
	zvol_create_minor_impl(const char *name)
	{
	zvol_state_t *zv;
	objset_t *os;
	dmu_object_info_t *doi;
	uint64_t volsize;
	uint64_t volmode, hash;
	int error;

	ZFS_LOG(1, "Creating ZVOL %s...", name);
	hash = zvol_name_hash(name);
	if ((zv = zvol_find_by_name_hash(name, hash, RW_NONE)) != NULL) {
	ASSERT(MUTEX_HELD(&zv->zv_state_lock));
	mutex_exit(&zv->zv_state_lock);
	return (SET_ERROR(EEXIST));
	}

	DROP_GIANT();

	doi = kmem_alloc(sizeof (dmu_object_info_t), KM_SLEEP);

	/* lie and say we're read-only */
	error = dmu_objset_own(name, DMU_OST_ZVOL, B_TRUE, B_TRUE, FTAG, &os);
	if (error)
	goto out_doi;

	error = dmu_object_info(os, ZVOL_OBJ, doi);
	if (error)
	goto out_dmu_objset_disown;

	error = zap_lookup(os, ZVOL_ZAP_OBJ, "size", 8, 1, &volsize);
	if (error)
	goto out_dmu_objset_disown;

	error = dsl_prop_get_integer(name,
	zfs_prop_to_name(ZFS_PROP_VOLMODE), &volmode, NULL);
	if (error \|\| volmode == ZFS_VOLMODE_DEFAULT)
	volmode = zvol_volmode;
	error = 0;

	/*
	* zvol_alloc equivalent ...
	*/
	zv = kmem_zalloc(sizeof (*zv), KM_SLEEP);
	zv->zv_hash = hash;
	mutex_init(&zv->zv_state_lock, NULL, MUTEX_DEFAULT, NULL);
	zv->zv_zso = kmem_zalloc(sizeof (struct zvol_state_os), KM_SLEEP);
	zv->zv_volmode = volmode;
	if (zv->zv_volmode == ZFS_VOLMODE_GEOM) {
	struct zvol_state_geom *zsg = &zv->zv_zso->zso_geom;
	struct g_provider *pp;
	struct g_geom *gp;

	zsg->zsg_state = ZVOL_GEOM_UNINIT;
	mtx_init(&zsg->zsg_queue_mtx, "zvol", NULL, MTX_DEF);

	g_topology_lock();
	gp = g_new_geomf(&zfs_zvol_class, "zfs::zvol::%s", name);
	gp->start = zvol_geom_bio_start;
	gp->access = zvol_geom_access;
	pp = g_new_providerf(gp, "%s/%s", ZVOL_DRIVER, name);
	pp->flags \|= G_PF_DIRECT_RECEIVE \| G_PF_DIRECT_SEND;
	pp->sectorsize = DEV_BSIZE;
	pp->mediasize = 0;
	pp->private = zv;

	zsg->zsg_provider = pp;
	bioq_init(&zsg->zsg_queue);
	} else if (zv->zv_volmode == ZFS_VOLMODE_DEV) {
	struct zvol_state_dev *zsd = &zv->zv_zso->zso_dev;
	struct cdev *dev;
	struct make_dev_args args;

	make_dev_args_init(&args);
	args.mda_flags = MAKEDEV_CHECKNAME \| MAKEDEV_WAITOK;
	args.mda_devsw = &zvol_cdevsw;
	args.mda_cr = NULL;
	args.mda_uid = UID_ROOT;
	args.mda_gid = GID_OPERATOR;
	args.mda_mode = 0640;
	args.mda_si_drv2 = zv;
	error = make_dev_s(&args, &dev, "%s/%s", ZVOL_DRIVER, name);
	if (error) {
	kmem_free(zv->zv_zso, sizeof (struct zvol_state_os));
	mutex_destroy(&zv->zv_state_lock);
	kmem_free(zv, sizeof (*zv));
	dmu_objset_disown(os, B_TRUE, FTAG);
	goto out_doi;
	}
	dev->si_iosize_max = maxphys;
	zsd->zsd_cdev = dev;
	}
	(void) strlcpy(zv->zv_name, name, MAXPATHLEN);
	rw_init(&zv->zv_suspend_lock, NULL, RW_DEFAULT, NULL);
	zfs_rangelock_init(&zv->zv_rangelock, NULL, NULL);

	if (dmu_objset_is_snapshot(os) \|\| !spa_writeable(dmu_objset_spa(os)))
	zv->zv_flags \|= ZVOL_RDONLY;

	zv->zv_volblocksize = doi->doi_data_block_size;
	zv->zv_volsize = volsize;
	zv->zv_objset = os;

	ASSERT3P(zv->zv_zilog, ==, NULL);
	zv->zv_zilog = zil_open(os, zvol_get_data);
	if (spa_writeable(dmu_objset_spa(os))) {
	if (zil_replay_disable)
	zil_destroy(zv->zv_zilog, B_FALSE);
	else
	zil_replay(os, zv, zvol_replay_vector);
	}
	zil_close(zv->zv_zilog);
	zv->zv_zilog = NULL;
	ASSERT3P(zv->zv_kstat.dk_kstats, ==, NULL);
	dataset_kstats_create(&zv->zv_kstat, zv->zv_objset);

	/* TODO: prefetch for geom tasting */

	zv->zv_objset = NULL;
	out_dmu_objset_disown:
	dmu_objset_disown(os, B_TRUE, FTAG);

	if (error == 0 && volmode == ZFS_VOLMODE_GEOM) {
	zvol_geom_run(zv);
	g_topology_unlock();
	}
	out_doi:
	kmem_free(doi, sizeof (dmu_object_info_t));
	if (error == 0) {
	rw_enter(&zvol_state_lock, RW_WRITER);
	zvol_insert(zv);
	zvol_minors++;
	rw_exit(&zvol_state_lock);
	ZFS_LOG(1, "ZVOL %s created.", name);
	}
	PICKUP_GIANT();
	return (error);
	}

	static void
	zvol_clear_private(zvol_state_t *zv)
	{
	ASSERT(RW_LOCK_HELD(&zvol_state_lock));
	if (zv->zv_volmode == ZFS_VOLMODE_GEOM) {
	struct zvol_state_geom *zsg = &zv->zv_zso->zso_geom;
	struct g_provider *pp = zsg->zsg_provider;

	if (pp->private == NULL) /* already cleared */
	return;

	mtx_lock(&zsg->zsg_queue_mtx);
	zsg->zsg_state = ZVOL_GEOM_STOPPED;
	pp->private = NULL;
	wakeup_one(&zsg->zsg_queue);
	while (zsg->zsg_state != ZVOL_GEOM_RUNNING)
	msleep(&zsg->zsg_state, &zsg->zsg_queue_mtx,
	0, "zvol:w", 0);
	mtx_unlock(&zsg->zsg_queue_mtx);
	ASSERT(!RW_LOCK_HELD(&zv->zv_suspend_lock));
	} else if (zv->zv_volmode == ZFS_VOLMODE_DEV) {
	struct zvol_state_dev *zsd = &zv->zv_zso->zso_dev;
	struct cdev *dev = zsd->zsd_cdev;

	dev->si_drv2 = NULL;
	}
	}

	static int
	zvol_update_volsize(zvol_state_t *zv, uint64_t volsize)
	{
	zv->zv_volsize = volsize;
	if (zv->zv_volmode == ZFS_VOLMODE_GEOM) {
	struct zvol_state_geom *zsg = &zv->zv_zso->zso_geom;
	struct g_provider *pp = zsg->zsg_provider;

	g_topology_lock();

	if (pp->private == NULL) {
	g_topology_unlock();
	return (SET_ERROR(ENXIO));
	}

	/*
	* Do not invoke resize event when initial size was zero.
	* ZVOL initializes the size on first open, this is not
	* real resizing.
	*/
	if (pp->mediasize == 0)
	pp->mediasize = zv->zv_volsize;
	else
	g_resize_provider(pp, zv->zv_volsize);

	g_topology_unlock();
	}
	return (0);
	}

	static void
	zvol_set_disk_ro_impl(zvol_state_t *zv, int flags)
	{
	// XXX? set_disk_ro(zv->zv_zso->zvo_disk, flags);
	}

	static void
	zvol_set_capacity_impl(zvol_state_t *zv, uint64_t capacity)
	{
	// XXX? set_capacity(zv->zv_zso->zvo_disk, capacity);
	}

	const static zvol_platform_ops_t zvol_freebsd_ops = {
	.zv_free = zvol_free,
	.zv_rename_minor = zvol_rename_minor,
	.zv_create_minor = zvol_create_minor_impl,
	.zv_update_volsize = zvol_update_volsize,
	.zv_clear_private = zvol_clear_private,
	.zv_is_zvol = zvol_is_zvol_impl,
	.zv_set_disk_ro = zvol_set_disk_ro_impl,
	.zv_set_capacity = zvol_set_capacity_impl,
	};

	/*
	* Public interfaces
	*/

	int
	zvol_busy(void)
	{
	return (zvol_minors != 0);
	}

	int
	zvol_init(void)
	{
	zvol_init_impl();
	zvol_register_ops(&zvol_freebsd_ops);
	return (0);
	}

	void
	zvol_fini(void)
	{
	zvol_fini_impl();
	}
	diff --git a/sys/contrib/openzfs/module/os/linux/spl/spl-generic.c b/sys/contrib/openzfs/module/os/linux/spl/spl-generic.c
	index 36fdff72a133..91eeaccfdc47 100644
	--- a/sys/contrib/openzfs/module/os/linux/spl/spl-generic.c
	+++ b/sys/contrib/openzfs/module/os/linux/spl/spl-generic.c
	@@ -1,841 +1,843 @@
	/*
	* Copyright (C) 2007-2010 Lawrence Livermore National Security, LLC.
	* Copyright (C) 2007 The Regents of the University of California.
	* Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
	* Written by Brian Behlendorf <behlendorf1@llnl.gov>.
	* UCRL-CODE-235197
	*
	* This file is part of the SPL, Solaris Porting Layer.
	*
	* The SPL is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License as published by the
	* Free Software Foundation; either version 2 of the License, or (at your
	* option) any later version.
	*
	* The SPL is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* for more details.
	*
	* You should have received a copy of the GNU General Public License along
	* with the SPL. If not, see <http://www.gnu.org/licenses/>.
	*
	* Solaris Porting Layer (SPL) Generic Implementation.
	*/

	#include <sys/sysmacros.h>
	#include <sys/systeminfo.h>
	#include <sys/vmsystm.h>
	#include <sys/kmem.h>
	#include <sys/kmem_cache.h>
	#include <sys/vmem.h>
	#include <sys/mutex.h>
	#include <sys/rwlock.h>
	#include <sys/taskq.h>
	#include <sys/tsd.h>
	#include <sys/zmod.h>
	#include <sys/debug.h>
	#include <sys/proc.h>
	#include <sys/kstat.h>
	#include <sys/file.h>
	#include <sys/sunddi.h>
	#include <linux/ctype.h>
	#include <sys/disp.h>
	#include <sys/random.h>
	#include <sys/strings.h>
	#include <linux/kmod.h>
	#include "zfs_gitrev.h"
	#include <linux/mod_compat.h>
	#include <sys/cred.h>
	#include <sys/vnode.h>

	char spl_gitrev[64] = ZFS_META_GITREV;

	/* BEGIN CSTYLED */
	unsigned long spl_hostid = 0;
	EXPORT_SYMBOL(spl_hostid);
	/* BEGIN CSTYLED */
	module_param(spl_hostid, ulong, 0644);
	MODULE_PARM_DESC(spl_hostid, "The system hostid.");
	/* END CSTYLED */

	proc_t p0;
	EXPORT_SYMBOL(p0);

	/*
	* Xorshift Pseudo Random Number Generator based on work by Sebastiano Vigna
	*
	* "Further scramblings of Marsaglia's xorshift generators"
	* http://vigna.di.unimi.it/ftp/papers/xorshiftplus.pdf
	*
	* random_get_pseudo_bytes() is an API function on Illumos whose sole purpose
	* is to provide bytes containing random numbers. It is mapped to /dev/urandom
	* on Illumos, which uses a "FIPS 186-2 algorithm". No user of the SPL's
	* random_get_pseudo_bytes() needs bytes that are of cryptographic quality, so
	* we can implement it using a fast PRNG that we seed using Linux' actual
	* equivalent to random_get_pseudo_bytes(). We do this by providing each CPU
	* with an independent seed so that all calls to random_get_pseudo_bytes() are
	* free of atomic instructions.
	*
	* A consequence of using a fast PRNG is that using random_get_pseudo_bytes()
	* to generate words larger than 128 bits will paradoxically be limited to
	* `2^128 - 1` possibilities. This is because we have a sequence of `2^128 - 1`
	* 128-bit words and selecting the first will implicitly select the second. If
	* a caller finds this behavior undesirable, random_get_bytes() should be used
	* instead.
	*
	* XXX: Linux interrupt handlers that trigger within the critical section
	* formed by `s[1] = xp[1];` and `xp[0] = s[0];` and call this function will
	* see the same numbers. Nothing in the code currently calls this in an
	* interrupt handler, so this is considered to be okay. If that becomes a
	* problem, we could create a set of per-cpu variables for interrupt handlers
	* and use them when in_interrupt() from linux/preempt_mask.h evaluates to
	* true.
	*/
	void __percpu *spl_pseudo_entropy;

	/*
	* spl_rand_next()/spl_rand_jump() are copied from the following CC-0 licensed
	* file:
	*
	* http://xorshift.di.unimi.it/xorshift128plus.c
	*/

	static inline uint64_t
	spl_rand_next(uint64_t *s)
	{
	uint64_t s1 = s[0];
	const uint64_t s0 = s[1];
	s[0] = s0;
	s1 ^= s1 << 23; // a
	s[1] = s1 ^ s0 ^ (s1 >> 18) ^ (s0 >> 5); // b, c
	return (s[1] + s0);
	}

	static inline void
	spl_rand_jump(uint64_t *s)
	{
	static const uint64_t JUMP[] =
	{ 0x8a5cd789635d2dff, 0x121fd2155c472f96 };

	uint64_t s0 = 0;
	uint64_t s1 = 0;
	int i, b;
	for (i = 0; i < sizeof (JUMP) / sizeof (*JUMP); i++)
	for (b = 0; b < 64; b++) {
	if (JUMP[i] & 1ULL << b) {
	s0 ^= s[0];
	s1 ^= s[1];
	}
	(void) spl_rand_next(s);
	}

	s[0] = s0;
	s[1] = s1;
	}

	int
	random_get_pseudo_bytes(uint8_t *ptr, size_t len)
	{
	uint64_t *xp, s[2];

	ASSERT(ptr);

	xp = get_cpu_ptr(spl_pseudo_entropy);

	s[0] = xp[0];
	s[1] = xp[1];

	while (len) {
	union {
	uint64_t ui64;
	uint8_t byte[sizeof (uint64_t)];
	}entropy;
	int i = MIN(len, sizeof (uint64_t));

	len -= i;
	entropy.ui64 = spl_rand_next(s);

	while (i--)
	*ptr++ = entropy.byte[i];
	}

	xp[0] = s[0];
	xp[1] = s[1];

	put_cpu_ptr(spl_pseudo_entropy);

	return (0);
	}


	EXPORT_SYMBOL(random_get_pseudo_bytes);

	#if BITS_PER_LONG == 32

	/*
	* Support 64/64 => 64 division on a 32-bit platform. While the kernel
	* provides a div64_u64() function for this we do not use it because the
	* implementation is flawed. There are cases which return incorrect
	* results as late as linux-2.6.35. Until this is fixed upstream the
	* spl must provide its own implementation.
	*
	* This implementation is a slightly modified version of the algorithm
	* proposed by the book 'Hacker's Delight'. The original source can be
	* found here and is available for use without restriction.
	*
	* http://www.hackersdelight.org/HDcode/newCode/divDouble.c
	*/

	/*
	* Calculate number of leading of zeros for a 64-bit value.
	*/
	static int
	nlz64(uint64_t x)
	{
	register int n = 0;

	if (x == 0)
	return (64);

	if (x <= 0x00000000FFFFFFFFULL) { n = n + 32; x = x << 32; }
	if (x <= 0x0000FFFFFFFFFFFFULL) { n = n + 16; x = x << 16; }
	if (x <= 0x00FFFFFFFFFFFFFFULL) { n = n + 8; x = x << 8; }
	if (x <= 0x0FFFFFFFFFFFFFFFULL) { n = n + 4; x = x << 4; }
	if (x <= 0x3FFFFFFFFFFFFFFFULL) { n = n + 2; x = x << 2; }
	if (x <= 0x7FFFFFFFFFFFFFFFULL) { n = n + 1; }

	return (n);
	}

	/*
	* Newer kernels have a div_u64() function but we define our own
	* to simplify portability between kernel versions.
	*/
	static inline uint64_t
	__div_u64(uint64_t u, uint32_t v)
	{
	(void) do_div(u, v);
	return (u);
	}

	/*
	* Turn off missing prototypes warning for these functions. They are
	* replacements for libgcc-provided functions and will never be called
	* directly.
	*/
	#pragma GCC diagnostic push
	#pragma GCC diagnostic ignored "-Wmissing-prototypes"

	/*
	* Implementation of 64-bit unsigned division for 32-bit machines.
	*
	* First the procedure takes care of the case in which the divisor is a
	* 32-bit quantity. There are two subcases: (1) If the left half of the
	* dividend is less than the divisor, one execution of do_div() is all that
	* is required (overflow is not possible). (2) Otherwise it does two
	* divisions, using the grade school method.
	*/
	uint64_t
	__udivdi3(uint64_t u, uint64_t v)
	{
	uint64_t u0, u1, v1, q0, q1, k;
	int n;

	if (v >> 32 == 0) { // If v < 2**32:
	if (u >> 32 < v) { // If u/v cannot overflow,
	return (__div_u64(u, v)); // just do one division.
	} else { // If u/v would overflow:
	u1 = u >> 32; // Break u into two halves.
	u0 = u & 0xFFFFFFFF;
	q1 = __div_u64(u1, v); // First quotient digit.
	k = u1 - q1 * v; // First remainder, < v.
	u0 += (k << 32);
	q0 = __div_u64(u0, v); // Seconds quotient digit.
	return ((q1 << 32) + q0);
	}
	} else { // If v >= 2**32:
	n = nlz64(v); // 0 <= n <= 31.
	v1 = (v << n) >> 32; // Normalize divisor, MSB is 1.
	u1 = u >> 1; // To ensure no overflow.
	q1 = __div_u64(u1, v1); // Get quotient from
	q0 = (q1 << n) >> 31; // Undo normalization and
	// division of u by 2.
	if (q0 != 0) // Make q0 correct or
	q0 = q0 - 1; // too small by 1.
	if ((u - q0 * v) >= v)
	q0 = q0 + 1; // Now q0 is correct.

	return (q0);
	}
	}
	EXPORT_SYMBOL(__udivdi3);

	/* BEGIN CSTYLED */
	#ifndef abs64
	#define abs64(x) ({ uint64_t t = (x) >> 63; ((x) ^ t) - t; })
	#endif
	/* END CSTYLED */

	/*
	* Implementation of 64-bit signed division for 32-bit machines.
	*/
	int64_t
	__divdi3(int64_t u, int64_t v)
	{
	int64_t q, t;
	q = __udivdi3(abs64(u), abs64(v));
	t = (u ^ v) >> 63; // If u, v have different
	return ((q ^ t) - t); // signs, negate q.
	}
	EXPORT_SYMBOL(__divdi3);

	/*
	* Implementation of 64-bit unsigned modulo for 32-bit machines.
	*/
	uint64_t
	__umoddi3(uint64_t dividend, uint64_t divisor)
	{
	return (dividend - (divisor * __udivdi3(dividend, divisor)));
	}
	EXPORT_SYMBOL(__umoddi3);

	/* 64-bit signed modulo for 32-bit machines. */
	int64_t
	__moddi3(int64_t n, int64_t d)
	{
	int64_t q;
	boolean_t nn = B_FALSE;

	if (n < 0) {
	nn = B_TRUE;
	n = -n;
	}
	if (d < 0)
	d = -d;

	q = __umoddi3(n, d);

	return (nn ? -q : q);
	}
	EXPORT_SYMBOL(__moddi3);

	/*
	* Implementation of 64-bit unsigned division/modulo for 32-bit machines.
	*/
	uint64_t
	__udivmoddi4(uint64_t n, uint64_t d, uint64_t *r)
	{
	uint64_t q = __udivdi3(n, d);
	if (r)
	r = n - d q;
	return (q);
	}
	EXPORT_SYMBOL(__udivmoddi4);

	/*
	* Implementation of 64-bit signed division/modulo for 32-bit machines.
	*/
	int64_t
	__divmoddi4(int64_t n, int64_t d, int64_t *r)
	{
	int64_t q, rr;
	boolean_t nn = B_FALSE;
	boolean_t nd = B_FALSE;
	if (n < 0) {
	nn = B_TRUE;
	n = -n;
	}
	if (d < 0) {
	nd = B_TRUE;
	d = -d;
	}

	q = __udivmoddi4(n, d, (uint64_t *)&rr);

	if (nn != nd)
	q = -q;
	if (nn)
	rr = -rr;
	if (r)
	*r = rr;
	return (q);
	}
	EXPORT_SYMBOL(__divmoddi4);

	#if defined(__arm) \|\| defined(__arm__)
	/*
	* Implementation of 64-bit (un)signed division for 32-bit arm machines.
	*
	* Run-time ABI for the ARM Architecture (page 20). A pair of (unsigned)
	* long longs is returned in {{r0, r1}, {r2,r3}}, the quotient in {r0, r1},
	* and the remainder in {r2, r3}. The return type is specifically left
	* set to 'void' to ensure the compiler does not overwrite these registers
	* during the return. All results are in registers as per ABI
	*/
	void
	__aeabi_uldivmod(uint64_t u, uint64_t v)
	{
	uint64_t res;
	uint64_t mod;

	res = __udivdi3(u, v);
	mod = __umoddi3(u, v);
	{
	register uint32_t r0 asm("r0") = (res & 0xFFFFFFFF);
	register uint32_t r1 asm("r1") = (res >> 32);
	register uint32_t r2 asm("r2") = (mod & 0xFFFFFFFF);
	register uint32_t r3 asm("r3") = (mod >> 32);

	/* BEGIN CSTYLED */
	asm volatile(""
	: "+r"(r0), "+r"(r1), "+r"(r2),"+r"(r3) /* output */
	: "r"(r0), "r"(r1), "r"(r2), "r"(r3)); /* input */
	/* END CSTYLED */

	return; /* r0; */
	}
	}
	EXPORT_SYMBOL(__aeabi_uldivmod);

	void
	__aeabi_ldivmod(int64_t u, int64_t v)
	{
	int64_t res;
	uint64_t mod;

	res = __divdi3(u, v);
	mod = __umoddi3(u, v);
	{
	register uint32_t r0 asm("r0") = (res & 0xFFFFFFFF);
	register uint32_t r1 asm("r1") = (res >> 32);
	register uint32_t r2 asm("r2") = (mod & 0xFFFFFFFF);
	register uint32_t r3 asm("r3") = (mod >> 32);

	/* BEGIN CSTYLED */
	asm volatile(""
	: "+r"(r0), "+r"(r1), "+r"(r2),"+r"(r3) /* output */
	: "r"(r0), "r"(r1), "r"(r2), "r"(r3)); /* input */
	/* END CSTYLED */

	return; /* r0; */
	}
	}
	EXPORT_SYMBOL(__aeabi_ldivmod);
	#endif /* __arm \|\| __arm__ */

	#pragma GCC diagnostic pop

	#endif /* BITS_PER_LONG */

	/*
	* NOTE: The strtoxx behavior is solely based on my reading of the Solaris
	* ddi_strtol(9F) man page. I have not verified the behavior of these
	* functions against their Solaris counterparts. It is possible that I
	* may have misinterpreted the man page or the man page is incorrect.
	*/
	int ddi_strtoul(const char , char , int, unsigned long );
	int ddi_strtol(const char , char , int, long );
	int ddi_strtoull(const char , char , int, unsigned long long );
	int ddi_strtoll(const char , char , int, long long );

	#define define_ddi_strtoux(type, valtype) \
	int ddi_strtou##type(const char str, char *endptr, \
	int base, valtype *result) \
	{ \
	valtype last_value, value = 0; \
	char ptr = (char )str; \
	int flag = 1, digit; \
	\
	if (strlen(ptr) == 0) \
	return (EINVAL); \
	\
	/* Auto-detect base based on prefix */ \
	if (!base) { \
	if (str[0] == '0') { \
	if (tolower(str[1]) == 'x' && isxdigit(str[2])) { \
	base = 16; /* hex */ \
	ptr += 2; \
	} else if (str[1] >= '0' && str[1] < 8) { \
	base = 8; /* octal */ \
	ptr += 1; \
	} else { \
	return (EINVAL); \
	} \
	} else { \
	base = 10; /* decimal */ \
	} \
	} \
	\
	while (1) { \
	if (isdigit(*ptr)) \
	digit = *ptr - '0'; \
	else if (isalpha(*ptr)) \
	digit = tolower(*ptr) - 'a' + 10; \
	else \
	break; \
	\
	if (digit >= base) \
	break; \
	\
	last_value = value; \
	value = value * base + digit; \
	if (last_value > value) /* Overflow */ \
	return (ERANGE); \
	\
	flag = 1; \
	ptr++; \
	} \
	\
	if (flag) \
	*result = value; \
	\
	if (endptr) \
	endptr = (char )(flag ? ptr : str); \
	\
	return (0); \
	} \

	#define define_ddi_strtox(type, valtype) \
	int ddi_strto##type(const char str, char *endptr, \
	int base, valtype *result) \
	{ \
	int rc; \
	\
	if (*str == '-') { \
	rc = ddi_strtou##type(str + 1, endptr, base, result); \
	if (!rc) { \
	if (*endptr == str + 1) \
	endptr = (char )str; \
	else \
	result = -result; \
	} \
	} else { \
	rc = ddi_strtou##type(str, endptr, base, result); \
	} \
	\
	return (rc); \
	}

	define_ddi_strtoux(l, unsigned long)
	define_ddi_strtox(l, long)
	define_ddi_strtoux(ll, unsigned long long)
	define_ddi_strtox(ll, long long)

	EXPORT_SYMBOL(ddi_strtoul);
	EXPORT_SYMBOL(ddi_strtol);
	EXPORT_SYMBOL(ddi_strtoll);
	EXPORT_SYMBOL(ddi_strtoull);

	int
	ddi_copyin(const void from, void to, size_t len, int flags)
	{
	/* Fake ioctl() issued by kernel, 'from' is a kernel address */
	if (flags & FKIOCTL) {
	memcpy(to, from, len);
	return (0);
	}

	return (copyin(from, to, len));
	}
	EXPORT_SYMBOL(ddi_copyin);

	int
	ddi_copyout(const void from, void to, size_t len, int flags)
	{
	/* Fake ioctl() issued by kernel, 'from' is a kernel address */
	if (flags & FKIOCTL) {
	memcpy(to, from, len);
	return (0);
	}

	return (copyout(from, to, len));
	}
	EXPORT_SYMBOL(ddi_copyout);

	static ssize_t
	spl_kernel_read(struct file file, void buf, size_t count, loff_t *pos)
	{
	#if defined(HAVE_KERNEL_READ_PPOS)
	return (kernel_read(file, buf, count, pos));
	#else
	mm_segment_t saved_fs;
	ssize_t ret;

	saved_fs = get_fs();
	set_fs(KERNEL_DS);

	ret = vfs_read(file, (void __user *)buf, count, pos);

	set_fs(saved_fs);

	return (ret);
	#endif
	}

	static int
	spl_getattr(struct file filp, struct kstat stat)
	{
	int rc;

	ASSERT(filp);
	ASSERT(stat);

	#if defined(HAVE_4ARGS_VFS_GETATTR)
	rc = vfs_getattr(&filp->f_path, stat, STATX_BASIC_STATS,
	AT_STATX_SYNC_AS_STAT);
	#elif defined(HAVE_2ARGS_VFS_GETATTR)
	rc = vfs_getattr(&filp->f_path, stat);
	-#else
	+#elif defined(HAVE_3ARGS_VFS_GETATTR)
	rc = vfs_getattr(filp->f_path.mnt, filp->f_dentry, stat);
	+#else
	+#error "No available vfs_getattr()"
	#endif
	if (rc)
	return (-rc);

	return (0);
	}

	/*
	* Read the unique system identifier from the /etc/hostid file.
	*
	* The behavior of /usr/bin/hostid on Linux systems with the
	* regular eglibc and coreutils is:
	*
	* 1. Generate the value if the /etc/hostid file does not exist
	* or if the /etc/hostid file is less than four bytes in size.
	*
	* 2. If the /etc/hostid file is at least 4 bytes, then return
	* the first four bytes [0..3] in native endian order.
	*
	* 3. Always ignore bytes [4..] if they exist in the file.
	*
	* Only the first four bytes are significant, even on systems that
	* have a 64-bit word size.
	*
	* See:
	*
	* eglibc: sysdeps/unix/sysv/linux/gethostid.c
	* coreutils: src/hostid.c
	*
	* Notes:
	*
	* The /etc/hostid file on Solaris is a text file that often reads:
	*
	* # DO NOT EDIT
	* "0123456789"
	*
	* Directly copying this file to Linux results in a constant
	* hostid of 4f442023 because the default comment constitutes
	* the first four bytes of the file.
	*
	*/

	char *spl_hostid_path = HW_HOSTID_PATH;
	module_param(spl_hostid_path, charp, 0444);
	MODULE_PARM_DESC(spl_hostid_path, "The system hostid file (/etc/hostid)");

	static int
	hostid_read(uint32_t *hostid)
	{
	uint64_t size;
	uint32_t value = 0;
	int error;
	loff_t off;
	struct file *filp;
	struct kstat stat;

	filp = filp_open(spl_hostid_path, 0, 0);

	if (IS_ERR(filp))
	return (ENOENT);

	error = spl_getattr(filp, &stat);
	if (error) {
	filp_close(filp, 0);
	return (error);
	}
	size = stat.size;
	if (size < sizeof (HW_HOSTID_MASK)) {
	filp_close(filp, 0);
	return (EINVAL);
	}

	off = 0;
	/*
	* Read directly into the variable like eglibc does.
	* Short reads are okay; native behavior is preserved.
	*/
	error = spl_kernel_read(filp, &value, sizeof (value), &off);
	if (error < 0) {
	filp_close(filp, 0);
	return (EIO);
	}

	/* Mask down to 32 bits like coreutils does. */
	*hostid = (value & HW_HOSTID_MASK);
	filp_close(filp, 0);

	return (0);
	}

	/*
	* Return the system hostid. Preferentially use the spl_hostid module option
	* when set, otherwise use the value in the /etc/hostid file.
	*/
	uint32_t
	zone_get_hostid(void *zone)
	{
	uint32_t hostid;

	ASSERT3P(zone, ==, NULL);

	if (spl_hostid != 0)
	return ((uint32_t)(spl_hostid & HW_HOSTID_MASK));

	if (hostid_read(&hostid) == 0)
	return (hostid);

	return (0);
	}
	EXPORT_SYMBOL(zone_get_hostid);

	static int
	spl_kvmem_init(void)
	{
	int rc = 0;

	rc = spl_kmem_init();
	if (rc)
	return (rc);

	rc = spl_vmem_init();
	if (rc) {
	spl_kmem_fini();
	return (rc);
	}

	return (rc);
	}

	/*
	* We initialize the random number generator with 128 bits of entropy from the
	* system random number generator. In the improbable case that we have a zero
	* seed, we fallback to the system jiffies, unless it is also zero, in which
	* situation we use a preprogrammed seed. We step forward by 2^64 iterations to
	* initialize each of the per-cpu seeds so that the sequences generated on each
	* CPU are guaranteed to never overlap in practice.
	*/
	static void __init
	spl_random_init(void)
	{
	uint64_t s[2];
	int i = 0;

	spl_pseudo_entropy = __alloc_percpu(2 * sizeof (uint64_t),
	sizeof (uint64_t));

	get_random_bytes(s, sizeof (s));

	if (s[0] == 0 && s[1] == 0) {
	if (jiffies != 0) {
	s[0] = jiffies;
	s[1] = ~0 - jiffies;
	} else {
	(void) memcpy(s, "improbable seed", sizeof (s));
	}
	printk("SPL: get_random_bytes() returned 0 "
	"when generating random seed. Setting initial seed to "
	"0x%016llx%016llx.\n", cpu_to_be64(s[0]),
	cpu_to_be64(s[1]));
	}

	for_each_possible_cpu(i) {
	uint64_t *wordp = per_cpu_ptr(spl_pseudo_entropy, i);

	spl_rand_jump(s);

	wordp[0] = s[0];
	wordp[1] = s[1];
	}
	}

	static void
	spl_random_fini(void)
	{
	free_percpu(spl_pseudo_entropy);
	}

	static void
	spl_kvmem_fini(void)
	{
	spl_vmem_fini();
	spl_kmem_fini();
	}

	static int __init
	spl_init(void)
	{
	int rc = 0;

	bzero(&p0, sizeof (proc_t));
	spl_random_init();

	if ((rc = spl_kvmem_init()))
	goto out1;

	if ((rc = spl_tsd_init()))
	goto out2;

	if ((rc = spl_taskq_init()))
	goto out3;

	if ((rc = spl_kmem_cache_init()))
	goto out4;

	if ((rc = spl_proc_init()))
	goto out5;

	if ((rc = spl_kstat_init()))
	goto out6;

	if ((rc = spl_zlib_init()))
	goto out7;

	return (rc);

	out7:
	spl_kstat_fini();
	out6:
	spl_proc_fini();
	out5:
	spl_kmem_cache_fini();
	out4:
	spl_taskq_fini();
	out3:
	spl_tsd_fini();
	out2:
	spl_kvmem_fini();
	out1:
	return (rc);
	}

	static void __exit
	spl_fini(void)
	{
	spl_zlib_fini();
	spl_kstat_fini();
	spl_proc_fini();
	spl_kmem_cache_fini();
	spl_taskq_fini();
	spl_tsd_fini();
	spl_kvmem_fini();
	spl_random_fini();
	}

	module_init(spl_init);
	module_exit(spl_fini);

	ZFS_MODULE_DESCRIPTION("Solaris Porting Layer");
	ZFS_MODULE_AUTHOR(ZFS_META_AUTHOR);
	ZFS_MODULE_LICENSE("GPL");
	ZFS_MODULE_VERSION(ZFS_META_VERSION "-" ZFS_META_RELEASE);
	diff --git a/sys/contrib/openzfs/module/os/linux/spl/spl-proc.c b/sys/contrib/openzfs/module/os/linux/spl/spl-proc.c
	index 3e58598d43f8..c4af27a7fcd7 100644
	--- a/sys/contrib/openzfs/module/os/linux/spl/spl-proc.c
	+++ b/sys/contrib/openzfs/module/os/linux/spl/spl-proc.c
	@@ -1,790 +1,731 @@
	/*
	* Copyright (C) 2007-2010 Lawrence Livermore National Security, LLC.
	* Copyright (C) 2007 The Regents of the University of California.
	* Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
	* Written by Brian Behlendorf <behlendorf1@llnl.gov>.
	* UCRL-CODE-235197
	*
	* This file is part of the SPL, Solaris Porting Layer.
	*
	* The SPL is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License as published by the
	* Free Software Foundation; either version 2 of the License, or (at your
	* option) any later version.
	*
	* The SPL is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* for more details.
	*
	* You should have received a copy of the GNU General Public License along
	* with the SPL. If not, see <http://www.gnu.org/licenses/>.
	*
	* Solaris Porting Layer (SPL) Proc Implementation.
	*/

	#include <sys/systeminfo.h>
	#include <sys/kstat.h>
	#include <sys/kmem.h>
	#include <sys/kmem_cache.h>
	#include <sys/vmem.h>
	#include <sys/taskq.h>
	#include <sys/proc.h>
	#include <linux/ctype.h>
	#include <linux/kmod.h>
	#include <linux/seq_file.h>
	#include <linux/uaccess.h>
	#include <linux/version.h>

	#if defined(CONSTIFY_PLUGIN) && LINUX_VERSION_CODE >= KERNEL_VERSION(3, 8, 0)
	typedef struct ctl_table __no_const spl_ctl_table;
	#else
	typedef struct ctl_table spl_ctl_table;
	#endif

	static unsigned long table_min = 0;
	static unsigned long table_max = ~0;

	static struct ctl_table_header *spl_header = NULL;
	static struct proc_dir_entry *proc_spl = NULL;
	static struct proc_dir_entry *proc_spl_kmem = NULL;
	static struct proc_dir_entry *proc_spl_kmem_slab = NULL;
	static struct proc_dir_entry *proc_spl_taskq_all = NULL;
	static struct proc_dir_entry *proc_spl_taskq = NULL;
	struct proc_dir_entry *proc_spl_kstat = NULL;

	-static int
	-proc_copyin_string(char kbuffer, int kbuffer_size, const char ubuffer,
	- int ubuffer_size)
	-{
	- int size;
	-
	- if (ubuffer_size > kbuffer_size)
	- return (-EOVERFLOW);
	-
	- if (copy_from_user((void )kbuffer, (void )ubuffer, ubuffer_size))
	- return (-EFAULT);
	-
	- /* strip trailing whitespace */
	- size = strnlen(kbuffer, ubuffer_size);
	- while (size-- >= 0)
	- if (!isspace(kbuffer[size]))
	- break;
	-
	- /* empty string */
	- if (size < 0)
	- return (-EINVAL);
	-
	- /* no space to terminate */
	- if (size == kbuffer_size)
	- return (-EOVERFLOW);
	-
	- kbuffer[size + 1] = 0;
	- return (0);
	-}
	-
	-static int
	-proc_copyout_string(char ubuffer, int ubuffer_size, const char kbuffer,
	- char *append)
	-{
	- /*
	- * NB if 'append' != NULL, it's a single character to append to the
	- * copied out string - usually "\n", for /proc entries and
	- * (i.e. a terminating zero byte) for sysctl entries
	- */
	- int size = MIN(strlen(kbuffer), ubuffer_size);
	-
	- if (copy_to_user(ubuffer, kbuffer, size))
	- return (-EFAULT);
	-
	- if (append != NULL && size < ubuffer_size) {
	- if (copy_to_user(ubuffer + size, append, 1))
	- return (-EFAULT);
	-
	- size++;
	- }
	-
	- return (size);
	-}
	-
	#ifdef DEBUG_KMEM
	static int
	proc_domemused(struct ctl_table *table, int write,
	void __user buffer, size_t lenp, loff_t *ppos)
	{
	int rc = 0;
	- unsigned long min = 0, max = ~0, val;
	+ unsigned long val;
	spl_ctl_table dummy = *table;

	dummy.data = &val;
	dummy.proc_handler = &proc_dointvec;
	- dummy.extra1 = &min;
	- dummy.extra2 = &max;
	+ dummy.extra1 = &table_min;
	+ dummy.extra2 = &table_max;

	if (write) {
	ppos += lenp;
	} else {
	#ifdef HAVE_ATOMIC64_T
	val = atomic64_read((atomic64_t *)table->data);
	#else
	val = atomic_read((atomic_t *)table->data);
	#endif /* HAVE_ATOMIC64_T */
	rc = proc_doulongvec_minmax(&dummy, write, buffer, lenp, ppos);
	}

	return (rc);
	}
	#endif /* DEBUG_KMEM */

	static int
	proc_doslab(struct ctl_table *table, int write,
	void __user buffer, size_t lenp, loff_t *ppos)
	{
	int rc = 0;
	- unsigned long min = 0, max = ~0, val = 0, mask;
	+ unsigned long val = 0, mask;
	spl_ctl_table dummy = *table;
	spl_kmem_cache_t *skc = NULL;

	dummy.data = &val;
	dummy.proc_handler = &proc_dointvec;
	- dummy.extra1 = &min;
	- dummy.extra2 = &max;
	+ dummy.extra1 = &table_min;
	+ dummy.extra2 = &table_max;

	if (write) {
	ppos += lenp;
	} else {
	down_read(&spl_kmem_cache_sem);
	mask = (unsigned long)table->data;

	list_for_each_entry(skc, &spl_kmem_cache_list, skc_list) {

	/* Only use slabs of the correct kmem/vmem type */
	if (!(skc->skc_flags & mask))
	continue;

	/* Sum the specified field for selected slabs */
	switch (mask & (KMC_TOTAL \| KMC_ALLOC \| KMC_MAX)) {
	case KMC_TOTAL:
	val += skc->skc_slab_size * skc->skc_slab_total;
	break;
	case KMC_ALLOC:
	val += skc->skc_obj_size * skc->skc_obj_alloc;
	break;
	case KMC_MAX:
	val += skc->skc_obj_size * skc->skc_obj_max;
	break;
	}
	}

	up_read(&spl_kmem_cache_sem);
	rc = proc_doulongvec_minmax(&dummy, write, buffer, lenp, ppos);
	}

	return (rc);
	}

	static int
	proc_dohostid(struct ctl_table *table, int write,
	void __user buffer, size_t lenp, loff_t *ppos)
	{
	- int len, rc = 0;
	char *end, str[32];
	+ unsigned long hid;
	+ spl_ctl_table dummy = *table;
	+
	+ dummy.data = str;
	+ dummy.maxlen = sizeof (str) - 1;
	+
	+ if (!write)
	+ snprintf(str, sizeof (str), "%lx",
	+ (unsigned long) zone_get_hostid(NULL));
	+
	+ /* always returns 0 */
	+ proc_dostring(&dummy, write, buffer, lenp, ppos);

	if (write) {
	/*
	* We can't use proc_doulongvec_minmax() in the write
	- * case here because hostid while a hex value has no
	- * leading 0x which confuses the helper function.
	+ * case here because hostid, while a hex value, has no
	+ * leading 0x, which confuses the helper function.
	*/
	- rc = proc_copyin_string(str, sizeof (str), buffer, *lenp);
	- if (rc < 0)
	- return (rc);

	- spl_hostid = simple_strtoul(str, &end, 16);
	+ hid = simple_strtoul(str, &end, 16);
	if (str == end)
	return (-EINVAL);
	-
	- } else {
	- len = snprintf(str, sizeof (str), "%lx",
	- (unsigned long) zone_get_hostid(NULL));
	- if (*ppos >= len)
	- rc = 0;
	- else
	- rc = proc_copyout_string(buffer,
	- lenp, str + ppos, "\n");
	-
	- if (rc >= 0) {
	- *lenp = rc;
	- *ppos += rc;
	- }
	+ spl_hostid = hid;
	}

	- return (rc);
	+ return (0);
	}

	static void
	taskq_seq_show_headers(struct seq_file *f)
	{
	seq_printf(f, "%-25s %5s %5s %5s %5s %5s %5s %12s %5s %10s\n",
	"taskq", "act", "nthr", "spwn", "maxt", "pri",
	"mina", "maxa", "cura", "flags");
	}

	/* indices into the lheads array below */
	#define LHEAD_PEND 0
	#define LHEAD_PRIO 1
	#define LHEAD_DELAY 2
	#define LHEAD_WAIT 3
	#define LHEAD_ACTIVE 4
	#define LHEAD_SIZE 5

	/* BEGIN CSTYLED */
	static unsigned int spl_max_show_tasks = 512;
	module_param(spl_max_show_tasks, uint, 0644);
	MODULE_PARM_DESC(spl_max_show_tasks, "Max number of tasks shown in taskq proc");
	/* END CSTYLED */

	static int
	taskq_seq_show_impl(struct seq_file f, void p, boolean_t allflag)
	{
	taskq_t *tq = p;
	taskq_thread_t *tqt = NULL;
	spl_wait_queue_entry_t *wq;
	struct task_struct *tsk;
	taskq_ent_t *tqe;
	char name[100];
	struct list_head lheads[LHEAD_SIZE], lh;
	static char *list_names[LHEAD_SIZE] =
	{"pend", "prio", "delay", "wait", "active" };
	int i, j, have_lheads = 0;
	unsigned long wflags, flags;

	spin_lock_irqsave_nested(&tq->tq_lock, flags, tq->tq_lock_class);
	spin_lock_irqsave(&tq->tq_wait_waitq.lock, wflags);

	/* get the various lists and check whether they're empty */
	lheads[LHEAD_PEND] = &tq->tq_pend_list;
	lheads[LHEAD_PRIO] = &tq->tq_prio_list;
	lheads[LHEAD_DELAY] = &tq->tq_delay_list;
	#ifdef HAVE_WAIT_QUEUE_HEAD_ENTRY
	lheads[LHEAD_WAIT] = &tq->tq_wait_waitq.head;
	#else
	lheads[LHEAD_WAIT] = &tq->tq_wait_waitq.task_list;
	#endif
	lheads[LHEAD_ACTIVE] = &tq->tq_active_list;

	for (i = 0; i < LHEAD_SIZE; ++i) {
	if (list_empty(lheads[i]))
	lheads[i] = NULL;
	else
	++have_lheads;
	}

	/* early return in non-"all" mode if lists are all empty */
	if (!allflag && !have_lheads) {
	spin_unlock_irqrestore(&tq->tq_wait_waitq.lock, wflags);
	spin_unlock_irqrestore(&tq->tq_lock, flags);
	return (0);
	}

	/* unlock the waitq quickly */
	if (!lheads[LHEAD_WAIT])
	spin_unlock_irqrestore(&tq->tq_wait_waitq.lock, wflags);

	/* show the base taskq contents */
	snprintf(name, sizeof (name), "%s/%d", tq->tq_name, tq->tq_instance);
	seq_printf(f, "%-25s ", name);
	seq_printf(f, "%5d %5d %5d %5d %5d %5d %12d %5d %10x\n",
	tq->tq_nactive, tq->tq_nthreads, tq->tq_nspawn,
	tq->tq_maxthreads, tq->tq_pri, tq->tq_minalloc, tq->tq_maxalloc,
	tq->tq_nalloc, tq->tq_flags);

	/* show the active list */
	if (lheads[LHEAD_ACTIVE]) {
	j = 0;
	list_for_each_entry(tqt, &tq->tq_active_list, tqt_active_list) {
	if (j == 0)
	seq_printf(f, "\t%s:",
	list_names[LHEAD_ACTIVE]);
	else if (j == 2) {
	seq_printf(f, "\n\t ");
	j = 0;
	}
	seq_printf(f, " [%d]%pf(%ps)",
	tqt->tqt_thread->pid,
	tqt->tqt_task->tqent_func,
	tqt->tqt_task->tqent_arg);
	++j;
	}
	seq_printf(f, "\n");
	}

	for (i = LHEAD_PEND; i <= LHEAD_WAIT; ++i)
	if (lheads[i]) {
	j = 0;
	list_for_each(lh, lheads[i]) {
	if (spl_max_show_tasks != 0 &&
	j >= spl_max_show_tasks) {
	seq_printf(f, "\n\t(truncated)");
	break;
	}
	/* show the wait waitq list */
	if (i == LHEAD_WAIT) {
	#ifdef HAVE_WAIT_QUEUE_HEAD_ENTRY
	wq = list_entry(lh,
	spl_wait_queue_entry_t, entry);
	#else
	wq = list_entry(lh,
	spl_wait_queue_entry_t, task_list);
	#endif
	if (j == 0)
	seq_printf(f, "\t%s:",
	list_names[i]);
	else if (j % 8 == 0)
	seq_printf(f, "\n\t ");

	tsk = wq->private;
	seq_printf(f, " %d", tsk->pid);
	/* pend, prio and delay lists */
	} else {
	tqe = list_entry(lh, taskq_ent_t,
	tqent_list);
	if (j == 0)
	seq_printf(f, "\t%s:",
	list_names[i]);
	else if (j % 2 == 0)
	seq_printf(f, "\n\t ");

	seq_printf(f, " %pf(%ps)",
	tqe->tqent_func,
	tqe->tqent_arg);
	}
	++j;
	}
	seq_printf(f, "\n");
	}
	if (lheads[LHEAD_WAIT])
	spin_unlock_irqrestore(&tq->tq_wait_waitq.lock, wflags);
	spin_unlock_irqrestore(&tq->tq_lock, flags);

	return (0);
	}

	static int
	taskq_all_seq_show(struct seq_file f, void p)
	{
	return (taskq_seq_show_impl(f, p, B_TRUE));
	}

	static int
	taskq_seq_show(struct seq_file f, void p)
	{
	return (taskq_seq_show_impl(f, p, B_FALSE));
	}

	static void *
	taskq_seq_start(struct seq_file f, loff_t pos)
	{
	struct list_head *p;
	loff_t n = *pos;

	down_read(&tq_list_sem);
	if (!n)
	taskq_seq_show_headers(f);

	p = tq_list.next;
	while (n--) {
	p = p->next;
	if (p == &tq_list)
	return (NULL);
	}

	return (list_entry(p, taskq_t, tq_taskqs));
	}

	static void *
	taskq_seq_next(struct seq_file f, void p, loff_t *pos)
	{
	taskq_t *tq = p;

	++*pos;
	return ((tq->tq_taskqs.next == &tq_list) ?
	NULL : list_entry(tq->tq_taskqs.next, taskq_t, tq_taskqs));
	}

	static void
	slab_seq_show_headers(struct seq_file *f)
	{
	seq_printf(f,
	"--------------------- cache ----------"
	"--------------------------------------------- "
	"----- slab ------ "
	"---- object ----- "
	"--- emergency ---\n");
	seq_printf(f,
	"name "
	" flags size alloc slabsize objsize "
	"total alloc max "
	"total alloc max "
	"dlock alloc max\n");
	}

	static int
	slab_seq_show(struct seq_file f, void p)
	{
	spl_kmem_cache_t *skc = p;

	ASSERT(skc->skc_magic == SKC_MAGIC);

	if (skc->skc_flags & KMC_SLAB) {
	/*
	* This cache is backed by a generic Linux kmem cache which
	* has its own accounting. For these caches we only track
	* the number of active allocated objects that exist within
	* the underlying Linux slabs. For the overall statistics of
	* the underlying Linux cache please refer to /proc/slabinfo.
	*/
	spin_lock(&skc->skc_lock);
	uint64_t objs_allocated =
	percpu_counter_sum(&skc->skc_linux_alloc);
	seq_printf(f, "%-36s ", skc->skc_name);
	seq_printf(f, "0x%05lx %9s %9lu %8s %8u "
	"%5s %5s %5s %5s %5lu %5s %5s %5s %5s\n",
	(long unsigned)skc->skc_flags,
	"-",
	(long unsigned)(skc->skc_obj_size * objs_allocated),
	"-",
	(unsigned)skc->skc_obj_size,
	"-", "-", "-", "-",
	(long unsigned)objs_allocated,
	"-", "-", "-", "-");
	spin_unlock(&skc->skc_lock);
	return (0);
	}

	spin_lock(&skc->skc_lock);
	seq_printf(f, "%-36s ", skc->skc_name);
	seq_printf(f, "0x%05lx %9lu %9lu %8u %8u "
	"%5lu %5lu %5lu %5lu %5lu %5lu %5lu %5lu %5lu\n",
	(long unsigned)skc->skc_flags,
	(long unsigned)(skc->skc_slab_size * skc->skc_slab_total),
	(long unsigned)(skc->skc_obj_size * skc->skc_obj_alloc),
	(unsigned)skc->skc_slab_size,
	(unsigned)skc->skc_obj_size,
	(long unsigned)skc->skc_slab_total,
	(long unsigned)skc->skc_slab_alloc,
	(long unsigned)skc->skc_slab_max,
	(long unsigned)skc->skc_obj_total,
	(long unsigned)skc->skc_obj_alloc,
	(long unsigned)skc->skc_obj_max,
	(long unsigned)skc->skc_obj_deadlock,
	(long unsigned)skc->skc_obj_emergency,
	(long unsigned)skc->skc_obj_emergency_max);
	spin_unlock(&skc->skc_lock);
	return (0);
	}

	static void *
	slab_seq_start(struct seq_file f, loff_t pos)
	{
	struct list_head *p;
	loff_t n = *pos;

	down_read(&spl_kmem_cache_sem);
	if (!n)
	slab_seq_show_headers(f);

	p = spl_kmem_cache_list.next;
	while (n--) {
	p = p->next;
	if (p == &spl_kmem_cache_list)
	return (NULL);
	}

	return (list_entry(p, spl_kmem_cache_t, skc_list));
	}

	static void *
	slab_seq_next(struct seq_file f, void p, loff_t *pos)
	{
	spl_kmem_cache_t *skc = p;

	++*pos;
	return ((skc->skc_list.next == &spl_kmem_cache_list) ?
	NULL : list_entry(skc->skc_list.next, spl_kmem_cache_t, skc_list));
	}

	static void
	slab_seq_stop(struct seq_file f, void v)
	{
	up_read(&spl_kmem_cache_sem);
	}

	static struct seq_operations slab_seq_ops = {
	.show = slab_seq_show,
	.start = slab_seq_start,
	.next = slab_seq_next,
	.stop = slab_seq_stop,
	};

	static int
	proc_slab_open(struct inode inode, struct file filp)
	{
	return (seq_open(filp, &slab_seq_ops));
	}

	static const kstat_proc_op_t proc_slab_operations = {
	#ifdef HAVE_PROC_OPS_STRUCT
	.proc_open = proc_slab_open,
	.proc_read = seq_read,
	.proc_lseek = seq_lseek,
	.proc_release = seq_release,
	#else
	.open = proc_slab_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = seq_release,
	#endif
	};

	static void
	taskq_seq_stop(struct seq_file f, void v)
	{
	up_read(&tq_list_sem);
	}

	static struct seq_operations taskq_all_seq_ops = {
	.show = taskq_all_seq_show,
	.start = taskq_seq_start,
	.next = taskq_seq_next,
	.stop = taskq_seq_stop,
	};

	static struct seq_operations taskq_seq_ops = {
	.show = taskq_seq_show,
	.start = taskq_seq_start,
	.next = taskq_seq_next,
	.stop = taskq_seq_stop,
	};

	static int
	proc_taskq_all_open(struct inode inode, struct file filp)
	{
	return (seq_open(filp, &taskq_all_seq_ops));
	}

	static int
	proc_taskq_open(struct inode inode, struct file filp)
	{
	return (seq_open(filp, &taskq_seq_ops));
	}

	static const kstat_proc_op_t proc_taskq_all_operations = {
	#ifdef HAVE_PROC_OPS_STRUCT
	.proc_open = proc_taskq_all_open,
	.proc_read = seq_read,
	.proc_lseek = seq_lseek,
	.proc_release = seq_release,
	#else
	.open = proc_taskq_all_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = seq_release,
	#endif
	};

	static const kstat_proc_op_t proc_taskq_operations = {
	#ifdef HAVE_PROC_OPS_STRUCT
	.proc_open = proc_taskq_open,
	.proc_read = seq_read,
	.proc_lseek = seq_lseek,
	.proc_release = seq_release,
	#else
	.open = proc_taskq_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = seq_release,
	#endif
	};

	static struct ctl_table spl_kmem_table[] = {
	#ifdef DEBUG_KMEM
	{
	.procname = "kmem_used",
	.data = &kmem_alloc_used,
	#ifdef HAVE_ATOMIC64_T
	.maxlen = sizeof (atomic64_t),
	#else
	.maxlen = sizeof (atomic_t),
	#endif /* HAVE_ATOMIC64_T */
	.mode = 0444,
	.proc_handler = &proc_domemused,
	},
	{
	.procname = "kmem_max",
	.data = &kmem_alloc_max,
	.maxlen = sizeof (unsigned long),
	.extra1 = &table_min,
	.extra2 = &table_max,
	.mode = 0444,
	.proc_handler = &proc_doulongvec_minmax,
	},
	#endif /* DEBUG_KMEM */
	{
	.procname = "slab_kvmem_total",
	.data = (void *)(KMC_KVMEM \| KMC_TOTAL),
	.maxlen = sizeof (unsigned long),
	.extra1 = &table_min,
	.extra2 = &table_max,
	.mode = 0444,
	.proc_handler = &proc_doslab,
	},
	{
	.procname = "slab_kvmem_alloc",
	.data = (void *)(KMC_KVMEM \| KMC_ALLOC),
	.maxlen = sizeof (unsigned long),
	.extra1 = &table_min,
	.extra2 = &table_max,
	.mode = 0444,
	.proc_handler = &proc_doslab,
	},
	{
	.procname = "slab_kvmem_max",
	.data = (void *)(KMC_KVMEM \| KMC_MAX),
	.maxlen = sizeof (unsigned long),
	.extra1 = &table_min,
	.extra2 = &table_max,
	.mode = 0444,
	.proc_handler = &proc_doslab,
	},
	{},
	};

	static struct ctl_table spl_kstat_table[] = {
	{},
	};

	static struct ctl_table spl_table[] = {
	/*
	* NB No .strategy entries have been provided since
	* sysctl(8) prefers to go via /proc for portability.
	*/
	{
	.procname = "gitrev",
	.data = spl_gitrev,
	.maxlen = sizeof (spl_gitrev),
	.mode = 0444,
	.proc_handler = &proc_dostring,
	},
	{
	.procname = "hostid",
	.data = &spl_hostid,
	.maxlen = sizeof (unsigned long),
	.mode = 0644,
	.proc_handler = &proc_dohostid,
	},
	{
	.procname = "kmem",
	.mode = 0555,
	.child = spl_kmem_table,
	},
	{
	.procname = "kstat",
	.mode = 0555,
	.child = spl_kstat_table,
	},
	{},
	};

	static struct ctl_table spl_dir[] = {
	{
	.procname = "spl",
	.mode = 0555,
	.child = spl_table,
	},
	{}
	};

	static struct ctl_table spl_root[] = {
	{
	.procname = "kernel",
	.mode = 0555,
	.child = spl_dir,
	},
	{}
	};

	int
	spl_proc_init(void)
	{
	int rc = 0;

	spl_header = register_sysctl_table(spl_root);
	if (spl_header == NULL)
	return (-EUNATCH);

	proc_spl = proc_mkdir("spl", NULL);
	if (proc_spl == NULL) {
	rc = -EUNATCH;
	goto out;
	}

	proc_spl_taskq_all = proc_create_data("taskq-all", 0444, proc_spl,
	&proc_taskq_all_operations, NULL);
	if (proc_spl_taskq_all == NULL) {
	rc = -EUNATCH;
	goto out;
	}

	proc_spl_taskq = proc_create_data("taskq", 0444, proc_spl,
	&proc_taskq_operations, NULL);
	if (proc_spl_taskq == NULL) {
	rc = -EUNATCH;
	goto out;
	}

	proc_spl_kmem = proc_mkdir("kmem", proc_spl);
	if (proc_spl_kmem == NULL) {
	rc = -EUNATCH;
	goto out;
	}

	proc_spl_kmem_slab = proc_create_data("slab", 0444, proc_spl_kmem,
	&proc_slab_operations, NULL);
	if (proc_spl_kmem_slab == NULL) {
	rc = -EUNATCH;
	goto out;
	}

	proc_spl_kstat = proc_mkdir("kstat", proc_spl);
	if (proc_spl_kstat == NULL) {
	rc = -EUNATCH;
	goto out;
	}
	out:
	if (rc) {
	remove_proc_entry("kstat", proc_spl);
	remove_proc_entry("slab", proc_spl_kmem);
	remove_proc_entry("kmem", proc_spl);
	remove_proc_entry("taskq-all", proc_spl);
	remove_proc_entry("taskq", proc_spl);
	remove_proc_entry("spl", NULL);
	unregister_sysctl_table(spl_header);
	}

	return (rc);
	}

	void
	spl_proc_fini(void)
	{
	remove_proc_entry("kstat", proc_spl);
	remove_proc_entry("slab", proc_spl_kmem);
	remove_proc_entry("kmem", proc_spl);
	remove_proc_entry("taskq-all", proc_spl);
	remove_proc_entry("taskq", proc_spl);
	remove_proc_entry("spl", NULL);

	ASSERT(spl_header != NULL);
	unregister_sysctl_table(spl_header);
	}
	diff --git a/sys/contrib/openzfs/module/os/linux/spl/spl-thread.c b/sys/contrib/openzfs/module/os/linux/spl/spl-thread.c
	index db23fb64a298..834c527117a3 100644
	--- a/sys/contrib/openzfs/module/os/linux/spl/spl-thread.c
	+++ b/sys/contrib/openzfs/module/os/linux/spl/spl-thread.c
	@@ -1,160 +1,211 @@
	/*
	* Copyright (C) 2007-2010 Lawrence Livermore National Security, LLC.
	* Copyright (C) 2007 The Regents of the University of California.
	* Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
	* Written by Brian Behlendorf <behlendorf1@llnl.gov>.
	* UCRL-CODE-235197
	*
	* This file is part of the SPL, Solaris Porting Layer.
	*
	* The SPL is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License as published by the
	* Free Software Foundation; either version 2 of the License, or (at your
	* option) any later version.
	*
	* The SPL is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* for more details.
	*
	* You should have received a copy of the GNU General Public License along
	* with the SPL. If not, see <http://www.gnu.org/licenses/>.
	*
	* Solaris Porting Layer (SPL) Thread Implementation.
	*/

	#include <sys/thread.h>
	#include <sys/kmem.h>
	#include <sys/tsd.h>

	/*
	* Thread interfaces
	*/
	typedef struct thread_priv_s {
	unsigned long tp_magic; /* Magic */
	int tp_name_size; /* Name size */
	char tp_name; / Name (without _thread suffix) */
	void (tp_func)(void ); /* Registered function */
	void tp_args; / Args to be passed to function */
	size_t tp_len; /* Len to be passed to function */
	int tp_state; /* State to start thread at */
	pri_t tp_pri; /* Priority to start threat at */
	} thread_priv_t;

	static int
	thread_generic_wrapper(void *arg)
	{
	thread_priv_t tp = (thread_priv_t )arg;
	void (func)(void );
	void *args;

	ASSERT(tp->tp_magic == TP_MAGIC);
	func = tp->tp_func;
	args = tp->tp_args;
	set_current_state(tp->tp_state);
	set_user_nice((kthread_t *)current, PRIO_TO_NICE(tp->tp_pri));
	kmem_free(tp->tp_name, tp->tp_name_size);
	kmem_free(tp, sizeof (thread_priv_t));

	if (func)
	func(args);

	return (0);
	}

	void
	__thread_exit(void)
	{
	tsd_exit();
	complete_and_exit(NULL, 0);
	/* Unreachable */
	}
	EXPORT_SYMBOL(__thread_exit);

	/*
	* thread_create() may block forever if it cannot create a thread or
	* allocate memory. This is preferable to returning a NULL which Solaris
	* style callers likely never check for... since it can't fail.
	*/
	kthread_t *
	__thread_create(caddr_t stk, size_t stksize, thread_func_t func,
	const char name, void args, size_t len, proc_t *pp, int state, pri_t pri)
	{
	thread_priv_t *tp;
	struct task_struct *tsk;
	char *p;

	/* Option pp is simply ignored */
	/* Variable stack size unsupported */
	ASSERT(stk == NULL);

	tp = kmem_alloc(sizeof (thread_priv_t), KM_PUSHPAGE);
	if (tp == NULL)
	return (NULL);

	tp->tp_magic = TP_MAGIC;
	tp->tp_name_size = strlen(name) + 1;

	tp->tp_name = kmem_alloc(tp->tp_name_size, KM_PUSHPAGE);
	if (tp->tp_name == NULL) {
	kmem_free(tp, sizeof (thread_priv_t));
	return (NULL);
	}

	strncpy(tp->tp_name, name, tp->tp_name_size);

	/*
	* Strip trailing "_thread" from passed name which will be the func
	* name since the exposed API has no parameter for passing a name.
	*/
	p = strstr(tp->tp_name, "_thread");
	if (p)
	p[0] = '\0';

	tp->tp_func = func;
	tp->tp_args = args;
	tp->tp_len = len;
	tp->tp_state = state;
	tp->tp_pri = pri;

	tsk = spl_kthread_create(thread_generic_wrapper, (void *)tp,
	"%s", tp->tp_name);
	if (IS_ERR(tsk))
	return (NULL);

	wake_up_process(tsk);
	return ((kthread_t *)tsk);
	}
	EXPORT_SYMBOL(__thread_create);

	/*
	* spl_kthread_create - Wrapper providing pre-3.13 semantics for
	* kthread_create() in which it is not killable and less likely
	* to return -ENOMEM.
	*/
	struct task_struct *
	spl_kthread_create(int (func)(void ), void *data, const char namefmt[], ...)
	{
	struct task_struct *tsk;
	va_list args;
	char name[TASK_COMM_LEN];

	va_start(args, namefmt);
	vsnprintf(name, sizeof (name), namefmt, args);
	va_end(args);
	do {
	tsk = kthread_create(func, data, "%s", name);
	if (IS_ERR(tsk)) {
	if (signal_pending(current)) {
	clear_thread_flag(TIF_SIGPENDING);
	continue;
	}
	if (PTR_ERR(tsk) == -ENOMEM)
	continue;
	return (NULL);
	} else {
	return (tsk);
	}
	} while (1);
	}
	EXPORT_SYMBOL(spl_kthread_create);
	+
	+/*
	+ * The "why" argument indicates the allowable side-effects of the call:
	+ *
	+ * FORREAL: Extract the next pending signal from p_sig into p_cursig;
	+ * stop the process if a stop has been requested or if a traced signal
	+ * is pending.
	+ *
	+ * JUSTLOOKING: Don't stop the process, just indicate whether or not
	+ * a signal might be pending (FORREAL is needed to tell for sure).
	+ */
	+int
	+issig(int why)
	+{
	+ ASSERT(why == FORREAL \|\| why == JUSTLOOKING);
	+
	+ if (!signal_pending(current))
	+ return (0);
	+
	+ if (why != FORREAL)
	+ return (1);
	+
	+ struct task_struct *task = current;
	+ spl_kernel_siginfo_t __info;
	+ sigset_t set;
	+ siginitsetinv(&set, 1ULL << (SIGSTOP - 1) \| 1ULL << (SIGTSTP - 1));
	+ sigorsets(&set, &task->blocked, &set);
	+
	+ spin_lock_irq(&task->sighand->siglock);
	+ int ret;
	+ if ((ret = dequeue_signal(task, &set, &__info)) != 0) {
	+#ifdef HAVE_SIGNAL_STOP
	+ spin_unlock_irq(&task->sighand->siglock);
	+ kernel_signal_stop();
	+#else
	+ if (current->jobctl & JOBCTL_STOP_DEQUEUED)
	+ spl_set_special_state(TASK_STOPPED);
	+
	+ spin_unlock_irq(&current->sighand->siglock);
	+
	+ schedule();
	+#endif
	+ return (0);
	+ }
	+
	+ spin_unlock_irq(&task->sighand->siglock);
	+
	+ return (1);
	+}
	+
	+EXPORT_SYMBOL(issig);
	diff --git a/sys/contrib/openzfs/module/os/linux/zfs/zfs_dir.c b/sys/contrib/openzfs/module/os/linux/zfs/zfs_dir.c
	index 207a51d75bc9..82b32d1cc3fa 100644
	--- a/sys/contrib/openzfs/module/os/linux/zfs/zfs_dir.c
	+++ b/sys/contrib/openzfs/module/os/linux/zfs/zfs_dir.c
	@@ -1,1225 +1,1225 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2013, 2016 by Delphix. All rights reserved.
	* Copyright 2017 Nexenta Systems, Inc.
	*/

	#include <sys/types.h>
	#include <sys/param.h>
	#include <sys/time.h>
	#include <sys/sysmacros.h>
	#include <sys/vfs.h>
	#include <sys/vnode.h>
	#include <sys/file.h>
	#include <sys/kmem.h>
	#include <sys/uio.h>
	#include <sys/pathname.h>
	#include <sys/cmn_err.h>
	#include <sys/errno.h>
	#include <sys/stat.h>
	#include <sys/sunddi.h>
	#include <sys/random.h>
	#include <sys/policy.h>
	#include <sys/zfs_dir.h>
	#include <sys/zfs_acl.h>
	#include <sys/zfs_vnops.h>
	#include <sys/fs/zfs.h>
	#include <sys/zap.h>
	#include <sys/dmu.h>
	#include <sys/atomic.h>
	#include <sys/zfs_ctldir.h>
	#include <sys/zfs_fuid.h>
	#include <sys/sa.h>
	#include <sys/zfs_sa.h>
	#include <sys/dmu_objset.h>
	#include <sys/dsl_dir.h>

	/*
	* zfs_match_find() is used by zfs_dirent_lock() to perform zap lookups
	* of names after deciding which is the appropriate lookup interface.
	*/
	static int
	zfs_match_find(zfsvfs_t zfsvfs, znode_t dzp, const char *name,
	matchtype_t mt, boolean_t update, int deflags, pathname_t rpnp,
	uint64_t *zoid)
	{
	boolean_t conflict = B_FALSE;
	int error;

	if (zfsvfs->z_norm) {
	size_t bufsz = 0;
	char *buf = NULL;

	if (rpnp) {
	buf = rpnp->pn_buf;
	bufsz = rpnp->pn_bufsize;
	}

	/*
	* In the non-mixed case we only expect there would ever
	* be one match, but we need to use the normalizing lookup.
	*/
	error = zap_lookup_norm(zfsvfs->z_os, dzp->z_id, name, 8, 1,
	zoid, mt, buf, bufsz, &conflict);
	} else {
	error = zap_lookup(zfsvfs->z_os, dzp->z_id, name, 8, 1, zoid);
	}

	/*
	* Allow multiple entries provided the first entry is
	* the object id. Non-zpl consumers may safely make
	* use of the additional space.
	*
	* XXX: This should be a feature flag for compatibility
	*/
	if (error == EOVERFLOW)
	error = 0;

	if (zfsvfs->z_norm && !error && deflags)
	*deflags = conflict ? ED_CASE_CONFLICT : 0;

	zoid = ZFS_DIRENT_OBJ(zoid);

	return (error);
	}

	/*
	* Lock a directory entry. A dirlock on <dzp, name> protects that name
	* in dzp's directory zap object. As long as you hold a dirlock, you can
	* assume two things: (1) dzp cannot be reaped, and (2) no other thread
	* can change the zap entry for (i.e. link or unlink) this name.
	*
	* Input arguments:
	* dzp - znode for directory
	* name - name of entry to lock
	* flag - ZNEW: if the entry already exists, fail with EEXIST.
	* ZEXISTS: if the entry does not exist, fail with ENOENT.
	* ZSHARED: allow concurrent access with other ZSHARED callers.
	* ZXATTR: we want dzp's xattr directory
	* ZCILOOK: On a mixed sensitivity file system,
	* this lookup should be case-insensitive.
	* ZCIEXACT: On a purely case-insensitive file system,
	* this lookup should be case-sensitive.
	* ZRENAMING: we are locking for renaming, force narrow locks
	* ZHAVELOCK: Don't grab the z_name_lock for this call. The
	* current thread already holds it.
	*
	* Output arguments:
	* zpp - pointer to the znode for the entry (NULL if there isn't one)
	* dlpp - pointer to the dirlock for this entry (NULL on error)
	* direntflags - (case-insensitive lookup only)
	* flags if multiple case-sensitive matches exist in directory
	* realpnp - (case-insensitive lookup only)
	* actual name matched within the directory
	*
	* Return value: 0 on success or errno on failure.
	*
	* NOTE: Always checks for, and rejects, '.' and '..'.
	* NOTE: For case-insensitive file systems we take wide locks (see below),
	* but return znode pointers to a single match.
	*/
	int
	zfs_dirent_lock(zfs_dirlock_t *dlpp, znode_t dzp, char *name,
	znode_t *zpp, int flag, int direntflags, pathname_t *realpnp)
	{
	zfsvfs_t *zfsvfs = ZTOZSB(dzp);
	zfs_dirlock_t *dl;
	boolean_t update;
	matchtype_t mt = 0;
	uint64_t zoid;
	int error = 0;
	int cmpflags;

	*zpp = NULL;
	*dlpp = NULL;

	/*
	* Verify that we are not trying to lock '.', '..', or '.zfs'
	*/
	if ((name[0] == '.' &&
	(name[1] == '\0' \|\| (name[1] == '.' && name[2] == '\0'))) \|\|
	(zfs_has_ctldir(dzp) && strcmp(name, ZFS_CTLDIR_NAME) == 0))
	return (SET_ERROR(EEXIST));

	/*
	* Case sensitivity and normalization preferences are set when
	* the file system is created. These are stored in the
	* zfsvfs->z_case and zfsvfs->z_norm fields. These choices
	* affect what vnodes can be cached in the DNLC, how we
	* perform zap lookups, and the "width" of our dirlocks.
	*
	* A normal dirlock locks a single name. Note that with
	* normalization a name can be composed multiple ways, but
	* when normalized, these names all compare equal. A wide
	* dirlock locks multiple names. We need these when the file
	* system is supporting mixed-mode access. It is sometimes
	* necessary to lock all case permutations of file name at
	* once so that simultaneous case-insensitive/case-sensitive
	* behaves as rationally as possible.
	*/

	/*
	* When matching we may need to normalize & change case according to
	* FS settings.
	*
	* Note that a normalized match is necessary for a case insensitive
	* filesystem when the lookup request is not exact because normalization
	* can fold case independent of normalizing code point sequences.
	*
	* See the table above zfs_dropname().
	*/
	if (zfsvfs->z_norm != 0) {
	mt = MT_NORMALIZE;

	/*
	* Determine if the match needs to honor the case specified in
	* lookup, and if so keep track of that so that during
	* normalization we don't fold case.
	*/
	if ((zfsvfs->z_case == ZFS_CASE_INSENSITIVE &&
	(flag & ZCIEXACT)) \|\|
	(zfsvfs->z_case == ZFS_CASE_MIXED && !(flag & ZCILOOK))) {
	mt \|= MT_MATCH_CASE;
	}
	}

	/*
	* Only look in or update the DNLC if we are looking for the
	* name on a file system that does not require normalization
	* or case folding. We can also look there if we happen to be
	* on a non-normalizing, mixed sensitivity file system IF we
	* are looking for the exact name.
	*
	* Maybe can add TO-UPPERed version of name to dnlc in ci-only
	* case for performance improvement?
	*/
	update = !zfsvfs->z_norm \|\|
	(zfsvfs->z_case == ZFS_CASE_MIXED &&
	!(zfsvfs->z_norm & ~U8_TEXTPREP_TOUPPER) && !(flag & ZCILOOK));

	/*
	* ZRENAMING indicates we are in a situation where we should
	* take narrow locks regardless of the file system's
	* preferences for normalizing and case folding. This will
	* prevent us deadlocking trying to grab the same wide lock
	* twice if the two names happen to be case-insensitive
	* matches.
	*/
	if (flag & ZRENAMING)
	cmpflags = 0;
	else
	cmpflags = zfsvfs->z_norm;

	/*
	* Wait until there are no locks on this name.
	*
	* Don't grab the lock if it is already held. However, cannot
	* have both ZSHARED and ZHAVELOCK together.
	*/
	ASSERT(!(flag & ZSHARED) \|\| !(flag & ZHAVELOCK));
	if (!(flag & ZHAVELOCK))
	rw_enter(&dzp->z_name_lock, RW_READER);

	mutex_enter(&dzp->z_lock);
	for (;;) {
	if (dzp->z_unlinked && !(flag & ZXATTR)) {
	mutex_exit(&dzp->z_lock);
	if (!(flag & ZHAVELOCK))
	rw_exit(&dzp->z_name_lock);
	return (SET_ERROR(ENOENT));
	}
	for (dl = dzp->z_dirlocks; dl != NULL; dl = dl->dl_next) {
	if ((u8_strcmp(name, dl->dl_name, 0, cmpflags,
	U8_UNICODE_LATEST, &error) == 0) \|\| error != 0)
	break;
	}
	if (error != 0) {
	mutex_exit(&dzp->z_lock);
	if (!(flag & ZHAVELOCK))
	rw_exit(&dzp->z_name_lock);
	return (SET_ERROR(ENOENT));
	}
	if (dl == NULL) {
	/*
	* Allocate a new dirlock and add it to the list.
	*/
	dl = kmem_alloc(sizeof (zfs_dirlock_t), KM_SLEEP);
	cv_init(&dl->dl_cv, NULL, CV_DEFAULT, NULL);
	dl->dl_name = name;
	dl->dl_sharecnt = 0;
	dl->dl_namelock = 0;
	dl->dl_namesize = 0;
	dl->dl_dzp = dzp;
	dl->dl_next = dzp->z_dirlocks;
	dzp->z_dirlocks = dl;
	break;
	}
	if ((flag & ZSHARED) && dl->dl_sharecnt != 0)
	break;
	cv_wait(&dl->dl_cv, &dzp->z_lock);
	}

	/*
	* If the z_name_lock was NOT held for this dirlock record it.
	*/
	if (flag & ZHAVELOCK)
	dl->dl_namelock = 1;

	if ((flag & ZSHARED) && ++dl->dl_sharecnt > 1 && dl->dl_namesize == 0) {
	/*
	* We're the second shared reference to dl. Make a copy of
	* dl_name in case the first thread goes away before we do.
	* Note that we initialize the new name before storing its
	* pointer into dl_name, because the first thread may load
	* dl->dl_name at any time. It'll either see the old value,
	* which belongs to it, or the new shared copy; either is OK.
	*/
	dl->dl_namesize = strlen(dl->dl_name) + 1;
	name = kmem_alloc(dl->dl_namesize, KM_SLEEP);
	bcopy(dl->dl_name, name, dl->dl_namesize);
	dl->dl_name = name;
	}

	mutex_exit(&dzp->z_lock);

	/*
	* We have a dirlock on the name. (Note that it is the dirlock,
	* not the dzp's z_lock, that protects the name in the zap object.)
	* See if there's an object by this name; if so, put a hold on it.
	*/
	if (flag & ZXATTR) {
	error = sa_lookup(dzp->z_sa_hdl, SA_ZPL_XATTR(zfsvfs), &zoid,
	sizeof (zoid));
	if (error == 0)
	error = (zoid == 0 ? SET_ERROR(ENOENT) : 0);
	} else {
	error = zfs_match_find(zfsvfs, dzp, name, mt,
	update, direntflags, realpnp, &zoid);
	}
	if (error) {
	if (error != ENOENT \|\| (flag & ZEXISTS)) {
	zfs_dirent_unlock(dl);
	return (error);
	}
	} else {
	if (flag & ZNEW) {
	zfs_dirent_unlock(dl);
	return (SET_ERROR(EEXIST));
	}
	error = zfs_zget(zfsvfs, zoid, zpp);
	if (error) {
	zfs_dirent_unlock(dl);
	return (error);
	}
	}

	*dlpp = dl;

	return (0);
	}

	/*
	* Unlock this directory entry and wake anyone who was waiting for it.
	*/
	void
	zfs_dirent_unlock(zfs_dirlock_t *dl)
	{
	znode_t *dzp = dl->dl_dzp;
	zfs_dirlock_t *prev_dl, cur_dl;

	mutex_enter(&dzp->z_lock);

	if (!dl->dl_namelock)
	rw_exit(&dzp->z_name_lock);

	if (dl->dl_sharecnt > 1) {
	dl->dl_sharecnt--;
	mutex_exit(&dzp->z_lock);
	return;
	}
	prev_dl = &dzp->z_dirlocks;
	while ((cur_dl = *prev_dl) != dl)
	prev_dl = &cur_dl->dl_next;
	*prev_dl = dl->dl_next;
	cv_broadcast(&dl->dl_cv);
	mutex_exit(&dzp->z_lock);

	if (dl->dl_namesize != 0)
	kmem_free(dl->dl_name, dl->dl_namesize);
	cv_destroy(&dl->dl_cv);
	kmem_free(dl, sizeof (*dl));
	}

	/*
	* Look up an entry in a directory.
	*
	* NOTE: '.' and '..' are handled as special cases because
	* no directory entries are actually stored for them. If this is
	* the root of a filesystem, then '.zfs' is also treated as a
	* special pseudo-directory.
	*/
	int
	zfs_dirlook(znode_t dzp, char name, znode_t **zpp, int flags,
	int deflg, pathname_t rpnp)
	{
	zfs_dirlock_t *dl;
	znode_t *zp;
	struct inode *ip;
	int error = 0;
	uint64_t parent;

	if (name[0] == 0 \|\| (name[0] == '.' && name[1] == 0)) {
	*zpp = dzp;
	zhold(*zpp);
	} else if (name[0] == '.' && name[1] == '.' && name[2] == 0) {
	zfsvfs_t *zfsvfs = ZTOZSB(dzp);

	/*
	* If we are a snapshot mounted under .zfs, return
	* the inode pointer for the snapshot directory.
	*/
	if ((error = sa_lookup(dzp->z_sa_hdl,
	SA_ZPL_PARENT(zfsvfs), &parent, sizeof (parent))) != 0)
	return (error);

	if (parent == dzp->z_id && zfsvfs->z_parent != zfsvfs) {
	error = zfsctl_root_lookup(zfsvfs->z_parent->z_ctldir,
	"snapshot", &ip, 0, kcred, NULL, NULL);
	*zpp = ITOZ(ip);
	return (error);
	}
	rw_enter(&dzp->z_parent_lock, RW_READER);
	error = zfs_zget(zfsvfs, parent, &zp);
	if (error == 0)
	*zpp = zp;
	rw_exit(&dzp->z_parent_lock);
	} else if (zfs_has_ctldir(dzp) && strcmp(name, ZFS_CTLDIR_NAME) == 0) {
	ip = zfsctl_root(dzp);
	*zpp = ITOZ(ip);
	} else {
	int zf;

	zf = ZEXISTS \| ZSHARED;
	if (flags & FIGNORECASE)
	zf \|= ZCILOOK;

	error = zfs_dirent_lock(&dl, dzp, name, &zp, zf, deflg, rpnp);
	if (error == 0) {
	*zpp = zp;
	zfs_dirent_unlock(dl);
	dzp->z_zn_prefetch = B_TRUE; /* enable prefetching */
	}
	rpnp = NULL;
	}

	if ((flags & FIGNORECASE) && rpnp && !error)
	(void) strlcpy(rpnp->pn_buf, name, rpnp->pn_bufsize);

	return (error);
	}

	/*
	* unlinked Set (formerly known as the "delete queue") Error Handling
	*
	* When dealing with the unlinked set, we dmu_tx_hold_zap(), but we
	* don't specify the name of the entry that we will be manipulating. We
	* also fib and say that we won't be adding any new entries to the
	* unlinked set, even though we might (this is to lower the minimum file
	* size that can be deleted in a full filesystem). So on the small
	* chance that the nlink list is using a fat zap (ie. has more than
	* 2000 entries), we may not pre-read a block that's needed.
	* Therefore it is remotely possible for some of the assertions
	* regarding the unlinked set below to fail due to i/o error. On a
	* nondebug system, this will result in the space being leaked.
	*/
	void
	zfs_unlinked_add(znode_t zp, dmu_tx_t tx)
	{
	zfsvfs_t *zfsvfs = ZTOZSB(zp);

	ASSERT(zp->z_unlinked);
	ASSERT(ZTOI(zp)->i_nlink == 0);

	VERIFY3U(0, ==,
	zap_add_int(zfsvfs->z_os, zfsvfs->z_unlinkedobj, zp->z_id, tx));

	dataset_kstats_update_nunlinks_kstat(&zfsvfs->z_kstat, 1);
	}

	/*
	* Clean up any znodes that had no links when we either crashed or
	* (force) umounted the file system.
	*/
	static void
	zfs_unlinked_drain_task(void *arg)
	{
	zfsvfs_t *zfsvfs = arg;
	zap_cursor_t zc;
	zap_attribute_t zap;
	dmu_object_info_t doi;
	znode_t *zp;
	int error;

	ASSERT3B(zfsvfs->z_draining, ==, B_TRUE);

	/*
	* Iterate over the contents of the unlinked set.
	*/
	for (zap_cursor_init(&zc, zfsvfs->z_os, zfsvfs->z_unlinkedobj);
	zap_cursor_retrieve(&zc, &zap) == 0 && !zfsvfs->z_drain_cancel;
	zap_cursor_advance(&zc)) {

	/*
	* See what kind of object we have in list
	*/

	error = dmu_object_info(zfsvfs->z_os,
	zap.za_first_integer, &doi);
	if (error != 0)
	continue;

	ASSERT((doi.doi_type == DMU_OT_PLAIN_FILE_CONTENTS) \|\|
	(doi.doi_type == DMU_OT_DIRECTORY_CONTENTS));
	/*
	* We need to re-mark these list entries for deletion,
	* so we pull them back into core and set zp->z_unlinked.
	*/
	error = zfs_zget(zfsvfs, zap.za_first_integer, &zp);

	/*
	* We may pick up znodes that are already marked for deletion.
	* This could happen during the purge of an extended attribute
	* directory. All we need to do is skip over them, since they
	* are already in the system marked z_unlinked.
	*/
	if (error != 0)
	continue;

	zp->z_unlinked = B_TRUE;

	/*
	* zrele() decrements the znode's ref count and may cause
	* it to be synchronously freed. We interrupt freeing
	* of this znode by checking the return value of
	* dmu_objset_zfs_unmounting() in dmu_free_long_range()
	* when an unmount is requested.
	*/
	zrele(zp);
	ASSERT3B(zfsvfs->z_unmounted, ==, B_FALSE);
	}
	zap_cursor_fini(&zc);

	zfsvfs->z_draining = B_FALSE;
	zfsvfs->z_drain_task = TASKQID_INVALID;
	}

	/*
	* Sets z_draining then tries to dispatch async unlinked drain.
	* If that fails executes synchronous unlinked drain.
	*/
	void
	zfs_unlinked_drain(zfsvfs_t *zfsvfs)
	{
	ASSERT3B(zfsvfs->z_unmounted, ==, B_FALSE);
	ASSERT3B(zfsvfs->z_draining, ==, B_FALSE);

	zfsvfs->z_draining = B_TRUE;
	zfsvfs->z_drain_cancel = B_FALSE;

	zfsvfs->z_drain_task = taskq_dispatch(
	dsl_pool_unlinked_drain_taskq(dmu_objset_pool(zfsvfs->z_os)),
	zfs_unlinked_drain_task, zfsvfs, TQ_SLEEP);
	if (zfsvfs->z_drain_task == TASKQID_INVALID) {
	zfs_dbgmsg("async zfs_unlinked_drain dispatch failed");
	zfs_unlinked_drain_task(zfsvfs);
	}
	}

	/*
	* Wait for the unlinked drain taskq task to stop. This will interrupt the
	* unlinked set processing if it is in progress.
	*/
	void
	zfs_unlinked_drain_stop_wait(zfsvfs_t *zfsvfs)
	{
	ASSERT3B(zfsvfs->z_unmounted, ==, B_FALSE);

	if (zfsvfs->z_draining) {
	zfsvfs->z_drain_cancel = B_TRUE;
	taskq_cancel_id(dsl_pool_unlinked_drain_taskq(
	dmu_objset_pool(zfsvfs->z_os)), zfsvfs->z_drain_task);
	zfsvfs->z_drain_task = TASKQID_INVALID;
	zfsvfs->z_draining = B_FALSE;
	}
	}

	/*
	* Delete the entire contents of a directory. Return a count
	* of the number of entries that could not be deleted. If we encounter
	* an error, return a count of at least one so that the directory stays
	* in the unlinked set.
	*
	* NOTE: this function assumes that the directory is inactive,
	* so there is no need to lock its entries before deletion.
	* Also, it assumes the directory contents is only regular
	* files.
	*/
	static int
	zfs_purgedir(znode_t *dzp)
	{
	zap_cursor_t zc;
	zap_attribute_t zap;
	znode_t *xzp;
	dmu_tx_t *tx;
	zfsvfs_t *zfsvfs = ZTOZSB(dzp);
	zfs_dirlock_t dl;
	int skipped = 0;
	int error;

	for (zap_cursor_init(&zc, zfsvfs->z_os, dzp->z_id);
	(error = zap_cursor_retrieve(&zc, &zap)) == 0;
	zap_cursor_advance(&zc)) {
	error = zfs_zget(zfsvfs,
	ZFS_DIRENT_OBJ(zap.za_first_integer), &xzp);
	if (error) {
	skipped += 1;
	continue;
	}

	ASSERT(S_ISREG(ZTOI(xzp)->i_mode) \|\|
	S_ISLNK(ZTOI(xzp)->i_mode));

	tx = dmu_tx_create(zfsvfs->z_os);
	dmu_tx_hold_sa(tx, dzp->z_sa_hdl, B_FALSE);
	dmu_tx_hold_zap(tx, dzp->z_id, FALSE, zap.za_name);
	dmu_tx_hold_sa(tx, xzp->z_sa_hdl, B_FALSE);
	dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, FALSE, NULL);
	/* Is this really needed ? */
	zfs_sa_upgrade_txholds(tx, xzp);
	dmu_tx_mark_netfree(tx);
	error = dmu_tx_assign(tx, TXG_WAIT);
	if (error) {
	dmu_tx_abort(tx);
	zfs_zrele_async(xzp);
	skipped += 1;
	continue;
	}
	bzero(&dl, sizeof (dl));
	dl.dl_dzp = dzp;
	dl.dl_name = zap.za_name;

	error = zfs_link_destroy(&dl, xzp, tx, 0, NULL);
	if (error)
	skipped += 1;
	dmu_tx_commit(tx);

	zfs_zrele_async(xzp);
	}
	zap_cursor_fini(&zc);
	if (error != ENOENT)
	skipped += 1;
	return (skipped);
	}

	void
	zfs_rmnode(znode_t *zp)
	{
	zfsvfs_t *zfsvfs = ZTOZSB(zp);
	objset_t *os = zfsvfs->z_os;
	znode_t *xzp = NULL;
	dmu_tx_t *tx;
	uint64_t acl_obj;
	uint64_t xattr_obj;
	uint64_t links;
	int error;

	ASSERT(ZTOI(zp)->i_nlink == 0);
	ASSERT(atomic_read(&ZTOI(zp)->i_count) == 0);

	/*
	* If this is an attribute directory, purge its contents.
	*/
	if (S_ISDIR(ZTOI(zp)->i_mode) && (zp->z_pflags & ZFS_XATTR)) {
	if (zfs_purgedir(zp) != 0) {
	/*
	* Not enough space to delete some xattrs.
	* Leave it in the unlinked set.
	*/
	zfs_znode_dmu_fini(zp);

	return;
	}
	}

	/*
	* Free up all the data in the file. We don't do this for directories
	* because we need truncate and remove to be in the same tx, like in
	* zfs_znode_delete(). Otherwise, if we crash here we'll end up with
	* an inconsistent truncated zap object in the delete queue. Note a
	* truncated file is harmless since it only contains user data.
	*/
	if (S_ISREG(ZTOI(zp)->i_mode)) {
	error = dmu_free_long_range(os, zp->z_id, 0, DMU_OBJECT_END);
	if (error) {
	/*
	* Not enough space or we were interrupted by unmount.
	* Leave the file in the unlinked set.
	*/
	zfs_znode_dmu_fini(zp);
	return;
	}
	}

	/*
	* If the file has extended attributes, we're going to unlink
	* the xattr dir.
	*/
	error = sa_lookup(zp->z_sa_hdl, SA_ZPL_XATTR(zfsvfs),
	&xattr_obj, sizeof (xattr_obj));
	if (error == 0 && xattr_obj) {
	error = zfs_zget(zfsvfs, xattr_obj, &xzp);
	ASSERT(error == 0);
	}

	acl_obj = zfs_external_acl(zp);

	/*
	* Set up the final transaction.
	*/
	tx = dmu_tx_create(os);
	dmu_tx_hold_free(tx, zp->z_id, 0, DMU_OBJECT_END);
	dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, FALSE, NULL);
	if (xzp) {
	dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, TRUE, NULL);
	dmu_tx_hold_sa(tx, xzp->z_sa_hdl, B_FALSE);
	}
	if (acl_obj)
	dmu_tx_hold_free(tx, acl_obj, 0, DMU_OBJECT_END);

	zfs_sa_upgrade_txholds(tx, zp);
	error = dmu_tx_assign(tx, TXG_WAIT);
	if (error) {
	/*
	* Not enough space to delete the file. Leave it in the
	* unlinked set, leaking it until the fs is remounted (at
	* which point we'll call zfs_unlinked_drain() to process it).
	*/
	dmu_tx_abort(tx);
	zfs_znode_dmu_fini(zp);
	goto out;
	}

	if (xzp) {
	ASSERT(error == 0);
	mutex_enter(&xzp->z_lock);
	xzp->z_unlinked = B_TRUE; /* mark xzp for deletion */
	clear_nlink(ZTOI(xzp)); /* no more links to it */
	links = 0;
	VERIFY(0 == sa_update(xzp->z_sa_hdl, SA_ZPL_LINKS(zfsvfs),
	&links, sizeof (links), tx));
	mutex_exit(&xzp->z_lock);
	zfs_unlinked_add(xzp, tx);
	}

	mutex_enter(&os->os_dsl_dataset->ds_dir->dd_activity_lock);

	/*
	* Remove this znode from the unlinked set. If a has rollback has
	* occurred while a file is open and unlinked. Then when the file
	* is closed post rollback it will not exist in the rolled back
	* version of the unlinked object.
	*/
	error = zap_remove_int(zfsvfs->z_os, zfsvfs->z_unlinkedobj,
	zp->z_id, tx);
	VERIFY(error == 0 \|\| error == ENOENT);

	uint64_t count;
	if (zap_count(os, zfsvfs->z_unlinkedobj, &count) == 0 && count == 0) {
	cv_broadcast(&os->os_dsl_dataset->ds_dir->dd_activity_cv);
	}

	mutex_exit(&os->os_dsl_dataset->ds_dir->dd_activity_lock);

	dataset_kstats_update_nunlinked_kstat(&zfsvfs->z_kstat, 1);

	zfs_znode_delete(zp, tx);

	dmu_tx_commit(tx);
	out:
	if (xzp)
	zfs_zrele_async(xzp);
	}

	static uint64_t
	zfs_dirent(znode_t *zp, uint64_t mode)
	{
	uint64_t de = zp->z_id;

	if (ZTOZSB(zp)->z_version >= ZPL_VERSION_DIRENT_TYPE)
	de \|= IFTODT(mode) << 60;
	return (de);
	}

	/*
	* Link zp into dl. Can fail in the following cases :
	* - if zp has been unlinked.
	* - if the number of entries with the same hash (aka. colliding entries)
	* exceed the capacity of a leaf-block of fatzap and splitting of the
	* leaf-block does not help.
	*/
	int
	zfs_link_create(zfs_dirlock_t dl, znode_t zp, dmu_tx_t *tx, int flag)
	{
	znode_t *dzp = dl->dl_dzp;
	zfsvfs_t *zfsvfs = ZTOZSB(zp);
	uint64_t value;
	int zp_is_dir = S_ISDIR(ZTOI(zp)->i_mode);
	sa_bulk_attr_t bulk[5];
	uint64_t mtime[2], ctime[2];
	uint64_t links;
	int count = 0;
	int error;

	mutex_enter(&zp->z_lock);

	if (!(flag & ZRENAMING)) {
	if (zp->z_unlinked) { /* no new links to unlinked zp */
	ASSERT(!(flag & (ZNEW \| ZEXISTS)));
	mutex_exit(&zp->z_lock);
	return (SET_ERROR(ENOENT));
	}
	if (!(flag & ZNEW)) {
	/*
	* ZNEW nodes come from zfs_mknode() where the link
	* count has already been initialised
	*/
	inc_nlink(ZTOI(zp));
	links = ZTOI(zp)->i_nlink;
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_LINKS(zfsvfs),
	NULL, &links, sizeof (links));
	}
	}

	value = zfs_dirent(zp, zp->z_mode);
	error = zap_add(ZTOZSB(zp)->z_os, dzp->z_id, dl->dl_name, 8, 1,
	&value, tx);

	/*
	* zap_add could fail to add the entry if it exceeds the capacity of the
	* leaf-block and zap_leaf_split() failed to help.
	* The caller of this routine is responsible for failing the transaction
	* which will rollback the SA updates done above.
	*/
	if (error != 0) {
	if (!(flag & ZRENAMING) && !(flag & ZNEW))
	drop_nlink(ZTOI(zp));
	mutex_exit(&zp->z_lock);
	return (error);
	}

	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_PARENT(zfsvfs), NULL,
	&dzp->z_id, sizeof (dzp->z_id));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zfsvfs), NULL,
	&zp->z_pflags, sizeof (zp->z_pflags));

	if (!(flag & ZNEW)) {
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs), NULL,
	ctime, sizeof (ctime));
	zfs_tstamp_update_setup(zp, STATE_CHANGED, mtime,
	ctime);
	}
	error = sa_bulk_update(zp->z_sa_hdl, bulk, count, tx);
	ASSERT(error == 0);

	mutex_exit(&zp->z_lock);

	mutex_enter(&dzp->z_lock);
	dzp->z_size++;
	if (zp_is_dir)
	inc_nlink(ZTOI(dzp));
	links = ZTOI(dzp)->i_nlink;
	count = 0;
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_SIZE(zfsvfs), NULL,
	&dzp->z_size, sizeof (dzp->z_size));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_LINKS(zfsvfs), NULL,
	&links, sizeof (links));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zfsvfs), NULL,
	mtime, sizeof (mtime));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs), NULL,
	ctime, sizeof (ctime));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zfsvfs), NULL,
	&dzp->z_pflags, sizeof (dzp->z_pflags));
	zfs_tstamp_update_setup(dzp, CONTENT_MODIFIED, mtime, ctime);
	error = sa_bulk_update(dzp->z_sa_hdl, bulk, count, tx);
	ASSERT(error == 0);
	mutex_exit(&dzp->z_lock);

	return (0);
	}

	/*
	* The match type in the code for this function should conform to:
	*
	* ------------------------------------------------------------------------
	* fs type \| z_norm \| lookup type \| match type
	* ---------\|-------------\|-------------\|----------------------------------
	* CS !norm \| 0 \| 0 \| 0 (exact)
	* CS norm \| formX \| 0 \| MT_NORMALIZE
	* CI !norm \| upper \| !ZCIEXACT \| MT_NORMALIZE
	* CI !norm \| upper \| ZCIEXACT \| MT_NORMALIZE \| MT_MATCH_CASE
	* CI norm \| upper\|formX \| !ZCIEXACT \| MT_NORMALIZE
	* CI norm \| upper\|formX \| ZCIEXACT \| MT_NORMALIZE \| MT_MATCH_CASE
	* CM !norm \| upper \| !ZCILOOK \| MT_NORMALIZE \| MT_MATCH_CASE
	* CM !norm \| upper \| ZCILOOK \| MT_NORMALIZE
	* CM norm \| upper\|formX \| !ZCILOOK \| MT_NORMALIZE \| MT_MATCH_CASE
	* CM norm \| upper\|formX \| ZCILOOK \| MT_NORMALIZE
	*
	* Abbreviations:
	* CS = Case Sensitive, CI = Case Insensitive, CM = Case Mixed
	* upper = case folding set by fs type on creation (U8_TEXTPREP_TOUPPER)
	* formX = unicode normalization form set on fs creation
	*/
	static int
	zfs_dropname(zfs_dirlock_t dl, znode_t zp, znode_t dzp, dmu_tx_t tx,
	int flag)
	{
	int error;

	if (ZTOZSB(zp)->z_norm) {
	matchtype_t mt = MT_NORMALIZE;

	if ((ZTOZSB(zp)->z_case == ZFS_CASE_INSENSITIVE &&
	(flag & ZCIEXACT)) \|\|
	(ZTOZSB(zp)->z_case == ZFS_CASE_MIXED &&
	!(flag & ZCILOOK))) {
	mt \|= MT_MATCH_CASE;
	}

	error = zap_remove_norm(ZTOZSB(zp)->z_os, dzp->z_id,
	dl->dl_name, mt, tx);
	} else {
	error = zap_remove(ZTOZSB(zp)->z_os, dzp->z_id, dl->dl_name,
	tx);
	}

	return (error);
	}

	/*
	* Unlink zp from dl, and mark zp for deletion if this was the last link. Can
	* fail if zp is a mount point (EBUSY) or a non-empty directory (ENOTEMPTY).
	* If 'unlinkedp' is NULL, we put unlinked znodes on the unlinked list.
	* If it's non-NULL, we use it to indicate whether the znode needs deletion,
	* and it's the caller's job to do it.
	*/
	int
	zfs_link_destroy(zfs_dirlock_t dl, znode_t zp, dmu_tx_t *tx, int flag,
	boolean_t *unlinkedp)
	{
	znode_t *dzp = dl->dl_dzp;
	zfsvfs_t *zfsvfs = ZTOZSB(dzp);
	int zp_is_dir = S_ISDIR(ZTOI(zp)->i_mode);
	boolean_t unlinked = B_FALSE;
	sa_bulk_attr_t bulk[5];
	uint64_t mtime[2], ctime[2];
	uint64_t links;
	int count = 0;
	int error;

	if (!(flag & ZRENAMING)) {
	mutex_enter(&zp->z_lock);

	if (zp_is_dir && !zfs_dirempty(zp)) {
	mutex_exit(&zp->z_lock);
	return (SET_ERROR(ENOTEMPTY));
	}

	/*
	* If we get here, we are going to try to remove the object.
	* First try removing the name from the directory; if that
	* fails, return the error.
	*/
	error = zfs_dropname(dl, zp, dzp, tx, flag);
	if (error != 0) {
	mutex_exit(&zp->z_lock);
	return (error);
	}

	if (ZTOI(zp)->i_nlink <= zp_is_dir) {
	zfs_panic_recover("zfs: link count on %lu is %u, "
	"should be at least %u", zp->z_id,
	(int)ZTOI(zp)->i_nlink, zp_is_dir + 1);
	set_nlink(ZTOI(zp), zp_is_dir + 1);
	}
	drop_nlink(ZTOI(zp));
	if (ZTOI(zp)->i_nlink == zp_is_dir) {
	zp->z_unlinked = B_TRUE;
	clear_nlink(ZTOI(zp));
	unlinked = B_TRUE;
	} else {
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs),
	NULL, &ctime, sizeof (ctime));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zfsvfs),
	NULL, &zp->z_pflags, sizeof (zp->z_pflags));
	zfs_tstamp_update_setup(zp, STATE_CHANGED, mtime,
	ctime);
	}
	links = ZTOI(zp)->i_nlink;
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_LINKS(zfsvfs),
	NULL, &links, sizeof (links));
	error = sa_bulk_update(zp->z_sa_hdl, bulk, count, tx);
	count = 0;
	ASSERT(error == 0);
	mutex_exit(&zp->z_lock);
	} else {
	error = zfs_dropname(dl, zp, dzp, tx, flag);
	if (error != 0)
	return (error);
	}

	mutex_enter(&dzp->z_lock);
	dzp->z_size--; /* one dirent removed */
	if (zp_is_dir)
	drop_nlink(ZTOI(dzp)); /* ".." link from zp */
	links = ZTOI(dzp)->i_nlink;
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_LINKS(zfsvfs),
	NULL, &links, sizeof (links));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_SIZE(zfsvfs),
	NULL, &dzp->z_size, sizeof (dzp->z_size));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs),
	NULL, ctime, sizeof (ctime));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zfsvfs),
	NULL, mtime, sizeof (mtime));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zfsvfs),
	NULL, &dzp->z_pflags, sizeof (dzp->z_pflags));
	zfs_tstamp_update_setup(dzp, CONTENT_MODIFIED, mtime, ctime);
	error = sa_bulk_update(dzp->z_sa_hdl, bulk, count, tx);
	ASSERT(error == 0);
	mutex_exit(&dzp->z_lock);

	if (unlinkedp != NULL)
	*unlinkedp = unlinked;
	else if (unlinked)
	zfs_unlinked_add(zp, tx);

	return (0);
	}

	/*
	* Indicate whether the directory is empty. Works with or without z_lock
	* held, but can only be consider a hint in the latter case. Returns true
	* if only "." and ".." remain and there's no work in progress.
	*
	* The internal ZAP size, rather than zp->z_size, needs to be checked since
	* some consumers (Lustre) do not strictly maintain an accurate SA_ZPL_SIZE.
	*/
	boolean_t
	zfs_dirempty(znode_t *dzp)
	{
	zfsvfs_t *zfsvfs = ZTOZSB(dzp);
	uint64_t count;
	int error;

	if (dzp->z_dirlocks != NULL)
	return (B_FALSE);

	error = zap_count(zfsvfs->z_os, dzp->z_id, &count);
	if (error != 0 \|\| count != 0)
	return (B_FALSE);

	return (B_TRUE);
	}

	int
	zfs_make_xattrdir(znode_t zp, vattr_t vap, znode_t *xzpp, cred_t cr)
	{
	zfsvfs_t *zfsvfs = ZTOZSB(zp);
	znode_t *xzp;
	dmu_tx_t *tx;
	int error;
	zfs_acl_ids_t acl_ids;
	boolean_t fuid_dirtied;
	#ifdef ZFS_DEBUG
	uint64_t parent;
	#endif

	*xzpp = NULL;

	if ((error = zfs_zaccess(zp, ACE_WRITE_NAMED_ATTRS, 0, B_FALSE, cr)))
	return (error);

	if ((error = zfs_acl_ids_create(zp, IS_XATTR, vap, cr, NULL,
	&acl_ids)) != 0)
	return (error);
	if (zfs_acl_ids_overquota(zfsvfs, &acl_ids, zp->z_projid)) {
	zfs_acl_ids_free(&acl_ids);
	return (SET_ERROR(EDQUOT));
	}

	tx = dmu_tx_create(zfsvfs->z_os);
	dmu_tx_hold_sa_create(tx, acl_ids.z_aclp->z_acl_bytes +
	ZFS_SA_BASE_ATTR_SIZE);
	dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_TRUE);
	dmu_tx_hold_zap(tx, DMU_NEW_OBJECT, FALSE, NULL);
	fuid_dirtied = zfsvfs->z_fuid_dirty;
	if (fuid_dirtied)
	zfs_fuid_txhold(zfsvfs, tx);
	error = dmu_tx_assign(tx, TXG_WAIT);
	if (error) {
	zfs_acl_ids_free(&acl_ids);
	dmu_tx_abort(tx);
	return (error);
	}
	zfs_mknode(zp, vap, tx, cr, IS_XATTR, &xzp, &acl_ids);

	if (fuid_dirtied)
	zfs_fuid_sync(zfsvfs, tx);

	#ifdef ZFS_DEBUG
	error = sa_lookup(xzp->z_sa_hdl, SA_ZPL_PARENT(zfsvfs),
	&parent, sizeof (parent));
	ASSERT(error == 0 && parent == zp->z_id);
	#endif

	VERIFY(0 == sa_update(zp->z_sa_hdl, SA_ZPL_XATTR(zfsvfs), &xzp->z_id,
	sizeof (xzp->z_id), tx));

	if (!zp->z_unlinked)
	- (void) zfs_log_create(zfsvfs->z_log, tx, TX_MKXATTR, zp,
	- xzp, "", NULL, acl_ids.z_fuidp, vap);
	+ zfs_log_create(zfsvfs->z_log, tx, TX_MKXATTR, zp, xzp, "", NULL,
	+ acl_ids.z_fuidp, vap);

	zfs_acl_ids_free(&acl_ids);
	dmu_tx_commit(tx);

	*xzpp = xzp;

	return (0);
	}

	/*
	* Return a znode for the extended attribute directory for zp.
	* If the directory does not already exist, it is created
	*
	* IN: zp - znode to obtain attribute directory from
	* cr - credentials of caller
	* flags - flags from the VOP_LOOKUP call
	*
	* OUT: xipp - pointer to extended attribute znode
	*
	* RETURN: 0 on success
	* error number on failure
	*/
	int
	zfs_get_xattrdir(znode_t zp, znode_t xzpp, cred_t cr, int flags)
	{
	zfsvfs_t *zfsvfs = ZTOZSB(zp);
	znode_t *xzp;
	zfs_dirlock_t *dl;
	vattr_t va;
	int error;
	top:
	error = zfs_dirent_lock(&dl, zp, "", &xzp, ZXATTR, NULL, NULL);
	if (error)
	return (error);

	if (xzp != NULL) {
	*xzpp = xzp;
	zfs_dirent_unlock(dl);
	return (0);
	}

	if (!(flags & CREATE_XATTR_DIR)) {
	zfs_dirent_unlock(dl);
	return (SET_ERROR(ENOENT));
	}

	if (zfs_is_readonly(zfsvfs)) {
	zfs_dirent_unlock(dl);
	return (SET_ERROR(EROFS));
	}

	/*
	* The ability to 'create' files in an attribute
	* directory comes from the write_xattr permission on the base file.
	*
	* The ability to 'search' an attribute directory requires
	* read_xattr permission on the base file.
	*
	* Once in a directory the ability to read/write attributes
	* is controlled by the permissions on the attribute file.
	*/
	va.va_mask = ATTR_MODE \| ATTR_UID \| ATTR_GID;
	va.va_mode = S_IFDIR \| S_ISVTX \| 0777;
	zfs_fuid_map_ids(zp, cr, &va.va_uid, &va.va_gid);

	va.va_dentry = NULL;
	error = zfs_make_xattrdir(zp, &va, xzpp, cr);
	zfs_dirent_unlock(dl);

	if (error == ERESTART) {
	/* NB: we already did dmu_tx_wait() if necessary */
	goto top;
	}

	return (error);
	}

	/*
	* Decide whether it is okay to remove within a sticky directory.
	*
	* In sticky directories, write access is not sufficient;
	* you can remove entries from a directory only if:
	*
	* you own the directory,
	* you own the entry,
	* you have write access to the entry,
	* or you are privileged (checked in secpolicy...).
	*
	* The function returns 0 if remove access is granted.
	*/
	int
	zfs_sticky_remove_access(znode_t zdp, znode_t zp, cred_t *cr)
	{
	uid_t uid;
	uid_t downer;
	uid_t fowner;
	zfsvfs_t *zfsvfs = ZTOZSB(zdp);

	if (zfsvfs->z_replay)
	return (0);

	if ((zdp->z_mode & S_ISVTX) == 0)
	return (0);

	downer = zfs_fuid_map_id(zfsvfs, KUID_TO_SUID(ZTOI(zdp)->i_uid),
	cr, ZFS_OWNER);
	fowner = zfs_fuid_map_id(zfsvfs, KUID_TO_SUID(ZTOI(zp)->i_uid),
	cr, ZFS_OWNER);

	if ((uid = crgetuid(cr)) == downer \|\| uid == fowner \|\|
	zfs_zaccess(zp, ACE_WRITE_DATA, 0, B_FALSE, cr) == 0)
	return (0);
	else
	return (secpolicy_vnode_remove(cr));
	}
	diff --git a/sys/contrib/openzfs/module/os/linux/zfs/zfs_file_os.c b/sys/contrib/openzfs/module/os/linux/zfs/zfs_file_os.c
	index 99c6ffc95940..35e647375d9d 100644
	--- a/sys/contrib/openzfs/module/os/linux/zfs/zfs_file_os.c
	+++ b/sys/contrib/openzfs/module/os/linux/zfs/zfs_file_os.c
	@@ -1,440 +1,442 @@
	/*
	* 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
	*/

	#include <sys/zfs_context.h>
	#include <sys/zfs_file.h>
	#include <sys/stat.h>
	#include <sys/file.h>
	#include <linux/falloc.h>
	#include <linux/fs.h>
	#include <linux/uaccess.h>
	#ifdef HAVE_FDTABLE_HEADER
	#include <linux/fdtable.h>
	#endif

	/*
	* Open file
	*
	* path - fully qualified path to file
	* flags - file attributes O_READ / O_WRITE / O_EXCL
	* fpp - pointer to return file pointer
	*
	* Returns 0 on success underlying error on failure.
	*/
	int
	zfs_file_open(const char path, int flags, int mode, zfs_file_t *fpp)
	{
	struct file *filp;
	int saved_umask;

	if (!(flags & O_CREAT) && (flags & O_WRONLY))
	flags \|= O_EXCL;

	if (flags & O_CREAT)
	saved_umask = xchg(&current->fs->umask, 0);

	filp = filp_open(path, flags, mode);

	if (flags & O_CREAT)
	(void) xchg(&current->fs->umask, saved_umask);

	if (IS_ERR(filp))
	return (-PTR_ERR(filp));

	*fpp = filp;
	return (0);
	}

	void
	zfs_file_close(zfs_file_t *fp)
	{
	filp_close(fp, 0);
	}

	static ssize_t
	zfs_file_write_impl(zfs_file_t fp, const void buf, size_t count, loff_t *off)
	{
	#if defined(HAVE_KERNEL_WRITE_PPOS)
	return (kernel_write(fp, buf, count, off));
	#else
	mm_segment_t saved_fs;
	ssize_t rc;

	saved_fs = get_fs();
	set_fs(KERNEL_DS);

	rc = vfs_write(fp, (__force const char __user __user *)buf, count, off);

	set_fs(saved_fs);

	return (rc);
	#endif
	}

	/*
	* Stateful write - use os internal file pointer to determine where to
	* write and update on successful completion.
	*
	* fp - pointer to file (pipe, socket, etc) to write to
	* buf - buffer to write
	* count - # of bytes to write
	* resid - pointer to count of unwritten bytes (if short write)
	*
	* Returns 0 on success errno on failure.
	*/
	int
	zfs_file_write(zfs_file_t fp, const void buf, size_t count, ssize_t *resid)
	{
	loff_t off = fp->f_pos;
	ssize_t rc;

	rc = zfs_file_write_impl(fp, buf, count, &off);
	if (rc < 0)
	return (-rc);

	fp->f_pos = off;

	if (resid) {
	*resid = count - rc;
	} else if (rc != count) {
	return (EIO);
	}

	return (0);
	}

	/*
	* Stateless write - os internal file pointer is not updated.
	*
	* fp - pointer to file (pipe, socket, etc) to write to
	* buf - buffer to write
	* count - # of bytes to write
	* off - file offset to write to (only valid for seekable types)
	* resid - pointer to count of unwritten bytes
	*
	* Returns 0 on success errno on failure.
	*/
	int
	zfs_file_pwrite(zfs_file_t fp, const void buf, size_t count, loff_t off,
	ssize_t *resid)
	{
	ssize_t rc;

	rc = zfs_file_write_impl(fp, buf, count, &off);
	if (rc < 0)
	return (-rc);

	if (resid) {
	*resid = count - rc;
	} else if (rc != count) {
	return (EIO);
	}

	return (0);
	}

	static ssize_t
	zfs_file_read_impl(zfs_file_t fp, void buf, size_t count, loff_t *off)
	{
	#if defined(HAVE_KERNEL_READ_PPOS)
	return (kernel_read(fp, buf, count, off));
	#else
	mm_segment_t saved_fs;
	ssize_t rc;

	saved_fs = get_fs();
	set_fs(KERNEL_DS);

	rc = vfs_read(fp, (void __user *)buf, count, off);
	set_fs(saved_fs);

	return (rc);
	#endif
	}

	/*
	* Stateful read - use os internal file pointer to determine where to
	* read and update on successful completion.
	*
	* fp - pointer to file (pipe, socket, etc) to read from
	* buf - buffer to write
	* count - # of bytes to read
	* resid - pointer to count of unread bytes (if short read)
	*
	* Returns 0 on success errno on failure.
	*/
	int
	zfs_file_read(zfs_file_t fp, void buf, size_t count, ssize_t *resid)
	{
	loff_t off = fp->f_pos;
	ssize_t rc;

	rc = zfs_file_read_impl(fp, buf, count, &off);
	if (rc < 0)
	return (-rc);

	fp->f_pos = off;

	if (resid) {
	*resid = count - rc;
	} else if (rc != count) {
	return (EIO);
	}

	return (0);
	}

	/*
	* Stateless read - os internal file pointer is not updated.
	*
	* fp - pointer to file (pipe, socket, etc) to read from
	* buf - buffer to write
	* count - # of bytes to write
	* off - file offset to read from (only valid for seekable types)
	* resid - pointer to count of unwritten bytes (if short write)
	*
	* Returns 0 on success errno on failure.
	*/
	int
	zfs_file_pread(zfs_file_t fp, void buf, size_t count, loff_t off,
	ssize_t *resid)
	{
	ssize_t rc;

	rc = zfs_file_read_impl(fp, buf, count, &off);
	if (rc < 0)
	return (-rc);

	if (resid) {
	*resid = count - rc;
	} else if (rc != count) {
	return (EIO);
	}

	return (0);
	}

	/*
	* lseek - set / get file pointer
	*
	* fp - pointer to file (pipe, socket, etc) to read from
	* offp - value to seek to, returns current value plus passed offset
	* whence - see man pages for standard lseek whence values
	*
	* Returns 0 on success errno on failure (ESPIPE for non seekable types)
	*/
	int
	zfs_file_seek(zfs_file_t fp, loff_t offp, int whence)
	{
	loff_t rc;

	if (offp < 0 \|\| offp > MAXOFFSET_T)
	return (EINVAL);

	rc = vfs_llseek(fp, *offp, whence);
	if (rc < 0)
	return (-rc);

	*offp = rc;

	return (0);
	}

	/*
	* Get file attributes
	*
	* filp - file pointer
	* zfattr - pointer to file attr structure
	*
	* Currently only used for fetching size and file mode.
	*
	* Returns 0 on success or error code of underlying getattr call on failure.
	*/
	int
	zfs_file_getattr(zfs_file_t filp, zfs_file_attr_t zfattr)
	{
	struct kstat stat;
	int rc;

	#if defined(HAVE_4ARGS_VFS_GETATTR)
	rc = vfs_getattr(&filp->f_path, &stat, STATX_BASIC_STATS,
	AT_STATX_SYNC_AS_STAT);
	#elif defined(HAVE_2ARGS_VFS_GETATTR)
	rc = vfs_getattr(&filp->f_path, &stat);
	-#else
	+#elif defined(HAVE_3ARGS_VFS_GETATTR)
	rc = vfs_getattr(filp->f_path.mnt, filp->f_dentry, &stat);
	+#else
	+#error "No available vfs_getattr()"
	#endif
	if (rc)
	return (-rc);

	zfattr->zfa_size = stat.size;
	zfattr->zfa_mode = stat.mode;

	return (0);
	}

	/*
	* Sync file to disk
	*
	* filp - file pointer
	* flags - O_SYNC and or O_DSYNC
	*
	* Returns 0 on success or error code of underlying sync call on failure.
	*/
	int
	zfs_file_fsync(zfs_file_t *filp, int flags)
	{
	int datasync = 0;
	int error;
	int fstrans;

	if (flags & O_DSYNC)
	datasync = 1;

	/*
	* May enter XFS which generates a warning when PF_FSTRANS is set.
	* To avoid this the flag is cleared over vfs_sync() and then reset.
	*/
	fstrans = __spl_pf_fstrans_check();
	if (fstrans)
	current->flags &= ~(__SPL_PF_FSTRANS);

	error = -vfs_fsync(filp, datasync);

	if (fstrans)
	current->flags \|= __SPL_PF_FSTRANS;

	return (error);
	}

	/*
	* fallocate - allocate or free space on disk
	*
	* fp - file pointer
	* mode (non-standard options for hole punching etc)
	* offset - offset to start allocating or freeing from
	* len - length to free / allocate
	*
	* OPTIONAL
	*/
	int
	zfs_file_fallocate(zfs_file_t *fp, int mode, loff_t offset, loff_t len)
	{
	/*
	* May enter XFS which generates a warning when PF_FSTRANS is set.
	* To avoid this the flag is cleared over vfs_sync() and then reset.
	*/
	int fstrans = __spl_pf_fstrans_check();
	if (fstrans)
	current->flags &= ~(__SPL_PF_FSTRANS);

	/*
	* When supported by the underlying file system preferentially
	* use the fallocate() callback to preallocate the space.
	*/
	int error = EOPNOTSUPP;
	if (fp->f_op->fallocate)
	error = fp->f_op->fallocate(fp, mode, offset, len);

	if (fstrans)
	current->flags \|= __SPL_PF_FSTRANS;

	return (error);
	}

	/*
	* Request current file pointer offset
	*
	* fp - pointer to file
	*
	* Returns current file offset.
	*/
	loff_t
	zfs_file_off(zfs_file_t *fp)
	{
	return (fp->f_pos);
	}

	/*
	* Request file pointer private data
	*
	* fp - pointer to file
	*
	* Returns pointer to file private data.
	*/
	void *
	zfs_file_private(zfs_file_t *fp)
	{
	return (fp->private_data);
	}

	/*
	* unlink file
	*
	* path - fully qualified file path
	*
	* Returns 0 on success.
	*
	* OPTIONAL
	*/
	int
	zfs_file_unlink(const char *path)
	{
	return (EOPNOTSUPP);
	}

	/*
	* Get reference to file pointer
	*
	* fd - input file descriptor
	* fpp - pointer to file pointer
	*
	* Returns 0 on success EBADF on failure.
	*/
	int
	zfs_file_get(int fd, zfs_file_t **fpp)
	{
	zfs_file_t *fp;

	fp = fget(fd);
	if (fp == NULL)
	return (EBADF);

	*fpp = fp;

	return (0);
	}

	/*
	* Drop reference to file pointer
	*
	* fd - input file descriptor
	*/
	void
	zfs_file_put(int fd)
	{
	struct file *fp;

	if ((fp = fget(fd)) != NULL) {
	fput(fp);
	fput(fp);
	}
	}
	diff --git a/sys/contrib/openzfs/module/os/linux/zfs/zfs_ioctl_os.c b/sys/contrib/openzfs/module/os/linux/zfs/zfs_ioctl_os.c
	index 6f5cff1770e1..812f9c0ea105 100644
	--- a/sys/contrib/openzfs/module/os/linux/zfs/zfs_ioctl_os.c
	+++ b/sys/contrib/openzfs/module/os/linux/zfs/zfs_ioctl_os.c
	@@ -1,329 +1,329 @@
	/*
	* 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) 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.
	*/

	#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/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);
	}

	static int
	zfsdev_state_init(struct file *filp)
	{
	zfsdev_state_t zs, zsprev = NULL;
	minor_t minor;
	boolean_t newzs = B_FALSE;

	ASSERT(MUTEX_HELD(&zfsdev_state_lock));

	minor = zfsdev_minor_alloc();
	if (minor == 0)
	return (SET_ERROR(ENXIO));

	for (zs = zfsdev_state_list; zs != NULL; zs = zs->zs_next) {
	if (zs->zs_minor == -1)
	break;
	zsprev = zs;
	}

	if (!zs) {
	zs = kmem_zalloc(sizeof (zfsdev_state_t), KM_SLEEP);
	newzs = B_TRUE;
	}

	filp->private_data = zs;

	zfs_onexit_init((zfs_onexit_t **)&zs->zs_onexit);
	zfs_zevent_init((zfs_zevent_t **)&zs->zs_zevent);

	/*
	* In order to provide for lock-free concurrent read access
	* to the minor list in zfsdev_get_state_impl(), new entries
	* must be completely written before linking them into the
	* list whereas existing entries are already linked; the last
	* operation must be updating zs_minor (from -1 to the new
	* value).
	*/
	if (newzs) {
	zs->zs_minor = minor;
	smp_wmb();
	zsprev->zs_next = zs;
	} else {
	smp_wmb();
	zs->zs_minor = minor;
	}

	return (0);
	}

	static int
	zfsdev_state_destroy(struct file *filp)
	{
	zfsdev_state_t *zs;

	ASSERT(MUTEX_HELD(&zfsdev_state_lock));
	ASSERT(filp->private_data != NULL);

	zs = filp->private_data;
	zs->zs_minor = -1;
	zfs_onexit_destroy(zs->zs_onexit);
	zfs_zevent_destroy(zs->zs_zevent);
	zs->zs_onexit = NULL;
	zs->zs_zevent = NULL;

	return (0);
	}

	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)
	{
	int error;

	mutex_enter(&zfsdev_state_lock);
	error = zfsdev_state_destroy(filp);
	mutex_exit(&zfsdev_state_lock);

	return (-error);
	}

	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);

	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));
	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));
	}

	void
	zfs_ioctl_init_os(void)
	{
	}

	#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 __init
	-_init(void)
	+openzfs_init(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 __exit
	-_fini(void)
	+openzfs_fini(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);
	}

	#if defined(_KERNEL)
	-module_init(_init);
	-module_exit(_fini);
	+module_init(openzfs_init);
	+module_exit(openzfs_fini);
	#endif

	ZFS_MODULE_DESCRIPTION("ZFS");
	ZFS_MODULE_AUTHOR(ZFS_META_AUTHOR);
	ZFS_MODULE_LICENSE(ZFS_META_LICENSE);
	ZFS_MODULE_VERSION(ZFS_META_VERSION "-" ZFS_META_RELEASE);
	diff --git a/sys/contrib/openzfs/module/os/linux/zfs/zfs_vnops_os.c b/sys/contrib/openzfs/module/os/linux/zfs/zfs_vnops_os.c
	index 8aeed6f568cf..6f3faab04f3b 100644
	--- a/sys/contrib/openzfs/module/os/linux/zfs/zfs_vnops_os.c
	+++ b/sys/contrib/openzfs/module/os/linux/zfs/zfs_vnops_os.c
	@@ -1,4011 +1,4018 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2012, 2018 by Delphix. All rights reserved.
	* Copyright (c) 2015 by Chunwei Chen. All rights reserved.
	* Copyright 2017 Nexenta Systems, Inc.
	*/

	/* Portions Copyright 2007 Jeremy Teo */
	/* Portions Copyright 2010 Robert Milkowski */


	#include <sys/types.h>
	#include <sys/param.h>
	#include <sys/time.h>
	#include <sys/sysmacros.h>
	#include <sys/vfs.h>
	#include <sys/file.h>
	#include <sys/stat.h>
	#include <sys/kmem.h>
	#include <sys/taskq.h>
	#include <sys/uio.h>
	#include <sys/vmsystm.h>
	#include <sys/atomic.h>
	#include <sys/pathname.h>
	#include <sys/cmn_err.h>
	#include <sys/errno.h>
	#include <sys/zfs_dir.h>
	#include <sys/zfs_acl.h>
	#include <sys/zfs_ioctl.h>
	#include <sys/fs/zfs.h>
	#include <sys/dmu.h>
	#include <sys/dmu_objset.h>
	#include <sys/spa.h>
	#include <sys/txg.h>
	#include <sys/dbuf.h>
	#include <sys/zap.h>
	#include <sys/sa.h>
	#include <sys/policy.h>
	#include <sys/sunddi.h>
	#include <sys/sid.h>
	#include <sys/zfs_ctldir.h>
	#include <sys/zfs_fuid.h>
	#include <sys/zfs_quota.h>
	#include <sys/zfs_sa.h>
	#include <sys/zfs_vnops.h>
	#include <sys/zfs_rlock.h>
	#include <sys/cred.h>
	#include <sys/zpl.h>
	#include <sys/zil.h>
	#include <sys/sa_impl.h>

	/*
	* Programming rules.
	*
	* Each vnode op performs some logical unit of work. To do this, the ZPL must
	* properly lock its in-core state, create a DMU transaction, do the work,
	* record this work in the intent log (ZIL), commit the DMU transaction,
	* and wait for the intent log to commit if it is a synchronous operation.
	* Moreover, the vnode ops must work in both normal and log replay context.
	* The ordering of events is important to avoid deadlocks and references
	* to freed memory. The example below illustrates the following Big Rules:
	*
	* (1) A check must be made in each zfs thread for a mounted file system.
	* This is done avoiding races using ZFS_ENTER(zfsvfs).
	* A ZFS_EXIT(zfsvfs) is needed before all returns. Any znodes
	* must be checked with ZFS_VERIFY_ZP(zp). Both of these macros
	* can return EIO from the calling function.
	*
	* (2) zrele() should always be the last thing except for zil_commit() (if
	* necessary) and ZFS_EXIT(). This is for 3 reasons: First, if it's the
	* last reference, the vnode/znode can be freed, so the zp may point to
	* freed memory. Second, the last reference will call zfs_zinactive(),
	* which may induce a lot of work -- pushing cached pages (which acquires
	* range locks) and syncing out cached atime changes. Third,
	* zfs_zinactive() may require a new tx, which could deadlock the system
	* if you were already holding one. This deadlock occurs because the tx
	* currently being operated on prevents a txg from syncing, which
	* prevents the new tx from progressing, resulting in a deadlock. If you
	* must call zrele() within a tx, use zfs_zrele_async(). Note that iput()
	* is a synonym for zrele().
	*
	* (3) All range locks must be grabbed before calling dmu_tx_assign(),
	* as they can span dmu_tx_assign() calls.
	*
	* (4) If ZPL locks are held, pass TXG_NOWAIT as the second argument to
	* dmu_tx_assign(). This is critical because we don't want to block
	* while holding locks.
	*
	* If no ZPL locks are held (aside from ZFS_ENTER()), use TXG_WAIT. This
	* reduces lock contention and CPU usage when we must wait (note that if
	* throughput is constrained by the storage, nearly every transaction
	* must wait).
	*
	* Note, in particular, that if a lock is sometimes acquired before
	* the tx assigns, and sometimes after (e.g. z_lock), then failing
	* to use a non-blocking assign can deadlock the system. The scenario:
	*
	* Thread A has grabbed a lock before calling dmu_tx_assign().
	* Thread B is in an already-assigned tx, and blocks for this lock.
	* Thread A calls dmu_tx_assign(TXG_WAIT) and blocks in txg_wait_open()
	* forever, because the previous txg can't quiesce until B's tx commits.
	*
	* If dmu_tx_assign() returns ERESTART and zfsvfs->z_assign is TXG_NOWAIT,
	* then drop all locks, call dmu_tx_wait(), and try again. On subsequent
	* calls to dmu_tx_assign(), pass TXG_NOTHROTTLE in addition to TXG_NOWAIT,
	* to indicate that this operation has already called dmu_tx_wait().
	* This will ensure that we don't retry forever, waiting a short bit
	* each time.
	*
	* (5) If the operation succeeded, generate the intent log entry for it
	* before dropping locks. This ensures that the ordering of events
	* in the intent log matches the order in which they actually occurred.
	* During ZIL replay the zfs_log_* functions will update the sequence
	* number to indicate the zil transaction has replayed.
	*
	* (6) At the end of each vnode op, the DMU tx must always commit,
	* regardless of whether there were any errors.
	*
	* (7) After dropping all locks, invoke zil_commit(zilog, foid)
	* to ensure that synchronous semantics are provided when necessary.
	*
	* In general, this is how things should be ordered in each vnode op:
	*
	* ZFS_ENTER(zfsvfs); // exit if unmounted
	* top:
	* zfs_dirent_lock(&dl, ...) // lock directory entry (may igrab())
	* rw_enter(...); // grab any other locks you need
	* tx = dmu_tx_create(...); // get DMU tx
	* dmu_tx_hold_*(); // hold each object you might modify
	* error = dmu_tx_assign(tx, (waited ? TXG_NOTHROTTLE : 0) \| TXG_NOWAIT);
	* if (error) {
	* rw_exit(...); // drop locks
	* zfs_dirent_unlock(dl); // unlock directory entry
	* zrele(...); // release held znodes
	* if (error == ERESTART) {
	* waited = B_TRUE;
	* dmu_tx_wait(tx);
	* dmu_tx_abort(tx);
	* goto top;
	* }
	* dmu_tx_abort(tx); // abort DMU tx
	* ZFS_EXIT(zfsvfs); // finished in zfs
	* return (error); // really out of space
	* }
	* error = do_real_work(); // do whatever this VOP does
	* if (error == 0)
	* zfs_log_*(...); // on success, make ZIL entry
	* dmu_tx_commit(tx); // commit DMU tx -- error or not
	* rw_exit(...); // drop locks
	* zfs_dirent_unlock(dl); // unlock directory entry
	* zrele(...); // release held znodes
	* zil_commit(zilog, foid); // synchronous when necessary
	* ZFS_EXIT(zfsvfs); // finished in zfs
	* return (error); // done, report error
	*/

	/*
	* Virus scanning is unsupported. It would be possible to add a hook
	* here to performance the required virus scan. This could be done
	* entirely in the kernel or potentially as an update to invoke a
	* scanning utility.
	*/
	static int
	zfs_vscan(struct inode ip, cred_t cr, int async)
	{
	return (0);
	}

	/* ARGSUSED */
	int
	zfs_open(struct inode ip, int mode, int flag, cred_t cr)
	{
	znode_t *zp = ITOZ(ip);
	zfsvfs_t *zfsvfs = ITOZSB(ip);

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zp);

	/* Honor ZFS_APPENDONLY file attribute */
	if ((mode & FMODE_WRITE) && (zp->z_pflags & ZFS_APPENDONLY) &&
	((flag & O_APPEND) == 0)) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EPERM));
	}

	/* Virus scan eligible files on open */
	if (!zfs_has_ctldir(zp) && zfsvfs->z_vscan && S_ISREG(ip->i_mode) &&
	!(zp->z_pflags & ZFS_AV_QUARANTINED) && zp->z_size > 0) {
	if (zfs_vscan(ip, cr, 0) != 0) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EACCES));
	}
	}

	/* Keep a count of the synchronous opens in the znode */
	if (flag & O_SYNC)
	atomic_inc_32(&zp->z_sync_cnt);

	ZFS_EXIT(zfsvfs);
	return (0);
	}

	/* ARGSUSED */
	int
	zfs_close(struct inode ip, int flag, cred_t cr)
	{
	znode_t *zp = ITOZ(ip);
	zfsvfs_t *zfsvfs = ITOZSB(ip);

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zp);

	/* Decrement the synchronous opens in the znode */
	if (flag & O_SYNC)
	atomic_dec_32(&zp->z_sync_cnt);

	if (!zfs_has_ctldir(zp) && zfsvfs->z_vscan && S_ISREG(ip->i_mode) &&
	!(zp->z_pflags & ZFS_AV_QUARANTINED) && zp->z_size > 0)
	VERIFY(zfs_vscan(ip, cr, 1) == 0);

	ZFS_EXIT(zfsvfs);
	return (0);
	}

	#if defined(_KERNEL)
	/*
	* When a file is memory mapped, we must keep the IO data synchronized
	* between the DMU cache and the memory mapped pages. What this means:
	*
	* On Write: If we find a memory mapped page, we write to both
	* the page and the dmu buffer.
	*/
	void
	update_pages(znode_t zp, int64_t start, int len, objset_t os)
	{
	struct inode *ip = ZTOI(zp);
	struct address_space *mp = ip->i_mapping;
	struct page *pp;
	uint64_t nbytes;
	int64_t off;
	void *pb;

	off = start & (PAGE_SIZE-1);
	for (start &= PAGE_MASK; len > 0; start += PAGE_SIZE) {
	nbytes = MIN(PAGE_SIZE - off, len);

	pp = find_lock_page(mp, start >> PAGE_SHIFT);
	if (pp) {
	if (mapping_writably_mapped(mp))
	flush_dcache_page(pp);

	pb = kmap(pp);
	(void) dmu_read(os, zp->z_id, start + off, nbytes,
	pb + off, DMU_READ_PREFETCH);
	kunmap(pp);

	if (mapping_writably_mapped(mp))
	flush_dcache_page(pp);

	mark_page_accessed(pp);
	SetPageUptodate(pp);
	ClearPageError(pp);
	unlock_page(pp);
	put_page(pp);
	}

	len -= nbytes;
	off = 0;
	}
	}

	/*
	* When a file is memory mapped, we must keep the IO data synchronized
	* between the DMU cache and the memory mapped pages. What this means:
	*
	* On Read: We "read" preferentially from memory mapped pages,
	* else we default from the dmu buffer.
	*
	* NOTE: We will always "break up" the IO into PAGESIZE uiomoves when
	* the file is memory mapped.
	*/
	int
	mappedread(znode_t zp, int nbytes, zfs_uio_t uio)
	{
	struct inode *ip = ZTOI(zp);
	struct address_space *mp = ip->i_mapping;
	struct page *pp;
	int64_t start, off;
	uint64_t bytes;
	int len = nbytes;
	int error = 0;
	void *pb;

	start = uio->uio_loffset;
	off = start & (PAGE_SIZE-1);
	for (start &= PAGE_MASK; len > 0; start += PAGE_SIZE) {
	bytes = MIN(PAGE_SIZE - off, len);

	pp = find_lock_page(mp, start >> PAGE_SHIFT);
	if (pp) {
	ASSERT(PageUptodate(pp));
	unlock_page(pp);

	pb = kmap(pp);
	error = zfs_uiomove(pb + off, bytes, UIO_READ, uio);
	kunmap(pp);

	if (mapping_writably_mapped(mp))
	flush_dcache_page(pp);

	mark_page_accessed(pp);
	put_page(pp);
	} else {
	error = dmu_read_uio_dbuf(sa_get_db(zp->z_sa_hdl),
	uio, bytes);
	}

	len -= bytes;
	off = 0;
	if (error)
	break;
	}
	return (error);
	}
	#endif /* _KERNEL */

	unsigned long zfs_delete_blocks = DMU_MAX_DELETEBLKCNT;

	/*
	* Write the bytes to a file.
	*
	* IN: zp - znode of file to be written to
	* data - bytes to write
	* len - number of bytes to write
	* pos - offset to start writing at
	*
	* OUT: resid - remaining bytes to write
	*
	* RETURN: 0 if success
	* positive error code if failure. EIO is returned
	* for a short write when residp isn't provided.
	*
	* Timestamps:
	* zp - ctime\|mtime updated if byte count > 0
	*/
	int
	zfs_write_simple(znode_t zp, const void data, size_t len,
	loff_t pos, size_t *residp)
	{
	fstrans_cookie_t cookie;
	int error;

	struct iovec iov;
	iov.iov_base = (void *)data;
	iov.iov_len = len;

	zfs_uio_t uio;
	zfs_uio_iovec_init(&uio, &iov, 1, pos, UIO_SYSSPACE, len, 0);

	cookie = spl_fstrans_mark();
	error = zfs_write(zp, &uio, 0, kcred);
	spl_fstrans_unmark(cookie);

	if (error == 0) {
	if (residp != NULL)
	*residp = zfs_uio_resid(&uio);
	else if (zfs_uio_resid(&uio) != 0)
	error = SET_ERROR(EIO);
	}

	return (error);
	}

	void
	zfs_zrele_async(znode_t *zp)
	{
	struct inode *ip = ZTOI(zp);
	objset_t *os = ITOZSB(ip)->z_os;

	ASSERT(atomic_read(&ip->i_count) > 0);
	ASSERT(os != NULL);

	/*
	* If decrementing the count would put us at 0, we can't do it inline
	* here, because that would be synchronous. Instead, dispatch an iput
	* to run later.
	*
	* For more information on the dangers of a synchronous iput, see the
	* header comment of this file.
	*/
	if (!atomic_add_unless(&ip->i_count, -1, 1)) {
	VERIFY(taskq_dispatch(dsl_pool_zrele_taskq(dmu_objset_pool(os)),
	(task_func_t *)iput, ip, TQ_SLEEP) != TASKQID_INVALID);
	}
	}


	/*
	* Lookup an entry in a directory, or an extended attribute directory.
	* If it exists, return a held inode reference for it.
	*
	* IN: zdp - znode of directory to search.
	* nm - name of entry to lookup.
	* flags - LOOKUP_XATTR set if looking for an attribute.
	* cr - credentials of caller.
	* direntflags - directory lookup flags
	* realpnp - returned pathname.
	*
	* OUT: zpp - znode of located entry, NULL if not found.
	*
	* RETURN: 0 on success, error code on failure.
	*
	* Timestamps:
	* NA
	*/
	/* ARGSUSED */
	int
	zfs_lookup(znode_t zdp, char nm, znode_t *zpp, int flags, cred_t cr,
	int direntflags, pathname_t realpnp)
	{
	zfsvfs_t *zfsvfs = ZTOZSB(zdp);
	int error = 0;

	/*
	* Fast path lookup, however we must skip DNLC lookup
	* for case folding or normalizing lookups because the
	* DNLC code only stores the passed in name. This means
	* creating 'a' and removing 'A' on a case insensitive
	* file system would work, but DNLC still thinks 'a'
	* exists and won't let you create it again on the next
	* pass through fast path.
	*/
	if (!(flags & (LOOKUP_XATTR \| FIGNORECASE))) {

	if (!S_ISDIR(ZTOI(zdp)->i_mode)) {
	return (SET_ERROR(ENOTDIR));
	} else if (zdp->z_sa_hdl == NULL) {
	return (SET_ERROR(EIO));
	}

	if (nm[0] == 0 \|\| (nm[0] == '.' && nm[1] == '\0')) {
	error = zfs_fastaccesschk_execute(zdp, cr);
	if (!error) {
	*zpp = zdp;
	zhold(*zpp);
	return (0);
	}
	return (error);
	}
	}

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zdp);

	*zpp = NULL;

	if (flags & LOOKUP_XATTR) {
	/*
	* We don't allow recursive attributes..
	* Maybe someday we will.
	*/
	if (zdp->z_pflags & ZFS_XATTR) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EINVAL));
	}

	if ((error = zfs_get_xattrdir(zdp, zpp, cr, flags))) {
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	/*
	* Do we have permission to get into attribute directory?
	*/

	if ((error = zfs_zaccess(*zpp, ACE_EXECUTE, 0,
	B_FALSE, cr))) {
	zrele(*zpp);
	*zpp = NULL;
	}

	ZFS_EXIT(zfsvfs);
	return (error);
	}

	if (!S_ISDIR(ZTOI(zdp)->i_mode)) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(ENOTDIR));
	}

	/*
	* Check accessibility of directory.
	*/

	if ((error = zfs_zaccess(zdp, ACE_EXECUTE, 0, B_FALSE, cr))) {
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	if (zfsvfs->z_utf8 && u8_validate(nm, strlen(nm),
	NULL, U8_VALIDATE_ENTIRE, &error) < 0) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EILSEQ));
	}

	error = zfs_dirlook(zdp, nm, zpp, flags, direntflags, realpnp);
	if ((error == 0) && (*zpp))
	zfs_znode_update_vfs(*zpp);

	ZFS_EXIT(zfsvfs);
	return (error);
	}

	/*
	* Attempt to create a new entry in a directory. If the entry
	* already exists, truncate the file if permissible, else return
	* an error. Return the ip of the created or trunc'd file.
	*
	* IN: dzp - znode of directory to put new file entry in.
	* name - name of new file entry.
	* vap - attributes of new file.
	* excl - flag indicating exclusive or non-exclusive mode.
	* mode - mode to open file with.
	* cr - credentials of caller.
	* flag - file flag.
	* vsecp - ACL to be set
	*
	* OUT: zpp - znode of created or trunc'd entry.
	*
	* RETURN: 0 on success, error code on failure.
	*
	* Timestamps:
	* dzp - ctime\|mtime updated if new entry created
	* zp - ctime\|mtime always, atime if new
	*/

	/* ARGSUSED */
	int
	zfs_create(znode_t dzp, char name, vattr_t *vap, int excl,
	int mode, znode_t *zpp, cred_t cr, int flag, vsecattr_t *vsecp)
	{
	znode_t *zp;
	zfsvfs_t *zfsvfs = ZTOZSB(dzp);
	zilog_t *zilog;
	objset_t *os;
	zfs_dirlock_t *dl;
	dmu_tx_t *tx;
	int error;
	uid_t uid;
	gid_t gid;
	zfs_acl_ids_t acl_ids;
	boolean_t fuid_dirtied;
	boolean_t have_acl = B_FALSE;
	boolean_t waited = B_FALSE;

	/*
	* If we have an ephemeral id, ACL, or XVATTR then
	* make sure file system is at proper version
	*/

	gid = crgetgid(cr);
	uid = crgetuid(cr);

	if (zfsvfs->z_use_fuids == B_FALSE &&
	(vsecp \|\| IS_EPHEMERAL(uid) \|\| IS_EPHEMERAL(gid)))
	return (SET_ERROR(EINVAL));

	if (name == NULL)
	return (SET_ERROR(EINVAL));

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(dzp);
	os = zfsvfs->z_os;
	zilog = zfsvfs->z_log;

	if (zfsvfs->z_utf8 && u8_validate(name, strlen(name),
	NULL, U8_VALIDATE_ENTIRE, &error) < 0) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EILSEQ));
	}

	if (vap->va_mask & ATTR_XVATTR) {
	if ((error = secpolicy_xvattr((xvattr_t *)vap,
	crgetuid(cr), cr, vap->va_mode)) != 0) {
	ZFS_EXIT(zfsvfs);
	return (error);
	}
	}

	top:
	*zpp = NULL;
	if (*name == '\0') {
	/*
	* Null component name refers to the directory itself.
	*/
	zhold(dzp);
	zp = dzp;
	dl = NULL;
	error = 0;
	} else {
	/* possible igrab(zp) */
	int zflg = 0;

	if (flag & FIGNORECASE)
	zflg \|= ZCILOOK;

	error = zfs_dirent_lock(&dl, dzp, name, &zp, zflg,
	NULL, NULL);
	if (error) {
	if (have_acl)
	zfs_acl_ids_free(&acl_ids);
	if (strcmp(name, "..") == 0)
	error = SET_ERROR(EISDIR);
	ZFS_EXIT(zfsvfs);
	return (error);
	}
	}

	if (zp == NULL) {
	uint64_t txtype;
	uint64_t projid = ZFS_DEFAULT_PROJID;

	/*
	* Create a new file object and update the directory
	* to reference it.
	*/
	if ((error = zfs_zaccess(dzp, ACE_ADD_FILE, 0, B_FALSE, cr))) {
	if (have_acl)
	zfs_acl_ids_free(&acl_ids);
	goto out;
	}

	/*
	* We only support the creation of regular files in
	* extended attribute directories.
	*/

	if ((dzp->z_pflags & ZFS_XATTR) && !S_ISREG(vap->va_mode)) {
	if (have_acl)
	zfs_acl_ids_free(&acl_ids);
	error = SET_ERROR(EINVAL);
	goto out;
	}

	if (!have_acl && (error = zfs_acl_ids_create(dzp, 0, vap,
	cr, vsecp, &acl_ids)) != 0)
	goto out;
	have_acl = B_TRUE;

	if (S_ISREG(vap->va_mode) \|\| S_ISDIR(vap->va_mode))
	projid = zfs_inherit_projid(dzp);
	if (zfs_acl_ids_overquota(zfsvfs, &acl_ids, projid)) {
	zfs_acl_ids_free(&acl_ids);
	error = SET_ERROR(EDQUOT);
	goto out;
	}

	tx = dmu_tx_create(os);

	dmu_tx_hold_sa_create(tx, acl_ids.z_aclp->z_acl_bytes +
	ZFS_SA_BASE_ATTR_SIZE);

	fuid_dirtied = zfsvfs->z_fuid_dirty;
	if (fuid_dirtied)
	zfs_fuid_txhold(zfsvfs, tx);
	dmu_tx_hold_zap(tx, dzp->z_id, TRUE, name);
	dmu_tx_hold_sa(tx, dzp->z_sa_hdl, B_FALSE);
	if (!zfsvfs->z_use_sa &&
	acl_ids.z_aclp->z_acl_bytes > ZFS_ACE_SPACE) {
	dmu_tx_hold_write(tx, DMU_NEW_OBJECT,
	0, acl_ids.z_aclp->z_acl_bytes);
	}

	error = dmu_tx_assign(tx,
	(waited ? TXG_NOTHROTTLE : 0) \| TXG_NOWAIT);
	if (error) {
	zfs_dirent_unlock(dl);
	if (error == ERESTART) {
	waited = B_TRUE;
	dmu_tx_wait(tx);
	dmu_tx_abort(tx);
	goto top;
	}
	zfs_acl_ids_free(&acl_ids);
	dmu_tx_abort(tx);
	ZFS_EXIT(zfsvfs);
	return (error);
	}
	zfs_mknode(dzp, vap, tx, cr, 0, &zp, &acl_ids);

	error = zfs_link_create(dl, zp, tx, ZNEW);
	if (error != 0) {
	/*
	* Since, we failed to add the directory entry for it,
	* delete the newly created dnode.
	*/
	zfs_znode_delete(zp, tx);
	remove_inode_hash(ZTOI(zp));
	zfs_acl_ids_free(&acl_ids);
	dmu_tx_commit(tx);
	goto out;
	}

	if (fuid_dirtied)
	zfs_fuid_sync(zfsvfs, tx);

	txtype = zfs_log_create_txtype(Z_FILE, vsecp, vap);
	if (flag & FIGNORECASE)
	txtype \|= TX_CI;
	zfs_log_create(zilog, tx, txtype, dzp, zp, name,
	vsecp, acl_ids.z_fuidp, vap);
	zfs_acl_ids_free(&acl_ids);
	dmu_tx_commit(tx);
	} else {
	int aflags = (flag & O_APPEND) ? V_APPEND : 0;

	if (have_acl)
	zfs_acl_ids_free(&acl_ids);
	have_acl = B_FALSE;

	/*
	* A directory entry already exists for this name.
	*/
	/*
	* Can't truncate an existing file if in exclusive mode.
	*/
	if (excl) {
	error = SET_ERROR(EEXIST);
	goto out;
	}
	/*
	* Can't open a directory for writing.
	*/
	if (S_ISDIR(ZTOI(zp)->i_mode)) {
	error = SET_ERROR(EISDIR);
	goto out;
	}
	/*
	* Verify requested access to file.
	*/
	if (mode && (error = zfs_zaccess_rwx(zp, mode, aflags, cr))) {
	goto out;
	}

	mutex_enter(&dzp->z_lock);
	dzp->z_seq++;
	mutex_exit(&dzp->z_lock);

	/*
	* Truncate regular files if requested.
	*/
	if (S_ISREG(ZTOI(zp)->i_mode) &&
	(vap->va_mask & ATTR_SIZE) && (vap->va_size == 0)) {
	/* we can't hold any locks when calling zfs_freesp() */
	if (dl) {
	zfs_dirent_unlock(dl);
	dl = NULL;
	}
	error = zfs_freesp(zp, 0, 0, mode, TRUE);
	}
	}
	out:

	if (dl)
	zfs_dirent_unlock(dl);

	if (error) {
	if (zp)
	zrele(zp);
	} else {
	zfs_znode_update_vfs(dzp);
	zfs_znode_update_vfs(zp);
	*zpp = zp;
	}

	if (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS)
	zil_commit(zilog, 0);

	ZFS_EXIT(zfsvfs);
	return (error);
	}

	/* ARGSUSED */
	int
	zfs_tmpfile(struct inode dip, vattr_t vap, int excl,
	int mode, struct inode *ipp, cred_t cr, int flag, vsecattr_t *vsecp)
	{
	znode_t zp = NULL, dzp = ITOZ(dip);
	zfsvfs_t *zfsvfs = ITOZSB(dip);
	objset_t *os;
	dmu_tx_t *tx;
	int error;
	uid_t uid;
	gid_t gid;
	zfs_acl_ids_t acl_ids;
	uint64_t projid = ZFS_DEFAULT_PROJID;
	boolean_t fuid_dirtied;
	boolean_t have_acl = B_FALSE;
	boolean_t waited = B_FALSE;

	/*
	* If we have an ephemeral id, ACL, or XVATTR then
	* make sure file system is at proper version
	*/

	gid = crgetgid(cr);
	uid = crgetuid(cr);

	if (zfsvfs->z_use_fuids == B_FALSE &&
	(vsecp \|\| IS_EPHEMERAL(uid) \|\| IS_EPHEMERAL(gid)))
	return (SET_ERROR(EINVAL));

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(dzp);
	os = zfsvfs->z_os;

	if (vap->va_mask & ATTR_XVATTR) {
	if ((error = secpolicy_xvattr((xvattr_t *)vap,
	crgetuid(cr), cr, vap->va_mode)) != 0) {
	ZFS_EXIT(zfsvfs);
	return (error);
	}
	}

	top:
	*ipp = NULL;

	/*
	* Create a new file object and update the directory
	* to reference it.
	*/
	if ((error = zfs_zaccess(dzp, ACE_ADD_FILE, 0, B_FALSE, cr))) {
	if (have_acl)
	zfs_acl_ids_free(&acl_ids);
	goto out;
	}

	if (!have_acl && (error = zfs_acl_ids_create(dzp, 0, vap,
	cr, vsecp, &acl_ids)) != 0)
	goto out;
	have_acl = B_TRUE;

	if (S_ISREG(vap->va_mode) \|\| S_ISDIR(vap->va_mode))
	projid = zfs_inherit_projid(dzp);
	if (zfs_acl_ids_overquota(zfsvfs, &acl_ids, projid)) {
	zfs_acl_ids_free(&acl_ids);
	error = SET_ERROR(EDQUOT);
	goto out;
	}

	tx = dmu_tx_create(os);

	dmu_tx_hold_sa_create(tx, acl_ids.z_aclp->z_acl_bytes +
	ZFS_SA_BASE_ATTR_SIZE);
	dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, FALSE, NULL);

	fuid_dirtied = zfsvfs->z_fuid_dirty;
	if (fuid_dirtied)
	zfs_fuid_txhold(zfsvfs, tx);
	if (!zfsvfs->z_use_sa &&
	acl_ids.z_aclp->z_acl_bytes > ZFS_ACE_SPACE) {
	dmu_tx_hold_write(tx, DMU_NEW_OBJECT,
	0, acl_ids.z_aclp->z_acl_bytes);
	}
	error = dmu_tx_assign(tx, (waited ? TXG_NOTHROTTLE : 0) \| TXG_NOWAIT);
	if (error) {
	if (error == ERESTART) {
	waited = B_TRUE;
	dmu_tx_wait(tx);
	dmu_tx_abort(tx);
	goto top;
	}
	zfs_acl_ids_free(&acl_ids);
	dmu_tx_abort(tx);
	ZFS_EXIT(zfsvfs);
	return (error);
	}
	zfs_mknode(dzp, vap, tx, cr, IS_TMPFILE, &zp, &acl_ids);

	if (fuid_dirtied)
	zfs_fuid_sync(zfsvfs, tx);

	/* Add to unlinked set */
	zp->z_unlinked = B_TRUE;
	zfs_unlinked_add(zp, tx);
	zfs_acl_ids_free(&acl_ids);
	dmu_tx_commit(tx);
	out:

	if (error) {
	if (zp)
	zrele(zp);
	} else {
	zfs_znode_update_vfs(dzp);
	zfs_znode_update_vfs(zp);
	*ipp = ZTOI(zp);
	}

	ZFS_EXIT(zfsvfs);
	return (error);
	}

	/*
	* Remove an entry from a directory.
	*
	* IN: dzp - znode of directory to remove entry from.
	* name - name of entry to remove.
	* cr - credentials of caller.
	* flags - case flags.
	*
	* RETURN: 0 if success
	* error code if failure
	*
	* Timestamps:
	* dzp - ctime\|mtime
	* ip - ctime (if nlink > 0)
	*/

	uint64_t null_xattr = 0;

	/ARGSUSED/
	int
	zfs_remove(znode_t dzp, char name, cred_t *cr, int flags)
	{
	znode_t *zp;
	znode_t *xzp;
	zfsvfs_t *zfsvfs = ZTOZSB(dzp);
	zilog_t *zilog;
	uint64_t acl_obj, xattr_obj;
	uint64_t xattr_obj_unlinked = 0;
	uint64_t obj = 0;
	uint64_t links;
	zfs_dirlock_t *dl;
	dmu_tx_t *tx;
	boolean_t may_delete_now, delete_now = FALSE;
	boolean_t unlinked, toobig = FALSE;
	uint64_t txtype;
	pathname_t *realnmp = NULL;
	pathname_t realnm;
	int error;
	int zflg = ZEXISTS;
	boolean_t waited = B_FALSE;

	if (name == NULL)
	return (SET_ERROR(EINVAL));

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(dzp);
	zilog = zfsvfs->z_log;

	if (flags & FIGNORECASE) {
	zflg \|= ZCILOOK;
	pn_alloc(&realnm);
	realnmp = &realnm;
	}

	top:
	xattr_obj = 0;
	xzp = NULL;
	/*
	* Attempt to lock directory; fail if entry doesn't exist.
	*/
	if ((error = zfs_dirent_lock(&dl, dzp, name, &zp, zflg,
	NULL, realnmp))) {
	if (realnmp)
	pn_free(realnmp);
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	if ((error = zfs_zaccess_delete(dzp, zp, cr))) {
	goto out;
	}

	/*
	* Need to use rmdir for removing directories.
	*/
	if (S_ISDIR(ZTOI(zp)->i_mode)) {
	error = SET_ERROR(EPERM);
	goto out;
	}

	mutex_enter(&zp->z_lock);
	may_delete_now = atomic_read(&ZTOI(zp)->i_count) == 1 &&
	!(zp->z_is_mapped);
	mutex_exit(&zp->z_lock);

	/*
	* We may delete the znode now, or we may put it in the unlinked set;
	* it depends on whether we're the last link, and on whether there are
	* other holds on the inode. So we dmu_tx_hold() the right things to
	* allow for either case.
	*/
	obj = zp->z_id;
	tx = dmu_tx_create(zfsvfs->z_os);
	dmu_tx_hold_zap(tx, dzp->z_id, FALSE, name);
	dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
	zfs_sa_upgrade_txholds(tx, zp);
	zfs_sa_upgrade_txholds(tx, dzp);
	if (may_delete_now) {
	toobig = zp->z_size > zp->z_blksz * zfs_delete_blocks;
	/* if the file is too big, only hold_free a token amount */
	dmu_tx_hold_free(tx, zp->z_id, 0,
	(toobig ? DMU_MAX_ACCESS : DMU_OBJECT_END));
	}

	/* are there any extended attributes? */
	error = sa_lookup(zp->z_sa_hdl, SA_ZPL_XATTR(zfsvfs),
	&xattr_obj, sizeof (xattr_obj));
	if (error == 0 && xattr_obj) {
	error = zfs_zget(zfsvfs, xattr_obj, &xzp);
	ASSERT0(error);
	dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_TRUE);
	dmu_tx_hold_sa(tx, xzp->z_sa_hdl, B_FALSE);
	}

	mutex_enter(&zp->z_lock);
	if ((acl_obj = zfs_external_acl(zp)) != 0 && may_delete_now)
	dmu_tx_hold_free(tx, acl_obj, 0, DMU_OBJECT_END);
	mutex_exit(&zp->z_lock);

	/* charge as an update -- would be nice not to charge at all */
	dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, FALSE, NULL);

	/*
	* Mark this transaction as typically resulting in a net free of space
	*/
	dmu_tx_mark_netfree(tx);

	error = dmu_tx_assign(tx, (waited ? TXG_NOTHROTTLE : 0) \| TXG_NOWAIT);
	if (error) {
	zfs_dirent_unlock(dl);
	if (error == ERESTART) {
	waited = B_TRUE;
	dmu_tx_wait(tx);
	dmu_tx_abort(tx);
	zrele(zp);
	if (xzp)
	zrele(xzp);
	goto top;
	}
	if (realnmp)
	pn_free(realnmp);
	dmu_tx_abort(tx);
	zrele(zp);
	if (xzp)
	zrele(xzp);
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	/*
	* Remove the directory entry.
	*/
	error = zfs_link_destroy(dl, zp, tx, zflg, &unlinked);

	if (error) {
	dmu_tx_commit(tx);
	goto out;
	}

	if (unlinked) {
	/*
	* Hold z_lock so that we can make sure that the ACL obj
	* hasn't changed. Could have been deleted due to
	* zfs_sa_upgrade().
	*/
	mutex_enter(&zp->z_lock);
	(void) sa_lookup(zp->z_sa_hdl, SA_ZPL_XATTR(zfsvfs),
	&xattr_obj_unlinked, sizeof (xattr_obj_unlinked));
	delete_now = may_delete_now && !toobig &&
	atomic_read(&ZTOI(zp)->i_count) == 1 &&
	!(zp->z_is_mapped) && xattr_obj == xattr_obj_unlinked &&
	zfs_external_acl(zp) == acl_obj;
	}

	if (delete_now) {
	if (xattr_obj_unlinked) {
	ASSERT3U(ZTOI(xzp)->i_nlink, ==, 2);
	mutex_enter(&xzp->z_lock);
	xzp->z_unlinked = B_TRUE;
	clear_nlink(ZTOI(xzp));
	links = 0;
	error = sa_update(xzp->z_sa_hdl, SA_ZPL_LINKS(zfsvfs),
	&links, sizeof (links), tx);
	ASSERT3U(error, ==, 0);
	mutex_exit(&xzp->z_lock);
	zfs_unlinked_add(xzp, tx);

	if (zp->z_is_sa)
	error = sa_remove(zp->z_sa_hdl,
	SA_ZPL_XATTR(zfsvfs), tx);
	else
	error = sa_update(zp->z_sa_hdl,
	SA_ZPL_XATTR(zfsvfs), &null_xattr,
	sizeof (uint64_t), tx);
	ASSERT0(error);
	}
	/*
	* Add to the unlinked set because a new reference could be
	* taken concurrently resulting in a deferred destruction.
	*/
	zfs_unlinked_add(zp, tx);
	mutex_exit(&zp->z_lock);
	} else if (unlinked) {
	mutex_exit(&zp->z_lock);
	zfs_unlinked_add(zp, tx);
	}

	txtype = TX_REMOVE;
	if (flags & FIGNORECASE)
	txtype \|= TX_CI;
	zfs_log_remove(zilog, tx, txtype, dzp, name, obj, unlinked);

	dmu_tx_commit(tx);
	out:
	if (realnmp)
	pn_free(realnmp);

	zfs_dirent_unlock(dl);
	zfs_znode_update_vfs(dzp);
	zfs_znode_update_vfs(zp);

	if (delete_now)
	zrele(zp);
	else
	zfs_zrele_async(zp);

	if (xzp) {
	zfs_znode_update_vfs(xzp);
	zfs_zrele_async(xzp);
	}

	if (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS)
	zil_commit(zilog, 0);

	ZFS_EXIT(zfsvfs);
	return (error);
	}

	/*
	* Create a new directory and insert it into dzp using the name
	* provided. Return a pointer to the inserted directory.
	*
	* IN: dzp - znode of directory to add subdir to.
	* dirname - name of new directory.
	* vap - attributes of new directory.
	* cr - credentials of caller.
	* flags - case flags.
	* vsecp - ACL to be set
	*
	* OUT: zpp - znode of created directory.
	*
	* RETURN: 0 if success
	* error code if failure
	*
	* Timestamps:
	* dzp - ctime\|mtime updated
	* zpp - ctime\|mtime\|atime updated
	*/
	/ARGSUSED/
	int
	zfs_mkdir(znode_t dzp, char dirname, vattr_t vap, znode_t *zpp,
	cred_t cr, int flags, vsecattr_t vsecp)
	{
	znode_t *zp;
	zfsvfs_t *zfsvfs = ZTOZSB(dzp);
	zilog_t *zilog;
	zfs_dirlock_t *dl;
	uint64_t txtype;
	dmu_tx_t *tx;
	int error;
	int zf = ZNEW;
	uid_t uid;
	gid_t gid = crgetgid(cr);
	zfs_acl_ids_t acl_ids;
	boolean_t fuid_dirtied;
	boolean_t waited = B_FALSE;

	ASSERT(S_ISDIR(vap->va_mode));

	/*
	* If we have an ephemeral id, ACL, or XVATTR then
	* make sure file system is at proper version
	*/

	uid = crgetuid(cr);
	if (zfsvfs->z_use_fuids == B_FALSE &&
	(vsecp \|\| IS_EPHEMERAL(uid) \|\| IS_EPHEMERAL(gid)))
	return (SET_ERROR(EINVAL));

	if (dirname == NULL)
	return (SET_ERROR(EINVAL));

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(dzp);
	zilog = zfsvfs->z_log;

	if (dzp->z_pflags & ZFS_XATTR) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EINVAL));
	}

	if (zfsvfs->z_utf8 && u8_validate(dirname,
	strlen(dirname), NULL, U8_VALIDATE_ENTIRE, &error) < 0) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EILSEQ));
	}
	if (flags & FIGNORECASE)
	zf \|= ZCILOOK;

	if (vap->va_mask & ATTR_XVATTR) {
	if ((error = secpolicy_xvattr((xvattr_t *)vap,
	crgetuid(cr), cr, vap->va_mode)) != 0) {
	ZFS_EXIT(zfsvfs);
	return (error);
	}
	}

	if ((error = zfs_acl_ids_create(dzp, 0, vap, cr,
	vsecp, &acl_ids)) != 0) {
	ZFS_EXIT(zfsvfs);
	return (error);
	}
	/*
	* First make sure the new directory doesn't exist.
	*
	* Existence is checked first to make sure we don't return
	* EACCES instead of EEXIST which can cause some applications
	* to fail.
	*/
	top:
	*zpp = NULL;

	if ((error = zfs_dirent_lock(&dl, dzp, dirname, &zp, zf,
	NULL, NULL))) {
	zfs_acl_ids_free(&acl_ids);
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	if ((error = zfs_zaccess(dzp, ACE_ADD_SUBDIRECTORY, 0, B_FALSE, cr))) {
	zfs_acl_ids_free(&acl_ids);
	zfs_dirent_unlock(dl);
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	if (zfs_acl_ids_overquota(zfsvfs, &acl_ids, zfs_inherit_projid(dzp))) {
	zfs_acl_ids_free(&acl_ids);
	zfs_dirent_unlock(dl);
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EDQUOT));
	}

	/*
	* Add a new entry to the directory.
	*/
	tx = dmu_tx_create(zfsvfs->z_os);
	dmu_tx_hold_zap(tx, dzp->z_id, TRUE, dirname);
	dmu_tx_hold_zap(tx, DMU_NEW_OBJECT, FALSE, NULL);
	fuid_dirtied = zfsvfs->z_fuid_dirty;
	if (fuid_dirtied)
	zfs_fuid_txhold(zfsvfs, tx);
	if (!zfsvfs->z_use_sa && acl_ids.z_aclp->z_acl_bytes > ZFS_ACE_SPACE) {
	dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0,
	acl_ids.z_aclp->z_acl_bytes);
	}

	dmu_tx_hold_sa_create(tx, acl_ids.z_aclp->z_acl_bytes +
	ZFS_SA_BASE_ATTR_SIZE);

	error = dmu_tx_assign(tx, (waited ? TXG_NOTHROTTLE : 0) \| TXG_NOWAIT);
	if (error) {
	zfs_dirent_unlock(dl);
	if (error == ERESTART) {
	waited = B_TRUE;
	dmu_tx_wait(tx);
	dmu_tx_abort(tx);
	goto top;
	}
	zfs_acl_ids_free(&acl_ids);
	dmu_tx_abort(tx);
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	/*
	* Create new node.
	*/
	zfs_mknode(dzp, vap, tx, cr, 0, &zp, &acl_ids);

	/*
	* Now put new name in parent dir.
	*/
	error = zfs_link_create(dl, zp, tx, ZNEW);
	if (error != 0) {
	zfs_znode_delete(zp, tx);
	remove_inode_hash(ZTOI(zp));
	goto out;
	}

	if (fuid_dirtied)
	zfs_fuid_sync(zfsvfs, tx);

	*zpp = zp;

	txtype = zfs_log_create_txtype(Z_DIR, vsecp, vap);
	if (flags & FIGNORECASE)
	txtype \|= TX_CI;
	zfs_log_create(zilog, tx, txtype, dzp, zp, dirname, vsecp,
	acl_ids.z_fuidp, vap);

	out:
	zfs_acl_ids_free(&acl_ids);

	dmu_tx_commit(tx);

	zfs_dirent_unlock(dl);

	if (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS)
	zil_commit(zilog, 0);

	if (error != 0) {
	zrele(zp);
	} else {
	zfs_znode_update_vfs(dzp);
	zfs_znode_update_vfs(zp);
	}
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	/*
	* Remove a directory subdir entry. If the current working
	* directory is the same as the subdir to be removed, the
	* remove will fail.
	*
	* IN: dzp - znode of directory to remove from.
	* name - name of directory to be removed.
	* cwd - inode of current working directory.
	* cr - credentials of caller.
	* flags - case flags
	*
	* RETURN: 0 on success, error code on failure.
	*
	* Timestamps:
	* dzp - ctime\|mtime updated
	*/
	/ARGSUSED/
	int
	zfs_rmdir(znode_t dzp, char name, znode_t cwd, cred_t cr,
	int flags)
	{
	znode_t *zp;
	zfsvfs_t *zfsvfs = ZTOZSB(dzp);
	zilog_t *zilog;
	zfs_dirlock_t *dl;
	dmu_tx_t *tx;
	int error;
	int zflg = ZEXISTS;
	boolean_t waited = B_FALSE;

	if (name == NULL)
	return (SET_ERROR(EINVAL));

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(dzp);
	zilog = zfsvfs->z_log;

	if (flags & FIGNORECASE)
	zflg \|= ZCILOOK;
	top:
	zp = NULL;

	/*
	* Attempt to lock directory; fail if entry doesn't exist.
	*/
	if ((error = zfs_dirent_lock(&dl, dzp, name, &zp, zflg,
	NULL, NULL))) {
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	if ((error = zfs_zaccess_delete(dzp, zp, cr))) {
	goto out;
	}

	if (!S_ISDIR(ZTOI(zp)->i_mode)) {
	error = SET_ERROR(ENOTDIR);
	goto out;
	}

	if (zp == cwd) {
	error = SET_ERROR(EINVAL);
	goto out;
	}

	/*
	* Grab a lock on the directory to make sure that no one is
	* trying to add (or lookup) entries while we are removing it.
	*/
	rw_enter(&zp->z_name_lock, RW_WRITER);

	/*
	* Grab a lock on the parent pointer to make sure we play well
	* with the treewalk and directory rename code.
	*/
	rw_enter(&zp->z_parent_lock, RW_WRITER);

	tx = dmu_tx_create(zfsvfs->z_os);
	dmu_tx_hold_zap(tx, dzp->z_id, FALSE, name);
	dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
	dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, FALSE, NULL);
	zfs_sa_upgrade_txholds(tx, zp);
	zfs_sa_upgrade_txholds(tx, dzp);
	dmu_tx_mark_netfree(tx);
	error = dmu_tx_assign(tx, (waited ? TXG_NOTHROTTLE : 0) \| TXG_NOWAIT);
	if (error) {
	rw_exit(&zp->z_parent_lock);
	rw_exit(&zp->z_name_lock);
	zfs_dirent_unlock(dl);
	if (error == ERESTART) {
	waited = B_TRUE;
	dmu_tx_wait(tx);
	dmu_tx_abort(tx);
	zrele(zp);
	goto top;
	}
	dmu_tx_abort(tx);
	zrele(zp);
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	error = zfs_link_destroy(dl, zp, tx, zflg, NULL);

	if (error == 0) {
	uint64_t txtype = TX_RMDIR;
	if (flags & FIGNORECASE)
	txtype \|= TX_CI;
	zfs_log_remove(zilog, tx, txtype, dzp, name, ZFS_NO_OBJECT,
	B_FALSE);
	}

	dmu_tx_commit(tx);

	rw_exit(&zp->z_parent_lock);
	rw_exit(&zp->z_name_lock);
	out:
	zfs_dirent_unlock(dl);

	zfs_znode_update_vfs(dzp);
	zfs_znode_update_vfs(zp);
	zrele(zp);

	if (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS)
	zil_commit(zilog, 0);

	ZFS_EXIT(zfsvfs);
	return (error);
	}

	/*
	* Read directory entries from the given directory cursor position and emit
	* name and position for each entry.
	*
	* IN: ip - inode of directory to read.
	* ctx - directory entry context.
	* cr - credentials of caller.
	*
	* RETURN: 0 if success
	* error code if failure
	*
	* Timestamps:
	* ip - atime updated
	*
	* Note that the low 4 bits of the cookie returned by zap is always zero.
	* This allows us to use the low range for "special" directory entries:
	* We use 0 for '.', and 1 for '..'. If this is the root of the filesystem,
	* we use the offset 2 for the '.zfs' directory.
	*/
	/* ARGSUSED */
	int
	zfs_readdir(struct inode ip, zpl_dir_context_t ctx, cred_t *cr)
	{
	znode_t *zp = ITOZ(ip);
	zfsvfs_t *zfsvfs = ITOZSB(ip);
	objset_t *os;
	zap_cursor_t zc;
	zap_attribute_t zap;
	int error;
	uint8_t prefetch;
	uint8_t type;
	int done = 0;
	uint64_t parent;
	uint64_t offset; /* must be unsigned; checks for < 1 */

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zp);

	if ((error = sa_lookup(zp->z_sa_hdl, SA_ZPL_PARENT(zfsvfs),
	&parent, sizeof (parent))) != 0)
	goto out;

	/*
	* Quit if directory has been removed (posix)
	*/
	if (zp->z_unlinked)
	goto out;

	error = 0;
	os = zfsvfs->z_os;
	offset = ctx->pos;
	prefetch = zp->z_zn_prefetch;

	/*
	* Initialize the iterator cursor.
	*/
	if (offset <= 3) {
	/*
	* Start iteration from the beginning of the directory.
	*/
	zap_cursor_init(&zc, os, zp->z_id);
	} else {
	/*
	* The offset is a serialized cursor.
	*/
	zap_cursor_init_serialized(&zc, os, zp->z_id, offset);
	}

	/*
	* Transform to file-system independent format
	*/
	while (!done) {
	uint64_t objnum;
	/*
	* Special case `.', `..', and `.zfs'.
	*/
	if (offset == 0) {
	(void) strcpy(zap.za_name, ".");
	zap.za_normalization_conflict = 0;
	objnum = zp->z_id;
	type = DT_DIR;
	} else if (offset == 1) {
	(void) strcpy(zap.za_name, "..");
	zap.za_normalization_conflict = 0;
	objnum = parent;
	type = DT_DIR;
	} else if (offset == 2 && zfs_show_ctldir(zp)) {
	(void) strcpy(zap.za_name, ZFS_CTLDIR_NAME);
	zap.za_normalization_conflict = 0;
	objnum = ZFSCTL_INO_ROOT;
	type = DT_DIR;
	} else {
	/*
	* Grab next entry.
	*/
	if ((error = zap_cursor_retrieve(&zc, &zap))) {
	if (error == ENOENT)
	break;
	else
	goto update;
	}

	/*
	* Allow multiple entries provided the first entry is
	* the object id. Non-zpl consumers may safely make
	* use of the additional space.
	*
	* XXX: This should be a feature flag for compatibility
	*/
	if (zap.za_integer_length != 8 \|\|
	zap.za_num_integers == 0) {
	cmn_err(CE_WARN, "zap_readdir: bad directory "
	"entry, obj = %lld, offset = %lld, "
	"length = %d, num = %lld\n",
	(u_longlong_t)zp->z_id,
	(u_longlong_t)offset,
	zap.za_integer_length,
	(u_longlong_t)zap.za_num_integers);
	error = SET_ERROR(ENXIO);
	goto update;
	}

	objnum = ZFS_DIRENT_OBJ(zap.za_first_integer);
	type = ZFS_DIRENT_TYPE(zap.za_first_integer);
	}

	done = !zpl_dir_emit(ctx, zap.za_name, strlen(zap.za_name),
	objnum, type);
	if (done)
	break;

	/* Prefetch znode */
	if (prefetch) {
	dmu_prefetch(os, objnum, 0, 0, 0,
	ZIO_PRIORITY_SYNC_READ);
	}

	/*
	* Move to the next entry, fill in the previous offset.
	*/
	if (offset > 2 \|\| (offset == 2 && !zfs_show_ctldir(zp))) {
	zap_cursor_advance(&zc);
	offset = zap_cursor_serialize(&zc);
	} else {
	offset += 1;
	}
	ctx->pos = offset;
	}
	zp->z_zn_prefetch = B_FALSE; /* a lookup will re-enable pre-fetching */

	update:
	zap_cursor_fini(&zc);
	if (error == ENOENT)
	error = 0;
	out:
	ZFS_EXIT(zfsvfs);

	return (error);
	}

	/*
	* Get the basic file attributes and place them in the provided kstat
	* structure. The inode is assumed to be the authoritative source
	* for most of the attributes. However, the znode currently has the
	* authoritative atime, blksize, and block count.
	*
	* IN: ip - inode of file.
	*
	* OUT: sp - kstat values.
	*
	* RETURN: 0 (always succeeds)
	*/
	/* ARGSUSED */
	int
	zfs_getattr_fast(struct user_namespace user_ns, struct inode ip,
	struct kstat *sp)
	{
	znode_t *zp = ITOZ(ip);
	zfsvfs_t *zfsvfs = ITOZSB(ip);
	uint32_t blksize;
	u_longlong_t nblocks;

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zp);

	mutex_enter(&zp->z_lock);

	zpl_generic_fillattr(user_ns, ip, sp);
	/*
	* +1 link count for root inode with visible '.zfs' directory.
	*/
	if ((zp->z_id == zfsvfs->z_root) && zfs_show_ctldir(zp))
	if (sp->nlink < ZFS_LINK_MAX)
	sp->nlink++;

	sa_object_size(zp->z_sa_hdl, &blksize, &nblocks);
	sp->blksize = blksize;
	sp->blocks = nblocks;

	if (unlikely(zp->z_blksz == 0)) {
	/*
	* Block size hasn't been set; suggest maximal I/O transfers.
	*/
	sp->blksize = zfsvfs->z_max_blksz;
	}

	mutex_exit(&zp->z_lock);

	/*
	* Required to prevent NFS client from detecting different inode
	* numbers of snapshot root dentry before and after snapshot mount.
	*/
	if (zfsvfs->z_issnap) {
	if (ip->i_sb->s_root->d_inode == ip)
	sp->ino = ZFSCTL_INO_SNAPDIRS -
	dmu_objset_id(zfsvfs->z_os);
	}

	ZFS_EXIT(zfsvfs);

	return (0);
	}

	/*
	* For the operation of changing file's user/group/project, we need to
	* handle not only the main object that is assigned to the file directly,
	* but also the ones that are used by the file via hidden xattr directory.
	*
	* Because the xattr directory may contains many EA entries, as to it may
	* be impossible to change all of them via the transaction of changing the
	* main object's user/group/project attributes. Then we have to change them
	* via other multiple independent transactions one by one. It may be not good
	* solution, but we have no better idea yet.
	*/
	static int
	zfs_setattr_dir(znode_t *dzp)
	{
	struct inode *dxip = ZTOI(dzp);
	struct inode *xip = NULL;
	zfsvfs_t *zfsvfs = ZTOZSB(dzp);
	objset_t *os = zfsvfs->z_os;
	zap_cursor_t zc;
	zap_attribute_t zap;
	zfs_dirlock_t *dl;
	znode_t *zp = NULL;
	dmu_tx_t *tx = NULL;
	uint64_t uid, gid;
	sa_bulk_attr_t bulk[4];
	int count;
	int err;

	zap_cursor_init(&zc, os, dzp->z_id);
	while ((err = zap_cursor_retrieve(&zc, &zap)) == 0) {
	count = 0;
	if (zap.za_integer_length != 8 \|\| zap.za_num_integers != 1) {
	err = ENXIO;
	break;
	}

	err = zfs_dirent_lock(&dl, dzp, (char *)zap.za_name, &zp,
	ZEXISTS, NULL, NULL);
	if (err == ENOENT)
	goto next;
	if (err)
	break;

	xip = ZTOI(zp);
	if (KUID_TO_SUID(xip->i_uid) == KUID_TO_SUID(dxip->i_uid) &&
	KGID_TO_SGID(xip->i_gid) == KGID_TO_SGID(dxip->i_gid) &&
	zp->z_projid == dzp->z_projid)
	goto next;

	tx = dmu_tx_create(os);
	if (!(zp->z_pflags & ZFS_PROJID))
	dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_TRUE);
	else
	dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);

	err = dmu_tx_assign(tx, TXG_WAIT);
	if (err)
	break;

	mutex_enter(&dzp->z_lock);

	if (KUID_TO_SUID(xip->i_uid) != KUID_TO_SUID(dxip->i_uid)) {
	xip->i_uid = dxip->i_uid;
	uid = zfs_uid_read(dxip);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_UID(zfsvfs), NULL,
	&uid, sizeof (uid));
	}

	if (KGID_TO_SGID(xip->i_gid) != KGID_TO_SGID(dxip->i_gid)) {
	xip->i_gid = dxip->i_gid;
	gid = zfs_gid_read(dxip);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_GID(zfsvfs), NULL,
	&gid, sizeof (gid));
	}

	if (zp->z_projid != dzp->z_projid) {
	if (!(zp->z_pflags & ZFS_PROJID)) {
	zp->z_pflags \|= ZFS_PROJID;
	SA_ADD_BULK_ATTR(bulk, count,
	SA_ZPL_FLAGS(zfsvfs), NULL, &zp->z_pflags,
	sizeof (zp->z_pflags));
	}

	zp->z_projid = dzp->z_projid;
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_PROJID(zfsvfs),
	NULL, &zp->z_projid, sizeof (zp->z_projid));
	}

	mutex_exit(&dzp->z_lock);

	if (likely(count > 0)) {
	err = sa_bulk_update(zp->z_sa_hdl, bulk, count, tx);
	dmu_tx_commit(tx);
	} else {
	dmu_tx_abort(tx);
	}
	tx = NULL;
	if (err != 0 && err != ENOENT)
	break;

	next:
	if (zp) {
	zrele(zp);
	zp = NULL;
	zfs_dirent_unlock(dl);
	}
	zap_cursor_advance(&zc);
	}

	if (tx)
	dmu_tx_abort(tx);
	if (zp) {
	zrele(zp);
	zfs_dirent_unlock(dl);
	}
	zap_cursor_fini(&zc);

	return (err == ENOENT ? 0 : err);
	}

	/*
	* Set the file attributes to the values contained in the
	* vattr structure.
	*
	* IN: zp - znode of file to be modified.
	* vap - new attribute values.
	* If ATTR_XVATTR set, then optional attrs are being set
	* flags - ATTR_UTIME set if non-default time values provided.
	* - ATTR_NOACLCHECK (CIFS context only).
	* cr - credentials of caller.
	*
	* RETURN: 0 if success
	* error code if failure
	*
	* Timestamps:
	* ip - ctime updated, mtime updated if size changed.
	*/
	/* ARGSUSED */
	int
	zfs_setattr(znode_t zp, vattr_t vap, int flags, cred_t *cr)
	{
	struct inode *ip;
	zfsvfs_t *zfsvfs = ZTOZSB(zp);
	objset_t *os = zfsvfs->z_os;
	zilog_t *zilog;
	dmu_tx_t *tx;
	vattr_t oldva;
	xvattr_t *tmpxvattr;
	uint_t mask = vap->va_mask;
	uint_t saved_mask = 0;
	int trim_mask = 0;
	uint64_t new_mode;
	uint64_t new_kuid = 0, new_kgid = 0, new_uid, new_gid;
	uint64_t xattr_obj;
	uint64_t mtime[2], ctime[2], atime[2];
	uint64_t projid = ZFS_INVALID_PROJID;
	znode_t *attrzp;
	int need_policy = FALSE;
	int err, err2 = 0;
	zfs_fuid_info_t *fuidp = NULL;
	xvattr_t xvap = (xvattr_t )vap; /* vap may be an xvattr_t * */
	xoptattr_t *xoap;
	zfs_acl_t *aclp;
	boolean_t skipaclchk = (flags & ATTR_NOACLCHECK) ? B_TRUE : B_FALSE;
	boolean_t fuid_dirtied = B_FALSE;
	boolean_t handle_eadir = B_FALSE;
	sa_bulk_attr_t bulk, xattr_bulk;
	int count = 0, xattr_count = 0, bulks = 8;

	if (mask == 0)
	return (0);

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zp);
	ip = ZTOI(zp);

	/*
	* If this is a xvattr_t, then get a pointer to the structure of
	* optional attributes. If this is NULL, then we have a vattr_t.
	*/
	xoap = xva_getxoptattr(xvap);
	if (xoap != NULL && (mask & ATTR_XVATTR)) {
	if (XVA_ISSET_REQ(xvap, XAT_PROJID)) {
	if (!dmu_objset_projectquota_enabled(os) \|\|
	(!S_ISREG(ip->i_mode) && !S_ISDIR(ip->i_mode))) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(ENOTSUP));
	}

	projid = xoap->xoa_projid;
	if (unlikely(projid == ZFS_INVALID_PROJID)) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EINVAL));
	}

	if (projid == zp->z_projid && zp->z_pflags & ZFS_PROJID)
	projid = ZFS_INVALID_PROJID;
	else
	need_policy = TRUE;
	}

	if (XVA_ISSET_REQ(xvap, XAT_PROJINHERIT) &&
	(xoap->xoa_projinherit !=
	((zp->z_pflags & ZFS_PROJINHERIT) != 0)) &&
	(!dmu_objset_projectquota_enabled(os) \|\|
	(!S_ISREG(ip->i_mode) && !S_ISDIR(ip->i_mode)))) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(ENOTSUP));
	}
	}

	zilog = zfsvfs->z_log;

	/*
	* Make sure that if we have ephemeral uid/gid or xvattr specified
	* that file system is at proper version level
	*/

	if (zfsvfs->z_use_fuids == B_FALSE &&
	(((mask & ATTR_UID) && IS_EPHEMERAL(vap->va_uid)) \|\|
	((mask & ATTR_GID) && IS_EPHEMERAL(vap->va_gid)) \|\|
	(mask & ATTR_XVATTR))) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EINVAL));
	}

	if (mask & ATTR_SIZE && S_ISDIR(ip->i_mode)) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EISDIR));
	}

	if (mask & ATTR_SIZE && !S_ISREG(ip->i_mode) && !S_ISFIFO(ip->i_mode)) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EINVAL));
	}

	tmpxvattr = kmem_alloc(sizeof (xvattr_t), KM_SLEEP);
	xva_init(tmpxvattr);

	bulk = kmem_alloc(sizeof (sa_bulk_attr_t) * bulks, KM_SLEEP);
	xattr_bulk = kmem_alloc(sizeof (sa_bulk_attr_t) * bulks, KM_SLEEP);

	/*
	* Immutable files can only alter immutable bit and atime
	*/
	if ((zp->z_pflags & ZFS_IMMUTABLE) &&
	((mask & (ATTR_SIZE\|ATTR_UID\|ATTR_GID\|ATTR_MTIME\|ATTR_MODE)) \|\|
	((mask & ATTR_XVATTR) && XVA_ISSET_REQ(xvap, XAT_CREATETIME)))) {
	err = SET_ERROR(EPERM);
	goto out3;
	}

	if ((mask & ATTR_SIZE) && (zp->z_pflags & ZFS_READONLY)) {
	err = SET_ERROR(EPERM);
	goto out3;
	}

	/*
	* Verify timestamps doesn't overflow 32 bits.
	* ZFS can handle large timestamps, but 32bit syscalls can't
	* handle times greater than 2039. This check should be removed
	* once large timestamps are fully supported.
	*/
	if (mask & (ATTR_ATIME \| ATTR_MTIME)) {
	if (((mask & ATTR_ATIME) &&
	TIMESPEC_OVERFLOW(&vap->va_atime)) \|\|
	((mask & ATTR_MTIME) &&
	TIMESPEC_OVERFLOW(&vap->va_mtime))) {
	err = SET_ERROR(EOVERFLOW);
	goto out3;
	}
	}

	top:
	attrzp = NULL;
	aclp = NULL;

	/* Can this be moved to before the top label? */
	if (zfs_is_readonly(zfsvfs)) {
	err = SET_ERROR(EROFS);
	goto out3;
	}

	/*
	* First validate permissions
	*/

	if (mask & ATTR_SIZE) {
	err = zfs_zaccess(zp, ACE_WRITE_DATA, 0, skipaclchk, cr);
	if (err)
	goto out3;

	/*
	* XXX - Note, we are not providing any open
	* mode flags here (like FNDELAY), so we may
	* block if there are locks present... this
	* should be addressed in openat().
	*/
	/* XXX - would it be OK to generate a log record here? */
	err = zfs_freesp(zp, vap->va_size, 0, 0, FALSE);
	if (err)
	goto out3;
	}

	if (mask & (ATTR_ATIME\|ATTR_MTIME) \|\|
	((mask & ATTR_XVATTR) && (XVA_ISSET_REQ(xvap, XAT_HIDDEN) \|\|
	XVA_ISSET_REQ(xvap, XAT_READONLY) \|\|
	XVA_ISSET_REQ(xvap, XAT_ARCHIVE) \|\|
	XVA_ISSET_REQ(xvap, XAT_OFFLINE) \|\|
	XVA_ISSET_REQ(xvap, XAT_SPARSE) \|\|
	XVA_ISSET_REQ(xvap, XAT_CREATETIME) \|\|
	XVA_ISSET_REQ(xvap, XAT_SYSTEM)))) {
	need_policy = zfs_zaccess(zp, ACE_WRITE_ATTRIBUTES, 0,
	skipaclchk, cr);
	}

	if (mask & (ATTR_UID\|ATTR_GID)) {
	int idmask = (mask & (ATTR_UID\|ATTR_GID));
	int take_owner;
	int take_group;

	/*
	* NOTE: even if a new mode is being set,
	* we may clear S_ISUID/S_ISGID bits.
	*/

	if (!(mask & ATTR_MODE))
	vap->va_mode = zp->z_mode;

	/*
	* Take ownership or chgrp to group we are a member of
	*/

	take_owner = (mask & ATTR_UID) && (vap->va_uid == crgetuid(cr));
	take_group = (mask & ATTR_GID) &&
	zfs_groupmember(zfsvfs, vap->va_gid, cr);

	/*
	* If both ATTR_UID and ATTR_GID are set then take_owner and
	* take_group must both be set in order to allow taking
	* ownership.
	*
	* Otherwise, send the check through secpolicy_vnode_setattr()
	*
	*/

	if (((idmask == (ATTR_UID\|ATTR_GID)) &&
	take_owner && take_group) \|\|
	((idmask == ATTR_UID) && take_owner) \|\|
	((idmask == ATTR_GID) && take_group)) {
	if (zfs_zaccess(zp, ACE_WRITE_OWNER, 0,
	skipaclchk, cr) == 0) {
	/*
	* Remove setuid/setgid for non-privileged users
	*/
	(void) secpolicy_setid_clear(vap, cr);
	trim_mask = (mask & (ATTR_UID\|ATTR_GID));
	} else {
	need_policy = TRUE;
	}
	} else {
	need_policy = TRUE;
	}
	}

	mutex_enter(&zp->z_lock);
	oldva.va_mode = zp->z_mode;
	zfs_fuid_map_ids(zp, cr, &oldva.va_uid, &oldva.va_gid);
	if (mask & ATTR_XVATTR) {
	/*
	* Update xvattr mask to include only those attributes
	* that are actually changing.
	*
	* the bits will be restored prior to actually setting
	* the attributes so the caller thinks they were set.
	*/
	if (XVA_ISSET_REQ(xvap, XAT_APPENDONLY)) {
	if (xoap->xoa_appendonly !=
	((zp->z_pflags & ZFS_APPENDONLY) != 0)) {
	need_policy = TRUE;
	} else {
	XVA_CLR_REQ(xvap, XAT_APPENDONLY);
	XVA_SET_REQ(tmpxvattr, XAT_APPENDONLY);
	}
	}

	if (XVA_ISSET_REQ(xvap, XAT_PROJINHERIT)) {
	if (xoap->xoa_projinherit !=
	((zp->z_pflags & ZFS_PROJINHERIT) != 0)) {
	need_policy = TRUE;
	} else {
	XVA_CLR_REQ(xvap, XAT_PROJINHERIT);
	XVA_SET_REQ(tmpxvattr, XAT_PROJINHERIT);
	}
	}

	if (XVA_ISSET_REQ(xvap, XAT_NOUNLINK)) {
	if (xoap->xoa_nounlink !=
	((zp->z_pflags & ZFS_NOUNLINK) != 0)) {
	need_policy = TRUE;
	} else {
	XVA_CLR_REQ(xvap, XAT_NOUNLINK);
	XVA_SET_REQ(tmpxvattr, XAT_NOUNLINK);
	}
	}

	if (XVA_ISSET_REQ(xvap, XAT_IMMUTABLE)) {
	if (xoap->xoa_immutable !=
	((zp->z_pflags & ZFS_IMMUTABLE) != 0)) {
	need_policy = TRUE;
	} else {
	XVA_CLR_REQ(xvap, XAT_IMMUTABLE);
	XVA_SET_REQ(tmpxvattr, XAT_IMMUTABLE);
	}
	}

	if (XVA_ISSET_REQ(xvap, XAT_NODUMP)) {
	if (xoap->xoa_nodump !=
	((zp->z_pflags & ZFS_NODUMP) != 0)) {
	need_policy = TRUE;
	} else {
	XVA_CLR_REQ(xvap, XAT_NODUMP);
	XVA_SET_REQ(tmpxvattr, XAT_NODUMP);
	}
	}

	if (XVA_ISSET_REQ(xvap, XAT_AV_MODIFIED)) {
	if (xoap->xoa_av_modified !=
	((zp->z_pflags & ZFS_AV_MODIFIED) != 0)) {
	need_policy = TRUE;
	} else {
	XVA_CLR_REQ(xvap, XAT_AV_MODIFIED);
	XVA_SET_REQ(tmpxvattr, XAT_AV_MODIFIED);
	}
	}

	if (XVA_ISSET_REQ(xvap, XAT_AV_QUARANTINED)) {
	if ((!S_ISREG(ip->i_mode) &&
	xoap->xoa_av_quarantined) \|\|
	xoap->xoa_av_quarantined !=
	((zp->z_pflags & ZFS_AV_QUARANTINED) != 0)) {
	need_policy = TRUE;
	} else {
	XVA_CLR_REQ(xvap, XAT_AV_QUARANTINED);
	XVA_SET_REQ(tmpxvattr, XAT_AV_QUARANTINED);
	}
	}

	if (XVA_ISSET_REQ(xvap, XAT_REPARSE)) {
	mutex_exit(&zp->z_lock);
	err = SET_ERROR(EPERM);
	goto out3;
	}

	if (need_policy == FALSE &&
	(XVA_ISSET_REQ(xvap, XAT_AV_SCANSTAMP) \|\|
	XVA_ISSET_REQ(xvap, XAT_OPAQUE))) {
	need_policy = TRUE;
	}
	}

	mutex_exit(&zp->z_lock);

	if (mask & ATTR_MODE) {
	if (zfs_zaccess(zp, ACE_WRITE_ACL, 0, skipaclchk, cr) == 0) {
	err = secpolicy_setid_setsticky_clear(ip, vap,
	&oldva, cr);
	if (err)
	goto out3;

	trim_mask \|= ATTR_MODE;
	} else {
	need_policy = TRUE;
	}
	}

	if (need_policy) {
	/*
	* If trim_mask is set then take ownership
	* has been granted or write_acl is present and user
	* has the ability to modify mode. In that case remove
	* UID\|GID and or MODE from mask so that
	* secpolicy_vnode_setattr() doesn't revoke it.
	*/

	if (trim_mask) {
	saved_mask = vap->va_mask;
	vap->va_mask &= ~trim_mask;
	}
	err = secpolicy_vnode_setattr(cr, ip, vap, &oldva, flags,
	(int ()(void , int, cred_t *))zfs_zaccess_unix, zp);
	if (err)
	goto out3;

	if (trim_mask)
	vap->va_mask \|= saved_mask;
	}

	/*
	* secpolicy_vnode_setattr, or take ownership may have
	* changed va_mask
	*/
	mask = vap->va_mask;

	if ((mask & (ATTR_UID \| ATTR_GID)) \|\| projid != ZFS_INVALID_PROJID) {
	handle_eadir = B_TRUE;
	err = sa_lookup(zp->z_sa_hdl, SA_ZPL_XATTR(zfsvfs),
	&xattr_obj, sizeof (xattr_obj));

	if (err == 0 && xattr_obj) {
	err = zfs_zget(ZTOZSB(zp), xattr_obj, &attrzp);
	if (err)
	goto out2;
	}
	if (mask & ATTR_UID) {
	new_kuid = zfs_fuid_create(zfsvfs,
	(uint64_t)vap->va_uid, cr, ZFS_OWNER, &fuidp);
	if (new_kuid != KUID_TO_SUID(ZTOI(zp)->i_uid) &&
	zfs_id_overquota(zfsvfs, DMU_USERUSED_OBJECT,
	new_kuid)) {
	if (attrzp)
	zrele(attrzp);
	err = SET_ERROR(EDQUOT);
	goto out2;
	}
	}

	if (mask & ATTR_GID) {
	new_kgid = zfs_fuid_create(zfsvfs,
	(uint64_t)vap->va_gid, cr, ZFS_GROUP, &fuidp);
	if (new_kgid != KGID_TO_SGID(ZTOI(zp)->i_gid) &&
	zfs_id_overquota(zfsvfs, DMU_GROUPUSED_OBJECT,
	new_kgid)) {
	if (attrzp)
	zrele(attrzp);
	err = SET_ERROR(EDQUOT);
	goto out2;
	}
	}

	if (projid != ZFS_INVALID_PROJID &&
	zfs_id_overquota(zfsvfs, DMU_PROJECTUSED_OBJECT, projid)) {
	if (attrzp)
	zrele(attrzp);
	err = EDQUOT;
	goto out2;
	}
	}
	tx = dmu_tx_create(os);

	if (mask & ATTR_MODE) {
	uint64_t pmode = zp->z_mode;
	uint64_t acl_obj;
	new_mode = (pmode & S_IFMT) \| (vap->va_mode & ~S_IFMT);

	if (ZTOZSB(zp)->z_acl_mode == ZFS_ACL_RESTRICTED &&
	!(zp->z_pflags & ZFS_ACL_TRIVIAL)) {
	err = EPERM;
	goto out;
	}

	if ((err = zfs_acl_chmod_setattr(zp, &aclp, new_mode)))
	goto out;

	mutex_enter(&zp->z_lock);
	if (!zp->z_is_sa && ((acl_obj = zfs_external_acl(zp)) != 0)) {
	/*
	* Are we upgrading ACL from old V0 format
	* to V1 format?
	*/
	if (zfsvfs->z_version >= ZPL_VERSION_FUID &&
	zfs_znode_acl_version(zp) ==
	ZFS_ACL_VERSION_INITIAL) {
	dmu_tx_hold_free(tx, acl_obj, 0,
	DMU_OBJECT_END);
	dmu_tx_hold_write(tx, DMU_NEW_OBJECT,
	0, aclp->z_acl_bytes);
	} else {
	dmu_tx_hold_write(tx, acl_obj, 0,
	aclp->z_acl_bytes);
	}
	} else if (!zp->z_is_sa && aclp->z_acl_bytes > ZFS_ACE_SPACE) {
	dmu_tx_hold_write(tx, DMU_NEW_OBJECT,
	0, aclp->z_acl_bytes);
	}
	mutex_exit(&zp->z_lock);
	dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_TRUE);
	} else {
	if (((mask & ATTR_XVATTR) &&
	XVA_ISSET_REQ(xvap, XAT_AV_SCANSTAMP)) \|\|
	(projid != ZFS_INVALID_PROJID &&
	!(zp->z_pflags & ZFS_PROJID)))
	dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_TRUE);
	else
	dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
	}

	if (attrzp) {
	dmu_tx_hold_sa(tx, attrzp->z_sa_hdl, B_FALSE);
	}

	fuid_dirtied = zfsvfs->z_fuid_dirty;
	if (fuid_dirtied)
	zfs_fuid_txhold(zfsvfs, tx);

	zfs_sa_upgrade_txholds(tx, zp);

	err = dmu_tx_assign(tx, TXG_WAIT);
	if (err)
	goto out;

	count = 0;
	/*
	* Set each attribute requested.
	* We group settings according to the locks they need to acquire.
	*
	* Note: you cannot set ctime directly, although it will be
	* updated as a side-effect of calling this function.
	*/

	if (projid != ZFS_INVALID_PROJID && !(zp->z_pflags & ZFS_PROJID)) {
	/*
	* For the existed object that is upgraded from old system,
	* its on-disk layout has no slot for the project ID attribute.
	* But quota accounting logic needs to access related slots by
	* offset directly. So we need to adjust old objects' layout
	* to make the project ID to some unified and fixed offset.
	*/
	if (attrzp)
	err = sa_add_projid(attrzp->z_sa_hdl, tx, projid);
	if (err == 0)
	err = sa_add_projid(zp->z_sa_hdl, tx, projid);

	if (unlikely(err == EEXIST))
	err = 0;
	else if (err != 0)
	goto out;
	else
	projid = ZFS_INVALID_PROJID;
	}

	if (mask & (ATTR_UID\|ATTR_GID\|ATTR_MODE))
	mutex_enter(&zp->z_acl_lock);
	mutex_enter(&zp->z_lock);

	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zfsvfs), NULL,
	&zp->z_pflags, sizeof (zp->z_pflags));

	if (attrzp) {
	if (mask & (ATTR_UID\|ATTR_GID\|ATTR_MODE))
	mutex_enter(&attrzp->z_acl_lock);
	mutex_enter(&attrzp->z_lock);
	SA_ADD_BULK_ATTR(xattr_bulk, xattr_count,
	SA_ZPL_FLAGS(zfsvfs), NULL, &attrzp->z_pflags,
	sizeof (attrzp->z_pflags));
	if (projid != ZFS_INVALID_PROJID) {
	attrzp->z_projid = projid;
	SA_ADD_BULK_ATTR(xattr_bulk, xattr_count,
	SA_ZPL_PROJID(zfsvfs), NULL, &attrzp->z_projid,
	sizeof (attrzp->z_projid));
	}
	}

	if (mask & (ATTR_UID\|ATTR_GID)) {

	if (mask & ATTR_UID) {
	ZTOI(zp)->i_uid = SUID_TO_KUID(new_kuid);
	new_uid = zfs_uid_read(ZTOI(zp));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_UID(zfsvfs), NULL,
	&new_uid, sizeof (new_uid));
	if (attrzp) {
	SA_ADD_BULK_ATTR(xattr_bulk, xattr_count,
	SA_ZPL_UID(zfsvfs), NULL, &new_uid,
	sizeof (new_uid));
	ZTOI(attrzp)->i_uid = SUID_TO_KUID(new_uid);
	}
	}

	if (mask & ATTR_GID) {
	ZTOI(zp)->i_gid = SGID_TO_KGID(new_kgid);
	new_gid = zfs_gid_read(ZTOI(zp));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_GID(zfsvfs),
	NULL, &new_gid, sizeof (new_gid));
	if (attrzp) {
	SA_ADD_BULK_ATTR(xattr_bulk, xattr_count,
	SA_ZPL_GID(zfsvfs), NULL, &new_gid,
	sizeof (new_gid));
	ZTOI(attrzp)->i_gid = SGID_TO_KGID(new_kgid);
	}
	}
	if (!(mask & ATTR_MODE)) {
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MODE(zfsvfs),
	NULL, &new_mode, sizeof (new_mode));
	new_mode = zp->z_mode;
	}
	err = zfs_acl_chown_setattr(zp);
	ASSERT(err == 0);
	if (attrzp) {
	err = zfs_acl_chown_setattr(attrzp);
	ASSERT(err == 0);
	}
	}

	if (mask & ATTR_MODE) {
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MODE(zfsvfs), NULL,
	&new_mode, sizeof (new_mode));
	zp->z_mode = ZTOI(zp)->i_mode = new_mode;
	ASSERT3P(aclp, !=, NULL);
	err = zfs_aclset_common(zp, aclp, cr, tx);
	ASSERT0(err);
	if (zp->z_acl_cached)
	zfs_acl_free(zp->z_acl_cached);
	zp->z_acl_cached = aclp;
	aclp = NULL;
	}

	if ((mask & ATTR_ATIME) \|\| zp->z_atime_dirty) {
	zp->z_atime_dirty = B_FALSE;
	ZFS_TIME_ENCODE(&ip->i_atime, atime);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_ATIME(zfsvfs), NULL,
	&atime, sizeof (atime));
	}

	if (mask & (ATTR_MTIME \| ATTR_SIZE)) {
	ZFS_TIME_ENCODE(&vap->va_mtime, mtime);
	ZTOI(zp)->i_mtime = zpl_inode_timestamp_truncate(
	vap->va_mtime, ZTOI(zp));

	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zfsvfs), NULL,
	mtime, sizeof (mtime));
	}

	if (mask & (ATTR_CTIME \| ATTR_SIZE)) {
	ZFS_TIME_ENCODE(&vap->va_ctime, ctime);
	ZTOI(zp)->i_ctime = zpl_inode_timestamp_truncate(vap->va_ctime,
	ZTOI(zp));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs), NULL,
	ctime, sizeof (ctime));
	}

	if (projid != ZFS_INVALID_PROJID) {
	zp->z_projid = projid;
	SA_ADD_BULK_ATTR(bulk, count,
	SA_ZPL_PROJID(zfsvfs), NULL, &zp->z_projid,
	sizeof (zp->z_projid));
	}

	if (attrzp && mask) {
	SA_ADD_BULK_ATTR(xattr_bulk, xattr_count,
	SA_ZPL_CTIME(zfsvfs), NULL, &ctime,
	sizeof (ctime));
	}

	/*
	* Do this after setting timestamps to prevent timestamp
	* update from toggling bit
	*/

	if (xoap && (mask & ATTR_XVATTR)) {

	/*
	* restore trimmed off masks
	* so that return masks can be set for caller.
	*/

	if (XVA_ISSET_REQ(tmpxvattr, XAT_APPENDONLY)) {
	XVA_SET_REQ(xvap, XAT_APPENDONLY);
	}
	if (XVA_ISSET_REQ(tmpxvattr, XAT_NOUNLINK)) {
	XVA_SET_REQ(xvap, XAT_NOUNLINK);
	}
	if (XVA_ISSET_REQ(tmpxvattr, XAT_IMMUTABLE)) {
	XVA_SET_REQ(xvap, XAT_IMMUTABLE);
	}
	if (XVA_ISSET_REQ(tmpxvattr, XAT_NODUMP)) {
	XVA_SET_REQ(xvap, XAT_NODUMP);
	}
	if (XVA_ISSET_REQ(tmpxvattr, XAT_AV_MODIFIED)) {
	XVA_SET_REQ(xvap, XAT_AV_MODIFIED);
	}
	if (XVA_ISSET_REQ(tmpxvattr, XAT_AV_QUARANTINED)) {
	XVA_SET_REQ(xvap, XAT_AV_QUARANTINED);
	}
	if (XVA_ISSET_REQ(tmpxvattr, XAT_PROJINHERIT)) {
	XVA_SET_REQ(xvap, XAT_PROJINHERIT);
	}

	if (XVA_ISSET_REQ(xvap, XAT_AV_SCANSTAMP))
	ASSERT(S_ISREG(ip->i_mode));

	zfs_xvattr_set(zp, xvap, tx);
	}

	if (fuid_dirtied)
	zfs_fuid_sync(zfsvfs, tx);

	if (mask != 0)
	zfs_log_setattr(zilog, tx, TX_SETATTR, zp, vap, mask, fuidp);

	mutex_exit(&zp->z_lock);
	if (mask & (ATTR_UID\|ATTR_GID\|ATTR_MODE))
	mutex_exit(&zp->z_acl_lock);

	if (attrzp) {
	if (mask & (ATTR_UID\|ATTR_GID\|ATTR_MODE))
	mutex_exit(&attrzp->z_acl_lock);
	mutex_exit(&attrzp->z_lock);
	}
	out:
	if (err == 0 && xattr_count > 0) {
	err2 = sa_bulk_update(attrzp->z_sa_hdl, xattr_bulk,
	xattr_count, tx);
	ASSERT(err2 == 0);
	}

	if (aclp)
	zfs_acl_free(aclp);

	if (fuidp) {
	zfs_fuid_info_free(fuidp);
	fuidp = NULL;
	}

	if (err) {
	dmu_tx_abort(tx);
	if (attrzp)
	zrele(attrzp);
	if (err == ERESTART)
	goto top;
	} else {
	if (count > 0)
	err2 = sa_bulk_update(zp->z_sa_hdl, bulk, count, tx);
	dmu_tx_commit(tx);
	if (attrzp) {
	if (err2 == 0 && handle_eadir)
	err2 = zfs_setattr_dir(attrzp);
	zrele(attrzp);
	}
	zfs_znode_update_vfs(zp);
	}

	out2:
	if (os->os_sync == ZFS_SYNC_ALWAYS)
	zil_commit(zilog, 0);

	out3:
	kmem_free(xattr_bulk, sizeof (sa_bulk_attr_t) * bulks);
	kmem_free(bulk, sizeof (sa_bulk_attr_t) * bulks);
	kmem_free(tmpxvattr, sizeof (xvattr_t));
	ZFS_EXIT(zfsvfs);
	return (err);
	}

	typedef struct zfs_zlock {
	krwlock_t zl_rwlock; / lock we acquired */
	znode_t zl_znode; / znode we held */
	struct zfs_zlock zl_next; / next in list */
	} zfs_zlock_t;

	/*
	* Drop locks and release vnodes that were held by zfs_rename_lock().
	*/
	static void
	zfs_rename_unlock(zfs_zlock_t **zlpp)
	{
	zfs_zlock_t *zl;

	while ((zl = *zlpp) != NULL) {
	if (zl->zl_znode != NULL)
	zfs_zrele_async(zl->zl_znode);
	rw_exit(zl->zl_rwlock);
	*zlpp = zl->zl_next;
	kmem_free(zl, sizeof (*zl));
	}
	}

	/*
	* Search back through the directory tree, using the ".." entries.
	* Lock each directory in the chain to prevent concurrent renames.
	* Fail any attempt to move a directory into one of its own descendants.
	* XXX - z_parent_lock can overlap with map or grow locks
	*/
	static int
	zfs_rename_lock(znode_t szp, znode_t tdzp, znode_t sdzp, zfs_zlock_t *zlpp)
	{
	zfs_zlock_t *zl;
	znode_t *zp = tdzp;
	uint64_t rootid = ZTOZSB(zp)->z_root;
	uint64_t oidp = zp->z_id;
	krwlock_t *rwlp = &szp->z_parent_lock;
	krw_t rw = RW_WRITER;

	/*
	* First pass write-locks szp and compares to zp->z_id.
	* Later passes read-lock zp and compare to zp->z_parent.
	*/
	do {
	if (!rw_tryenter(rwlp, rw)) {
	/*
	* Another thread is renaming in this path.
	* Note that if we are a WRITER, we don't have any
	* parent_locks held yet.
	*/
	if (rw == RW_READER && zp->z_id > szp->z_id) {
	/*
	* Drop our locks and restart
	*/
	zfs_rename_unlock(&zl);
	*zlpp = NULL;
	zp = tdzp;
	oidp = zp->z_id;
	rwlp = &szp->z_parent_lock;
	rw = RW_WRITER;
	continue;
	} else {
	/*
	* Wait for other thread to drop its locks
	*/
	rw_enter(rwlp, rw);
	}
	}

	zl = kmem_alloc(sizeof (*zl), KM_SLEEP);
	zl->zl_rwlock = rwlp;
	zl->zl_znode = NULL;
	zl->zl_next = *zlpp;
	*zlpp = zl;

	if (oidp == szp->z_id) /* We're a descendant of szp */
	return (SET_ERROR(EINVAL));

	if (oidp == rootid) /* We've hit the top */
	return (0);

	if (rw == RW_READER) { /* i.e. not the first pass */
	int error = zfs_zget(ZTOZSB(zp), oidp, &zp);
	if (error)
	return (error);
	zl->zl_znode = zp;
	}
	(void) sa_lookup(zp->z_sa_hdl, SA_ZPL_PARENT(ZTOZSB(zp)),
	&oidp, sizeof (oidp));
	rwlp = &zp->z_parent_lock;
	rw = RW_READER;

	} while (zp->z_id != sdzp->z_id);

	return (0);
	}

	/*
	* Move an entry from the provided source directory to the target
	* directory. Change the entry name as indicated.
	*
	* IN: sdzp - Source directory containing the "old entry".
	* snm - Old entry name.
	* tdzp - Target directory to contain the "new entry".
	* tnm - New entry name.
	* cr - credentials of caller.
	* flags - case flags
	*
	* RETURN: 0 on success, error code on failure.
	*
	* Timestamps:
	* sdzp,tdzp - ctime\|mtime updated
	*/
	/ARGSUSED/
	int
	zfs_rename(znode_t sdzp, char snm, znode_t tdzp, char tnm,
	cred_t *cr, int flags)
	{
	znode_t szp, tzp;
	zfsvfs_t *zfsvfs = ZTOZSB(sdzp);
	zilog_t *zilog;
	zfs_dirlock_t sdl, tdl;
	dmu_tx_t *tx;
	zfs_zlock_t *zl;
	int cmp, serr, terr;
	int error = 0;
	int zflg = 0;
	boolean_t waited = B_FALSE;

	if (snm == NULL \|\| tnm == NULL)
	return (SET_ERROR(EINVAL));

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(sdzp);
	zilog = zfsvfs->z_log;

	ZFS_VERIFY_ZP(tdzp);

	/*
	* We check i_sb because snapshots and the ctldir must have different
	* super blocks.
	*/
	if (ZTOI(tdzp)->i_sb != ZTOI(sdzp)->i_sb \|\|
	zfsctl_is_node(ZTOI(tdzp))) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EXDEV));
	}

	if (zfsvfs->z_utf8 && u8_validate(tnm,
	strlen(tnm), NULL, U8_VALIDATE_ENTIRE, &error) < 0) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EILSEQ));
	}

	if (flags & FIGNORECASE)
	zflg \|= ZCILOOK;

	top:
	szp = NULL;
	tzp = NULL;
	zl = NULL;

	/*
	* This is to prevent the creation of links into attribute space
	* by renaming a linked file into/outof an attribute directory.
	* See the comment in zfs_link() for why this is considered bad.
	*/
	if ((tdzp->z_pflags & ZFS_XATTR) != (sdzp->z_pflags & ZFS_XATTR)) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EINVAL));
	}

	/*
	* Lock source and target directory entries. To prevent deadlock,
	* a lock ordering must be defined. We lock the directory with
	* the smallest object id first, or if it's a tie, the one with
	* the lexically first name.
	*/
	if (sdzp->z_id < tdzp->z_id) {
	cmp = -1;
	} else if (sdzp->z_id > tdzp->z_id) {
	cmp = 1;
	} else {
	/*
	* First compare the two name arguments without
	* considering any case folding.
	*/
	int nofold = (zfsvfs->z_norm & ~U8_TEXTPREP_TOUPPER);

	cmp = u8_strcmp(snm, tnm, 0, nofold, U8_UNICODE_LATEST, &error);
	ASSERT(error == 0 \|\| !zfsvfs->z_utf8);
	if (cmp == 0) {
	/*
	* POSIX: "If the old argument and the new argument
	* both refer to links to the same existing file,
	* the rename() function shall return successfully
	* and perform no other action."
	*/
	ZFS_EXIT(zfsvfs);
	return (0);
	}
	/*
	* If the file system is case-folding, then we may
	* have some more checking to do. A case-folding file
	* system is either supporting mixed case sensitivity
	* access or is completely case-insensitive. Note
	* that the file system is always case preserving.
	*
	* In mixed sensitivity mode case sensitive behavior
	* is the default. FIGNORECASE must be used to
	* explicitly request case insensitive behavior.
	*
	* If the source and target names provided differ only
	* by case (e.g., a request to rename 'tim' to 'Tim'),
	* we will treat this as a special case in the
	* case-insensitive mode: as long as the source name
	* is an exact match, we will allow this to proceed as
	* a name-change request.
	*/
	if ((zfsvfs->z_case == ZFS_CASE_INSENSITIVE \|\|
	(zfsvfs->z_case == ZFS_CASE_MIXED &&
	flags & FIGNORECASE)) &&
	u8_strcmp(snm, tnm, 0, zfsvfs->z_norm, U8_UNICODE_LATEST,
	&error) == 0) {
	/*
	* case preserving rename request, require exact
	* name matches
	*/
	zflg \|= ZCIEXACT;
	zflg &= ~ZCILOOK;
	}
	}

	/*
	* If the source and destination directories are the same, we should
	* grab the z_name_lock of that directory only once.
	*/
	if (sdzp == tdzp) {
	zflg \|= ZHAVELOCK;
	rw_enter(&sdzp->z_name_lock, RW_READER);
	}

	if (cmp < 0) {
	serr = zfs_dirent_lock(&sdl, sdzp, snm, &szp,
	ZEXISTS \| zflg, NULL, NULL);
	terr = zfs_dirent_lock(&tdl,
	tdzp, tnm, &tzp, ZRENAMING \| zflg, NULL, NULL);
	} else {
	terr = zfs_dirent_lock(&tdl,
	tdzp, tnm, &tzp, zflg, NULL, NULL);
	serr = zfs_dirent_lock(&sdl,
	sdzp, snm, &szp, ZEXISTS \| ZRENAMING \| zflg,
	NULL, NULL);
	}

	if (serr) {
	/*
	* Source entry invalid or not there.
	*/
	if (!terr) {
	zfs_dirent_unlock(tdl);
	if (tzp)
	zrele(tzp);
	}

	if (sdzp == tdzp)
	rw_exit(&sdzp->z_name_lock);

	if (strcmp(snm, "..") == 0)
	serr = EINVAL;
	ZFS_EXIT(zfsvfs);
	return (serr);
	}
	if (terr) {
	zfs_dirent_unlock(sdl);
	zrele(szp);

	if (sdzp == tdzp)
	rw_exit(&sdzp->z_name_lock);

	if (strcmp(tnm, "..") == 0)
	terr = EINVAL;
	ZFS_EXIT(zfsvfs);
	return (terr);
	}

	/*
	* If we are using project inheritance, means if the directory has
	* ZFS_PROJINHERIT set, then its descendant directories will inherit
	* not only the project ID, but also the ZFS_PROJINHERIT flag. Under
	* such case, we only allow renames into our tree when the project
	* IDs are the same.
	*/
	if (tdzp->z_pflags & ZFS_PROJINHERIT &&
	tdzp->z_projid != szp->z_projid) {
	error = SET_ERROR(EXDEV);
	goto out;
	}

	/*
	* Must have write access at the source to remove the old entry
	* and write access at the target to create the new entry.
	* Note that if target and source are the same, this can be
	* done in a single check.
	*/

	if ((error = zfs_zaccess_rename(sdzp, szp, tdzp, tzp, cr)))
	goto out;

	if (S_ISDIR(ZTOI(szp)->i_mode)) {
	/*
	* Check to make sure rename is valid.
	* Can't do a move like this: /usr/a/b to /usr/a/b/c/d
	*/
	if ((error = zfs_rename_lock(szp, tdzp, sdzp, &zl)))
	goto out;
	}

	/*
	* Does target exist?
	*/
	if (tzp) {
	/*
	* Source and target must be the same type.
	*/
	if (S_ISDIR(ZTOI(szp)->i_mode)) {
	if (!S_ISDIR(ZTOI(tzp)->i_mode)) {
	error = SET_ERROR(ENOTDIR);
	goto out;
	}
	} else {
	if (S_ISDIR(ZTOI(tzp)->i_mode)) {
	error = SET_ERROR(EISDIR);
	goto out;
	}
	}
	/*
	* POSIX dictates that when the source and target
	* entries refer to the same file object, rename
	* must do nothing and exit without error.
	*/
	if (szp->z_id == tzp->z_id) {
	error = 0;
	goto out;
	}
	}

	tx = dmu_tx_create(zfsvfs->z_os);
	dmu_tx_hold_sa(tx, szp->z_sa_hdl, B_FALSE);
	dmu_tx_hold_sa(tx, sdzp->z_sa_hdl, B_FALSE);
	dmu_tx_hold_zap(tx, sdzp->z_id, FALSE, snm);
	dmu_tx_hold_zap(tx, tdzp->z_id, TRUE, tnm);
	if (sdzp != tdzp) {
	dmu_tx_hold_sa(tx, tdzp->z_sa_hdl, B_FALSE);
	zfs_sa_upgrade_txholds(tx, tdzp);
	}
	if (tzp) {
	dmu_tx_hold_sa(tx, tzp->z_sa_hdl, B_FALSE);
	zfs_sa_upgrade_txholds(tx, tzp);
	}

	zfs_sa_upgrade_txholds(tx, szp);
	dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, FALSE, NULL);
	error = dmu_tx_assign(tx, (waited ? TXG_NOTHROTTLE : 0) \| TXG_NOWAIT);
	if (error) {
	if (zl != NULL)
	zfs_rename_unlock(&zl);
	zfs_dirent_unlock(sdl);
	zfs_dirent_unlock(tdl);

	if (sdzp == tdzp)
	rw_exit(&sdzp->z_name_lock);

	if (error == ERESTART) {
	waited = B_TRUE;
	dmu_tx_wait(tx);
	dmu_tx_abort(tx);
	zrele(szp);
	if (tzp)
	zrele(tzp);
	goto top;
	}
	dmu_tx_abort(tx);
	zrele(szp);
	if (tzp)
	zrele(tzp);
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	if (tzp) /* Attempt to remove the existing target */
	error = zfs_link_destroy(tdl, tzp, tx, zflg, NULL);

	if (error == 0) {
	error = zfs_link_create(tdl, szp, tx, ZRENAMING);
	if (error == 0) {
	szp->z_pflags \|= ZFS_AV_MODIFIED;
	if (tdzp->z_pflags & ZFS_PROJINHERIT)
	szp->z_pflags \|= ZFS_PROJINHERIT;

	error = sa_update(szp->z_sa_hdl, SA_ZPL_FLAGS(zfsvfs),
	(void *)&szp->z_pflags, sizeof (uint64_t), tx);
	ASSERT0(error);

	error = zfs_link_destroy(sdl, szp, tx, ZRENAMING, NULL);
	if (error == 0) {
	zfs_log_rename(zilog, tx, TX_RENAME \|
	(flags & FIGNORECASE ? TX_CI : 0), sdzp,
	sdl->dl_name, tdzp, tdl->dl_name, szp);
	} else {
	/*
	* At this point, we have successfully created
	* the target name, but have failed to remove
	* the source name. Since the create was done
	* with the ZRENAMING flag, there are
	* complications; for one, the link count is
	* wrong. The easiest way to deal with this
	* is to remove the newly created target, and
	* return the original error. This must
	* succeed; fortunately, it is very unlikely to
	* fail, since we just created it.
	*/
	VERIFY3U(zfs_link_destroy(tdl, szp, tx,
	ZRENAMING, NULL), ==, 0);
	}
	} else {
	/*
	* If we had removed the existing target, subsequent
	* call to zfs_link_create() to add back the same entry
	* but, the new dnode (szp) should not fail.
	*/
	ASSERT(tzp == NULL);
	}
	}

	dmu_tx_commit(tx);
	out:
	if (zl != NULL)
	zfs_rename_unlock(&zl);

	zfs_dirent_unlock(sdl);
	zfs_dirent_unlock(tdl);

	zfs_znode_update_vfs(sdzp);
	if (sdzp == tdzp)
	rw_exit(&sdzp->z_name_lock);

	if (sdzp != tdzp)
	zfs_znode_update_vfs(tdzp);

	zfs_znode_update_vfs(szp);
	zrele(szp);
	if (tzp) {
	zfs_znode_update_vfs(tzp);
	zrele(tzp);
	}

	if (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS)
	zil_commit(zilog, 0);

	ZFS_EXIT(zfsvfs);
	return (error);
	}

	/*
	* Insert the indicated symbolic reference entry into the directory.
	*
	* IN: dzp - Directory to contain new symbolic link.
	* name - Name of directory entry in dip.
	* vap - Attributes of new entry.
	* link - Name for new symlink entry.
	* cr - credentials of caller.
	* flags - case flags
	*
	* OUT: zpp - Znode for new symbolic link.
	*
	* RETURN: 0 on success, error code on failure.
	*
	* Timestamps:
	* dip - ctime\|mtime updated
	*/
	/ARGSUSED/
	int
	zfs_symlink(znode_t dzp, char name, vattr_t vap, char link,
	znode_t *zpp, cred_t cr, int flags)
	{
	znode_t *zp;
	zfs_dirlock_t *dl;
	dmu_tx_t *tx;
	zfsvfs_t *zfsvfs = ZTOZSB(dzp);
	zilog_t *zilog;
	uint64_t len = strlen(link);
	int error;
	int zflg = ZNEW;
	zfs_acl_ids_t acl_ids;
	boolean_t fuid_dirtied;
	uint64_t txtype = TX_SYMLINK;
	boolean_t waited = B_FALSE;

	ASSERT(S_ISLNK(vap->va_mode));

	if (name == NULL)
	return (SET_ERROR(EINVAL));

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(dzp);
	zilog = zfsvfs->z_log;

	if (zfsvfs->z_utf8 && u8_validate(name, strlen(name),
	NULL, U8_VALIDATE_ENTIRE, &error) < 0) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EILSEQ));
	}
	if (flags & FIGNORECASE)
	zflg \|= ZCILOOK;

	if (len > MAXPATHLEN) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(ENAMETOOLONG));
	}

	if ((error = zfs_acl_ids_create(dzp, 0,
	vap, cr, NULL, &acl_ids)) != 0) {
	ZFS_EXIT(zfsvfs);
	return (error);
	}
	top:
	*zpp = NULL;

	/*
	* Attempt to lock directory; fail if entry already exists.
	*/
	error = zfs_dirent_lock(&dl, dzp, name, &zp, zflg, NULL, NULL);
	if (error) {
	zfs_acl_ids_free(&acl_ids);
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	if ((error = zfs_zaccess(dzp, ACE_ADD_FILE, 0, B_FALSE, cr))) {
	zfs_acl_ids_free(&acl_ids);
	zfs_dirent_unlock(dl);
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	if (zfs_acl_ids_overquota(zfsvfs, &acl_ids, ZFS_DEFAULT_PROJID)) {
	zfs_acl_ids_free(&acl_ids);
	zfs_dirent_unlock(dl);
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EDQUOT));
	}
	tx = dmu_tx_create(zfsvfs->z_os);
	fuid_dirtied = zfsvfs->z_fuid_dirty;
	dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0, MAX(1, len));
	dmu_tx_hold_zap(tx, dzp->z_id, TRUE, name);
	dmu_tx_hold_sa_create(tx, acl_ids.z_aclp->z_acl_bytes +
	ZFS_SA_BASE_ATTR_SIZE + len);
	dmu_tx_hold_sa(tx, dzp->z_sa_hdl, B_FALSE);
	if (!zfsvfs->z_use_sa && acl_ids.z_aclp->z_acl_bytes > ZFS_ACE_SPACE) {
	dmu_tx_hold_write(tx, DMU_NEW_OBJECT, 0,
	acl_ids.z_aclp->z_acl_bytes);
	}
	if (fuid_dirtied)
	zfs_fuid_txhold(zfsvfs, tx);
	error = dmu_tx_assign(tx, (waited ? TXG_NOTHROTTLE : 0) \| TXG_NOWAIT);
	if (error) {
	zfs_dirent_unlock(dl);
	if (error == ERESTART) {
	waited = B_TRUE;
	dmu_tx_wait(tx);
	dmu_tx_abort(tx);
	goto top;
	}
	zfs_acl_ids_free(&acl_ids);
	dmu_tx_abort(tx);
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	/*
	* Create a new object for the symlink.
	- * for version 4 ZPL datsets the symlink will be an SA attribute
	+ * for version 4 ZPL datasets the symlink will be an SA attribute
	*/
	zfs_mknode(dzp, vap, tx, cr, 0, &zp, &acl_ids);

	if (fuid_dirtied)
	zfs_fuid_sync(zfsvfs, tx);

	mutex_enter(&zp->z_lock);
	if (zp->z_is_sa)
	error = sa_update(zp->z_sa_hdl, SA_ZPL_SYMLINK(zfsvfs),
	link, len, tx);
	else
	zfs_sa_symlink(zp, link, len, tx);
	mutex_exit(&zp->z_lock);

	zp->z_size = len;
	(void) sa_update(zp->z_sa_hdl, SA_ZPL_SIZE(zfsvfs),
	&zp->z_size, sizeof (zp->z_size), tx);
	/*
	* Insert the new object into the directory.
	*/
	error = zfs_link_create(dl, zp, tx, ZNEW);
	if (error != 0) {
	zfs_znode_delete(zp, tx);
	remove_inode_hash(ZTOI(zp));
	} else {
	if (flags & FIGNORECASE)
	txtype \|= TX_CI;
	zfs_log_symlink(zilog, tx, txtype, dzp, zp, name, link);

	zfs_znode_update_vfs(dzp);
	zfs_znode_update_vfs(zp);
	}

	zfs_acl_ids_free(&acl_ids);

	dmu_tx_commit(tx);

	zfs_dirent_unlock(dl);

	if (error == 0) {
	*zpp = zp;

	if (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS)
	zil_commit(zilog, 0);
	} else {
	zrele(zp);
	}

	ZFS_EXIT(zfsvfs);
	return (error);
	}

	/*
	* Return, in the buffer contained in the provided uio structure,
	* the symbolic path referred to by ip.
	*
	* IN: ip - inode of symbolic link
	* uio - structure to contain the link path.
	* cr - credentials of caller.
	*
	* RETURN: 0 if success
	* error code if failure
	*
	* Timestamps:
	* ip - atime updated
	*/
	/* ARGSUSED */
	int
	zfs_readlink(struct inode ip, zfs_uio_t uio, cred_t *cr)
	{
	znode_t *zp = ITOZ(ip);
	zfsvfs_t *zfsvfs = ITOZSB(ip);
	int error;

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zp);

	mutex_enter(&zp->z_lock);
	if (zp->z_is_sa)
	error = sa_lookup_uio(zp->z_sa_hdl,
	SA_ZPL_SYMLINK(zfsvfs), uio);
	else
	error = zfs_sa_readlink(zp, uio);
	mutex_exit(&zp->z_lock);

	ZFS_EXIT(zfsvfs);
	return (error);
	}

	/*
	* Insert a new entry into directory tdzp referencing szp.
	*
	* IN: tdzp - Directory to contain new entry.
	* szp - znode of new entry.
	* name - name of new entry.
	* cr - credentials of caller.
	* flags - case flags.
	*
	* RETURN: 0 if success
	* error code if failure
	*
	* Timestamps:
	* tdzp - ctime\|mtime updated
	* szp - ctime updated
	*/
	/* ARGSUSED */
	int
	zfs_link(znode_t tdzp, znode_t szp, char name, cred_t cr,
	int flags)
	{
	struct inode *sip = ZTOI(szp);
	znode_t *tzp;
	zfsvfs_t *zfsvfs = ZTOZSB(tdzp);
	zilog_t *zilog;
	zfs_dirlock_t *dl;
	dmu_tx_t *tx;
	int error;
	int zf = ZNEW;
	uint64_t parent;
	uid_t owner;
	boolean_t waited = B_FALSE;
	boolean_t is_tmpfile = 0;
	uint64_t txg;
	#ifdef HAVE_TMPFILE
	is_tmpfile = (sip->i_nlink == 0 && (sip->i_state & I_LINKABLE));
	#endif
	ASSERT(S_ISDIR(ZTOI(tdzp)->i_mode));

	if (name == NULL)
	return (SET_ERROR(EINVAL));

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(tdzp);
	zilog = zfsvfs->z_log;

	/*
	* POSIX dictates that we return EPERM here.
	* Better choices include ENOTSUP or EISDIR.
	*/
	if (S_ISDIR(sip->i_mode)) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EPERM));
	}

	ZFS_VERIFY_ZP(szp);

	/*
	* If we are using project inheritance, means if the directory has
	* ZFS_PROJINHERIT set, then its descendant directories will inherit
	* not only the project ID, but also the ZFS_PROJINHERIT flag. Under
	* such case, we only allow hard link creation in our tree when the
	* project IDs are the same.
	*/
	if (tdzp->z_pflags & ZFS_PROJINHERIT &&
	tdzp->z_projid != szp->z_projid) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EXDEV));
	}

	/*
	* We check i_sb because snapshots and the ctldir must have different
	* super blocks.
	*/
	if (sip->i_sb != ZTOI(tdzp)->i_sb \|\| zfsctl_is_node(sip)) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EXDEV));
	}

	/* Prevent links to .zfs/shares files */

	if ((error = sa_lookup(szp->z_sa_hdl, SA_ZPL_PARENT(zfsvfs),
	&parent, sizeof (uint64_t))) != 0) {
	ZFS_EXIT(zfsvfs);
	return (error);
	}
	if (parent == zfsvfs->z_shares_dir) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EPERM));
	}

	if (zfsvfs->z_utf8 && u8_validate(name,
	strlen(name), NULL, U8_VALIDATE_ENTIRE, &error) < 0) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EILSEQ));
	}
	if (flags & FIGNORECASE)
	zf \|= ZCILOOK;

	/*
	* We do not support links between attributes and non-attributes
	* because of the potential security risk of creating links
	* into "normal" file space in order to circumvent restrictions
	* imposed in attribute space.
	*/
	if ((szp->z_pflags & ZFS_XATTR) != (tdzp->z_pflags & ZFS_XATTR)) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EINVAL));
	}

	owner = zfs_fuid_map_id(zfsvfs, KUID_TO_SUID(sip->i_uid),
	cr, ZFS_OWNER);
	if (owner != crgetuid(cr) && secpolicy_basic_link(cr) != 0) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EPERM));
	}

	if ((error = zfs_zaccess(tdzp, ACE_ADD_FILE, 0, B_FALSE, cr))) {
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	top:
	/*
	* Attempt to lock directory; fail if entry already exists.
	*/
	error = zfs_dirent_lock(&dl, tdzp, name, &tzp, zf, NULL, NULL);
	if (error) {
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	tx = dmu_tx_create(zfsvfs->z_os);
	dmu_tx_hold_sa(tx, szp->z_sa_hdl, B_FALSE);
	dmu_tx_hold_zap(tx, tdzp->z_id, TRUE, name);
	if (is_tmpfile)
	dmu_tx_hold_zap(tx, zfsvfs->z_unlinkedobj, FALSE, NULL);

	zfs_sa_upgrade_txholds(tx, szp);
	zfs_sa_upgrade_txholds(tx, tdzp);
	error = dmu_tx_assign(tx, (waited ? TXG_NOTHROTTLE : 0) \| TXG_NOWAIT);
	if (error) {
	zfs_dirent_unlock(dl);
	if (error == ERESTART) {
	waited = B_TRUE;
	dmu_tx_wait(tx);
	dmu_tx_abort(tx);
	goto top;
	}
	dmu_tx_abort(tx);
	ZFS_EXIT(zfsvfs);
	return (error);
	}
	/* unmark z_unlinked so zfs_link_create will not reject */
	if (is_tmpfile)
	szp->z_unlinked = B_FALSE;
	error = zfs_link_create(dl, szp, tx, 0);

	if (error == 0) {
	uint64_t txtype = TX_LINK;
	/*
	* tmpfile is created to be in z_unlinkedobj, so remove it.
	* Also, we don't log in ZIL, because all previous file
	* operation on the tmpfile are ignored by ZIL. Instead we
	* always wait for txg to sync to make sure all previous
	* operation are sync safe.
	*/
	if (is_tmpfile) {
	VERIFY(zap_remove_int(zfsvfs->z_os,
	zfsvfs->z_unlinkedobj, szp->z_id, tx) == 0);
	} else {
	if (flags & FIGNORECASE)
	txtype \|= TX_CI;
	zfs_log_link(zilog, tx, txtype, tdzp, szp, name);
	}
	} else if (is_tmpfile) {
	/* restore z_unlinked since when linking failed */
	szp->z_unlinked = B_TRUE;
	}
	txg = dmu_tx_get_txg(tx);
	dmu_tx_commit(tx);

	zfs_dirent_unlock(dl);

	if (!is_tmpfile && zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS)
	zil_commit(zilog, 0);

	if (is_tmpfile && zfsvfs->z_os->os_sync != ZFS_SYNC_DISABLED)
	txg_wait_synced(dmu_objset_pool(zfsvfs->z_os), txg);

	zfs_znode_update_vfs(tdzp);
	zfs_znode_update_vfs(szp);
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	static void
	zfs_putpage_commit_cb(void *arg)
	{
	struct page *pp = arg;

	ClearPageError(pp);
	end_page_writeback(pp);
	}

	/*
	* Push a page out to disk, once the page is on stable storage the
	* registered commit callback will be run as notification of completion.
	*
	* IN: ip - page mapped for inode.
	* pp - page to push (page is locked)
	* wbc - writeback control data
	*
	* RETURN: 0 if success
	* error code if failure
	*
	* Timestamps:
	* ip - ctime\|mtime updated
	*/
	/* ARGSUSED */
	int
	zfs_putpage(struct inode ip, struct page pp, struct writeback_control *wbc)
	{
	znode_t *zp = ITOZ(ip);
	zfsvfs_t *zfsvfs = ITOZSB(ip);
	loff_t offset;
	loff_t pgoff;
	unsigned int pglen;
	dmu_tx_t *tx;
	caddr_t va;
	int err = 0;
	uint64_t mtime[2], ctime[2];
	sa_bulk_attr_t bulk[3];
	int cnt = 0;
	struct address_space *mapping;

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zp);

	ASSERT(PageLocked(pp));

	pgoff = page_offset(pp); /* Page byte-offset in file */
	offset = i_size_read(ip); /* File length in bytes */
	pglen = MIN(PAGE_SIZE, /* Page length in bytes */
	P2ROUNDUP(offset, PAGE_SIZE)-pgoff);

	/* Page is beyond end of file */
	if (pgoff >= offset) {
	unlock_page(pp);
	ZFS_EXIT(zfsvfs);
	return (0);
	}

	/* Truncate page length to end of file */
	if (pgoff + pglen > offset)
	pglen = offset - pgoff;

	#if 0
	/*
	* FIXME: Allow mmap writes past its quota. The correct fix
	* is to register a page_mkwrite() handler to count the page
	* against its quota when it is about to be dirtied.
	*/
	if (zfs_id_overblockquota(zfsvfs, DMU_USERUSED_OBJECT,
	KUID_TO_SUID(ip->i_uid)) \|\|
	zfs_id_overblockquota(zfsvfs, DMU_GROUPUSED_OBJECT,
	KGID_TO_SGID(ip->i_gid)) \|\|
	(zp->z_projid != ZFS_DEFAULT_PROJID &&
	zfs_id_overblockquota(zfsvfs, DMU_PROJECTUSED_OBJECT,
	zp->z_projid))) {
	err = EDQUOT;
	}
	#endif

	/*
	* The ordering here is critical and must adhere to the following
	* rules in order to avoid deadlocking in either zfs_read() or
	* zfs_free_range() due to a lock inversion.
	*
	* 1) The page must be unlocked prior to acquiring the range lock.
	* This is critical because zfs_read() calls find_lock_page()
	* which may block on the page lock while holding the range lock.
	*
	* 2) Before setting or clearing write back on a page the range lock
	* must be held in order to prevent a lock inversion with the
	* zfs_free_range() function.
	*
	* This presents a problem because upon entering this function the
	* page lock is already held. To safely acquire the range lock the
	* page lock must be dropped. This creates a window where another
	* process could truncate, invalidate, dirty, or write out the page.
	*
	* Therefore, after successfully reacquiring the range and page locks
	* the current page state is checked. In the common case everything
	* will be as is expected and it can be written out. However, if
	* the page state has changed it must be handled accordingly.
	*/
	mapping = pp->mapping;
	redirty_page_for_writepage(wbc, pp);
	unlock_page(pp);

	zfs_locked_range_t *lr = zfs_rangelock_enter(&zp->z_rangelock,
	pgoff, pglen, RL_WRITER);
	lock_page(pp);

	/* Page mapping changed or it was no longer dirty, we're done */
	if (unlikely((mapping != pp->mapping) \|\| !PageDirty(pp))) {
	unlock_page(pp);
	zfs_rangelock_exit(lr);
	ZFS_EXIT(zfsvfs);
	return (0);
	}

	/* Another process started write block if required */
	if (PageWriteback(pp)) {
	unlock_page(pp);
	zfs_rangelock_exit(lr);

	if (wbc->sync_mode != WB_SYNC_NONE) {
	if (PageWriteback(pp))
	wait_on_page_bit(pp, PG_writeback);
	}

	ZFS_EXIT(zfsvfs);
	return (0);
	}

	/* Clear the dirty flag the required locks are held */
	if (!clear_page_dirty_for_io(pp)) {
	unlock_page(pp);
	zfs_rangelock_exit(lr);
	ZFS_EXIT(zfsvfs);
	return (0);
	}

	/*
	* Counterpart for redirty_page_for_writepage() above. This page
	* was in fact not skipped and should not be counted as if it were.
	*/
	wbc->pages_skipped--;
	set_page_writeback(pp);
	unlock_page(pp);

	tx = dmu_tx_create(zfsvfs->z_os);
	dmu_tx_hold_write(tx, zp->z_id, pgoff, pglen);
	dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
	zfs_sa_upgrade_txholds(tx, zp);

	err = dmu_tx_assign(tx, TXG_NOWAIT);
	if (err != 0) {
	if (err == ERESTART)
	dmu_tx_wait(tx);

	dmu_tx_abort(tx);
	__set_page_dirty_nobuffers(pp);
	ClearPageError(pp);
	end_page_writeback(pp);
	zfs_rangelock_exit(lr);
	ZFS_EXIT(zfsvfs);
	return (err);
	}

	va = kmap(pp);
	ASSERT3U(pglen, <=, PAGE_SIZE);
	dmu_write(zfsvfs->z_os, zp->z_id, pgoff, pglen, va, tx);
	kunmap(pp);

	SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_MTIME(zfsvfs), NULL, &mtime, 16);
	SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_CTIME(zfsvfs), NULL, &ctime, 16);
	SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_FLAGS(zfsvfs), NULL,
	&zp->z_pflags, 8);

	/* Preserve the mtime and ctime provided by the inode */
	ZFS_TIME_ENCODE(&ip->i_mtime, mtime);
	ZFS_TIME_ENCODE(&ip->i_ctime, ctime);
	zp->z_atime_dirty = B_FALSE;
	zp->z_seq++;

	err = sa_bulk_update(zp->z_sa_hdl, bulk, cnt, tx);

	zfs_log_write(zfsvfs->z_log, tx, TX_WRITE, zp, pgoff, pglen, 0,
	zfs_putpage_commit_cb, pp);
	dmu_tx_commit(tx);

	zfs_rangelock_exit(lr);

	if (wbc->sync_mode != WB_SYNC_NONE) {
	/*
	* Note that this is rarely called under writepages(), because
	* writepages() normally handles the entire commit for
	* performance reasons.
	*/
	zil_commit(zfsvfs->z_log, zp->z_id);
	}

	ZFS_EXIT(zfsvfs);
	return (err);
	}

	/*
	* Update the system attributes when the inode has been dirtied. For the
	* moment we only update the mode, atime, mtime, and ctime.
	*/
	int
	zfs_dirty_inode(struct inode *ip, int flags)
	{
	znode_t *zp = ITOZ(ip);
	zfsvfs_t *zfsvfs = ITOZSB(ip);
	dmu_tx_t *tx;
	uint64_t mode, atime[2], mtime[2], ctime[2];
	sa_bulk_attr_t bulk[4];
	int error = 0;
	int cnt = 0;

	if (zfs_is_readonly(zfsvfs) \|\| dmu_objset_is_snapshot(zfsvfs->z_os))
	return (0);

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zp);

	#ifdef I_DIRTY_TIME
	/*
	* This is the lazytime semantic introduced in Linux 4.0
	* This flag will only be called from update_time when lazytime is set.
	* (Note, I_DIRTY_SYNC will also set if not lazytime)
	* Fortunately mtime and ctime are managed within ZFS itself, so we
	* only need to dirty atime.
	*/
	if (flags == I_DIRTY_TIME) {
	zp->z_atime_dirty = B_TRUE;
	goto out;
	}
	#endif

	tx = dmu_tx_create(zfsvfs->z_os);

	dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
	zfs_sa_upgrade_txholds(tx, zp);

	error = dmu_tx_assign(tx, TXG_WAIT);
	if (error) {
	dmu_tx_abort(tx);
	goto out;
	}

	mutex_enter(&zp->z_lock);
	zp->z_atime_dirty = B_FALSE;

	SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_MODE(zfsvfs), NULL, &mode, 8);
	SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_ATIME(zfsvfs), NULL, &atime, 16);
	SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_MTIME(zfsvfs), NULL, &mtime, 16);
	SA_ADD_BULK_ATTR(bulk, cnt, SA_ZPL_CTIME(zfsvfs), NULL, &ctime, 16);

	/* Preserve the mode, mtime and ctime provided by the inode */
	ZFS_TIME_ENCODE(&ip->i_atime, atime);
	ZFS_TIME_ENCODE(&ip->i_mtime, mtime);
	ZFS_TIME_ENCODE(&ip->i_ctime, ctime);
	mode = ip->i_mode;

	zp->z_mode = mode;

	error = sa_bulk_update(zp->z_sa_hdl, bulk, cnt, tx);
	mutex_exit(&zp->z_lock);

	dmu_tx_commit(tx);
	out:
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	/ARGSUSED/
	void
	zfs_inactive(struct inode *ip)
	{
	znode_t *zp = ITOZ(ip);
	zfsvfs_t *zfsvfs = ITOZSB(ip);
	uint64_t atime[2];
	int error;
	int need_unlock = 0;

	/* Only read lock if we haven't already write locked, e.g. rollback */
	if (!RW_WRITE_HELD(&zfsvfs->z_teardown_inactive_lock)) {
	need_unlock = 1;
	rw_enter(&zfsvfs->z_teardown_inactive_lock, RW_READER);
	}
	if (zp->z_sa_hdl == NULL) {
	if (need_unlock)
	rw_exit(&zfsvfs->z_teardown_inactive_lock);
	return;
	}

	if (zp->z_atime_dirty && zp->z_unlinked == B_FALSE) {
	dmu_tx_t *tx = dmu_tx_create(zfsvfs->z_os);

	dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
	zfs_sa_upgrade_txholds(tx, zp);
	error = dmu_tx_assign(tx, TXG_WAIT);
	if (error) {
	dmu_tx_abort(tx);
	} else {
	ZFS_TIME_ENCODE(&ip->i_atime, atime);
	mutex_enter(&zp->z_lock);
	(void) sa_update(zp->z_sa_hdl, SA_ZPL_ATIME(zfsvfs),
	(void *)&atime, sizeof (atime), tx);
	zp->z_atime_dirty = B_FALSE;
	mutex_exit(&zp->z_lock);
	dmu_tx_commit(tx);
	}
	}

	zfs_zinactive(zp);
	if (need_unlock)
	rw_exit(&zfsvfs->z_teardown_inactive_lock);
	}

	/*
	* Fill pages with data from the disk.
	*/
	static int
	zfs_fillpage(struct inode ip, struct page pl[], int nr_pages)
	{
	znode_t *zp = ITOZ(ip);
	zfsvfs_t *zfsvfs = ITOZSB(ip);
	objset_t *os;
	struct page *cur_pp;
	u_offset_t io_off, total;
	size_t io_len;
	loff_t i_size;
	unsigned page_idx;
	int err;

	os = zfsvfs->z_os;
	io_len = nr_pages << PAGE_SHIFT;
	i_size = i_size_read(ip);
	io_off = page_offset(pl[0]);

	if (io_off + io_len > i_size)
	io_len = i_size - io_off;

	/*
	* Iterate over list of pages and read each page individually.
	*/
	page_idx = 0;
	for (total = io_off + io_len; io_off < total; io_off += PAGESIZE) {
	caddr_t va;

	cur_pp = pl[page_idx++];
	va = kmap(cur_pp);
	err = dmu_read(os, zp->z_id, io_off, PAGESIZE, va,
	DMU_READ_PREFETCH);
	kunmap(cur_pp);
	if (err) {
	/* convert checksum errors into IO errors */
	if (err == ECKSUM)
	err = SET_ERROR(EIO);
	return (err);
	}
	}

	return (0);
	}

	/*
	* Uses zfs_fillpage to read data from the file and fill the pages.
	*
	* IN: ip - inode of file to get data from.
	* pl - list of pages to read
	* nr_pages - number of pages to read
	*
	* RETURN: 0 on success, error code on failure.
	*
	* Timestamps:
	* vp - atime updated
	*/
	/* ARGSUSED */
	int
	zfs_getpage(struct inode ip, struct page pl[], int nr_pages)
	{
	znode_t *zp = ITOZ(ip);
	zfsvfs_t *zfsvfs = ITOZSB(ip);
	int err;

	if (pl == NULL)
	return (0);

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zp);

	err = zfs_fillpage(ip, pl, nr_pages);

	ZFS_EXIT(zfsvfs);
	return (err);
	}

	/*
	* Check ZFS specific permissions to memory map a section of a file.
	*
	* IN: ip - inode of the file to mmap
	* off - file offset
	* addrp - start address in memory region
	* len - length of memory region
	* vm_flags- address flags
	*
	* RETURN: 0 if success
	* error code if failure
	*/
	/ARGSUSED/
	int
	zfs_map(struct inode ip, offset_t off, caddr_t addrp, size_t len,
	unsigned long vm_flags)
	{
	znode_t *zp = ITOZ(ip);
	zfsvfs_t *zfsvfs = ITOZSB(ip);

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zp);

	if ((vm_flags & VM_WRITE) && (zp->z_pflags &
	(ZFS_IMMUTABLE \| ZFS_READONLY \| ZFS_APPENDONLY))) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EPERM));
	}

	if ((vm_flags & (VM_READ \| VM_EXEC)) &&
	(zp->z_pflags & ZFS_AV_QUARANTINED)) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EACCES));
	}

	if (off < 0 \|\| len > MAXOFFSET_T - off) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(ENXIO));
	}

	ZFS_EXIT(zfsvfs);
	return (0);
	}

	/*
	* Free or allocate space in a file. Currently, this function only
	* supports the `F_FREESP' command. However, this command is somewhat
	* misnamed, as its functionality includes the ability to allocate as
	* well as free space.
	*
	* IN: zp - znode of file to free data in.
	* cmd - action to take (only F_FREESP supported).
	* bfp - section of file to free/alloc.
	* flag - current file open mode flags.
	* offset - current file offset.
	* cr - credentials of caller.
	*
	* RETURN: 0 on success, error code on failure.
	*
	* Timestamps:
	* zp - ctime\|mtime updated
	*/
	/* ARGSUSED */
	int
	zfs_space(znode_t zp, int cmd, flock64_t bfp, int flag,
	offset_t offset, cred_t *cr)
	{
	zfsvfs_t *zfsvfs = ZTOZSB(zp);
	uint64_t off, len;
	int error;

	ZFS_ENTER(zfsvfs);
	ZFS_VERIFY_ZP(zp);

	if (cmd != F_FREESP) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EINVAL));
	}

	/*
	* Callers might not be able to detect properly that we are read-only,
	* so check it explicitly here.
	*/
	if (zfs_is_readonly(zfsvfs)) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EROFS));
	}

	if (bfp->l_len < 0) {
	ZFS_EXIT(zfsvfs);
	return (SET_ERROR(EINVAL));
	}

	/*
	* Permissions aren't checked on Solaris because on this OS
	* zfs_space() can only be called with an opened file handle.
	* On Linux we can get here through truncate_range() which
	* operates directly on inodes, so we need to check access rights.
	*/
	if ((error = zfs_zaccess(zp, ACE_WRITE_DATA, 0, B_FALSE, cr))) {
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	off = bfp->l_start;
	len = bfp->l_len; /* 0 means from off to end of file */

	error = zfs_freesp(zp, off, len, flag, TRUE);

	ZFS_EXIT(zfsvfs);
	return (error);
	}

	/ARGSUSED/
	int
	zfs_fid(struct inode ip, fid_t fidp)
	{
	znode_t *zp = ITOZ(ip);
	zfsvfs_t *zfsvfs = ITOZSB(ip);
	uint32_t gen;
	uint64_t gen64;
	uint64_t object = zp->z_id;
	zfid_short_t *zfid;
	int size, i, error;

	ZFS_ENTER(zfsvfs);
	+
	+ if (fidp->fid_len < SHORT_FID_LEN) {
	+ fidp->fid_len = SHORT_FID_LEN;
	+ ZFS_EXIT(zfsvfs);
	+ return (SET_ERROR(ENOSPC));
	+ }
	+
	ZFS_VERIFY_ZP(zp);

	if ((error = sa_lookup(zp->z_sa_hdl, SA_ZPL_GEN(zfsvfs),
	&gen64, sizeof (uint64_t))) != 0) {
	ZFS_EXIT(zfsvfs);
	return (error);
	}

	gen = (uint32_t)gen64;

	size = SHORT_FID_LEN;

	zfid = (zfid_short_t *)fidp;

	zfid->zf_len = size;

	for (i = 0; i < sizeof (zfid->zf_object); i++)
	zfid->zf_object[i] = (uint8_t)(object >> (8 * i));

	/* Must have a non-zero generation number to distinguish from .zfs */
	if (gen == 0)
	gen = 1;
	for (i = 0; i < sizeof (zfid->zf_gen); i++)
	zfid->zf_gen[i] = (uint8_t)(gen >> (8 * i));

	ZFS_EXIT(zfsvfs);
	return (0);
	}

	#if defined(_KERNEL)
	EXPORT_SYMBOL(zfs_open);
	EXPORT_SYMBOL(zfs_close);
	EXPORT_SYMBOL(zfs_lookup);
	EXPORT_SYMBOL(zfs_create);
	EXPORT_SYMBOL(zfs_tmpfile);
	EXPORT_SYMBOL(zfs_remove);
	EXPORT_SYMBOL(zfs_mkdir);
	EXPORT_SYMBOL(zfs_rmdir);
	EXPORT_SYMBOL(zfs_readdir);
	EXPORT_SYMBOL(zfs_getattr_fast);
	EXPORT_SYMBOL(zfs_setattr);
	EXPORT_SYMBOL(zfs_rename);
	EXPORT_SYMBOL(zfs_symlink);
	EXPORT_SYMBOL(zfs_readlink);
	EXPORT_SYMBOL(zfs_link);
	EXPORT_SYMBOL(zfs_inactive);
	EXPORT_SYMBOL(zfs_space);
	EXPORT_SYMBOL(zfs_fid);
	EXPORT_SYMBOL(zfs_getpage);
	EXPORT_SYMBOL(zfs_putpage);
	EXPORT_SYMBOL(zfs_dirty_inode);
	EXPORT_SYMBOL(zfs_map);

	/* BEGIN CSTYLED */
	module_param(zfs_delete_blocks, ulong, 0644);
	MODULE_PARM_DESC(zfs_delete_blocks, "Delete files larger than N blocks async");
	/* END CSTYLED */

	#endif
	diff --git a/sys/contrib/openzfs/module/os/linux/zfs/zfs_znode.c b/sys/contrib/openzfs/module/os/linux/zfs/zfs_znode.c
	index d59c1bb0716a..4bfb26302b52 100644
	--- a/sys/contrib/openzfs/module/os/linux/zfs/zfs_znode.c
	+++ b/sys/contrib/openzfs/module/os/linux/zfs/zfs_znode.c
	@@ -1,2244 +1,2244 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2012, 2018 by Delphix. All rights reserved.
	*/

	/* Portions Copyright 2007 Jeremy Teo */

	#ifdef _KERNEL
	#include <sys/types.h>
	#include <sys/param.h>
	#include <sys/time.h>
	#include <sys/sysmacros.h>
	#include <sys/mntent.h>
	#include <sys/u8_textprep.h>
	#include <sys/dsl_dataset.h>
	#include <sys/vfs.h>
	#include <sys/vnode.h>
	#include <sys/file.h>
	#include <sys/kmem.h>
	#include <sys/errno.h>
	#include <sys/atomic.h>
	#include <sys/zfs_dir.h>
	#include <sys/zfs_acl.h>
	#include <sys/zfs_ioctl.h>
	#include <sys/zfs_rlock.h>
	#include <sys/zfs_fuid.h>
	#include <sys/zfs_vnops.h>
	#include <sys/zfs_ctldir.h>
	#include <sys/dnode.h>
	#include <sys/fs/zfs.h>
	#include <sys/zpl.h>
	#endif /* _KERNEL */

	#include <sys/dmu.h>
	#include <sys/dmu_objset.h>
	#include <sys/dmu_tx.h>
	#include <sys/zfs_refcount.h>
	#include <sys/stat.h>
	#include <sys/zap.h>
	#include <sys/zfs_znode.h>
	#include <sys/sa.h>
	#include <sys/zfs_sa.h>
	#include <sys/zfs_stat.h>

	#include "zfs_prop.h"
	#include "zfs_comutil.h"

	/*
	* Functions needed for userland (ie: libzpool) are not put under
	* #ifdef_KERNEL; the rest of the functions have dependencies
	* (such as VFS logic) that will not compile easily in userland.
	*/
	#ifdef _KERNEL

	static kmem_cache_t *znode_cache = NULL;
	static kmem_cache_t *znode_hold_cache = NULL;
	unsigned int zfs_object_mutex_size = ZFS_OBJ_MTX_SZ;

	/*
	* This is used by the test suite so that it can delay znodes from being
	* freed in order to inspect the unlinked set.
	*/
	int zfs_unlink_suspend_progress = 0;

	/*
	* This callback is invoked when acquiring a RL_WRITER or RL_APPEND lock on
	* z_rangelock. It will modify the offset and length of the lock to reflect
	* znode-specific information, and convert RL_APPEND to RL_WRITER. This is
	* called with the rangelock_t's rl_lock held, which avoids races.
	*/
	static void
	zfs_rangelock_cb(zfs_locked_range_t new, void arg)
	{
	znode_t *zp = arg;

	/*
	* If in append mode, convert to writer and lock starting at the
	* current end of file.
	*/
	if (new->lr_type == RL_APPEND) {
	new->lr_offset = zp->z_size;
	new->lr_type = RL_WRITER;
	}

	/*
	* If we need to grow the block size then lock the whole file range.
	*/
	uint64_t end_size = MAX(zp->z_size, new->lr_offset + new->lr_length);
	if (end_size > zp->z_blksz && (!ISP2(zp->z_blksz) \|\|
	zp->z_blksz < ZTOZSB(zp)->z_max_blksz)) {
	new->lr_offset = 0;
	new->lr_length = UINT64_MAX;
	}
	}

	/ARGSUSED/
	static int
	zfs_znode_cache_constructor(void buf, void arg, int kmflags)
	{
	znode_t *zp = buf;

	inode_init_once(ZTOI(zp));
	list_link_init(&zp->z_link_node);

	mutex_init(&zp->z_lock, NULL, MUTEX_DEFAULT, NULL);
	rw_init(&zp->z_parent_lock, NULL, RW_DEFAULT, NULL);
	rw_init(&zp->z_name_lock, NULL, RW_NOLOCKDEP, NULL);
	mutex_init(&zp->z_acl_lock, NULL, MUTEX_DEFAULT, NULL);
	rw_init(&zp->z_xattr_lock, NULL, RW_DEFAULT, NULL);

	zfs_rangelock_init(&zp->z_rangelock, zfs_rangelock_cb, zp);

	zp->z_dirlocks = NULL;
	zp->z_acl_cached = NULL;
	zp->z_xattr_cached = NULL;
	zp->z_xattr_parent = 0;
	return (0);
	}

	/ARGSUSED/
	static void
	zfs_znode_cache_destructor(void buf, void arg)
	{
	znode_t *zp = buf;

	ASSERT(!list_link_active(&zp->z_link_node));
	mutex_destroy(&zp->z_lock);
	rw_destroy(&zp->z_parent_lock);
	rw_destroy(&zp->z_name_lock);
	mutex_destroy(&zp->z_acl_lock);
	rw_destroy(&zp->z_xattr_lock);
	zfs_rangelock_fini(&zp->z_rangelock);

	ASSERT(zp->z_dirlocks == NULL);
	ASSERT(zp->z_acl_cached == NULL);
	ASSERT(zp->z_xattr_cached == NULL);
	}

	static int
	zfs_znode_hold_cache_constructor(void buf, void arg, int kmflags)
	{
	znode_hold_t *zh = buf;

	mutex_init(&zh->zh_lock, NULL, MUTEX_DEFAULT, NULL);
	zfs_refcount_create(&zh->zh_refcount);
	zh->zh_obj = ZFS_NO_OBJECT;

	return (0);
	}

	static void
	zfs_znode_hold_cache_destructor(void buf, void arg)
	{
	znode_hold_t *zh = buf;

	mutex_destroy(&zh->zh_lock);
	zfs_refcount_destroy(&zh->zh_refcount);
	}

	void
	zfs_znode_init(void)
	{
	/*
	* Initialize zcache. The KMC_SLAB hint is used in order that it be
	* backed by kmalloc() when on the Linux slab in order that any
	* wait_on_bit() operations on the related inode operate properly.
	*/
	ASSERT(znode_cache == NULL);
	znode_cache = kmem_cache_create("zfs_znode_cache",
	sizeof (znode_t), 0, zfs_znode_cache_constructor,
	zfs_znode_cache_destructor, NULL, NULL, NULL, KMC_SLAB);

	ASSERT(znode_hold_cache == NULL);
	znode_hold_cache = kmem_cache_create("zfs_znode_hold_cache",
	sizeof (znode_hold_t), 0, zfs_znode_hold_cache_constructor,
	zfs_znode_hold_cache_destructor, NULL, NULL, NULL, 0);
	}

	void
	zfs_znode_fini(void)
	{
	/*
	* Cleanup zcache
	*/
	if (znode_cache)
	kmem_cache_destroy(znode_cache);
	znode_cache = NULL;

	if (znode_hold_cache)
	kmem_cache_destroy(znode_hold_cache);
	znode_hold_cache = NULL;
	}

	/*
	* The zfs_znode_hold_enter() / zfs_znode_hold_exit() functions are used to
	* serialize access to a znode and its SA buffer while the object is being
	* created or destroyed. This kind of locking would normally reside in the
	* znode itself but in this case that's impossible because the znode and SA
	* buffer may not yet exist. Therefore the locking is handled externally
	- * with an array of mutexs and AVLs trees which contain per-object locks.
	+ * with an array of mutexes and AVLs trees which contain per-object locks.
	*
	* In zfs_znode_hold_enter() a per-object lock is created as needed, inserted
	* in to the correct AVL tree and finally the per-object lock is held. In
	* zfs_znode_hold_exit() the process is reversed. The per-object lock is
	* released, removed from the AVL tree and destroyed if there are no waiters.
	*
	* This scheme has two important properties:
	*
	* 1) No memory allocations are performed while holding one of the z_hold_locks.
	* This ensures evict(), which can be called from direct memory reclaim, will
	* never block waiting on a z_hold_locks which just happens to have hashed
	* to the same index.
	*
	* 2) All locks used to serialize access to an object are per-object and never
	* shared. This minimizes lock contention without creating a large number
	* of dedicated locks.
	*
	* On the downside it does require znode_lock_t structures to be frequently
	* allocated and freed. However, because these are backed by a kmem cache
	* and very short lived this cost is minimal.
	*/
	int
	zfs_znode_hold_compare(const void a, const void b)
	{
	const znode_hold_t zh_a = (const znode_hold_t )a;
	const znode_hold_t zh_b = (const znode_hold_t )b;

	return (TREE_CMP(zh_a->zh_obj, zh_b->zh_obj));
	}

	static boolean_t __maybe_unused
	zfs_znode_held(zfsvfs_t *zfsvfs, uint64_t obj)
	{
	znode_hold_t *zh, search;
	int i = ZFS_OBJ_HASH(zfsvfs, obj);
	boolean_t held;

	search.zh_obj = obj;

	mutex_enter(&zfsvfs->z_hold_locks[i]);
	zh = avl_find(&zfsvfs->z_hold_trees[i], &search, NULL);
	held = (zh && MUTEX_HELD(&zh->zh_lock)) ? B_TRUE : B_FALSE;
	mutex_exit(&zfsvfs->z_hold_locks[i]);

	return (held);
	}

	static znode_hold_t *
	zfs_znode_hold_enter(zfsvfs_t *zfsvfs, uint64_t obj)
	{
	znode_hold_t zh, zh_new, search;
	int i = ZFS_OBJ_HASH(zfsvfs, obj);
	boolean_t found = B_FALSE;

	zh_new = kmem_cache_alloc(znode_hold_cache, KM_SLEEP);
	zh_new->zh_obj = obj;
	search.zh_obj = obj;

	mutex_enter(&zfsvfs->z_hold_locks[i]);
	zh = avl_find(&zfsvfs->z_hold_trees[i], &search, NULL);
	if (likely(zh == NULL)) {
	zh = zh_new;
	avl_add(&zfsvfs->z_hold_trees[i], zh);
	} else {
	ASSERT3U(zh->zh_obj, ==, obj);
	found = B_TRUE;
	}
	zfs_refcount_add(&zh->zh_refcount, NULL);
	mutex_exit(&zfsvfs->z_hold_locks[i]);

	if (found == B_TRUE)
	kmem_cache_free(znode_hold_cache, zh_new);

	ASSERT(MUTEX_NOT_HELD(&zh->zh_lock));
	ASSERT3S(zfs_refcount_count(&zh->zh_refcount), >, 0);
	mutex_enter(&zh->zh_lock);

	return (zh);
	}

	static void
	zfs_znode_hold_exit(zfsvfs_t zfsvfs, znode_hold_t zh)
	{
	int i = ZFS_OBJ_HASH(zfsvfs, zh->zh_obj);
	boolean_t remove = B_FALSE;

	ASSERT(zfs_znode_held(zfsvfs, zh->zh_obj));
	ASSERT3S(zfs_refcount_count(&zh->zh_refcount), >, 0);
	mutex_exit(&zh->zh_lock);

	mutex_enter(&zfsvfs->z_hold_locks[i]);
	if (zfs_refcount_remove(&zh->zh_refcount, NULL) == 0) {
	avl_remove(&zfsvfs->z_hold_trees[i], zh);
	remove = B_TRUE;
	}
	mutex_exit(&zfsvfs->z_hold_locks[i]);

	if (remove == B_TRUE)
	kmem_cache_free(znode_hold_cache, zh);
	}

	dev_t
	zfs_cmpldev(uint64_t dev)
	{
	return (dev);
	}

	static void
	zfs_znode_sa_init(zfsvfs_t zfsvfs, znode_t zp,
	dmu_buf_t db, dmu_object_type_t obj_type, sa_handle_t sa_hdl)
	{
	ASSERT(zfs_znode_held(zfsvfs, zp->z_id));

	mutex_enter(&zp->z_lock);

	ASSERT(zp->z_sa_hdl == NULL);
	ASSERT(zp->z_acl_cached == NULL);
	if (sa_hdl == NULL) {
	VERIFY(0 == sa_handle_get_from_db(zfsvfs->z_os, db, zp,
	SA_HDL_SHARED, &zp->z_sa_hdl));
	} else {
	zp->z_sa_hdl = sa_hdl;
	sa_set_userp(sa_hdl, zp);
	}

	zp->z_is_sa = (obj_type == DMU_OT_SA) ? B_TRUE : B_FALSE;

	mutex_exit(&zp->z_lock);
	}

	void
	zfs_znode_dmu_fini(znode_t *zp)
	{
	ASSERT(zfs_znode_held(ZTOZSB(zp), zp->z_id) \|\| zp->z_unlinked \|\|
	RW_WRITE_HELD(&ZTOZSB(zp)->z_teardown_inactive_lock));

	sa_handle_destroy(zp->z_sa_hdl);
	zp->z_sa_hdl = NULL;
	}

	/*
	* Called by new_inode() to allocate a new inode.
	*/
	int
	zfs_inode_alloc(struct super_block sb, struct inode *ip)
	{
	znode_t *zp;

	zp = kmem_cache_alloc(znode_cache, KM_SLEEP);
	*ip = ZTOI(zp);

	return (0);
	}

	/*
	* Called in multiple places when an inode should be destroyed.
	*/
	void
	zfs_inode_destroy(struct inode *ip)
	{
	znode_t *zp = ITOZ(ip);
	zfsvfs_t *zfsvfs = ZTOZSB(zp);

	mutex_enter(&zfsvfs->z_znodes_lock);
	if (list_link_active(&zp->z_link_node)) {
	list_remove(&zfsvfs->z_all_znodes, zp);
	zfsvfs->z_nr_znodes--;
	}
	mutex_exit(&zfsvfs->z_znodes_lock);

	if (zp->z_acl_cached) {
	zfs_acl_free(zp->z_acl_cached);
	zp->z_acl_cached = NULL;
	}

	if (zp->z_xattr_cached) {
	nvlist_free(zp->z_xattr_cached);
	zp->z_xattr_cached = NULL;
	}

	kmem_cache_free(znode_cache, zp);
	}

	static void
	zfs_inode_set_ops(zfsvfs_t zfsvfs, struct inode ip)
	{
	uint64_t rdev = 0;

	switch (ip->i_mode & S_IFMT) {
	case S_IFREG:
	ip->i_op = &zpl_inode_operations;
	ip->i_fop = &zpl_file_operations;
	ip->i_mapping->a_ops = &zpl_address_space_operations;
	break;

	case S_IFDIR:
	ip->i_op = &zpl_dir_inode_operations;
	ip->i_fop = &zpl_dir_file_operations;
	ITOZ(ip)->z_zn_prefetch = B_TRUE;
	break;

	case S_IFLNK:
	ip->i_op = &zpl_symlink_inode_operations;
	break;

	/*
	* rdev is only stored in a SA only for device files.
	*/
	case S_IFCHR:
	case S_IFBLK:
	(void) sa_lookup(ITOZ(ip)->z_sa_hdl, SA_ZPL_RDEV(zfsvfs), &rdev,
	sizeof (rdev));
	/FALLTHROUGH/
	case S_IFIFO:
	case S_IFSOCK:
	init_special_inode(ip, ip->i_mode, rdev);
	ip->i_op = &zpl_special_inode_operations;
	break;

	default:
	zfs_panic_recover("inode %llu has invalid mode: 0x%x\n",
	(u_longlong_t)ip->i_ino, ip->i_mode);

	/* Assume the inode is a file and attempt to continue */
	ip->i_mode = S_IFREG \| 0644;
	ip->i_op = &zpl_inode_operations;
	ip->i_fop = &zpl_file_operations;
	ip->i_mapping->a_ops = &zpl_address_space_operations;
	break;
	}
	}

	static void
	zfs_set_inode_flags(znode_t zp, struct inode ip)
	{
	/*
	* Linux and Solaris have different sets of file attributes, so we
	* restrict this conversion to the intersection of the two.
	*/
	#ifdef HAVE_INODE_SET_FLAGS
	unsigned int flags = 0;
	if (zp->z_pflags & ZFS_IMMUTABLE)
	flags \|= S_IMMUTABLE;
	if (zp->z_pflags & ZFS_APPENDONLY)
	flags \|= S_APPEND;

	inode_set_flags(ip, flags, S_IMMUTABLE\|S_APPEND);
	#else
	if (zp->z_pflags & ZFS_IMMUTABLE)
	ip->i_flags \|= S_IMMUTABLE;
	else
	ip->i_flags &= ~S_IMMUTABLE;

	if (zp->z_pflags & ZFS_APPENDONLY)
	ip->i_flags \|= S_APPEND;
	else
	ip->i_flags &= ~S_APPEND;
	#endif
	}

	/*
	* Update the embedded inode given the znode.
	*/
	void
	zfs_znode_update_vfs(znode_t *zp)
	{
	zfsvfs_t *zfsvfs;
	struct inode *ip;
	uint32_t blksize;
	u_longlong_t i_blocks;

	ASSERT(zp != NULL);
	zfsvfs = ZTOZSB(zp);
	ip = ZTOI(zp);

	/* Skip .zfs control nodes which do not exist on disk. */
	if (zfsctl_is_node(ip))
	return;

	dmu_object_size_from_db(sa_get_db(zp->z_sa_hdl), &blksize, &i_blocks);

	spin_lock(&ip->i_lock);
	ip->i_mode = zp->z_mode;
	ip->i_blocks = i_blocks;
	i_size_write(ip, zp->z_size);
	spin_unlock(&ip->i_lock);
	}


	/*
	* Construct a znode+inode and initialize.
	*
	* This does not do a call to dmu_set_user() that is
	* up to the caller to do, in case you don't want to
	* return the znode
	*/
	static znode_t *
	zfs_znode_alloc(zfsvfs_t zfsvfs, dmu_buf_t db, int blksz,
	dmu_object_type_t obj_type, sa_handle_t *hdl)
	{
	znode_t *zp;
	struct inode *ip;
	uint64_t mode;
	uint64_t parent;
	uint64_t tmp_gen;
	uint64_t links;
	uint64_t z_uid, z_gid;
	uint64_t atime[2], mtime[2], ctime[2];
	uint64_t projid = ZFS_DEFAULT_PROJID;
	sa_bulk_attr_t bulk[11];
	int count = 0;

	ASSERT(zfsvfs != NULL);

	ip = new_inode(zfsvfs->z_sb);
	if (ip == NULL)
	return (NULL);

	zp = ITOZ(ip);
	ASSERT(zp->z_dirlocks == NULL);
	ASSERT3P(zp->z_acl_cached, ==, NULL);
	ASSERT3P(zp->z_xattr_cached, ==, NULL);
	zp->z_unlinked = B_FALSE;
	zp->z_atime_dirty = B_FALSE;
	zp->z_is_mapped = B_FALSE;
	zp->z_is_ctldir = B_FALSE;
	zp->z_is_stale = B_FALSE;
	zp->z_suspended = B_FALSE;
	zp->z_sa_hdl = NULL;
	zp->z_mapcnt = 0;
	zp->z_id = db->db_object;
	zp->z_blksz = blksz;
	zp->z_seq = 0x7A4653;
	zp->z_sync_cnt = 0;

	zfs_znode_sa_init(zfsvfs, zp, db, obj_type, hdl);

	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MODE(zfsvfs), NULL, &mode, 8);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_GEN(zfsvfs), NULL, &tmp_gen, 8);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_SIZE(zfsvfs), NULL,
	&zp->z_size, 8);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_LINKS(zfsvfs), NULL, &links, 8);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zfsvfs), NULL,
	&zp->z_pflags, 8);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_PARENT(zfsvfs), NULL,
	&parent, 8);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_UID(zfsvfs), NULL, &z_uid, 8);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_GID(zfsvfs), NULL, &z_gid, 8);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_ATIME(zfsvfs), NULL, &atime, 16);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zfsvfs), NULL, &mtime, 16);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs), NULL, &ctime, 16);

	if (sa_bulk_lookup(zp->z_sa_hdl, bulk, count) != 0 \|\| tmp_gen == 0 \|\|
	(dmu_objset_projectquota_enabled(zfsvfs->z_os) &&
	(zp->z_pflags & ZFS_PROJID) &&
	sa_lookup(zp->z_sa_hdl, SA_ZPL_PROJID(zfsvfs), &projid, 8) != 0)) {
	if (hdl == NULL)
	sa_handle_destroy(zp->z_sa_hdl);
	zp->z_sa_hdl = NULL;
	goto error;
	}

	zp->z_projid = projid;
	zp->z_mode = ip->i_mode = mode;
	ip->i_generation = (uint32_t)tmp_gen;
	ip->i_blkbits = SPA_MINBLOCKSHIFT;
	set_nlink(ip, (uint32_t)links);
	zfs_uid_write(ip, z_uid);
	zfs_gid_write(ip, z_gid);
	zfs_set_inode_flags(zp, ip);

	/* Cache the xattr parent id */
	if (zp->z_pflags & ZFS_XATTR)
	zp->z_xattr_parent = parent;

	ZFS_TIME_DECODE(&ip->i_atime, atime);
	ZFS_TIME_DECODE(&ip->i_mtime, mtime);
	ZFS_TIME_DECODE(&ip->i_ctime, ctime);

	ip->i_ino = zp->z_id;
	zfs_znode_update_vfs(zp);
	zfs_inode_set_ops(zfsvfs, ip);

	/*
	* The only way insert_inode_locked() can fail is if the ip->i_ino
	* number is already hashed for this super block. This can never
	* happen because the inode numbers map 1:1 with the object numbers.
	*
	* The one exception is rolling back a mounted file system, but in
	* this case all the active inode are unhashed during the rollback.
	*/
	VERIFY3S(insert_inode_locked(ip), ==, 0);

	mutex_enter(&zfsvfs->z_znodes_lock);
	list_insert_tail(&zfsvfs->z_all_znodes, zp);
	zfsvfs->z_nr_znodes++;
	mutex_exit(&zfsvfs->z_znodes_lock);

	unlock_new_inode(ip);
	return (zp);

	error:
	iput(ip);
	return (NULL);
	}

	/*
	* Safely mark an inode dirty. Inodes which are part of a read-only
	* file system or snapshot may not be dirtied.
	*/
	void
	zfs_mark_inode_dirty(struct inode *ip)
	{
	zfsvfs_t *zfsvfs = ITOZSB(ip);

	if (zfs_is_readonly(zfsvfs) \|\| dmu_objset_is_snapshot(zfsvfs->z_os))
	return;

	mark_inode_dirty(ip);
	}

	static uint64_t empty_xattr;
	static uint64_t pad[4];
	static zfs_acl_phys_t acl_phys;
	/*
	* Create a new DMU object to hold a zfs znode.
	*
	* IN: dzp - parent directory for new znode
	* vap - file attributes for new znode
	* tx - dmu transaction id for zap operations
	* cr - credentials of caller
	* flag - flags:
	* IS_ROOT_NODE - new object will be root
	* IS_TMPFILE - new object is of O_TMPFILE
	* IS_XATTR - new object is an attribute
	* acl_ids - ACL related attributes
	*
	* OUT: zpp - allocated znode (set to dzp if IS_ROOT_NODE)
	*
	*/
	void
	zfs_mknode(znode_t dzp, vattr_t vap, dmu_tx_t tx, cred_t cr,
	uint_t flag, znode_t *zpp, zfs_acl_ids_t acl_ids)
	{
	uint64_t crtime[2], atime[2], mtime[2], ctime[2];
	uint64_t mode, size, links, parent, pflags;
	uint64_t projid = ZFS_DEFAULT_PROJID;
	uint64_t rdev = 0;
	zfsvfs_t *zfsvfs = ZTOZSB(dzp);
	dmu_buf_t *db;
	inode_timespec_t now;
	uint64_t gen, obj;
	int bonuslen;
	int dnodesize;
	sa_handle_t *sa_hdl;
	dmu_object_type_t obj_type;
	sa_bulk_attr_t *sa_attrs;
	int cnt = 0;
	zfs_acl_locator_cb_t locate = { 0 };
	znode_hold_t *zh;

	if (zfsvfs->z_replay) {
	obj = vap->va_nodeid;
	now = vap->va_ctime; /* see zfs_replay_create() */
	gen = vap->va_nblocks; /* ditto */
	dnodesize = vap->va_fsid; /* ditto */
	} else {
	obj = 0;
	gethrestime(&now);
	gen = dmu_tx_get_txg(tx);
	dnodesize = dmu_objset_dnodesize(zfsvfs->z_os);
	}

	if (dnodesize == 0)
	dnodesize = DNODE_MIN_SIZE;

	obj_type = zfsvfs->z_use_sa ? DMU_OT_SA : DMU_OT_ZNODE;

	bonuslen = (obj_type == DMU_OT_SA) ?
	DN_BONUS_SIZE(dnodesize) : ZFS_OLD_ZNODE_PHYS_SIZE;

	/*
	* Create a new DMU object.
	*/
	/*
	* There's currently no mechanism for pre-reading the blocks that will
	* be needed to allocate a new object, so we accept the small chance
	* that there will be an i/o error and we will fail one of the
	* assertions below.
	*/
	if (S_ISDIR(vap->va_mode)) {
	if (zfsvfs->z_replay) {
	VERIFY0(zap_create_claim_norm_dnsize(zfsvfs->z_os, obj,
	zfsvfs->z_norm, DMU_OT_DIRECTORY_CONTENTS,
	obj_type, bonuslen, dnodesize, tx));
	} else {
	obj = zap_create_norm_dnsize(zfsvfs->z_os,
	zfsvfs->z_norm, DMU_OT_DIRECTORY_CONTENTS,
	obj_type, bonuslen, dnodesize, tx);
	}
	} else {
	if (zfsvfs->z_replay) {
	VERIFY0(dmu_object_claim_dnsize(zfsvfs->z_os, obj,
	DMU_OT_PLAIN_FILE_CONTENTS, 0,
	obj_type, bonuslen, dnodesize, tx));
	} else {
	obj = dmu_object_alloc_dnsize(zfsvfs->z_os,
	DMU_OT_PLAIN_FILE_CONTENTS, 0,
	obj_type, bonuslen, dnodesize, tx);
	}
	}

	zh = zfs_znode_hold_enter(zfsvfs, obj);
	VERIFY0(sa_buf_hold(zfsvfs->z_os, obj, NULL, &db));

	/*
	* If this is the root, fix up the half-initialized parent pointer
	* to reference the just-allocated physical data area.
	*/
	if (flag & IS_ROOT_NODE) {
	dzp->z_id = obj;
	}

	/*
	* If parent is an xattr, so am I.
	*/
	if (dzp->z_pflags & ZFS_XATTR) {
	flag \|= IS_XATTR;
	}

	if (zfsvfs->z_use_fuids)
	pflags = ZFS_ARCHIVE \| ZFS_AV_MODIFIED;
	else
	pflags = 0;

	if (S_ISDIR(vap->va_mode)) {
	size = 2; /* contents ("." and "..") */
	links = 2;
	} else {
	size = 0;
	links = (flag & IS_TMPFILE) ? 0 : 1;
	}

	if (S_ISBLK(vap->va_mode) \|\| S_ISCHR(vap->va_mode))
	rdev = vap->va_rdev;

	parent = dzp->z_id;
	mode = acl_ids->z_mode;
	if (flag & IS_XATTR)
	pflags \|= ZFS_XATTR;

	if (S_ISREG(vap->va_mode) \|\| S_ISDIR(vap->va_mode)) {
	/*
	* With ZFS_PROJID flag, we can easily know whether there is
	* project ID stored on disk or not. See zfs_space_delta_cb().
	*/
	if (obj_type != DMU_OT_ZNODE &&
	dmu_objset_projectquota_enabled(zfsvfs->z_os))
	pflags \|= ZFS_PROJID;

	/*
	* Inherit project ID from parent if required.
	*/
	projid = zfs_inherit_projid(dzp);
	if (dzp->z_pflags & ZFS_PROJINHERIT)
	pflags \|= ZFS_PROJINHERIT;
	}

	/*
	* No execs denied will be determined when zfs_mode_compute() is called.
	*/
	pflags \|= acl_ids->z_aclp->z_hints &
	(ZFS_ACL_TRIVIAL\|ZFS_INHERIT_ACE\|ZFS_ACL_AUTO_INHERIT\|
	ZFS_ACL_DEFAULTED\|ZFS_ACL_PROTECTED);

	ZFS_TIME_ENCODE(&now, crtime);
	ZFS_TIME_ENCODE(&now, ctime);

	if (vap->va_mask & ATTR_ATIME) {
	ZFS_TIME_ENCODE(&vap->va_atime, atime);
	} else {
	ZFS_TIME_ENCODE(&now, atime);
	}

	if (vap->va_mask & ATTR_MTIME) {
	ZFS_TIME_ENCODE(&vap->va_mtime, mtime);
	} else {
	ZFS_TIME_ENCODE(&now, mtime);
	}

	/* Now add in all of the "SA" attributes */
	VERIFY(0 == sa_handle_get_from_db(zfsvfs->z_os, db, NULL, SA_HDL_SHARED,
	&sa_hdl));

	/*
	* Setup the array of attributes to be replaced/set on the new file
	*
	* order for DMU_OT_ZNODE is critical since it needs to be constructed
	* in the old znode_phys_t format. Don't change this ordering
	*/
	sa_attrs = kmem_alloc(sizeof (sa_bulk_attr_t) * ZPL_END, KM_SLEEP);

	if (obj_type == DMU_OT_ZNODE) {
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_ATIME(zfsvfs),
	NULL, &atime, 16);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_MTIME(zfsvfs),
	NULL, &mtime, 16);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_CTIME(zfsvfs),
	NULL, &ctime, 16);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_CRTIME(zfsvfs),
	NULL, &crtime, 16);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_GEN(zfsvfs),
	NULL, &gen, 8);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_MODE(zfsvfs),
	NULL, &mode, 8);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_SIZE(zfsvfs),
	NULL, &size, 8);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_PARENT(zfsvfs),
	NULL, &parent, 8);
	} else {
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_MODE(zfsvfs),
	NULL, &mode, 8);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_SIZE(zfsvfs),
	NULL, &size, 8);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_GEN(zfsvfs),
	NULL, &gen, 8);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_UID(zfsvfs),
	NULL, &acl_ids->z_fuid, 8);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_GID(zfsvfs),
	NULL, &acl_ids->z_fgid, 8);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_PARENT(zfsvfs),
	NULL, &parent, 8);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_FLAGS(zfsvfs),
	NULL, &pflags, 8);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_ATIME(zfsvfs),
	NULL, &atime, 16);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_MTIME(zfsvfs),
	NULL, &mtime, 16);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_CTIME(zfsvfs),
	NULL, &ctime, 16);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_CRTIME(zfsvfs),
	NULL, &crtime, 16);
	}

	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_LINKS(zfsvfs), NULL, &links, 8);

	if (obj_type == DMU_OT_ZNODE) {
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_XATTR(zfsvfs), NULL,
	&empty_xattr, 8);
	} else if (dmu_objset_projectquota_enabled(zfsvfs->z_os) &&
	pflags & ZFS_PROJID) {
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_PROJID(zfsvfs),
	NULL, &projid, 8);
	}
	if (obj_type == DMU_OT_ZNODE \|\|
	(S_ISBLK(vap->va_mode) \|\| S_ISCHR(vap->va_mode))) {
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_RDEV(zfsvfs),
	NULL, &rdev, 8);
	}
	if (obj_type == DMU_OT_ZNODE) {
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_FLAGS(zfsvfs),
	NULL, &pflags, 8);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_UID(zfsvfs), NULL,
	&acl_ids->z_fuid, 8);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_GID(zfsvfs), NULL,
	&acl_ids->z_fgid, 8);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_PAD(zfsvfs), NULL, pad,
	sizeof (uint64_t) * 4);
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_ZNODE_ACL(zfsvfs), NULL,
	&acl_phys, sizeof (zfs_acl_phys_t));
	} else if (acl_ids->z_aclp->z_version >= ZFS_ACL_VERSION_FUID) {
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_DACL_COUNT(zfsvfs), NULL,
	&acl_ids->z_aclp->z_acl_count, 8);
	locate.cb_aclp = acl_ids->z_aclp;
	SA_ADD_BULK_ATTR(sa_attrs, cnt, SA_ZPL_DACL_ACES(zfsvfs),
	zfs_acl_data_locator, &locate,
	acl_ids->z_aclp->z_acl_bytes);
	mode = zfs_mode_compute(mode, acl_ids->z_aclp, &pflags,
	acl_ids->z_fuid, acl_ids->z_fgid);
	}

	VERIFY(sa_replace_all_by_template(sa_hdl, sa_attrs, cnt, tx) == 0);

	if (!(flag & IS_ROOT_NODE)) {
	/*
	* The call to zfs_znode_alloc() may fail if memory is low
	* via the call path: alloc_inode() -> inode_init_always() ->
	* security_inode_alloc() -> inode_alloc_security(). Since
	* the existing code is written such that zfs_mknode() can
	* not fail retry until sufficient memory has been reclaimed.
	*/
	do {
	*zpp = zfs_znode_alloc(zfsvfs, db, 0, obj_type, sa_hdl);
	} while (*zpp == NULL);

	VERIFY(*zpp != NULL);
	VERIFY(dzp != NULL);
	} else {
	/*
	* If we are creating the root node, the "parent" we
	* passed in is the znode for the root.
	*/
	*zpp = dzp;

	(*zpp)->z_sa_hdl = sa_hdl;
	}

	(*zpp)->z_pflags = pflags;
	(zpp)->z_mode = ZTOI(zpp)->i_mode = mode;
	(*zpp)->z_dnodesize = dnodesize;
	(*zpp)->z_projid = projid;

	if (obj_type == DMU_OT_ZNODE \|\|
	acl_ids->z_aclp->z_version < ZFS_ACL_VERSION_FUID) {
	VERIFY0(zfs_aclset_common(*zpp, acl_ids->z_aclp, cr, tx));
	}
	kmem_free(sa_attrs, sizeof (sa_bulk_attr_t) * ZPL_END);
	zfs_znode_hold_exit(zfsvfs, zh);
	}

	/*
	* Update in-core attributes. It is assumed the caller will be doing an
	* sa_bulk_update to push the changes out.
	*/
	void
	zfs_xvattr_set(znode_t zp, xvattr_t xvap, dmu_tx_t *tx)
	{
	xoptattr_t *xoap;
	boolean_t update_inode = B_FALSE;

	xoap = xva_getxoptattr(xvap);
	ASSERT(xoap);

	if (XVA_ISSET_REQ(xvap, XAT_CREATETIME)) {
	uint64_t times[2];
	ZFS_TIME_ENCODE(&xoap->xoa_createtime, times);
	(void) sa_update(zp->z_sa_hdl, SA_ZPL_CRTIME(ZTOZSB(zp)),
	&times, sizeof (times), tx);
	XVA_SET_RTN(xvap, XAT_CREATETIME);
	}
	if (XVA_ISSET_REQ(xvap, XAT_READONLY)) {
	ZFS_ATTR_SET(zp, ZFS_READONLY, xoap->xoa_readonly,
	zp->z_pflags, tx);
	XVA_SET_RTN(xvap, XAT_READONLY);
	}
	if (XVA_ISSET_REQ(xvap, XAT_HIDDEN)) {
	ZFS_ATTR_SET(zp, ZFS_HIDDEN, xoap->xoa_hidden,
	zp->z_pflags, tx);
	XVA_SET_RTN(xvap, XAT_HIDDEN);
	}
	if (XVA_ISSET_REQ(xvap, XAT_SYSTEM)) {
	ZFS_ATTR_SET(zp, ZFS_SYSTEM, xoap->xoa_system,
	zp->z_pflags, tx);
	XVA_SET_RTN(xvap, XAT_SYSTEM);
	}
	if (XVA_ISSET_REQ(xvap, XAT_ARCHIVE)) {
	ZFS_ATTR_SET(zp, ZFS_ARCHIVE, xoap->xoa_archive,
	zp->z_pflags, tx);
	XVA_SET_RTN(xvap, XAT_ARCHIVE);
	}
	if (XVA_ISSET_REQ(xvap, XAT_IMMUTABLE)) {
	ZFS_ATTR_SET(zp, ZFS_IMMUTABLE, xoap->xoa_immutable,
	zp->z_pflags, tx);
	XVA_SET_RTN(xvap, XAT_IMMUTABLE);

	update_inode = B_TRUE;
	}
	if (XVA_ISSET_REQ(xvap, XAT_NOUNLINK)) {
	ZFS_ATTR_SET(zp, ZFS_NOUNLINK, xoap->xoa_nounlink,
	zp->z_pflags, tx);
	XVA_SET_RTN(xvap, XAT_NOUNLINK);
	}
	if (XVA_ISSET_REQ(xvap, XAT_APPENDONLY)) {
	ZFS_ATTR_SET(zp, ZFS_APPENDONLY, xoap->xoa_appendonly,
	zp->z_pflags, tx);
	XVA_SET_RTN(xvap, XAT_APPENDONLY);

	update_inode = B_TRUE;
	}
	if (XVA_ISSET_REQ(xvap, XAT_NODUMP)) {
	ZFS_ATTR_SET(zp, ZFS_NODUMP, xoap->xoa_nodump,
	zp->z_pflags, tx);
	XVA_SET_RTN(xvap, XAT_NODUMP);
	}
	if (XVA_ISSET_REQ(xvap, XAT_OPAQUE)) {
	ZFS_ATTR_SET(zp, ZFS_OPAQUE, xoap->xoa_opaque,
	zp->z_pflags, tx);
	XVA_SET_RTN(xvap, XAT_OPAQUE);
	}
	if (XVA_ISSET_REQ(xvap, XAT_AV_QUARANTINED)) {
	ZFS_ATTR_SET(zp, ZFS_AV_QUARANTINED,
	xoap->xoa_av_quarantined, zp->z_pflags, tx);
	XVA_SET_RTN(xvap, XAT_AV_QUARANTINED);
	}
	if (XVA_ISSET_REQ(xvap, XAT_AV_MODIFIED)) {
	ZFS_ATTR_SET(zp, ZFS_AV_MODIFIED, xoap->xoa_av_modified,
	zp->z_pflags, tx);
	XVA_SET_RTN(xvap, XAT_AV_MODIFIED);
	}
	if (XVA_ISSET_REQ(xvap, XAT_AV_SCANSTAMP)) {
	zfs_sa_set_scanstamp(zp, xvap, tx);
	XVA_SET_RTN(xvap, XAT_AV_SCANSTAMP);
	}
	if (XVA_ISSET_REQ(xvap, XAT_REPARSE)) {
	ZFS_ATTR_SET(zp, ZFS_REPARSE, xoap->xoa_reparse,
	zp->z_pflags, tx);
	XVA_SET_RTN(xvap, XAT_REPARSE);
	}
	if (XVA_ISSET_REQ(xvap, XAT_OFFLINE)) {
	ZFS_ATTR_SET(zp, ZFS_OFFLINE, xoap->xoa_offline,
	zp->z_pflags, tx);
	XVA_SET_RTN(xvap, XAT_OFFLINE);
	}
	if (XVA_ISSET_REQ(xvap, XAT_SPARSE)) {
	ZFS_ATTR_SET(zp, ZFS_SPARSE, xoap->xoa_sparse,
	zp->z_pflags, tx);
	XVA_SET_RTN(xvap, XAT_SPARSE);
	}
	if (XVA_ISSET_REQ(xvap, XAT_PROJINHERIT)) {
	ZFS_ATTR_SET(zp, ZFS_PROJINHERIT, xoap->xoa_projinherit,
	zp->z_pflags, tx);
	XVA_SET_RTN(xvap, XAT_PROJINHERIT);
	}

	if (update_inode)
	zfs_set_inode_flags(zp, ZTOI(zp));
	}

	int
	zfs_zget(zfsvfs_t zfsvfs, uint64_t obj_num, znode_t *zpp)
	{
	dmu_object_info_t doi;
	dmu_buf_t *db;
	znode_t *zp;
	znode_hold_t *zh;
	int err;
	sa_handle_t *hdl;

	*zpp = NULL;

	again:
	zh = zfs_znode_hold_enter(zfsvfs, obj_num);

	err = sa_buf_hold(zfsvfs->z_os, obj_num, NULL, &db);
	if (err) {
	zfs_znode_hold_exit(zfsvfs, zh);
	return (err);
	}

	dmu_object_info_from_db(db, &doi);
	if (doi.doi_bonus_type != DMU_OT_SA &&
	(doi.doi_bonus_type != DMU_OT_ZNODE \|\|
	(doi.doi_bonus_type == DMU_OT_ZNODE &&
	doi.doi_bonus_size < sizeof (znode_phys_t)))) {
	sa_buf_rele(db, NULL);
	zfs_znode_hold_exit(zfsvfs, zh);
	return (SET_ERROR(EINVAL));
	}

	hdl = dmu_buf_get_user(db);
	if (hdl != NULL) {
	zp = sa_get_userdata(hdl);


	/*
	* Since "SA" does immediate eviction we
	* should never find a sa handle that doesn't
	* know about the znode.
	*/

	ASSERT3P(zp, !=, NULL);

	mutex_enter(&zp->z_lock);
	ASSERT3U(zp->z_id, ==, obj_num);
	/*
	* If zp->z_unlinked is set, the znode is already marked
	* for deletion and should not be discovered. Check this
	* after checking igrab() due to fsetxattr() & O_TMPFILE.
	*
	* If igrab() returns NULL the VFS has independently
	* determined the inode should be evicted and has
	* called iput_final() to start the eviction process.
	* The SA handle is still valid but because the VFS
	* requires that the eviction succeed we must drop
	* our locks and references to allow the eviction to
	* complete. The zfs_zget() may then be retried.
	*
	* This unlikely case could be optimized by registering
	* a sops->drop_inode() callback. The callback would
	* need to detect the active SA hold thereby informing
	* the VFS that this inode should not be evicted.
	*/
	if (igrab(ZTOI(zp)) == NULL) {
	if (zp->z_unlinked)
	err = SET_ERROR(ENOENT);
	else
	err = SET_ERROR(EAGAIN);
	} else {
	*zpp = zp;
	err = 0;
	}

	mutex_exit(&zp->z_lock);
	sa_buf_rele(db, NULL);
	zfs_znode_hold_exit(zfsvfs, zh);

	if (err == EAGAIN) {
	/* inode might need this to finish evict */
	cond_resched();
	goto again;
	}
	return (err);
	}

	/*
	* Not found create new znode/vnode but only if file exists.
	*
	* There is a small window where zfs_vget() could
	* find this object while a file create is still in
	* progress. This is checked for in zfs_znode_alloc()
	*
	* if zfs_znode_alloc() fails it will drop the hold on the
	* bonus buffer.
	*/
	zp = zfs_znode_alloc(zfsvfs, db, doi.doi_data_block_size,
	doi.doi_bonus_type, NULL);
	if (zp == NULL) {
	err = SET_ERROR(ENOENT);
	} else {
	*zpp = zp;
	}
	zfs_znode_hold_exit(zfsvfs, zh);
	return (err);
	}

	int
	zfs_rezget(znode_t *zp)
	{
	zfsvfs_t *zfsvfs = ZTOZSB(zp);
	dmu_object_info_t doi;
	dmu_buf_t *db;
	uint64_t obj_num = zp->z_id;
	uint64_t mode;
	uint64_t links;
	sa_bulk_attr_t bulk[10];
	int err;
	int count = 0;
	uint64_t gen;
	uint64_t z_uid, z_gid;
	uint64_t atime[2], mtime[2], ctime[2];
	uint64_t projid = ZFS_DEFAULT_PROJID;
	znode_hold_t *zh;

	/*
	* skip ctldir, otherwise they will always get invalidated. This will
	* cause funny behaviour for the mounted snapdirs. Especially for
	* Linux >= 3.18, d_invalidate will detach the mountpoint and prevent
	* anyone automount it again as long as someone is still using the
	* detached mount.
	*/
	if (zp->z_is_ctldir)
	return (0);

	zh = zfs_znode_hold_enter(zfsvfs, obj_num);

	mutex_enter(&zp->z_acl_lock);
	if (zp->z_acl_cached) {
	zfs_acl_free(zp->z_acl_cached);
	zp->z_acl_cached = NULL;
	}
	mutex_exit(&zp->z_acl_lock);

	rw_enter(&zp->z_xattr_lock, RW_WRITER);
	if (zp->z_xattr_cached) {
	nvlist_free(zp->z_xattr_cached);
	zp->z_xattr_cached = NULL;
	}
	rw_exit(&zp->z_xattr_lock);

	ASSERT(zp->z_sa_hdl == NULL);
	err = sa_buf_hold(zfsvfs->z_os, obj_num, NULL, &db);
	if (err) {
	zfs_znode_hold_exit(zfsvfs, zh);
	return (err);
	}

	dmu_object_info_from_db(db, &doi);
	if (doi.doi_bonus_type != DMU_OT_SA &&
	(doi.doi_bonus_type != DMU_OT_ZNODE \|\|
	(doi.doi_bonus_type == DMU_OT_ZNODE &&
	doi.doi_bonus_size < sizeof (znode_phys_t)))) {
	sa_buf_rele(db, NULL);
	zfs_znode_hold_exit(zfsvfs, zh);
	return (SET_ERROR(EINVAL));
	}

	zfs_znode_sa_init(zfsvfs, zp, db, doi.doi_bonus_type, NULL);

	/* reload cached values */
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_GEN(zfsvfs), NULL,
	&gen, sizeof (gen));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_SIZE(zfsvfs), NULL,
	&zp->z_size, sizeof (zp->z_size));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_LINKS(zfsvfs), NULL,
	&links, sizeof (links));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zfsvfs), NULL,
	&zp->z_pflags, sizeof (zp->z_pflags));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_UID(zfsvfs), NULL,
	&z_uid, sizeof (z_uid));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_GID(zfsvfs), NULL,
	&z_gid, sizeof (z_gid));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MODE(zfsvfs), NULL,
	&mode, sizeof (mode));
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_ATIME(zfsvfs), NULL,
	&atime, 16);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zfsvfs), NULL,
	&mtime, 16);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs), NULL,
	&ctime, 16);

	if (sa_bulk_lookup(zp->z_sa_hdl, bulk, count)) {
	zfs_znode_dmu_fini(zp);
	zfs_znode_hold_exit(zfsvfs, zh);
	return (SET_ERROR(EIO));
	}

	if (dmu_objset_projectquota_enabled(zfsvfs->z_os)) {
	err = sa_lookup(zp->z_sa_hdl, SA_ZPL_PROJID(zfsvfs),
	&projid, 8);
	if (err != 0 && err != ENOENT) {
	zfs_znode_dmu_fini(zp);
	zfs_znode_hold_exit(zfsvfs, zh);
	return (SET_ERROR(err));
	}
	}

	zp->z_projid = projid;
	zp->z_mode = ZTOI(zp)->i_mode = mode;
	zfs_uid_write(ZTOI(zp), z_uid);
	zfs_gid_write(ZTOI(zp), z_gid);

	ZFS_TIME_DECODE(&ZTOI(zp)->i_atime, atime);
	ZFS_TIME_DECODE(&ZTOI(zp)->i_mtime, mtime);
	ZFS_TIME_DECODE(&ZTOI(zp)->i_ctime, ctime);

	if ((uint32_t)gen != ZTOI(zp)->i_generation) {
	zfs_znode_dmu_fini(zp);
	zfs_znode_hold_exit(zfsvfs, zh);
	return (SET_ERROR(EIO));
	}

	set_nlink(ZTOI(zp), (uint32_t)links);
	zfs_set_inode_flags(zp, ZTOI(zp));

	zp->z_blksz = doi.doi_data_block_size;
	zp->z_atime_dirty = B_FALSE;
	zfs_znode_update_vfs(zp);

	/*
	* If the file has zero links, then it has been unlinked on the send
	* side and it must be in the received unlinked set.
	* We call zfs_znode_dmu_fini() now to prevent any accesses to the
	* stale data and to prevent automatic removal of the file in
	* zfs_zinactive(). The file will be removed either when it is removed
	* on the send side and the next incremental stream is received or
	* when the unlinked set gets processed.
	*/
	zp->z_unlinked = (ZTOI(zp)->i_nlink == 0);
	if (zp->z_unlinked)
	zfs_znode_dmu_fini(zp);

	zfs_znode_hold_exit(zfsvfs, zh);

	return (0);
	}

	void
	zfs_znode_delete(znode_t zp, dmu_tx_t tx)
	{
	zfsvfs_t *zfsvfs = ZTOZSB(zp);
	objset_t *os = zfsvfs->z_os;
	uint64_t obj = zp->z_id;
	uint64_t acl_obj = zfs_external_acl(zp);
	znode_hold_t *zh;

	zh = zfs_znode_hold_enter(zfsvfs, obj);
	if (acl_obj) {
	VERIFY(!zp->z_is_sa);
	VERIFY(0 == dmu_object_free(os, acl_obj, tx));
	}
	VERIFY(0 == dmu_object_free(os, obj, tx));
	zfs_znode_dmu_fini(zp);
	zfs_znode_hold_exit(zfsvfs, zh);
	}

	void
	zfs_zinactive(znode_t *zp)
	{
	zfsvfs_t *zfsvfs = ZTOZSB(zp);
	uint64_t z_id = zp->z_id;
	znode_hold_t *zh;

	ASSERT(zp->z_sa_hdl);

	/*
	* Don't allow a zfs_zget() while were trying to release this znode.
	*/
	zh = zfs_znode_hold_enter(zfsvfs, z_id);

	mutex_enter(&zp->z_lock);

	/*
	* If this was the last reference to a file with no links, remove
	* the file from the file system unless the file system is mounted
	* read-only. That can happen, for example, if the file system was
	* originally read-write, the file was opened, then unlinked and
	* the file system was made read-only before the file was finally
	* closed. The file will remain in the unlinked set.
	*/
	if (zp->z_unlinked) {
	ASSERT(!zfsvfs->z_issnap);
	if (!zfs_is_readonly(zfsvfs) && !zfs_unlink_suspend_progress) {
	mutex_exit(&zp->z_lock);
	zfs_znode_hold_exit(zfsvfs, zh);
	zfs_rmnode(zp);
	return;
	}
	}

	mutex_exit(&zp->z_lock);
	zfs_znode_dmu_fini(zp);

	zfs_znode_hold_exit(zfsvfs, zh);
	}

	#if defined(HAVE_INODE_TIMESPEC64_TIMES)
	#define zfs_compare_timespec timespec64_compare
	#else
	#define zfs_compare_timespec timespec_compare
	#endif

	/*
	* Determine whether the znode's atime must be updated. The logic mostly
	* duplicates the Linux kernel's relatime_need_update() functionality.
	* This function is only called if the underlying filesystem actually has
	* atime updates enabled.
	*/
	boolean_t
	zfs_relatime_need_update(const struct inode *ip)
	{
	inode_timespec_t now;

	gethrestime(&now);
	/*
	* In relatime mode, only update the atime if the previous atime
	* is earlier than either the ctime or mtime or if at least a day
	* has passed since the last update of atime.
	*/
	if (zfs_compare_timespec(&ip->i_mtime, &ip->i_atime) >= 0)
	return (B_TRUE);

	if (zfs_compare_timespec(&ip->i_ctime, &ip->i_atime) >= 0)
	return (B_TRUE);

	if ((hrtime_t)now.tv_sec - (hrtime_t)ip->i_atime.tv_sec >= 246060)
	return (B_TRUE);

	return (B_FALSE);
	}

	/*
	* Prepare to update znode time stamps.
	*
	* IN: zp - znode requiring timestamp update
	* flag - ATTR_MTIME, ATTR_CTIME flags
	*
	* OUT: zp - z_seq
	* mtime - new mtime
	* ctime - new ctime
	*
	* Note: We don't update atime here, because we rely on Linux VFS to do
	* atime updating.
	*/
	void
	zfs_tstamp_update_setup(znode_t *zp, uint_t flag, uint64_t mtime[2],
	uint64_t ctime[2])
	{
	inode_timespec_t now;

	gethrestime(&now);

	zp->z_seq++;

	if (flag & ATTR_MTIME) {
	ZFS_TIME_ENCODE(&now, mtime);
	ZFS_TIME_DECODE(&(ZTOI(zp)->i_mtime), mtime);
	if (ZTOZSB(zp)->z_use_fuids) {
	zp->z_pflags \|= (ZFS_ARCHIVE \|
	ZFS_AV_MODIFIED);
	}
	}

	if (flag & ATTR_CTIME) {
	ZFS_TIME_ENCODE(&now, ctime);
	ZFS_TIME_DECODE(&(ZTOI(zp)->i_ctime), ctime);
	if (ZTOZSB(zp)->z_use_fuids)
	zp->z_pflags \|= ZFS_ARCHIVE;
	}
	}

	/*
	* Grow the block size for a file.
	*
	* IN: zp - znode of file to free data in.
	* size - requested block size
	* tx - open transaction.
	*
	* NOTE: this function assumes that the znode is write locked.
	*/
	void
	zfs_grow_blocksize(znode_t zp, uint64_t size, dmu_tx_t tx)
	{
	int error;
	u_longlong_t dummy;

	if (size <= zp->z_blksz)
	return;
	/*
	* If the file size is already greater than the current blocksize,
	* we will not grow. If there is more than one block in a file,
	* the blocksize cannot change.
	*/
	if (zp->z_blksz && zp->z_size > zp->z_blksz)
	return;

	error = dmu_object_set_blocksize(ZTOZSB(zp)->z_os, zp->z_id,
	size, 0, tx);

	if (error == ENOTSUP)
	return;
	ASSERT0(error);

	/* What blocksize did we actually get? */
	dmu_object_size_from_db(sa_get_db(zp->z_sa_hdl), &zp->z_blksz, &dummy);
	}

	/*
	* Increase the file length
	*
	* IN: zp - znode of file to free data in.
	* end - new end-of-file
	*
	* RETURN: 0 on success, error code on failure
	*/
	static int
	zfs_extend(znode_t *zp, uint64_t end)
	{
	zfsvfs_t *zfsvfs = ZTOZSB(zp);
	dmu_tx_t *tx;
	zfs_locked_range_t *lr;
	uint64_t newblksz;
	int error;

	/*
	* We will change zp_size, lock the whole file.
	*/
	lr = zfs_rangelock_enter(&zp->z_rangelock, 0, UINT64_MAX, RL_WRITER);

	/*
	* Nothing to do if file already at desired length.
	*/
	if (end <= zp->z_size) {
	zfs_rangelock_exit(lr);
	return (0);
	}
	tx = dmu_tx_create(zfsvfs->z_os);
	dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
	zfs_sa_upgrade_txholds(tx, zp);
	if (end > zp->z_blksz &&
	(!ISP2(zp->z_blksz) \|\| zp->z_blksz < zfsvfs->z_max_blksz)) {
	/*
	* We are growing the file past the current block size.
	*/
	if (zp->z_blksz > ZTOZSB(zp)->z_max_blksz) {
	/*
	* File's blocksize is already larger than the
	* "recordsize" property. Only let it grow to
	* the next power of 2.
	*/
	ASSERT(!ISP2(zp->z_blksz));
	newblksz = MIN(end, 1 << highbit64(zp->z_blksz));
	} else {
	newblksz = MIN(end, ZTOZSB(zp)->z_max_blksz);
	}
	dmu_tx_hold_write(tx, zp->z_id, 0, newblksz);
	} else {
	newblksz = 0;
	}

	error = dmu_tx_assign(tx, TXG_WAIT);
	if (error) {
	dmu_tx_abort(tx);
	zfs_rangelock_exit(lr);
	return (error);
	}

	if (newblksz)
	zfs_grow_blocksize(zp, newblksz, tx);

	zp->z_size = end;

	VERIFY(0 == sa_update(zp->z_sa_hdl, SA_ZPL_SIZE(ZTOZSB(zp)),
	&zp->z_size, sizeof (zp->z_size), tx));

	zfs_rangelock_exit(lr);

	dmu_tx_commit(tx);

	return (0);
	}

	/*
	* zfs_zero_partial_page - Modeled after update_pages() but
	* with different arguments and semantics for use by zfs_freesp().
	*
	* Zeroes a piece of a single page cache entry for zp at offset
	* start and length len.
	*
	* Caller must acquire a range lock on the file for the region
	* being zeroed in order that the ARC and page cache stay in sync.
	*/
	static void
	zfs_zero_partial_page(znode_t *zp, uint64_t start, uint64_t len)
	{
	struct address_space *mp = ZTOI(zp)->i_mapping;
	struct page *pp;
	int64_t off;
	void *pb;

	ASSERT((start & PAGE_MASK) == ((start + len - 1) & PAGE_MASK));

	off = start & (PAGE_SIZE - 1);
	start &= PAGE_MASK;

	pp = find_lock_page(mp, start >> PAGE_SHIFT);
	if (pp) {
	if (mapping_writably_mapped(mp))
	flush_dcache_page(pp);

	pb = kmap(pp);
	bzero(pb + off, len);
	kunmap(pp);

	if (mapping_writably_mapped(mp))
	flush_dcache_page(pp);

	mark_page_accessed(pp);
	SetPageUptodate(pp);
	ClearPageError(pp);
	unlock_page(pp);
	put_page(pp);
	}
	}

	/*
	* Free space in a file.
	*
	* IN: zp - znode of file to free data in.
	* off - start of section to free.
	* len - length of section to free.
	*
	* RETURN: 0 on success, error code on failure
	*/
	static int
	zfs_free_range(znode_t *zp, uint64_t off, uint64_t len)
	{
	zfsvfs_t *zfsvfs = ZTOZSB(zp);
	zfs_locked_range_t *lr;
	int error;

	/*
	* Lock the range being freed.
	*/
	lr = zfs_rangelock_enter(&zp->z_rangelock, off, len, RL_WRITER);

	/*
	* Nothing to do if file already at desired length.
	*/
	if (off >= zp->z_size) {
	zfs_rangelock_exit(lr);
	return (0);
	}

	if (off + len > zp->z_size)
	len = zp->z_size - off;

	error = dmu_free_long_range(zfsvfs->z_os, zp->z_id, off, len);

	/*
	* Zero partial page cache entries. This must be done under a
	* range lock in order to keep the ARC and page cache in sync.
	*/
	if (zp->z_is_mapped) {
	loff_t first_page, last_page, page_len;
	loff_t first_page_offset, last_page_offset;

	/* first possible full page in hole */
	first_page = (off + PAGE_SIZE - 1) >> PAGE_SHIFT;
	/* last page of hole */
	last_page = (off + len) >> PAGE_SHIFT;

	/* offset of first_page */
	first_page_offset = first_page << PAGE_SHIFT;
	/* offset of last_page */
	last_page_offset = last_page << PAGE_SHIFT;

	/* truncate whole pages */
	if (last_page_offset > first_page_offset) {
	truncate_inode_pages_range(ZTOI(zp)->i_mapping,
	first_page_offset, last_page_offset - 1);
	}

	/* truncate sub-page ranges */
	if (first_page > last_page) {
	/* entire punched area within a single page */
	zfs_zero_partial_page(zp, off, len);
	} else {
	/* beginning of punched area at the end of a page */
	page_len = first_page_offset - off;
	if (page_len > 0)
	zfs_zero_partial_page(zp, off, page_len);

	/* end of punched area at the beginning of a page */
	page_len = off + len - last_page_offset;
	if (page_len > 0)
	zfs_zero_partial_page(zp, last_page_offset,
	page_len);
	}
	}
	zfs_rangelock_exit(lr);

	return (error);
	}

	/*
	* Truncate a file
	*
	* IN: zp - znode of file to free data in.
	* end - new end-of-file.
	*
	* RETURN: 0 on success, error code on failure
	*/
	static int
	zfs_trunc(znode_t *zp, uint64_t end)
	{
	zfsvfs_t *zfsvfs = ZTOZSB(zp);
	dmu_tx_t *tx;
	zfs_locked_range_t *lr;
	int error;
	sa_bulk_attr_t bulk[2];
	int count = 0;

	/*
	* We will change zp_size, lock the whole file.
	*/
	lr = zfs_rangelock_enter(&zp->z_rangelock, 0, UINT64_MAX, RL_WRITER);

	/*
	* Nothing to do if file already at desired length.
	*/
	if (end >= zp->z_size) {
	zfs_rangelock_exit(lr);
	return (0);
	}

	error = dmu_free_long_range(zfsvfs->z_os, zp->z_id, end,
	DMU_OBJECT_END);
	if (error) {
	zfs_rangelock_exit(lr);
	return (error);
	}
	tx = dmu_tx_create(zfsvfs->z_os);
	dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
	zfs_sa_upgrade_txholds(tx, zp);
	dmu_tx_mark_netfree(tx);
	error = dmu_tx_assign(tx, TXG_WAIT);
	if (error) {
	dmu_tx_abort(tx);
	zfs_rangelock_exit(lr);
	return (error);
	}

	zp->z_size = end;
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_SIZE(zfsvfs),
	NULL, &zp->z_size, sizeof (zp->z_size));

	if (end == 0) {
	zp->z_pflags &= ~ZFS_SPARSE;
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zfsvfs),
	NULL, &zp->z_pflags, 8);
	}
	VERIFY(sa_bulk_update(zp->z_sa_hdl, bulk, count, tx) == 0);

	dmu_tx_commit(tx);
	zfs_rangelock_exit(lr);

	return (0);
	}

	/*
	* Free space in a file
	*
	* IN: zp - znode of file to free data in.
	* off - start of range
	* len - end of range (0 => EOF)
	* flag - current file open mode flags.
	* log - TRUE if this action should be logged
	*
	* RETURN: 0 on success, error code on failure
	*/
	int
	zfs_freesp(znode_t *zp, uint64_t off, uint64_t len, int flag, boolean_t log)
	{
	dmu_tx_t *tx;
	zfsvfs_t *zfsvfs = ZTOZSB(zp);
	zilog_t *zilog = zfsvfs->z_log;
	uint64_t mode;
	uint64_t mtime[2], ctime[2];
	sa_bulk_attr_t bulk[3];
	int count = 0;
	int error;

	if ((error = sa_lookup(zp->z_sa_hdl, SA_ZPL_MODE(zfsvfs), &mode,
	sizeof (mode))) != 0)
	return (error);

	if (off > zp->z_size) {
	error = zfs_extend(zp, off+len);
	if (error == 0 && log)
	goto log;
	goto out;
	}

	if (len == 0) {
	error = zfs_trunc(zp, off);
	} else {
	if ((error = zfs_free_range(zp, off, len)) == 0 &&
	off + len > zp->z_size)
	error = zfs_extend(zp, off+len);
	}
	if (error \|\| !log)
	goto out;
	log:
	tx = dmu_tx_create(zfsvfs->z_os);
	dmu_tx_hold_sa(tx, zp->z_sa_hdl, B_FALSE);
	zfs_sa_upgrade_txholds(tx, zp);
	error = dmu_tx_assign(tx, TXG_WAIT);
	if (error) {
	dmu_tx_abort(tx);
	goto out;
	}

	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_MTIME(zfsvfs), NULL, mtime, 16);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_CTIME(zfsvfs), NULL, ctime, 16);
	SA_ADD_BULK_ATTR(bulk, count, SA_ZPL_FLAGS(zfsvfs),
	NULL, &zp->z_pflags, 8);
	zfs_tstamp_update_setup(zp, CONTENT_MODIFIED, mtime, ctime);
	error = sa_bulk_update(zp->z_sa_hdl, bulk, count, tx);
	ASSERT(error == 0);

	zfs_log_truncate(zilog, tx, TX_TRUNCATE, zp, off, len);

	dmu_tx_commit(tx);

	zfs_znode_update_vfs(zp);
	error = 0;

	out:
	/*
	* Truncate the page cache - for file truncate operations, use
	* the purpose-built API for truncations. For punching operations,
	* the truncation is handled under a range lock in zfs_free_range.
	*/
	if (len == 0)
	truncate_setsize(ZTOI(zp), off);
	return (error);
	}

	void
	zfs_create_fs(objset_t os, cred_t cr, nvlist_t zplprops, dmu_tx_t tx)
	{
	struct super_block *sb;
	zfsvfs_t *zfsvfs;
	uint64_t moid, obj, sa_obj, version;
	uint64_t sense = ZFS_CASE_SENSITIVE;
	uint64_t norm = 0;
	nvpair_t *elem;
	int size;
	int error;
	int i;
	znode_t *rootzp = NULL;
	vattr_t vattr;
	znode_t *zp;
	zfs_acl_ids_t acl_ids;

	/*
	* First attempt to create master node.
	*/
	/*
	* In an empty objset, there are no blocks to read and thus
	* there can be no i/o errors (which we assert below).
	*/
	moid = MASTER_NODE_OBJ;
	error = zap_create_claim(os, moid, DMU_OT_MASTER_NODE,
	DMU_OT_NONE, 0, tx);
	ASSERT(error == 0);

	/*
	* Set starting attributes.
	*/
	version = zfs_zpl_version_map(spa_version(dmu_objset_spa(os)));
	elem = NULL;
	while ((elem = nvlist_next_nvpair(zplprops, elem)) != NULL) {
	/* For the moment we expect all zpl props to be uint64_ts */
	uint64_t val;
	char *name;

	ASSERT(nvpair_type(elem) == DATA_TYPE_UINT64);
	VERIFY(nvpair_value_uint64(elem, &val) == 0);
	name = nvpair_name(elem);
	if (strcmp(name, zfs_prop_to_name(ZFS_PROP_VERSION)) == 0) {
	if (val < version)
	version = val;
	} else {
	error = zap_update(os, moid, name, 8, 1, &val, tx);
	}
	ASSERT(error == 0);
	if (strcmp(name, zfs_prop_to_name(ZFS_PROP_NORMALIZE)) == 0)
	norm = val;
	else if (strcmp(name, zfs_prop_to_name(ZFS_PROP_CASE)) == 0)
	sense = val;
	}
	ASSERT(version != 0);
	error = zap_update(os, moid, ZPL_VERSION_STR, 8, 1, &version, tx);

	/*
	* Create zap object used for SA attribute registration
	*/

	if (version >= ZPL_VERSION_SA) {
	sa_obj = zap_create(os, DMU_OT_SA_MASTER_NODE,
	DMU_OT_NONE, 0, tx);
	error = zap_add(os, moid, ZFS_SA_ATTRS, 8, 1, &sa_obj, tx);
	ASSERT(error == 0);
	} else {
	sa_obj = 0;
	}
	/*
	* Create a delete queue.
	*/
	obj = zap_create(os, DMU_OT_UNLINKED_SET, DMU_OT_NONE, 0, tx);

	error = zap_add(os, moid, ZFS_UNLINKED_SET, 8, 1, &obj, tx);
	ASSERT(error == 0);

	/*
	* Create root znode. Create minimal znode/inode/zfsvfs/sb
	* to allow zfs_mknode to work.
	*/
	vattr.va_mask = ATTR_MODE\|ATTR_UID\|ATTR_GID;
	vattr.va_mode = S_IFDIR\|0755;
	vattr.va_uid = crgetuid(cr);
	vattr.va_gid = crgetgid(cr);

	rootzp = kmem_cache_alloc(znode_cache, KM_SLEEP);
	rootzp->z_unlinked = B_FALSE;
	rootzp->z_atime_dirty = B_FALSE;
	rootzp->z_is_sa = USE_SA(version, os);
	rootzp->z_pflags = 0;

	zfsvfs = kmem_zalloc(sizeof (zfsvfs_t), KM_SLEEP);
	zfsvfs->z_os = os;
	zfsvfs->z_parent = zfsvfs;
	zfsvfs->z_version = version;
	zfsvfs->z_use_fuids = USE_FUIDS(version, os);
	zfsvfs->z_use_sa = USE_SA(version, os);
	zfsvfs->z_norm = norm;

	sb = kmem_zalloc(sizeof (struct super_block), KM_SLEEP);
	sb->s_fs_info = zfsvfs;

	ZTOI(rootzp)->i_sb = sb;

	error = sa_setup(os, sa_obj, zfs_attr_table, ZPL_END,
	&zfsvfs->z_attr_table);

	ASSERT(error == 0);

	/*
	* Fold case on file systems that are always or sometimes case
	* insensitive.
	*/
	if (sense == ZFS_CASE_INSENSITIVE \|\| sense == ZFS_CASE_MIXED)
	zfsvfs->z_norm \|= U8_TEXTPREP_TOUPPER;

	mutex_init(&zfsvfs->z_znodes_lock, NULL, MUTEX_DEFAULT, NULL);
	list_create(&zfsvfs->z_all_znodes, sizeof (znode_t),
	offsetof(znode_t, z_link_node));

	size = MIN(1 << (highbit64(zfs_object_mutex_size)-1), ZFS_OBJ_MTX_MAX);
	zfsvfs->z_hold_size = size;
	zfsvfs->z_hold_trees = vmem_zalloc(sizeof (avl_tree_t) * size,
	KM_SLEEP);
	zfsvfs->z_hold_locks = vmem_zalloc(sizeof (kmutex_t) * size, KM_SLEEP);
	for (i = 0; i != size; i++) {
	avl_create(&zfsvfs->z_hold_trees[i], zfs_znode_hold_compare,
	sizeof (znode_hold_t), offsetof(znode_hold_t, zh_node));
	mutex_init(&zfsvfs->z_hold_locks[i], NULL, MUTEX_DEFAULT, NULL);
	}

	VERIFY(0 == zfs_acl_ids_create(rootzp, IS_ROOT_NODE, &vattr,
	cr, NULL, &acl_ids));
	zfs_mknode(rootzp, &vattr, tx, cr, IS_ROOT_NODE, &zp, &acl_ids);
	ASSERT3P(zp, ==, rootzp);
	error = zap_add(os, moid, ZFS_ROOT_OBJ, 8, 1, &rootzp->z_id, tx);
	ASSERT(error == 0);
	zfs_acl_ids_free(&acl_ids);

	atomic_set(&ZTOI(rootzp)->i_count, 0);
	sa_handle_destroy(rootzp->z_sa_hdl);
	kmem_cache_free(znode_cache, rootzp);

	for (i = 0; i != size; i++) {
	avl_destroy(&zfsvfs->z_hold_trees[i]);
	mutex_destroy(&zfsvfs->z_hold_locks[i]);
	}

	mutex_destroy(&zfsvfs->z_znodes_lock);

	vmem_free(zfsvfs->z_hold_trees, sizeof (avl_tree_t) * size);
	vmem_free(zfsvfs->z_hold_locks, sizeof (kmutex_t) * size);
	kmem_free(sb, sizeof (struct super_block));
	kmem_free(zfsvfs, sizeof (zfsvfs_t));
	}
	#endif /* _KERNEL */

	static int
	zfs_sa_setup(objset_t osp, sa_attr_type_t *sa_table)
	{
	uint64_t sa_obj = 0;
	int error;

	error = zap_lookup(osp, MASTER_NODE_OBJ, ZFS_SA_ATTRS, 8, 1, &sa_obj);
	if (error != 0 && error != ENOENT)
	return (error);

	error = sa_setup(osp, sa_obj, zfs_attr_table, ZPL_END, sa_table);
	return (error);
	}

	static int
	zfs_grab_sa_handle(objset_t osp, uint64_t obj, sa_handle_t *hdlp,
	dmu_buf_t *db, void tag)
	{
	dmu_object_info_t doi;
	int error;

	if ((error = sa_buf_hold(osp, obj, tag, db)) != 0)
	return (error);

	dmu_object_info_from_db(*db, &doi);
	if ((doi.doi_bonus_type != DMU_OT_SA &&
	doi.doi_bonus_type != DMU_OT_ZNODE) \|\|
	(doi.doi_bonus_type == DMU_OT_ZNODE &&
	doi.doi_bonus_size < sizeof (znode_phys_t))) {
	sa_buf_rele(*db, tag);
	return (SET_ERROR(ENOTSUP));
	}

	error = sa_handle_get(osp, obj, NULL, SA_HDL_PRIVATE, hdlp);
	if (error != 0) {
	sa_buf_rele(*db, tag);
	return (error);
	}

	return (0);
	}

	static void
	zfs_release_sa_handle(sa_handle_t hdl, dmu_buf_t db, void *tag)
	{
	sa_handle_destroy(hdl);
	sa_buf_rele(db, tag);
	}

	/*
	* Given an object number, return its parent object number and whether
	* or not the object is an extended attribute directory.
	*/
	static int
	zfs_obj_to_pobj(objset_t osp, sa_handle_t hdl, sa_attr_type_t *sa_table,
	uint64_t pobjp, int is_xattrdir)
	{
	uint64_t parent;
	uint64_t pflags;
	uint64_t mode;
	uint64_t parent_mode;
	sa_bulk_attr_t bulk[3];
	sa_handle_t *sa_hdl;
	dmu_buf_t *sa_db;
	int count = 0;
	int error;

	SA_ADD_BULK_ATTR(bulk, count, sa_table[ZPL_PARENT], NULL,
	&parent, sizeof (parent));
	SA_ADD_BULK_ATTR(bulk, count, sa_table[ZPL_FLAGS], NULL,
	&pflags, sizeof (pflags));
	SA_ADD_BULK_ATTR(bulk, count, sa_table[ZPL_MODE], NULL,
	&mode, sizeof (mode));

	if ((error = sa_bulk_lookup(hdl, bulk, count)) != 0)
	return (error);

	/*
	* When a link is removed its parent pointer is not changed and will
	* be invalid. There are two cases where a link is removed but the
	* file stays around, when it goes to the delete queue and when there
	* are additional links.
	*/
	error = zfs_grab_sa_handle(osp, parent, &sa_hdl, &sa_db, FTAG);
	if (error != 0)
	return (error);

	error = sa_lookup(sa_hdl, ZPL_MODE, &parent_mode, sizeof (parent_mode));
	zfs_release_sa_handle(sa_hdl, sa_db, FTAG);
	if (error != 0)
	return (error);

	*is_xattrdir = ((pflags & ZFS_XATTR) != 0) && S_ISDIR(mode);

	/*
	* Extended attributes can be applied to files, directories, etc.
	* Otherwise the parent must be a directory.
	*/
	if (!*is_xattrdir && !S_ISDIR(parent_mode))
	return (SET_ERROR(EINVAL));

	*pobjp = parent;

	return (0);
	}

	/*
	* Given an object number, return some zpl level statistics
	*/
	static int
	zfs_obj_to_stats_impl(sa_handle_t hdl, sa_attr_type_t sa_table,
	zfs_stat_t *sb)
	{
	sa_bulk_attr_t bulk[4];
	int count = 0;

	SA_ADD_BULK_ATTR(bulk, count, sa_table[ZPL_MODE], NULL,
	&sb->zs_mode, sizeof (sb->zs_mode));
	SA_ADD_BULK_ATTR(bulk, count, sa_table[ZPL_GEN], NULL,
	&sb->zs_gen, sizeof (sb->zs_gen));
	SA_ADD_BULK_ATTR(bulk, count, sa_table[ZPL_LINKS], NULL,
	&sb->zs_links, sizeof (sb->zs_links));
	SA_ADD_BULK_ATTR(bulk, count, sa_table[ZPL_CTIME], NULL,
	&sb->zs_ctime, sizeof (sb->zs_ctime));

	return (sa_bulk_lookup(hdl, bulk, count));
	}

	static int
	zfs_obj_to_path_impl(objset_t osp, uint64_t obj, sa_handle_t hdl,
	sa_attr_type_t sa_table, char buf, int len)
	{
	sa_handle_t *sa_hdl;
	sa_handle_t *prevhdl = NULL;
	dmu_buf_t *prevdb = NULL;
	dmu_buf_t *sa_db = NULL;
	char *path = buf + len - 1;
	int error;

	*path = '\0';
	sa_hdl = hdl;

	uint64_t deleteq_obj;
	VERIFY0(zap_lookup(osp, MASTER_NODE_OBJ,
	ZFS_UNLINKED_SET, sizeof (uint64_t), 1, &deleteq_obj));
	error = zap_lookup_int(osp, deleteq_obj, obj);
	if (error == 0) {
	return (ESTALE);
	} else if (error != ENOENT) {
	return (error);
	}
	error = 0;

	for (;;) {
	uint64_t pobj = 0;
	char component[MAXNAMELEN + 2];
	size_t complen;
	int is_xattrdir = 0;

	if (prevdb) {
	ASSERT(prevhdl != NULL);
	zfs_release_sa_handle(prevhdl, prevdb, FTAG);
	}

	if ((error = zfs_obj_to_pobj(osp, sa_hdl, sa_table, &pobj,
	&is_xattrdir)) != 0)
	break;

	if (pobj == obj) {
	if (path[0] != '/')
	*--path = '/';
	break;
	}

	component[0] = '/';
	if (is_xattrdir) {
	(void) sprintf(component + 1, "<xattrdir>");
	} else {
	error = zap_value_search(osp, pobj, obj,
	ZFS_DIRENT_OBJ(-1ULL), component + 1);
	if (error != 0)
	break;
	}

	complen = strlen(component);
	path -= complen;
	ASSERT(path >= buf);
	bcopy(component, path, complen);
	obj = pobj;

	if (sa_hdl != hdl) {
	prevhdl = sa_hdl;
	prevdb = sa_db;
	}
	error = zfs_grab_sa_handle(osp, obj, &sa_hdl, &sa_db, FTAG);
	if (error != 0) {
	sa_hdl = prevhdl;
	sa_db = prevdb;
	break;
	}
	}

	if (sa_hdl != NULL && sa_hdl != hdl) {
	ASSERT(sa_db != NULL);
	zfs_release_sa_handle(sa_hdl, sa_db, FTAG);
	}

	if (error == 0)
	(void) memmove(buf, path, buf + len - path);

	return (error);
	}

	int
	zfs_obj_to_path(objset_t osp, uint64_t obj, char buf, int len)
	{
	sa_attr_type_t *sa_table;
	sa_handle_t *hdl;
	dmu_buf_t *db;
	int error;

	error = zfs_sa_setup(osp, &sa_table);
	if (error != 0)
	return (error);

	error = zfs_grab_sa_handle(osp, obj, &hdl, &db, FTAG);
	if (error != 0)
	return (error);

	error = zfs_obj_to_path_impl(osp, obj, hdl, sa_table, buf, len);

	zfs_release_sa_handle(hdl, db, FTAG);
	return (error);
	}

	int
	zfs_obj_to_stats(objset_t osp, uint64_t obj, zfs_stat_t sb,
	char *buf, int len)
	{
	char *path = buf + len - 1;
	sa_attr_type_t *sa_table;
	sa_handle_t *hdl;
	dmu_buf_t *db;
	int error;

	*path = '\0';

	error = zfs_sa_setup(osp, &sa_table);
	if (error != 0)
	return (error);

	error = zfs_grab_sa_handle(osp, obj, &hdl, &db, FTAG);
	if (error != 0)
	return (error);

	error = zfs_obj_to_stats_impl(hdl, sa_table, sb);
	if (error != 0) {
	zfs_release_sa_handle(hdl, db, FTAG);
	return (error);
	}

	error = zfs_obj_to_path_impl(osp, obj, hdl, sa_table, buf, len);

	zfs_release_sa_handle(hdl, db, FTAG);
	return (error);
	}

	#if defined(_KERNEL)
	EXPORT_SYMBOL(zfs_create_fs);
	EXPORT_SYMBOL(zfs_obj_to_path);

	/* CSTYLED */
	module_param(zfs_object_mutex_size, uint, 0644);
	MODULE_PARM_DESC(zfs_object_mutex_size, "Size of znode hold array");
	module_param(zfs_unlink_suspend_progress, int, 0644);
	MODULE_PARM_DESC(zfs_unlink_suspend_progress, "Set to prevent async unlinks "
	"(debug - leaks space into the unlinked set)");
	#endif
	diff --git a/sys/contrib/openzfs/module/os/linux/zfs/zio_crypt.c b/sys/contrib/openzfs/module/os/linux/zfs/zio_crypt.c
	index 2c58fecb2066..94406999cb89 100644
	--- a/sys/contrib/openzfs/module/os/linux/zfs/zio_crypt.c
	+++ b/sys/contrib/openzfs/module/os/linux/zfs/zio_crypt.c
	@@ -1,2050 +1,2037 @@
	/*
	* CDDL HEADER START
	*
	* This file and its contents are supplied under the terms of the
	* Common Development and Distribution License ("CDDL"), version 1.0.
	* You may only use this file in accordance with the terms of version
	* 1.0 of the CDDL.
	*
	* A full copy of the text of the CDDL should have accompanied this
	* source. A copy of the CDDL is also available via the Internet at
	* http://www.illumos.org/license/CDDL.
	*
	* CDDL HEADER END
	*/

	/*
	* Copyright (c) 2017, Datto, Inc. All rights reserved.
	*/

	#include <sys/zio_crypt.h>
	#include <sys/dmu.h>
	#include <sys/dmu_objset.h>
	#include <sys/dnode.h>
	#include <sys/fs/zfs.h>
	#include <sys/zio.h>
	#include <sys/zil.h>
	#include <sys/sha2.h>
	#include <sys/hkdf.h>
	#include <sys/qat.h>

	/*
	* This file is responsible for handling all of the details of generating
	* encryption parameters and performing encryption and authentication.
	*
	* BLOCK ENCRYPTION PARAMETERS:
	* Encryption /Authentication Algorithm Suite (crypt):
	* The encryption algorithm, mode, and key length we are going to use. We
	* currently support AES in either GCM or CCM modes with 128, 192, and 256 bit
	* keys. All authentication is currently done with SHA512-HMAC.
	*
	* Plaintext:
	* The unencrypted data that we want to encrypt.
	*
	* Initialization Vector (IV):
	* An initialization vector for the encryption algorithms. This is used to
	* "tweak" the encryption algorithms so that two blocks of the same data are
	* encrypted into different ciphertext outputs, thus obfuscating block patterns.
	* The supported encryption modes (AES-GCM and AES-CCM) require that an IV is
	* never reused with the same encryption key. This value is stored unencrypted
	* and must simply be provided to the decryption function. We use a 96 bit IV
	* (as recommended by NIST) for all block encryption. For non-dedup blocks we
	* derive the IV randomly. The first 64 bits of the IV are stored in the second
	* word of DVA[2] and the remaining 32 bits are stored in the upper 32 bits of
	* blk_fill. This is safe because encrypted blocks can't use the upper 32 bits
	* of blk_fill. We only encrypt level 0 blocks, which normally have a fill count
	* of 1. The only exception is for DMU_OT_DNODE objects, where the fill count of
	* level 0 blocks is the number of allocated dnodes in that block. The on-disk
	* format supports at most 2^15 slots per L0 dnode block, because the maximum
	* block size is 16MB (2^24). In either case, for level 0 blocks this number
	* will still be smaller than UINT32_MAX so it is safe to store the IV in the
	* top 32 bits of blk_fill, while leaving the bottom 32 bits of the fill count
	* for the dnode code.
	*
	* Master key:
	* This is the most important secret data of an encrypted dataset. It is used
	* along with the salt to generate that actual encryption keys via HKDF. We
	* do not use the master key to directly encrypt any data because there are
	* theoretical limits on how much data can actually be safely encrypted with
	* any encryption mode. The master key is stored encrypted on disk with the
	* user's wrapping key. Its length is determined by the encryption algorithm.
	* For details on how this is stored see the block comment in dsl_crypt.c
	*
	* Salt:
	* Used as an input to the HKDF function, along with the master key. We use a
	* 64 bit salt, stored unencrypted in the first word of DVA[2]. Any given salt
	* can be used for encrypting many blocks, so we cache the current salt and the
	* associated derived key in zio_crypt_t so we do not need to derive it again
	* needlessly.
	*
	* Encryption Key:
	* A secret binary key, generated from an HKDF function used to encrypt and
	* decrypt data.
	*
	* Message Authentication Code (MAC)
	* The MAC is an output of authenticated encryption modes such as AES-GCM and
	* AES-CCM. Its purpose is to ensure that an attacker cannot modify encrypted
	* data on disk and return garbage to the application. Effectively, it is a
	* checksum that can not be reproduced by an attacker. We store the MAC in the
	* second 128 bits of blk_cksum, leaving the first 128 bits for a truncated
	* regular checksum of the ciphertext which can be used for scrubbing.
	*
	* OBJECT AUTHENTICATION:
	* Some object types, such as DMU_OT_MASTER_NODE cannot be encrypted because
	* they contain some info that always needs to be readable. To prevent this
	* data from being altered, we authenticate this data using SHA512-HMAC. This
	* will produce a MAC (similar to the one produced via encryption) which can
	* be used to verify the object was not modified. HMACs do not require key
	* rotation or IVs, so we can keep up to the full 3 copies of authenticated
	* data.
	*
	* ZIL ENCRYPTION:
	* ZIL blocks have their bp written to disk ahead of the associated data, so we
	* cannot store the MAC there as we normally do. For these blocks the MAC is
	* stored in the embedded checksum within the zil_chain_t header. The salt and
	* IV are generated for the block on bp allocation instead of at encryption
	* time. In addition, ZIL blocks have some pieces that must be left in plaintext
	* for claiming even though all of the sensitive user data still needs to be
	* encrypted. The function zio_crypt_init_uios_zil() handles parsing which
	* pieces of the block need to be encrypted. All data that is not encrypted is
	* authenticated using the AAD mechanisms that the supported encryption modes
	* provide for. In order to preserve the semantics of the ZIL for encrypted
	* datasets, the ZIL is not protected at the objset level as described below.
	*
	* DNODE ENCRYPTION:
	* Similarly to ZIL blocks, the core part of each dnode_phys_t needs to be left
	* in plaintext for scrubbing and claiming, but the bonus buffers might contain
	* sensitive user data. The function zio_crypt_init_uios_dnode() handles parsing
	- * which which pieces of the block need to be encrypted. For more details about
	+ * which pieces of the block need to be encrypted. For more details about
	* dnode authentication and encryption, see zio_crypt_init_uios_dnode().
	*
	* OBJECT SET AUTHENTICATION:
	* Up to this point, everything we have encrypted and authenticated has been
	* at level 0 (or -2 for the ZIL). If we did not do any further work the
	* on-disk format would be susceptible to attacks that deleted or rearranged
	* the order of level 0 blocks. Ideally, the cleanest solution would be to
	* maintain a tree of authentication MACs going up the bp tree. However, this
	* presents a problem for raw sends. Send files do not send information about
	* indirect blocks so there would be no convenient way to transfer the MACs and
	* they cannot be recalculated on the receive side without the master key which
	* would defeat one of the purposes of raw sends in the first place. Instead,
	* for the indirect levels of the bp tree, we use a regular SHA512 of the MACs
	* from the level below. We also include some portable fields from blk_prop such
	* as the lsize and compression algorithm to prevent the data from being
	* misinterpreted.
	*
	* At the objset level, we maintain 2 separate 256 bit MACs in the
	* objset_phys_t. The first one is "portable" and is the logical root of the
	* MAC tree maintained in the metadnode's bps. The second, is "local" and is
	* used as the root MAC for the user accounting objects, which are also not
	* transferred via "zfs send". The portable MAC is sent in the DRR_BEGIN payload
	* of the send file. The useraccounting code ensures that the useraccounting
	* info is not present upon a receive, so the local MAC can simply be cleared
	* out at that time. For more info about objset_phys_t authentication, see
	* zio_crypt_do_objset_hmacs().
	*
	* CONSIDERATIONS FOR DEDUP:
	* In order for dedup to work, blocks that we want to dedup with one another
	* need to use the same IV and encryption key, so that they will have the same
	* ciphertext. Normally, one should never reuse an IV with the same encryption
	* key or else AES-GCM and AES-CCM can both actually leak the plaintext of both
	* blocks. In this case, however, since we are using the same plaintext as
	* well all that we end up with is a duplicate of the original ciphertext we
	* already had. As a result, an attacker with read access to the raw disk will
	* be able to tell which blocks are the same but this information is given away
	* by dedup anyway. In order to get the same IVs and encryption keys for
	* equivalent blocks of data we use an HMAC of the plaintext. We use an HMAC
	* here so that a reproducible checksum of the plaintext is never available to
	* the attacker. The HMAC key is kept alongside the master key, encrypted on
	* disk. The first 64 bits of the HMAC are used in place of the random salt, and
	* the next 96 bits are used as the IV. As a result of this mechanism, dedup
	* will only work within a clone family since encrypted dedup requires use of
	* the same master and HMAC keys.
	*/

	/*
	* After encrypting many blocks with the same key we may start to run up
	* against the theoretical limits of how much data can securely be encrypted
	* with a single key using the supported encryption modes. The most obvious
	* limitation is that our risk of generating 2 equivalent 96 bit IVs increases
	* the more IVs we generate (which both GCM and CCM modes strictly forbid).
	* This risk actually grows surprisingly quickly over time according to the
	* Birthday Problem. With a total IV space of 2^(96 bits), and assuming we have
	* generated n IVs with a cryptographically secure RNG, the approximate
	* probability p(n) of a collision is given as:
	*
	* p(n) ~= e^(-n(n-1)/(2(2^96)))
	*
	* [http://www.math.cornell.edu/~mec/2008-2009/TianyiZheng/Birthday.html]
	*
	* Assuming that we want to ensure that p(n) never goes over 1 / 1 trillion
	* we must not write more than 398,065,730 blocks with the same encryption key.
	* Therefore, we rotate our keys after 400,000,000 blocks have been written by
	* generating a new random 64 bit salt for our HKDF encryption key generation
	* function.
	*/
	#define ZFS_KEY_MAX_SALT_USES_DEFAULT 400000000
	#define ZFS_CURRENT_MAX_SALT_USES \
	(MIN(zfs_key_max_salt_uses, ZFS_KEY_MAX_SALT_USES_DEFAULT))
	unsigned long zfs_key_max_salt_uses = ZFS_KEY_MAX_SALT_USES_DEFAULT;

	typedef struct blkptr_auth_buf {
	uint64_t bab_prop; /* blk_prop - portable mask */
	uint8_t bab_mac[ZIO_DATA_MAC_LEN]; /* MAC from blk_cksum */
	uint64_t bab_pad; /* reserved for future use */
	} blkptr_auth_buf_t;

	zio_crypt_info_t zio_crypt_table[ZIO_CRYPT_FUNCTIONS] = {
	{"", ZC_TYPE_NONE, 0, "inherit"},
	{"", ZC_TYPE_NONE, 0, "on"},
	{"", ZC_TYPE_NONE, 0, "off"},
	{SUN_CKM_AES_CCM, ZC_TYPE_CCM, 16, "aes-128-ccm"},
	{SUN_CKM_AES_CCM, ZC_TYPE_CCM, 24, "aes-192-ccm"},
	{SUN_CKM_AES_CCM, ZC_TYPE_CCM, 32, "aes-256-ccm"},
	{SUN_CKM_AES_GCM, ZC_TYPE_GCM, 16, "aes-128-gcm"},
	{SUN_CKM_AES_GCM, ZC_TYPE_GCM, 24, "aes-192-gcm"},
	{SUN_CKM_AES_GCM, ZC_TYPE_GCM, 32, "aes-256-gcm"}
	};

	void
	zio_crypt_key_destroy(zio_crypt_key_t *key)
	{
	rw_destroy(&key->zk_salt_lock);

	/* free crypto templates */
	crypto_destroy_ctx_template(key->zk_current_tmpl);
	crypto_destroy_ctx_template(key->zk_hmac_tmpl);

	/* zero out sensitive data */
	bzero(key, sizeof (zio_crypt_key_t));
	}

	int
	zio_crypt_key_init(uint64_t crypt, zio_crypt_key_t *key)
	{
	int ret;
	crypto_mechanism_t mech;
	uint_t keydata_len;

	ASSERT(key != NULL);
	ASSERT3U(crypt, <, ZIO_CRYPT_FUNCTIONS);

	keydata_len = zio_crypt_table[crypt].ci_keylen;
	bzero(key, sizeof (zio_crypt_key_t));

	/* fill keydata buffers and salt with random data */
	ret = random_get_bytes((uint8_t *)&key->zk_guid, sizeof (uint64_t));
	if (ret != 0)
	goto error;

	ret = random_get_bytes(key->zk_master_keydata, keydata_len);
	if (ret != 0)
	goto error;

	ret = random_get_bytes(key->zk_hmac_keydata, SHA512_HMAC_KEYLEN);
	if (ret != 0)
	goto error;

	ret = random_get_bytes(key->zk_salt, ZIO_DATA_SALT_LEN);
	if (ret != 0)
	goto error;

	/* derive the current key from the master key */
	ret = hkdf_sha512(key->zk_master_keydata, keydata_len, NULL, 0,
	key->zk_salt, ZIO_DATA_SALT_LEN, key->zk_current_keydata,
	keydata_len);
	if (ret != 0)
	goto error;

	/* initialize keys for the ICP */
	key->zk_current_key.ck_format = CRYPTO_KEY_RAW;
	key->zk_current_key.ck_data = key->zk_current_keydata;
	key->zk_current_key.ck_length = CRYPTO_BYTES2BITS(keydata_len);

	key->zk_hmac_key.ck_format = CRYPTO_KEY_RAW;
	key->zk_hmac_key.ck_data = &key->zk_hmac_key;
	key->zk_hmac_key.ck_length = CRYPTO_BYTES2BITS(SHA512_HMAC_KEYLEN);

	/*
	* Initialize the crypto templates. It's ok if this fails because
	* this is just an optimization.
	*/
	mech.cm_type = crypto_mech2id(zio_crypt_table[crypt].ci_mechname);
	ret = crypto_create_ctx_template(&mech, &key->zk_current_key,
	&key->zk_current_tmpl, KM_SLEEP);
	if (ret != CRYPTO_SUCCESS)
	key->zk_current_tmpl = NULL;

	mech.cm_type = crypto_mech2id(SUN_CKM_SHA512_HMAC);
	ret = crypto_create_ctx_template(&mech, &key->zk_hmac_key,
	&key->zk_hmac_tmpl, KM_SLEEP);
	if (ret != CRYPTO_SUCCESS)
	key->zk_hmac_tmpl = NULL;

	key->zk_crypt = crypt;
	key->zk_version = ZIO_CRYPT_KEY_CURRENT_VERSION;
	key->zk_salt_count = 0;
	rw_init(&key->zk_salt_lock, NULL, RW_DEFAULT, NULL);

	return (0);

	error:
	zio_crypt_key_destroy(key);
	return (ret);
	}

	static int
	zio_crypt_key_change_salt(zio_crypt_key_t *key)
	{
	int ret = 0;
	uint8_t salt[ZIO_DATA_SALT_LEN];
	crypto_mechanism_t mech;
	uint_t keydata_len = zio_crypt_table[key->zk_crypt].ci_keylen;

	/* generate a new salt */
	ret = random_get_bytes(salt, ZIO_DATA_SALT_LEN);
	if (ret != 0)
	goto error;

	rw_enter(&key->zk_salt_lock, RW_WRITER);

	/* someone beat us to the salt rotation, just unlock and return */
	if (key->zk_salt_count < ZFS_CURRENT_MAX_SALT_USES)
	goto out_unlock;

	/* derive the current key from the master key and the new salt */
	ret = hkdf_sha512(key->zk_master_keydata, keydata_len, NULL, 0,
	salt, ZIO_DATA_SALT_LEN, key->zk_current_keydata, keydata_len);
	if (ret != 0)
	goto out_unlock;

	/* assign the salt and reset the usage count */
	bcopy(salt, key->zk_salt, ZIO_DATA_SALT_LEN);
	key->zk_salt_count = 0;

	/* destroy the old context template and create the new one */
	crypto_destroy_ctx_template(key->zk_current_tmpl);
	ret = crypto_create_ctx_template(&mech, &key->zk_current_key,
	&key->zk_current_tmpl, KM_SLEEP);
	if (ret != CRYPTO_SUCCESS)
	key->zk_current_tmpl = NULL;

	rw_exit(&key->zk_salt_lock);

	return (0);

	out_unlock:
	rw_exit(&key->zk_salt_lock);
	error:
	return (ret);
	}

	/* See comment above zfs_key_max_salt_uses definition for details */
	int
	zio_crypt_key_get_salt(zio_crypt_key_t key, uint8_t salt)
	{
	int ret;
	boolean_t salt_change;

	rw_enter(&key->zk_salt_lock, RW_READER);

	bcopy(key->zk_salt, salt, ZIO_DATA_SALT_LEN);
	salt_change = (atomic_inc_64_nv(&key->zk_salt_count) >=
	ZFS_CURRENT_MAX_SALT_USES);

	rw_exit(&key->zk_salt_lock);

	if (salt_change) {
	ret = zio_crypt_key_change_salt(key);
	if (ret != 0)
	goto error;
	}

	return (0);

	error:
	return (ret);
	}

	/*
	* This function handles all encryption and decryption in zfs. When
	* encrypting it expects puio to reference the plaintext and cuio to
	* reference the ciphertext. cuio must have enough space for the
	* ciphertext + room for a MAC. datalen should be the length of the
	* plaintext / ciphertext alone.
	*/
	static int
	zio_do_crypt_uio(boolean_t encrypt, uint64_t crypt, crypto_key_t *key,
	crypto_ctx_template_t tmpl, uint8_t *ivbuf, uint_t datalen,
	zfs_uio_t puio, zfs_uio_t cuio, uint8_t *authbuf, uint_t auth_len)
	{
	int ret;
	crypto_data_t plaindata, cipherdata;
	CK_AES_CCM_PARAMS ccmp;
	CK_AES_GCM_PARAMS gcmp;
	crypto_mechanism_t mech;
	zio_crypt_info_t crypt_info;
	uint_t plain_full_len, maclen;

	ASSERT3U(crypt, <, ZIO_CRYPT_FUNCTIONS);
	ASSERT3U(key->ck_format, ==, CRYPTO_KEY_RAW);

	/* lookup the encryption info */
	crypt_info = zio_crypt_table[crypt];

	/* the mac will always be the last iovec_t in the cipher uio */
	maclen = cuio->uio_iov[cuio->uio_iovcnt - 1].iov_len;

	ASSERT(maclen <= ZIO_DATA_MAC_LEN);

	/* setup encryption mechanism (same as crypt) */
	mech.cm_type = crypto_mech2id(crypt_info.ci_mechname);

	/*
	* Strangely, the ICP requires that plain_full_len must include
	* the MAC length when decrypting, even though the UIO does not
	* need to have the extra space allocated.
	*/
	if (encrypt) {
	plain_full_len = datalen;
	} else {
	plain_full_len = datalen + maclen;
	}

	/*
	* setup encryption params (currently only AES CCM and AES GCM
	* are supported)
	*/
	if (crypt_info.ci_crypt_type == ZC_TYPE_CCM) {
	ccmp.ulNonceSize = ZIO_DATA_IV_LEN;
	ccmp.ulAuthDataSize = auth_len;
	ccmp.authData = authbuf;
	ccmp.ulMACSize = maclen;
	ccmp.nonce = ivbuf;
	ccmp.ulDataSize = plain_full_len;

	mech.cm_param = (char *)(&ccmp);
	mech.cm_param_len = sizeof (CK_AES_CCM_PARAMS);
	} else {
	gcmp.ulIvLen = ZIO_DATA_IV_LEN;
	gcmp.ulIvBits = CRYPTO_BYTES2BITS(ZIO_DATA_IV_LEN);
	gcmp.ulAADLen = auth_len;
	gcmp.pAAD = authbuf;
	gcmp.ulTagBits = CRYPTO_BYTES2BITS(maclen);
	gcmp.pIv = ivbuf;

	mech.cm_param = (char *)(&gcmp);
	mech.cm_param_len = sizeof (CK_AES_GCM_PARAMS);
	}

	/* populate the cipher and plain data structs. */
	plaindata.cd_format = CRYPTO_DATA_UIO;
	plaindata.cd_offset = 0;
	plaindata.cd_uio = puio;
	plaindata.cd_miscdata = NULL;
	plaindata.cd_length = plain_full_len;

	cipherdata.cd_format = CRYPTO_DATA_UIO;
	cipherdata.cd_offset = 0;
	cipherdata.cd_uio = cuio;
	cipherdata.cd_miscdata = NULL;
	cipherdata.cd_length = datalen + maclen;

	/* perform the actual encryption */
	if (encrypt) {
	ret = crypto_encrypt(&mech, &plaindata, key, tmpl, &cipherdata,
	NULL);
	if (ret != CRYPTO_SUCCESS) {
	ret = SET_ERROR(EIO);
	goto error;
	}
	} else {
	ret = crypto_decrypt(&mech, &cipherdata, key, tmpl, &plaindata,
	NULL);
	if (ret != CRYPTO_SUCCESS) {
	ASSERT3U(ret, ==, CRYPTO_INVALID_MAC);
	ret = SET_ERROR(ECKSUM);
	goto error;
	}
	}

	return (0);

	error:
	return (ret);
	}

	int
	zio_crypt_key_wrap(crypto_key_t cwkey, zio_crypt_key_t key, uint8_t *iv,
	uint8_t mac, uint8_t keydata_out, uint8_t *hmac_keydata_out)
	{
	int ret;
	zfs_uio_t puio, cuio;
	uint64_t aad[3];
	iovec_t plain_iovecs[2], cipher_iovecs[3];
	uint64_t crypt = key->zk_crypt;
	uint_t enc_len, keydata_len, aad_len;

	ASSERT3U(crypt, <, ZIO_CRYPT_FUNCTIONS);
	ASSERT3U(cwkey->ck_format, ==, CRYPTO_KEY_RAW);

	keydata_len = zio_crypt_table[crypt].ci_keylen;

	/* generate iv for wrapping the master and hmac key */
	ret = random_get_pseudo_bytes(iv, WRAPPING_IV_LEN);
	if (ret != 0)
	goto error;

	/* initialize zfs_uio_ts */
	plain_iovecs[0].iov_base = key->zk_master_keydata;
	plain_iovecs[0].iov_len = keydata_len;
	plain_iovecs[1].iov_base = key->zk_hmac_keydata;
	plain_iovecs[1].iov_len = SHA512_HMAC_KEYLEN;

	cipher_iovecs[0].iov_base = keydata_out;
	cipher_iovecs[0].iov_len = keydata_len;
	cipher_iovecs[1].iov_base = hmac_keydata_out;
	cipher_iovecs[1].iov_len = SHA512_HMAC_KEYLEN;
	cipher_iovecs[2].iov_base = mac;
	cipher_iovecs[2].iov_len = WRAPPING_MAC_LEN;

	/*
	* Although we don't support writing to the old format, we do
	* support rewrapping the key so that the user can move and
	* quarantine datasets on the old format.
	*/
	if (key->zk_version == 0) {
	aad_len = sizeof (uint64_t);
	aad[0] = LE_64(key->zk_guid);
	} else {
	ASSERT3U(key->zk_version, ==, ZIO_CRYPT_KEY_CURRENT_VERSION);
	aad_len = sizeof (uint64_t) * 3;
	aad[0] = LE_64(key->zk_guid);
	aad[1] = LE_64(crypt);
	aad[2] = LE_64(key->zk_version);
	}

	enc_len = zio_crypt_table[crypt].ci_keylen + SHA512_HMAC_KEYLEN;
	puio.uio_iov = plain_iovecs;
	puio.uio_iovcnt = 2;
	puio.uio_segflg = UIO_SYSSPACE;
	cuio.uio_iov = cipher_iovecs;
	cuio.uio_iovcnt = 3;
	cuio.uio_segflg = UIO_SYSSPACE;

	/* encrypt the keys and store the resulting ciphertext and mac */
	ret = zio_do_crypt_uio(B_TRUE, crypt, cwkey, NULL, iv, enc_len,
	&puio, &cuio, (uint8_t *)aad, aad_len);
	if (ret != 0)
	goto error;

	return (0);

	error:
	return (ret);
	}

	int
	zio_crypt_key_unwrap(crypto_key_t *cwkey, uint64_t crypt, uint64_t version,
	uint64_t guid, uint8_t keydata, uint8_t hmac_keydata, uint8_t *iv,
	uint8_t mac, zio_crypt_key_t key)
	{
	crypto_mechanism_t mech;
	zfs_uio_t puio, cuio;
	uint64_t aad[3];
	iovec_t plain_iovecs[2], cipher_iovecs[3];
	uint_t enc_len, keydata_len, aad_len;
	int ret;

	ASSERT3U(crypt, <, ZIO_CRYPT_FUNCTIONS);
	ASSERT3U(cwkey->ck_format, ==, CRYPTO_KEY_RAW);

	rw_init(&key->zk_salt_lock, NULL, RW_DEFAULT, NULL);

	keydata_len = zio_crypt_table[crypt].ci_keylen;

	/* initialize zfs_uio_ts */
	plain_iovecs[0].iov_base = key->zk_master_keydata;
	plain_iovecs[0].iov_len = keydata_len;
	plain_iovecs[1].iov_base = key->zk_hmac_keydata;
	plain_iovecs[1].iov_len = SHA512_HMAC_KEYLEN;

	cipher_iovecs[0].iov_base = keydata;
	cipher_iovecs[0].iov_len = keydata_len;
	cipher_iovecs[1].iov_base = hmac_keydata;
	cipher_iovecs[1].iov_len = SHA512_HMAC_KEYLEN;
	cipher_iovecs[2].iov_base = mac;
	cipher_iovecs[2].iov_len = WRAPPING_MAC_LEN;

	if (version == 0) {
	aad_len = sizeof (uint64_t);
	aad[0] = LE_64(guid);
	} else {
	ASSERT3U(version, ==, ZIO_CRYPT_KEY_CURRENT_VERSION);
	aad_len = sizeof (uint64_t) * 3;
	aad[0] = LE_64(guid);
	aad[1] = LE_64(crypt);
	aad[2] = LE_64(version);
	}

	enc_len = keydata_len + SHA512_HMAC_KEYLEN;
	puio.uio_iov = plain_iovecs;
	puio.uio_segflg = UIO_SYSSPACE;
	puio.uio_iovcnt = 2;
	cuio.uio_iov = cipher_iovecs;
	cuio.uio_iovcnt = 3;
	cuio.uio_segflg = UIO_SYSSPACE;

	/* decrypt the keys and store the result in the output buffers */
	ret = zio_do_crypt_uio(B_FALSE, crypt, cwkey, NULL, iv, enc_len,
	&puio, &cuio, (uint8_t *)aad, aad_len);
	if (ret != 0)
	goto error;

	/* generate a fresh salt */
	ret = random_get_bytes(key->zk_salt, ZIO_DATA_SALT_LEN);
	if (ret != 0)
	goto error;

	/* derive the current key from the master key */
	ret = hkdf_sha512(key->zk_master_keydata, keydata_len, NULL, 0,
	key->zk_salt, ZIO_DATA_SALT_LEN, key->zk_current_keydata,
	keydata_len);
	if (ret != 0)
	goto error;

	/* initialize keys for ICP */
	key->zk_current_key.ck_format = CRYPTO_KEY_RAW;
	key->zk_current_key.ck_data = key->zk_current_keydata;
	key->zk_current_key.ck_length = CRYPTO_BYTES2BITS(keydata_len);

	key->zk_hmac_key.ck_format = CRYPTO_KEY_RAW;
	key->zk_hmac_key.ck_data = key->zk_hmac_keydata;
	key->zk_hmac_key.ck_length = CRYPTO_BYTES2BITS(SHA512_HMAC_KEYLEN);

	/*
	* Initialize the crypto templates. It's ok if this fails because
	* this is just an optimization.
	*/
	mech.cm_type = crypto_mech2id(zio_crypt_table[crypt].ci_mechname);
	ret = crypto_create_ctx_template(&mech, &key->zk_current_key,
	&key->zk_current_tmpl, KM_SLEEP);
	if (ret != CRYPTO_SUCCESS)
	key->zk_current_tmpl = NULL;

	mech.cm_type = crypto_mech2id(SUN_CKM_SHA512_HMAC);
	ret = crypto_create_ctx_template(&mech, &key->zk_hmac_key,
	&key->zk_hmac_tmpl, KM_SLEEP);
	if (ret != CRYPTO_SUCCESS)
	key->zk_hmac_tmpl = NULL;

	key->zk_crypt = crypt;
	key->zk_version = version;
	key->zk_guid = guid;
	key->zk_salt_count = 0;

	return (0);

	error:
	zio_crypt_key_destroy(key);
	return (ret);
	}

	int
	zio_crypt_generate_iv(uint8_t *ivbuf)
	{
	int ret;

	/* randomly generate the IV */
	ret = random_get_pseudo_bytes(ivbuf, ZIO_DATA_IV_LEN);
	if (ret != 0)
	goto error;

	return (0);

	error:
	bzero(ivbuf, ZIO_DATA_IV_LEN);
	return (ret);
	}

	int
	zio_crypt_do_hmac(zio_crypt_key_t key, uint8_t data, uint_t datalen,
	uint8_t *digestbuf, uint_t digestlen)
	{
	int ret;
	crypto_mechanism_t mech;
	crypto_data_t in_data, digest_data;
	uint8_t raw_digestbuf[SHA512_DIGEST_LENGTH];

	ASSERT3U(digestlen, <=, SHA512_DIGEST_LENGTH);

	/* initialize sha512-hmac mechanism and crypto data */
	mech.cm_type = crypto_mech2id(SUN_CKM_SHA512_HMAC);
	mech.cm_param = NULL;
	mech.cm_param_len = 0;

	/* initialize the crypto data */
	in_data.cd_format = CRYPTO_DATA_RAW;
	in_data.cd_offset = 0;
	in_data.cd_length = datalen;
	in_data.cd_raw.iov_base = (char *)data;
	in_data.cd_raw.iov_len = in_data.cd_length;

	digest_data.cd_format = CRYPTO_DATA_RAW;
	digest_data.cd_offset = 0;
	digest_data.cd_length = SHA512_DIGEST_LENGTH;
	digest_data.cd_raw.iov_base = (char *)raw_digestbuf;
	digest_data.cd_raw.iov_len = digest_data.cd_length;

	/* generate the hmac */
	ret = crypto_mac(&mech, &in_data, &key->zk_hmac_key, key->zk_hmac_tmpl,
	&digest_data, NULL);
	if (ret != CRYPTO_SUCCESS) {
	ret = SET_ERROR(EIO);
	goto error;
	}

	bcopy(raw_digestbuf, digestbuf, digestlen);

	return (0);

	error:
	bzero(digestbuf, digestlen);
	return (ret);
	}

	int
	zio_crypt_generate_iv_salt_dedup(zio_crypt_key_t key, uint8_t data,
	uint_t datalen, uint8_t ivbuf, uint8_t salt)
	{
	int ret;
	uint8_t digestbuf[SHA512_DIGEST_LENGTH];

	ret = zio_crypt_do_hmac(key, data, datalen,
	digestbuf, SHA512_DIGEST_LENGTH);
	if (ret != 0)
	return (ret);

	bcopy(digestbuf, salt, ZIO_DATA_SALT_LEN);
	bcopy(digestbuf + ZIO_DATA_SALT_LEN, ivbuf, ZIO_DATA_IV_LEN);

	return (0);
	}

	/*
	* The following functions are used to encode and decode encryption parameters
	* into blkptr_t and zil_header_t. The ICP wants to use these parameters as
	* byte strings, which normally means that these strings would not need to deal
	* with byteswapping at all. However, both blkptr_t and zil_header_t may be
	* byteswapped by lower layers and so we must "undo" that byteswap here upon
	* decoding and encoding in a non-native byteorder. These functions require
	* that the byteorder bit is correct before being called.
	*/
	void
	zio_crypt_encode_params_bp(blkptr_t bp, uint8_t salt, uint8_t *iv)
	{
	uint64_t val64;
	uint32_t val32;

	ASSERT(BP_IS_ENCRYPTED(bp));

	if (!BP_SHOULD_BYTESWAP(bp)) {
	bcopy(salt, &bp->blk_dva[2].dva_word[0], sizeof (uint64_t));
	bcopy(iv, &bp->blk_dva[2].dva_word[1], sizeof (uint64_t));
	bcopy(iv + sizeof (uint64_t), &val32, sizeof (uint32_t));
	BP_SET_IV2(bp, val32);
	} else {
	bcopy(salt, &val64, sizeof (uint64_t));
	bp->blk_dva[2].dva_word[0] = BSWAP_64(val64);

	bcopy(iv, &val64, sizeof (uint64_t));
	bp->blk_dva[2].dva_word[1] = BSWAP_64(val64);

	bcopy(iv + sizeof (uint64_t), &val32, sizeof (uint32_t));
	BP_SET_IV2(bp, BSWAP_32(val32));
	}
	}

	void
	zio_crypt_decode_params_bp(const blkptr_t bp, uint8_t salt, uint8_t *iv)
	{
	uint64_t val64;
	uint32_t val32;

	ASSERT(BP_IS_PROTECTED(bp));

	/* for convenience, so callers don't need to check */
	if (BP_IS_AUTHENTICATED(bp)) {
	bzero(salt, ZIO_DATA_SALT_LEN);
	bzero(iv, ZIO_DATA_IV_LEN);
	return;
	}

	if (!BP_SHOULD_BYTESWAP(bp)) {
	bcopy(&bp->blk_dva[2].dva_word[0], salt, sizeof (uint64_t));
	bcopy(&bp->blk_dva[2].dva_word[1], iv, sizeof (uint64_t));

	val32 = (uint32_t)BP_GET_IV2(bp);
	bcopy(&val32, iv + sizeof (uint64_t), sizeof (uint32_t));
	} else {
	val64 = BSWAP_64(bp->blk_dva[2].dva_word[0]);
	bcopy(&val64, salt, sizeof (uint64_t));

	val64 = BSWAP_64(bp->blk_dva[2].dva_word[1]);
	bcopy(&val64, iv, sizeof (uint64_t));

	val32 = BSWAP_32((uint32_t)BP_GET_IV2(bp));
	bcopy(&val32, iv + sizeof (uint64_t), sizeof (uint32_t));
	}
	}

	void
	zio_crypt_encode_mac_bp(blkptr_t bp, uint8_t mac)
	{
	uint64_t val64;

	ASSERT(BP_USES_CRYPT(bp));
	ASSERT3U(BP_GET_TYPE(bp), !=, DMU_OT_OBJSET);

	if (!BP_SHOULD_BYTESWAP(bp)) {
	bcopy(mac, &bp->blk_cksum.zc_word[2], sizeof (uint64_t));
	bcopy(mac + sizeof (uint64_t), &bp->blk_cksum.zc_word[3],
	sizeof (uint64_t));
	} else {
	bcopy(mac, &val64, sizeof (uint64_t));
	bp->blk_cksum.zc_word[2] = BSWAP_64(val64);

	bcopy(mac + sizeof (uint64_t), &val64, sizeof (uint64_t));
	bp->blk_cksum.zc_word[3] = BSWAP_64(val64);
	}
	}

	void
	zio_crypt_decode_mac_bp(const blkptr_t bp, uint8_t mac)
	{
	uint64_t val64;

	ASSERT(BP_USES_CRYPT(bp) \|\| BP_IS_HOLE(bp));

	/* for convenience, so callers don't need to check */
	if (BP_GET_TYPE(bp) == DMU_OT_OBJSET) {
	bzero(mac, ZIO_DATA_MAC_LEN);
	return;
	}

	if (!BP_SHOULD_BYTESWAP(bp)) {
	bcopy(&bp->blk_cksum.zc_word[2], mac, sizeof (uint64_t));
	bcopy(&bp->blk_cksum.zc_word[3], mac + sizeof (uint64_t),
	sizeof (uint64_t));
	} else {
	val64 = BSWAP_64(bp->blk_cksum.zc_word[2]);
	bcopy(&val64, mac, sizeof (uint64_t));

	val64 = BSWAP_64(bp->blk_cksum.zc_word[3]);
	bcopy(&val64, mac + sizeof (uint64_t), sizeof (uint64_t));
	}
	}

	void
	zio_crypt_encode_mac_zil(void data, uint8_t mac)
	{
	zil_chain_t *zilc = data;

	bcopy(mac, &zilc->zc_eck.zec_cksum.zc_word[2], sizeof (uint64_t));
	bcopy(mac + sizeof (uint64_t), &zilc->zc_eck.zec_cksum.zc_word[3],
	sizeof (uint64_t));
	}

	void
	zio_crypt_decode_mac_zil(const void data, uint8_t mac)
	{
	/*
	* The ZIL MAC is embedded in the block it protects, which will
	* not have been byteswapped by the time this function has been called.
	* As a result, we don't need to worry about byteswapping the MAC.
	*/
	const zil_chain_t *zilc = data;

	bcopy(&zilc->zc_eck.zec_cksum.zc_word[2], mac, sizeof (uint64_t));
	bcopy(&zilc->zc_eck.zec_cksum.zc_word[3], mac + sizeof (uint64_t),
	sizeof (uint64_t));
	}

	/*
	* This routine takes a block of dnodes (src_abd) and copies only the bonus
	* buffers to the same offsets in the dst buffer. datalen should be the size
	* of both the src_abd and the dst buffer (not just the length of the bonus
	* buffers).
	*/
	void
	zio_crypt_copy_dnode_bonus(abd_t src_abd, uint8_t dst, uint_t datalen)
	{
	uint_t i, max_dnp = datalen >> DNODE_SHIFT;
	uint8_t *src;
	dnode_phys_t dnp, sdnp, *ddnp;

	src = abd_borrow_buf_copy(src_abd, datalen);

	sdnp = (dnode_phys_t *)src;
	ddnp = (dnode_phys_t *)dst;

	for (i = 0; i < max_dnp; i += sdnp[i].dn_extra_slots + 1) {
	dnp = &sdnp[i];
	if (dnp->dn_type != DMU_OT_NONE &&
	DMU_OT_IS_ENCRYPTED(dnp->dn_bonustype) &&
	dnp->dn_bonuslen != 0) {
	bcopy(DN_BONUS(dnp), DN_BONUS(&ddnp[i]),
	DN_MAX_BONUS_LEN(dnp));
	}
	}

	abd_return_buf(src_abd, src, datalen);
	}

	/*
	* This function decides what fields from blk_prop are included in
	* the on-disk various MAC algorithms.
	*/
	static void
	zio_crypt_bp_zero_nonportable_blkprop(blkptr_t *bp, uint64_t version)
	{
	/*
	* Version 0 did not properly zero out all non-portable fields
	* as it should have done. We maintain this code so that we can
	* do read-only imports of pools on this version.
	*/
	if (version == 0) {
	BP_SET_DEDUP(bp, 0);
	BP_SET_CHECKSUM(bp, 0);
	BP_SET_PSIZE(bp, SPA_MINBLOCKSIZE);
	return;
	}

	ASSERT3U(version, ==, ZIO_CRYPT_KEY_CURRENT_VERSION);

	/*
	* The hole_birth feature might set these fields even if this bp
	* is a hole. We zero them out here to guarantee that raw sends
	* will function with or without the feature.
	*/
	if (BP_IS_HOLE(bp)) {
	bp->blk_prop = 0ULL;
	return;
	}

	/*
	* At L0 we want to verify these fields to ensure that data blocks
	* can not be reinterpreted. For instance, we do not want an attacker
	* to trick us into returning raw lz4 compressed data to the user
	* by modifying the compression bits. At higher levels, we cannot
	* enforce this policy since raw sends do not convey any information
	* about indirect blocks, so these values might be different on the
	* receive side. Fortunately, this does not open any new attack
	* vectors, since any alterations that can be made to a higher level
	* bp must still verify the correct order of the layer below it.
	*/
	if (BP_GET_LEVEL(bp) != 0) {
	BP_SET_BYTEORDER(bp, 0);
	BP_SET_COMPRESS(bp, 0);

	/*
	* psize cannot be set to zero or it will trigger
	* asserts, but the value doesn't really matter as
	* long as it is constant.
	*/
	BP_SET_PSIZE(bp, SPA_MINBLOCKSIZE);
	}

	BP_SET_DEDUP(bp, 0);
	BP_SET_CHECKSUM(bp, 0);
	}

	static void
	zio_crypt_bp_auth_init(uint64_t version, boolean_t should_bswap, blkptr_t *bp,
	blkptr_auth_buf_t bab, uint_t bab_len)
	{
	blkptr_t tmpbp = *bp;

	if (should_bswap)
	byteswap_uint64_array(&tmpbp, sizeof (blkptr_t));

	ASSERT(BP_USES_CRYPT(&tmpbp) \|\| BP_IS_HOLE(&tmpbp));
	ASSERT0(BP_IS_EMBEDDED(&tmpbp));

	zio_crypt_decode_mac_bp(&tmpbp, bab->bab_mac);

	/*
	* We always MAC blk_prop in LE to ensure portability. This
	* must be done after decoding the mac, since the endianness
	* will get zero'd out here.
	*/
	zio_crypt_bp_zero_nonportable_blkprop(&tmpbp, version);
	bab->bab_prop = LE_64(tmpbp.blk_prop);
	bab->bab_pad = 0ULL;

	/* version 0 did not include the padding */
	*bab_len = sizeof (blkptr_auth_buf_t);
	if (version == 0)
	*bab_len -= sizeof (uint64_t);
	}

	static int
	zio_crypt_bp_do_hmac_updates(crypto_context_t ctx, uint64_t version,
	boolean_t should_bswap, blkptr_t *bp)
	{
	int ret;
	uint_t bab_len;
	blkptr_auth_buf_t bab;
	crypto_data_t cd;

	zio_crypt_bp_auth_init(version, should_bswap, bp, &bab, &bab_len);
	cd.cd_format = CRYPTO_DATA_RAW;
	cd.cd_offset = 0;
	cd.cd_length = bab_len;
	cd.cd_raw.iov_base = (char *)&bab;
	cd.cd_raw.iov_len = cd.cd_length;

	ret = crypto_mac_update(ctx, &cd, NULL);
	if (ret != CRYPTO_SUCCESS) {
	ret = SET_ERROR(EIO);
	goto error;
	}

	return (0);

	error:
	return (ret);
	}

	static void
	zio_crypt_bp_do_indrect_checksum_updates(SHA2_CTX *ctx, uint64_t version,
	boolean_t should_bswap, blkptr_t *bp)
	{
	uint_t bab_len;
	blkptr_auth_buf_t bab;

	zio_crypt_bp_auth_init(version, should_bswap, bp, &bab, &bab_len);
	SHA2Update(ctx, &bab, bab_len);
	}

	static void
	zio_crypt_bp_do_aad_updates(uint8_t *aadp, uint_t aad_len, uint64_t version,
	boolean_t should_bswap, blkptr_t *bp)
	{
	uint_t bab_len;
	blkptr_auth_buf_t bab;

	zio_crypt_bp_auth_init(version, should_bswap, bp, &bab, &bab_len);
	bcopy(&bab, *aadp, bab_len);
	*aadp += bab_len;
	*aad_len += bab_len;
	}

	static int
	zio_crypt_do_dnode_hmac_updates(crypto_context_t ctx, uint64_t version,
	boolean_t should_bswap, dnode_phys_t *dnp)
	{
	int ret, i;
	dnode_phys_t *adnp;
	boolean_t le_bswap = (should_bswap == ZFS_HOST_BYTEORDER);
	crypto_data_t cd;
	uint8_t tmp_dncore[offsetof(dnode_phys_t, dn_blkptr)];

	cd.cd_format = CRYPTO_DATA_RAW;
	cd.cd_offset = 0;

	/* authenticate the core dnode (masking out non-portable bits) */
	bcopy(dnp, tmp_dncore, sizeof (tmp_dncore));
	adnp = (dnode_phys_t *)tmp_dncore;
	if (le_bswap) {
	adnp->dn_datablkszsec = BSWAP_16(adnp->dn_datablkszsec);
	adnp->dn_bonuslen = BSWAP_16(adnp->dn_bonuslen);
	adnp->dn_maxblkid = BSWAP_64(adnp->dn_maxblkid);
	adnp->dn_used = BSWAP_64(adnp->dn_used);
	}
	adnp->dn_flags &= DNODE_CRYPT_PORTABLE_FLAGS_MASK;
	adnp->dn_used = 0;

	cd.cd_length = sizeof (tmp_dncore);
	cd.cd_raw.iov_base = (char *)adnp;
	cd.cd_raw.iov_len = cd.cd_length;

	ret = crypto_mac_update(ctx, &cd, NULL);
	if (ret != CRYPTO_SUCCESS) {
	ret = SET_ERROR(EIO);
	goto error;
	}

	for (i = 0; i < dnp->dn_nblkptr; i++) {
	ret = zio_crypt_bp_do_hmac_updates(ctx, version,
	should_bswap, &dnp->dn_blkptr[i]);
	if (ret != 0)
	goto error;
	}

	if (dnp->dn_flags & DNODE_FLAG_SPILL_BLKPTR) {
	ret = zio_crypt_bp_do_hmac_updates(ctx, version,
	should_bswap, DN_SPILL_BLKPTR(dnp));
	if (ret != 0)
	goto error;
	}

	return (0);

	error:
	return (ret);
	}

	/*
	* objset_phys_t blocks introduce a number of exceptions to the normal
	* authentication process. objset_phys_t's contain 2 separate HMACS for
	* protecting the integrity of their data. The portable_mac protects the
	* metadnode. This MAC can be sent with a raw send and protects against
	* reordering of data within the metadnode. The local_mac protects the user
	* accounting objects which are not sent from one system to another.
	*
	* In addition, objset blocks are the only blocks that can be modified and
	* written to disk without the key loaded under certain circumstances. During
	* zil_claim() we need to be able to update the zil_header_t to complete
	* claiming log blocks and during raw receives we need to write out the
	* portable_mac from the send file. Both of these actions are possible
	* because these fields are not protected by either MAC so neither one will
	* need to modify the MACs without the key. However, when the modified blocks
	* are written out they will be byteswapped into the host machine's native
	* endianness which will modify fields protected by the MAC. As a result, MAC
	* calculation for objset blocks works slightly differently from other block
	* types. Where other block types MAC the data in whatever endianness is
	* written to disk, objset blocks always MAC little endian version of their
	* values. In the code, should_bswap is the value from BP_SHOULD_BYTESWAP()
	* and le_bswap indicates whether a byteswap is needed to get this block
	* into little endian format.
	*/
	int
	zio_crypt_do_objset_hmacs(zio_crypt_key_t key, void data, uint_t datalen,
	boolean_t should_bswap, uint8_t portable_mac, uint8_t local_mac)
	{
	int ret;
	crypto_mechanism_t mech;
	crypto_context_t ctx;
	crypto_data_t cd;
	objset_phys_t *osp = data;
	uint64_t intval;
	boolean_t le_bswap = (should_bswap == ZFS_HOST_BYTEORDER);
	uint8_t raw_portable_mac[SHA512_DIGEST_LENGTH];
	uint8_t raw_local_mac[SHA512_DIGEST_LENGTH];

	/* initialize HMAC mechanism */
	mech.cm_type = crypto_mech2id(SUN_CKM_SHA512_HMAC);
	mech.cm_param = NULL;
	mech.cm_param_len = 0;

	cd.cd_format = CRYPTO_DATA_RAW;
	cd.cd_offset = 0;

	/* calculate the portable MAC from the portable fields and metadnode */
	ret = crypto_mac_init(&mech, &key->zk_hmac_key, NULL, &ctx, NULL);
	if (ret != CRYPTO_SUCCESS) {
	ret = SET_ERROR(EIO);
	goto error;
	}

	/* add in the os_type */
	intval = (le_bswap) ? osp->os_type : BSWAP_64(osp->os_type);
	cd.cd_length = sizeof (uint64_t);
	cd.cd_raw.iov_base = (char *)&intval;
	cd.cd_raw.iov_len = cd.cd_length;

	ret = crypto_mac_update(ctx, &cd, NULL);
	if (ret != CRYPTO_SUCCESS) {
	ret = SET_ERROR(EIO);
	goto error;
	}

	/* add in the portable os_flags */
	intval = osp->os_flags;
	if (should_bswap)
	intval = BSWAP_64(intval);
	intval &= OBJSET_CRYPT_PORTABLE_FLAGS_MASK;
	if (!ZFS_HOST_BYTEORDER)
	intval = BSWAP_64(intval);

	cd.cd_length = sizeof (uint64_t);
	cd.cd_raw.iov_base = (char *)&intval;
	cd.cd_raw.iov_len = cd.cd_length;

	ret = crypto_mac_update(ctx, &cd, NULL);
	if (ret != CRYPTO_SUCCESS) {
	ret = SET_ERROR(EIO);
	goto error;
	}

	/* add in fields from the metadnode */
	ret = zio_crypt_do_dnode_hmac_updates(ctx, key->zk_version,
	should_bswap, &osp->os_meta_dnode);
	if (ret)
	goto error;

	/* store the final digest in a temporary buffer and copy what we need */
	cd.cd_length = SHA512_DIGEST_LENGTH;
	cd.cd_raw.iov_base = (char *)raw_portable_mac;
	cd.cd_raw.iov_len = cd.cd_length;

	ret = crypto_mac_final(ctx, &cd, NULL);
	if (ret != CRYPTO_SUCCESS) {
	ret = SET_ERROR(EIO);
	goto error;
	}

	bcopy(raw_portable_mac, portable_mac, ZIO_OBJSET_MAC_LEN);

	- /*
	- * This is necessary here as we check next whether
	- * OBJSET_FLAG_USERACCOUNTING_COMPLETE or
	- * OBJSET_FLAG_USEROBJACCOUNTING are set in order to
	- * decide if the local_mac should be zeroed out.
	- */
	- intval = osp->os_flags;
	- if (should_bswap)
	- intval = BSWAP_64(intval);
	-
	/*
	* The local MAC protects the user, group and project accounting.
	* If these objects are not present, the local MAC is zeroed out.
	*/
	if ((datalen >= OBJSET_PHYS_SIZE_V3 &&
	osp->os_userused_dnode.dn_type == DMU_OT_NONE &&
	osp->os_groupused_dnode.dn_type == DMU_OT_NONE &&
	osp->os_projectused_dnode.dn_type == DMU_OT_NONE) \|\|
	(datalen >= OBJSET_PHYS_SIZE_V2 &&
	osp->os_userused_dnode.dn_type == DMU_OT_NONE &&
	osp->os_groupused_dnode.dn_type == DMU_OT_NONE) \|\|
	- (datalen <= OBJSET_PHYS_SIZE_V1) \|\|
	- (((intval & OBJSET_FLAG_USERACCOUNTING_COMPLETE) == 0 \|\|
	- (intval & OBJSET_FLAG_USEROBJACCOUNTING_COMPLETE) == 0) &&
	- key->zk_version > 0)) {
	+ (datalen <= OBJSET_PHYS_SIZE_V1)) {
	bzero(local_mac, ZIO_OBJSET_MAC_LEN);
	return (0);
	}

	/* calculate the local MAC from the userused and groupused dnodes */
	ret = crypto_mac_init(&mech, &key->zk_hmac_key, NULL, &ctx, NULL);
	if (ret != CRYPTO_SUCCESS) {
	ret = SET_ERROR(EIO);
	goto error;
	}

	/* add in the non-portable os_flags */
	intval = osp->os_flags;
	if (should_bswap)
	intval = BSWAP_64(intval);
	intval &= ~OBJSET_CRYPT_PORTABLE_FLAGS_MASK;
	if (!ZFS_HOST_BYTEORDER)
	intval = BSWAP_64(intval);

	cd.cd_length = sizeof (uint64_t);
	cd.cd_raw.iov_base = (char *)&intval;
	cd.cd_raw.iov_len = cd.cd_length;

	ret = crypto_mac_update(ctx, &cd, NULL);
	if (ret != CRYPTO_SUCCESS) {
	ret = SET_ERROR(EIO);
	goto error;
	}

	/* add in fields from the user accounting dnodes */
	if (osp->os_userused_dnode.dn_type != DMU_OT_NONE) {
	ret = zio_crypt_do_dnode_hmac_updates(ctx, key->zk_version,
	should_bswap, &osp->os_userused_dnode);
	if (ret)
	goto error;
	}

	if (osp->os_groupused_dnode.dn_type != DMU_OT_NONE) {
	ret = zio_crypt_do_dnode_hmac_updates(ctx, key->zk_version,
	should_bswap, &osp->os_groupused_dnode);
	if (ret)
	goto error;
	}

	if (osp->os_projectused_dnode.dn_type != DMU_OT_NONE &&
	datalen >= OBJSET_PHYS_SIZE_V3) {
	ret = zio_crypt_do_dnode_hmac_updates(ctx, key->zk_version,
	should_bswap, &osp->os_projectused_dnode);
	if (ret)
	goto error;
	}

	/* store the final digest in a temporary buffer and copy what we need */
	cd.cd_length = SHA512_DIGEST_LENGTH;
	cd.cd_raw.iov_base = (char *)raw_local_mac;
	cd.cd_raw.iov_len = cd.cd_length;

	ret = crypto_mac_final(ctx, &cd, NULL);
	if (ret != CRYPTO_SUCCESS) {
	ret = SET_ERROR(EIO);
	goto error;
	}

	bcopy(raw_local_mac, local_mac, ZIO_OBJSET_MAC_LEN);

	return (0);

	error:
	bzero(portable_mac, ZIO_OBJSET_MAC_LEN);
	bzero(local_mac, ZIO_OBJSET_MAC_LEN);
	return (ret);
	}

	static void
	zio_crypt_destroy_uio(zfs_uio_t *uio)
	{
	if (uio->uio_iov)
	kmem_free(uio->uio_iov, uio->uio_iovcnt * sizeof (iovec_t));
	}

	/*
	* This function parses an uncompressed indirect block and returns a checksum
	* of all the portable fields from all of the contained bps. The portable
	* fields are the MAC and all of the fields from blk_prop except for the dedup,
	* checksum, and psize bits. For an explanation of the purpose of this, see
	* the comment block on object set authentication.
	*/
	static int
	zio_crypt_do_indirect_mac_checksum_impl(boolean_t generate, void *buf,
	uint_t datalen, uint64_t version, boolean_t byteswap, uint8_t *cksum)
	{
	blkptr_t *bp;
	int i, epb = datalen >> SPA_BLKPTRSHIFT;
	SHA2_CTX ctx;
	uint8_t digestbuf[SHA512_DIGEST_LENGTH];

	/* checksum all of the MACs from the layer below */
	SHA2Init(SHA512, &ctx);
	for (i = 0, bp = buf; i < epb; i++, bp++) {
	zio_crypt_bp_do_indrect_checksum_updates(&ctx, version,
	byteswap, bp);
	}
	SHA2Final(digestbuf, &ctx);

	if (generate) {
	bcopy(digestbuf, cksum, ZIO_DATA_MAC_LEN);
	return (0);
	}

	if (bcmp(digestbuf, cksum, ZIO_DATA_MAC_LEN) != 0)
	return (SET_ERROR(ECKSUM));

	return (0);
	}

	int
	zio_crypt_do_indirect_mac_checksum(boolean_t generate, void *buf,
	uint_t datalen, boolean_t byteswap, uint8_t *cksum)
	{
	int ret;

	/*
	* Unfortunately, callers of this function will not always have
	* easy access to the on-disk format version. This info is
	* normally found in the DSL Crypto Key, but the checksum-of-MACs
	* is expected to be verifiable even when the key isn't loaded.
	* Here, instead of doing a ZAP lookup for the version for each
	* zio, we simply try both existing formats.
	*/
	ret = zio_crypt_do_indirect_mac_checksum_impl(generate, buf,
	datalen, ZIO_CRYPT_KEY_CURRENT_VERSION, byteswap, cksum);
	if (ret == ECKSUM) {
	ASSERT(!generate);
	ret = zio_crypt_do_indirect_mac_checksum_impl(generate,
	buf, datalen, 0, byteswap, cksum);
	}

	return (ret);
	}

	int
	zio_crypt_do_indirect_mac_checksum_abd(boolean_t generate, abd_t *abd,
	uint_t datalen, boolean_t byteswap, uint8_t *cksum)
	{
	int ret;
	void *buf;

	buf = abd_borrow_buf_copy(abd, datalen);
	ret = zio_crypt_do_indirect_mac_checksum(generate, buf, datalen,
	byteswap, cksum);
	abd_return_buf(abd, buf, datalen);

	return (ret);
	}

	/*
	* Special case handling routine for encrypting / decrypting ZIL blocks.
	* We do not check for the older ZIL chain because the encryption feature
	* was not available before the newer ZIL chain was introduced. The goal
	* here is to encrypt everything except the blkptr_t of a lr_write_t and
	* the zil_chain_t header. Everything that is not encrypted is authenticated.
	*/
	static int
	zio_crypt_init_uios_zil(boolean_t encrypt, uint8_t *plainbuf,
	uint8_t cipherbuf, uint_t datalen, boolean_t byteswap, zfs_uio_t puio,
	zfs_uio_t cuio, uint_t enc_len, uint8_t *authbuf, uint_t auth_len,
	boolean_t *no_crypt)
	{
	int ret;
	uint64_t txtype, lr_len;
	uint_t nr_src, nr_dst, crypt_len;
	uint_t aad_len = 0, nr_iovecs = 0, total_len = 0;
	iovec_t src_iovecs = NULL, dst_iovecs = NULL;
	uint8_t src, dst, slrp, dlrp, blkend, aadp;
	zil_chain_t *zilc;
	lr_t *lr;
	uint8_t *aadbuf = zio_buf_alloc(datalen);

	/* cipherbuf always needs an extra iovec for the MAC */
	if (encrypt) {
	src = plainbuf;
	dst = cipherbuf;
	nr_src = 0;
	nr_dst = 1;
	} else {
	src = cipherbuf;
	dst = plainbuf;
	nr_src = 1;
	nr_dst = 0;
	}
	bzero(dst, datalen);

	/* find the start and end record of the log block */
	zilc = (zil_chain_t *)src;
	slrp = src + sizeof (zil_chain_t);
	aadp = aadbuf;
	blkend = src + ((byteswap) ? BSWAP_64(zilc->zc_nused) : zilc->zc_nused);

	/* calculate the number of encrypted iovecs we will need */
	for (; slrp < blkend; slrp += lr_len) {
	lr = (lr_t *)slrp;

	if (!byteswap) {
	txtype = lr->lrc_txtype;
	lr_len = lr->lrc_reclen;
	} else {
	txtype = BSWAP_64(lr->lrc_txtype);
	lr_len = BSWAP_64(lr->lrc_reclen);
	}

	nr_iovecs++;
	if (txtype == TX_WRITE && lr_len != sizeof (lr_write_t))
	nr_iovecs++;
	}

	nr_src += nr_iovecs;
	nr_dst += nr_iovecs;

	/* allocate the iovec arrays */
	if (nr_src != 0) {
	src_iovecs = kmem_alloc(nr_src * sizeof (iovec_t), KM_SLEEP);
	if (src_iovecs == NULL) {
	ret = SET_ERROR(ENOMEM);
	goto error;
	}
	}

	if (nr_dst != 0) {
	dst_iovecs = kmem_alloc(nr_dst * sizeof (iovec_t), KM_SLEEP);
	if (dst_iovecs == NULL) {
	ret = SET_ERROR(ENOMEM);
	goto error;
	}
	}

	/*
	* Copy the plain zil header over and authenticate everything except
	* the checksum that will store our MAC. If we are writing the data
	* the embedded checksum will not have been calculated yet, so we don't
	* authenticate that.
	*/
	bcopy(src, dst, sizeof (zil_chain_t));
	bcopy(src, aadp, sizeof (zil_chain_t) - sizeof (zio_eck_t));
	aadp += sizeof (zil_chain_t) - sizeof (zio_eck_t);
	aad_len += sizeof (zil_chain_t) - sizeof (zio_eck_t);

	/* loop over records again, filling in iovecs */
	nr_iovecs = 0;
	slrp = src + sizeof (zil_chain_t);
	dlrp = dst + sizeof (zil_chain_t);

	for (; slrp < blkend; slrp += lr_len, dlrp += lr_len) {
	lr = (lr_t *)slrp;

	if (!byteswap) {
	txtype = lr->lrc_txtype;
	lr_len = lr->lrc_reclen;
	} else {
	txtype = BSWAP_64(lr->lrc_txtype);
	lr_len = BSWAP_64(lr->lrc_reclen);
	}

	/* copy the common lr_t */
	bcopy(slrp, dlrp, sizeof (lr_t));
	bcopy(slrp, aadp, sizeof (lr_t));
	aadp += sizeof (lr_t);
	aad_len += sizeof (lr_t);

	ASSERT3P(src_iovecs, !=, NULL);
	ASSERT3P(dst_iovecs, !=, NULL);

	/*
	* If this is a TX_WRITE record we want to encrypt everything
	* except the bp if exists. If the bp does exist we want to
	* authenticate it.
	*/
	if (txtype == TX_WRITE) {
	crypt_len = sizeof (lr_write_t) -
	sizeof (lr_t) - sizeof (blkptr_t);
	src_iovecs[nr_iovecs].iov_base = slrp + sizeof (lr_t);
	src_iovecs[nr_iovecs].iov_len = crypt_len;
	dst_iovecs[nr_iovecs].iov_base = dlrp + sizeof (lr_t);
	dst_iovecs[nr_iovecs].iov_len = crypt_len;

	/* copy the bp now since it will not be encrypted */
	bcopy(slrp + sizeof (lr_write_t) - sizeof (blkptr_t),
	dlrp + sizeof (lr_write_t) - sizeof (blkptr_t),
	sizeof (blkptr_t));
	bcopy(slrp + sizeof (lr_write_t) - sizeof (blkptr_t),
	aadp, sizeof (blkptr_t));
	aadp += sizeof (blkptr_t);
	aad_len += sizeof (blkptr_t);
	nr_iovecs++;
	total_len += crypt_len;

	if (lr_len != sizeof (lr_write_t)) {
	crypt_len = lr_len - sizeof (lr_write_t);
	src_iovecs[nr_iovecs].iov_base =
	slrp + sizeof (lr_write_t);
	src_iovecs[nr_iovecs].iov_len = crypt_len;
	dst_iovecs[nr_iovecs].iov_base =
	dlrp + sizeof (lr_write_t);
	dst_iovecs[nr_iovecs].iov_len = crypt_len;
	nr_iovecs++;
	total_len += crypt_len;
	}
	} else {
	crypt_len = lr_len - sizeof (lr_t);
	src_iovecs[nr_iovecs].iov_base = slrp + sizeof (lr_t);
	src_iovecs[nr_iovecs].iov_len = crypt_len;
	dst_iovecs[nr_iovecs].iov_base = dlrp + sizeof (lr_t);
	dst_iovecs[nr_iovecs].iov_len = crypt_len;
	nr_iovecs++;
	total_len += crypt_len;
	}
	}

	*no_crypt = (nr_iovecs == 0);
	*enc_len = total_len;
	*authbuf = aadbuf;
	*auth_len = aad_len;

	if (encrypt) {
	puio->uio_iov = src_iovecs;
	puio->uio_iovcnt = nr_src;
	cuio->uio_iov = dst_iovecs;
	cuio->uio_iovcnt = nr_dst;
	} else {
	puio->uio_iov = dst_iovecs;
	puio->uio_iovcnt = nr_dst;
	cuio->uio_iov = src_iovecs;
	cuio->uio_iovcnt = nr_src;
	}

	return (0);

	error:
	zio_buf_free(aadbuf, datalen);
	if (src_iovecs != NULL)
	kmem_free(src_iovecs, nr_src * sizeof (iovec_t));
	if (dst_iovecs != NULL)
	kmem_free(dst_iovecs, nr_dst * sizeof (iovec_t));

	*enc_len = 0;
	*authbuf = NULL;
	*auth_len = 0;
	*no_crypt = B_FALSE;
	puio->uio_iov = NULL;
	puio->uio_iovcnt = 0;
	cuio->uio_iov = NULL;
	cuio->uio_iovcnt = 0;
	return (ret);
	}

	/*
	* Special case handling routine for encrypting / decrypting dnode blocks.
	*/
	static int
	zio_crypt_init_uios_dnode(boolean_t encrypt, uint64_t version,
	uint8_t plainbuf, uint8_t cipherbuf, uint_t datalen, boolean_t byteswap,
	zfs_uio_t puio, zfs_uio_t cuio, uint_t enc_len, uint8_t *authbuf,
	uint_t auth_len, boolean_t no_crypt)
	{
	int ret;
	uint_t nr_src, nr_dst, crypt_len;
	uint_t aad_len = 0, nr_iovecs = 0, total_len = 0;
	uint_t i, j, max_dnp = datalen >> DNODE_SHIFT;
	iovec_t src_iovecs = NULL, dst_iovecs = NULL;
	uint8_t src, dst, *aadp;
	dnode_phys_t dnp, adnp, sdnp, ddnp;
	uint8_t *aadbuf = zio_buf_alloc(datalen);

	if (encrypt) {
	src = plainbuf;
	dst = cipherbuf;
	nr_src = 0;
	nr_dst = 1;
	} else {
	src = cipherbuf;
	dst = plainbuf;
	nr_src = 1;
	nr_dst = 0;
	}

	sdnp = (dnode_phys_t *)src;
	ddnp = (dnode_phys_t *)dst;
	aadp = aadbuf;

	/*
	* Count the number of iovecs we will need to do the encryption by
	* counting the number of bonus buffers that need to be encrypted.
	*/
	for (i = 0; i < max_dnp; i += sdnp[i].dn_extra_slots + 1) {
	/*
	* This block may still be byteswapped. However, all of the
	* values we use are either uint8_t's (for which byteswapping
	* is a noop) or a * != 0 check, which will work regardless
	* of whether or not we byteswap.
	*/
	if (sdnp[i].dn_type != DMU_OT_NONE &&
	DMU_OT_IS_ENCRYPTED(sdnp[i].dn_bonustype) &&
	sdnp[i].dn_bonuslen != 0) {
	nr_iovecs++;
	}
	}

	nr_src += nr_iovecs;
	nr_dst += nr_iovecs;

	if (nr_src != 0) {
	src_iovecs = kmem_alloc(nr_src * sizeof (iovec_t), KM_SLEEP);
	if (src_iovecs == NULL) {
	ret = SET_ERROR(ENOMEM);
	goto error;
	}
	}

	if (nr_dst != 0) {
	dst_iovecs = kmem_alloc(nr_dst * sizeof (iovec_t), KM_SLEEP);
	if (dst_iovecs == NULL) {
	ret = SET_ERROR(ENOMEM);
	goto error;
	}
	}

	nr_iovecs = 0;

	/*
	* Iterate through the dnodes again, this time filling in the uios
	* we allocated earlier. We also concatenate any data we want to
	* authenticate onto aadbuf.
	*/
	for (i = 0; i < max_dnp; i += sdnp[i].dn_extra_slots + 1) {
	dnp = &sdnp[i];

	/* copy over the core fields and blkptrs (kept as plaintext) */
	bcopy(dnp, &ddnp[i], (uint8_t )DN_BONUS(dnp) - (uint8_t )dnp);

	if (dnp->dn_flags & DNODE_FLAG_SPILL_BLKPTR) {
	bcopy(DN_SPILL_BLKPTR(dnp), DN_SPILL_BLKPTR(&ddnp[i]),
	sizeof (blkptr_t));
	}

	/*
	* Handle authenticated data. We authenticate everything in
	* the dnode that can be brought over when we do a raw send.
	* This includes all of the core fields as well as the MACs
	* stored in the bp checksums and all of the portable bits
	* from blk_prop. We include the dnode padding here in case it
	* ever gets used in the future. Some dn_flags and dn_used are
	* not portable so we mask those out values out of the
	* authenticated data.
	*/
	crypt_len = offsetof(dnode_phys_t, dn_blkptr);
	bcopy(dnp, aadp, crypt_len);
	adnp = (dnode_phys_t *)aadp;
	adnp->dn_flags &= DNODE_CRYPT_PORTABLE_FLAGS_MASK;
	adnp->dn_used = 0;
	aadp += crypt_len;
	aad_len += crypt_len;

	for (j = 0; j < dnp->dn_nblkptr; j++) {
	zio_crypt_bp_do_aad_updates(&aadp, &aad_len,
	version, byteswap, &dnp->dn_blkptr[j]);
	}

	if (dnp->dn_flags & DNODE_FLAG_SPILL_BLKPTR) {
	zio_crypt_bp_do_aad_updates(&aadp, &aad_len,
	version, byteswap, DN_SPILL_BLKPTR(dnp));
	}

	/*
	* If this bonus buffer needs to be encrypted, we prepare an
	* iovec_t. The encryption / decryption functions will fill
	* this in for us with the encrypted or decrypted data.
	* Otherwise we add the bonus buffer to the authenticated
	* data buffer and copy it over to the destination. The
	* encrypted iovec extends to DN_MAX_BONUS_LEN(dnp) so that
	* we can guarantee alignment with the AES block size
	* (128 bits).
	*/
	crypt_len = DN_MAX_BONUS_LEN(dnp);
	if (dnp->dn_type != DMU_OT_NONE &&
	DMU_OT_IS_ENCRYPTED(dnp->dn_bonustype) &&
	dnp->dn_bonuslen != 0) {
	ASSERT3U(nr_iovecs, <, nr_src);
	ASSERT3U(nr_iovecs, <, nr_dst);
	ASSERT3P(src_iovecs, !=, NULL);
	ASSERT3P(dst_iovecs, !=, NULL);
	src_iovecs[nr_iovecs].iov_base = DN_BONUS(dnp);
	src_iovecs[nr_iovecs].iov_len = crypt_len;
	dst_iovecs[nr_iovecs].iov_base = DN_BONUS(&ddnp[i]);
	dst_iovecs[nr_iovecs].iov_len = crypt_len;

	nr_iovecs++;
	total_len += crypt_len;
	} else {
	bcopy(DN_BONUS(dnp), DN_BONUS(&ddnp[i]), crypt_len);
	bcopy(DN_BONUS(dnp), aadp, crypt_len);
	aadp += crypt_len;
	aad_len += crypt_len;
	}
	}

	*no_crypt = (nr_iovecs == 0);
	*enc_len = total_len;
	*authbuf = aadbuf;
	*auth_len = aad_len;

	if (encrypt) {
	puio->uio_iov = src_iovecs;
	puio->uio_iovcnt = nr_src;
	cuio->uio_iov = dst_iovecs;
	cuio->uio_iovcnt = nr_dst;
	} else {
	puio->uio_iov = dst_iovecs;
	puio->uio_iovcnt = nr_dst;
	cuio->uio_iov = src_iovecs;
	cuio->uio_iovcnt = nr_src;
	}

	return (0);

	error:
	zio_buf_free(aadbuf, datalen);
	if (src_iovecs != NULL)
	kmem_free(src_iovecs, nr_src * sizeof (iovec_t));
	if (dst_iovecs != NULL)
	kmem_free(dst_iovecs, nr_dst * sizeof (iovec_t));

	*enc_len = 0;
	*authbuf = NULL;
	*auth_len = 0;
	*no_crypt = B_FALSE;
	puio->uio_iov = NULL;
	puio->uio_iovcnt = 0;
	cuio->uio_iov = NULL;
	cuio->uio_iovcnt = 0;
	return (ret);
	}

	static int
	zio_crypt_init_uios_normal(boolean_t encrypt, uint8_t *plainbuf,
	uint8_t cipherbuf, uint_t datalen, zfs_uio_t puio, zfs_uio_t *cuio,
	uint_t *enc_len)
	{
	int ret;
	uint_t nr_plain = 1, nr_cipher = 2;
	iovec_t plain_iovecs = NULL, cipher_iovecs = NULL;

	/* allocate the iovecs for the plain and cipher data */
	plain_iovecs = kmem_alloc(nr_plain * sizeof (iovec_t),
	KM_SLEEP);
	if (!plain_iovecs) {
	ret = SET_ERROR(ENOMEM);
	goto error;
	}

	cipher_iovecs = kmem_alloc(nr_cipher * sizeof (iovec_t),
	KM_SLEEP);
	if (!cipher_iovecs) {
	ret = SET_ERROR(ENOMEM);
	goto error;
	}

	plain_iovecs[0].iov_base = plainbuf;
	plain_iovecs[0].iov_len = datalen;
	cipher_iovecs[0].iov_base = cipherbuf;
	cipher_iovecs[0].iov_len = datalen;

	*enc_len = datalen;
	puio->uio_iov = plain_iovecs;
	puio->uio_iovcnt = nr_plain;
	cuio->uio_iov = cipher_iovecs;
	cuio->uio_iovcnt = nr_cipher;

	return (0);

	error:
	if (plain_iovecs != NULL)
	kmem_free(plain_iovecs, nr_plain * sizeof (iovec_t));
	if (cipher_iovecs != NULL)
	kmem_free(cipher_iovecs, nr_cipher * sizeof (iovec_t));

	*enc_len = 0;
	puio->uio_iov = NULL;
	puio->uio_iovcnt = 0;
	cuio->uio_iov = NULL;
	cuio->uio_iovcnt = 0;
	return (ret);
	}

	/*
	* This function builds up the plaintext (puio) and ciphertext (cuio) uios so
	* that they can be used for encryption and decryption by zio_do_crypt_uio().
	* Most blocks will use zio_crypt_init_uios_normal(), with ZIL and dnode blocks
	* requiring special handling to parse out pieces that are to be encrypted. The
	* authbuf is used by these special cases to store additional authenticated
	* data (AAD) for the encryption modes.
	*/
	static int
	zio_crypt_init_uios(boolean_t encrypt, uint64_t version, dmu_object_type_t ot,
	uint8_t plainbuf, uint8_t cipherbuf, uint_t datalen, boolean_t byteswap,
	uint8_t mac, zfs_uio_t puio, zfs_uio_t cuio, uint_t enc_len,
	uint8_t *authbuf, uint_t auth_len, boolean_t *no_crypt)
	{
	int ret;
	iovec_t *mac_iov;

	ASSERT(DMU_OT_IS_ENCRYPTED(ot) \|\| ot == DMU_OT_NONE);

	/* route to handler */
	switch (ot) {
	case DMU_OT_INTENT_LOG:
	ret = zio_crypt_init_uios_zil(encrypt, plainbuf, cipherbuf,
	datalen, byteswap, puio, cuio, enc_len, authbuf, auth_len,
	no_crypt);
	break;
	case DMU_OT_DNODE:
	ret = zio_crypt_init_uios_dnode(encrypt, version, plainbuf,
	cipherbuf, datalen, byteswap, puio, cuio, enc_len, authbuf,
	auth_len, no_crypt);
	break;
	default:
	ret = zio_crypt_init_uios_normal(encrypt, plainbuf, cipherbuf,
	datalen, puio, cuio, enc_len);
	*authbuf = NULL;
	*auth_len = 0;
	*no_crypt = B_FALSE;
	break;
	}

	if (ret != 0)
	goto error;

	/* populate the uios */
	puio->uio_segflg = UIO_SYSSPACE;
	cuio->uio_segflg = UIO_SYSSPACE;

	mac_iov = ((iovec_t *)&cuio->uio_iov[cuio->uio_iovcnt - 1]);
	mac_iov->iov_base = mac;
	mac_iov->iov_len = ZIO_DATA_MAC_LEN;

	return (0);

	error:
	return (ret);
	}

	/*
	* Primary encryption / decryption entrypoint for zio data.
	*/
	int
	zio_do_crypt_data(boolean_t encrypt, zio_crypt_key_t *key,
	dmu_object_type_t ot, boolean_t byteswap, uint8_t salt, uint8_t iv,
	uint8_t mac, uint_t datalen, uint8_t plainbuf, uint8_t *cipherbuf,
	boolean_t *no_crypt)
	{
	int ret;
	boolean_t locked = B_FALSE;
	uint64_t crypt = key->zk_crypt;
	uint_t keydata_len = zio_crypt_table[crypt].ci_keylen;
	uint_t enc_len, auth_len;
	zfs_uio_t puio, cuio;
	uint8_t enc_keydata[MASTER_KEY_MAX_LEN];
	crypto_key_t tmp_ckey, *ckey = NULL;
	crypto_ctx_template_t tmpl;
	uint8_t *authbuf = NULL;

	/*
	* If the needed key is the current one, just use it. Otherwise we
	* need to generate a temporary one from the given salt + master key.
	* If we are encrypting, we must return a copy of the current salt
	* so that it can be stored in the blkptr_t.
	*/
	rw_enter(&key->zk_salt_lock, RW_READER);
	locked = B_TRUE;

	if (bcmp(salt, key->zk_salt, ZIO_DATA_SALT_LEN) == 0) {
	ckey = &key->zk_current_key;
	tmpl = key->zk_current_tmpl;
	} else {
	rw_exit(&key->zk_salt_lock);
	locked = B_FALSE;

	ret = hkdf_sha512(key->zk_master_keydata, keydata_len, NULL, 0,
	salt, ZIO_DATA_SALT_LEN, enc_keydata, keydata_len);
	if (ret != 0)
	goto error;

	tmp_ckey.ck_format = CRYPTO_KEY_RAW;
	tmp_ckey.ck_data = enc_keydata;
	tmp_ckey.ck_length = CRYPTO_BYTES2BITS(keydata_len);

	ckey = &tmp_ckey;
	tmpl = NULL;
	}

	/*
	* Attempt to use QAT acceleration if we can. We currently don't
	* do this for metadnode and ZIL blocks, since they have a much
	* more involved buffer layout and the qat_crypt() function only
	* works in-place.
	*/
	if (qat_crypt_use_accel(datalen) &&
	ot != DMU_OT_INTENT_LOG && ot != DMU_OT_DNODE) {
	uint8_t srcbuf, dstbuf;

	if (encrypt) {
	srcbuf = plainbuf;
	dstbuf = cipherbuf;
	} else {
	srcbuf = cipherbuf;
	dstbuf = plainbuf;
	}

	ret = qat_crypt((encrypt) ? QAT_ENCRYPT : QAT_DECRYPT, srcbuf,
	dstbuf, NULL, 0, iv, mac, ckey, key->zk_crypt, datalen);
	if (ret == CPA_STATUS_SUCCESS) {
	if (locked) {
	rw_exit(&key->zk_salt_lock);
	locked = B_FALSE;
	}

	return (0);
	}
	/* If the hardware implementation fails fall back to software */
	}

	bzero(&puio, sizeof (zfs_uio_t));
	bzero(&cuio, sizeof (zfs_uio_t));

	/* create uios for encryption */
	ret = zio_crypt_init_uios(encrypt, key->zk_version, ot, plainbuf,
	cipherbuf, datalen, byteswap, mac, &puio, &cuio, &enc_len,
	&authbuf, &auth_len, no_crypt);
	if (ret != 0)
	goto error;

	/* perform the encryption / decryption in software */
	ret = zio_do_crypt_uio(encrypt, key->zk_crypt, ckey, tmpl, iv, enc_len,
	&puio, &cuio, authbuf, auth_len);
	if (ret != 0)
	goto error;

	if (locked) {
	rw_exit(&key->zk_salt_lock);
	locked = B_FALSE;
	}

	if (authbuf != NULL)
	zio_buf_free(authbuf, datalen);
	if (ckey == &tmp_ckey)
	bzero(enc_keydata, keydata_len);
	zio_crypt_destroy_uio(&puio);
	zio_crypt_destroy_uio(&cuio);

	return (0);

	error:
	if (locked)
	rw_exit(&key->zk_salt_lock);
	if (authbuf != NULL)
	zio_buf_free(authbuf, datalen);
	if (ckey == &tmp_ckey)
	bzero(enc_keydata, keydata_len);
	zio_crypt_destroy_uio(&puio);
	zio_crypt_destroy_uio(&cuio);

	return (ret);
	}

	/*
	* Simple wrapper around zio_do_crypt_data() to work with abd's instead of
	* linear buffers.
	*/
	int
	zio_do_crypt_abd(boolean_t encrypt, zio_crypt_key_t *key, dmu_object_type_t ot,
	boolean_t byteswap, uint8_t salt, uint8_t iv, uint8_t *mac,
	uint_t datalen, abd_t pabd, abd_t cabd, boolean_t *no_crypt)
	{
	int ret;
	void ptmp, ctmp;

	if (encrypt) {
	ptmp = abd_borrow_buf_copy(pabd, datalen);
	ctmp = abd_borrow_buf(cabd, datalen);
	} else {
	ptmp = abd_borrow_buf(pabd, datalen);
	ctmp = abd_borrow_buf_copy(cabd, datalen);
	}

	ret = zio_do_crypt_data(encrypt, key, ot, byteswap, salt, iv, mac,
	datalen, ptmp, ctmp, no_crypt);
	if (ret != 0)
	goto error;

	if (encrypt) {
	abd_return_buf(pabd, ptmp, datalen);
	abd_return_buf_copy(cabd, ctmp, datalen);
	} else {
	abd_return_buf_copy(pabd, ptmp, datalen);
	abd_return_buf(cabd, ctmp, datalen);
	}

	return (0);

	error:
	if (encrypt) {
	abd_return_buf(pabd, ptmp, datalen);
	abd_return_buf_copy(cabd, ctmp, datalen);
	} else {
	abd_return_buf_copy(pabd, ptmp, datalen);
	abd_return_buf(cabd, ctmp, datalen);
	}

	return (ret);
	}

	#if defined(_KERNEL)
	/* BEGIN CSTYLED */
	module_param(zfs_key_max_salt_uses, ulong, 0644);
	MODULE_PARM_DESC(zfs_key_max_salt_uses, "Max number of times a salt value "
	"can be used for generating encryption keys before it is rotated");
	/* END CSTYLED */
	#endif
	diff --git a/sys/contrib/openzfs/module/os/linux/zfs/zpl_export.c b/sys/contrib/openzfs/module/os/linux/zfs/zpl_export.c
	index eaf048c38db1..5be63532d329 100644
	--- a/sys/contrib/openzfs/module/os/linux/zfs/zpl_export.c
	+++ b/sys/contrib/openzfs/module/os/linux/zfs/zpl_export.c
	@@ -1,154 +1,158 @@
	/*
	* 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) 2011 Gunnar Beutner
	* Copyright (c) 2012 Cyril Plisko. All rights reserved.
	*/


	#include <sys/zfs_znode.h>
	#include <sys/zfs_vnops.h>
	#include <sys/zfs_ctldir.h>
	#include <sys/zpl.h>


	static int
	#ifdef HAVE_ENCODE_FH_WITH_INODE
	zpl_encode_fh(struct inode ip, __u32 fh, int max_len, struct inode parent)
	{
	#else
	zpl_encode_fh(struct dentry dentry, __u32 fh, int *max_len, int connectable)
	{
	/* CSTYLED */
	struct inode *ip = dentry->d_inode;
	#endif /* HAVE_ENCODE_FH_WITH_INODE */
	fstrans_cookie_t cookie;
	- fid_t fid = (fid_t )fh;
	+ ushort_t empty_fid = 0;
	+ fid_t *fid;
	int len_bytes, rc;

	len_bytes = max_len sizeof (__u32);

	- if (len_bytes < offsetof(fid_t, fid_data))
	- return (255);
	+ if (len_bytes < offsetof(fid_t, fid_data)) {
	+ fid = (fid_t *)&empty_fid;
	+ } else {
	+ fid = (fid_t *)fh;
	+ fid->fid_len = len_bytes - offsetof(fid_t, fid_data);
	+ }

	- fid->fid_len = len_bytes - offsetof(fid_t, fid_data);
	cookie = spl_fstrans_mark();

	if (zfsctl_is_node(ip))
	rc = zfsctl_fid(ip, fid);
	else
	rc = zfs_fid(ip, fid);

	spl_fstrans_unmark(cookie);
	len_bytes = offsetof(fid_t, fid_data) + fid->fid_len;
	*max_len = roundup(len_bytes, sizeof (__u32)) / sizeof (__u32);

	return (rc == 0 ? FILEID_INO32_GEN : 255);
	}

	static struct dentry *
	zpl_fh_to_dentry(struct super_block sb, struct fid fh,
	int fh_len, int fh_type)
	{
	fid_t fid = (fid_t )fh;
	fstrans_cookie_t cookie;
	struct inode *ip;
	int len_bytes, rc;

	len_bytes = fh_len * sizeof (__u32);

	if (fh_type != FILEID_INO32_GEN \|\|
	len_bytes < offsetof(fid_t, fid_data) \|\|
	len_bytes < offsetof(fid_t, fid_data) + fid->fid_len)
	return (ERR_PTR(-EINVAL));

	cookie = spl_fstrans_mark();
	rc = zfs_vget(sb, &ip, fid);
	spl_fstrans_unmark(cookie);

	if (rc) {
	/*
	* If we see ENOENT it might mean that an NFSv4 * client
	* is using a cached inode value in a file handle and
	* that the sought after file has had its inode changed
	* by a third party. So change the error to ESTALE
	* which will trigger a full lookup by the client and
	* will find the new filename/inode pair if it still
	* exists.
	*/
	if (rc == ENOENT)
	rc = ESTALE;

	return (ERR_PTR(-rc));
	}

	ASSERT((ip != NULL) && !IS_ERR(ip));

	return (d_obtain_alias(ip));
	}

	static struct dentry *
	zpl_get_parent(struct dentry *child)
	{
	cred_t *cr = CRED();
	fstrans_cookie_t cookie;
	znode_t *zp;
	int error;

	crhold(cr);
	cookie = spl_fstrans_mark();
	error = -zfs_lookup(ITOZ(child->d_inode), "..", &zp, 0, cr, NULL, NULL);
	spl_fstrans_unmark(cookie);
	crfree(cr);
	ASSERT3S(error, <=, 0);

	if (error)
	return (ERR_PTR(error));

	return (d_obtain_alias(ZTOI(zp)));
	}

	static int
	zpl_commit_metadata(struct inode *inode)
	{
	cred_t *cr = CRED();
	fstrans_cookie_t cookie;
	int error;

	if (zfsctl_is_node(inode))
	return (0);

	crhold(cr);
	cookie = spl_fstrans_mark();
	error = -zfs_fsync(ITOZ(inode), 0, cr);
	spl_fstrans_unmark(cookie);
	crfree(cr);
	ASSERT3S(error, <=, 0);

	return (error);
	}

	const struct export_operations zpl_export_operations = {
	.encode_fh = zpl_encode_fh,
	.fh_to_dentry = zpl_fh_to_dentry,
	.get_parent = zpl_get_parent,
	.commit_metadata = zpl_commit_metadata,
	};
	diff --git a/sys/contrib/openzfs/module/os/linux/zfs/zpl_file.c b/sys/contrib/openzfs/module/os/linux/zfs/zpl_file.c
	index d042783da1b2..421aebefe465 100644
	--- a/sys/contrib/openzfs/module/os/linux/zfs/zpl_file.c
	+++ b/sys/contrib/openzfs/module/os/linux/zfs/zpl_file.c
	@@ -1,1069 +1,1069 @@
	/*
	* 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) 2011, Lawrence Livermore National Security, LLC.
	* Copyright (c) 2015 by Chunwei Chen. All rights reserved.
	*/


	#ifdef CONFIG_COMPAT
	#include <linux/compat.h>
	#endif
	#include <sys/file.h>
	#include <sys/dmu_objset.h>
	#include <sys/zfs_znode.h>
	#include <sys/zfs_vfsops.h>
	#include <sys/zfs_vnops.h>
	#include <sys/zfs_project.h>

	/*
	* When using fallocate(2) to preallocate space, inflate the requested
	* capacity check by 10% to account for the required metadata blocks.
	*/
	unsigned int zfs_fallocate_reserve_percent = 110;

	static int
	zpl_open(struct inode ip, struct file filp)
	{
	cred_t *cr = CRED();
	int error;
	fstrans_cookie_t cookie;

	error = generic_file_open(ip, filp);
	if (error)
	return (error);

	crhold(cr);
	cookie = spl_fstrans_mark();
	error = -zfs_open(ip, filp->f_mode, filp->f_flags, cr);
	spl_fstrans_unmark(cookie);
	crfree(cr);
	ASSERT3S(error, <=, 0);

	return (error);
	}

	static int
	zpl_release(struct inode ip, struct file filp)
	{
	cred_t *cr = CRED();
	int error;
	fstrans_cookie_t cookie;

	cookie = spl_fstrans_mark();
	if (ITOZ(ip)->z_atime_dirty)
	zfs_mark_inode_dirty(ip);

	crhold(cr);
	error = -zfs_close(ip, filp->f_flags, cr);
	spl_fstrans_unmark(cookie);
	crfree(cr);
	ASSERT3S(error, <=, 0);

	return (error);
	}

	static int
	zpl_iterate(struct file filp, zpl_dir_context_t ctx)
	{
	cred_t *cr = CRED();
	int error;
	fstrans_cookie_t cookie;

	crhold(cr);
	cookie = spl_fstrans_mark();
	error = -zfs_readdir(file_inode(filp), ctx, cr);
	spl_fstrans_unmark(cookie);
	crfree(cr);
	ASSERT3S(error, <=, 0);

	return (error);
	}

	#if !defined(HAVE_VFS_ITERATE) && !defined(HAVE_VFS_ITERATE_SHARED)
	static int
	zpl_readdir(struct file filp, void dirent, filldir_t filldir)
	{
	zpl_dir_context_t ctx =
	ZPL_DIR_CONTEXT_INIT(dirent, filldir, filp->f_pos);
	int error;

	error = zpl_iterate(filp, &ctx);
	filp->f_pos = ctx.pos;

	return (error);
	}
	#endif /* !HAVE_VFS_ITERATE && !HAVE_VFS_ITERATE_SHARED */

	#if defined(HAVE_FSYNC_WITHOUT_DENTRY)
	/*
	* Linux 2.6.35 - 3.0 API,
	* As of 2.6.35 the dentry argument to the fops->fsync() hook was deemed
	* redundant. The dentry is still accessible via filp->f_path.dentry,
	* and we are guaranteed that filp will never be NULL.
	*/
	static int
	zpl_fsync(struct file *filp, int datasync)
	{
	struct inode *inode = filp->f_mapping->host;
	cred_t *cr = CRED();
	int error;
	fstrans_cookie_t cookie;

	crhold(cr);
	cookie = spl_fstrans_mark();
	error = -zfs_fsync(ITOZ(inode), datasync, cr);
	spl_fstrans_unmark(cookie);
	crfree(cr);
	ASSERT3S(error, <=, 0);

	return (error);
	}

	#ifdef HAVE_FILE_AIO_FSYNC
	static int
	zpl_aio_fsync(struct kiocb *kiocb, int datasync)
	{
	return (zpl_fsync(kiocb->ki_filp, datasync));
	}
	#endif

	#elif defined(HAVE_FSYNC_RANGE)
	/*
	- * Linux 3.1 - 3.x API,
	+ * Linux 3.1 API,
	* As of 3.1 the responsibility to call filemap_write_and_wait_range() has
	* been pushed down in to the .fsync() vfs hook. Additionally, the i_mutex
	* lock is no longer held by the caller, for zfs we don't require the lock
	* to be held so we don't acquire it.
	*/
	static int
	zpl_fsync(struct file *filp, loff_t start, loff_t end, int datasync)
	{
	struct inode *inode = filp->f_mapping->host;
	cred_t *cr = CRED();
	int error;
	fstrans_cookie_t cookie;

	error = filemap_write_and_wait_range(inode->i_mapping, start, end);
	if (error)
	return (error);

	crhold(cr);
	cookie = spl_fstrans_mark();
	error = -zfs_fsync(ITOZ(inode), datasync, cr);
	spl_fstrans_unmark(cookie);
	crfree(cr);
	ASSERT3S(error, <=, 0);

	return (error);
	}

	#ifdef HAVE_FILE_AIO_FSYNC
	static int
	zpl_aio_fsync(struct kiocb *kiocb, int datasync)
	{
	return (zpl_fsync(kiocb->ki_filp, kiocb->ki_pos, -1, datasync));
	}
	#endif

	#else
	#error "Unsupported fops->fsync() implementation"
	#endif

	static inline int
	zfs_io_flags(struct kiocb *kiocb)
	{
	int flags = 0;

	#if defined(IOCB_DSYNC)
	if (kiocb->ki_flags & IOCB_DSYNC)
	flags \|= O_DSYNC;
	#endif
	#if defined(IOCB_SYNC)
	if (kiocb->ki_flags & IOCB_SYNC)
	flags \|= O_SYNC;
	#endif
	#if defined(IOCB_APPEND)
	if (kiocb->ki_flags & IOCB_APPEND)
	flags \|= O_APPEND;
	#endif
	#if defined(IOCB_DIRECT)
	if (kiocb->ki_flags & IOCB_DIRECT)
	flags \|= O_DIRECT;
	#endif
	return (flags);
	}

	/*
	* If relatime is enabled, call file_accessed() if zfs_relatime_need_update()
	* is true. This is needed since datasets with inherited "relatime" property
	* aren't necessarily mounted with the MNT_RELATIME flag (e.g. after
	* `zfs set relatime=...`), which is what relatime test in VFS by
	* relatime_need_update() is based on.
	*/
	static inline void
	zpl_file_accessed(struct file *filp)
	{
	struct inode *ip = filp->f_mapping->host;

	if (!IS_NOATIME(ip) && ITOZSB(ip)->z_relatime) {
	if (zfs_relatime_need_update(ip))
	file_accessed(filp);
	} else {
	file_accessed(filp);
	}
	}

	#if defined(HAVE_VFS_RW_ITERATE)

	/*
	* When HAVE_VFS_IOV_ITER is defined the iov_iter structure supports
	* iovecs, kvevs, bvecs and pipes, plus all the required interfaces to
	* manipulate the iov_iter are available. In which case the full iov_iter
	* can be attached to the uio and correctly handled in the lower layers.
	* Otherwise, for older kernels extract the iovec and pass it instead.
	*/
	static void
	zpl_uio_init(zfs_uio_t uio, struct kiocb kiocb, struct iov_iter *to,
	loff_t pos, ssize_t count, size_t skip)
	{
	#if defined(HAVE_VFS_IOV_ITER)
	zfs_uio_iov_iter_init(uio, to, pos, count, skip);
	#else
	zfs_uio_iovec_init(uio, to->iov, to->nr_segs, pos,
	to->type & ITER_KVEC ? UIO_SYSSPACE : UIO_USERSPACE,
	count, skip);
	#endif
	}

	static ssize_t
	zpl_iter_read(struct kiocb kiocb, struct iov_iter to)
	{
	cred_t *cr = CRED();
	fstrans_cookie_t cookie;
	struct file *filp = kiocb->ki_filp;
	ssize_t count = iov_iter_count(to);
	zfs_uio_t uio;

	zpl_uio_init(&uio, kiocb, to, kiocb->ki_pos, count, 0);

	crhold(cr);
	cookie = spl_fstrans_mark();

	int error = -zfs_read(ITOZ(filp->f_mapping->host), &uio,
	filp->f_flags \| zfs_io_flags(kiocb), cr);

	spl_fstrans_unmark(cookie);
	crfree(cr);

	if (error < 0)
	return (error);

	ssize_t read = count - uio.uio_resid;
	kiocb->ki_pos += read;

	zpl_file_accessed(filp);

	return (read);
	}

	static inline ssize_t
	zpl_generic_write_checks(struct kiocb kiocb, struct iov_iter from,
	size_t *countp)
	{
	#ifdef HAVE_GENERIC_WRITE_CHECKS_KIOCB
	ssize_t ret = generic_write_checks(kiocb, from);
	if (ret <= 0)
	return (ret);

	*countp = ret;
	#else
	struct file *file = kiocb->ki_filp;
	struct address_space *mapping = file->f_mapping;
	struct inode *ip = mapping->host;
	int isblk = S_ISBLK(ip->i_mode);

	*countp = iov_iter_count(from);
	ssize_t ret = generic_write_checks(file, &kiocb->ki_pos, countp, isblk);
	if (ret)
	return (ret);
	#endif

	return (0);
	}

	static ssize_t
	zpl_iter_write(struct kiocb kiocb, struct iov_iter from)
	{
	cred_t *cr = CRED();
	fstrans_cookie_t cookie;
	struct file *filp = kiocb->ki_filp;
	struct inode *ip = filp->f_mapping->host;
	zfs_uio_t uio;
	size_t count = 0;
	ssize_t ret;

	ret = zpl_generic_write_checks(kiocb, from, &count);
	if (ret)
	return (ret);

	zpl_uio_init(&uio, kiocb, from, kiocb->ki_pos, count, from->iov_offset);

	crhold(cr);
	cookie = spl_fstrans_mark();

	int error = -zfs_write(ITOZ(ip), &uio,
	filp->f_flags \| zfs_io_flags(kiocb), cr);

	spl_fstrans_unmark(cookie);
	crfree(cr);

	if (error < 0)
	return (error);

	ssize_t wrote = count - uio.uio_resid;
	kiocb->ki_pos += wrote;

	if (wrote > 0)
	iov_iter_advance(from, wrote);

	return (wrote);
	}

	#else /* !HAVE_VFS_RW_ITERATE */

	static ssize_t
	zpl_aio_read(struct kiocb kiocb, const struct iovec iov,
	unsigned long nr_segs, loff_t pos)
	{
	cred_t *cr = CRED();
	fstrans_cookie_t cookie;
	struct file *filp = kiocb->ki_filp;
	size_t count;
	ssize_t ret;

	ret = generic_segment_checks(iov, &nr_segs, &count, VERIFY_WRITE);
	if (ret)
	return (ret);

	zfs_uio_t uio;
	zfs_uio_iovec_init(&uio, iov, nr_segs, kiocb->ki_pos, UIO_USERSPACE,
	count, 0);

	crhold(cr);
	cookie = spl_fstrans_mark();

	int error = -zfs_read(ITOZ(filp->f_mapping->host), &uio,
	filp->f_flags \| zfs_io_flags(kiocb), cr);

	spl_fstrans_unmark(cookie);
	crfree(cr);

	if (error < 0)
	return (error);

	ssize_t read = count - uio.uio_resid;
	kiocb->ki_pos += read;

	zpl_file_accessed(filp);

	return (read);
	}

	static ssize_t
	zpl_aio_write(struct kiocb kiocb, const struct iovec iov,
	unsigned long nr_segs, loff_t pos)
	{
	cred_t *cr = CRED();
	fstrans_cookie_t cookie;
	struct file *filp = kiocb->ki_filp;
	struct inode *ip = filp->f_mapping->host;
	size_t count;
	ssize_t ret;

	ret = generic_segment_checks(iov, &nr_segs, &count, VERIFY_READ);
	if (ret)
	return (ret);

	ret = generic_write_checks(filp, &pos, &count, S_ISBLK(ip->i_mode));
	if (ret)
	return (ret);

	zfs_uio_t uio;
	zfs_uio_iovec_init(&uio, iov, nr_segs, kiocb->ki_pos, UIO_USERSPACE,
	count, 0);

	crhold(cr);
	cookie = spl_fstrans_mark();

	int error = -zfs_write(ITOZ(ip), &uio,
	filp->f_flags \| zfs_io_flags(kiocb), cr);

	spl_fstrans_unmark(cookie);
	crfree(cr);

	if (error < 0)
	return (error);

	ssize_t wrote = count - uio.uio_resid;
	kiocb->ki_pos += wrote;

	return (wrote);
	}
	#endif /* HAVE_VFS_RW_ITERATE */

	#if defined(HAVE_VFS_RW_ITERATE)
	static ssize_t
	zpl_direct_IO_impl(int rw, struct kiocb kiocb, struct iov_iter iter)
	{
	if (rw == WRITE)
	return (zpl_iter_write(kiocb, iter));
	else
	return (zpl_iter_read(kiocb, iter));
	}
	#if defined(HAVE_VFS_DIRECT_IO_ITER)
	static ssize_t
	zpl_direct_IO(struct kiocb kiocb, struct iov_iter iter)
	{
	return (zpl_direct_IO_impl(iov_iter_rw(iter), kiocb, iter));
	}
	#elif defined(HAVE_VFS_DIRECT_IO_ITER_OFFSET)
	static ssize_t
	zpl_direct_IO(struct kiocb kiocb, struct iov_iter iter, loff_t pos)
	{
	ASSERT3S(pos, ==, kiocb->ki_pos);
	return (zpl_direct_IO_impl(iov_iter_rw(iter), kiocb, iter));
	}
	#elif defined(HAVE_VFS_DIRECT_IO_ITER_RW_OFFSET)
	static ssize_t
	zpl_direct_IO(int rw, struct kiocb kiocb, struct iov_iter iter, loff_t pos)
	{
	ASSERT3S(pos, ==, kiocb->ki_pos);
	return (zpl_direct_IO_impl(rw, kiocb, iter));
	}
	#else
	#error "Unknown direct IO interface"
	#endif

	#else /* HAVE_VFS_RW_ITERATE */

	#if defined(HAVE_VFS_DIRECT_IO_IOVEC)
	static ssize_t
	zpl_direct_IO(int rw, struct kiocb kiocb, const struct iovec iov,
	loff_t pos, unsigned long nr_segs)
	{
	if (rw == WRITE)
	return (zpl_aio_write(kiocb, iov, nr_segs, pos));
	else
	return (zpl_aio_read(kiocb, iov, nr_segs, pos));
	}
	#elif defined(HAVE_VFS_DIRECT_IO_ITER_RW_OFFSET)
	static ssize_t
	zpl_direct_IO(int rw, struct kiocb kiocb, struct iov_iter iter, loff_t pos)
	{
	const struct iovec *iovp = iov_iter_iovec(iter);
	unsigned long nr_segs = iter->nr_segs;

	ASSERT3S(pos, ==, kiocb->ki_pos);
	if (rw == WRITE)
	return (zpl_aio_write(kiocb, iovp, nr_segs, pos));
	else
	return (zpl_aio_read(kiocb, iovp, nr_segs, pos));
	}
	#else
	#error "Unknown direct IO interface"
	#endif

	#endif /* HAVE_VFS_RW_ITERATE */

	static loff_t
	zpl_llseek(struct file *filp, loff_t offset, int whence)
	{
	#if defined(SEEK_HOLE) && defined(SEEK_DATA)
	fstrans_cookie_t cookie;

	if (whence == SEEK_DATA \|\| whence == SEEK_HOLE) {
	struct inode *ip = filp->f_mapping->host;
	loff_t maxbytes = ip->i_sb->s_maxbytes;
	loff_t error;

	spl_inode_lock_shared(ip);
	cookie = spl_fstrans_mark();
	error = -zfs_holey(ITOZ(ip), whence, &offset);
	spl_fstrans_unmark(cookie);
	if (error == 0)
	error = lseek_execute(filp, ip, offset, maxbytes);
	spl_inode_unlock_shared(ip);

	return (error);
	}
	#endif /* SEEK_HOLE && SEEK_DATA */

	return (generic_file_llseek(filp, offset, whence));
	}

	/*
	* It's worth taking a moment to describe how mmap is implemented
	* for zfs because it differs considerably from other Linux filesystems.
	* However, this issue is handled the same way under OpenSolaris.
	*
	* The issue is that by design zfs bypasses the Linux page cache and
	* leaves all caching up to the ARC. This has been shown to work
	* well for the common read(2)/write(2) case. However, mmap(2)
	* is problem because it relies on being tightly integrated with the
	* page cache. To handle this we cache mmap'ed files twice, once in
	* the ARC and a second time in the page cache. The code is careful
	* to keep both copies synchronized.
	*
	* When a file with an mmap'ed region is written to using write(2)
	* both the data in the ARC and existing pages in the page cache
	* are updated. For a read(2) data will be read first from the page
	* cache then the ARC if needed. Neither a write(2) or read(2) will
	* will ever result in new pages being added to the page cache.
	*
	* New pages are added to the page cache only via .readpage() which
	* is called when the vfs needs to read a page off disk to back the
	* virtual memory region. These pages may be modified without
	* notifying the ARC and will be written out periodically via
	* .writepage(). This will occur due to either a sync or the usual
	* page aging behavior. Note because a read(2) of a mmap'ed file
	* will always check the page cache first even when the ARC is out
	* of date correct data will still be returned.
	*
	* While this implementation ensures correct behavior it does have
	* have some drawbacks. The most obvious of which is that it
	* increases the required memory footprint when access mmap'ed
	* files. It also adds additional complexity to the code keeping
	* both caches synchronized.
	*
	* Longer term it may be possible to cleanly resolve this wart by
	* mapping page cache pages directly on to the ARC buffers. The
	* Linux address space operations are flexible enough to allow
	* selection of which pages back a particular index. The trick
	* would be working out the details of which subsystem is in
	* charge, the ARC, the page cache, or both. It may also prove
	* helpful to move the ARC buffers to a scatter-gather lists
	* rather than a vmalloc'ed region.
	*/
	static int
	zpl_mmap(struct file filp, struct vm_area_struct vma)
	{
	struct inode *ip = filp->f_mapping->host;
	znode_t *zp = ITOZ(ip);
	int error;
	fstrans_cookie_t cookie;

	cookie = spl_fstrans_mark();
	error = -zfs_map(ip, vma->vm_pgoff, (caddr_t *)vma->vm_start,
	(size_t)(vma->vm_end - vma->vm_start), vma->vm_flags);
	spl_fstrans_unmark(cookie);
	if (error)
	return (error);

	error = generic_file_mmap(filp, vma);
	if (error)
	return (error);

	mutex_enter(&zp->z_lock);
	zp->z_is_mapped = B_TRUE;
	mutex_exit(&zp->z_lock);

	return (error);
	}

	/*
	* Populate a page with data for the Linux page cache. This function is
	* only used to support mmap(2). There will be an identical copy of the
	* data in the ARC which is kept up to date via .write() and .writepage().
	*/
	static int
	zpl_readpage(struct file filp, struct page pp)
	{
	struct inode *ip;
	struct page *pl[1];
	int error = 0;
	fstrans_cookie_t cookie;

	ASSERT(PageLocked(pp));
	ip = pp->mapping->host;
	pl[0] = pp;

	cookie = spl_fstrans_mark();
	error = -zfs_getpage(ip, pl, 1);
	spl_fstrans_unmark(cookie);

	if (error) {
	SetPageError(pp);
	ClearPageUptodate(pp);
	} else {
	ClearPageError(pp);
	SetPageUptodate(pp);
	flush_dcache_page(pp);
	}

	unlock_page(pp);
	return (error);
	}

	/*
	* Populate a set of pages with data for the Linux page cache. This
	* function will only be called for read ahead and never for demand
	* paging. For simplicity, the code relies on read_cache_pages() to
	* correctly lock each page for IO and call zpl_readpage().
	*/
	static int
	zpl_readpages(struct file filp, struct address_space mapping,
	struct list_head *pages, unsigned nr_pages)
	{
	return (read_cache_pages(mapping, pages,
	(filler_t *)zpl_readpage, filp));
	}

	static int
	zpl_putpage(struct page pp, struct writeback_control wbc, void *data)
	{
	struct address_space *mapping = data;
	fstrans_cookie_t cookie;

	ASSERT(PageLocked(pp));
	ASSERT(!PageWriteback(pp));

	cookie = spl_fstrans_mark();
	(void) zfs_putpage(mapping->host, pp, wbc);
	spl_fstrans_unmark(cookie);

	return (0);
	}

	static int
	zpl_writepages(struct address_space mapping, struct writeback_control wbc)
	{
	znode_t *zp = ITOZ(mapping->host);
	zfsvfs_t *zfsvfs = ITOZSB(mapping->host);
	enum writeback_sync_modes sync_mode;
	int result;

	ZPL_ENTER(zfsvfs);
	if (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS)
	wbc->sync_mode = WB_SYNC_ALL;
	ZPL_EXIT(zfsvfs);
	sync_mode = wbc->sync_mode;

	/*
	* We don't want to run write_cache_pages() in SYNC mode here, because
	* that would make putpage() wait for a single page to be committed to
	* disk every single time, resulting in atrocious performance. Instead
	* we run it once in non-SYNC mode so that the ZIL gets all the data,
	* and then we commit it all in one go.
	*/
	wbc->sync_mode = WB_SYNC_NONE;
	result = write_cache_pages(mapping, wbc, zpl_putpage, mapping);
	if (sync_mode != wbc->sync_mode) {
	ZPL_ENTER(zfsvfs);
	ZPL_VERIFY_ZP(zp);
	if (zfsvfs->z_log != NULL)
	zil_commit(zfsvfs->z_log, zp->z_id);
	ZPL_EXIT(zfsvfs);

	/*
	* We need to call write_cache_pages() again (we can't just
	* return after the commit) because the previous call in
	* non-SYNC mode does not guarantee that we got all the dirty
	* pages (see the implementation of write_cache_pages() for
	* details). That being said, this is a no-op in most cases.
	*/
	wbc->sync_mode = sync_mode;
	result = write_cache_pages(mapping, wbc, zpl_putpage, mapping);
	}
	return (result);
	}

	/*
	* Write out dirty pages to the ARC, this function is only required to
	* support mmap(2). Mapped pages may be dirtied by memory operations
	* which never call .write(). These dirty pages are kept in sync with
	* the ARC buffers via this hook.
	*/
	static int
	zpl_writepage(struct page pp, struct writeback_control wbc)
	{
	if (ITOZSB(pp->mapping->host)->z_os->os_sync == ZFS_SYNC_ALWAYS)
	wbc->sync_mode = WB_SYNC_ALL;

	return (zpl_putpage(pp, wbc, pp->mapping));
	}

	/*
	* The flag combination which matches the behavior of zfs_space() is
	* FALLOC_FL_KEEP_SIZE \| FALLOC_FL_PUNCH_HOLE. The FALLOC_FL_PUNCH_HOLE
	* flag was introduced in the 2.6.38 kernel.
	*
	* The original mode=0 (allocate space) behavior can be reasonably emulated
	* by checking if enough space exists and creating a sparse file, as real
	* persistent space reservation is not possible due to COW, snapshots, etc.
	*/
	static long
	zpl_fallocate_common(struct inode *ip, int mode, loff_t offset, loff_t len)
	{
	cred_t *cr = CRED();
	loff_t olen;
	fstrans_cookie_t cookie;
	int error = 0;

	if ((mode & ~(FALLOC_FL_KEEP_SIZE \| FALLOC_FL_PUNCH_HOLE)) != 0)
	return (-EOPNOTSUPP);

	if (offset < 0 \|\| len <= 0)
	return (-EINVAL);

	spl_inode_lock(ip);
	olen = i_size_read(ip);

	crhold(cr);
	cookie = spl_fstrans_mark();
	if (mode & FALLOC_FL_PUNCH_HOLE) {
	flock64_t bf;

	if (offset > olen)
	goto out_unmark;

	if (offset + len > olen)
	len = olen - offset;
	bf.l_type = F_WRLCK;
	bf.l_whence = SEEK_SET;
	bf.l_start = offset;
	bf.l_len = len;
	bf.l_pid = 0;

	error = -zfs_space(ITOZ(ip), F_FREESP, &bf, O_RDWR, offset, cr);
	} else if ((mode & ~FALLOC_FL_KEEP_SIZE) == 0) {
	unsigned int percent = zfs_fallocate_reserve_percent;
	struct kstatfs statfs;

	/* Legacy mode, disable fallocate compatibility. */
	if (percent == 0) {
	error = -EOPNOTSUPP;
	goto out_unmark;
	}

	/*
	* Use zfs_statvfs() instead of dmu_objset_space() since it
	* also checks project quota limits, which are relevant here.
	*/
	error = zfs_statvfs(ip, &statfs);
	if (error)
	goto out_unmark;

	/*
	* Shrink available space a bit to account for overhead/races.
	* We know the product previously fit into availbytes from
	* dmu_objset_space(), so the smaller product will also fit.
	*/
	if (len > statfs.f_bavail * (statfs.f_bsize * 100 / percent)) {
	error = -ENOSPC;
	goto out_unmark;
	}
	if (!(mode & FALLOC_FL_KEEP_SIZE) && offset + len > olen)
	error = zfs_freesp(ITOZ(ip), offset + len, 0, 0, FALSE);
	}
	out_unmark:
	spl_fstrans_unmark(cookie);
	spl_inode_unlock(ip);

	crfree(cr);

	return (error);
	}

	static long
	zpl_fallocate(struct file *filp, int mode, loff_t offset, loff_t len)
	{
	return zpl_fallocate_common(file_inode(filp),
	mode, offset, len);
	}

	#define ZFS_FL_USER_VISIBLE (FS_FL_USER_VISIBLE \| ZFS_PROJINHERIT_FL)
	#define ZFS_FL_USER_MODIFIABLE (FS_FL_USER_MODIFIABLE \| ZFS_PROJINHERIT_FL)

	static uint32_t
	__zpl_ioctl_getflags(struct inode *ip)
	{
	uint64_t zfs_flags = ITOZ(ip)->z_pflags;
	uint32_t ioctl_flags = 0;

	if (zfs_flags & ZFS_IMMUTABLE)
	ioctl_flags \|= FS_IMMUTABLE_FL;

	if (zfs_flags & ZFS_APPENDONLY)
	ioctl_flags \|= FS_APPEND_FL;

	if (zfs_flags & ZFS_NODUMP)
	ioctl_flags \|= FS_NODUMP_FL;

	if (zfs_flags & ZFS_PROJINHERIT)
	ioctl_flags \|= ZFS_PROJINHERIT_FL;

	return (ioctl_flags & ZFS_FL_USER_VISIBLE);
	}

	/*
	* Map zfs file z_pflags (xvattr_t) to linux file attributes. Only file
	* attributes common to both Linux and Solaris are mapped.
	*/
	static int
	zpl_ioctl_getflags(struct file filp, void __user arg)
	{
	uint32_t flags;
	int err;

	flags = __zpl_ioctl_getflags(file_inode(filp));
	err = copy_to_user(arg, &flags, sizeof (flags));

	return (err);
	}

	/*
	* fchange() is a helper macro to detect if we have been asked to change a
	* flag. This is ugly, but the requirement that we do this is a consequence of
	* how the Linux file attribute interface was designed. Another consequence is
	* that concurrent modification of files suffers from a TOCTOU race. Neither
	* are things we can fix without modifying the kernel-userland interface, which
	* is outside of our jurisdiction.
	*/

	#define fchange(f0, f1, b0, b1) (!((f0) & (b0)) != !((f1) & (b1)))

	static int
	__zpl_ioctl_setflags(struct inode ip, uint32_t ioctl_flags, xvattr_t xva)
	{
	uint64_t zfs_flags = ITOZ(ip)->z_pflags;
	xoptattr_t *xoap;

	if (ioctl_flags & ~(FS_IMMUTABLE_FL \| FS_APPEND_FL \| FS_NODUMP_FL \|
	ZFS_PROJINHERIT_FL))
	return (-EOPNOTSUPP);

	if (ioctl_flags & ~ZFS_FL_USER_MODIFIABLE)
	return (-EACCES);

	if ((fchange(ioctl_flags, zfs_flags, FS_IMMUTABLE_FL, ZFS_IMMUTABLE) \|\|
	fchange(ioctl_flags, zfs_flags, FS_APPEND_FL, ZFS_APPENDONLY)) &&
	!capable(CAP_LINUX_IMMUTABLE))
	return (-EPERM);

	if (!zpl_inode_owner_or_capable(kcred->user_ns, ip))
	return (-EACCES);

	xva_init(xva);
	xoap = xva_getxoptattr(xva);

	XVA_SET_REQ(xva, XAT_IMMUTABLE);
	if (ioctl_flags & FS_IMMUTABLE_FL)
	xoap->xoa_immutable = B_TRUE;

	XVA_SET_REQ(xva, XAT_APPENDONLY);
	if (ioctl_flags & FS_APPEND_FL)
	xoap->xoa_appendonly = B_TRUE;

	XVA_SET_REQ(xva, XAT_NODUMP);
	if (ioctl_flags & FS_NODUMP_FL)
	xoap->xoa_nodump = B_TRUE;

	XVA_SET_REQ(xva, XAT_PROJINHERIT);
	if (ioctl_flags & ZFS_PROJINHERIT_FL)
	xoap->xoa_projinherit = B_TRUE;

	return (0);
	}

	static int
	zpl_ioctl_setflags(struct file filp, void __user arg)
	{
	struct inode *ip = file_inode(filp);
	uint32_t flags;
	cred_t *cr = CRED();
	xvattr_t xva;
	int err;
	fstrans_cookie_t cookie;

	if (copy_from_user(&flags, arg, sizeof (flags)))
	return (-EFAULT);

	err = __zpl_ioctl_setflags(ip, flags, &xva);
	if (err)
	return (err);

	crhold(cr);
	cookie = spl_fstrans_mark();
	err = -zfs_setattr(ITOZ(ip), (vattr_t *)&xva, 0, cr);
	spl_fstrans_unmark(cookie);
	crfree(cr);

	return (err);
	}

	static int
	zpl_ioctl_getxattr(struct file filp, void __user arg)
	{
	zfsxattr_t fsx = { 0 };
	struct inode *ip = file_inode(filp);
	int err;

	fsx.fsx_xflags = __zpl_ioctl_getflags(ip);
	fsx.fsx_projid = ITOZ(ip)->z_projid;
	err = copy_to_user(arg, &fsx, sizeof (fsx));

	return (err);
	}

	static int
	zpl_ioctl_setxattr(struct file filp, void __user arg)
	{
	struct inode *ip = file_inode(filp);
	zfsxattr_t fsx;
	cred_t *cr = CRED();
	xvattr_t xva;
	xoptattr_t *xoap;
	int err;
	fstrans_cookie_t cookie;

	if (copy_from_user(&fsx, arg, sizeof (fsx)))
	return (-EFAULT);

	if (!zpl_is_valid_projid(fsx.fsx_projid))
	return (-EINVAL);

	err = __zpl_ioctl_setflags(ip, fsx.fsx_xflags, &xva);
	if (err)
	return (err);

	xoap = xva_getxoptattr(&xva);
	XVA_SET_REQ(&xva, XAT_PROJID);
	xoap->xoa_projid = fsx.fsx_projid;

	crhold(cr);
	cookie = spl_fstrans_mark();
	err = -zfs_setattr(ITOZ(ip), (vattr_t *)&xva, 0, cr);
	spl_fstrans_unmark(cookie);
	crfree(cr);

	return (err);
	}

	static long
	zpl_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
	{
	switch (cmd) {
	case FS_IOC_GETFLAGS:
	return (zpl_ioctl_getflags(filp, (void *)arg));
	case FS_IOC_SETFLAGS:
	return (zpl_ioctl_setflags(filp, (void *)arg));
	case ZFS_IOC_FSGETXATTR:
	return (zpl_ioctl_getxattr(filp, (void *)arg));
	case ZFS_IOC_FSSETXATTR:
	return (zpl_ioctl_setxattr(filp, (void *)arg));
	default:
	return (-ENOTTY);
	}
	}

	#ifdef CONFIG_COMPAT
	static long
	zpl_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
	{
	switch (cmd) {
	case FS_IOC32_GETFLAGS:
	cmd = FS_IOC_GETFLAGS;
	break;
	case FS_IOC32_SETFLAGS:
	cmd = FS_IOC_SETFLAGS;
	break;
	default:
	return (-ENOTTY);
	}
	return (zpl_ioctl(filp, cmd, (unsigned long)compat_ptr(arg)));
	}
	#endif /* CONFIG_COMPAT */


	const struct address_space_operations zpl_address_space_operations = {
	.readpages = zpl_readpages,
	.readpage = zpl_readpage,
	.writepage = zpl_writepage,
	.writepages = zpl_writepages,
	.direct_IO = zpl_direct_IO,
	};

	const struct file_operations zpl_file_operations = {
	.open = zpl_open,
	.release = zpl_release,
	.llseek = zpl_llseek,
	#ifdef HAVE_VFS_RW_ITERATE
	#ifdef HAVE_NEW_SYNC_READ
	.read = new_sync_read,
	.write = new_sync_write,
	#endif
	.read_iter = zpl_iter_read,
	.write_iter = zpl_iter_write,
	#ifdef HAVE_VFS_IOV_ITER
	.splice_read = generic_file_splice_read,
	.splice_write = iter_file_splice_write,
	#endif
	#else
	.read = do_sync_read,
	.write = do_sync_write,
	.aio_read = zpl_aio_read,
	.aio_write = zpl_aio_write,
	#endif
	.mmap = zpl_mmap,
	.fsync = zpl_fsync,
	#ifdef HAVE_FILE_AIO_FSYNC
	.aio_fsync = zpl_aio_fsync,
	#endif
	.fallocate = zpl_fallocate,
	.unlocked_ioctl = zpl_ioctl,
	#ifdef CONFIG_COMPAT
	.compat_ioctl = zpl_compat_ioctl,
	#endif
	};

	const struct file_operations zpl_dir_file_operations = {
	.llseek = generic_file_llseek,
	.read = generic_read_dir,
	#if defined(HAVE_VFS_ITERATE_SHARED)
	.iterate_shared = zpl_iterate,
	#elif defined(HAVE_VFS_ITERATE)
	.iterate = zpl_iterate,
	#else
	.readdir = zpl_readdir,
	#endif
	.fsync = zpl_fsync,
	.unlocked_ioctl = zpl_ioctl,
	#ifdef CONFIG_COMPAT
	.compat_ioctl = zpl_compat_ioctl,
	#endif
	};

	/* BEGIN CSTYLED */
	module_param(zfs_fallocate_reserve_percent, uint, 0644);
	MODULE_PARM_DESC(zfs_fallocate_reserve_percent,
	"Percentage of length to use for the available capacity check");
	/* END CSTYLED */
	diff --git a/sys/contrib/openzfs/module/os/linux/zfs/zpl_inode.c b/sys/contrib/openzfs/module/os/linux/zfs/zpl_inode.c
	index cf0eab3e8c90..98c2fb3a0c92 100644
	--- a/sys/contrib/openzfs/module/os/linux/zfs/zpl_inode.c
	+++ b/sys/contrib/openzfs/module/os/linux/zfs/zpl_inode.c
	@@ -1,787 +1,804 @@
	/*
	* 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) 2011, Lawrence Livermore National Security, LLC.
	* Copyright (c) 2015 by Chunwei Chen. All rights reserved.
	*/


	#include <sys/zfs_ctldir.h>
	#include <sys/zfs_vfsops.h>
	#include <sys/zfs_vnops.h>
	#include <sys/zfs_znode.h>
	#include <sys/dmu_objset.h>
	#include <sys/vfs.h>
	#include <sys/zpl.h>
	#include <sys/file.h>


	static struct dentry *
	zpl_lookup(struct inode dir, struct dentry dentry, unsigned int flags)
	{
	cred_t *cr = CRED();
	struct inode *ip;
	znode_t *zp;
	int error;
	fstrans_cookie_t cookie;
	pathname_t *ppn = NULL;
	pathname_t pn;
	int zfs_flags = 0;
	zfsvfs_t *zfsvfs = dentry->d_sb->s_fs_info;

	if (dlen(dentry) >= ZAP_MAXNAMELEN)
	return (ERR_PTR(-ENAMETOOLONG));

	crhold(cr);
	cookie = spl_fstrans_mark();

	/* If we are a case insensitive fs, we need the real name */
	if (zfsvfs->z_case == ZFS_CASE_INSENSITIVE) {
	zfs_flags = FIGNORECASE;
	pn_alloc(&pn);
	ppn = &pn;
	}

	error = -zfs_lookup(ITOZ(dir), dname(dentry), &zp,
	zfs_flags, cr, NULL, ppn);
	spl_fstrans_unmark(cookie);
	ASSERT3S(error, <=, 0);
	crfree(cr);

	spin_lock(&dentry->d_lock);
	dentry->d_time = jiffies;
	spin_unlock(&dentry->d_lock);

	if (error) {
	/*
	* If we have a case sensitive fs, we do not want to
	* insert negative entries, so return NULL for ENOENT.
	* Fall through if the error is not ENOENT. Also free memory.
	*/
	if (ppn) {
	pn_free(ppn);
	if (error == -ENOENT)
	return (NULL);
	}

	if (error == -ENOENT)
	return (d_splice_alias(NULL, dentry));
	else
	return (ERR_PTR(error));
	}
	ip = ZTOI(zp);

	/*
	* If we are case insensitive, call the correct function
	* to install the name.
	*/
	if (ppn) {
	struct dentry *new_dentry;
	struct qstr ci_name;

	if (strcmp(dname(dentry), pn.pn_buf) == 0) {
	new_dentry = d_splice_alias(ip, dentry);
	} else {
	ci_name.name = pn.pn_buf;
	ci_name.len = strlen(pn.pn_buf);
	new_dentry = d_add_ci(dentry, ip, &ci_name);
	}
	pn_free(ppn);
	return (new_dentry);
	} else {
	return (d_splice_alias(ip, dentry));
	}
	}

	void
	zpl_vap_init(vattr_t vap, struct inode dir, umode_t mode, cred_t *cr)
	{
	vap->va_mask = ATTR_MODE;
	vap->va_mode = mode;
	vap->va_uid = crgetfsuid(cr);

	if (dir && dir->i_mode & S_ISGID) {
	vap->va_gid = KGID_TO_SGID(dir->i_gid);
	if (S_ISDIR(mode))
	vap->va_mode \|= S_ISGID;
	} else {
	vap->va_gid = crgetfsgid(cr);
	}
	}

	static int
	#ifdef HAVE_IOPS_CREATE_USERNS
	zpl_create(struct user_namespace user_ns, struct inode dir,
	struct dentry *dentry, umode_t mode, bool flag)
	#else
	zpl_create(struct inode dir, struct dentry dentry, umode_t mode, bool flag)
	#endif
	{
	cred_t *cr = CRED();
	znode_t *zp;
	vattr_t *vap;
	int error;
	fstrans_cookie_t cookie;

	crhold(cr);
	vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
	zpl_vap_init(vap, dir, mode, cr);

	cookie = spl_fstrans_mark();
	error = -zfs_create(ITOZ(dir), dname(dentry), vap, 0,
	mode, &zp, cr, 0, NULL);
	if (error == 0) {
	- d_instantiate(dentry, ZTOI(zp));
	-
	error = zpl_xattr_security_init(ZTOI(zp), dir, &dentry->d_name);
	if (error == 0)
	error = zpl_init_acl(ZTOI(zp), dir);

	- if (error)
	+ if (error) {
	(void) zfs_remove(ITOZ(dir), dname(dentry), cr, 0);
	+ remove_inode_hash(ZTOI(zp));
	+ iput(ZTOI(zp));
	+ } else {
	+ d_instantiate(dentry, ZTOI(zp));
	+ }
	}

	spl_fstrans_unmark(cookie);
	kmem_free(vap, sizeof (vattr_t));
	crfree(cr);
	ASSERT3S(error, <=, 0);

	return (error);
	}

	static int
	#ifdef HAVE_IOPS_MKNOD_USERNS
	zpl_mknod(struct user_namespace user_ns, struct inode dir,
	struct dentry *dentry, umode_t mode,
	#else
	zpl_mknod(struct inode dir, struct dentry dentry, umode_t mode,
	#endif
	dev_t rdev)
	{
	cred_t *cr = CRED();
	znode_t *zp;
	vattr_t *vap;
	int error;
	fstrans_cookie_t cookie;

	/*
	* We currently expect Linux to supply rdev=0 for all sockets
	* and fifos, but we want to know if this behavior ever changes.
	*/
	if (S_ISSOCK(mode) \|\| S_ISFIFO(mode))
	ASSERT(rdev == 0);

	crhold(cr);
	vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
	zpl_vap_init(vap, dir, mode, cr);
	vap->va_rdev = rdev;

	cookie = spl_fstrans_mark();
	error = -zfs_create(ITOZ(dir), dname(dentry), vap, 0,
	mode, &zp, cr, 0, NULL);
	if (error == 0) {
	- d_instantiate(dentry, ZTOI(zp));
	-
	error = zpl_xattr_security_init(ZTOI(zp), dir, &dentry->d_name);
	if (error == 0)
	error = zpl_init_acl(ZTOI(zp), dir);

	- if (error)
	+ if (error) {
	(void) zfs_remove(ITOZ(dir), dname(dentry), cr, 0);
	+ remove_inode_hash(ZTOI(zp));
	+ iput(ZTOI(zp));
	+ } else {
	+ d_instantiate(dentry, ZTOI(zp));
	+ }
	}

	spl_fstrans_unmark(cookie);
	kmem_free(vap, sizeof (vattr_t));
	crfree(cr);
	ASSERT3S(error, <=, 0);

	return (error);
	}

	#ifdef HAVE_TMPFILE
	static int
	+#ifdef HAVE_TMPFILE_USERNS
	+zpl_tmpfile(struct user_namespace userns, struct inode dir,
	+ struct dentry *dentry, umode_t mode)
	+#else
	zpl_tmpfile(struct inode dir, struct dentry dentry, umode_t mode)
	+#endif
	{
	cred_t *cr = CRED();
	struct inode *ip;
	vattr_t *vap;
	int error;
	fstrans_cookie_t cookie;

	crhold(cr);
	vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
	/*
	* The VFS does not apply the umask, therefore it is applied here
	* when POSIX ACLs are not enabled.
	*/
	if (!IS_POSIXACL(dir))
	mode &= ~current_umask();
	zpl_vap_init(vap, dir, mode, cr);

	cookie = spl_fstrans_mark();
	error = -zfs_tmpfile(dir, vap, 0, mode, &ip, cr, 0, NULL);
	if (error == 0) {
	/* d_tmpfile will do drop_nlink, so we should set it first */
	set_nlink(ip, 1);
	d_tmpfile(dentry, ip);

	error = zpl_xattr_security_init(ip, dir, &dentry->d_name);
	if (error == 0)
	error = zpl_init_acl(ip, dir);
	/*
	* don't need to handle error here, file is already in
	* unlinked set.
	*/
	}

	spl_fstrans_unmark(cookie);
	kmem_free(vap, sizeof (vattr_t));
	crfree(cr);
	ASSERT3S(error, <=, 0);

	return (error);
	}
	#endif

	static int
	zpl_unlink(struct inode dir, struct dentry dentry)
	{
	cred_t *cr = CRED();
	int error;
	fstrans_cookie_t cookie;
	zfsvfs_t *zfsvfs = dentry->d_sb->s_fs_info;

	crhold(cr);
	cookie = spl_fstrans_mark();
	error = -zfs_remove(ITOZ(dir), dname(dentry), cr, 0);

	/*
	* For a CI FS we must invalidate the dentry to prevent the
	* creation of negative entries.
	*/
	if (error == 0 && zfsvfs->z_case == ZFS_CASE_INSENSITIVE)
	d_invalidate(dentry);

	spl_fstrans_unmark(cookie);
	crfree(cr);
	ASSERT3S(error, <=, 0);

	return (error);
	}

	static int
	#ifdef HAVE_IOPS_MKDIR_USERNS
	zpl_mkdir(struct user_namespace user_ns, struct inode dir,
	struct dentry *dentry, umode_t mode)
	#else
	zpl_mkdir(struct inode dir, struct dentry dentry, umode_t mode)
	#endif
	{
	cred_t *cr = CRED();
	vattr_t *vap;
	znode_t *zp;
	int error;
	fstrans_cookie_t cookie;

	crhold(cr);
	vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
	zpl_vap_init(vap, dir, mode \| S_IFDIR, cr);

	cookie = spl_fstrans_mark();
	error = -zfs_mkdir(ITOZ(dir), dname(dentry), vap, &zp, cr, 0, NULL);
	if (error == 0) {
	- d_instantiate(dentry, ZTOI(zp));
	-
	error = zpl_xattr_security_init(ZTOI(zp), dir, &dentry->d_name);
	if (error == 0)
	error = zpl_init_acl(ZTOI(zp), dir);

	- if (error)
	+ if (error) {
	(void) zfs_rmdir(ITOZ(dir), dname(dentry), NULL, cr, 0);
	+ remove_inode_hash(ZTOI(zp));
	+ iput(ZTOI(zp));
	+ } else {
	+ d_instantiate(dentry, ZTOI(zp));
	+ }
	}

	spl_fstrans_unmark(cookie);
	kmem_free(vap, sizeof (vattr_t));
	crfree(cr);
	ASSERT3S(error, <=, 0);

	return (error);
	}

	static int
	zpl_rmdir(struct inode dir, struct dentry dentry)
	{
	cred_t *cr = CRED();
	int error;
	fstrans_cookie_t cookie;
	zfsvfs_t *zfsvfs = dentry->d_sb->s_fs_info;

	crhold(cr);
	cookie = spl_fstrans_mark();
	error = -zfs_rmdir(ITOZ(dir), dname(dentry), NULL, cr, 0);

	/*
	* For a CI FS we must invalidate the dentry to prevent the
	* creation of negative entries.
	*/
	if (error == 0 && zfsvfs->z_case == ZFS_CASE_INSENSITIVE)
	d_invalidate(dentry);

	spl_fstrans_unmark(cookie);
	crfree(cr);
	ASSERT3S(error, <=, 0);

	return (error);
	}

	static int
	#ifdef HAVE_USERNS_IOPS_GETATTR
	zpl_getattr_impl(struct user_namespace *user_ns,
	const struct path path, struct kstat stat, u32 request_mask,
	unsigned int query_flags)
	#else
	zpl_getattr_impl(const struct path path, struct kstat stat, u32 request_mask,
	unsigned int query_flags)
	#endif
	{
	int error;
	fstrans_cookie_t cookie;

	cookie = spl_fstrans_mark();

	/*
	* XXX request_mask and query_flags currently ignored.
	*/

	#ifdef HAVE_USERNS_IOPS_GETATTR
	error = -zfs_getattr_fast(user_ns, path->dentry->d_inode, stat);
	#else
	error = -zfs_getattr_fast(kcred->user_ns, path->dentry->d_inode, stat);
	#endif
	spl_fstrans_unmark(cookie);
	ASSERT3S(error, <=, 0);

	return (error);
	}
	ZPL_GETATTR_WRAPPER(zpl_getattr);

	static int
	#ifdef HAVE_SETATTR_PREPARE_USERNS
	zpl_setattr(struct user_namespace user_ns, struct dentry dentry,
	struct iattr *ia)
	#else
	zpl_setattr(struct dentry dentry, struct iattr ia)
	#endif
	{
	struct inode *ip = dentry->d_inode;
	cred_t *cr = CRED();
	vattr_t *vap;
	int error;
	fstrans_cookie_t cookie;

	error = zpl_setattr_prepare(kcred->user_ns, dentry, ia);
	if (error)
	return (error);

	crhold(cr);
	vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
	vap->va_mask = ia->ia_valid & ATTR_IATTR_MASK;
	vap->va_mode = ia->ia_mode;
	vap->va_uid = KUID_TO_SUID(ia->ia_uid);
	vap->va_gid = KGID_TO_SGID(ia->ia_gid);
	vap->va_size = ia->ia_size;
	vap->va_atime = ia->ia_atime;
	vap->va_mtime = ia->ia_mtime;
	vap->va_ctime = ia->ia_ctime;

	if (vap->va_mask & ATTR_ATIME)
	ip->i_atime = zpl_inode_timestamp_truncate(ia->ia_atime, ip);

	cookie = spl_fstrans_mark();
	error = -zfs_setattr(ITOZ(ip), vap, 0, cr);
	if (!error && (ia->ia_valid & ATTR_MODE))
	error = zpl_chmod_acl(ip);

	spl_fstrans_unmark(cookie);
	kmem_free(vap, sizeof (vattr_t));
	crfree(cr);
	ASSERT3S(error, <=, 0);

	return (error);
	}

	static int
	#ifdef HAVE_IOPS_RENAME_USERNS
	zpl_rename2(struct user_namespace user_ns, struct inode sdip,
	struct dentry sdentry, struct inode tdip, struct dentry *tdentry,
	unsigned int flags)
	#else
	zpl_rename2(struct inode sdip, struct dentry sdentry,
	struct inode tdip, struct dentry tdentry, unsigned int flags)
	#endif
	{
	cred_t *cr = CRED();
	int error;
	fstrans_cookie_t cookie;

	/* We don't have renameat2(2) support */
	if (flags)
	return (-EINVAL);

	crhold(cr);
	cookie = spl_fstrans_mark();
	error = -zfs_rename(ITOZ(sdip), dname(sdentry), ITOZ(tdip),
	dname(tdentry), cr, 0);
	spl_fstrans_unmark(cookie);
	crfree(cr);
	ASSERT3S(error, <=, 0);

	return (error);
	}

	#if !defined(HAVE_RENAME_WANTS_FLAGS) && !defined(HAVE_IOPS_RENAME_USERNS)
	static int
	zpl_rename(struct inode sdip, struct dentry sdentry,
	struct inode tdip, struct dentry tdentry)
	{
	return (zpl_rename2(sdip, sdentry, tdip, tdentry, 0));
	}
	#endif

	static int
	#ifdef HAVE_IOPS_SYMLINK_USERNS
	zpl_symlink(struct user_namespace user_ns, struct inode dir,
	struct dentry dentry, const char name)
	#else
	zpl_symlink(struct inode dir, struct dentry dentry, const char *name)
	#endif
	{
	cred_t *cr = CRED();
	vattr_t *vap;
	znode_t *zp;
	int error;
	fstrans_cookie_t cookie;

	crhold(cr);
	vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
	zpl_vap_init(vap, dir, S_IFLNK \| S_IRWXUGO, cr);

	cookie = spl_fstrans_mark();
	error = -zfs_symlink(ITOZ(dir), dname(dentry), vap,
	(char *)name, &zp, cr, 0);
	if (error == 0) {
	- d_instantiate(dentry, ZTOI(zp));
	-
	error = zpl_xattr_security_init(ZTOI(zp), dir, &dentry->d_name);
	- if (error)
	+ if (error) {
	(void) zfs_remove(ITOZ(dir), dname(dentry), cr, 0);
	+ remove_inode_hash(ZTOI(zp));
	+ iput(ZTOI(zp));
	+ } else {
	+ d_instantiate(dentry, ZTOI(zp));
	+ }
	}

	spl_fstrans_unmark(cookie);
	kmem_free(vap, sizeof (vattr_t));
	crfree(cr);
	ASSERT3S(error, <=, 0);

	return (error);
	}

	#if defined(HAVE_PUT_LINK_COOKIE)
	static void
	zpl_put_link(struct inode unused, void cookie)
	{
	kmem_free(cookie, MAXPATHLEN);
	}
	#elif defined(HAVE_PUT_LINK_NAMEIDATA)
	static void
	zpl_put_link(struct dentry dentry, struct nameidata nd, void *ptr)
	{
	const char *link = nd_get_link(nd);

	if (!IS_ERR(link))
	kmem_free(link, MAXPATHLEN);
	}
	#elif defined(HAVE_PUT_LINK_DELAYED)
	static void
	zpl_put_link(void *ptr)
	{
	kmem_free(ptr, MAXPATHLEN);
	}
	#endif

	static int
	zpl_get_link_common(struct dentry dentry, struct inode ip, char **link)
	{
	fstrans_cookie_t cookie;
	cred_t *cr = CRED();
	int error;

	crhold(cr);
	*link = NULL;

	struct iovec iov;
	iov.iov_len = MAXPATHLEN;
	iov.iov_base = kmem_zalloc(MAXPATHLEN, KM_SLEEP);

	zfs_uio_t uio;
	zfs_uio_iovec_init(&uio, &iov, 1, 0, UIO_SYSSPACE, MAXPATHLEN - 1, 0);

	cookie = spl_fstrans_mark();
	error = -zfs_readlink(ip, &uio, cr);
	spl_fstrans_unmark(cookie);
	crfree(cr);

	if (error)
	kmem_free(iov.iov_base, MAXPATHLEN);
	else
	*link = iov.iov_base;

	return (error);
	}

	#if defined(HAVE_GET_LINK_DELAYED)
	static const char *
	zpl_get_link(struct dentry dentry, struct inode inode,
	struct delayed_call *done)
	{
	char *link = NULL;
	int error;

	if (!dentry)
	return (ERR_PTR(-ECHILD));

	error = zpl_get_link_common(dentry, inode, &link);
	if (error)
	return (ERR_PTR(error));

	set_delayed_call(done, zpl_put_link, link);

	return (link);
	}
	#elif defined(HAVE_GET_LINK_COOKIE)
	static const char *
	zpl_get_link(struct dentry dentry, struct inode inode, void **cookie)
	{
	char *link = NULL;
	int error;

	if (!dentry)
	return (ERR_PTR(-ECHILD));

	error = zpl_get_link_common(dentry, inode, &link);
	if (error)
	return (ERR_PTR(error));

	return (*cookie = link);
	}
	#elif defined(HAVE_FOLLOW_LINK_COOKIE)
	static const char *
	zpl_follow_link(struct dentry dentry, void *cookie)
	{
	char *link = NULL;
	int error;

	error = zpl_get_link_common(dentry, dentry->d_inode, &link);
	if (error)
	return (ERR_PTR(error));

	return (*cookie = link);
	}
	#elif defined(HAVE_FOLLOW_LINK_NAMEIDATA)
	static void *
	zpl_follow_link(struct dentry dentry, struct nameidata nd)
	{
	char *link = NULL;
	int error;

	error = zpl_get_link_common(dentry, dentry->d_inode, &link);
	if (error)
	nd_set_link(nd, ERR_PTR(error));
	else
	nd_set_link(nd, link);

	return (NULL);
	}
	#endif

	static int
	zpl_link(struct dentry old_dentry, struct inode dir, struct dentry *dentry)
	{
	cred_t *cr = CRED();
	struct inode *ip = old_dentry->d_inode;
	int error;
	fstrans_cookie_t cookie;

	if (ip->i_nlink >= ZFS_LINK_MAX)
	return (-EMLINK);

	crhold(cr);
	ip->i_ctime = current_time(ip);
	/* Must have an existing ref, so igrab() cannot return NULL */
	VERIFY3P(igrab(ip), !=, NULL);

	cookie = spl_fstrans_mark();
	error = -zfs_link(ITOZ(dir), ITOZ(ip), dname(dentry), cr, 0);
	if (error) {
	iput(ip);
	goto out;
	}

	d_instantiate(dentry, ip);
	out:
	spl_fstrans_unmark(cookie);
	crfree(cr);
	ASSERT3S(error, <=, 0);

	return (error);
	}

	static int
	#ifdef HAVE_D_REVALIDATE_NAMEIDATA
	zpl_revalidate(struct dentry dentry, struct nameidata nd)
	{
	unsigned int flags = (nd ? nd->flags : 0);
	#else
	zpl_revalidate(struct dentry *dentry, unsigned int flags)
	{
	#endif /* HAVE_D_REVALIDATE_NAMEIDATA */
	/* CSTYLED */
	zfsvfs_t *zfsvfs = dentry->d_sb->s_fs_info;
	int error;

	if (flags & LOOKUP_RCU)
	return (-ECHILD);

	/*
	* After a rollback negative dentries created before the rollback
	* time must be invalidated. Otherwise they can obscure files which
	* are only present in the rolled back dataset.
	*/
	if (dentry->d_inode == NULL) {
	spin_lock(&dentry->d_lock);
	error = time_before(dentry->d_time, zfsvfs->z_rollback_time);
	spin_unlock(&dentry->d_lock);

	if (error)
	return (0);
	}

	/*
	* The dentry may reference a stale inode if a mounted file system
	* was rolled back to a point in time where the object didn't exist.
	*/
	if (dentry->d_inode && ITOZ(dentry->d_inode)->z_is_stale)
	return (0);

	return (1);
	}

	const struct inode_operations zpl_inode_operations = {
	.setattr = zpl_setattr,
	.getattr = zpl_getattr,
	#ifdef HAVE_GENERIC_SETXATTR
	.setxattr = generic_setxattr,
	.getxattr = generic_getxattr,
	.removexattr = generic_removexattr,
	#endif
	.listxattr = zpl_xattr_list,
	#if defined(CONFIG_FS_POSIX_ACL)
	#if defined(HAVE_SET_ACL)
	.set_acl = zpl_set_acl,
	#endif /* HAVE_SET_ACL */
	.get_acl = zpl_get_acl,
	#endif /* CONFIG_FS_POSIX_ACL */
	};

	const struct inode_operations zpl_dir_inode_operations = {
	.create = zpl_create,
	.lookup = zpl_lookup,
	.link = zpl_link,
	.unlink = zpl_unlink,
	.symlink = zpl_symlink,
	.mkdir = zpl_mkdir,
	.rmdir = zpl_rmdir,
	.mknod = zpl_mknod,
	#if defined(HAVE_RENAME_WANTS_FLAGS) \|\| defined(HAVE_IOPS_RENAME_USERNS)
	.rename = zpl_rename2,
	#else
	.rename = zpl_rename,
	#endif
	#ifdef HAVE_TMPFILE
	.tmpfile = zpl_tmpfile,
	#endif
	.setattr = zpl_setattr,
	.getattr = zpl_getattr,
	#ifdef HAVE_GENERIC_SETXATTR
	.setxattr = generic_setxattr,
	.getxattr = generic_getxattr,
	.removexattr = generic_removexattr,
	#endif
	.listxattr = zpl_xattr_list,
	#if defined(CONFIG_FS_POSIX_ACL)
	#if defined(HAVE_SET_ACL)
	.set_acl = zpl_set_acl,
	#endif /* HAVE_SET_ACL */
	.get_acl = zpl_get_acl,
	#endif /* CONFIG_FS_POSIX_ACL */
	};

	const struct inode_operations zpl_symlink_inode_operations = {
	#ifdef HAVE_GENERIC_READLINK
	.readlink = generic_readlink,
	#endif
	#if defined(HAVE_GET_LINK_DELAYED) \|\| defined(HAVE_GET_LINK_COOKIE)
	.get_link = zpl_get_link,
	#elif defined(HAVE_FOLLOW_LINK_COOKIE) \|\| defined(HAVE_FOLLOW_LINK_NAMEIDATA)
	.follow_link = zpl_follow_link,
	#endif
	#if defined(HAVE_PUT_LINK_COOKIE) \|\| defined(HAVE_PUT_LINK_NAMEIDATA)
	.put_link = zpl_put_link,
	#endif
	.setattr = zpl_setattr,
	.getattr = zpl_getattr,
	#ifdef HAVE_GENERIC_SETXATTR
	.setxattr = generic_setxattr,
	.getxattr = generic_getxattr,
	.removexattr = generic_removexattr,
	#endif
	.listxattr = zpl_xattr_list,
	};

	const struct inode_operations zpl_special_inode_operations = {
	.setattr = zpl_setattr,
	.getattr = zpl_getattr,
	#ifdef HAVE_GENERIC_SETXATTR
	.setxattr = generic_setxattr,
	.getxattr = generic_getxattr,
	.removexattr = generic_removexattr,
	#endif
	.listxattr = zpl_xattr_list,
	#if defined(CONFIG_FS_POSIX_ACL)
	#if defined(HAVE_SET_ACL)
	.set_acl = zpl_set_acl,
	#endif /* HAVE_SET_ACL */
	.get_acl = zpl_get_acl,
	#endif /* CONFIG_FS_POSIX_ACL */
	};

	dentry_operations_t zpl_dentry_operations = {
	.d_revalidate = zpl_revalidate,
	};
	diff --git a/sys/contrib/openzfs/module/os/linux/zfs/zpl_xattr.c b/sys/contrib/openzfs/module/os/linux/zfs/zpl_xattr.c
	index 971cd6ad031e..c6d4da582be0 100644
	--- a/sys/contrib/openzfs/module/os/linux/zfs/zpl_xattr.c
	+++ b/sys/contrib/openzfs/module/os/linux/zfs/zpl_xattr.c
	@@ -1,1486 +1,1497 @@
	/*
	* 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) 2011, Lawrence Livermore National Security, LLC.
	*
	* Extended attributes (xattr) on Solaris are implemented as files
	* which exist in a hidden xattr directory. These extended attributes
	* can be accessed using the attropen() system call which opens
	* the extended attribute. It can then be manipulated just like
	* a standard file descriptor. This has a couple advantages such
	* as practically no size limit on the file, and the extended
	* attributes permissions may differ from those of the parent file.
	* This interface is really quite clever, but it's also completely
	* different than what is supported on Linux. It also comes with a
	* steep performance penalty when accessing small xattrs because they
	* are not stored with the parent file.
	*
	* Under Linux extended attributes are manipulated by the system
	* calls getxattr(2), setxattr(2), and listxattr(2). They consider
	* extended attributes to be name/value pairs where the name is a
	* NULL terminated string. The name must also include one of the
	* following namespace prefixes:
	*
	* user - No restrictions and is available to user applications.
	* trusted - Restricted to kernel and root (CAP_SYS_ADMIN) use.
	* system - Used for access control lists (system.nfs4_acl, etc).
	* security - Used by SELinux to store a files security context.
	*
	* The value under Linux to limited to 65536 bytes of binary data.
	* In practice, individual xattrs tend to be much smaller than this
	* and are typically less than 100 bytes. A good example of this
	* are the security.selinux xattrs which are less than 100 bytes and
	* exist for every file when xattr labeling is enabled.
	*
	* The Linux xattr implementation has been written to take advantage of
	* this typical usage. When the dataset property 'xattr=sa' is set,
	* then xattrs will be preferentially stored as System Attributes (SA).
	* This allows tiny xattrs (~100 bytes) to be stored with the dnode and
	* up to 64k of xattrs to be stored in the spill block. If additional
	* xattr space is required, which is unlikely under Linux, they will
	* be stored using the traditional directory approach.
	*
	* This optimization results in roughly a 3x performance improvement
	* when accessing xattrs because it avoids the need to perform a seek
	* for every xattr value. When multiple xattrs are stored per-file
	* the performance improvements are even greater because all of the
	* xattrs stored in the spill block will be cached.
	*
	* However, by default SA based xattrs are disabled in the Linux port
	* to maximize compatibility with other implementations. If you do
	* enable SA based xattrs then they will not be visible on platforms
	* which do not support this feature.
	*
	* NOTE: One additional consequence of the xattr directory implementation
	* is that when an extended attribute is manipulated an inode is created.
	* This inode will exist in the Linux inode cache but there will be no
	* associated entry in the dentry cache which references it. This is
	* safe but it may result in some confusion. Enabling SA based xattrs
	* largely avoids the issue except in the overflow case.
	*/

	#include <sys/zfs_znode.h>
	#include <sys/zfs_vfsops.h>
	#include <sys/zfs_vnops.h>
	#include <sys/zap.h>
	#include <sys/vfs.h>
	#include <sys/zpl.h>

	typedef struct xattr_filldir {
	size_t size;
	size_t offset;
	char *buf;
	struct dentry *dentry;
	} xattr_filldir_t;

	static const struct xattr_handler zpl_xattr_handler(const char );

	static int
	zpl_xattr_permission(xattr_filldir_t xf, const char name, int name_len)
	{
	static const struct xattr_handler *handler;
	struct dentry *d = xf->dentry;

	handler = zpl_xattr_handler(name);
	if (!handler)
	return (0);

	if (handler->list) {
	#if defined(HAVE_XATTR_LIST_SIMPLE)
	if (!handler->list(d))
	return (0);
	#elif defined(HAVE_XATTR_LIST_DENTRY)
	if (!handler->list(d, NULL, 0, name, name_len, 0))
	return (0);
	#elif defined(HAVE_XATTR_LIST_HANDLER)
	if (!handler->list(handler, d, NULL, 0, name, name_len))
	return (0);
	#endif
	}

	return (1);
	}

	/*
	* Determine is a given xattr name should be visible and if so copy it
	* in to the provided buffer (xf->buf).
	*/
	static int
	zpl_xattr_filldir(xattr_filldir_t xf, const char name, int name_len)
	{
	/* Check permissions using the per-namespace list xattr handler. */
	if (!zpl_xattr_permission(xf, name, name_len))
	return (0);

	/* When xf->buf is NULL only calculate the required size. */
	if (xf->buf) {
	if (xf->offset + name_len + 1 > xf->size)
	return (-ERANGE);

	memcpy(xf->buf + xf->offset, name, name_len);
	xf->buf[xf->offset + name_len] = '\0';
	}

	xf->offset += (name_len + 1);

	return (0);
	}

	/*
	* Read as many directory entry names as will fit in to the provided buffer,
	* or when no buffer is provided calculate the required buffer size.
	*/
	static int
	zpl_xattr_readdir(struct inode dxip, xattr_filldir_t xf)
	{
	zap_cursor_t zc;
	zap_attribute_t zap;
	int error;

	zap_cursor_init(&zc, ITOZSB(dxip)->z_os, ITOZ(dxip)->z_id);

	while ((error = -zap_cursor_retrieve(&zc, &zap)) == 0) {

	if (zap.za_integer_length != 8 \|\| zap.za_num_integers != 1) {
	error = -ENXIO;
	break;
	}

	error = zpl_xattr_filldir(xf, zap.za_name, strlen(zap.za_name));
	if (error)
	break;

	zap_cursor_advance(&zc);
	}

	zap_cursor_fini(&zc);

	if (error == -ENOENT)
	error = 0;

	return (error);
	}

	static ssize_t
	zpl_xattr_list_dir(xattr_filldir_t xf, cred_t cr)
	{
	struct inode *ip = xf->dentry->d_inode;
	struct inode *dxip = NULL;
	znode_t *dxzp;
	int error;

	/* Lookup the xattr directory */
	error = -zfs_lookup(ITOZ(ip), NULL, &dxzp, LOOKUP_XATTR,
	cr, NULL, NULL);
	if (error) {
	if (error == -ENOENT)
	error = 0;

	return (error);
	}

	dxip = ZTOI(dxzp);
	error = zpl_xattr_readdir(dxip, xf);
	iput(dxip);

	return (error);
	}

	static ssize_t
	zpl_xattr_list_sa(xattr_filldir_t *xf)
	{
	znode_t *zp = ITOZ(xf->dentry->d_inode);
	nvpair_t *nvp = NULL;
	int error = 0;

	mutex_enter(&zp->z_lock);
	if (zp->z_xattr_cached == NULL)
	error = -zfs_sa_get_xattr(zp);
	mutex_exit(&zp->z_lock);

	if (error)
	return (error);

	ASSERT(zp->z_xattr_cached);

	while ((nvp = nvlist_next_nvpair(zp->z_xattr_cached, nvp)) != NULL) {
	ASSERT3U(nvpair_type(nvp), ==, DATA_TYPE_BYTE_ARRAY);

	error = zpl_xattr_filldir(xf, nvpair_name(nvp),
	strlen(nvpair_name(nvp)));
	if (error)
	return (error);
	}

	return (0);
	}

	ssize_t
	zpl_xattr_list(struct dentry dentry, char buffer, size_t buffer_size)
	{
	znode_t *zp = ITOZ(dentry->d_inode);
	zfsvfs_t *zfsvfs = ZTOZSB(zp);
	xattr_filldir_t xf = { buffer_size, 0, buffer, dentry };
	cred_t *cr = CRED();
	fstrans_cookie_t cookie;
	int error = 0;

	crhold(cr);
	cookie = spl_fstrans_mark();
	ZPL_ENTER(zfsvfs);
	ZPL_VERIFY_ZP(zp);
	rw_enter(&zp->z_xattr_lock, RW_READER);

	if (zfsvfs->z_use_sa && zp->z_is_sa) {
	error = zpl_xattr_list_sa(&xf);
	if (error)
	goto out;
	}

	error = zpl_xattr_list_dir(&xf, cr);
	if (error)
	goto out;

	error = xf.offset;
	out:

	rw_exit(&zp->z_xattr_lock);
	ZPL_EXIT(zfsvfs);
	spl_fstrans_unmark(cookie);
	crfree(cr);

	return (error);
	}

	static int
	zpl_xattr_get_dir(struct inode ip, const char name, void *value,
	size_t size, cred_t *cr)
	{
	fstrans_cookie_t cookie;
	struct inode *xip = NULL;
	znode_t *dxzp = NULL;
	znode_t *xzp = NULL;
	int error;

	/* Lookup the xattr directory */
	error = -zfs_lookup(ITOZ(ip), NULL, &dxzp, LOOKUP_XATTR,
	cr, NULL, NULL);
	if (error)
	goto out;

	/* Lookup a specific xattr name in the directory */
	error = -zfs_lookup(dxzp, (char *)name, &xzp, 0, cr, NULL, NULL);
	if (error)
	goto out;

	xip = ZTOI(xzp);
	if (!size) {
	error = i_size_read(xip);
	goto out;
	}

	if (size < i_size_read(xip)) {
	error = -ERANGE;
	goto out;
	}

	struct iovec iov;
	iov.iov_base = (void *)value;
	iov.iov_len = size;

	zfs_uio_t uio;
	zfs_uio_iovec_init(&uio, &iov, 1, 0, UIO_SYSSPACE, size, 0);

	cookie = spl_fstrans_mark();
	error = -zfs_read(ITOZ(xip), &uio, 0, cr);
	spl_fstrans_unmark(cookie);

	if (error == 0)
	error = size - zfs_uio_resid(&uio);
	out:
	if (xzp)
	zrele(xzp);

	if (dxzp)
	zrele(dxzp);

	return (error);
	}

	static int
	zpl_xattr_get_sa(struct inode ip, const char name, void *value, size_t size)
	{
	znode_t *zp = ITOZ(ip);
	uchar_t *nv_value;
	uint_t nv_size;
	int error = 0;

	ASSERT(RW_LOCK_HELD(&zp->z_xattr_lock));

	mutex_enter(&zp->z_lock);
	if (zp->z_xattr_cached == NULL)
	error = -zfs_sa_get_xattr(zp);
	mutex_exit(&zp->z_lock);

	if (error)
	return (error);

	ASSERT(zp->z_xattr_cached);
	error = -nvlist_lookup_byte_array(zp->z_xattr_cached, name,
	&nv_value, &nv_size);
	if (error)
	return (error);

	if (size == 0 \|\| value == NULL)
	return (nv_size);

	if (size < nv_size)
	return (-ERANGE);

	memcpy(value, nv_value, nv_size);

	return (nv_size);
	}

	static int
	__zpl_xattr_get(struct inode ip, const char name, void *value, size_t size,
	cred_t *cr)
	{
	znode_t *zp = ITOZ(ip);
	zfsvfs_t *zfsvfs = ZTOZSB(zp);
	int error;

	ASSERT(RW_LOCK_HELD(&zp->z_xattr_lock));

	if (zfsvfs->z_use_sa && zp->z_is_sa) {
	error = zpl_xattr_get_sa(ip, name, value, size);
	if (error != -ENOENT)
	goto out;
	}

	error = zpl_xattr_get_dir(ip, name, value, size, cr);
	out:
	if (error == -ENOENT)
	error = -ENODATA;

	return (error);
	}

	#define XATTR_NOENT 0x0
	#define XATTR_IN_SA 0x1
	#define XATTR_IN_DIR 0x2
	/* check where the xattr resides */
	static int
	__zpl_xattr_where(struct inode ip, const char name, int where, cred_t cr)
	{
	znode_t *zp = ITOZ(ip);
	zfsvfs_t *zfsvfs = ZTOZSB(zp);
	int error;

	ASSERT(where);
	ASSERT(RW_LOCK_HELD(&zp->z_xattr_lock));

	*where = XATTR_NOENT;
	if (zfsvfs->z_use_sa && zp->z_is_sa) {
	error = zpl_xattr_get_sa(ip, name, NULL, 0);
	if (error >= 0)
	*where \|= XATTR_IN_SA;
	else if (error != -ENOENT)
	return (error);
	}

	error = zpl_xattr_get_dir(ip, name, NULL, 0, cr);
	if (error >= 0)
	*where \|= XATTR_IN_DIR;
	else if (error != -ENOENT)
	return (error);

	if (*where == (XATTR_IN_SA\|XATTR_IN_DIR))
	cmn_err(CE_WARN, "ZFS: inode %p has xattr \"%s\""
	" in both SA and dir", ip, name);
	if (*where == XATTR_NOENT)
	error = -ENODATA;
	else
	error = 0;
	return (error);
	}

	static int
	zpl_xattr_get(struct inode ip, const char name, void *value, size_t size)
	{
	znode_t *zp = ITOZ(ip);
	zfsvfs_t *zfsvfs = ZTOZSB(zp);
	cred_t *cr = CRED();
	fstrans_cookie_t cookie;
	int error;

	crhold(cr);
	cookie = spl_fstrans_mark();
	ZPL_ENTER(zfsvfs);
	ZPL_VERIFY_ZP(zp);
	rw_enter(&zp->z_xattr_lock, RW_READER);
	error = __zpl_xattr_get(ip, name, value, size, cr);
	rw_exit(&zp->z_xattr_lock);
	ZPL_EXIT(zfsvfs);
	spl_fstrans_unmark(cookie);
	crfree(cr);

	return (error);
	}

	static int
	zpl_xattr_set_dir(struct inode ip, const char name, const void *value,
	size_t size, int flags, cred_t *cr)
	{
	znode_t *dxzp = NULL;
	znode_t *xzp = NULL;
	vattr_t *vap = NULL;
	int lookup_flags, error;
	const int xattr_mode = S_IFREG \| 0644;
	loff_t pos = 0;

	/*
	* Lookup the xattr directory. When we're adding an entry pass
	* CREATE_XATTR_DIR to ensure the xattr directory is created.
	* When removing an entry this flag is not passed to avoid
	* unnecessarily creating a new xattr directory.
	*/
	lookup_flags = LOOKUP_XATTR;
	if (value != NULL)
	lookup_flags \|= CREATE_XATTR_DIR;

	error = -zfs_lookup(ITOZ(ip), NULL, &dxzp, lookup_flags,
	cr, NULL, NULL);
	if (error)
	goto out;

	/* Lookup a specific xattr name in the directory */
	error = -zfs_lookup(dxzp, (char *)name, &xzp, 0, cr, NULL, NULL);
	if (error && (error != -ENOENT))
	goto out;

	error = 0;

	/* Remove a specific name xattr when value is set to NULL. */
	if (value == NULL) {
	if (xzp)
	error = -zfs_remove(dxzp, (char *)name, cr, 0);

	goto out;
	}

	/* Lookup failed create a new xattr. */
	if (xzp == NULL) {
	vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
	vap->va_mode = xattr_mode;
	vap->va_mask = ATTR_MODE;
	vap->va_uid = crgetfsuid(cr);
	vap->va_gid = crgetfsgid(cr);

	error = -zfs_create(dxzp, (char *)name, vap, 0, 0644, &xzp,
	cr, 0, NULL);
	if (error)
	goto out;
	}

	ASSERT(xzp != NULL);

	error = -zfs_freesp(xzp, 0, 0, xattr_mode, TRUE);
	if (error)
	goto out;

	error = -zfs_write_simple(xzp, value, size, pos, NULL);
	out:
	if (error == 0) {
	ip->i_ctime = current_time(ip);
	zfs_mark_inode_dirty(ip);
	}

	if (vap)
	kmem_free(vap, sizeof (vattr_t));

	if (xzp)
	zrele(xzp);

	if (dxzp)
	zrele(dxzp);

	if (error == -ENOENT)
	error = -ENODATA;

	ASSERT3S(error, <=, 0);

	return (error);
	}

	static int
	zpl_xattr_set_sa(struct inode ip, const char name, const void *value,
	size_t size, int flags, cred_t *cr)
	{
	znode_t *zp = ITOZ(ip);
	nvlist_t *nvl;
	size_t sa_size;
	int error = 0;

	mutex_enter(&zp->z_lock);
	if (zp->z_xattr_cached == NULL)
	error = -zfs_sa_get_xattr(zp);
	mutex_exit(&zp->z_lock);

	if (error)
	return (error);

	ASSERT(zp->z_xattr_cached);
	nvl = zp->z_xattr_cached;

	if (value == NULL) {
	error = -nvlist_remove(nvl, name, DATA_TYPE_BYTE_ARRAY);
	if (error == -ENOENT)
	error = zpl_xattr_set_dir(ip, name, NULL, 0, flags, cr);
	} else {
	/* Limited to 32k to keep nvpair memory allocations small */
	if (size > DXATTR_MAX_ENTRY_SIZE)
	return (-EFBIG);

	/* Prevent the DXATTR SA from consuming the entire SA region */
	error = -nvlist_size(nvl, &sa_size, NV_ENCODE_XDR);
	if (error)
	return (error);

	if (sa_size > DXATTR_MAX_SA_SIZE)
	return (-EFBIG);

	error = -nvlist_add_byte_array(nvl, name,
	(uchar_t *)value, size);
	}

	/*
	* Update the SA for additions, modifications, and removals. On
	* error drop the inconsistent cached version of the nvlist, it
	* will be reconstructed from the ARC when next accessed.
	*/
	if (error == 0)
	error = -zfs_sa_set_xattr(zp);

	if (error) {
	nvlist_free(nvl);
	zp->z_xattr_cached = NULL;
	}

	ASSERT3S(error, <=, 0);

	return (error);
	}

	static int
	zpl_xattr_set(struct inode ip, const char name, const void *value,
	size_t size, int flags)
	{
	znode_t *zp = ITOZ(ip);
	zfsvfs_t *zfsvfs = ZTOZSB(zp);
	cred_t *cr = CRED();
	fstrans_cookie_t cookie;
	int where;
	int error;

	crhold(cr);
	cookie = spl_fstrans_mark();
	ZPL_ENTER(zfsvfs);
	ZPL_VERIFY_ZP(zp);
	rw_enter(&ITOZ(ip)->z_xattr_lock, RW_WRITER);

	/*
	* Before setting the xattr check to see if it already exists.
	* This is done to ensure the following optional flags are honored.
	*
	* XATTR_CREATE: fail if xattr already exists
	* XATTR_REPLACE: fail if xattr does not exist
	*
	* We also want to know if it resides in sa or dir, so we can make
	* sure we don't end up with duplicate in both places.
	*/
	error = __zpl_xattr_where(ip, name, &where, cr);
	if (error < 0) {
	if (error != -ENODATA)
	goto out;
	if (flags & XATTR_REPLACE)
	goto out;

	/* The xattr to be removed already doesn't exist */
	error = 0;
	if (value == NULL)
	goto out;
	} else {
	error = -EEXIST;
	if (flags & XATTR_CREATE)
	goto out;
	}

	/* Preferentially store the xattr as a SA for better performance */
	if (zfsvfs->z_use_sa && zp->z_is_sa &&
	(zfsvfs->z_xattr_sa \|\| (value == NULL && where & XATTR_IN_SA))) {
	error = zpl_xattr_set_sa(ip, name, value, size, flags, cr);
	if (error == 0) {
	/*
	* Successfully put into SA, we need to clear the one
	* in dir.
	*/
	if (where & XATTR_IN_DIR)
	zpl_xattr_set_dir(ip, name, NULL, 0, 0, cr);
	goto out;
	}
	}

	error = zpl_xattr_set_dir(ip, name, value, size, flags, cr);
	/*
	* Successfully put into dir, we need to clear the one in SA.
	*/
	if (error == 0 && (where & XATTR_IN_SA))
	zpl_xattr_set_sa(ip, name, NULL, 0, 0, cr);
	out:
	rw_exit(&ITOZ(ip)->z_xattr_lock);
	ZPL_EXIT(zfsvfs);
	spl_fstrans_unmark(cookie);
	crfree(cr);
	ASSERT3S(error, <=, 0);

	return (error);
	}

	/*
	* Extended user attributes
	*
	* "Extended user attributes may be assigned to files and directories for
	* storing arbitrary additional information such as the mime type,
	* character set or encoding of a file. The access permissions for user
	* attributes are defined by the file permission bits: read permission
	* is required to retrieve the attribute value, and writer permission is
	* required to change it.
	*
	* The file permission bits of regular files and directories are
	* interpreted differently from the file permission bits of special
	* files and symbolic links. For regular files and directories the file
	* permission bits define access to the file's contents, while for
	* device special files they define access to the device described by
	* the special file. The file permissions of symbolic links are not
	* used in access checks. These differences would allow users to
	* consume filesystem resources in a way not controllable by disk quotas
	* for group or world writable special files and directories.
	*
	* For this reason, extended user attributes are allowed only for
	* regular files and directories, and access to extended user attributes
	* is restricted to the owner and to users with appropriate capabilities
	* for directories with the sticky bit set (see the chmod(1) manual page
	* for an explanation of the sticky bit)." - xattr(7)
	*
	* ZFS allows extended user attributes to be disabled administratively
	* by setting the 'xattr=off' property on the dataset.
	*/
	static int
	__zpl_xattr_user_list(struct inode ip, char list, size_t list_size,
	const char *name, size_t name_len)
	{
	return (ITOZSB(ip)->z_flags & ZSB_XATTR);
	}
	ZPL_XATTR_LIST_WRAPPER(zpl_xattr_user_list);

	static int
	__zpl_xattr_user_get(struct inode ip, const char name,
	void *value, size_t size)
	{
	char *xattr_name;
	int error;
	/* xattr_resolve_name will do this for us if this is defined */
	#ifndef HAVE_XATTR_HANDLER_NAME
	if (strcmp(name, "") == 0)
	return (-EINVAL);
	#endif
	if (!(ITOZSB(ip)->z_flags & ZSB_XATTR))
	return (-EOPNOTSUPP);

	xattr_name = kmem_asprintf("%s%s", XATTR_USER_PREFIX, name);
	error = zpl_xattr_get(ip, xattr_name, value, size);
	kmem_strfree(xattr_name);

	return (error);
	}
	ZPL_XATTR_GET_WRAPPER(zpl_xattr_user_get);

	static int
	__zpl_xattr_user_set(struct inode ip, const char name,
	const void *value, size_t size, int flags)
	{
	char *xattr_name;
	int error;
	/* xattr_resolve_name will do this for us if this is defined */
	#ifndef HAVE_XATTR_HANDLER_NAME
	if (strcmp(name, "") == 0)
	return (-EINVAL);
	#endif
	if (!(ITOZSB(ip)->z_flags & ZSB_XATTR))
	return (-EOPNOTSUPP);

	xattr_name = kmem_asprintf("%s%s", XATTR_USER_PREFIX, name);
	error = zpl_xattr_set(ip, xattr_name, value, size, flags);
	kmem_strfree(xattr_name);

	return (error);
	}
	ZPL_XATTR_SET_WRAPPER(zpl_xattr_user_set);

	xattr_handler_t zpl_xattr_user_handler =
	{
	.prefix = XATTR_USER_PREFIX,
	.list = zpl_xattr_user_list,
	.get = zpl_xattr_user_get,
	.set = zpl_xattr_user_set,
	};

	/*
	* Trusted extended attributes
	*
	* "Trusted extended attributes are visible and accessible only to
	* processes that have the CAP_SYS_ADMIN capability. Attributes in this
	* class are used to implement mechanisms in user space (i.e., outside
	* the kernel) which keep information in extended attributes to which
	* ordinary processes should not have access." - xattr(7)
	*/
	static int
	__zpl_xattr_trusted_list(struct inode ip, char list, size_t list_size,
	const char *name, size_t name_len)
	{
	return (capable(CAP_SYS_ADMIN));
	}
	ZPL_XATTR_LIST_WRAPPER(zpl_xattr_trusted_list);

	static int
	__zpl_xattr_trusted_get(struct inode ip, const char name,
	void *value, size_t size)
	{
	char *xattr_name;
	int error;

	if (!capable(CAP_SYS_ADMIN))
	return (-EACCES);
	/* xattr_resolve_name will do this for us if this is defined */
	#ifndef HAVE_XATTR_HANDLER_NAME
	if (strcmp(name, "") == 0)
	return (-EINVAL);
	#endif
	xattr_name = kmem_asprintf("%s%s", XATTR_TRUSTED_PREFIX, name);
	error = zpl_xattr_get(ip, xattr_name, value, size);
	kmem_strfree(xattr_name);

	return (error);
	}
	ZPL_XATTR_GET_WRAPPER(zpl_xattr_trusted_get);

	static int
	__zpl_xattr_trusted_set(struct inode ip, const char name,
	const void *value, size_t size, int flags)
	{
	char *xattr_name;
	int error;

	if (!capable(CAP_SYS_ADMIN))
	return (-EACCES);
	/* xattr_resolve_name will do this for us if this is defined */
	#ifndef HAVE_XATTR_HANDLER_NAME
	if (strcmp(name, "") == 0)
	return (-EINVAL);
	#endif
	xattr_name = kmem_asprintf("%s%s", XATTR_TRUSTED_PREFIX, name);
	error = zpl_xattr_set(ip, xattr_name, value, size, flags);
	kmem_strfree(xattr_name);

	return (error);
	}
	ZPL_XATTR_SET_WRAPPER(zpl_xattr_trusted_set);

	xattr_handler_t zpl_xattr_trusted_handler =
	{
	.prefix = XATTR_TRUSTED_PREFIX,
	.list = zpl_xattr_trusted_list,
	.get = zpl_xattr_trusted_get,
	.set = zpl_xattr_trusted_set,
	};

	/*
	* Extended security attributes
	*
	* "The security attribute namespace is used by kernel security modules,
	* such as Security Enhanced Linux, and also to implement file
	* capabilities (see capabilities(7)). Read and write access
	* permissions to security attributes depend on the policy implemented
	* for each security attribute by the security module. When no security
	* module is loaded, all processes have read access to extended security
	* attributes, and write access is limited to processes that have the
	* CAP_SYS_ADMIN capability." - xattr(7)
	*/
	static int
	__zpl_xattr_security_list(struct inode ip, char list, size_t list_size,
	const char *name, size_t name_len)
	{
	return (1);
	}
	ZPL_XATTR_LIST_WRAPPER(zpl_xattr_security_list);

	static int
	__zpl_xattr_security_get(struct inode ip, const char name,
	void *value, size_t size)
	{
	char *xattr_name;
	int error;
	/* xattr_resolve_name will do this for us if this is defined */
	#ifndef HAVE_XATTR_HANDLER_NAME
	if (strcmp(name, "") == 0)
	return (-EINVAL);
	#endif
	xattr_name = kmem_asprintf("%s%s", XATTR_SECURITY_PREFIX, name);
	error = zpl_xattr_get(ip, xattr_name, value, size);
	kmem_strfree(xattr_name);

	return (error);
	}
	ZPL_XATTR_GET_WRAPPER(zpl_xattr_security_get);

	static int
	__zpl_xattr_security_set(struct inode ip, const char name,
	const void *value, size_t size, int flags)
	{
	char *xattr_name;
	int error;
	/* xattr_resolve_name will do this for us if this is defined */
	#ifndef HAVE_XATTR_HANDLER_NAME
	if (strcmp(name, "") == 0)
	return (-EINVAL);
	#endif
	xattr_name = kmem_asprintf("%s%s", XATTR_SECURITY_PREFIX, name);
	error = zpl_xattr_set(ip, xattr_name, value, size, flags);
	kmem_strfree(xattr_name);

	return (error);
	}
	ZPL_XATTR_SET_WRAPPER(zpl_xattr_security_set);

	static int
	zpl_xattr_security_init_impl(struct inode ip, const struct xattr xattrs,
	void *fs_info)
	{
	const struct xattr *xattr;
	int error = 0;

	for (xattr = xattrs; xattr->name != NULL; xattr++) {
	error = __zpl_xattr_security_set(ip,
	xattr->name, xattr->value, xattr->value_len, 0);

	if (error < 0)
	break;
	}

	return (error);
	}

	int
	zpl_xattr_security_init(struct inode ip, struct inode dip,
	const struct qstr *qstr)
	{
	return security_inode_init_security(ip, dip, qstr,
	&zpl_xattr_security_init_impl, NULL);
	}

	/*
	* Security xattr namespace handlers.
	*/
	xattr_handler_t zpl_xattr_security_handler = {
	.prefix = XATTR_SECURITY_PREFIX,
	.list = zpl_xattr_security_list,
	.get = zpl_xattr_security_get,
	.set = zpl_xattr_security_set,
	};

	/*
	* Extended system attributes
	*
	* "Extended system attributes are used by the kernel to store system
	* objects such as Access Control Lists. Read and write access permissions
	* to system attributes depend on the policy implemented for each system
	* attribute implemented by filesystems in the kernel." - xattr(7)
	*/
	#ifdef CONFIG_FS_POSIX_ACL
	-#ifndef HAVE_SET_ACL
	-static
	-#endif
	-int
	-zpl_set_acl(struct inode ip, struct posix_acl acl, int type)
	+static int
	+zpl_set_acl_impl(struct inode ip, struct posix_acl acl, int type)
	{
	char name, value = NULL;
	int error = 0;
	size_t size = 0;

	if (S_ISLNK(ip->i_mode))
	return (-EOPNOTSUPP);

	switch (type) {
	case ACL_TYPE_ACCESS:
	name = XATTR_NAME_POSIX_ACL_ACCESS;
	if (acl) {
	umode_t mode = ip->i_mode;
	error = posix_acl_equiv_mode(acl, &mode);
	if (error < 0) {
	return (error);
	} else {
	/*
	* The mode bits will have been set by
	* ->zfs_setattr()->zfs_acl_chmod_setattr()
	* using the ZFS ACL conversion. If they
	* differ from the Posix ACL conversion dirty
	* the inode to write the Posix mode bits.
	*/
	if (ip->i_mode != mode) {
	ip->i_mode = mode;
	ip->i_ctime = current_time(ip);
	zfs_mark_inode_dirty(ip);
	}

	if (error == 0)
	acl = NULL;
	}
	}
	break;

	case ACL_TYPE_DEFAULT:
	name = XATTR_NAME_POSIX_ACL_DEFAULT;
	if (!S_ISDIR(ip->i_mode))
	return (acl ? -EACCES : 0);
	break;

	default:
	return (-EINVAL);
	}

	if (acl) {
	size = posix_acl_xattr_size(acl->a_count);
	value = kmem_alloc(size, KM_SLEEP);

	error = zpl_acl_to_xattr(acl, value, size);
	if (error < 0) {
	kmem_free(value, size);
	return (error);
	}
	}

	error = zpl_xattr_set(ip, name, value, size, 0);
	if (value)
	kmem_free(value, size);

	if (!error) {
	if (acl)
	zpl_set_cached_acl(ip, type, acl);
	else
	zpl_forget_cached_acl(ip, type);
	}

	return (error);
	}

	+#ifdef HAVE_SET_ACL
	+int
	+#ifdef HAVE_SET_ACL_USERNS
	+zpl_set_acl(struct user_namespace userns, struct inode ip,
	+ struct posix_acl *acl, int type)
	+#else
	+zpl_set_acl(struct inode ip, struct posix_acl acl, int type)
	+#endif /* HAVE_SET_ACL_USERNS */
	+{
	+ return (zpl_set_acl_impl(ip, acl, type));
	+}
	+#endif /* HAVE_SET_ACL */
	+
	struct posix_acl *
	zpl_get_acl(struct inode *ip, int type)
	{
	struct posix_acl *acl;
	void *value = NULL;
	char *name;
	int size;

	/*
	* As of Linux 3.14, the kernel get_acl will check this for us.
	* Also as of Linux 4.7, comparing against ACL_NOT_CACHED is wrong
	* as the kernel get_acl will set it to temporary sentinel value.
	*/
	#ifndef HAVE_KERNEL_GET_ACL_HANDLE_CACHE
	acl = get_cached_acl(ip, type);
	if (acl != ACL_NOT_CACHED)
	return (acl);
	#endif

	switch (type) {
	case ACL_TYPE_ACCESS:
	name = XATTR_NAME_POSIX_ACL_ACCESS;
	break;
	case ACL_TYPE_DEFAULT:
	name = XATTR_NAME_POSIX_ACL_DEFAULT;
	break;
	default:
	return (ERR_PTR(-EINVAL));
	}

	size = zpl_xattr_get(ip, name, NULL, 0);
	if (size > 0) {
	value = kmem_alloc(size, KM_SLEEP);
	size = zpl_xattr_get(ip, name, value, size);
	}

	if (size > 0) {
	acl = zpl_acl_from_xattr(value, size);
	} else if (size == -ENODATA \|\| size == -ENOSYS) {
	acl = NULL;
	} else {
	acl = ERR_PTR(-EIO);
	}

	if (size > 0)
	kmem_free(value, size);

	/* As of Linux 4.7, the kernel get_acl will set this for us */
	#ifndef HAVE_KERNEL_GET_ACL_HANDLE_CACHE
	if (!IS_ERR(acl))
	zpl_set_cached_acl(ip, type, acl);
	#endif

	return (acl);
	}

	int
	zpl_init_acl(struct inode ip, struct inode dir)
	{
	struct posix_acl *acl = NULL;
	int error = 0;

	if (ITOZSB(ip)->z_acl_type != ZFS_ACLTYPE_POSIX)
	return (0);

	if (!S_ISLNK(ip->i_mode)) {
	acl = zpl_get_acl(dir, ACL_TYPE_DEFAULT);
	if (IS_ERR(acl))
	return (PTR_ERR(acl));
	if (!acl) {
	ip->i_mode &= ~current_umask();
	ip->i_ctime = current_time(ip);
	zfs_mark_inode_dirty(ip);
	return (0);
	}
	}

	if (acl) {
	umode_t mode;

	if (S_ISDIR(ip->i_mode)) {
	- error = zpl_set_acl(ip, acl, ACL_TYPE_DEFAULT);
	+ error = zpl_set_acl_impl(ip, acl, ACL_TYPE_DEFAULT);
	if (error)
	goto out;
	}

	mode = ip->i_mode;
	error = __posix_acl_create(&acl, GFP_KERNEL, &mode);
	if (error >= 0) {
	ip->i_mode = mode;
	zfs_mark_inode_dirty(ip);
	- if (error > 0)
	- error = zpl_set_acl(ip, acl, ACL_TYPE_ACCESS);
	+ if (error > 0) {
	+ error = zpl_set_acl_impl(ip, acl,
	+ ACL_TYPE_ACCESS);
	+ }
	}
	}
	out:
	zpl_posix_acl_release(acl);

	return (error);
	}

	int
	zpl_chmod_acl(struct inode *ip)
	{
	struct posix_acl *acl;
	int error;

	if (ITOZSB(ip)->z_acl_type != ZFS_ACLTYPE_POSIX)
	return (0);

	if (S_ISLNK(ip->i_mode))
	return (-EOPNOTSUPP);

	acl = zpl_get_acl(ip, ACL_TYPE_ACCESS);
	if (IS_ERR(acl) \|\| !acl)
	return (PTR_ERR(acl));

	error = __posix_acl_chmod(&acl, GFP_KERNEL, ip->i_mode);
	if (!error)
	- error = zpl_set_acl(ip, acl, ACL_TYPE_ACCESS);
	+ error = zpl_set_acl_impl(ip, acl, ACL_TYPE_ACCESS);

	zpl_posix_acl_release(acl);

	return (error);
	}

	static int
	__zpl_xattr_acl_list_access(struct inode ip, char list, size_t list_size,
	const char *name, size_t name_len)
	{
	char *xattr_name = XATTR_NAME_POSIX_ACL_ACCESS;
	size_t xattr_size = sizeof (XATTR_NAME_POSIX_ACL_ACCESS);

	if (ITOZSB(ip)->z_acl_type != ZFS_ACLTYPE_POSIX)
	return (0);

	if (list && xattr_size <= list_size)
	memcpy(list, xattr_name, xattr_size);

	return (xattr_size);
	}
	ZPL_XATTR_LIST_WRAPPER(zpl_xattr_acl_list_access);

	static int
	__zpl_xattr_acl_list_default(struct inode ip, char list, size_t list_size,
	const char *name, size_t name_len)
	{
	char *xattr_name = XATTR_NAME_POSIX_ACL_DEFAULT;
	size_t xattr_size = sizeof (XATTR_NAME_POSIX_ACL_DEFAULT);

	if (ITOZSB(ip)->z_acl_type != ZFS_ACLTYPE_POSIX)
	return (0);

	if (list && xattr_size <= list_size)
	memcpy(list, xattr_name, xattr_size);

	return (xattr_size);
	}
	ZPL_XATTR_LIST_WRAPPER(zpl_xattr_acl_list_default);

	static int
	__zpl_xattr_acl_get_access(struct inode ip, const char name,
	void *buffer, size_t size)
	{
	struct posix_acl *acl;
	int type = ACL_TYPE_ACCESS;
	int error;
	/* xattr_resolve_name will do this for us if this is defined */
	#ifndef HAVE_XATTR_HANDLER_NAME
	if (strcmp(name, "") != 0)
	return (-EINVAL);
	#endif
	if (ITOZSB(ip)->z_acl_type != ZFS_ACLTYPE_POSIX)
	return (-EOPNOTSUPP);

	acl = zpl_get_acl(ip, type);
	if (IS_ERR(acl))
	return (PTR_ERR(acl));
	if (acl == NULL)
	return (-ENODATA);

	error = zpl_acl_to_xattr(acl, buffer, size);
	zpl_posix_acl_release(acl);

	return (error);
	}
	ZPL_XATTR_GET_WRAPPER(zpl_xattr_acl_get_access);

	static int
	__zpl_xattr_acl_get_default(struct inode ip, const char name,
	void *buffer, size_t size)
	{
	struct posix_acl *acl;
	int type = ACL_TYPE_DEFAULT;
	int error;
	/* xattr_resolve_name will do this for us if this is defined */
	#ifndef HAVE_XATTR_HANDLER_NAME
	if (strcmp(name, "") != 0)
	return (-EINVAL);
	#endif
	if (ITOZSB(ip)->z_acl_type != ZFS_ACLTYPE_POSIX)
	return (-EOPNOTSUPP);

	acl = zpl_get_acl(ip, type);
	if (IS_ERR(acl))
	return (PTR_ERR(acl));
	if (acl == NULL)
	return (-ENODATA);

	error = zpl_acl_to_xattr(acl, buffer, size);
	zpl_posix_acl_release(acl);

	return (error);
	}
	ZPL_XATTR_GET_WRAPPER(zpl_xattr_acl_get_default);

	static int
	__zpl_xattr_acl_set_access(struct inode ip, const char name,
	const void *value, size_t size, int flags)
	{
	struct posix_acl *acl;
	int type = ACL_TYPE_ACCESS;
	int error = 0;
	/* xattr_resolve_name will do this for us if this is defined */
	#ifndef HAVE_XATTR_HANDLER_NAME
	if (strcmp(name, "") != 0)
	return (-EINVAL);
	#endif
	if (ITOZSB(ip)->z_acl_type != ZFS_ACLTYPE_POSIX)
	return (-EOPNOTSUPP);

	if (!zpl_inode_owner_or_capable(kcred->user_ns, ip))
	return (-EPERM);

	if (value) {
	acl = zpl_acl_from_xattr(value, size);
	if (IS_ERR(acl))
	return (PTR_ERR(acl));
	else if (acl) {
	error = zpl_posix_acl_valid(ip, acl);
	if (error) {
	zpl_posix_acl_release(acl);
	return (error);
	}
	}
	} else {
	acl = NULL;
	}
	-
	- error = zpl_set_acl(ip, acl, type);
	+ error = zpl_set_acl_impl(ip, acl, type);
	zpl_posix_acl_release(acl);

	return (error);
	}
	ZPL_XATTR_SET_WRAPPER(zpl_xattr_acl_set_access);

	static int
	__zpl_xattr_acl_set_default(struct inode ip, const char name,
	const void *value, size_t size, int flags)
	{
	struct posix_acl *acl;
	int type = ACL_TYPE_DEFAULT;
	int error = 0;
	/* xattr_resolve_name will do this for us if this is defined */
	#ifndef HAVE_XATTR_HANDLER_NAME
	if (strcmp(name, "") != 0)
	return (-EINVAL);
	#endif
	if (ITOZSB(ip)->z_acl_type != ZFS_ACLTYPE_POSIX)
	return (-EOPNOTSUPP);

	if (!zpl_inode_owner_or_capable(kcred->user_ns, ip))
	return (-EPERM);

	if (value) {
	acl = zpl_acl_from_xattr(value, size);
	if (IS_ERR(acl))
	return (PTR_ERR(acl));
	else if (acl) {
	error = zpl_posix_acl_valid(ip, acl);
	if (error) {
	zpl_posix_acl_release(acl);
	return (error);
	}
	}
	} else {
	acl = NULL;
	}

	- error = zpl_set_acl(ip, acl, type);
	+ error = zpl_set_acl_impl(ip, acl, type);
	zpl_posix_acl_release(acl);

	return (error);
	}
	ZPL_XATTR_SET_WRAPPER(zpl_xattr_acl_set_default);

	/*
	* ACL access xattr namespace handlers.
	*
	* Use .name instead of .prefix when available. xattr_resolve_name will match
	* whole name and reject anything that has .name only as prefix.
	*/
	xattr_handler_t zpl_xattr_acl_access_handler =
	{
	#ifdef HAVE_XATTR_HANDLER_NAME
	.name = XATTR_NAME_POSIX_ACL_ACCESS,
	#else
	.prefix = XATTR_NAME_POSIX_ACL_ACCESS,
	#endif
	.list = zpl_xattr_acl_list_access,
	.get = zpl_xattr_acl_get_access,
	.set = zpl_xattr_acl_set_access,
	#if defined(HAVE_XATTR_LIST_SIMPLE) \|\| \
	defined(HAVE_XATTR_LIST_DENTRY) \|\| \
	defined(HAVE_XATTR_LIST_HANDLER)
	.flags = ACL_TYPE_ACCESS,
	#endif
	};

	/*
	* ACL default xattr namespace handlers.
	*
	* Use .name instead of .prefix when available. xattr_resolve_name will match
	* whole name and reject anything that has .name only as prefix.
	*/
	xattr_handler_t zpl_xattr_acl_default_handler =
	{
	#ifdef HAVE_XATTR_HANDLER_NAME
	.name = XATTR_NAME_POSIX_ACL_DEFAULT,
	#else
	.prefix = XATTR_NAME_POSIX_ACL_DEFAULT,
	#endif
	.list = zpl_xattr_acl_list_default,
	.get = zpl_xattr_acl_get_default,
	.set = zpl_xattr_acl_set_default,
	#if defined(HAVE_XATTR_LIST_SIMPLE) \|\| \
	defined(HAVE_XATTR_LIST_DENTRY) \|\| \
	defined(HAVE_XATTR_LIST_HANDLER)
	.flags = ACL_TYPE_DEFAULT,
	#endif
	};

	#endif /* CONFIG_FS_POSIX_ACL */

	xattr_handler_t *zpl_xattr_handlers[] = {
	&zpl_xattr_security_handler,
	&zpl_xattr_trusted_handler,
	&zpl_xattr_user_handler,
	#ifdef CONFIG_FS_POSIX_ACL
	&zpl_xattr_acl_access_handler,
	&zpl_xattr_acl_default_handler,
	#endif /* CONFIG_FS_POSIX_ACL */
	NULL
	};

	static const struct xattr_handler *
	zpl_xattr_handler(const char *name)
	{
	if (strncmp(name, XATTR_USER_PREFIX,
	XATTR_USER_PREFIX_LEN) == 0)
	return (&zpl_xattr_user_handler);

	if (strncmp(name, XATTR_TRUSTED_PREFIX,
	XATTR_TRUSTED_PREFIX_LEN) == 0)
	return (&zpl_xattr_trusted_handler);

	if (strncmp(name, XATTR_SECURITY_PREFIX,
	XATTR_SECURITY_PREFIX_LEN) == 0)
	return (&zpl_xattr_security_handler);

	#ifdef CONFIG_FS_POSIX_ACL
	if (strncmp(name, XATTR_NAME_POSIX_ACL_ACCESS,
	sizeof (XATTR_NAME_POSIX_ACL_ACCESS)) == 0)
	return (&zpl_xattr_acl_access_handler);

	if (strncmp(name, XATTR_NAME_POSIX_ACL_DEFAULT,
	sizeof (XATTR_NAME_POSIX_ACL_DEFAULT)) == 0)
	return (&zpl_xattr_acl_default_handler);
	#endif /* CONFIG_FS_POSIX_ACL */

	return (NULL);
	}

	#if !defined(HAVE_POSIX_ACL_RELEASE) \|\| defined(HAVE_POSIX_ACL_RELEASE_GPL_ONLY)
	struct acl_rel_struct {
	struct acl_rel_struct *next;
	struct posix_acl *acl;
	clock_t time;
	};

	#define ACL_REL_GRACE (60*HZ)
	#define ACL_REL_WINDOW (1*HZ)
	#define ACL_REL_SCHED (ACL_REL_GRACE+ACL_REL_WINDOW)

	/*
	* Lockless multi-producer single-consumer fifo list.
	* Nodes are added to tail and removed from head. Tail pointer is our
	* synchronization point. It always points to the next pointer of the last
	* node, or head if list is empty.
	*/
	static struct acl_rel_struct *acl_rel_head = NULL;
	static struct acl_rel_struct **acl_rel_tail = &acl_rel_head;

	static void
	zpl_posix_acl_free(void *arg)
	{
	struct acl_rel_struct *freelist = NULL;
	struct acl_rel_struct *a;
	clock_t new_time;
	boolean_t refire = B_FALSE;

	ASSERT3P(acl_rel_head, !=, NULL);
	while (acl_rel_head) {
	a = acl_rel_head;
	if (ddi_get_lbolt() - a->time >= ACL_REL_GRACE) {
	/*
	* If a is the last node we need to reset tail, but we
	* need to use cmpxchg to make sure it is still the
	* last node.
	*/
	if (acl_rel_tail == &a->next) {
	acl_rel_head = NULL;
	if (cmpxchg(&acl_rel_tail, &a->next,
	&acl_rel_head) == &a->next) {
	ASSERT3P(a->next, ==, NULL);
	a->next = freelist;
	freelist = a;
	break;
	}
	}
	/*
	* a is not last node, make sure next pointer is set
	* by the adder and advance the head.
	*/
	while (READ_ONCE(a->next) == NULL)
	cpu_relax();
	acl_rel_head = a->next;
	a->next = freelist;
	freelist = a;
	} else {
	/*
	* a is still in grace period. We are responsible to
	* reschedule the free task, since adder will only do
	* so if list is empty.
	*/
	new_time = a->time + ACL_REL_SCHED;
	refire = B_TRUE;
	break;
	}
	}

	if (refire)
	taskq_dispatch_delay(system_delay_taskq, zpl_posix_acl_free,
	NULL, TQ_SLEEP, new_time);

	while (freelist) {
	a = freelist;
	freelist = a->next;
	kfree(a->acl);
	kmem_free(a, sizeof (struct acl_rel_struct));
	}
	}

	void
	zpl_posix_acl_release_impl(struct posix_acl *acl)
	{
	struct acl_rel_struct a, *prev;

	a = kmem_alloc(sizeof (struct acl_rel_struct), KM_SLEEP);
	a->next = NULL;
	a->acl = acl;
	a->time = ddi_get_lbolt();
	/* atomically points tail to us and get the previous tail */
	prev = xchg(&acl_rel_tail, &a->next);
	ASSERT3P(*prev, ==, NULL);
	*prev = a;
	/* if it was empty before, schedule the free task */
	if (prev == &acl_rel_head)
	taskq_dispatch_delay(system_delay_taskq, zpl_posix_acl_free,
	NULL, TQ_SLEEP, ddi_get_lbolt() + ACL_REL_SCHED);
	}
	#endif
	diff --git a/sys/contrib/openzfs/module/os/linux/zfs/zvol_os.c b/sys/contrib/openzfs/module/os/linux/zfs/zvol_os.c
	index 7756d819fdeb..741979f11af8 100644
	--- a/sys/contrib/openzfs/module/os/linux/zfs/zvol_os.c
	+++ b/sys/contrib/openzfs/module/os/linux/zfs/zvol_os.c
	@@ -1,1144 +1,1146 @@
	/*
	* 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, 2020 by Delphix. All rights reserved.
	*/

	#include <sys/dataset_kstats.h>
	#include <sys/dbuf.h>
	#include <sys/dmu_traverse.h>
	#include <sys/dsl_dataset.h>
	#include <sys/dsl_prop.h>
	#include <sys/dsl_dir.h>
	#include <sys/zap.h>
	#include <sys/zfeature.h>
	#include <sys/zil_impl.h>
	#include <sys/dmu_tx.h>
	#include <sys/zio.h>
	#include <sys/zfs_rlock.h>
	#include <sys/spa_impl.h>
	#include <sys/zvol.h>
	#include <sys/zvol_impl.h>

	#include <linux/blkdev_compat.h>
	#include <linux/task_io_accounting_ops.h>

	unsigned int zvol_major = ZVOL_MAJOR;
	unsigned int zvol_request_sync = 0;
	unsigned int zvol_prefetch_bytes = (128 * 1024);
	unsigned long zvol_max_discard_blocks = 16384;
	unsigned int zvol_threads = 32;

	struct zvol_state_os {
	struct gendisk zvo_disk; / generic disk */
	struct request_queue zvo_queue; / request queue */
	dev_t zvo_dev; /* device id */
	};

	taskq_t *zvol_taskq;
	static struct ida zvol_ida;

	typedef struct zv_request_stack {
	zvol_state_t *zv;
	struct bio *bio;
	} zv_request_t;

	typedef struct zv_request_task {
	zv_request_t zvr;
	taskq_ent_t ent;
	} zv_request_task_t;

	static zv_request_task_t *
	zv_request_task_create(zv_request_t zvr)
	{
	zv_request_task_t *task;
	task = kmem_alloc(sizeof (zv_request_task_t), KM_SLEEP);
	taskq_init_ent(&task->ent);
	task->zvr = zvr;
	return (task);
	}

	static void
	zv_request_task_free(zv_request_task_t *task)
	{
	kmem_free(task, sizeof (*task));
	}

	/*
	* Given a path, return TRUE if path is a ZVOL.
	*/
	static boolean_t
	zvol_is_zvol_impl(const char *path)
	{
	dev_t dev = 0;

	if (vdev_lookup_bdev(path, &dev) != 0)
	return (B_FALSE);

	if (MAJOR(dev) == zvol_major)
	return (B_TRUE);

	return (B_FALSE);
	}

	static void
	zvol_write(zv_request_t *zvr)
	{
	struct bio *bio = zvr->bio;
	int error = 0;
	zfs_uio_t uio;

	zfs_uio_bvec_init(&uio, bio);

	zvol_state_t *zv = zvr->zv;
	ASSERT3P(zv, !=, NULL);
	ASSERT3U(zv->zv_open_count, >, 0);
	ASSERT3P(zv->zv_zilog, !=, NULL);

	/* bio marked as FLUSH need to flush before write */
	if (bio_is_flush(bio))
	zil_commit(zv->zv_zilog, ZVOL_OBJ);

	/* Some requests are just for flush and nothing else. */
	if (uio.uio_resid == 0) {
	rw_exit(&zv->zv_suspend_lock);
	BIO_END_IO(bio, 0);
	return;
	}

	struct request_queue *q = zv->zv_zso->zvo_queue;
	struct gendisk *disk = zv->zv_zso->zvo_disk;
	ssize_t start_resid = uio.uio_resid;
	unsigned long start_time;

	boolean_t acct = blk_queue_io_stat(q);
	if (acct)
	start_time = blk_generic_start_io_acct(q, disk, WRITE, bio);

	boolean_t sync =
	bio_is_fua(bio) \|\| zv->zv_objset->os_sync == ZFS_SYNC_ALWAYS;

	zfs_locked_range_t *lr = zfs_rangelock_enter(&zv->zv_rangelock,
	uio.uio_loffset, uio.uio_resid, RL_WRITER);

	uint64_t volsize = zv->zv_volsize;
	while (uio.uio_resid > 0 && uio.uio_loffset < volsize) {
	uint64_t bytes = MIN(uio.uio_resid, DMU_MAX_ACCESS >> 1);
	uint64_t off = uio.uio_loffset;
	dmu_tx_t *tx = dmu_tx_create(zv->zv_objset);

	if (bytes > volsize - off) /* don't write past the end */
	bytes = volsize - off;

	dmu_tx_hold_write_by_dnode(tx, zv->zv_dn, off, bytes);

	/* This will only fail for ENOSPC */
	error = dmu_tx_assign(tx, TXG_WAIT);
	if (error) {
	dmu_tx_abort(tx);
	break;
	}
	error = dmu_write_uio_dnode(zv->zv_dn, &uio, bytes, tx);
	if (error == 0) {
	zvol_log_write(zv, tx, off, bytes, sync);
	}
	dmu_tx_commit(tx);

	if (error)
	break;
	}
	zfs_rangelock_exit(lr);

	int64_t nwritten = start_resid - uio.uio_resid;
	dataset_kstats_update_write_kstats(&zv->zv_kstat, nwritten);
	task_io_account_write(nwritten);

	if (sync)
	zil_commit(zv->zv_zilog, ZVOL_OBJ);

	rw_exit(&zv->zv_suspend_lock);

	if (acct)
	blk_generic_end_io_acct(q, disk, WRITE, bio, start_time);

	BIO_END_IO(bio, -error);
	}

	static void
	zvol_write_task(void *arg)
	{
	zv_request_task_t *task = arg;
	zvol_write(&task->zvr);
	zv_request_task_free(task);
	}

	static void
	zvol_discard(zv_request_t *zvr)
	{
	struct bio *bio = zvr->bio;
	zvol_state_t *zv = zvr->zv;
	uint64_t start = BIO_BI_SECTOR(bio) << 9;
	uint64_t size = BIO_BI_SIZE(bio);
	uint64_t end = start + size;
	boolean_t sync;
	int error = 0;
	dmu_tx_t *tx;

	ASSERT3P(zv, !=, NULL);
	ASSERT3U(zv->zv_open_count, >, 0);
	ASSERT3P(zv->zv_zilog, !=, NULL);

	struct request_queue *q = zv->zv_zso->zvo_queue;
	struct gendisk *disk = zv->zv_zso->zvo_disk;
	unsigned long start_time;

	boolean_t acct = blk_queue_io_stat(q);
	if (acct)
	start_time = blk_generic_start_io_acct(q, disk, WRITE, bio);

	sync = bio_is_fua(bio) \|\| zv->zv_objset->os_sync == ZFS_SYNC_ALWAYS;

	if (end > zv->zv_volsize) {
	error = SET_ERROR(EIO);
	goto unlock;
	}

	/*
	* Align the request to volume block boundaries when a secure erase is
	* not required. This will prevent dnode_free_range() from zeroing out
	* the unaligned parts which is slow (read-modify-write) and useless
	* since we are not freeing any space by doing so.
	*/
	if (!bio_is_secure_erase(bio)) {
	start = P2ROUNDUP(start, zv->zv_volblocksize);
	end = P2ALIGN(end, zv->zv_volblocksize);
	size = end - start;
	}

	if (start >= end)
	goto unlock;

	zfs_locked_range_t *lr = zfs_rangelock_enter(&zv->zv_rangelock,
	start, size, RL_WRITER);

	tx = dmu_tx_create(zv->zv_objset);
	dmu_tx_mark_netfree(tx);
	error = dmu_tx_assign(tx, TXG_WAIT);
	if (error != 0) {
	dmu_tx_abort(tx);
	} else {
	zvol_log_truncate(zv, tx, start, size, B_TRUE);
	dmu_tx_commit(tx);
	error = dmu_free_long_range(zv->zv_objset,
	ZVOL_OBJ, start, size);
	}
	zfs_rangelock_exit(lr);

	if (error == 0 && sync)
	zil_commit(zv->zv_zilog, ZVOL_OBJ);

	unlock:
	rw_exit(&zv->zv_suspend_lock);

	if (acct)
	blk_generic_end_io_acct(q, disk, WRITE, bio, start_time);

	BIO_END_IO(bio, -error);
	}

	static void
	zvol_discard_task(void *arg)
	{
	zv_request_task_t *task = arg;
	zvol_discard(&task->zvr);
	zv_request_task_free(task);
	}

	static void
	zvol_read(zv_request_t *zvr)
	{
	struct bio *bio = zvr->bio;
	int error = 0;
	zfs_uio_t uio;

	zfs_uio_bvec_init(&uio, bio);

	zvol_state_t *zv = zvr->zv;
	ASSERT3P(zv, !=, NULL);
	ASSERT3U(zv->zv_open_count, >, 0);

	struct request_queue *q = zv->zv_zso->zvo_queue;
	struct gendisk *disk = zv->zv_zso->zvo_disk;
	ssize_t start_resid = uio.uio_resid;
	unsigned long start_time;

	boolean_t acct = blk_queue_io_stat(q);
	if (acct)
	start_time = blk_generic_start_io_acct(q, disk, READ, bio);

	zfs_locked_range_t *lr = zfs_rangelock_enter(&zv->zv_rangelock,
	uio.uio_loffset, uio.uio_resid, RL_READER);

	uint64_t volsize = zv->zv_volsize;
	while (uio.uio_resid > 0 && uio.uio_loffset < volsize) {
	uint64_t bytes = MIN(uio.uio_resid, DMU_MAX_ACCESS >> 1);

	/* don't read past the end */
	if (bytes > volsize - uio.uio_loffset)
	bytes = volsize - uio.uio_loffset;

	error = dmu_read_uio_dnode(zv->zv_dn, &uio, bytes);
	if (error) {
	/* convert checksum errors into IO errors */
	if (error == ECKSUM)
	error = SET_ERROR(EIO);
	break;
	}
	}
	zfs_rangelock_exit(lr);

	int64_t nread = start_resid - uio.uio_resid;
	dataset_kstats_update_read_kstats(&zv->zv_kstat, nread);
	task_io_account_read(nread);

	rw_exit(&zv->zv_suspend_lock);

	if (acct)
	blk_generic_end_io_acct(q, disk, READ, bio, start_time);

	BIO_END_IO(bio, -error);
	}

	static void
	zvol_read_task(void *arg)
	{
	zv_request_task_t *task = arg;
	zvol_read(&task->zvr);
	zv_request_task_free(task);
	}

	#ifdef HAVE_SUBMIT_BIO_IN_BLOCK_DEVICE_OPERATIONS
	static blk_qc_t
	zvol_submit_bio(struct bio *bio)
	#else
	static MAKE_REQUEST_FN_RET
	zvol_request(struct request_queue q, struct bio bio)
	#endif
	{
	#ifdef HAVE_SUBMIT_BIO_IN_BLOCK_DEVICE_OPERATIONS
	#if defined(HAVE_BIO_BDEV_DISK)
	struct request_queue *q = bio->bi_bdev->bd_disk->queue;
	#else
	struct request_queue *q = bio->bi_disk->queue;
	#endif
	#endif
	zvol_state_t *zv = q->queuedata;
	fstrans_cookie_t cookie = spl_fstrans_mark();
	uint64_t offset = BIO_BI_SECTOR(bio) << 9;
	uint64_t size = BIO_BI_SIZE(bio);
	int rw = bio_data_dir(bio);

	if (bio_has_data(bio) && offset + size > zv->zv_volsize) {
	printk(KERN_INFO
	"%s: bad access: offset=%llu, size=%lu\n",
	zv->zv_zso->zvo_disk->disk_name,
	(long long unsigned)offset,
	(long unsigned)size);

	BIO_END_IO(bio, -SET_ERROR(EIO));
	goto out;
	}

	zv_request_t zvr = {
	.zv = zv,
	.bio = bio,
	};
	zv_request_task_t *task;

	if (rw == WRITE) {
	if (unlikely(zv->zv_flags & ZVOL_RDONLY)) {
	BIO_END_IO(bio, -SET_ERROR(EROFS));
	goto out;
	}

	/*
	* Prevents the zvol from being suspended, or the ZIL being
	* concurrently opened. Will be released after the i/o
	* completes.
	*/
	rw_enter(&zv->zv_suspend_lock, RW_READER);

	/*
	* Open a ZIL if this is the first time we have written to this
	* zvol. We protect zv->zv_zilog with zv_suspend_lock rather
	* than zv_state_lock so that we don't need to acquire an
	* additional lock in this path.
	*/
	if (zv->zv_zilog == NULL) {
	rw_exit(&zv->zv_suspend_lock);
	rw_enter(&zv->zv_suspend_lock, RW_WRITER);
	if (zv->zv_zilog == NULL) {
	zv->zv_zilog = zil_open(zv->zv_objset,
	zvol_get_data);
	zv->zv_flags \|= ZVOL_WRITTEN_TO;
	/* replay / destroy done in zvol_create_minor */
	VERIFY0((zv->zv_zilog->zl_header->zh_flags &
	ZIL_REPLAY_NEEDED));
	}
	rw_downgrade(&zv->zv_suspend_lock);
	}

	/*
	* We don't want this thread to be blocked waiting for i/o to
	* complete, so we instead wait from a taskq callback. The
	* i/o may be a ZIL write (via zil_commit()), or a read of an
	* indirect block, or a read of a data block (if this is a
	* partial-block write). We will indicate that the i/o is
	* complete by calling BIO_END_IO() from the taskq callback.
	*
	* This design allows the calling thread to continue and
	* initiate more concurrent operations by calling
	* zvol_request() again. There are typically only a small
	* number of threads available to call zvol_request() (e.g.
	* one per iSCSI target), so keeping the latency of
	* zvol_request() low is important for performance.
	*
	* The zvol_request_sync module parameter allows this
	* behavior to be altered, for performance evaluation
	* purposes. If the callback blocks, setting
	* zvol_request_sync=1 will result in much worse performance.
	*
	* We can have up to zvol_threads concurrent i/o's being
	* processed for all zvols on the system. This is typically
	* a vast improvement over the zvol_request_sync=1 behavior
	* of one i/o at a time per zvol. However, an even better
	* design would be for zvol_request() to initiate the zio
	* directly, and then be notified by the zio_done callback,
	* which would call BIO_END_IO(). Unfortunately, the DMU/ZIL
	* interfaces lack this functionality (they block waiting for
	* the i/o to complete).
	*/
	if (bio_is_discard(bio) \|\| bio_is_secure_erase(bio)) {
	if (zvol_request_sync) {
	zvol_discard(&zvr);
	} else {
	task = zv_request_task_create(zvr);
	taskq_dispatch_ent(zvol_taskq,
	zvol_discard_task, task, 0, &task->ent);
	}
	} else {
	if (zvol_request_sync) {
	zvol_write(&zvr);
	} else {
	task = zv_request_task_create(zvr);
	taskq_dispatch_ent(zvol_taskq,
	zvol_write_task, task, 0, &task->ent);
	}
	}
	} else {
	/*
	* The SCST driver, and possibly others, may issue READ I/Os
	* with a length of zero bytes. These empty I/Os contain no
	* data and require no additional handling.
	*/
	if (size == 0) {
	BIO_END_IO(bio, 0);
	goto out;
	}

	rw_enter(&zv->zv_suspend_lock, RW_READER);

	/* See comment in WRITE case above. */
	if (zvol_request_sync) {
	zvol_read(&zvr);
	} else {
	task = zv_request_task_create(zvr);
	taskq_dispatch_ent(zvol_taskq,
	zvol_read_task, task, 0, &task->ent);
	}
	}

	out:
	spl_fstrans_unmark(cookie);
	#if defined(HAVE_MAKE_REQUEST_FN_RET_QC) \|\| \
	defined(HAVE_SUBMIT_BIO_IN_BLOCK_DEVICE_OPERATIONS)
	return (BLK_QC_T_NONE);
	#endif
	}

	static int
	zvol_open(struct block_device *bdev, fmode_t flag)
	{
	zvol_state_t *zv;
	int error = 0;
	boolean_t drop_suspend = B_TRUE;

	rw_enter(&zvol_state_lock, RW_READER);
	/*
	* Obtain a copy of private_data under the zvol_state_lock to make
	* sure that either the result of zvol free code path setting
	* bdev->bd_disk->private_data to NULL is observed, or zvol_free()
	* is not called on this zv because of the positive zv_open_count.
	*/
	zv = bdev->bd_disk->private_data;
	if (zv == NULL) {
	rw_exit(&zvol_state_lock);
	return (SET_ERROR(-ENXIO));
	}

	mutex_enter(&zv->zv_state_lock);
	/*
	* make sure zvol is not suspended during first open
	* (hold zv_suspend_lock) and respect proper lock acquisition
	* ordering - zv_suspend_lock before zv_state_lock
	*/
	if (zv->zv_open_count == 0) {
	if (!rw_tryenter(&zv->zv_suspend_lock, RW_READER)) {
	mutex_exit(&zv->zv_state_lock);
	rw_enter(&zv->zv_suspend_lock, RW_READER);
	mutex_enter(&zv->zv_state_lock);
	/* check to see if zv_suspend_lock is needed */
	if (zv->zv_open_count != 0) {
	rw_exit(&zv->zv_suspend_lock);
	drop_suspend = B_FALSE;
	}
	}
	} else {
	drop_suspend = B_FALSE;
	}
	rw_exit(&zvol_state_lock);

	ASSERT(MUTEX_HELD(&zv->zv_state_lock));

	if (zv->zv_open_count == 0) {
	ASSERT(RW_READ_HELD(&zv->zv_suspend_lock));
	error = -zvol_first_open(zv, !(flag & FMODE_WRITE));
	if (error)
	goto out_mutex;
	}

	if ((flag & FMODE_WRITE) && (zv->zv_flags & ZVOL_RDONLY)) {
	error = -EROFS;
	goto out_open_count;
	}

	zv->zv_open_count++;

	mutex_exit(&zv->zv_state_lock);
	if (drop_suspend)
	rw_exit(&zv->zv_suspend_lock);

	zfs_check_media_change(bdev);

	return (0);

	out_open_count:
	if (zv->zv_open_count == 0)
	zvol_last_close(zv);

	out_mutex:
	mutex_exit(&zv->zv_state_lock);
	if (drop_suspend)
	rw_exit(&zv->zv_suspend_lock);
	if (error == -EINTR) {
	error = -ERESTARTSYS;
	schedule();
	}
	return (SET_ERROR(error));
	}

	static void
	zvol_release(struct gendisk *disk, fmode_t mode)
	{
	zvol_state_t *zv;
	boolean_t drop_suspend = B_TRUE;

	rw_enter(&zvol_state_lock, RW_READER);
	zv = disk->private_data;

	mutex_enter(&zv->zv_state_lock);
	ASSERT3U(zv->zv_open_count, >, 0);
	/*
	* make sure zvol is not suspended during last close
	* (hold zv_suspend_lock) and respect proper lock acquisition
	* ordering - zv_suspend_lock before zv_state_lock
	*/
	if (zv->zv_open_count == 1) {
	if (!rw_tryenter(&zv->zv_suspend_lock, RW_READER)) {
	mutex_exit(&zv->zv_state_lock);
	rw_enter(&zv->zv_suspend_lock, RW_READER);
	mutex_enter(&zv->zv_state_lock);
	/* check to see if zv_suspend_lock is needed */
	if (zv->zv_open_count != 1) {
	rw_exit(&zv->zv_suspend_lock);
	drop_suspend = B_FALSE;
	}
	}
	} else {
	drop_suspend = B_FALSE;
	}
	rw_exit(&zvol_state_lock);

	ASSERT(MUTEX_HELD(&zv->zv_state_lock));

	zv->zv_open_count--;
	if (zv->zv_open_count == 0) {
	ASSERT(RW_READ_HELD(&zv->zv_suspend_lock));
	zvol_last_close(zv);
	}

	mutex_exit(&zv->zv_state_lock);

	if (drop_suspend)
	rw_exit(&zv->zv_suspend_lock);
	}

	static int
	zvol_ioctl(struct block_device *bdev, fmode_t mode,
	unsigned int cmd, unsigned long arg)
	{
	zvol_state_t *zv = bdev->bd_disk->private_data;
	int error = 0;

	ASSERT3U(zv->zv_open_count, >, 0);

	switch (cmd) {
	case BLKFLSBUF:
	fsync_bdev(bdev);
	invalidate_bdev(bdev);
	rw_enter(&zv->zv_suspend_lock, RW_READER);

	if (!(zv->zv_flags & ZVOL_RDONLY))
	txg_wait_synced(dmu_objset_pool(zv->zv_objset), 0);

	rw_exit(&zv->zv_suspend_lock);
	break;

	case BLKZNAME:
	mutex_enter(&zv->zv_state_lock);
	error = copy_to_user((void *)arg, zv->zv_name, MAXNAMELEN);
	mutex_exit(&zv->zv_state_lock);
	break;

	default:
	error = -ENOTTY;
	break;
	}

	return (SET_ERROR(error));
	}

	#ifdef CONFIG_COMPAT
	static int
	zvol_compat_ioctl(struct block_device *bdev, fmode_t mode,
	unsigned cmd, unsigned long arg)
	{
	return (zvol_ioctl(bdev, mode, cmd, arg));
	}
	#else
	#define zvol_compat_ioctl NULL
	#endif

	static unsigned int
	zvol_check_events(struct gendisk *disk, unsigned int clearing)
	{
	unsigned int mask = 0;

	rw_enter(&zvol_state_lock, RW_READER);

	zvol_state_t *zv = disk->private_data;
	if (zv != NULL) {
	mutex_enter(&zv->zv_state_lock);
	mask = zv->zv_changed ? DISK_EVENT_MEDIA_CHANGE : 0;
	zv->zv_changed = 0;
	mutex_exit(&zv->zv_state_lock);
	}

	rw_exit(&zvol_state_lock);

	return (mask);
	}

	static int
	zvol_revalidate_disk(struct gendisk *disk)
	{
	rw_enter(&zvol_state_lock, RW_READER);

	zvol_state_t *zv = disk->private_data;
	if (zv != NULL) {
	mutex_enter(&zv->zv_state_lock);
	set_capacity(zv->zv_zso->zvo_disk,
	zv->zv_volsize >> SECTOR_BITS);
	mutex_exit(&zv->zv_state_lock);
	}

	rw_exit(&zvol_state_lock);

	return (0);
	}

	static int
	zvol_update_volsize(zvol_state_t *zv, uint64_t volsize)
	{
	struct gendisk *disk = zv->zv_zso->zvo_disk;

	#if defined(HAVE_REVALIDATE_DISK_SIZE)
	revalidate_disk_size(disk, zvol_revalidate_disk(disk) == 0);
	#elif defined(HAVE_REVALIDATE_DISK)
	revalidate_disk(disk);
	#else
	zvol_revalidate_disk(disk);
	#endif
	return (0);
	}

	static void
	zvol_clear_private(zvol_state_t *zv)
	{
	/*
	* Cleared while holding zvol_state_lock as a writer
	* which will prevent zvol_open() from opening it.
	*/
	zv->zv_zso->zvo_disk->private_data = NULL;
	}

	/*
	* Provide a simple virtual geometry for legacy compatibility. For devices
	* smaller than 1 MiB a small head and sector count is used to allow very
	* tiny devices. For devices over 1 Mib a standard head and sector count
	* is used to keep the cylinders count reasonable.
	*/
	static int
	zvol_getgeo(struct block_device bdev, struct hd_geometry geo)
	{
	zvol_state_t *zv = bdev->bd_disk->private_data;
	sector_t sectors;

	ASSERT3U(zv->zv_open_count, >, 0);

	sectors = get_capacity(zv->zv_zso->zvo_disk);

	if (sectors > 2048) {
	geo->heads = 16;
	geo->sectors = 63;
	} else {
	geo->heads = 2;
	geo->sectors = 4;
	}

	geo->start = 0;
	geo->cylinders = sectors / (geo->heads * geo->sectors);

	return (0);
	}

	static struct block_device_operations zvol_ops = {
	.open = zvol_open,
	.release = zvol_release,
	.ioctl = zvol_ioctl,
	.compat_ioctl = zvol_compat_ioctl,
	.check_events = zvol_check_events,
	+#ifdef HAVE_BLOCK_DEVICE_OPERATIONS_REVALIDATE_DISK
	.revalidate_disk = zvol_revalidate_disk,
	+#endif
	.getgeo = zvol_getgeo,
	.owner = THIS_MODULE,
	#ifdef HAVE_SUBMIT_BIO_IN_BLOCK_DEVICE_OPERATIONS
	.submit_bio = zvol_submit_bio,
	#endif
	};

	/*
	* Allocate memory for a new zvol_state_t and setup the required
	* request queue and generic disk structures for the block device.
	*/
	static zvol_state_t *
	zvol_alloc(dev_t dev, const char *name)
	{
	zvol_state_t *zv;
	struct zvol_state_os *zso;
	uint64_t volmode;

	if (dsl_prop_get_integer(name, "volmode", &volmode, NULL) != 0)
	return (NULL);

	if (volmode == ZFS_VOLMODE_DEFAULT)
	volmode = zvol_volmode;

	if (volmode == ZFS_VOLMODE_NONE)
	return (NULL);

	zv = kmem_zalloc(sizeof (zvol_state_t), KM_SLEEP);
	zso = kmem_zalloc(sizeof (struct zvol_state_os), KM_SLEEP);
	zv->zv_zso = zso;
	zv->zv_volmode = volmode;

	list_link_init(&zv->zv_next);
	mutex_init(&zv->zv_state_lock, NULL, MUTEX_DEFAULT, NULL);

	#ifdef HAVE_SUBMIT_BIO_IN_BLOCK_DEVICE_OPERATIONS
	zso->zvo_queue = blk_alloc_queue(NUMA_NO_NODE);
	#else
	zso->zvo_queue = blk_generic_alloc_queue(zvol_request, NUMA_NO_NODE);
	#endif
	if (zso->zvo_queue == NULL)
	goto out_kmem;

	blk_queue_set_write_cache(zso->zvo_queue, B_TRUE, B_TRUE);

	/* Limit read-ahead to a single page to prevent over-prefetching. */
	blk_queue_set_read_ahead(zso->zvo_queue, 1);

	/* Disable write merging in favor of the ZIO pipeline. */
	blk_queue_flag_set(QUEUE_FLAG_NOMERGES, zso->zvo_queue);

	zso->zvo_disk = alloc_disk(ZVOL_MINORS);
	if (zso->zvo_disk == NULL)
	goto out_queue;

	zso->zvo_queue->queuedata = zv;
	zso->zvo_dev = dev;
	zv->zv_open_count = 0;
	strlcpy(zv->zv_name, name, MAXNAMELEN);

	zfs_rangelock_init(&zv->zv_rangelock, NULL, NULL);
	rw_init(&zv->zv_suspend_lock, NULL, RW_DEFAULT, NULL);

	zso->zvo_disk->major = zvol_major;
	zso->zvo_disk->events = DISK_EVENT_MEDIA_CHANGE;

	if (volmode == ZFS_VOLMODE_DEV) {
	/*
	* ZFS_VOLMODE_DEV disable partitioning on ZVOL devices: set
	* gendisk->minors = 1 as noted in include/linux/genhd.h.
	* Also disable extended partition numbers (GENHD_FL_EXT_DEVT)
	* and suppresses partition scanning (GENHD_FL_NO_PART_SCAN)
	* setting gendisk->flags accordingly.
	*/
	zso->zvo_disk->minors = 1;
	#if defined(GENHD_FL_EXT_DEVT)
	zso->zvo_disk->flags &= ~GENHD_FL_EXT_DEVT;
	#endif
	#if defined(GENHD_FL_NO_PART_SCAN)
	zso->zvo_disk->flags \|= GENHD_FL_NO_PART_SCAN;
	#endif
	}
	zso->zvo_disk->first_minor = (dev & MINORMASK);
	zso->zvo_disk->fops = &zvol_ops;
	zso->zvo_disk->private_data = zv;
	zso->zvo_disk->queue = zso->zvo_queue;
	snprintf(zso->zvo_disk->disk_name, DISK_NAME_LEN, "%s%d",
	ZVOL_DEV_NAME, (dev & MINORMASK));

	return (zv);

	out_queue:
	blk_cleanup_queue(zso->zvo_queue);
	out_kmem:
	kmem_free(zso, sizeof (struct zvol_state_os));
	kmem_free(zv, sizeof (zvol_state_t));
	return (NULL);
	}

	/*
	* Cleanup then free a zvol_state_t which was created by zvol_alloc().
	* At this time, the structure is not opened by anyone, is taken off
	* the zvol_state_list, and has its private data set to NULL.
	* The zvol_state_lock is dropped.
	*
	* This function may take many milliseconds to complete (e.g. we've seen
	* it take over 256ms), due to the calls to "blk_cleanup_queue" and
	* "del_gendisk". Thus, consumers need to be careful to account for this
	* latency when calling this function.
	*/
	static void
	zvol_free(zvol_state_t *zv)
	{

	ASSERT(!RW_LOCK_HELD(&zv->zv_suspend_lock));
	ASSERT(!MUTEX_HELD(&zv->zv_state_lock));
	ASSERT0(zv->zv_open_count);
	ASSERT3P(zv->zv_zso->zvo_disk->private_data, ==, NULL);

	rw_destroy(&zv->zv_suspend_lock);
	zfs_rangelock_fini(&zv->zv_rangelock);

	del_gendisk(zv->zv_zso->zvo_disk);
	blk_cleanup_queue(zv->zv_zso->zvo_queue);
	put_disk(zv->zv_zso->zvo_disk);

	ida_simple_remove(&zvol_ida,
	MINOR(zv->zv_zso->zvo_dev) >> ZVOL_MINOR_BITS);

	mutex_destroy(&zv->zv_state_lock);
	dataset_kstats_destroy(&zv->zv_kstat);

	kmem_free(zv->zv_zso, sizeof (struct zvol_state_os));
	kmem_free(zv, sizeof (zvol_state_t));
	}

	void
	zvol_wait_close(zvol_state_t *zv)
	{
	}

	/*
	* Create a block device minor node and setup the linkage between it
	* and the specified volume. Once this function returns the block
	* device is live and ready for use.
	*/
	static int
	zvol_os_create_minor(const char *name)
	{
	zvol_state_t *zv;
	objset_t *os;
	dmu_object_info_t *doi;
	uint64_t volsize;
	uint64_t len;
	unsigned minor = 0;
	int error = 0;
	int idx;
	uint64_t hash = zvol_name_hash(name);

	if (zvol_inhibit_dev)
	return (0);

	idx = ida_simple_get(&zvol_ida, 0, 0, kmem_flags_convert(KM_SLEEP));
	if (idx < 0)
	return (SET_ERROR(-idx));
	minor = idx << ZVOL_MINOR_BITS;

	zv = zvol_find_by_name_hash(name, hash, RW_NONE);
	if (zv) {
	ASSERT(MUTEX_HELD(&zv->zv_state_lock));
	mutex_exit(&zv->zv_state_lock);
	ida_simple_remove(&zvol_ida, idx);
	return (SET_ERROR(EEXIST));
	}

	doi = kmem_alloc(sizeof (dmu_object_info_t), KM_SLEEP);

	error = dmu_objset_own(name, DMU_OST_ZVOL, B_TRUE, B_TRUE, FTAG, &os);
	if (error)
	goto out_doi;

	error = dmu_object_info(os, ZVOL_OBJ, doi);
	if (error)
	goto out_dmu_objset_disown;

	error = zap_lookup(os, ZVOL_ZAP_OBJ, "size", 8, 1, &volsize);
	if (error)
	goto out_dmu_objset_disown;

	zv = zvol_alloc(MKDEV(zvol_major, minor), name);
	if (zv == NULL) {
	error = SET_ERROR(EAGAIN);
	goto out_dmu_objset_disown;
	}
	zv->zv_hash = hash;

	if (dmu_objset_is_snapshot(os))
	zv->zv_flags \|= ZVOL_RDONLY;

	zv->zv_volblocksize = doi->doi_data_block_size;
	zv->zv_volsize = volsize;
	zv->zv_objset = os;

	set_capacity(zv->zv_zso->zvo_disk, zv->zv_volsize >> 9);

	blk_queue_max_hw_sectors(zv->zv_zso->zvo_queue,
	(DMU_MAX_ACCESS / 4) >> 9);
	blk_queue_max_segments(zv->zv_zso->zvo_queue, UINT16_MAX);
	blk_queue_max_segment_size(zv->zv_zso->zvo_queue, UINT_MAX);
	blk_queue_physical_block_size(zv->zv_zso->zvo_queue,
	zv->zv_volblocksize);
	blk_queue_io_opt(zv->zv_zso->zvo_queue, zv->zv_volblocksize);
	blk_queue_max_discard_sectors(zv->zv_zso->zvo_queue,
	(zvol_max_discard_blocks * zv->zv_volblocksize) >> 9);
	blk_queue_discard_granularity(zv->zv_zso->zvo_queue,
	zv->zv_volblocksize);
	blk_queue_flag_set(QUEUE_FLAG_DISCARD, zv->zv_zso->zvo_queue);
	#ifdef QUEUE_FLAG_NONROT
	blk_queue_flag_set(QUEUE_FLAG_NONROT, zv->zv_zso->zvo_queue);
	#endif
	#ifdef QUEUE_FLAG_ADD_RANDOM
	blk_queue_flag_clear(QUEUE_FLAG_ADD_RANDOM, zv->zv_zso->zvo_queue);
	#endif
	/* This flag was introduced in kernel version 4.12. */
	#ifdef QUEUE_FLAG_SCSI_PASSTHROUGH
	blk_queue_flag_set(QUEUE_FLAG_SCSI_PASSTHROUGH, zv->zv_zso->zvo_queue);
	#endif

	ASSERT3P(zv->zv_zilog, ==, NULL);
	zv->zv_zilog = zil_open(os, zvol_get_data);
	if (spa_writeable(dmu_objset_spa(os))) {
	if (zil_replay_disable)
	zil_destroy(zv->zv_zilog, B_FALSE);
	else
	zil_replay(os, zv, zvol_replay_vector);
	}
	zil_close(zv->zv_zilog);
	zv->zv_zilog = NULL;
	ASSERT3P(zv->zv_kstat.dk_kstats, ==, NULL);
	dataset_kstats_create(&zv->zv_kstat, zv->zv_objset);

	/*
	* When udev detects the addition of the device it will immediately
	* invoke blkid(8) to determine the type of content on the device.
	* Prefetching the blocks commonly scanned by blkid(8) will speed
	* up this process.
	*/
	len = MIN(MAX(zvol_prefetch_bytes, 0), SPA_MAXBLOCKSIZE);
	if (len > 0) {
	dmu_prefetch(os, ZVOL_OBJ, 0, 0, len, ZIO_PRIORITY_SYNC_READ);
	dmu_prefetch(os, ZVOL_OBJ, 0, volsize - len, len,
	ZIO_PRIORITY_SYNC_READ);
	}

	zv->zv_objset = NULL;
	out_dmu_objset_disown:
	dmu_objset_disown(os, B_TRUE, FTAG);
	out_doi:
	kmem_free(doi, sizeof (dmu_object_info_t));

	/*
	* Keep in mind that once add_disk() is called, the zvol is
	* announced to the world, and zvol_open()/zvol_release() can
	* be called at any time. Incidentally, add_disk() itself calls
	* zvol_open()->zvol_first_open() and zvol_release()->zvol_last_close()
	* directly as well.
	*/
	if (error == 0) {
	rw_enter(&zvol_state_lock, RW_WRITER);
	zvol_insert(zv);
	rw_exit(&zvol_state_lock);
	add_disk(zv->zv_zso->zvo_disk);
	} else {
	ida_simple_remove(&zvol_ida, idx);
	}

	return (error);
	}

	static void
	zvol_rename_minor(zvol_state_t zv, const char newname)
	{
	int readonly = get_disk_ro(zv->zv_zso->zvo_disk);

	ASSERT(RW_LOCK_HELD(&zvol_state_lock));
	ASSERT(MUTEX_HELD(&zv->zv_state_lock));

	strlcpy(zv->zv_name, newname, sizeof (zv->zv_name));

	/* move to new hashtable entry */
	zv->zv_hash = zvol_name_hash(zv->zv_name);
	hlist_del(&zv->zv_hlink);
	hlist_add_head(&zv->zv_hlink, ZVOL_HT_HEAD(zv->zv_hash));

	/*
	* The block device's read-only state is briefly changed causing
	* a KOBJ_CHANGE uevent to be issued. This ensures udev detects
	* the name change and fixes the symlinks. This does not change
	* ZVOL_RDONLY in zv->zv_flags so the actual read-only state never
	* changes. This would normally be done using kobject_uevent() but
	* that is a GPL-only symbol which is why we need this workaround.
	*/
	set_disk_ro(zv->zv_zso->zvo_disk, !readonly);
	set_disk_ro(zv->zv_zso->zvo_disk, readonly);
	}

	static void
	zvol_set_disk_ro_impl(zvol_state_t *zv, int flags)
	{

	set_disk_ro(zv->zv_zso->zvo_disk, flags);
	}

	static void
	zvol_set_capacity_impl(zvol_state_t *zv, uint64_t capacity)
	{

	set_capacity(zv->zv_zso->zvo_disk, capacity);
	}

	const static zvol_platform_ops_t zvol_linux_ops = {
	.zv_free = zvol_free,
	.zv_rename_minor = zvol_rename_minor,
	.zv_create_minor = zvol_os_create_minor,
	.zv_update_volsize = zvol_update_volsize,
	.zv_clear_private = zvol_clear_private,
	.zv_is_zvol = zvol_is_zvol_impl,
	.zv_set_disk_ro = zvol_set_disk_ro_impl,
	.zv_set_capacity = zvol_set_capacity_impl,
	};

	int
	zvol_init(void)
	{
	int error;
	int threads = MIN(MAX(zvol_threads, 1), 1024);

	error = register_blkdev(zvol_major, ZVOL_DRIVER);
	if (error) {
	printk(KERN_INFO "ZFS: register_blkdev() failed %d\n", error);
	return (error);
	}
	zvol_taskq = taskq_create(ZVOL_DRIVER, threads, maxclsyspri,
	threads * 2, INT_MAX, TASKQ_PREPOPULATE \| TASKQ_DYNAMIC);
	if (zvol_taskq == NULL) {
	unregister_blkdev(zvol_major, ZVOL_DRIVER);
	return (-ENOMEM);
	}
	zvol_init_impl();
	ida_init(&zvol_ida);
	zvol_register_ops(&zvol_linux_ops);
	return (0);
	}

	void
	zvol_fini(void)
	{
	zvol_fini_impl();
	unregister_blkdev(zvol_major, ZVOL_DRIVER);
	taskq_destroy(zvol_taskq);
	ida_destroy(&zvol_ida);
	}

	/* BEGIN CSTYLED */
	module_param(zvol_inhibit_dev, uint, 0644);
	MODULE_PARM_DESC(zvol_inhibit_dev, "Do not create zvol device nodes");

	module_param(zvol_major, uint, 0444);
	MODULE_PARM_DESC(zvol_major, "Major number for zvol device");

	module_param(zvol_threads, uint, 0444);
	MODULE_PARM_DESC(zvol_threads, "Max number of threads to handle I/O requests");

	module_param(zvol_request_sync, uint, 0644);
	MODULE_PARM_DESC(zvol_request_sync, "Synchronously handle bio requests");

	module_param(zvol_max_discard_blocks, ulong, 0444);
	MODULE_PARM_DESC(zvol_max_discard_blocks, "Max number of blocks to discard");

	module_param(zvol_prefetch_bytes, uint, 0644);
	MODULE_PARM_DESC(zvol_prefetch_bytes, "Prefetch N bytes at zvol start+end");

	module_param(zvol_volmode, uint, 0644);
	MODULE_PARM_DESC(zvol_volmode, "Default volmode property value");
	/* END CSTYLED */
	diff --git a/sys/contrib/openzfs/module/unicode/u8_textprep.c b/sys/contrib/openzfs/module/unicode/u8_textprep.c
	index be816d728359..c1d9a325f511 100644
	--- a/sys/contrib/openzfs/module/unicode/u8_textprep.c
	+++ b/sys/contrib/openzfs/module/unicode/u8_textprep.c
	@@ -1,2151 +1,2151 @@
	/*
	* 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 2008 Sun Microsystems, Inc. All rights reserved.
	* Use is subject to license terms.
	*/




	/*
	* UTF-8 text preparation functions (PSARC/2007/149, PSARC/2007/458).
	*
	* Man pages: u8_textprep_open(9F), u8_textprep_buf(9F), u8_textprep_close(9F),
	* u8_textprep_str(9F), u8_strcmp(9F), and u8_validate(9F). See also
	* the section 3C man pages.
	* Interface stability: Committed.
	*/

	#include <sys/types.h>
	#include <sys/strings.h>
	#include <sys/param.h>
	#include <sys/sysmacros.h>
	#include <sys/debug.h>
	#include <sys/kmem.h>
	#include <sys/sunddi.h>
	#include <sys/u8_textprep.h>
	#include <sys/byteorder.h>
	#include <sys/errno.h>
	#include <sys/u8_textprep_data.h>
	#include <sys/mod.h>

	/* The maximum possible number of bytes in a UTF-8 character. */
	#define U8_MB_CUR_MAX (4)

	/*
	* The maximum number of bytes needed for a UTF-8 character to cover
	* U+0000 - U+FFFF, i.e., the coding space of now deprecated UCS-2.
	*/
	#define U8_MAX_BYTES_UCS2 (3)

	/* The maximum possible number of bytes in a Stream-Safe Text. */
	#define U8_STREAM_SAFE_TEXT_MAX (128)

	/*
	* The maximum number of characters in a combining/conjoining sequence and
	* the actual upperbound limit of a combining/conjoining sequence.
	*/
	#define U8_MAX_CHARS_A_SEQ (32)
	#define U8_UPPER_LIMIT_IN_A_SEQ (31)

	/* The combining class value for Starter. */
	#define U8_COMBINING_CLASS_STARTER (0)

	/*
	* Some Hangul related macros at below.
	*
	* The first and the last of Hangul syllables, Hangul Jamo Leading consonants,
	* Vowels, and optional Trailing consonants in Unicode scalar values.
	*
	* Please be noted that the U8_HANGUL_JAMO_T_FIRST is 0x11A7 at below not
	* the actual U+11A8. This is due to that the trailing consonant is optional
	* and thus we are doing a pre-calculation of subtracting one.
	*
	* Each of 19 modern leading consonants has total 588 possible syllables since
	* Hangul has 21 modern vowels and 27 modern trailing consonants plus 1 for
	* no trailing consonant case, i.e., 21 x 28 = 588.
	*
	* We also have bunch of Hangul related macros at below. Please bear in mind
	* that the U8_HANGUL_JAMO_1ST_BYTE can be used to check whether it is
	* a Hangul Jamo or not but the value does not guarantee that it is a Hangul
	* Jamo; it just guarantee that it will be most likely.
	*/
	#define U8_HANGUL_SYL_FIRST (0xAC00U)
	#define U8_HANGUL_SYL_LAST (0xD7A3U)

	#define U8_HANGUL_JAMO_L_FIRST (0x1100U)
	#define U8_HANGUL_JAMO_L_LAST (0x1112U)
	#define U8_HANGUL_JAMO_V_FIRST (0x1161U)
	#define U8_HANGUL_JAMO_V_LAST (0x1175U)
	#define U8_HANGUL_JAMO_T_FIRST (0x11A7U)
	#define U8_HANGUL_JAMO_T_LAST (0x11C2U)

	#define U8_HANGUL_V_COUNT (21)
	#define U8_HANGUL_VT_COUNT (588)
	#define U8_HANGUL_T_COUNT (28)

	#define U8_HANGUL_JAMO_1ST_BYTE (0xE1U)

	#define U8_SAVE_HANGUL_AS_UTF8(s, i, j, k, b) \
	(s)[(i)] = (uchar_t)(0xE0U \| ((uint32_t)(b) & 0xF000U) >> 12); \
	(s)[(j)] = (uchar_t)(0x80U \| ((uint32_t)(b) & 0x0FC0U) >> 6); \
	(s)[(k)] = (uchar_t)(0x80U \| ((uint32_t)(b) & 0x003FU));

	#define U8_HANGUL_JAMO_L(u) \
	((u) >= U8_HANGUL_JAMO_L_FIRST && (u) <= U8_HANGUL_JAMO_L_LAST)

	#define U8_HANGUL_JAMO_V(u) \
	((u) >= U8_HANGUL_JAMO_V_FIRST && (u) <= U8_HANGUL_JAMO_V_LAST)

	#define U8_HANGUL_JAMO_T(u) \
	((u) > U8_HANGUL_JAMO_T_FIRST && (u) <= U8_HANGUL_JAMO_T_LAST)

	#define U8_HANGUL_JAMO(u) \
	((u) >= U8_HANGUL_JAMO_L_FIRST && (u) <= U8_HANGUL_JAMO_T_LAST)

	#define U8_HANGUL_SYLLABLE(u) \
	((u) >= U8_HANGUL_SYL_FIRST && (u) <= U8_HANGUL_SYL_LAST)

	#define U8_HANGUL_COMPOSABLE_L_V(s, u) \
	((s) == U8_STATE_HANGUL_L && U8_HANGUL_JAMO_V((u)))

	#define U8_HANGUL_COMPOSABLE_LV_T(s, u) \
	((s) == U8_STATE_HANGUL_LV && U8_HANGUL_JAMO_T((u)))

	/* The types of decomposition mappings. */
	#define U8_DECOMP_BOTH (0xF5U)
	#define U8_DECOMP_CANONICAL (0xF6U)

	/* The indicator for 16-bit table. */
	#define U8_16BIT_TABLE_INDICATOR (0x8000U)

	/* The following are some convenience macros. */
	#define U8_PUT_3BYTES_INTO_UTF32(u, b1, b2, b3) \
	(u) = ((((uint32_t)(b1) & 0x0F) << 12) \| \
	(((uint32_t)(b2) & 0x3F) << 6) \| \
	((uint32_t)(b3) & 0x3F));

	#define U8_SIMPLE_SWAP(a, b, t) \
	(t) = (a); \
	(a) = (b); \
	(b) = (t);

	#define U8_ASCII_TOUPPER(c) \
	(((c) >= 'a' && (c) <= 'z') ? (c) - 'a' + 'A' : (c))

	#define U8_ASCII_TOLOWER(c) \
	(((c) >= 'A' && (c) <= 'Z') ? (c) - 'A' + 'a' : (c))

	#define U8_ISASCII(c) (((uchar_t)(c)) < 0x80U)
	/*
	* The following macro assumes that the two characters that are to be
	* swapped are adjacent to each other and 'a' comes before 'b'.
	*
	* If the assumptions are not met, then, the macro will fail.
	*/
	#define U8_SWAP_COMB_MARKS(a, b) \
	for (k = 0; k < disp[(a)]; k++) \
	u8t[k] = u8s[start[(a)] + k]; \
	for (k = 0; k < disp[(b)]; k++) \
	u8s[start[(a)] + k] = u8s[start[(b)] + k]; \
	start[(b)] = start[(a)] + disp[(b)]; \
	for (k = 0; k < disp[(a)]; k++) \
	u8s[start[(b)] + k] = u8t[k]; \
	U8_SIMPLE_SWAP(comb_class[(a)], comb_class[(b)], tc); \
	U8_SIMPLE_SWAP(disp[(a)], disp[(b)], tc);

	/* The possible states during normalization. */
	typedef enum {
	U8_STATE_START = 0,
	U8_STATE_HANGUL_L = 1,
	U8_STATE_HANGUL_LV = 2,
	U8_STATE_HANGUL_LVT = 3,
	U8_STATE_HANGUL_V = 4,
	U8_STATE_HANGUL_T = 5,
	U8_STATE_COMBINING_MARK = 6
	} u8_normalization_states_t;

	/*
	* The three vectors at below are used to check bytes of a given UTF-8
	* character are valid and not containing any malformed byte values.
	*
	* We used to have a quite relaxed UTF-8 binary representation but then there
	* was some security related issues and so the Unicode Consortium defined
	* and announced the UTF-8 Corrigendum at Unicode 3.1 and then refined it
	* one more time at the Unicode 3.2. The following three tables are based on
	* that.
	*/

	#define U8_ILLEGAL_NEXT_BYTE_COMMON(c) ((c) < 0x80 \|\| (c) > 0xBF)

	#define I_ U8_ILLEGAL_CHAR
	#define O_ U8_OUT_OF_RANGE_CHAR

	const int8_t u8_number_of_bytes[0x100] = {
	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

	/* 80 81 82 83 84 85 86 87 88 89 8A 8B 8C 8D 8E 8F */
	I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_,

	/* 90 91 92 93 94 95 96 97 98 99 9A 9B 9C 9D 9E 9F */
	I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_,

	/* A0 A1 A2 A3 A4 A5 A6 A7 A8 A9 AA AB AC AD AE AF */
	I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_,

	/* B0 B1 B2 B3 B4 B5 B6 B7 B8 B9 BA BB BC BD BE BF */
	I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_, I_,

	/* C0 C1 C2 C3 C4 C5 C6 C7 C8 C9 CA CB CC CD CE CF */
	I_, I_, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

	/* D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 DA DB DC DD DE DF */
	2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

	/* E0 E1 E2 E3 E4 E5 E6 E7 E8 E9 EA EB EC ED EE EF */
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,

	/* F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 FA FB FC FD FE FF */
	4, 4, 4, 4, 4, O_, O_, O_, O_, O_, O_, O_, O_, O_, O_, O_,
	};

	#undef I_
	#undef O_

	const uint8_t u8_valid_min_2nd_byte[0x100] = {
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	/* C0 C1 C2 C3 C4 C5 C6 C7 */
	0, 0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
	/* C8 C9 CA CB CC CD CE CF */
	0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
	/* D0 D1 D2 D3 D4 D5 D6 D7 */
	0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
	/* D8 D9 DA DB DC DD DE DF */
	0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
	/* E0 E1 E2 E3 E4 E5 E6 E7 */
	0xa0, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
	/* E8 E9 EA EB EC ED EE EF */
	0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
	/* F0 F1 F2 F3 F4 F5 F6 F7 */
	0x90, 0x80, 0x80, 0x80, 0x80, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	};

	const uint8_t u8_valid_max_2nd_byte[0x100] = {
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	/* C0 C1 C2 C3 C4 C5 C6 C7 */
	0, 0, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
	/* C8 C9 CA CB CC CD CE CF */
	0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
	/* D0 D1 D2 D3 D4 D5 D6 D7 */
	0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
	/* D8 D9 DA DB DC DD DE DF */
	0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
	/* E0 E1 E2 E3 E4 E5 E6 E7 */
	0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0xbf,
	/* E8 E9 EA EB EC ED EE EF */
	0xbf, 0xbf, 0xbf, 0xbf, 0xbf, 0x9f, 0xbf, 0xbf,
	/* F0 F1 F2 F3 F4 F5 F6 F7 */
	0xbf, 0xbf, 0xbf, 0xbf, 0x8f, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0,
	};


	/*
	* The u8_validate() validates on the given UTF-8 character string and
	* calculate the byte length. It is quite similar to mblen(3C) except that
	* this will validate against the list of characters if required and
	* specific to UTF-8 and Unicode.
	*/
	int
	u8_validate(const char u8str, size_t n, char list, int flag, int errnum)
	{
	uchar_t *ib;
	uchar_t *ibtail;
	uchar_t **p;
	uchar_t *s1;
	uchar_t *s2;
	uchar_t f;
	int sz;
	size_t i;
	int ret_val;
	boolean_t second;
	boolean_t no_need_to_validate_entire;
	boolean_t check_additional;
	boolean_t validate_ucs2_range_only;

	if (! u8str)
	return (0);

	ib = (uchar_t *)u8str;
	ibtail = ib + n;

	ret_val = 0;

	no_need_to_validate_entire = ! (flag & U8_VALIDATE_ENTIRE);
	check_additional = flag & U8_VALIDATE_CHECK_ADDITIONAL;
	validate_ucs2_range_only = flag & U8_VALIDATE_UCS2_RANGE;

	while (ib < ibtail) {
	/*
	* The first byte of a UTF-8 character tells how many
	* bytes will follow for the character. If the first byte
	* is an illegal byte value or out of range value, we just
	* return -1 with an appropriate error number.
	*/
	sz = u8_number_of_bytes[*ib];
	if (sz == U8_ILLEGAL_CHAR) {
	*errnum = EILSEQ;
	return (-1);
	}

	if (sz == U8_OUT_OF_RANGE_CHAR \|\|
	(validate_ucs2_range_only && sz > U8_MAX_BYTES_UCS2)) {
	*errnum = ERANGE;
	return (-1);
	}

	/*
	* If we don't have enough bytes to check on, that's also
	* an error. As you can see, we give illegal byte sequence
	* checking higher priority then EINVAL cases.
	*/
	if ((ibtail - ib) < sz) {
	*errnum = EINVAL;
	return (-1);
	}

	if (sz == 1) {
	ib++;
	ret_val++;
	} else {
	/*
	* Check on the multi-byte UTF-8 character. For more
	* details on this, see comment added for the used
	* data structures at the beginning of the file.
	*/
	f = *ib++;
	ret_val++;
	second = B_TRUE;
	for (i = 1; i < sz; i++) {
	if (second) {
	if (*ib < u8_valid_min_2nd_byte[f] \|\|
	*ib > u8_valid_max_2nd_byte[f]) {
	*errnum = EILSEQ;
	return (-1);
	}
	second = B_FALSE;
	} else if (U8_ILLEGAL_NEXT_BYTE_COMMON(*ib)) {
	*errnum = EILSEQ;
	return (-1);
	}
	ib++;
	ret_val++;
	}
	}

	if (check_additional) {
	for (p = (uchar_t **)list, i = 0; p[i]; i++) {
	s1 = ib - sz;
	s2 = p[i];
	while (s1 < ib) {
	if (s1 != s2 \|\| *s2 == '\0')
	break;
	s1++;
	s2++;
	}

	if (s1 >= ib && *s2 == '\0') {
	*errnum = EBADF;
	return (-1);
	}
	}
	}

	if (no_need_to_validate_entire)
	break;
	}

	return (ret_val);
	}

	/*
	* The do_case_conv() looks at the mapping tables and returns found
	* bytes if any. If not found, the input bytes are returned. The function
	* always terminate the return bytes with a null character assuming that
	* there are plenty of room to do so.
	*
	* The case conversions are simple case conversions mapping a character to
	* another character as specified in the Unicode data. The byte size of
	* the mapped character could be different from that of the input character.
	*
	* The return value is the byte length of the returned character excluding
	* the terminating null byte.
	*/
	static size_t
	do_case_conv(int uv, uchar_t u8s, uchar_t s, int sz, boolean_t is_it_toupper)
	{
	size_t i;
	uint16_t b1 = 0;
	uint16_t b2 = 0;
	uint16_t b3 = 0;
	uint16_t b3_tbl;
	uint16_t b3_base;
	uint16_t b4 = 0;
	size_t start_id;
	size_t end_id;

	/*
	* At this point, the only possible values for sz are 2, 3, and 4.
	* The u8s should point to a vector that is well beyond the size of
	* 5 bytes.
	*/
	if (sz == 2) {
	b3 = u8s[0] = s[0];
	b4 = u8s[1] = s[1];
	} else if (sz == 3) {
	b2 = u8s[0] = s[0];
	b3 = u8s[1] = s[1];
	b4 = u8s[2] = s[2];
	} else if (sz == 4) {
	b1 = u8s[0] = s[0];
	b2 = u8s[1] = s[1];
	b3 = u8s[2] = s[2];
	b4 = u8s[3] = s[3];
	} else {
	/* This is not possible but just in case as a fallback. */
	if (is_it_toupper)
	u8s = U8_ASCII_TOUPPER(s);
	else
	u8s = U8_ASCII_TOLOWER(s);
	u8s[1] = '\0';

	return (1);
	}
	u8s[sz] = '\0';

	/*
	* Let's find out if we have a corresponding character.
	*/
	b1 = u8_common_b1_tbl[uv][b1];
	if (b1 == U8_TBL_ELEMENT_NOT_DEF)
	return ((size_t)sz);

	b2 = u8_case_common_b2_tbl[uv][b1][b2];
	if (b2 == U8_TBL_ELEMENT_NOT_DEF)
	return ((size_t)sz);

	if (is_it_toupper) {
	b3_tbl = u8_toupper_b3_tbl[uv][b2][b3].tbl_id;
	if (b3_tbl == U8_TBL_ELEMENT_NOT_DEF)
	return ((size_t)sz);

	start_id = u8_toupper_b4_tbl[uv][b3_tbl][b4];
	end_id = u8_toupper_b4_tbl[uv][b3_tbl][b4 + 1];

	/* Either there is no match or an error at the table. */
	if (start_id >= end_id \|\| (end_id - start_id) > U8_MB_CUR_MAX)
	return ((size_t)sz);

	b3_base = u8_toupper_b3_tbl[uv][b2][b3].base;

	for (i = 0; start_id < end_id; start_id++)
	u8s[i++] = u8_toupper_final_tbl[uv][b3_base + start_id];
	} else {
	b3_tbl = u8_tolower_b3_tbl[uv][b2][b3].tbl_id;
	if (b3_tbl == U8_TBL_ELEMENT_NOT_DEF)
	return ((size_t)sz);

	start_id = u8_tolower_b4_tbl[uv][b3_tbl][b4];
	end_id = u8_tolower_b4_tbl[uv][b3_tbl][b4 + 1];

	if (start_id >= end_id \|\| (end_id - start_id) > U8_MB_CUR_MAX)
	return ((size_t)sz);

	b3_base = u8_tolower_b3_tbl[uv][b2][b3].base;

	for (i = 0; start_id < end_id; start_id++)
	u8s[i++] = u8_tolower_final_tbl[uv][b3_base + start_id];
	}

	/*
	* If i is still zero, that means there is no corresponding character.
	*/
	if (i == 0)
	return ((size_t)sz);

	u8s[i] = '\0';

	return (i);
	}

	/*
	* The do_case_compare() function compares the two input strings, s1 and s2,
	* one character at a time doing case conversions if applicable and return
	* the comparison result as like strcmp().
	*
	* Since, in empirical sense, most of text data are 7-bit ASCII characters,
	* we treat the 7-bit ASCII characters as a special case trying to yield
	* faster processing time.
	*/
	static int
	do_case_compare(size_t uv, uchar_t s1, uchar_t s2, size_t n1,
	size_t n2, boolean_t is_it_toupper, int *errnum)
	{
	int f;
	int sz1;
	int sz2;
	size_t j;
	size_t i1;
	size_t i2;
	uchar_t u8s1[U8_MB_CUR_MAX + 1];
	uchar_t u8s2[U8_MB_CUR_MAX + 1];

	i1 = i2 = 0;
	while (i1 < n1 && i2 < n2) {
	/*
	* Find out what would be the byte length for this UTF-8
	* character at string s1 and also find out if this is
	* an illegal start byte or not and if so, issue a proper
	* error number and yet treat this byte as a character.
	*/
	sz1 = u8_number_of_bytes[*s1];
	if (sz1 < 0) {
	*errnum = EILSEQ;
	sz1 = 1;
	}

	/*
	* For 7-bit ASCII characters mainly, we do a quick case
	* conversion right at here.
	*
	* If we don't have enough bytes for this character, issue
	* an EINVAL error and use what are available.
	*
	* If we have enough bytes, find out if there is
	* a corresponding uppercase character and if so, copy over
	* the bytes for a comparison later. If there is no
	* corresponding uppercase character, then, use what we have
	* for the comparison.
	*/
	if (sz1 == 1) {
	if (is_it_toupper)
	u8s1[0] = U8_ASCII_TOUPPER(*s1);
	else
	u8s1[0] = U8_ASCII_TOLOWER(*s1);
	s1++;
	u8s1[1] = '\0';
	} else if ((i1 + sz1) > n1) {
	*errnum = EINVAL;
	for (j = 0; (i1 + j) < n1; )
	u8s1[j++] = *s1++;
	u8s1[j] = '\0';
	} else {
	(void) do_case_conv(uv, u8s1, s1, sz1, is_it_toupper);
	s1 += sz1;
	}

	/* Do the same for the string s2. */
	sz2 = u8_number_of_bytes[*s2];
	if (sz2 < 0) {
	*errnum = EILSEQ;
	sz2 = 1;
	}

	if (sz2 == 1) {
	if (is_it_toupper)
	u8s2[0] = U8_ASCII_TOUPPER(*s2);
	else
	u8s2[0] = U8_ASCII_TOLOWER(*s2);
	s2++;
	u8s2[1] = '\0';
	} else if ((i2 + sz2) > n2) {
	*errnum = EINVAL;
	for (j = 0; (i2 + j) < n2; )
	u8s2[j++] = *s2++;
	u8s2[j] = '\0';
	} else {
	(void) do_case_conv(uv, u8s2, s2, sz2, is_it_toupper);
	s2 += sz2;
	}

	/* Now compare the two characters. */
	if (sz1 == 1 && sz2 == 1) {
	if (u8s1 > u8s2)
	return (1);
	if (u8s1 < u8s2)
	return (-1);
	} else {
	f = strcmp((const char )u8s1, (const char )u8s2);
	if (f != 0)
	return (f);
	}

	/*
	* They were the same. Let's move on to the next
	* characters then.
	*/
	i1 += sz1;
	i2 += sz2;
	}

	/*
	* We compared until the end of either or both strings.
	*
	* If we reached to or went over the ends for the both, that means
	* they are the same.
	*
	* If we reached only one of the two ends, that means the other string
	* has something which then the fact can be used to determine
	* the return value.
	*/
	if (i1 >= n1) {
	if (i2 >= n2)
	return (0);
	return (-1);
	}
	return (1);
	}

	/*
	* The combining_class() function checks on the given bytes and find out
	* the corresponding Unicode combining class value. The return value 0 means
	* it is a Starter. Any illegal UTF-8 character will also be treated as
	* a Starter.
	*/
	static uchar_t
	combining_class(size_t uv, uchar_t *s, size_t sz)
	{
	uint16_t b1 = 0;
	uint16_t b2 = 0;
	uint16_t b3 = 0;
	uint16_t b4 = 0;

	if (sz == 1 \|\| sz > 4)
	return (0);

	if (sz == 2) {
	b3 = s[0];
	b4 = s[1];
	} else if (sz == 3) {
	b2 = s[0];
	b3 = s[1];
	b4 = s[2];
	} else if (sz == 4) {
	b1 = s[0];
	b2 = s[1];
	b3 = s[2];
	b4 = s[3];
	}

	b1 = u8_common_b1_tbl[uv][b1];
	if (b1 == U8_TBL_ELEMENT_NOT_DEF)
	return (0);

	b2 = u8_combining_class_b2_tbl[uv][b1][b2];
	if (b2 == U8_TBL_ELEMENT_NOT_DEF)
	return (0);

	b3 = u8_combining_class_b3_tbl[uv][b2][b3];
	if (b3 == U8_TBL_ELEMENT_NOT_DEF)
	return (0);

	return (u8_combining_class_b4_tbl[uv][b3][b4]);
	}

	/*
	* The do_decomp() function finds out a matching decomposition if any
	* and return. If there is no match, the input bytes are copied and returned.
	* The function also checks if there is a Hangul, decomposes it if necessary
	* and returns.
	*
	* To save time, a single byte 7-bit ASCII character should be handled by
	* the caller.
	*
	* The function returns the number of bytes returned sans always terminating
	* the null byte. It will also return a state that will tell if there was
	* a Hangul character decomposed which then will be used by the caller.
	*/
	static size_t
	do_decomp(size_t uv, uchar_t u8s, uchar_t s, int sz,
	boolean_t canonical_decomposition, u8_normalization_states_t *state)
	{
	uint16_t b1 = 0;
	uint16_t b2 = 0;
	uint16_t b3 = 0;
	uint16_t b3_tbl;
	uint16_t b3_base;
	uint16_t b4 = 0;
	size_t start_id;
	size_t end_id;
	size_t i;
	uint32_t u1;

	if (sz == 2) {
	b3 = u8s[0] = s[0];
	b4 = u8s[1] = s[1];
	u8s[2] = '\0';
	} else if (sz == 3) {
	/* Convert it to a Unicode scalar value. */
	U8_PUT_3BYTES_INTO_UTF32(u1, s[0], s[1], s[2]);

	/*
	* If this is a Hangul syllable, we decompose it into
	* a leading consonant, a vowel, and an optional trailing
	* consonant and then return.
	*/
	if (U8_HANGUL_SYLLABLE(u1)) {
	u1 -= U8_HANGUL_SYL_FIRST;

	b1 = U8_HANGUL_JAMO_L_FIRST + u1 / U8_HANGUL_VT_COUNT;
	b2 = U8_HANGUL_JAMO_V_FIRST + (u1 % U8_HANGUL_VT_COUNT)
	/ U8_HANGUL_T_COUNT;
	b3 = u1 % U8_HANGUL_T_COUNT;

	U8_SAVE_HANGUL_AS_UTF8(u8s, 0, 1, 2, b1);
	U8_SAVE_HANGUL_AS_UTF8(u8s, 3, 4, 5, b2);
	if (b3) {
	b3 += U8_HANGUL_JAMO_T_FIRST;
	U8_SAVE_HANGUL_AS_UTF8(u8s, 6, 7, 8, b3);

	u8s[9] = '\0';
	*state = U8_STATE_HANGUL_LVT;
	return (9);
	}

	u8s[6] = '\0';
	*state = U8_STATE_HANGUL_LV;
	return (6);
	}

	b2 = u8s[0] = s[0];
	b3 = u8s[1] = s[1];
	b4 = u8s[2] = s[2];
	u8s[3] = '\0';

	/*
	* If this is a Hangul Jamo, we know there is nothing
	* further that we can decompose.
	*/
	if (U8_HANGUL_JAMO_L(u1)) {
	*state = U8_STATE_HANGUL_L;
	return (3);
	}

	if (U8_HANGUL_JAMO_V(u1)) {
	if (*state == U8_STATE_HANGUL_L)
	*state = U8_STATE_HANGUL_LV;
	else
	*state = U8_STATE_HANGUL_V;
	return (3);
	}

	if (U8_HANGUL_JAMO_T(u1)) {
	if (*state == U8_STATE_HANGUL_LV)
	*state = U8_STATE_HANGUL_LVT;
	else
	*state = U8_STATE_HANGUL_T;
	return (3);
	}
	} else if (sz == 4) {
	b1 = u8s[0] = s[0];
	b2 = u8s[1] = s[1];
	b3 = u8s[2] = s[2];
	b4 = u8s[3] = s[3];
	u8s[4] = '\0';
	} else {
	/*
	* This is a fallback and should not happen if the function
	* was called properly.
	*/
	u8s[0] = s[0];
	u8s[1] = '\0';
	*state = U8_STATE_START;
	return (1);
	}

	/*
	* At this point, this routine does not know what it would get.
	* The caller should sort it out if the state isn't a Hangul one.
	*/
	*state = U8_STATE_START;

	/* Try to find matching decomposition mapping byte sequence. */
	b1 = u8_common_b1_tbl[uv][b1];
	if (b1 == U8_TBL_ELEMENT_NOT_DEF)
	return ((size_t)sz);

	b2 = u8_decomp_b2_tbl[uv][b1][b2];
	if (b2 == U8_TBL_ELEMENT_NOT_DEF)
	return ((size_t)sz);

	b3_tbl = u8_decomp_b3_tbl[uv][b2][b3].tbl_id;
	if (b3_tbl == U8_TBL_ELEMENT_NOT_DEF)
	return ((size_t)sz);

	/*
	* If b3_tbl is bigger than or equal to U8_16BIT_TABLE_INDICATOR
	* which is 0x8000, this means we couldn't fit the mappings into
	* the cardinality of a unsigned byte.
	*/
	if (b3_tbl >= U8_16BIT_TABLE_INDICATOR) {
	b3_tbl -= U8_16BIT_TABLE_INDICATOR;
	start_id = u8_decomp_b4_16bit_tbl[uv][b3_tbl][b4];
	end_id = u8_decomp_b4_16bit_tbl[uv][b3_tbl][b4 + 1];
	} else {
	start_id = u8_decomp_b4_tbl[uv][b3_tbl][b4];
	end_id = u8_decomp_b4_tbl[uv][b3_tbl][b4 + 1];
	}

	/* This also means there wasn't any matching decomposition. */
	if (start_id >= end_id)
	return ((size_t)sz);

	/*
	* The final table for decomposition mappings has three types of
	* byte sequences depending on whether a mapping is for compatibility
	* decomposition, canonical decomposition, or both like the following:
	*
	* (1) Compatibility decomposition mappings:
	*
	* +---+---+-...-+---+
	* \| B0\| B1\| ... \| Bm\|
	* +---+---+-...-+---+
	*
	- * The first byte, B0, is always less then 0xF5 (U8_DECOMP_BOTH).
	+ * The first byte, B0, is always less than 0xF5 (U8_DECOMP_BOTH).
	*
	* (2) Canonical decomposition mappings:
	*
	* +---+---+---+-...-+---+
	* \| T \| b0\| b1\| ... \| bn\|
	* +---+---+---+-...-+---+
	*
	* where the first byte, T, is 0xF6 (U8_DECOMP_CANONICAL).
	*
	* (3) Both mappings:
	*
	* +---+---+---+---+-...-+---+---+---+-...-+---+
	* \| T \| D \| b0\| b1\| ... \| bn\| B0\| B1\| ... \| Bm\|
	* +---+---+---+---+-...-+---+---+---+-...-+---+
	*
	* where T is 0xF5 (U8_DECOMP_BOTH) and D is a displacement
	* byte, b0 to bn are canonical mapping bytes and B0 to Bm are
	* compatibility mapping bytes.
	*
	* Note that compatibility decomposition means doing recursive
	* decompositions using both compatibility decomposition mappings and
	* canonical decomposition mappings. On the other hand, canonical
	* decomposition means doing recursive decompositions using only
	* canonical decomposition mappings. Since the table we have has gone
	* through the recursions already, we do not need to do so during
	* runtime, i.e., the table has been completely flattened out
	* already.
	*/

	b3_base = u8_decomp_b3_tbl[uv][b2][b3].base;

	/* Get the type, T, of the byte sequence. */
	b1 = u8_decomp_final_tbl[uv][b3_base + start_id];

	/*
	* If necessary, adjust start_id, end_id, or both. Note that if
	* this is compatibility decomposition mapping, there is no
	* adjustment.
	*/
	if (canonical_decomposition) {
	/* Is the mapping only for compatibility decomposition? */
	if (b1 < U8_DECOMP_BOTH)
	return ((size_t)sz);

	start_id++;

	if (b1 == U8_DECOMP_BOTH) {
	end_id = start_id +
	u8_decomp_final_tbl[uv][b3_base + start_id];
	start_id++;
	}
	} else {
	/*
	* Unless this is a compatibility decomposition mapping,
	* we adjust the start_id.
	*/
	if (b1 == U8_DECOMP_BOTH) {
	start_id++;
	start_id += u8_decomp_final_tbl[uv][b3_base + start_id];
	} else if (b1 == U8_DECOMP_CANONICAL) {
	start_id++;
	}
	}

	for (i = 0; start_id < end_id; start_id++)
	u8s[i++] = u8_decomp_final_tbl[uv][b3_base + start_id];
	u8s[i] = '\0';

	return (i);
	}

	/*
	* The find_composition_start() function uses the character bytes given and
	* find out the matching composition mappings if any and return the address
	* to the composition mappings as explained in the do_composition().
	*/
	static uchar_t *
	find_composition_start(size_t uv, uchar_t *s, size_t sz)
	{
	uint16_t b1 = 0;
	uint16_t b2 = 0;
	uint16_t b3 = 0;
	uint16_t b3_tbl;
	uint16_t b3_base;
	uint16_t b4 = 0;
	size_t start_id;
	size_t end_id;

	if (sz == 1) {
	b4 = s[0];
	} else if (sz == 2) {
	b3 = s[0];
	b4 = s[1];
	} else if (sz == 3) {
	b2 = s[0];
	b3 = s[1];
	b4 = s[2];
	} else if (sz == 4) {
	b1 = s[0];
	b2 = s[1];
	b3 = s[2];
	b4 = s[3];
	} else {
	/*
	* This is a fallback and should not happen if the function
	* was called properly.
	*/
	return (NULL);
	}

	b1 = u8_composition_b1_tbl[uv][b1];
	if (b1 == U8_TBL_ELEMENT_NOT_DEF)
	return (NULL);

	b2 = u8_composition_b2_tbl[uv][b1][b2];
	if (b2 == U8_TBL_ELEMENT_NOT_DEF)
	return (NULL);

	b3_tbl = u8_composition_b3_tbl[uv][b2][b3].tbl_id;
	if (b3_tbl == U8_TBL_ELEMENT_NOT_DEF)
	return (NULL);

	if (b3_tbl >= U8_16BIT_TABLE_INDICATOR) {
	b3_tbl -= U8_16BIT_TABLE_INDICATOR;
	start_id = u8_composition_b4_16bit_tbl[uv][b3_tbl][b4];
	end_id = u8_composition_b4_16bit_tbl[uv][b3_tbl][b4 + 1];
	} else {
	start_id = u8_composition_b4_tbl[uv][b3_tbl][b4];
	end_id = u8_composition_b4_tbl[uv][b3_tbl][b4 + 1];
	}

	if (start_id >= end_id)
	return (NULL);

	b3_base = u8_composition_b3_tbl[uv][b2][b3].base;

	return ((uchar_t *)&(u8_composition_final_tbl[uv][b3_base + start_id]));
	}

	/*
	* The blocked() function checks on the combining class values of previous
	* characters in this sequence and return whether it is blocked or not.
	*/
	static boolean_t
	blocked(uchar_t *comb_class, size_t last)
	{
	uchar_t my_comb_class;
	size_t i;

	my_comb_class = comb_class[last];
	for (i = 1; i < last; i++)
	if (comb_class[i] >= my_comb_class \|\|
	comb_class[i] == U8_COMBINING_CLASS_STARTER)
	return (B_TRUE);

	return (B_FALSE);
	}

	/*
	* The do_composition() reads the character string pointed by 's' and
	* do necessary canonical composition and then copy over the result back to
	* the 's'.
	*
	* The input argument 's' cannot contain more than 32 characters.
	*/
	static size_t
	do_composition(size_t uv, uchar_t s, uchar_t comb_class, uchar_t *start,
	uchar_t disp, size_t last, uchar_t os, uchar_t oslast)
	{
	uchar_t t[U8_STREAM_SAFE_TEXT_MAX + 1];
	uchar_t tc[U8_MB_CUR_MAX] = { '\0' };
	uint8_t saved_marks[U8_MAX_CHARS_A_SEQ];
	size_t saved_marks_count;
	uchar_t *p;
	uchar_t *saved_p;
	uchar_t *q;
	size_t i;
	size_t saved_i;
	size_t j;
	size_t k;
	size_t l;
	size_t C;
	size_t saved_l;
	size_t size;
	uint32_t u1;
	uint32_t u2;
	boolean_t match_not_found = B_TRUE;

	/*
	* This should never happen unless the callers are doing some strange
	* and unexpected things.
	*
	* The "last" is the index pointing to the last character not last + 1.
	*/
	if (last >= U8_MAX_CHARS_A_SEQ)
	last = U8_UPPER_LIMIT_IN_A_SEQ;

	for (i = l = 0; i <= last; i++) {
	/*
	* The last or any non-Starters at the beginning, we don't
	* have any chance to do composition and so we just copy them
	* to the temporary buffer.
	*/
	if (i >= last \|\| comb_class[i] != U8_COMBINING_CLASS_STARTER) {
	SAVE_THE_CHAR:
	p = s + start[i];
	size = disp[i];
	for (k = 0; k < size; k++)
	t[l++] = *p++;
	continue;
	}

	/*
	* If this could be a start of Hangul Jamos, then, we try to
	* conjoin them.
	*/
	if (s[start[i]] == U8_HANGUL_JAMO_1ST_BYTE) {
	U8_PUT_3BYTES_INTO_UTF32(u1, s[start[i]],
	s[start[i] + 1], s[start[i] + 2]);
	U8_PUT_3BYTES_INTO_UTF32(u2, s[start[i] + 3],
	s[start[i] + 4], s[start[i] + 5]);

	if (U8_HANGUL_JAMO_L(u1) && U8_HANGUL_JAMO_V(u2)) {
	u1 -= U8_HANGUL_JAMO_L_FIRST;
	u2 -= U8_HANGUL_JAMO_V_FIRST;
	u1 = U8_HANGUL_SYL_FIRST +
	(u1 * U8_HANGUL_V_COUNT + u2) *
	U8_HANGUL_T_COUNT;

	i += 2;
	if (i <= last) {
	U8_PUT_3BYTES_INTO_UTF32(u2,
	s[start[i]], s[start[i] + 1],
	s[start[i] + 2]);

	if (U8_HANGUL_JAMO_T(u2)) {
	u1 += u2 -
	U8_HANGUL_JAMO_T_FIRST;
	i++;
	}
	}

	U8_SAVE_HANGUL_AS_UTF8(t + l, 0, 1, 2, u1);
	i--;
	l += 3;
	continue;
	}
	}

	/*
	* Let's then find out if this Starter has composition
	* mapping.
	*/
	p = find_composition_start(uv, s + start[i], disp[i]);
	if (p == NULL)
	goto SAVE_THE_CHAR;

	/*
	* We have a Starter with composition mapping and the next
	* character is a non-Starter. Let's try to find out if
	* we can do composition.
	*/

	saved_p = p;
	saved_i = i;
	saved_l = l;
	saved_marks_count = 0;

	TRY_THE_NEXT_MARK:
	q = s + start[++i];
	size = disp[i];

	/*
	* The next for() loop compares the non-Starter pointed by
	* 'q' with the possible (joinable) characters pointed by 'p'.
	*
	* The composition final table entry pointed by the 'p'
	* looks like the following:
	*
	* +---+---+---+-...-+---+---+---+---+-...-+---+---+
	* \| C \| b0\| b2\| ... \| bn\| F \| B0\| B1\| ... \| Bm\| F \|
	* +---+---+---+-...-+---+---+---+---+-...-+---+---+
	*
	* where C is the count byte indicating the number of
	* mapping pairs where each pair would be look like
	* (b0-bn F, B0-Bm F). The b0-bn are the bytes of the second
	* character of a canonical decomposition and the B0-Bm are
	* the bytes of a matching composite character. The F is
	* a filler byte after each character as the separator.
	*/

	match_not_found = B_TRUE;

	for (C = *p++; C > 0; C--) {
	for (k = 0; k < size; p++, k++)
	if (*p != q[k])
	break;

	/* Have we found it? */
	if (k >= size && *p == U8_TBL_ELEMENT_FILLER) {
	match_not_found = B_FALSE;

	l = saved_l;

	while (*++p != U8_TBL_ELEMENT_FILLER)
	t[l++] = *p;

	break;
	}

	/* We didn't find; skip to the next pair. */
	if (*p != U8_TBL_ELEMENT_FILLER)
	while (*++p != U8_TBL_ELEMENT_FILLER)
	;
	while (*++p != U8_TBL_ELEMENT_FILLER)
	;
	p++;
	}

	/*
	* If there was no match, we will need to save the combining
	* mark for later appending. After that, if the next one
	* is a non-Starter and not blocked, then, we try once
	* again to do composition with the next non-Starter.
	*
	* If there was no match and this was a Starter, then,
	* this is a new start.
	*
	* If there was a match and a composition done and we have
	* more to check on, then, we retrieve a new composition final
	* table entry for the composite and then try to do the
	* composition again.
	*/

	if (match_not_found) {
	if (comb_class[i] == U8_COMBINING_CLASS_STARTER) {
	i--;
	goto SAVE_THE_CHAR;
	}

	saved_marks[saved_marks_count++] = i;
	}

	if (saved_l == l) {
	while (i < last) {
	if (blocked(comb_class, i + 1))
	saved_marks[saved_marks_count++] = ++i;
	else
	break;
	}
	if (i < last) {
	p = saved_p;
	goto TRY_THE_NEXT_MARK;
	}
	} else if (i < last) {
	p = find_composition_start(uv, t + saved_l,
	l - saved_l);
	if (p != NULL) {
	saved_p = p;
	goto TRY_THE_NEXT_MARK;
	}
	}

	/*
	* There is no more composition possible.
	*
	* If there was no composition what so ever then we copy
	* over the original Starter and then append any non-Starters
	* remaining at the target string sequentially after that.
	*/

	if (saved_l == l) {
	p = s + start[saved_i];
	size = disp[saved_i];
	for (j = 0; j < size; j++)
	t[l++] = *p++;
	}

	for (k = 0; k < saved_marks_count; k++) {
	p = s + start[saved_marks[k]];
	size = disp[saved_marks[k]];
	for (j = 0; j < size; j++)
	t[l++] = *p++;
	}
	}

	/*
	* If the last character is a Starter and if we have a character
	* (possibly another Starter) that can be turned into a composite,
	* we do so and we do so until there is no more of composition
	* possible.
	*/
	if (comb_class[last] == U8_COMBINING_CLASS_STARTER) {
	p = *os;
	saved_l = l - disp[last];

	while (p < oslast) {
	size = u8_number_of_bytes[*p];
	if (size <= 1 \|\| (p + size) > oslast)
	break;

	saved_p = p;

	for (i = 0; i < size; i++)
	tc[i] = *p++;

	q = find_composition_start(uv, t + saved_l,
	l - saved_l);
	if (q == NULL) {
	p = saved_p;
	break;
	}

	match_not_found = B_TRUE;

	for (C = *q++; C > 0; C--) {
	for (k = 0; k < size; q++, k++)
	if (*q != tc[k])
	break;

	if (k >= size && *q == U8_TBL_ELEMENT_FILLER) {
	match_not_found = B_FALSE;

	l = saved_l;

	while (*++q != U8_TBL_ELEMENT_FILLER) {
	/*
	* This is practically
	* impossible but we don't
	* want to take any chances.
	*/
	if (l >=
	U8_STREAM_SAFE_TEXT_MAX) {
	p = saved_p;
	goto SAFE_RETURN;
	}
	t[l++] = *q;
	}

	break;
	}

	if (*q != U8_TBL_ELEMENT_FILLER)
	while (*++q != U8_TBL_ELEMENT_FILLER)
	;
	while (*++q != U8_TBL_ELEMENT_FILLER)
	;
	q++;
	}

	if (match_not_found) {
	p = saved_p;
	break;
	}
	}
	SAFE_RETURN:
	*os = p;
	}

	/*
	* Now we copy over the temporary string to the target string.
	* Since composition always reduces the number of characters or
	* the number of characters stay, we don't need to worry about
	* the buffer overflow here.
	*/
	for (i = 0; i < l; i++)
	s[i] = t[i];
	s[l] = '\0';

	return (l);
	}

	/*
	* The collect_a_seq() function checks on the given string s, collect
	* a sequence of characters at u8s, and return the sequence. While it collects
	* a sequence, it also applies case conversion, canonical or compatibility
	* decomposition, canonical decomposition, or some or all of them and
	* in that order.
	*
	* The collected sequence cannot be bigger than 32 characters since if
	* it is having more than 31 characters, the sequence will be terminated
	* with a U+034F COMBINING GRAPHEME JOINER (CGJ) character and turned into
	* a Stream-Safe Text. The collected sequence is always terminated with
	* a null byte and the return value is the byte length of the sequence
	* including 0. The return value does not include the terminating
	* null byte.
	*/
	static size_t
	collect_a_seq(size_t uv, uchar_t u8s, uchar_t source, uchar_t slast,
	boolean_t is_it_toupper, boolean_t is_it_tolower,
	boolean_t canonical_decomposition, boolean_t compatibility_decomposition,
	boolean_t canonical_composition,
	int errnum, u8_normalization_states_t state)
	{
	uchar_t *s;
	int sz;
	int saved_sz;
	size_t i;
	size_t j;
	size_t k;
	size_t l;
	uchar_t comb_class[U8_MAX_CHARS_A_SEQ];
	uchar_t disp[U8_MAX_CHARS_A_SEQ];
	uchar_t start[U8_MAX_CHARS_A_SEQ];
	uchar_t u8t[U8_MB_CUR_MAX] = { '\0' };
	uchar_t uts[U8_STREAM_SAFE_TEXT_MAX + 1];
	uchar_t tc;
	size_t last;
	size_t saved_last;
	uint32_t u1;

	/*
	* Save the source string pointer which we will return a changed
	* pointer if we do processing.
	*/
	s = *source;

	/*
	* The following is a fallback for just in case callers are not
	* checking the string boundaries before the calling.
	*/
	if (s >= slast) {
	u8s[0] = '\0';

	return (0);
	}

	/*
	* As the first thing, let's collect a character and do case
	* conversion if necessary.
	*/

	sz = u8_number_of_bytes[*s];

	if (sz < 0) {
	*errnum = EILSEQ;

	u8s[0] = *s++;
	u8s[1] = '\0';

	*source = s;

	return (1);
	}

	if (sz == 1) {
	if (is_it_toupper)
	u8s[0] = U8_ASCII_TOUPPER(*s);
	else if (is_it_tolower)
	u8s[0] = U8_ASCII_TOLOWER(*s);
	else
	u8s[0] = *s;
	s++;
	u8s[1] = '\0';
	} else if ((s + sz) > slast) {
	*errnum = EINVAL;

	for (i = 0; s < slast; )
	u8s[i++] = *s++;
	u8s[i] = '\0';

	*source = s;

	return (i);
	} else {
	if (is_it_toupper \|\| is_it_tolower) {
	i = do_case_conv(uv, u8s, s, sz, is_it_toupper);
	s += sz;
	sz = i;
	} else {
	for (i = 0; i < sz; )
	u8s[i++] = *s++;
	u8s[i] = '\0';
	}
	}

	/*
	* And then canonical/compatibility decomposition followed by
	* an optional canonical composition. Please be noted that
	* canonical composition is done only when a decomposition is
	* done.
	*/
	if (canonical_decomposition \|\| compatibility_decomposition) {
	if (sz == 1) {
	*state = U8_STATE_START;

	saved_sz = 1;

	comb_class[0] = 0;
	start[0] = 0;
	disp[0] = 1;

	last = 1;
	} else {
	saved_sz = do_decomp(uv, u8s, u8s, sz,
	canonical_decomposition, state);

	last = 0;

	for (i = 0; i < saved_sz; ) {
	sz = u8_number_of_bytes[u8s[i]];

	comb_class[last] = combining_class(uv,
	u8s + i, sz);
	start[last] = i;
	disp[last] = sz;

	last++;
	i += sz;
	}

	/*
	* Decomposition yields various Hangul related
	* states but not on combining marks. We need to
	* find out at here by checking on the last
	* character.
	*/
	if (*state == U8_STATE_START) {
	if (comb_class[last - 1])
	*state = U8_STATE_COMBINING_MARK;
	}
	}

	saved_last = last;

	while (s < slast) {
	sz = u8_number_of_bytes[*s];

	/*
	* If this is an illegal character, an incomplete
	* character, or an 7-bit ASCII Starter character,
	* then we have collected a sequence; break and let
	* the next call deal with the two cases.
	*
	* Note that this is okay only if you are using this
	* function with a fixed length string, not on
	* a buffer with multiple calls of one chunk at a time.
	*/
	if (sz <= 1) {
	break;
	} else if ((s + sz) > slast) {
	break;
	} else {
	/*
	* If the previous character was a Hangul Jamo
	* and this character is a Hangul Jamo that
	* can be conjoined, we collect the Jamo.
	*/
	if (*s == U8_HANGUL_JAMO_1ST_BYTE) {
	U8_PUT_3BYTES_INTO_UTF32(u1,
	s, (s + 1), *(s + 2));

	if (U8_HANGUL_COMPOSABLE_L_V(*state,
	u1)) {
	i = 0;
	*state = U8_STATE_HANGUL_LV;
	goto COLLECT_A_HANGUL;
	}

	if (U8_HANGUL_COMPOSABLE_LV_T(*state,
	u1)) {
	i = 0;
	*state = U8_STATE_HANGUL_LVT;
	goto COLLECT_A_HANGUL;
	}
	}

	/*
	* Regardless of whatever it was, if this is
	* a Starter, we don't collect the character
	* since that's a new start and we will deal
	* with it at the next time.
	*/
	i = combining_class(uv, s, sz);
	if (i == U8_COMBINING_CLASS_STARTER)
	break;

	/*
	* We know the current character is a combining
	* mark. If the previous character wasn't
	* a Starter (not Hangul) or a combining mark,
	* then, we don't collect this combining mark.
	*/
	if (*state != U8_STATE_START &&
	*state != U8_STATE_COMBINING_MARK)
	break;

	*state = U8_STATE_COMBINING_MARK;
	COLLECT_A_HANGUL:
	/*
	* If we collected a Starter and combining
	* marks up to 30, i.e., total 31 characters,
	* then, we terminate this degenerately long
	* combining sequence with a U+034F COMBINING
	* GRAPHEME JOINER (CGJ) which is 0xCD 0x8F in
	* UTF-8 and turn this into a Stream-Safe
	* Text. This will be extremely rare but
	* possible.
	*
	* The following will also guarantee that
	* we are not writing more than 32 characters
	* plus a NULL at u8s[].
	*/
	if (last >= U8_UPPER_LIMIT_IN_A_SEQ) {
	TURN_STREAM_SAFE:
	*state = U8_STATE_START;
	comb_class[last] = 0;
	start[last] = saved_sz;
	disp[last] = 2;
	last++;

	u8s[saved_sz++] = 0xCD;
	u8s[saved_sz++] = 0x8F;

	break;
	}

	/*
	* Some combining marks also do decompose into
	* another combining mark or marks.
	*/
	if (*state == U8_STATE_COMBINING_MARK) {
	k = last;
	l = sz;
	i = do_decomp(uv, uts, s, sz,
	canonical_decomposition, state);
	for (j = 0; j < i; ) {
	sz = u8_number_of_bytes[uts[j]];

	comb_class[last] =
	combining_class(uv,
	uts + j, sz);
	start[last] = saved_sz + j;
	disp[last] = sz;

	last++;
	if (last >=
	U8_UPPER_LIMIT_IN_A_SEQ) {
	last = k;
	goto TURN_STREAM_SAFE;
	}
	j += sz;
	}

	*state = U8_STATE_COMBINING_MARK;
	sz = i;
	s += l;

	for (i = 0; i < sz; i++)
	u8s[saved_sz++] = uts[i];
	} else {
	comb_class[last] = i;
	start[last] = saved_sz;
	disp[last] = sz;
	last++;

	for (i = 0; i < sz; i++)
	u8s[saved_sz++] = *s++;
	}

	/*
	* If this is U+0345 COMBINING GREEK
	* YPOGEGRAMMENI (0xCD 0x85 in UTF-8), a.k.a.,
	* iota subscript, and need to be converted to
	* uppercase letter, convert it to U+0399 GREEK
	* CAPITAL LETTER IOTA (0xCE 0x99 in UTF-8),
	* i.e., convert to capital adscript form as
	* specified in the Unicode standard.
	*
	* This is the only special case of (ambiguous)
	* case conversion at combining marks and
	* probably the standard will never have
	* anything similar like this in future.
	*/
	if (is_it_toupper && sz >= 2 &&
	u8s[saved_sz - 2] == 0xCD &&
	u8s[saved_sz - 1] == 0x85) {
	u8s[saved_sz - 2] = 0xCE;
	u8s[saved_sz - 1] = 0x99;
	}
	}
	}

	/*
	* Let's try to ensure a canonical ordering for the collected
	* combining marks. We do this only if we have collected
	* at least one more non-Starter. (The decomposition mapping
	* data tables have fully (and recursively) expanded and
	* canonically ordered decompositions.)
	*
	* The U8_SWAP_COMB_MARKS() convenience macro has some
	* assumptions and we are meeting the assumptions.
	*/
	last--;
	if (last >= saved_last) {
	for (i = 0; i < last; i++)
	for (j = last; j > i; j--)
	if (comb_class[j] &&
	comb_class[j - 1] > comb_class[j]) {
	U8_SWAP_COMB_MARKS(j - 1, j);
	}
	}

	*source = s;

	if (! canonical_composition) {
	u8s[saved_sz] = '\0';
	return (saved_sz);
	}

	/*
	* Now do the canonical composition. Note that we do this
	* only after a canonical or compatibility decomposition to
	* finish up NFC or NFKC.
	*/
	sz = do_composition(uv, u8s, comb_class, start, disp, last,
	&s, slast);
	}

	*source = s;

	return ((size_t)sz);
	}

	/*
	* The do_norm_compare() function does string comparison based on Unicode
	* simple case mappings and Unicode Normalization definitions.
	*
	* It does so by collecting a sequence of character at a time and comparing
	* the collected sequences from the strings.
	*
	* The meanings on the return values are the same as the usual strcmp().
	*/
	static int
	do_norm_compare(size_t uv, uchar_t s1, uchar_t s2, size_t n1, size_t n2,
	int flag, int *errnum)
	{
	int result;
	size_t sz1;
	size_t sz2;
	uchar_t u8s1[U8_STREAM_SAFE_TEXT_MAX + 1];
	uchar_t u8s2[U8_STREAM_SAFE_TEXT_MAX + 1];
	uchar_t *s1last;
	uchar_t *s2last;
	boolean_t is_it_toupper;
	boolean_t is_it_tolower;
	boolean_t canonical_decomposition;
	boolean_t compatibility_decomposition;
	boolean_t canonical_composition;
	u8_normalization_states_t state;

	s1last = s1 + n1;
	s2last = s2 + n2;

	is_it_toupper = flag & U8_TEXTPREP_TOUPPER;
	is_it_tolower = flag & U8_TEXTPREP_TOLOWER;
	canonical_decomposition = flag & U8_CANON_DECOMP;
	compatibility_decomposition = flag & U8_COMPAT_DECOMP;
	canonical_composition = flag & U8_CANON_COMP;

	while (s1 < s1last && s2 < s2last) {
	/*
	* If the current character is a 7-bit ASCII and the last
	* character, or, if the current character and the next
	* character are both some 7-bit ASCII characters then
	* we treat the current character as a sequence.
	*
	* In any other cases, we need to call collect_a_seq().
	*/

	if (U8_ISASCII(*s1) && ((s1 + 1) >= s1last \|\|
	((s1 + 1) < s1last && U8_ISASCII(*(s1 + 1))))) {
	if (is_it_toupper)
	u8s1[0] = U8_ASCII_TOUPPER(*s1);
	else if (is_it_tolower)
	u8s1[0] = U8_ASCII_TOLOWER(*s1);
	else
	u8s1[0] = *s1;
	u8s1[1] = '\0';
	sz1 = 1;
	s1++;
	} else {
	state = U8_STATE_START;
	sz1 = collect_a_seq(uv, u8s1, &s1, s1last,
	is_it_toupper, is_it_tolower,
	canonical_decomposition,
	compatibility_decomposition,
	canonical_composition, errnum, &state);
	}

	if (U8_ISASCII(*s2) && ((s2 + 1) >= s2last \|\|
	((s2 + 1) < s2last && U8_ISASCII(*(s2 + 1))))) {
	if (is_it_toupper)
	u8s2[0] = U8_ASCII_TOUPPER(*s2);
	else if (is_it_tolower)
	u8s2[0] = U8_ASCII_TOLOWER(*s2);
	else
	u8s2[0] = *s2;
	u8s2[1] = '\0';
	sz2 = 1;
	s2++;
	} else {
	state = U8_STATE_START;
	sz2 = collect_a_seq(uv, u8s2, &s2, s2last,
	is_it_toupper, is_it_tolower,
	canonical_decomposition,
	compatibility_decomposition,
	canonical_composition, errnum, &state);
	}

	/*
	* Now compare the two characters. If they are the same,
	* we move on to the next character sequences.
	*/
	if (sz1 == 1 && sz2 == 1) {
	if (u8s1 > u8s2)
	return (1);
	if (u8s1 < u8s2)
	return (-1);
	} else {
	result = strcmp((const char )u8s1, (const char )u8s2);
	if (result != 0)
	return (result);
	}
	}

	/*
	* We compared until the end of either or both strings.
	*
	* If we reached to or went over the ends for the both, that means
	* they are the same.
	*
	* If we reached only one end, that means the other string has
	* something which then can be used to determine the return value.
	*/
	if (s1 >= s1last) {
	if (s2 >= s2last)
	return (0);
	return (-1);
	}
	return (1);
	}

	/*
	* The u8_strcmp() function compares two UTF-8 strings quite similar to
	* the strcmp(). For the comparison, however, Unicode Normalization specific
	* equivalency and Unicode simple case conversion mappings based equivalency
	* can be requested and checked against.
	*/
	int
	u8_strcmp(const char s1, const char s2, size_t n, int flag, size_t uv,
	int *errnum)
	{
	int f;
	size_t n1;
	size_t n2;

	*errnum = 0;

	/*
	* Check on the requested Unicode version, case conversion, and
	* normalization flag values.
	*/

	if (uv > U8_UNICODE_LATEST) {
	*errnum = ERANGE;
	uv = U8_UNICODE_LATEST;
	}

	if (flag == 0) {
	flag = U8_STRCMP_CS;
	} else {
	f = flag & (U8_STRCMP_CS \| U8_STRCMP_CI_UPPER \|
	U8_STRCMP_CI_LOWER);
	if (f == 0) {
	flag \|= U8_STRCMP_CS;
	} else if (f != U8_STRCMP_CS && f != U8_STRCMP_CI_UPPER &&
	f != U8_STRCMP_CI_LOWER) {
	*errnum = EBADF;
	flag = U8_STRCMP_CS;
	}

	f = flag & (U8_CANON_DECOMP \| U8_COMPAT_DECOMP \| U8_CANON_COMP);
	if (f && f != U8_STRCMP_NFD && f != U8_STRCMP_NFC &&
	f != U8_STRCMP_NFKD && f != U8_STRCMP_NFKC) {
	*errnum = EBADF;
	flag = U8_STRCMP_CS;
	}
	}

	if (flag == U8_STRCMP_CS) {
	return (n == 0 ? strcmp(s1, s2) : strncmp(s1, s2, n));
	}

	n1 = strlen(s1);
	n2 = strlen(s2);
	if (n != 0) {
	if (n < n1)
	n1 = n;
	if (n < n2)
	n2 = n;
	}

	/*
	* Simple case conversion can be done much faster and so we do
	* them separately here.
	*/
	if (flag == U8_STRCMP_CI_UPPER) {
	return (do_case_compare(uv, (uchar_t )s1, (uchar_t )s2,
	n1, n2, B_TRUE, errnum));
	} else if (flag == U8_STRCMP_CI_LOWER) {
	return (do_case_compare(uv, (uchar_t )s1, (uchar_t )s2,
	n1, n2, B_FALSE, errnum));
	}

	return (do_norm_compare(uv, (uchar_t )s1, (uchar_t )s2, n1, n2,
	flag, errnum));
	}

	size_t
	u8_textprep_str(char inarray, size_t inlen, char outarray, size_t outlen,
	int flag, size_t unicode_version, int *errnum)
	{
	int f;
	int sz;
	uchar_t *ib;
	uchar_t *ibtail;
	uchar_t *ob;
	uchar_t *obtail;
	boolean_t do_not_ignore_null;
	boolean_t do_not_ignore_invalid;
	boolean_t is_it_toupper;
	boolean_t is_it_tolower;
	boolean_t canonical_decomposition;
	boolean_t compatibility_decomposition;
	boolean_t canonical_composition;
	size_t ret_val;
	size_t i;
	size_t j;
	uchar_t u8s[U8_STREAM_SAFE_TEXT_MAX + 1];
	u8_normalization_states_t state;

	if (unicode_version > U8_UNICODE_LATEST) {
	*errnum = ERANGE;
	return ((size_t)-1);
	}

	f = flag & (U8_TEXTPREP_TOUPPER \| U8_TEXTPREP_TOLOWER);
	if (f == (U8_TEXTPREP_TOUPPER \| U8_TEXTPREP_TOLOWER)) {
	*errnum = EBADF;
	return ((size_t)-1);
	}

	f = flag & (U8_CANON_DECOMP \| U8_COMPAT_DECOMP \| U8_CANON_COMP);
	if (f && f != U8_TEXTPREP_NFD && f != U8_TEXTPREP_NFC &&
	f != U8_TEXTPREP_NFKD && f != U8_TEXTPREP_NFKC) {
	*errnum = EBADF;
	return ((size_t)-1);
	}

	if (inarray == NULL \|\| *inlen == 0)
	return (0);

	if (outarray == NULL) {
	*errnum = E2BIG;
	return ((size_t)-1);
	}

	ib = (uchar_t *)inarray;
	ob = (uchar_t *)outarray;
	ibtail = ib + *inlen;
	obtail = ob + *outlen;

	do_not_ignore_null = !(flag & U8_TEXTPREP_IGNORE_NULL);
	do_not_ignore_invalid = !(flag & U8_TEXTPREP_IGNORE_INVALID);
	is_it_toupper = flag & U8_TEXTPREP_TOUPPER;
	is_it_tolower = flag & U8_TEXTPREP_TOLOWER;

	ret_val = 0;

	/*
	* If we don't have a normalization flag set, we do the simple case
	* conversion based text preparation separately below. Text
	* preparation involving Normalization will be done in the false task
	* block, again, separately since it will take much more time and
	* resource than doing simple case conversions.
	*/
	if (f == 0) {
	while (ib < ibtail) {
	if (*ib == '\0' && do_not_ignore_null)
	break;

	sz = u8_number_of_bytes[*ib];

	if (sz < 0) {
	if (do_not_ignore_invalid) {
	*errnum = EILSEQ;
	ret_val = (size_t)-1;
	break;
	}

	sz = 1;
	ret_val++;
	}

	if (sz == 1) {
	if (ob >= obtail) {
	*errnum = E2BIG;
	ret_val = (size_t)-1;
	break;
	}

	if (is_it_toupper)
	ob = U8_ASCII_TOUPPER(ib);
	else if (is_it_tolower)
	ob = U8_ASCII_TOLOWER(ib);
	else
	ob = ib;
	ib++;
	ob++;
	} else if ((ib + sz) > ibtail) {
	if (do_not_ignore_invalid) {
	*errnum = EINVAL;
	ret_val = (size_t)-1;
	break;
	}

	if ((obtail - ob) < (ibtail - ib)) {
	*errnum = E2BIG;
	ret_val = (size_t)-1;
	break;
	}

	/*
	* We treat the remaining incomplete character
	* bytes as a character.
	*/
	ret_val++;

	while (ib < ibtail)
	ob++ = ib++;
	} else {
	if (is_it_toupper \|\| is_it_tolower) {
	i = do_case_conv(unicode_version, u8s,
	ib, sz, is_it_toupper);

	if ((obtail - ob) < i) {
	*errnum = E2BIG;
	ret_val = (size_t)-1;
	break;
	}

	ib += sz;

	for (sz = 0; sz < i; sz++)
	*ob++ = u8s[sz];
	} else {
	if ((obtail - ob) < sz) {
	*errnum = E2BIG;
	ret_val = (size_t)-1;
	break;
	}

	for (i = 0; i < sz; i++)
	ob++ = ib++;
	}
	}
	}
	} else {
	canonical_decomposition = flag & U8_CANON_DECOMP;
	compatibility_decomposition = flag & U8_COMPAT_DECOMP;
	canonical_composition = flag & U8_CANON_COMP;

	while (ib < ibtail) {
	if (*ib == '\0' && do_not_ignore_null)
	break;

	/*
	* If the current character is a 7-bit ASCII
	* character and it is the last character, or,
	* if the current character is a 7-bit ASCII
	* character and the next character is also a 7-bit
	* ASCII character, then, we copy over this
	* character without going through collect_a_seq().
	*
	* In any other cases, we need to look further with
	* the collect_a_seq() function.
	*/
	if (U8_ISASCII(*ib) && ((ib + 1) >= ibtail \|\|
	((ib + 1) < ibtail && U8_ISASCII(*(ib + 1))))) {
	if (ob >= obtail) {
	*errnum = E2BIG;
	ret_val = (size_t)-1;
	break;
	}

	if (is_it_toupper)
	ob = U8_ASCII_TOUPPER(ib);
	else if (is_it_tolower)
	ob = U8_ASCII_TOLOWER(ib);
	else
	ob = ib;
	ib++;
	ob++;
	} else {
	*errnum = 0;
	state = U8_STATE_START;

	j = collect_a_seq(unicode_version, u8s,
	&ib, ibtail,
	is_it_toupper,
	is_it_tolower,
	canonical_decomposition,
	compatibility_decomposition,
	canonical_composition,
	errnum, &state);

	if (*errnum && do_not_ignore_invalid) {
	ret_val = (size_t)-1;
	break;
	}

	if ((obtail - ob) < j) {
	*errnum = E2BIG;
	ret_val = (size_t)-1;
	break;
	}

	for (i = 0; i < j; i++)
	*ob++ = u8s[i];
	}
	}
	}

	*inlen = ibtail - ib;
	*outlen = obtail - ob;

	return (ret_val);
	}

	#if defined(_KERNEL)
	static int __init
	unicode_init(void)
	{
	return (0);
	}

	static void __exit
	unicode_fini(void)
	{
	}

	module_init(unicode_init);
	module_exit(unicode_fini);
	#endif

	ZFS_MODULE_DESCRIPTION("Unicode implementation");
	ZFS_MODULE_AUTHOR(ZFS_META_AUTHOR);
	ZFS_MODULE_LICENSE(ZFS_META_LICENSE);
	ZFS_MODULE_VERSION(ZFS_META_VERSION "-" ZFS_META_RELEASE);

	EXPORT_SYMBOL(u8_validate);
	EXPORT_SYMBOL(u8_strcmp);
	EXPORT_SYMBOL(u8_textprep_str);
	diff --git a/sys/contrib/openzfs/module/zcommon/zfs_comutil.c b/sys/contrib/openzfs/module/zcommon/zfs_comutil.c
	index 1cec60ac1d67..886167759be8 100644
	--- a/sys/contrib/openzfs/module/zcommon/zfs_comutil.c
	+++ b/sys/contrib/openzfs/module/zcommon/zfs_comutil.c
	@@ -1,263 +1,263 @@
	/*
	* 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) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2012, 2017 by Delphix. All rights reserved.
	*/

	/*
	* This file is intended for functions that ought to be common between user
	* land (libzfs) and the kernel. When many common routines need to be shared
	- * then a separate file should to be created.
	+ * then a separate file should be created.
	*/

	#if !defined(_KERNEL)
	#include <string.h>
	#endif

	#include <sys/types.h>
	#include <sys/fs/zfs.h>
	#include <sys/nvpair.h>
	#include "zfs_comutil.h"
	#include <sys/zfs_ratelimit.h>

	/*
	* Are there allocatable vdevs?
	*/
	boolean_t
	zfs_allocatable_devs(nvlist_t *nv)
	{
	uint64_t is_log;
	uint_t c;
	nvlist_t **child;
	uint_t children;

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
	&child, &children) != 0) {
	return (B_FALSE);
	}
	for (c = 0; c < children; c++) {
	is_log = 0;
	(void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_LOG,
	&is_log);
	if (!is_log)
	return (B_TRUE);
	}
	return (B_FALSE);
	}

	/*
	* Are there special vdevs?
	*/
	boolean_t
	zfs_special_devs(nvlist_t nv, char type)
	{
	char *bias;
	uint_t c;
	nvlist_t **child;
	uint_t children;

	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
	&child, &children) != 0) {
	return (B_FALSE);
	}
	for (c = 0; c < children; c++) {
	if (nvlist_lookup_string(child[c], ZPOOL_CONFIG_ALLOCATION_BIAS,
	&bias) == 0) {
	if (strcmp(bias, VDEV_ALLOC_BIAS_SPECIAL) == 0 \|\|
	strcmp(bias, VDEV_ALLOC_BIAS_DEDUP) == 0) {
	if (type != NULL && strcmp(bias, type) == 0) {
	return (B_TRUE);
	} else if (type == NULL) {
	return (B_TRUE);
	}
	}
	}
	}
	return (B_FALSE);
	}

	void
	zpool_get_load_policy(nvlist_t nvl, zpool_load_policy_t zlpp)
	{
	nvlist_t *policy;
	nvpair_t *elem;
	char *nm;

	/* Defaults */
	zlpp->zlp_rewind = ZPOOL_NO_REWIND;
	zlpp->zlp_maxmeta = 0;
	zlpp->zlp_maxdata = UINT64_MAX;
	zlpp->zlp_txg = UINT64_MAX;

	if (nvl == NULL)
	return;

	elem = NULL;
	while ((elem = nvlist_next_nvpair(nvl, elem)) != NULL) {
	nm = nvpair_name(elem);
	if (strcmp(nm, ZPOOL_LOAD_POLICY) == 0) {
	if (nvpair_value_nvlist(elem, &policy) == 0)
	zpool_get_load_policy(policy, zlpp);
	return;
	} else if (strcmp(nm, ZPOOL_LOAD_REWIND_POLICY) == 0) {
	if (nvpair_value_uint32(elem, &zlpp->zlp_rewind) == 0)
	if (zlpp->zlp_rewind & ~ZPOOL_REWIND_POLICIES)
	zlpp->zlp_rewind = ZPOOL_NO_REWIND;
	} else if (strcmp(nm, ZPOOL_LOAD_REQUEST_TXG) == 0) {
	(void) nvpair_value_uint64(elem, &zlpp->zlp_txg);
	} else if (strcmp(nm, ZPOOL_LOAD_META_THRESH) == 0) {
	(void) nvpair_value_uint64(elem, &zlpp->zlp_maxmeta);
	} else if (strcmp(nm, ZPOOL_LOAD_DATA_THRESH) == 0) {
	(void) nvpair_value_uint64(elem, &zlpp->zlp_maxdata);
	}
	}
	if (zlpp->zlp_rewind == 0)
	zlpp->zlp_rewind = ZPOOL_NO_REWIND;
	}

	typedef struct zfs_version_spa_map {
	int version_zpl;
	int version_spa;
	} zfs_version_spa_map_t;

	/*
	* Keep this table in monotonically increasing version number order.
	*/
	static zfs_version_spa_map_t zfs_version_table[] = {
	{ZPL_VERSION_INITIAL, SPA_VERSION_INITIAL},
	{ZPL_VERSION_DIRENT_TYPE, SPA_VERSION_INITIAL},
	{ZPL_VERSION_FUID, SPA_VERSION_FUID},
	{ZPL_VERSION_USERSPACE, SPA_VERSION_USERSPACE},
	{ZPL_VERSION_SA, SPA_VERSION_SA},
	{0, 0}
	};

	/*
	* Return the max zpl version for a corresponding spa version
	* -1 is returned if no mapping exists.
	*/
	int
	zfs_zpl_version_map(int spa_version)
	{
	int i;
	int version = -1;

	for (i = 0; zfs_version_table[i].version_spa; i++) {
	if (spa_version >= zfs_version_table[i].version_spa)
	version = zfs_version_table[i].version_zpl;
	}

	return (version);
	}

	/*
	* Return the min spa version for a corresponding spa version
	* -1 is returned if no mapping exists.
	*/
	int
	zfs_spa_version_map(int zpl_version)
	{
	int i;
	int version = -1;

	for (i = 0; zfs_version_table[i].version_zpl; i++) {
	if (zfs_version_table[i].version_zpl >= zpl_version)
	return (zfs_version_table[i].version_spa);
	}

	return (version);
	}

	/*
	* This is the table of legacy internal event names; it should not be modified.
	* The internal events are now stored in the history log as strings.
	*/
	const char *zfs_history_event_names[ZFS_NUM_LEGACY_HISTORY_EVENTS] = {
	"invalid event",
	"pool create",
	"vdev add",
	"pool remove",
	"pool destroy",
	"pool export",
	"pool import",
	"vdev attach",
	"vdev replace",
	"vdev detach",
	"vdev online",
	"vdev offline",
	"vdev upgrade",
	"pool clear",
	"pool scrub",
	"pool property set",
	"create",
	"clone",
	"destroy",
	"destroy_begin_sync",
	"inherit",
	"property set",
	"quota set",
	"permission update",
	"permission remove",
	"permission who remove",
	"promote",
	"receive",
	"rename",
	"reservation set",
	"replay_inc_sync",
	"replay_full_sync",
	"rollback",
	"snapshot",
	"filesystem version upgrade",
	"refquota set",
	"refreservation set",
	"pool scrub done",
	"user hold",
	"user release",
	"pool split",
	};

	boolean_t
	zfs_dataset_name_hidden(const char *name)
	{
	/*
	* Skip over datasets that are not visible in this zone,
	* internal datasets (which have a $ in their name), and
	* temporary datasets (which have a % in their name).
	*/
	if (strchr(name, '$') != NULL)
	return (B_TRUE);
	if (strchr(name, '%') != NULL)
	return (B_TRUE);
	if (!INGLOBALZONE(curproc) && !zone_dataset_visible(name, NULL))
	return (B_TRUE);
	return (B_FALSE);
	}

	#if defined(_KERNEL)
	EXPORT_SYMBOL(zfs_allocatable_devs);
	EXPORT_SYMBOL(zfs_special_devs);
	EXPORT_SYMBOL(zpool_get_load_policy);
	EXPORT_SYMBOL(zfs_zpl_version_map);
	EXPORT_SYMBOL(zfs_spa_version_map);
	EXPORT_SYMBOL(zfs_history_event_names);
	EXPORT_SYMBOL(zfs_dataset_name_hidden);
	#endif
	diff --git a/sys/contrib/openzfs/module/zcommon/zfs_fletcher_avx512.c b/sys/contrib/openzfs/module/zcommon/zfs_fletcher_avx512.c
	index 300ec4c1fb69..963f089b04f5 100644
	--- a/sys/contrib/openzfs/module/zcommon/zfs_fletcher_avx512.c
	+++ b/sys/contrib/openzfs/module/zcommon/zfs_fletcher_avx512.c
	@@ -1,225 +1,231 @@
	/*
	* 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) 2016 Gvozden Nešković. All rights reserved.
	*/

	#if defined(__x86_64) && defined(HAVE_AVX512F)

	#include <sys/byteorder.h>
	#include <sys/frame.h>
	#include <sys/spa_checksum.h>
	#include <sys/strings.h>
	#include <sys/simd.h>
	#include <zfs_fletcher.h>

	#ifdef __linux__
	#define __asm __asm__ __volatile__
	#endif

	static void
	fletcher_4_avx512f_init(fletcher_4_ctx_t *ctx)
	{
	bzero(ctx->avx512, 4 * sizeof (zfs_fletcher_avx512_t));
	}

	static void
	fletcher_4_avx512f_fini(fletcher_4_ctx_t ctx, zio_cksum_t zcp)
	{
	static const uint64_t
	CcA[] = { 0, 0, 1, 3, 6, 10, 15, 21 },
	CcB[] = { 28, 36, 44, 52, 60, 68, 76, 84 },
	DcA[] = { 0, 0, 0, 1, 4, 10, 20, 35 },
	DcB[] = { 56, 84, 120, 164, 216, 276, 344, 420 },
	DcC[] = { 448, 512, 576, 640, 704, 768, 832, 896 };

	uint64_t A, B, C, D;
	uint64_t i;

	A = ctx->avx512[0].v[0];
	B = 8 * ctx->avx512[1].v[0];
	C = 64 * ctx->avx512[2].v[0] - CcB[0] * ctx->avx512[1].v[0];
	D = 512 * ctx->avx512[3].v[0] - DcC[0] * ctx->avx512[2].v[0] +
	DcB[0] * ctx->avx512[1].v[0];

	for (i = 1; i < 8; i++) {
	A += ctx->avx512[0].v[i];
	B += 8 * ctx->avx512[1].v[i] - i * ctx->avx512[0].v[i];
	C += 64 * ctx->avx512[2].v[i] - CcB[i] * ctx->avx512[1].v[i] +
	CcA[i] * ctx->avx512[0].v[i];
	D += 512 * ctx->avx512[3].v[i] - DcC[i] * ctx->avx512[2].v[i] +
	DcB[i] * ctx->avx512[1].v[i] - DcA[i] * ctx->avx512[0].v[i];
	}

	ZIO_SET_CHECKSUM(zcp, A, B, C, D);
	}

	#define FLETCHER_4_AVX512_RESTORE_CTX(ctx) \
	{ \
	__asm("vmovdqu64 %0, %%zmm0" :: "m" ((ctx)->avx512[0])); \
	__asm("vmovdqu64 %0, %%zmm1" :: "m" ((ctx)->avx512[1])); \
	__asm("vmovdqu64 %0, %%zmm2" :: "m" ((ctx)->avx512[2])); \
	__asm("vmovdqu64 %0, %%zmm3" :: "m" ((ctx)->avx512[3])); \
	}

	#define FLETCHER_4_AVX512_SAVE_CTX(ctx) \
	{ \
	__asm("vmovdqu64 %%zmm0, %0" : "=m" ((ctx)->avx512[0])); \
	__asm("vmovdqu64 %%zmm1, %0" : "=m" ((ctx)->avx512[1])); \
	__asm("vmovdqu64 %%zmm2, %0" : "=m" ((ctx)->avx512[2])); \
	__asm("vmovdqu64 %%zmm3, %0" : "=m" ((ctx)->avx512[3])); \
	}

	static void
	fletcher_4_avx512f_native(fletcher_4_ctx_t ctx, const void buf, uint64_t size)
	{
	const uint32_t *ip = buf;
	const uint32_t ipend = (uint32_t )((uint8_t *)ip + size);

	kfpu_begin();

	FLETCHER_4_AVX512_RESTORE_CTX(ctx);

	for (; ip < ipend; ip += 8) {
	__asm("vpmovzxdq %0, %%zmm4"::"m" (*ip));
	__asm("vpaddq %zmm4, %zmm0, %zmm0");
	__asm("vpaddq %zmm0, %zmm1, %zmm1");
	__asm("vpaddq %zmm1, %zmm2, %zmm2");
	__asm("vpaddq %zmm2, %zmm3, %zmm3");
	}

	FLETCHER_4_AVX512_SAVE_CTX(ctx);

	kfpu_end();
	}
	STACK_FRAME_NON_STANDARD(fletcher_4_avx512f_native);

	static void
	fletcher_4_avx512f_byteswap(fletcher_4_ctx_t ctx, const void buf,
	uint64_t size)
	{
	static const uint64_t byteswap_mask = 0xFFULL;
	const uint32_t *ip = buf;
	const uint32_t ipend = (uint32_t )((uint8_t *)ip + size);

	kfpu_begin();

	FLETCHER_4_AVX512_RESTORE_CTX(ctx);

	__asm("vpbroadcastq %0, %%zmm8" :: "r" (byteswap_mask));
	__asm("vpsllq $8, %zmm8, %zmm9");
	__asm("vpsllq $16, %zmm8, %zmm10");
	__asm("vpsllq $24, %zmm8, %zmm11");

	for (; ip < ipend; ip += 8) {
	__asm("vpmovzxdq %0, %%zmm5"::"m" (*ip));

	__asm("vpsrlq $24, %zmm5, %zmm6");
	__asm("vpandd %zmm8, %zmm6, %zmm6");
	__asm("vpsrlq $8, %zmm5, %zmm7");
	__asm("vpandd %zmm9, %zmm7, %zmm7");
	__asm("vpord %zmm6, %zmm7, %zmm4");
	__asm("vpsllq $8, %zmm5, %zmm6");
	__asm("vpandd %zmm10, %zmm6, %zmm6");
	__asm("vpord %zmm6, %zmm4, %zmm4");
	__asm("vpsllq $24, %zmm5, %zmm5");
	__asm("vpandd %zmm11, %zmm5, %zmm5");
	__asm("vpord %zmm5, %zmm4, %zmm4");

	__asm("vpaddq %zmm4, %zmm0, %zmm0");
	__asm("vpaddq %zmm0, %zmm1, %zmm1");
	__asm("vpaddq %zmm1, %zmm2, %zmm2");
	__asm("vpaddq %zmm2, %zmm3, %zmm3");
	}

	FLETCHER_4_AVX512_SAVE_CTX(ctx)

	kfpu_end();
	}
	STACK_FRAME_NON_STANDARD(fletcher_4_avx512f_byteswap);

	static boolean_t
	fletcher_4_avx512f_valid(void)
	{
	return (kfpu_allowed() && zfs_avx512f_available());
	}

	const fletcher_4_ops_t fletcher_4_avx512f_ops = {
	.init_native = fletcher_4_avx512f_init,
	.fini_native = fletcher_4_avx512f_fini,
	.compute_native = fletcher_4_avx512f_native,
	.init_byteswap = fletcher_4_avx512f_init,
	.fini_byteswap = fletcher_4_avx512f_fini,
	.compute_byteswap = fletcher_4_avx512f_byteswap,
	.valid = fletcher_4_avx512f_valid,
	.name = "avx512f"
	};

	#if defined(HAVE_AVX512BW)
	static void
	fletcher_4_avx512bw_byteswap(fletcher_4_ctx_t ctx, const void buf,
	uint64_t size)
	{
	static const zfs_fletcher_avx512_t mask = {
	.v = { 0xFFFFFFFF00010203, 0xFFFFFFFF08090A0B,
	0xFFFFFFFF00010203, 0xFFFFFFFF08090A0B,
	0xFFFFFFFF00010203, 0xFFFFFFFF08090A0B,
	0xFFFFFFFF00010203, 0xFFFFFFFF08090A0B }
	};
	const uint32_t *ip = buf;
	const uint32_t ipend = (uint32_t )((uint8_t *)ip + size);

	kfpu_begin();

	FLETCHER_4_AVX512_RESTORE_CTX(ctx);

	__asm("vmovdqu64 %0, %%zmm5" :: "m" (mask));

	for (; ip < ipend; ip += 8) {
	__asm("vpmovzxdq %0, %%zmm4"::"m" (*ip));

	__asm("vpshufb %zmm5, %zmm4, %zmm4");

	__asm("vpaddq %zmm4, %zmm0, %zmm0");
	__asm("vpaddq %zmm0, %zmm1, %zmm1");
	__asm("vpaddq %zmm1, %zmm2, %zmm2");
	__asm("vpaddq %zmm2, %zmm3, %zmm3");
	}

	FLETCHER_4_AVX512_SAVE_CTX(ctx)

	kfpu_end();
	}
	STACK_FRAME_NON_STANDARD(fletcher_4_avx512bw_byteswap);

	+static boolean_t
	+fletcher_4_avx512bw_valid(void)
	+{
	+ return (fletcher_4_avx512f_valid() && zfs_avx512bw_available());
	+}
	+
	const fletcher_4_ops_t fletcher_4_avx512bw_ops = {
	.init_native = fletcher_4_avx512f_init,
	.fini_native = fletcher_4_avx512f_fini,
	.compute_native = fletcher_4_avx512f_native,
	.init_byteswap = fletcher_4_avx512f_init,
	.fini_byteswap = fletcher_4_avx512f_fini,
	.compute_byteswap = fletcher_4_avx512bw_byteswap,
	- .valid = fletcher_4_avx512f_valid,
	+ .valid = fletcher_4_avx512bw_valid,
	.name = "avx512bw"
	};
	#endif

	#endif /* defined(__x86_64) && defined(HAVE_AVX512F) */
	diff --git a/sys/contrib/openzfs/module/zcommon/zfs_namecheck.c b/sys/contrib/openzfs/module/zcommon/zfs_namecheck.c
	index 0011a971cacb..7ecce451b42d 100644
	--- a/sys/contrib/openzfs/module/zcommon/zfs_namecheck.c
	+++ b/sys/contrib/openzfs/module/zcommon/zfs_namecheck.c
	@@ -1,473 +1,467 @@
	/*
	* 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 2009 Sun Microsystems, Inc. All rights reserved.
	* Use is subject to license terms.
	*/
	/*
	* Copyright (c) 2013, 2016 by Delphix. All rights reserved.
	*/

	/*
	* Common name validation routines for ZFS. These routines are shared by the
	* userland code as well as the ioctl() layer to ensure that we don't
	* inadvertently expose a hole through direct ioctl()s that never gets tested.
	* In userland, however, we want significantly more information about _why_ the
	* name is invalid. In the kernel, we only care whether it's valid or not.
	* Each routine therefore takes a 'namecheck_err_t' which describes exactly why
	* the name failed to validate.
	*/

	#if !defined(_KERNEL)
	#include <string.h>
	#endif

	#include <sys/dsl_dir.h>
	#include <sys/param.h>
	#include <sys/nvpair.h>
	#include "zfs_namecheck.h"
	#include "zfs_deleg.h"

	/*
	* Deeply nested datasets can overflow the stack, so we put a limit
	* in the amount of nesting a path can have. zfs_max_dataset_nesting
	* can be tuned temporarily to fix existing datasets that exceed our
	* predefined limit.
	*/
	int zfs_max_dataset_nesting = 50;

	static int
	valid_char(char c)
	{
	return ((c >= 'a' && c <= 'z') \|\|
	(c >= 'A' && c <= 'Z') \|\|
	(c >= '0' && c <= '9') \|\|
	c == '-' \|\| c == '_' \|\| c == '.' \|\| c == ':' \|\| c == ' ');
	}

	/*
	* Looks at a path and returns its level of nesting (depth).
	*/
	int
	get_dataset_depth(const char *path)
	{
	const char *loc = path;
	int nesting = 0;

	/*
	* Keep track of nesting until you hit the end of the
	* path or found the snapshot/bookmark separator.
	*/
	for (int i = 0; loc[i] != '\0' &&
	loc[i] != '@' &&
	loc[i] != '#'; i++) {
	if (loc[i] == '/')
	nesting++;
	}

	return (nesting);
	}

	/*
	* Snapshot names must be made up of alphanumeric characters plus the following
	* characters:
	*
	* [-_.: ]
	*
	* Returns 0 on success, -1 on error.
	*/
	int
	zfs_component_namecheck(const char path, namecheck_err_t why, char *what)
	{
	const char *loc;

	if (strlen(path) >= ZFS_MAX_DATASET_NAME_LEN) {
	if (why)
	*why = NAME_ERR_TOOLONG;
	return (-1);
	}

	if (path[0] == '\0') {
	if (why)
	*why = NAME_ERR_EMPTY_COMPONENT;
	return (-1);
	}

	for (loc = path; *loc; loc++) {
	if (!valid_char(*loc)) {
	if (why) {
	*why = NAME_ERR_INVALCHAR;
	what = loc;
	}
	return (-1);
	}
	}
	return (0);
	}


	/*
	* Permissions set name must start with the letter '@' followed by the
	* same character restrictions as snapshot names, except that the name
	* cannot exceed 64 characters.
	*
	* Returns 0 on success, -1 on error.
	*/
	int
	permset_namecheck(const char path, namecheck_err_t why, char *what)
	{
	if (strlen(path) >= ZFS_PERMSET_MAXLEN) {
	if (why)
	*why = NAME_ERR_TOOLONG;
	return (-1);
	}

	if (path[0] != '@') {
	if (why) {
	*why = NAME_ERR_NO_AT;
	*what = path[0];
	}
	return (-1);
	}

	return (zfs_component_namecheck(&path[1], why, what));
	}

	/*
	* Dataset paths should not be deeper than zfs_max_dataset_nesting
	* in terms of nesting.
	*
	* Returns 0 on success, -1 on error.
	*/
	int
	dataset_nestcheck(const char *path)
	{
	return ((get_dataset_depth(path) < zfs_max_dataset_nesting) ? 0 : -1);
	}

	/*
	* Entity names must be of the following form:
	*
	* [component/]*[component][(@\|#)component]?
	*
	* Where each component is made up of alphanumeric characters plus the following
	* characters:
	*
	* [-_.: %]
	*
	* We allow '%' here as we use that character internally to create unique
	* names for temporary clones (for online recv).
	*
	* Returns 0 on success, -1 on error.
	*/
	int
	entity_namecheck(const char path, namecheck_err_t why, char *what)
	{
	const char *end;

	EQUIV(why == NULL, what == NULL);

	/*
	* Make sure the name is not too long.
	*/
	if (strlen(path) >= ZFS_MAX_DATASET_NAME_LEN) {
	if (why)
	*why = NAME_ERR_TOOLONG;
	return (-1);
	}

	/* Explicitly check for a leading slash. */
	if (path[0] == '/') {
	if (why)
	*why = NAME_ERR_LEADING_SLASH;
	return (-1);
	}

	if (path[0] == '\0') {
	if (why)
	*why = NAME_ERR_EMPTY_COMPONENT;
	return (-1);
	}

	const char *start = path;
	boolean_t found_delim = B_FALSE;
	for (;;) {
	/* Find the end of this component */
	end = start;
	while (end != '/' && end != '@' && *end != '#' &&
	*end != '\0')
	end++;

	if (*end == '\0' && end[-1] == '/') {
	/* trailing slashes are not allowed */
	if (why)
	*why = NAME_ERR_TRAILING_SLASH;
	return (-1);
	}

	/* Validate the contents of this component */
	for (const char *loc = start; loc != end; loc++) {
	if (!valid_char(loc) && loc != '%') {
	if (why) {
	*why = NAME_ERR_INVALCHAR;
	what = loc;
	}
	return (-1);
	}
	}

	if (end == '\0' \|\| end == '/') {
	int component_length = end - start;
	/* Validate the contents of this component is not '.' */
	if (component_length == 1) {
	if (start[0] == '.') {
	if (why)
	*why = NAME_ERR_SELF_REF;
	return (-1);
	}
	}

	/* Validate the content of this component is not '..' */
	if (component_length == 2) {
	if (start[0] == '.' && start[1] == '.') {
	if (why)
	*why = NAME_ERR_PARENT_REF;
	return (-1);
	}
	}
	}

	/* Snapshot or bookmark delimiter found */
	if (end == '@' \|\| end == '#') {
	/* Multiple delimiters are not allowed */
	if (found_delim != 0) {
	if (why)
	*why = NAME_ERR_MULTIPLE_DELIMITERS;
	return (-1);
	}

	found_delim = B_TRUE;
	}

	/* Zero-length components are not allowed */
	if (start == end) {
	if (why)
	*why = NAME_ERR_EMPTY_COMPONENT;
	return (-1);
	}

	/* If we've reached the end of the string, we're OK */
	if (*end == '\0')
	return (0);

	/*
	* If there is a '/' in a snapshot or bookmark name
	* then report an error
	*/
	if (*end == '/' && found_delim != 0) {
	if (why)
	*why = NAME_ERR_TRAILING_SLASH;
	return (-1);
	}

	/* Update to the next component */
	start = end + 1;
	}
	}

	/*
	* Dataset is any entity, except bookmark
	*/
	int
	dataset_namecheck(const char path, namecheck_err_t why, char *what)
	{
	int ret = entity_namecheck(path, why, what);

	if (ret == 0 && strchr(path, '#') != NULL) {
	if (why != NULL) {
	*why = NAME_ERR_INVALCHAR;
	*what = '#';
	}
	return (-1);
	}

	return (ret);
	}

	/*
	* Assert path is a valid bookmark name
	*/
	int
	bookmark_namecheck(const char path, namecheck_err_t why, char *what)
	{
	int ret = entity_namecheck(path, why, what);

	if (ret == 0 && strchr(path, '#') == NULL) {
	if (why != NULL) {
	*why = NAME_ERR_NO_POUND;
	*what = '#';
	}
	return (-1);
	}

	return (ret);
	}

	/*
	* Assert path is a valid snapshot name
	*/
	int
	snapshot_namecheck(const char path, namecheck_err_t why, char *what)
	{
	int ret = entity_namecheck(path, why, what);

	if (ret == 0 && strchr(path, '@') == NULL) {
	if (why != NULL) {
	*why = NAME_ERR_NO_AT;
	*what = '@';
	}
	return (-1);
	}

	return (ret);
	}

	/*
	* mountpoint names must be of the following form:
	*
	* /[component][/]*[component][/]
	*
	* Returns 0 on success, -1 on error.
	*/
	int
	mountpoint_namecheck(const char path, namecheck_err_t why)
	{
	const char start, end;

	/*
	* Make sure none of the mountpoint component names are too long.
	* If a component name is too long then the mkdir of the mountpoint
	* will fail but then the mountpoint property will be set to a value
	* that can never be mounted. Better to fail before setting the prop.
	* Extra slashes are OK, they will be tossed by the mountpoint mkdir.
	*/

	if (path == NULL \|\| *path != '/') {
	if (why)
	*why = NAME_ERR_LEADING_SLASH;
	return (-1);
	}

	/* Skip leading slash */
	start = &path[1];
	do {
	end = start;
	while (end != '/' && end != '\0')
	end++;

	if (end - start >= ZFS_MAX_DATASET_NAME_LEN) {
	if (why)
	*why = NAME_ERR_TOOLONG;
	return (-1);
	}
	start = end + 1;

	} while (*end != '\0');

	return (0);
	}

	/*
	* For pool names, we have the same set of valid characters as described in
	* dataset names, with the additional restriction that the pool name must begin
	* with a letter. The pool names 'raidz' and 'mirror' are also reserved names
	* that cannot be used.
	*
	* Returns 0 on success, -1 on error.
	*/
	int
	pool_namecheck(const char pool, namecheck_err_t why, char *what)
	{
	const char *c;

	/*
	* Make sure the name is not too long.
	* If we're creating a pool with version >= SPA_VERSION_DSL_SCRUB (v11)
	* we need to account for additional space needed by the origin ds which
	* will also be snapshotted: "poolname"+"/"+"$ORIGIN"+"@"+"$ORIGIN".
	* Play it safe and enforce this limit even if the pool version is < 11
	* so it can be upgraded without issues.
	*/
	if (strlen(pool) >= (ZFS_MAX_DATASET_NAME_LEN - 2 -
	strlen(ORIGIN_DIR_NAME) * 2)) {
	if (why)
	*why = NAME_ERR_TOOLONG;
	return (-1);
	}

	c = pool;
	while (*c != '\0') {
	if (!valid_char(*c)) {
	if (why) {
	*why = NAME_ERR_INVALCHAR;
	what = c;
	}
	return (-1);
	}
	c++;
	}

	if (!(pool >= 'a' && pool <= 'z') &&
	!(pool >= 'A' && pool <= 'Z')) {
	if (why)
	*why = NAME_ERR_NOLETTER;
	return (-1);
	}

	if (strcmp(pool, "mirror") == 0 \|\|
	strcmp(pool, "raidz") == 0 \|\|
	strcmp(pool, "draid") == 0) {
	if (why)
	*why = NAME_ERR_RESERVED;
	return (-1);
	}

	- if (pool[0] == 'c' && (pool[1] >= '0' && pool[1] <= '9')) {
	- if (why)
	- *why = NAME_ERR_DISKLIKE;
	- return (-1);
	- }
	-
	return (0);
	}

	EXPORT_SYMBOL(entity_namecheck);
	EXPORT_SYMBOL(pool_namecheck);
	EXPORT_SYMBOL(dataset_namecheck);
	EXPORT_SYMBOL(bookmark_namecheck);
	EXPORT_SYMBOL(snapshot_namecheck);
	EXPORT_SYMBOL(zfs_component_namecheck);
	EXPORT_SYMBOL(dataset_nestcheck);
	EXPORT_SYMBOL(get_dataset_depth);
	EXPORT_SYMBOL(zfs_max_dataset_nesting);

	ZFS_MODULE_PARAM(zfs, zfs_, max_dataset_nesting, INT, ZMOD_RW,
	"Limit to the amount of nesting a path can have. Defaults to 50.");
	diff --git a/sys/contrib/openzfs/module/zfs/abd.c b/sys/contrib/openzfs/module/zfs/abd.c
	index 1e6645c90c95..2d1be9752d4f 100644
	--- a/sys/contrib/openzfs/module/zfs/abd.c
	+++ b/sys/contrib/openzfs/module/zfs/abd.c
	@@ -1,1216 +1,1216 @@
	/*
	* 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) 2014 by Chunwei Chen. All rights reserved.
	* Copyright (c) 2019 by Delphix. All rights reserved.
	*/

	/*
	* ARC buffer data (ABD).
	*
	* ABDs are an abstract data structure for the ARC which can use two
	* different ways of storing the underlying data:
	*
	* (a) Linear buffer. In this case, all the data in the ABD is stored in one
	* contiguous buffer in memory (from a zio_[data_]buf_* kmem cache).
	*
	* +-------------------+
	* \| ABD (linear) \|
	* \| abd_flags = ... \|
	* \| abd_size = ... \| +--------------------------------+
	* \| abd_buf ------------->\| raw buffer of size abd_size \|
	* +-------------------+ +--------------------------------+
	* no abd_chunks
	*
	* (b) Scattered buffer. In this case, the data in the ABD is split into
	* equal-sized chunks (from the abd_chunk_cache kmem_cache), with pointers
	* to the chunks recorded in an array at the end of the ABD structure.
	*
	* +-------------------+
	* \| ABD (scattered) \|
	* \| abd_flags = ... \|
	* \| abd_size = ... \|
	* \| abd_offset = 0 \| +-----------+
	* \| abd_chunks[0] ----------------------------->\| chunk 0 \|
	* \| abd_chunks[1] ---------------------+ +-----------+
	* \| ... \| \| +-----------+
	* \| abd_chunks[N-1] ---------+ +------->\| chunk 1 \|
	* +-------------------+ \| +-----------+
	* \| ...
	* \| +-----------+
	* +----------------->\| chunk N-1 \|
	* +-----------+
	*
	* In addition to directly allocating a linear or scattered ABD, it is also
	* possible to create an ABD by requesting the "sub-ABD" starting at an offset
	* within an existing ABD. In linear buffers this is simple (set abd_buf of
	* the new ABD to the starting point within the original raw buffer), but
	* scattered ABDs are a little more complex. The new ABD makes a copy of the
	* relevant abd_chunks pointers (but not the underlying data). However, to
	* provide arbitrary rather than only chunk-aligned starting offsets, it also
	* tracks an abd_offset field which represents the starting point of the data
	* within the first chunk in abd_chunks. For both linear and scattered ABDs,
	* creating an offset ABD marks the original ABD as the offset's parent, and the
	* original ABD's abd_children refcount is incremented. This data allows us to
	* ensure the root ABD isn't deleted before its children.
	*
	* Most consumers should never need to know what type of ABD they're using --
	* the ABD public API ensures that it's possible to transparently switch from
	* using a linear ABD to a scattered one when doing so would be beneficial.
	*
	* If you need to use the data within an ABD directly, if you know it's linear
	* (because you allocated it) you can use abd_to_buf() to access the underlying
	* raw buffer. Otherwise, you should use one of the abd_borrow_buf* functions
	* which will allocate a raw buffer if necessary. Use the abd_return_buf*
	* functions to return any raw buffers that are no longer necessary when you're
	* done using them.
	*
	* There are a variety of ABD APIs that implement basic buffer operations:
	* compare, copy, read, write, and fill with zeroes. If you need a custom
	* function which progressively accesses the whole ABD, use the abd_iterate_*
	* functions.
	*
	* As an additional feature, linear and scatter ABD's can be stitched together
	* by using the gang ABD type (abd_alloc_gang_abd()). This allows for
	* multiple ABDs to be viewed as a singular ABD.
	*
	* It is possible to make all ABDs linear by setting zfs_abd_scatter_enabled to
	* B_FALSE.
	*/

	#include <sys/abd_impl.h>
	#include <sys/param.h>
	#include <sys/zio.h>
	#include <sys/zfs_context.h>
	#include <sys/zfs_znode.h>

	/* see block comment above for description */
	int zfs_abd_scatter_enabled = B_TRUE;

	void
	abd_verify(abd_t *abd)
	{
	ASSERT3U(abd->abd_size, >, 0);
	ASSERT3U(abd->abd_size, <=, SPA_MAXBLOCKSIZE);
	ASSERT3U(abd->abd_flags, ==, abd->abd_flags & (ABD_FLAG_LINEAR \|
	ABD_FLAG_OWNER \| ABD_FLAG_META \| ABD_FLAG_MULTI_ZONE \|
	ABD_FLAG_MULTI_CHUNK \| ABD_FLAG_LINEAR_PAGE \| ABD_FLAG_GANG \|
	ABD_FLAG_GANG_FREE \| ABD_FLAG_ZEROS \| ABD_FLAG_ALLOCD));
	#ifdef ZFS_DEBUG
	IMPLY(abd->abd_parent != NULL, !(abd->abd_flags & ABD_FLAG_OWNER));
	#endif
	IMPLY(abd->abd_flags & ABD_FLAG_META, abd->abd_flags & ABD_FLAG_OWNER);
	if (abd_is_linear(abd)) {
	ASSERT3P(ABD_LINEAR_BUF(abd), !=, NULL);
	} else if (abd_is_gang(abd)) {
	uint_t child_sizes = 0;
	for (abd_t *cabd = list_head(&ABD_GANG(abd).abd_gang_chain);
	cabd != NULL;
	cabd = list_next(&ABD_GANG(abd).abd_gang_chain, cabd)) {
	ASSERT(list_link_active(&cabd->abd_gang_link));
	child_sizes += cabd->abd_size;
	abd_verify(cabd);
	}
	ASSERT3U(abd->abd_size, ==, child_sizes);
	} else {
	abd_verify_scatter(abd);
	}
	}

	static void
	abd_init_struct(abd_t *abd)
	{
	list_link_init(&abd->abd_gang_link);
	mutex_init(&abd->abd_mtx, NULL, MUTEX_DEFAULT, NULL);
	abd->abd_flags = 0;
	#ifdef ZFS_DEBUG
	zfs_refcount_create(&abd->abd_children);
	abd->abd_parent = NULL;
	#endif
	abd->abd_size = 0;
	}

	static void
	abd_fini_struct(abd_t *abd)
	{
	mutex_destroy(&abd->abd_mtx);
	ASSERT(!list_link_active(&abd->abd_gang_link));
	#ifdef ZFS_DEBUG
	zfs_refcount_destroy(&abd->abd_children);
	#endif
	}

	abd_t *
	abd_alloc_struct(size_t size)
	{
	abd_t *abd = abd_alloc_struct_impl(size);
	abd_init_struct(abd);
	abd->abd_flags \|= ABD_FLAG_ALLOCD;
	return (abd);
	}

	void
	abd_free_struct(abd_t *abd)
	{
	abd_fini_struct(abd);
	abd_free_struct_impl(abd);
	}

	/*
	* Allocate an ABD, along with its own underlying data buffers. Use this if you
	* don't care whether the ABD is linear or not.
	*/
	abd_t *
	abd_alloc(size_t size, boolean_t is_metadata)
	{
	if (!zfs_abd_scatter_enabled \|\| abd_size_alloc_linear(size))
	return (abd_alloc_linear(size, is_metadata));

	VERIFY3U(size, <=, SPA_MAXBLOCKSIZE);

	abd_t *abd = abd_alloc_struct(size);
	abd->abd_flags \|= ABD_FLAG_OWNER;
	abd->abd_u.abd_scatter.abd_offset = 0;
	abd_alloc_chunks(abd, size);

	if (is_metadata) {
	abd->abd_flags \|= ABD_FLAG_META;
	}
	abd->abd_size = size;

	abd_update_scatter_stats(abd, ABDSTAT_INCR);

	return (abd);
	}

	/*
	* Allocate an ABD that must be linear, along with its own underlying data
	* buffer. Only use this when it would be very annoying to write your ABD
	* consumer with a scattered ABD.
	*/
	abd_t *
	abd_alloc_linear(size_t size, boolean_t is_metadata)
	{
	abd_t *abd = abd_alloc_struct(0);

	VERIFY3U(size, <=, SPA_MAXBLOCKSIZE);

	abd->abd_flags \|= ABD_FLAG_LINEAR \| ABD_FLAG_OWNER;
	if (is_metadata) {
	abd->abd_flags \|= ABD_FLAG_META;
	}
	abd->abd_size = size;

	if (is_metadata) {
	ABD_LINEAR_BUF(abd) = zio_buf_alloc(size);
	} else {
	ABD_LINEAR_BUF(abd) = zio_data_buf_alloc(size);
	}

	abd_update_linear_stats(abd, ABDSTAT_INCR);

	return (abd);
	}

	static void
	abd_free_linear(abd_t *abd)
	{
	if (abd_is_linear_page(abd)) {
	abd_free_linear_page(abd);
	return;
	}
	if (abd->abd_flags & ABD_FLAG_META) {
	zio_buf_free(ABD_LINEAR_BUF(abd), abd->abd_size);
	} else {
	zio_data_buf_free(ABD_LINEAR_BUF(abd), abd->abd_size);
	}

	abd_update_linear_stats(abd, ABDSTAT_DECR);
	}

	static void
	abd_free_gang(abd_t *abd)
	{
	ASSERT(abd_is_gang(abd));
	abd_t *cabd;

	while ((cabd = list_head(&ABD_GANG(abd).abd_gang_chain)) != NULL) {
	/*
	* We must acquire the child ABDs mutex to ensure that if it
	* is being added to another gang ABD we will set the link
	* as inactive when removing it from this gang ABD and before
	* adding it to the other gang ABD.
	*/
	mutex_enter(&cabd->abd_mtx);
	ASSERT(list_link_active(&cabd->abd_gang_link));
	list_remove(&ABD_GANG(abd).abd_gang_chain, cabd);
	mutex_exit(&cabd->abd_mtx);
	if (cabd->abd_flags & ABD_FLAG_GANG_FREE)
	abd_free(cabd);
	}
	list_destroy(&ABD_GANG(abd).abd_gang_chain);
	}

	static void
	abd_free_scatter(abd_t *abd)
	{
	abd_free_chunks(abd);
	abd_update_scatter_stats(abd, ABDSTAT_DECR);
	}

	/*
	* Free an ABD. Use with any kind of abd: those created with abd_alloc_*()
	* and abd_get_*(), including abd_get_offset_struct().
	*
	* If the ABD was created with abd_alloc_*(), the underlying data
	* (scatterlist or linear buffer) will also be freed. (Subject to ownership
	* changes via abd_*_ownership_of_buf().)
	*
	* Unless the ABD was created with abd_get_offset_struct(), the abd_t will
	* also be freed.
	*/
	void
	abd_free(abd_t *abd)
	{
	if (abd == NULL)
	return;

	abd_verify(abd);
	#ifdef ZFS_DEBUG
	IMPLY(abd->abd_flags & ABD_FLAG_OWNER, abd->abd_parent == NULL);
	#endif

	if (abd_is_gang(abd)) {
	abd_free_gang(abd);
	} else if (abd_is_linear(abd)) {
	if (abd->abd_flags & ABD_FLAG_OWNER)
	abd_free_linear(abd);
	} else {
	if (abd->abd_flags & ABD_FLAG_OWNER)
	abd_free_scatter(abd);
	}

	#ifdef ZFS_DEBUG
	if (abd->abd_parent != NULL) {
	(void) zfs_refcount_remove_many(&abd->abd_parent->abd_children,
	abd->abd_size, abd);
	}
	#endif

	abd_fini_struct(abd);
	if (abd->abd_flags & ABD_FLAG_ALLOCD)
	abd_free_struct_impl(abd);
	}

	/*
	* Allocate an ABD of the same format (same metadata flag, same scatterize
	* setting) as another ABD.
	*/
	abd_t *
	abd_alloc_sametype(abd_t *sabd, size_t size)
	{
	boolean_t is_metadata = (sabd->abd_flags & ABD_FLAG_META) != 0;
	if (abd_is_linear(sabd) &&
	!abd_is_linear_page(sabd)) {
	return (abd_alloc_linear(size, is_metadata));
	} else {
	return (abd_alloc(size, is_metadata));
	}
	}

	/*
	* Create gang ABD that will be the head of a list of ABD's. This is used
	* to "chain" scatter/gather lists together when constructing aggregated
	* IO's. To free this abd, abd_free() must be called.
	*/
	abd_t *
	abd_alloc_gang(void)
	{
	abd_t *abd = abd_alloc_struct(0);
	abd->abd_flags \|= ABD_FLAG_GANG \| ABD_FLAG_OWNER;
	list_create(&ABD_GANG(abd).abd_gang_chain,
	sizeof (abd_t), offsetof(abd_t, abd_gang_link));
	return (abd);
	}

	/*
	* Add a child gang ABD to a parent gang ABDs chained list.
	*/
	static void
	abd_gang_add_gang(abd_t pabd, abd_t cabd, boolean_t free_on_free)
	{
	ASSERT(abd_is_gang(pabd));
	ASSERT(abd_is_gang(cabd));

	if (free_on_free) {
	/*
	* If the parent is responsible for freeing the child gang
	* ABD we will just splice the child's children ABD list to
	* the parent's list and immediately free the child gang ABD
	* struct. The parent gang ABDs children from the child gang
	* will retain all the free_on_free settings after being
	* added to the parents list.
	*/
	pabd->abd_size += cabd->abd_size;
	list_move_tail(&ABD_GANG(pabd).abd_gang_chain,
	&ABD_GANG(cabd).abd_gang_chain);
	ASSERT(list_is_empty(&ABD_GANG(cabd).abd_gang_chain));
	abd_verify(pabd);
	abd_free(cabd);
	} else {
	for (abd_t *child = list_head(&ABD_GANG(cabd).abd_gang_chain);
	child != NULL;
	child = list_next(&ABD_GANG(cabd).abd_gang_chain, child)) {
	/*
	* We always pass B_FALSE for free_on_free as it is the
	- * original child gang ABDs responsibilty to determine
	+ * original child gang ABDs responsibility to determine
	* if any of its child ABDs should be free'd on the call
	* to abd_free().
	*/
	abd_gang_add(pabd, child, B_FALSE);
	}
	abd_verify(pabd);
	}
	}

	/*
	* Add a child ABD to a gang ABD's chained list.
	*/
	void
	abd_gang_add(abd_t pabd, abd_t cabd, boolean_t free_on_free)
	{
	ASSERT(abd_is_gang(pabd));
	abd_t *child_abd = NULL;

	/*
	* If the child being added is a gang ABD, we will add the
	* child's ABDs to the parent gang ABD. This allows us to account
	* for the offset correctly in the parent gang ABD.
	*/
	if (abd_is_gang(cabd)) {
	ASSERT(!list_link_active(&cabd->abd_gang_link));
	ASSERT(!list_is_empty(&ABD_GANG(cabd).abd_gang_chain));
	return (abd_gang_add_gang(pabd, cabd, free_on_free));
	}
	ASSERT(!abd_is_gang(cabd));

	/*
	* In order to verify that an ABD is not already part of
	* another gang ABD, we must lock the child ABD's abd_mtx
	* to check its abd_gang_link status. We unlock the abd_mtx
	* only after it is has been added to a gang ABD, which
	* will update the abd_gang_link's status. See comment below
	* for how an ABD can be in multiple gang ABD's simultaneously.
	*/
	mutex_enter(&cabd->abd_mtx);
	if (list_link_active(&cabd->abd_gang_link)) {
	/*
	* If the child ABD is already part of another
	* gang ABD then we must allocate a new
	* ABD to use a separate link. We mark the newly
	* allocated ABD with ABD_FLAG_GANG_FREE, before
	* adding it to the gang ABD's list, to make the
	* gang ABD aware that it is responsible to call
	* abd_free(). We use abd_get_offset() in order
	* to just allocate a new ABD but avoid copying the
	* data over into the newly allocated ABD.
	*
	* An ABD may become part of multiple gang ABD's. For
	* example, when writing ditto bocks, the same ABD
	* is used to write 2 or 3 locations with 2 or 3
	* zio_t's. Each of the zio's may be aggregated with
	* different adjacent zio's. zio aggregation uses gang
	* zio's, so the single ABD can become part of multiple
	* gang zio's.
	*
	* The ASSERT below is to make sure that if
	* free_on_free is passed as B_TRUE, the ABD can
	* not be in multiple gang ABD's. The gang ABD
	* can not be responsible for cleaning up the child
	* ABD memory allocation if the ABD can be in
	* multiple gang ABD's at one time.
	*/
	ASSERT3B(free_on_free, ==, B_FALSE);
	child_abd = abd_get_offset(cabd, 0);
	child_abd->abd_flags \|= ABD_FLAG_GANG_FREE;
	} else {
	child_abd = cabd;
	if (free_on_free)
	child_abd->abd_flags \|= ABD_FLAG_GANG_FREE;
	}
	ASSERT3P(child_abd, !=, NULL);

	list_insert_tail(&ABD_GANG(pabd).abd_gang_chain, child_abd);
	mutex_exit(&cabd->abd_mtx);
	pabd->abd_size += child_abd->abd_size;
	}

	/*
	* Locate the ABD for the supplied offset in the gang ABD.
	* Return a new offset relative to the returned ABD.
	*/
	abd_t *
	abd_gang_get_offset(abd_t abd, size_t off)
	{
	abd_t *cabd;

	ASSERT(abd_is_gang(abd));
	ASSERT3U(*off, <, abd->abd_size);
	for (cabd = list_head(&ABD_GANG(abd).abd_gang_chain); cabd != NULL;
	cabd = list_next(&ABD_GANG(abd).abd_gang_chain, cabd)) {
	if (*off >= cabd->abd_size)
	*off -= cabd->abd_size;
	else
	return (cabd);
	}
	VERIFY3P(cabd, !=, NULL);
	return (cabd);
	}

	/*
	* Allocate a new ABD, using the provided struct (if non-NULL, and if
	* circumstances allow - otherwise allocate the struct). The returned ABD will
	* point to offset off of sabd. It shares the underlying buffer data with sabd.
	* Use abd_free() to free. sabd must not be freed while any derived ABDs exist.
	*/
	static abd_t *
	abd_get_offset_impl(abd_t abd, abd_t sabd, size_t off, size_t size)
	{
	abd_verify(sabd);
	ASSERT3U(off + size, <=, sabd->abd_size);

	if (abd_is_linear(sabd)) {
	if (abd == NULL)
	abd = abd_alloc_struct(0);
	/*
	* Even if this buf is filesystem metadata, we only track that
	* if we own the underlying data buffer, which is not true in
	* this case. Therefore, we don't ever use ABD_FLAG_META here.
	*/
	abd->abd_flags \|= ABD_FLAG_LINEAR;

	ABD_LINEAR_BUF(abd) = (char *)ABD_LINEAR_BUF(sabd) + off;
	} else if (abd_is_gang(sabd)) {
	size_t left = size;
	if (abd == NULL) {
	abd = abd_alloc_gang();
	} else {
	abd->abd_flags \|= ABD_FLAG_GANG;
	list_create(&ABD_GANG(abd).abd_gang_chain,
	sizeof (abd_t), offsetof(abd_t, abd_gang_link));
	}

	abd->abd_flags &= ~ABD_FLAG_OWNER;
	for (abd_t *cabd = abd_gang_get_offset(sabd, &off);
	cabd != NULL && left > 0;
	cabd = list_next(&ABD_GANG(sabd).abd_gang_chain, cabd)) {
	int csize = MIN(left, cabd->abd_size - off);

	abd_t *nabd = abd_get_offset_size(cabd, off, csize);
	abd_gang_add(abd, nabd, B_TRUE);
	left -= csize;
	off = 0;
	}
	ASSERT3U(left, ==, 0);
	} else {
	abd = abd_get_offset_scatter(abd, sabd, off);
	}

	ASSERT3P(abd, !=, NULL);
	abd->abd_size = size;
	#ifdef ZFS_DEBUG
	abd->abd_parent = sabd;
	(void) zfs_refcount_add_many(&sabd->abd_children, abd->abd_size, abd);
	#endif
	return (abd);
	}

	/*
	* Like abd_get_offset_size(), but memory for the abd_t is provided by the
	* caller. Using this routine can improve performance by avoiding the cost
	* of allocating memory for the abd_t struct, and updating the abd stats.
	* Usually, the provided abd is returned, but in some circumstances (FreeBSD,
	* if sabd is scatter and size is more than 2 pages) a new abd_t may need to
	* be allocated. Therefore callers should be careful to use the returned
	* abd_t*.
	*/
	abd_t *
	abd_get_offset_struct(abd_t abd, abd_t sabd, size_t off, size_t size)
	{
	abd_t *result;
	abd_init_struct(abd);
	result = abd_get_offset_impl(abd, sabd, off, size);
	if (result != abd)
	abd_fini_struct(abd);
	return (result);
	}

	abd_t *
	abd_get_offset(abd_t *sabd, size_t off)
	{
	size_t size = sabd->abd_size > off ? sabd->abd_size - off : 0;
	VERIFY3U(size, >, 0);
	return (abd_get_offset_impl(NULL, sabd, off, size));
	}

	abd_t *
	abd_get_offset_size(abd_t *sabd, size_t off, size_t size)
	{
	ASSERT3U(off + size, <=, sabd->abd_size);
	return (abd_get_offset_impl(NULL, sabd, off, size));
	}

	/*
	* Return a size scatter ABD containing only zeros.
	*/
	abd_t *
	abd_get_zeros(size_t size)
	{
	ASSERT3P(abd_zero_scatter, !=, NULL);
	ASSERT3U(size, <=, SPA_MAXBLOCKSIZE);
	return (abd_get_offset_size(abd_zero_scatter, 0, size));
	}

	/*
	* Allocate a linear ABD structure for buf.
	*/
	abd_t *
	abd_get_from_buf(void *buf, size_t size)
	{
	abd_t *abd = abd_alloc_struct(0);

	VERIFY3U(size, <=, SPA_MAXBLOCKSIZE);

	/*
	* Even if this buf is filesystem metadata, we only track that if we
	* own the underlying data buffer, which is not true in this case.
	* Therefore, we don't ever use ABD_FLAG_META here.
	*/
	abd->abd_flags \|= ABD_FLAG_LINEAR;
	abd->abd_size = size;

	ABD_LINEAR_BUF(abd) = buf;

	return (abd);
	}

	/*
	* Get the raw buffer associated with a linear ABD.
	*/
	void *
	abd_to_buf(abd_t *abd)
	{
	ASSERT(abd_is_linear(abd));
	abd_verify(abd);
	return (ABD_LINEAR_BUF(abd));
	}

	/*
	* Borrow a raw buffer from an ABD without copying the contents of the ABD
	* into the buffer. If the ABD is scattered, this will allocate a raw buffer
	* whose contents are undefined. To copy over the existing data in the ABD, use
	* abd_borrow_buf_copy() instead.
	*/
	void *
	abd_borrow_buf(abd_t *abd, size_t n)
	{
	void *buf;
	abd_verify(abd);
	ASSERT3U(abd->abd_size, >=, n);
	if (abd_is_linear(abd)) {
	buf = abd_to_buf(abd);
	} else {
	buf = zio_buf_alloc(n);
	}
	#ifdef ZFS_DEBUG
	(void) zfs_refcount_add_many(&abd->abd_children, n, buf);
	#endif
	return (buf);
	}

	void *
	abd_borrow_buf_copy(abd_t *abd, size_t n)
	{
	void *buf = abd_borrow_buf(abd, n);
	if (!abd_is_linear(abd)) {
	abd_copy_to_buf(buf, abd, n);
	}
	return (buf);
	}

	/*
	* Return a borrowed raw buffer to an ABD. If the ABD is scattered, this will
	* not change the contents of the ABD and will ASSERT that you didn't modify
	* the buffer since it was borrowed. If you want any changes you made to buf to
	* be copied back to abd, use abd_return_buf_copy() instead.
	*/
	void
	abd_return_buf(abd_t abd, void buf, size_t n)
	{
	abd_verify(abd);
	ASSERT3U(abd->abd_size, >=, n);
	if (abd_is_linear(abd)) {
	ASSERT3P(buf, ==, abd_to_buf(abd));
	} else {
	ASSERT0(abd_cmp_buf(abd, buf, n));
	zio_buf_free(buf, n);
	}
	#ifdef ZFS_DEBUG
	(void) zfs_refcount_remove_many(&abd->abd_children, n, buf);
	#endif
	}

	void
	abd_return_buf_copy(abd_t abd, void buf, size_t n)
	{
	if (!abd_is_linear(abd)) {
	abd_copy_from_buf(abd, buf, n);
	}
	abd_return_buf(abd, buf, n);
	}

	void
	abd_release_ownership_of_buf(abd_t *abd)
	{
	ASSERT(abd_is_linear(abd));
	ASSERT(abd->abd_flags & ABD_FLAG_OWNER);

	/*
	* abd_free() needs to handle LINEAR_PAGE ABD's specially.
	* Since that flag does not survive the
	* abd_release_ownership_of_buf() -> abd_get_from_buf() ->
	* abd_take_ownership_of_buf() sequence, we don't allow releasing
	* these "linear but not zio_[data_]buf_alloc()'ed" ABD's.
	*/
	ASSERT(!abd_is_linear_page(abd));

	abd_verify(abd);

	abd->abd_flags &= ~ABD_FLAG_OWNER;
	/* Disable this flag since we no longer own the data buffer */
	abd->abd_flags &= ~ABD_FLAG_META;

	abd_update_linear_stats(abd, ABDSTAT_DECR);
	}


	/*
	* Give this ABD ownership of the buffer that it's storing. Can only be used on
	* linear ABDs which were allocated via abd_get_from_buf(), or ones allocated
	* with abd_alloc_linear() which subsequently released ownership of their buf
	* with abd_release_ownership_of_buf().
	*/
	void
	abd_take_ownership_of_buf(abd_t *abd, boolean_t is_metadata)
	{
	ASSERT(abd_is_linear(abd));
	ASSERT(!(abd->abd_flags & ABD_FLAG_OWNER));
	abd_verify(abd);

	abd->abd_flags \|= ABD_FLAG_OWNER;
	if (is_metadata) {
	abd->abd_flags \|= ABD_FLAG_META;
	}

	abd_update_linear_stats(abd, ABDSTAT_INCR);
	}

	/*
	* Initializes an abd_iter based on whether the abd is a gang ABD
	* or just a single ABD.
	*/
	static inline abd_t *
	abd_init_abd_iter(abd_t abd, struct abd_iter aiter, size_t off)
	{
	abd_t *cabd = NULL;

	if (abd_is_gang(abd)) {
	cabd = abd_gang_get_offset(abd, &off);
	if (cabd) {
	abd_iter_init(aiter, cabd);
	abd_iter_advance(aiter, off);
	}
	} else {
	abd_iter_init(aiter, abd);
	abd_iter_advance(aiter, off);
	}
	return (cabd);
	}

	/*
	* Advances an abd_iter. We have to be careful with gang ABD as
	* advancing could mean that we are at the end of a particular ABD and
	* must grab the ABD in the gang ABD's list.
	*/
	static inline abd_t *
	abd_advance_abd_iter(abd_t abd, abd_t cabd, struct abd_iter *aiter,
	size_t len)
	{
	abd_iter_advance(aiter, len);
	if (abd_is_gang(abd) && abd_iter_at_end(aiter)) {
	ASSERT3P(cabd, !=, NULL);
	cabd = list_next(&ABD_GANG(abd).abd_gang_chain, cabd);
	if (cabd) {
	abd_iter_init(aiter, cabd);
	abd_iter_advance(aiter, 0);
	}
	}
	return (cabd);
	}

	int
	abd_iterate_func(abd_t *abd, size_t off, size_t size,
	abd_iter_func_t func, void private)
	{
	struct abd_iter aiter;
	int ret = 0;

	if (size == 0)
	return (0);

	abd_verify(abd);
	ASSERT3U(off + size, <=, abd->abd_size);

	boolean_t gang = abd_is_gang(abd);
	abd_t *c_abd = abd_init_abd_iter(abd, &aiter, off);

	while (size > 0) {
	/* If we are at the end of the gang ABD we are done */
	if (gang && !c_abd)
	break;

	abd_iter_map(&aiter);

	size_t len = MIN(aiter.iter_mapsize, size);
	ASSERT3U(len, >, 0);

	ret = func(aiter.iter_mapaddr, len, private);

	abd_iter_unmap(&aiter);

	if (ret != 0)
	break;

	size -= len;
	c_abd = abd_advance_abd_iter(abd, c_abd, &aiter, len);
	}

	return (ret);
	}

	struct buf_arg {
	void *arg_buf;
	};

	static int
	abd_copy_to_buf_off_cb(void buf, size_t size, void private)
	{
	struct buf_arg *ba_ptr = private;

	(void) memcpy(ba_ptr->arg_buf, buf, size);
	ba_ptr->arg_buf = (char *)ba_ptr->arg_buf + size;

	return (0);
	}

	/*
	* Copy abd to buf. (off is the offset in abd.)
	*/
	void
	abd_copy_to_buf_off(void buf, abd_t abd, size_t off, size_t size)
	{
	struct buf_arg ba_ptr = { buf };

	(void) abd_iterate_func(abd, off, size, abd_copy_to_buf_off_cb,
	&ba_ptr);
	}

	static int
	abd_cmp_buf_off_cb(void buf, size_t size, void private)
	{
	int ret;
	struct buf_arg *ba_ptr = private;

	ret = memcmp(buf, ba_ptr->arg_buf, size);
	ba_ptr->arg_buf = (char *)ba_ptr->arg_buf + size;

	return (ret);
	}

	/*
	* Compare the contents of abd to buf. (off is the offset in abd.)
	*/
	int
	abd_cmp_buf_off(abd_t abd, const void buf, size_t off, size_t size)
	{
	struct buf_arg ba_ptr = { (void *) buf };

	return (abd_iterate_func(abd, off, size, abd_cmp_buf_off_cb, &ba_ptr));
	}

	static int
	abd_copy_from_buf_off_cb(void buf, size_t size, void private)
	{
	struct buf_arg *ba_ptr = private;

	(void) memcpy(buf, ba_ptr->arg_buf, size);
	ba_ptr->arg_buf = (char *)ba_ptr->arg_buf + size;

	return (0);
	}

	/*
	* Copy from buf to abd. (off is the offset in abd.)
	*/
	void
	abd_copy_from_buf_off(abd_t abd, const void buf, size_t off, size_t size)
	{
	struct buf_arg ba_ptr = { (void *) buf };

	(void) abd_iterate_func(abd, off, size, abd_copy_from_buf_off_cb,
	&ba_ptr);
	}

	/ARGSUSED/
	static int
	abd_zero_off_cb(void buf, size_t size, void private)
	{
	(void) memset(buf, 0, size);
	return (0);
	}

	/*
	* Zero out the abd from a particular offset to the end.
	*/
	void
	abd_zero_off(abd_t *abd, size_t off, size_t size)
	{
	(void) abd_iterate_func(abd, off, size, abd_zero_off_cb, NULL);
	}

	/*
	* Iterate over two ABDs and call func incrementally on the two ABDs' data in
	* equal-sized chunks (passed to func as raw buffers). func could be called many
	* times during this iteration.
	*/
	int
	abd_iterate_func2(abd_t dabd, abd_t sabd, size_t doff, size_t soff,
	size_t size, abd_iter_func2_t func, void private)
	{
	int ret = 0;
	struct abd_iter daiter, saiter;
	boolean_t dabd_is_gang_abd, sabd_is_gang_abd;
	abd_t c_dabd, c_sabd;

	if (size == 0)
	return (0);

	abd_verify(dabd);
	abd_verify(sabd);

	ASSERT3U(doff + size, <=, dabd->abd_size);
	ASSERT3U(soff + size, <=, sabd->abd_size);

	dabd_is_gang_abd = abd_is_gang(dabd);
	sabd_is_gang_abd = abd_is_gang(sabd);
	c_dabd = abd_init_abd_iter(dabd, &daiter, doff);
	c_sabd = abd_init_abd_iter(sabd, &saiter, soff);

	while (size > 0) {
	/* if we are at the end of the gang ABD we are done */
	if ((dabd_is_gang_abd && !c_dabd) \|\|
	(sabd_is_gang_abd && !c_sabd))
	break;

	abd_iter_map(&daiter);
	abd_iter_map(&saiter);

	size_t dlen = MIN(daiter.iter_mapsize, size);
	size_t slen = MIN(saiter.iter_mapsize, size);
	size_t len = MIN(dlen, slen);
	ASSERT(dlen > 0 \|\| slen > 0);

	ret = func(daiter.iter_mapaddr, saiter.iter_mapaddr, len,
	private);

	abd_iter_unmap(&saiter);
	abd_iter_unmap(&daiter);

	if (ret != 0)
	break;

	size -= len;
	c_dabd =
	abd_advance_abd_iter(dabd, c_dabd, &daiter, len);
	c_sabd =
	abd_advance_abd_iter(sabd, c_sabd, &saiter, len);
	}

	return (ret);
	}

	/ARGSUSED/
	static int
	abd_copy_off_cb(void dbuf, void sbuf, size_t size, void *private)
	{
	(void) memcpy(dbuf, sbuf, size);
	return (0);
	}

	/*
	* Copy from sabd to dabd starting from soff and doff.
	*/
	void
	abd_copy_off(abd_t dabd, abd_t sabd, size_t doff, size_t soff, size_t size)
	{
	(void) abd_iterate_func2(dabd, sabd, doff, soff, size,
	abd_copy_off_cb, NULL);
	}

	/ARGSUSED/
	static int
	abd_cmp_cb(void bufa, void bufb, size_t size, void *private)
	{
	return (memcmp(bufa, bufb, size));
	}

	/*
	* Compares the contents of two ABDs.
	*/
	int
	abd_cmp(abd_t dabd, abd_t sabd)
	{
	ASSERT3U(dabd->abd_size, ==, sabd->abd_size);
	return (abd_iterate_func2(dabd, sabd, 0, 0, dabd->abd_size,
	abd_cmp_cb, NULL));
	}

	/*
	* Iterate over code ABDs and a data ABD and call @func_raidz_gen.
	*
	* @cabds parity ABDs, must have equal size
	* @dabd data ABD. Can be NULL (in this case @dsize = 0)
	* @func_raidz_gen should be implemented so that its behaviour
	* is the same when taking linear and when taking scatter
	*/
	void
	abd_raidz_gen_iterate(abd_t *cabds, abd_t dabd,
	ssize_t csize, ssize_t dsize, const unsigned parity,
	void (func_raidz_gen)(void , const void , size_t, size_t))
	{
	int i;
	ssize_t len, dlen;
	struct abd_iter caiters[3];
	struct abd_iter daiter = {0};
	void *caddrs[3];
	unsigned long flags __maybe_unused = 0;
	abd_t *c_cabds[3];
	abd_t *c_dabd = NULL;
	boolean_t cabds_is_gang_abd[3];
	boolean_t dabd_is_gang_abd = B_FALSE;

	ASSERT3U(parity, <=, 3);

	for (i = 0; i < parity; i++) {
	cabds_is_gang_abd[i] = abd_is_gang(cabds[i]);
	c_cabds[i] = abd_init_abd_iter(cabds[i], &caiters[i], 0);
	}

	if (dabd) {
	dabd_is_gang_abd = abd_is_gang(dabd);
	c_dabd = abd_init_abd_iter(dabd, &daiter, 0);
	}

	ASSERT3S(dsize, >=, 0);

	abd_enter_critical(flags);
	while (csize > 0) {
	/* if we are at the end of the gang ABD we are done */
	if (dabd_is_gang_abd && !c_dabd)
	break;

	for (i = 0; i < parity; i++) {
	/*
	* If we are at the end of the gang ABD we are
	* done.
	*/
	if (cabds_is_gang_abd[i] && !c_cabds[i])
	break;
	abd_iter_map(&caiters[i]);
	caddrs[i] = caiters[i].iter_mapaddr;
	}

	len = csize;

	if (dabd && dsize > 0)
	abd_iter_map(&daiter);

	switch (parity) {
	case 3:
	len = MIN(caiters[2].iter_mapsize, len);
	/* falls through */
	case 2:
	len = MIN(caiters[1].iter_mapsize, len);
	/* falls through */
	case 1:
	len = MIN(caiters[0].iter_mapsize, len);
	}

	/* must be progressive */
	ASSERT3S(len, >, 0);

	if (dabd && dsize > 0) {
	/* this needs precise iter.length */
	len = MIN(daiter.iter_mapsize, len);
	dlen = len;
	} else
	dlen = 0;

	/* must be progressive */
	ASSERT3S(len, >, 0);
	/*
	* The iterated function likely will not do well if each
	* segment except the last one is not multiple of 512 (raidz).
	*/
	ASSERT3U(((uint64_t)len & 511ULL), ==, 0);

	func_raidz_gen(caddrs, daiter.iter_mapaddr, len, dlen);

	for (i = parity-1; i >= 0; i--) {
	abd_iter_unmap(&caiters[i]);
	c_cabds[i] =
	abd_advance_abd_iter(cabds[i], c_cabds[i],
	&caiters[i], len);
	}

	if (dabd && dsize > 0) {
	abd_iter_unmap(&daiter);
	c_dabd =
	abd_advance_abd_iter(dabd, c_dabd, &daiter,
	dlen);
	dsize -= dlen;
	}

	csize -= len;

	ASSERT3S(dsize, >=, 0);
	ASSERT3S(csize, >=, 0);
	}
	abd_exit_critical(flags);
	}

	/*
	* Iterate over code ABDs and data reconstruction target ABDs and call
	* @func_raidz_rec. Function maps at most 6 pages atomically.
	*
	* @cabds parity ABDs, must have equal size
	* @tabds rec target ABDs, at most 3
	* @tsize size of data target columns
	* @func_raidz_rec expects syndrome data in target columns. Function
	* reconstructs data and overwrites target columns.
	*/
	void
	abd_raidz_rec_iterate(abd_t cabds, abd_t tabds,
	ssize_t tsize, const unsigned parity,
	void (func_raidz_rec)(void t, const size_t tsize, void *c,
	const unsigned *mul),
	const unsigned *mul)
	{
	int i;
	ssize_t len;
	struct abd_iter citers[3];
	struct abd_iter xiters[3];
	void caddrs[3], xaddrs[3];
	unsigned long flags __maybe_unused = 0;
	boolean_t cabds_is_gang_abd[3];
	boolean_t tabds_is_gang_abd[3];
	abd_t *c_cabds[3];
	abd_t *c_tabds[3];

	ASSERT3U(parity, <=, 3);

	for (i = 0; i < parity; i++) {
	cabds_is_gang_abd[i] = abd_is_gang(cabds[i]);
	tabds_is_gang_abd[i] = abd_is_gang(tabds[i]);
	c_cabds[i] =
	abd_init_abd_iter(cabds[i], &citers[i], 0);
	c_tabds[i] =
	abd_init_abd_iter(tabds[i], &xiters[i], 0);
	}

	abd_enter_critical(flags);
	while (tsize > 0) {

	for (i = 0; i < parity; i++) {
	/*
	* If we are at the end of the gang ABD we
	* are done.
	*/
	if (cabds_is_gang_abd[i] && !c_cabds[i])
	break;
	if (tabds_is_gang_abd[i] && !c_tabds[i])
	break;
	abd_iter_map(&citers[i]);
	abd_iter_map(&xiters[i]);
	caddrs[i] = citers[i].iter_mapaddr;
	xaddrs[i] = xiters[i].iter_mapaddr;
	}

	len = tsize;
	switch (parity) {
	case 3:
	len = MIN(xiters[2].iter_mapsize, len);
	len = MIN(citers[2].iter_mapsize, len);
	/* falls through */
	case 2:
	len = MIN(xiters[1].iter_mapsize, len);
	len = MIN(citers[1].iter_mapsize, len);
	/* falls through */
	case 1:
	len = MIN(xiters[0].iter_mapsize, len);
	len = MIN(citers[0].iter_mapsize, len);
	}
	/* must be progressive */
	ASSERT3S(len, >, 0);
	/*
	* The iterated function likely will not do well if each
	* segment except the last one is not multiple of 512 (raidz).
	*/
	ASSERT3U(((uint64_t)len & 511ULL), ==, 0);

	func_raidz_rec(xaddrs, len, caddrs, mul);

	for (i = parity-1; i >= 0; i--) {
	abd_iter_unmap(&xiters[i]);
	abd_iter_unmap(&citers[i]);
	c_tabds[i] =
	abd_advance_abd_iter(tabds[i], c_tabds[i],
	&xiters[i], len);
	c_cabds[i] =
	abd_advance_abd_iter(cabds[i], c_cabds[i],
	&citers[i], len);
	}

	tsize -= len;
	ASSERT3S(tsize, >=, 0);
	}
	abd_exit_critical(flags);
	}
	diff --git a/sys/contrib/openzfs/module/zfs/arc.c b/sys/contrib/openzfs/module/zfs/arc.c
	index 55c71a3829cd..f0ae3938a333 100644
	--- a/sys/contrib/openzfs/module/zfs/arc.c
	+++ b/sys/contrib/openzfs/module/zfs/arc.c
	@@ -1,10769 +1,10769 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2018, Joyent, Inc.
	* Copyright (c) 2011, 2020, Delphix. All rights reserved.
	* Copyright (c) 2014, Saso Kiselkov. All rights reserved.
	* Copyright (c) 2017, Nexenta Systems, Inc. All rights reserved.
	* Copyright (c) 2019, loli10K <ezomori.nozomu@gmail.com>. All rights reserved.
	* Copyright (c) 2020, George Amanakis. All rights reserved.
	* Copyright (c) 2019, Klara Inc.
	* Copyright (c) 2019, Allan Jude
	* Copyright (c) 2020, The FreeBSD Foundation [1]
	*
	* [1] Portions of this software were developed by Allan Jude
	* under sponsorship from the FreeBSD Foundation.
	*/

	/*
	* DVA-based Adjustable Replacement Cache
	*
	* While much of the theory of operation used here is
	* based on the self-tuning, low overhead replacement cache
	* presented by Megiddo and Modha at FAST 2003, there are some
	* significant differences:
	*
	* 1. The Megiddo and Modha model assumes any page is evictable.
	* Pages in its cache cannot be "locked" into memory. This makes
	* the eviction algorithm simple: evict the last page in the list.
	* This also make the performance characteristics easy to reason
	* about. Our cache is not so simple. At any given moment, some
	* subset of the blocks in the cache are un-evictable because we
	* have handed out a reference to them. Blocks are only evictable
	* when there are no external references active. This makes
	* eviction far more problematic: we choose to evict the evictable
	* blocks that are the "lowest" in the list.
	*
	* There are times when it is not possible to evict the requested
	* space. In these circumstances we are unable to adjust the cache
	* size. To prevent the cache growing unbounded at these times we
	* implement a "cache throttle" that slows the flow of new data
	* into the cache until we can make space available.
	*
	* 2. The Megiddo and Modha model assumes a fixed cache size.
	* Pages are evicted when the cache is full and there is a cache
	* miss. Our model has a variable sized cache. It grows with
	* high use, but also tries to react to memory pressure from the
	* operating system: decreasing its size when system memory is
	* tight.
	*
	* 3. The Megiddo and Modha model assumes a fixed page size. All
	* elements of the cache are therefore exactly the same size. So
	* when adjusting the cache size following a cache miss, its simply
	* a matter of choosing a single page to evict. In our model, we
	* have variable sized cache blocks (ranging from 512 bytes to
	* 128K bytes). We therefore choose a set of blocks to evict to make
	* space for a cache miss that approximates as closely as possible
	* the space used by the new block.
	*
	* See also: "ARC: A Self-Tuning, Low Overhead Replacement Cache"
	* by N. Megiddo & D. Modha, FAST 2003
	*/

	/*
	* The locking model:
	*
	* A new reference to a cache buffer can be obtained in two
	* ways: 1) via a hash table lookup using the DVA as a key,
	* or 2) via one of the ARC lists. The arc_read() interface
	* uses method 1, while the internal ARC algorithms for
	* adjusting the cache use method 2. We therefore provide two
	* types of locks: 1) the hash table lock array, and 2) the
	* ARC list locks.
	*
	* Buffers do not have their own mutexes, rather they rely on the
	* hash table mutexes for the bulk of their protection (i.e. most
	* fields in the arc_buf_hdr_t are protected by these mutexes).
	*
	* buf_hash_find() returns the appropriate mutex (held) when it
	* locates the requested buffer in the hash table. It returns
	* NULL for the mutex if the buffer was not in the table.
	*
	* buf_hash_remove() expects the appropriate hash mutex to be
	* already held before it is invoked.
	*
	* Each ARC state also has a mutex which is used to protect the
	* buffer list associated with the state. When attempting to
	* obtain a hash table lock while holding an ARC list lock you
	* must use: mutex_tryenter() to avoid deadlock. Also note that
	* the active state mutex must be held before the ghost state mutex.
	*
	* It as also possible to register a callback which is run when the
	* arc_meta_limit is reached and no buffers can be safely evicted. In
	* this case the arc user should drop a reference on some arc buffers so
	* they can be reclaimed and the arc_meta_limit honored. For example,
	* when using the ZPL each dentry holds a references on a znode. These
	* dentries must be pruned before the arc buffer holding the znode can
	* be safely evicted.
	*
	* Note that the majority of the performance stats are manipulated
	* with atomic operations.
	*
	* The L2ARC uses the l2ad_mtx on each vdev for the following:
	*
	* - L2ARC buflist creation
	* - L2ARC buflist eviction
	* - L2ARC write completion, which walks L2ARC buflists
	* - ARC header destruction, as it removes from L2ARC buflists
	* - ARC header release, as it removes from L2ARC buflists
	*/

	/*
	* ARC operation:
	*
	* Every block that is in the ARC is tracked by an arc_buf_hdr_t structure.
	* This structure can point either to a block that is still in the cache or to
	* one that is only accessible in an L2 ARC device, or it can provide
	* information about a block that was recently evicted. If a block is
	* only accessible in the L2ARC, then the arc_buf_hdr_t only has enough
	* information to retrieve it from the L2ARC device. This information is
	* stored in the l2arc_buf_hdr_t sub-structure of the arc_buf_hdr_t. A block
	* that is in this state cannot access the data directly.
	*
	* Blocks that are actively being referenced or have not been evicted
	* are cached in the L1ARC. The L1ARC (l1arc_buf_hdr_t) is a structure within
	* the arc_buf_hdr_t that will point to the data block in memory. A block can
	* only be read by a consumer if it has an l1arc_buf_hdr_t. The L1ARC
	* caches data in two ways -- in a list of ARC buffers (arc_buf_t) and
	* also in the arc_buf_hdr_t's private physical data block pointer (b_pabd).
	*
	* The L1ARC's data pointer may or may not be uncompressed. The ARC has the
	* ability to store the physical data (b_pabd) associated with the DVA of the
	* arc_buf_hdr_t. Since the b_pabd is a copy of the on-disk physical block,
	* it will match its on-disk compression characteristics. This behavior can be
	* disabled by setting 'zfs_compressed_arc_enabled' to B_FALSE. When the
	* compressed ARC functionality is disabled, the b_pabd will point to an
	* uncompressed version of the on-disk data.
	*
	* Data in the L1ARC is not accessed by consumers of the ARC directly. Each
	* arc_buf_hdr_t can have multiple ARC buffers (arc_buf_t) which reference it.
	* Each ARC buffer (arc_buf_t) is being actively accessed by a specific ARC
	* consumer. The ARC will provide references to this data and will keep it
	* cached until it is no longer in use. The ARC caches only the L1ARC's physical
	* data block and will evict any arc_buf_t that is no longer referenced. The
	* amount of memory consumed by the arc_buf_ts' data buffers can be seen via the
	* "overhead_size" kstat.
	*
	* Depending on the consumer, an arc_buf_t can be requested in uncompressed or
	* compressed form. The typical case is that consumers will want uncompressed
	* data, and when that happens a new data buffer is allocated where the data is
	* decompressed for them to use. Currently the only consumer who wants
	* compressed arc_buf_t's is "zfs send", when it streams data exactly as it
	* exists on disk. When this happens, the arc_buf_t's data buffer is shared
	* with the arc_buf_hdr_t.
	*
	* Here is a diagram showing an arc_buf_hdr_t referenced by two arc_buf_t's. The
	* first one is owned by a compressed send consumer (and therefore references
	* the same compressed data buffer as the arc_buf_hdr_t) and the second could be
	* used by any other consumer (and has its own uncompressed copy of the data
	* buffer).
	*
	* arc_buf_hdr_t
	* +-----------+
	* \| fields \|
	* \| common to \|
	* \| L1- and \|
	* \| L2ARC \|
	* +-----------+
	* \| l2arc_buf_hdr_t
	* \| \|
	* +-----------+
	* \| l1arc_buf_hdr_t
	* \| \| arc_buf_t
	* \| b_buf +------------>+-----------+ arc_buf_t
	* \| b_pabd +-+ \|b_next +---->+-----------+
	* +-----------+ \| \|-----------\| \|b_next +-->NULL
	* \| \|b_comp = T \| +-----------+
	* \| \|b_data +-+ \|b_comp = F \|
	* \| +-----------+ \| \|b_data +-+
	* +->+------+ \| +-----------+ \|
	* compressed \| \| \| \|
	* data \| \|<--------------+ \| uncompressed
	* +------+ compressed, \| data
	* shared +-->+------+
	* data \| \|
	* \| \|
	* +------+
	*
	* When a consumer reads a block, the ARC must first look to see if the
	* arc_buf_hdr_t is cached. If the hdr is cached then the ARC allocates a new
	* arc_buf_t and either copies uncompressed data into a new data buffer from an
	* existing uncompressed arc_buf_t, decompresses the hdr's b_pabd buffer into a
	* new data buffer, or shares the hdr's b_pabd buffer, depending on whether the
	* hdr is compressed and the desired compression characteristics of the
	* arc_buf_t consumer. If the arc_buf_t ends up sharing data with the
	* arc_buf_hdr_t and both of them are uncompressed then the arc_buf_t must be
	* the last buffer in the hdr's b_buf list, however a shared compressed buf can
	* be anywhere in the hdr's list.
	*
	* The diagram below shows an example of an uncompressed ARC hdr that is
	* sharing its data with an arc_buf_t (note that the shared uncompressed buf is
	* the last element in the buf list):
	*
	* arc_buf_hdr_t
	* +-----------+
	* \| \|
	* \| \|
	* \| \|
	* +-----------+
	* l2arc_buf_hdr_t\| \|
	* \| \|
	* +-----------+
	* l1arc_buf_hdr_t\| \|
	* \| \| arc_buf_t (shared)
	* \| b_buf +------------>+---------+ arc_buf_t
	* \| \| \|b_next +---->+---------+
	* \| b_pabd +-+ \|---------\| \|b_next +-->NULL
	* +-----------+ \| \| \| +---------+
	* \| \|b_data +-+ \| \|
	* \| +---------+ \| \|b_data +-+
	* +->+------+ \| +---------+ \|
	* \| \| \| \|
	* uncompressed \| \| \| \|
	* data +------+ \| \|
	* ^ +->+------+ \|
	* \| uncompressed \| \| \|
	* \| data \| \| \|
	* \| +------+ \|
	* +---------------------------------+
	*
	* Writing to the ARC requires that the ARC first discard the hdr's b_pabd
	* since the physical block is about to be rewritten. The new data contents
	* will be contained in the arc_buf_t. As the I/O pipeline performs the write,
	* it may compress the data before writing it to disk. The ARC will be called
	* with the transformed data and will bcopy the transformed on-disk block into
	* a newly allocated b_pabd. Writes are always done into buffers which have
	* either been loaned (and hence are new and don't have other readers) or
	* buffers which have been released (and hence have their own hdr, if there
	* were originally other readers of the buf's original hdr). This ensures that
	* the ARC only needs to update a single buf and its hdr after a write occurs.
	*
	* When the L2ARC is in use, it will also take advantage of the b_pabd. The
	* L2ARC will always write the contents of b_pabd to the L2ARC. This means
	* that when compressed ARC is enabled that the L2ARC blocks are identical
	* to the on-disk block in the main data pool. This provides a significant
	* advantage since the ARC can leverage the bp's checksum when reading from the
	* L2ARC to determine if the contents are valid. However, if the compressed
	* ARC is disabled, then the L2ARC's block must be transformed to look
	* like the physical block in the main data pool before comparing the
	* checksum and determining its validity.
	*
	* The L1ARC has a slightly different system for storing encrypted data.
	* Raw (encrypted + possibly compressed) data has a few subtle differences from
	* data that is just compressed. The biggest difference is that it is not
	* possible to decrypt encrypted data (or vice-versa) if the keys aren't loaded.
	* The other difference is that encryption cannot be treated as a suggestion.
	* If a caller would prefer compressed data, but they actually wind up with
	* uncompressed data the worst thing that could happen is there might be a
	* performance hit. If the caller requests encrypted data, however, we must be
	* sure they actually get it or else secret information could be leaked. Raw
	* data is stored in hdr->b_crypt_hdr.b_rabd. An encrypted header, therefore,
	* may have both an encrypted version and a decrypted version of its data at
	* once. When a caller needs a raw arc_buf_t, it is allocated and the data is
	* copied out of this header. To avoid complications with b_pabd, raw buffers
	* cannot be shared.
	*/

	#include <sys/spa.h>
	#include <sys/zio.h>
	#include <sys/spa_impl.h>
	#include <sys/zio_compress.h>
	#include <sys/zio_checksum.h>
	#include <sys/zfs_context.h>
	#include <sys/arc.h>
	#include <sys/zfs_refcount.h>
	#include <sys/vdev.h>
	#include <sys/vdev_impl.h>
	#include <sys/dsl_pool.h>
	#include <sys/multilist.h>
	#include <sys/abd.h>
	#include <sys/zil.h>
	#include <sys/fm/fs/zfs.h>
	#include <sys/callb.h>
	#include <sys/kstat.h>
	#include <sys/zthr.h>
	#include <zfs_fletcher.h>
	#include <sys/arc_impl.h>
	#include <sys/trace_zfs.h>
	#include <sys/aggsum.h>
	#include <cityhash.h>
	#include <sys/vdev_trim.h>
	#include <sys/zfs_racct.h>
	#include <sys/zstd/zstd.h>

	#ifndef _KERNEL
	/* set with ZFS_DEBUG=watch, to enable watchpoints on frozen buffers */
	boolean_t arc_watch = B_FALSE;
	#endif

	/*
	* This thread's job is to keep enough free memory in the system, by
	* calling arc_kmem_reap_soon() plus arc_reduce_target_size(), which improves
	* arc_available_memory().
	*/
	static zthr_t *arc_reap_zthr;

	/*
	* This thread's job is to keep arc_size under arc_c, by calling
	* arc_evict(), which improves arc_is_overflowing().
	*/
	static zthr_t *arc_evict_zthr;

	static kmutex_t arc_evict_lock;
	static boolean_t arc_evict_needed = B_FALSE;

	/*
	* Count of bytes evicted since boot.
	*/
	static uint64_t arc_evict_count;

	/*
	* List of arc_evict_waiter_t's, representing threads waiting for the
	* arc_evict_count to reach specific values.
	*/
	static list_t arc_evict_waiters;

	/*
	* When arc_is_overflowing(), arc_get_data_impl() waits for this percent of
	* the requested amount of data to be evicted. For example, by default for
	* every 2KB that's evicted, 1KB of it may be "reused" by a new allocation.
	* Since this is above 100%, it ensures that progress is made towards getting
	* arc_size under arc_c. Since this is finite, it ensures that allocations
	* can still happen, even during the potentially long time that arc_size is
	* more than arc_c.
	*/
	int zfs_arc_eviction_pct = 200;

	/*
	* The number of headers to evict in arc_evict_state_impl() before
	* dropping the sublist lock and evicting from another sublist. A lower
	* value means we're more likely to evict the "correct" header (i.e. the
	* oldest header in the arc state), but comes with higher overhead
	* (i.e. more invocations of arc_evict_state_impl()).
	*/
	int zfs_arc_evict_batch_limit = 10;

	/* number of seconds before growing cache again */
	int arc_grow_retry = 5;

	/*
	* Minimum time between calls to arc_kmem_reap_soon().
	*/
	int arc_kmem_cache_reap_retry_ms = 1000;

	/* shift of arc_c for calculating overflow limit in arc_get_data_impl */
	int zfs_arc_overflow_shift = 8;

	/* shift of arc_c for calculating both min and max arc_p */
	int arc_p_min_shift = 4;

	/* log2(fraction of arc to reclaim) */
	int arc_shrink_shift = 7;

	/* percent of pagecache to reclaim arc to */
	#ifdef _KERNEL
	uint_t zfs_arc_pc_percent = 0;
	#endif

	/*
	* log2(fraction of ARC which must be free to allow growing).
	* I.e. If there is less than arc_c >> arc_no_grow_shift free memory,
	* when reading a new block into the ARC, we will evict an equal-sized block
	* from the ARC.
	*
	* This must be less than arc_shrink_shift, so that when we shrink the ARC,
	* we will still not allow it to grow.
	*/
	int arc_no_grow_shift = 5;


	/*
	* minimum lifespan of a prefetch block in clock ticks
	* (initialized in arc_init())
	*/
	static int arc_min_prefetch_ms;
	static int arc_min_prescient_prefetch_ms;

	/*
	* If this percent of memory is free, don't throttle.
	*/
	int arc_lotsfree_percent = 10;

	/*
	* The arc has filled available memory and has now warmed up.
	*/
	boolean_t arc_warm;

	/*
	* These tunables are for performance analysis.
	*/
	unsigned long zfs_arc_max = 0;
	unsigned long zfs_arc_min = 0;
	unsigned long zfs_arc_meta_limit = 0;
	unsigned long zfs_arc_meta_min = 0;
	unsigned long zfs_arc_dnode_limit = 0;
	unsigned long zfs_arc_dnode_reduce_percent = 10;
	int zfs_arc_grow_retry = 0;
	int zfs_arc_shrink_shift = 0;
	int zfs_arc_p_min_shift = 0;
	int zfs_arc_average_blocksize = 8 * 1024; /* 8KB */

	/*
	* ARC dirty data constraints for arc_tempreserve_space() throttle.
	*/
	unsigned long zfs_arc_dirty_limit_percent = 50; /* total dirty data limit */
	unsigned long zfs_arc_anon_limit_percent = 25; /* anon block dirty limit */
	unsigned long zfs_arc_pool_dirty_percent = 20; /* each pool's anon allowance */

	/*
	* Enable or disable compressed arc buffers.
	*/
	int zfs_compressed_arc_enabled = B_TRUE;

	/*
	* ARC will evict meta buffers that exceed arc_meta_limit. This
	* tunable make arc_meta_limit adjustable for different workloads.
	*/
	unsigned long zfs_arc_meta_limit_percent = 75;

	/*
	* Percentage that can be consumed by dnodes of ARC meta buffers.
	*/
	unsigned long zfs_arc_dnode_limit_percent = 10;

	/*
	* These tunables are Linux specific
	*/
	unsigned long zfs_arc_sys_free = 0;
	int zfs_arc_min_prefetch_ms = 0;
	int zfs_arc_min_prescient_prefetch_ms = 0;
	int zfs_arc_p_dampener_disable = 1;
	int zfs_arc_meta_prune = 10000;
	int zfs_arc_meta_strategy = ARC_STRATEGY_META_BALANCED;
	int zfs_arc_meta_adjust_restarts = 4096;
	int zfs_arc_lotsfree_percent = 10;

	/* The 6 states: */
	arc_state_t ARC_anon;
	arc_state_t ARC_mru;
	arc_state_t ARC_mru_ghost;
	arc_state_t ARC_mfu;
	arc_state_t ARC_mfu_ghost;
	arc_state_t ARC_l2c_only;

	arc_stats_t arc_stats = {
	{ "hits", KSTAT_DATA_UINT64 },
	{ "misses", KSTAT_DATA_UINT64 },
	{ "demand_data_hits", KSTAT_DATA_UINT64 },
	{ "demand_data_misses", KSTAT_DATA_UINT64 },
	{ "demand_metadata_hits", KSTAT_DATA_UINT64 },
	{ "demand_metadata_misses", KSTAT_DATA_UINT64 },
	{ "prefetch_data_hits", KSTAT_DATA_UINT64 },
	{ "prefetch_data_misses", KSTAT_DATA_UINT64 },
	{ "prefetch_metadata_hits", KSTAT_DATA_UINT64 },
	{ "prefetch_metadata_misses", KSTAT_DATA_UINT64 },
	{ "mru_hits", KSTAT_DATA_UINT64 },
	{ "mru_ghost_hits", KSTAT_DATA_UINT64 },
	{ "mfu_hits", KSTAT_DATA_UINT64 },
	{ "mfu_ghost_hits", KSTAT_DATA_UINT64 },
	{ "deleted", KSTAT_DATA_UINT64 },
	{ "mutex_miss", KSTAT_DATA_UINT64 },
	{ "access_skip", KSTAT_DATA_UINT64 },
	{ "evict_skip", KSTAT_DATA_UINT64 },
	{ "evict_not_enough", KSTAT_DATA_UINT64 },
	{ "evict_l2_cached", KSTAT_DATA_UINT64 },
	{ "evict_l2_eligible", KSTAT_DATA_UINT64 },
	{ "evict_l2_eligible_mfu", KSTAT_DATA_UINT64 },
	{ "evict_l2_eligible_mru", KSTAT_DATA_UINT64 },
	{ "evict_l2_ineligible", KSTAT_DATA_UINT64 },
	{ "evict_l2_skip", KSTAT_DATA_UINT64 },
	{ "hash_elements", KSTAT_DATA_UINT64 },
	{ "hash_elements_max", KSTAT_DATA_UINT64 },
	{ "hash_collisions", KSTAT_DATA_UINT64 },
	{ "hash_chains", KSTAT_DATA_UINT64 },
	{ "hash_chain_max", KSTAT_DATA_UINT64 },
	{ "p", KSTAT_DATA_UINT64 },
	{ "c", KSTAT_DATA_UINT64 },
	{ "c_min", KSTAT_DATA_UINT64 },
	{ "c_max", KSTAT_DATA_UINT64 },
	{ "size", KSTAT_DATA_UINT64 },
	{ "compressed_size", KSTAT_DATA_UINT64 },
	{ "uncompressed_size", KSTAT_DATA_UINT64 },
	{ "overhead_size", KSTAT_DATA_UINT64 },
	{ "hdr_size", KSTAT_DATA_UINT64 },
	{ "data_size", KSTAT_DATA_UINT64 },
	{ "metadata_size", KSTAT_DATA_UINT64 },
	{ "dbuf_size", KSTAT_DATA_UINT64 },
	{ "dnode_size", KSTAT_DATA_UINT64 },
	{ "bonus_size", KSTAT_DATA_UINT64 },
	#if defined(COMPAT_FREEBSD11)
	{ "other_size", KSTAT_DATA_UINT64 },
	#endif
	{ "anon_size", KSTAT_DATA_UINT64 },
	{ "anon_evictable_data", KSTAT_DATA_UINT64 },
	{ "anon_evictable_metadata", KSTAT_DATA_UINT64 },
	{ "mru_size", KSTAT_DATA_UINT64 },
	{ "mru_evictable_data", KSTAT_DATA_UINT64 },
	{ "mru_evictable_metadata", KSTAT_DATA_UINT64 },
	{ "mru_ghost_size", KSTAT_DATA_UINT64 },
	{ "mru_ghost_evictable_data", KSTAT_DATA_UINT64 },
	{ "mru_ghost_evictable_metadata", KSTAT_DATA_UINT64 },
	{ "mfu_size", KSTAT_DATA_UINT64 },
	{ "mfu_evictable_data", KSTAT_DATA_UINT64 },
	{ "mfu_evictable_metadata", KSTAT_DATA_UINT64 },
	{ "mfu_ghost_size", KSTAT_DATA_UINT64 },
	{ "mfu_ghost_evictable_data", KSTAT_DATA_UINT64 },
	{ "mfu_ghost_evictable_metadata", KSTAT_DATA_UINT64 },
	{ "l2_hits", KSTAT_DATA_UINT64 },
	{ "l2_misses", KSTAT_DATA_UINT64 },
	{ "l2_prefetch_asize", KSTAT_DATA_UINT64 },
	{ "l2_mru_asize", KSTAT_DATA_UINT64 },
	{ "l2_mfu_asize", KSTAT_DATA_UINT64 },
	{ "l2_bufc_data_asize", KSTAT_DATA_UINT64 },
	{ "l2_bufc_metadata_asize", KSTAT_DATA_UINT64 },
	{ "l2_feeds", KSTAT_DATA_UINT64 },
	{ "l2_rw_clash", KSTAT_DATA_UINT64 },
	{ "l2_read_bytes", KSTAT_DATA_UINT64 },
	{ "l2_write_bytes", KSTAT_DATA_UINT64 },
	{ "l2_writes_sent", KSTAT_DATA_UINT64 },
	{ "l2_writes_done", KSTAT_DATA_UINT64 },
	{ "l2_writes_error", KSTAT_DATA_UINT64 },
	{ "l2_writes_lock_retry", KSTAT_DATA_UINT64 },
	{ "l2_evict_lock_retry", KSTAT_DATA_UINT64 },
	{ "l2_evict_reading", KSTAT_DATA_UINT64 },
	{ "l2_evict_l1cached", KSTAT_DATA_UINT64 },
	{ "l2_free_on_write", KSTAT_DATA_UINT64 },
	{ "l2_abort_lowmem", KSTAT_DATA_UINT64 },
	{ "l2_cksum_bad", KSTAT_DATA_UINT64 },
	{ "l2_io_error", KSTAT_DATA_UINT64 },
	{ "l2_size", KSTAT_DATA_UINT64 },
	{ "l2_asize", KSTAT_DATA_UINT64 },
	{ "l2_hdr_size", KSTAT_DATA_UINT64 },
	{ "l2_log_blk_writes", KSTAT_DATA_UINT64 },
	{ "l2_log_blk_avg_asize", KSTAT_DATA_UINT64 },
	{ "l2_log_blk_asize", KSTAT_DATA_UINT64 },
	{ "l2_log_blk_count", KSTAT_DATA_UINT64 },
	{ "l2_data_to_meta_ratio", KSTAT_DATA_UINT64 },
	{ "l2_rebuild_success", KSTAT_DATA_UINT64 },
	{ "l2_rebuild_unsupported", KSTAT_DATA_UINT64 },
	{ "l2_rebuild_io_errors", KSTAT_DATA_UINT64 },
	{ "l2_rebuild_dh_errors", KSTAT_DATA_UINT64 },
	{ "l2_rebuild_cksum_lb_errors", KSTAT_DATA_UINT64 },
	{ "l2_rebuild_lowmem", KSTAT_DATA_UINT64 },
	{ "l2_rebuild_size", KSTAT_DATA_UINT64 },
	{ "l2_rebuild_asize", KSTAT_DATA_UINT64 },
	{ "l2_rebuild_bufs", KSTAT_DATA_UINT64 },
	{ "l2_rebuild_bufs_precached", KSTAT_DATA_UINT64 },
	{ "l2_rebuild_log_blks", KSTAT_DATA_UINT64 },
	{ "memory_throttle_count", KSTAT_DATA_UINT64 },
	{ "memory_direct_count", KSTAT_DATA_UINT64 },
	{ "memory_indirect_count", KSTAT_DATA_UINT64 },
	{ "memory_all_bytes", KSTAT_DATA_UINT64 },
	{ "memory_free_bytes", KSTAT_DATA_UINT64 },
	{ "memory_available_bytes", KSTAT_DATA_INT64 },
	{ "arc_no_grow", KSTAT_DATA_UINT64 },
	{ "arc_tempreserve", KSTAT_DATA_UINT64 },
	{ "arc_loaned_bytes", KSTAT_DATA_UINT64 },
	{ "arc_prune", KSTAT_DATA_UINT64 },
	{ "arc_meta_used", KSTAT_DATA_UINT64 },
	{ "arc_meta_limit", KSTAT_DATA_UINT64 },
	{ "arc_dnode_limit", KSTAT_DATA_UINT64 },
	{ "arc_meta_max", KSTAT_DATA_UINT64 },
	{ "arc_meta_min", KSTAT_DATA_UINT64 },
	{ "async_upgrade_sync", KSTAT_DATA_UINT64 },
	{ "demand_hit_predictive_prefetch", KSTAT_DATA_UINT64 },
	{ "demand_hit_prescient_prefetch", KSTAT_DATA_UINT64 },
	{ "arc_need_free", KSTAT_DATA_UINT64 },
	{ "arc_sys_free", KSTAT_DATA_UINT64 },
	{ "arc_raw_size", KSTAT_DATA_UINT64 },
	{ "cached_only_in_progress", KSTAT_DATA_UINT64 },
	{ "abd_chunk_waste_size", KSTAT_DATA_UINT64 },
	};

	#define ARCSTAT_MAX(stat, val) { \
	uint64_t m; \
	while ((val) > (m = arc_stats.stat.value.ui64) && \
	(m != atomic_cas_64(&arc_stats.stat.value.ui64, m, (val)))) \
	continue; \
	}

	#define ARCSTAT_MAXSTAT(stat) \
	ARCSTAT_MAX(stat##_max, arc_stats.stat.value.ui64)

	/*
	* We define a macro to allow ARC hits/misses to be easily broken down by
	* two separate conditions, giving a total of four different subtypes for
	* each of hits and misses (so eight statistics total).
	*/
	#define ARCSTAT_CONDSTAT(cond1, stat1, notstat1, cond2, stat2, notstat2, stat) \
	if (cond1) { \
	if (cond2) { \
	ARCSTAT_BUMP(arcstat_##stat1##_##stat2##_##stat); \
	} else { \
	ARCSTAT_BUMP(arcstat_##stat1##_##notstat2##_##stat); \
	} \
	} else { \
	if (cond2) { \
	ARCSTAT_BUMP(arcstat_##notstat1##_##stat2##_##stat); \
	} else { \
	ARCSTAT_BUMP(arcstat_##notstat1##_##notstat2##_##stat);\
	} \
	}

	/*
	* This macro allows us to use kstats as floating averages. Each time we
	* update this kstat, we first factor it and the update value by
	* ARCSTAT_AVG_FACTOR to shrink the new value's contribution to the overall
	* average. This macro assumes that integer loads and stores are atomic, but
	* is not safe for multiple writers updating the kstat in parallel (only the
	* last writer's update will remain).
	*/
	#define ARCSTAT_F_AVG_FACTOR 3
	#define ARCSTAT_F_AVG(stat, value) \
	do { \
	uint64_t x = ARCSTAT(stat); \
	x = x - x / ARCSTAT_F_AVG_FACTOR + \
	(value) / ARCSTAT_F_AVG_FACTOR; \
	ARCSTAT(stat) = x; \
	_NOTE(CONSTCOND) \
	} while (0)

	kstat_t *arc_ksp;
	static arc_state_t *arc_anon;
	static arc_state_t *arc_mru_ghost;
	static arc_state_t *arc_mfu_ghost;
	static arc_state_t *arc_l2c_only;

	arc_state_t *arc_mru;
	arc_state_t *arc_mfu;

	/*
	* There are several ARC variables that are critical to export as kstats --
	* but we don't want to have to grovel around in the kstat whenever we wish to
	* manipulate them. For these variables, we therefore define them to be in
	* terms of the statistic variable. This assures that we are not introducing
	* the possibility of inconsistency by having shadow copies of the variables,
	* while still allowing the code to be readable.
	*/
	#define arc_tempreserve ARCSTAT(arcstat_tempreserve)
	#define arc_loaned_bytes ARCSTAT(arcstat_loaned_bytes)
	#define arc_meta_limit ARCSTAT(arcstat_meta_limit) /* max size for metadata */
	/* max size for dnodes */
	#define arc_dnode_size_limit ARCSTAT(arcstat_dnode_limit)
	#define arc_meta_min ARCSTAT(arcstat_meta_min) /* min size for metadata */
	#define arc_meta_max ARCSTAT(arcstat_meta_max) /* max size of metadata */
	#define arc_need_free ARCSTAT(arcstat_need_free) /* waiting to be evicted */

	/* size of all b_rabd's in entire arc */
	#define arc_raw_size ARCSTAT(arcstat_raw_size)
	/* compressed size of entire arc */
	#define arc_compressed_size ARCSTAT(arcstat_compressed_size)
	/* uncompressed size of entire arc */
	#define arc_uncompressed_size ARCSTAT(arcstat_uncompressed_size)
	/* number of bytes in the arc from arc_buf_t's */
	#define arc_overhead_size ARCSTAT(arcstat_overhead_size)

	/*
	* There are also some ARC variables that we want to export, but that are
	* updated so often that having the canonical representation be the statistic
	* variable causes a performance bottleneck. We want to use aggsum_t's for these
	* instead, but still be able to export the kstat in the same way as before.
	* The solution is to always use the aggsum version, except in the kstat update
	* callback.
	*/
	aggsum_t arc_size;
	aggsum_t arc_meta_used;
	aggsum_t astat_data_size;
	aggsum_t astat_metadata_size;
	aggsum_t astat_dbuf_size;
	aggsum_t astat_dnode_size;
	aggsum_t astat_bonus_size;
	aggsum_t astat_hdr_size;
	aggsum_t astat_l2_hdr_size;
	aggsum_t astat_abd_chunk_waste_size;

	hrtime_t arc_growtime;
	list_t arc_prune_list;
	kmutex_t arc_prune_mtx;
	taskq_t *arc_prune_taskq;

	#define GHOST_STATE(state) \
	((state) == arc_mru_ghost \|\| (state) == arc_mfu_ghost \|\| \
	(state) == arc_l2c_only)

	#define HDR_IN_HASH_TABLE(hdr) ((hdr)->b_flags & ARC_FLAG_IN_HASH_TABLE)
	#define HDR_IO_IN_PROGRESS(hdr) ((hdr)->b_flags & ARC_FLAG_IO_IN_PROGRESS)
	#define HDR_IO_ERROR(hdr) ((hdr)->b_flags & ARC_FLAG_IO_ERROR)
	#define HDR_PREFETCH(hdr) ((hdr)->b_flags & ARC_FLAG_PREFETCH)
	#define HDR_PRESCIENT_PREFETCH(hdr) \
	((hdr)->b_flags & ARC_FLAG_PRESCIENT_PREFETCH)
	#define HDR_COMPRESSION_ENABLED(hdr) \
	((hdr)->b_flags & ARC_FLAG_COMPRESSED_ARC)

	#define HDR_L2CACHE(hdr) ((hdr)->b_flags & ARC_FLAG_L2CACHE)
	#define HDR_L2_READING(hdr) \
	(((hdr)->b_flags & ARC_FLAG_IO_IN_PROGRESS) && \
	((hdr)->b_flags & ARC_FLAG_HAS_L2HDR))
	#define HDR_L2_WRITING(hdr) ((hdr)->b_flags & ARC_FLAG_L2_WRITING)
	#define HDR_L2_EVICTED(hdr) ((hdr)->b_flags & ARC_FLAG_L2_EVICTED)
	#define HDR_L2_WRITE_HEAD(hdr) ((hdr)->b_flags & ARC_FLAG_L2_WRITE_HEAD)
	#define HDR_PROTECTED(hdr) ((hdr)->b_flags & ARC_FLAG_PROTECTED)
	#define HDR_NOAUTH(hdr) ((hdr)->b_flags & ARC_FLAG_NOAUTH)
	#define HDR_SHARED_DATA(hdr) ((hdr)->b_flags & ARC_FLAG_SHARED_DATA)

	#define HDR_ISTYPE_METADATA(hdr) \
	((hdr)->b_flags & ARC_FLAG_BUFC_METADATA)
	#define HDR_ISTYPE_DATA(hdr) (!HDR_ISTYPE_METADATA(hdr))

	#define HDR_HAS_L1HDR(hdr) ((hdr)->b_flags & ARC_FLAG_HAS_L1HDR)
	#define HDR_HAS_L2HDR(hdr) ((hdr)->b_flags & ARC_FLAG_HAS_L2HDR)
	#define HDR_HAS_RABD(hdr) \
	(HDR_HAS_L1HDR(hdr) && HDR_PROTECTED(hdr) && \
	(hdr)->b_crypt_hdr.b_rabd != NULL)
	#define HDR_ENCRYPTED(hdr) \
	(HDR_PROTECTED(hdr) && DMU_OT_IS_ENCRYPTED((hdr)->b_crypt_hdr.b_ot))
	#define HDR_AUTHENTICATED(hdr) \
	(HDR_PROTECTED(hdr) && !DMU_OT_IS_ENCRYPTED((hdr)->b_crypt_hdr.b_ot))

	/* For storing compression mode in b_flags */
	#define HDR_COMPRESS_OFFSET (highbit64(ARC_FLAG_COMPRESS_0) - 1)

	#define HDR_GET_COMPRESS(hdr) ((enum zio_compress)BF32_GET((hdr)->b_flags, \
	HDR_COMPRESS_OFFSET, SPA_COMPRESSBITS))
	#define HDR_SET_COMPRESS(hdr, cmp) BF32_SET((hdr)->b_flags, \
	HDR_COMPRESS_OFFSET, SPA_COMPRESSBITS, (cmp));

	#define ARC_BUF_LAST(buf) ((buf)->b_next == NULL)
	#define ARC_BUF_SHARED(buf) ((buf)->b_flags & ARC_BUF_FLAG_SHARED)
	#define ARC_BUF_COMPRESSED(buf) ((buf)->b_flags & ARC_BUF_FLAG_COMPRESSED)
	#define ARC_BUF_ENCRYPTED(buf) ((buf)->b_flags & ARC_BUF_FLAG_ENCRYPTED)

	/*
	* Other sizes
	*/

	#define HDR_FULL_CRYPT_SIZE ((int64_t)sizeof (arc_buf_hdr_t))
	#define HDR_FULL_SIZE ((int64_t)offsetof(arc_buf_hdr_t, b_crypt_hdr))
	#define HDR_L2ONLY_SIZE ((int64_t)offsetof(arc_buf_hdr_t, b_l1hdr))

	/*
	* Hash table routines
	*/

	#define HT_LOCK_ALIGN 64
	#define HT_LOCK_PAD (P2NPHASE(sizeof (kmutex_t), (HT_LOCK_ALIGN)))

	struct ht_lock {
	kmutex_t ht_lock;
	#ifdef _KERNEL
	unsigned char pad[HT_LOCK_PAD];
	#endif
	};

	#define BUF_LOCKS 8192
	typedef struct buf_hash_table {
	uint64_t ht_mask;
	arc_buf_hdr_t **ht_table;
	struct ht_lock ht_locks[BUF_LOCKS];
	} buf_hash_table_t;

	static buf_hash_table_t buf_hash_table;

	#define BUF_HASH_INDEX(spa, dva, birth) \
	(buf_hash(spa, dva, birth) & buf_hash_table.ht_mask)
	#define BUF_HASH_LOCK_NTRY(idx) (buf_hash_table.ht_locks[idx & (BUF_LOCKS-1)])
	#define BUF_HASH_LOCK(idx) (&(BUF_HASH_LOCK_NTRY(idx).ht_lock))
	#define HDR_LOCK(hdr) \
	(BUF_HASH_LOCK(BUF_HASH_INDEX(hdr->b_spa, &hdr->b_dva, hdr->b_birth)))

	uint64_t zfs_crc64_table[256];

	/*
	* Level 2 ARC
	*/

	#define L2ARC_WRITE_SIZE (8 * 1024 * 1024) /* initial write max */
	#define L2ARC_HEADROOM 2 /* num of writes */

	/*
	* If we discover during ARC scan any buffers to be compressed, we boost
	* our headroom for the next scanning cycle by this percentage multiple.
	*/
	#define L2ARC_HEADROOM_BOOST 200
	#define L2ARC_FEED_SECS 1 /* caching interval secs */
	#define L2ARC_FEED_MIN_MS 200 /* min caching interval ms */

	/*
	* We can feed L2ARC from two states of ARC buffers, mru and mfu,
	* and each of the state has two types: data and metadata.
	*/
	#define L2ARC_FEED_TYPES 4

	#define l2arc_writes_sent ARCSTAT(arcstat_l2_writes_sent)
	#define l2arc_writes_done ARCSTAT(arcstat_l2_writes_done)

	/* L2ARC Performance Tunables */
	unsigned long l2arc_write_max = L2ARC_WRITE_SIZE; /* def max write size */
	unsigned long l2arc_write_boost = L2ARC_WRITE_SIZE; /* extra warmup write */
	unsigned long l2arc_headroom = L2ARC_HEADROOM; /* # of dev writes */
	unsigned long l2arc_headroom_boost = L2ARC_HEADROOM_BOOST;
	unsigned long l2arc_feed_secs = L2ARC_FEED_SECS; /* interval seconds */
	unsigned long l2arc_feed_min_ms = L2ARC_FEED_MIN_MS; /* min interval msecs */
	int l2arc_noprefetch = B_TRUE; /* don't cache prefetch bufs */
	int l2arc_feed_again = B_TRUE; /* turbo warmup */
	int l2arc_norw = B_FALSE; /* no reads during writes */
	int l2arc_meta_percent = 33; /* limit on headers size */

	/*
	* L2ARC Internals
	*/
	static list_t L2ARC_dev_list; /* device list */
	static list_t l2arc_dev_list; / device list pointer */
	static kmutex_t l2arc_dev_mtx; /* device list mutex */
	static l2arc_dev_t l2arc_dev_last; / last device used */
	static list_t L2ARC_free_on_write; /* free after write buf list */
	static list_t l2arc_free_on_write; / free after write list ptr */
	static kmutex_t l2arc_free_on_write_mtx; /* mutex for list */
	static uint64_t l2arc_ndev; /* number of devices */

	typedef struct l2arc_read_callback {
	arc_buf_hdr_t l2rcb_hdr; / read header */
	blkptr_t l2rcb_bp; /* original blkptr */
	zbookmark_phys_t l2rcb_zb; /* original bookmark */
	int l2rcb_flags; /* original flags */
	abd_t l2rcb_abd; / temporary buffer */
	} l2arc_read_callback_t;

	typedef struct l2arc_data_free {
	/* protected by l2arc_free_on_write_mtx */
	abd_t *l2df_abd;
	size_t l2df_size;
	arc_buf_contents_t l2df_type;
	list_node_t l2df_list_node;
	} l2arc_data_free_t;

	typedef enum arc_fill_flags {
	ARC_FILL_LOCKED = 1 << 0, /* hdr lock is held */
	ARC_FILL_COMPRESSED = 1 << 1, /* fill with compressed data */
	ARC_FILL_ENCRYPTED = 1 << 2, /* fill with encrypted data */
	ARC_FILL_NOAUTH = 1 << 3, /* don't attempt to authenticate */
	ARC_FILL_IN_PLACE = 1 << 4 /* fill in place (special case) */
	} arc_fill_flags_t;

	static kmutex_t l2arc_feed_thr_lock;
	static kcondvar_t l2arc_feed_thr_cv;
	static uint8_t l2arc_thread_exit;

	static kmutex_t l2arc_rebuild_thr_lock;
	static kcondvar_t l2arc_rebuild_thr_cv;

	enum arc_hdr_alloc_flags {
	ARC_HDR_ALLOC_RDATA = 0x1,
	ARC_HDR_DO_ADAPT = 0x2,
	};


	static abd_t arc_get_data_abd(arc_buf_hdr_t , uint64_t, void *, boolean_t);
	static void arc_get_data_buf(arc_buf_hdr_t , uint64_t, void *);
	static void arc_get_data_impl(arc_buf_hdr_t , uint64_t, void , boolean_t);
	static void arc_free_data_abd(arc_buf_hdr_t , abd_t , uint64_t, void *);
	static void arc_free_data_buf(arc_buf_hdr_t , void , uint64_t, void *);
	static void arc_free_data_impl(arc_buf_hdr_t hdr, uint64_t size, void tag);
	static void arc_hdr_free_abd(arc_buf_hdr_t *, boolean_t);
	static void arc_hdr_alloc_abd(arc_buf_hdr_t *, int);
	static void arc_access(arc_buf_hdr_t , kmutex_t );
	static void arc_buf_watch(arc_buf_t *);

	static arc_buf_contents_t arc_buf_type(arc_buf_hdr_t *);
	static uint32_t arc_bufc_to_flags(arc_buf_contents_t);
	static inline void arc_hdr_set_flags(arc_buf_hdr_t *hdr, arc_flags_t flags);
	static inline void arc_hdr_clear_flags(arc_buf_hdr_t *hdr, arc_flags_t flags);

	static boolean_t l2arc_write_eligible(uint64_t, arc_buf_hdr_t *);
	static void l2arc_read_done(zio_t *);
	static void l2arc_do_free_on_write(void);
	static void l2arc_hdr_arcstats_update(arc_buf_hdr_t *hdr, boolean_t incr,
	boolean_t state_only);

	#define l2arc_hdr_arcstats_increment(hdr) \
	l2arc_hdr_arcstats_update((hdr), B_TRUE, B_FALSE)
	#define l2arc_hdr_arcstats_decrement(hdr) \
	l2arc_hdr_arcstats_update((hdr), B_FALSE, B_FALSE)
	#define l2arc_hdr_arcstats_increment_state(hdr) \
	l2arc_hdr_arcstats_update((hdr), B_TRUE, B_TRUE)
	#define l2arc_hdr_arcstats_decrement_state(hdr) \
	l2arc_hdr_arcstats_update((hdr), B_FALSE, B_TRUE)

	/*
	* l2arc_mfuonly : A ZFS module parameter that controls whether only MFU
	* metadata and data are cached from ARC into L2ARC.
	*/
	int l2arc_mfuonly = 0;

	/*
	* L2ARC TRIM
	* l2arc_trim_ahead : A ZFS module parameter that controls how much ahead of
	* the current write size (l2arc_write_max) we should TRIM if we
	* have filled the device. It is defined as a percentage of the
	* write size. If set to 100 we trim twice the space required to
	* accommodate upcoming writes. A minimum of 64MB will be trimmed.
	* It also enables TRIM of the whole L2ARC device upon creation or
	* addition to an existing pool or if the header of the device is
	* invalid upon importing a pool or onlining a cache device. The
	* default is 0, which disables TRIM on L2ARC altogether as it can
	* put significant stress on the underlying storage devices. This
	* will vary depending of how well the specific device handles
	* these commands.
	*/
	unsigned long l2arc_trim_ahead = 0;

	/*
	* Performance tuning of L2ARC persistence:
	*
	* l2arc_rebuild_enabled : A ZFS module parameter that controls whether adding
	* an L2ARC device (either at pool import or later) will attempt
	* to rebuild L2ARC buffer contents.
	* l2arc_rebuild_blocks_min_l2size : A ZFS module parameter that controls
	* whether log blocks are written to the L2ARC device. If the L2ARC
	* device is less than 1GB, the amount of data l2arc_evict()
	* evicts is significant compared to the amount of restored L2ARC
	* data. In this case do not write log blocks in L2ARC in order
	* not to waste space.
	*/
	int l2arc_rebuild_enabled = B_TRUE;
	unsigned long l2arc_rebuild_blocks_min_l2size = 1024 * 1024 * 1024;

	/* L2ARC persistence rebuild control routines. */
	void l2arc_rebuild_vdev(vdev_t *vd, boolean_t reopen);
	static void l2arc_dev_rebuild_thread(void *arg);
	static int l2arc_rebuild(l2arc_dev_t *dev);

	/* L2ARC persistence read I/O routines. */
	static int l2arc_dev_hdr_read(l2arc_dev_t *dev);
	static int l2arc_log_blk_read(l2arc_dev_t *dev,
	const l2arc_log_blkptr_t this_lp, const l2arc_log_blkptr_t next_lp,
	l2arc_log_blk_phys_t this_lb, l2arc_log_blk_phys_t next_lb,
	zio_t this_io, zio_t *next_io);
	static zio_t l2arc_log_blk_fetch(vdev_t vd,
	const l2arc_log_blkptr_t lp, l2arc_log_blk_phys_t lb);
	static void l2arc_log_blk_fetch_abort(zio_t *zio);

	/* L2ARC persistence block restoration routines. */
	static void l2arc_log_blk_restore(l2arc_dev_t *dev,
	const l2arc_log_blk_phys_t *lb, uint64_t lb_asize);
	static void l2arc_hdr_restore(const l2arc_log_ent_phys_t *le,
	l2arc_dev_t *dev);

	/* L2ARC persistence write I/O routines. */
	static void l2arc_log_blk_commit(l2arc_dev_t dev, zio_t pio,
	l2arc_write_callback_t *cb);

	/* L2ARC persistence auxiliary routines. */
	boolean_t l2arc_log_blkptr_valid(l2arc_dev_t *dev,
	const l2arc_log_blkptr_t *lbp);
	static boolean_t l2arc_log_blk_insert(l2arc_dev_t *dev,
	const arc_buf_hdr_t *ab);
	boolean_t l2arc_range_check_overlap(uint64_t bottom,
	uint64_t top, uint64_t check);
	static void l2arc_blk_fetch_done(zio_t *zio);
	static inline uint64_t
	l2arc_log_blk_overhead(uint64_t write_sz, l2arc_dev_t *dev);

	/*
	* We use Cityhash for this. It's fast, and has good hash properties without
	* requiring any large static buffers.
	*/
	static uint64_t
	buf_hash(uint64_t spa, const dva_t *dva, uint64_t birth)
	{
	return (cityhash4(spa, dva->dva_word[0], dva->dva_word[1], birth));
	}

	#define HDR_EMPTY(hdr) \
	((hdr)->b_dva.dva_word[0] == 0 && \
	(hdr)->b_dva.dva_word[1] == 0)

	#define HDR_EMPTY_OR_LOCKED(hdr) \
	(HDR_EMPTY(hdr) \|\| MUTEX_HELD(HDR_LOCK(hdr)))

	#define HDR_EQUAL(spa, dva, birth, hdr) \
	((hdr)->b_dva.dva_word[0] == (dva)->dva_word[0]) && \
	((hdr)->b_dva.dva_word[1] == (dva)->dva_word[1]) && \
	((hdr)->b_birth == birth) && ((hdr)->b_spa == spa)

	static void
	buf_discard_identity(arc_buf_hdr_t *hdr)
	{
	hdr->b_dva.dva_word[0] = 0;
	hdr->b_dva.dva_word[1] = 0;
	hdr->b_birth = 0;
	}

	static arc_buf_hdr_t *
	buf_hash_find(uint64_t spa, const blkptr_t bp, kmutex_t *lockp)
	{
	const dva_t *dva = BP_IDENTITY(bp);
	uint64_t birth = BP_PHYSICAL_BIRTH(bp);
	uint64_t idx = BUF_HASH_INDEX(spa, dva, birth);
	kmutex_t *hash_lock = BUF_HASH_LOCK(idx);
	arc_buf_hdr_t *hdr;

	mutex_enter(hash_lock);
	for (hdr = buf_hash_table.ht_table[idx]; hdr != NULL;
	hdr = hdr->b_hash_next) {
	if (HDR_EQUAL(spa, dva, birth, hdr)) {
	*lockp = hash_lock;
	return (hdr);
	}
	}
	mutex_exit(hash_lock);
	*lockp = NULL;
	return (NULL);
	}

	/*
	* Insert an entry into the hash table. If there is already an element
	* equal to elem in the hash table, then the already existing element
	* will be returned and the new element will not be inserted.
	* Otherwise returns NULL.
	* If lockp == NULL, the caller is assumed to already hold the hash lock.
	*/
	static arc_buf_hdr_t *
	buf_hash_insert(arc_buf_hdr_t hdr, kmutex_t *lockp)
	{
	uint64_t idx = BUF_HASH_INDEX(hdr->b_spa, &hdr->b_dva, hdr->b_birth);
	kmutex_t *hash_lock = BUF_HASH_LOCK(idx);
	arc_buf_hdr_t *fhdr;
	uint32_t i;

	ASSERT(!DVA_IS_EMPTY(&hdr->b_dva));
	ASSERT(hdr->b_birth != 0);
	ASSERT(!HDR_IN_HASH_TABLE(hdr));

	if (lockp != NULL) {
	*lockp = hash_lock;
	mutex_enter(hash_lock);
	} else {
	ASSERT(MUTEX_HELD(hash_lock));
	}

	for (fhdr = buf_hash_table.ht_table[idx], i = 0; fhdr != NULL;
	fhdr = fhdr->b_hash_next, i++) {
	if (HDR_EQUAL(hdr->b_spa, &hdr->b_dva, hdr->b_birth, fhdr))
	return (fhdr);
	}

	hdr->b_hash_next = buf_hash_table.ht_table[idx];
	buf_hash_table.ht_table[idx] = hdr;
	arc_hdr_set_flags(hdr, ARC_FLAG_IN_HASH_TABLE);

	/* collect some hash table performance data */
	if (i > 0) {
	ARCSTAT_BUMP(arcstat_hash_collisions);
	if (i == 1)
	ARCSTAT_BUMP(arcstat_hash_chains);

	ARCSTAT_MAX(arcstat_hash_chain_max, i);
	}

	ARCSTAT_BUMP(arcstat_hash_elements);
	ARCSTAT_MAXSTAT(arcstat_hash_elements);

	return (NULL);
	}

	static void
	buf_hash_remove(arc_buf_hdr_t *hdr)
	{
	arc_buf_hdr_t fhdr, *hdrp;
	uint64_t idx = BUF_HASH_INDEX(hdr->b_spa, &hdr->b_dva, hdr->b_birth);

	ASSERT(MUTEX_HELD(BUF_HASH_LOCK(idx)));
	ASSERT(HDR_IN_HASH_TABLE(hdr));

	hdrp = &buf_hash_table.ht_table[idx];
	while ((fhdr = *hdrp) != hdr) {
	ASSERT3P(fhdr, !=, NULL);
	hdrp = &fhdr->b_hash_next;
	}
	*hdrp = hdr->b_hash_next;
	hdr->b_hash_next = NULL;
	arc_hdr_clear_flags(hdr, ARC_FLAG_IN_HASH_TABLE);

	/* collect some hash table performance data */
	ARCSTAT_BUMPDOWN(arcstat_hash_elements);

	if (buf_hash_table.ht_table[idx] &&
	buf_hash_table.ht_table[idx]->b_hash_next == NULL)
	ARCSTAT_BUMPDOWN(arcstat_hash_chains);
	}

	/*
	* Global data structures and functions for the buf kmem cache.
	*/

	static kmem_cache_t *hdr_full_cache;
	static kmem_cache_t *hdr_full_crypt_cache;
	static kmem_cache_t *hdr_l2only_cache;
	static kmem_cache_t *buf_cache;

	static void
	buf_fini(void)
	{
	int i;

	#if defined(_KERNEL)
	/*
	* Large allocations which do not require contiguous pages
	* should be using vmem_free() in the linux kernel\
	*/
	vmem_free(buf_hash_table.ht_table,
	(buf_hash_table.ht_mask + 1) * sizeof (void *));
	#else
	kmem_free(buf_hash_table.ht_table,
	(buf_hash_table.ht_mask + 1) * sizeof (void *));
	#endif
	for (i = 0; i < BUF_LOCKS; i++)
	mutex_destroy(&buf_hash_table.ht_locks[i].ht_lock);
	kmem_cache_destroy(hdr_full_cache);
	kmem_cache_destroy(hdr_full_crypt_cache);
	kmem_cache_destroy(hdr_l2only_cache);
	kmem_cache_destroy(buf_cache);
	}

	/*
	* Constructor callback - called when the cache is empty
	* and a new buf is requested.
	*/
	/* ARGSUSED */
	static int
	hdr_full_cons(void vbuf, void unused, int kmflag)
	{
	arc_buf_hdr_t *hdr = vbuf;

	bzero(hdr, HDR_FULL_SIZE);
	hdr->b_l1hdr.b_byteswap = DMU_BSWAP_NUMFUNCS;
	cv_init(&hdr->b_l1hdr.b_cv, NULL, CV_DEFAULT, NULL);
	zfs_refcount_create(&hdr->b_l1hdr.b_refcnt);
	mutex_init(&hdr->b_l1hdr.b_freeze_lock, NULL, MUTEX_DEFAULT, NULL);
	list_link_init(&hdr->b_l1hdr.b_arc_node);
	list_link_init(&hdr->b_l2hdr.b_l2node);
	multilist_link_init(&hdr->b_l1hdr.b_arc_node);
	arc_space_consume(HDR_FULL_SIZE, ARC_SPACE_HDRS);

	return (0);
	}

	/* ARGSUSED */
	static int
	hdr_full_crypt_cons(void vbuf, void unused, int kmflag)
	{
	arc_buf_hdr_t *hdr = vbuf;

	hdr_full_cons(vbuf, unused, kmflag);
	bzero(&hdr->b_crypt_hdr, sizeof (hdr->b_crypt_hdr));
	arc_space_consume(sizeof (hdr->b_crypt_hdr), ARC_SPACE_HDRS);

	return (0);
	}

	/* ARGSUSED */
	static int
	hdr_l2only_cons(void vbuf, void unused, int kmflag)
	{
	arc_buf_hdr_t *hdr = vbuf;

	bzero(hdr, HDR_L2ONLY_SIZE);
	arc_space_consume(HDR_L2ONLY_SIZE, ARC_SPACE_L2HDRS);

	return (0);
	}

	/* ARGSUSED */
	static int
	buf_cons(void vbuf, void unused, int kmflag)
	{
	arc_buf_t *buf = vbuf;

	bzero(buf, sizeof (arc_buf_t));
	mutex_init(&buf->b_evict_lock, NULL, MUTEX_DEFAULT, NULL);
	arc_space_consume(sizeof (arc_buf_t), ARC_SPACE_HDRS);

	return (0);
	}

	/*
	* Destructor callback - called when a cached buf is
	* no longer required.
	*/
	/* ARGSUSED */
	static void
	hdr_full_dest(void vbuf, void unused)
	{
	arc_buf_hdr_t *hdr = vbuf;

	ASSERT(HDR_EMPTY(hdr));
	cv_destroy(&hdr->b_l1hdr.b_cv);
	zfs_refcount_destroy(&hdr->b_l1hdr.b_refcnt);
	mutex_destroy(&hdr->b_l1hdr.b_freeze_lock);
	ASSERT(!multilist_link_active(&hdr->b_l1hdr.b_arc_node));
	arc_space_return(HDR_FULL_SIZE, ARC_SPACE_HDRS);
	}

	/* ARGSUSED */
	static void
	hdr_full_crypt_dest(void vbuf, void unused)
	{
	arc_buf_hdr_t *hdr = vbuf;

	hdr_full_dest(vbuf, unused);
	arc_space_return(sizeof (hdr->b_crypt_hdr), ARC_SPACE_HDRS);
	}

	/* ARGSUSED */
	static void
	hdr_l2only_dest(void vbuf, void unused)
	{
	arc_buf_hdr_t *hdr __maybe_unused = vbuf;

	ASSERT(HDR_EMPTY(hdr));
	arc_space_return(HDR_L2ONLY_SIZE, ARC_SPACE_L2HDRS);
	}

	/* ARGSUSED */
	static void
	buf_dest(void vbuf, void unused)
	{
	arc_buf_t *buf = vbuf;

	mutex_destroy(&buf->b_evict_lock);
	arc_space_return(sizeof (arc_buf_t), ARC_SPACE_HDRS);
	}

	static void
	buf_init(void)
	{
	uint64_t *ct = NULL;
	uint64_t hsize = 1ULL << 12;
	int i, j;

	/*
	* The hash table is big enough to fill all of physical memory
	* with an average block size of zfs_arc_average_blocksize (default 8K).
	* By default, the table will take up
	* totalmem * sizeof(void*) / 8K (1MB per GB with 8-byte pointers).
	*/
	while (hsize * zfs_arc_average_blocksize < arc_all_memory())
	hsize <<= 1;
	retry:
	buf_hash_table.ht_mask = hsize - 1;
	#if defined(_KERNEL)
	/*
	* Large allocations which do not require contiguous pages
	* should be using vmem_alloc() in the linux kernel
	*/
	buf_hash_table.ht_table =
	vmem_zalloc(hsize * sizeof (void*), KM_SLEEP);
	#else
	buf_hash_table.ht_table =
	kmem_zalloc(hsize * sizeof (void*), KM_NOSLEEP);
	#endif
	if (buf_hash_table.ht_table == NULL) {
	ASSERT(hsize > (1ULL << 8));
	hsize >>= 1;
	goto retry;
	}

	hdr_full_cache = kmem_cache_create("arc_buf_hdr_t_full", HDR_FULL_SIZE,
	0, hdr_full_cons, hdr_full_dest, NULL, NULL, NULL, 0);
	hdr_full_crypt_cache = kmem_cache_create("arc_buf_hdr_t_full_crypt",
	HDR_FULL_CRYPT_SIZE, 0, hdr_full_crypt_cons, hdr_full_crypt_dest,
	NULL, NULL, NULL, 0);
	hdr_l2only_cache = kmem_cache_create("arc_buf_hdr_t_l2only",
	HDR_L2ONLY_SIZE, 0, hdr_l2only_cons, hdr_l2only_dest, NULL,
	NULL, NULL, 0);
	buf_cache = kmem_cache_create("arc_buf_t", sizeof (arc_buf_t),
	0, buf_cons, buf_dest, NULL, NULL, NULL, 0);

	for (i = 0; i < 256; i++)
	for (ct = zfs_crc64_table + i, *ct = i, j = 8; j > 0; j--)
	ct = (ct >> 1) ^ (-(*ct & 1) & ZFS_CRC64_POLY);

	for (i = 0; i < BUF_LOCKS; i++) {
	mutex_init(&buf_hash_table.ht_locks[i].ht_lock,
	NULL, MUTEX_DEFAULT, NULL);
	}
	}

	#define ARC_MINTIME (hz>>4) /* 62 ms */

	/*
	* This is the size that the buf occupies in memory. If the buf is compressed,
	* it will correspond to the compressed size. You should use this method of
	* getting the buf size unless you explicitly need the logical size.
	*/
	uint64_t
	arc_buf_size(arc_buf_t *buf)
	{
	return (ARC_BUF_COMPRESSED(buf) ?
	HDR_GET_PSIZE(buf->b_hdr) : HDR_GET_LSIZE(buf->b_hdr));
	}

	uint64_t
	arc_buf_lsize(arc_buf_t *buf)
	{
	return (HDR_GET_LSIZE(buf->b_hdr));
	}

	/*
	* This function will return B_TRUE if the buffer is encrypted in memory.
	* This buffer can be decrypted by calling arc_untransform().
	*/
	boolean_t
	arc_is_encrypted(arc_buf_t *buf)
	{
	return (ARC_BUF_ENCRYPTED(buf) != 0);
	}

	/*
	* Returns B_TRUE if the buffer represents data that has not had its MAC
	* verified yet.
	*/
	boolean_t
	arc_is_unauthenticated(arc_buf_t *buf)
	{
	return (HDR_NOAUTH(buf->b_hdr) != 0);
	}

	void
	arc_get_raw_params(arc_buf_t buf, boolean_t byteorder, uint8_t *salt,
	uint8_t iv, uint8_t mac)
	{
	arc_buf_hdr_t *hdr = buf->b_hdr;

	ASSERT(HDR_PROTECTED(hdr));

	bcopy(hdr->b_crypt_hdr.b_salt, salt, ZIO_DATA_SALT_LEN);
	bcopy(hdr->b_crypt_hdr.b_iv, iv, ZIO_DATA_IV_LEN);
	bcopy(hdr->b_crypt_hdr.b_mac, mac, ZIO_DATA_MAC_LEN);
	*byteorder = (hdr->b_l1hdr.b_byteswap == DMU_BSWAP_NUMFUNCS) ?
	ZFS_HOST_BYTEORDER : !ZFS_HOST_BYTEORDER;
	}

	/*
	* Indicates how this buffer is compressed in memory. If it is not compressed
	* the value will be ZIO_COMPRESS_OFF. It can be made normally readable with
	* arc_untransform() as long as it is also unencrypted.
	*/
	enum zio_compress
	arc_get_compression(arc_buf_t *buf)
	{
	return (ARC_BUF_COMPRESSED(buf) ?
	HDR_GET_COMPRESS(buf->b_hdr) : ZIO_COMPRESS_OFF);
	}

	/*
	* Return the compression algorithm used to store this data in the ARC. If ARC
	* compression is enabled or this is an encrypted block, this will be the same
	* as what's used to store it on-disk. Otherwise, this will be ZIO_COMPRESS_OFF.
	*/
	static inline enum zio_compress
	arc_hdr_get_compress(arc_buf_hdr_t *hdr)
	{
	return (HDR_COMPRESSION_ENABLED(hdr) ?
	HDR_GET_COMPRESS(hdr) : ZIO_COMPRESS_OFF);
	}

	uint8_t
	arc_get_complevel(arc_buf_t *buf)
	{
	return (buf->b_hdr->b_complevel);
	}

	static inline boolean_t
	arc_buf_is_shared(arc_buf_t *buf)
	{
	boolean_t shared = (buf->b_data != NULL &&
	buf->b_hdr->b_l1hdr.b_pabd != NULL &&
	abd_is_linear(buf->b_hdr->b_l1hdr.b_pabd) &&
	buf->b_data == abd_to_buf(buf->b_hdr->b_l1hdr.b_pabd));
	IMPLY(shared, HDR_SHARED_DATA(buf->b_hdr));
	IMPLY(shared, ARC_BUF_SHARED(buf));
	IMPLY(shared, ARC_BUF_COMPRESSED(buf) \|\| ARC_BUF_LAST(buf));

	/*
	* It would be nice to assert arc_can_share() too, but the "hdr isn't
	* already being shared" requirement prevents us from doing that.
	*/

	return (shared);
	}

	/*
	* Free the checksum associated with this header. If there is no checksum, this
	* is a no-op.
	*/
	static inline void
	arc_cksum_free(arc_buf_hdr_t *hdr)
	{
	ASSERT(HDR_HAS_L1HDR(hdr));

	mutex_enter(&hdr->b_l1hdr.b_freeze_lock);
	if (hdr->b_l1hdr.b_freeze_cksum != NULL) {
	kmem_free(hdr->b_l1hdr.b_freeze_cksum, sizeof (zio_cksum_t));
	hdr->b_l1hdr.b_freeze_cksum = NULL;
	}
	mutex_exit(&hdr->b_l1hdr.b_freeze_lock);
	}

	/*
	* Return true iff at least one of the bufs on hdr is not compressed.
	* Encrypted buffers count as compressed.
	*/
	static boolean_t
	arc_hdr_has_uncompressed_buf(arc_buf_hdr_t *hdr)
	{
	ASSERT(hdr->b_l1hdr.b_state == arc_anon \|\| HDR_EMPTY_OR_LOCKED(hdr));

	for (arc_buf_t *b = hdr->b_l1hdr.b_buf; b != NULL; b = b->b_next) {
	if (!ARC_BUF_COMPRESSED(b)) {
	return (B_TRUE);
	}
	}
	return (B_FALSE);
	}


	/*
	* If we've turned on the ZFS_DEBUG_MODIFY flag, verify that the buf's data
	* matches the checksum that is stored in the hdr. If there is no checksum,
	* or if the buf is compressed, this is a no-op.
	*/
	static void
	arc_cksum_verify(arc_buf_t *buf)
	{
	arc_buf_hdr_t *hdr = buf->b_hdr;
	zio_cksum_t zc;

	if (!(zfs_flags & ZFS_DEBUG_MODIFY))
	return;

	if (ARC_BUF_COMPRESSED(buf))
	return;

	ASSERT(HDR_HAS_L1HDR(hdr));

	mutex_enter(&hdr->b_l1hdr.b_freeze_lock);

	if (hdr->b_l1hdr.b_freeze_cksum == NULL \|\| HDR_IO_ERROR(hdr)) {
	mutex_exit(&hdr->b_l1hdr.b_freeze_lock);
	return;
	}

	fletcher_2_native(buf->b_data, arc_buf_size(buf), NULL, &zc);
	if (!ZIO_CHECKSUM_EQUAL(*hdr->b_l1hdr.b_freeze_cksum, zc))
	panic("buffer modified while frozen!");
	mutex_exit(&hdr->b_l1hdr.b_freeze_lock);
	}

	/*
	* This function makes the assumption that data stored in the L2ARC
	* will be transformed exactly as it is in the main pool. Because of
	* this we can verify the checksum against the reading process's bp.
	*/
	static boolean_t
	arc_cksum_is_equal(arc_buf_hdr_t hdr, zio_t zio)
	{
	ASSERT(!BP_IS_EMBEDDED(zio->io_bp));
	VERIFY3U(BP_GET_PSIZE(zio->io_bp), ==, HDR_GET_PSIZE(hdr));

	/*
	* Block pointers always store the checksum for the logical data.
	* If the block pointer has the gang bit set, then the checksum
	* it represents is for the reconstituted data and not for an
	* individual gang member. The zio pipeline, however, must be able to
	* determine the checksum of each of the gang constituents so it
	* treats the checksum comparison differently than what we need
	* for l2arc blocks. This prevents us from using the
	* zio_checksum_error() interface directly. Instead we must call the
	* zio_checksum_error_impl() so that we can ensure the checksum is
	* generated using the correct checksum algorithm and accounts for the
	* logical I/O size and not just a gang fragment.
	*/
	return (zio_checksum_error_impl(zio->io_spa, zio->io_bp,
	BP_GET_CHECKSUM(zio->io_bp), zio->io_abd, zio->io_size,
	zio->io_offset, NULL) == 0);
	}

	/*
	* Given a buf full of data, if ZFS_DEBUG_MODIFY is enabled this computes a
	* checksum and attaches it to the buf's hdr so that we can ensure that the buf
	* isn't modified later on. If buf is compressed or there is already a checksum
	* on the hdr, this is a no-op (we only checksum uncompressed bufs).
	*/
	static void
	arc_cksum_compute(arc_buf_t *buf)
	{
	arc_buf_hdr_t *hdr = buf->b_hdr;

	if (!(zfs_flags & ZFS_DEBUG_MODIFY))
	return;

	ASSERT(HDR_HAS_L1HDR(hdr));

	mutex_enter(&buf->b_hdr->b_l1hdr.b_freeze_lock);
	if (hdr->b_l1hdr.b_freeze_cksum != NULL \|\| ARC_BUF_COMPRESSED(buf)) {
	mutex_exit(&hdr->b_l1hdr.b_freeze_lock);
	return;
	}

	ASSERT(!ARC_BUF_ENCRYPTED(buf));
	ASSERT(!ARC_BUF_COMPRESSED(buf));
	hdr->b_l1hdr.b_freeze_cksum = kmem_alloc(sizeof (zio_cksum_t),
	KM_SLEEP);
	fletcher_2_native(buf->b_data, arc_buf_size(buf), NULL,
	hdr->b_l1hdr.b_freeze_cksum);
	mutex_exit(&hdr->b_l1hdr.b_freeze_lock);
	arc_buf_watch(buf);
	}

	#ifndef _KERNEL
	void
	arc_buf_sigsegv(int sig, siginfo_t si, void unused)
	{
	panic("Got SIGSEGV at address: 0x%lx\n", (long)si->si_addr);
	}
	#endif

	/* ARGSUSED */
	static void
	arc_buf_unwatch(arc_buf_t *buf)
	{
	#ifndef _KERNEL
	if (arc_watch) {
	ASSERT0(mprotect(buf->b_data, arc_buf_size(buf),
	PROT_READ \| PROT_WRITE));
	}
	#endif
	}

	/* ARGSUSED */
	static void
	arc_buf_watch(arc_buf_t *buf)
	{
	#ifndef _KERNEL
	if (arc_watch)
	ASSERT0(mprotect(buf->b_data, arc_buf_size(buf),
	PROT_READ));
	#endif
	}

	static arc_buf_contents_t
	arc_buf_type(arc_buf_hdr_t *hdr)
	{
	arc_buf_contents_t type;
	if (HDR_ISTYPE_METADATA(hdr)) {
	type = ARC_BUFC_METADATA;
	} else {
	type = ARC_BUFC_DATA;
	}
	VERIFY3U(hdr->b_type, ==, type);
	return (type);
	}

	boolean_t
	arc_is_metadata(arc_buf_t *buf)
	{
	return (HDR_ISTYPE_METADATA(buf->b_hdr) != 0);
	}

	static uint32_t
	arc_bufc_to_flags(arc_buf_contents_t type)
	{
	switch (type) {
	case ARC_BUFC_DATA:
	/* metadata field is 0 if buffer contains normal data */
	return (0);
	case ARC_BUFC_METADATA:
	return (ARC_FLAG_BUFC_METADATA);
	default:
	break;
	}
	panic("undefined ARC buffer type!");
	return ((uint32_t)-1);
	}

	void
	arc_buf_thaw(arc_buf_t *buf)
	{
	arc_buf_hdr_t *hdr = buf->b_hdr;

	ASSERT3P(hdr->b_l1hdr.b_state, ==, arc_anon);
	ASSERT(!HDR_IO_IN_PROGRESS(hdr));

	arc_cksum_verify(buf);

	/*
	* Compressed buffers do not manipulate the b_freeze_cksum.
	*/
	if (ARC_BUF_COMPRESSED(buf))
	return;

	ASSERT(HDR_HAS_L1HDR(hdr));
	arc_cksum_free(hdr);
	arc_buf_unwatch(buf);
	}

	void
	arc_buf_freeze(arc_buf_t *buf)
	{
	if (!(zfs_flags & ZFS_DEBUG_MODIFY))
	return;

	if (ARC_BUF_COMPRESSED(buf))
	return;

	ASSERT(HDR_HAS_L1HDR(buf->b_hdr));
	arc_cksum_compute(buf);
	}

	/*
	* The arc_buf_hdr_t's b_flags should never be modified directly. Instead,
	* the following functions should be used to ensure that the flags are
	* updated in a thread-safe way. When manipulating the flags either
	* the hash_lock must be held or the hdr must be undiscoverable. This
	* ensures that we're not racing with any other threads when updating
	* the flags.
	*/
	static inline void
	arc_hdr_set_flags(arc_buf_hdr_t *hdr, arc_flags_t flags)
	{
	ASSERT(HDR_EMPTY_OR_LOCKED(hdr));
	hdr->b_flags \|= flags;
	}

	static inline void
	arc_hdr_clear_flags(arc_buf_hdr_t *hdr, arc_flags_t flags)
	{
	ASSERT(HDR_EMPTY_OR_LOCKED(hdr));
	hdr->b_flags &= ~flags;
	}

	/*
	* Setting the compression bits in the arc_buf_hdr_t's b_flags is
	* done in a special way since we have to clear and set bits
	* at the same time. Consumers that wish to set the compression bits
	* must use this function to ensure that the flags are updated in
	* thread-safe manner.
	*/
	static void
	arc_hdr_set_compress(arc_buf_hdr_t *hdr, enum zio_compress cmp)
	{
	ASSERT(HDR_EMPTY_OR_LOCKED(hdr));

	/*
	* Holes and embedded blocks will always have a psize = 0 so
	* we ignore the compression of the blkptr and set the
	* want to uncompress them. Mark them as uncompressed.
	*/
	if (!zfs_compressed_arc_enabled \|\| HDR_GET_PSIZE(hdr) == 0) {
	arc_hdr_clear_flags(hdr, ARC_FLAG_COMPRESSED_ARC);
	ASSERT(!HDR_COMPRESSION_ENABLED(hdr));
	} else {
	arc_hdr_set_flags(hdr, ARC_FLAG_COMPRESSED_ARC);
	ASSERT(HDR_COMPRESSION_ENABLED(hdr));
	}

	HDR_SET_COMPRESS(hdr, cmp);
	ASSERT3U(HDR_GET_COMPRESS(hdr), ==, cmp);
	}

	/*
	* Looks for another buf on the same hdr which has the data decompressed, copies
	* from it, and returns true. If no such buf exists, returns false.
	*/
	static boolean_t
	arc_buf_try_copy_decompressed_data(arc_buf_t *buf)
	{
	arc_buf_hdr_t *hdr = buf->b_hdr;
	boolean_t copied = B_FALSE;

	ASSERT(HDR_HAS_L1HDR(hdr));
	ASSERT3P(buf->b_data, !=, NULL);
	ASSERT(!ARC_BUF_COMPRESSED(buf));

	for (arc_buf_t *from = hdr->b_l1hdr.b_buf; from != NULL;
	from = from->b_next) {
	/* can't use our own data buffer */
	if (from == buf) {
	continue;
	}

	if (!ARC_BUF_COMPRESSED(from)) {
	bcopy(from->b_data, buf->b_data, arc_buf_size(buf));
	copied = B_TRUE;
	break;
	}
	}

	/*
	* There were no decompressed bufs, so there should not be a
	* checksum on the hdr either.
	*/
	if (zfs_flags & ZFS_DEBUG_MODIFY)
	EQUIV(!copied, hdr->b_l1hdr.b_freeze_cksum == NULL);

	return (copied);
	}

	/*
	* Allocates an ARC buf header that's in an evicted & L2-cached state.
	* This is used during l2arc reconstruction to make empty ARC buffers
	* which circumvent the regular disk->arc->l2arc path and instead come
	* into being in the reverse order, i.e. l2arc->arc.
	*/
	static arc_buf_hdr_t *
	arc_buf_alloc_l2only(size_t size, arc_buf_contents_t type, l2arc_dev_t *dev,
	dva_t dva, uint64_t daddr, int32_t psize, uint64_t birth,
	enum zio_compress compress, uint8_t complevel, boolean_t protected,
	boolean_t prefetch, arc_state_type_t arcs_state)
	{
	arc_buf_hdr_t *hdr;

	ASSERT(size != 0);
	hdr = kmem_cache_alloc(hdr_l2only_cache, KM_SLEEP);
	hdr->b_birth = birth;
	hdr->b_type = type;
	hdr->b_flags = 0;
	arc_hdr_set_flags(hdr, arc_bufc_to_flags(type) \| ARC_FLAG_HAS_L2HDR);
	HDR_SET_LSIZE(hdr, size);
	HDR_SET_PSIZE(hdr, psize);
	arc_hdr_set_compress(hdr, compress);
	hdr->b_complevel = complevel;
	if (protected)
	arc_hdr_set_flags(hdr, ARC_FLAG_PROTECTED);
	if (prefetch)
	arc_hdr_set_flags(hdr, ARC_FLAG_PREFETCH);
	hdr->b_spa = spa_load_guid(dev->l2ad_vdev->vdev_spa);

	hdr->b_dva = dva;

	hdr->b_l2hdr.b_dev = dev;
	hdr->b_l2hdr.b_daddr = daddr;
	hdr->b_l2hdr.b_arcs_state = arcs_state;

	return (hdr);
	}

	/*
	* Return the size of the block, b_pabd, that is stored in the arc_buf_hdr_t.
	*/
	static uint64_t
	arc_hdr_size(arc_buf_hdr_t *hdr)
	{
	uint64_t size;

	if (arc_hdr_get_compress(hdr) != ZIO_COMPRESS_OFF &&
	HDR_GET_PSIZE(hdr) > 0) {
	size = HDR_GET_PSIZE(hdr);
	} else {
	ASSERT3U(HDR_GET_LSIZE(hdr), !=, 0);
	size = HDR_GET_LSIZE(hdr);
	}
	return (size);
	}

	static int
	arc_hdr_authenticate(arc_buf_hdr_t hdr, spa_t spa, uint64_t dsobj)
	{
	int ret;
	uint64_t csize;
	uint64_t lsize = HDR_GET_LSIZE(hdr);
	uint64_t psize = HDR_GET_PSIZE(hdr);
	void *tmpbuf = NULL;
	abd_t *abd = hdr->b_l1hdr.b_pabd;

	ASSERT(HDR_EMPTY_OR_LOCKED(hdr));
	ASSERT(HDR_AUTHENTICATED(hdr));
	ASSERT3P(hdr->b_l1hdr.b_pabd, !=, NULL);

	/*
	* The MAC is calculated on the compressed data that is stored on disk.
	* However, if compressed arc is disabled we will only have the
	* decompressed data available to us now. Compress it into a temporary
	* abd so we can verify the MAC. The performance overhead of this will
	* be relatively low, since most objects in an encrypted objset will
	* be encrypted (instead of authenticated) anyway.
	*/
	if (HDR_GET_COMPRESS(hdr) != ZIO_COMPRESS_OFF &&
	!HDR_COMPRESSION_ENABLED(hdr)) {
	tmpbuf = zio_buf_alloc(lsize);
	abd = abd_get_from_buf(tmpbuf, lsize);
	abd_take_ownership_of_buf(abd, B_TRUE);
	csize = zio_compress_data(HDR_GET_COMPRESS(hdr),
	hdr->b_l1hdr.b_pabd, tmpbuf, lsize, hdr->b_complevel);
	ASSERT3U(csize, <=, psize);
	abd_zero_off(abd, csize, psize - csize);
	}

	/*
	* Authentication is best effort. We authenticate whenever the key is
	* available. If we succeed we clear ARC_FLAG_NOAUTH.
	*/
	if (hdr->b_crypt_hdr.b_ot == DMU_OT_OBJSET) {
	ASSERT3U(HDR_GET_COMPRESS(hdr), ==, ZIO_COMPRESS_OFF);
	ASSERT3U(lsize, ==, psize);
	ret = spa_do_crypt_objset_mac_abd(B_FALSE, spa, dsobj, abd,
	psize, hdr->b_l1hdr.b_byteswap != DMU_BSWAP_NUMFUNCS);
	} else {
	ret = spa_do_crypt_mac_abd(B_FALSE, spa, dsobj, abd, psize,
	hdr->b_crypt_hdr.b_mac);
	}

	if (ret == 0)
	arc_hdr_clear_flags(hdr, ARC_FLAG_NOAUTH);
	else if (ret != ENOENT)
	goto error;

	if (tmpbuf != NULL)
	abd_free(abd);

	return (0);

	error:
	if (tmpbuf != NULL)
	abd_free(abd);

	return (ret);
	}

	/*
	* This function will take a header that only has raw encrypted data in
	* b_crypt_hdr.b_rabd and decrypt it into a new buffer which is stored in
	* b_l1hdr.b_pabd. If designated in the header flags, this function will
	* also decompress the data.
	*/
	static int
	arc_hdr_decrypt(arc_buf_hdr_t hdr, spa_t spa, const zbookmark_phys_t *zb)
	{
	int ret;
	abd_t *cabd = NULL;
	void *tmp = NULL;
	boolean_t no_crypt = B_FALSE;
	boolean_t bswap = (hdr->b_l1hdr.b_byteswap != DMU_BSWAP_NUMFUNCS);

	ASSERT(HDR_EMPTY_OR_LOCKED(hdr));
	ASSERT(HDR_ENCRYPTED(hdr));

	arc_hdr_alloc_abd(hdr, ARC_HDR_DO_ADAPT);

	ret = spa_do_crypt_abd(B_FALSE, spa, zb, hdr->b_crypt_hdr.b_ot,
	B_FALSE, bswap, hdr->b_crypt_hdr.b_salt, hdr->b_crypt_hdr.b_iv,
	hdr->b_crypt_hdr.b_mac, HDR_GET_PSIZE(hdr), hdr->b_l1hdr.b_pabd,
	hdr->b_crypt_hdr.b_rabd, &no_crypt);
	if (ret != 0)
	goto error;

	if (no_crypt) {
	abd_copy(hdr->b_l1hdr.b_pabd, hdr->b_crypt_hdr.b_rabd,
	HDR_GET_PSIZE(hdr));
	}

	/*
	* If this header has disabled arc compression but the b_pabd is
	* compressed after decrypting it, we need to decompress the newly
	* decrypted data.
	*/
	if (HDR_GET_COMPRESS(hdr) != ZIO_COMPRESS_OFF &&
	!HDR_COMPRESSION_ENABLED(hdr)) {
	/*
	* We want to make sure that we are correctly honoring the
	* zfs_abd_scatter_enabled setting, so we allocate an abd here
	* and then loan a buffer from it, rather than allocating a
	* linear buffer and wrapping it in an abd later.
	*/
	cabd = arc_get_data_abd(hdr, arc_hdr_size(hdr), hdr, B_TRUE);
	tmp = abd_borrow_buf(cabd, arc_hdr_size(hdr));

	ret = zio_decompress_data(HDR_GET_COMPRESS(hdr),
	hdr->b_l1hdr.b_pabd, tmp, HDR_GET_PSIZE(hdr),
	HDR_GET_LSIZE(hdr), &hdr->b_complevel);
	if (ret != 0) {
	abd_return_buf(cabd, tmp, arc_hdr_size(hdr));
	goto error;
	}

	abd_return_buf_copy(cabd, tmp, arc_hdr_size(hdr));
	arc_free_data_abd(hdr, hdr->b_l1hdr.b_pabd,
	arc_hdr_size(hdr), hdr);
	hdr->b_l1hdr.b_pabd = cabd;
	}

	return (0);

	error:
	arc_hdr_free_abd(hdr, B_FALSE);
	if (cabd != NULL)
	arc_free_data_buf(hdr, cabd, arc_hdr_size(hdr), hdr);

	return (ret);
	}

	/*
	* This function is called during arc_buf_fill() to prepare the header's
	* abd plaintext pointer for use. This involves authenticated protected
	* data and decrypting encrypted data into the plaintext abd.
	*/
	static int
	arc_fill_hdr_crypt(arc_buf_hdr_t hdr, kmutex_t hash_lock, spa_t *spa,
	const zbookmark_phys_t *zb, boolean_t noauth)
	{
	int ret;

	ASSERT(HDR_PROTECTED(hdr));

	if (hash_lock != NULL)
	mutex_enter(hash_lock);

	if (HDR_NOAUTH(hdr) && !noauth) {
	/*
	* The caller requested authenticated data but our data has
	* not been authenticated yet. Verify the MAC now if we can.
	*/
	ret = arc_hdr_authenticate(hdr, spa, zb->zb_objset);
	if (ret != 0)
	goto error;
	} else if (HDR_HAS_RABD(hdr) && hdr->b_l1hdr.b_pabd == NULL) {
	/*
	* If we only have the encrypted version of the data, but the
	* unencrypted version was requested we take this opportunity
	* to store the decrypted version in the header for future use.
	*/
	ret = arc_hdr_decrypt(hdr, spa, zb);
	if (ret != 0)
	goto error;
	}

	ASSERT3P(hdr->b_l1hdr.b_pabd, !=, NULL);

	if (hash_lock != NULL)
	mutex_exit(hash_lock);

	return (0);

	error:
	if (hash_lock != NULL)
	mutex_exit(hash_lock);

	return (ret);
	}

	/*
	* This function is used by the dbuf code to decrypt bonus buffers in place.
	* The dbuf code itself doesn't have any locking for decrypting a shared dnode
	* block, so we use the hash lock here to protect against concurrent calls to
	* arc_buf_fill().
	*/
	static void
	arc_buf_untransform_in_place(arc_buf_t buf, kmutex_t hash_lock)
	{
	arc_buf_hdr_t *hdr = buf->b_hdr;

	ASSERT(HDR_ENCRYPTED(hdr));
	ASSERT3U(hdr->b_crypt_hdr.b_ot, ==, DMU_OT_DNODE);
	ASSERT(HDR_EMPTY_OR_LOCKED(hdr));
	ASSERT3P(hdr->b_l1hdr.b_pabd, !=, NULL);

	zio_crypt_copy_dnode_bonus(hdr->b_l1hdr.b_pabd, buf->b_data,
	arc_buf_size(buf));
	buf->b_flags &= ~ARC_BUF_FLAG_ENCRYPTED;
	buf->b_flags &= ~ARC_BUF_FLAG_COMPRESSED;
	hdr->b_crypt_hdr.b_ebufcnt -= 1;
	}

	/*
	* Given a buf that has a data buffer attached to it, this function will
	* efficiently fill the buf with data of the specified compression setting from
	* the hdr and update the hdr's b_freeze_cksum if necessary. If the buf and hdr
	* are already sharing a data buf, no copy is performed.
	*
	* If the buf is marked as compressed but uncompressed data was requested, this
	* will allocate a new data buffer for the buf, remove that flag, and fill the
	* buf with uncompressed data. You can't request a compressed buf on a hdr with
	* uncompressed data, and (since we haven't added support for it yet) if you
	* want compressed data your buf must already be marked as compressed and have
	* the correct-sized data buffer.
	*/
	static int
	arc_buf_fill(arc_buf_t buf, spa_t spa, const zbookmark_phys_t *zb,
	arc_fill_flags_t flags)
	{
	int error = 0;
	arc_buf_hdr_t *hdr = buf->b_hdr;
	boolean_t hdr_compressed =
	(arc_hdr_get_compress(hdr) != ZIO_COMPRESS_OFF);
	boolean_t compressed = (flags & ARC_FILL_COMPRESSED) != 0;
	boolean_t encrypted = (flags & ARC_FILL_ENCRYPTED) != 0;
	dmu_object_byteswap_t bswap = hdr->b_l1hdr.b_byteswap;
	kmutex_t *hash_lock = (flags & ARC_FILL_LOCKED) ? NULL : HDR_LOCK(hdr);

	ASSERT3P(buf->b_data, !=, NULL);
	IMPLY(compressed, hdr_compressed \|\| ARC_BUF_ENCRYPTED(buf));
	IMPLY(compressed, ARC_BUF_COMPRESSED(buf));
	IMPLY(encrypted, HDR_ENCRYPTED(hdr));
	IMPLY(encrypted, ARC_BUF_ENCRYPTED(buf));
	IMPLY(encrypted, ARC_BUF_COMPRESSED(buf));
	IMPLY(encrypted, !ARC_BUF_SHARED(buf));

	/*
	* If the caller wanted encrypted data we just need to copy it from
	* b_rabd and potentially byteswap it. We won't be able to do any
	* further transforms on it.
	*/
	if (encrypted) {
	ASSERT(HDR_HAS_RABD(hdr));
	abd_copy_to_buf(buf->b_data, hdr->b_crypt_hdr.b_rabd,
	HDR_GET_PSIZE(hdr));
	goto byteswap;
	}

	/*
	* Adjust encrypted and authenticated headers to accommodate
	* the request if needed. Dnode blocks (ARC_FILL_IN_PLACE) are
	* allowed to fail decryption due to keys not being loaded
	* without being marked as an IO error.
	*/
	if (HDR_PROTECTED(hdr)) {
	error = arc_fill_hdr_crypt(hdr, hash_lock, spa,
	zb, !!(flags & ARC_FILL_NOAUTH));
	if (error == EACCES && (flags & ARC_FILL_IN_PLACE) != 0) {
	return (error);
	} else if (error != 0) {
	if (hash_lock != NULL)
	mutex_enter(hash_lock);
	arc_hdr_set_flags(hdr, ARC_FLAG_IO_ERROR);
	if (hash_lock != NULL)
	mutex_exit(hash_lock);
	return (error);
	}
	}

	/*
	* There is a special case here for dnode blocks which are
	* decrypting their bonus buffers. These blocks may request to
	* be decrypted in-place. This is necessary because there may
	* be many dnodes pointing into this buffer and there is
	* currently no method to synchronize replacing the backing
	* b_data buffer and updating all of the pointers. Here we use
	* the hash lock to ensure there are no races. If the need
	* arises for other types to be decrypted in-place, they must
	* add handling here as well.
	*/
	if ((flags & ARC_FILL_IN_PLACE) != 0) {
	ASSERT(!hdr_compressed);
	ASSERT(!compressed);
	ASSERT(!encrypted);

	if (HDR_ENCRYPTED(hdr) && ARC_BUF_ENCRYPTED(buf)) {
	ASSERT3U(hdr->b_crypt_hdr.b_ot, ==, DMU_OT_DNODE);

	if (hash_lock != NULL)
	mutex_enter(hash_lock);
	arc_buf_untransform_in_place(buf, hash_lock);
	if (hash_lock != NULL)
	mutex_exit(hash_lock);

	/* Compute the hdr's checksum if necessary */
	arc_cksum_compute(buf);
	}

	return (0);
	}

	if (hdr_compressed == compressed) {
	if (!arc_buf_is_shared(buf)) {
	abd_copy_to_buf(buf->b_data, hdr->b_l1hdr.b_pabd,
	arc_buf_size(buf));
	}
	} else {
	ASSERT(hdr_compressed);
	ASSERT(!compressed);
	ASSERT3U(HDR_GET_LSIZE(hdr), !=, HDR_GET_PSIZE(hdr));

	/*
	* If the buf is sharing its data with the hdr, unlink it and
	* allocate a new data buffer for the buf.
	*/
	if (arc_buf_is_shared(buf)) {
	ASSERT(ARC_BUF_COMPRESSED(buf));

	/* We need to give the buf its own b_data */
	buf->b_flags &= ~ARC_BUF_FLAG_SHARED;
	buf->b_data =
	arc_get_data_buf(hdr, HDR_GET_LSIZE(hdr), buf);
	arc_hdr_clear_flags(hdr, ARC_FLAG_SHARED_DATA);

	/* Previously overhead was 0; just add new overhead */
	ARCSTAT_INCR(arcstat_overhead_size, HDR_GET_LSIZE(hdr));
	} else if (ARC_BUF_COMPRESSED(buf)) {
	/* We need to reallocate the buf's b_data */
	arc_free_data_buf(hdr, buf->b_data, HDR_GET_PSIZE(hdr),
	buf);
	buf->b_data =
	arc_get_data_buf(hdr, HDR_GET_LSIZE(hdr), buf);

	/* We increased the size of b_data; update overhead */
	ARCSTAT_INCR(arcstat_overhead_size,
	HDR_GET_LSIZE(hdr) - HDR_GET_PSIZE(hdr));
	}

	/*
	* Regardless of the buf's previous compression settings, it
	* should not be compressed at the end of this function.
	*/
	buf->b_flags &= ~ARC_BUF_FLAG_COMPRESSED;

	/*
	* Try copying the data from another buf which already has a
	* decompressed version. If that's not possible, it's time to
	* bite the bullet and decompress the data from the hdr.
	*/
	if (arc_buf_try_copy_decompressed_data(buf)) {
	/* Skip byteswapping and checksumming (already done) */
	return (0);
	} else {
	error = zio_decompress_data(HDR_GET_COMPRESS(hdr),
	hdr->b_l1hdr.b_pabd, buf->b_data,
	HDR_GET_PSIZE(hdr), HDR_GET_LSIZE(hdr),
	&hdr->b_complevel);

	/*
	* Absent hardware errors or software bugs, this should
	* be impossible, but log it anyway so we can debug it.
	*/
	if (error != 0) {
	zfs_dbgmsg(
	"hdr %px, compress %d, psize %d, lsize %d",
	hdr, arc_hdr_get_compress(hdr),
	HDR_GET_PSIZE(hdr), HDR_GET_LSIZE(hdr));
	if (hash_lock != NULL)
	mutex_enter(hash_lock);
	arc_hdr_set_flags(hdr, ARC_FLAG_IO_ERROR);
	if (hash_lock != NULL)
	mutex_exit(hash_lock);
	return (SET_ERROR(EIO));
	}
	}
	}

	byteswap:
	/* Byteswap the buf's data if necessary */
	if (bswap != DMU_BSWAP_NUMFUNCS) {
	ASSERT(!HDR_SHARED_DATA(hdr));
	ASSERT3U(bswap, <, DMU_BSWAP_NUMFUNCS);
	dmu_ot_byteswap[bswap].ob_func(buf->b_data, HDR_GET_LSIZE(hdr));
	}

	/* Compute the hdr's checksum if necessary */
	arc_cksum_compute(buf);

	return (0);
	}

	/*
	* If this function is being called to decrypt an encrypted buffer or verify an
	* authenticated one, the key must be loaded and a mapping must be made
	* available in the keystore via spa_keystore_create_mapping() or one of its
	* callers.
	*/
	int
	arc_untransform(arc_buf_t buf, spa_t spa, const zbookmark_phys_t *zb,
	boolean_t in_place)
	{
	int ret;
	arc_fill_flags_t flags = 0;

	if (in_place)
	flags \|= ARC_FILL_IN_PLACE;

	ret = arc_buf_fill(buf, spa, zb, flags);
	if (ret == ECKSUM) {
	/*
	* Convert authentication and decryption errors to EIO
	* (and generate an ereport) before leaving the ARC.
	*/
	ret = SET_ERROR(EIO);
	spa_log_error(spa, zb);
	(void) zfs_ereport_post(FM_EREPORT_ZFS_AUTHENTICATION,
	spa, NULL, zb, NULL, 0);
	}

	return (ret);
	}

	/*
	* Increment the amount of evictable space in the arc_state_t's refcount.
	* We account for the space used by the hdr and the arc buf individually
	* so that we can add and remove them from the refcount individually.
	*/
	static void
	arc_evictable_space_increment(arc_buf_hdr_t hdr, arc_state_t state)
	{
	arc_buf_contents_t type = arc_buf_type(hdr);

	ASSERT(HDR_HAS_L1HDR(hdr));

	if (GHOST_STATE(state)) {
	ASSERT0(hdr->b_l1hdr.b_bufcnt);
	ASSERT3P(hdr->b_l1hdr.b_buf, ==, NULL);
	ASSERT3P(hdr->b_l1hdr.b_pabd, ==, NULL);
	ASSERT(!HDR_HAS_RABD(hdr));
	(void) zfs_refcount_add_many(&state->arcs_esize[type],
	HDR_GET_LSIZE(hdr), hdr);
	return;
	}

	ASSERT(!GHOST_STATE(state));
	if (hdr->b_l1hdr.b_pabd != NULL) {
	(void) zfs_refcount_add_many(&state->arcs_esize[type],
	arc_hdr_size(hdr), hdr);
	}
	if (HDR_HAS_RABD(hdr)) {
	(void) zfs_refcount_add_many(&state->arcs_esize[type],
	HDR_GET_PSIZE(hdr), hdr);
	}

	for (arc_buf_t *buf = hdr->b_l1hdr.b_buf; buf != NULL;
	buf = buf->b_next) {
	if (arc_buf_is_shared(buf))
	continue;
	(void) zfs_refcount_add_many(&state->arcs_esize[type],
	arc_buf_size(buf), buf);
	}
	}

	/*
	* Decrement the amount of evictable space in the arc_state_t's refcount.
	* We account for the space used by the hdr and the arc buf individually
	* so that we can add and remove them from the refcount individually.
	*/
	static void
	arc_evictable_space_decrement(arc_buf_hdr_t hdr, arc_state_t state)
	{
	arc_buf_contents_t type = arc_buf_type(hdr);

	ASSERT(HDR_HAS_L1HDR(hdr));

	if (GHOST_STATE(state)) {
	ASSERT0(hdr->b_l1hdr.b_bufcnt);
	ASSERT3P(hdr->b_l1hdr.b_buf, ==, NULL);
	ASSERT3P(hdr->b_l1hdr.b_pabd, ==, NULL);
	ASSERT(!HDR_HAS_RABD(hdr));
	(void) zfs_refcount_remove_many(&state->arcs_esize[type],
	HDR_GET_LSIZE(hdr), hdr);
	return;
	}

	ASSERT(!GHOST_STATE(state));
	if (hdr->b_l1hdr.b_pabd != NULL) {
	(void) zfs_refcount_remove_many(&state->arcs_esize[type],
	arc_hdr_size(hdr), hdr);
	}
	if (HDR_HAS_RABD(hdr)) {
	(void) zfs_refcount_remove_many(&state->arcs_esize[type],
	HDR_GET_PSIZE(hdr), hdr);
	}

	for (arc_buf_t *buf = hdr->b_l1hdr.b_buf; buf != NULL;
	buf = buf->b_next) {
	if (arc_buf_is_shared(buf))
	continue;
	(void) zfs_refcount_remove_many(&state->arcs_esize[type],
	arc_buf_size(buf), buf);
	}
	}

	/*
	* Add a reference to this hdr indicating that someone is actively
	* referencing that memory. When the refcount transitions from 0 to 1,
	* we remove it from the respective arc_state_t list to indicate that
	* it is not evictable.
	*/
	static void
	add_reference(arc_buf_hdr_t hdr, void tag)
	{
	arc_state_t *state;

	ASSERT(HDR_HAS_L1HDR(hdr));
	if (!HDR_EMPTY(hdr) && !MUTEX_HELD(HDR_LOCK(hdr))) {
	ASSERT(hdr->b_l1hdr.b_state == arc_anon);
	ASSERT(zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt));
	ASSERT3P(hdr->b_l1hdr.b_buf, ==, NULL);
	}

	state = hdr->b_l1hdr.b_state;

	if ((zfs_refcount_add(&hdr->b_l1hdr.b_refcnt, tag) == 1) &&
	(state != arc_anon)) {
	/* We don't use the L2-only state list. */
	if (state != arc_l2c_only) {
	multilist_remove(state->arcs_list[arc_buf_type(hdr)],
	hdr);
	arc_evictable_space_decrement(hdr, state);
	}
	/* remove the prefetch flag if we get a reference */
	if (HDR_HAS_L2HDR(hdr))
	l2arc_hdr_arcstats_decrement_state(hdr);
	arc_hdr_clear_flags(hdr, ARC_FLAG_PREFETCH);
	if (HDR_HAS_L2HDR(hdr))
	l2arc_hdr_arcstats_increment_state(hdr);
	}
	}

	/*
	* Remove a reference from this hdr. When the reference transitions from
	* 1 to 0 and we're not anonymous, then we add this hdr to the arc_state_t's
	* list making it eligible for eviction.
	*/
	static int
	remove_reference(arc_buf_hdr_t hdr, kmutex_t hash_lock, void *tag)
	{
	int cnt;
	arc_state_t *state = hdr->b_l1hdr.b_state;

	ASSERT(HDR_HAS_L1HDR(hdr));
	ASSERT(state == arc_anon \|\| MUTEX_HELD(hash_lock));
	ASSERT(!GHOST_STATE(state));

	/*
	* arc_l2c_only counts as a ghost state so we don't need to explicitly
	* check to prevent usage of the arc_l2c_only list.
	*/
	if (((cnt = zfs_refcount_remove(&hdr->b_l1hdr.b_refcnt, tag)) == 0) &&
	(state != arc_anon)) {
	multilist_insert(state->arcs_list[arc_buf_type(hdr)], hdr);
	ASSERT3U(hdr->b_l1hdr.b_bufcnt, >, 0);
	arc_evictable_space_increment(hdr, state);
	}
	return (cnt);
	}

	/*
	* Returns detailed information about a specific arc buffer. When the
	* state_index argument is set the function will calculate the arc header
	* list position for its arc state. Since this requires a linear traversal
	* callers are strongly encourage not to do this. However, it can be helpful
	* for targeted analysis so the functionality is provided.
	*/
	void
	arc_buf_info(arc_buf_t ab, arc_buf_info_t abi, int state_index)
	{
	arc_buf_hdr_t *hdr = ab->b_hdr;
	l1arc_buf_hdr_t *l1hdr = NULL;
	l2arc_buf_hdr_t *l2hdr = NULL;
	arc_state_t *state = NULL;

	memset(abi, 0, sizeof (arc_buf_info_t));

	if (hdr == NULL)
	return;

	abi->abi_flags = hdr->b_flags;

	if (HDR_HAS_L1HDR(hdr)) {
	l1hdr = &hdr->b_l1hdr;
	state = l1hdr->b_state;
	}
	if (HDR_HAS_L2HDR(hdr))
	l2hdr = &hdr->b_l2hdr;

	if (l1hdr) {
	abi->abi_bufcnt = l1hdr->b_bufcnt;
	abi->abi_access = l1hdr->b_arc_access;
	abi->abi_mru_hits = l1hdr->b_mru_hits;
	abi->abi_mru_ghost_hits = l1hdr->b_mru_ghost_hits;
	abi->abi_mfu_hits = l1hdr->b_mfu_hits;
	abi->abi_mfu_ghost_hits = l1hdr->b_mfu_ghost_hits;
	abi->abi_holds = zfs_refcount_count(&l1hdr->b_refcnt);
	}

	if (l2hdr) {
	abi->abi_l2arc_dattr = l2hdr->b_daddr;
	abi->abi_l2arc_hits = l2hdr->b_hits;
	}

	abi->abi_state_type = state ? state->arcs_state : ARC_STATE_ANON;
	abi->abi_state_contents = arc_buf_type(hdr);
	abi->abi_size = arc_hdr_size(hdr);
	}

	/*
	* Move the supplied buffer to the indicated state. The hash lock
	* for the buffer must be held by the caller.
	*/
	static void
	arc_change_state(arc_state_t new_state, arc_buf_hdr_t hdr,
	kmutex_t *hash_lock)
	{
	arc_state_t *old_state;
	int64_t refcnt;
	uint32_t bufcnt;
	boolean_t update_old, update_new;
	arc_buf_contents_t buftype = arc_buf_type(hdr);

	/*
	* We almost always have an L1 hdr here, since we call arc_hdr_realloc()
	* in arc_read() when bringing a buffer out of the L2ARC. However, the
	* L1 hdr doesn't always exist when we change state to arc_anon before
	* destroying a header, in which case reallocating to add the L1 hdr is
	* pointless.
	*/
	if (HDR_HAS_L1HDR(hdr)) {
	old_state = hdr->b_l1hdr.b_state;
	refcnt = zfs_refcount_count(&hdr->b_l1hdr.b_refcnt);
	bufcnt = hdr->b_l1hdr.b_bufcnt;
	update_old = (bufcnt > 0 \|\| hdr->b_l1hdr.b_pabd != NULL \|\|
	HDR_HAS_RABD(hdr));
	} else {
	old_state = arc_l2c_only;
	refcnt = 0;
	bufcnt = 0;
	update_old = B_FALSE;
	}
	update_new = update_old;

	ASSERT(MUTEX_HELD(hash_lock));
	ASSERT3P(new_state, !=, old_state);
	ASSERT(!GHOST_STATE(new_state) \|\| bufcnt == 0);
	ASSERT(old_state != arc_anon \|\| bufcnt <= 1);

	/*
	* If this buffer is evictable, transfer it from the
	* old state list to the new state list.
	*/
	if (refcnt == 0) {
	if (old_state != arc_anon && old_state != arc_l2c_only) {
	ASSERT(HDR_HAS_L1HDR(hdr));
	multilist_remove(old_state->arcs_list[buftype], hdr);

	if (GHOST_STATE(old_state)) {
	ASSERT0(bufcnt);
	ASSERT3P(hdr->b_l1hdr.b_buf, ==, NULL);
	update_old = B_TRUE;
	}
	arc_evictable_space_decrement(hdr, old_state);
	}
	if (new_state != arc_anon && new_state != arc_l2c_only) {
	/*
	* An L1 header always exists here, since if we're
	* moving to some L1-cached state (i.e. not l2c_only or
	* anonymous), we realloc the header to add an L1hdr
	* beforehand.
	*/
	ASSERT(HDR_HAS_L1HDR(hdr));
	multilist_insert(new_state->arcs_list[buftype], hdr);

	if (GHOST_STATE(new_state)) {
	ASSERT0(bufcnt);
	ASSERT3P(hdr->b_l1hdr.b_buf, ==, NULL);
	update_new = B_TRUE;
	}
	arc_evictable_space_increment(hdr, new_state);
	}
	}

	ASSERT(!HDR_EMPTY(hdr));
	if (new_state == arc_anon && HDR_IN_HASH_TABLE(hdr))
	buf_hash_remove(hdr);

	/* adjust state sizes (ignore arc_l2c_only) */

	if (update_new && new_state != arc_l2c_only) {
	ASSERT(HDR_HAS_L1HDR(hdr));
	if (GHOST_STATE(new_state)) {
	ASSERT0(bufcnt);

	/*
	* When moving a header to a ghost state, we first
	* remove all arc buffers. Thus, we'll have a
	* bufcnt of zero, and no arc buffer to use for
	* the reference. As a result, we use the arc
	* header pointer for the reference.
	*/
	(void) zfs_refcount_add_many(&new_state->arcs_size,
	HDR_GET_LSIZE(hdr), hdr);
	ASSERT3P(hdr->b_l1hdr.b_pabd, ==, NULL);
	ASSERT(!HDR_HAS_RABD(hdr));
	} else {
	uint32_t buffers = 0;

	/*
	* Each individual buffer holds a unique reference,
	* thus we must remove each of these references one
	* at a time.
	*/
	for (arc_buf_t *buf = hdr->b_l1hdr.b_buf; buf != NULL;
	buf = buf->b_next) {
	ASSERT3U(bufcnt, !=, 0);
	buffers++;

	/*
	* When the arc_buf_t is sharing the data
	* block with the hdr, the owner of the
	* reference belongs to the hdr. Only
	* add to the refcount if the arc_buf_t is
	* not shared.
	*/
	if (arc_buf_is_shared(buf))
	continue;

	(void) zfs_refcount_add_many(
	&new_state->arcs_size,
	arc_buf_size(buf), buf);
	}
	ASSERT3U(bufcnt, ==, buffers);

	if (hdr->b_l1hdr.b_pabd != NULL) {
	(void) zfs_refcount_add_many(
	&new_state->arcs_size,
	arc_hdr_size(hdr), hdr);
	}

	if (HDR_HAS_RABD(hdr)) {
	(void) zfs_refcount_add_many(
	&new_state->arcs_size,
	HDR_GET_PSIZE(hdr), hdr);
	}
	}
	}

	if (update_old && old_state != arc_l2c_only) {
	ASSERT(HDR_HAS_L1HDR(hdr));
	if (GHOST_STATE(old_state)) {
	ASSERT0(bufcnt);
	ASSERT3P(hdr->b_l1hdr.b_pabd, ==, NULL);
	ASSERT(!HDR_HAS_RABD(hdr));

	/*
	* When moving a header off of a ghost state,
	* the header will not contain any arc buffers.
	* We use the arc header pointer for the reference
	* which is exactly what we did when we put the
	* header on the ghost state.
	*/

	(void) zfs_refcount_remove_many(&old_state->arcs_size,
	HDR_GET_LSIZE(hdr), hdr);
	} else {
	uint32_t buffers = 0;

	/*
	* Each individual buffer holds a unique reference,
	* thus we must remove each of these references one
	* at a time.
	*/
	for (arc_buf_t *buf = hdr->b_l1hdr.b_buf; buf != NULL;
	buf = buf->b_next) {
	ASSERT3U(bufcnt, !=, 0);
	buffers++;

	/*
	* When the arc_buf_t is sharing the data
	* block with the hdr, the owner of the
	* reference belongs to the hdr. Only
	* add to the refcount if the arc_buf_t is
	* not shared.
	*/
	if (arc_buf_is_shared(buf))
	continue;

	(void) zfs_refcount_remove_many(
	&old_state->arcs_size, arc_buf_size(buf),
	buf);
	}
	ASSERT3U(bufcnt, ==, buffers);
	ASSERT(hdr->b_l1hdr.b_pabd != NULL \|\|
	HDR_HAS_RABD(hdr));

	if (hdr->b_l1hdr.b_pabd != NULL) {
	(void) zfs_refcount_remove_many(
	&old_state->arcs_size, arc_hdr_size(hdr),
	hdr);
	}

	if (HDR_HAS_RABD(hdr)) {
	(void) zfs_refcount_remove_many(
	&old_state->arcs_size, HDR_GET_PSIZE(hdr),
	hdr);
	}
	}
	}

	if (HDR_HAS_L1HDR(hdr)) {
	hdr->b_l1hdr.b_state = new_state;

	if (HDR_HAS_L2HDR(hdr) && new_state != arc_l2c_only) {
	l2arc_hdr_arcstats_decrement_state(hdr);
	hdr->b_l2hdr.b_arcs_state = new_state->arcs_state;
	l2arc_hdr_arcstats_increment_state(hdr);
	}
	}

	/*
	* L2 headers should never be on the L2 state list since they don't
	* have L1 headers allocated.
	*/
	ASSERT(multilist_is_empty(arc_l2c_only->arcs_list[ARC_BUFC_DATA]) &&
	multilist_is_empty(arc_l2c_only->arcs_list[ARC_BUFC_METADATA]));
	}

	void
	arc_space_consume(uint64_t space, arc_space_type_t type)
	{
	ASSERT(type >= 0 && type < ARC_SPACE_NUMTYPES);

	switch (type) {
	default:
	break;
	case ARC_SPACE_DATA:
	aggsum_add(&astat_data_size, space);
	break;
	case ARC_SPACE_META:
	aggsum_add(&astat_metadata_size, space);
	break;
	case ARC_SPACE_BONUS:
	aggsum_add(&astat_bonus_size, space);
	break;
	case ARC_SPACE_DNODE:
	aggsum_add(&astat_dnode_size, space);
	break;
	case ARC_SPACE_DBUF:
	aggsum_add(&astat_dbuf_size, space);
	break;
	case ARC_SPACE_HDRS:
	aggsum_add(&astat_hdr_size, space);
	break;
	case ARC_SPACE_L2HDRS:
	aggsum_add(&astat_l2_hdr_size, space);
	break;
	case ARC_SPACE_ABD_CHUNK_WASTE:
	/*
	* Note: this includes space wasted by all scatter ABD's, not
	* just those allocated by the ARC. But the vast majority of
	* scatter ABD's come from the ARC, because other users are
	* very short-lived.
	*/
	aggsum_add(&astat_abd_chunk_waste_size, space);
	break;
	}

	if (type != ARC_SPACE_DATA && type != ARC_SPACE_ABD_CHUNK_WASTE)
	aggsum_add(&arc_meta_used, space);

	aggsum_add(&arc_size, space);
	}

	void
	arc_space_return(uint64_t space, arc_space_type_t type)
	{
	ASSERT(type >= 0 && type < ARC_SPACE_NUMTYPES);

	switch (type) {
	default:
	break;
	case ARC_SPACE_DATA:
	aggsum_add(&astat_data_size, -space);
	break;
	case ARC_SPACE_META:
	aggsum_add(&astat_metadata_size, -space);
	break;
	case ARC_SPACE_BONUS:
	aggsum_add(&astat_bonus_size, -space);
	break;
	case ARC_SPACE_DNODE:
	aggsum_add(&astat_dnode_size, -space);
	break;
	case ARC_SPACE_DBUF:
	aggsum_add(&astat_dbuf_size, -space);
	break;
	case ARC_SPACE_HDRS:
	aggsum_add(&astat_hdr_size, -space);
	break;
	case ARC_SPACE_L2HDRS:
	aggsum_add(&astat_l2_hdr_size, -space);
	break;
	case ARC_SPACE_ABD_CHUNK_WASTE:
	aggsum_add(&astat_abd_chunk_waste_size, -space);
	break;
	}

	if (type != ARC_SPACE_DATA && type != ARC_SPACE_ABD_CHUNK_WASTE) {
	ASSERT(aggsum_compare(&arc_meta_used, space) >= 0);
	/*
	* We use the upper bound here rather than the precise value
	* because the arc_meta_max value doesn't need to be
	* precise. It's only consumed by humans via arcstats.
	*/
	if (arc_meta_max < aggsum_upper_bound(&arc_meta_used))
	arc_meta_max = aggsum_upper_bound(&arc_meta_used);
	aggsum_add(&arc_meta_used, -space);
	}

	ASSERT(aggsum_compare(&arc_size, space) >= 0);
	aggsum_add(&arc_size, -space);
	}

	/*
	* Given a hdr and a buf, returns whether that buf can share its b_data buffer
	* with the hdr's b_pabd.
	*/
	static boolean_t
	arc_can_share(arc_buf_hdr_t hdr, arc_buf_t buf)
	{
	/*
	* The criteria for sharing a hdr's data are:
	* 1. the buffer is not encrypted
	* 2. the hdr's compression matches the buf's compression
	* 3. the hdr doesn't need to be byteswapped
	* 4. the hdr isn't already being shared
	* 5. the buf is either compressed or it is the last buf in the hdr list
	*
	* Criterion #5 maintains the invariant that shared uncompressed
	* bufs must be the final buf in the hdr's b_buf list. Reading this, you
	* might ask, "if a compressed buf is allocated first, won't that be the
	* last thing in the list?", but in that case it's impossible to create
	* a shared uncompressed buf anyway (because the hdr must be compressed
	* to have the compressed buf). You might also think that #3 is
	* sufficient to make this guarantee, however it's possible
	* (specifically in the rare L2ARC write race mentioned in
	* arc_buf_alloc_impl()) there will be an existing uncompressed buf that
	* is shareable, but wasn't at the time of its allocation. Rather than
	* allow a new shared uncompressed buf to be created and then shuffle
	* the list around to make it the last element, this simply disallows
	* sharing if the new buf isn't the first to be added.
	*/
	ASSERT3P(buf->b_hdr, ==, hdr);
	boolean_t hdr_compressed =
	arc_hdr_get_compress(hdr) != ZIO_COMPRESS_OFF;
	boolean_t buf_compressed = ARC_BUF_COMPRESSED(buf) != 0;
	return (!ARC_BUF_ENCRYPTED(buf) &&
	buf_compressed == hdr_compressed &&
	hdr->b_l1hdr.b_byteswap == DMU_BSWAP_NUMFUNCS &&
	!HDR_SHARED_DATA(hdr) &&
	(ARC_BUF_LAST(buf) \|\| ARC_BUF_COMPRESSED(buf)));
	}

	/*
	* Allocate a buf for this hdr. If you care about the data that's in the hdr,
	* or if you want a compressed buffer, pass those flags in. Returns 0 if the
	* copy was made successfully, or an error code otherwise.
	*/
	static int
	arc_buf_alloc_impl(arc_buf_hdr_t hdr, spa_t spa, const zbookmark_phys_t *zb,
	void *tag, boolean_t encrypted, boolean_t compressed, boolean_t noauth,
	boolean_t fill, arc_buf_t **ret)
	{
	arc_buf_t *buf;
	arc_fill_flags_t flags = ARC_FILL_LOCKED;

	ASSERT(HDR_HAS_L1HDR(hdr));
	ASSERT3U(HDR_GET_LSIZE(hdr), >, 0);
	VERIFY(hdr->b_type == ARC_BUFC_DATA \|\|
	hdr->b_type == ARC_BUFC_METADATA);
	ASSERT3P(ret, !=, NULL);
	ASSERT3P(*ret, ==, NULL);
	IMPLY(encrypted, compressed);

	hdr->b_l1hdr.b_mru_hits = 0;
	hdr->b_l1hdr.b_mru_ghost_hits = 0;
	hdr->b_l1hdr.b_mfu_hits = 0;
	hdr->b_l1hdr.b_mfu_ghost_hits = 0;
	hdr->b_l1hdr.b_l2_hits = 0;

	buf = *ret = kmem_cache_alloc(buf_cache, KM_PUSHPAGE);
	buf->b_hdr = hdr;
	buf->b_data = NULL;
	buf->b_next = hdr->b_l1hdr.b_buf;
	buf->b_flags = 0;

	add_reference(hdr, tag);

	/*
	* We're about to change the hdr's b_flags. We must either
	* hold the hash_lock or be undiscoverable.
	*/
	ASSERT(HDR_EMPTY_OR_LOCKED(hdr));

	/*
	* Only honor requests for compressed bufs if the hdr is actually
	* compressed. This must be overridden if the buffer is encrypted since
	* encrypted buffers cannot be decompressed.
	*/
	if (encrypted) {
	buf->b_flags \|= ARC_BUF_FLAG_COMPRESSED;
	buf->b_flags \|= ARC_BUF_FLAG_ENCRYPTED;
	flags \|= ARC_FILL_COMPRESSED \| ARC_FILL_ENCRYPTED;
	} else if (compressed &&
	arc_hdr_get_compress(hdr) != ZIO_COMPRESS_OFF) {
	buf->b_flags \|= ARC_BUF_FLAG_COMPRESSED;
	flags \|= ARC_FILL_COMPRESSED;
	}

	if (noauth) {
	ASSERT0(encrypted);
	flags \|= ARC_FILL_NOAUTH;
	}

	/*
	* If the hdr's data can be shared then we share the data buffer and
	* set the appropriate bit in the hdr's b_flags to indicate the hdr is
	* sharing it's b_pabd with the arc_buf_t. Otherwise, we allocate a new
	* buffer to store the buf's data.
	*
	* There are two additional restrictions here because we're sharing
	* hdr -> buf instead of the usual buf -> hdr. First, the hdr can't be
	* actively involved in an L2ARC write, because if this buf is used by
	* an arc_write() then the hdr's data buffer will be released when the
	* write completes, even though the L2ARC write might still be using it.
	* Second, the hdr's ABD must be linear so that the buf's user doesn't
	* need to be ABD-aware. It must be allocated via
	* zio_[data_]buf_alloc(), not as a page, because we need to be able
	* to abd_release_ownership_of_buf(), which isn't allowed on "linear
	* page" buffers because the ABD code needs to handle freeing them
	* specially.
	*/
	boolean_t can_share = arc_can_share(hdr, buf) &&
	!HDR_L2_WRITING(hdr) &&
	hdr->b_l1hdr.b_pabd != NULL &&
	abd_is_linear(hdr->b_l1hdr.b_pabd) &&
	!abd_is_linear_page(hdr->b_l1hdr.b_pabd);

	/* Set up b_data and sharing */
	if (can_share) {
	buf->b_data = abd_to_buf(hdr->b_l1hdr.b_pabd);
	buf->b_flags \|= ARC_BUF_FLAG_SHARED;
	arc_hdr_set_flags(hdr, ARC_FLAG_SHARED_DATA);
	} else {
	buf->b_data =
	arc_get_data_buf(hdr, arc_buf_size(buf), buf);
	ARCSTAT_INCR(arcstat_overhead_size, arc_buf_size(buf));
	}
	VERIFY3P(buf->b_data, !=, NULL);

	hdr->b_l1hdr.b_buf = buf;
	hdr->b_l1hdr.b_bufcnt += 1;
	if (encrypted)
	hdr->b_crypt_hdr.b_ebufcnt += 1;

	/*
	* If the user wants the data from the hdr, we need to either copy or
	* decompress the data.
	*/
	if (fill) {
	ASSERT3P(zb, !=, NULL);
	return (arc_buf_fill(buf, spa, zb, flags));
	}

	return (0);
	}

	static char *arc_onloan_tag = "onloan";

	static inline void
	arc_loaned_bytes_update(int64_t delta)
	{
	atomic_add_64(&arc_loaned_bytes, delta);

	/* assert that it did not wrap around */
	ASSERT3S(atomic_add_64_nv(&arc_loaned_bytes, 0), >=, 0);
	}

	/*
	* Loan out an anonymous arc buffer. Loaned buffers are not counted as in
	* flight data by arc_tempreserve_space() until they are "returned". Loaned
	* buffers must be returned to the arc before they can be used by the DMU or
	* freed.
	*/
	arc_buf_t *
	arc_loan_buf(spa_t *spa, boolean_t is_metadata, int size)
	{
	arc_buf_t *buf = arc_alloc_buf(spa, arc_onloan_tag,
	is_metadata ? ARC_BUFC_METADATA : ARC_BUFC_DATA, size);

	arc_loaned_bytes_update(arc_buf_size(buf));

	return (buf);
	}

	arc_buf_t *
	arc_loan_compressed_buf(spa_t *spa, uint64_t psize, uint64_t lsize,
	enum zio_compress compression_type, uint8_t complevel)
	{
	arc_buf_t *buf = arc_alloc_compressed_buf(spa, arc_onloan_tag,
	psize, lsize, compression_type, complevel);

	arc_loaned_bytes_update(arc_buf_size(buf));

	return (buf);
	}

	arc_buf_t *
	arc_loan_raw_buf(spa_t *spa, uint64_t dsobj, boolean_t byteorder,
	const uint8_t salt, const uint8_t iv, const uint8_t *mac,
	dmu_object_type_t ot, uint64_t psize, uint64_t lsize,
	enum zio_compress compression_type, uint8_t complevel)
	{
	arc_buf_t *buf = arc_alloc_raw_buf(spa, arc_onloan_tag, dsobj,
	byteorder, salt, iv, mac, ot, psize, lsize, compression_type,
	complevel);

	atomic_add_64(&arc_loaned_bytes, psize);
	return (buf);
	}


	/*
	* Return a loaned arc buffer to the arc.
	*/
	void
	arc_return_buf(arc_buf_t buf, void tag)
	{
	arc_buf_hdr_t *hdr = buf->b_hdr;

	ASSERT3P(buf->b_data, !=, NULL);
	ASSERT(HDR_HAS_L1HDR(hdr));
	(void) zfs_refcount_add(&hdr->b_l1hdr.b_refcnt, tag);
	(void) zfs_refcount_remove(&hdr->b_l1hdr.b_refcnt, arc_onloan_tag);

	arc_loaned_bytes_update(-arc_buf_size(buf));
	}

	/* Detach an arc_buf from a dbuf (tag) */
	void
	arc_loan_inuse_buf(arc_buf_t buf, void tag)
	{
	arc_buf_hdr_t *hdr = buf->b_hdr;

	ASSERT3P(buf->b_data, !=, NULL);
	ASSERT(HDR_HAS_L1HDR(hdr));
	(void) zfs_refcount_add(&hdr->b_l1hdr.b_refcnt, arc_onloan_tag);
	(void) zfs_refcount_remove(&hdr->b_l1hdr.b_refcnt, tag);

	arc_loaned_bytes_update(arc_buf_size(buf));
	}

	static void
	l2arc_free_abd_on_write(abd_t *abd, size_t size, arc_buf_contents_t type)
	{
	l2arc_data_free_t df = kmem_alloc(sizeof (df), KM_SLEEP);

	df->l2df_abd = abd;
	df->l2df_size = size;
	df->l2df_type = type;
	mutex_enter(&l2arc_free_on_write_mtx);
	list_insert_head(l2arc_free_on_write, df);
	mutex_exit(&l2arc_free_on_write_mtx);
	}

	static void
	arc_hdr_free_on_write(arc_buf_hdr_t *hdr, boolean_t free_rdata)
	{
	arc_state_t *state = hdr->b_l1hdr.b_state;
	arc_buf_contents_t type = arc_buf_type(hdr);
	uint64_t size = (free_rdata) ? HDR_GET_PSIZE(hdr) : arc_hdr_size(hdr);

	/* protected by hash lock, if in the hash table */
	if (multilist_link_active(&hdr->b_l1hdr.b_arc_node)) {
	ASSERT(zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt));
	ASSERT(state != arc_anon && state != arc_l2c_only);

	(void) zfs_refcount_remove_many(&state->arcs_esize[type],
	size, hdr);
	}
	(void) zfs_refcount_remove_many(&state->arcs_size, size, hdr);
	if (type == ARC_BUFC_METADATA) {
	arc_space_return(size, ARC_SPACE_META);
	} else {
	ASSERT(type == ARC_BUFC_DATA);
	arc_space_return(size, ARC_SPACE_DATA);
	}

	if (free_rdata) {
	l2arc_free_abd_on_write(hdr->b_crypt_hdr.b_rabd, size, type);
	} else {
	l2arc_free_abd_on_write(hdr->b_l1hdr.b_pabd, size, type);
	}
	}

	/*
	* Share the arc_buf_t's data with the hdr. Whenever we are sharing the
	* data buffer, we transfer the refcount ownership to the hdr and update
	* the appropriate kstats.
	*/
	static void
	arc_share_buf(arc_buf_hdr_t hdr, arc_buf_t buf)
	{
	ASSERT(arc_can_share(hdr, buf));
	ASSERT3P(hdr->b_l1hdr.b_pabd, ==, NULL);
	ASSERT(!ARC_BUF_ENCRYPTED(buf));
	ASSERT(HDR_EMPTY_OR_LOCKED(hdr));

	/*
	* Start sharing the data buffer. We transfer the
	* refcount ownership to the hdr since it always owns
	* the refcount whenever an arc_buf_t is shared.
	*/
	zfs_refcount_transfer_ownership_many(&hdr->b_l1hdr.b_state->arcs_size,
	arc_hdr_size(hdr), buf, hdr);
	hdr->b_l1hdr.b_pabd = abd_get_from_buf(buf->b_data, arc_buf_size(buf));
	abd_take_ownership_of_buf(hdr->b_l1hdr.b_pabd,
	HDR_ISTYPE_METADATA(hdr));
	arc_hdr_set_flags(hdr, ARC_FLAG_SHARED_DATA);
	buf->b_flags \|= ARC_BUF_FLAG_SHARED;

	/*
	* Since we've transferred ownership to the hdr we need
	* to increment its compressed and uncompressed kstats and
	* decrement the overhead size.
	*/
	ARCSTAT_INCR(arcstat_compressed_size, arc_hdr_size(hdr));
	ARCSTAT_INCR(arcstat_uncompressed_size, HDR_GET_LSIZE(hdr));
	ARCSTAT_INCR(arcstat_overhead_size, -arc_buf_size(buf));
	}

	static void
	arc_unshare_buf(arc_buf_hdr_t hdr, arc_buf_t buf)
	{
	ASSERT(arc_buf_is_shared(buf));
	ASSERT3P(hdr->b_l1hdr.b_pabd, !=, NULL);
	ASSERT(HDR_EMPTY_OR_LOCKED(hdr));

	/*
	* We are no longer sharing this buffer so we need
	* to transfer its ownership to the rightful owner.
	*/
	zfs_refcount_transfer_ownership_many(&hdr->b_l1hdr.b_state->arcs_size,
	arc_hdr_size(hdr), hdr, buf);
	arc_hdr_clear_flags(hdr, ARC_FLAG_SHARED_DATA);
	abd_release_ownership_of_buf(hdr->b_l1hdr.b_pabd);
	abd_free(hdr->b_l1hdr.b_pabd);
	hdr->b_l1hdr.b_pabd = NULL;
	buf->b_flags &= ~ARC_BUF_FLAG_SHARED;

	/*
	* Since the buffer is no longer shared between
	* the arc buf and the hdr, count it as overhead.
	*/
	ARCSTAT_INCR(arcstat_compressed_size, -arc_hdr_size(hdr));
	ARCSTAT_INCR(arcstat_uncompressed_size, -HDR_GET_LSIZE(hdr));
	ARCSTAT_INCR(arcstat_overhead_size, arc_buf_size(buf));
	}

	/*
	* Remove an arc_buf_t from the hdr's buf list and return the last
	* arc_buf_t on the list. If no buffers remain on the list then return
	* NULL.
	*/
	static arc_buf_t *
	arc_buf_remove(arc_buf_hdr_t hdr, arc_buf_t buf)
	{
	ASSERT(HDR_HAS_L1HDR(hdr));
	ASSERT(HDR_EMPTY_OR_LOCKED(hdr));

	arc_buf_t **bufp = &hdr->b_l1hdr.b_buf;
	arc_buf_t *lastbuf = NULL;

	/*
	* Remove the buf from the hdr list and locate the last
	* remaining buffer on the list.
	*/
	while (*bufp != NULL) {
	if (*bufp == buf)
	*bufp = buf->b_next;

	/*
	* If we've removed a buffer in the middle of
	* the list then update the lastbuf and update
	* bufp.
	*/
	if (*bufp != NULL) {
	lastbuf = *bufp;
	bufp = &(*bufp)->b_next;
	}
	}
	buf->b_next = NULL;
	ASSERT3P(lastbuf, !=, buf);
	IMPLY(hdr->b_l1hdr.b_bufcnt > 0, lastbuf != NULL);
	IMPLY(hdr->b_l1hdr.b_bufcnt > 0, hdr->b_l1hdr.b_buf != NULL);
	IMPLY(lastbuf != NULL, ARC_BUF_LAST(lastbuf));

	return (lastbuf);
	}

	/*
	* Free up buf->b_data and pull the arc_buf_t off of the arc_buf_hdr_t's
	* list and free it.
	*/
	static void
	arc_buf_destroy_impl(arc_buf_t *buf)
	{
	arc_buf_hdr_t *hdr = buf->b_hdr;

	/*
	* Free up the data associated with the buf but only if we're not
	* sharing this with the hdr. If we are sharing it with the hdr, the
	* hdr is responsible for doing the free.
	*/
	if (buf->b_data != NULL) {
	/*
	* We're about to change the hdr's b_flags. We must either
	* hold the hash_lock or be undiscoverable.
	*/
	ASSERT(HDR_EMPTY_OR_LOCKED(hdr));

	arc_cksum_verify(buf);
	arc_buf_unwatch(buf);

	if (arc_buf_is_shared(buf)) {
	arc_hdr_clear_flags(hdr, ARC_FLAG_SHARED_DATA);
	} else {
	uint64_t size = arc_buf_size(buf);
	arc_free_data_buf(hdr, buf->b_data, size, buf);
	ARCSTAT_INCR(arcstat_overhead_size, -size);
	}
	buf->b_data = NULL;

	ASSERT(hdr->b_l1hdr.b_bufcnt > 0);
	hdr->b_l1hdr.b_bufcnt -= 1;

	if (ARC_BUF_ENCRYPTED(buf)) {
	hdr->b_crypt_hdr.b_ebufcnt -= 1;

	/*
	* If we have no more encrypted buffers and we've
	* already gotten a copy of the decrypted data we can
	* free b_rabd to save some space.
	*/
	if (hdr->b_crypt_hdr.b_ebufcnt == 0 &&
	HDR_HAS_RABD(hdr) && hdr->b_l1hdr.b_pabd != NULL &&
	!HDR_IO_IN_PROGRESS(hdr)) {
	arc_hdr_free_abd(hdr, B_TRUE);
	}
	}
	}

	arc_buf_t *lastbuf = arc_buf_remove(hdr, buf);

	if (ARC_BUF_SHARED(buf) && !ARC_BUF_COMPRESSED(buf)) {
	/*
	* If the current arc_buf_t is sharing its data buffer with the
	* hdr, then reassign the hdr's b_pabd to share it with the new
	* buffer at the end of the list. The shared buffer is always
	* the last one on the hdr's buffer list.
	*
	* There is an equivalent case for compressed bufs, but since
	* they aren't guaranteed to be the last buf in the list and
	* that is an exceedingly rare case, we just allow that space be
	* wasted temporarily. We must also be careful not to share
	* encrypted buffers, since they cannot be shared.
	*/
	if (lastbuf != NULL && !ARC_BUF_ENCRYPTED(lastbuf)) {
	/* Only one buf can be shared at once */
	VERIFY(!arc_buf_is_shared(lastbuf));
	/* hdr is uncompressed so can't have compressed buf */
	VERIFY(!ARC_BUF_COMPRESSED(lastbuf));

	ASSERT3P(hdr->b_l1hdr.b_pabd, !=, NULL);
	arc_hdr_free_abd(hdr, B_FALSE);

	/*
	* We must setup a new shared block between the
	* last buffer and the hdr. The data would have
	* been allocated by the arc buf so we need to transfer
	* ownership to the hdr since it's now being shared.
	*/
	arc_share_buf(hdr, lastbuf);
	}
	} else if (HDR_SHARED_DATA(hdr)) {
	/*
	* Uncompressed shared buffers are always at the end
	* of the list. Compressed buffers don't have the
	* same requirements. This makes it hard to
	* simply assert that the lastbuf is shared so
	* we rely on the hdr's compression flags to determine
	* if we have a compressed, shared buffer.
	*/
	ASSERT3P(lastbuf, !=, NULL);
	ASSERT(arc_buf_is_shared(lastbuf) \|\|
	arc_hdr_get_compress(hdr) != ZIO_COMPRESS_OFF);
	}

	/*
	* Free the checksum if we're removing the last uncompressed buf from
	* this hdr.
	*/
	if (!arc_hdr_has_uncompressed_buf(hdr)) {
	arc_cksum_free(hdr);
	}

	/* clean up the buf */
	buf->b_hdr = NULL;
	kmem_cache_free(buf_cache, buf);
	}

	static void
	arc_hdr_alloc_abd(arc_buf_hdr_t *hdr, int alloc_flags)
	{
	uint64_t size;
	boolean_t alloc_rdata = ((alloc_flags & ARC_HDR_ALLOC_RDATA) != 0);
	boolean_t do_adapt = ((alloc_flags & ARC_HDR_DO_ADAPT) != 0);

	ASSERT3U(HDR_GET_LSIZE(hdr), >, 0);
	ASSERT(HDR_HAS_L1HDR(hdr));
	ASSERT(!HDR_SHARED_DATA(hdr) \|\| alloc_rdata);
	IMPLY(alloc_rdata, HDR_PROTECTED(hdr));

	if (alloc_rdata) {
	size = HDR_GET_PSIZE(hdr);
	ASSERT3P(hdr->b_crypt_hdr.b_rabd, ==, NULL);
	hdr->b_crypt_hdr.b_rabd = arc_get_data_abd(hdr, size, hdr,
	do_adapt);
	ASSERT3P(hdr->b_crypt_hdr.b_rabd, !=, NULL);
	ARCSTAT_INCR(arcstat_raw_size, size);
	} else {
	size = arc_hdr_size(hdr);
	ASSERT3P(hdr->b_l1hdr.b_pabd, ==, NULL);
	hdr->b_l1hdr.b_pabd = arc_get_data_abd(hdr, size, hdr,
	do_adapt);
	ASSERT3P(hdr->b_l1hdr.b_pabd, !=, NULL);
	}

	ARCSTAT_INCR(arcstat_compressed_size, size);
	ARCSTAT_INCR(arcstat_uncompressed_size, HDR_GET_LSIZE(hdr));
	}

	static void
	arc_hdr_free_abd(arc_buf_hdr_t *hdr, boolean_t free_rdata)
	{
	uint64_t size = (free_rdata) ? HDR_GET_PSIZE(hdr) : arc_hdr_size(hdr);

	ASSERT(HDR_HAS_L1HDR(hdr));
	ASSERT(hdr->b_l1hdr.b_pabd != NULL \|\| HDR_HAS_RABD(hdr));
	IMPLY(free_rdata, HDR_HAS_RABD(hdr));

	/*
	* If the hdr is currently being written to the l2arc then
	* we defer freeing the data by adding it to the l2arc_free_on_write
	* list. The l2arc will free the data once it's finished
	* writing it to the l2arc device.
	*/
	if (HDR_L2_WRITING(hdr)) {
	arc_hdr_free_on_write(hdr, free_rdata);
	ARCSTAT_BUMP(arcstat_l2_free_on_write);
	} else if (free_rdata) {
	arc_free_data_abd(hdr, hdr->b_crypt_hdr.b_rabd, size, hdr);
	} else {
	arc_free_data_abd(hdr, hdr->b_l1hdr.b_pabd, size, hdr);
	}

	if (free_rdata) {
	hdr->b_crypt_hdr.b_rabd = NULL;
	ARCSTAT_INCR(arcstat_raw_size, -size);
	} else {
	hdr->b_l1hdr.b_pabd = NULL;
	}

	if (hdr->b_l1hdr.b_pabd == NULL && !HDR_HAS_RABD(hdr))
	hdr->b_l1hdr.b_byteswap = DMU_BSWAP_NUMFUNCS;

	ARCSTAT_INCR(arcstat_compressed_size, -size);
	ARCSTAT_INCR(arcstat_uncompressed_size, -HDR_GET_LSIZE(hdr));
	}

	static arc_buf_hdr_t *
	arc_hdr_alloc(uint64_t spa, int32_t psize, int32_t lsize,
	boolean_t protected, enum zio_compress compression_type, uint8_t complevel,
	arc_buf_contents_t type, boolean_t alloc_rdata)
	{
	arc_buf_hdr_t *hdr;
	int flags = ARC_HDR_DO_ADAPT;

	VERIFY(type == ARC_BUFC_DATA \|\| type == ARC_BUFC_METADATA);
	if (protected) {
	hdr = kmem_cache_alloc(hdr_full_crypt_cache, KM_PUSHPAGE);
	} else {
	hdr = kmem_cache_alloc(hdr_full_cache, KM_PUSHPAGE);
	}
	flags \|= alloc_rdata ? ARC_HDR_ALLOC_RDATA : 0;

	ASSERT(HDR_EMPTY(hdr));
	ASSERT3P(hdr->b_l1hdr.b_freeze_cksum, ==, NULL);
	HDR_SET_PSIZE(hdr, psize);
	HDR_SET_LSIZE(hdr, lsize);
	hdr->b_spa = spa;
	hdr->b_type = type;
	hdr->b_flags = 0;
	arc_hdr_set_flags(hdr, arc_bufc_to_flags(type) \| ARC_FLAG_HAS_L1HDR);
	arc_hdr_set_compress(hdr, compression_type);
	hdr->b_complevel = complevel;
	if (protected)
	arc_hdr_set_flags(hdr, ARC_FLAG_PROTECTED);

	hdr->b_l1hdr.b_state = arc_anon;
	hdr->b_l1hdr.b_arc_access = 0;
	hdr->b_l1hdr.b_bufcnt = 0;
	hdr->b_l1hdr.b_buf = NULL;

	/*
	* Allocate the hdr's buffer. This will contain either
	* the compressed or uncompressed data depending on the block
	* it references and compressed arc enablement.
	*/
	arc_hdr_alloc_abd(hdr, flags);
	ASSERT(zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt));

	return (hdr);
	}

	/*
	* Transition between the two allocation states for the arc_buf_hdr struct.
	* The arc_buf_hdr struct can be allocated with (hdr_full_cache) or without
	* (hdr_l2only_cache) the fields necessary for the L1 cache - the smaller
	* version is used when a cache buffer is only in the L2ARC in order to reduce
	* memory usage.
	*/
	static arc_buf_hdr_t *
	arc_hdr_realloc(arc_buf_hdr_t hdr, kmem_cache_t old, kmem_cache_t *new)
	{
	ASSERT(HDR_HAS_L2HDR(hdr));

	arc_buf_hdr_t *nhdr;
	l2arc_dev_t *dev = hdr->b_l2hdr.b_dev;

	ASSERT((old == hdr_full_cache && new == hdr_l2only_cache) \|\|
	(old == hdr_l2only_cache && new == hdr_full_cache));

	/*
	* if the caller wanted a new full header and the header is to be
	* encrypted we will actually allocate the header from the full crypt
	* cache instead. The same applies to freeing from the old cache.
	*/
	if (HDR_PROTECTED(hdr) && new == hdr_full_cache)
	new = hdr_full_crypt_cache;
	if (HDR_PROTECTED(hdr) && old == hdr_full_cache)
	old = hdr_full_crypt_cache;

	nhdr = kmem_cache_alloc(new, KM_PUSHPAGE);

	ASSERT(MUTEX_HELD(HDR_LOCK(hdr)));
	buf_hash_remove(hdr);

	bcopy(hdr, nhdr, HDR_L2ONLY_SIZE);

	if (new == hdr_full_cache \|\| new == hdr_full_crypt_cache) {
	arc_hdr_set_flags(nhdr, ARC_FLAG_HAS_L1HDR);
	/*
	* arc_access and arc_change_state need to be aware that a
	* header has just come out of L2ARC, so we set its state to
	* l2c_only even though it's about to change.
	*/
	nhdr->b_l1hdr.b_state = arc_l2c_only;

	/* Verify previous threads set to NULL before freeing */
	ASSERT3P(nhdr->b_l1hdr.b_pabd, ==, NULL);
	ASSERT(!HDR_HAS_RABD(hdr));
	} else {
	ASSERT3P(hdr->b_l1hdr.b_buf, ==, NULL);
	ASSERT0(hdr->b_l1hdr.b_bufcnt);
	ASSERT3P(hdr->b_l1hdr.b_freeze_cksum, ==, NULL);

	/*
	* If we've reached here, We must have been called from
	* arc_evict_hdr(), as such we should have already been
	* removed from any ghost list we were previously on
	* (which protects us from racing with arc_evict_state),
	* thus no locking is needed during this check.
	*/
	ASSERT(!multilist_link_active(&hdr->b_l1hdr.b_arc_node));

	/*
	* A buffer must not be moved into the arc_l2c_only
	* state if it's not finished being written out to the
	* l2arc device. Otherwise, the b_l1hdr.b_pabd field
	* might try to be accessed, even though it was removed.
	*/
	VERIFY(!HDR_L2_WRITING(hdr));
	VERIFY3P(hdr->b_l1hdr.b_pabd, ==, NULL);
	ASSERT(!HDR_HAS_RABD(hdr));

	arc_hdr_clear_flags(nhdr, ARC_FLAG_HAS_L1HDR);
	}
	/*
	* The header has been reallocated so we need to re-insert it into any
	* lists it was on.
	*/
	(void) buf_hash_insert(nhdr, NULL);

	ASSERT(list_link_active(&hdr->b_l2hdr.b_l2node));

	mutex_enter(&dev->l2ad_mtx);

	/*
	* We must place the realloc'ed header back into the list at
	* the same spot. Otherwise, if it's placed earlier in the list,
	* l2arc_write_buffers() could find it during the function's
	* write phase, and try to write it out to the l2arc.
	*/
	list_insert_after(&dev->l2ad_buflist, hdr, nhdr);
	list_remove(&dev->l2ad_buflist, hdr);

	mutex_exit(&dev->l2ad_mtx);

	/*
	* Since we're using the pointer address as the tag when
	* incrementing and decrementing the l2ad_alloc refcount, we
	* must remove the old pointer (that we're about to destroy) and
	* add the new pointer to the refcount. Otherwise we'd remove
	* the wrong pointer address when calling arc_hdr_destroy() later.
	*/

	(void) zfs_refcount_remove_many(&dev->l2ad_alloc,
	arc_hdr_size(hdr), hdr);
	(void) zfs_refcount_add_many(&dev->l2ad_alloc,
	arc_hdr_size(nhdr), nhdr);

	buf_discard_identity(hdr);
	kmem_cache_free(old, hdr);

	return (nhdr);
	}

	/*
	* This function allows an L1 header to be reallocated as a crypt
	* header and vice versa. If we are going to a crypt header, the
	* new fields will be zeroed out.
	*/
	static arc_buf_hdr_t *
	arc_hdr_realloc_crypt(arc_buf_hdr_t *hdr, boolean_t need_crypt)
	{
	arc_buf_hdr_t *nhdr;
	arc_buf_t *buf;
	kmem_cache_t ncache, ocache;
	unsigned nsize, osize;

	/*
	* This function requires that hdr is in the arc_anon state.
	* Therefore it won't have any L2ARC data for us to worry
	* about copying.
	*/
	ASSERT(HDR_HAS_L1HDR(hdr));
	ASSERT(!HDR_HAS_L2HDR(hdr));
	ASSERT3U(!!HDR_PROTECTED(hdr), !=, need_crypt);
	ASSERT3P(hdr->b_l1hdr.b_state, ==, arc_anon);
	ASSERT(!multilist_link_active(&hdr->b_l1hdr.b_arc_node));
	ASSERT(!list_link_active(&hdr->b_l2hdr.b_l2node));
	ASSERT3P(hdr->b_hash_next, ==, NULL);

	if (need_crypt) {
	ncache = hdr_full_crypt_cache;
	nsize = sizeof (hdr->b_crypt_hdr);
	ocache = hdr_full_cache;
	osize = HDR_FULL_SIZE;
	} else {
	ncache = hdr_full_cache;
	nsize = HDR_FULL_SIZE;
	ocache = hdr_full_crypt_cache;
	osize = sizeof (hdr->b_crypt_hdr);
	}

	nhdr = kmem_cache_alloc(ncache, KM_PUSHPAGE);

	/*
	* Copy all members that aren't locks or condvars to the new header.
	* No lists are pointing to us (as we asserted above), so we don't
	* need to worry about the list nodes.
	*/
	nhdr->b_dva = hdr->b_dva;
	nhdr->b_birth = hdr->b_birth;
	nhdr->b_type = hdr->b_type;
	nhdr->b_flags = hdr->b_flags;
	nhdr->b_psize = hdr->b_psize;
	nhdr->b_lsize = hdr->b_lsize;
	nhdr->b_spa = hdr->b_spa;
	nhdr->b_l1hdr.b_freeze_cksum = hdr->b_l1hdr.b_freeze_cksum;
	nhdr->b_l1hdr.b_bufcnt = hdr->b_l1hdr.b_bufcnt;
	nhdr->b_l1hdr.b_byteswap = hdr->b_l1hdr.b_byteswap;
	nhdr->b_l1hdr.b_state = hdr->b_l1hdr.b_state;
	nhdr->b_l1hdr.b_arc_access = hdr->b_l1hdr.b_arc_access;
	nhdr->b_l1hdr.b_mru_hits = hdr->b_l1hdr.b_mru_hits;
	nhdr->b_l1hdr.b_mru_ghost_hits = hdr->b_l1hdr.b_mru_ghost_hits;
	nhdr->b_l1hdr.b_mfu_hits = hdr->b_l1hdr.b_mfu_hits;
	nhdr->b_l1hdr.b_mfu_ghost_hits = hdr->b_l1hdr.b_mfu_ghost_hits;
	nhdr->b_l1hdr.b_l2_hits = hdr->b_l1hdr.b_l2_hits;
	nhdr->b_l1hdr.b_acb = hdr->b_l1hdr.b_acb;
	nhdr->b_l1hdr.b_pabd = hdr->b_l1hdr.b_pabd;

	/*
	* This zfs_refcount_add() exists only to ensure that the individual
	* arc buffers always point to a header that is referenced, avoiding
	* a small race condition that could trigger ASSERTs.
	*/
	(void) zfs_refcount_add(&nhdr->b_l1hdr.b_refcnt, FTAG);
	nhdr->b_l1hdr.b_buf = hdr->b_l1hdr.b_buf;
	for (buf = nhdr->b_l1hdr.b_buf; buf != NULL; buf = buf->b_next) {
	mutex_enter(&buf->b_evict_lock);
	buf->b_hdr = nhdr;
	mutex_exit(&buf->b_evict_lock);
	}

	zfs_refcount_transfer(&nhdr->b_l1hdr.b_refcnt, &hdr->b_l1hdr.b_refcnt);
	(void) zfs_refcount_remove(&nhdr->b_l1hdr.b_refcnt, FTAG);
	ASSERT0(zfs_refcount_count(&hdr->b_l1hdr.b_refcnt));

	if (need_crypt) {
	arc_hdr_set_flags(nhdr, ARC_FLAG_PROTECTED);
	} else {
	arc_hdr_clear_flags(nhdr, ARC_FLAG_PROTECTED);
	}

	/* unset all members of the original hdr */
	bzero(&hdr->b_dva, sizeof (dva_t));
	hdr->b_birth = 0;
	hdr->b_type = ARC_BUFC_INVALID;
	hdr->b_flags = 0;
	hdr->b_psize = 0;
	hdr->b_lsize = 0;
	hdr->b_spa = 0;
	hdr->b_l1hdr.b_freeze_cksum = NULL;
	hdr->b_l1hdr.b_buf = NULL;
	hdr->b_l1hdr.b_bufcnt = 0;
	hdr->b_l1hdr.b_byteswap = 0;
	hdr->b_l1hdr.b_state = NULL;
	hdr->b_l1hdr.b_arc_access = 0;
	hdr->b_l1hdr.b_mru_hits = 0;
	hdr->b_l1hdr.b_mru_ghost_hits = 0;
	hdr->b_l1hdr.b_mfu_hits = 0;
	hdr->b_l1hdr.b_mfu_ghost_hits = 0;
	hdr->b_l1hdr.b_l2_hits = 0;
	hdr->b_l1hdr.b_acb = NULL;
	hdr->b_l1hdr.b_pabd = NULL;

	if (ocache == hdr_full_crypt_cache) {
	ASSERT(!HDR_HAS_RABD(hdr));
	hdr->b_crypt_hdr.b_ot = DMU_OT_NONE;
	hdr->b_crypt_hdr.b_ebufcnt = 0;
	hdr->b_crypt_hdr.b_dsobj = 0;
	bzero(hdr->b_crypt_hdr.b_salt, ZIO_DATA_SALT_LEN);
	bzero(hdr->b_crypt_hdr.b_iv, ZIO_DATA_IV_LEN);
	bzero(hdr->b_crypt_hdr.b_mac, ZIO_DATA_MAC_LEN);
	}

	buf_discard_identity(hdr);
	kmem_cache_free(ocache, hdr);

	return (nhdr);
	}

	/*
	* This function is used by the send / receive code to convert a newly
	* allocated arc_buf_t to one that is suitable for a raw encrypted write. It
	* is also used to allow the root objset block to be updated without altering
	* its embedded MACs. Both block types will always be uncompressed so we do not
	* have to worry about compression type or psize.
	*/
	void
	arc_convert_to_raw(arc_buf_t *buf, uint64_t dsobj, boolean_t byteorder,
	dmu_object_type_t ot, const uint8_t salt, const uint8_t iv,
	const uint8_t *mac)
	{
	arc_buf_hdr_t *hdr = buf->b_hdr;

	ASSERT(ot == DMU_OT_DNODE \|\| ot == DMU_OT_OBJSET);
	ASSERT(HDR_HAS_L1HDR(hdr));
	ASSERT3P(hdr->b_l1hdr.b_state, ==, arc_anon);

	buf->b_flags \|= (ARC_BUF_FLAG_COMPRESSED \| ARC_BUF_FLAG_ENCRYPTED);
	if (!HDR_PROTECTED(hdr))
	hdr = arc_hdr_realloc_crypt(hdr, B_TRUE);
	hdr->b_crypt_hdr.b_dsobj = dsobj;
	hdr->b_crypt_hdr.b_ot = ot;
	hdr->b_l1hdr.b_byteswap = (byteorder == ZFS_HOST_BYTEORDER) ?
	DMU_BSWAP_NUMFUNCS : DMU_OT_BYTESWAP(ot);
	if (!arc_hdr_has_uncompressed_buf(hdr))
	arc_cksum_free(hdr);

	if (salt != NULL)
	bcopy(salt, hdr->b_crypt_hdr.b_salt, ZIO_DATA_SALT_LEN);
	if (iv != NULL)
	bcopy(iv, hdr->b_crypt_hdr.b_iv, ZIO_DATA_IV_LEN);
	if (mac != NULL)
	bcopy(mac, hdr->b_crypt_hdr.b_mac, ZIO_DATA_MAC_LEN);
	}

	/*
	* Allocate a new arc_buf_hdr_t and arc_buf_t and return the buf to the caller.
	* The buf is returned thawed since we expect the consumer to modify it.
	*/
	arc_buf_t *
	arc_alloc_buf(spa_t spa, void tag, arc_buf_contents_t type, int32_t size)
	{
	arc_buf_hdr_t *hdr = arc_hdr_alloc(spa_load_guid(spa), size, size,
	B_FALSE, ZIO_COMPRESS_OFF, 0, type, B_FALSE);

	arc_buf_t *buf = NULL;
	VERIFY0(arc_buf_alloc_impl(hdr, spa, NULL, tag, B_FALSE, B_FALSE,
	B_FALSE, B_FALSE, &buf));
	arc_buf_thaw(buf);

	return (buf);
	}

	/*
	* Allocate a compressed buf in the same manner as arc_alloc_buf. Don't use this
	* for bufs containing metadata.
	*/
	arc_buf_t *
	arc_alloc_compressed_buf(spa_t spa, void tag, uint64_t psize, uint64_t lsize,
	enum zio_compress compression_type, uint8_t complevel)
	{
	ASSERT3U(lsize, >, 0);
	ASSERT3U(lsize, >=, psize);
	ASSERT3U(compression_type, >, ZIO_COMPRESS_OFF);
	ASSERT3U(compression_type, <, ZIO_COMPRESS_FUNCTIONS);

	arc_buf_hdr_t *hdr = arc_hdr_alloc(spa_load_guid(spa), psize, lsize,
	B_FALSE, compression_type, complevel, ARC_BUFC_DATA, B_FALSE);

	arc_buf_t *buf = NULL;
	VERIFY0(arc_buf_alloc_impl(hdr, spa, NULL, tag, B_FALSE,
	B_TRUE, B_FALSE, B_FALSE, &buf));
	arc_buf_thaw(buf);
	ASSERT3P(hdr->b_l1hdr.b_freeze_cksum, ==, NULL);

	if (!arc_buf_is_shared(buf)) {
	/*
	* To ensure that the hdr has the correct data in it if we call
	* arc_untransform() on this buf before it's been written to
	* disk, it's easiest if we just set up sharing between the
	* buf and the hdr.
	*/
	arc_hdr_free_abd(hdr, B_FALSE);
	arc_share_buf(hdr, buf);
	}

	return (buf);
	}

	arc_buf_t *
	arc_alloc_raw_buf(spa_t spa, void tag, uint64_t dsobj, boolean_t byteorder,
	const uint8_t salt, const uint8_t iv, const uint8_t *mac,
	dmu_object_type_t ot, uint64_t psize, uint64_t lsize,
	enum zio_compress compression_type, uint8_t complevel)
	{
	arc_buf_hdr_t *hdr;
	arc_buf_t *buf;
	arc_buf_contents_t type = DMU_OT_IS_METADATA(ot) ?
	ARC_BUFC_METADATA : ARC_BUFC_DATA;

	ASSERT3U(lsize, >, 0);
	ASSERT3U(lsize, >=, psize);
	ASSERT3U(compression_type, >=, ZIO_COMPRESS_OFF);
	ASSERT3U(compression_type, <, ZIO_COMPRESS_FUNCTIONS);

	hdr = arc_hdr_alloc(spa_load_guid(spa), psize, lsize, B_TRUE,
	compression_type, complevel, type, B_TRUE);

	hdr->b_crypt_hdr.b_dsobj = dsobj;
	hdr->b_crypt_hdr.b_ot = ot;
	hdr->b_l1hdr.b_byteswap = (byteorder == ZFS_HOST_BYTEORDER) ?
	DMU_BSWAP_NUMFUNCS : DMU_OT_BYTESWAP(ot);
	bcopy(salt, hdr->b_crypt_hdr.b_salt, ZIO_DATA_SALT_LEN);
	bcopy(iv, hdr->b_crypt_hdr.b_iv, ZIO_DATA_IV_LEN);
	bcopy(mac, hdr->b_crypt_hdr.b_mac, ZIO_DATA_MAC_LEN);

	/*
	* This buffer will be considered encrypted even if the ot is not an
	* encrypted type. It will become authenticated instead in
	* arc_write_ready().
	*/
	buf = NULL;
	VERIFY0(arc_buf_alloc_impl(hdr, spa, NULL, tag, B_TRUE, B_TRUE,
	B_FALSE, B_FALSE, &buf));
	arc_buf_thaw(buf);
	ASSERT3P(hdr->b_l1hdr.b_freeze_cksum, ==, NULL);

	return (buf);
	}

	static void
	l2arc_hdr_arcstats_update(arc_buf_hdr_t *hdr, boolean_t incr,
	boolean_t state_only)
	{
	l2arc_buf_hdr_t *l2hdr = &hdr->b_l2hdr;
	l2arc_dev_t *dev = l2hdr->b_dev;
	uint64_t lsize = HDR_GET_LSIZE(hdr);
	uint64_t psize = HDR_GET_PSIZE(hdr);
	uint64_t asize = vdev_psize_to_asize(dev->l2ad_vdev, psize);
	arc_buf_contents_t type = hdr->b_type;
	int64_t lsize_s;
	int64_t psize_s;
	int64_t asize_s;

	if (incr) {
	lsize_s = lsize;
	psize_s = psize;
	asize_s = asize;
	} else {
	lsize_s = -lsize;
	psize_s = -psize;
	asize_s = -asize;
	}

	/* If the buffer is a prefetch, count it as such. */
	if (HDR_PREFETCH(hdr)) {
	ARCSTAT_INCR(arcstat_l2_prefetch_asize, asize_s);
	} else {
	/*
	* We use the value stored in the L2 header upon initial
	* caching in L2ARC. This value will be updated in case
	* an MRU/MRU_ghost buffer transitions to MFU but the L2ARC
	* metadata (log entry) cannot currently be updated. Having
	* the ARC state in the L2 header solves the problem of a
	* possibly absent L1 header (apparent in buffers restored
	* from persistent L2ARC).
	*/
	switch (hdr->b_l2hdr.b_arcs_state) {
	case ARC_STATE_MRU_GHOST:
	case ARC_STATE_MRU:
	ARCSTAT_INCR(arcstat_l2_mru_asize, asize_s);
	break;
	case ARC_STATE_MFU_GHOST:
	case ARC_STATE_MFU:
	ARCSTAT_INCR(arcstat_l2_mfu_asize, asize_s);
	break;
	default:
	break;
	}
	}

	if (state_only)
	return;

	ARCSTAT_INCR(arcstat_l2_psize, psize_s);
	ARCSTAT_INCR(arcstat_l2_lsize, lsize_s);

	switch (type) {
	case ARC_BUFC_DATA:
	ARCSTAT_INCR(arcstat_l2_bufc_data_asize, asize_s);
	break;
	case ARC_BUFC_METADATA:
	ARCSTAT_INCR(arcstat_l2_bufc_metadata_asize, asize_s);
	break;
	default:
	break;
	}
	}


	static void
	arc_hdr_l2hdr_destroy(arc_buf_hdr_t *hdr)
	{
	l2arc_buf_hdr_t *l2hdr = &hdr->b_l2hdr;
	l2arc_dev_t *dev = l2hdr->b_dev;
	uint64_t psize = HDR_GET_PSIZE(hdr);
	uint64_t asize = vdev_psize_to_asize(dev->l2ad_vdev, psize);

	ASSERT(MUTEX_HELD(&dev->l2ad_mtx));
	ASSERT(HDR_HAS_L2HDR(hdr));

	list_remove(&dev->l2ad_buflist, hdr);

	l2arc_hdr_arcstats_decrement(hdr);
	vdev_space_update(dev->l2ad_vdev, -asize, 0, 0);

	(void) zfs_refcount_remove_many(&dev->l2ad_alloc, arc_hdr_size(hdr),
	hdr);
	arc_hdr_clear_flags(hdr, ARC_FLAG_HAS_L2HDR);
	}

	static void
	arc_hdr_destroy(arc_buf_hdr_t *hdr)
	{
	if (HDR_HAS_L1HDR(hdr)) {
	ASSERT(hdr->b_l1hdr.b_buf == NULL \|\|
	hdr->b_l1hdr.b_bufcnt > 0);
	ASSERT(zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt));
	ASSERT3P(hdr->b_l1hdr.b_state, ==, arc_anon);
	}
	ASSERT(!HDR_IO_IN_PROGRESS(hdr));
	ASSERT(!HDR_IN_HASH_TABLE(hdr));

	if (HDR_HAS_L2HDR(hdr)) {
	l2arc_dev_t *dev = hdr->b_l2hdr.b_dev;
	boolean_t buflist_held = MUTEX_HELD(&dev->l2ad_mtx);

	if (!buflist_held)
	mutex_enter(&dev->l2ad_mtx);

	/*
	* Even though we checked this conditional above, we
	* need to check this again now that we have the
	* l2ad_mtx. This is because we could be racing with
	* another thread calling l2arc_evict() which might have
	* destroyed this header's L2 portion as we were waiting
	* to acquire the l2ad_mtx. If that happens, we don't
	* want to re-destroy the header's L2 portion.
	*/
	if (HDR_HAS_L2HDR(hdr))
	arc_hdr_l2hdr_destroy(hdr);

	if (!buflist_held)
	mutex_exit(&dev->l2ad_mtx);
	}

	/*
	* The header's identify can only be safely discarded once it is no
	* longer discoverable. This requires removing it from the hash table
	* and the l2arc header list. After this point the hash lock can not
	* be used to protect the header.
	*/
	if (!HDR_EMPTY(hdr))
	buf_discard_identity(hdr);

	if (HDR_HAS_L1HDR(hdr)) {
	arc_cksum_free(hdr);

	while (hdr->b_l1hdr.b_buf != NULL)
	arc_buf_destroy_impl(hdr->b_l1hdr.b_buf);

	if (hdr->b_l1hdr.b_pabd != NULL)
	arc_hdr_free_abd(hdr, B_FALSE);

	if (HDR_HAS_RABD(hdr))
	arc_hdr_free_abd(hdr, B_TRUE);
	}

	ASSERT3P(hdr->b_hash_next, ==, NULL);
	if (HDR_HAS_L1HDR(hdr)) {
	ASSERT(!multilist_link_active(&hdr->b_l1hdr.b_arc_node));
	ASSERT3P(hdr->b_l1hdr.b_acb, ==, NULL);

	if (!HDR_PROTECTED(hdr)) {
	kmem_cache_free(hdr_full_cache, hdr);
	} else {
	kmem_cache_free(hdr_full_crypt_cache, hdr);
	}
	} else {
	kmem_cache_free(hdr_l2only_cache, hdr);
	}
	}

	void
	arc_buf_destroy(arc_buf_t buf, void tag)
	{
	arc_buf_hdr_t *hdr = buf->b_hdr;

	if (hdr->b_l1hdr.b_state == arc_anon) {
	ASSERT3U(hdr->b_l1hdr.b_bufcnt, ==, 1);
	ASSERT(!HDR_IO_IN_PROGRESS(hdr));
	VERIFY0(remove_reference(hdr, NULL, tag));
	arc_hdr_destroy(hdr);
	return;
	}

	kmutex_t *hash_lock = HDR_LOCK(hdr);
	mutex_enter(hash_lock);

	ASSERT3P(hdr, ==, buf->b_hdr);
	ASSERT(hdr->b_l1hdr.b_bufcnt > 0);
	ASSERT3P(hash_lock, ==, HDR_LOCK(hdr));
	ASSERT3P(hdr->b_l1hdr.b_state, !=, arc_anon);
	ASSERT3P(buf->b_data, !=, NULL);

	(void) remove_reference(hdr, hash_lock, tag);
	arc_buf_destroy_impl(buf);
	mutex_exit(hash_lock);
	}

	/*
	* Evict the arc_buf_hdr that is provided as a parameter. The resultant
	* state of the header is dependent on its state prior to entering this
	* function. The following transitions are possible:
	*
	* - arc_mru -> arc_mru_ghost
	* - arc_mfu -> arc_mfu_ghost
	* - arc_mru_ghost -> arc_l2c_only
	* - arc_mru_ghost -> deleted
	* - arc_mfu_ghost -> arc_l2c_only
	* - arc_mfu_ghost -> deleted
	*/
	static int64_t
	arc_evict_hdr(arc_buf_hdr_t hdr, kmutex_t hash_lock)
	{
	arc_state_t evicted_state, state;
	int64_t bytes_evicted = 0;
	int min_lifetime = HDR_PRESCIENT_PREFETCH(hdr) ?
	arc_min_prescient_prefetch_ms : arc_min_prefetch_ms;

	ASSERT(MUTEX_HELD(hash_lock));
	ASSERT(HDR_HAS_L1HDR(hdr));

	state = hdr->b_l1hdr.b_state;
	if (GHOST_STATE(state)) {
	ASSERT(!HDR_IO_IN_PROGRESS(hdr));
	ASSERT3P(hdr->b_l1hdr.b_buf, ==, NULL);

	/*
	* l2arc_write_buffers() relies on a header's L1 portion
	* (i.e. its b_pabd field) during it's write phase.
	* Thus, we cannot push a header onto the arc_l2c_only
	* state (removing its L1 piece) until the header is
	* done being written to the l2arc.
	*/
	if (HDR_HAS_L2HDR(hdr) && HDR_L2_WRITING(hdr)) {
	ARCSTAT_BUMP(arcstat_evict_l2_skip);
	return (bytes_evicted);
	}

	ARCSTAT_BUMP(arcstat_deleted);
	bytes_evicted += HDR_GET_LSIZE(hdr);

	DTRACE_PROBE1(arc__delete, arc_buf_hdr_t *, hdr);

	if (HDR_HAS_L2HDR(hdr)) {
	ASSERT(hdr->b_l1hdr.b_pabd == NULL);
	ASSERT(!HDR_HAS_RABD(hdr));
	/*
	* This buffer is cached on the 2nd Level ARC;
	* don't destroy the header.
	*/
	arc_change_state(arc_l2c_only, hdr, hash_lock);
	/*
	* dropping from L1+L2 cached to L2-only,
	* realloc to remove the L1 header.
	*/
	hdr = arc_hdr_realloc(hdr, hdr_full_cache,
	hdr_l2only_cache);
	} else {
	arc_change_state(arc_anon, hdr, hash_lock);
	arc_hdr_destroy(hdr);
	}
	return (bytes_evicted);
	}

	ASSERT(state == arc_mru \|\| state == arc_mfu);
	evicted_state = (state == arc_mru) ? arc_mru_ghost : arc_mfu_ghost;

	/* prefetch buffers have a minimum lifespan */
	if (HDR_IO_IN_PROGRESS(hdr) \|\|
	((hdr->b_flags & (ARC_FLAG_PREFETCH \| ARC_FLAG_INDIRECT)) &&
	ddi_get_lbolt() - hdr->b_l1hdr.b_arc_access <
	MSEC_TO_TICK(min_lifetime))) {
	ARCSTAT_BUMP(arcstat_evict_skip);
	return (bytes_evicted);
	}

	ASSERT0(zfs_refcount_count(&hdr->b_l1hdr.b_refcnt));
	while (hdr->b_l1hdr.b_buf) {
	arc_buf_t *buf = hdr->b_l1hdr.b_buf;
	if (!mutex_tryenter(&buf->b_evict_lock)) {
	ARCSTAT_BUMP(arcstat_mutex_miss);
	break;
	}
	if (buf->b_data != NULL)
	bytes_evicted += HDR_GET_LSIZE(hdr);
	mutex_exit(&buf->b_evict_lock);
	arc_buf_destroy_impl(buf);
	}

	if (HDR_HAS_L2HDR(hdr)) {
	ARCSTAT_INCR(arcstat_evict_l2_cached, HDR_GET_LSIZE(hdr));
	} else {
	if (l2arc_write_eligible(hdr->b_spa, hdr)) {
	ARCSTAT_INCR(arcstat_evict_l2_eligible,
	HDR_GET_LSIZE(hdr));

	switch (state->arcs_state) {
	case ARC_STATE_MRU:
	ARCSTAT_INCR(
	arcstat_evict_l2_eligible_mru,
	HDR_GET_LSIZE(hdr));
	break;
	case ARC_STATE_MFU:
	ARCSTAT_INCR(
	arcstat_evict_l2_eligible_mfu,
	HDR_GET_LSIZE(hdr));
	break;
	default:
	break;
	}
	} else {
	ARCSTAT_INCR(arcstat_evict_l2_ineligible,
	HDR_GET_LSIZE(hdr));
	}
	}

	if (hdr->b_l1hdr.b_bufcnt == 0) {
	arc_cksum_free(hdr);

	bytes_evicted += arc_hdr_size(hdr);

	/*
	* If this hdr is being evicted and has a compressed
	* buffer then we discard it here before we change states.
	* This ensures that the accounting is updated correctly
	* in arc_free_data_impl().
	*/
	if (hdr->b_l1hdr.b_pabd != NULL)
	arc_hdr_free_abd(hdr, B_FALSE);

	if (HDR_HAS_RABD(hdr))
	arc_hdr_free_abd(hdr, B_TRUE);

	arc_change_state(evicted_state, hdr, hash_lock);
	ASSERT(HDR_IN_HASH_TABLE(hdr));
	arc_hdr_set_flags(hdr, ARC_FLAG_IN_HASH_TABLE);
	DTRACE_PROBE1(arc__evict, arc_buf_hdr_t *, hdr);
	}

	return (bytes_evicted);
	}

	static void
	arc_set_need_free(void)
	{
	ASSERT(MUTEX_HELD(&arc_evict_lock));
	int64_t remaining = arc_free_memory() - arc_sys_free / 2;
	arc_evict_waiter_t *aw = list_tail(&arc_evict_waiters);
	if (aw == NULL) {
	arc_need_free = MAX(-remaining, 0);
	} else {
	arc_need_free =
	MAX(-remaining, (int64_t)(aw->aew_count - arc_evict_count));
	}
	}

	static uint64_t
	arc_evict_state_impl(multilist_t ml, int idx, arc_buf_hdr_t marker,
	uint64_t spa, int64_t bytes)
	{
	multilist_sublist_t *mls;
	uint64_t bytes_evicted = 0;
	arc_buf_hdr_t *hdr;
	kmutex_t *hash_lock;
	int evict_count = 0;

	ASSERT3P(marker, !=, NULL);
	IMPLY(bytes < 0, bytes == ARC_EVICT_ALL);

	mls = multilist_sublist_lock(ml, idx);

	for (hdr = multilist_sublist_prev(mls, marker); hdr != NULL;
	hdr = multilist_sublist_prev(mls, marker)) {
	if ((bytes != ARC_EVICT_ALL && bytes_evicted >= bytes) \|\|
	(evict_count >= zfs_arc_evict_batch_limit))
	break;

	/*
	* To keep our iteration location, move the marker
	* forward. Since we're not holding hdr's hash lock, we
	* must be very careful and not remove 'hdr' from the
	* sublist. Otherwise, other consumers might mistake the
	* 'hdr' as not being on a sublist when they call the
	* multilist_link_active() function (they all rely on
	* the hash lock protecting concurrent insertions and
	* removals). multilist_sublist_move_forward() was
	* specifically implemented to ensure this is the case
	* (only 'marker' will be removed and re-inserted).
	*/
	multilist_sublist_move_forward(mls, marker);

	/*
	* The only case where the b_spa field should ever be
	* zero, is the marker headers inserted by
	* arc_evict_state(). It's possible for multiple threads
	* to be calling arc_evict_state() concurrently (e.g.
	* dsl_pool_close() and zio_inject_fault()), so we must
	* skip any markers we see from these other threads.
	*/
	if (hdr->b_spa == 0)
	continue;

	/* we're only interested in evicting buffers of a certain spa */
	if (spa != 0 && hdr->b_spa != spa) {
	ARCSTAT_BUMP(arcstat_evict_skip);
	continue;
	}

	hash_lock = HDR_LOCK(hdr);

	/*
	* We aren't calling this function from any code path
	* that would already be holding a hash lock, so we're
	* asserting on this assumption to be defensive in case
	* this ever changes. Without this check, it would be
	* possible to incorrectly increment arcstat_mutex_miss
	* below (e.g. if the code changed such that we called
	* this function with a hash lock held).
	*/
	ASSERT(!MUTEX_HELD(hash_lock));

	if (mutex_tryenter(hash_lock)) {
	uint64_t evicted = arc_evict_hdr(hdr, hash_lock);
	mutex_exit(hash_lock);

	bytes_evicted += evicted;

	/*
	* If evicted is zero, arc_evict_hdr() must have
	* decided to skip this header, don't increment
	* evict_count in this case.
	*/
	if (evicted != 0)
	evict_count++;

	} else {
	ARCSTAT_BUMP(arcstat_mutex_miss);
	}
	}

	multilist_sublist_unlock(mls);

	/*
	* Increment the count of evicted bytes, and wake up any threads that
	* are waiting for the count to reach this value. Since the list is
	* ordered by ascending aew_count, we pop off the beginning of the
	* list until we reach the end, or a waiter that's past the current
	* "count". Doing this outside the loop reduces the number of times
	* we need to acquire the global arc_evict_lock.
	*
	* Only wake when there's sufficient free memory in the system
	* (specifically, arc_sys_free/2, which by default is a bit more than
	* 1/64th of RAM). See the comments in arc_wait_for_eviction().
	*/
	mutex_enter(&arc_evict_lock);
	arc_evict_count += bytes_evicted;

	if (arc_free_memory() > arc_sys_free / 2) {
	arc_evict_waiter_t *aw;
	while ((aw = list_head(&arc_evict_waiters)) != NULL &&
	aw->aew_count <= arc_evict_count) {
	list_remove(&arc_evict_waiters, aw);
	cv_broadcast(&aw->aew_cv);
	}
	}
	arc_set_need_free();
	mutex_exit(&arc_evict_lock);

	/*
	* If the ARC size is reduced from arc_c_max to arc_c_min (especially
	* if the average cached block is small), eviction can be on-CPU for
	* many seconds. To ensure that other threads that may be bound to
	* this CPU are able to make progress, make a voluntary preemption
	* call here.
	*/
	cond_resched();

	return (bytes_evicted);
	}

	/*
	* Evict buffers from the given arc state, until we've removed the
	* specified number of bytes. Move the removed buffers to the
	* appropriate evict state.
	*
	* This function makes a "best effort". It skips over any buffers
	* it can't get a hash_lock on, and so, may not catch all candidates.
	* It may also return without evicting as much space as requested.
	*
	* If bytes is specified using the special value ARC_EVICT_ALL, this
	* will evict all available (i.e. unlocked and evictable) buffers from
	* the given arc state; which is used by arc_flush().
	*/
	static uint64_t
	arc_evict_state(arc_state_t *state, uint64_t spa, int64_t bytes,
	arc_buf_contents_t type)
	{
	uint64_t total_evicted = 0;
	multilist_t *ml = state->arcs_list[type];
	int num_sublists;
	arc_buf_hdr_t **markers;

	IMPLY(bytes < 0, bytes == ARC_EVICT_ALL);

	num_sublists = multilist_get_num_sublists(ml);

	/*
	* If we've tried to evict from each sublist, made some
	* progress, but still have not hit the target number of bytes
	* to evict, we want to keep trying. The markers allow us to
	* pick up where we left off for each individual sublist, rather
	* than starting from the tail each time.
	*/
	markers = kmem_zalloc(sizeof (markers) num_sublists, KM_SLEEP);
	for (int i = 0; i < num_sublists; i++) {
	multilist_sublist_t *mls;

	markers[i] = kmem_cache_alloc(hdr_full_cache, KM_SLEEP);

	/*
	* A b_spa of 0 is used to indicate that this header is
	* a marker. This fact is used in arc_evict_type() and
	* arc_evict_state_impl().
	*/
	markers[i]->b_spa = 0;

	mls = multilist_sublist_lock(ml, i);
	multilist_sublist_insert_tail(mls, markers[i]);
	multilist_sublist_unlock(mls);
	}

	/*
	* While we haven't hit our target number of bytes to evict, or
	* we're evicting all available buffers.
	*/
	while (total_evicted < bytes \|\| bytes == ARC_EVICT_ALL) {
	int sublist_idx = multilist_get_random_index(ml);
	uint64_t scan_evicted = 0;

	/*
	* Try to reduce pinned dnodes with a floor of arc_dnode_limit.
	* Request that 10% of the LRUs be scanned by the superblock
	* shrinker.
	*/
	if (type == ARC_BUFC_DATA && aggsum_compare(&astat_dnode_size,
	arc_dnode_size_limit) > 0) {
	arc_prune_async((aggsum_upper_bound(&astat_dnode_size) -
	arc_dnode_size_limit) / sizeof (dnode_t) /
	zfs_arc_dnode_reduce_percent);
	}

	/*
	* Start eviction using a randomly selected sublist,
	* this is to try and evenly balance eviction across all
	* sublists. Always starting at the same sublist
	* (e.g. index 0) would cause evictions to favor certain
	* sublists over others.
	*/
	for (int i = 0; i < num_sublists; i++) {
	uint64_t bytes_remaining;
	uint64_t bytes_evicted;

	if (bytes == ARC_EVICT_ALL)
	bytes_remaining = ARC_EVICT_ALL;
	else if (total_evicted < bytes)
	bytes_remaining = bytes - total_evicted;
	else
	break;

	bytes_evicted = arc_evict_state_impl(ml, sublist_idx,
	markers[sublist_idx], spa, bytes_remaining);

	scan_evicted += bytes_evicted;
	total_evicted += bytes_evicted;

	/* we've reached the end, wrap to the beginning */
	if (++sublist_idx >= num_sublists)
	sublist_idx = 0;
	}

	/*
	* If we didn't evict anything during this scan, we have
	* no reason to believe we'll evict more during another
	* scan, so break the loop.
	*/
	if (scan_evicted == 0) {
	/* This isn't possible, let's make that obvious */
	ASSERT3S(bytes, !=, 0);

	/*
	* When bytes is ARC_EVICT_ALL, the only way to
	* break the loop is when scan_evicted is zero.
	* In that case, we actually have evicted enough,
	* so we don't want to increment the kstat.
	*/
	if (bytes != ARC_EVICT_ALL) {
	ASSERT3S(total_evicted, <, bytes);
	ARCSTAT_BUMP(arcstat_evict_not_enough);
	}

	break;
	}
	}

	for (int i = 0; i < num_sublists; i++) {
	multilist_sublist_t *mls = multilist_sublist_lock(ml, i);
	multilist_sublist_remove(mls, markers[i]);
	multilist_sublist_unlock(mls);

	kmem_cache_free(hdr_full_cache, markers[i]);
	}
	kmem_free(markers, sizeof (markers) num_sublists);

	return (total_evicted);
	}

	/*
	* Flush all "evictable" data of the given type from the arc state
	* specified. This will not evict any "active" buffers (i.e. referenced).
	*
	* When 'retry' is set to B_FALSE, the function will make a single pass
	* over the state and evict any buffers that it can. Since it doesn't
	* continually retry the eviction, it might end up leaving some buffers
	* in the ARC due to lock misses.
	*
	* When 'retry' is set to B_TRUE, the function will continually retry the
	* eviction until all evictable buffers have been removed from the
	* state. As a result, if concurrent insertions into the state are
	* allowed (e.g. if the ARC isn't shutting down), this function might
	* wind up in an infinite loop, continually trying to evict buffers.
	*/
	static uint64_t
	arc_flush_state(arc_state_t *state, uint64_t spa, arc_buf_contents_t type,
	boolean_t retry)
	{
	uint64_t evicted = 0;

	while (zfs_refcount_count(&state->arcs_esize[type]) != 0) {
	evicted += arc_evict_state(state, spa, ARC_EVICT_ALL, type);

	if (!retry)
	break;
	}

	return (evicted);
	}

	/*
	* Evict the specified number of bytes from the state specified,
	* restricting eviction to the spa and type given. This function
	* prevents us from trying to evict more from a state's list than
	* is "evictable", and to skip evicting altogether when passed a
	* negative value for "bytes". In contrast, arc_evict_state() will
	* evict everything it can, when passed a negative value for "bytes".
	*/
	static uint64_t
	arc_evict_impl(arc_state_t *state, uint64_t spa, int64_t bytes,
	arc_buf_contents_t type)
	{
	int64_t delta;

	if (bytes > 0 && zfs_refcount_count(&state->arcs_esize[type]) > 0) {
	delta = MIN(zfs_refcount_count(&state->arcs_esize[type]),
	bytes);
	return (arc_evict_state(state, spa, delta, type));
	}

	return (0);
	}

	/*
	* The goal of this function is to evict enough meta data buffers from the
	* ARC in order to enforce the arc_meta_limit. Achieving this is slightly
	* more complicated than it appears because it is common for data buffers
	* to have holds on meta data buffers. In addition, dnode meta data buffers
	* will be held by the dnodes in the block preventing them from being freed.
	* This means we can't simply traverse the ARC and expect to always find
	* enough unheld meta data buffer to release.
	*
	* Therefore, this function has been updated to make alternating passes
	* over the ARC releasing data buffers and then newly unheld meta data
	* buffers. This ensures forward progress is maintained and meta_used
	* will decrease. Normally this is sufficient, but if required the ARC
	* will call the registered prune callbacks causing dentry and inodes to
	* be dropped from the VFS cache. This will make dnode meta data buffers
	* available for reclaim.
	*/
	static uint64_t
	arc_evict_meta_balanced(uint64_t meta_used)
	{
	int64_t delta, prune = 0, adjustmnt;
	uint64_t total_evicted = 0;
	arc_buf_contents_t type = ARC_BUFC_DATA;
	int restarts = MAX(zfs_arc_meta_adjust_restarts, 0);

	restart:
	/*
	* This slightly differs than the way we evict from the mru in
	* arc_evict because we don't have a "target" value (i.e. no
	* "meta" arc_p). As a result, I think we can completely
	* cannibalize the metadata in the MRU before we evict the
	* metadata from the MFU. I think we probably need to implement a
	* "metadata arc_p" value to do this properly.
	*/
	adjustmnt = meta_used - arc_meta_limit;

	if (adjustmnt > 0 &&
	zfs_refcount_count(&arc_mru->arcs_esize[type]) > 0) {
	delta = MIN(zfs_refcount_count(&arc_mru->arcs_esize[type]),
	adjustmnt);
	total_evicted += arc_evict_impl(arc_mru, 0, delta, type);
	adjustmnt -= delta;
	}

	/*
	* We can't afford to recalculate adjustmnt here. If we do,
	* new metadata buffers can sneak into the MRU or ANON lists,
	* thus penalize the MFU metadata. Although the fudge factor is
	* small, it has been empirically shown to be significant for
	* certain workloads (e.g. creating many empty directories). As
	* such, we use the original calculation for adjustmnt, and
	* simply decrement the amount of data evicted from the MRU.
	*/

	if (adjustmnt > 0 &&
	zfs_refcount_count(&arc_mfu->arcs_esize[type]) > 0) {
	delta = MIN(zfs_refcount_count(&arc_mfu->arcs_esize[type]),
	adjustmnt);
	total_evicted += arc_evict_impl(arc_mfu, 0, delta, type);
	}

	adjustmnt = meta_used - arc_meta_limit;

	if (adjustmnt > 0 &&
	zfs_refcount_count(&arc_mru_ghost->arcs_esize[type]) > 0) {
	delta = MIN(adjustmnt,
	zfs_refcount_count(&arc_mru_ghost->arcs_esize[type]));
	total_evicted += arc_evict_impl(arc_mru_ghost, 0, delta, type);
	adjustmnt -= delta;
	}

	if (adjustmnt > 0 &&
	zfs_refcount_count(&arc_mfu_ghost->arcs_esize[type]) > 0) {
	delta = MIN(adjustmnt,
	zfs_refcount_count(&arc_mfu_ghost->arcs_esize[type]));
	total_evicted += arc_evict_impl(arc_mfu_ghost, 0, delta, type);
	}

	/*
	* If after attempting to make the requested adjustment to the ARC
	* the meta limit is still being exceeded then request that the
	* higher layers drop some cached objects which have holds on ARC
	* meta buffers. Requests to the upper layers will be made with
	* increasingly large scan sizes until the ARC is below the limit.
	*/
	if (meta_used > arc_meta_limit) {
	if (type == ARC_BUFC_DATA) {
	type = ARC_BUFC_METADATA;
	} else {
	type = ARC_BUFC_DATA;

	if (zfs_arc_meta_prune) {
	prune += zfs_arc_meta_prune;
	arc_prune_async(prune);
	}
	}

	if (restarts > 0) {
	restarts--;
	goto restart;
	}
	}
	return (total_evicted);
	}

	/*
	* Evict metadata buffers from the cache, such that arc_meta_used is
	* capped by the arc_meta_limit tunable.
	*/
	static uint64_t
	arc_evict_meta_only(uint64_t meta_used)
	{
	uint64_t total_evicted = 0;
	int64_t target;

	/*
	* If we're over the meta limit, we want to evict enough
	* metadata to get back under the meta limit. We don't want to
	* evict so much that we drop the MRU below arc_p, though. If
	* we're over the meta limit more than we're over arc_p, we
	* evict some from the MRU here, and some from the MFU below.
	*/
	target = MIN((int64_t)(meta_used - arc_meta_limit),
	(int64_t)(zfs_refcount_count(&arc_anon->arcs_size) +
	zfs_refcount_count(&arc_mru->arcs_size) - arc_p));

	total_evicted += arc_evict_impl(arc_mru, 0, target, ARC_BUFC_METADATA);

	/*
	* Similar to the above, we want to evict enough bytes to get us
	* below the meta limit, but not so much as to drop us below the
	* space allotted to the MFU (which is defined as arc_c - arc_p).
	*/
	target = MIN((int64_t)(meta_used - arc_meta_limit),
	(int64_t)(zfs_refcount_count(&arc_mfu->arcs_size) -
	(arc_c - arc_p)));

	total_evicted += arc_evict_impl(arc_mfu, 0, target, ARC_BUFC_METADATA);

	return (total_evicted);
	}

	static uint64_t
	arc_evict_meta(uint64_t meta_used)
	{
	if (zfs_arc_meta_strategy == ARC_STRATEGY_META_ONLY)
	return (arc_evict_meta_only(meta_used));
	else
	return (arc_evict_meta_balanced(meta_used));
	}

	/*
	* Return the type of the oldest buffer in the given arc state
	*
	* This function will select a random sublist of type ARC_BUFC_DATA and
	* a random sublist of type ARC_BUFC_METADATA. The tail of each sublist
	* is compared, and the type which contains the "older" buffer will be
	* returned.
	*/
	static arc_buf_contents_t
	arc_evict_type(arc_state_t *state)
	{
	multilist_t *data_ml = state->arcs_list[ARC_BUFC_DATA];
	multilist_t *meta_ml = state->arcs_list[ARC_BUFC_METADATA];
	int data_idx = multilist_get_random_index(data_ml);
	int meta_idx = multilist_get_random_index(meta_ml);
	multilist_sublist_t *data_mls;
	multilist_sublist_t *meta_mls;
	arc_buf_contents_t type;
	arc_buf_hdr_t *data_hdr;
	arc_buf_hdr_t *meta_hdr;

	/*
	* We keep the sublist lock until we're finished, to prevent
	* the headers from being destroyed via arc_evict_state().
	*/
	data_mls = multilist_sublist_lock(data_ml, data_idx);
	meta_mls = multilist_sublist_lock(meta_ml, meta_idx);

	/*
	* These two loops are to ensure we skip any markers that
	* might be at the tail of the lists due to arc_evict_state().
	*/

	for (data_hdr = multilist_sublist_tail(data_mls); data_hdr != NULL;
	data_hdr = multilist_sublist_prev(data_mls, data_hdr)) {
	if (data_hdr->b_spa != 0)
	break;
	}

	for (meta_hdr = multilist_sublist_tail(meta_mls); meta_hdr != NULL;
	meta_hdr = multilist_sublist_prev(meta_mls, meta_hdr)) {
	if (meta_hdr->b_spa != 0)
	break;
	}

	if (data_hdr == NULL && meta_hdr == NULL) {
	type = ARC_BUFC_DATA;
	} else if (data_hdr == NULL) {
	ASSERT3P(meta_hdr, !=, NULL);
	type = ARC_BUFC_METADATA;
	} else if (meta_hdr == NULL) {
	ASSERT3P(data_hdr, !=, NULL);
	type = ARC_BUFC_DATA;
	} else {
	ASSERT3P(data_hdr, !=, NULL);
	ASSERT3P(meta_hdr, !=, NULL);

	/* The headers can't be on the sublist without an L1 header */
	ASSERT(HDR_HAS_L1HDR(data_hdr));
	ASSERT(HDR_HAS_L1HDR(meta_hdr));

	if (data_hdr->b_l1hdr.b_arc_access <
	meta_hdr->b_l1hdr.b_arc_access) {
	type = ARC_BUFC_DATA;
	} else {
	type = ARC_BUFC_METADATA;
	}
	}

	multilist_sublist_unlock(meta_mls);
	multilist_sublist_unlock(data_mls);

	return (type);
	}

	/*
	* Evict buffers from the cache, such that arc_size is capped by arc_c.
	*/
	static uint64_t
	arc_evict(void)
	{
	uint64_t total_evicted = 0;
	uint64_t bytes;
	int64_t target;
	uint64_t asize = aggsum_value(&arc_size);
	uint64_t ameta = aggsum_value(&arc_meta_used);

	/*
	* If we're over arc_meta_limit, we want to correct that before
	* potentially evicting data buffers below.
	*/
	total_evicted += arc_evict_meta(ameta);

	/*
	* Adjust MRU size
	*
	* If we're over the target cache size, we want to evict enough
	* from the list to get back to our target size. We don't want
	* to evict too much from the MRU, such that it drops below
	* arc_p. So, if we're over our target cache size more than
	* the MRU is over arc_p, we'll evict enough to get back to
	* arc_p here, and then evict more from the MFU below.
	*/
	target = MIN((int64_t)(asize - arc_c),
	(int64_t)(zfs_refcount_count(&arc_anon->arcs_size) +
	zfs_refcount_count(&arc_mru->arcs_size) + ameta - arc_p));

	/*
	* If we're below arc_meta_min, always prefer to evict data.
	* Otherwise, try to satisfy the requested number of bytes to
	* evict from the type which contains older buffers; in an
	* effort to keep newer buffers in the cache regardless of their
	* type. If we cannot satisfy the number of bytes from this
	* type, spill over into the next type.
	*/
	if (arc_evict_type(arc_mru) == ARC_BUFC_METADATA &&
	ameta > arc_meta_min) {
	bytes = arc_evict_impl(arc_mru, 0, target, ARC_BUFC_METADATA);
	total_evicted += bytes;

	/*
	* If we couldn't evict our target number of bytes from
	* metadata, we try to get the rest from data.
	*/
	target -= bytes;

	total_evicted +=
	arc_evict_impl(arc_mru, 0, target, ARC_BUFC_DATA);
	} else {
	bytes = arc_evict_impl(arc_mru, 0, target, ARC_BUFC_DATA);
	total_evicted += bytes;

	/*
	* If we couldn't evict our target number of bytes from
	* data, we try to get the rest from metadata.
	*/
	target -= bytes;

	total_evicted +=
	arc_evict_impl(arc_mru, 0, target, ARC_BUFC_METADATA);
	}

	/*
	* Re-sum ARC stats after the first round of evictions.
	*/
	asize = aggsum_value(&arc_size);
	ameta = aggsum_value(&arc_meta_used);


	/*
	* Adjust MFU size
	*
	* Now that we've tried to evict enough from the MRU to get its
	* size back to arc_p, if we're still above the target cache
	* size, we evict the rest from the MFU.
	*/
	target = asize - arc_c;

	if (arc_evict_type(arc_mfu) == ARC_BUFC_METADATA &&
	ameta > arc_meta_min) {
	bytes = arc_evict_impl(arc_mfu, 0, target, ARC_BUFC_METADATA);
	total_evicted += bytes;

	/*
	* If we couldn't evict our target number of bytes from
	* metadata, we try to get the rest from data.
	*/
	target -= bytes;

	total_evicted +=
	arc_evict_impl(arc_mfu, 0, target, ARC_BUFC_DATA);
	} else {
	bytes = arc_evict_impl(arc_mfu, 0, target, ARC_BUFC_DATA);
	total_evicted += bytes;

	/*
	* If we couldn't evict our target number of bytes from
	* data, we try to get the rest from data.
	*/
	target -= bytes;

	total_evicted +=
	arc_evict_impl(arc_mfu, 0, target, ARC_BUFC_METADATA);
	}

	/*
	* Adjust ghost lists
	*
	* In addition to the above, the ARC also defines target values
	* for the ghost lists. The sum of the mru list and mru ghost
	* list should never exceed the target size of the cache, and
	* the sum of the mru list, mfu list, mru ghost list, and mfu
	* ghost list should never exceed twice the target size of the
	* cache. The following logic enforces these limits on the ghost
	* caches, and evicts from them as needed.
	*/
	target = zfs_refcount_count(&arc_mru->arcs_size) +
	zfs_refcount_count(&arc_mru_ghost->arcs_size) - arc_c;

	bytes = arc_evict_impl(arc_mru_ghost, 0, target, ARC_BUFC_DATA);
	total_evicted += bytes;

	target -= bytes;

	total_evicted +=
	arc_evict_impl(arc_mru_ghost, 0, target, ARC_BUFC_METADATA);

	/*
	* We assume the sum of the mru list and mfu list is less than
	* or equal to arc_c (we enforced this above), which means we
	* can use the simpler of the two equations below:
	*
	* mru + mfu + mru ghost + mfu ghost <= 2 * arc_c
	* mru ghost + mfu ghost <= arc_c
	*/
	target = zfs_refcount_count(&arc_mru_ghost->arcs_size) +
	zfs_refcount_count(&arc_mfu_ghost->arcs_size) - arc_c;

	bytes = arc_evict_impl(arc_mfu_ghost, 0, target, ARC_BUFC_DATA);
	total_evicted += bytes;

	target -= bytes;

	total_evicted +=
	arc_evict_impl(arc_mfu_ghost, 0, target, ARC_BUFC_METADATA);

	return (total_evicted);
	}

	void
	arc_flush(spa_t *spa, boolean_t retry)
	{
	uint64_t guid = 0;

	/*
	* If retry is B_TRUE, a spa must not be specified since we have
	* no good way to determine if all of a spa's buffers have been
	* evicted from an arc state.
	*/
	ASSERT(!retry \|\| spa == 0);

	if (spa != NULL)
	guid = spa_load_guid(spa);

	(void) arc_flush_state(arc_mru, guid, ARC_BUFC_DATA, retry);
	(void) arc_flush_state(arc_mru, guid, ARC_BUFC_METADATA, retry);

	(void) arc_flush_state(arc_mfu, guid, ARC_BUFC_DATA, retry);
	(void) arc_flush_state(arc_mfu, guid, ARC_BUFC_METADATA, retry);

	(void) arc_flush_state(arc_mru_ghost, guid, ARC_BUFC_DATA, retry);
	(void) arc_flush_state(arc_mru_ghost, guid, ARC_BUFC_METADATA, retry);

	(void) arc_flush_state(arc_mfu_ghost, guid, ARC_BUFC_DATA, retry);
	(void) arc_flush_state(arc_mfu_ghost, guid, ARC_BUFC_METADATA, retry);
	}

	void
	arc_reduce_target_size(int64_t to_free)
	{
	uint64_t asize = aggsum_value(&arc_size);

	/*
	* All callers want the ARC to actually evict (at least) this much
	* memory. Therefore we reduce from the lower of the current size and
	* the target size. This way, even if arc_c is much higher than
	* arc_size (as can be the case after many calls to arc_freed(), we will
	* immediately have arc_c < arc_size and therefore the arc_evict_zthr
	* will evict.
	*/
	uint64_t c = MIN(arc_c, asize);

	if (c > to_free && c - to_free > arc_c_min) {
	arc_c = c - to_free;
	atomic_add_64(&arc_p, -(arc_p >> arc_shrink_shift));
	if (arc_p > arc_c)
	arc_p = (arc_c >> 1);
	ASSERT(arc_c >= arc_c_min);
	ASSERT((int64_t)arc_p >= 0);
	} else {
	arc_c = arc_c_min;
	}

	if (asize > arc_c) {
	/* See comment in arc_evict_cb_check() on why lock+flag */
	mutex_enter(&arc_evict_lock);
	arc_evict_needed = B_TRUE;
	mutex_exit(&arc_evict_lock);
	zthr_wakeup(arc_evict_zthr);
	}
	}

	/*
	* Determine if the system is under memory pressure and is asking
	* to reclaim memory. A return value of B_TRUE indicates that the system
	* is under memory pressure and that the arc should adjust accordingly.
	*/
	boolean_t
	arc_reclaim_needed(void)
	{
	return (arc_available_memory() < 0);
	}

	void
	arc_kmem_reap_soon(void)
	{
	size_t i;
	kmem_cache_t *prev_cache = NULL;
	kmem_cache_t *prev_data_cache = NULL;
	extern kmem_cache_t *zio_buf_cache[];
	extern kmem_cache_t *zio_data_buf_cache[];

	#ifdef _KERNEL
	if ((aggsum_compare(&arc_meta_used, arc_meta_limit) >= 0) &&
	zfs_arc_meta_prune) {
	/*
	* We are exceeding our meta-data cache limit.
	* Prune some entries to release holds on meta-data.
	*/
	arc_prune_async(zfs_arc_meta_prune);
	}
	#if defined(_ILP32)
	/*
	* Reclaim unused memory from all kmem caches.
	*/
	kmem_reap();
	#endif
	#endif

	for (i = 0; i < SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT; i++) {
	#if defined(_ILP32)
	/* reach upper limit of cache size on 32-bit */
	if (zio_buf_cache[i] == NULL)
	break;
	#endif
	if (zio_buf_cache[i] != prev_cache) {
	prev_cache = zio_buf_cache[i];
	kmem_cache_reap_now(zio_buf_cache[i]);
	}
	if (zio_data_buf_cache[i] != prev_data_cache) {
	prev_data_cache = zio_data_buf_cache[i];
	kmem_cache_reap_now(zio_data_buf_cache[i]);
	}
	}
	kmem_cache_reap_now(buf_cache);
	kmem_cache_reap_now(hdr_full_cache);
	kmem_cache_reap_now(hdr_l2only_cache);
	kmem_cache_reap_now(zfs_btree_leaf_cache);
	abd_cache_reap_now();
	}

	/* ARGSUSED */
	static boolean_t
	arc_evict_cb_check(void arg, zthr_t zthr)
	{
	#ifdef ZFS_DEBUG
	/*
	* This is necessary in order to keep the kstat information
	* up to date for tools that display kstat data such as the
	* mdb ::arc dcmd and the Linux crash utility. These tools
	* typically do not call kstat's update function, but simply
	* dump out stats from the most recent update. Without
	* this call, these commands may show stale stats for the
	* anon, mru, mru_ghost, mfu, and mfu_ghost lists. Even
	* with this call, the data might be out of date if the
	* evict thread hasn't been woken recently; but that should
	* suffice. The arc_state_t structures can be queried
	* directly if more accurate information is needed.
	*/
	if (arc_ksp != NULL)
	arc_ksp->ks_update(arc_ksp, KSTAT_READ);
	#endif

	/*
	* We have to rely on arc_wait_for_eviction() to tell us when to
	* evict, rather than checking if we are overflowing here, so that we
	* are sure to not leave arc_wait_for_eviction() waiting on aew_cv.
	* If we have become "not overflowing" since arc_wait_for_eviction()
	* checked, we need to wake it up. We could broadcast the CV here,
	* but arc_wait_for_eviction() may have not yet gone to sleep. We
	* would need to use a mutex to ensure that this function doesn't
	* broadcast until arc_wait_for_eviction() has gone to sleep (e.g.
	* the arc_evict_lock). However, the lock ordering of such a lock
	* would necessarily be incorrect with respect to the zthr_lock,
	* which is held before this function is called, and is held by
	* arc_wait_for_eviction() when it calls zthr_wakeup().
	*/
	return (arc_evict_needed);
	}

	/*
	* Keep arc_size under arc_c by running arc_evict which evicts data
	* from the ARC.
	*/
	/* ARGSUSED */
	static void
	arc_evict_cb(void arg, zthr_t zthr)
	{
	uint64_t evicted = 0;
	fstrans_cookie_t cookie = spl_fstrans_mark();

	/* Evict from cache */
	evicted = arc_evict();

	/*
	* If evicted is zero, we couldn't evict anything
	* via arc_evict(). This could be due to hash lock
	* collisions, but more likely due to the majority of
	* arc buffers being unevictable. Therefore, even if
	* arc_size is above arc_c, another pass is unlikely to
	* be helpful and could potentially cause us to enter an
	* infinite loop. Additionally, zthr_iscancelled() is
	* checked here so that if the arc is shutting down, the
	* broadcast will wake any remaining arc evict waiters.
	*/
	mutex_enter(&arc_evict_lock);
	arc_evict_needed = !zthr_iscancelled(arc_evict_zthr) &&
	evicted > 0 && aggsum_compare(&arc_size, arc_c) > 0;
	if (!arc_evict_needed) {
	/*
	* We're either no longer overflowing, or we
	* can't evict anything more, so we should wake
	* arc_get_data_impl() sooner.
	*/
	arc_evict_waiter_t *aw;
	while ((aw = list_remove_head(&arc_evict_waiters)) != NULL) {
	cv_broadcast(&aw->aew_cv);
	}
	arc_set_need_free();
	}
	mutex_exit(&arc_evict_lock);
	spl_fstrans_unmark(cookie);
	}

	/* ARGSUSED */
	static boolean_t
	arc_reap_cb_check(void arg, zthr_t zthr)
	{
	int64_t free_memory = arc_available_memory();
	static int reap_cb_check_counter = 0;

	/*
	* If a kmem reap is already active, don't schedule more. We must
	* check for this because kmem_cache_reap_soon() won't actually
	* block on the cache being reaped (this is to prevent callers from
	* becoming implicitly blocked by a system-wide kmem reap -- which,
	* on a system with many, many full magazines, can take minutes).
	*/
	if (!kmem_cache_reap_active() && free_memory < 0) {

	arc_no_grow = B_TRUE;
	arc_warm = B_TRUE;
	/*
	* Wait at least zfs_grow_retry (default 5) seconds
	* before considering growing.
	*/
	arc_growtime = gethrtime() + SEC2NSEC(arc_grow_retry);
	return (B_TRUE);
	} else if (free_memory < arc_c >> arc_no_grow_shift) {
	arc_no_grow = B_TRUE;
	} else if (gethrtime() >= arc_growtime) {
	arc_no_grow = B_FALSE;
	}

	/*
	* Called unconditionally every 60 seconds to reclaim unused
	* zstd compression and decompression context. This is done
	* here to avoid the need for an independent thread.
	*/
	if (!((reap_cb_check_counter++) % 60))
	zfs_zstd_cache_reap_now();

	return (B_FALSE);
	}

	/*
	* Keep enough free memory in the system by reaping the ARC's kmem
	* caches. To cause more slabs to be reapable, we may reduce the
	* target size of the cache (arc_c), causing the arc_evict_cb()
	* to free more buffers.
	*/
	/* ARGSUSED */
	static void
	arc_reap_cb(void arg, zthr_t zthr)
	{
	int64_t free_memory;
	fstrans_cookie_t cookie = spl_fstrans_mark();

	/*
	* Kick off asynchronous kmem_reap()'s of all our caches.
	*/
	arc_kmem_reap_soon();

	/*
	* Wait at least arc_kmem_cache_reap_retry_ms between
	* arc_kmem_reap_soon() calls. Without this check it is possible to
	* end up in a situation where we spend lots of time reaping
	* caches, while we're near arc_c_min. Waiting here also gives the
	* subsequent free memory check a chance of finding that the
	* asynchronous reap has already freed enough memory, and we don't
	* need to call arc_reduce_target_size().
	*/
	delay((hz * arc_kmem_cache_reap_retry_ms + 999) / 1000);

	/*
	* Reduce the target size as needed to maintain the amount of free
	* memory in the system at a fraction of the arc_size (1/128th by
	* default). If oversubscribed (free_memory < 0) then reduce the
	* target arc_size by the deficit amount plus the fractional
	- * amount. If free memory is positive but less then the fractional
	+ * amount. If free memory is positive but less than the fractional
	* amount, reduce by what is needed to hit the fractional amount.
	*/
	free_memory = arc_available_memory();

	int64_t to_free =
	(arc_c >> arc_shrink_shift) - free_memory;
	if (to_free > 0) {
	arc_reduce_target_size(to_free);
	}
	spl_fstrans_unmark(cookie);
	}

	#ifdef _KERNEL
	/*
	* Determine the amount of memory eligible for eviction contained in the
	* ARC. All clean data reported by the ghost lists can always be safely
	* evicted. Due to arc_c_min, the same does not hold for all clean data
	* contained by the regular mru and mfu lists.
	*
	* In the case of the regular mru and mfu lists, we need to report as
	* much clean data as possible, such that evicting that same reported
	* data will not bring arc_size below arc_c_min. Thus, in certain
	* circumstances, the total amount of clean data in the mru and mfu
	* lists might not actually be evictable.
	*
	* The following two distinct cases are accounted for:
	*
	* 1. The sum of the amount of dirty data contained by both the mru and
	* mfu lists, plus the ARC's other accounting (e.g. the anon list),
	* is greater than or equal to arc_c_min.
	* (i.e. amount of dirty data >= arc_c_min)
	*
	* This is the easy case; all clean data contained by the mru and mfu
	* lists is evictable. Evicting all clean data can only drop arc_size
	* to the amount of dirty data, which is greater than arc_c_min.
	*
	* 2. The sum of the amount of dirty data contained by both the mru and
	* mfu lists, plus the ARC's other accounting (e.g. the anon list),
	* is less than arc_c_min.
	* (i.e. arc_c_min > amount of dirty data)
	*
	* 2.1. arc_size is greater than or equal arc_c_min.
	* (i.e. arc_size >= arc_c_min > amount of dirty data)
	*
	* In this case, not all clean data from the regular mru and mfu
	* lists is actually evictable; we must leave enough clean data
	* to keep arc_size above arc_c_min. Thus, the maximum amount of
	* evictable data from the two lists combined, is exactly the
	* difference between arc_size and arc_c_min.
	*
	* 2.2. arc_size is less than arc_c_min
	* (i.e. arc_c_min > arc_size > amount of dirty data)
	*
	* In this case, none of the data contained in the mru and mfu
	* lists is evictable, even if it's clean. Since arc_size is
	* already below arc_c_min, evicting any more would only
	* increase this negative difference.
	*/

	#endif /* _KERNEL */

	/*
	* Adapt arc info given the number of bytes we are trying to add and
	* the state that we are coming from. This function is only called
	* when we are adding new content to the cache.
	*/
	static void
	arc_adapt(int bytes, arc_state_t *state)
	{
	int mult;
	uint64_t arc_p_min = (arc_c >> arc_p_min_shift);
	int64_t mrug_size = zfs_refcount_count(&arc_mru_ghost->arcs_size);
	int64_t mfug_size = zfs_refcount_count(&arc_mfu_ghost->arcs_size);

	ASSERT(bytes > 0);
	/*
	* Adapt the target size of the MRU list:
	* - if we just hit in the MRU ghost list, then increase
	* the target size of the MRU list.
	* - if we just hit in the MFU ghost list, then increase
	* the target size of the MFU list by decreasing the
	* target size of the MRU list.
	*/
	if (state == arc_mru_ghost) {
	mult = (mrug_size >= mfug_size) ? 1 : (mfug_size / mrug_size);
	if (!zfs_arc_p_dampener_disable)
	mult = MIN(mult, 10); /* avoid wild arc_p adjustment */

	arc_p = MIN(arc_c - arc_p_min, arc_p + bytes * mult);
	} else if (state == arc_mfu_ghost) {
	uint64_t delta;

	mult = (mfug_size >= mrug_size) ? 1 : (mrug_size / mfug_size);
	if (!zfs_arc_p_dampener_disable)
	mult = MIN(mult, 10);

	delta = MIN(bytes * mult, arc_p);
	arc_p = MAX(arc_p_min, arc_p - delta);
	}
	ASSERT((int64_t)arc_p >= 0);

	/*
	* Wake reap thread if we do not have any available memory
	*/
	if (arc_reclaim_needed()) {
	zthr_wakeup(arc_reap_zthr);
	return;
	}

	if (arc_no_grow)
	return;

	if (arc_c >= arc_c_max)
	return;

	/*
	* If we're within (2 * maxblocksize) bytes of the target
	* cache size, increment the target cache size
	*/
	ASSERT3U(arc_c, >=, 2ULL << SPA_MAXBLOCKSHIFT);
	if (aggsum_upper_bound(&arc_size) >=
	arc_c - (2ULL << SPA_MAXBLOCKSHIFT)) {
	atomic_add_64(&arc_c, (int64_t)bytes);
	if (arc_c > arc_c_max)
	arc_c = arc_c_max;
	else if (state == arc_anon)
	atomic_add_64(&arc_p, (int64_t)bytes);
	if (arc_p > arc_c)
	arc_p = arc_c;
	}
	ASSERT((int64_t)arc_p >= 0);
	}

	/*
	* Check if arc_size has grown past our upper threshold, determined by
	* zfs_arc_overflow_shift.
	*/
	boolean_t
	arc_is_overflowing(void)
	{
	/* Always allow at least one block of overflow */
	int64_t overflow = MAX(SPA_MAXBLOCKSIZE,
	arc_c >> zfs_arc_overflow_shift);

	/*
	* We just compare the lower bound here for performance reasons. Our
	* primary goals are to make sure that the arc never grows without
	* bound, and that it can reach its maximum size. This check
	* accomplishes both goals. The maximum amount we could run over by is
	* 2 * aggsum_borrow_multiplier * NUM_CPUS * the average size of a block
	* in the ARC. In practice, that's in the tens of MB, which is low
	* enough to be safe.
	*/
	return (aggsum_lower_bound(&arc_size) >= (int64_t)arc_c + overflow);
	}

	static abd_t *
	arc_get_data_abd(arc_buf_hdr_t hdr, uint64_t size, void tag,
	boolean_t do_adapt)
	{
	arc_buf_contents_t type = arc_buf_type(hdr);

	arc_get_data_impl(hdr, size, tag, do_adapt);
	if (type == ARC_BUFC_METADATA) {
	return (abd_alloc(size, B_TRUE));
	} else {
	ASSERT(type == ARC_BUFC_DATA);
	return (abd_alloc(size, B_FALSE));
	}
	}

	static void *
	arc_get_data_buf(arc_buf_hdr_t hdr, uint64_t size, void tag)
	{
	arc_buf_contents_t type = arc_buf_type(hdr);

	arc_get_data_impl(hdr, size, tag, B_TRUE);
	if (type == ARC_BUFC_METADATA) {
	return (zio_buf_alloc(size));
	} else {
	ASSERT(type == ARC_BUFC_DATA);
	return (zio_data_buf_alloc(size));
	}
	}

	/*
	* Wait for the specified amount of data (in bytes) to be evicted from the
	* ARC, and for there to be sufficient free memory in the system. Waiting for
	* eviction ensures that the memory used by the ARC decreases. Waiting for
	* free memory ensures that the system won't run out of free pages, regardless
	* of ARC behavior and settings. See arc_lowmem_init().
	*/
	void
	arc_wait_for_eviction(uint64_t amount)
	{
	mutex_enter(&arc_evict_lock);
	if (arc_is_overflowing()) {
	arc_evict_needed = B_TRUE;
	zthr_wakeup(arc_evict_zthr);

	if (amount != 0) {
	arc_evict_waiter_t aw;
	list_link_init(&aw.aew_node);
	cv_init(&aw.aew_cv, NULL, CV_DEFAULT, NULL);

	uint64_t last_count = 0;
	if (!list_is_empty(&arc_evict_waiters)) {
	arc_evict_waiter_t *last =
	list_tail(&arc_evict_waiters);
	last_count = last->aew_count;
	}
	/*
	* Note, the last waiter's count may be less than
	* arc_evict_count if we are low on memory in which
	* case arc_evict_state_impl() may have deferred
	* wakeups (but still incremented arc_evict_count).
	*/
	aw.aew_count =
	MAX(last_count, arc_evict_count) + amount;

	list_insert_tail(&arc_evict_waiters, &aw);

	arc_set_need_free();

	DTRACE_PROBE3(arc__wait__for__eviction,
	uint64_t, amount,
	uint64_t, arc_evict_count,
	uint64_t, aw.aew_count);

	/*
	* We will be woken up either when arc_evict_count
	* reaches aew_count, or when the ARC is no longer
	* overflowing and eviction completes.
	*/
	cv_wait(&aw.aew_cv, &arc_evict_lock);

	/*
	* In case of "false" wakeup, we will still be on the
	* list.
	*/
	if (list_link_active(&aw.aew_node))
	list_remove(&arc_evict_waiters, &aw);

	cv_destroy(&aw.aew_cv);
	}
	}
	mutex_exit(&arc_evict_lock);
	}

	/*
	* Allocate a block and return it to the caller. If we are hitting the
	* hard limit for the cache size, we must sleep, waiting for the eviction
	* thread to catch up. If we're past the target size but below the hard
	* limit, we'll only signal the reclaim thread and continue on.
	*/
	static void
	arc_get_data_impl(arc_buf_hdr_t hdr, uint64_t size, void tag,
	boolean_t do_adapt)
	{
	arc_state_t *state = hdr->b_l1hdr.b_state;
	arc_buf_contents_t type = arc_buf_type(hdr);

	if (do_adapt)
	arc_adapt(size, state);

	/*
	* If arc_size is currently overflowing, we must be adding data
	* faster than we are evicting. To ensure we don't compound the
	* problem by adding more data and forcing arc_size to grow even
	* further past it's target size, we wait for the eviction thread to
	* make some progress. We also wait for there to be sufficient free
	* memory in the system, as measured by arc_free_memory().
	*
	* Specifically, we wait for zfs_arc_eviction_pct percent of the
	* requested size to be evicted. This should be more than 100%, to
	* ensure that that progress is also made towards getting arc_size
	* under arc_c. See the comment above zfs_arc_eviction_pct.
	*
	* We do the overflowing check without holding the arc_evict_lock to
	* reduce lock contention in this hot path. Note that
	* arc_wait_for_eviction() will acquire the lock and check again to
	* ensure we are truly overflowing before blocking.
	*/
	if (arc_is_overflowing()) {
	arc_wait_for_eviction(size *
	zfs_arc_eviction_pct / 100);
	}

	VERIFY3U(hdr->b_type, ==, type);
	if (type == ARC_BUFC_METADATA) {
	arc_space_consume(size, ARC_SPACE_META);
	} else {
	arc_space_consume(size, ARC_SPACE_DATA);
	}

	/*
	* Update the state size. Note that ghost states have a
	* "ghost size" and so don't need to be updated.
	*/
	if (!GHOST_STATE(state)) {

	(void) zfs_refcount_add_many(&state->arcs_size, size, tag);

	/*
	* If this is reached via arc_read, the link is
	* protected by the hash lock. If reached via
	* arc_buf_alloc, the header should not be accessed by
	* any other thread. And, if reached via arc_read_done,
	* the hash lock will protect it if it's found in the
	* hash table; otherwise no other thread should be
	* trying to [add\|remove]_reference it.
	*/
	if (multilist_link_active(&hdr->b_l1hdr.b_arc_node)) {
	ASSERT(zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt));
	(void) zfs_refcount_add_many(&state->arcs_esize[type],
	size, tag);
	}

	/*
	* If we are growing the cache, and we are adding anonymous
	* data, and we have outgrown arc_p, update arc_p
	*/
	if (aggsum_upper_bound(&arc_size) < arc_c &&
	hdr->b_l1hdr.b_state == arc_anon &&
	(zfs_refcount_count(&arc_anon->arcs_size) +
	zfs_refcount_count(&arc_mru->arcs_size) > arc_p))
	arc_p = MIN(arc_c, arc_p + size);
	}
	}

	static void
	arc_free_data_abd(arc_buf_hdr_t hdr, abd_t abd, uint64_t size, void *tag)
	{
	arc_free_data_impl(hdr, size, tag);
	abd_free(abd);
	}

	static void
	arc_free_data_buf(arc_buf_hdr_t hdr, void buf, uint64_t size, void *tag)
	{
	arc_buf_contents_t type = arc_buf_type(hdr);

	arc_free_data_impl(hdr, size, tag);
	if (type == ARC_BUFC_METADATA) {
	zio_buf_free(buf, size);
	} else {
	ASSERT(type == ARC_BUFC_DATA);
	zio_data_buf_free(buf, size);
	}
	}

	/*
	* Free the arc data buffer.
	*/
	static void
	arc_free_data_impl(arc_buf_hdr_t hdr, uint64_t size, void tag)
	{
	arc_state_t *state = hdr->b_l1hdr.b_state;
	arc_buf_contents_t type = arc_buf_type(hdr);

	/* protected by hash lock, if in the hash table */
	if (multilist_link_active(&hdr->b_l1hdr.b_arc_node)) {
	ASSERT(zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt));
	ASSERT(state != arc_anon && state != arc_l2c_only);

	(void) zfs_refcount_remove_many(&state->arcs_esize[type],
	size, tag);
	}
	(void) zfs_refcount_remove_many(&state->arcs_size, size, tag);

	VERIFY3U(hdr->b_type, ==, type);
	if (type == ARC_BUFC_METADATA) {
	arc_space_return(size, ARC_SPACE_META);
	} else {
	ASSERT(type == ARC_BUFC_DATA);
	arc_space_return(size, ARC_SPACE_DATA);
	}
	}

	/*
	* This routine is called whenever a buffer is accessed.
	* NOTE: the hash lock is dropped in this function.
	*/
	static void
	arc_access(arc_buf_hdr_t hdr, kmutex_t hash_lock)
	{
	clock_t now;

	ASSERT(MUTEX_HELD(hash_lock));
	ASSERT(HDR_HAS_L1HDR(hdr));

	if (hdr->b_l1hdr.b_state == arc_anon) {
	/*
	* This buffer is not in the cache, and does not
	* appear in our "ghost" list. Add the new buffer
	* to the MRU state.
	*/

	ASSERT0(hdr->b_l1hdr.b_arc_access);
	hdr->b_l1hdr.b_arc_access = ddi_get_lbolt();
	DTRACE_PROBE1(new_state__mru, arc_buf_hdr_t *, hdr);
	arc_change_state(arc_mru, hdr, hash_lock);

	} else if (hdr->b_l1hdr.b_state == arc_mru) {
	now = ddi_get_lbolt();

	/*
	* If this buffer is here because of a prefetch, then either:
	* - clear the flag if this is a "referencing" read
	* (any subsequent access will bump this into the MFU state).
	* or
	* - move the buffer to the head of the list if this is
	* another prefetch (to make it less likely to be evicted).
	*/
	if (HDR_PREFETCH(hdr) \|\| HDR_PRESCIENT_PREFETCH(hdr)) {
	if (zfs_refcount_count(&hdr->b_l1hdr.b_refcnt) == 0) {
	/* link protected by hash lock */
	ASSERT(multilist_link_active(
	&hdr->b_l1hdr.b_arc_node));
	} else {
	if (HDR_HAS_L2HDR(hdr))
	l2arc_hdr_arcstats_decrement_state(hdr);
	arc_hdr_clear_flags(hdr,
	ARC_FLAG_PREFETCH \|
	ARC_FLAG_PRESCIENT_PREFETCH);
	atomic_inc_32(&hdr->b_l1hdr.b_mru_hits);
	ARCSTAT_BUMP(arcstat_mru_hits);
	if (HDR_HAS_L2HDR(hdr))
	l2arc_hdr_arcstats_increment_state(hdr);
	}
	hdr->b_l1hdr.b_arc_access = now;
	return;
	}

	/*
	* This buffer has been "accessed" only once so far,
	* but it is still in the cache. Move it to the MFU
	* state.
	*/
	if (ddi_time_after(now, hdr->b_l1hdr.b_arc_access +
	ARC_MINTIME)) {
	/*
	* More than 125ms have passed since we
	* instantiated this buffer. Move it to the
	* most frequently used state.
	*/
	hdr->b_l1hdr.b_arc_access = now;
	DTRACE_PROBE1(new_state__mfu, arc_buf_hdr_t *, hdr);
	arc_change_state(arc_mfu, hdr, hash_lock);
	}
	atomic_inc_32(&hdr->b_l1hdr.b_mru_hits);
	ARCSTAT_BUMP(arcstat_mru_hits);
	} else if (hdr->b_l1hdr.b_state == arc_mru_ghost) {
	arc_state_t *new_state;
	/*
	* This buffer has been "accessed" recently, but
	* was evicted from the cache. Move it to the
	* MFU state.
	*/
	if (HDR_PREFETCH(hdr) \|\| HDR_PRESCIENT_PREFETCH(hdr)) {
	new_state = arc_mru;
	if (zfs_refcount_count(&hdr->b_l1hdr.b_refcnt) > 0) {
	if (HDR_HAS_L2HDR(hdr))
	l2arc_hdr_arcstats_decrement_state(hdr);
	arc_hdr_clear_flags(hdr,
	ARC_FLAG_PREFETCH \|
	ARC_FLAG_PRESCIENT_PREFETCH);
	if (HDR_HAS_L2HDR(hdr))
	l2arc_hdr_arcstats_increment_state(hdr);
	}
	DTRACE_PROBE1(new_state__mru, arc_buf_hdr_t *, hdr);
	} else {
	new_state = arc_mfu;
	DTRACE_PROBE1(new_state__mfu, arc_buf_hdr_t *, hdr);
	}

	hdr->b_l1hdr.b_arc_access = ddi_get_lbolt();
	arc_change_state(new_state, hdr, hash_lock);

	atomic_inc_32(&hdr->b_l1hdr.b_mru_ghost_hits);
	ARCSTAT_BUMP(arcstat_mru_ghost_hits);
	} else if (hdr->b_l1hdr.b_state == arc_mfu) {
	/*
	* This buffer has been accessed more than once and is
	* still in the cache. Keep it in the MFU state.
	*
	* NOTE: an add_reference() that occurred when we did
	* the arc_read() will have kicked this off the list.
	* If it was a prefetch, we will explicitly move it to
	* the head of the list now.
	*/

	atomic_inc_32(&hdr->b_l1hdr.b_mfu_hits);
	ARCSTAT_BUMP(arcstat_mfu_hits);
	hdr->b_l1hdr.b_arc_access = ddi_get_lbolt();
	} else if (hdr->b_l1hdr.b_state == arc_mfu_ghost) {
	arc_state_t *new_state = arc_mfu;
	/*
	* This buffer has been accessed more than once but has
	* been evicted from the cache. Move it back to the
	* MFU state.
	*/

	if (HDR_PREFETCH(hdr) \|\| HDR_PRESCIENT_PREFETCH(hdr)) {
	/*
	* This is a prefetch access...
	* move this block back to the MRU state.
	*/
	new_state = arc_mru;
	}

	hdr->b_l1hdr.b_arc_access = ddi_get_lbolt();
	DTRACE_PROBE1(new_state__mfu, arc_buf_hdr_t *, hdr);
	arc_change_state(new_state, hdr, hash_lock);

	atomic_inc_32(&hdr->b_l1hdr.b_mfu_ghost_hits);
	ARCSTAT_BUMP(arcstat_mfu_ghost_hits);
	} else if (hdr->b_l1hdr.b_state == arc_l2c_only) {
	/*
	* This buffer is on the 2nd Level ARC.
	*/

	hdr->b_l1hdr.b_arc_access = ddi_get_lbolt();
	DTRACE_PROBE1(new_state__mfu, arc_buf_hdr_t *, hdr);
	arc_change_state(arc_mfu, hdr, hash_lock);
	} else {
	cmn_err(CE_PANIC, "invalid arc state 0x%p",
	hdr->b_l1hdr.b_state);
	}
	}

	/*
	* This routine is called by dbuf_hold() to update the arc_access() state
	* which otherwise would be skipped for entries in the dbuf cache.
	*/
	void
	arc_buf_access(arc_buf_t *buf)
	{
	mutex_enter(&buf->b_evict_lock);
	arc_buf_hdr_t *hdr = buf->b_hdr;

	/*
	* Avoid taking the hash_lock when possible as an optimization.
	* The header must be checked again under the hash_lock in order
	* to handle the case where it is concurrently being released.
	*/
	if (hdr->b_l1hdr.b_state == arc_anon \|\| HDR_EMPTY(hdr)) {
	mutex_exit(&buf->b_evict_lock);
	return;
	}

	kmutex_t *hash_lock = HDR_LOCK(hdr);
	mutex_enter(hash_lock);

	if (hdr->b_l1hdr.b_state == arc_anon \|\| HDR_EMPTY(hdr)) {
	mutex_exit(hash_lock);
	mutex_exit(&buf->b_evict_lock);
	ARCSTAT_BUMP(arcstat_access_skip);
	return;
	}

	mutex_exit(&buf->b_evict_lock);

	ASSERT(hdr->b_l1hdr.b_state == arc_mru \|\|
	hdr->b_l1hdr.b_state == arc_mfu);

	DTRACE_PROBE1(arc__hit, arc_buf_hdr_t *, hdr);
	arc_access(hdr, hash_lock);
	mutex_exit(hash_lock);

	ARCSTAT_BUMP(arcstat_hits);
	ARCSTAT_CONDSTAT(!HDR_PREFETCH(hdr) && !HDR_PRESCIENT_PREFETCH(hdr),
	demand, prefetch, !HDR_ISTYPE_METADATA(hdr), data, metadata, hits);
	}

	/* a generic arc_read_done_func_t which you can use */
	/* ARGSUSED */
	void
	arc_bcopy_func(zio_t zio, const zbookmark_phys_t zb, const blkptr_t *bp,
	arc_buf_t buf, void arg)
	{
	if (buf == NULL)
	return;

	bcopy(buf->b_data, arg, arc_buf_size(buf));
	arc_buf_destroy(buf, arg);
	}

	/* a generic arc_read_done_func_t */
	/* ARGSUSED */
	void
	arc_getbuf_func(zio_t zio, const zbookmark_phys_t zb, const blkptr_t *bp,
	arc_buf_t buf, void arg)
	{
	arc_buf_t **bufp = arg;

	if (buf == NULL) {
	ASSERT(zio == NULL \|\| zio->io_error != 0);
	*bufp = NULL;
	} else {
	ASSERT(zio == NULL \|\| zio->io_error == 0);
	*bufp = buf;
	ASSERT(buf->b_data != NULL);
	}
	}

	static void
	arc_hdr_verify(arc_buf_hdr_t hdr, blkptr_t bp)
	{
	if (BP_IS_HOLE(bp) \|\| BP_IS_EMBEDDED(bp)) {
	ASSERT3U(HDR_GET_PSIZE(hdr), ==, 0);
	ASSERT3U(arc_hdr_get_compress(hdr), ==, ZIO_COMPRESS_OFF);
	} else {
	if (HDR_COMPRESSION_ENABLED(hdr)) {
	ASSERT3U(arc_hdr_get_compress(hdr), ==,
	BP_GET_COMPRESS(bp));
	}
	ASSERT3U(HDR_GET_LSIZE(hdr), ==, BP_GET_LSIZE(bp));
	ASSERT3U(HDR_GET_PSIZE(hdr), ==, BP_GET_PSIZE(bp));
	ASSERT3U(!!HDR_PROTECTED(hdr), ==, BP_IS_PROTECTED(bp));
	}
	}

	static void
	arc_read_done(zio_t *zio)
	{
	blkptr_t *bp = zio->io_bp;
	arc_buf_hdr_t *hdr = zio->io_private;
	kmutex_t *hash_lock = NULL;
	arc_callback_t *callback_list;
	arc_callback_t *acb;
	boolean_t freeable = B_FALSE;

	/*
	* The hdr was inserted into hash-table and removed from lists
	* prior to starting I/O. We should find this header, since
	* it's in the hash table, and it should be legit since it's
	* not possible to evict it during the I/O. The only possible
	* reason for it not to be found is if we were freed during the
	* read.
	*/
	if (HDR_IN_HASH_TABLE(hdr)) {
	arc_buf_hdr_t *found;

	ASSERT3U(hdr->b_birth, ==, BP_PHYSICAL_BIRTH(zio->io_bp));
	ASSERT3U(hdr->b_dva.dva_word[0], ==,
	BP_IDENTITY(zio->io_bp)->dva_word[0]);
	ASSERT3U(hdr->b_dva.dva_word[1], ==,
	BP_IDENTITY(zio->io_bp)->dva_word[1]);

	found = buf_hash_find(hdr->b_spa, zio->io_bp, &hash_lock);

	ASSERT((found == hdr &&
	DVA_EQUAL(&hdr->b_dva, BP_IDENTITY(zio->io_bp))) \|\|
	(found == hdr && HDR_L2_READING(hdr)));
	ASSERT3P(hash_lock, !=, NULL);
	}

	if (BP_IS_PROTECTED(bp)) {
	hdr->b_crypt_hdr.b_ot = BP_GET_TYPE(bp);
	hdr->b_crypt_hdr.b_dsobj = zio->io_bookmark.zb_objset;
	zio_crypt_decode_params_bp(bp, hdr->b_crypt_hdr.b_salt,
	hdr->b_crypt_hdr.b_iv);

	if (BP_GET_TYPE(bp) == DMU_OT_INTENT_LOG) {
	void *tmpbuf;

	tmpbuf = abd_borrow_buf_copy(zio->io_abd,
	sizeof (zil_chain_t));
	zio_crypt_decode_mac_zil(tmpbuf,
	hdr->b_crypt_hdr.b_mac);
	abd_return_buf(zio->io_abd, tmpbuf,
	sizeof (zil_chain_t));
	} else {
	zio_crypt_decode_mac_bp(bp, hdr->b_crypt_hdr.b_mac);
	}
	}

	if (zio->io_error == 0) {
	/* byteswap if necessary */
	if (BP_SHOULD_BYTESWAP(zio->io_bp)) {
	if (BP_GET_LEVEL(zio->io_bp) > 0) {
	hdr->b_l1hdr.b_byteswap = DMU_BSWAP_UINT64;
	} else {
	hdr->b_l1hdr.b_byteswap =
	DMU_OT_BYTESWAP(BP_GET_TYPE(zio->io_bp));
	}
	} else {
	hdr->b_l1hdr.b_byteswap = DMU_BSWAP_NUMFUNCS;
	}
	if (!HDR_L2_READING(hdr)) {
	hdr->b_complevel = zio->io_prop.zp_complevel;
	}
	}

	arc_hdr_clear_flags(hdr, ARC_FLAG_L2_EVICTED);
	if (l2arc_noprefetch && HDR_PREFETCH(hdr))
	arc_hdr_clear_flags(hdr, ARC_FLAG_L2CACHE);

	callback_list = hdr->b_l1hdr.b_acb;
	ASSERT3P(callback_list, !=, NULL);

	if (hash_lock && zio->io_error == 0 &&
	hdr->b_l1hdr.b_state == arc_anon) {
	/*
	* Only call arc_access on anonymous buffers. This is because
	* if we've issued an I/O for an evicted buffer, we've already
	* called arc_access (to prevent any simultaneous readers from
	* getting confused).
	*/
	arc_access(hdr, hash_lock);
	}

	/*
	* If a read request has a callback (i.e. acb_done is not NULL), then we
	* make a buf containing the data according to the parameters which were
	* passed in. The implementation of arc_buf_alloc_impl() ensures that we
	* aren't needlessly decompressing the data multiple times.
	*/
	int callback_cnt = 0;
	for (acb = callback_list; acb != NULL; acb = acb->acb_next) {
	if (!acb->acb_done \|\| acb->acb_nobuf)
	continue;

	callback_cnt++;

	if (zio->io_error != 0)
	continue;

	int error = arc_buf_alloc_impl(hdr, zio->io_spa,
	&acb->acb_zb, acb->acb_private, acb->acb_encrypted,
	acb->acb_compressed, acb->acb_noauth, B_TRUE,
	&acb->acb_buf);

	/*
	* Assert non-speculative zios didn't fail because an
	* encryption key wasn't loaded
	*/
	ASSERT((zio->io_flags & ZIO_FLAG_SPECULATIVE) \|\|
	error != EACCES);

	/*
	* If we failed to decrypt, report an error now (as the zio
	* layer would have done if it had done the transforms).
	*/
	if (error == ECKSUM) {
	ASSERT(BP_IS_PROTECTED(bp));
	error = SET_ERROR(EIO);
	if ((zio->io_flags & ZIO_FLAG_SPECULATIVE) == 0) {
	spa_log_error(zio->io_spa, &acb->acb_zb);
	(void) zfs_ereport_post(
	FM_EREPORT_ZFS_AUTHENTICATION,
	zio->io_spa, NULL, &acb->acb_zb, zio, 0);
	}
	}

	if (error != 0) {
	/*
	* Decompression or decryption failed. Set
	* io_error so that when we call acb_done
	* (below), we will indicate that the read
	* failed. Note that in the unusual case
	* where one callback is compressed and another
	* uncompressed, we will mark all of them
	* as failed, even though the uncompressed
	* one can't actually fail. In this case,
	* the hdr will not be anonymous, because
	* if there are multiple callbacks, it's
	* because multiple threads found the same
	* arc buf in the hash table.
	*/
	zio->io_error = error;
	}
	}

	/*
	* If there are multiple callbacks, we must have the hash lock,
	* because the only way for multiple threads to find this hdr is
	* in the hash table. This ensures that if there are multiple
	* callbacks, the hdr is not anonymous. If it were anonymous,
	* we couldn't use arc_buf_destroy() in the error case below.
	*/
	ASSERT(callback_cnt < 2 \|\| hash_lock != NULL);

	hdr->b_l1hdr.b_acb = NULL;
	arc_hdr_clear_flags(hdr, ARC_FLAG_IO_IN_PROGRESS);
	if (callback_cnt == 0)
	ASSERT(hdr->b_l1hdr.b_pabd != NULL \|\| HDR_HAS_RABD(hdr));

	ASSERT(zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt) \|\|
	callback_list != NULL);

	if (zio->io_error == 0) {
	arc_hdr_verify(hdr, zio->io_bp);
	} else {
	arc_hdr_set_flags(hdr, ARC_FLAG_IO_ERROR);
	if (hdr->b_l1hdr.b_state != arc_anon)
	arc_change_state(arc_anon, hdr, hash_lock);
	if (HDR_IN_HASH_TABLE(hdr))
	buf_hash_remove(hdr);
	freeable = zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt);
	}

	/*
	* Broadcast before we drop the hash_lock to avoid the possibility
	* that the hdr (and hence the cv) might be freed before we get to
	* the cv_broadcast().
	*/
	cv_broadcast(&hdr->b_l1hdr.b_cv);

	if (hash_lock != NULL) {
	mutex_exit(hash_lock);
	} else {
	/*
	* This block was freed while we waited for the read to
	* complete. It has been removed from the hash table and
	* moved to the anonymous state (so that it won't show up
	* in the cache).
	*/
	ASSERT3P(hdr->b_l1hdr.b_state, ==, arc_anon);
	freeable = zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt);
	}

	/* execute each callback and free its structure */
	while ((acb = callback_list) != NULL) {
	if (acb->acb_done != NULL) {
	if (zio->io_error != 0 && acb->acb_buf != NULL) {
	/*
	* If arc_buf_alloc_impl() fails during
	* decompression, the buf will still be
	* allocated, and needs to be freed here.
	*/
	arc_buf_destroy(acb->acb_buf,
	acb->acb_private);
	acb->acb_buf = NULL;
	}
	acb->acb_done(zio, &zio->io_bookmark, zio->io_bp,
	acb->acb_buf, acb->acb_private);
	}

	if (acb->acb_zio_dummy != NULL) {
	acb->acb_zio_dummy->io_error = zio->io_error;
	zio_nowait(acb->acb_zio_dummy);
	}

	callback_list = acb->acb_next;
	kmem_free(acb, sizeof (arc_callback_t));
	}

	if (freeable)
	arc_hdr_destroy(hdr);
	}

	/*
	* "Read" the block at the specified DVA (in bp) via the
	* cache. If the block is found in the cache, invoke the provided
	* callback immediately and return. Note that the `zio' parameter
	* in the callback will be NULL in this case, since no IO was
	* required. If the block is not in the cache pass the read request
	* on to the spa with a substitute callback function, so that the
	* requested block will be added to the cache.
	*
	* If a read request arrives for a block that has a read in-progress,
	* either wait for the in-progress read to complete (and return the
	* results); or, if this is a read with a "done" func, add a record
	* to the read to invoke the "done" func when the read completes,
	* and return; or just return.
	*
	* arc_read_done() will invoke all the requested "done" functions
	* for readers of this block.
	*/
	int
	arc_read(zio_t pio, spa_t spa, const blkptr_t *bp,
	arc_read_done_func_t done, void private, zio_priority_t priority,
	int zio_flags, arc_flags_t arc_flags, const zbookmark_phys_t zb)
	{
	arc_buf_hdr_t *hdr = NULL;
	kmutex_t *hash_lock = NULL;
	zio_t *rzio;
	uint64_t guid = spa_load_guid(spa);
	boolean_t compressed_read = (zio_flags & ZIO_FLAG_RAW_COMPRESS) != 0;
	boolean_t encrypted_read = BP_IS_ENCRYPTED(bp) &&
	(zio_flags & ZIO_FLAG_RAW_ENCRYPT) != 0;
	boolean_t noauth_read = BP_IS_AUTHENTICATED(bp) &&
	(zio_flags & ZIO_FLAG_RAW_ENCRYPT) != 0;
	boolean_t embedded_bp = !!BP_IS_EMBEDDED(bp);
	boolean_t no_buf = *arc_flags & ARC_FLAG_NO_BUF;
	int rc = 0;

	ASSERT(!embedded_bp \|\|
	BPE_GET_ETYPE(bp) == BP_EMBEDDED_TYPE_DATA);
	ASSERT(!BP_IS_HOLE(bp));
	ASSERT(!BP_IS_REDACTED(bp));

	/*
	* Normally SPL_FSTRANS will already be set since kernel threads which
	* expect to call the DMU interfaces will set it when created. System
	* calls are similarly handled by setting/cleaning the bit in the
	* registered callback (module/os/.../zfs/zpl_*).
	*
	* External consumers such as Lustre which call the exported DMU
	* interfaces may not have set SPL_FSTRANS. To avoid a deadlock
	* on the hash_lock always set and clear the bit.
	*/
	fstrans_cookie_t cookie = spl_fstrans_mark();
	top:
	if (!embedded_bp) {
	/*
	* Embedded BP's have no DVA and require no I/O to "read".
	* Create an anonymous arc buf to back it.
	*/
	hdr = buf_hash_find(guid, bp, &hash_lock);
	}

	/*
	* Determine if we have an L1 cache hit or a cache miss. For simplicity
	* we maintain encrypted data separately from compressed / uncompressed
	* data. If the user is requesting raw encrypted data and we don't have
	* that in the header we will read from disk to guarantee that we can
	* get it even if the encryption keys aren't loaded.
	*/
	if (hdr != NULL && HDR_HAS_L1HDR(hdr) && (HDR_HAS_RABD(hdr) \|\|
	(hdr->b_l1hdr.b_pabd != NULL && !encrypted_read))) {
	arc_buf_t *buf = NULL;
	*arc_flags \|= ARC_FLAG_CACHED;

	if (HDR_IO_IN_PROGRESS(hdr)) {
	zio_t *head_zio = hdr->b_l1hdr.b_acb->acb_zio_head;

	if (*arc_flags & ARC_FLAG_CACHED_ONLY) {
	mutex_exit(hash_lock);
	ARCSTAT_BUMP(arcstat_cached_only_in_progress);
	rc = SET_ERROR(ENOENT);
	goto out;
	}

	ASSERT3P(head_zio, !=, NULL);
	if ((hdr->b_flags & ARC_FLAG_PRIO_ASYNC_READ) &&
	priority == ZIO_PRIORITY_SYNC_READ) {
	/*
	* This is a sync read that needs to wait for
	* an in-flight async read. Request that the
	* zio have its priority upgraded.
	*/
	zio_change_priority(head_zio, priority);
	DTRACE_PROBE1(arc__async__upgrade__sync,
	arc_buf_hdr_t *, hdr);
	ARCSTAT_BUMP(arcstat_async_upgrade_sync);
	}
	if (hdr->b_flags & ARC_FLAG_PREDICTIVE_PREFETCH) {
	arc_hdr_clear_flags(hdr,
	ARC_FLAG_PREDICTIVE_PREFETCH);
	}

	if (*arc_flags & ARC_FLAG_WAIT) {
	cv_wait(&hdr->b_l1hdr.b_cv, hash_lock);
	mutex_exit(hash_lock);
	goto top;
	}
	ASSERT(*arc_flags & ARC_FLAG_NOWAIT);

	if (done) {
	arc_callback_t *acb = NULL;

	acb = kmem_zalloc(sizeof (arc_callback_t),
	KM_SLEEP);
	acb->acb_done = done;
	acb->acb_private = private;
	acb->acb_compressed = compressed_read;
	acb->acb_encrypted = encrypted_read;
	acb->acb_noauth = noauth_read;
	acb->acb_nobuf = no_buf;
	acb->acb_zb = *zb;
	if (pio != NULL)
	acb->acb_zio_dummy = zio_null(pio,
	spa, NULL, NULL, NULL, zio_flags);

	ASSERT3P(acb->acb_done, !=, NULL);
	acb->acb_zio_head = head_zio;
	acb->acb_next = hdr->b_l1hdr.b_acb;
	hdr->b_l1hdr.b_acb = acb;
	}
	mutex_exit(hash_lock);
	goto out;
	}

	ASSERT(hdr->b_l1hdr.b_state == arc_mru \|\|
	hdr->b_l1hdr.b_state == arc_mfu);

	if (done && !no_buf) {
	if (hdr->b_flags & ARC_FLAG_PREDICTIVE_PREFETCH) {
	/*
	* This is a demand read which does not have to
	* wait for i/o because we did a predictive
	* prefetch i/o for it, which has completed.
	*/
	DTRACE_PROBE1(
	arc__demand__hit__predictive__prefetch,
	arc_buf_hdr_t *, hdr);
	ARCSTAT_BUMP(
	arcstat_demand_hit_predictive_prefetch);
	arc_hdr_clear_flags(hdr,
	ARC_FLAG_PREDICTIVE_PREFETCH);
	}

	if (hdr->b_flags & ARC_FLAG_PRESCIENT_PREFETCH) {
	ARCSTAT_BUMP(
	arcstat_demand_hit_prescient_prefetch);
	arc_hdr_clear_flags(hdr,
	ARC_FLAG_PRESCIENT_PREFETCH);
	}

	ASSERT(!embedded_bp \|\| !BP_IS_HOLE(bp));

	/* Get a buf with the desired data in it. */
	rc = arc_buf_alloc_impl(hdr, spa, zb, private,
	encrypted_read, compressed_read, noauth_read,
	B_TRUE, &buf);
	if (rc == ECKSUM) {
	/*
	* Convert authentication and decryption errors
	* to EIO (and generate an ereport if needed)
	* before leaving the ARC.
	*/
	rc = SET_ERROR(EIO);
	if ((zio_flags & ZIO_FLAG_SPECULATIVE) == 0) {
	spa_log_error(spa, zb);
	(void) zfs_ereport_post(
	FM_EREPORT_ZFS_AUTHENTICATION,
	spa, NULL, zb, NULL, 0);
	}
	}
	if (rc != 0) {
	(void) remove_reference(hdr, hash_lock,
	private);
	arc_buf_destroy_impl(buf);
	buf = NULL;
	}

	/* assert any errors weren't due to unloaded keys */
	ASSERT((zio_flags & ZIO_FLAG_SPECULATIVE) \|\|
	rc != EACCES);
	} else if (*arc_flags & ARC_FLAG_PREFETCH &&
	zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt)) {
	if (HDR_HAS_L2HDR(hdr))
	l2arc_hdr_arcstats_decrement_state(hdr);
	arc_hdr_set_flags(hdr, ARC_FLAG_PREFETCH);
	if (HDR_HAS_L2HDR(hdr))
	l2arc_hdr_arcstats_increment_state(hdr);
	}
	DTRACE_PROBE1(arc__hit, arc_buf_hdr_t *, hdr);
	arc_access(hdr, hash_lock);
	if (*arc_flags & ARC_FLAG_PRESCIENT_PREFETCH)
	arc_hdr_set_flags(hdr, ARC_FLAG_PRESCIENT_PREFETCH);
	if (*arc_flags & ARC_FLAG_L2CACHE)
	arc_hdr_set_flags(hdr, ARC_FLAG_L2CACHE);
	mutex_exit(hash_lock);
	ARCSTAT_BUMP(arcstat_hits);
	ARCSTAT_CONDSTAT(!HDR_PREFETCH(hdr),
	demand, prefetch, !HDR_ISTYPE_METADATA(hdr),
	data, metadata, hits);

	if (done)
	done(NULL, zb, bp, buf, private);
	} else {
	uint64_t lsize = BP_GET_LSIZE(bp);
	uint64_t psize = BP_GET_PSIZE(bp);
	arc_callback_t *acb;
	vdev_t *vd = NULL;
	uint64_t addr = 0;
	boolean_t devw = B_FALSE;
	uint64_t size;
	abd_t *hdr_abd;
	int alloc_flags = encrypted_read ? ARC_HDR_ALLOC_RDATA : 0;

	if (*arc_flags & ARC_FLAG_CACHED_ONLY) {
	rc = SET_ERROR(ENOENT);
	if (hash_lock != NULL)
	mutex_exit(hash_lock);
	goto out;
	}

	/*
	* Gracefully handle a damaged logical block size as a
	* checksum error.
	*/
	if (lsize > spa_maxblocksize(spa)) {
	rc = SET_ERROR(ECKSUM);
	if (hash_lock != NULL)
	mutex_exit(hash_lock);
	goto out;
	}

	if (hdr == NULL) {
	/*
	* This block is not in the cache or it has
	* embedded data.
	*/
	arc_buf_hdr_t *exists = NULL;
	arc_buf_contents_t type = BP_GET_BUFC_TYPE(bp);
	hdr = arc_hdr_alloc(spa_load_guid(spa), psize, lsize,
	BP_IS_PROTECTED(bp), BP_GET_COMPRESS(bp), 0, type,
	encrypted_read);

	if (!embedded_bp) {
	hdr->b_dva = *BP_IDENTITY(bp);
	hdr->b_birth = BP_PHYSICAL_BIRTH(bp);
	exists = buf_hash_insert(hdr, &hash_lock);
	}
	if (exists != NULL) {
	/* somebody beat us to the hash insert */
	mutex_exit(hash_lock);
	buf_discard_identity(hdr);
	arc_hdr_destroy(hdr);
	goto top; /* restart the IO request */
	}
	} else {
	/*
	* This block is in the ghost cache or encrypted data
	* was requested and we didn't have it. If it was
	* L2-only (and thus didn't have an L1 hdr),
	* we realloc the header to add an L1 hdr.
	*/
	if (!HDR_HAS_L1HDR(hdr)) {
	hdr = arc_hdr_realloc(hdr, hdr_l2only_cache,
	hdr_full_cache);
	}

	if (GHOST_STATE(hdr->b_l1hdr.b_state)) {
	ASSERT3P(hdr->b_l1hdr.b_pabd, ==, NULL);
	ASSERT(!HDR_HAS_RABD(hdr));
	ASSERT(!HDR_IO_IN_PROGRESS(hdr));
	ASSERT0(zfs_refcount_count(
	&hdr->b_l1hdr.b_refcnt));
	ASSERT3P(hdr->b_l1hdr.b_buf, ==, NULL);
	ASSERT3P(hdr->b_l1hdr.b_freeze_cksum, ==, NULL);
	} else if (HDR_IO_IN_PROGRESS(hdr)) {
	/*
	* If this header already had an IO in progress
	* and we are performing another IO to fetch
	* encrypted data we must wait until the first
	* IO completes so as not to confuse
	* arc_read_done(). This should be very rare
	* and so the performance impact shouldn't
	* matter.
	*/
	cv_wait(&hdr->b_l1hdr.b_cv, hash_lock);
	mutex_exit(hash_lock);
	goto top;
	}

	/*
	* This is a delicate dance that we play here.
	* This hdr might be in the ghost list so we access
	* it to move it out of the ghost list before we
	* initiate the read. If it's a prefetch then
	* it won't have a callback so we'll remove the
	* reference that arc_buf_alloc_impl() created. We
	* do this after we've called arc_access() to
	* avoid hitting an assert in remove_reference().
	*/
	arc_adapt(arc_hdr_size(hdr), hdr->b_l1hdr.b_state);
	arc_access(hdr, hash_lock);
	arc_hdr_alloc_abd(hdr, alloc_flags);
	}

	if (encrypted_read) {
	ASSERT(HDR_HAS_RABD(hdr));
	size = HDR_GET_PSIZE(hdr);
	hdr_abd = hdr->b_crypt_hdr.b_rabd;
	zio_flags \|= ZIO_FLAG_RAW;
	} else {
	ASSERT3P(hdr->b_l1hdr.b_pabd, !=, NULL);
	size = arc_hdr_size(hdr);
	hdr_abd = hdr->b_l1hdr.b_pabd;

	if (arc_hdr_get_compress(hdr) != ZIO_COMPRESS_OFF) {
	zio_flags \|= ZIO_FLAG_RAW_COMPRESS;
	}

	/*
	* For authenticated bp's, we do not ask the ZIO layer
	* to authenticate them since this will cause the entire
	* IO to fail if the key isn't loaded. Instead, we
	* defer authentication until arc_buf_fill(), which will
	* verify the data when the key is available.
	*/
	if (BP_IS_AUTHENTICATED(bp))
	zio_flags \|= ZIO_FLAG_RAW_ENCRYPT;
	}

	if (*arc_flags & ARC_FLAG_PREFETCH &&
	zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt)) {
	if (HDR_HAS_L2HDR(hdr))
	l2arc_hdr_arcstats_decrement_state(hdr);
	arc_hdr_set_flags(hdr, ARC_FLAG_PREFETCH);
	if (HDR_HAS_L2HDR(hdr))
	l2arc_hdr_arcstats_increment_state(hdr);
	}
	if (*arc_flags & ARC_FLAG_PRESCIENT_PREFETCH)
	arc_hdr_set_flags(hdr, ARC_FLAG_PRESCIENT_PREFETCH);
	if (*arc_flags & ARC_FLAG_L2CACHE)
	arc_hdr_set_flags(hdr, ARC_FLAG_L2CACHE);
	if (BP_IS_AUTHENTICATED(bp))
	arc_hdr_set_flags(hdr, ARC_FLAG_NOAUTH);
	if (BP_GET_LEVEL(bp) > 0)
	arc_hdr_set_flags(hdr, ARC_FLAG_INDIRECT);
	if (*arc_flags & ARC_FLAG_PREDICTIVE_PREFETCH)
	arc_hdr_set_flags(hdr, ARC_FLAG_PREDICTIVE_PREFETCH);
	ASSERT(!GHOST_STATE(hdr->b_l1hdr.b_state));

	acb = kmem_zalloc(sizeof (arc_callback_t), KM_SLEEP);
	acb->acb_done = done;
	acb->acb_private = private;
	acb->acb_compressed = compressed_read;
	acb->acb_encrypted = encrypted_read;
	acb->acb_noauth = noauth_read;
	acb->acb_zb = *zb;

	ASSERT3P(hdr->b_l1hdr.b_acb, ==, NULL);
	hdr->b_l1hdr.b_acb = acb;
	arc_hdr_set_flags(hdr, ARC_FLAG_IO_IN_PROGRESS);

	if (HDR_HAS_L2HDR(hdr) &&
	(vd = hdr->b_l2hdr.b_dev->l2ad_vdev) != NULL) {
	devw = hdr->b_l2hdr.b_dev->l2ad_writing;
	addr = hdr->b_l2hdr.b_daddr;
	/*
	* Lock out L2ARC device removal.
	*/
	if (vdev_is_dead(vd) \|\|
	!spa_config_tryenter(spa, SCL_L2ARC, vd, RW_READER))
	vd = NULL;
	}

	/*
	* We count both async reads and scrub IOs as asynchronous so
	* that both can be upgraded in the event of a cache hit while
	* the read IO is still in-flight.
	*/
	if (priority == ZIO_PRIORITY_ASYNC_READ \|\|
	priority == ZIO_PRIORITY_SCRUB)
	arc_hdr_set_flags(hdr, ARC_FLAG_PRIO_ASYNC_READ);
	else
	arc_hdr_clear_flags(hdr, ARC_FLAG_PRIO_ASYNC_READ);

	/*
	* At this point, we have a level 1 cache miss or a blkptr
	* with embedded data. Try again in L2ARC if possible.
	*/
	ASSERT3U(HDR_GET_LSIZE(hdr), ==, lsize);

	/*
	* Skip ARC stat bump for block pointers with embedded
	* data. The data are read from the blkptr itself via
	* decode_embedded_bp_compressed().
	*/
	if (!embedded_bp) {
	DTRACE_PROBE4(arc__miss, arc_buf_hdr_t *, hdr,
	blkptr_t *, bp, uint64_t, lsize,
	zbookmark_phys_t *, zb);
	ARCSTAT_BUMP(arcstat_misses);
	ARCSTAT_CONDSTAT(!HDR_PREFETCH(hdr),
	demand, prefetch, !HDR_ISTYPE_METADATA(hdr), data,
	metadata, misses);
	zfs_racct_read(size, 1);
	}

	/* Check if the spa even has l2 configured */
	const boolean_t spa_has_l2 = l2arc_ndev != 0 &&
	spa->spa_l2cache.sav_count > 0;

	if (vd != NULL && spa_has_l2 && !(l2arc_norw && devw)) {
	/*
	* Read from the L2ARC if the following are true:
	* 1. The L2ARC vdev was previously cached.
	* 2. This buffer still has L2ARC metadata.
	* 3. This buffer isn't currently writing to the L2ARC.
	* 4. The L2ARC entry wasn't evicted, which may
	* also have invalidated the vdev.
	* 5. This isn't prefetch or l2arc_noprefetch is 0.
	*/
	if (HDR_HAS_L2HDR(hdr) &&
	!HDR_L2_WRITING(hdr) && !HDR_L2_EVICTED(hdr) &&
	!(l2arc_noprefetch && HDR_PREFETCH(hdr))) {
	l2arc_read_callback_t *cb;
	abd_t *abd;
	uint64_t asize;

	DTRACE_PROBE1(l2arc__hit, arc_buf_hdr_t *, hdr);
	ARCSTAT_BUMP(arcstat_l2_hits);
	atomic_inc_32(&hdr->b_l2hdr.b_hits);

	cb = kmem_zalloc(sizeof (l2arc_read_callback_t),
	KM_SLEEP);
	cb->l2rcb_hdr = hdr;
	cb->l2rcb_bp = *bp;
	cb->l2rcb_zb = *zb;
	cb->l2rcb_flags = zio_flags;

	/*
	* When Compressed ARC is disabled, but the
	* L2ARC block is compressed, arc_hdr_size()
	* will have returned LSIZE rather than PSIZE.
	*/
	if (HDR_GET_COMPRESS(hdr) != ZIO_COMPRESS_OFF &&
	!HDR_COMPRESSION_ENABLED(hdr) &&
	HDR_GET_PSIZE(hdr) != 0) {
	size = HDR_GET_PSIZE(hdr);
	}

	asize = vdev_psize_to_asize(vd, size);
	if (asize != size) {
	abd = abd_alloc_for_io(asize,
	HDR_ISTYPE_METADATA(hdr));
	cb->l2rcb_abd = abd;
	} else {
	abd = hdr_abd;
	}

	ASSERT(addr >= VDEV_LABEL_START_SIZE &&
	addr + asize <= vd->vdev_psize -
	VDEV_LABEL_END_SIZE);

	/*
	* l2arc read. The SCL_L2ARC lock will be
	* released by l2arc_read_done().
	* Issue a null zio if the underlying buffer
	* was squashed to zero size by compression.
	*/
	ASSERT3U(arc_hdr_get_compress(hdr), !=,
	ZIO_COMPRESS_EMPTY);
	rzio = zio_read_phys(pio, vd, addr,
	asize, abd,
	ZIO_CHECKSUM_OFF,
	l2arc_read_done, cb, priority,
	zio_flags \| ZIO_FLAG_DONT_CACHE \|
	ZIO_FLAG_CANFAIL \|
	ZIO_FLAG_DONT_PROPAGATE \|
	ZIO_FLAG_DONT_RETRY, B_FALSE);
	acb->acb_zio_head = rzio;

	if (hash_lock != NULL)
	mutex_exit(hash_lock);

	DTRACE_PROBE2(l2arc__read, vdev_t *, vd,
	zio_t *, rzio);
	ARCSTAT_INCR(arcstat_l2_read_bytes,
	HDR_GET_PSIZE(hdr));

	if (*arc_flags & ARC_FLAG_NOWAIT) {
	zio_nowait(rzio);
	goto out;
	}

	ASSERT(*arc_flags & ARC_FLAG_WAIT);
	if (zio_wait(rzio) == 0)
	goto out;

	/* l2arc read error; goto zio_read() */
	if (hash_lock != NULL)
	mutex_enter(hash_lock);
	} else {
	DTRACE_PROBE1(l2arc__miss,
	arc_buf_hdr_t *, hdr);
	ARCSTAT_BUMP(arcstat_l2_misses);
	if (HDR_L2_WRITING(hdr))
	ARCSTAT_BUMP(arcstat_l2_rw_clash);
	spa_config_exit(spa, SCL_L2ARC, vd);
	}
	} else {
	if (vd != NULL)
	spa_config_exit(spa, SCL_L2ARC, vd);

	/*
	* Only a spa with l2 should contribute to l2
	* miss stats. (Including the case of having a
	* faulted cache device - that's also a miss.)
	*/
	if (spa_has_l2) {
	/*
	* Skip ARC stat bump for block pointers with
	* embedded data. The data are read from the
	* blkptr itself via
	* decode_embedded_bp_compressed().
	*/
	if (!embedded_bp) {
	DTRACE_PROBE1(l2arc__miss,
	arc_buf_hdr_t *, hdr);
	ARCSTAT_BUMP(arcstat_l2_misses);
	}
	}
	}

	rzio = zio_read(pio, spa, bp, hdr_abd, size,
	arc_read_done, hdr, priority, zio_flags, zb);
	acb->acb_zio_head = rzio;

	if (hash_lock != NULL)
	mutex_exit(hash_lock);

	if (*arc_flags & ARC_FLAG_WAIT) {
	rc = zio_wait(rzio);
	goto out;
	}

	ASSERT(*arc_flags & ARC_FLAG_NOWAIT);
	zio_nowait(rzio);
	}

	out:
	/* embedded bps don't actually go to disk */
	if (!embedded_bp)
	spa_read_history_add(spa, zb, *arc_flags);
	spl_fstrans_unmark(cookie);
	return (rc);
	}

	arc_prune_t *
	arc_add_prune_callback(arc_prune_func_t func, void private)
	{
	arc_prune_t *p;

	p = kmem_alloc(sizeof (*p), KM_SLEEP);
	p->p_pfunc = func;
	p->p_private = private;
	list_link_init(&p->p_node);
	zfs_refcount_create(&p->p_refcnt);

	mutex_enter(&arc_prune_mtx);
	zfs_refcount_add(&p->p_refcnt, &arc_prune_list);
	list_insert_head(&arc_prune_list, p);
	mutex_exit(&arc_prune_mtx);

	return (p);
	}

	void
	arc_remove_prune_callback(arc_prune_t *p)
	{
	boolean_t wait = B_FALSE;
	mutex_enter(&arc_prune_mtx);
	list_remove(&arc_prune_list, p);
	if (zfs_refcount_remove(&p->p_refcnt, &arc_prune_list) > 0)
	wait = B_TRUE;
	mutex_exit(&arc_prune_mtx);

	/* wait for arc_prune_task to finish */
	if (wait)
	taskq_wait_outstanding(arc_prune_taskq, 0);
	ASSERT0(zfs_refcount_count(&p->p_refcnt));
	zfs_refcount_destroy(&p->p_refcnt);
	kmem_free(p, sizeof (*p));
	}

	/*
	* Notify the arc that a block was freed, and thus will never be used again.
	*/
	void
	arc_freed(spa_t spa, const blkptr_t bp)
	{
	arc_buf_hdr_t *hdr;
	kmutex_t *hash_lock;
	uint64_t guid = spa_load_guid(spa);

	ASSERT(!BP_IS_EMBEDDED(bp));

	hdr = buf_hash_find(guid, bp, &hash_lock);
	if (hdr == NULL)
	return;

	/*
	* We might be trying to free a block that is still doing I/O
	* (i.e. prefetch) or has a reference (i.e. a dedup-ed,
	* dmu_sync-ed block). If this block is being prefetched, then it
	* would still have the ARC_FLAG_IO_IN_PROGRESS flag set on the hdr
	* until the I/O completes. A block may also have a reference if it is
	* part of a dedup-ed, dmu_synced write. The dmu_sync() function would
	* have written the new block to its final resting place on disk but
	* without the dedup flag set. This would have left the hdr in the MRU
	* state and discoverable. When the txg finally syncs it detects that
	* the block was overridden in open context and issues an override I/O.
	* Since this is a dedup block, the override I/O will determine if the
	* block is already in the DDT. If so, then it will replace the io_bp
	* with the bp from the DDT and allow the I/O to finish. When the I/O
	* reaches the done callback, dbuf_write_override_done, it will
	* check to see if the io_bp and io_bp_override are identical.
	* If they are not, then it indicates that the bp was replaced with
	* the bp in the DDT and the override bp is freed. This allows
	* us to arrive here with a reference on a block that is being
	* freed. So if we have an I/O in progress, or a reference to
	* this hdr, then we don't destroy the hdr.
	*/
	if (!HDR_HAS_L1HDR(hdr) \|\| (!HDR_IO_IN_PROGRESS(hdr) &&
	zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt))) {
	arc_change_state(arc_anon, hdr, hash_lock);
	arc_hdr_destroy(hdr);
	mutex_exit(hash_lock);
	} else {
	mutex_exit(hash_lock);
	}

	}

	/*
	* Release this buffer from the cache, making it an anonymous buffer. This
	* must be done after a read and prior to modifying the buffer contents.
	* If the buffer has more than one reference, we must make
	* a new hdr for the buffer.
	*/
	void
	arc_release(arc_buf_t buf, void tag)
	{
	arc_buf_hdr_t *hdr = buf->b_hdr;

	/*
	* It would be nice to assert that if its DMU metadata (level >
	* 0 \|\| it's the dnode file), then it must be syncing context.
	* But we don't know that information at this level.
	*/

	mutex_enter(&buf->b_evict_lock);

	ASSERT(HDR_HAS_L1HDR(hdr));

	/*
	* We don't grab the hash lock prior to this check, because if
	* the buffer's header is in the arc_anon state, it won't be
	* linked into the hash table.
	*/
	if (hdr->b_l1hdr.b_state == arc_anon) {
	mutex_exit(&buf->b_evict_lock);
	ASSERT(!HDR_IO_IN_PROGRESS(hdr));
	ASSERT(!HDR_IN_HASH_TABLE(hdr));
	ASSERT(!HDR_HAS_L2HDR(hdr));
	ASSERT(HDR_EMPTY(hdr));

	ASSERT3U(hdr->b_l1hdr.b_bufcnt, ==, 1);
	ASSERT3S(zfs_refcount_count(&hdr->b_l1hdr.b_refcnt), ==, 1);
	ASSERT(!list_link_active(&hdr->b_l1hdr.b_arc_node));

	hdr->b_l1hdr.b_arc_access = 0;

	/*
	* If the buf is being overridden then it may already
	* have a hdr that is not empty.
	*/
	buf_discard_identity(hdr);
	arc_buf_thaw(buf);

	return;
	}

	kmutex_t *hash_lock = HDR_LOCK(hdr);
	mutex_enter(hash_lock);

	/*
	* This assignment is only valid as long as the hash_lock is
	* held, we must be careful not to reference state or the
	* b_state field after dropping the lock.
	*/
	arc_state_t *state = hdr->b_l1hdr.b_state;
	ASSERT3P(hash_lock, ==, HDR_LOCK(hdr));
	ASSERT3P(state, !=, arc_anon);

	/* this buffer is not on any list */
	ASSERT3S(zfs_refcount_count(&hdr->b_l1hdr.b_refcnt), >, 0);

	if (HDR_HAS_L2HDR(hdr)) {
	mutex_enter(&hdr->b_l2hdr.b_dev->l2ad_mtx);

	/*
	* We have to recheck this conditional again now that
	* we're holding the l2ad_mtx to prevent a race with
	* another thread which might be concurrently calling
	* l2arc_evict(). In that case, l2arc_evict() might have
	* destroyed the header's L2 portion as we were waiting
	* to acquire the l2ad_mtx.
	*/
	if (HDR_HAS_L2HDR(hdr))
	arc_hdr_l2hdr_destroy(hdr);

	mutex_exit(&hdr->b_l2hdr.b_dev->l2ad_mtx);
	}

	/*
	* Do we have more than one buf?
	*/
	if (hdr->b_l1hdr.b_bufcnt > 1) {
	arc_buf_hdr_t *nhdr;
	uint64_t spa = hdr->b_spa;
	uint64_t psize = HDR_GET_PSIZE(hdr);
	uint64_t lsize = HDR_GET_LSIZE(hdr);
	boolean_t protected = HDR_PROTECTED(hdr);
	enum zio_compress compress = arc_hdr_get_compress(hdr);
	arc_buf_contents_t type = arc_buf_type(hdr);
	VERIFY3U(hdr->b_type, ==, type);

	ASSERT(hdr->b_l1hdr.b_buf != buf \|\| buf->b_next != NULL);
	(void) remove_reference(hdr, hash_lock, tag);

	if (arc_buf_is_shared(buf) && !ARC_BUF_COMPRESSED(buf)) {
	ASSERT3P(hdr->b_l1hdr.b_buf, !=, buf);
	ASSERT(ARC_BUF_LAST(buf));
	}

	/*
	* Pull the data off of this hdr and attach it to
	* a new anonymous hdr. Also find the last buffer
	* in the hdr's buffer list.
	*/
	arc_buf_t *lastbuf = arc_buf_remove(hdr, buf);
	ASSERT3P(lastbuf, !=, NULL);

	/*
	* If the current arc_buf_t and the hdr are sharing their data
	* buffer, then we must stop sharing that block.
	*/
	if (arc_buf_is_shared(buf)) {
	ASSERT3P(hdr->b_l1hdr.b_buf, !=, buf);
	VERIFY(!arc_buf_is_shared(lastbuf));

	/*
	* First, sever the block sharing relationship between
	* buf and the arc_buf_hdr_t.
	*/
	arc_unshare_buf(hdr, buf);

	/*
	* Now we need to recreate the hdr's b_pabd. Since we
	* have lastbuf handy, we try to share with it, but if
	* we can't then we allocate a new b_pabd and copy the
	* data from buf into it.
	*/
	if (arc_can_share(hdr, lastbuf)) {
	arc_share_buf(hdr, lastbuf);
	} else {
	arc_hdr_alloc_abd(hdr, ARC_HDR_DO_ADAPT);
	abd_copy_from_buf(hdr->b_l1hdr.b_pabd,
	buf->b_data, psize);
	}
	VERIFY3P(lastbuf->b_data, !=, NULL);
	} else if (HDR_SHARED_DATA(hdr)) {
	/*
	* Uncompressed shared buffers are always at the end
	* of the list. Compressed buffers don't have the
	* same requirements. This makes it hard to
	* simply assert that the lastbuf is shared so
	* we rely on the hdr's compression flags to determine
	* if we have a compressed, shared buffer.
	*/
	ASSERT(arc_buf_is_shared(lastbuf) \|\|
	arc_hdr_get_compress(hdr) != ZIO_COMPRESS_OFF);
	ASSERT(!ARC_BUF_SHARED(buf));
	}

	ASSERT(hdr->b_l1hdr.b_pabd != NULL \|\| HDR_HAS_RABD(hdr));
	ASSERT3P(state, !=, arc_l2c_only);

	(void) zfs_refcount_remove_many(&state->arcs_size,
	arc_buf_size(buf), buf);

	if (zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt)) {
	ASSERT3P(state, !=, arc_l2c_only);
	(void) zfs_refcount_remove_many(
	&state->arcs_esize[type],
	arc_buf_size(buf), buf);
	}

	hdr->b_l1hdr.b_bufcnt -= 1;
	if (ARC_BUF_ENCRYPTED(buf))
	hdr->b_crypt_hdr.b_ebufcnt -= 1;

	arc_cksum_verify(buf);
	arc_buf_unwatch(buf);

	/* if this is the last uncompressed buf free the checksum */
	if (!arc_hdr_has_uncompressed_buf(hdr))
	arc_cksum_free(hdr);

	mutex_exit(hash_lock);

	/*
	* Allocate a new hdr. The new hdr will contain a b_pabd
	* buffer which will be freed in arc_write().
	*/
	nhdr = arc_hdr_alloc(spa, psize, lsize, protected,
	compress, hdr->b_complevel, type, HDR_HAS_RABD(hdr));
	ASSERT3P(nhdr->b_l1hdr.b_buf, ==, NULL);
	ASSERT0(nhdr->b_l1hdr.b_bufcnt);
	ASSERT0(zfs_refcount_count(&nhdr->b_l1hdr.b_refcnt));
	VERIFY3U(nhdr->b_type, ==, type);
	ASSERT(!HDR_SHARED_DATA(nhdr));

	nhdr->b_l1hdr.b_buf = buf;
	nhdr->b_l1hdr.b_bufcnt = 1;
	if (ARC_BUF_ENCRYPTED(buf))
	nhdr->b_crypt_hdr.b_ebufcnt = 1;
	nhdr->b_l1hdr.b_mru_hits = 0;
	nhdr->b_l1hdr.b_mru_ghost_hits = 0;
	nhdr->b_l1hdr.b_mfu_hits = 0;
	nhdr->b_l1hdr.b_mfu_ghost_hits = 0;
	nhdr->b_l1hdr.b_l2_hits = 0;
	(void) zfs_refcount_add(&nhdr->b_l1hdr.b_refcnt, tag);
	buf->b_hdr = nhdr;

	mutex_exit(&buf->b_evict_lock);
	(void) zfs_refcount_add_many(&arc_anon->arcs_size,
	arc_buf_size(buf), buf);
	} else {
	mutex_exit(&buf->b_evict_lock);
	ASSERT(zfs_refcount_count(&hdr->b_l1hdr.b_refcnt) == 1);
	/* protected by hash lock, or hdr is on arc_anon */
	ASSERT(!multilist_link_active(&hdr->b_l1hdr.b_arc_node));
	ASSERT(!HDR_IO_IN_PROGRESS(hdr));
	hdr->b_l1hdr.b_mru_hits = 0;
	hdr->b_l1hdr.b_mru_ghost_hits = 0;
	hdr->b_l1hdr.b_mfu_hits = 0;
	hdr->b_l1hdr.b_mfu_ghost_hits = 0;
	hdr->b_l1hdr.b_l2_hits = 0;
	arc_change_state(arc_anon, hdr, hash_lock);
	hdr->b_l1hdr.b_arc_access = 0;

	mutex_exit(hash_lock);
	buf_discard_identity(hdr);
	arc_buf_thaw(buf);
	}
	}

	int
	arc_released(arc_buf_t *buf)
	{
	int released;

	mutex_enter(&buf->b_evict_lock);
	released = (buf->b_data != NULL &&
	buf->b_hdr->b_l1hdr.b_state == arc_anon);
	mutex_exit(&buf->b_evict_lock);
	return (released);
	}

	#ifdef ZFS_DEBUG
	int
	arc_referenced(arc_buf_t *buf)
	{
	int referenced;

	mutex_enter(&buf->b_evict_lock);
	referenced = (zfs_refcount_count(&buf->b_hdr->b_l1hdr.b_refcnt));
	mutex_exit(&buf->b_evict_lock);
	return (referenced);
	}
	#endif

	static void
	arc_write_ready(zio_t *zio)
	{
	arc_write_callback_t *callback = zio->io_private;
	arc_buf_t *buf = callback->awcb_buf;
	arc_buf_hdr_t *hdr = buf->b_hdr;
	blkptr_t *bp = zio->io_bp;
	uint64_t psize = BP_IS_HOLE(bp) ? 0 : BP_GET_PSIZE(bp);
	fstrans_cookie_t cookie = spl_fstrans_mark();

	ASSERT(HDR_HAS_L1HDR(hdr));
	ASSERT(!zfs_refcount_is_zero(&buf->b_hdr->b_l1hdr.b_refcnt));
	ASSERT(hdr->b_l1hdr.b_bufcnt > 0);

	/*
	* If we're reexecuting this zio because the pool suspended, then
	* cleanup any state that was previously set the first time the
	* callback was invoked.
	*/
	if (zio->io_flags & ZIO_FLAG_REEXECUTED) {
	arc_cksum_free(hdr);
	arc_buf_unwatch(buf);
	if (hdr->b_l1hdr.b_pabd != NULL) {
	if (arc_buf_is_shared(buf)) {
	arc_unshare_buf(hdr, buf);
	} else {
	arc_hdr_free_abd(hdr, B_FALSE);
	}
	}

	if (HDR_HAS_RABD(hdr))
	arc_hdr_free_abd(hdr, B_TRUE);
	}
	ASSERT3P(hdr->b_l1hdr.b_pabd, ==, NULL);
	ASSERT(!HDR_HAS_RABD(hdr));
	ASSERT(!HDR_SHARED_DATA(hdr));
	ASSERT(!arc_buf_is_shared(buf));

	callback->awcb_ready(zio, buf, callback->awcb_private);

	if (HDR_IO_IN_PROGRESS(hdr))
	ASSERT(zio->io_flags & ZIO_FLAG_REEXECUTED);

	arc_hdr_set_flags(hdr, ARC_FLAG_IO_IN_PROGRESS);

	if (BP_IS_PROTECTED(bp) != !!HDR_PROTECTED(hdr))
	hdr = arc_hdr_realloc_crypt(hdr, BP_IS_PROTECTED(bp));

	if (BP_IS_PROTECTED(bp)) {
	/* ZIL blocks are written through zio_rewrite */
	ASSERT3U(BP_GET_TYPE(bp), !=, DMU_OT_INTENT_LOG);
	ASSERT(HDR_PROTECTED(hdr));

	if (BP_SHOULD_BYTESWAP(bp)) {
	if (BP_GET_LEVEL(bp) > 0) {
	hdr->b_l1hdr.b_byteswap = DMU_BSWAP_UINT64;
	} else {
	hdr->b_l1hdr.b_byteswap =
	DMU_OT_BYTESWAP(BP_GET_TYPE(bp));
	}
	} else {
	hdr->b_l1hdr.b_byteswap = DMU_BSWAP_NUMFUNCS;
	}

	hdr->b_crypt_hdr.b_ot = BP_GET_TYPE(bp);
	hdr->b_crypt_hdr.b_dsobj = zio->io_bookmark.zb_objset;
	zio_crypt_decode_params_bp(bp, hdr->b_crypt_hdr.b_salt,
	hdr->b_crypt_hdr.b_iv);
	zio_crypt_decode_mac_bp(bp, hdr->b_crypt_hdr.b_mac);
	}

	/*
	* If this block was written for raw encryption but the zio layer
	* ended up only authenticating it, adjust the buffer flags now.
	*/
	if (BP_IS_AUTHENTICATED(bp) && ARC_BUF_ENCRYPTED(buf)) {
	arc_hdr_set_flags(hdr, ARC_FLAG_NOAUTH);
	buf->b_flags &= ~ARC_BUF_FLAG_ENCRYPTED;
	if (BP_GET_COMPRESS(bp) == ZIO_COMPRESS_OFF)
	buf->b_flags &= ~ARC_BUF_FLAG_COMPRESSED;
	} else if (BP_IS_HOLE(bp) && ARC_BUF_ENCRYPTED(buf)) {
	buf->b_flags &= ~ARC_BUF_FLAG_ENCRYPTED;
	buf->b_flags &= ~ARC_BUF_FLAG_COMPRESSED;
	}

	/* this must be done after the buffer flags are adjusted */
	arc_cksum_compute(buf);

	enum zio_compress compress;
	if (BP_IS_HOLE(bp) \|\| BP_IS_EMBEDDED(bp)) {
	compress = ZIO_COMPRESS_OFF;
	} else {
	ASSERT3U(HDR_GET_LSIZE(hdr), ==, BP_GET_LSIZE(bp));
	compress = BP_GET_COMPRESS(bp);
	}
	HDR_SET_PSIZE(hdr, psize);
	arc_hdr_set_compress(hdr, compress);
	hdr->b_complevel = zio->io_prop.zp_complevel;

	if (zio->io_error != 0 \|\| psize == 0)
	goto out;

	/*
	* Fill the hdr with data. If the buffer is encrypted we have no choice
	* but to copy the data into b_radb. If the hdr is compressed, the data
	* we want is available from the zio, otherwise we can take it from
	* the buf.
	*
	* We might be able to share the buf's data with the hdr here. However,
	* doing so would cause the ARC to be full of linear ABDs if we write a
	* lot of shareable data. As a compromise, we check whether scattered
	* ABDs are allowed, and assume that if they are then the user wants
	* the ARC to be primarily filled with them regardless of the data being
	* written. Therefore, if they're allowed then we allocate one and copy
	* the data into it; otherwise, we share the data directly if we can.
	*/
	if (ARC_BUF_ENCRYPTED(buf)) {
	ASSERT3U(psize, >, 0);
	ASSERT(ARC_BUF_COMPRESSED(buf));
	arc_hdr_alloc_abd(hdr, ARC_HDR_DO_ADAPT\|ARC_HDR_ALLOC_RDATA);
	abd_copy(hdr->b_crypt_hdr.b_rabd, zio->io_abd, psize);
	} else if (zfs_abd_scatter_enabled \|\| !arc_can_share(hdr, buf)) {
	/*
	* Ideally, we would always copy the io_abd into b_pabd, but the
	* user may have disabled compressed ARC, thus we must check the
	* hdr's compression setting rather than the io_bp's.
	*/
	if (BP_IS_ENCRYPTED(bp)) {
	ASSERT3U(psize, >, 0);
	arc_hdr_alloc_abd(hdr,
	ARC_HDR_DO_ADAPT\|ARC_HDR_ALLOC_RDATA);
	abd_copy(hdr->b_crypt_hdr.b_rabd, zio->io_abd, psize);
	} else if (arc_hdr_get_compress(hdr) != ZIO_COMPRESS_OFF &&
	!ARC_BUF_COMPRESSED(buf)) {
	ASSERT3U(psize, >, 0);
	arc_hdr_alloc_abd(hdr, ARC_HDR_DO_ADAPT);
	abd_copy(hdr->b_l1hdr.b_pabd, zio->io_abd, psize);
	} else {
	ASSERT3U(zio->io_orig_size, ==, arc_hdr_size(hdr));
	arc_hdr_alloc_abd(hdr, ARC_HDR_DO_ADAPT);
	abd_copy_from_buf(hdr->b_l1hdr.b_pabd, buf->b_data,
	arc_buf_size(buf));
	}
	} else {
	ASSERT3P(buf->b_data, ==, abd_to_buf(zio->io_orig_abd));
	ASSERT3U(zio->io_orig_size, ==, arc_buf_size(buf));
	ASSERT3U(hdr->b_l1hdr.b_bufcnt, ==, 1);

	arc_share_buf(hdr, buf);
	}

	out:
	arc_hdr_verify(hdr, bp);
	spl_fstrans_unmark(cookie);
	}

	static void
	arc_write_children_ready(zio_t *zio)
	{
	arc_write_callback_t *callback = zio->io_private;
	arc_buf_t *buf = callback->awcb_buf;

	callback->awcb_children_ready(zio, buf, callback->awcb_private);
	}

	/*
	* The SPA calls this callback for each physical write that happens on behalf
	* of a logical write. See the comment in dbuf_write_physdone() for details.
	*/
	static void
	arc_write_physdone(zio_t *zio)
	{
	arc_write_callback_t *cb = zio->io_private;
	if (cb->awcb_physdone != NULL)
	cb->awcb_physdone(zio, cb->awcb_buf, cb->awcb_private);
	}

	static void
	arc_write_done(zio_t *zio)
	{
	arc_write_callback_t *callback = zio->io_private;
	arc_buf_t *buf = callback->awcb_buf;
	arc_buf_hdr_t *hdr = buf->b_hdr;

	ASSERT3P(hdr->b_l1hdr.b_acb, ==, NULL);

	if (zio->io_error == 0) {
	arc_hdr_verify(hdr, zio->io_bp);

	if (BP_IS_HOLE(zio->io_bp) \|\| BP_IS_EMBEDDED(zio->io_bp)) {
	buf_discard_identity(hdr);
	} else {
	hdr->b_dva = *BP_IDENTITY(zio->io_bp);
	hdr->b_birth = BP_PHYSICAL_BIRTH(zio->io_bp);
	}
	} else {
	ASSERT(HDR_EMPTY(hdr));
	}

	/*
	* If the block to be written was all-zero or compressed enough to be
	* embedded in the BP, no write was performed so there will be no
	* dva/birth/checksum. The buffer must therefore remain anonymous
	* (and uncached).
	*/
	if (!HDR_EMPTY(hdr)) {
	arc_buf_hdr_t *exists;
	kmutex_t *hash_lock;

	ASSERT3U(zio->io_error, ==, 0);

	arc_cksum_verify(buf);

	exists = buf_hash_insert(hdr, &hash_lock);
	if (exists != NULL) {
	/*
	* This can only happen if we overwrite for
	* sync-to-convergence, because we remove
	* buffers from the hash table when we arc_free().
	*/
	if (zio->io_flags & ZIO_FLAG_IO_REWRITE) {
	if (!BP_EQUAL(&zio->io_bp_orig, zio->io_bp))
	panic("bad overwrite, hdr=%p exists=%p",
	(void )hdr, (void )exists);
	ASSERT(zfs_refcount_is_zero(
	&exists->b_l1hdr.b_refcnt));
	arc_change_state(arc_anon, exists, hash_lock);
	arc_hdr_destroy(exists);
	mutex_exit(hash_lock);
	exists = buf_hash_insert(hdr, &hash_lock);
	ASSERT3P(exists, ==, NULL);
	} else if (zio->io_flags & ZIO_FLAG_NOPWRITE) {
	/* nopwrite */
	ASSERT(zio->io_prop.zp_nopwrite);
	if (!BP_EQUAL(&zio->io_bp_orig, zio->io_bp))
	panic("bad nopwrite, hdr=%p exists=%p",
	(void )hdr, (void )exists);
	} else {
	/* Dedup */
	ASSERT(hdr->b_l1hdr.b_bufcnt == 1);
	ASSERT(hdr->b_l1hdr.b_state == arc_anon);
	ASSERT(BP_GET_DEDUP(zio->io_bp));
	ASSERT(BP_GET_LEVEL(zio->io_bp) == 0);
	}
	}
	arc_hdr_clear_flags(hdr, ARC_FLAG_IO_IN_PROGRESS);
	/* if it's not anon, we are doing a scrub */
	if (exists == NULL && hdr->b_l1hdr.b_state == arc_anon)
	arc_access(hdr, hash_lock);
	mutex_exit(hash_lock);
	} else {
	arc_hdr_clear_flags(hdr, ARC_FLAG_IO_IN_PROGRESS);
	}

	ASSERT(!zfs_refcount_is_zero(&hdr->b_l1hdr.b_refcnt));
	callback->awcb_done(zio, buf, callback->awcb_private);

	abd_free(zio->io_abd);
	kmem_free(callback, sizeof (arc_write_callback_t));
	}

	zio_t *
	arc_write(zio_t pio, spa_t spa, uint64_t txg,
	blkptr_t bp, arc_buf_t buf, boolean_t l2arc,
	const zio_prop_t zp, arc_write_done_func_t ready,
	arc_write_done_func_t children_ready, arc_write_done_func_t physdone,
	arc_write_done_func_t done, void private, zio_priority_t priority,
	int zio_flags, const zbookmark_phys_t *zb)
	{
	arc_buf_hdr_t *hdr = buf->b_hdr;
	arc_write_callback_t *callback;
	zio_t *zio;
	zio_prop_t localprop = *zp;

	ASSERT3P(ready, !=, NULL);
	ASSERT3P(done, !=, NULL);
	ASSERT(!HDR_IO_ERROR(hdr));
	ASSERT(!HDR_IO_IN_PROGRESS(hdr));
	ASSERT3P(hdr->b_l1hdr.b_acb, ==, NULL);
	ASSERT3U(hdr->b_l1hdr.b_bufcnt, >, 0);
	if (l2arc)
	arc_hdr_set_flags(hdr, ARC_FLAG_L2CACHE);

	if (ARC_BUF_ENCRYPTED(buf)) {
	ASSERT(ARC_BUF_COMPRESSED(buf));
	localprop.zp_encrypt = B_TRUE;
	localprop.zp_compress = HDR_GET_COMPRESS(hdr);
	localprop.zp_complevel = hdr->b_complevel;
	localprop.zp_byteorder =
	(hdr->b_l1hdr.b_byteswap == DMU_BSWAP_NUMFUNCS) ?
	ZFS_HOST_BYTEORDER : !ZFS_HOST_BYTEORDER;
	bcopy(hdr->b_crypt_hdr.b_salt, localprop.zp_salt,
	ZIO_DATA_SALT_LEN);
	bcopy(hdr->b_crypt_hdr.b_iv, localprop.zp_iv,
	ZIO_DATA_IV_LEN);
	bcopy(hdr->b_crypt_hdr.b_mac, localprop.zp_mac,
	ZIO_DATA_MAC_LEN);
	if (DMU_OT_IS_ENCRYPTED(localprop.zp_type)) {
	localprop.zp_nopwrite = B_FALSE;
	localprop.zp_copies =
	MIN(localprop.zp_copies, SPA_DVAS_PER_BP - 1);
	}
	zio_flags \|= ZIO_FLAG_RAW;
	} else if (ARC_BUF_COMPRESSED(buf)) {
	ASSERT3U(HDR_GET_LSIZE(hdr), !=, arc_buf_size(buf));
	localprop.zp_compress = HDR_GET_COMPRESS(hdr);
	localprop.zp_complevel = hdr->b_complevel;
	zio_flags \|= ZIO_FLAG_RAW_COMPRESS;
	}
	callback = kmem_zalloc(sizeof (arc_write_callback_t), KM_SLEEP);
	callback->awcb_ready = ready;
	callback->awcb_children_ready = children_ready;
	callback->awcb_physdone = physdone;
	callback->awcb_done = done;
	callback->awcb_private = private;
	callback->awcb_buf = buf;

	/*
	* The hdr's b_pabd is now stale, free it now. A new data block
	* will be allocated when the zio pipeline calls arc_write_ready().
	*/
	if (hdr->b_l1hdr.b_pabd != NULL) {
	/*
	* If the buf is currently sharing the data block with
	* the hdr then we need to break that relationship here.
	* The hdr will remain with a NULL data pointer and the
	* buf will take sole ownership of the block.
	*/
	if (arc_buf_is_shared(buf)) {
	arc_unshare_buf(hdr, buf);
	} else {
	arc_hdr_free_abd(hdr, B_FALSE);
	}
	VERIFY3P(buf->b_data, !=, NULL);
	}

	if (HDR_HAS_RABD(hdr))
	arc_hdr_free_abd(hdr, B_TRUE);

	if (!(zio_flags & ZIO_FLAG_RAW))
	arc_hdr_set_compress(hdr, ZIO_COMPRESS_OFF);

	ASSERT(!arc_buf_is_shared(buf));
	ASSERT3P(hdr->b_l1hdr.b_pabd, ==, NULL);

	zio = zio_write(pio, spa, txg, bp,
	abd_get_from_buf(buf->b_data, HDR_GET_LSIZE(hdr)),
	HDR_GET_LSIZE(hdr), arc_buf_size(buf), &localprop, arc_write_ready,
	(children_ready != NULL) ? arc_write_children_ready : NULL,
	arc_write_physdone, arc_write_done, callback,
	priority, zio_flags, zb);

	return (zio);
	}

	void
	arc_tempreserve_clear(uint64_t reserve)
	{
	atomic_add_64(&arc_tempreserve, -reserve);
	ASSERT((int64_t)arc_tempreserve >= 0);
	}

	int
	arc_tempreserve_space(spa_t *spa, uint64_t reserve, uint64_t txg)
	{
	int error;
	uint64_t anon_size;

	if (!arc_no_grow &&
	reserve > arc_c/4 &&
	reserve * 4 > (2ULL << SPA_MAXBLOCKSHIFT))
	arc_c = MIN(arc_c_max, reserve * 4);

	/*
	* Throttle when the calculated memory footprint for the TXG
	* exceeds the target ARC size.
	*/
	if (reserve > arc_c) {
	DMU_TX_STAT_BUMP(dmu_tx_memory_reserve);
	return (SET_ERROR(ERESTART));
	}

	/*
	* Don't count loaned bufs as in flight dirty data to prevent long
	* network delays from blocking transactions that are ready to be
	* assigned to a txg.
	*/

	/* assert that it has not wrapped around */
	ASSERT3S(atomic_add_64_nv(&arc_loaned_bytes, 0), >=, 0);

	anon_size = MAX((int64_t)(zfs_refcount_count(&arc_anon->arcs_size) -
	arc_loaned_bytes), 0);

	/*
	* Writes will, almost always, require additional memory allocations
	* in order to compress/encrypt/etc the data. We therefore need to
	* make sure that there is sufficient available memory for this.
	*/
	error = arc_memory_throttle(spa, reserve, txg);
	if (error != 0)
	return (error);

	/*
	* Throttle writes when the amount of dirty data in the cache
	* gets too large. We try to keep the cache less than half full
	* of dirty blocks so that our sync times don't grow too large.
	*
	* In the case of one pool being built on another pool, we want
	* to make sure we don't end up throttling the lower (backing)
	* pool when the upper pool is the majority contributor to dirty
	* data. To insure we make forward progress during throttling, we
	* also check the current pool's net dirty data and only throttle
	* if it exceeds zfs_arc_pool_dirty_percent of the anonymous dirty
	* data in the cache.
	*
	* Note: if two requests come in concurrently, we might let them
	* both succeed, when one of them should fail. Not a huge deal.
	*/
	uint64_t total_dirty = reserve + arc_tempreserve + anon_size;
	uint64_t spa_dirty_anon = spa_dirty_data(spa);
	uint64_t rarc_c = arc_warm ? arc_c : arc_c_max;
	if (total_dirty > rarc_c * zfs_arc_dirty_limit_percent / 100 &&
	anon_size > rarc_c * zfs_arc_anon_limit_percent / 100 &&
	spa_dirty_anon > anon_size * zfs_arc_pool_dirty_percent / 100) {
	#ifdef ZFS_DEBUG
	uint64_t meta_esize = zfs_refcount_count(
	&arc_anon->arcs_esize[ARC_BUFC_METADATA]);
	uint64_t data_esize =
	zfs_refcount_count(&arc_anon->arcs_esize[ARC_BUFC_DATA]);
	dprintf("failing, arc_tempreserve=%lluK anon_meta=%lluK "
	"anon_data=%lluK tempreserve=%lluK rarc_c=%lluK\n",
	arc_tempreserve >> 10, meta_esize >> 10,
	data_esize >> 10, reserve >> 10, rarc_c >> 10);
	#endif
	DMU_TX_STAT_BUMP(dmu_tx_dirty_throttle);
	return (SET_ERROR(ERESTART));
	}
	atomic_add_64(&arc_tempreserve, reserve);
	return (0);
	}

	static void
	arc_kstat_update_state(arc_state_t state, kstat_named_t size,
	kstat_named_t evict_data, kstat_named_t evict_metadata)
	{
	size->value.ui64 = zfs_refcount_count(&state->arcs_size);
	evict_data->value.ui64 =
	zfs_refcount_count(&state->arcs_esize[ARC_BUFC_DATA]);
	evict_metadata->value.ui64 =
	zfs_refcount_count(&state->arcs_esize[ARC_BUFC_METADATA]);
	}

	static int
	arc_kstat_update(kstat_t *ksp, int rw)
	{
	arc_stats_t *as = ksp->ks_data;

	if (rw == KSTAT_WRITE) {
	return (SET_ERROR(EACCES));
	} else {
	arc_kstat_update_state(arc_anon,
	&as->arcstat_anon_size,
	&as->arcstat_anon_evictable_data,
	&as->arcstat_anon_evictable_metadata);
	arc_kstat_update_state(arc_mru,
	&as->arcstat_mru_size,
	&as->arcstat_mru_evictable_data,
	&as->arcstat_mru_evictable_metadata);
	arc_kstat_update_state(arc_mru_ghost,
	&as->arcstat_mru_ghost_size,
	&as->arcstat_mru_ghost_evictable_data,
	&as->arcstat_mru_ghost_evictable_metadata);
	arc_kstat_update_state(arc_mfu,
	&as->arcstat_mfu_size,
	&as->arcstat_mfu_evictable_data,
	&as->arcstat_mfu_evictable_metadata);
	arc_kstat_update_state(arc_mfu_ghost,
	&as->arcstat_mfu_ghost_size,
	&as->arcstat_mfu_ghost_evictable_data,
	&as->arcstat_mfu_ghost_evictable_metadata);

	ARCSTAT(arcstat_size) = aggsum_value(&arc_size);
	ARCSTAT(arcstat_meta_used) = aggsum_value(&arc_meta_used);
	ARCSTAT(arcstat_data_size) = aggsum_value(&astat_data_size);
	ARCSTAT(arcstat_metadata_size) =
	aggsum_value(&astat_metadata_size);
	ARCSTAT(arcstat_hdr_size) = aggsum_value(&astat_hdr_size);
	ARCSTAT(arcstat_l2_hdr_size) = aggsum_value(&astat_l2_hdr_size);
	ARCSTAT(arcstat_dbuf_size) = aggsum_value(&astat_dbuf_size);
	#if defined(COMPAT_FREEBSD11)
	ARCSTAT(arcstat_other_size) = aggsum_value(&astat_bonus_size) +
	aggsum_value(&astat_dnode_size) +
	aggsum_value(&astat_dbuf_size);
	#endif
	ARCSTAT(arcstat_dnode_size) = aggsum_value(&astat_dnode_size);
	ARCSTAT(arcstat_bonus_size) = aggsum_value(&astat_bonus_size);
	ARCSTAT(arcstat_abd_chunk_waste_size) =
	aggsum_value(&astat_abd_chunk_waste_size);

	as->arcstat_memory_all_bytes.value.ui64 =
	arc_all_memory();
	as->arcstat_memory_free_bytes.value.ui64 =
	arc_free_memory();
	as->arcstat_memory_available_bytes.value.i64 =
	arc_available_memory();
	}

	return (0);
	}

	/*
	* This function must return indices evenly distributed between all
	* sublists of the multilist. This is needed due to how the ARC eviction
	* code is laid out; arc_evict_state() assumes ARC buffers are evenly
	* distributed between all sublists and uses this assumption when
	* deciding which sublist to evict from and how much to evict from it.
	*/
	static unsigned int
	arc_state_multilist_index_func(multilist_t ml, void obj)
	{
	arc_buf_hdr_t *hdr = obj;

	/*
	* We rely on b_dva to generate evenly distributed index
	* numbers using buf_hash below. So, as an added precaution,
	* let's make sure we never add empty buffers to the arc lists.
	*/
	ASSERT(!HDR_EMPTY(hdr));

	/*
	* The assumption here, is the hash value for a given
	* arc_buf_hdr_t will remain constant throughout its lifetime
	* (i.e. its b_spa, b_dva, and b_birth fields don't change).
	* Thus, we don't need to store the header's sublist index
	* on insertion, as this index can be recalculated on removal.
	*
	* Also, the low order bits of the hash value are thought to be
	* distributed evenly. Otherwise, in the case that the multilist
	* has a power of two number of sublists, each sublists' usage
	* would not be evenly distributed.
	*/
	return (buf_hash(hdr->b_spa, &hdr->b_dva, hdr->b_birth) %
	multilist_get_num_sublists(ml));
	}

	#define WARN_IF_TUNING_IGNORED(tuning, value, do_warn) do { \
	if ((do_warn) && (tuning) && ((tuning) != (value))) { \
	cmn_err(CE_WARN, \
	"ignoring tunable %s (using %llu instead)", \
	(#tuning), (value)); \
	} \
	} while (0)

	/*
	* Called during module initialization and periodically thereafter to
	* apply reasonable changes to the exposed performance tunings. Can also be
	* called explicitly by param_set_arc_*() functions when ARC tunables are
	* updated manually. Non-zero zfs_* values which differ from the currently set
	* values will be applied.
	*/
	void
	arc_tuning_update(boolean_t verbose)
	{
	uint64_t allmem = arc_all_memory();
	unsigned long limit;

	/* Valid range: 32M - <arc_c_max> */
	if ((zfs_arc_min) && (zfs_arc_min != arc_c_min) &&
	(zfs_arc_min >= 2ULL << SPA_MAXBLOCKSHIFT) &&
	(zfs_arc_min <= arc_c_max)) {
	arc_c_min = zfs_arc_min;
	arc_c = MAX(arc_c, arc_c_min);
	}
	WARN_IF_TUNING_IGNORED(zfs_arc_min, arc_c_min, verbose);

	/* Valid range: 64M - <all physical memory> */
	if ((zfs_arc_max) && (zfs_arc_max != arc_c_max) &&
	(zfs_arc_max >= 64 << 20) && (zfs_arc_max < allmem) &&
	(zfs_arc_max > arc_c_min)) {
	arc_c_max = zfs_arc_max;
	arc_c = MIN(arc_c, arc_c_max);
	arc_p = (arc_c >> 1);
	if (arc_meta_limit > arc_c_max)
	arc_meta_limit = arc_c_max;
	if (arc_dnode_size_limit > arc_meta_limit)
	arc_dnode_size_limit = arc_meta_limit;
	}
	WARN_IF_TUNING_IGNORED(zfs_arc_max, arc_c_max, verbose);

	/* Valid range: 16M - <arc_c_max> */
	if ((zfs_arc_meta_min) && (zfs_arc_meta_min != arc_meta_min) &&
	(zfs_arc_meta_min >= 1ULL << SPA_MAXBLOCKSHIFT) &&
	(zfs_arc_meta_min <= arc_c_max)) {
	arc_meta_min = zfs_arc_meta_min;
	if (arc_meta_limit < arc_meta_min)
	arc_meta_limit = arc_meta_min;
	if (arc_dnode_size_limit < arc_meta_min)
	arc_dnode_size_limit = arc_meta_min;
	}
	WARN_IF_TUNING_IGNORED(zfs_arc_meta_min, arc_meta_min, verbose);

	/* Valid range: <arc_meta_min> - <arc_c_max> */
	limit = zfs_arc_meta_limit ? zfs_arc_meta_limit :
	MIN(zfs_arc_meta_limit_percent, 100) * arc_c_max / 100;
	if ((limit != arc_meta_limit) &&
	(limit >= arc_meta_min) &&
	(limit <= arc_c_max))
	arc_meta_limit = limit;
	WARN_IF_TUNING_IGNORED(zfs_arc_meta_limit, arc_meta_limit, verbose);

	/* Valid range: <arc_meta_min> - <arc_meta_limit> */
	limit = zfs_arc_dnode_limit ? zfs_arc_dnode_limit :
	MIN(zfs_arc_dnode_limit_percent, 100) * arc_meta_limit / 100;
	if ((limit != arc_dnode_size_limit) &&
	(limit >= arc_meta_min) &&
	(limit <= arc_meta_limit))
	arc_dnode_size_limit = limit;
	WARN_IF_TUNING_IGNORED(zfs_arc_dnode_limit, arc_dnode_size_limit,
	verbose);

	/* Valid range: 1 - N */
	if (zfs_arc_grow_retry)
	arc_grow_retry = zfs_arc_grow_retry;

	/* Valid range: 1 - N */
	if (zfs_arc_shrink_shift) {
	arc_shrink_shift = zfs_arc_shrink_shift;
	arc_no_grow_shift = MIN(arc_no_grow_shift, arc_shrink_shift -1);
	}

	/* Valid range: 1 - N */
	if (zfs_arc_p_min_shift)
	arc_p_min_shift = zfs_arc_p_min_shift;

	/* Valid range: 1 - N ms */
	if (zfs_arc_min_prefetch_ms)
	arc_min_prefetch_ms = zfs_arc_min_prefetch_ms;

	/* Valid range: 1 - N ms */
	if (zfs_arc_min_prescient_prefetch_ms) {
	arc_min_prescient_prefetch_ms =
	zfs_arc_min_prescient_prefetch_ms;
	}

	/* Valid range: 0 - 100 */
	if ((zfs_arc_lotsfree_percent >= 0) &&
	(zfs_arc_lotsfree_percent <= 100))
	arc_lotsfree_percent = zfs_arc_lotsfree_percent;
	WARN_IF_TUNING_IGNORED(zfs_arc_lotsfree_percent, arc_lotsfree_percent,
	verbose);

	/* Valid range: 0 - <all physical memory> */
	if ((zfs_arc_sys_free) && (zfs_arc_sys_free != arc_sys_free))
	arc_sys_free = MIN(MAX(zfs_arc_sys_free, 0), allmem);
	WARN_IF_TUNING_IGNORED(zfs_arc_sys_free, arc_sys_free, verbose);
	}

	static void
	arc_state_init(void)
	{
	arc_anon = &ARC_anon;
	arc_mru = &ARC_mru;
	arc_mru_ghost = &ARC_mru_ghost;
	arc_mfu = &ARC_mfu;
	arc_mfu_ghost = &ARC_mfu_ghost;
	arc_l2c_only = &ARC_l2c_only;

	arc_mru->arcs_list[ARC_BUFC_METADATA] =
	multilist_create(sizeof (arc_buf_hdr_t),
	offsetof(arc_buf_hdr_t, b_l1hdr.b_arc_node),
	arc_state_multilist_index_func);
	arc_mru->arcs_list[ARC_BUFC_DATA] =
	multilist_create(sizeof (arc_buf_hdr_t),
	offsetof(arc_buf_hdr_t, b_l1hdr.b_arc_node),
	arc_state_multilist_index_func);
	arc_mru_ghost->arcs_list[ARC_BUFC_METADATA] =
	multilist_create(sizeof (arc_buf_hdr_t),
	offsetof(arc_buf_hdr_t, b_l1hdr.b_arc_node),
	arc_state_multilist_index_func);
	arc_mru_ghost->arcs_list[ARC_BUFC_DATA] =
	multilist_create(sizeof (arc_buf_hdr_t),
	offsetof(arc_buf_hdr_t, b_l1hdr.b_arc_node),
	arc_state_multilist_index_func);
	arc_mfu->arcs_list[ARC_BUFC_METADATA] =
	multilist_create(sizeof (arc_buf_hdr_t),
	offsetof(arc_buf_hdr_t, b_l1hdr.b_arc_node),
	arc_state_multilist_index_func);
	arc_mfu->arcs_list[ARC_BUFC_DATA] =
	multilist_create(sizeof (arc_buf_hdr_t),
	offsetof(arc_buf_hdr_t, b_l1hdr.b_arc_node),
	arc_state_multilist_index_func);
	arc_mfu_ghost->arcs_list[ARC_BUFC_METADATA] =
	multilist_create(sizeof (arc_buf_hdr_t),
	offsetof(arc_buf_hdr_t, b_l1hdr.b_arc_node),
	arc_state_multilist_index_func);
	arc_mfu_ghost->arcs_list[ARC_BUFC_DATA] =
	multilist_create(sizeof (arc_buf_hdr_t),
	offsetof(arc_buf_hdr_t, b_l1hdr.b_arc_node),
	arc_state_multilist_index_func);
	arc_l2c_only->arcs_list[ARC_BUFC_METADATA] =
	multilist_create(sizeof (arc_buf_hdr_t),
	offsetof(arc_buf_hdr_t, b_l1hdr.b_arc_node),
	arc_state_multilist_index_func);
	arc_l2c_only->arcs_list[ARC_BUFC_DATA] =
	multilist_create(sizeof (arc_buf_hdr_t),
	offsetof(arc_buf_hdr_t, b_l1hdr.b_arc_node),
	arc_state_multilist_index_func);

	zfs_refcount_create(&arc_anon->arcs_esize[ARC_BUFC_METADATA]);
	zfs_refcount_create(&arc_anon->arcs_esize[ARC_BUFC_DATA]);
	zfs_refcount_create(&arc_mru->arcs_esize[ARC_BUFC_METADATA]);
	zfs_refcount_create(&arc_mru->arcs_esize[ARC_BUFC_DATA]);
	zfs_refcount_create(&arc_mru_ghost->arcs_esize[ARC_BUFC_METADATA]);
	zfs_refcount_create(&arc_mru_ghost->arcs_esize[ARC_BUFC_DATA]);
	zfs_refcount_create(&arc_mfu->arcs_esize[ARC_BUFC_METADATA]);
	zfs_refcount_create(&arc_mfu->arcs_esize[ARC_BUFC_DATA]);
	zfs_refcount_create(&arc_mfu_ghost->arcs_esize[ARC_BUFC_METADATA]);
	zfs_refcount_create(&arc_mfu_ghost->arcs_esize[ARC_BUFC_DATA]);
	zfs_refcount_create(&arc_l2c_only->arcs_esize[ARC_BUFC_METADATA]);
	zfs_refcount_create(&arc_l2c_only->arcs_esize[ARC_BUFC_DATA]);

	zfs_refcount_create(&arc_anon->arcs_size);
	zfs_refcount_create(&arc_mru->arcs_size);
	zfs_refcount_create(&arc_mru_ghost->arcs_size);
	zfs_refcount_create(&arc_mfu->arcs_size);
	zfs_refcount_create(&arc_mfu_ghost->arcs_size);
	zfs_refcount_create(&arc_l2c_only->arcs_size);

	aggsum_init(&arc_meta_used, 0);
	aggsum_init(&arc_size, 0);
	aggsum_init(&astat_data_size, 0);
	aggsum_init(&astat_metadata_size, 0);
	aggsum_init(&astat_hdr_size, 0);
	aggsum_init(&astat_l2_hdr_size, 0);
	aggsum_init(&astat_bonus_size, 0);
	aggsum_init(&astat_dnode_size, 0);
	aggsum_init(&astat_dbuf_size, 0);
	aggsum_init(&astat_abd_chunk_waste_size, 0);

	arc_anon->arcs_state = ARC_STATE_ANON;
	arc_mru->arcs_state = ARC_STATE_MRU;
	arc_mru_ghost->arcs_state = ARC_STATE_MRU_GHOST;
	arc_mfu->arcs_state = ARC_STATE_MFU;
	arc_mfu_ghost->arcs_state = ARC_STATE_MFU_GHOST;
	arc_l2c_only->arcs_state = ARC_STATE_L2C_ONLY;
	}

	static void
	arc_state_fini(void)
	{
	zfs_refcount_destroy(&arc_anon->arcs_esize[ARC_BUFC_METADATA]);
	zfs_refcount_destroy(&arc_anon->arcs_esize[ARC_BUFC_DATA]);
	zfs_refcount_destroy(&arc_mru->arcs_esize[ARC_BUFC_METADATA]);
	zfs_refcount_destroy(&arc_mru->arcs_esize[ARC_BUFC_DATA]);
	zfs_refcount_destroy(&arc_mru_ghost->arcs_esize[ARC_BUFC_METADATA]);
	zfs_refcount_destroy(&arc_mru_ghost->arcs_esize[ARC_BUFC_DATA]);
	zfs_refcount_destroy(&arc_mfu->arcs_esize[ARC_BUFC_METADATA]);
	zfs_refcount_destroy(&arc_mfu->arcs_esize[ARC_BUFC_DATA]);
	zfs_refcount_destroy(&arc_mfu_ghost->arcs_esize[ARC_BUFC_METADATA]);
	zfs_refcount_destroy(&arc_mfu_ghost->arcs_esize[ARC_BUFC_DATA]);
	zfs_refcount_destroy(&arc_l2c_only->arcs_esize[ARC_BUFC_METADATA]);
	zfs_refcount_destroy(&arc_l2c_only->arcs_esize[ARC_BUFC_DATA]);

	zfs_refcount_destroy(&arc_anon->arcs_size);
	zfs_refcount_destroy(&arc_mru->arcs_size);
	zfs_refcount_destroy(&arc_mru_ghost->arcs_size);
	zfs_refcount_destroy(&arc_mfu->arcs_size);
	zfs_refcount_destroy(&arc_mfu_ghost->arcs_size);
	zfs_refcount_destroy(&arc_l2c_only->arcs_size);

	multilist_destroy(arc_mru->arcs_list[ARC_BUFC_METADATA]);
	multilist_destroy(arc_mru_ghost->arcs_list[ARC_BUFC_METADATA]);
	multilist_destroy(arc_mfu->arcs_list[ARC_BUFC_METADATA]);
	multilist_destroy(arc_mfu_ghost->arcs_list[ARC_BUFC_METADATA]);
	multilist_destroy(arc_mru->arcs_list[ARC_BUFC_DATA]);
	multilist_destroy(arc_mru_ghost->arcs_list[ARC_BUFC_DATA]);
	multilist_destroy(arc_mfu->arcs_list[ARC_BUFC_DATA]);
	multilist_destroy(arc_mfu_ghost->arcs_list[ARC_BUFC_DATA]);
	multilist_destroy(arc_l2c_only->arcs_list[ARC_BUFC_METADATA]);
	multilist_destroy(arc_l2c_only->arcs_list[ARC_BUFC_DATA]);

	aggsum_fini(&arc_meta_used);
	aggsum_fini(&arc_size);
	aggsum_fini(&astat_data_size);
	aggsum_fini(&astat_metadata_size);
	aggsum_fini(&astat_hdr_size);
	aggsum_fini(&astat_l2_hdr_size);
	aggsum_fini(&astat_bonus_size);
	aggsum_fini(&astat_dnode_size);
	aggsum_fini(&astat_dbuf_size);
	aggsum_fini(&astat_abd_chunk_waste_size);
	}

	uint64_t
	arc_target_bytes(void)
	{
	return (arc_c);
	}

	void
	arc_set_limits(uint64_t allmem)
	{
	/* Set min cache to 1/32 of all memory, or 32MB, whichever is more. */
	arc_c_min = MAX(allmem / 32, 2ULL << SPA_MAXBLOCKSHIFT);

	/* How to set default max varies by platform. */
	arc_c_max = arc_default_max(arc_c_min, allmem);
	}
	void
	arc_init(void)
	{
	uint64_t percent, allmem = arc_all_memory();
	mutex_init(&arc_evict_lock, NULL, MUTEX_DEFAULT, NULL);
	list_create(&arc_evict_waiters, sizeof (arc_evict_waiter_t),
	offsetof(arc_evict_waiter_t, aew_node));

	arc_min_prefetch_ms = 1000;
	arc_min_prescient_prefetch_ms = 6000;

	#if defined(_KERNEL)
	arc_lowmem_init();
	#endif

	arc_set_limits(allmem);

	#ifndef _KERNEL
	/*
	* In userland, there's only the memory pressure that we artificially
	* create (see arc_available_memory()). Don't let arc_c get too
	* small, because it can cause transactions to be larger than
	* arc_c, causing arc_tempreserve_space() to fail.
	*/
	arc_c_min = MAX(arc_c_max / 2, 2ULL << SPA_MAXBLOCKSHIFT);
	#endif

	arc_c = arc_c_min;
	arc_p = (arc_c >> 1);

	/* Set min to 1/2 of arc_c_min */
	arc_meta_min = 1ULL << SPA_MAXBLOCKSHIFT;
	/* Initialize maximum observed usage to zero */
	arc_meta_max = 0;
	/*
	* Set arc_meta_limit to a percent of arc_c_max with a floor of
	* arc_meta_min, and a ceiling of arc_c_max.
	*/
	percent = MIN(zfs_arc_meta_limit_percent, 100);
	arc_meta_limit = MAX(arc_meta_min, (percent * arc_c_max) / 100);
	percent = MIN(zfs_arc_dnode_limit_percent, 100);
	arc_dnode_size_limit = (percent * arc_meta_limit) / 100;

	/* Apply user specified tunings */
	arc_tuning_update(B_TRUE);

	/* if kmem_flags are set, lets try to use less memory */
	if (kmem_debugging())
	arc_c = arc_c / 2;
	if (arc_c < arc_c_min)
	arc_c = arc_c_min;

	arc_register_hotplug();

	arc_state_init();

	buf_init();

	list_create(&arc_prune_list, sizeof (arc_prune_t),
	offsetof(arc_prune_t, p_node));
	mutex_init(&arc_prune_mtx, NULL, MUTEX_DEFAULT, NULL);

	arc_prune_taskq = taskq_create("arc_prune", 100, defclsyspri,
	boot_ncpus, INT_MAX, TASKQ_PREPOPULATE \| TASKQ_DYNAMIC \|
	TASKQ_THREADS_CPU_PCT);

	arc_ksp = kstat_create("zfs", 0, "arcstats", "misc", KSTAT_TYPE_NAMED,
	sizeof (arc_stats) / sizeof (kstat_named_t), KSTAT_FLAG_VIRTUAL);

	if (arc_ksp != NULL) {
	arc_ksp->ks_data = &arc_stats;
	arc_ksp->ks_update = arc_kstat_update;
	kstat_install(arc_ksp);
	}

	arc_evict_zthr = zthr_create("arc_evict",
	arc_evict_cb_check, arc_evict_cb, NULL);
	arc_reap_zthr = zthr_create_timer("arc_reap",
	arc_reap_cb_check, arc_reap_cb, NULL, SEC2NSEC(1));

	arc_warm = B_FALSE;

	/*
	* Calculate maximum amount of dirty data per pool.
	*
	* If it has been set by a module parameter, take that.
	* Otherwise, use a percentage of physical memory defined by
	* zfs_dirty_data_max_percent (default 10%) with a cap at
	* zfs_dirty_data_max_max (default 4G or 25% of physical memory).
	*/
	#ifdef __LP64__
	if (zfs_dirty_data_max_max == 0)
	zfs_dirty_data_max_max = MIN(4ULL * 1024 * 1024 * 1024,
	allmem * zfs_dirty_data_max_max_percent / 100);
	#else
	if (zfs_dirty_data_max_max == 0)
	zfs_dirty_data_max_max = MIN(1ULL * 1024 * 1024 * 1024,
	allmem * zfs_dirty_data_max_max_percent / 100);
	#endif

	if (zfs_dirty_data_max == 0) {
	zfs_dirty_data_max = allmem *
	zfs_dirty_data_max_percent / 100;
	zfs_dirty_data_max = MIN(zfs_dirty_data_max,
	zfs_dirty_data_max_max);
	}
	}

	void
	arc_fini(void)
	{
	arc_prune_t *p;

	#ifdef _KERNEL
	arc_lowmem_fini();
	#endif /* _KERNEL */

	/* Use B_TRUE to ensure all buffers are evicted */
	arc_flush(NULL, B_TRUE);

	if (arc_ksp != NULL) {
	kstat_delete(arc_ksp);
	arc_ksp = NULL;
	}

	taskq_wait(arc_prune_taskq);
	taskq_destroy(arc_prune_taskq);

	mutex_enter(&arc_prune_mtx);
	while ((p = list_head(&arc_prune_list)) != NULL) {
	list_remove(&arc_prune_list, p);
	zfs_refcount_remove(&p->p_refcnt, &arc_prune_list);
	zfs_refcount_destroy(&p->p_refcnt);
	kmem_free(p, sizeof (*p));
	}
	mutex_exit(&arc_prune_mtx);

	list_destroy(&arc_prune_list);
	mutex_destroy(&arc_prune_mtx);

	(void) zthr_cancel(arc_evict_zthr);
	(void) zthr_cancel(arc_reap_zthr);

	mutex_destroy(&arc_evict_lock);
	list_destroy(&arc_evict_waiters);

	/*
	* Free any buffers that were tagged for destruction. This needs
	* to occur before arc_state_fini() runs and destroys the aggsum
	* values which are updated when freeing scatter ABDs.
	*/
	l2arc_do_free_on_write();

	/*
	* buf_fini() must proceed arc_state_fini() because buf_fin() may
	* trigger the release of kmem magazines, which can callback to
	* arc_space_return() which accesses aggsums freed in act_state_fini().
	*/
	buf_fini();
	arc_state_fini();

	arc_unregister_hotplug();

	/*
	* We destroy the zthrs after all the ARC state has been
	* torn down to avoid the case of them receiving any
	* wakeup() signals after they are destroyed.
	*/
	zthr_destroy(arc_evict_zthr);
	zthr_destroy(arc_reap_zthr);

	ASSERT0(arc_loaned_bytes);
	}

	/*
	* Level 2 ARC
	*
	* The level 2 ARC (L2ARC) is a cache layer in-between main memory and disk.
	* It uses dedicated storage devices to hold cached data, which are populated
	* using large infrequent writes. The main role of this cache is to boost
	* the performance of random read workloads. The intended L2ARC devices
	* include short-stroked disks, solid state disks, and other media with
	* substantially faster read latency than disk.
	*
	* +-----------------------+
	* \| ARC \|
	* +-----------------------+
	* \| ^ ^
	* \| \| \|
	* l2arc_feed_thread() arc_read()
	* \| \| \|
	* \| l2arc read \|
	* V \| \|
	* +---------------+ \|
	* \| L2ARC \| \|
	* +---------------+ \|
	* \| ^ \|
	* l2arc_write() \| \|
	* \| \| \|
	* V \| \|
	* +-------+ +-------+
	* \| vdev \| \| vdev \|
	* \| cache \| \| cache \|
	* +-------+ +-------+
	* +=========+ .-----.
	* : L2ARC : \|-_____-\|
	* : devices : \| Disks \|
	* +=========+ `-_____-'
	*
	* Read requests are satisfied from the following sources, in order:
	*
	* 1) ARC
	* 2) vdev cache of L2ARC devices
	* 3) L2ARC devices
	* 4) vdev cache of disks
	* 5) disks
	*
	* Some L2ARC device types exhibit extremely slow write performance.
	* To accommodate for this there are some significant differences between
	* the L2ARC and traditional cache design:
	*
	* 1. There is no eviction path from the ARC to the L2ARC. Evictions from
	* the ARC behave as usual, freeing buffers and placing headers on ghost
	* lists. The ARC does not send buffers to the L2ARC during eviction as
	* this would add inflated write latencies for all ARC memory pressure.
	*
	* 2. The L2ARC attempts to cache data from the ARC before it is evicted.
	* It does this by periodically scanning buffers from the eviction-end of
	* the MFU and MRU ARC lists, copying them to the L2ARC devices if they are
	* not already there. It scans until a headroom of buffers is satisfied,
	* which itself is a buffer for ARC eviction. If a compressible buffer is
	* found during scanning and selected for writing to an L2ARC device, we
	* temporarily boost scanning headroom during the next scan cycle to make
	* sure we adapt to compression effects (which might significantly reduce
	* the data volume we write to L2ARC). The thread that does this is
	* l2arc_feed_thread(), illustrated below; example sizes are included to
	* provide a better sense of ratio than this diagram:
	*
	* head --> tail
	* +---------------------+----------+
	* ARC_mfu \|:::::#:::::::::::::::\|o#o###o###\|-->. # already on L2ARC
	* +---------------------+----------+ \| o L2ARC eligible
	* ARC_mru \|:#:::::::::::::::::::\|#o#ooo####\|-->\| : ARC buffer
	* +---------------------+----------+ \|
	* 15.9 Gbytes ^ 32 Mbytes \|
	* headroom \|
	* l2arc_feed_thread()
	* \|
	* l2arc write hand <--[oooo]--'
	* \| 8 Mbyte
	* \| write max
	* V
	* +==============================+
	* L2ARC dev \|####\|#\|###\|###\| \|####\| ... \|
	* +==============================+
	* 32 Gbytes
	*
	* 3. If an ARC buffer is copied to the L2ARC but then hit instead of
	* evicted, then the L2ARC has cached a buffer much sooner than it probably
	* needed to, potentially wasting L2ARC device bandwidth and storage. It is
	* safe to say that this is an uncommon case, since buffers at the end of
	* the ARC lists have moved there due to inactivity.
	*
	* 4. If the ARC evicts faster than the L2ARC can maintain a headroom,
	* then the L2ARC simply misses copying some buffers. This serves as a
	* pressure valve to prevent heavy read workloads from both stalling the ARC
	* with waits and clogging the L2ARC with writes. This also helps prevent
	* the potential for the L2ARC to churn if it attempts to cache content too
	* quickly, such as during backups of the entire pool.
	*
	* 5. After system boot and before the ARC has filled main memory, there are
	* no evictions from the ARC and so the tails of the ARC_mfu and ARC_mru
	* lists can remain mostly static. Instead of searching from tail of these
	* lists as pictured, the l2arc_feed_thread() will search from the list heads
	* for eligible buffers, greatly increasing its chance of finding them.
	*
	* The L2ARC device write speed is also boosted during this time so that
	* the L2ARC warms up faster. Since there have been no ARC evictions yet,
	* there are no L2ARC reads, and no fear of degrading read performance
	* through increased writes.
	*
	* 6. Writes to the L2ARC devices are grouped and sent in-sequence, so that
	* the vdev queue can aggregate them into larger and fewer writes. Each
	* device is written to in a rotor fashion, sweeping writes through
	* available space then repeating.
	*
	* 7. The L2ARC does not store dirty content. It never needs to flush
	* write buffers back to disk based storage.
	*
	* 8. If an ARC buffer is written (and dirtied) which also exists in the
	* L2ARC, the now stale L2ARC buffer is immediately dropped.
	*
	* The performance of the L2ARC can be tweaked by a number of tunables, which
	* may be necessary for different workloads:
	*
	* l2arc_write_max max write bytes per interval
	* l2arc_write_boost extra write bytes during device warmup
	* l2arc_noprefetch skip caching prefetched buffers
	* l2arc_headroom number of max device writes to precache
	* l2arc_headroom_boost when we find compressed buffers during ARC
	* scanning, we multiply headroom by this
	* percentage factor for the next scan cycle,
	* since more compressed buffers are likely to
	* be present
	* l2arc_feed_secs seconds between L2ARC writing
	*
	* Tunables may be removed or added as future performance improvements are
	* integrated, and also may become zpool properties.
	*
	* There are three key functions that control how the L2ARC warms up:
	*
	* l2arc_write_eligible() check if a buffer is eligible to cache
	* l2arc_write_size() calculate how much to write
	* l2arc_write_interval() calculate sleep delay between writes
	*
	* These three functions determine what to write, how much, and how quickly
	* to send writes.
	*
	* L2ARC persistence:
	*
	* When writing buffers to L2ARC, we periodically add some metadata to
	* make sure we can pick them up after reboot, thus dramatically reducing
	* the impact that any downtime has on the performance of storage systems
	* with large caches.
	*
	* The implementation works fairly simply by integrating the following two
	* modifications:
	*
	* *) When writing to the L2ARC, we occasionally write a "l2arc log block",
	* which is an additional piece of metadata which describes what's been
	* written. This allows us to rebuild the arc_buf_hdr_t structures of the
	* main ARC buffers. There are 2 linked-lists of log blocks headed by
	* dh_start_lbps[2]. We alternate which chain we append to, so they are
	* time-wise and offset-wise interleaved, but that is an optimization rather
	* than for correctness. The log block also includes a pointer to the
	* previous block in its chain.
	*
	* *) We reserve SPA_MINBLOCKSIZE of space at the start of each L2ARC device
	* for our header bookkeeping purposes. This contains a device header,
	* which contains our top-level reference structures. We update it each
	* time we write a new log block, so that we're able to locate it in the
	* L2ARC device. If this write results in an inconsistent device header
	* (e.g. due to power failure), we detect this by verifying the header's
	* checksum and simply fail to reconstruct the L2ARC after reboot.
	*
	* Implementation diagram:
	*
	* +=== L2ARC device (not to scale) ======================================+
	* \| ___two newest log block pointers__.__________ \|
	* \| / \dh_start_lbps[1] \|
	* \| / \ \dh_start_lbps[0]\|
	* \|.___/__. V V \|
	* \|\|L2 dev\|....\|lb \|bufs \|lb \|bufs \|lb \|bufs \|lb \|bufs \|lb \|---(empty)---\|
	* \|\| hdr\| ^ /^ /^ / / \|
	* \|+------+ ...--\-------/ \-----/--\------/ / \|
	* \| \--------------/ \--------------/ \|
	* +======================================================================+
	*
	* As can be seen on the diagram, rather than using a simple linked list,
	* we use a pair of linked lists with alternating elements. This is a
	* performance enhancement due to the fact that we only find out the
	* address of the next log block access once the current block has been
	* completely read in. Obviously, this hurts performance, because we'd be
	* keeping the device's I/O queue at only a 1 operation deep, thus
	* incurring a large amount of I/O round-trip latency. Having two lists
	* allows us to fetch two log blocks ahead of where we are currently
	* rebuilding L2ARC buffers.
	*
	* On-device data structures:
	*
	* L2ARC device header: l2arc_dev_hdr_phys_t
	* L2ARC log block: l2arc_log_blk_phys_t
	*
	* L2ARC reconstruction:
	*
	* When writing data, we simply write in the standard rotary fashion,
	* evicting buffers as we go and simply writing new data over them (writing
	* a new log block every now and then). This obviously means that once we
	* loop around the end of the device, we will start cutting into an already
	* committed log block (and its referenced data buffers), like so:
	*
	* current write head__ __old tail
	* \ /
	* V V
	* <--\|bufs \|lb \|bufs \|lb \| \|bufs \|lb \|bufs \|lb \|-->
	* ^ ^^^^^^^^^___________________________________
	* \| \
	* <<nextwrite>> may overwrite this blk and/or its bufs --'
	*
	* When importing the pool, we detect this situation and use it to stop
	* our scanning process (see l2arc_rebuild).
	*
	* There is one significant caveat to consider when rebuilding ARC contents
	* from an L2ARC device: what about invalidated buffers? Given the above
	* construction, we cannot update blocks which we've already written to amend
	* them to remove buffers which were invalidated. Thus, during reconstruction,
	* we might be populating the cache with buffers for data that's not on the
	* main pool anymore, or may have been overwritten!
	*
	* As it turns out, this isn't a problem. Every arc_read request includes
	* both the DVA and, crucially, the birth TXG of the BP the caller is
	* looking for. So even if the cache were populated by completely rotten
	* blocks for data that had been long deleted and/or overwritten, we'll
	* never actually return bad data from the cache, since the DVA with the
	* birth TXG uniquely identify a block in space and time - once created,
	* a block is immutable on disk. The worst thing we have done is wasted
	* some time and memory at l2arc rebuild to reconstruct outdated ARC
	* entries that will get dropped from the l2arc as it is being updated
	* with new blocks.
	*
	* L2ARC buffers that have been evicted by l2arc_evict() ahead of the write
	* hand are not restored. This is done by saving the offset (in bytes)
	* l2arc_evict() has evicted to in the L2ARC device header and taking it
	* into account when restoring buffers.
	*/

	static boolean_t
	l2arc_write_eligible(uint64_t spa_guid, arc_buf_hdr_t *hdr)
	{
	/*
	* A buffer is not eligible for the L2ARC if it:
	* 1. belongs to a different spa.
	* 2. is already cached on the L2ARC.
	* 3. has an I/O in progress (it may be an incomplete read).
	* 4. is flagged not eligible (zfs property).
	*/
	if (hdr->b_spa != spa_guid \|\| HDR_HAS_L2HDR(hdr) \|\|
	HDR_IO_IN_PROGRESS(hdr) \|\| !HDR_L2CACHE(hdr))
	return (B_FALSE);

	return (B_TRUE);
	}

	static uint64_t
	l2arc_write_size(l2arc_dev_t *dev)
	{
	uint64_t size, dev_size, tsize;

	/*
	* Make sure our globals have meaningful values in case the user
	* altered them.
	*/
	size = l2arc_write_max;
	if (size == 0) {
	cmn_err(CE_NOTE, "Bad value for l2arc_write_max, value must "
	"be greater than zero, resetting it to the default (%d)",
	L2ARC_WRITE_SIZE);
	size = l2arc_write_max = L2ARC_WRITE_SIZE;
	}

	if (arc_warm == B_FALSE)
	size += l2arc_write_boost;

	/*
	* Make sure the write size does not exceed the size of the cache
	* device. This is important in l2arc_evict(), otherwise infinite
	* iteration can occur.
	*/
	dev_size = dev->l2ad_end - dev->l2ad_start;
	tsize = size + l2arc_log_blk_overhead(size, dev);
	if (dev->l2ad_vdev->vdev_has_trim && l2arc_trim_ahead > 0)
	tsize += MAX(64 * 1024 * 1024,
	(tsize * l2arc_trim_ahead) / 100);

	if (tsize >= dev_size) {
	cmn_err(CE_NOTE, "l2arc_write_max or l2arc_write_boost "
	"plus the overhead of log blocks (persistent L2ARC, "
	"%llu bytes) exceeds the size of the cache device "
	"(guid %llu), resetting them to the default (%d)",
	l2arc_log_blk_overhead(size, dev),
	dev->l2ad_vdev->vdev_guid, L2ARC_WRITE_SIZE);
	size = l2arc_write_max = l2arc_write_boost = L2ARC_WRITE_SIZE;

	if (arc_warm == B_FALSE)
	size += l2arc_write_boost;
	}

	return (size);

	}

	static clock_t
	l2arc_write_interval(clock_t began, uint64_t wanted, uint64_t wrote)
	{
	clock_t interval, next, now;

	/*
	* If the ARC lists are busy, increase our write rate; if the
	* lists are stale, idle back. This is achieved by checking
	* how much we previously wrote - if it was more than half of
	* what we wanted, schedule the next write much sooner.
	*/
	if (l2arc_feed_again && wrote > (wanted / 2))
	interval = (hz * l2arc_feed_min_ms) / 1000;
	else
	interval = hz * l2arc_feed_secs;

	now = ddi_get_lbolt();
	next = MAX(now, MIN(now + interval, began + interval));

	return (next);
	}

	/*
	* Cycle through L2ARC devices. This is how L2ARC load balances.
	* If a device is returned, this also returns holding the spa config lock.
	*/
	static l2arc_dev_t *
	l2arc_dev_get_next(void)
	{
	l2arc_dev_t first, next = NULL;

	/*
	* Lock out the removal of spas (spa_namespace_lock), then removal
	* of cache devices (l2arc_dev_mtx). Once a device has been selected,
	* both locks will be dropped and a spa config lock held instead.
	*/
	mutex_enter(&spa_namespace_lock);
	mutex_enter(&l2arc_dev_mtx);

	/* if there are no vdevs, there is nothing to do */
	if (l2arc_ndev == 0)
	goto out;

	first = NULL;
	next = l2arc_dev_last;
	do {
	/* loop around the list looking for a non-faulted vdev */
	if (next == NULL) {
	next = list_head(l2arc_dev_list);
	} else {
	next = list_next(l2arc_dev_list, next);
	if (next == NULL)
	next = list_head(l2arc_dev_list);
	}

	/* if we have come back to the start, bail out */
	if (first == NULL)
	first = next;
	else if (next == first)
	break;

	} while (vdev_is_dead(next->l2ad_vdev) \|\| next->l2ad_rebuild \|\|
	next->l2ad_trim_all);

	/* if we were unable to find any usable vdevs, return NULL */
	if (vdev_is_dead(next->l2ad_vdev) \|\| next->l2ad_rebuild \|\|
	next->l2ad_trim_all)
	next = NULL;

	l2arc_dev_last = next;

	out:
	mutex_exit(&l2arc_dev_mtx);

	/*
	* Grab the config lock to prevent the 'next' device from being
	* removed while we are writing to it.
	*/
	if (next != NULL)
	spa_config_enter(next->l2ad_spa, SCL_L2ARC, next, RW_READER);
	mutex_exit(&spa_namespace_lock);

	return (next);
	}

	/*
	* Free buffers that were tagged for destruction.
	*/
	static void
	l2arc_do_free_on_write(void)
	{
	list_t *buflist;
	l2arc_data_free_t df, df_prev;

	mutex_enter(&l2arc_free_on_write_mtx);
	buflist = l2arc_free_on_write;

	for (df = list_tail(buflist); df; df = df_prev) {
	df_prev = list_prev(buflist, df);
	ASSERT3P(df->l2df_abd, !=, NULL);
	abd_free(df->l2df_abd);
	list_remove(buflist, df);
	kmem_free(df, sizeof (l2arc_data_free_t));
	}

	mutex_exit(&l2arc_free_on_write_mtx);
	}

	/*
	* A write to a cache device has completed. Update all headers to allow
	* reads from these buffers to begin.
	*/
	static void
	l2arc_write_done(zio_t *zio)
	{
	l2arc_write_callback_t *cb;
	l2arc_lb_abd_buf_t *abd_buf;
	l2arc_lb_ptr_buf_t *lb_ptr_buf;
	l2arc_dev_t *dev;
	l2arc_dev_hdr_phys_t *l2dhdr;
	list_t *buflist;
	arc_buf_hdr_t head, hdr, *hdr_prev;
	kmutex_t *hash_lock;
	int64_t bytes_dropped = 0;

	cb = zio->io_private;
	ASSERT3P(cb, !=, NULL);
	dev = cb->l2wcb_dev;
	l2dhdr = dev->l2ad_dev_hdr;
	ASSERT3P(dev, !=, NULL);
	head = cb->l2wcb_head;
	ASSERT3P(head, !=, NULL);
	buflist = &dev->l2ad_buflist;
	ASSERT3P(buflist, !=, NULL);
	DTRACE_PROBE2(l2arc__iodone, zio_t *, zio,
	l2arc_write_callback_t *, cb);

	/*
	* All writes completed, or an error was hit.
	*/
	top:
	mutex_enter(&dev->l2ad_mtx);
	for (hdr = list_prev(buflist, head); hdr; hdr = hdr_prev) {
	hdr_prev = list_prev(buflist, hdr);

	hash_lock = HDR_LOCK(hdr);

	/*
	* We cannot use mutex_enter or else we can deadlock
	* with l2arc_write_buffers (due to swapping the order
	* the hash lock and l2ad_mtx are taken).
	*/
	if (!mutex_tryenter(hash_lock)) {
	/*
	* Missed the hash lock. We must retry so we
	* don't leave the ARC_FLAG_L2_WRITING bit set.
	*/
	ARCSTAT_BUMP(arcstat_l2_writes_lock_retry);

	/*
	* We don't want to rescan the headers we've
	* already marked as having been written out, so
	* we reinsert the head node so we can pick up
	* where we left off.
	*/
	list_remove(buflist, head);
	list_insert_after(buflist, hdr, head);

	mutex_exit(&dev->l2ad_mtx);

	/*
	* We wait for the hash lock to become available
	* to try and prevent busy waiting, and increase
	* the chance we'll be able to acquire the lock
	* the next time around.
	*/
	mutex_enter(hash_lock);
	mutex_exit(hash_lock);
	goto top;
	}

	/*
	* We could not have been moved into the arc_l2c_only
	* state while in-flight due to our ARC_FLAG_L2_WRITING
	* bit being set. Let's just ensure that's being enforced.
	*/
	ASSERT(HDR_HAS_L1HDR(hdr));

	/*
	* Skipped - drop L2ARC entry and mark the header as no
	* longer L2 eligibile.
	*/
	if (zio->io_error != 0) {
	/*
	* Error - drop L2ARC entry.
	*/
	list_remove(buflist, hdr);
	arc_hdr_clear_flags(hdr, ARC_FLAG_HAS_L2HDR);

	uint64_t psize = HDR_GET_PSIZE(hdr);
	l2arc_hdr_arcstats_decrement(hdr);

	bytes_dropped +=
	vdev_psize_to_asize(dev->l2ad_vdev, psize);
	(void) zfs_refcount_remove_many(&dev->l2ad_alloc,
	arc_hdr_size(hdr), hdr);
	}

	/*
	* Allow ARC to begin reads and ghost list evictions to
	* this L2ARC entry.
	*/
	arc_hdr_clear_flags(hdr, ARC_FLAG_L2_WRITING);

	mutex_exit(hash_lock);
	}

	/*
	* Free the allocated abd buffers for writing the log blocks.
	* If the zio failed reclaim the allocated space and remove the
	* pointers to these log blocks from the log block pointer list
	* of the L2ARC device.
	*/
	while ((abd_buf = list_remove_tail(&cb->l2wcb_abd_list)) != NULL) {
	abd_free(abd_buf->abd);
	zio_buf_free(abd_buf, sizeof (*abd_buf));
	if (zio->io_error != 0) {
	lb_ptr_buf = list_remove_head(&dev->l2ad_lbptr_list);
	/*
	* L2BLK_GET_PSIZE returns aligned size for log
	* blocks.
	*/
	uint64_t asize =
	L2BLK_GET_PSIZE((lb_ptr_buf->lb_ptr)->lbp_prop);
	bytes_dropped += asize;
	ARCSTAT_INCR(arcstat_l2_log_blk_asize, -asize);
	ARCSTAT_BUMPDOWN(arcstat_l2_log_blk_count);
	zfs_refcount_remove_many(&dev->l2ad_lb_asize, asize,
	lb_ptr_buf);
	zfs_refcount_remove(&dev->l2ad_lb_count, lb_ptr_buf);
	kmem_free(lb_ptr_buf->lb_ptr,
	sizeof (l2arc_log_blkptr_t));
	kmem_free(lb_ptr_buf, sizeof (l2arc_lb_ptr_buf_t));
	}
	}
	list_destroy(&cb->l2wcb_abd_list);

	if (zio->io_error != 0) {
	ARCSTAT_BUMP(arcstat_l2_writes_error);

	/*
	* Restore the lbps array in the header to its previous state.
	* If the list of log block pointers is empty, zero out the
	* log block pointers in the device header.
	*/
	lb_ptr_buf = list_head(&dev->l2ad_lbptr_list);
	for (int i = 0; i < 2; i++) {
	if (lb_ptr_buf == NULL) {
	/*
	* If the list is empty zero out the device
	* header. Otherwise zero out the second log
	* block pointer in the header.
	*/
	if (i == 0) {
	bzero(l2dhdr, dev->l2ad_dev_hdr_asize);
	} else {
	bzero(&l2dhdr->dh_start_lbps[i],
	sizeof (l2arc_log_blkptr_t));
	}
	break;
	}
	bcopy(lb_ptr_buf->lb_ptr, &l2dhdr->dh_start_lbps[i],
	sizeof (l2arc_log_blkptr_t));
	lb_ptr_buf = list_next(&dev->l2ad_lbptr_list,
	lb_ptr_buf);
	}
	}

	atomic_inc_64(&l2arc_writes_done);
	list_remove(buflist, head);
	ASSERT(!HDR_HAS_L1HDR(head));
	kmem_cache_free(hdr_l2only_cache, head);
	mutex_exit(&dev->l2ad_mtx);

	ASSERT(dev->l2ad_vdev != NULL);
	vdev_space_update(dev->l2ad_vdev, -bytes_dropped, 0, 0);

	l2arc_do_free_on_write();

	kmem_free(cb, sizeof (l2arc_write_callback_t));
	}

	static int
	l2arc_untransform(zio_t zio, l2arc_read_callback_t cb)
	{
	int ret;
	spa_t *spa = zio->io_spa;
	arc_buf_hdr_t *hdr = cb->l2rcb_hdr;
	blkptr_t *bp = zio->io_bp;
	uint8_t salt[ZIO_DATA_SALT_LEN];
	uint8_t iv[ZIO_DATA_IV_LEN];
	uint8_t mac[ZIO_DATA_MAC_LEN];
	boolean_t no_crypt = B_FALSE;

	/*
	* ZIL data is never be written to the L2ARC, so we don't need
	* special handling for its unique MAC storage.
	*/
	ASSERT3U(BP_GET_TYPE(bp), !=, DMU_OT_INTENT_LOG);
	ASSERT(MUTEX_HELD(HDR_LOCK(hdr)));
	ASSERT3P(hdr->b_l1hdr.b_pabd, !=, NULL);

	/*
	* If the data was encrypted, decrypt it now. Note that
	* we must check the bp here and not the hdr, since the
	* hdr does not have its encryption parameters updated
	* until arc_read_done().
	*/
	if (BP_IS_ENCRYPTED(bp)) {
	abd_t *eabd = arc_get_data_abd(hdr, arc_hdr_size(hdr), hdr,
	B_TRUE);

	zio_crypt_decode_params_bp(bp, salt, iv);
	zio_crypt_decode_mac_bp(bp, mac);

	ret = spa_do_crypt_abd(B_FALSE, spa, &cb->l2rcb_zb,
	BP_GET_TYPE(bp), BP_GET_DEDUP(bp), BP_SHOULD_BYTESWAP(bp),
	salt, iv, mac, HDR_GET_PSIZE(hdr), eabd,
	hdr->b_l1hdr.b_pabd, &no_crypt);
	if (ret != 0) {
	arc_free_data_abd(hdr, eabd, arc_hdr_size(hdr), hdr);
	goto error;
	}

	/*
	* If we actually performed decryption, replace b_pabd
	* with the decrypted data. Otherwise we can just throw
	* our decryption buffer away.
	*/
	if (!no_crypt) {
	arc_free_data_abd(hdr, hdr->b_l1hdr.b_pabd,
	arc_hdr_size(hdr), hdr);
	hdr->b_l1hdr.b_pabd = eabd;
	zio->io_abd = eabd;
	} else {
	arc_free_data_abd(hdr, eabd, arc_hdr_size(hdr), hdr);
	}
	}

	/*
	* If the L2ARC block was compressed, but ARC compression
	* is disabled we decompress the data into a new buffer and
	* replace the existing data.
	*/
	if (HDR_GET_COMPRESS(hdr) != ZIO_COMPRESS_OFF &&
	!HDR_COMPRESSION_ENABLED(hdr)) {
	abd_t *cabd = arc_get_data_abd(hdr, arc_hdr_size(hdr), hdr,
	B_TRUE);
	void *tmp = abd_borrow_buf(cabd, arc_hdr_size(hdr));

	ret = zio_decompress_data(HDR_GET_COMPRESS(hdr),
	hdr->b_l1hdr.b_pabd, tmp, HDR_GET_PSIZE(hdr),
	HDR_GET_LSIZE(hdr), &hdr->b_complevel);
	if (ret != 0) {
	abd_return_buf_copy(cabd, tmp, arc_hdr_size(hdr));
	arc_free_data_abd(hdr, cabd, arc_hdr_size(hdr), hdr);
	goto error;
	}

	abd_return_buf_copy(cabd, tmp, arc_hdr_size(hdr));
	arc_free_data_abd(hdr, hdr->b_l1hdr.b_pabd,
	arc_hdr_size(hdr), hdr);
	hdr->b_l1hdr.b_pabd = cabd;
	zio->io_abd = cabd;
	zio->io_size = HDR_GET_LSIZE(hdr);
	}

	return (0);

	error:
	return (ret);
	}


	/*
	* A read to a cache device completed. Validate buffer contents before
	* handing over to the regular ARC routines.
	*/
	static void
	l2arc_read_done(zio_t *zio)
	{
	int tfm_error = 0;
	l2arc_read_callback_t *cb = zio->io_private;
	arc_buf_hdr_t *hdr;
	kmutex_t *hash_lock;
	boolean_t valid_cksum;
	boolean_t using_rdata = (BP_IS_ENCRYPTED(&cb->l2rcb_bp) &&
	(cb->l2rcb_flags & ZIO_FLAG_RAW_ENCRYPT));

	ASSERT3P(zio->io_vd, !=, NULL);
	ASSERT(zio->io_flags & ZIO_FLAG_DONT_PROPAGATE);

	spa_config_exit(zio->io_spa, SCL_L2ARC, zio->io_vd);

	ASSERT3P(cb, !=, NULL);
	hdr = cb->l2rcb_hdr;
	ASSERT3P(hdr, !=, NULL);

	hash_lock = HDR_LOCK(hdr);
	mutex_enter(hash_lock);
	ASSERT3P(hash_lock, ==, HDR_LOCK(hdr));

	/*
	* If the data was read into a temporary buffer,
	* move it and free the buffer.
	*/
	if (cb->l2rcb_abd != NULL) {
	ASSERT3U(arc_hdr_size(hdr), <, zio->io_size);
	if (zio->io_error == 0) {
	if (using_rdata) {
	abd_copy(hdr->b_crypt_hdr.b_rabd,
	cb->l2rcb_abd, arc_hdr_size(hdr));
	} else {
	abd_copy(hdr->b_l1hdr.b_pabd,
	cb->l2rcb_abd, arc_hdr_size(hdr));
	}
	}

	/*
	* The following must be done regardless of whether
	* there was an error:
	* - free the temporary buffer
	* - point zio to the real ARC buffer
	* - set zio size accordingly
	* These are required because zio is either re-used for
	* an I/O of the block in the case of the error
	* or the zio is passed to arc_read_done() and it
	* needs real data.
	*/
	abd_free(cb->l2rcb_abd);
	zio->io_size = zio->io_orig_size = arc_hdr_size(hdr);

	if (using_rdata) {
	ASSERT(HDR_HAS_RABD(hdr));
	zio->io_abd = zio->io_orig_abd =
	hdr->b_crypt_hdr.b_rabd;
	} else {
	ASSERT3P(hdr->b_l1hdr.b_pabd, !=, NULL);
	zio->io_abd = zio->io_orig_abd = hdr->b_l1hdr.b_pabd;
	}
	}

	ASSERT3P(zio->io_abd, !=, NULL);

	/*
	* Check this survived the L2ARC journey.
	*/
	ASSERT(zio->io_abd == hdr->b_l1hdr.b_pabd \|\|
	(HDR_HAS_RABD(hdr) && zio->io_abd == hdr->b_crypt_hdr.b_rabd));
	zio->io_bp_copy = cb->l2rcb_bp; /* XXX fix in L2ARC 2.0 */
	zio->io_bp = &zio->io_bp_copy; /* XXX fix in L2ARC 2.0 */
	zio->io_prop.zp_complevel = hdr->b_complevel;

	valid_cksum = arc_cksum_is_equal(hdr, zio);

	/*
	* b_rabd will always match the data as it exists on disk if it is
	* being used. Therefore if we are reading into b_rabd we do not
	* attempt to untransform the data.
	*/
	if (valid_cksum && !using_rdata)
	tfm_error = l2arc_untransform(zio, cb);

	if (valid_cksum && tfm_error == 0 && zio->io_error == 0 &&
	!HDR_L2_EVICTED(hdr)) {
	mutex_exit(hash_lock);
	zio->io_private = hdr;
	arc_read_done(zio);
	} else {
	/*
	* Buffer didn't survive caching. Increment stats and
	* reissue to the original storage device.
	*/
	if (zio->io_error != 0) {
	ARCSTAT_BUMP(arcstat_l2_io_error);
	} else {
	zio->io_error = SET_ERROR(EIO);
	}
	if (!valid_cksum \|\| tfm_error != 0)
	ARCSTAT_BUMP(arcstat_l2_cksum_bad);

	/*
	* If there's no waiter, issue an async i/o to the primary
	* storage now. If there is a waiter, the caller must
	* issue the i/o in a context where it's OK to block.
	*/
	if (zio->io_waiter == NULL) {
	zio_t *pio = zio_unique_parent(zio);
	void *abd = (using_rdata) ?
	hdr->b_crypt_hdr.b_rabd : hdr->b_l1hdr.b_pabd;

	ASSERT(!pio \|\| pio->io_child_type == ZIO_CHILD_LOGICAL);

	zio = zio_read(pio, zio->io_spa, zio->io_bp,
	abd, zio->io_size, arc_read_done,
	hdr, zio->io_priority, cb->l2rcb_flags,
	&cb->l2rcb_zb);

	/*
	* Original ZIO will be freed, so we need to update
	* ARC header with the new ZIO pointer to be used
	* by zio_change_priority() in arc_read().
	*/
	for (struct arc_callback *acb = hdr->b_l1hdr.b_acb;
	acb != NULL; acb = acb->acb_next)
	acb->acb_zio_head = zio;

	mutex_exit(hash_lock);
	zio_nowait(zio);
	} else {
	mutex_exit(hash_lock);
	}
	}

	kmem_free(cb, sizeof (l2arc_read_callback_t));
	}

	/*
	* This is the list priority from which the L2ARC will search for pages to
	* cache. This is used within loops (0..3) to cycle through lists in the
	* desired order. This order can have a significant effect on cache
	* performance.
	*
	* Currently the metadata lists are hit first, MFU then MRU, followed by
	* the data lists. This function returns a locked list, and also returns
	* the lock pointer.
	*/
	static multilist_sublist_t *
	l2arc_sublist_lock(int list_num)
	{
	multilist_t *ml = NULL;
	unsigned int idx;

	ASSERT(list_num >= 0 && list_num < L2ARC_FEED_TYPES);

	switch (list_num) {
	case 0:
	ml = arc_mfu->arcs_list[ARC_BUFC_METADATA];
	break;
	case 1:
	ml = arc_mru->arcs_list[ARC_BUFC_METADATA];
	break;
	case 2:
	ml = arc_mfu->arcs_list[ARC_BUFC_DATA];
	break;
	case 3:
	ml = arc_mru->arcs_list[ARC_BUFC_DATA];
	break;
	default:
	return (NULL);
	}

	/*
	* Return a randomly-selected sublist. This is acceptable
	* because the caller feeds only a little bit of data for each
	* call (8MB). Subsequent calls will result in different
	* sublists being selected.
	*/
	idx = multilist_get_random_index(ml);
	return (multilist_sublist_lock(ml, idx));
	}

	/*
	* Calculates the maximum overhead of L2ARC metadata log blocks for a given
	* L2ARC write size. l2arc_evict and l2arc_write_size need to include this
	* overhead in processing to make sure there is enough headroom available
	* when writing buffers.
	*/
	static inline uint64_t
	l2arc_log_blk_overhead(uint64_t write_sz, l2arc_dev_t *dev)
	{
	if (dev->l2ad_log_entries == 0) {
	return (0);
	} else {
	uint64_t log_entries = write_sz >> SPA_MINBLOCKSHIFT;

	uint64_t log_blocks = (log_entries +
	dev->l2ad_log_entries - 1) /
	dev->l2ad_log_entries;

	return (vdev_psize_to_asize(dev->l2ad_vdev,
	sizeof (l2arc_log_blk_phys_t)) * log_blocks);
	}
	}

	/*
	* Evict buffers from the device write hand to the distance specified in
	* bytes. This distance may span populated buffers, it may span nothing.
	* This is clearing a region on the L2ARC device ready for writing.
	* If the 'all' boolean is set, every buffer is evicted.
	*/
	static void
	l2arc_evict(l2arc_dev_t *dev, uint64_t distance, boolean_t all)
	{
	list_t *buflist;
	arc_buf_hdr_t hdr, hdr_prev;
	kmutex_t *hash_lock;
	uint64_t taddr;
	l2arc_lb_ptr_buf_t lb_ptr_buf, lb_ptr_buf_prev;
	vdev_t *vd = dev->l2ad_vdev;
	boolean_t rerun;

	buflist = &dev->l2ad_buflist;

	/*
	* We need to add in the worst case scenario of log block overhead.
	*/
	distance += l2arc_log_blk_overhead(distance, dev);
	if (vd->vdev_has_trim && l2arc_trim_ahead > 0) {
	/*
	* Trim ahead of the write size 64MB or (l2arc_trim_ahead/100)
	* times the write size, whichever is greater.
	*/
	distance += MAX(64 * 1024 * 1024,
	(distance * l2arc_trim_ahead) / 100);
	}

	top:
	rerun = B_FALSE;
	if (dev->l2ad_hand >= (dev->l2ad_end - distance)) {
	/*
	* When there is no space to accommodate upcoming writes,
	* evict to the end. Then bump the write and evict hands
	* to the start and iterate. This iteration does not
	* happen indefinitely as we make sure in
	* l2arc_write_size() that when the write hand is reset,
	* the write size does not exceed the end of the device.
	*/
	rerun = B_TRUE;
	taddr = dev->l2ad_end;
	} else {
	taddr = dev->l2ad_hand + distance;
	}
	DTRACE_PROBE4(l2arc__evict, l2arc_dev_t , dev, list_t , buflist,
	uint64_t, taddr, boolean_t, all);

	if (!all) {
	/*
	* This check has to be placed after deciding whether to
	* iterate (rerun).
	*/
	if (dev->l2ad_first) {
	/*
	* This is the first sweep through the device. There is
	* nothing to evict. We have already trimmmed the
	* whole device.
	*/
	goto out;
	} else {
	/*
	* Trim the space to be evicted.
	*/
	if (vd->vdev_has_trim && dev->l2ad_evict < taddr &&
	l2arc_trim_ahead > 0) {
	/*
	* We have to drop the spa_config lock because
	* vdev_trim_range() will acquire it.
	* l2ad_evict already accounts for the label
	* size. To prevent vdev_trim_ranges() from
	* adding it again, we subtract it from
	* l2ad_evict.
	*/
	spa_config_exit(dev->l2ad_spa, SCL_L2ARC, dev);
	vdev_trim_simple(vd,
	dev->l2ad_evict - VDEV_LABEL_START_SIZE,
	taddr - dev->l2ad_evict);
	spa_config_enter(dev->l2ad_spa, SCL_L2ARC, dev,
	RW_READER);
	}

	/*
	* When rebuilding L2ARC we retrieve the evict hand
	* from the header of the device. Of note, l2arc_evict()
	* does not actually delete buffers from the cache
	* device, but trimming may do so depending on the
	* hardware implementation. Thus keeping track of the
	* evict hand is useful.
	*/
	dev->l2ad_evict = MAX(dev->l2ad_evict, taddr);
	}
	}

	retry:
	mutex_enter(&dev->l2ad_mtx);
	/*
	* We have to account for evicted log blocks. Run vdev_space_update()
	* on log blocks whose offset (in bytes) is before the evicted offset
	* (in bytes) by searching in the list of pointers to log blocks
	* present in the L2ARC device.
	*/
	for (lb_ptr_buf = list_tail(&dev->l2ad_lbptr_list); lb_ptr_buf;
	lb_ptr_buf = lb_ptr_buf_prev) {

	lb_ptr_buf_prev = list_prev(&dev->l2ad_lbptr_list, lb_ptr_buf);

	/* L2BLK_GET_PSIZE returns aligned size for log blocks */
	uint64_t asize = L2BLK_GET_PSIZE(
	(lb_ptr_buf->lb_ptr)->lbp_prop);

	/*
	* We don't worry about log blocks left behind (ie
	* lbp_payload_start < l2ad_hand) because l2arc_write_buffers()
	* will never write more than l2arc_evict() evicts.
	*/
	if (!all && l2arc_log_blkptr_valid(dev, lb_ptr_buf->lb_ptr)) {
	break;
	} else {
	vdev_space_update(vd, -asize, 0, 0);
	ARCSTAT_INCR(arcstat_l2_log_blk_asize, -asize);
	ARCSTAT_BUMPDOWN(arcstat_l2_log_blk_count);
	zfs_refcount_remove_many(&dev->l2ad_lb_asize, asize,
	lb_ptr_buf);
	zfs_refcount_remove(&dev->l2ad_lb_count, lb_ptr_buf);
	list_remove(&dev->l2ad_lbptr_list, lb_ptr_buf);
	kmem_free(lb_ptr_buf->lb_ptr,
	sizeof (l2arc_log_blkptr_t));
	kmem_free(lb_ptr_buf, sizeof (l2arc_lb_ptr_buf_t));
	}
	}

	for (hdr = list_tail(buflist); hdr; hdr = hdr_prev) {
	hdr_prev = list_prev(buflist, hdr);

	ASSERT(!HDR_EMPTY(hdr));
	hash_lock = HDR_LOCK(hdr);

	/*
	* We cannot use mutex_enter or else we can deadlock
	* with l2arc_write_buffers (due to swapping the order
	* the hash lock and l2ad_mtx are taken).
	*/
	if (!mutex_tryenter(hash_lock)) {
	/*
	* Missed the hash lock. Retry.
	*/
	ARCSTAT_BUMP(arcstat_l2_evict_lock_retry);
	mutex_exit(&dev->l2ad_mtx);
	mutex_enter(hash_lock);
	mutex_exit(hash_lock);
	goto retry;
	}

	/*
	* A header can't be on this list if it doesn't have L2 header.
	*/
	ASSERT(HDR_HAS_L2HDR(hdr));

	/* Ensure this header has finished being written. */
	ASSERT(!HDR_L2_WRITING(hdr));
	ASSERT(!HDR_L2_WRITE_HEAD(hdr));

	if (!all && (hdr->b_l2hdr.b_daddr >= dev->l2ad_evict \|\|
	hdr->b_l2hdr.b_daddr < dev->l2ad_hand)) {
	/*
	* We've evicted to the target address,
	* or the end of the device.
	*/
	mutex_exit(hash_lock);
	break;
	}

	if (!HDR_HAS_L1HDR(hdr)) {
	ASSERT(!HDR_L2_READING(hdr));
	/*
	* This doesn't exist in the ARC. Destroy.
	* arc_hdr_destroy() will call list_remove()
	* and decrement arcstat_l2_lsize.
	*/
	arc_change_state(arc_anon, hdr, hash_lock);
	arc_hdr_destroy(hdr);
	} else {
	ASSERT(hdr->b_l1hdr.b_state != arc_l2c_only);
	ARCSTAT_BUMP(arcstat_l2_evict_l1cached);
	/*
	* Invalidate issued or about to be issued
	* reads, since we may be about to write
	* over this location.
	*/
	if (HDR_L2_READING(hdr)) {
	ARCSTAT_BUMP(arcstat_l2_evict_reading);
	arc_hdr_set_flags(hdr, ARC_FLAG_L2_EVICTED);
	}

	arc_hdr_l2hdr_destroy(hdr);
	}
	mutex_exit(hash_lock);
	}
	mutex_exit(&dev->l2ad_mtx);

	out:
	/*
	* We need to check if we evict all buffers, otherwise we may iterate
	* unnecessarily.
	*/
	if (!all && rerun) {
	/*
	* Bump device hand to the device start if it is approaching the
	* end. l2arc_evict() has already evicted ahead for this case.
	*/
	dev->l2ad_hand = dev->l2ad_start;
	dev->l2ad_evict = dev->l2ad_start;
	dev->l2ad_first = B_FALSE;
	goto top;
	}

	if (!all) {
	/*
	* In case of cache device removal (all) the following
	* assertions may be violated without functional consequences
	* as the device is about to be removed.
	*/
	ASSERT3U(dev->l2ad_hand + distance, <, dev->l2ad_end);
	if (!dev->l2ad_first)
	ASSERT3U(dev->l2ad_hand, <, dev->l2ad_evict);
	}
	}

	/*
	* Handle any abd transforms that might be required for writing to the L2ARC.
	* If successful, this function will always return an abd with the data
	* transformed as it is on disk in a new abd of asize bytes.
	*/
	static int
	l2arc_apply_transforms(spa_t spa, arc_buf_hdr_t hdr, uint64_t asize,
	abd_t **abd_out)
	{
	int ret;
	void *tmp = NULL;
	abd_t cabd = NULL, eabd = NULL, *to_write = hdr->b_l1hdr.b_pabd;
	enum zio_compress compress = HDR_GET_COMPRESS(hdr);
	uint64_t psize = HDR_GET_PSIZE(hdr);
	uint64_t size = arc_hdr_size(hdr);
	boolean_t ismd = HDR_ISTYPE_METADATA(hdr);
	boolean_t bswap = (hdr->b_l1hdr.b_byteswap != DMU_BSWAP_NUMFUNCS);
	dsl_crypto_key_t *dck = NULL;
	uint8_t mac[ZIO_DATA_MAC_LEN] = { 0 };
	boolean_t no_crypt = B_FALSE;

	ASSERT((HDR_GET_COMPRESS(hdr) != ZIO_COMPRESS_OFF &&
	!HDR_COMPRESSION_ENABLED(hdr)) \|\|
	HDR_ENCRYPTED(hdr) \|\| HDR_SHARED_DATA(hdr) \|\| psize != asize);
	ASSERT3U(psize, <=, asize);

	/*
	* If this data simply needs its own buffer, we simply allocate it
	* and copy the data. This may be done to eliminate a dependency on a
	* shared buffer or to reallocate the buffer to match asize.
	*/
	if (HDR_HAS_RABD(hdr) && asize != psize) {
	ASSERT3U(asize, >=, psize);
	to_write = abd_alloc_for_io(asize, ismd);
	abd_copy(to_write, hdr->b_crypt_hdr.b_rabd, psize);
	if (psize != asize)
	abd_zero_off(to_write, psize, asize - psize);
	goto out;
	}

	if ((compress == ZIO_COMPRESS_OFF \|\| HDR_COMPRESSION_ENABLED(hdr)) &&
	!HDR_ENCRYPTED(hdr)) {
	ASSERT3U(size, ==, psize);
	to_write = abd_alloc_for_io(asize, ismd);
	abd_copy(to_write, hdr->b_l1hdr.b_pabd, size);
	if (size != asize)
	abd_zero_off(to_write, size, asize - size);
	goto out;
	}

	if (compress != ZIO_COMPRESS_OFF && !HDR_COMPRESSION_ENABLED(hdr)) {
	cabd = abd_alloc_for_io(asize, ismd);
	tmp = abd_borrow_buf(cabd, asize);

	psize = zio_compress_data(compress, to_write, tmp, size,
	hdr->b_complevel);

	if (psize >= size) {
	abd_return_buf(cabd, tmp, asize);
	HDR_SET_COMPRESS(hdr, ZIO_COMPRESS_OFF);
	to_write = cabd;
	abd_copy(to_write, hdr->b_l1hdr.b_pabd, size);
	if (size != asize)
	abd_zero_off(to_write, size, asize - size);
	goto encrypt;
	}
	ASSERT3U(psize, <=, HDR_GET_PSIZE(hdr));
	if (psize < asize)
	bzero((char *)tmp + psize, asize - psize);
	psize = HDR_GET_PSIZE(hdr);
	abd_return_buf_copy(cabd, tmp, asize);
	to_write = cabd;
	}

	encrypt:
	if (HDR_ENCRYPTED(hdr)) {
	eabd = abd_alloc_for_io(asize, ismd);

	/*
	* If the dataset was disowned before the buffer
	* made it to this point, the key to re-encrypt
	* it won't be available. In this case we simply
	* won't write the buffer to the L2ARC.
	*/
	ret = spa_keystore_lookup_key(spa, hdr->b_crypt_hdr.b_dsobj,
	FTAG, &dck);
	if (ret != 0)
	goto error;

	ret = zio_do_crypt_abd(B_TRUE, &dck->dck_key,
	hdr->b_crypt_hdr.b_ot, bswap, hdr->b_crypt_hdr.b_salt,
	hdr->b_crypt_hdr.b_iv, mac, psize, to_write, eabd,
	&no_crypt);
	if (ret != 0)
	goto error;

	if (no_crypt)
	abd_copy(eabd, to_write, psize);

	if (psize != asize)
	abd_zero_off(eabd, psize, asize - psize);

	/* assert that the MAC we got here matches the one we saved */
	ASSERT0(bcmp(mac, hdr->b_crypt_hdr.b_mac, ZIO_DATA_MAC_LEN));
	spa_keystore_dsl_key_rele(spa, dck, FTAG);

	if (to_write == cabd)
	abd_free(cabd);

	to_write = eabd;
	}

	out:
	ASSERT3P(to_write, !=, hdr->b_l1hdr.b_pabd);
	*abd_out = to_write;
	return (0);

	error:
	if (dck != NULL)
	spa_keystore_dsl_key_rele(spa, dck, FTAG);
	if (cabd != NULL)
	abd_free(cabd);
	if (eabd != NULL)
	abd_free(eabd);

	*abd_out = NULL;
	return (ret);
	}

	static void
	l2arc_blk_fetch_done(zio_t *zio)
	{
	l2arc_read_callback_t *cb;

	cb = zio->io_private;
	if (cb->l2rcb_abd != NULL)
	abd_free(cb->l2rcb_abd);
	kmem_free(cb, sizeof (l2arc_read_callback_t));
	}

	/*
	* Find and write ARC buffers to the L2ARC device.
	*
	* An ARC_FLAG_L2_WRITING flag is set so that the L2ARC buffers are not valid
	* for reading until they have completed writing.
	* The headroom_boost is an in-out parameter used to maintain headroom boost
	* state between calls to this function.
	*
	* Returns the number of bytes actually written (which may be smaller than
	* the delta by which the device hand has changed due to alignment and the
	* writing of log blocks).
	*/
	static uint64_t
	l2arc_write_buffers(spa_t spa, l2arc_dev_t dev, uint64_t target_sz)
	{
	arc_buf_hdr_t hdr, hdr_prev, *head;
	uint64_t write_asize, write_psize, write_lsize, headroom;
	boolean_t full;
	l2arc_write_callback_t *cb = NULL;
	zio_t pio, wzio;
	uint64_t guid = spa_load_guid(spa);
	l2arc_dev_hdr_phys_t *l2dhdr = dev->l2ad_dev_hdr;

	ASSERT3P(dev->l2ad_vdev, !=, NULL);

	pio = NULL;
	write_lsize = write_asize = write_psize = 0;
	full = B_FALSE;
	head = kmem_cache_alloc(hdr_l2only_cache, KM_PUSHPAGE);
	arc_hdr_set_flags(head, ARC_FLAG_L2_WRITE_HEAD \| ARC_FLAG_HAS_L2HDR);

	/*
	* Copy buffers for L2ARC writing.
	*/
	for (int pass = 0; pass < L2ARC_FEED_TYPES; pass++) {
	/*
	* If pass == 1 or 3, we cache MRU metadata and data
	* respectively.
	*/
	if (l2arc_mfuonly) {
	if (pass == 1 \|\| pass == 3)
	continue;
	}

	multilist_sublist_t *mls = l2arc_sublist_lock(pass);
	uint64_t passed_sz = 0;

	VERIFY3P(mls, !=, NULL);

	/*
	* L2ARC fast warmup.
	*
	* Until the ARC is warm and starts to evict, read from the
	* head of the ARC lists rather than the tail.
	*/
	if (arc_warm == B_FALSE)
	hdr = multilist_sublist_head(mls);
	else
	hdr = multilist_sublist_tail(mls);

	headroom = target_sz * l2arc_headroom;
	if (zfs_compressed_arc_enabled)
	headroom = (headroom * l2arc_headroom_boost) / 100;

	for (; hdr; hdr = hdr_prev) {
	kmutex_t *hash_lock;
	abd_t *to_write = NULL;

	if (arc_warm == B_FALSE)
	hdr_prev = multilist_sublist_next(mls, hdr);
	else
	hdr_prev = multilist_sublist_prev(mls, hdr);

	hash_lock = HDR_LOCK(hdr);
	if (!mutex_tryenter(hash_lock)) {
	/*
	* Skip this buffer rather than waiting.
	*/
	continue;
	}

	passed_sz += HDR_GET_LSIZE(hdr);
	if (l2arc_headroom != 0 && passed_sz > headroom) {
	/*
	* Searched too far.
	*/
	mutex_exit(hash_lock);
	break;
	}

	if (!l2arc_write_eligible(guid, hdr)) {
	mutex_exit(hash_lock);
	continue;
	}

	/*
	* We rely on the L1 portion of the header below, so
	* it's invalid for this header to have been evicted out
	* of the ghost cache, prior to being written out. The
	* ARC_FLAG_L2_WRITING bit ensures this won't happen.
	*/
	ASSERT(HDR_HAS_L1HDR(hdr));

	ASSERT3U(HDR_GET_PSIZE(hdr), >, 0);
	ASSERT3U(arc_hdr_size(hdr), >, 0);
	ASSERT(hdr->b_l1hdr.b_pabd != NULL \|\|
	HDR_HAS_RABD(hdr));
	uint64_t psize = HDR_GET_PSIZE(hdr);
	uint64_t asize = vdev_psize_to_asize(dev->l2ad_vdev,
	psize);

	if ((write_asize + asize) > target_sz) {
	full = B_TRUE;
	mutex_exit(hash_lock);
	break;
	}

	/*
	* We rely on the L1 portion of the header below, so
	* it's invalid for this header to have been evicted out
	* of the ghost cache, prior to being written out. The
	* ARC_FLAG_L2_WRITING bit ensures this won't happen.
	*/
	arc_hdr_set_flags(hdr, ARC_FLAG_L2_WRITING);
	ASSERT(HDR_HAS_L1HDR(hdr));

	ASSERT3U(HDR_GET_PSIZE(hdr), >, 0);
	ASSERT(hdr->b_l1hdr.b_pabd != NULL \|\|
	HDR_HAS_RABD(hdr));
	ASSERT3U(arc_hdr_size(hdr), >, 0);

	/*
	* If this header has b_rabd, we can use this since it
	* must always match the data exactly as it exists on
	* disk. Otherwise, the L2ARC can normally use the
	* hdr's data, but if we're sharing data between the
	* hdr and one of its bufs, L2ARC needs its own copy of
	* the data so that the ZIO below can't race with the
	* buf consumer. To ensure that this copy will be
	* available for the lifetime of the ZIO and be cleaned
	* up afterwards, we add it to the l2arc_free_on_write
	* queue. If we need to apply any transforms to the
	* data (compression, encryption) we will also need the
	* extra buffer.
	*/
	if (HDR_HAS_RABD(hdr) && psize == asize) {
	to_write = hdr->b_crypt_hdr.b_rabd;
	} else if ((HDR_COMPRESSION_ENABLED(hdr) \|\|
	HDR_GET_COMPRESS(hdr) == ZIO_COMPRESS_OFF) &&
	!HDR_ENCRYPTED(hdr) && !HDR_SHARED_DATA(hdr) &&
	psize == asize) {
	to_write = hdr->b_l1hdr.b_pabd;
	} else {
	int ret;
	arc_buf_contents_t type = arc_buf_type(hdr);

	ret = l2arc_apply_transforms(spa, hdr, asize,
	&to_write);
	if (ret != 0) {
	arc_hdr_clear_flags(hdr,
	ARC_FLAG_L2_WRITING);
	mutex_exit(hash_lock);
	continue;
	}

	l2arc_free_abd_on_write(to_write, asize, type);
	}

	if (pio == NULL) {
	/*
	* Insert a dummy header on the buflist so
	* l2arc_write_done() can find where the
	* write buffers begin without searching.
	*/
	mutex_enter(&dev->l2ad_mtx);
	list_insert_head(&dev->l2ad_buflist, head);
	mutex_exit(&dev->l2ad_mtx);

	cb = kmem_alloc(
	sizeof (l2arc_write_callback_t), KM_SLEEP);
	cb->l2wcb_dev = dev;
	cb->l2wcb_head = head;
	/*
	* Create a list to save allocated abd buffers
	* for l2arc_log_blk_commit().
	*/
	list_create(&cb->l2wcb_abd_list,
	sizeof (l2arc_lb_abd_buf_t),
	offsetof(l2arc_lb_abd_buf_t, node));
	pio = zio_root(spa, l2arc_write_done, cb,
	ZIO_FLAG_CANFAIL);
	}

	hdr->b_l2hdr.b_dev = dev;
	hdr->b_l2hdr.b_hits = 0;

	hdr->b_l2hdr.b_daddr = dev->l2ad_hand;
	hdr->b_l2hdr.b_arcs_state =
	hdr->b_l1hdr.b_state->arcs_state;
	arc_hdr_set_flags(hdr, ARC_FLAG_HAS_L2HDR);

	mutex_enter(&dev->l2ad_mtx);
	list_insert_head(&dev->l2ad_buflist, hdr);
	mutex_exit(&dev->l2ad_mtx);

	(void) zfs_refcount_add_many(&dev->l2ad_alloc,
	arc_hdr_size(hdr), hdr);

	wzio = zio_write_phys(pio, dev->l2ad_vdev,
	hdr->b_l2hdr.b_daddr, asize, to_write,
	ZIO_CHECKSUM_OFF, NULL, hdr,
	ZIO_PRIORITY_ASYNC_WRITE,
	ZIO_FLAG_CANFAIL, B_FALSE);

	write_lsize += HDR_GET_LSIZE(hdr);
	DTRACE_PROBE2(l2arc__write, vdev_t *, dev->l2ad_vdev,
	zio_t *, wzio);

	write_psize += psize;
	write_asize += asize;
	dev->l2ad_hand += asize;
	l2arc_hdr_arcstats_increment(hdr);
	vdev_space_update(dev->l2ad_vdev, asize, 0, 0);

	mutex_exit(hash_lock);

	/*
	* Append buf info to current log and commit if full.
	* arcstat_l2_{size,asize} kstats are updated
	* internally.
	*/
	if (l2arc_log_blk_insert(dev, hdr))
	l2arc_log_blk_commit(dev, pio, cb);

	zio_nowait(wzio);
	}

	multilist_sublist_unlock(mls);

	if (full == B_TRUE)
	break;
	}

	/* No buffers selected for writing? */
	if (pio == NULL) {
	ASSERT0(write_lsize);
	ASSERT(!HDR_HAS_L1HDR(head));
	kmem_cache_free(hdr_l2only_cache, head);

	/*
	* Although we did not write any buffers l2ad_evict may
	* have advanced.
	*/
	if (dev->l2ad_evict != l2dhdr->dh_evict)
	l2arc_dev_hdr_update(dev);

	return (0);
	}

	if (!dev->l2ad_first)
	ASSERT3U(dev->l2ad_hand, <=, dev->l2ad_evict);

	ASSERT3U(write_asize, <=, target_sz);
	ARCSTAT_BUMP(arcstat_l2_writes_sent);
	ARCSTAT_INCR(arcstat_l2_write_bytes, write_psize);

	dev->l2ad_writing = B_TRUE;
	(void) zio_wait(pio);
	dev->l2ad_writing = B_FALSE;

	/*
	* Update the device header after the zio completes as
	* l2arc_write_done() may have updated the memory holding the log block
	* pointers in the device header.
	*/
	l2arc_dev_hdr_update(dev);

	return (write_asize);
	}

	static boolean_t
	l2arc_hdr_limit_reached(void)
	{
	int64_t s = aggsum_upper_bound(&astat_l2_hdr_size);

	return (arc_reclaim_needed() \|\| (s > arc_meta_limit * 3 / 4) \|\|
	(s > (arc_warm ? arc_c : arc_c_max) * l2arc_meta_percent / 100));
	}

	/*
	* This thread feeds the L2ARC at regular intervals. This is the beating
	* heart of the L2ARC.
	*/
	/* ARGSUSED */
	static void
	l2arc_feed_thread(void *unused)
	{
	callb_cpr_t cpr;
	l2arc_dev_t *dev;
	spa_t *spa;
	uint64_t size, wrote;
	clock_t begin, next = ddi_get_lbolt();
	fstrans_cookie_t cookie;

	CALLB_CPR_INIT(&cpr, &l2arc_feed_thr_lock, callb_generic_cpr, FTAG);

	mutex_enter(&l2arc_feed_thr_lock);

	cookie = spl_fstrans_mark();
	while (l2arc_thread_exit == 0) {
	CALLB_CPR_SAFE_BEGIN(&cpr);
	(void) cv_timedwait_idle(&l2arc_feed_thr_cv,
	&l2arc_feed_thr_lock, next);
	CALLB_CPR_SAFE_END(&cpr, &l2arc_feed_thr_lock);
	next = ddi_get_lbolt() + hz;

	/*
	* Quick check for L2ARC devices.
	*/
	mutex_enter(&l2arc_dev_mtx);
	if (l2arc_ndev == 0) {
	mutex_exit(&l2arc_dev_mtx);
	continue;
	}
	mutex_exit(&l2arc_dev_mtx);
	begin = ddi_get_lbolt();

	/*
	* This selects the next l2arc device to write to, and in
	* doing so the next spa to feed from: dev->l2ad_spa. This
	* will return NULL if there are now no l2arc devices or if
	* they are all faulted.
	*
	* If a device is returned, its spa's config lock is also
	* held to prevent device removal. l2arc_dev_get_next()
	* will grab and release l2arc_dev_mtx.
	*/
	if ((dev = l2arc_dev_get_next()) == NULL)
	continue;

	spa = dev->l2ad_spa;
	ASSERT3P(spa, !=, NULL);

	/*
	* If the pool is read-only then force the feed thread to
	* sleep a little longer.
	*/
	if (!spa_writeable(spa)) {
	next = ddi_get_lbolt() + 5 * l2arc_feed_secs * hz;
	spa_config_exit(spa, SCL_L2ARC, dev);
	continue;
	}

	/*
	* Avoid contributing to memory pressure.
	*/
	if (l2arc_hdr_limit_reached()) {
	ARCSTAT_BUMP(arcstat_l2_abort_lowmem);
	spa_config_exit(spa, SCL_L2ARC, dev);
	continue;
	}

	ARCSTAT_BUMP(arcstat_l2_feeds);

	size = l2arc_write_size(dev);

	/*
	* Evict L2ARC buffers that will be overwritten.
	*/
	l2arc_evict(dev, size, B_FALSE);

	/*
	* Write ARC buffers.
	*/
	wrote = l2arc_write_buffers(spa, dev, size);

	/*
	* Calculate interval between writes.
	*/
	next = l2arc_write_interval(begin, size, wrote);
	spa_config_exit(spa, SCL_L2ARC, dev);
	}
	spl_fstrans_unmark(cookie);

	l2arc_thread_exit = 0;
	cv_broadcast(&l2arc_feed_thr_cv);
	CALLB_CPR_EXIT(&cpr); /* drops l2arc_feed_thr_lock */
	thread_exit();
	}

	boolean_t
	l2arc_vdev_present(vdev_t *vd)
	{
	return (l2arc_vdev_get(vd) != NULL);
	}

	/*
	* Returns the l2arc_dev_t associated with a particular vdev_t or NULL if
	* the vdev_t isn't an L2ARC device.
	*/
	l2arc_dev_t *
	l2arc_vdev_get(vdev_t *vd)
	{
	l2arc_dev_t *dev;

	mutex_enter(&l2arc_dev_mtx);
	for (dev = list_head(l2arc_dev_list); dev != NULL;
	dev = list_next(l2arc_dev_list, dev)) {
	if (dev->l2ad_vdev == vd)
	break;
	}
	mutex_exit(&l2arc_dev_mtx);

	return (dev);
	}

	/*
	* Add a vdev for use by the L2ARC. By this point the spa has already
	* validated the vdev and opened it.
	*/
	void
	l2arc_add_vdev(spa_t spa, vdev_t vd)
	{
	l2arc_dev_t *adddev;
	uint64_t l2dhdr_asize;

	ASSERT(!l2arc_vdev_present(vd));

	/*
	* Create a new l2arc device entry.
	*/
	adddev = vmem_zalloc(sizeof (l2arc_dev_t), KM_SLEEP);
	adddev->l2ad_spa = spa;
	adddev->l2ad_vdev = vd;
	/* leave extra size for an l2arc device header */
	l2dhdr_asize = adddev->l2ad_dev_hdr_asize =
	MAX(sizeof (*adddev->l2ad_dev_hdr), 1 << vd->vdev_ashift);
	adddev->l2ad_start = VDEV_LABEL_START_SIZE + l2dhdr_asize;
	adddev->l2ad_end = VDEV_LABEL_START_SIZE + vdev_get_min_asize(vd);
	ASSERT3U(adddev->l2ad_start, <, adddev->l2ad_end);
	adddev->l2ad_hand = adddev->l2ad_start;
	adddev->l2ad_evict = adddev->l2ad_start;
	adddev->l2ad_first = B_TRUE;
	adddev->l2ad_writing = B_FALSE;
	adddev->l2ad_trim_all = B_FALSE;
	list_link_init(&adddev->l2ad_node);
	adddev->l2ad_dev_hdr = kmem_zalloc(l2dhdr_asize, KM_SLEEP);

	mutex_init(&adddev->l2ad_mtx, NULL, MUTEX_DEFAULT, NULL);
	/*
	* This is a list of all ARC buffers that are still valid on the
	* device.
	*/
	list_create(&adddev->l2ad_buflist, sizeof (arc_buf_hdr_t),
	offsetof(arc_buf_hdr_t, b_l2hdr.b_l2node));

	/*
	* This is a list of pointers to log blocks that are still present
	* on the device.
	*/
	list_create(&adddev->l2ad_lbptr_list, sizeof (l2arc_lb_ptr_buf_t),
	offsetof(l2arc_lb_ptr_buf_t, node));

	vdev_space_update(vd, 0, 0, adddev->l2ad_end - adddev->l2ad_hand);
	zfs_refcount_create(&adddev->l2ad_alloc);
	zfs_refcount_create(&adddev->l2ad_lb_asize);
	zfs_refcount_create(&adddev->l2ad_lb_count);

	/*
	* Add device to global list
	*/
	mutex_enter(&l2arc_dev_mtx);
	list_insert_head(l2arc_dev_list, adddev);
	atomic_inc_64(&l2arc_ndev);
	mutex_exit(&l2arc_dev_mtx);

	/*
	* Decide if vdev is eligible for L2ARC rebuild
	*/
	l2arc_rebuild_vdev(adddev->l2ad_vdev, B_FALSE);
	}

	void
	l2arc_rebuild_vdev(vdev_t *vd, boolean_t reopen)
	{
	l2arc_dev_t *dev = NULL;
	l2arc_dev_hdr_phys_t *l2dhdr;
	uint64_t l2dhdr_asize;
	spa_t *spa;

	dev = l2arc_vdev_get(vd);
	ASSERT3P(dev, !=, NULL);
	spa = dev->l2ad_spa;
	l2dhdr = dev->l2ad_dev_hdr;
	l2dhdr_asize = dev->l2ad_dev_hdr_asize;

	/*
	* The L2ARC has to hold at least the payload of one log block for
	* them to be restored (persistent L2ARC). The payload of a log block
	* depends on the amount of its log entries. We always write log blocks
	* with 1022 entries. How many of them are committed or restored depends
	* on the size of the L2ARC device. Thus the maximum payload of
	* one log block is 1022 * SPA_MAXBLOCKSIZE = 16GB. If the L2ARC device
	* is less than that, we reduce the amount of committed and restored
	* log entries per block so as to enable persistence.
	*/
	if (dev->l2ad_end < l2arc_rebuild_blocks_min_l2size) {
	dev->l2ad_log_entries = 0;
	} else {
	dev->l2ad_log_entries = MIN((dev->l2ad_end -
	dev->l2ad_start) >> SPA_MAXBLOCKSHIFT,
	L2ARC_LOG_BLK_MAX_ENTRIES);
	}

	/*
	* Read the device header, if an error is returned do not rebuild L2ARC.
	*/
	if (l2arc_dev_hdr_read(dev) == 0 && dev->l2ad_log_entries > 0) {
	/*
	* If we are onlining a cache device (vdev_reopen) that was
	* still present (l2arc_vdev_present()) and rebuild is enabled,
	* we should evict all ARC buffers and pointers to log blocks
	* and reclaim their space before restoring its contents to
	* L2ARC.
	*/
	if (reopen) {
	if (!l2arc_rebuild_enabled) {
	return;
	} else {
	l2arc_evict(dev, 0, B_TRUE);
	/* start a new log block */
	dev->l2ad_log_ent_idx = 0;
	dev->l2ad_log_blk_payload_asize = 0;
	dev->l2ad_log_blk_payload_start = 0;
	}
	}
	/*
	* Just mark the device as pending for a rebuild. We won't
	* be starting a rebuild in line here as it would block pool
	* import. Instead spa_load_impl will hand that off to an
	* async task which will call l2arc_spa_rebuild_start.
	*/
	dev->l2ad_rebuild = B_TRUE;
	} else if (spa_writeable(spa)) {
	/*
	* In this case TRIM the whole device if l2arc_trim_ahead > 0,
	* otherwise create a new header. We zero out the memory holding
	* the header to reset dh_start_lbps. If we TRIM the whole
	* device the new header will be written by
	* vdev_trim_l2arc_thread() at the end of the TRIM to update the
	* trim_state in the header too. When reading the header, if
	* trim_state is not VDEV_TRIM_COMPLETE and l2arc_trim_ahead > 0
	* we opt to TRIM the whole device again.
	*/
	if (l2arc_trim_ahead > 0) {
	dev->l2ad_trim_all = B_TRUE;
	} else {
	bzero(l2dhdr, l2dhdr_asize);
	l2arc_dev_hdr_update(dev);
	}
	}
	}

	/*
	* Remove a vdev from the L2ARC.
	*/
	void
	l2arc_remove_vdev(vdev_t *vd)
	{
	l2arc_dev_t *remdev = NULL;

	/*
	* Find the device by vdev
	*/
	remdev = l2arc_vdev_get(vd);
	ASSERT3P(remdev, !=, NULL);

	/*
	* Cancel any ongoing or scheduled rebuild.
	*/
	mutex_enter(&l2arc_rebuild_thr_lock);
	if (remdev->l2ad_rebuild_began == B_TRUE) {
	remdev->l2ad_rebuild_cancel = B_TRUE;
	while (remdev->l2ad_rebuild == B_TRUE)
	cv_wait(&l2arc_rebuild_thr_cv, &l2arc_rebuild_thr_lock);
	}
	mutex_exit(&l2arc_rebuild_thr_lock);

	/*
	* Remove device from global list
	*/
	mutex_enter(&l2arc_dev_mtx);
	list_remove(l2arc_dev_list, remdev);
	l2arc_dev_last = NULL; /* may have been invalidated */
	atomic_dec_64(&l2arc_ndev);
	mutex_exit(&l2arc_dev_mtx);

	/*
	* Clear all buflists and ARC references. L2ARC device flush.
	*/
	l2arc_evict(remdev, 0, B_TRUE);
	list_destroy(&remdev->l2ad_buflist);
	ASSERT(list_is_empty(&remdev->l2ad_lbptr_list));
	list_destroy(&remdev->l2ad_lbptr_list);
	mutex_destroy(&remdev->l2ad_mtx);
	zfs_refcount_destroy(&remdev->l2ad_alloc);
	zfs_refcount_destroy(&remdev->l2ad_lb_asize);
	zfs_refcount_destroy(&remdev->l2ad_lb_count);
	kmem_free(remdev->l2ad_dev_hdr, remdev->l2ad_dev_hdr_asize);
	vmem_free(remdev, sizeof (l2arc_dev_t));
	}

	void
	l2arc_init(void)
	{
	l2arc_thread_exit = 0;
	l2arc_ndev = 0;
	l2arc_writes_sent = 0;
	l2arc_writes_done = 0;

	mutex_init(&l2arc_feed_thr_lock, NULL, MUTEX_DEFAULT, NULL);
	cv_init(&l2arc_feed_thr_cv, NULL, CV_DEFAULT, NULL);
	mutex_init(&l2arc_rebuild_thr_lock, NULL, MUTEX_DEFAULT, NULL);
	cv_init(&l2arc_rebuild_thr_cv, NULL, CV_DEFAULT, NULL);
	mutex_init(&l2arc_dev_mtx, NULL, MUTEX_DEFAULT, NULL);
	mutex_init(&l2arc_free_on_write_mtx, NULL, MUTEX_DEFAULT, NULL);

	l2arc_dev_list = &L2ARC_dev_list;
	l2arc_free_on_write = &L2ARC_free_on_write;
	list_create(l2arc_dev_list, sizeof (l2arc_dev_t),
	offsetof(l2arc_dev_t, l2ad_node));
	list_create(l2arc_free_on_write, sizeof (l2arc_data_free_t),
	offsetof(l2arc_data_free_t, l2df_list_node));
	}

	void
	l2arc_fini(void)
	{
	mutex_destroy(&l2arc_feed_thr_lock);
	cv_destroy(&l2arc_feed_thr_cv);
	mutex_destroy(&l2arc_rebuild_thr_lock);
	cv_destroy(&l2arc_rebuild_thr_cv);
	mutex_destroy(&l2arc_dev_mtx);
	mutex_destroy(&l2arc_free_on_write_mtx);

	list_destroy(l2arc_dev_list);
	list_destroy(l2arc_free_on_write);
	}

	void
	l2arc_start(void)
	{
	if (!(spa_mode_global & SPA_MODE_WRITE))
	return;

	(void) thread_create(NULL, 0, l2arc_feed_thread, NULL, 0, &p0,
	TS_RUN, defclsyspri);
	}

	void
	l2arc_stop(void)
	{
	if (!(spa_mode_global & SPA_MODE_WRITE))
	return;

	mutex_enter(&l2arc_feed_thr_lock);
	cv_signal(&l2arc_feed_thr_cv); /* kick thread out of startup */
	l2arc_thread_exit = 1;
	while (l2arc_thread_exit != 0)
	cv_wait(&l2arc_feed_thr_cv, &l2arc_feed_thr_lock);
	mutex_exit(&l2arc_feed_thr_lock);
	}

	/*
	* Punches out rebuild threads for the L2ARC devices in a spa. This should
	* be called after pool import from the spa async thread, since starting
	* these threads directly from spa_import() will make them part of the
	* "zpool import" context and delay process exit (and thus pool import).
	*/
	void
	l2arc_spa_rebuild_start(spa_t *spa)
	{
	ASSERT(MUTEX_HELD(&spa_namespace_lock));

	/*
	* Locate the spa's l2arc devices and kick off rebuild threads.
	*/
	for (int i = 0; i < spa->spa_l2cache.sav_count; i++) {
	l2arc_dev_t *dev =
	l2arc_vdev_get(spa->spa_l2cache.sav_vdevs[i]);
	if (dev == NULL) {
	/* Don't attempt a rebuild if the vdev is UNAVAIL */
	continue;
	}
	mutex_enter(&l2arc_rebuild_thr_lock);
	if (dev->l2ad_rebuild && !dev->l2ad_rebuild_cancel) {
	dev->l2ad_rebuild_began = B_TRUE;
	(void) thread_create(NULL, 0, l2arc_dev_rebuild_thread,
	dev, 0, &p0, TS_RUN, minclsyspri);
	}
	mutex_exit(&l2arc_rebuild_thr_lock);
	}
	}

	/*
	* Main entry point for L2ARC rebuilding.
	*/
	static void
	l2arc_dev_rebuild_thread(void *arg)
	{
	l2arc_dev_t *dev = arg;

	VERIFY(!dev->l2ad_rebuild_cancel);
	VERIFY(dev->l2ad_rebuild);
	(void) l2arc_rebuild(dev);
	mutex_enter(&l2arc_rebuild_thr_lock);
	dev->l2ad_rebuild_began = B_FALSE;
	dev->l2ad_rebuild = B_FALSE;
	mutex_exit(&l2arc_rebuild_thr_lock);

	thread_exit();
	}

	/*
	* This function implements the actual L2ARC metadata rebuild. It:
	* starts reading the log block chain and restores each block's contents
	* to memory (reconstructing arc_buf_hdr_t's).
	*
	* Operation stops under any of the following conditions:
	*
	* 1) We reach the end of the log block chain.
	* 2) We encounter any error condition (cksum errors, io errors)
	*/
	static int
	l2arc_rebuild(l2arc_dev_t *dev)
	{
	vdev_t *vd = dev->l2ad_vdev;
	spa_t *spa = vd->vdev_spa;
	int err = 0;
	l2arc_dev_hdr_phys_t *l2dhdr = dev->l2ad_dev_hdr;
	l2arc_log_blk_phys_t this_lb, next_lb;
	zio_t this_io = NULL, next_io = NULL;
	l2arc_log_blkptr_t lbps[2];
	l2arc_lb_ptr_buf_t *lb_ptr_buf;
	boolean_t lock_held;

	this_lb = vmem_zalloc(sizeof (*this_lb), KM_SLEEP);
	next_lb = vmem_zalloc(sizeof (*next_lb), KM_SLEEP);

	/*
	* We prevent device removal while issuing reads to the device,
	* then during the rebuilding phases we drop this lock again so
	* that a spa_unload or device remove can be initiated - this is
	* safe, because the spa will signal us to stop before removing
	* our device and wait for us to stop.
	*/
	spa_config_enter(spa, SCL_L2ARC, vd, RW_READER);
	lock_held = B_TRUE;

	/*
	* Retrieve the persistent L2ARC device state.
	* L2BLK_GET_PSIZE returns aligned size for log blocks.
	*/
	dev->l2ad_evict = MAX(l2dhdr->dh_evict, dev->l2ad_start);
	dev->l2ad_hand = MAX(l2dhdr->dh_start_lbps[0].lbp_daddr +
	L2BLK_GET_PSIZE((&l2dhdr->dh_start_lbps[0])->lbp_prop),
	dev->l2ad_start);
	dev->l2ad_first = !!(l2dhdr->dh_flags & L2ARC_DEV_HDR_EVICT_FIRST);

	vd->vdev_trim_action_time = l2dhdr->dh_trim_action_time;
	vd->vdev_trim_state = l2dhdr->dh_trim_state;

	/*
	* In case the zfs module parameter l2arc_rebuild_enabled is false
	* we do not start the rebuild process.
	*/
	if (!l2arc_rebuild_enabled)
	goto out;

	/* Prepare the rebuild process */
	bcopy(l2dhdr->dh_start_lbps, lbps, sizeof (lbps));

	/* Start the rebuild process */
	for (;;) {
	if (!l2arc_log_blkptr_valid(dev, &lbps[0]))
	break;

	if ((err = l2arc_log_blk_read(dev, &lbps[0], &lbps[1],
	this_lb, next_lb, this_io, &next_io)) != 0)
	goto out;

	/*
	* Our memory pressure valve. If the system is running low
	* on memory, rather than swamping memory with new ARC buf
	* hdrs, we opt not to rebuild the L2ARC. At this point,
	* however, we have already set up our L2ARC dev to chain in
	* new metadata log blocks, so the user may choose to offline/
	* online the L2ARC dev at a later time (or re-import the pool)
	* to reconstruct it (when there's less memory pressure).
	*/
	if (l2arc_hdr_limit_reached()) {
	ARCSTAT_BUMP(arcstat_l2_rebuild_abort_lowmem);
	cmn_err(CE_NOTE, "System running low on memory, "
	"aborting L2ARC rebuild.");
	err = SET_ERROR(ENOMEM);
	goto out;
	}

	spa_config_exit(spa, SCL_L2ARC, vd);
	lock_held = B_FALSE;

	/*
	* Now that we know that the next_lb checks out alright, we
	* can start reconstruction from this log block.
	* L2BLK_GET_PSIZE returns aligned size for log blocks.
	*/
	uint64_t asize = L2BLK_GET_PSIZE((&lbps[0])->lbp_prop);
	l2arc_log_blk_restore(dev, this_lb, asize);

	/*
	* log block restored, include its pointer in the list of
	* pointers to log blocks present in the L2ARC device.
	*/
	lb_ptr_buf = kmem_zalloc(sizeof (l2arc_lb_ptr_buf_t), KM_SLEEP);
	lb_ptr_buf->lb_ptr = kmem_zalloc(sizeof (l2arc_log_blkptr_t),
	KM_SLEEP);
	bcopy(&lbps[0], lb_ptr_buf->lb_ptr,
	sizeof (l2arc_log_blkptr_t));
	mutex_enter(&dev->l2ad_mtx);
	list_insert_tail(&dev->l2ad_lbptr_list, lb_ptr_buf);
	ARCSTAT_INCR(arcstat_l2_log_blk_asize, asize);
	ARCSTAT_BUMP(arcstat_l2_log_blk_count);
	zfs_refcount_add_many(&dev->l2ad_lb_asize, asize, lb_ptr_buf);
	zfs_refcount_add(&dev->l2ad_lb_count, lb_ptr_buf);
	mutex_exit(&dev->l2ad_mtx);
	vdev_space_update(vd, asize, 0, 0);

	/*
	* Protection against loops of log blocks:
	*
	* l2ad_hand l2ad_evict
	* V V
	* l2ad_start \|=======================================\| l2ad_end
	* -----\|\|\|----\|\|\|---\|\|\|----\|\|\|
	* (3) (2) (1) (0)
	* ---\|\|\|---\|\|\|----\|\|\|---\|\|\|
	* (7) (6) (5) (4)
	*
	* In this situation the pointer of log block (4) passes
	* l2arc_log_blkptr_valid() but the log block should not be
	* restored as it is overwritten by the payload of log block
	* (0). Only log blocks (0)-(3) should be restored. We check
	* whether l2ad_evict lies in between the payload starting
	* offset of the next log block (lbps[1].lbp_payload_start)
	* and the payload starting offset of the present log block
	* (lbps[0].lbp_payload_start). If true and this isn't the
	* first pass, we are looping from the beginning and we should
	* stop.
	*/
	if (l2arc_range_check_overlap(lbps[1].lbp_payload_start,
	lbps[0].lbp_payload_start, dev->l2ad_evict) &&
	!dev->l2ad_first)
	goto out;

	cond_resched();
	for (;;) {
	mutex_enter(&l2arc_rebuild_thr_lock);
	if (dev->l2ad_rebuild_cancel) {
	dev->l2ad_rebuild = B_FALSE;
	cv_signal(&l2arc_rebuild_thr_cv);
	mutex_exit(&l2arc_rebuild_thr_lock);
	err = SET_ERROR(ECANCELED);
	goto out;
	}
	mutex_exit(&l2arc_rebuild_thr_lock);
	if (spa_config_tryenter(spa, SCL_L2ARC, vd,
	RW_READER)) {
	lock_held = B_TRUE;
	break;
	}
	/*
	* L2ARC config lock held by somebody in writer,
	* possibly due to them trying to remove us. They'll
	* likely to want us to shut down, so after a little
	* delay, we check l2ad_rebuild_cancel and retry
	* the lock again.
	*/
	delay(1);
	}

	/*
	* Continue with the next log block.
	*/
	lbps[0] = lbps[1];
	lbps[1] = this_lb->lb_prev_lbp;
	PTR_SWAP(this_lb, next_lb);
	this_io = next_io;
	next_io = NULL;
	}

	if (this_io != NULL)
	l2arc_log_blk_fetch_abort(this_io);
	out:
	if (next_io != NULL)
	l2arc_log_blk_fetch_abort(next_io);
	vmem_free(this_lb, sizeof (*this_lb));
	vmem_free(next_lb, sizeof (*next_lb));

	if (!l2arc_rebuild_enabled) {
	spa_history_log_internal(spa, "L2ARC rebuild", NULL,
	"disabled");
	} else if (err == 0 && zfs_refcount_count(&dev->l2ad_lb_count) > 0) {
	ARCSTAT_BUMP(arcstat_l2_rebuild_success);
	spa_history_log_internal(spa, "L2ARC rebuild", NULL,
	"successful, restored %llu blocks",
	(u_longlong_t)zfs_refcount_count(&dev->l2ad_lb_count));
	} else if (err == 0 && zfs_refcount_count(&dev->l2ad_lb_count) == 0) {
	/*
	* No error but also nothing restored, meaning the lbps array
	* in the device header points to invalid/non-present log
	* blocks. Reset the header.
	*/
	spa_history_log_internal(spa, "L2ARC rebuild", NULL,
	"no valid log blocks");
	bzero(l2dhdr, dev->l2ad_dev_hdr_asize);
	l2arc_dev_hdr_update(dev);
	} else if (err == ECANCELED) {
	/*
	* In case the rebuild was canceled do not log to spa history
	* log as the pool may be in the process of being removed.
	*/
	zfs_dbgmsg("L2ARC rebuild aborted, restored %llu blocks",
	zfs_refcount_count(&dev->l2ad_lb_count));
	} else if (err != 0) {
	spa_history_log_internal(spa, "L2ARC rebuild", NULL,
	"aborted, restored %llu blocks",
	(u_longlong_t)zfs_refcount_count(&dev->l2ad_lb_count));
	}

	if (lock_held)
	spa_config_exit(spa, SCL_L2ARC, vd);

	return (err);
	}

	/*
	* Attempts to read the device header on the provided L2ARC device and writes
	* it to `hdr'. On success, this function returns 0, otherwise the appropriate
	* error code is returned.
	*/
	static int
	l2arc_dev_hdr_read(l2arc_dev_t *dev)
	{
	int err;
	uint64_t guid;
	l2arc_dev_hdr_phys_t *l2dhdr = dev->l2ad_dev_hdr;
	const uint64_t l2dhdr_asize = dev->l2ad_dev_hdr_asize;
	abd_t *abd;

	guid = spa_guid(dev->l2ad_vdev->vdev_spa);

	abd = abd_get_from_buf(l2dhdr, l2dhdr_asize);

	err = zio_wait(zio_read_phys(NULL, dev->l2ad_vdev,
	VDEV_LABEL_START_SIZE, l2dhdr_asize, abd,
	ZIO_CHECKSUM_LABEL, NULL, NULL, ZIO_PRIORITY_SYNC_READ,
	ZIO_FLAG_DONT_CACHE \| ZIO_FLAG_CANFAIL \|
	ZIO_FLAG_DONT_PROPAGATE \| ZIO_FLAG_DONT_RETRY \|
	ZIO_FLAG_SPECULATIVE, B_FALSE));

	abd_free(abd);

	if (err != 0) {
	ARCSTAT_BUMP(arcstat_l2_rebuild_abort_dh_errors);
	zfs_dbgmsg("L2ARC IO error (%d) while reading device header, "
	"vdev guid: %llu", err, dev->l2ad_vdev->vdev_guid);
	return (err);
	}

	if (l2dhdr->dh_magic == BSWAP_64(L2ARC_DEV_HDR_MAGIC))
	byteswap_uint64_array(l2dhdr, sizeof (*l2dhdr));

	if (l2dhdr->dh_magic != L2ARC_DEV_HDR_MAGIC \|\|
	l2dhdr->dh_spa_guid != guid \|\|
	l2dhdr->dh_vdev_guid != dev->l2ad_vdev->vdev_guid \|\|
	l2dhdr->dh_version != L2ARC_PERSISTENT_VERSION \|\|
	l2dhdr->dh_log_entries != dev->l2ad_log_entries \|\|
	l2dhdr->dh_end != dev->l2ad_end \|\|
	!l2arc_range_check_overlap(dev->l2ad_start, dev->l2ad_end,
	l2dhdr->dh_evict) \|\|
	(l2dhdr->dh_trim_state != VDEV_TRIM_COMPLETE &&
	l2arc_trim_ahead > 0)) {
	/*
	* Attempt to rebuild a device containing no actual dev hdr
	* or containing a header from some other pool or from another
	* version of persistent L2ARC.
	*/
	ARCSTAT_BUMP(arcstat_l2_rebuild_abort_unsupported);
	return (SET_ERROR(ENOTSUP));
	}

	return (0);
	}

	/*
	* Reads L2ARC log blocks from storage and validates their contents.
	*
	* This function implements a simple fetcher to make sure that while
	* we're processing one buffer the L2ARC is already fetching the next
	* one in the chain.
	*
	* The arguments this_lp and next_lp point to the current and next log block
	* address in the block chain. Similarly, this_lb and next_lb hold the
	* l2arc_log_blk_phys_t's of the current and next L2ARC blk.
	*
	* The `this_io' and `next_io' arguments are used for block fetching.
	* When issuing the first blk IO during rebuild, you should pass NULL for
	* `this_io'. This function will then issue a sync IO to read the block and
	* also issue an async IO to fetch the next block in the block chain. The
	* fetched IO is returned in `next_io'. On subsequent calls to this
	* function, pass the value returned in `next_io' from the previous call
	* as `this_io' and a fresh `next_io' pointer to hold the next fetch IO.
	* Prior to the call, you should initialize your `next_io' pointer to be
	* NULL. If no fetch IO was issued, the pointer is left set at NULL.
	*
	* On success, this function returns 0, otherwise it returns an appropriate
	* error code. On error the fetching IO is aborted and cleared before
	* returning from this function. Therefore, if we return `success', the
	* caller can assume that we have taken care of cleanup of fetch IOs.
	*/
	static int
	l2arc_log_blk_read(l2arc_dev_t *dev,
	const l2arc_log_blkptr_t this_lbp, const l2arc_log_blkptr_t next_lbp,
	l2arc_log_blk_phys_t this_lb, l2arc_log_blk_phys_t next_lb,
	zio_t this_io, zio_t *next_io)
	{
	int err = 0;
	zio_cksum_t cksum;
	abd_t *abd = NULL;
	uint64_t asize;

	ASSERT(this_lbp != NULL && next_lbp != NULL);
	ASSERT(this_lb != NULL && next_lb != NULL);
	ASSERT(next_io != NULL && *next_io == NULL);
	ASSERT(l2arc_log_blkptr_valid(dev, this_lbp));

	/*
	* Check to see if we have issued the IO for this log block in a
	* previous run. If not, this is the first call, so issue it now.
	*/
	if (this_io == NULL) {
	this_io = l2arc_log_blk_fetch(dev->l2ad_vdev, this_lbp,
	this_lb);
	}

	/*
	* Peek to see if we can start issuing the next IO immediately.
	*/
	if (l2arc_log_blkptr_valid(dev, next_lbp)) {
	/*
	* Start issuing IO for the next log block early - this
	* should help keep the L2ARC device busy while we
	* decompress and restore this log block.
	*/
	*next_io = l2arc_log_blk_fetch(dev->l2ad_vdev, next_lbp,
	next_lb);
	}

	/* Wait for the IO to read this log block to complete */
	if ((err = zio_wait(this_io)) != 0) {
	ARCSTAT_BUMP(arcstat_l2_rebuild_abort_io_errors);
	zfs_dbgmsg("L2ARC IO error (%d) while reading log block, "
	"offset: %llu, vdev guid: %llu", err, this_lbp->lbp_daddr,
	dev->l2ad_vdev->vdev_guid);
	goto cleanup;
	}

	/*
	* Make sure the buffer checks out.
	* L2BLK_GET_PSIZE returns aligned size for log blocks.
	*/
	asize = L2BLK_GET_PSIZE((this_lbp)->lbp_prop);
	fletcher_4_native(this_lb, asize, NULL, &cksum);
	if (!ZIO_CHECKSUM_EQUAL(cksum, this_lbp->lbp_cksum)) {
	ARCSTAT_BUMP(arcstat_l2_rebuild_abort_cksum_lb_errors);
	zfs_dbgmsg("L2ARC log block cksum failed, offset: %llu, "
	"vdev guid: %llu, l2ad_hand: %llu, l2ad_evict: %llu",
	this_lbp->lbp_daddr, dev->l2ad_vdev->vdev_guid,
	dev->l2ad_hand, dev->l2ad_evict);
	err = SET_ERROR(ECKSUM);
	goto cleanup;
	}

	/* Now we can take our time decoding this buffer */
	switch (L2BLK_GET_COMPRESS((this_lbp)->lbp_prop)) {
	case ZIO_COMPRESS_OFF:
	break;
	case ZIO_COMPRESS_LZ4:
	abd = abd_alloc_for_io(asize, B_TRUE);
	abd_copy_from_buf_off(abd, this_lb, 0, asize);
	if ((err = zio_decompress_data(
	L2BLK_GET_COMPRESS((this_lbp)->lbp_prop),
	abd, this_lb, asize, sizeof (*this_lb), NULL)) != 0) {
	err = SET_ERROR(EINVAL);
	goto cleanup;
	}
	break;
	default:
	err = SET_ERROR(EINVAL);
	goto cleanup;
	}
	if (this_lb->lb_magic == BSWAP_64(L2ARC_LOG_BLK_MAGIC))
	byteswap_uint64_array(this_lb, sizeof (*this_lb));
	if (this_lb->lb_magic != L2ARC_LOG_BLK_MAGIC) {
	err = SET_ERROR(EINVAL);
	goto cleanup;
	}
	cleanup:
	/* Abort an in-flight fetch I/O in case of error */
	if (err != 0 && *next_io != NULL) {
	l2arc_log_blk_fetch_abort(*next_io);
	*next_io = NULL;
	}
	if (abd != NULL)
	abd_free(abd);
	return (err);
	}

	/*
	* Restores the payload of a log block to ARC. This creates empty ARC hdr
	* entries which only contain an l2arc hdr, essentially restoring the
	* buffers to their L2ARC evicted state. This function also updates space
	* usage on the L2ARC vdev to make sure it tracks restored buffers.
	*/
	static void
	l2arc_log_blk_restore(l2arc_dev_t dev, const l2arc_log_blk_phys_t lb,
	uint64_t lb_asize)
	{
	uint64_t size = 0, asize = 0;
	uint64_t log_entries = dev->l2ad_log_entries;

	/*
	* Usually arc_adapt() is called only for data, not headers, but
	* since we may allocate significant amount of memory here, let ARC
	* grow its arc_c.
	*/
	arc_adapt(log_entries * HDR_L2ONLY_SIZE, arc_l2c_only);

	for (int i = log_entries - 1; i >= 0; i--) {
	/*
	* Restore goes in the reverse temporal direction to preserve
	* correct temporal ordering of buffers in the l2ad_buflist.
	* l2arc_hdr_restore also does a list_insert_tail instead of
	* list_insert_head on the l2ad_buflist:
	*
	* LIST l2ad_buflist LIST
	* HEAD <------ (time) ------ TAIL
	* direction +-----+-----+-----+-----+-----+ direction
	* of l2arc <== \| buf \| buf \| buf \| buf \| buf \| ===> of rebuild
	* fill +-----+-----+-----+-----+-----+
	* ^ ^
	* \| \|
	* \| \|
	* l2arc_feed_thread l2arc_rebuild
	* will place new bufs here restores bufs here
	*
	* During l2arc_rebuild() the device is not used by
	* l2arc_feed_thread() as dev->l2ad_rebuild is set to true.
	*/
	size += L2BLK_GET_LSIZE((&lb->lb_entries[i])->le_prop);
	asize += vdev_psize_to_asize(dev->l2ad_vdev,
	L2BLK_GET_PSIZE((&lb->lb_entries[i])->le_prop));
	l2arc_hdr_restore(&lb->lb_entries[i], dev);
	}

	/*
	* Record rebuild stats:
	* size Logical size of restored buffers in the L2ARC
	* asize Aligned size of restored buffers in the L2ARC
	*/
	ARCSTAT_INCR(arcstat_l2_rebuild_size, size);
	ARCSTAT_INCR(arcstat_l2_rebuild_asize, asize);
	ARCSTAT_INCR(arcstat_l2_rebuild_bufs, log_entries);
	ARCSTAT_F_AVG(arcstat_l2_log_blk_avg_asize, lb_asize);
	ARCSTAT_F_AVG(arcstat_l2_data_to_meta_ratio, asize / lb_asize);
	ARCSTAT_BUMP(arcstat_l2_rebuild_log_blks);
	}

	/*
	* Restores a single ARC buf hdr from a log entry. The ARC buffer is put
	* into a state indicating that it has been evicted to L2ARC.
	*/
	static void
	l2arc_hdr_restore(const l2arc_log_ent_phys_t le, l2arc_dev_t dev)
	{
	arc_buf_hdr_t hdr, exists;
	kmutex_t *hash_lock;
	arc_buf_contents_t type = L2BLK_GET_TYPE((le)->le_prop);
	uint64_t asize;

	/*
	* Do all the allocation before grabbing any locks, this lets us
	* sleep if memory is full and we don't have to deal with failed
	* allocations.
	*/
	hdr = arc_buf_alloc_l2only(L2BLK_GET_LSIZE((le)->le_prop), type,
	dev, le->le_dva, le->le_daddr,
	L2BLK_GET_PSIZE((le)->le_prop), le->le_birth,
	L2BLK_GET_COMPRESS((le)->le_prop), le->le_complevel,
	L2BLK_GET_PROTECTED((le)->le_prop),
	L2BLK_GET_PREFETCH((le)->le_prop),
	L2BLK_GET_STATE((le)->le_prop));
	asize = vdev_psize_to_asize(dev->l2ad_vdev,
	L2BLK_GET_PSIZE((le)->le_prop));

	/*
	* vdev_space_update() has to be called before arc_hdr_destroy() to
	* avoid underflow since the latter also calls vdev_space_update().
	*/
	l2arc_hdr_arcstats_increment(hdr);
	vdev_space_update(dev->l2ad_vdev, asize, 0, 0);

	mutex_enter(&dev->l2ad_mtx);
	list_insert_tail(&dev->l2ad_buflist, hdr);
	(void) zfs_refcount_add_many(&dev->l2ad_alloc, arc_hdr_size(hdr), hdr);
	mutex_exit(&dev->l2ad_mtx);

	exists = buf_hash_insert(hdr, &hash_lock);
	if (exists) {
	/* Buffer was already cached, no need to restore it. */
	arc_hdr_destroy(hdr);
	/*
	* If the buffer is already cached, check whether it has
	* L2ARC metadata. If not, enter them and update the flag.
	* This is important is case of onlining a cache device, since
	* we previously evicted all L2ARC metadata from ARC.
	*/
	if (!HDR_HAS_L2HDR(exists)) {
	arc_hdr_set_flags(exists, ARC_FLAG_HAS_L2HDR);
	exists->b_l2hdr.b_dev = dev;
	exists->b_l2hdr.b_daddr = le->le_daddr;
	exists->b_l2hdr.b_arcs_state =
	L2BLK_GET_STATE((le)->le_prop);
	mutex_enter(&dev->l2ad_mtx);
	list_insert_tail(&dev->l2ad_buflist, exists);
	(void) zfs_refcount_add_many(&dev->l2ad_alloc,
	arc_hdr_size(exists), exists);
	mutex_exit(&dev->l2ad_mtx);
	l2arc_hdr_arcstats_increment(exists);
	vdev_space_update(dev->l2ad_vdev, asize, 0, 0);
	}
	ARCSTAT_BUMP(arcstat_l2_rebuild_bufs_precached);
	}

	mutex_exit(hash_lock);
	}

	/*
	* Starts an asynchronous read IO to read a log block. This is used in log
	* block reconstruction to start reading the next block before we are done
	* decoding and reconstructing the current block, to keep the l2arc device
	* nice and hot with read IO to process.
	* The returned zio will contain a newly allocated memory buffers for the IO
	* data which should then be freed by the caller once the zio is no longer
	* needed (i.e. due to it having completed). If you wish to abort this
	* zio, you should do so using l2arc_log_blk_fetch_abort, which takes
	* care of disposing of the allocated buffers correctly.
	*/
	static zio_t *
	l2arc_log_blk_fetch(vdev_t vd, const l2arc_log_blkptr_t lbp,
	l2arc_log_blk_phys_t *lb)
	{
	uint32_t asize;
	zio_t *pio;
	l2arc_read_callback_t *cb;

	/* L2BLK_GET_PSIZE returns aligned size for log blocks */
	asize = L2BLK_GET_PSIZE((lbp)->lbp_prop);
	ASSERT(asize <= sizeof (l2arc_log_blk_phys_t));

	cb = kmem_zalloc(sizeof (l2arc_read_callback_t), KM_SLEEP);
	cb->l2rcb_abd = abd_get_from_buf(lb, asize);
	pio = zio_root(vd->vdev_spa, l2arc_blk_fetch_done, cb,
	ZIO_FLAG_DONT_CACHE \| ZIO_FLAG_CANFAIL \| ZIO_FLAG_DONT_PROPAGATE \|
	ZIO_FLAG_DONT_RETRY);
	(void) zio_nowait(zio_read_phys(pio, vd, lbp->lbp_daddr, asize,
	cb->l2rcb_abd, ZIO_CHECKSUM_OFF, NULL, NULL,
	ZIO_PRIORITY_ASYNC_READ, ZIO_FLAG_DONT_CACHE \| ZIO_FLAG_CANFAIL \|
	ZIO_FLAG_DONT_PROPAGATE \| ZIO_FLAG_DONT_RETRY, B_FALSE));

	return (pio);
	}

	/*
	* Aborts a zio returned from l2arc_log_blk_fetch and frees the data
	* buffers allocated for it.
	*/
	static void
	l2arc_log_blk_fetch_abort(zio_t *zio)
	{
	(void) zio_wait(zio);
	}

	/*
	* Creates a zio to update the device header on an l2arc device.
	*/
	void
	l2arc_dev_hdr_update(l2arc_dev_t *dev)
	{
	l2arc_dev_hdr_phys_t *l2dhdr = dev->l2ad_dev_hdr;
	const uint64_t l2dhdr_asize = dev->l2ad_dev_hdr_asize;
	abd_t *abd;
	int err;

	VERIFY(spa_config_held(dev->l2ad_spa, SCL_STATE_ALL, RW_READER));

	l2dhdr->dh_magic = L2ARC_DEV_HDR_MAGIC;
	l2dhdr->dh_version = L2ARC_PERSISTENT_VERSION;
	l2dhdr->dh_spa_guid = spa_guid(dev->l2ad_vdev->vdev_spa);
	l2dhdr->dh_vdev_guid = dev->l2ad_vdev->vdev_guid;
	l2dhdr->dh_log_entries = dev->l2ad_log_entries;
	l2dhdr->dh_evict = dev->l2ad_evict;
	l2dhdr->dh_start = dev->l2ad_start;
	l2dhdr->dh_end = dev->l2ad_end;
	l2dhdr->dh_lb_asize = zfs_refcount_count(&dev->l2ad_lb_asize);
	l2dhdr->dh_lb_count = zfs_refcount_count(&dev->l2ad_lb_count);
	l2dhdr->dh_flags = 0;
	l2dhdr->dh_trim_action_time = dev->l2ad_vdev->vdev_trim_action_time;
	l2dhdr->dh_trim_state = dev->l2ad_vdev->vdev_trim_state;
	if (dev->l2ad_first)
	l2dhdr->dh_flags \|= L2ARC_DEV_HDR_EVICT_FIRST;

	abd = abd_get_from_buf(l2dhdr, l2dhdr_asize);

	err = zio_wait(zio_write_phys(NULL, dev->l2ad_vdev,
	VDEV_LABEL_START_SIZE, l2dhdr_asize, abd, ZIO_CHECKSUM_LABEL, NULL,
	NULL, ZIO_PRIORITY_ASYNC_WRITE, ZIO_FLAG_CANFAIL, B_FALSE));

	abd_free(abd);

	if (err != 0) {
	zfs_dbgmsg("L2ARC IO error (%d) while writing device header, "
	"vdev guid: %llu", err, dev->l2ad_vdev->vdev_guid);
	}
	}

	/*
	* Commits a log block to the L2ARC device. This routine is invoked from
	* l2arc_write_buffers when the log block fills up.
	* This function allocates some memory to temporarily hold the serialized
	* buffer to be written. This is then released in l2arc_write_done.
	*/
	static void
	l2arc_log_blk_commit(l2arc_dev_t dev, zio_t pio, l2arc_write_callback_t *cb)
	{
	l2arc_log_blk_phys_t *lb = &dev->l2ad_log_blk;
	l2arc_dev_hdr_phys_t *l2dhdr = dev->l2ad_dev_hdr;
	uint64_t psize, asize;
	zio_t *wzio;
	l2arc_lb_abd_buf_t *abd_buf;
	uint8_t *tmpbuf;
	l2arc_lb_ptr_buf_t *lb_ptr_buf;

	VERIFY3S(dev->l2ad_log_ent_idx, ==, dev->l2ad_log_entries);

	tmpbuf = zio_buf_alloc(sizeof (*lb));
	abd_buf = zio_buf_alloc(sizeof (*abd_buf));
	abd_buf->abd = abd_get_from_buf(lb, sizeof (*lb));
	lb_ptr_buf = kmem_zalloc(sizeof (l2arc_lb_ptr_buf_t), KM_SLEEP);
	lb_ptr_buf->lb_ptr = kmem_zalloc(sizeof (l2arc_log_blkptr_t), KM_SLEEP);

	/* link the buffer into the block chain */
	lb->lb_prev_lbp = l2dhdr->dh_start_lbps[1];
	lb->lb_magic = L2ARC_LOG_BLK_MAGIC;

	/*
	* l2arc_log_blk_commit() may be called multiple times during a single
	* l2arc_write_buffers() call. Save the allocated abd buffers in a list
	* so we can free them in l2arc_write_done() later on.
	*/
	list_insert_tail(&cb->l2wcb_abd_list, abd_buf);

	/* try to compress the buffer */
	psize = zio_compress_data(ZIO_COMPRESS_LZ4,
	abd_buf->abd, tmpbuf, sizeof (*lb), 0);

	/* a log block is never entirely zero */
	ASSERT(psize != 0);
	asize = vdev_psize_to_asize(dev->l2ad_vdev, psize);
	ASSERT(asize <= sizeof (*lb));

	/*
	* Update the start log block pointer in the device header to point
	* to the log block we're about to write.
	*/
	l2dhdr->dh_start_lbps[1] = l2dhdr->dh_start_lbps[0];
	l2dhdr->dh_start_lbps[0].lbp_daddr = dev->l2ad_hand;
	l2dhdr->dh_start_lbps[0].lbp_payload_asize =
	dev->l2ad_log_blk_payload_asize;
	l2dhdr->dh_start_lbps[0].lbp_payload_start =
	dev->l2ad_log_blk_payload_start;
	_NOTE(CONSTCOND)
	L2BLK_SET_LSIZE(
	(&l2dhdr->dh_start_lbps[0])->lbp_prop, sizeof (*lb));
	L2BLK_SET_PSIZE(
	(&l2dhdr->dh_start_lbps[0])->lbp_prop, asize);
	L2BLK_SET_CHECKSUM(
	(&l2dhdr->dh_start_lbps[0])->lbp_prop,
	ZIO_CHECKSUM_FLETCHER_4);
	if (asize < sizeof (*lb)) {
	/* compression succeeded */
	bzero(tmpbuf + psize, asize - psize);
	L2BLK_SET_COMPRESS(
	(&l2dhdr->dh_start_lbps[0])->lbp_prop,
	ZIO_COMPRESS_LZ4);
	} else {
	/* compression failed */
	bcopy(lb, tmpbuf, sizeof (*lb));
	L2BLK_SET_COMPRESS(
	(&l2dhdr->dh_start_lbps[0])->lbp_prop,
	ZIO_COMPRESS_OFF);
	}

	/* checksum what we're about to write */
	fletcher_4_native(tmpbuf, asize, NULL,
	&l2dhdr->dh_start_lbps[0].lbp_cksum);

	abd_free(abd_buf->abd);

	/* perform the write itself */
	abd_buf->abd = abd_get_from_buf(tmpbuf, sizeof (*lb));
	abd_take_ownership_of_buf(abd_buf->abd, B_TRUE);
	wzio = zio_write_phys(pio, dev->l2ad_vdev, dev->l2ad_hand,
	asize, abd_buf->abd, ZIO_CHECKSUM_OFF, NULL, NULL,
	ZIO_PRIORITY_ASYNC_WRITE, ZIO_FLAG_CANFAIL, B_FALSE);
	DTRACE_PROBE2(l2arc__write, vdev_t , dev->l2ad_vdev, zio_t , wzio);
	(void) zio_nowait(wzio);

	dev->l2ad_hand += asize;
	/*
	* Include the committed log block's pointer in the list of pointers
	* to log blocks present in the L2ARC device.
	*/
	bcopy(&l2dhdr->dh_start_lbps[0], lb_ptr_buf->lb_ptr,
	sizeof (l2arc_log_blkptr_t));
	mutex_enter(&dev->l2ad_mtx);
	list_insert_head(&dev->l2ad_lbptr_list, lb_ptr_buf);
	ARCSTAT_INCR(arcstat_l2_log_blk_asize, asize);
	ARCSTAT_BUMP(arcstat_l2_log_blk_count);
	zfs_refcount_add_many(&dev->l2ad_lb_asize, asize, lb_ptr_buf);
	zfs_refcount_add(&dev->l2ad_lb_count, lb_ptr_buf);
	mutex_exit(&dev->l2ad_mtx);
	vdev_space_update(dev->l2ad_vdev, asize, 0, 0);

	/* bump the kstats */
	ARCSTAT_INCR(arcstat_l2_write_bytes, asize);
	ARCSTAT_BUMP(arcstat_l2_log_blk_writes);
	ARCSTAT_F_AVG(arcstat_l2_log_blk_avg_asize, asize);
	ARCSTAT_F_AVG(arcstat_l2_data_to_meta_ratio,
	dev->l2ad_log_blk_payload_asize / asize);

	/* start a new log block */
	dev->l2ad_log_ent_idx = 0;
	dev->l2ad_log_blk_payload_asize = 0;
	dev->l2ad_log_blk_payload_start = 0;
	}

	/*
	* Validates an L2ARC log block address to make sure that it can be read
	* from the provided L2ARC device.
	*/
	boolean_t
	l2arc_log_blkptr_valid(l2arc_dev_t dev, const l2arc_log_blkptr_t lbp)
	{
	/* L2BLK_GET_PSIZE returns aligned size for log blocks */
	uint64_t asize = L2BLK_GET_PSIZE((lbp)->lbp_prop);
	uint64_t end = lbp->lbp_daddr + asize - 1;
	uint64_t start = lbp->lbp_payload_start;
	boolean_t evicted = B_FALSE;

	/*
	* A log block is valid if all of the following conditions are true:
	* - it fits entirely (including its payload) between l2ad_start and
	* l2ad_end
	* - it has a valid size
	* - neither the log block itself nor part of its payload was evicted
	* by l2arc_evict():
	*
	* l2ad_hand l2ad_evict
	* \| \| lbp_daddr
	* \| start \| \| end
	* \| \| \| \| \|
	* V V V V V
	* l2ad_start ============================================ l2ad_end
	* --------------------------\|\|\|\|
	* ^ ^
	* \| log block
	* payload
	*/

	evicted =
	l2arc_range_check_overlap(start, end, dev->l2ad_hand) \|\|
	l2arc_range_check_overlap(start, end, dev->l2ad_evict) \|\|
	l2arc_range_check_overlap(dev->l2ad_hand, dev->l2ad_evict, start) \|\|
	l2arc_range_check_overlap(dev->l2ad_hand, dev->l2ad_evict, end);

	return (start >= dev->l2ad_start && end <= dev->l2ad_end &&
	asize > 0 && asize <= sizeof (l2arc_log_blk_phys_t) &&
	(!evicted \|\| dev->l2ad_first));
	}

	/*
	* Inserts ARC buffer header `hdr' into the current L2ARC log block on
	* the device. The buffer being inserted must be present in L2ARC.
	* Returns B_TRUE if the L2ARC log block is full and needs to be committed
	* to L2ARC, or B_FALSE if it still has room for more ARC buffers.
	*/
	static boolean_t
	l2arc_log_blk_insert(l2arc_dev_t dev, const arc_buf_hdr_t hdr)
	{
	l2arc_log_blk_phys_t *lb = &dev->l2ad_log_blk;
	l2arc_log_ent_phys_t *le;

	if (dev->l2ad_log_entries == 0)
	return (B_FALSE);

	int index = dev->l2ad_log_ent_idx++;

	ASSERT3S(index, <, dev->l2ad_log_entries);
	ASSERT(HDR_HAS_L2HDR(hdr));

	le = &lb->lb_entries[index];
	bzero(le, sizeof (*le));
	le->le_dva = hdr->b_dva;
	le->le_birth = hdr->b_birth;
	le->le_daddr = hdr->b_l2hdr.b_daddr;
	if (index == 0)
	dev->l2ad_log_blk_payload_start = le->le_daddr;
	L2BLK_SET_LSIZE((le)->le_prop, HDR_GET_LSIZE(hdr));
	L2BLK_SET_PSIZE((le)->le_prop, HDR_GET_PSIZE(hdr));
	L2BLK_SET_COMPRESS((le)->le_prop, HDR_GET_COMPRESS(hdr));
	le->le_complevel = hdr->b_complevel;
	L2BLK_SET_TYPE((le)->le_prop, hdr->b_type);
	L2BLK_SET_PROTECTED((le)->le_prop, !!(HDR_PROTECTED(hdr)));
	L2BLK_SET_PREFETCH((le)->le_prop, !!(HDR_PREFETCH(hdr)));
	L2BLK_SET_STATE((le)->le_prop, hdr->b_l1hdr.b_state->arcs_state);

	dev->l2ad_log_blk_payload_asize += vdev_psize_to_asize(dev->l2ad_vdev,
	HDR_GET_PSIZE(hdr));

	return (dev->l2ad_log_ent_idx == dev->l2ad_log_entries);
	}

	/*
	* Checks whether a given L2ARC device address sits in a time-sequential
	* range. The trick here is that the L2ARC is a rotary buffer, so we can't
	* just do a range comparison, we need to handle the situation in which the
	* range wraps around the end of the L2ARC device. Arguments:
	* bottom -- Lower end of the range to check (written to earlier).
	* top -- Upper end of the range to check (written to later).
	* check -- The address for which we want to determine if it sits in
	* between the top and bottom.
	*
	* The 3-way conditional below represents the following cases:
	*
	* bottom < top : Sequentially ordered case:
	* <check>--------+-------------------+
	* \| (overlap here?) \|
	* L2ARC dev V V
	* \|---------------<bottom>============<top>--------------\|
	*
	* bottom > top: Looped-around case:
	* <check>--------+------------------+
	* \| (overlap here?) \|
	* L2ARC dev V V
	* \|===============<top>---------------<bottom>===========\|
	* ^ ^
	* \| (or here?) \|
	* +---------------+---------<check>
	*
	* top == bottom : Just a single address comparison.
	*/
	boolean_t
	l2arc_range_check_overlap(uint64_t bottom, uint64_t top, uint64_t check)
	{
	if (bottom < top)
	return (bottom <= check && check <= top);
	else if (bottom > top)
	return (check <= top \|\| bottom <= check);
	else
	return (check == top);
	}

	EXPORT_SYMBOL(arc_buf_size);
	EXPORT_SYMBOL(arc_write);
	EXPORT_SYMBOL(arc_read);
	EXPORT_SYMBOL(arc_buf_info);
	EXPORT_SYMBOL(arc_getbuf_func);
	EXPORT_SYMBOL(arc_add_prune_callback);
	EXPORT_SYMBOL(arc_remove_prune_callback);

	/* BEGIN CSTYLED */
	ZFS_MODULE_PARAM_CALL(zfs_arc, zfs_arc_, min, param_set_arc_long,
	param_get_long, ZMOD_RW, "Min arc size");

	ZFS_MODULE_PARAM_CALL(zfs_arc, zfs_arc_, max, param_set_arc_long,
	param_get_long, ZMOD_RW, "Max arc size");

	ZFS_MODULE_PARAM_CALL(zfs_arc, zfs_arc_, meta_limit, param_set_arc_long,
	param_get_long, ZMOD_RW, "Metadata limit for arc size");

	ZFS_MODULE_PARAM_CALL(zfs_arc, zfs_arc_, meta_limit_percent,
	param_set_arc_long, param_get_long, ZMOD_RW,
	"Percent of arc size for arc meta limit");

	ZFS_MODULE_PARAM_CALL(zfs_arc, zfs_arc_, meta_min, param_set_arc_long,
	param_get_long, ZMOD_RW, "Min arc metadata");

	ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, meta_prune, INT, ZMOD_RW,
	"Meta objects to scan for prune");

	ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, meta_adjust_restarts, INT, ZMOD_RW,
	"Limit number of restarts in arc_evict_meta");

	ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, meta_strategy, INT, ZMOD_RW,
	"Meta reclaim strategy");

	ZFS_MODULE_PARAM_CALL(zfs_arc, zfs_arc_, grow_retry, param_set_arc_int,
	param_get_int, ZMOD_RW, "Seconds before growing arc size");

	ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, p_dampener_disable, INT, ZMOD_RW,
	"Disable arc_p adapt dampener");

	ZFS_MODULE_PARAM_CALL(zfs_arc, zfs_arc_, shrink_shift, param_set_arc_int,
	param_get_int, ZMOD_RW, "log2(fraction of arc to reclaim)");

	ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, pc_percent, UINT, ZMOD_RW,
	"Percent of pagecache to reclaim arc to");

	ZFS_MODULE_PARAM_CALL(zfs_arc, zfs_arc_, p_min_shift, param_set_arc_int,
	param_get_int, ZMOD_RW, "arc_c shift to calc min/max arc_p");

	ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, average_blocksize, INT, ZMOD_RD,
	"Target average block size");

	ZFS_MODULE_PARAM(zfs, zfs_, compressed_arc_enabled, INT, ZMOD_RW,
	"Disable compressed arc buffers");

	ZFS_MODULE_PARAM_CALL(zfs_arc, zfs_arc_, min_prefetch_ms, param_set_arc_int,
	param_get_int, ZMOD_RW, "Min life of prefetch block in ms");

	ZFS_MODULE_PARAM_CALL(zfs_arc, zfs_arc_, min_prescient_prefetch_ms,
	param_set_arc_int, param_get_int, ZMOD_RW,
	"Min life of prescient prefetched block in ms");

	ZFS_MODULE_PARAM(zfs_l2arc, l2arc_, write_max, ULONG, ZMOD_RW,
	"Max write bytes per interval");

	ZFS_MODULE_PARAM(zfs_l2arc, l2arc_, write_boost, ULONG, ZMOD_RW,
	"Extra write bytes during device warmup");

	ZFS_MODULE_PARAM(zfs_l2arc, l2arc_, headroom, ULONG, ZMOD_RW,
	"Number of max device writes to precache");

	ZFS_MODULE_PARAM(zfs_l2arc, l2arc_, headroom_boost, ULONG, ZMOD_RW,
	"Compressed l2arc_headroom multiplier");

	ZFS_MODULE_PARAM(zfs_l2arc, l2arc_, trim_ahead, ULONG, ZMOD_RW,
	"TRIM ahead L2ARC write size multiplier");

	ZFS_MODULE_PARAM(zfs_l2arc, l2arc_, feed_secs, ULONG, ZMOD_RW,
	"Seconds between L2ARC writing");

	ZFS_MODULE_PARAM(zfs_l2arc, l2arc_, feed_min_ms, ULONG, ZMOD_RW,
	"Min feed interval in milliseconds");

	ZFS_MODULE_PARAM(zfs_l2arc, l2arc_, noprefetch, INT, ZMOD_RW,
	"Skip caching prefetched buffers");

	ZFS_MODULE_PARAM(zfs_l2arc, l2arc_, feed_again, INT, ZMOD_RW,
	"Turbo L2ARC warmup");

	ZFS_MODULE_PARAM(zfs_l2arc, l2arc_, norw, INT, ZMOD_RW,
	"No reads during writes");

	ZFS_MODULE_PARAM(zfs_l2arc, l2arc_, meta_percent, INT, ZMOD_RW,
	"Percent of ARC size allowed for L2ARC-only headers");

	ZFS_MODULE_PARAM(zfs_l2arc, l2arc_, rebuild_enabled, INT, ZMOD_RW,
	"Rebuild the L2ARC when importing a pool");

	ZFS_MODULE_PARAM(zfs_l2arc, l2arc_, rebuild_blocks_min_l2size, ULONG, ZMOD_RW,
	"Min size in bytes to write rebuild log blocks in L2ARC");

	ZFS_MODULE_PARAM(zfs_l2arc, l2arc_, mfuonly, INT, ZMOD_RW,
	"Cache only MFU data from ARC into L2ARC");

	ZFS_MODULE_PARAM_CALL(zfs_arc, zfs_arc_, lotsfree_percent, param_set_arc_int,
	param_get_int, ZMOD_RW, "System free memory I/O throttle in bytes");

	ZFS_MODULE_PARAM_CALL(zfs_arc, zfs_arc_, sys_free, param_set_arc_long,
	param_get_long, ZMOD_RW, "System free memory target size in bytes");

	ZFS_MODULE_PARAM_CALL(zfs_arc, zfs_arc_, dnode_limit, param_set_arc_long,
	param_get_long, ZMOD_RW, "Minimum bytes of dnodes in arc");

	ZFS_MODULE_PARAM_CALL(zfs_arc, zfs_arc_, dnode_limit_percent,
	param_set_arc_long, param_get_long, ZMOD_RW,
	"Percent of ARC meta buffers for dnodes");

	ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, dnode_reduce_percent, ULONG, ZMOD_RW,
	"Percentage of excess dnodes to try to unpin");

	ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, eviction_pct, INT, ZMOD_RW,
	"When full, ARC allocation waits for eviction of this % of alloc size");

	ZFS_MODULE_PARAM(zfs_arc, zfs_arc_, evict_batch_limit, INT, ZMOD_RW,
	"The number of headers to evict per sublist before moving to the next");
	/* END CSTYLED */
	diff --git a/sys/contrib/openzfs/module/zfs/dmu_recv.c b/sys/contrib/openzfs/module/zfs/dmu_recv.c
	index 123ea05b0436..a713e1329027 100644
	--- a/sys/contrib/openzfs/module/zfs/dmu_recv.c
	+++ b/sys/contrib/openzfs/module/zfs/dmu_recv.c
	@@ -1,3389 +1,3389 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright 2011 Nexenta Systems, Inc. All rights reserved.
	* Copyright (c) 2011, 2020 by Delphix. All rights reserved.
	* Copyright (c) 2014, Joyent, Inc. All rights reserved.
	* Copyright 2014 HybridCluster. All rights reserved.
	* Copyright (c) 2018, loli10K <ezomori.nozomu@gmail.com>. All rights reserved.
	* Copyright (c) 2019, Klara Inc.
	* Copyright (c) 2019, Allan Jude
	*/

	#include <sys/dmu.h>
	#include <sys/dmu_impl.h>
	#include <sys/dmu_send.h>
	#include <sys/dmu_recv.h>
	#include <sys/dmu_tx.h>
	#include <sys/dbuf.h>
	#include <sys/dnode.h>
	#include <sys/zfs_context.h>
	#include <sys/dmu_objset.h>
	#include <sys/dmu_traverse.h>
	#include <sys/dsl_dataset.h>
	#include <sys/dsl_dir.h>
	#include <sys/dsl_prop.h>
	#include <sys/dsl_pool.h>
	#include <sys/dsl_synctask.h>
	#include <sys/zfs_ioctl.h>
	#include <sys/zap.h>
	#include <sys/zvol.h>
	#include <sys/zio_checksum.h>
	#include <sys/zfs_znode.h>
	#include <zfs_fletcher.h>
	#include <sys/avl.h>
	#include <sys/ddt.h>
	#include <sys/zfs_onexit.h>
	#include <sys/dsl_destroy.h>
	#include <sys/blkptr.h>
	#include <sys/dsl_bookmark.h>
	#include <sys/zfeature.h>
	#include <sys/bqueue.h>
	#include <sys/objlist.h>
	#ifdef _KERNEL
	#include <sys/zfs_vfsops.h>
	#endif
	#include <sys/zfs_file.h>

	int zfs_recv_queue_length = SPA_MAXBLOCKSIZE;
	int zfs_recv_queue_ff = 20;
	int zfs_recv_write_batch_size = 1024 * 1024;

	static char *dmu_recv_tag = "dmu_recv_tag";
	const char *recv_clone_name = "%recv";

	static int receive_read_payload_and_next_header(dmu_recv_cookie_t *ra, int len,
	void *buf);

	struct receive_record_arg {
	dmu_replay_record_t header;
	void payload; / Pointer to a buffer containing the payload */
	/*
	* If the record is a WRITE or SPILL, pointer to the abd containing the
	* payload.
	*/
	abd_t *abd;
	int payload_size;
	uint64_t bytes_read; /* bytes read from stream when record created */
	boolean_t eos_marker; /* Marks the end of the stream */
	bqueue_node_t node;
	};

	struct receive_writer_arg {
	objset_t *os;
	boolean_t byteswap;
	bqueue_t q;

	/*
	* These three members are used to signal to the main thread when
	* we're done.
	*/
	kmutex_t mutex;
	kcondvar_t cv;
	boolean_t done;

	int err;
	boolean_t resumable;
	boolean_t raw; /* DMU_BACKUP_FEATURE_RAW set */
	boolean_t spill; /* DRR_FLAG_SPILL_BLOCK set */
	boolean_t full; /* this is a full send stream */
	uint64_t last_object;
	uint64_t last_offset;
	uint64_t max_object; /* highest object ID referenced in stream */
	uint64_t bytes_read; /* bytes read when current record created */

	list_t write_batch;

	/* Encryption parameters for the last received DRR_OBJECT_RANGE */
	boolean_t or_crypt_params_present;
	uint64_t or_firstobj;
	uint64_t or_numslots;
	uint8_t or_salt[ZIO_DATA_SALT_LEN];
	uint8_t or_iv[ZIO_DATA_IV_LEN];
	uint8_t or_mac[ZIO_DATA_MAC_LEN];
	boolean_t or_byteorder;
	};

	typedef struct dmu_recv_begin_arg {
	const char *drba_origin;
	dmu_recv_cookie_t *drba_cookie;
	cred_t *drba_cred;
	proc_t *drba_proc;
	dsl_crypto_params_t *drba_dcp;
	} dmu_recv_begin_arg_t;

	static void
	byteswap_record(dmu_replay_record_t *drr)
	{
	#define DO64(X) (drr->drr_u.X = BSWAP_64(drr->drr_u.X))
	#define DO32(X) (drr->drr_u.X = BSWAP_32(drr->drr_u.X))
	drr->drr_type = BSWAP_32(drr->drr_type);
	drr->drr_payloadlen = BSWAP_32(drr->drr_payloadlen);

	switch (drr->drr_type) {
	case DRR_BEGIN:
	DO64(drr_begin.drr_magic);
	DO64(drr_begin.drr_versioninfo);
	DO64(drr_begin.drr_creation_time);
	DO32(drr_begin.drr_type);
	DO32(drr_begin.drr_flags);
	DO64(drr_begin.drr_toguid);
	DO64(drr_begin.drr_fromguid);
	break;
	case DRR_OBJECT:
	DO64(drr_object.drr_object);
	DO32(drr_object.drr_type);
	DO32(drr_object.drr_bonustype);
	DO32(drr_object.drr_blksz);
	DO32(drr_object.drr_bonuslen);
	DO32(drr_object.drr_raw_bonuslen);
	DO64(drr_object.drr_toguid);
	DO64(drr_object.drr_maxblkid);
	break;
	case DRR_FREEOBJECTS:
	DO64(drr_freeobjects.drr_firstobj);
	DO64(drr_freeobjects.drr_numobjs);
	DO64(drr_freeobjects.drr_toguid);
	break;
	case DRR_WRITE:
	DO64(drr_write.drr_object);
	DO32(drr_write.drr_type);
	DO64(drr_write.drr_offset);
	DO64(drr_write.drr_logical_size);
	DO64(drr_write.drr_toguid);
	ZIO_CHECKSUM_BSWAP(&drr->drr_u.drr_write.drr_key.ddk_cksum);
	DO64(drr_write.drr_key.ddk_prop);
	DO64(drr_write.drr_compressed_size);
	break;
	case DRR_WRITE_EMBEDDED:
	DO64(drr_write_embedded.drr_object);
	DO64(drr_write_embedded.drr_offset);
	DO64(drr_write_embedded.drr_length);
	DO64(drr_write_embedded.drr_toguid);
	DO32(drr_write_embedded.drr_lsize);
	DO32(drr_write_embedded.drr_psize);
	break;
	case DRR_FREE:
	DO64(drr_free.drr_object);
	DO64(drr_free.drr_offset);
	DO64(drr_free.drr_length);
	DO64(drr_free.drr_toguid);
	break;
	case DRR_SPILL:
	DO64(drr_spill.drr_object);
	DO64(drr_spill.drr_length);
	DO64(drr_spill.drr_toguid);
	DO64(drr_spill.drr_compressed_size);
	DO32(drr_spill.drr_type);
	break;
	case DRR_OBJECT_RANGE:
	DO64(drr_object_range.drr_firstobj);
	DO64(drr_object_range.drr_numslots);
	DO64(drr_object_range.drr_toguid);
	break;
	case DRR_REDACT:
	DO64(drr_redact.drr_object);
	DO64(drr_redact.drr_offset);
	DO64(drr_redact.drr_length);
	DO64(drr_redact.drr_toguid);
	break;
	case DRR_END:
	DO64(drr_end.drr_toguid);
	ZIO_CHECKSUM_BSWAP(&drr->drr_u.drr_end.drr_checksum);
	break;
	default:
	break;
	}

	if (drr->drr_type != DRR_BEGIN) {
	ZIO_CHECKSUM_BSWAP(&drr->drr_u.drr_checksum.drr_checksum);
	}

	#undef DO64
	#undef DO32
	}

	static boolean_t
	redact_snaps_contains(uint64_t *snaps, uint64_t num_snaps, uint64_t guid)
	{
	for (int i = 0; i < num_snaps; i++) {
	if (snaps[i] == guid)
	return (B_TRUE);
	}
	return (B_FALSE);
	}

	/*
	* Check that the new stream we're trying to receive is redacted with respect to
	* a subset of the snapshots that the origin was redacted with respect to. For
	* the reasons behind this, see the man page on redacted zfs sends and receives.
	*/
	static boolean_t
	compatible_redact_snaps(uint64_t *origin_snaps, uint64_t origin_num_snaps,
	uint64_t *redact_snaps, uint64_t num_redact_snaps)
	{
	/*
	* Short circuit the comparison; if we are redacted with respect to
	* more snapshots than the origin, we can't be redacted with respect
	* to a subset.
	*/
	if (num_redact_snaps > origin_num_snaps) {
	return (B_FALSE);
	}

	for (int i = 0; i < num_redact_snaps; i++) {
	if (!redact_snaps_contains(origin_snaps, origin_num_snaps,
	redact_snaps[i])) {
	return (B_FALSE);
	}
	}
	return (B_TRUE);
	}

	static boolean_t
	redact_check(dmu_recv_begin_arg_t drba, dsl_dataset_t origin)
	{
	uint64_t *origin_snaps;
	uint64_t origin_num_snaps;
	dmu_recv_cookie_t *drc = drba->drba_cookie;
	struct drr_begin *drrb = drc->drc_drrb;
	int featureflags = DMU_GET_FEATUREFLAGS(drrb->drr_versioninfo);
	int err = 0;
	boolean_t ret = B_TRUE;
	uint64_t *redact_snaps;
	uint_t numredactsnaps;

	/*
	* If this is a full send stream, we're safe no matter what.
	*/
	if (drrb->drr_fromguid == 0)
	return (ret);

	VERIFY(dsl_dataset_get_uint64_array_feature(origin,
	SPA_FEATURE_REDACTED_DATASETS, &origin_num_snaps, &origin_snaps));

	if (nvlist_lookup_uint64_array(drc->drc_begin_nvl,
	BEGINNV_REDACT_FROM_SNAPS, &redact_snaps, &numredactsnaps) ==
	0) {
	/*
	* If the send stream was sent from the redaction bookmark or
	* the redacted version of the dataset, then we're safe. Verify
	* that this is from the a compatible redaction bookmark or
	* redacted dataset.
	*/
	if (!compatible_redact_snaps(origin_snaps, origin_num_snaps,
	redact_snaps, numredactsnaps)) {
	err = EINVAL;
	}
	} else if (featureflags & DMU_BACKUP_FEATURE_REDACTED) {
	/*
	* If the stream is redacted, it must be redacted with respect
	* to a subset of what the origin is redacted with respect to.
	* See case number 2 in the zfs man page section on redacted zfs
	* send.
	*/
	err = nvlist_lookup_uint64_array(drc->drc_begin_nvl,
	BEGINNV_REDACT_SNAPS, &redact_snaps, &numredactsnaps);

	if (err != 0 \|\| !compatible_redact_snaps(origin_snaps,
	origin_num_snaps, redact_snaps, numredactsnaps)) {
	err = EINVAL;
	}
	} else if (!redact_snaps_contains(origin_snaps, origin_num_snaps,
	drrb->drr_toguid)) {
	/*
	* If the stream isn't redacted but the origin is, this must be
	* one of the snapshots the origin is redacted with respect to.
	* See case number 1 in the zfs man page section on redacted zfs
	* send.
	*/
	err = EINVAL;
	}

	if (err != 0)
	ret = B_FALSE;
	return (ret);
	}

	/*
	* If we previously received a stream with --large-block, we don't support
	* receiving an incremental on top of it without --large-block. This avoids
	* forcing a read-modify-write or trying to re-aggregate a string of WRITE
	* records.
	*/
	static int
	recv_check_large_blocks(dsl_dataset_t *ds, uint64_t featureflags)
	{
	if (dsl_dataset_feature_is_active(ds, SPA_FEATURE_LARGE_BLOCKS) &&
	!(featureflags & DMU_BACKUP_FEATURE_LARGE_BLOCKS))
	return (SET_ERROR(ZFS_ERR_STREAM_LARGE_BLOCK_MISMATCH));
	return (0);
	}

	static int
	recv_begin_check_existing_impl(dmu_recv_begin_arg_t drba, dsl_dataset_t ds,
	uint64_t fromguid, uint64_t featureflags)
	{
	uint64_t val;
	uint64_t children;
	int error;
	dsl_pool_t *dp = ds->ds_dir->dd_pool;
	boolean_t encrypted = ds->ds_dir->dd_crypto_obj != 0;
	boolean_t raw = (featureflags & DMU_BACKUP_FEATURE_RAW) != 0;
	boolean_t embed = (featureflags & DMU_BACKUP_FEATURE_EMBED_DATA) != 0;

	/* Temporary clone name must not exist. */
	error = zap_lookup(dp->dp_meta_objset,
	dsl_dir_phys(ds->ds_dir)->dd_child_dir_zapobj, recv_clone_name,
	8, 1, &val);
	if (error != ENOENT)
	return (error == 0 ? SET_ERROR(EBUSY) : error);

	/* Resume state must not be set. */
	if (dsl_dataset_has_resume_receive_state(ds))
	return (SET_ERROR(EBUSY));

	/* New snapshot name must not exist. */
	error = zap_lookup(dp->dp_meta_objset,
	dsl_dataset_phys(ds)->ds_snapnames_zapobj,
	drba->drba_cookie->drc_tosnap, 8, 1, &val);
	if (error != ENOENT)
	return (error == 0 ? SET_ERROR(EEXIST) : error);

	/* Must not have children if receiving a ZVOL. */
	error = zap_count(dp->dp_meta_objset,
	dsl_dir_phys(ds->ds_dir)->dd_child_dir_zapobj, &children);
	if (error != 0)
	return (error);
	if (drba->drba_cookie->drc_drrb->drr_type != DMU_OST_ZFS &&
	children > 0)
	return (SET_ERROR(ZFS_ERR_WRONG_PARENT));

	/*
	* Check snapshot limit before receiving. We'll recheck again at the
	* end, but might as well abort before receiving if we're already over
	* the limit.
	*
	* Note that we do not check the file system limit with
	* dsl_dir_fscount_check because the temporary %clones don't count
	* against that limit.
	*/
	error = dsl_fs_ss_limit_check(ds->ds_dir, 1, ZFS_PROP_SNAPSHOT_LIMIT,
	NULL, drba->drba_cred, drba->drba_proc);
	if (error != 0)
	return (error);

	if (fromguid != 0) {
	dsl_dataset_t *snap;
	uint64_t obj = dsl_dataset_phys(ds)->ds_prev_snap_obj;

	/* Can't perform a raw receive on top of a non-raw receive */
	if (!encrypted && raw)
	return (SET_ERROR(EINVAL));

	/* Encryption is incompatible with embedded data */
	if (encrypted && embed)
	return (SET_ERROR(EINVAL));

	/* Find snapshot in this dir that matches fromguid. */
	while (obj != 0) {
	error = dsl_dataset_hold_obj(dp, obj, FTAG,
	&snap);
	if (error != 0)
	return (SET_ERROR(ENODEV));
	if (snap->ds_dir != ds->ds_dir) {
	dsl_dataset_rele(snap, FTAG);
	return (SET_ERROR(ENODEV));
	}
	if (dsl_dataset_phys(snap)->ds_guid == fromguid)
	break;
	obj = dsl_dataset_phys(snap)->ds_prev_snap_obj;
	dsl_dataset_rele(snap, FTAG);
	}
	if (obj == 0)
	return (SET_ERROR(ENODEV));

	if (drba->drba_cookie->drc_force) {
	drba->drba_cookie->drc_fromsnapobj = obj;
	} else {
	/*
	* If we are not forcing, there must be no
	* changes since fromsnap. Raw sends have an
	* additional constraint that requires that
	* no "noop" snapshots exist between fromsnap
	* and tosnap for the IVset checking code to
	* work properly.
	*/
	if (dsl_dataset_modified_since_snap(ds, snap) \|\|
	(raw &&
	dsl_dataset_phys(ds)->ds_prev_snap_obj !=
	snap->ds_object)) {
	dsl_dataset_rele(snap, FTAG);
	return (SET_ERROR(ETXTBSY));
	}
	drba->drba_cookie->drc_fromsnapobj =
	ds->ds_prev->ds_object;
	}

	if (dsl_dataset_feature_is_active(snap,
	SPA_FEATURE_REDACTED_DATASETS) && !redact_check(drba,
	snap)) {
	dsl_dataset_rele(snap, FTAG);
	return (SET_ERROR(EINVAL));
	}

	error = recv_check_large_blocks(snap, featureflags);
	if (error != 0) {
	dsl_dataset_rele(snap, FTAG);
	return (error);
	}

	dsl_dataset_rele(snap, FTAG);
	} else {
	/* if full, then must be forced */
	if (!drba->drba_cookie->drc_force)
	return (SET_ERROR(EEXIST));

	/*
	* We don't support using zfs recv -F to blow away
	* encrypted filesystems. This would require the
	* dsl dir to point to the old encryption key and
	* the new one at the same time during the receive.
	*/
	if ((!encrypted && raw) \|\| encrypted)
	return (SET_ERROR(EINVAL));

	/*
	* Perform the same encryption checks we would if
	* we were creating a new dataset from scratch.
	*/
	if (!raw) {
	boolean_t will_encrypt;

	error = dmu_objset_create_crypt_check(
	ds->ds_dir->dd_parent, drba->drba_dcp,
	&will_encrypt);
	if (error != 0)
	return (error);

	if (will_encrypt && embed)
	return (SET_ERROR(EINVAL));
	}
	}

	return (0);
	}

	/*
	* Check that any feature flags used in the data stream we're receiving are
	* supported by the pool we are receiving into.
	*
	* Note that some of the features we explicitly check here have additional
	* (implicit) features they depend on, but those dependencies are enforced
	* through the zfeature_register() calls declaring the features that we
	* explicitly check.
	*/
	static int
	recv_begin_check_feature_flags_impl(uint64_t featureflags, spa_t *spa)
	{
	/*
	* Check if there are any unsupported feature flags.
	*/
	if (!DMU_STREAM_SUPPORTED(featureflags)) {
	return (SET_ERROR(ZFS_ERR_UNKNOWN_SEND_STREAM_FEATURE));
	}

	/* Verify pool version supports SA if SA_SPILL feature set */
	if ((featureflags & DMU_BACKUP_FEATURE_SA_SPILL) &&
	spa_version(spa) < SPA_VERSION_SA)
	return (SET_ERROR(ENOTSUP));

	/*
	* LZ4 compressed, ZSTD compressed, embedded, mooched, large blocks,
	* and large_dnodes in the stream can only be used if those pool
	* features are enabled because we don't attempt to decompress /
	* un-embed / un-mooch / split up the blocks / dnodes during the
	* receive process.
	*/
	if ((featureflags & DMU_BACKUP_FEATURE_LZ4) &&
	!spa_feature_is_enabled(spa, SPA_FEATURE_LZ4_COMPRESS))
	return (SET_ERROR(ENOTSUP));
	if ((featureflags & DMU_BACKUP_FEATURE_ZSTD) &&
	!spa_feature_is_enabled(spa, SPA_FEATURE_ZSTD_COMPRESS))
	return (SET_ERROR(ENOTSUP));
	if ((featureflags & DMU_BACKUP_FEATURE_EMBED_DATA) &&
	!spa_feature_is_enabled(spa, SPA_FEATURE_EMBEDDED_DATA))
	return (SET_ERROR(ENOTSUP));
	if ((featureflags & DMU_BACKUP_FEATURE_LARGE_BLOCKS) &&
	!spa_feature_is_enabled(spa, SPA_FEATURE_LARGE_BLOCKS))
	return (SET_ERROR(ENOTSUP));
	if ((featureflags & DMU_BACKUP_FEATURE_LARGE_DNODE) &&
	!spa_feature_is_enabled(spa, SPA_FEATURE_LARGE_DNODE))
	return (SET_ERROR(ENOTSUP));

	/*
	* Receiving redacted streams requires that redacted datasets are
	* enabled.
	*/
	if ((featureflags & DMU_BACKUP_FEATURE_REDACTED) &&
	!spa_feature_is_enabled(spa, SPA_FEATURE_REDACTED_DATASETS))
	return (SET_ERROR(ENOTSUP));

	return (0);
	}

	static int
	dmu_recv_begin_check(void arg, dmu_tx_t tx)
	{
	dmu_recv_begin_arg_t *drba = arg;
	dsl_pool_t *dp = dmu_tx_pool(tx);
	struct drr_begin *drrb = drba->drba_cookie->drc_drrb;
	uint64_t fromguid = drrb->drr_fromguid;
	int flags = drrb->drr_flags;
	ds_hold_flags_t dsflags = DS_HOLD_FLAG_NONE;
	int error;
	uint64_t featureflags = drba->drba_cookie->drc_featureflags;
	dsl_dataset_t *ds;
	const char *tofs = drba->drba_cookie->drc_tofs;

	/* already checked */
	ASSERT3U(drrb->drr_magic, ==, DMU_BACKUP_MAGIC);
	ASSERT(!(featureflags & DMU_BACKUP_FEATURE_RESUMING));

	if (DMU_GET_STREAM_HDRTYPE(drrb->drr_versioninfo) ==
	DMU_COMPOUNDSTREAM \|\|
	drrb->drr_type >= DMU_OST_NUMTYPES \|\|
	((flags & DRR_FLAG_CLONE) && drba->drba_origin == NULL))
	return (SET_ERROR(EINVAL));

	error = recv_begin_check_feature_flags_impl(featureflags, dp->dp_spa);
	if (error != 0)
	return (error);

	/* Resumable receives require extensible datasets */
	if (drba->drba_cookie->drc_resumable &&
	!spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_EXTENSIBLE_DATASET))
	return (SET_ERROR(ENOTSUP));

	if (featureflags & DMU_BACKUP_FEATURE_RAW) {
	/* raw receives require the encryption feature */
	if (!spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_ENCRYPTION))
	return (SET_ERROR(ENOTSUP));

	/* embedded data is incompatible with encryption and raw recv */
	if (featureflags & DMU_BACKUP_FEATURE_EMBED_DATA)
	return (SET_ERROR(EINVAL));

	/* raw receives require spill block allocation flag */
	if (!(flags & DRR_FLAG_SPILL_BLOCK))
	return (SET_ERROR(ZFS_ERR_SPILL_BLOCK_FLAG_MISSING));
	} else {
	dsflags \|= DS_HOLD_FLAG_DECRYPT;
	}

	error = dsl_dataset_hold_flags(dp, tofs, dsflags, FTAG, &ds);
	if (error == 0) {
	/* target fs already exists; recv into temp clone */

	/* Can't recv a clone into an existing fs */
	if (flags & DRR_FLAG_CLONE \|\| drba->drba_origin) {
	dsl_dataset_rele_flags(ds, dsflags, FTAG);
	return (SET_ERROR(EINVAL));
	}

	error = recv_begin_check_existing_impl(drba, ds, fromguid,
	featureflags);
	dsl_dataset_rele_flags(ds, dsflags, FTAG);
	} else if (error == ENOENT) {
	/* target fs does not exist; must be a full backup or clone */
	char buf[ZFS_MAX_DATASET_NAME_LEN];
	objset_t *os;

	/*
	* If it's a non-clone incremental, we are missing the
	* target fs, so fail the recv.
	*/
	if (fromguid != 0 && !((flags & DRR_FLAG_CLONE) \|\|
	drba->drba_origin))
	return (SET_ERROR(ENOENT));

	/*
	* If we're receiving a full send as a clone, and it doesn't
	* contain all the necessary free records and freeobject
	* records, reject it.
	*/
	if (fromguid == 0 && drba->drba_origin != NULL &&
	!(flags & DRR_FLAG_FREERECORDS))
	return (SET_ERROR(EINVAL));

	/* Open the parent of tofs */
	ASSERT3U(strlen(tofs), <, sizeof (buf));
	(void) strlcpy(buf, tofs, strrchr(tofs, '/') - tofs + 1);
	error = dsl_dataset_hold(dp, buf, FTAG, &ds);
	if (error != 0)
	return (error);

	if ((featureflags & DMU_BACKUP_FEATURE_RAW) == 0 &&
	drba->drba_origin == NULL) {
	boolean_t will_encrypt;

	/*
	* Check that we aren't breaking any encryption rules
	* and that we have all the parameters we need to
	* create an encrypted dataset if necessary. If we are
	* making an encrypted dataset the stream can't have
	* embedded data.
	*/
	error = dmu_objset_create_crypt_check(ds->ds_dir,
	drba->drba_dcp, &will_encrypt);
	if (error != 0) {
	dsl_dataset_rele(ds, FTAG);
	return (error);
	}

	if (will_encrypt &&
	(featureflags & DMU_BACKUP_FEATURE_EMBED_DATA)) {
	dsl_dataset_rele(ds, FTAG);
	return (SET_ERROR(EINVAL));
	}
	}

	/*
	* Check filesystem and snapshot limits before receiving. We'll
	* recheck snapshot limits again at the end (we create the
	* filesystems and increment those counts during begin_sync).
	*/
	error = dsl_fs_ss_limit_check(ds->ds_dir, 1,
	ZFS_PROP_FILESYSTEM_LIMIT, NULL,
	drba->drba_cred, drba->drba_proc);
	if (error != 0) {
	dsl_dataset_rele(ds, FTAG);
	return (error);
	}

	error = dsl_fs_ss_limit_check(ds->ds_dir, 1,
	ZFS_PROP_SNAPSHOT_LIMIT, NULL,
	drba->drba_cred, drba->drba_proc);
	if (error != 0) {
	dsl_dataset_rele(ds, FTAG);
	return (error);
	}

	/* can't recv below anything but filesystems (eg. no ZVOLs) */
	error = dmu_objset_from_ds(ds, &os);
	if (error != 0) {
	dsl_dataset_rele(ds, FTAG);
	return (error);
	}
	if (dmu_objset_type(os) != DMU_OST_ZFS) {
	dsl_dataset_rele(ds, FTAG);
	return (SET_ERROR(ZFS_ERR_WRONG_PARENT));
	}

	if (drba->drba_origin != NULL) {
	dsl_dataset_t *origin;
	error = dsl_dataset_hold_flags(dp, drba->drba_origin,
	dsflags, FTAG, &origin);
	if (error != 0) {
	dsl_dataset_rele(ds, FTAG);
	return (error);
	}
	if (!origin->ds_is_snapshot) {
	dsl_dataset_rele_flags(origin, dsflags, FTAG);
	dsl_dataset_rele(ds, FTAG);
	return (SET_ERROR(EINVAL));
	}
	if (dsl_dataset_phys(origin)->ds_guid != fromguid &&
	fromguid != 0) {
	dsl_dataset_rele_flags(origin, dsflags, FTAG);
	dsl_dataset_rele(ds, FTAG);
	return (SET_ERROR(ENODEV));
	}

	if (origin->ds_dir->dd_crypto_obj != 0 &&
	(featureflags & DMU_BACKUP_FEATURE_EMBED_DATA)) {
	dsl_dataset_rele_flags(origin, dsflags, FTAG);
	dsl_dataset_rele(ds, FTAG);
	return (SET_ERROR(EINVAL));
	}

	/*
	* If the origin is redacted we need to verify that this
	* send stream can safely be received on top of the
	* origin.
	*/
	if (dsl_dataset_feature_is_active(origin,
	SPA_FEATURE_REDACTED_DATASETS)) {
	if (!redact_check(drba, origin)) {
	dsl_dataset_rele_flags(origin, dsflags,
	FTAG);
	dsl_dataset_rele_flags(ds, dsflags,
	FTAG);
	return (SET_ERROR(EINVAL));
	}
	}

	error = recv_check_large_blocks(ds, featureflags);
	if (error != 0) {
	dsl_dataset_rele_flags(origin, dsflags, FTAG);
	dsl_dataset_rele_flags(ds, dsflags, FTAG);
	return (error);
	}

	dsl_dataset_rele_flags(origin, dsflags, FTAG);
	}

	dsl_dataset_rele(ds, FTAG);
	error = 0;
	}
	return (error);
	}

	static void
	dmu_recv_begin_sync(void arg, dmu_tx_t tx)
	{
	dmu_recv_begin_arg_t *drba = arg;
	dsl_pool_t *dp = dmu_tx_pool(tx);
	objset_t *mos = dp->dp_meta_objset;
	dmu_recv_cookie_t *drc = drba->drba_cookie;
	struct drr_begin *drrb = drc->drc_drrb;
	const char *tofs = drc->drc_tofs;
	uint64_t featureflags = drc->drc_featureflags;
	dsl_dataset_t ds, newds;
	objset_t *os;
	uint64_t dsobj;
	ds_hold_flags_t dsflags = DS_HOLD_FLAG_NONE;
	int error;
	uint64_t crflags = 0;
	dsl_crypto_params_t dummy_dcp = { 0 };
	dsl_crypto_params_t *dcp = drba->drba_dcp;

	if (drrb->drr_flags & DRR_FLAG_CI_DATA)
	crflags \|= DS_FLAG_CI_DATASET;

	if ((featureflags & DMU_BACKUP_FEATURE_RAW) == 0)
	dsflags \|= DS_HOLD_FLAG_DECRYPT;

	/*
	* Raw, non-incremental recvs always use a dummy dcp with
	* the raw cmd set. Raw incremental recvs do not use a dcp
	* since the encryption parameters are already set in stone.
	*/
	if (dcp == NULL && drrb->drr_fromguid == 0 &&
	drba->drba_origin == NULL) {
	ASSERT3P(dcp, ==, NULL);
	dcp = &dummy_dcp;

	if (featureflags & DMU_BACKUP_FEATURE_RAW)
	dcp->cp_cmd = DCP_CMD_RAW_RECV;
	}

	error = dsl_dataset_hold_flags(dp, tofs, dsflags, FTAG, &ds);
	if (error == 0) {
	/* create temporary clone */
	dsl_dataset_t *snap = NULL;

	if (drba->drba_cookie->drc_fromsnapobj != 0) {
	VERIFY0(dsl_dataset_hold_obj(dp,
	drba->drba_cookie->drc_fromsnapobj, FTAG, &snap));
	ASSERT3P(dcp, ==, NULL);
	}
	dsobj = dsl_dataset_create_sync(ds->ds_dir, recv_clone_name,
	snap, crflags, drba->drba_cred, dcp, tx);
	if (drba->drba_cookie->drc_fromsnapobj != 0)
	dsl_dataset_rele(snap, FTAG);
	dsl_dataset_rele_flags(ds, dsflags, FTAG);
	} else {
	dsl_dir_t *dd;
	const char *tail;
	dsl_dataset_t *origin = NULL;

	VERIFY0(dsl_dir_hold(dp, tofs, FTAG, &dd, &tail));

	if (drba->drba_origin != NULL) {
	VERIFY0(dsl_dataset_hold(dp, drba->drba_origin,
	FTAG, &origin));
	ASSERT3P(dcp, ==, NULL);
	}

	/* Create new dataset. */
	dsobj = dsl_dataset_create_sync(dd, strrchr(tofs, '/') + 1,
	origin, crflags, drba->drba_cred, dcp, tx);
	if (origin != NULL)
	dsl_dataset_rele(origin, FTAG);
	dsl_dir_rele(dd, FTAG);
	drc->drc_newfs = B_TRUE;
	}
	VERIFY0(dsl_dataset_own_obj_force(dp, dsobj, dsflags, dmu_recv_tag,
	&newds));
	if (dsl_dataset_feature_is_active(newds,
	SPA_FEATURE_REDACTED_DATASETS)) {
	/*
	* If the origin dataset is redacted, the child will be redacted
	* when we create it. We clear the new dataset's
	* redaction info; if it should be redacted, we'll fill
	* in its information later.
	*/
	dsl_dataset_deactivate_feature(newds,
	SPA_FEATURE_REDACTED_DATASETS, tx);
	}
	VERIFY0(dmu_objset_from_ds(newds, &os));

	if (drc->drc_resumable) {
	dsl_dataset_zapify(newds, tx);
	if (drrb->drr_fromguid != 0) {
	VERIFY0(zap_add(mos, dsobj, DS_FIELD_RESUME_FROMGUID,
	8, 1, &drrb->drr_fromguid, tx));
	}
	VERIFY0(zap_add(mos, dsobj, DS_FIELD_RESUME_TOGUID,
	8, 1, &drrb->drr_toguid, tx));
	VERIFY0(zap_add(mos, dsobj, DS_FIELD_RESUME_TONAME,
	1, strlen(drrb->drr_toname) + 1, drrb->drr_toname, tx));
	uint64_t one = 1;
	uint64_t zero = 0;
	VERIFY0(zap_add(mos, dsobj, DS_FIELD_RESUME_OBJECT,
	8, 1, &one, tx));
	VERIFY0(zap_add(mos, dsobj, DS_FIELD_RESUME_OFFSET,
	8, 1, &zero, tx));
	VERIFY0(zap_add(mos, dsobj, DS_FIELD_RESUME_BYTES,
	8, 1, &zero, tx));
	if (featureflags & DMU_BACKUP_FEATURE_LARGE_BLOCKS) {
	VERIFY0(zap_add(mos, dsobj, DS_FIELD_RESUME_LARGEBLOCK,
	8, 1, &one, tx));
	}
	if (featureflags & DMU_BACKUP_FEATURE_EMBED_DATA) {
	VERIFY0(zap_add(mos, dsobj, DS_FIELD_RESUME_EMBEDOK,
	8, 1, &one, tx));
	}
	if (featureflags & DMU_BACKUP_FEATURE_COMPRESSED) {
	VERIFY0(zap_add(mos, dsobj, DS_FIELD_RESUME_COMPRESSOK,
	8, 1, &one, tx));
	}
	if (featureflags & DMU_BACKUP_FEATURE_RAW) {
	VERIFY0(zap_add(mos, dsobj, DS_FIELD_RESUME_RAWOK,
	8, 1, &one, tx));
	}

	uint64_t *redact_snaps;
	uint_t numredactsnaps;
	if (nvlist_lookup_uint64_array(drc->drc_begin_nvl,
	BEGINNV_REDACT_FROM_SNAPS, &redact_snaps,
	&numredactsnaps) == 0) {
	VERIFY0(zap_add(mos, dsobj,
	DS_FIELD_RESUME_REDACT_BOOKMARK_SNAPS,
	sizeof (*redact_snaps), numredactsnaps,
	redact_snaps, tx));
	}
	}

	/*
	* Usually the os->os_encrypted value is tied to the presence of a
	* DSL Crypto Key object in the dd. However, that will not be received
	* until dmu_recv_stream(), so we set the value manually for now.
	*/
	if (featureflags & DMU_BACKUP_FEATURE_RAW) {
	os->os_encrypted = B_TRUE;
	drba->drba_cookie->drc_raw = B_TRUE;
	}

	if (featureflags & DMU_BACKUP_FEATURE_REDACTED) {
	uint64_t *redact_snaps;
	uint_t numredactsnaps;
	VERIFY0(nvlist_lookup_uint64_array(drc->drc_begin_nvl,
	BEGINNV_REDACT_SNAPS, &redact_snaps, &numredactsnaps));
	dsl_dataset_activate_redaction(newds, redact_snaps,
	numredactsnaps, tx);
	}

	dmu_buf_will_dirty(newds->ds_dbuf, tx);
	dsl_dataset_phys(newds)->ds_flags \|= DS_FLAG_INCONSISTENT;

	/*
	* If we actually created a non-clone, we need to create the objset
	* in our new dataset. If this is a raw send we postpone this until
	* dmu_recv_stream() so that we can allocate the metadnode with the
	* properties from the DRR_BEGIN payload.
	*/
	rrw_enter(&newds->ds_bp_rwlock, RW_READER, FTAG);
	if (BP_IS_HOLE(dsl_dataset_get_blkptr(newds)) &&
	(featureflags & DMU_BACKUP_FEATURE_RAW) == 0) {
	(void) dmu_objset_create_impl(dp->dp_spa,
	newds, dsl_dataset_get_blkptr(newds), drrb->drr_type, tx);
	}
	rrw_exit(&newds->ds_bp_rwlock, FTAG);

	drba->drba_cookie->drc_ds = newds;
	drba->drba_cookie->drc_os = os;

	spa_history_log_internal_ds(newds, "receive", tx, " ");
	}

	static int
	dmu_recv_resume_begin_check(void arg, dmu_tx_t tx)
	{
	dmu_recv_begin_arg_t *drba = arg;
	dmu_recv_cookie_t *drc = drba->drba_cookie;
	dsl_pool_t *dp = dmu_tx_pool(tx);
	struct drr_begin *drrb = drc->drc_drrb;
	int error;
	ds_hold_flags_t dsflags = DS_HOLD_FLAG_NONE;
	dsl_dataset_t *ds;
	const char *tofs = drc->drc_tofs;

	/* already checked */
	ASSERT3U(drrb->drr_magic, ==, DMU_BACKUP_MAGIC);
	ASSERT(drc->drc_featureflags & DMU_BACKUP_FEATURE_RESUMING);

	if (DMU_GET_STREAM_HDRTYPE(drrb->drr_versioninfo) ==
	DMU_COMPOUNDSTREAM \|\|
	drrb->drr_type >= DMU_OST_NUMTYPES)
	return (SET_ERROR(EINVAL));

	/*
	* This is mostly a sanity check since we should have already done these
	* checks during a previous attempt to receive the data.
	*/
	error = recv_begin_check_feature_flags_impl(drc->drc_featureflags,
	dp->dp_spa);
	if (error != 0)
	return (error);

	/* 6 extra bytes for /%recv */
	char recvname[ZFS_MAX_DATASET_NAME_LEN + 6];

	(void) snprintf(recvname, sizeof (recvname), "%s/%s",
	tofs, recv_clone_name);

	if (drc->drc_featureflags & DMU_BACKUP_FEATURE_RAW) {
	/* raw receives require spill block allocation flag */
	if (!(drrb->drr_flags & DRR_FLAG_SPILL_BLOCK))
	return (SET_ERROR(ZFS_ERR_SPILL_BLOCK_FLAG_MISSING));
	} else {
	dsflags \|= DS_HOLD_FLAG_DECRYPT;
	}

	if (dsl_dataset_hold_flags(dp, recvname, dsflags, FTAG, &ds) != 0) {
	/* %recv does not exist; continue in tofs */
	error = dsl_dataset_hold_flags(dp, tofs, dsflags, FTAG, &ds);
	if (error != 0)
	return (error);
	}

	/* check that ds is marked inconsistent */
	if (!DS_IS_INCONSISTENT(ds)) {
	dsl_dataset_rele_flags(ds, dsflags, FTAG);
	return (SET_ERROR(EINVAL));
	}

	/* check that there is resuming data, and that the toguid matches */
	if (!dsl_dataset_is_zapified(ds)) {
	dsl_dataset_rele_flags(ds, dsflags, FTAG);
	return (SET_ERROR(EINVAL));
	}
	uint64_t val;
	error = zap_lookup(dp->dp_meta_objset, ds->ds_object,
	DS_FIELD_RESUME_TOGUID, sizeof (val), 1, &val);
	if (error != 0 \|\| drrb->drr_toguid != val) {
	dsl_dataset_rele_flags(ds, dsflags, FTAG);
	return (SET_ERROR(EINVAL));
	}

	/*
	* Check if the receive is still running. If so, it will be owned.
	* Note that nothing else can own the dataset (e.g. after the receive
	* fails) because it will be marked inconsistent.
	*/
	if (dsl_dataset_has_owner(ds)) {
	dsl_dataset_rele_flags(ds, dsflags, FTAG);
	return (SET_ERROR(EBUSY));
	}

	/* There should not be any snapshots of this fs yet. */
	if (ds->ds_prev != NULL && ds->ds_prev->ds_dir == ds->ds_dir) {
	dsl_dataset_rele_flags(ds, dsflags, FTAG);
	return (SET_ERROR(EINVAL));
	}

	/*
	* Note: resume point will be checked when we process the first WRITE
	* record.
	*/

	/* check that the origin matches */
	val = 0;
	(void) zap_lookup(dp->dp_meta_objset, ds->ds_object,
	DS_FIELD_RESUME_FROMGUID, sizeof (val), 1, &val);
	if (drrb->drr_fromguid != val) {
	dsl_dataset_rele_flags(ds, dsflags, FTAG);
	return (SET_ERROR(EINVAL));
	}

	if (ds->ds_prev != NULL && drrb->drr_fromguid != 0)
	drc->drc_fromsnapobj = ds->ds_prev->ds_object;

	/*
	* If we're resuming, and the send is redacted, then the original send
	* must have been redacted, and must have been redacted with respect to
	* the same snapshots.
	*/
	if (drc->drc_featureflags & DMU_BACKUP_FEATURE_REDACTED) {
	uint64_t num_ds_redact_snaps;
	uint64_t *ds_redact_snaps;

	uint_t num_stream_redact_snaps;
	uint64_t *stream_redact_snaps;

	if (nvlist_lookup_uint64_array(drc->drc_begin_nvl,
	BEGINNV_REDACT_SNAPS, &stream_redact_snaps,
	&num_stream_redact_snaps) != 0) {
	dsl_dataset_rele_flags(ds, dsflags, FTAG);
	return (SET_ERROR(EINVAL));
	}

	if (!dsl_dataset_get_uint64_array_feature(ds,
	SPA_FEATURE_REDACTED_DATASETS, &num_ds_redact_snaps,
	&ds_redact_snaps)) {
	dsl_dataset_rele_flags(ds, dsflags, FTAG);
	return (SET_ERROR(EINVAL));
	}

	for (int i = 0; i < num_ds_redact_snaps; i++) {
	if (!redact_snaps_contains(ds_redact_snaps,
	num_ds_redact_snaps, stream_redact_snaps[i])) {
	dsl_dataset_rele_flags(ds, dsflags, FTAG);
	return (SET_ERROR(EINVAL));
	}
	}
	}

	error = recv_check_large_blocks(ds, drc->drc_featureflags);
	if (error != 0) {
	dsl_dataset_rele_flags(ds, dsflags, FTAG);
	return (error);
	}

	dsl_dataset_rele_flags(ds, dsflags, FTAG);
	return (0);
	}

	static void
	dmu_recv_resume_begin_sync(void arg, dmu_tx_t tx)
	{
	dmu_recv_begin_arg_t *drba = arg;
	dsl_pool_t *dp = dmu_tx_pool(tx);
	const char *tofs = drba->drba_cookie->drc_tofs;
	uint64_t featureflags = drba->drba_cookie->drc_featureflags;
	dsl_dataset_t *ds;
	ds_hold_flags_t dsflags = DS_HOLD_FLAG_NONE;
	/* 6 extra bytes for /%recv */
	char recvname[ZFS_MAX_DATASET_NAME_LEN + 6];

	(void) snprintf(recvname, sizeof (recvname), "%s/%s", tofs,
	recv_clone_name);

	if (featureflags & DMU_BACKUP_FEATURE_RAW) {
	drba->drba_cookie->drc_raw = B_TRUE;
	} else {
	dsflags \|= DS_HOLD_FLAG_DECRYPT;
	}

	if (dsl_dataset_own_force(dp, recvname, dsflags, dmu_recv_tag, &ds)
	!= 0) {
	/* %recv does not exist; continue in tofs */
	VERIFY0(dsl_dataset_own_force(dp, tofs, dsflags, dmu_recv_tag,
	&ds));
	drba->drba_cookie->drc_newfs = B_TRUE;
	}

	ASSERT(DS_IS_INCONSISTENT(ds));
	rrw_enter(&ds->ds_bp_rwlock, RW_READER, FTAG);
	ASSERT(!BP_IS_HOLE(dsl_dataset_get_blkptr(ds)) \|\|
	drba->drba_cookie->drc_raw);
	rrw_exit(&ds->ds_bp_rwlock, FTAG);

	drba->drba_cookie->drc_ds = ds;
	VERIFY0(dmu_objset_from_ds(ds, &drba->drba_cookie->drc_os));
	drba->drba_cookie->drc_should_save = B_TRUE;

	spa_history_log_internal_ds(ds, "resume receive", tx, " ");
	}

	/*
	* NB: callers MUST call dmu_recv_stream() if dmu_recv_begin()
	* succeeds; otherwise we will leak the holds on the datasets.
	*/
	int
	dmu_recv_begin(char tofs, char tosnap, dmu_replay_record_t *drr_begin,
	boolean_t force, boolean_t resumable, nvlist_t *localprops,
	nvlist_t hidden_args, char origin, dmu_recv_cookie_t *drc,
	zfs_file_t fp, offset_t voffp)
	{
	dmu_recv_begin_arg_t drba = { 0 };
	int err;

	bzero(drc, sizeof (dmu_recv_cookie_t));
	drc->drc_drr_begin = drr_begin;
	drc->drc_drrb = &drr_begin->drr_u.drr_begin;
	drc->drc_tosnap = tosnap;
	drc->drc_tofs = tofs;
	drc->drc_force = force;
	drc->drc_resumable = resumable;
	drc->drc_cred = CRED();
	drc->drc_proc = curproc;
	drc->drc_clone = (origin != NULL);

	if (drc->drc_drrb->drr_magic == BSWAP_64(DMU_BACKUP_MAGIC)) {
	drc->drc_byteswap = B_TRUE;
	(void) fletcher_4_incremental_byteswap(drr_begin,
	sizeof (dmu_replay_record_t), &drc->drc_cksum);
	byteswap_record(drr_begin);
	} else if (drc->drc_drrb->drr_magic == DMU_BACKUP_MAGIC) {
	(void) fletcher_4_incremental_native(drr_begin,
	sizeof (dmu_replay_record_t), &drc->drc_cksum);
	} else {
	return (SET_ERROR(EINVAL));
	}

	drc->drc_fp = fp;
	drc->drc_voff = *voffp;
	drc->drc_featureflags =
	DMU_GET_FEATUREFLAGS(drc->drc_drrb->drr_versioninfo);

	uint32_t payloadlen = drc->drc_drr_begin->drr_payloadlen;
	void *payload = NULL;
	if (payloadlen != 0)
	payload = kmem_alloc(payloadlen, KM_SLEEP);

	err = receive_read_payload_and_next_header(drc, payloadlen,
	payload);
	if (err != 0) {
	kmem_free(payload, payloadlen);
	return (err);
	}
	if (payloadlen != 0) {
	err = nvlist_unpack(payload, payloadlen, &drc->drc_begin_nvl,
	KM_SLEEP);
	kmem_free(payload, payloadlen);
	if (err != 0) {
	kmem_free(drc->drc_next_rrd,
	sizeof (*drc->drc_next_rrd));
	return (err);
	}
	}

	if (drc->drc_drrb->drr_flags & DRR_FLAG_SPILL_BLOCK)
	drc->drc_spill = B_TRUE;

	drba.drba_origin = origin;
	drba.drba_cookie = drc;
	drba.drba_cred = CRED();
	drba.drba_proc = curproc;

	if (drc->drc_featureflags & DMU_BACKUP_FEATURE_RESUMING) {
	err = dsl_sync_task(tofs,
	dmu_recv_resume_begin_check, dmu_recv_resume_begin_sync,
	&drba, 5, ZFS_SPACE_CHECK_NORMAL);
	} else {

	/*
	* For non-raw, non-incremental, non-resuming receives the
	* user can specify encryption parameters on the command line
	* with "zfs recv -o". For these receives we create a dcp and
	* pass it to the sync task. Creating the dcp will implicitly
	* remove the encryption params from the localprops nvlist,
	* which avoids errors when trying to set these normally
	* read-only properties. Any other kind of receive that
	* attempts to set these properties will fail as a result.
	*/
	if ((DMU_GET_FEATUREFLAGS(drc->drc_drrb->drr_versioninfo) &
	DMU_BACKUP_FEATURE_RAW) == 0 &&
	origin == NULL && drc->drc_drrb->drr_fromguid == 0) {
	err = dsl_crypto_params_create_nvlist(DCP_CMD_NONE,
	localprops, hidden_args, &drba.drba_dcp);
	}

	if (err == 0) {
	err = dsl_sync_task(tofs,
	dmu_recv_begin_check, dmu_recv_begin_sync,
	&drba, 5, ZFS_SPACE_CHECK_NORMAL);
	dsl_crypto_params_free(drba.drba_dcp, !!err);
	}
	}

	if (err != 0) {
	kmem_free(drc->drc_next_rrd, sizeof (*drc->drc_next_rrd));
	nvlist_free(drc->drc_begin_nvl);
	}
	return (err);
	}

	static int
	receive_read(dmu_recv_cookie_t drc, int len, void buf)
	{
	int done = 0;

	/*
	* The code doesn't rely on this (lengths being multiples of 8). See
	* comment in dump_bytes.
	*/
	ASSERT(len % 8 == 0 \|\|
	(drc->drc_featureflags & DMU_BACKUP_FEATURE_RAW) != 0);

	while (done < len) {
	ssize_t resid;
	zfs_file_t *fp = drc->drc_fp;
	int err = zfs_file_read(fp, (char *)buf + done,
	len - done, &resid);
	if (resid == len - done) {
	/*
	* Note: ECKSUM or ZFS_ERR_STREAM_TRUNCATED indicates
	* that the receive was interrupted and can
	* potentially be resumed.
	*/
	err = SET_ERROR(ZFS_ERR_STREAM_TRUNCATED);
	}
	drc->drc_voff += len - done - resid;
	done = len - resid;
	if (err != 0)
	return (err);
	}

	drc->drc_bytes_read += len;

	ASSERT3U(done, ==, len);
	return (0);
	}

	static inline uint8_t
	deduce_nblkptr(dmu_object_type_t bonus_type, uint64_t bonus_size)
	{
	if (bonus_type == DMU_OT_SA) {
	return (1);
	} else {
	return (1 +
	((DN_OLD_MAX_BONUSLEN -
	MIN(DN_OLD_MAX_BONUSLEN, bonus_size)) >> SPA_BLKPTRSHIFT));
	}
	}

	static void
	save_resume_state(struct receive_writer_arg *rwa,
	uint64_t object, uint64_t offset, dmu_tx_t *tx)
	{
	int txgoff = dmu_tx_get_txg(tx) & TXG_MASK;

	if (!rwa->resumable)
	return;

	/*
	* We use ds_resume_bytes[] != 0 to indicate that we need to
	* update this on disk, so it must not be 0.
	*/
	ASSERT(rwa->bytes_read != 0);

	/*
	* We only resume from write records, which have a valid
	* (non-meta-dnode) object number.
	*/
	ASSERT(object != 0);

	/*
	* For resuming to work correctly, we must receive records in order,
	* sorted by object,offset. This is checked by the callers, but
	* assert it here for good measure.
	*/
	ASSERT3U(object, >=, rwa->os->os_dsl_dataset->ds_resume_object[txgoff]);
	ASSERT(object != rwa->os->os_dsl_dataset->ds_resume_object[txgoff] \|\|
	offset >= rwa->os->os_dsl_dataset->ds_resume_offset[txgoff]);
	ASSERT3U(rwa->bytes_read, >=,
	rwa->os->os_dsl_dataset->ds_resume_bytes[txgoff]);

	rwa->os->os_dsl_dataset->ds_resume_object[txgoff] = object;
	rwa->os->os_dsl_dataset->ds_resume_offset[txgoff] = offset;
	rwa->os->os_dsl_dataset->ds_resume_bytes[txgoff] = rwa->bytes_read;
	}

	static int
	receive_object_is_same_generation(objset_t *os, uint64_t object,
	dmu_object_type_t old_bonus_type, dmu_object_type_t new_bonus_type,
	const void new_bonus, boolean_t samegenp)
	{
	zfs_file_info_t zoi;
	int err;

	dmu_buf_t *old_bonus_dbuf;
	err = dmu_bonus_hold(os, object, FTAG, &old_bonus_dbuf);
	if (err != 0)
	return (err);
	err = dmu_get_file_info(os, old_bonus_type, old_bonus_dbuf->db_data,
	&zoi);
	dmu_buf_rele(old_bonus_dbuf, FTAG);
	if (err != 0)
	return (err);
	uint64_t old_gen = zoi.zfi_generation;

	err = dmu_get_file_info(os, new_bonus_type, new_bonus, &zoi);
	if (err != 0)
	return (err);
	uint64_t new_gen = zoi.zfi_generation;

	*samegenp = (old_gen == new_gen);
	return (0);
	}

	static int
	receive_handle_existing_object(const struct receive_writer_arg *rwa,
	const struct drr_object drro, const dmu_object_info_t doi,
	const void *bonus_data,
	uint64_t object_to_hold, uint32_t new_blksz)
	{
	uint32_t indblksz = drro->drr_indblkshift ?
	1ULL << drro->drr_indblkshift : 0;
	int nblkptr = deduce_nblkptr(drro->drr_bonustype,
	drro->drr_bonuslen);
	uint8_t dn_slots = drro->drr_dn_slots != 0 ?
	drro->drr_dn_slots : DNODE_MIN_SLOTS;
	boolean_t do_free_range = B_FALSE;
	int err;

	*object_to_hold = drro->drr_object;

	/* nblkptr should be bounded by the bonus size and type */
	if (rwa->raw && nblkptr != drro->drr_nblkptr)
	return (SET_ERROR(EINVAL));

	/*
	* After the previous send stream, the sending system may
	* have freed this object, and then happened to re-allocate
	* this object number in a later txg. In this case, we are
	* receiving a different logical file, and the block size may
	* appear to be different. i.e. we may have a different
	* block size for this object than what the send stream says.
	* In this case we need to remove the object's contents,
	* so that its structure can be changed and then its contents
	* entirely replaced by subsequent WRITE records.
	*
	* If this is a -L (--large-block) incremental stream, and
	* the previous stream was not -L, the block size may appear
	* to increase. i.e. we may have a smaller block size for
	* this object than what the send stream says. In this case
	* we need to keep the object's contents and block size
	* intact, so that we don't lose parts of the object's
	* contents that are not changed by this incremental send
	* stream.
	*
	* We can distinguish between the two above cases by using
	* the ZPL's generation number (see
	* receive_object_is_same_generation()). However, we only
	* want to rely on the generation number when absolutely
	* necessary, because with raw receives, the generation is
	* encrypted. We also want to minimize dependence on the
	* ZPL, so that other types of datasets can also be received
	* (e.g. ZVOLs, although note that ZVOLS currently do not
	* reallocate their objects or change their structure).
	* Therefore, we check a number of different cases where we
	* know it is safe to discard the object's contents, before
	* using the ZPL's generation number to make the above
	* distinction.
	*/
	if (drro->drr_blksz != doi->doi_data_block_size) {
	if (rwa->raw) {
	/*
	* RAW streams always have large blocks, so
	* we are sure that the data is not needed
	* due to changing --large-block to be on.
	* Which is fortunate since the bonus buffer
	* (which contains the ZPL generation) is
	* encrypted, and the key might not be
	* loaded.
	*/
	do_free_range = B_TRUE;
	} else if (rwa->full) {
	/*
	* This is a full send stream, so it always
	* replaces what we have. Even if the
	* generation numbers happen to match, this
	* can not actually be the same logical file.
	* This is relevant when receiving a full
	* send as a clone.
	*/
	do_free_range = B_TRUE;
	} else if (drro->drr_type !=
	DMU_OT_PLAIN_FILE_CONTENTS \|\|
	doi->doi_type != DMU_OT_PLAIN_FILE_CONTENTS) {
	/*
	* PLAIN_FILE_CONTENTS are the only type of
	* objects that have ever been stored with
	* large blocks, so we don't need the special
	* logic below. ZAP blocks can shrink (when
	* there's only one block), so we don't want
	* to hit the error below about block size
	* only increasing.
	*/
	do_free_range = B_TRUE;
	} else if (doi->doi_max_offset <=
	doi->doi_data_block_size) {
	/*
	* There is only one block. We can free it,
	* because its contents will be replaced by a
	* WRITE record. This can not be the no-L ->
	* -L case, because the no-L case would have
	* resulted in multiple blocks. If we
	* supported -L -> no-L, it would not be safe
	* to free the file's contents. Fortunately,
	* that is not allowed (see
	* recv_check_large_blocks()).
	*/
	do_free_range = B_TRUE;
	} else {
	boolean_t is_same_gen;
	err = receive_object_is_same_generation(rwa->os,
	drro->drr_object, doi->doi_bonus_type,
	drro->drr_bonustype, bonus_data, &is_same_gen);
	if (err != 0)
	return (SET_ERROR(EINVAL));

	if (is_same_gen) {
	/*
	* This is the same logical file, and
	* the block size must be increasing.
	* It could only decrease if
	* --large-block was changed to be
	* off, which is checked in
	* recv_check_large_blocks().
	*/
	if (drro->drr_blksz <=
	doi->doi_data_block_size)
	return (SET_ERROR(EINVAL));
	/*
	* We keep the existing blocksize and
	* contents.
	*/
	*new_blksz =
	doi->doi_data_block_size;
	} else {
	do_free_range = B_TRUE;
	}
	}
	}

	/* nblkptr can only decrease if the object was reallocated */
	if (nblkptr < doi->doi_nblkptr)
	do_free_range = B_TRUE;

	/* number of slots can only change on reallocation */
	if (dn_slots != doi->doi_dnodesize >> DNODE_SHIFT)
	do_free_range = B_TRUE;

	/*
	* For raw sends we also check a few other fields to
	* ensure we are preserving the objset structure exactly
	* as it was on the receive side:
	* - A changed indirect block size
	* - A smaller nlevels
	*/
	if (rwa->raw) {
	if (indblksz != doi->doi_metadata_block_size)
	do_free_range = B_TRUE;
	if (drro->drr_nlevels < doi->doi_indirection)
	do_free_range = B_TRUE;
	}

	if (do_free_range) {
	err = dmu_free_long_range(rwa->os, drro->drr_object,
	0, DMU_OBJECT_END);
	if (err != 0)
	return (SET_ERROR(EINVAL));
	}

	/*
	* The dmu does not currently support decreasing nlevels
	* or changing the number of dnode slots on an object. For
	* non-raw sends, this does not matter and the new object
	* can just use the previous one's nlevels. For raw sends,
	* however, the structure of the received dnode (including
	* nlevels and dnode slots) must match that of the send
	* side. Therefore, instead of using dmu_object_reclaim(),
	* we must free the object completely and call
	* dmu_object_claim_dnsize() instead.
	*/
	if ((rwa->raw && drro->drr_nlevels < doi->doi_indirection) \|\|
	dn_slots != doi->doi_dnodesize >> DNODE_SHIFT) {
	err = dmu_free_long_object(rwa->os, drro->drr_object);
	if (err != 0)
	return (SET_ERROR(EINVAL));

	txg_wait_synced(dmu_objset_pool(rwa->os), 0);
	*object_to_hold = DMU_NEW_OBJECT;
	}

	/*
	* For raw receives, free everything beyond the new incoming
	* maxblkid. Normally this would be done with a DRR_FREE
	* record that would come after this DRR_OBJECT record is
	* processed. However, for raw receives we manually set the
	* maxblkid from the drr_maxblkid and so we must first free
	* everything above that blkid to ensure the DMU is always
	* consistent with itself. We will never free the first block
	* of the object here because a maxblkid of 0 could indicate
	* an object with a single block or one with no blocks. This
	* free may be skipped when dmu_free_long_range() was called
	* above since it covers the entire object's contents.
	*/
	if (rwa->raw && *object_to_hold != DMU_NEW_OBJECT && !do_free_range) {
	err = dmu_free_long_range(rwa->os, drro->drr_object,
	(drro->drr_maxblkid + 1) * doi->doi_data_block_size,
	DMU_OBJECT_END);
	if (err != 0)
	return (SET_ERROR(EINVAL));
	}
	return (0);
	}

	noinline static int
	receive_object(struct receive_writer_arg rwa, struct drr_object drro,
	void *data)
	{
	dmu_object_info_t doi;
	dmu_tx_t *tx;
	int err;
	uint32_t new_blksz = drro->drr_blksz;
	uint8_t dn_slots = drro->drr_dn_slots != 0 ?
	drro->drr_dn_slots : DNODE_MIN_SLOTS;

	if (drro->drr_type == DMU_OT_NONE \|\|
	!DMU_OT_IS_VALID(drro->drr_type) \|\|
	!DMU_OT_IS_VALID(drro->drr_bonustype) \|\|
	drro->drr_checksumtype >= ZIO_CHECKSUM_FUNCTIONS \|\|
	drro->drr_compress >= ZIO_COMPRESS_FUNCTIONS \|\|
	P2PHASE(drro->drr_blksz, SPA_MINBLOCKSIZE) \|\|
	drro->drr_blksz < SPA_MINBLOCKSIZE \|\|
	drro->drr_blksz > spa_maxblocksize(dmu_objset_spa(rwa->os)) \|\|
	drro->drr_bonuslen >
	DN_BONUS_SIZE(spa_maxdnodesize(dmu_objset_spa(rwa->os))) \|\|
	dn_slots >
	(spa_maxdnodesize(dmu_objset_spa(rwa->os)) >> DNODE_SHIFT)) {
	return (SET_ERROR(EINVAL));
	}

	if (rwa->raw) {
	/*
	* We should have received a DRR_OBJECT_RANGE record
	* containing this block and stored it in rwa.
	*/
	if (drro->drr_object < rwa->or_firstobj \|\|
	drro->drr_object >= rwa->or_firstobj + rwa->or_numslots \|\|
	drro->drr_raw_bonuslen < drro->drr_bonuslen \|\|
	drro->drr_indblkshift > SPA_MAXBLOCKSHIFT \|\|
	drro->drr_nlevels > DN_MAX_LEVELS \|\|
	drro->drr_nblkptr > DN_MAX_NBLKPTR \|\|
	DN_SLOTS_TO_BONUSLEN(dn_slots) <
	drro->drr_raw_bonuslen)
	return (SET_ERROR(EINVAL));
	} else {
	/*
	* The DRR_OBJECT_SPILL flag is valid when the DRR_BEGIN
	* record indicates this by setting DRR_FLAG_SPILL_BLOCK.
	*/
	if (((drro->drr_flags & ~(DRR_OBJECT_SPILL))) \|\|
	(!rwa->spill && DRR_OBJECT_HAS_SPILL(drro->drr_flags))) {
	return (SET_ERROR(EINVAL));
	}

	if (drro->drr_raw_bonuslen != 0 \|\| drro->drr_nblkptr != 0 \|\|
	drro->drr_indblkshift != 0 \|\| drro->drr_nlevels != 0) {
	return (SET_ERROR(EINVAL));
	}
	}

	err = dmu_object_info(rwa->os, drro->drr_object, &doi);

	if (err != 0 && err != ENOENT && err != EEXIST)
	return (SET_ERROR(EINVAL));

	if (drro->drr_object > rwa->max_object)
	rwa->max_object = drro->drr_object;

	/*
	* If we are losing blkptrs or changing the block size this must
	* be a new file instance. We must clear out the previous file
	* contents before we can change this type of metadata in the dnode.
	* Raw receives will also check that the indirect structure of the
	* dnode hasn't changed.
	*/
	uint64_t object_to_hold;
	if (err == 0) {
	err = receive_handle_existing_object(rwa, drro, &doi, data,
	&object_to_hold, &new_blksz);
	} else if (err == EEXIST) {
	/*
	* The object requested is currently an interior slot of a
	* multi-slot dnode. This will be resolved when the next txg
	* is synced out, since the send stream will have told us
	* to free this slot when we freed the associated dnode
	* earlier in the stream.
	*/
	txg_wait_synced(dmu_objset_pool(rwa->os), 0);

	if (dmu_object_info(rwa->os, drro->drr_object, NULL) != ENOENT)
	return (SET_ERROR(EINVAL));

	/* object was freed and we are about to allocate a new one */
	object_to_hold = DMU_NEW_OBJECT;
	} else {
	/* object is free and we are about to allocate a new one */
	object_to_hold = DMU_NEW_OBJECT;
	}

	/*
	* If this is a multi-slot dnode there is a chance that this
	* object will expand into a slot that is already used by
	* another object from the previous snapshot. We must free
	* these objects before we attempt to allocate the new dnode.
	*/
	if (dn_slots > 1) {
	boolean_t need_sync = B_FALSE;

	for (uint64_t slot = drro->drr_object + 1;
	slot < drro->drr_object + dn_slots;
	slot++) {
	dmu_object_info_t slot_doi;

	err = dmu_object_info(rwa->os, slot, &slot_doi);
	if (err == ENOENT \|\| err == EEXIST)
	continue;
	else if (err != 0)
	return (err);

	err = dmu_free_long_object(rwa->os, slot);
	if (err != 0)
	return (err);

	need_sync = B_TRUE;
	}

	if (need_sync)
	txg_wait_synced(dmu_objset_pool(rwa->os), 0);
	}

	tx = dmu_tx_create(rwa->os);
	dmu_tx_hold_bonus(tx, object_to_hold);
	dmu_tx_hold_write(tx, object_to_hold, 0, 0);
	err = dmu_tx_assign(tx, TXG_WAIT);
	if (err != 0) {
	dmu_tx_abort(tx);
	return (err);
	}

	if (object_to_hold == DMU_NEW_OBJECT) {
	/* Currently free, wants to be allocated */
	err = dmu_object_claim_dnsize(rwa->os, drro->drr_object,
	drro->drr_type, new_blksz,
	drro->drr_bonustype, drro->drr_bonuslen,
	dn_slots << DNODE_SHIFT, tx);
	} else if (drro->drr_type != doi.doi_type \|\|
	new_blksz != doi.doi_data_block_size \|\|
	drro->drr_bonustype != doi.doi_bonus_type \|\|
	drro->drr_bonuslen != doi.doi_bonus_size) {
	/* Currently allocated, but with different properties */
	err = dmu_object_reclaim_dnsize(rwa->os, drro->drr_object,
	drro->drr_type, new_blksz,
	drro->drr_bonustype, drro->drr_bonuslen,
	dn_slots << DNODE_SHIFT, rwa->spill ?
	DRR_OBJECT_HAS_SPILL(drro->drr_flags) : B_FALSE, tx);
	} else if (rwa->spill && !DRR_OBJECT_HAS_SPILL(drro->drr_flags)) {
	/*
	* Currently allocated, the existing version of this object
	* may reference a spill block that is no longer allocated
	* at the source and needs to be freed.
	*/
	err = dmu_object_rm_spill(rwa->os, drro->drr_object, tx);
	}

	if (err != 0) {
	dmu_tx_commit(tx);
	return (SET_ERROR(EINVAL));
	}

	if (rwa->or_crypt_params_present) {
	/*
	* Set the crypt params for the buffer associated with this
	* range of dnodes. This causes the blkptr_t to have the
	* same crypt params (byteorder, salt, iv, mac) as on the
	* sending side.
	*
	* Since we are committing this tx now, it is possible for
	* the dnode block to end up on-disk with the incorrect MAC,
	* if subsequent objects in this block are received in a
	* different txg. However, since the dataset is marked as
	* inconsistent, no code paths will do a non-raw read (or
	* decrypt the block / verify the MAC). The receive code and
	* scrub code can safely do raw reads and verify the
	* checksum. They don't need to verify the MAC.
	*/
	dmu_buf_t *db = NULL;
	uint64_t offset = rwa->or_firstobj * DNODE_MIN_SIZE;

	err = dmu_buf_hold_by_dnode(DMU_META_DNODE(rwa->os),
	offset, FTAG, &db, DMU_READ_PREFETCH \| DMU_READ_NO_DECRYPT);
	if (err != 0) {
	dmu_tx_commit(tx);
	return (SET_ERROR(EINVAL));
	}

	dmu_buf_set_crypt_params(db, rwa->or_byteorder,
	rwa->or_salt, rwa->or_iv, rwa->or_mac, tx);

	dmu_buf_rele(db, FTAG);

	rwa->or_crypt_params_present = B_FALSE;
	}

	dmu_object_set_checksum(rwa->os, drro->drr_object,
	drro->drr_checksumtype, tx);
	dmu_object_set_compress(rwa->os, drro->drr_object,
	drro->drr_compress, tx);

	/* handle more restrictive dnode structuring for raw recvs */
	if (rwa->raw) {
	/*
	* Set the indirect block size, block shift, nlevels.
	* This will not fail because we ensured all of the
	* blocks were freed earlier if this is a new object.
	* For non-new objects block size and indirect block
	* shift cannot change and nlevels can only increase.
	*/
	ASSERT3U(new_blksz, ==, drro->drr_blksz);
	VERIFY0(dmu_object_set_blocksize(rwa->os, drro->drr_object,
	drro->drr_blksz, drro->drr_indblkshift, tx));
	VERIFY0(dmu_object_set_nlevels(rwa->os, drro->drr_object,
	drro->drr_nlevels, tx));

	/*
	* Set the maxblkid. This will always succeed because
	* we freed all blocks beyond the new maxblkid above.
	*/
	VERIFY0(dmu_object_set_maxblkid(rwa->os, drro->drr_object,
	drro->drr_maxblkid, tx));
	}

	if (data != NULL) {
	dmu_buf_t *db;
	dnode_t *dn;
	uint32_t flags = DMU_READ_NO_PREFETCH;

	if (rwa->raw)
	flags \|= DMU_READ_NO_DECRYPT;

	VERIFY0(dnode_hold(rwa->os, drro->drr_object, FTAG, &dn));
	VERIFY0(dmu_bonus_hold_by_dnode(dn, FTAG, &db, flags));

	dmu_buf_will_dirty(db, tx);

	ASSERT3U(db->db_size, >=, drro->drr_bonuslen);
	bcopy(data, db->db_data, DRR_OBJECT_PAYLOAD_SIZE(drro));

	/*
	* Raw bonus buffers have their byteorder determined by the
	* DRR_OBJECT_RANGE record.
	*/
	if (rwa->byteswap && !rwa->raw) {
	dmu_object_byteswap_t byteswap =
	DMU_OT_BYTESWAP(drro->drr_bonustype);
	dmu_ot_byteswap[byteswap].ob_func(db->db_data,
	DRR_OBJECT_PAYLOAD_SIZE(drro));
	}
	dmu_buf_rele(db, FTAG);
	dnode_rele(dn, FTAG);
	}
	dmu_tx_commit(tx);

	return (0);
	}

	/* ARGSUSED */
	noinline static int
	receive_freeobjects(struct receive_writer_arg *rwa,
	struct drr_freeobjects *drrfo)
	{
	uint64_t obj;
	int next_err = 0;

	if (drrfo->drr_firstobj + drrfo->drr_numobjs < drrfo->drr_firstobj)
	return (SET_ERROR(EINVAL));

	for (obj = drrfo->drr_firstobj == 0 ? 1 : drrfo->drr_firstobj;
	obj < drrfo->drr_firstobj + drrfo->drr_numobjs &&
	obj < DN_MAX_OBJECT && next_err == 0;
	next_err = dmu_object_next(rwa->os, &obj, FALSE, 0)) {
	dmu_object_info_t doi;
	int err;

	err = dmu_object_info(rwa->os, obj, &doi);
	if (err == ENOENT)
	continue;
	else if (err != 0)
	return (err);

	err = dmu_free_long_object(rwa->os, obj);

	if (err != 0)
	return (err);
	}
	if (next_err != ESRCH)
	return (next_err);
	return (0);
	}

	/*
	* Note: if this fails, the caller will clean up any records left on the
	* rwa->write_batch list.
	*/
	static int
	flush_write_batch_impl(struct receive_writer_arg *rwa)
	{
	dnode_t *dn;
	int err;

	if (dnode_hold(rwa->os, rwa->last_object, FTAG, &dn) != 0)
	return (SET_ERROR(EINVAL));

	struct receive_record_arg *last_rrd = list_tail(&rwa->write_batch);
	struct drr_write *last_drrw = &last_rrd->header.drr_u.drr_write;

	struct receive_record_arg *first_rrd = list_head(&rwa->write_batch);
	struct drr_write *first_drrw = &first_rrd->header.drr_u.drr_write;

	ASSERT3U(rwa->last_object, ==, last_drrw->drr_object);
	ASSERT3U(rwa->last_offset, ==, last_drrw->drr_offset);

	dmu_tx_t *tx = dmu_tx_create(rwa->os);
	dmu_tx_hold_write_by_dnode(tx, dn, first_drrw->drr_offset,
	last_drrw->drr_offset - first_drrw->drr_offset +
	last_drrw->drr_logical_size);
	err = dmu_tx_assign(tx, TXG_WAIT);
	if (err != 0) {
	dmu_tx_abort(tx);
	dnode_rele(dn, FTAG);
	return (err);
	}

	struct receive_record_arg *rrd;
	while ((rrd = list_head(&rwa->write_batch)) != NULL) {
	struct drr_write *drrw = &rrd->header.drr_u.drr_write;
	abd_t *abd = rrd->abd;

	ASSERT3U(drrw->drr_object, ==, rwa->last_object);

	if (drrw->drr_logical_size != dn->dn_datablksz) {
	/*
	* The WRITE record is larger than the object's block
	* size. We must be receiving an incremental
	* large-block stream into a dataset that previously did
	* a non-large-block receive. Lightweight writes must
	* be exactly one block, so we need to decompress the
	* data (if compressed) and do a normal dmu_write().
	*/
	ASSERT3U(drrw->drr_logical_size, >, dn->dn_datablksz);
	if (DRR_WRITE_COMPRESSED(drrw)) {
	abd_t *decomp_abd =
	abd_alloc_linear(drrw->drr_logical_size,
	B_FALSE);

	err = zio_decompress_data(
	drrw->drr_compressiontype,
	abd, abd_to_buf(decomp_abd),
	abd_get_size(abd),
	abd_get_size(decomp_abd), NULL);

	if (err == 0) {
	dmu_write_by_dnode(dn,
	drrw->drr_offset,
	drrw->drr_logical_size,
	abd_to_buf(decomp_abd), tx);
	}
	abd_free(decomp_abd);
	} else {
	dmu_write_by_dnode(dn,
	drrw->drr_offset,
	drrw->drr_logical_size,
	abd_to_buf(abd), tx);
	}
	if (err == 0)
	abd_free(abd);
	} else {
	zio_prop_t zp;
	dmu_write_policy(rwa->os, dn, 0, 0, &zp);

	enum zio_flag zio_flags = 0;

	if (rwa->raw) {
	zp.zp_encrypt = B_TRUE;
	zp.zp_compress = drrw->drr_compressiontype;
	zp.zp_byteorder = ZFS_HOST_BYTEORDER ^
	!!DRR_IS_RAW_BYTESWAPPED(drrw->drr_flags) ^
	rwa->byteswap;
	bcopy(drrw->drr_salt, zp.zp_salt,
	ZIO_DATA_SALT_LEN);
	bcopy(drrw->drr_iv, zp.zp_iv,
	ZIO_DATA_IV_LEN);
	bcopy(drrw->drr_mac, zp.zp_mac,
	ZIO_DATA_MAC_LEN);
	if (DMU_OT_IS_ENCRYPTED(zp.zp_type)) {
	zp.zp_nopwrite = B_FALSE;
	zp.zp_copies = MIN(zp.zp_copies,
	SPA_DVAS_PER_BP - 1);
	}
	zio_flags \|= ZIO_FLAG_RAW;
	} else if (DRR_WRITE_COMPRESSED(drrw)) {
	ASSERT3U(drrw->drr_compressed_size, >, 0);
	ASSERT3U(drrw->drr_logical_size, >=,
	drrw->drr_compressed_size);
	zp.zp_compress = drrw->drr_compressiontype;
	zio_flags \|= ZIO_FLAG_RAW_COMPRESS;
	} else if (rwa->byteswap) {
	/*
	* Note: compressed blocks never need to be
	* byteswapped, because WRITE records for
	* metadata blocks are never compressed. The
	* exception is raw streams, which are written
	* in the original byteorder, and the byteorder
	* bit is preserved in the BP by setting
	* zp_byteorder above.
	*/
	dmu_object_byteswap_t byteswap =
	DMU_OT_BYTESWAP(drrw->drr_type);
	dmu_ot_byteswap[byteswap].ob_func(
	abd_to_buf(abd),
	DRR_WRITE_PAYLOAD_SIZE(drrw));
	}

	/*
	* Since this data can't be read until the receive
	* completes, we can do a "lightweight" write for
	* improved performance.
	*/
	err = dmu_lightweight_write_by_dnode(dn,
	drrw->drr_offset, abd, &zp, zio_flags, tx);
	}

	if (err != 0) {
	/*
	* This rrd is left on the list, so the caller will
	* free it (and the abd).
	*/
	break;
	}

	/*
	* Note: If the receive fails, we want the resume stream to
	* start with the same record that we last successfully
	* received (as opposed to the next record), so that we can
	* verify that we are resuming from the correct location.
	*/
	save_resume_state(rwa, drrw->drr_object, drrw->drr_offset, tx);

	list_remove(&rwa->write_batch, rrd);
	kmem_free(rrd, sizeof (*rrd));
	}

	dmu_tx_commit(tx);
	dnode_rele(dn, FTAG);
	return (err);
	}

	noinline static int
	flush_write_batch(struct receive_writer_arg *rwa)
	{
	if (list_is_empty(&rwa->write_batch))
	return (0);
	int err = rwa->err;
	if (err == 0)
	err = flush_write_batch_impl(rwa);
	if (err != 0) {
	struct receive_record_arg *rrd;
	while ((rrd = list_remove_head(&rwa->write_batch)) != NULL) {
	abd_free(rrd->abd);
	kmem_free(rrd, sizeof (*rrd));
	}
	}
	ASSERT(list_is_empty(&rwa->write_batch));
	return (err);
	}

	noinline static int
	receive_process_write_record(struct receive_writer_arg *rwa,
	struct receive_record_arg *rrd)
	{
	int err = 0;

	ASSERT3U(rrd->header.drr_type, ==, DRR_WRITE);
	struct drr_write *drrw = &rrd->header.drr_u.drr_write;

	if (drrw->drr_offset + drrw->drr_logical_size < drrw->drr_offset \|\|
	!DMU_OT_IS_VALID(drrw->drr_type))
	return (SET_ERROR(EINVAL));

	/*
	* For resuming to work, records must be in increasing order
	* by (object, offset).
	*/
	if (drrw->drr_object < rwa->last_object \|\|
	(drrw->drr_object == rwa->last_object &&
	drrw->drr_offset < rwa->last_offset)) {
	return (SET_ERROR(EINVAL));
	}

	struct receive_record_arg *first_rrd = list_head(&rwa->write_batch);
	struct drr_write *first_drrw = &first_rrd->header.drr_u.drr_write;
	uint64_t batch_size =
	MIN(zfs_recv_write_batch_size, DMU_MAX_ACCESS / 2);
	if (first_rrd != NULL &&
	(drrw->drr_object != first_drrw->drr_object \|\|
	drrw->drr_offset >= first_drrw->drr_offset + batch_size)) {
	err = flush_write_batch(rwa);
	if (err != 0)
	return (err);
	}

	rwa->last_object = drrw->drr_object;
	rwa->last_offset = drrw->drr_offset;

	if (rwa->last_object > rwa->max_object)
	rwa->max_object = rwa->last_object;

	list_insert_tail(&rwa->write_batch, rrd);
	/*
	* Return EAGAIN to indicate that we will use this rrd again,
	* so the caller should not free it
	*/
	return (EAGAIN);
	}

	static int
	receive_write_embedded(struct receive_writer_arg *rwa,
	struct drr_write_embedded drrwe, void data)
	{
	dmu_tx_t *tx;
	int err;

	if (drrwe->drr_offset + drrwe->drr_length < drrwe->drr_offset)
	return (SET_ERROR(EINVAL));

	if (drrwe->drr_psize > BPE_PAYLOAD_SIZE)
	return (SET_ERROR(EINVAL));

	if (drrwe->drr_etype >= NUM_BP_EMBEDDED_TYPES)
	return (SET_ERROR(EINVAL));
	if (drrwe->drr_compression >= ZIO_COMPRESS_FUNCTIONS)
	return (SET_ERROR(EINVAL));
	if (rwa->raw)
	return (SET_ERROR(EINVAL));

	if (drrwe->drr_object > rwa->max_object)
	rwa->max_object = drrwe->drr_object;

	tx = dmu_tx_create(rwa->os);

	dmu_tx_hold_write(tx, drrwe->drr_object,
	drrwe->drr_offset, drrwe->drr_length);
	err = dmu_tx_assign(tx, TXG_WAIT);
	if (err != 0) {
	dmu_tx_abort(tx);
	return (err);
	}

	dmu_write_embedded(rwa->os, drrwe->drr_object,
	drrwe->drr_offset, data, drrwe->drr_etype,
	drrwe->drr_compression, drrwe->drr_lsize, drrwe->drr_psize,
	rwa->byteswap ^ ZFS_HOST_BYTEORDER, tx);

	/* See comment in restore_write. */
	save_resume_state(rwa, drrwe->drr_object, drrwe->drr_offset, tx);
	dmu_tx_commit(tx);
	return (0);
	}

	static int
	receive_spill(struct receive_writer_arg rwa, struct drr_spill drrs,
	abd_t *abd)
	{
	dmu_buf_t db, db_spill;
	int err;

	if (drrs->drr_length < SPA_MINBLOCKSIZE \|\|
	drrs->drr_length > spa_maxblocksize(dmu_objset_spa(rwa->os)))
	return (SET_ERROR(EINVAL));

	/*
	* This is an unmodified spill block which was added to the stream
	* to resolve an issue with incorrectly removing spill blocks. It
	* should be ignored by current versions of the code which support
	* the DRR_FLAG_SPILL_BLOCK flag.
	*/
	if (rwa->spill && DRR_SPILL_IS_UNMODIFIED(drrs->drr_flags)) {
	abd_free(abd);
	return (0);
	}

	if (rwa->raw) {
	if (!DMU_OT_IS_VALID(drrs->drr_type) \|\|
	drrs->drr_compressiontype >= ZIO_COMPRESS_FUNCTIONS \|\|
	drrs->drr_compressed_size == 0)
	return (SET_ERROR(EINVAL));
	}

	if (dmu_object_info(rwa->os, drrs->drr_object, NULL) != 0)
	return (SET_ERROR(EINVAL));

	if (drrs->drr_object > rwa->max_object)
	rwa->max_object = drrs->drr_object;

	VERIFY0(dmu_bonus_hold(rwa->os, drrs->drr_object, FTAG, &db));
	if ((err = dmu_spill_hold_by_bonus(db, DMU_READ_NO_DECRYPT, FTAG,
	&db_spill)) != 0) {
	dmu_buf_rele(db, FTAG);
	return (err);
	}

	dmu_tx_t *tx = dmu_tx_create(rwa->os);

	dmu_tx_hold_spill(tx, db->db_object);

	err = dmu_tx_assign(tx, TXG_WAIT);
	if (err != 0) {
	dmu_buf_rele(db, FTAG);
	dmu_buf_rele(db_spill, FTAG);
	dmu_tx_abort(tx);
	return (err);
	}

	/*
	* Spill blocks may both grow and shrink. When a change in size
	* occurs any existing dbuf must be updated to match the logical
	* size of the provided arc_buf_t.
	*/
	if (db_spill->db_size != drrs->drr_length) {
	dmu_buf_will_fill(db_spill, tx);
	VERIFY0(dbuf_spill_set_blksz(db_spill,
	drrs->drr_length, tx));
	}

	arc_buf_t *abuf;
	if (rwa->raw) {
	boolean_t byteorder = ZFS_HOST_BYTEORDER ^
	!!DRR_IS_RAW_BYTESWAPPED(drrs->drr_flags) ^
	rwa->byteswap;

	abuf = arc_loan_raw_buf(dmu_objset_spa(rwa->os),
	drrs->drr_object, byteorder, drrs->drr_salt,
	drrs->drr_iv, drrs->drr_mac, drrs->drr_type,
	drrs->drr_compressed_size, drrs->drr_length,
	drrs->drr_compressiontype, 0);
	} else {
	abuf = arc_loan_buf(dmu_objset_spa(rwa->os),
	DMU_OT_IS_METADATA(drrs->drr_type),
	drrs->drr_length);
	if (rwa->byteswap) {
	dmu_object_byteswap_t byteswap =
	DMU_OT_BYTESWAP(drrs->drr_type);
	dmu_ot_byteswap[byteswap].ob_func(abd_to_buf(abd),
	DRR_SPILL_PAYLOAD_SIZE(drrs));
	}
	}

	bcopy(abd_to_buf(abd), abuf->b_data, DRR_SPILL_PAYLOAD_SIZE(drrs));
	abd_free(abd);
	dbuf_assign_arcbuf((dmu_buf_impl_t *)db_spill, abuf, tx);

	dmu_buf_rele(db, FTAG);
	dmu_buf_rele(db_spill, FTAG);

	dmu_tx_commit(tx);
	return (0);
	}

	/* ARGSUSED */
	noinline static int
	receive_free(struct receive_writer_arg rwa, struct drr_free drrf)
	{
	int err;

	if (drrf->drr_length != -1ULL &&
	drrf->drr_offset + drrf->drr_length < drrf->drr_offset)
	return (SET_ERROR(EINVAL));

	if (dmu_object_info(rwa->os, drrf->drr_object, NULL) != 0)
	return (SET_ERROR(EINVAL));

	if (drrf->drr_object > rwa->max_object)
	rwa->max_object = drrf->drr_object;

	err = dmu_free_long_range(rwa->os, drrf->drr_object,
	drrf->drr_offset, drrf->drr_length);

	return (err);
	}

	static int
	receive_object_range(struct receive_writer_arg *rwa,
	struct drr_object_range *drror)
	{
	/*
	* By default, we assume this block is in our native format
	* (ZFS_HOST_BYTEORDER). We then take into account whether
	* the send stream is byteswapped (rwa->byteswap). Finally,
	* we need to byteswap again if this particular block was
	* in non-native format on the send side.
	*/
	boolean_t byteorder = ZFS_HOST_BYTEORDER ^ rwa->byteswap ^
	!!DRR_IS_RAW_BYTESWAPPED(drror->drr_flags);

	/*
	* Since dnode block sizes are constant, we should not need to worry
	* about making sure that the dnode block size is the same on the
	* sending and receiving sides for the time being. For non-raw sends,
	* this does not matter (and in fact we do not send a DRR_OBJECT_RANGE
	* record at all). Raw sends require this record type because the
	* encryption parameters are used to protect an entire block of bonus
	* buffers. If the size of dnode blocks ever becomes variable,
	* handling will need to be added to ensure that dnode block sizes
	* match on the sending and receiving side.
	*/
	if (drror->drr_numslots != DNODES_PER_BLOCK \|\|
	P2PHASE(drror->drr_firstobj, DNODES_PER_BLOCK) != 0 \|\|
	!rwa->raw)
	return (SET_ERROR(EINVAL));

	if (drror->drr_firstobj > rwa->max_object)
	rwa->max_object = drror->drr_firstobj;

	/*
	* The DRR_OBJECT_RANGE handling must be deferred to receive_object()
	* so that the block of dnodes is not written out when it's empty,
	* and converted to a HOLE BP.
	*/
	rwa->or_crypt_params_present = B_TRUE;
	rwa->or_firstobj = drror->drr_firstobj;
	rwa->or_numslots = drror->drr_numslots;
	bcopy(drror->drr_salt, rwa->or_salt, ZIO_DATA_SALT_LEN);
	bcopy(drror->drr_iv, rwa->or_iv, ZIO_DATA_IV_LEN);
	bcopy(drror->drr_mac, rwa->or_mac, ZIO_DATA_MAC_LEN);
	rwa->or_byteorder = byteorder;

	return (0);
	}

	/*
	* Until we have the ability to redact large ranges of data efficiently, we
	* process these records as frees.
	*/
	/* ARGSUSED */
	noinline static int
	receive_redact(struct receive_writer_arg rwa, struct drr_redact drrr)
	{
	struct drr_free drrf = {0};
	drrf.drr_length = drrr->drr_length;
	drrf.drr_object = drrr->drr_object;
	drrf.drr_offset = drrr->drr_offset;
	drrf.drr_toguid = drrr->drr_toguid;
	return (receive_free(rwa, &drrf));
	}

	/* used to destroy the drc_ds on error */
	static void
	dmu_recv_cleanup_ds(dmu_recv_cookie_t *drc)
	{
	dsl_dataset_t *ds = drc->drc_ds;
	ds_hold_flags_t dsflags;

	dsflags = (drc->drc_raw) ? DS_HOLD_FLAG_NONE : DS_HOLD_FLAG_DECRYPT;
	/*
	* Wait for the txg sync before cleaning up the receive. For
	* resumable receives, this ensures that our resume state has
	* been written out to disk. For raw receives, this ensures
	* that the user accounting code will not attempt to do anything
	* after we stopped receiving the dataset.
	*/
	txg_wait_synced(ds->ds_dir->dd_pool, 0);
	ds->ds_objset->os_raw_receive = B_FALSE;

	rrw_enter(&ds->ds_bp_rwlock, RW_READER, FTAG);
	if (drc->drc_resumable && drc->drc_should_save &&
	!BP_IS_HOLE(dsl_dataset_get_blkptr(ds))) {
	rrw_exit(&ds->ds_bp_rwlock, FTAG);
	dsl_dataset_disown(ds, dsflags, dmu_recv_tag);
	} else {
	char name[ZFS_MAX_DATASET_NAME_LEN];
	rrw_exit(&ds->ds_bp_rwlock, FTAG);
	dsl_dataset_name(ds, name);
	dsl_dataset_disown(ds, dsflags, dmu_recv_tag);
	(void) dsl_destroy_head(name);
	}
	}

	static void
	receive_cksum(dmu_recv_cookie_t drc, int len, void buf)
	{
	if (drc->drc_byteswap) {
	(void) fletcher_4_incremental_byteswap(buf, len,
	&drc->drc_cksum);
	} else {
	(void) fletcher_4_incremental_native(buf, len, &drc->drc_cksum);
	}
	}

	/*
	* Read the payload into a buffer of size len, and update the current record's
	* payload field.
	* Allocate drc->drc_next_rrd and read the next record's header into
	* drc->drc_next_rrd->header.
	* Verify checksum of payload and next record.
	*/
	static int
	receive_read_payload_and_next_header(dmu_recv_cookie_t drc, int len, void buf)
	{
	int err;

	if (len != 0) {
	ASSERT3U(len, <=, SPA_MAXBLOCKSIZE);
	err = receive_read(drc, len, buf);
	if (err != 0)
	return (err);
	receive_cksum(drc, len, buf);

	/* note: rrd is NULL when reading the begin record's payload */
	if (drc->drc_rrd != NULL) {
	drc->drc_rrd->payload = buf;
	drc->drc_rrd->payload_size = len;
	drc->drc_rrd->bytes_read = drc->drc_bytes_read;
	}
	} else {
	ASSERT3P(buf, ==, NULL);
	}

	drc->drc_prev_cksum = drc->drc_cksum;

	drc->drc_next_rrd = kmem_zalloc(sizeof (*drc->drc_next_rrd), KM_SLEEP);
	err = receive_read(drc, sizeof (drc->drc_next_rrd->header),
	&drc->drc_next_rrd->header);
	drc->drc_next_rrd->bytes_read = drc->drc_bytes_read;

	if (err != 0) {
	kmem_free(drc->drc_next_rrd, sizeof (*drc->drc_next_rrd));
	drc->drc_next_rrd = NULL;
	return (err);
	}
	if (drc->drc_next_rrd->header.drr_type == DRR_BEGIN) {
	kmem_free(drc->drc_next_rrd, sizeof (*drc->drc_next_rrd));
	drc->drc_next_rrd = NULL;
	return (SET_ERROR(EINVAL));
	}

	/*
	* Note: checksum is of everything up to but not including the
	* checksum itself.
	*/
	ASSERT3U(offsetof(dmu_replay_record_t, drr_u.drr_checksum.drr_checksum),
	==, sizeof (dmu_replay_record_t) - sizeof (zio_cksum_t));
	receive_cksum(drc,
	offsetof(dmu_replay_record_t, drr_u.drr_checksum.drr_checksum),
	&drc->drc_next_rrd->header);

	zio_cksum_t cksum_orig =
	drc->drc_next_rrd->header.drr_u.drr_checksum.drr_checksum;
	zio_cksum_t *cksump =
	&drc->drc_next_rrd->header.drr_u.drr_checksum.drr_checksum;

	if (drc->drc_byteswap)
	byteswap_record(&drc->drc_next_rrd->header);

	if ((!ZIO_CHECKSUM_IS_ZERO(cksump)) &&
	!ZIO_CHECKSUM_EQUAL(drc->drc_cksum, *cksump)) {
	kmem_free(drc->drc_next_rrd, sizeof (*drc->drc_next_rrd));
	drc->drc_next_rrd = NULL;
	return (SET_ERROR(ECKSUM));
	}

	receive_cksum(drc, sizeof (cksum_orig), &cksum_orig);

	return (0);
	}

	/*
	* Issue the prefetch reads for any necessary indirect blocks.
	*
	* We use the object ignore list to tell us whether or not to issue prefetches
	* for a given object. We do this for both correctness (in case the blocksize
	* of an object has changed) and performance (if the object doesn't exist, don't
	* needlessly try to issue prefetches). We also trim the list as we go through
	* the stream to prevent it from growing to an unbounded size.
	*
	* The object numbers within will always be in sorted order, and any write
	* records we see will also be in sorted order, but they're not sorted with
	* respect to each other (i.e. we can get several object records before
	* receiving each object's write records). As a result, once we've reached a
	* given object number, we can safely remove any reference to lower object
	* numbers in the ignore list. In practice, we receive up to 32 object records
	* before receiving write records, so the list can have up to 32 nodes in it.
	*/
	/* ARGSUSED */
	static void
	receive_read_prefetch(dmu_recv_cookie_t *drc, uint64_t object, uint64_t offset,
	uint64_t length)
	{
	if (!objlist_exists(drc->drc_ignore_objlist, object)) {
	dmu_prefetch(drc->drc_os, object, 1, offset, length,
	ZIO_PRIORITY_SYNC_READ);
	}
	}

	/*
	* Read records off the stream, issuing any necessary prefetches.
	*/
	static int
	receive_read_record(dmu_recv_cookie_t *drc)
	{
	int err;

	switch (drc->drc_rrd->header.drr_type) {
	case DRR_OBJECT:
	{
	struct drr_object *drro =
	&drc->drc_rrd->header.drr_u.drr_object;
	uint32_t size = DRR_OBJECT_PAYLOAD_SIZE(drro);
	void *buf = NULL;
	dmu_object_info_t doi;

	if (size != 0)
	buf = kmem_zalloc(size, KM_SLEEP);

	err = receive_read_payload_and_next_header(drc, size, buf);
	if (err != 0) {
	kmem_free(buf, size);
	return (err);
	}
	err = dmu_object_info(drc->drc_os, drro->drr_object, &doi);
	/*
	* See receive_read_prefetch for an explanation why we're
	* storing this object in the ignore_obj_list.
	*/
	if (err == ENOENT \|\| err == EEXIST \|\|
	(err == 0 && doi.doi_data_block_size != drro->drr_blksz)) {
	objlist_insert(drc->drc_ignore_objlist,
	drro->drr_object);
	err = 0;
	}
	return (err);
	}
	case DRR_FREEOBJECTS:
	{
	err = receive_read_payload_and_next_header(drc, 0, NULL);
	return (err);
	}
	case DRR_WRITE:
	{
	struct drr_write *drrw = &drc->drc_rrd->header.drr_u.drr_write;
	int size = DRR_WRITE_PAYLOAD_SIZE(drrw);
	abd_t *abd = abd_alloc_linear(size, B_FALSE);
	err = receive_read_payload_and_next_header(drc, size,
	abd_to_buf(abd));
	if (err != 0) {
	abd_free(abd);
	return (err);
	}
	drc->drc_rrd->abd = abd;
	receive_read_prefetch(drc, drrw->drr_object, drrw->drr_offset,
	drrw->drr_logical_size);
	return (err);
	}
	case DRR_WRITE_EMBEDDED:
	{
	struct drr_write_embedded *drrwe =
	&drc->drc_rrd->header.drr_u.drr_write_embedded;
	uint32_t size = P2ROUNDUP(drrwe->drr_psize, 8);
	void *buf = kmem_zalloc(size, KM_SLEEP);

	err = receive_read_payload_and_next_header(drc, size, buf);
	if (err != 0) {
	kmem_free(buf, size);
	return (err);
	}

	receive_read_prefetch(drc, drrwe->drr_object, drrwe->drr_offset,
	drrwe->drr_length);
	return (err);
	}
	case DRR_FREE:
	case DRR_REDACT:
	{
	/*
	* It might be beneficial to prefetch indirect blocks here, but
	* we don't really have the data to decide for sure.
	*/
	err = receive_read_payload_and_next_header(drc, 0, NULL);
	return (err);
	}
	case DRR_END:
	{
	struct drr_end *drre = &drc->drc_rrd->header.drr_u.drr_end;
	if (!ZIO_CHECKSUM_EQUAL(drc->drc_prev_cksum,
	drre->drr_checksum))
	return (SET_ERROR(ECKSUM));
	return (0);
	}
	case DRR_SPILL:
	{
	struct drr_spill *drrs = &drc->drc_rrd->header.drr_u.drr_spill;
	int size = DRR_SPILL_PAYLOAD_SIZE(drrs);
	abd_t *abd = abd_alloc_linear(size, B_FALSE);
	err = receive_read_payload_and_next_header(drc, size,
	abd_to_buf(abd));
	if (err != 0)
	abd_free(abd);
	else
	drc->drc_rrd->abd = abd;
	return (err);
	}
	case DRR_OBJECT_RANGE:
	{
	err = receive_read_payload_and_next_header(drc, 0, NULL);
	return (err);

	}
	default:
	return (SET_ERROR(EINVAL));
	}
	}



	static void
	dprintf_drr(struct receive_record_arg *rrd, int err)
	{
	#ifdef ZFS_DEBUG
	switch (rrd->header.drr_type) {
	case DRR_OBJECT:
	{
	struct drr_object *drro = &rrd->header.drr_u.drr_object;
	dprintf("drr_type = OBJECT obj = %llu type = %u "
	"bonustype = %u blksz = %u bonuslen = %u cksumtype = %u "
	"compress = %u dn_slots = %u err = %d\n",
	drro->drr_object, drro->drr_type, drro->drr_bonustype,
	drro->drr_blksz, drro->drr_bonuslen,
	drro->drr_checksumtype, drro->drr_compress,
	drro->drr_dn_slots, err);
	break;
	}
	case DRR_FREEOBJECTS:
	{
	struct drr_freeobjects *drrfo =
	&rrd->header.drr_u.drr_freeobjects;
	dprintf("drr_type = FREEOBJECTS firstobj = %llu "
	"numobjs = %llu err = %d\n",
	drrfo->drr_firstobj, drrfo->drr_numobjs, err);
	break;
	}
	case DRR_WRITE:
	{
	struct drr_write *drrw = &rrd->header.drr_u.drr_write;
	dprintf("drr_type = WRITE obj = %llu type = %u offset = %llu "
	"lsize = %llu cksumtype = %u flags = %u "
	"compress = %u psize = %llu err = %d\n",
	drrw->drr_object, drrw->drr_type, drrw->drr_offset,
	drrw->drr_logical_size, drrw->drr_checksumtype,
	drrw->drr_flags, drrw->drr_compressiontype,
	drrw->drr_compressed_size, err);
	break;
	}
	case DRR_WRITE_BYREF:
	{
	struct drr_write_byref *drrwbr =
	&rrd->header.drr_u.drr_write_byref;
	dprintf("drr_type = WRITE_BYREF obj = %llu offset = %llu "
	"length = %llu toguid = %llx refguid = %llx "
	"refobject = %llu refoffset = %llu cksumtype = %u "
	"flags = %u err = %d\n",
	drrwbr->drr_object, drrwbr->drr_offset,
	drrwbr->drr_length, drrwbr->drr_toguid,
	drrwbr->drr_refguid, drrwbr->drr_refobject,
	drrwbr->drr_refoffset, drrwbr->drr_checksumtype,
	drrwbr->drr_flags, err);
	break;
	}
	case DRR_WRITE_EMBEDDED:
	{
	struct drr_write_embedded *drrwe =
	&rrd->header.drr_u.drr_write_embedded;
	dprintf("drr_type = WRITE_EMBEDDED obj = %llu offset = %llu "
	"length = %llu compress = %u etype = %u lsize = %u "
	"psize = %u err = %d\n",
	drrwe->drr_object, drrwe->drr_offset, drrwe->drr_length,
	drrwe->drr_compression, drrwe->drr_etype,
	drrwe->drr_lsize, drrwe->drr_psize, err);
	break;
	}
	case DRR_FREE:
	{
	struct drr_free *drrf = &rrd->header.drr_u.drr_free;
	dprintf("drr_type = FREE obj = %llu offset = %llu "
	"length = %lld err = %d\n",
	drrf->drr_object, drrf->drr_offset, drrf->drr_length,
	err);
	break;
	}
	case DRR_SPILL:
	{
	struct drr_spill *drrs = &rrd->header.drr_u.drr_spill;
	dprintf("drr_type = SPILL obj = %llu length = %llu "
	"err = %d\n", drrs->drr_object, drrs->drr_length, err);
	break;
	}
	case DRR_OBJECT_RANGE:
	{
	struct drr_object_range *drror =
	&rrd->header.drr_u.drr_object_range;
	dprintf("drr_type = OBJECT_RANGE firstobj = %llu "
	"numslots = %llu flags = %u err = %d\n",
	drror->drr_firstobj, drror->drr_numslots,
	drror->drr_flags, err);
	break;
	}
	default:
	return;
	}
	#endif
	}

	/*
	* Commit the records to the pool.
	*/
	static int
	receive_process_record(struct receive_writer_arg *rwa,
	struct receive_record_arg *rrd)
	{
	int err;

	/* Processing in order, therefore bytes_read should be increasing. */
	ASSERT3U(rrd->bytes_read, >=, rwa->bytes_read);
	rwa->bytes_read = rrd->bytes_read;

	if (rrd->header.drr_type != DRR_WRITE) {
	err = flush_write_batch(rwa);
	if (err != 0) {
	if (rrd->abd != NULL) {
	abd_free(rrd->abd);
	rrd->abd = NULL;
	rrd->payload = NULL;
	} else if (rrd->payload != NULL) {
	kmem_free(rrd->payload, rrd->payload_size);
	rrd->payload = NULL;
	}

	return (err);
	}
	}

	switch (rrd->header.drr_type) {
	case DRR_OBJECT:
	{
	struct drr_object *drro = &rrd->header.drr_u.drr_object;
	err = receive_object(rwa, drro, rrd->payload);
	kmem_free(rrd->payload, rrd->payload_size);
	rrd->payload = NULL;
	break;
	}
	case DRR_FREEOBJECTS:
	{
	struct drr_freeobjects *drrfo =
	&rrd->header.drr_u.drr_freeobjects;
	err = receive_freeobjects(rwa, drrfo);
	break;
	}
	case DRR_WRITE:
	{
	err = receive_process_write_record(rwa, rrd);
	if (err != EAGAIN) {
	/*
	* On success, receive_process_write_record() returns
	* EAGAIN to indicate that we do not want to free
	* the rrd or arc_buf.
	*/
	ASSERT(err != 0);
	abd_free(rrd->abd);
	rrd->abd = NULL;
	}
	break;
	}
	case DRR_WRITE_EMBEDDED:
	{
	struct drr_write_embedded *drrwe =
	&rrd->header.drr_u.drr_write_embedded;
	err = receive_write_embedded(rwa, drrwe, rrd->payload);
	kmem_free(rrd->payload, rrd->payload_size);
	rrd->payload = NULL;
	break;
	}
	case DRR_FREE:
	{
	struct drr_free *drrf = &rrd->header.drr_u.drr_free;
	err = receive_free(rwa, drrf);
	break;
	}
	case DRR_SPILL:
	{
	struct drr_spill *drrs = &rrd->header.drr_u.drr_spill;
	err = receive_spill(rwa, drrs, rrd->abd);
	if (err != 0)
	abd_free(rrd->abd);
	rrd->abd = NULL;
	rrd->payload = NULL;
	break;
	}
	case DRR_OBJECT_RANGE:
	{
	struct drr_object_range *drror =
	&rrd->header.drr_u.drr_object_range;
	err = receive_object_range(rwa, drror);
	break;
	}
	case DRR_REDACT:
	{
	struct drr_redact *drrr = &rrd->header.drr_u.drr_redact;
	err = receive_redact(rwa, drrr);
	break;
	}
	default:
	err = (SET_ERROR(EINVAL));
	}

	if (err != 0)
	dprintf_drr(rrd, err);

	return (err);
	}

	/*
	* dmu_recv_stream's worker thread; pull records off the queue, and then call
	* receive_process_record When we're done, signal the main thread and exit.
	*/
	static void
	receive_writer_thread(void *arg)
	{
	struct receive_writer_arg *rwa = arg;
	struct receive_record_arg *rrd;
	fstrans_cookie_t cookie = spl_fstrans_mark();

	for (rrd = bqueue_dequeue(&rwa->q); !rrd->eos_marker;
	rrd = bqueue_dequeue(&rwa->q)) {
	/*
	* If there's an error, the main thread will stop putting things
	* on the queue, but we need to clear everything in it before we
	* can exit.
	*/
	int err = 0;
	if (rwa->err == 0) {
	err = receive_process_record(rwa, rrd);
	} else if (rrd->abd != NULL) {
	abd_free(rrd->abd);
	rrd->abd = NULL;
	rrd->payload = NULL;
	} else if (rrd->payload != NULL) {
	kmem_free(rrd->payload, rrd->payload_size);
	rrd->payload = NULL;
	}
	/*
	* EAGAIN indicates that this record has been saved (on
	* raw->write_batch), and will be used again, so we don't
	* free it.
	*/
	if (err != EAGAIN) {
	if (rwa->err == 0)
	rwa->err = err;
	kmem_free(rrd, sizeof (*rrd));
	}
	}
	kmem_free(rrd, sizeof (*rrd));

	int err = flush_write_batch(rwa);
	if (rwa->err == 0)
	rwa->err = err;

	mutex_enter(&rwa->mutex);
	rwa->done = B_TRUE;
	cv_signal(&rwa->cv);
	mutex_exit(&rwa->mutex);
	spl_fstrans_unmark(cookie);
	thread_exit();
	}

	static int
	resume_check(dmu_recv_cookie_t drc, nvlist_t begin_nvl)
	{
	uint64_t val;
	objset_t *mos = dmu_objset_pool(drc->drc_os)->dp_meta_objset;
	uint64_t dsobj = dmu_objset_id(drc->drc_os);
	uint64_t resume_obj, resume_off;

	if (nvlist_lookup_uint64(begin_nvl,
	"resume_object", &resume_obj) != 0 \|\|
	nvlist_lookup_uint64(begin_nvl,
	"resume_offset", &resume_off) != 0) {
	return (SET_ERROR(EINVAL));
	}
	VERIFY0(zap_lookup(mos, dsobj,
	DS_FIELD_RESUME_OBJECT, sizeof (val), 1, &val));
	if (resume_obj != val)
	return (SET_ERROR(EINVAL));
	VERIFY0(zap_lookup(mos, dsobj,
	DS_FIELD_RESUME_OFFSET, sizeof (val), 1, &val));
	if (resume_off != val)
	return (SET_ERROR(EINVAL));

	return (0);
	}

	/*
	* Read in the stream's records, one by one, and apply them to the pool. There
	* are two threads involved; the thread that calls this function will spin up a
	* worker thread, read the records off the stream one by one, and issue
	* prefetches for any necessary indirect blocks. It will then push the records
	* onto an internal blocking queue. The worker thread will pull the records off
	* the queue, and actually write the data into the DMU. This way, the worker
	* thread doesn't have to wait for reads to complete, since everything it needs
	* (the indirect blocks) will be prefetched.
	*
	* NB: callers must call dmu_recv_end() if this succeeds.
	*/
	int
	dmu_recv_stream(dmu_recv_cookie_t drc, offset_t voffp)
	{
	int err = 0;
	struct receive_writer_arg rwa = kmem_zalloc(sizeof (rwa), KM_SLEEP);

	- if (dsl_dataset_is_zapified(drc->drc_ds)) {
	- uint64_t bytes;
	+ if (dsl_dataset_has_resume_receive_state(drc->drc_ds)) {
	+ uint64_t bytes = 0;
	(void) zap_lookup(drc->drc_ds->ds_dir->dd_pool->dp_meta_objset,
	drc->drc_ds->ds_object, DS_FIELD_RESUME_BYTES,
	sizeof (bytes), 1, &bytes);
	drc->drc_bytes_read += bytes;
	}

	drc->drc_ignore_objlist = objlist_create();

	/* these were verified in dmu_recv_begin */
	ASSERT3U(DMU_GET_STREAM_HDRTYPE(drc->drc_drrb->drr_versioninfo), ==,
	DMU_SUBSTREAM);
	ASSERT3U(drc->drc_drrb->drr_type, <, DMU_OST_NUMTYPES);

	ASSERT(dsl_dataset_phys(drc->drc_ds)->ds_flags & DS_FLAG_INCONSISTENT);
	ASSERT0(drc->drc_os->os_encrypted &&
	(drc->drc_featureflags & DMU_BACKUP_FEATURE_EMBED_DATA));

	/* handle DSL encryption key payload */
	if (drc->drc_featureflags & DMU_BACKUP_FEATURE_RAW) {
	nvlist_t *keynvl = NULL;

	ASSERT(drc->drc_os->os_encrypted);
	ASSERT(drc->drc_raw);

	err = nvlist_lookup_nvlist(drc->drc_begin_nvl, "crypt_keydata",
	&keynvl);
	if (err != 0)
	goto out;

	/*
	* If this is a new dataset we set the key immediately.
	* Otherwise we don't want to change the key until we
	* are sure the rest of the receive succeeded so we stash
	* the keynvl away until then.
	*/
	err = dsl_crypto_recv_raw(spa_name(drc->drc_os->os_spa),
	drc->drc_ds->ds_object, drc->drc_fromsnapobj,
	drc->drc_drrb->drr_type, keynvl, drc->drc_newfs);
	if (err != 0)
	goto out;

	/* see comment in dmu_recv_end_sync() */
	drc->drc_ivset_guid = 0;
	(void) nvlist_lookup_uint64(keynvl, "to_ivset_guid",
	&drc->drc_ivset_guid);

	if (!drc->drc_newfs)
	drc->drc_keynvl = fnvlist_dup(keynvl);
	}

	if (drc->drc_featureflags & DMU_BACKUP_FEATURE_RESUMING) {
	err = resume_check(drc, drc->drc_begin_nvl);
	if (err != 0)
	goto out;
	}

	/*
	* If we failed before this point we will clean up any new resume
	* state that was created. Now that we've gotten past the initial
	* checks we are ok to retain that resume state.
	*/
	drc->drc_should_save = B_TRUE;

	(void) bqueue_init(&rwa->q, zfs_recv_queue_ff,
	MAX(zfs_recv_queue_length, 2 * zfs_max_recordsize),
	offsetof(struct receive_record_arg, node));
	cv_init(&rwa->cv, NULL, CV_DEFAULT, NULL);
	mutex_init(&rwa->mutex, NULL, MUTEX_DEFAULT, NULL);
	rwa->os = drc->drc_os;
	rwa->byteswap = drc->drc_byteswap;
	rwa->resumable = drc->drc_resumable;
	rwa->raw = drc->drc_raw;
	rwa->spill = drc->drc_spill;
	rwa->full = (drc->drc_drr_begin->drr_u.drr_begin.drr_fromguid == 0);
	rwa->os->os_raw_receive = drc->drc_raw;
	list_create(&rwa->write_batch, sizeof (struct receive_record_arg),
	offsetof(struct receive_record_arg, node.bqn_node));

	(void) thread_create(NULL, 0, receive_writer_thread, rwa, 0, curproc,
	TS_RUN, minclsyspri);
	/*
	* We're reading rwa->err without locks, which is safe since we are the
	* only reader, and the worker thread is the only writer. It's ok if we
	* miss a write for an iteration or two of the loop, since the writer
	* thread will keep freeing records we send it until we send it an eos
	* marker.
	*
	* We can leave this loop in 3 ways: First, if rwa->err is
	* non-zero. In that case, the writer thread will free the rrd we just
	* pushed. Second, if we're interrupted; in that case, either it's the
	* first loop and drc->drc_rrd was never allocated, or it's later, and
	* drc->drc_rrd has been handed off to the writer thread who will free
	* it. Finally, if receive_read_record fails or we're at the end of the
	* stream, then we free drc->drc_rrd and exit.
	*/
	while (rwa->err == 0) {
	if (issig(JUSTLOOKING) && issig(FORREAL)) {
	err = SET_ERROR(EINTR);
	break;
	}

	ASSERT3P(drc->drc_rrd, ==, NULL);
	drc->drc_rrd = drc->drc_next_rrd;
	drc->drc_next_rrd = NULL;
	/* Allocates and loads header into drc->drc_next_rrd */
	err = receive_read_record(drc);

	if (drc->drc_rrd->header.drr_type == DRR_END \|\| err != 0) {
	kmem_free(drc->drc_rrd, sizeof (*drc->drc_rrd));
	drc->drc_rrd = NULL;
	break;
	}

	bqueue_enqueue(&rwa->q, drc->drc_rrd,
	sizeof (struct receive_record_arg) +
	drc->drc_rrd->payload_size);
	drc->drc_rrd = NULL;
	}

	ASSERT3P(drc->drc_rrd, ==, NULL);
	drc->drc_rrd = kmem_zalloc(sizeof (*drc->drc_rrd), KM_SLEEP);
	drc->drc_rrd->eos_marker = B_TRUE;
	bqueue_enqueue_flush(&rwa->q, drc->drc_rrd, 1);

	mutex_enter(&rwa->mutex);
	while (!rwa->done) {
	/*
	* We need to use cv_wait_sig() so that any process that may
	* be sleeping here can still fork.
	*/
	(void) cv_wait_sig(&rwa->cv, &rwa->mutex);
	}
	mutex_exit(&rwa->mutex);

	/*
	* If we are receiving a full stream as a clone, all object IDs which
	* are greater than the maximum ID referenced in the stream are
	* by definition unused and must be freed.
	*/
	if (drc->drc_clone && drc->drc_drrb->drr_fromguid == 0) {
	uint64_t obj = rwa->max_object + 1;
	int free_err = 0;
	int next_err = 0;

	while (next_err == 0) {
	free_err = dmu_free_long_object(rwa->os, obj);
	if (free_err != 0 && free_err != ENOENT)
	break;

	next_err = dmu_object_next(rwa->os, &obj, FALSE, 0);
	}

	if (err == 0) {
	if (free_err != 0 && free_err != ENOENT)
	err = free_err;
	else if (next_err != ESRCH)
	err = next_err;
	}
	}

	cv_destroy(&rwa->cv);
	mutex_destroy(&rwa->mutex);
	bqueue_destroy(&rwa->q);
	list_destroy(&rwa->write_batch);
	if (err == 0)
	err = rwa->err;

	out:
	/*
	* If we hit an error before we started the receive_writer_thread
	* we need to clean up the next_rrd we create by processing the
	* DRR_BEGIN record.
	*/
	if (drc->drc_next_rrd != NULL)
	kmem_free(drc->drc_next_rrd, sizeof (*drc->drc_next_rrd));

	/*
	* The objset will be invalidated by dmu_recv_end() when we do
	* dsl_dataset_clone_swap_sync_impl().
	*/
	drc->drc_os = NULL;

	kmem_free(rwa, sizeof (*rwa));
	nvlist_free(drc->drc_begin_nvl);

	if (err != 0) {
	/*
	* Clean up references. If receive is not resumable,
	* destroy what we created, so we don't leave it in
	* the inconsistent state.
	*/
	dmu_recv_cleanup_ds(drc);
	nvlist_free(drc->drc_keynvl);
	}

	objlist_destroy(drc->drc_ignore_objlist);
	drc->drc_ignore_objlist = NULL;
	*voffp = drc->drc_voff;
	return (err);
	}

	static int
	dmu_recv_end_check(void arg, dmu_tx_t tx)
	{
	dmu_recv_cookie_t *drc = arg;
	dsl_pool_t *dp = dmu_tx_pool(tx);
	int error;

	ASSERT3P(drc->drc_ds->ds_owner, ==, dmu_recv_tag);

	if (!drc->drc_newfs) {
	dsl_dataset_t *origin_head;

	error = dsl_dataset_hold(dp, drc->drc_tofs, FTAG, &origin_head);
	if (error != 0)
	return (error);
	if (drc->drc_force) {
	/*
	* We will destroy any snapshots in tofs (i.e. before
	* origin_head) that are after the origin (which is
	* the snap before drc_ds, because drc_ds can not
	* have any snaps of its own).
	*/
	uint64_t obj;

	obj = dsl_dataset_phys(origin_head)->ds_prev_snap_obj;
	while (obj !=
	dsl_dataset_phys(drc->drc_ds)->ds_prev_snap_obj) {
	dsl_dataset_t *snap;
	error = dsl_dataset_hold_obj(dp, obj, FTAG,
	&snap);
	if (error != 0)
	break;
	if (snap->ds_dir != origin_head->ds_dir)
	error = SET_ERROR(EINVAL);
	if (error == 0) {
	error = dsl_destroy_snapshot_check_impl(
	snap, B_FALSE);
	}
	obj = dsl_dataset_phys(snap)->ds_prev_snap_obj;
	dsl_dataset_rele(snap, FTAG);
	if (error != 0)
	break;
	}
	if (error != 0) {
	dsl_dataset_rele(origin_head, FTAG);
	return (error);
	}
	}
	if (drc->drc_keynvl != NULL) {
	error = dsl_crypto_recv_raw_key_check(drc->drc_ds,
	drc->drc_keynvl, tx);
	if (error != 0) {
	dsl_dataset_rele(origin_head, FTAG);
	return (error);
	}
	}

	error = dsl_dataset_clone_swap_check_impl(drc->drc_ds,
	origin_head, drc->drc_force, drc->drc_owner, tx);
	if (error != 0) {
	dsl_dataset_rele(origin_head, FTAG);
	return (error);
	}
	error = dsl_dataset_snapshot_check_impl(origin_head,
	drc->drc_tosnap, tx, B_TRUE, 1,
	drc->drc_cred, drc->drc_proc);
	dsl_dataset_rele(origin_head, FTAG);
	if (error != 0)
	return (error);

	error = dsl_destroy_head_check_impl(drc->drc_ds, 1);
	} else {
	error = dsl_dataset_snapshot_check_impl(drc->drc_ds,
	drc->drc_tosnap, tx, B_TRUE, 1,
	drc->drc_cred, drc->drc_proc);
	}
	return (error);
	}

	static void
	dmu_recv_end_sync(void arg, dmu_tx_t tx)
	{
	dmu_recv_cookie_t *drc = arg;
	dsl_pool_t *dp = dmu_tx_pool(tx);
	boolean_t encrypted = drc->drc_ds->ds_dir->dd_crypto_obj != 0;
	uint64_t newsnapobj;

	spa_history_log_internal_ds(drc->drc_ds, "finish receiving",
	tx, "snap=%s", drc->drc_tosnap);
	drc->drc_ds->ds_objset->os_raw_receive = B_FALSE;

	if (!drc->drc_newfs) {
	dsl_dataset_t *origin_head;

	VERIFY0(dsl_dataset_hold(dp, drc->drc_tofs, FTAG,
	&origin_head));

	if (drc->drc_force) {
	/*
	* Destroy any snapshots of drc_tofs (origin_head)
	* after the origin (the snap before drc_ds).
	*/
	uint64_t obj;

	obj = dsl_dataset_phys(origin_head)->ds_prev_snap_obj;
	while (obj !=
	dsl_dataset_phys(drc->drc_ds)->ds_prev_snap_obj) {
	dsl_dataset_t *snap;
	VERIFY0(dsl_dataset_hold_obj(dp, obj, FTAG,
	&snap));
	ASSERT3P(snap->ds_dir, ==, origin_head->ds_dir);
	obj = dsl_dataset_phys(snap)->ds_prev_snap_obj;
	dsl_destroy_snapshot_sync_impl(snap,
	B_FALSE, tx);
	dsl_dataset_rele(snap, FTAG);
	}
	}
	if (drc->drc_keynvl != NULL) {
	dsl_crypto_recv_raw_key_sync(drc->drc_ds,
	drc->drc_keynvl, tx);
	nvlist_free(drc->drc_keynvl);
	drc->drc_keynvl = NULL;
	}

	VERIFY3P(drc->drc_ds->ds_prev, ==,
	origin_head->ds_prev);

	dsl_dataset_clone_swap_sync_impl(drc->drc_ds,
	origin_head, tx);
	/*
	* The objset was evicted by dsl_dataset_clone_swap_sync_impl,
	* so drc_os is no longer valid.
	*/
	drc->drc_os = NULL;

	dsl_dataset_snapshot_sync_impl(origin_head,
	drc->drc_tosnap, tx);

	/* set snapshot's creation time and guid */
	dmu_buf_will_dirty(origin_head->ds_prev->ds_dbuf, tx);
	dsl_dataset_phys(origin_head->ds_prev)->ds_creation_time =
	drc->drc_drrb->drr_creation_time;
	dsl_dataset_phys(origin_head->ds_prev)->ds_guid =
	drc->drc_drrb->drr_toguid;
	dsl_dataset_phys(origin_head->ds_prev)->ds_flags &=
	~DS_FLAG_INCONSISTENT;

	dmu_buf_will_dirty(origin_head->ds_dbuf, tx);
	dsl_dataset_phys(origin_head)->ds_flags &=
	~DS_FLAG_INCONSISTENT;

	newsnapobj =
	dsl_dataset_phys(origin_head)->ds_prev_snap_obj;

	dsl_dataset_rele(origin_head, FTAG);
	dsl_destroy_head_sync_impl(drc->drc_ds, tx);

	if (drc->drc_owner != NULL)
	VERIFY3P(origin_head->ds_owner, ==, drc->drc_owner);
	} else {
	dsl_dataset_t *ds = drc->drc_ds;

	dsl_dataset_snapshot_sync_impl(ds, drc->drc_tosnap, tx);

	/* set snapshot's creation time and guid */
	dmu_buf_will_dirty(ds->ds_prev->ds_dbuf, tx);
	dsl_dataset_phys(ds->ds_prev)->ds_creation_time =
	drc->drc_drrb->drr_creation_time;
	dsl_dataset_phys(ds->ds_prev)->ds_guid =
	drc->drc_drrb->drr_toguid;
	dsl_dataset_phys(ds->ds_prev)->ds_flags &=
	~DS_FLAG_INCONSISTENT;

	dmu_buf_will_dirty(ds->ds_dbuf, tx);
	dsl_dataset_phys(ds)->ds_flags &= ~DS_FLAG_INCONSISTENT;
	if (dsl_dataset_has_resume_receive_state(ds)) {
	(void) zap_remove(dp->dp_meta_objset, ds->ds_object,
	DS_FIELD_RESUME_FROMGUID, tx);
	(void) zap_remove(dp->dp_meta_objset, ds->ds_object,
	DS_FIELD_RESUME_OBJECT, tx);
	(void) zap_remove(dp->dp_meta_objset, ds->ds_object,
	DS_FIELD_RESUME_OFFSET, tx);
	(void) zap_remove(dp->dp_meta_objset, ds->ds_object,
	DS_FIELD_RESUME_BYTES, tx);
	(void) zap_remove(dp->dp_meta_objset, ds->ds_object,
	DS_FIELD_RESUME_TOGUID, tx);
	(void) zap_remove(dp->dp_meta_objset, ds->ds_object,
	DS_FIELD_RESUME_TONAME, tx);
	(void) zap_remove(dp->dp_meta_objset, ds->ds_object,
	DS_FIELD_RESUME_REDACT_BOOKMARK_SNAPS, tx);
	}
	newsnapobj =
	dsl_dataset_phys(drc->drc_ds)->ds_prev_snap_obj;
	}

	/*
	* If this is a raw receive, the crypt_keydata nvlist will include
	* a to_ivset_guid for us to set on the new snapshot. This value
	* will override the value generated by the snapshot code. However,
	* this value may not be present, because older implementations of
	* the raw send code did not include this value, and we are still
	* allowed to receive them if the zfs_disable_ivset_guid_check
	* tunable is set, in which case we will leave the newly-generated
	* value.
	*/
	if (drc->drc_raw && drc->drc_ivset_guid != 0) {
	dmu_object_zapify(dp->dp_meta_objset, newsnapobj,
	DMU_OT_DSL_DATASET, tx);
	VERIFY0(zap_update(dp->dp_meta_objset, newsnapobj,
	DS_FIELD_IVSET_GUID, sizeof (uint64_t), 1,
	&drc->drc_ivset_guid, tx));
	}

	/*
	* Release the hold from dmu_recv_begin. This must be done before
	* we return to open context, so that when we free the dataset's dnode
	* we can evict its bonus buffer. Since the dataset may be destroyed
	* at this point (and therefore won't have a valid pointer to the spa)
	* we release the key mapping manually here while we do have a valid
	* pointer, if it exists.
	*/
	if (!drc->drc_raw && encrypted) {
	(void) spa_keystore_remove_mapping(dmu_tx_pool(tx)->dp_spa,
	drc->drc_ds->ds_object, drc->drc_ds);
	}
	dsl_dataset_disown(drc->drc_ds, 0, dmu_recv_tag);
	drc->drc_ds = NULL;
	}

	static int dmu_recv_end_modified_blocks = 3;

	static int
	dmu_recv_existing_end(dmu_recv_cookie_t *drc)
	{
	#ifdef _KERNEL
	/*
	* We will be destroying the ds; make sure its origin is unmounted if
	* necessary.
	*/
	char name[ZFS_MAX_DATASET_NAME_LEN];
	dsl_dataset_name(drc->drc_ds, name);
	zfs_destroy_unmount_origin(name);
	#endif

	return (dsl_sync_task(drc->drc_tofs,
	dmu_recv_end_check, dmu_recv_end_sync, drc,
	dmu_recv_end_modified_blocks, ZFS_SPACE_CHECK_NORMAL));
	}

	static int
	dmu_recv_new_end(dmu_recv_cookie_t *drc)
	{
	return (dsl_sync_task(drc->drc_tofs,
	dmu_recv_end_check, dmu_recv_end_sync, drc,
	dmu_recv_end_modified_blocks, ZFS_SPACE_CHECK_NORMAL));
	}

	int
	dmu_recv_end(dmu_recv_cookie_t drc, void owner)
	{
	int error;

	drc->drc_owner = owner;

	if (drc->drc_newfs)
	error = dmu_recv_new_end(drc);
	else
	error = dmu_recv_existing_end(drc);

	if (error != 0) {
	dmu_recv_cleanup_ds(drc);
	nvlist_free(drc->drc_keynvl);
	} else {
	if (drc->drc_newfs) {
	zvol_create_minor(drc->drc_tofs);
	}
	char *snapname = kmem_asprintf("%s@%s",
	drc->drc_tofs, drc->drc_tosnap);
	zvol_create_minor(snapname);
	kmem_strfree(snapname);
	}
	return (error);
	}

	/*
	* Return TRUE if this objset is currently being received into.
	*/
	boolean_t
	dmu_objset_is_receiving(objset_t *os)
	{
	return (os->os_dsl_dataset != NULL &&
	os->os_dsl_dataset->ds_owner == dmu_recv_tag);
	}

	/* BEGIN CSTYLED */
	ZFS_MODULE_PARAM(zfs_recv, zfs_recv_, queue_length, INT, ZMOD_RW,
	"Maximum receive queue length");

	ZFS_MODULE_PARAM(zfs_recv, zfs_recv_, queue_ff, INT, ZMOD_RW,
	"Receive queue fill fraction");

	ZFS_MODULE_PARAM(zfs_recv, zfs_recv_, write_batch_size, INT, ZMOD_RW,
	"Maximum amount of writes to batch into one transaction");
	/* END CSTYLED */
	diff --git a/sys/contrib/openzfs/module/zfs/dmu_traverse.c b/sys/contrib/openzfs/module/zfs/dmu_traverse.c
	index 31db49dae68c..862c0bf404ad 100644
	--- a/sys/contrib/openzfs/module/zfs/dmu_traverse.c
	+++ b/sys/contrib/openzfs/module/zfs/dmu_traverse.c
	@@ -1,788 +1,827 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2012, 2018 by Delphix. All rights reserved.
	*/

	#include <sys/zfs_context.h>
	#include <sys/dmu_objset.h>
	#include <sys/dmu_traverse.h>
	#include <sys/dsl_dataset.h>
	#include <sys/dsl_dir.h>
	#include <sys/dsl_pool.h>
	#include <sys/dnode.h>
	#include <sys/spa.h>
	#include <sys/spa_impl.h>
	#include <sys/zio.h>
	#include <sys/dmu_impl.h>
	#include <sys/sa.h>
	#include <sys/sa_impl.h>
	#include <sys/callb.h>
	#include <sys/zfeature.h>

	int32_t zfs_pd_bytes_max = 50 * 1024 * 1024; /* 50MB */
	int32_t send_holes_without_birth_time = 1;
	+int32_t zfs_traverse_indirect_prefetch_limit = 32;

	typedef struct prefetch_data {
	kmutex_t pd_mtx;
	kcondvar_t pd_cv;
	int32_t pd_bytes_fetched;
	int pd_flags;
	boolean_t pd_cancel;
	boolean_t pd_exited;
	zbookmark_phys_t pd_resume;
	} prefetch_data_t;

	typedef struct traverse_data {
	spa_t *td_spa;
	uint64_t td_objset;
	blkptr_t *td_rootbp;
	uint64_t td_min_txg;
	zbookmark_phys_t *td_resume;
	int td_flags;
	prefetch_data_t *td_pfd;
	boolean_t td_paused;
	uint64_t td_hole_birth_enabled_txg;
	blkptr_cb_t *td_func;
	void *td_arg;
	boolean_t td_realloc_possible;
	} traverse_data_t;

	static int traverse_dnode(traverse_data_t td, const blkptr_t bp,
	const dnode_phys_t *dnp, uint64_t objset, uint64_t object);
	static void prefetch_dnode_metadata(traverse_data_t td, const dnode_phys_t ,
	uint64_t objset, uint64_t object);

	static int
	traverse_zil_block(zilog_t zilog, const blkptr_t bp, void *arg,
	uint64_t claim_txg)
	{
	traverse_data_t *td = arg;
	zbookmark_phys_t zb;

	if (BP_IS_HOLE(bp))
	return (0);

	if (claim_txg == 0 && bp->blk_birth >= spa_min_claim_txg(td->td_spa))
	return (-1);

	SET_BOOKMARK(&zb, td->td_objset, ZB_ZIL_OBJECT, ZB_ZIL_LEVEL,
	bp->blk_cksum.zc_word[ZIL_ZC_SEQ]);

	(void) td->td_func(td->td_spa, zilog, bp, &zb, NULL, td->td_arg);

	return (0);
	}

	static int
	traverse_zil_record(zilog_t zilog, const lr_t lrc, void *arg,
	uint64_t claim_txg)
	{
	traverse_data_t *td = arg;

	if (lrc->lrc_txtype == TX_WRITE) {
	lr_write_t lr = (lr_write_t )lrc;
	blkptr_t *bp = &lr->lr_blkptr;
	zbookmark_phys_t zb;

	if (BP_IS_HOLE(bp))
	return (0);

	if (claim_txg == 0 \|\| bp->blk_birth < claim_txg)
	return (0);

	SET_BOOKMARK(&zb, td->td_objset, lr->lr_foid,
	ZB_ZIL_LEVEL, lr->lr_offset / BP_GET_LSIZE(bp));

	(void) td->td_func(td->td_spa, zilog, bp, &zb, NULL,
	td->td_arg);
	}
	return (0);
	}

	static void
	traverse_zil(traverse_data_t td, zil_header_t zh)
	{
	uint64_t claim_txg = zh->zh_claim_txg;

	/*
	* We only want to visit blocks that have been claimed but not yet
	* replayed; plus blocks that are already stable in read-only mode.
	*/
	if (claim_txg == 0 && spa_writeable(td->td_spa))
	return;

	zilog_t *zilog = zil_alloc(spa_get_dsl(td->td_spa)->dp_meta_objset, zh);
	(void) zil_parse(zilog, traverse_zil_block, traverse_zil_record, td,
	claim_txg, !(td->td_flags & TRAVERSE_NO_DECRYPT));
	zil_free(zilog);
	}

	typedef enum resume_skip {
	RESUME_SKIP_ALL,
	RESUME_SKIP_NONE,
	RESUME_SKIP_CHILDREN
	} resume_skip_t;

	/*
	* Returns RESUME_SKIP_ALL if td indicates that we are resuming a traversal and
	* the block indicated by zb does not need to be visited at all. Returns
	* RESUME_SKIP_CHILDREN if we are resuming a post traversal and we reach the
	* resume point. This indicates that this block should be visited but not its
	* children (since they must have been visited in a previous traversal).
	* Otherwise returns RESUME_SKIP_NONE.
	*/
	static resume_skip_t
	resume_skip_check(traverse_data_t td, const dnode_phys_t dnp,
	const zbookmark_phys_t *zb)
	{
	if (td->td_resume != NULL && !ZB_IS_ZERO(td->td_resume)) {
	/*
	* If we already visited this bp & everything below,
	* don't bother doing it again.
	*/
	if (zbookmark_subtree_completed(dnp, zb, td->td_resume))
	return (RESUME_SKIP_ALL);

	/*
	* If we found the block we're trying to resume from, zero
	* the bookmark out to indicate that we have resumed.
	*/
	if (bcmp(zb, td->td_resume, sizeof (*zb)) == 0) {
	bzero(td->td_resume, sizeof (*zb));
	if (td->td_flags & TRAVERSE_POST)
	return (RESUME_SKIP_CHILDREN);
	}
	}
	return (RESUME_SKIP_NONE);
	}

	-static void
	+/*
	+ * Returns B_TRUE, if prefetch read is issued, otherwise B_FALSE.
	+ */
	+static boolean_t
	traverse_prefetch_metadata(traverse_data_t *td,
	const blkptr_t bp, const zbookmark_phys_t zb)
	{
	arc_flags_t flags = ARC_FLAG_NOWAIT \| ARC_FLAG_PREFETCH;
	int zio_flags = ZIO_FLAG_CANFAIL \| ZIO_FLAG_SPECULATIVE;

	if (!(td->td_flags & TRAVERSE_PREFETCH_METADATA))
	- return;
	+ return (B_FALSE);
	/*
	* If we are in the process of resuming, don't prefetch, because
	* some children will not be needed (and in fact may have already
	* been freed).
	*/
	if (td->td_resume != NULL && !ZB_IS_ZERO(td->td_resume))
	- return;
	+ return (B_FALSE);
	if (BP_IS_HOLE(bp) \|\| bp->blk_birth <= td->td_min_txg)
	- return;
	+ return (B_FALSE);
	if (BP_GET_LEVEL(bp) == 0 && BP_GET_TYPE(bp) != DMU_OT_DNODE)
	- return;
	+ return (B_FALSE);
	ASSERT(!BP_IS_REDACTED(bp));

	if ((td->td_flags & TRAVERSE_NO_DECRYPT) && BP_IS_PROTECTED(bp))
	zio_flags \|= ZIO_FLAG_RAW;

	(void) arc_read(NULL, td->td_spa, bp, NULL, NULL,
	ZIO_PRIORITY_ASYNC_READ, zio_flags, &flags, zb);
	+ return (B_TRUE);
	}

	static boolean_t
	prefetch_needed(prefetch_data_t pfd, const blkptr_t bp)
	{
	ASSERT(pfd->pd_flags & TRAVERSE_PREFETCH_DATA);
	if (BP_IS_HOLE(bp) \|\| BP_IS_EMBEDDED(bp) \|\|
	BP_GET_TYPE(bp) == DMU_OT_INTENT_LOG \|\| BP_IS_REDACTED(bp))
	return (B_FALSE);
	return (B_TRUE);
	}

	static int
	traverse_visitbp(traverse_data_t td, const dnode_phys_t dnp,
	const blkptr_t bp, const zbookmark_phys_t zb)
	{
	int err = 0;
	arc_buf_t *buf = NULL;
	prefetch_data_t *pd = td->td_pfd;

	switch (resume_skip_check(td, dnp, zb)) {
	case RESUME_SKIP_ALL:
	return (0);
	case RESUME_SKIP_CHILDREN:
	goto post;
	case RESUME_SKIP_NONE:
	break;
	default:
	ASSERT(0);
	}

	if (bp->blk_birth == 0) {
	/*
	* Since this block has a birth time of 0 it must be one of
	* two things: a hole created before the
	* SPA_FEATURE_HOLE_BIRTH feature was enabled, or a hole
	* which has always been a hole in an object.
	*
	* If a file is written sparsely, then the unwritten parts of
	* the file were "always holes" -- that is, they have been
	* holes since this object was allocated. However, we (and
	* our callers) can not necessarily tell when an object was
	* allocated. Therefore, if it's possible that this object
	* was freed and then its object number reused, we need to
	* visit all the holes with birth==0.
	*
	* If it isn't possible that the object number was reused,
	* then if SPA_FEATURE_HOLE_BIRTH was enabled before we wrote
	* all the blocks we will visit as part of this traversal,
	* then this hole must have always existed, so we can skip
	* it. We visit blocks born after (exclusive) td_min_txg.
	*
	* Note that the meta-dnode cannot be reallocated.
	*/
	if (!send_holes_without_birth_time &&
	(!td->td_realloc_possible \|\|
	zb->zb_object == DMU_META_DNODE_OBJECT) &&
	td->td_hole_birth_enabled_txg <= td->td_min_txg)
	return (0);
	} else if (bp->blk_birth <= td->td_min_txg) {
	return (0);
	}

	if (pd != NULL && !pd->pd_exited && prefetch_needed(pd, bp)) {
	uint64_t size = BP_GET_LSIZE(bp);
	mutex_enter(&pd->pd_mtx);
	ASSERT(pd->pd_bytes_fetched >= 0);
	while (pd->pd_bytes_fetched < size && !pd->pd_exited)
	cv_wait_sig(&pd->pd_cv, &pd->pd_mtx);
	pd->pd_bytes_fetched -= size;
	cv_broadcast(&pd->pd_cv);
	mutex_exit(&pd->pd_mtx);
	}

	if (BP_IS_HOLE(bp) \|\| BP_IS_REDACTED(bp)) {
	err = td->td_func(td->td_spa, NULL, bp, zb, dnp, td->td_arg);
	if (err != 0)
	goto post;
	return (0);
	}

	if (td->td_flags & TRAVERSE_PRE) {
	err = td->td_func(td->td_spa, NULL, bp, zb, dnp,
	td->td_arg);
	if (err == TRAVERSE_VISIT_NO_CHILDREN)
	return (0);
	if (err != 0)
	goto post;
	}

	if (BP_GET_LEVEL(bp) > 0) {
	uint32_t flags = ARC_FLAG_WAIT;
	- int32_t i;
	+ int32_t i, ptidx, pidx;
	+ uint32_t prefetchlimit;
	int32_t epb = BP_GET_LSIZE(bp) >> SPA_BLKPTRSHIFT;
	zbookmark_phys_t *czb;

	ASSERT(!BP_IS_PROTECTED(bp));

	err = arc_read(NULL, td->td_spa, bp, arc_getbuf_func, &buf,
	ZIO_PRIORITY_ASYNC_READ, ZIO_FLAG_CANFAIL, &flags, zb);
	if (err != 0)
	goto post;

	czb = kmem_alloc(sizeof (zbookmark_phys_t), KM_SLEEP);

	+ /*
	+ * When performing a traversal it is beneficial to
	+ * asynchronously read-ahead the upcoming indirect
	+ * blocks since they will be needed shortly. However,
	+ * since a 128k indirect (non-L0) block may contain up
	+ * to 1024 128-byte block pointers, its preferable to not
	+ * prefetch them all at once. Issuing a large number of
	+ * async reads may effect performance, and the earlier
	+ * the indirect blocks are prefetched the less likely
	+ * they are to still be resident in the ARC when needed.
	+ * Therefore, prefetching indirect blocks is limited to
	+ * zfs_traverse_indirect_prefetch_limit=32 blocks by
	+ * default.
	+ *
	+ * pidx: Index for which next prefetch to be issued.
	+ * ptidx: Index at which next prefetch to be triggered.
	+ */
	+ ptidx = 0;
	+ pidx = 1;
	+ prefetchlimit = zfs_traverse_indirect_prefetch_limit;
	for (i = 0; i < epb; i++) {
	- SET_BOOKMARK(czb, zb->zb_objset, zb->zb_object,
	- zb->zb_level - 1,
	- zb->zb_blkid * epb + i);
	- traverse_prefetch_metadata(td,
	- &((blkptr_t *)buf->b_data)[i], czb);
	- }
	+ if (prefetchlimit && i == ptidx) {
	+ ASSERT3S(ptidx, <=, pidx);
	+ for (uint32_t prefetched = 0; pidx < epb &&
	+ prefetched < prefetchlimit; pidx++) {
	+ SET_BOOKMARK(czb, zb->zb_objset,
	+ zb->zb_object, zb->zb_level - 1,
	+ zb->zb_blkid * epb + pidx);
	+ if (traverse_prefetch_metadata(td,
	+ &((blkptr_t *)buf->b_data)[pidx],
	+ czb) == B_TRUE) {
	+ prefetched++;
	+ if (prefetched ==
	+ MAX(prefetchlimit / 2, 1))
	+ ptidx = pidx;
	+ }
	+ }
	+ }

	- /* recursively visitbp() blocks below this */
	- for (i = 0; i < epb; i++) {
	+ /* recursively visitbp() blocks below this */
	SET_BOOKMARK(czb, zb->zb_objset, zb->zb_object,
	zb->zb_level - 1,
	zb->zb_blkid * epb + i);
	err = traverse_visitbp(td, dnp,
	&((blkptr_t *)buf->b_data)[i], czb);
	if (err != 0)
	break;
	}

	kmem_free(czb, sizeof (zbookmark_phys_t));

	} else if (BP_GET_TYPE(bp) == DMU_OT_DNODE) {
	uint32_t flags = ARC_FLAG_WAIT;
	uint32_t zio_flags = ZIO_FLAG_CANFAIL;
	int32_t i;
	int32_t epb = BP_GET_LSIZE(bp) >> DNODE_SHIFT;
	dnode_phys_t *child_dnp;

	/*
	* dnode blocks might have their bonus buffers encrypted, so
	* we must be careful to honor TRAVERSE_NO_DECRYPT
	*/
	if ((td->td_flags & TRAVERSE_NO_DECRYPT) && BP_IS_PROTECTED(bp))
	zio_flags \|= ZIO_FLAG_RAW;

	err = arc_read(NULL, td->td_spa, bp, arc_getbuf_func, &buf,
	ZIO_PRIORITY_ASYNC_READ, zio_flags, &flags, zb);
	if (err != 0)
	goto post;

	child_dnp = buf->b_data;

	for (i = 0; i < epb; i += child_dnp[i].dn_extra_slots + 1) {
	prefetch_dnode_metadata(td, &child_dnp[i],
	zb->zb_objset, zb->zb_blkid * epb + i);
	}

	/* recursively visitbp() blocks below this */
	for (i = 0; i < epb; i += child_dnp[i].dn_extra_slots + 1) {
	err = traverse_dnode(td, bp, &child_dnp[i],
	zb->zb_objset, zb->zb_blkid * epb + i);
	if (err != 0)
	break;
	}
	} else if (BP_GET_TYPE(bp) == DMU_OT_OBJSET) {
	uint32_t zio_flags = ZIO_FLAG_CANFAIL;
	arc_flags_t flags = ARC_FLAG_WAIT;
	objset_phys_t *osp;

	if ((td->td_flags & TRAVERSE_NO_DECRYPT) && BP_IS_PROTECTED(bp))
	zio_flags \|= ZIO_FLAG_RAW;

	err = arc_read(NULL, td->td_spa, bp, arc_getbuf_func, &buf,
	ZIO_PRIORITY_ASYNC_READ, zio_flags, &flags, zb);
	if (err != 0)
	goto post;

	osp = buf->b_data;
	prefetch_dnode_metadata(td, &osp->os_meta_dnode, zb->zb_objset,
	DMU_META_DNODE_OBJECT);
	/*
	* See the block comment above for the goal of this variable.
	* If the maxblkid of the meta-dnode is 0, then we know that
	* we've never had more than DNODES_PER_BLOCK objects in the
	* dataset, which means we can't have reused any object ids.
	*/
	if (osp->os_meta_dnode.dn_maxblkid == 0)
	td->td_realloc_possible = B_FALSE;

	if (OBJSET_BUF_HAS_USERUSED(buf)) {
	if (OBJSET_BUF_HAS_PROJECTUSED(buf))
	prefetch_dnode_metadata(td,
	&osp->os_projectused_dnode,
	zb->zb_objset, DMU_PROJECTUSED_OBJECT);
	prefetch_dnode_metadata(td, &osp->os_groupused_dnode,
	zb->zb_objset, DMU_GROUPUSED_OBJECT);
	prefetch_dnode_metadata(td, &osp->os_userused_dnode,
	zb->zb_objset, DMU_USERUSED_OBJECT);
	}

	err = traverse_dnode(td, bp, &osp->os_meta_dnode, zb->zb_objset,
	DMU_META_DNODE_OBJECT);
	if (err == 0 && OBJSET_BUF_HAS_USERUSED(buf)) {
	if (OBJSET_BUF_HAS_PROJECTUSED(buf))
	err = traverse_dnode(td, bp,
	&osp->os_projectused_dnode, zb->zb_objset,
	DMU_PROJECTUSED_OBJECT);
	if (err == 0)
	err = traverse_dnode(td, bp,
	&osp->os_groupused_dnode, zb->zb_objset,
	DMU_GROUPUSED_OBJECT);
	if (err == 0)
	err = traverse_dnode(td, bp,
	&osp->os_userused_dnode, zb->zb_objset,
	DMU_USERUSED_OBJECT);
	}
	}

	if (buf)
	arc_buf_destroy(buf, &buf);

	post:
	if (err == 0 && (td->td_flags & TRAVERSE_POST))
	err = td->td_func(td->td_spa, NULL, bp, zb, dnp, td->td_arg);

	if ((td->td_flags & TRAVERSE_HARD) && (err == EIO \|\| err == ECKSUM)) {
	/*
	* Ignore this disk error as requested by the HARD flag,
	* and continue traversal.
	*/
	err = 0;
	}

	/*
	* If we are stopping here, set td_resume.
	*/
	if (td->td_resume != NULL && err != 0 && !td->td_paused) {
	td->td_resume->zb_objset = zb->zb_objset;
	td->td_resume->zb_object = zb->zb_object;
	td->td_resume->zb_level = 0;
	/*
	* If we have stopped on an indirect block (e.g. due to
	* i/o error), we have not visited anything below it.
	* Set the bookmark to the first level-0 block that we need
	* to visit. This way, the resuming code does not need to
	* deal with resuming from indirect blocks.
	*
	* Note, if zb_level <= 0, dnp may be NULL, so we don't want
	* to dereference it.
	*/
	td->td_resume->zb_blkid = zb->zb_blkid;
	if (zb->zb_level > 0) {
	td->td_resume->zb_blkid <<= zb->zb_level *
	(dnp->dn_indblkshift - SPA_BLKPTRSHIFT);
	}
	td->td_paused = B_TRUE;
	}

	return (err);
	}

	static void
	prefetch_dnode_metadata(traverse_data_t td, const dnode_phys_t dnp,
	uint64_t objset, uint64_t object)
	{
	int j;
	zbookmark_phys_t czb;

	for (j = 0; j < dnp->dn_nblkptr; j++) {
	SET_BOOKMARK(&czb, objset, object, dnp->dn_nlevels - 1, j);
	traverse_prefetch_metadata(td, &dnp->dn_blkptr[j], &czb);
	}

	if (dnp->dn_flags & DNODE_FLAG_SPILL_BLKPTR) {
	SET_BOOKMARK(&czb, objset, object, 0, DMU_SPILL_BLKID);
	traverse_prefetch_metadata(td, DN_SPILL_BLKPTR(dnp), &czb);
	}
	}

	static int
	traverse_dnode(traverse_data_t td, const blkptr_t bp, const dnode_phys_t *dnp,
	uint64_t objset, uint64_t object)
	{
	int j, err = 0;
	zbookmark_phys_t czb;

	if (object != DMU_META_DNODE_OBJECT && td->td_resume != NULL &&
	object < td->td_resume->zb_object)
	return (0);

	if (td->td_flags & TRAVERSE_PRE) {
	SET_BOOKMARK(&czb, objset, object, ZB_DNODE_LEVEL,
	ZB_DNODE_BLKID);
	err = td->td_func(td->td_spa, NULL, bp, &czb, dnp,
	td->td_arg);
	if (err == TRAVERSE_VISIT_NO_CHILDREN)
	return (0);
	if (err != 0)
	return (err);
	}

	for (j = 0; j < dnp->dn_nblkptr; j++) {
	SET_BOOKMARK(&czb, objset, object, dnp->dn_nlevels - 1, j);
	err = traverse_visitbp(td, dnp, &dnp->dn_blkptr[j], &czb);
	if (err != 0)
	break;
	}

	if (err == 0 && (dnp->dn_flags & DNODE_FLAG_SPILL_BLKPTR)) {
	SET_BOOKMARK(&czb, objset, object, 0, DMU_SPILL_BLKID);
	err = traverse_visitbp(td, dnp, DN_SPILL_BLKPTR(dnp), &czb);
	}

	if (err == 0 && (td->td_flags & TRAVERSE_POST)) {
	SET_BOOKMARK(&czb, objset, object, ZB_DNODE_LEVEL,
	ZB_DNODE_BLKID);
	err = td->td_func(td->td_spa, NULL, bp, &czb, dnp,
	td->td_arg);
	if (err == TRAVERSE_VISIT_NO_CHILDREN)
	return (0);
	if (err != 0)
	return (err);
	}
	return (err);
	}

	/* ARGSUSED */
	static int
	traverse_prefetcher(spa_t spa, zilog_t zilog, const blkptr_t *bp,
	const zbookmark_phys_t zb, const dnode_phys_t dnp, void *arg)
	{
	prefetch_data_t *pfd = arg;
	int zio_flags = ZIO_FLAG_CANFAIL \| ZIO_FLAG_SPECULATIVE;
	arc_flags_t aflags = ARC_FLAG_NOWAIT \| ARC_FLAG_PREFETCH \|
	ARC_FLAG_PRESCIENT_PREFETCH;

	ASSERT(pfd->pd_bytes_fetched >= 0);
	if (zb->zb_level == ZB_DNODE_LEVEL)
	return (0);
	if (pfd->pd_cancel)
	return (SET_ERROR(EINTR));

	if (!prefetch_needed(pfd, bp))
	return (0);

	mutex_enter(&pfd->pd_mtx);
	while (!pfd->pd_cancel && pfd->pd_bytes_fetched >= zfs_pd_bytes_max)
	cv_wait_sig(&pfd->pd_cv, &pfd->pd_mtx);
	pfd->pd_bytes_fetched += BP_GET_LSIZE(bp);
	cv_broadcast(&pfd->pd_cv);
	mutex_exit(&pfd->pd_mtx);

	if ((pfd->pd_flags & TRAVERSE_NO_DECRYPT) && BP_IS_PROTECTED(bp))
	zio_flags \|= ZIO_FLAG_RAW;

	(void) arc_read(NULL, spa, bp, NULL, NULL, ZIO_PRIORITY_ASYNC_READ,
	zio_flags, &aflags, zb);

	return (0);
	}

	static void
	traverse_prefetch_thread(void *arg)
	{
	traverse_data_t *td_main = arg;
	traverse_data_t td = *td_main;
	zbookmark_phys_t czb;
	fstrans_cookie_t cookie = spl_fstrans_mark();

	td.td_func = traverse_prefetcher;
	td.td_arg = td_main->td_pfd;
	td.td_pfd = NULL;
	td.td_resume = &td_main->td_pfd->pd_resume;

	SET_BOOKMARK(&czb, td.td_objset,
	ZB_ROOT_OBJECT, ZB_ROOT_LEVEL, ZB_ROOT_BLKID);
	(void) traverse_visitbp(&td, NULL, td.td_rootbp, &czb);

	mutex_enter(&td_main->td_pfd->pd_mtx);
	td_main->td_pfd->pd_exited = B_TRUE;
	cv_broadcast(&td_main->td_pfd->pd_cv);
	mutex_exit(&td_main->td_pfd->pd_mtx);
	spl_fstrans_unmark(cookie);
	}

	/*
	* NB: dataset must not be changing on-disk (eg, is a snapshot or we are
	* in syncing context).
	*/
	static int
	traverse_impl(spa_t spa, dsl_dataset_t ds, uint64_t objset, blkptr_t *rootbp,
	uint64_t txg_start, zbookmark_phys_t *resume, int flags,
	blkptr_cb_t func, void *arg)
	{
	traverse_data_t *td;
	prefetch_data_t *pd;
	zbookmark_phys_t *czb;
	int err;

	ASSERT(ds == NULL \|\| objset == ds->ds_object);
	ASSERT(!(flags & TRAVERSE_PRE) \|\| !(flags & TRAVERSE_POST));

	td = kmem_alloc(sizeof (traverse_data_t), KM_SLEEP);
	pd = kmem_zalloc(sizeof (prefetch_data_t), KM_SLEEP);
	czb = kmem_alloc(sizeof (zbookmark_phys_t), KM_SLEEP);

	td->td_spa = spa;
	td->td_objset = objset;
	td->td_rootbp = rootbp;
	td->td_min_txg = txg_start;
	td->td_resume = resume;
	td->td_func = func;
	td->td_arg = arg;
	td->td_pfd = pd;
	td->td_flags = flags;
	td->td_paused = B_FALSE;
	td->td_realloc_possible = (txg_start == 0 ? B_FALSE : B_TRUE);

	if (spa_feature_is_active(spa, SPA_FEATURE_HOLE_BIRTH)) {
	VERIFY(spa_feature_enabled_txg(spa,
	SPA_FEATURE_HOLE_BIRTH, &td->td_hole_birth_enabled_txg));
	} else {
	td->td_hole_birth_enabled_txg = UINT64_MAX;
	}

	pd->pd_flags = flags;
	if (resume != NULL)
	pd->pd_resume = *resume;
	mutex_init(&pd->pd_mtx, NULL, MUTEX_DEFAULT, NULL);
	cv_init(&pd->pd_cv, NULL, CV_DEFAULT, NULL);

	SET_BOOKMARK(czb, td->td_objset,
	ZB_ROOT_OBJECT, ZB_ROOT_LEVEL, ZB_ROOT_BLKID);

	/* See comment on ZIL traversal in dsl_scan_visitds. */
	if (ds != NULL && !ds->ds_is_snapshot && !BP_IS_HOLE(rootbp)) {
	enum zio_flag zio_flags = ZIO_FLAG_CANFAIL;
	uint32_t flags = ARC_FLAG_WAIT;
	objset_phys_t *osp;
	arc_buf_t *buf;
	ASSERT(!BP_IS_REDACTED(rootbp));

	if ((td->td_flags & TRAVERSE_NO_DECRYPT) &&
	BP_IS_PROTECTED(rootbp))
	zio_flags \|= ZIO_FLAG_RAW;

	err = arc_read(NULL, td->td_spa, rootbp, arc_getbuf_func,
	&buf, ZIO_PRIORITY_ASYNC_READ, zio_flags, &flags, czb);
	if (err != 0) {
	/*
	* If both TRAVERSE_HARD and TRAVERSE_PRE are set,
	* continue to visitbp so that td_func can be called
	* in pre stage, and err will reset to zero.
	*/
	if (!(td->td_flags & TRAVERSE_HARD) \|\|
	!(td->td_flags & TRAVERSE_PRE))
	goto out;
	} else {
	osp = buf->b_data;
	traverse_zil(td, &osp->os_zil_header);
	arc_buf_destroy(buf, &buf);
	}
	}

	if (!(flags & TRAVERSE_PREFETCH_DATA) \|\|
	taskq_dispatch(spa->spa_prefetch_taskq, traverse_prefetch_thread,
	td, TQ_NOQUEUE) == TASKQID_INVALID)
	pd->pd_exited = B_TRUE;

	err = traverse_visitbp(td, NULL, rootbp, czb);

	mutex_enter(&pd->pd_mtx);
	pd->pd_cancel = B_TRUE;
	cv_broadcast(&pd->pd_cv);
	while (!pd->pd_exited)
	cv_wait_sig(&pd->pd_cv, &pd->pd_mtx);
	mutex_exit(&pd->pd_mtx);
	out:
	mutex_destroy(&pd->pd_mtx);
	cv_destroy(&pd->pd_cv);

	kmem_free(czb, sizeof (zbookmark_phys_t));
	kmem_free(pd, sizeof (struct prefetch_data));
	kmem_free(td, sizeof (struct traverse_data));

	return (err);
	}

	/*
	* NB: dataset must not be changing on-disk (eg, is a snapshot or we are
	* in syncing context).
	*/
	int
	traverse_dataset_resume(dsl_dataset_t *ds, uint64_t txg_start,
	zbookmark_phys_t *resume,
	int flags, blkptr_cb_t func, void *arg)
	{
	return (traverse_impl(ds->ds_dir->dd_pool->dp_spa, ds, ds->ds_object,
	&dsl_dataset_phys(ds)->ds_bp, txg_start, resume, flags, func, arg));
	}

	int
	traverse_dataset(dsl_dataset_t *ds, uint64_t txg_start,
	int flags, blkptr_cb_t func, void *arg)
	{
	return (traverse_dataset_resume(ds, txg_start, NULL, flags, func, arg));
	}

	int
	traverse_dataset_destroyed(spa_t spa, blkptr_t blkptr,
	uint64_t txg_start, zbookmark_phys_t *resume, int flags,
	blkptr_cb_t func, void *arg)
	{
	return (traverse_impl(spa, NULL, ZB_DESTROYED_OBJSET,
	blkptr, txg_start, resume, flags, func, arg));
	}

	/*
	* NB: pool must not be changing on-disk (eg, from zdb or sync context).
	*/
	int
	traverse_pool(spa_t *spa, uint64_t txg_start, int flags,
	blkptr_cb_t func, void *arg)
	{
	int err;
	dsl_pool_t *dp = spa_get_dsl(spa);
	objset_t *mos = dp->dp_meta_objset;
	boolean_t hard = (flags & TRAVERSE_HARD);

	/* visit the MOS */
	err = traverse_impl(spa, NULL, 0, spa_get_rootblkptr(spa),
	txg_start, NULL, flags, func, arg);
	if (err != 0)
	return (err);

	/* visit each dataset */
	for (uint64_t obj = 1; err == 0;
	err = dmu_object_next(mos, &obj, B_FALSE, txg_start)) {
	dmu_object_info_t doi;

	err = dmu_object_info(mos, obj, &doi);
	if (err != 0) {
	if (hard)
	continue;
	break;
	}

	if (doi.doi_bonus_type == DMU_OT_DSL_DATASET) {
	dsl_dataset_t *ds;
	uint64_t txg = txg_start;

	dsl_pool_config_enter(dp, FTAG);
	err = dsl_dataset_hold_obj(dp, obj, FTAG, &ds);
	dsl_pool_config_exit(dp, FTAG);
	if (err != 0) {
	if (hard)
	continue;
	break;
	}
	if (dsl_dataset_phys(ds)->ds_prev_snap_txg > txg)
	txg = dsl_dataset_phys(ds)->ds_prev_snap_txg;
	err = traverse_dataset(ds, txg, flags, func, arg);
	dsl_dataset_rele(ds, FTAG);
	if (err != 0)
	break;
	}
	}
	if (err == ESRCH)
	err = 0;
	return (err);
	}

	EXPORT_SYMBOL(traverse_dataset);
	EXPORT_SYMBOL(traverse_pool);

	/* BEGIN CSTYLED */
	ZFS_MODULE_PARAM(zfs, zfs_, pd_bytes_max, INT, ZMOD_RW,
	"Max number of bytes to prefetch");

	+ZFS_MODULE_PARAM(zfs, zfs_, traverse_indirect_prefetch_limit, INT, ZMOD_RW,
	+ "Traverse prefetch number of blocks pointed by indirect block");
	+
	#if defined(_KERNEL)
	module_param_named(ignore_hole_birth, send_holes_without_birth_time, int, 0644);
	MODULE_PARM_DESC(ignore_hole_birth,
	"Alias for send_holes_without_birth_time");
	#endif

	ZFS_MODULE_PARAM(zfs, , send_holes_without_birth_time, INT, ZMOD_RW,
	"Ignore hole_birth txg for zfs send");
	/* END CSTYLED */
	diff --git a/sys/contrib/openzfs/module/zfs/dnode.c b/sys/contrib/openzfs/module/zfs/dnode.c
	index eaba9c0c0e7f..0fc788e28fe4 100644
	--- a/sys/contrib/openzfs/module/zfs/dnode.c
	+++ b/sys/contrib/openzfs/module/zfs/dnode.c
	@@ -1,2583 +1,2577 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2012, 2020 by Delphix. All rights reserved.
	* Copyright (c) 2014 Spectra Logic Corporation, All rights reserved.
	*/

	#include <sys/zfs_context.h>
	#include <sys/dbuf.h>
	#include <sys/dnode.h>
	#include <sys/dmu.h>
	#include <sys/dmu_impl.h>
	#include <sys/dmu_tx.h>
	#include <sys/dmu_objset.h>
	#include <sys/dsl_dir.h>
	#include <sys/dsl_dataset.h>
	#include <sys/spa.h>
	#include <sys/zio.h>
	#include <sys/dmu_zfetch.h>
	#include <sys/range_tree.h>
	#include <sys/trace_zfs.h>
	#include <sys/zfs_project.h>

	dnode_stats_t dnode_stats = {
	{ "dnode_hold_dbuf_hold", KSTAT_DATA_UINT64 },
	{ "dnode_hold_dbuf_read", KSTAT_DATA_UINT64 },
	{ "dnode_hold_alloc_hits", KSTAT_DATA_UINT64 },
	{ "dnode_hold_alloc_misses", KSTAT_DATA_UINT64 },
	{ "dnode_hold_alloc_interior", KSTAT_DATA_UINT64 },
	{ "dnode_hold_alloc_lock_retry", KSTAT_DATA_UINT64 },
	{ "dnode_hold_alloc_lock_misses", KSTAT_DATA_UINT64 },
	{ "dnode_hold_alloc_type_none", KSTAT_DATA_UINT64 },
	{ "dnode_hold_free_hits", KSTAT_DATA_UINT64 },
	{ "dnode_hold_free_misses", KSTAT_DATA_UINT64 },
	{ "dnode_hold_free_lock_misses", KSTAT_DATA_UINT64 },
	{ "dnode_hold_free_lock_retry", KSTAT_DATA_UINT64 },
	{ "dnode_hold_free_overflow", KSTAT_DATA_UINT64 },
	{ "dnode_hold_free_refcount", KSTAT_DATA_UINT64 },
	{ "dnode_free_interior_lock_retry", KSTAT_DATA_UINT64 },
	{ "dnode_allocate", KSTAT_DATA_UINT64 },
	{ "dnode_reallocate", KSTAT_DATA_UINT64 },
	{ "dnode_buf_evict", KSTAT_DATA_UINT64 },
	{ "dnode_alloc_next_chunk", KSTAT_DATA_UINT64 },
	{ "dnode_alloc_race", KSTAT_DATA_UINT64 },
	{ "dnode_alloc_next_block", KSTAT_DATA_UINT64 },
	{ "dnode_move_invalid", KSTAT_DATA_UINT64 },
	{ "dnode_move_recheck1", KSTAT_DATA_UINT64 },
	{ "dnode_move_recheck2", KSTAT_DATA_UINT64 },
	{ "dnode_move_special", KSTAT_DATA_UINT64 },
	{ "dnode_move_handle", KSTAT_DATA_UINT64 },
	{ "dnode_move_rwlock", KSTAT_DATA_UINT64 },
	{ "dnode_move_active", KSTAT_DATA_UINT64 },
	};

	static kstat_t *dnode_ksp;
	static kmem_cache_t *dnode_cache;

	static dnode_phys_t dnode_phys_zero __maybe_unused;

	int zfs_default_bs = SPA_MINBLOCKSHIFT;
	int zfs_default_ibs = DN_MAX_INDBLKSHIFT;

	#ifdef _KERNEL
	static kmem_cbrc_t dnode_move(void , void , size_t, void *);
	#endif /* _KERNEL */

	static int
	dbuf_compare(const void x1, const void x2)
	{
	const dmu_buf_impl_t *d1 = x1;
	const dmu_buf_impl_t *d2 = x2;

	int cmp = TREE_CMP(d1->db_level, d2->db_level);
	if (likely(cmp))
	return (cmp);

	cmp = TREE_CMP(d1->db_blkid, d2->db_blkid);
	if (likely(cmp))
	return (cmp);

	if (d1->db_state == DB_SEARCH) {
	ASSERT3S(d2->db_state, !=, DB_SEARCH);
	return (-1);
	} else if (d2->db_state == DB_SEARCH) {
	ASSERT3S(d1->db_state, !=, DB_SEARCH);
	return (1);
	}

	return (TREE_PCMP(d1, d2));
	}

	/* ARGSUSED */
	static int
	dnode_cons(void arg, void unused, int kmflag)
	{
	dnode_t *dn = arg;
	int i;

	rw_init(&dn->dn_struct_rwlock, NULL, RW_NOLOCKDEP, NULL);
	mutex_init(&dn->dn_mtx, NULL, MUTEX_DEFAULT, NULL);
	mutex_init(&dn->dn_dbufs_mtx, NULL, MUTEX_DEFAULT, NULL);
	cv_init(&dn->dn_notxholds, NULL, CV_DEFAULT, NULL);
	cv_init(&dn->dn_nodnholds, NULL, CV_DEFAULT, NULL);

	/*
	* Every dbuf has a reference, and dropping a tracked reference is
	* O(number of references), so don't track dn_holds.
	*/
	zfs_refcount_create_untracked(&dn->dn_holds);
	zfs_refcount_create(&dn->dn_tx_holds);
	list_link_init(&dn->dn_link);

	bzero(&dn->dn_next_nblkptr[0], sizeof (dn->dn_next_nblkptr));
	bzero(&dn->dn_next_nlevels[0], sizeof (dn->dn_next_nlevels));
	bzero(&dn->dn_next_indblkshift[0], sizeof (dn->dn_next_indblkshift));
	bzero(&dn->dn_next_bonustype[0], sizeof (dn->dn_next_bonustype));
	bzero(&dn->dn_rm_spillblk[0], sizeof (dn->dn_rm_spillblk));
	bzero(&dn->dn_next_bonuslen[0], sizeof (dn->dn_next_bonuslen));
	bzero(&dn->dn_next_blksz[0], sizeof (dn->dn_next_blksz));
	bzero(&dn->dn_next_maxblkid[0], sizeof (dn->dn_next_maxblkid));

	for (i = 0; i < TXG_SIZE; i++) {
	multilist_link_init(&dn->dn_dirty_link[i]);
	dn->dn_free_ranges[i] = NULL;
	list_create(&dn->dn_dirty_records[i],
	sizeof (dbuf_dirty_record_t),
	offsetof(dbuf_dirty_record_t, dr_dirty_node));
	}

	dn->dn_allocated_txg = 0;
	dn->dn_free_txg = 0;
	dn->dn_assigned_txg = 0;
	dn->dn_dirty_txg = 0;
	dn->dn_dirtyctx = 0;
	dn->dn_dirtyctx_firstset = NULL;
	dn->dn_bonus = NULL;
	dn->dn_have_spill = B_FALSE;
	dn->dn_zio = NULL;
	dn->dn_oldused = 0;
	dn->dn_oldflags = 0;
	dn->dn_olduid = 0;
	dn->dn_oldgid = 0;
	dn->dn_oldprojid = ZFS_DEFAULT_PROJID;
	dn->dn_newuid = 0;
	dn->dn_newgid = 0;
	dn->dn_newprojid = ZFS_DEFAULT_PROJID;
	dn->dn_id_flags = 0;

	dn->dn_dbufs_count = 0;
	avl_create(&dn->dn_dbufs, dbuf_compare, sizeof (dmu_buf_impl_t),
	offsetof(dmu_buf_impl_t, db_link));

	dn->dn_moved = 0;
	return (0);
	}

	/* ARGSUSED */
	static void
	dnode_dest(void arg, void unused)
	{
	int i;
	dnode_t *dn = arg;

	rw_destroy(&dn->dn_struct_rwlock);
	mutex_destroy(&dn->dn_mtx);
	mutex_destroy(&dn->dn_dbufs_mtx);
	cv_destroy(&dn->dn_notxholds);
	cv_destroy(&dn->dn_nodnholds);
	zfs_refcount_destroy(&dn->dn_holds);
	zfs_refcount_destroy(&dn->dn_tx_holds);
	ASSERT(!list_link_active(&dn->dn_link));

	for (i = 0; i < TXG_SIZE; i++) {
	ASSERT(!multilist_link_active(&dn->dn_dirty_link[i]));
	ASSERT3P(dn->dn_free_ranges[i], ==, NULL);
	list_destroy(&dn->dn_dirty_records[i]);
	ASSERT0(dn->dn_next_nblkptr[i]);
	ASSERT0(dn->dn_next_nlevels[i]);
	ASSERT0(dn->dn_next_indblkshift[i]);
	ASSERT0(dn->dn_next_bonustype[i]);
	ASSERT0(dn->dn_rm_spillblk[i]);
	ASSERT0(dn->dn_next_bonuslen[i]);
	ASSERT0(dn->dn_next_blksz[i]);
	ASSERT0(dn->dn_next_maxblkid[i]);
	}

	ASSERT0(dn->dn_allocated_txg);
	ASSERT0(dn->dn_free_txg);
	ASSERT0(dn->dn_assigned_txg);
	ASSERT0(dn->dn_dirty_txg);
	ASSERT0(dn->dn_dirtyctx);
	ASSERT3P(dn->dn_dirtyctx_firstset, ==, NULL);
	ASSERT3P(dn->dn_bonus, ==, NULL);
	ASSERT(!dn->dn_have_spill);
	ASSERT3P(dn->dn_zio, ==, NULL);
	ASSERT0(dn->dn_oldused);
	ASSERT0(dn->dn_oldflags);
	ASSERT0(dn->dn_olduid);
	ASSERT0(dn->dn_oldgid);
	ASSERT0(dn->dn_oldprojid);
	ASSERT0(dn->dn_newuid);
	ASSERT0(dn->dn_newgid);
	ASSERT0(dn->dn_newprojid);
	ASSERT0(dn->dn_id_flags);

	ASSERT0(dn->dn_dbufs_count);
	avl_destroy(&dn->dn_dbufs);
	}

	void
	dnode_init(void)
	{
	ASSERT(dnode_cache == NULL);
	dnode_cache = kmem_cache_create("dnode_t", sizeof (dnode_t),
	0, dnode_cons, dnode_dest, NULL, NULL, NULL, 0);
	kmem_cache_set_move(dnode_cache, dnode_move);

	dnode_ksp = kstat_create("zfs", 0, "dnodestats", "misc",
	KSTAT_TYPE_NAMED, sizeof (dnode_stats) / sizeof (kstat_named_t),
	KSTAT_FLAG_VIRTUAL);
	if (dnode_ksp != NULL) {
	dnode_ksp->ks_data = &dnode_stats;
	kstat_install(dnode_ksp);
	}
	}

	void
	dnode_fini(void)
	{
	if (dnode_ksp != NULL) {
	kstat_delete(dnode_ksp);
	dnode_ksp = NULL;
	}

	kmem_cache_destroy(dnode_cache);
	dnode_cache = NULL;
	}


	#ifdef ZFS_DEBUG
	void
	dnode_verify(dnode_t *dn)
	{
	int drop_struct_lock = FALSE;

	ASSERT(dn->dn_phys);
	ASSERT(dn->dn_objset);
	ASSERT(dn->dn_handle->dnh_dnode == dn);

	ASSERT(DMU_OT_IS_VALID(dn->dn_phys->dn_type));

	if (!(zfs_flags & ZFS_DEBUG_DNODE_VERIFY))
	return;

	if (!RW_WRITE_HELD(&dn->dn_struct_rwlock)) {
	rw_enter(&dn->dn_struct_rwlock, RW_READER);
	drop_struct_lock = TRUE;
	}
	if (dn->dn_phys->dn_type != DMU_OT_NONE \|\| dn->dn_allocated_txg != 0) {
	int i;
	int max_bonuslen = DN_SLOTS_TO_BONUSLEN(dn->dn_num_slots);
	ASSERT3U(dn->dn_indblkshift, <=, SPA_MAXBLOCKSHIFT);
	if (dn->dn_datablkshift) {
	ASSERT3U(dn->dn_datablkshift, >=, SPA_MINBLOCKSHIFT);
	ASSERT3U(dn->dn_datablkshift, <=, SPA_MAXBLOCKSHIFT);
	ASSERT3U(1<<dn->dn_datablkshift, ==, dn->dn_datablksz);
	}
	ASSERT3U(dn->dn_nlevels, <=, 30);
	ASSERT(DMU_OT_IS_VALID(dn->dn_type));
	ASSERT3U(dn->dn_nblkptr, >=, 1);
	ASSERT3U(dn->dn_nblkptr, <=, DN_MAX_NBLKPTR);
	ASSERT3U(dn->dn_bonuslen, <=, max_bonuslen);
	ASSERT3U(dn->dn_datablksz, ==,
	dn->dn_datablkszsec << SPA_MINBLOCKSHIFT);
	ASSERT3U(ISP2(dn->dn_datablksz), ==, dn->dn_datablkshift != 0);
	ASSERT3U((dn->dn_nblkptr - 1) * sizeof (blkptr_t) +
	dn->dn_bonuslen, <=, max_bonuslen);
	for (i = 0; i < TXG_SIZE; i++) {
	ASSERT3U(dn->dn_next_nlevels[i], <=, dn->dn_nlevels);
	}
	}
	if (dn->dn_phys->dn_type != DMU_OT_NONE)
	ASSERT3U(dn->dn_phys->dn_nlevels, <=, dn->dn_nlevels);
	ASSERT(DMU_OBJECT_IS_SPECIAL(dn->dn_object) \|\| dn->dn_dbuf != NULL);
	if (dn->dn_dbuf != NULL) {
	ASSERT3P(dn->dn_phys, ==,
	(dnode_phys_t *)dn->dn_dbuf->db.db_data +
	(dn->dn_object % (dn->dn_dbuf->db.db_size >> DNODE_SHIFT)));
	}
	if (drop_struct_lock)
	rw_exit(&dn->dn_struct_rwlock);
	}
	#endif

	void
	dnode_byteswap(dnode_phys_t *dnp)
	{
	uint64_t buf64 = (void)&dnp->dn_blkptr;
	int i;

	if (dnp->dn_type == DMU_OT_NONE) {
	bzero(dnp, sizeof (dnode_phys_t));
	return;
	}

	dnp->dn_datablkszsec = BSWAP_16(dnp->dn_datablkszsec);
	dnp->dn_bonuslen = BSWAP_16(dnp->dn_bonuslen);
	dnp->dn_extra_slots = BSWAP_8(dnp->dn_extra_slots);
	dnp->dn_maxblkid = BSWAP_64(dnp->dn_maxblkid);
	dnp->dn_used = BSWAP_64(dnp->dn_used);

	/*
	* dn_nblkptr is only one byte, so it's OK to read it in either
	* byte order. We can't read dn_bouslen.
	*/
	ASSERT(dnp->dn_indblkshift <= SPA_MAXBLOCKSHIFT);
	ASSERT(dnp->dn_nblkptr <= DN_MAX_NBLKPTR);
	for (i = 0; i < dnp->dn_nblkptr * sizeof (blkptr_t)/8; i++)
	buf64[i] = BSWAP_64(buf64[i]);

	/*
	* OK to check dn_bonuslen for zero, because it won't matter if
	* we have the wrong byte order. This is necessary because the
	* dnode dnode is smaller than a regular dnode.
	*/
	if (dnp->dn_bonuslen != 0) {
	/*
	* Note that the bonus length calculated here may be
	* longer than the actual bonus buffer. This is because
	* we always put the bonus buffer after the last block
	* pointer (instead of packing it against the end of the
	* dnode buffer).
	*/
	int off = (dnp->dn_nblkptr-1) * sizeof (blkptr_t);
	int slots = dnp->dn_extra_slots + 1;
	size_t len = DN_SLOTS_TO_BONUSLEN(slots) - off;
	dmu_object_byteswap_t byteswap;
	ASSERT(DMU_OT_IS_VALID(dnp->dn_bonustype));
	byteswap = DMU_OT_BYTESWAP(dnp->dn_bonustype);
	dmu_ot_byteswap[byteswap].ob_func(dnp->dn_bonus + off, len);
	}

	/* Swap SPILL block if we have one */
	if (dnp->dn_flags & DNODE_FLAG_SPILL_BLKPTR)
	byteswap_uint64_array(DN_SPILL_BLKPTR(dnp), sizeof (blkptr_t));
	}

	void
	dnode_buf_byteswap(void *vbuf, size_t size)
	{
	int i = 0;

	ASSERT3U(sizeof (dnode_phys_t), ==, (1<<DNODE_SHIFT));
	ASSERT((size & (sizeof (dnode_phys_t)-1)) == 0);

	while (i < size) {
	dnode_phys_t dnp = (void )(((char *)vbuf) + i);
	dnode_byteswap(dnp);

	i += DNODE_MIN_SIZE;
	if (dnp->dn_type != DMU_OT_NONE)
	i += dnp->dn_extra_slots * DNODE_MIN_SIZE;
	}
	}

	void
	dnode_setbonuslen(dnode_t dn, int newsize, dmu_tx_t tx)
	{
	ASSERT3U(zfs_refcount_count(&dn->dn_holds), >=, 1);

	dnode_setdirty(dn, tx);
	rw_enter(&dn->dn_struct_rwlock, RW_WRITER);
	ASSERT3U(newsize, <=, DN_SLOTS_TO_BONUSLEN(dn->dn_num_slots) -
	(dn->dn_nblkptr-1) * sizeof (blkptr_t));

	if (newsize < dn->dn_bonuslen) {
	/* clear any data after the end of the new size */
	size_t diff = dn->dn_bonuslen - newsize;
	char data_end = ((char )dn->dn_bonus->db.db_data) + newsize;
	bzero(data_end, diff);
	}

	dn->dn_bonuslen = newsize;
	if (newsize == 0)
	dn->dn_next_bonuslen[tx->tx_txg & TXG_MASK] = DN_ZERO_BONUSLEN;
	else
	dn->dn_next_bonuslen[tx->tx_txg & TXG_MASK] = dn->dn_bonuslen;
	rw_exit(&dn->dn_struct_rwlock);
	}

	void
	dnode_setbonus_type(dnode_t dn, dmu_object_type_t newtype, dmu_tx_t tx)
	{
	ASSERT3U(zfs_refcount_count(&dn->dn_holds), >=, 1);
	dnode_setdirty(dn, tx);
	rw_enter(&dn->dn_struct_rwlock, RW_WRITER);
	dn->dn_bonustype = newtype;
	dn->dn_next_bonustype[tx->tx_txg & TXG_MASK] = dn->dn_bonustype;
	rw_exit(&dn->dn_struct_rwlock);
	}

	void
	dnode_rm_spill(dnode_t dn, dmu_tx_t tx)
	{
	ASSERT3U(zfs_refcount_count(&dn->dn_holds), >=, 1);
	ASSERT(RW_WRITE_HELD(&dn->dn_struct_rwlock));
	dnode_setdirty(dn, tx);
	dn->dn_rm_spillblk[tx->tx_txg & TXG_MASK] = DN_KILL_SPILLBLK;
	dn->dn_have_spill = B_FALSE;
	}

	static void
	dnode_setdblksz(dnode_t *dn, int size)
	{
	ASSERT0(P2PHASE(size, SPA_MINBLOCKSIZE));
	ASSERT3U(size, <=, SPA_MAXBLOCKSIZE);
	ASSERT3U(size, >=, SPA_MINBLOCKSIZE);
	ASSERT3U(size >> SPA_MINBLOCKSHIFT, <,
	1<<(sizeof (dn->dn_phys->dn_datablkszsec) * 8));
	dn->dn_datablksz = size;
	dn->dn_datablkszsec = size >> SPA_MINBLOCKSHIFT;
	dn->dn_datablkshift = ISP2(size) ? highbit64(size - 1) : 0;
	}

	static dnode_t *
	dnode_create(objset_t os, dnode_phys_t dnp, dmu_buf_impl_t *db,
	uint64_t object, dnode_handle_t *dnh)
	{
	dnode_t *dn;

	dn = kmem_cache_alloc(dnode_cache, KM_SLEEP);
	dn->dn_moved = 0;

	/*
	* Defer setting dn_objset until the dnode is ready to be a candidate
	* for the dnode_move() callback.
	*/
	dn->dn_object = object;
	dn->dn_dbuf = db;
	dn->dn_handle = dnh;
	dn->dn_phys = dnp;

	if (dnp->dn_datablkszsec) {
	dnode_setdblksz(dn, dnp->dn_datablkszsec << SPA_MINBLOCKSHIFT);
	} else {
	dn->dn_datablksz = 0;
	dn->dn_datablkszsec = 0;
	dn->dn_datablkshift = 0;
	}
	dn->dn_indblkshift = dnp->dn_indblkshift;
	dn->dn_nlevels = dnp->dn_nlevels;
	dn->dn_type = dnp->dn_type;
	dn->dn_nblkptr = dnp->dn_nblkptr;
	dn->dn_checksum = dnp->dn_checksum;
	dn->dn_compress = dnp->dn_compress;
	dn->dn_bonustype = dnp->dn_bonustype;
	dn->dn_bonuslen = dnp->dn_bonuslen;
	dn->dn_num_slots = dnp->dn_extra_slots + 1;
	dn->dn_maxblkid = dnp->dn_maxblkid;
	dn->dn_have_spill = ((dnp->dn_flags & DNODE_FLAG_SPILL_BLKPTR) != 0);
	dn->dn_id_flags = 0;

	dmu_zfetch_init(&dn->dn_zfetch, dn);

	ASSERT(DMU_OT_IS_VALID(dn->dn_phys->dn_type));
	ASSERT(zrl_is_locked(&dnh->dnh_zrlock));
	ASSERT(!DN_SLOT_IS_PTR(dnh->dnh_dnode));

	mutex_enter(&os->os_lock);

	/*
	* Exclude special dnodes from os_dnodes so an empty os_dnodes
	* signifies that the special dnodes have no references from
	* their children (the entries in os_dnodes). This allows
	* dnode_destroy() to easily determine if the last child has
	* been removed and then complete eviction of the objset.
	*/
	if (!DMU_OBJECT_IS_SPECIAL(object))
	list_insert_head(&os->os_dnodes, dn);
	membar_producer();

	/*
	* Everything else must be valid before assigning dn_objset
	* makes the dnode eligible for dnode_move().
	*/
	dn->dn_objset = os;

	dnh->dnh_dnode = dn;
	mutex_exit(&os->os_lock);

	arc_space_consume(sizeof (dnode_t), ARC_SPACE_DNODE);

	return (dn);
	}

	/*
	* Caller must be holding the dnode handle, which is released upon return.
	*/
	static void
	dnode_destroy(dnode_t *dn)
	{
	objset_t *os = dn->dn_objset;
	boolean_t complete_os_eviction = B_FALSE;

	ASSERT((dn->dn_id_flags & DN_ID_NEW_EXIST) == 0);

	mutex_enter(&os->os_lock);
	POINTER_INVALIDATE(&dn->dn_objset);
	if (!DMU_OBJECT_IS_SPECIAL(dn->dn_object)) {
	list_remove(&os->os_dnodes, dn);
	complete_os_eviction =
	list_is_empty(&os->os_dnodes) &&
	list_link_active(&os->os_evicting_node);
	}
	mutex_exit(&os->os_lock);

	/* the dnode can no longer move, so we can release the handle */
	if (!zrl_is_locked(&dn->dn_handle->dnh_zrlock))
	zrl_remove(&dn->dn_handle->dnh_zrlock);

	dn->dn_allocated_txg = 0;
	dn->dn_free_txg = 0;
	dn->dn_assigned_txg = 0;
	dn->dn_dirty_txg = 0;

	dn->dn_dirtyctx = 0;
	dn->dn_dirtyctx_firstset = NULL;
	if (dn->dn_bonus != NULL) {
	mutex_enter(&dn->dn_bonus->db_mtx);
	dbuf_destroy(dn->dn_bonus);
	dn->dn_bonus = NULL;
	}
	dn->dn_zio = NULL;

	dn->dn_have_spill = B_FALSE;
	dn->dn_oldused = 0;
	dn->dn_oldflags = 0;
	dn->dn_olduid = 0;
	dn->dn_oldgid = 0;
	dn->dn_oldprojid = ZFS_DEFAULT_PROJID;
	dn->dn_newuid = 0;
	dn->dn_newgid = 0;
	dn->dn_newprojid = ZFS_DEFAULT_PROJID;
	dn->dn_id_flags = 0;

	dmu_zfetch_fini(&dn->dn_zfetch);
	kmem_cache_free(dnode_cache, dn);
	arc_space_return(sizeof (dnode_t), ARC_SPACE_DNODE);

	if (complete_os_eviction)
	dmu_objset_evict_done(os);
	}

	void
	dnode_allocate(dnode_t *dn, dmu_object_type_t ot, int blocksize, int ibs,
	dmu_object_type_t bonustype, int bonuslen, int dn_slots, dmu_tx_t *tx)
	{
	int i;

	ASSERT3U(dn_slots, >, 0);
	ASSERT3U(dn_slots << DNODE_SHIFT, <=,
	spa_maxdnodesize(dmu_objset_spa(dn->dn_objset)));
	ASSERT3U(blocksize, <=,
	spa_maxblocksize(dmu_objset_spa(dn->dn_objset)));
	if (blocksize == 0)
	blocksize = 1 << zfs_default_bs;
	else
	blocksize = P2ROUNDUP(blocksize, SPA_MINBLOCKSIZE);

	if (ibs == 0)
	ibs = zfs_default_ibs;

	ibs = MIN(MAX(ibs, DN_MIN_INDBLKSHIFT), DN_MAX_INDBLKSHIFT);

	dprintf("os=%p obj=%llu txg=%llu blocksize=%d ibs=%d dn_slots=%d\n",
	dn->dn_objset, dn->dn_object, tx->tx_txg, blocksize, ibs, dn_slots);
	DNODE_STAT_BUMP(dnode_allocate);

	ASSERT(dn->dn_type == DMU_OT_NONE);
	ASSERT(bcmp(dn->dn_phys, &dnode_phys_zero, sizeof (dnode_phys_t)) == 0);
	ASSERT(dn->dn_phys->dn_type == DMU_OT_NONE);
	ASSERT(ot != DMU_OT_NONE);
	ASSERT(DMU_OT_IS_VALID(ot));
	ASSERT((bonustype == DMU_OT_NONE && bonuslen == 0) \|\|
	(bonustype == DMU_OT_SA && bonuslen == 0) \|\|
	(bonustype != DMU_OT_NONE && bonuslen != 0));
	ASSERT(DMU_OT_IS_VALID(bonustype));
	ASSERT3U(bonuslen, <=, DN_SLOTS_TO_BONUSLEN(dn_slots));
	ASSERT(dn->dn_type == DMU_OT_NONE);
	ASSERT0(dn->dn_maxblkid);
	ASSERT0(dn->dn_allocated_txg);
	ASSERT0(dn->dn_assigned_txg);
	ASSERT(zfs_refcount_is_zero(&dn->dn_tx_holds));
	ASSERT3U(zfs_refcount_count(&dn->dn_holds), <=, 1);
	ASSERT(avl_is_empty(&dn->dn_dbufs));

	for (i = 0; i < TXG_SIZE; i++) {
	ASSERT0(dn->dn_next_nblkptr[i]);
	ASSERT0(dn->dn_next_nlevels[i]);
	ASSERT0(dn->dn_next_indblkshift[i]);
	ASSERT0(dn->dn_next_bonuslen[i]);
	ASSERT0(dn->dn_next_bonustype[i]);
	ASSERT0(dn->dn_rm_spillblk[i]);
	ASSERT0(dn->dn_next_blksz[i]);
	ASSERT0(dn->dn_next_maxblkid[i]);
	ASSERT(!multilist_link_active(&dn->dn_dirty_link[i]));
	ASSERT3P(list_head(&dn->dn_dirty_records[i]), ==, NULL);
	ASSERT3P(dn->dn_free_ranges[i], ==, NULL);
	}

	dn->dn_type = ot;
	dnode_setdblksz(dn, blocksize);
	dn->dn_indblkshift = ibs;
	dn->dn_nlevels = 1;
	dn->dn_num_slots = dn_slots;
	if (bonustype == DMU_OT_SA) /* Maximize bonus space for SA */
	dn->dn_nblkptr = 1;
	else {
	dn->dn_nblkptr = MIN(DN_MAX_NBLKPTR,
	1 + ((DN_SLOTS_TO_BONUSLEN(dn_slots) - bonuslen) >>
	SPA_BLKPTRSHIFT));
	}

	dn->dn_bonustype = bonustype;
	dn->dn_bonuslen = bonuslen;
	dn->dn_checksum = ZIO_CHECKSUM_INHERIT;
	dn->dn_compress = ZIO_COMPRESS_INHERIT;
	dn->dn_dirtyctx = 0;

	dn->dn_free_txg = 0;
	dn->dn_dirtyctx_firstset = NULL;
	dn->dn_dirty_txg = 0;

	dn->dn_allocated_txg = tx->tx_txg;
	dn->dn_id_flags = 0;

	dnode_setdirty(dn, tx);
	dn->dn_next_indblkshift[tx->tx_txg & TXG_MASK] = ibs;
	dn->dn_next_bonuslen[tx->tx_txg & TXG_MASK] = dn->dn_bonuslen;
	dn->dn_next_bonustype[tx->tx_txg & TXG_MASK] = dn->dn_bonustype;
	dn->dn_next_blksz[tx->tx_txg & TXG_MASK] = dn->dn_datablksz;
	}

	void
	dnode_reallocate(dnode_t *dn, dmu_object_type_t ot, int blocksize,
	dmu_object_type_t bonustype, int bonuslen, int dn_slots,
	boolean_t keep_spill, dmu_tx_t *tx)
	{
	int nblkptr;

	ASSERT3U(blocksize, >=, SPA_MINBLOCKSIZE);
	ASSERT3U(blocksize, <=,
	spa_maxblocksize(dmu_objset_spa(dn->dn_objset)));
	ASSERT0(blocksize % SPA_MINBLOCKSIZE);
	ASSERT(dn->dn_object != DMU_META_DNODE_OBJECT \|\| dmu_tx_private_ok(tx));
	ASSERT(tx->tx_txg != 0);
	ASSERT((bonustype == DMU_OT_NONE && bonuslen == 0) \|\|
	(bonustype != DMU_OT_NONE && bonuslen != 0) \|\|
	(bonustype == DMU_OT_SA && bonuslen == 0));
	ASSERT(DMU_OT_IS_VALID(bonustype));
	ASSERT3U(bonuslen, <=,
	DN_BONUS_SIZE(spa_maxdnodesize(dmu_objset_spa(dn->dn_objset))));
	ASSERT3U(bonuslen, <=, DN_BONUS_SIZE(dn_slots << DNODE_SHIFT));

	dnode_free_interior_slots(dn);
	DNODE_STAT_BUMP(dnode_reallocate);

	/* clean up any unreferenced dbufs */
	dnode_evict_dbufs(dn);

	dn->dn_id_flags = 0;

	rw_enter(&dn->dn_struct_rwlock, RW_WRITER);
	dnode_setdirty(dn, tx);
	if (dn->dn_datablksz != blocksize) {
	/* change blocksize */
	ASSERT0(dn->dn_maxblkid);
	ASSERT(BP_IS_HOLE(&dn->dn_phys->dn_blkptr[0]) \|\|
	dnode_block_freed(dn, 0));

	dnode_setdblksz(dn, blocksize);
	dn->dn_next_blksz[tx->tx_txg & TXG_MASK] = blocksize;
	}
	if (dn->dn_bonuslen != bonuslen)
	dn->dn_next_bonuslen[tx->tx_txg & TXG_MASK] = bonuslen;

	if (bonustype == DMU_OT_SA) /* Maximize bonus space for SA */
	nblkptr = 1;
	else
	nblkptr = MIN(DN_MAX_NBLKPTR,
	1 + ((DN_SLOTS_TO_BONUSLEN(dn_slots) - bonuslen) >>
	SPA_BLKPTRSHIFT));
	if (dn->dn_bonustype != bonustype)
	dn->dn_next_bonustype[tx->tx_txg & TXG_MASK] = bonustype;
	if (dn->dn_nblkptr != nblkptr)
	dn->dn_next_nblkptr[tx->tx_txg & TXG_MASK] = nblkptr;
	if (dn->dn_phys->dn_flags & DNODE_FLAG_SPILL_BLKPTR && !keep_spill) {
	dbuf_rm_spill(dn, tx);
	dnode_rm_spill(dn, tx);
	}

	rw_exit(&dn->dn_struct_rwlock);

	/* change type */
	dn->dn_type = ot;

	/* change bonus size and type */
	mutex_enter(&dn->dn_mtx);
	dn->dn_bonustype = bonustype;
	dn->dn_bonuslen = bonuslen;
	dn->dn_num_slots = dn_slots;
	dn->dn_nblkptr = nblkptr;
	dn->dn_checksum = ZIO_CHECKSUM_INHERIT;
	dn->dn_compress = ZIO_COMPRESS_INHERIT;
	ASSERT3U(dn->dn_nblkptr, <=, DN_MAX_NBLKPTR);

	/* fix up the bonus db_size */
	if (dn->dn_bonus) {
	dn->dn_bonus->db.db_size =
	DN_SLOTS_TO_BONUSLEN(dn->dn_num_slots) -
	(dn->dn_nblkptr-1) * sizeof (blkptr_t);
	ASSERT(dn->dn_bonuslen <= dn->dn_bonus->db.db_size);
	}

	dn->dn_allocated_txg = tx->tx_txg;
	mutex_exit(&dn->dn_mtx);
	}

	#ifdef _KERNEL
	static void
	dnode_move_impl(dnode_t odn, dnode_t ndn)
	{
	int i;

	ASSERT(!RW_LOCK_HELD(&odn->dn_struct_rwlock));
	ASSERT(MUTEX_NOT_HELD(&odn->dn_mtx));
	ASSERT(MUTEX_NOT_HELD(&odn->dn_dbufs_mtx));
	- ASSERT(!MUTEX_HELD(&odn->dn_zfetch.zf_lock));

	/* Copy fields. */
	ndn->dn_objset = odn->dn_objset;
	ndn->dn_object = odn->dn_object;
	ndn->dn_dbuf = odn->dn_dbuf;
	ndn->dn_handle = odn->dn_handle;
	ndn->dn_phys = odn->dn_phys;
	ndn->dn_type = odn->dn_type;
	ndn->dn_bonuslen = odn->dn_bonuslen;
	ndn->dn_bonustype = odn->dn_bonustype;
	ndn->dn_nblkptr = odn->dn_nblkptr;
	ndn->dn_checksum = odn->dn_checksum;
	ndn->dn_compress = odn->dn_compress;
	ndn->dn_nlevels = odn->dn_nlevels;
	ndn->dn_indblkshift = odn->dn_indblkshift;
	ndn->dn_datablkshift = odn->dn_datablkshift;
	ndn->dn_datablkszsec = odn->dn_datablkszsec;
	ndn->dn_datablksz = odn->dn_datablksz;
	ndn->dn_maxblkid = odn->dn_maxblkid;
	ndn->dn_num_slots = odn->dn_num_slots;
	bcopy(&odn->dn_next_type[0], &ndn->dn_next_type[0],
	sizeof (odn->dn_next_type));
	bcopy(&odn->dn_next_nblkptr[0], &ndn->dn_next_nblkptr[0],
	sizeof (odn->dn_next_nblkptr));
	bcopy(&odn->dn_next_nlevels[0], &ndn->dn_next_nlevels[0],
	sizeof (odn->dn_next_nlevels));
	bcopy(&odn->dn_next_indblkshift[0], &ndn->dn_next_indblkshift[0],
	sizeof (odn->dn_next_indblkshift));
	bcopy(&odn->dn_next_bonustype[0], &ndn->dn_next_bonustype[0],
	sizeof (odn->dn_next_bonustype));
	bcopy(&odn->dn_rm_spillblk[0], &ndn->dn_rm_spillblk[0],
	sizeof (odn->dn_rm_spillblk));
	bcopy(&odn->dn_next_bonuslen[0], &ndn->dn_next_bonuslen[0],
	sizeof (odn->dn_next_bonuslen));
	bcopy(&odn->dn_next_blksz[0], &ndn->dn_next_blksz[0],
	sizeof (odn->dn_next_blksz));
	bcopy(&odn->dn_next_maxblkid[0], &ndn->dn_next_maxblkid[0],
	sizeof (odn->dn_next_maxblkid));
	for (i = 0; i < TXG_SIZE; i++) {
	list_move_tail(&ndn->dn_dirty_records[i],
	&odn->dn_dirty_records[i]);
	}
	bcopy(&odn->dn_free_ranges[0], &ndn->dn_free_ranges[0],
	sizeof (odn->dn_free_ranges));
	ndn->dn_allocated_txg = odn->dn_allocated_txg;
	ndn->dn_free_txg = odn->dn_free_txg;
	ndn->dn_assigned_txg = odn->dn_assigned_txg;
	ndn->dn_dirty_txg = odn->dn_dirty_txg;
	ndn->dn_dirtyctx = odn->dn_dirtyctx;
	ndn->dn_dirtyctx_firstset = odn->dn_dirtyctx_firstset;
	ASSERT(zfs_refcount_count(&odn->dn_tx_holds) == 0);
	zfs_refcount_transfer(&ndn->dn_holds, &odn->dn_holds);
	ASSERT(avl_is_empty(&ndn->dn_dbufs));
	avl_swap(&ndn->dn_dbufs, &odn->dn_dbufs);
	ndn->dn_dbufs_count = odn->dn_dbufs_count;
	ndn->dn_bonus = odn->dn_bonus;
	ndn->dn_have_spill = odn->dn_have_spill;
	ndn->dn_zio = odn->dn_zio;
	ndn->dn_oldused = odn->dn_oldused;
	ndn->dn_oldflags = odn->dn_oldflags;
	ndn->dn_olduid = odn->dn_olduid;
	ndn->dn_oldgid = odn->dn_oldgid;
	ndn->dn_oldprojid = odn->dn_oldprojid;
	ndn->dn_newuid = odn->dn_newuid;
	ndn->dn_newgid = odn->dn_newgid;
	ndn->dn_newprojid = odn->dn_newprojid;
	ndn->dn_id_flags = odn->dn_id_flags;
	- dmu_zfetch_init(&ndn->dn_zfetch, NULL);
	- list_move_tail(&ndn->dn_zfetch.zf_stream, &odn->dn_zfetch.zf_stream);
	- ndn->dn_zfetch.zf_dnode = odn->dn_zfetch.zf_dnode;
	+ dmu_zfetch_init(&ndn->dn_zfetch, ndn);

	/*
	* Update back pointers. Updating the handle fixes the back pointer of
	* every descendant dbuf as well as the bonus dbuf.
	*/
	ASSERT(ndn->dn_handle->dnh_dnode == odn);
	ndn->dn_handle->dnh_dnode = ndn;
	- if (ndn->dn_zfetch.zf_dnode == odn) {
	- ndn->dn_zfetch.zf_dnode = ndn;
	- }

	/*
	* Invalidate the original dnode by clearing all of its back pointers.
	*/
	odn->dn_dbuf = NULL;
	odn->dn_handle = NULL;
	avl_create(&odn->dn_dbufs, dbuf_compare, sizeof (dmu_buf_impl_t),
	offsetof(dmu_buf_impl_t, db_link));
	odn->dn_dbufs_count = 0;
	odn->dn_bonus = NULL;
	dmu_zfetch_fini(&odn->dn_zfetch);

	/*
	* Set the low bit of the objset pointer to ensure that dnode_move()
	* recognizes the dnode as invalid in any subsequent callback.
	*/
	POINTER_INVALIDATE(&odn->dn_objset);

	/*
	* Satisfy the destructor.
	*/
	for (i = 0; i < TXG_SIZE; i++) {
	list_create(&odn->dn_dirty_records[i],
	sizeof (dbuf_dirty_record_t),
	offsetof(dbuf_dirty_record_t, dr_dirty_node));
	odn->dn_free_ranges[i] = NULL;
	odn->dn_next_nlevels[i] = 0;
	odn->dn_next_indblkshift[i] = 0;
	odn->dn_next_bonustype[i] = 0;
	odn->dn_rm_spillblk[i] = 0;
	odn->dn_next_bonuslen[i] = 0;
	odn->dn_next_blksz[i] = 0;
	}
	odn->dn_allocated_txg = 0;
	odn->dn_free_txg = 0;
	odn->dn_assigned_txg = 0;
	odn->dn_dirty_txg = 0;
	odn->dn_dirtyctx = 0;
	odn->dn_dirtyctx_firstset = NULL;
	odn->dn_have_spill = B_FALSE;
	odn->dn_zio = NULL;
	odn->dn_oldused = 0;
	odn->dn_oldflags = 0;
	odn->dn_olduid = 0;
	odn->dn_oldgid = 0;
	odn->dn_oldprojid = ZFS_DEFAULT_PROJID;
	odn->dn_newuid = 0;
	odn->dn_newgid = 0;
	odn->dn_newprojid = ZFS_DEFAULT_PROJID;
	odn->dn_id_flags = 0;

	/*
	* Mark the dnode.
	*/
	ndn->dn_moved = 1;
	odn->dn_moved = (uint8_t)-1;
	}

	/ARGSUSED/
	static kmem_cbrc_t
	dnode_move(void buf, void newbuf, size_t size, void *arg)
	{
	dnode_t odn = buf, ndn = newbuf;
	objset_t *os;
	int64_t refcount;
	uint32_t dbufs;

	/*
	* The dnode is on the objset's list of known dnodes if the objset
	* pointer is valid. We set the low bit of the objset pointer when
	* freeing the dnode to invalidate it, and the memory patterns written
	* by kmem (baddcafe and deadbeef) set at least one of the two low bits.
	* A newly created dnode sets the objset pointer last of all to indicate
	* that the dnode is known and in a valid state to be moved by this
	* function.
	*/
	os = odn->dn_objset;
	if (!POINTER_IS_VALID(os)) {
	DNODE_STAT_BUMP(dnode_move_invalid);
	return (KMEM_CBRC_DONT_KNOW);
	}

	/*
	* Ensure that the objset does not go away during the move.
	*/
	rw_enter(&os_lock, RW_WRITER);
	if (os != odn->dn_objset) {
	rw_exit(&os_lock);
	DNODE_STAT_BUMP(dnode_move_recheck1);
	return (KMEM_CBRC_DONT_KNOW);
	}

	/*
	* If the dnode is still valid, then so is the objset. We know that no
	* valid objset can be freed while we hold os_lock, so we can safely
	* ensure that the objset remains in use.
	*/
	mutex_enter(&os->os_lock);

	/*
	* Recheck the objset pointer in case the dnode was removed just before
	* acquiring the lock.
	*/
	if (os != odn->dn_objset) {
	mutex_exit(&os->os_lock);
	rw_exit(&os_lock);
	DNODE_STAT_BUMP(dnode_move_recheck2);
	return (KMEM_CBRC_DONT_KNOW);
	}

	/*
	* At this point we know that as long as we hold os->os_lock, the dnode
	* cannot be freed and fields within the dnode can be safely accessed.
	* The objset listing this dnode cannot go away as long as this dnode is
	* on its list.
	*/
	rw_exit(&os_lock);
	if (DMU_OBJECT_IS_SPECIAL(odn->dn_object)) {
	mutex_exit(&os->os_lock);
	DNODE_STAT_BUMP(dnode_move_special);
	return (KMEM_CBRC_NO);
	}
	ASSERT(odn->dn_dbuf != NULL); /* only "special" dnodes have no parent */

	/*
	* Lock the dnode handle to prevent the dnode from obtaining any new
	* holds. This also prevents the descendant dbufs and the bonus dbuf
	* from accessing the dnode, so that we can discount their holds. The
	* handle is safe to access because we know that while the dnode cannot
	* go away, neither can its handle. Once we hold dnh_zrlock, we can
	* safely move any dnode referenced only by dbufs.
	*/
	if (!zrl_tryenter(&odn->dn_handle->dnh_zrlock)) {
	mutex_exit(&os->os_lock);
	DNODE_STAT_BUMP(dnode_move_handle);
	return (KMEM_CBRC_LATER);
	}

	/*
	* Ensure a consistent view of the dnode's holds and the dnode's dbufs.
	* We need to guarantee that there is a hold for every dbuf in order to
	* determine whether the dnode is actively referenced. Falsely matching
	* a dbuf to an active hold would lead to an unsafe move. It's possible
	* that a thread already having an active dnode hold is about to add a
	* dbuf, and we can't compare hold and dbuf counts while the add is in
	* progress.
	*/
	if (!rw_tryenter(&odn->dn_struct_rwlock, RW_WRITER)) {
	zrl_exit(&odn->dn_handle->dnh_zrlock);
	mutex_exit(&os->os_lock);
	DNODE_STAT_BUMP(dnode_move_rwlock);
	return (KMEM_CBRC_LATER);
	}

	/*
	* A dbuf may be removed (evicted) without an active dnode hold. In that
	* case, the dbuf count is decremented under the handle lock before the
	* dbuf's hold is released. This order ensures that if we count the hold
	* after the dbuf is removed but before its hold is released, we will
	* treat the unmatched hold as active and exit safely. If we count the
	* hold before the dbuf is removed, the hold is discounted, and the
	* removal is blocked until the move completes.
	*/
	refcount = zfs_refcount_count(&odn->dn_holds);
	ASSERT(refcount >= 0);
	dbufs = DN_DBUFS_COUNT(odn);

	/* We can't have more dbufs than dnode holds. */
	ASSERT3U(dbufs, <=, refcount);
	DTRACE_PROBE3(dnode__move, dnode_t *, odn, int64_t, refcount,
	uint32_t, dbufs);

	if (refcount > dbufs) {
	rw_exit(&odn->dn_struct_rwlock);
	zrl_exit(&odn->dn_handle->dnh_zrlock);
	mutex_exit(&os->os_lock);
	DNODE_STAT_BUMP(dnode_move_active);
	return (KMEM_CBRC_LATER);
	}

	rw_exit(&odn->dn_struct_rwlock);

	/*
	* At this point we know that anyone with a hold on the dnode is not
	* actively referencing it. The dnode is known and in a valid state to
	* move. We're holding the locks needed to execute the critical section.
	*/
	dnode_move_impl(odn, ndn);

	list_link_replace(&odn->dn_link, &ndn->dn_link);
	/* If the dnode was safe to move, the refcount cannot have changed. */
	ASSERT(refcount == zfs_refcount_count(&ndn->dn_holds));
	ASSERT(dbufs == DN_DBUFS_COUNT(ndn));
	zrl_exit(&ndn->dn_handle->dnh_zrlock); /* handle has moved */
	mutex_exit(&os->os_lock);

	return (KMEM_CBRC_YES);
	}
	#endif /* _KERNEL */

	static void
	dnode_slots_hold(dnode_children_t *children, int idx, int slots)
	{
	ASSERT3S(idx + slots, <=, DNODES_PER_BLOCK);

	for (int i = idx; i < idx + slots; i++) {
	dnode_handle_t *dnh = &children->dnc_children[i];
	zrl_add(&dnh->dnh_zrlock);
	}
	}

	static void
	dnode_slots_rele(dnode_children_t *children, int idx, int slots)
	{
	ASSERT3S(idx + slots, <=, DNODES_PER_BLOCK);

	for (int i = idx; i < idx + slots; i++) {
	dnode_handle_t *dnh = &children->dnc_children[i];

	if (zrl_is_locked(&dnh->dnh_zrlock))
	zrl_exit(&dnh->dnh_zrlock);
	else
	zrl_remove(&dnh->dnh_zrlock);
	}
	}

	static int
	dnode_slots_tryenter(dnode_children_t *children, int idx, int slots)
	{
	ASSERT3S(idx + slots, <=, DNODES_PER_BLOCK);

	for (int i = idx; i < idx + slots; i++) {
	dnode_handle_t *dnh = &children->dnc_children[i];

	if (!zrl_tryenter(&dnh->dnh_zrlock)) {
	for (int j = idx; j < i; j++) {
	dnh = &children->dnc_children[j];
	zrl_exit(&dnh->dnh_zrlock);
	}

	return (0);
	}
	}

	return (1);
	}

	static void
	dnode_set_slots(dnode_children_t children, int idx, int slots, void ptr)
	{
	ASSERT3S(idx + slots, <=, DNODES_PER_BLOCK);

	for (int i = idx; i < idx + slots; i++) {
	dnode_handle_t *dnh = &children->dnc_children[i];
	dnh->dnh_dnode = ptr;
	}
	}

	static boolean_t
	dnode_check_slots_free(dnode_children_t *children, int idx, int slots)
	{
	ASSERT3S(idx + slots, <=, DNODES_PER_BLOCK);

	/*
	* If all dnode slots are either already free or
	* evictable return B_TRUE.
	*/
	for (int i = idx; i < idx + slots; i++) {
	dnode_handle_t *dnh = &children->dnc_children[i];
	dnode_t *dn = dnh->dnh_dnode;

	if (dn == DN_SLOT_FREE) {
	continue;
	} else if (DN_SLOT_IS_PTR(dn)) {
	mutex_enter(&dn->dn_mtx);
	boolean_t can_free = (dn->dn_type == DMU_OT_NONE &&
	zfs_refcount_is_zero(&dn->dn_holds) &&
	!DNODE_IS_DIRTY(dn));
	mutex_exit(&dn->dn_mtx);

	if (!can_free)
	return (B_FALSE);
	else
	continue;
	} else {
	return (B_FALSE);
	}
	}

	return (B_TRUE);
	}

	static void
	dnode_reclaim_slots(dnode_children_t *children, int idx, int slots)
	{
	ASSERT3S(idx + slots, <=, DNODES_PER_BLOCK);

	for (int i = idx; i < idx + slots; i++) {
	dnode_handle_t *dnh = &children->dnc_children[i];

	ASSERT(zrl_is_locked(&dnh->dnh_zrlock));

	if (DN_SLOT_IS_PTR(dnh->dnh_dnode)) {
	ASSERT3S(dnh->dnh_dnode->dn_type, ==, DMU_OT_NONE);
	dnode_destroy(dnh->dnh_dnode);
	dnh->dnh_dnode = DN_SLOT_FREE;
	}
	}
	}

	void
	dnode_free_interior_slots(dnode_t *dn)
	{
	dnode_children_t *children = dmu_buf_get_user(&dn->dn_dbuf->db);
	int epb = dn->dn_dbuf->db.db_size >> DNODE_SHIFT;
	int idx = (dn->dn_object & (epb - 1)) + 1;
	int slots = dn->dn_num_slots - 1;

	if (slots == 0)
	return;

	ASSERT3S(idx + slots, <=, DNODES_PER_BLOCK);

	while (!dnode_slots_tryenter(children, idx, slots)) {
	DNODE_STAT_BUMP(dnode_free_interior_lock_retry);
	cond_resched();
	}

	dnode_set_slots(children, idx, slots, DN_SLOT_FREE);
	dnode_slots_rele(children, idx, slots);
	}

	void
	dnode_special_close(dnode_handle_t *dnh)
	{
	dnode_t *dn = dnh->dnh_dnode;

	/*
	* Ensure dnode_rele_and_unlock() has released dn_mtx, after final
	* zfs_refcount_remove()
	*/
	mutex_enter(&dn->dn_mtx);
	if (zfs_refcount_count(&dn->dn_holds) > 0)
	cv_wait(&dn->dn_nodnholds, &dn->dn_mtx);
	mutex_exit(&dn->dn_mtx);
	ASSERT3U(zfs_refcount_count(&dn->dn_holds), ==, 0);

	ASSERT(dn->dn_dbuf == NULL \|\|
	dmu_buf_get_user(&dn->dn_dbuf->db) == NULL);
	zrl_add(&dnh->dnh_zrlock);
	dnode_destroy(dn); /* implicit zrl_remove() */
	zrl_destroy(&dnh->dnh_zrlock);
	dnh->dnh_dnode = NULL;
	}

	void
	dnode_special_open(objset_t os, dnode_phys_t dnp, uint64_t object,
	dnode_handle_t *dnh)
	{
	dnode_t *dn;

	zrl_init(&dnh->dnh_zrlock);
	VERIFY3U(1, ==, zrl_tryenter(&dnh->dnh_zrlock));

	dn = dnode_create(os, dnp, NULL, object, dnh);
	DNODE_VERIFY(dn);

	zrl_exit(&dnh->dnh_zrlock);
	}

	static void
	dnode_buf_evict_async(void *dbu)
	{
	dnode_children_t *dnc = dbu;

	DNODE_STAT_BUMP(dnode_buf_evict);

	for (int i = 0; i < dnc->dnc_count; i++) {
	dnode_handle_t *dnh = &dnc->dnc_children[i];
	dnode_t *dn;

	/*
	* The dnode handle lock guards against the dnode moving to
	* another valid address, so there is no need here to guard
	* against changes to or from NULL.
	*/
	if (!DN_SLOT_IS_PTR(dnh->dnh_dnode)) {
	zrl_destroy(&dnh->dnh_zrlock);
	dnh->dnh_dnode = DN_SLOT_UNINIT;
	continue;
	}

	zrl_add(&dnh->dnh_zrlock);
	dn = dnh->dnh_dnode;
	/*
	* If there are holds on this dnode, then there should
	* be holds on the dnode's containing dbuf as well; thus
	* it wouldn't be eligible for eviction and this function
	* would not have been called.
	*/
	ASSERT(zfs_refcount_is_zero(&dn->dn_holds));
	ASSERT(zfs_refcount_is_zero(&dn->dn_tx_holds));

	dnode_destroy(dn); /* implicit zrl_remove() for first slot */
	zrl_destroy(&dnh->dnh_zrlock);
	dnh->dnh_dnode = DN_SLOT_UNINIT;
	}
	kmem_free(dnc, sizeof (dnode_children_t) +
	dnc->dnc_count * sizeof (dnode_handle_t));
	}

	/*
	* When the DNODE_MUST_BE_FREE flag is set, the "slots" parameter is used
	* to ensure the hole at the specified object offset is large enough to
	* hold the dnode being created. The slots parameter is also used to ensure
	* a dnode does not span multiple dnode blocks. In both of these cases, if
	* a failure occurs, ENOSPC is returned. Keep in mind, these failure cases
	* are only possible when using DNODE_MUST_BE_FREE.
	*
	* If the DNODE_MUST_BE_ALLOCATED flag is set, "slots" must be 0.
	* dnode_hold_impl() will check if the requested dnode is already consumed
	* as an extra dnode slot by an large dnode, in which case it returns
	* ENOENT.
	*
	* If the DNODE_DRY_RUN flag is set, we don't actually hold the dnode, just
	* return whether the hold would succeed or not. tag and dnp should set to
	* NULL in this case.
	*
	* errors:
	* EINVAL - Invalid object number or flags.
	* ENOSPC - Hole too small to fulfill "slots" request (DNODE_MUST_BE_FREE)
	* EEXIST - Refers to an allocated dnode (DNODE_MUST_BE_FREE)
	* - Refers to a freeing dnode (DNODE_MUST_BE_FREE)
	* - Refers to an interior dnode slot (DNODE_MUST_BE_ALLOCATED)
	* ENOENT - The requested dnode is not allocated (DNODE_MUST_BE_ALLOCATED)
	* - The requested dnode is being freed (DNODE_MUST_BE_ALLOCATED)
	* EIO - I/O error when reading the meta dnode dbuf.
	*
	* succeeds even for free dnodes.
	*/
	int
	dnode_hold_impl(objset_t *os, uint64_t object, int flag, int slots,
	void tag, dnode_t *dnp)
	{
	int epb, idx, err;
	int drop_struct_lock = FALSE;
	int type;
	uint64_t blk;
	dnode_t mdn, dn;
	dmu_buf_impl_t *db;
	dnode_children_t *dnc;
	dnode_phys_t *dn_block;
	dnode_handle_t *dnh;

	ASSERT(!(flag & DNODE_MUST_BE_ALLOCATED) \|\| (slots == 0));
	ASSERT(!(flag & DNODE_MUST_BE_FREE) \|\| (slots > 0));
	IMPLY(flag & DNODE_DRY_RUN, (tag == NULL) && (dnp == NULL));

	/*
	* If you are holding the spa config lock as writer, you shouldn't
	* be asking the DMU to do anything unless it's the root pool
	* which may require us to read from the root filesystem while
	* holding some (not all) of the locks as writer.
	*/
	ASSERT(spa_config_held(os->os_spa, SCL_ALL, RW_WRITER) == 0 \|\|
	(spa_is_root(os->os_spa) &&
	spa_config_held(os->os_spa, SCL_STATE, RW_WRITER)));

	ASSERT((flag & DNODE_MUST_BE_ALLOCATED) \|\| (flag & DNODE_MUST_BE_FREE));

	if (object == DMU_USERUSED_OBJECT \|\| object == DMU_GROUPUSED_OBJECT \|\|
	object == DMU_PROJECTUSED_OBJECT) {
	if (object == DMU_USERUSED_OBJECT)
	dn = DMU_USERUSED_DNODE(os);
	else if (object == DMU_GROUPUSED_OBJECT)
	dn = DMU_GROUPUSED_DNODE(os);
	else
	dn = DMU_PROJECTUSED_DNODE(os);
	if (dn == NULL)
	return (SET_ERROR(ENOENT));
	type = dn->dn_type;
	if ((flag & DNODE_MUST_BE_ALLOCATED) && type == DMU_OT_NONE)
	return (SET_ERROR(ENOENT));
	if ((flag & DNODE_MUST_BE_FREE) && type != DMU_OT_NONE)
	return (SET_ERROR(EEXIST));
	DNODE_VERIFY(dn);
	/* Don't actually hold if dry run, just return 0 */
	if (!(flag & DNODE_DRY_RUN)) {
	(void) zfs_refcount_add(&dn->dn_holds, tag);
	*dnp = dn;
	}
	return (0);
	}

	if (object == 0 \|\| object >= DN_MAX_OBJECT)
	return (SET_ERROR(EINVAL));

	mdn = DMU_META_DNODE(os);
	ASSERT(mdn->dn_object == DMU_META_DNODE_OBJECT);

	DNODE_VERIFY(mdn);

	if (!RW_WRITE_HELD(&mdn->dn_struct_rwlock)) {
	rw_enter(&mdn->dn_struct_rwlock, RW_READER);
	drop_struct_lock = TRUE;
	}

	blk = dbuf_whichblock(mdn, 0, object * sizeof (dnode_phys_t));
	db = dbuf_hold(mdn, blk, FTAG);
	if (drop_struct_lock)
	rw_exit(&mdn->dn_struct_rwlock);
	if (db == NULL) {
	DNODE_STAT_BUMP(dnode_hold_dbuf_hold);
	return (SET_ERROR(EIO));
	}

	/*
	* We do not need to decrypt to read the dnode so it doesn't matter
	* if we get the encrypted or decrypted version.
	*/
	err = dbuf_read(db, NULL, DB_RF_CANFAIL \|
	DB_RF_NO_DECRYPT \| DB_RF_NOPREFETCH);
	if (err) {
	DNODE_STAT_BUMP(dnode_hold_dbuf_read);
	dbuf_rele(db, FTAG);
	return (err);
	}

	ASSERT3U(db->db.db_size, >=, 1<<DNODE_SHIFT);
	epb = db->db.db_size >> DNODE_SHIFT;

	idx = object & (epb - 1);
	dn_block = (dnode_phys_t *)db->db.db_data;

	ASSERT(DB_DNODE(db)->dn_type == DMU_OT_DNODE);
	dnc = dmu_buf_get_user(&db->db);
	dnh = NULL;
	if (dnc == NULL) {
	dnode_children_t *winner;
	int skip = 0;

	dnc = kmem_zalloc(sizeof (dnode_children_t) +
	epb * sizeof (dnode_handle_t), KM_SLEEP);
	dnc->dnc_count = epb;
	dnh = &dnc->dnc_children[0];

	/* Initialize dnode slot status from dnode_phys_t */
	for (int i = 0; i < epb; i++) {
	zrl_init(&dnh[i].dnh_zrlock);

	if (skip) {
	skip--;
	continue;
	}

	if (dn_block[i].dn_type != DMU_OT_NONE) {
	int interior = dn_block[i].dn_extra_slots;

	dnode_set_slots(dnc, i, 1, DN_SLOT_ALLOCATED);
	dnode_set_slots(dnc, i + 1, interior,
	DN_SLOT_INTERIOR);
	skip = interior;
	} else {
	dnh[i].dnh_dnode = DN_SLOT_FREE;
	skip = 0;
	}
	}

	dmu_buf_init_user(&dnc->dnc_dbu, NULL,
	dnode_buf_evict_async, NULL);
	winner = dmu_buf_set_user(&db->db, &dnc->dnc_dbu);
	if (winner != NULL) {

	for (int i = 0; i < epb; i++)
	zrl_destroy(&dnh[i].dnh_zrlock);

	kmem_free(dnc, sizeof (dnode_children_t) +
	epb * sizeof (dnode_handle_t));
	dnc = winner;
	}
	}

	ASSERT(dnc->dnc_count == epb);

	if (flag & DNODE_MUST_BE_ALLOCATED) {
	slots = 1;

	dnode_slots_hold(dnc, idx, slots);
	dnh = &dnc->dnc_children[idx];

	if (DN_SLOT_IS_PTR(dnh->dnh_dnode)) {
	dn = dnh->dnh_dnode;
	} else if (dnh->dnh_dnode == DN_SLOT_INTERIOR) {
	DNODE_STAT_BUMP(dnode_hold_alloc_interior);
	dnode_slots_rele(dnc, idx, slots);
	dbuf_rele(db, FTAG);
	return (SET_ERROR(EEXIST));
	} else if (dnh->dnh_dnode != DN_SLOT_ALLOCATED) {
	DNODE_STAT_BUMP(dnode_hold_alloc_misses);
	dnode_slots_rele(dnc, idx, slots);
	dbuf_rele(db, FTAG);
	return (SET_ERROR(ENOENT));
	} else {
	dnode_slots_rele(dnc, idx, slots);
	while (!dnode_slots_tryenter(dnc, idx, slots)) {
	DNODE_STAT_BUMP(dnode_hold_alloc_lock_retry);
	cond_resched();
	}

	/*
	* Someone else won the race and called dnode_create()
	* after we checked DN_SLOT_IS_PTR() above but before
	* we acquired the lock.
	*/
	if (DN_SLOT_IS_PTR(dnh->dnh_dnode)) {
	DNODE_STAT_BUMP(dnode_hold_alloc_lock_misses);
	dn = dnh->dnh_dnode;
	} else {
	dn = dnode_create(os, dn_block + idx, db,
	object, dnh);
	}
	}

	mutex_enter(&dn->dn_mtx);
	if (dn->dn_type == DMU_OT_NONE \|\| dn->dn_free_txg != 0) {
	DNODE_STAT_BUMP(dnode_hold_alloc_type_none);
	mutex_exit(&dn->dn_mtx);
	dnode_slots_rele(dnc, idx, slots);
	dbuf_rele(db, FTAG);
	return (SET_ERROR(ENOENT));
	}

	/* Don't actually hold if dry run, just return 0 */
	if (flag & DNODE_DRY_RUN) {
	mutex_exit(&dn->dn_mtx);
	dnode_slots_rele(dnc, idx, slots);
	dbuf_rele(db, FTAG);
	return (0);
	}

	DNODE_STAT_BUMP(dnode_hold_alloc_hits);
	} else if (flag & DNODE_MUST_BE_FREE) {

	if (idx + slots - 1 >= DNODES_PER_BLOCK) {
	DNODE_STAT_BUMP(dnode_hold_free_overflow);
	dbuf_rele(db, FTAG);
	return (SET_ERROR(ENOSPC));
	}

	dnode_slots_hold(dnc, idx, slots);

	if (!dnode_check_slots_free(dnc, idx, slots)) {
	DNODE_STAT_BUMP(dnode_hold_free_misses);
	dnode_slots_rele(dnc, idx, slots);
	dbuf_rele(db, FTAG);
	return (SET_ERROR(ENOSPC));
	}

	dnode_slots_rele(dnc, idx, slots);
	while (!dnode_slots_tryenter(dnc, idx, slots)) {
	DNODE_STAT_BUMP(dnode_hold_free_lock_retry);
	cond_resched();
	}

	if (!dnode_check_slots_free(dnc, idx, slots)) {
	DNODE_STAT_BUMP(dnode_hold_free_lock_misses);
	dnode_slots_rele(dnc, idx, slots);
	dbuf_rele(db, FTAG);
	return (SET_ERROR(ENOSPC));
	}

	/*
	* Allocated but otherwise free dnodes which would
	* be in the interior of a multi-slot dnodes need
	* to be freed. Single slot dnodes can be safely
	* re-purposed as a performance optimization.
	*/
	if (slots > 1)
	dnode_reclaim_slots(dnc, idx + 1, slots - 1);

	dnh = &dnc->dnc_children[idx];
	if (DN_SLOT_IS_PTR(dnh->dnh_dnode)) {
	dn = dnh->dnh_dnode;
	} else {
	dn = dnode_create(os, dn_block + idx, db,
	object, dnh);
	}

	mutex_enter(&dn->dn_mtx);
	if (!zfs_refcount_is_zero(&dn->dn_holds) \|\| dn->dn_free_txg) {
	DNODE_STAT_BUMP(dnode_hold_free_refcount);
	mutex_exit(&dn->dn_mtx);
	dnode_slots_rele(dnc, idx, slots);
	dbuf_rele(db, FTAG);
	return (SET_ERROR(EEXIST));
	}

	/* Don't actually hold if dry run, just return 0 */
	if (flag & DNODE_DRY_RUN) {
	mutex_exit(&dn->dn_mtx);
	dnode_slots_rele(dnc, idx, slots);
	dbuf_rele(db, FTAG);
	return (0);
	}

	dnode_set_slots(dnc, idx + 1, slots - 1, DN_SLOT_INTERIOR);
	DNODE_STAT_BUMP(dnode_hold_free_hits);
	} else {
	dbuf_rele(db, FTAG);
	return (SET_ERROR(EINVAL));
	}

	ASSERT0(dn->dn_free_txg);

	if (zfs_refcount_add(&dn->dn_holds, tag) == 1)
	dbuf_add_ref(db, dnh);

	mutex_exit(&dn->dn_mtx);

	/* Now we can rely on the hold to prevent the dnode from moving. */
	dnode_slots_rele(dnc, idx, slots);

	DNODE_VERIFY(dn);
	ASSERT3P(dnp, !=, NULL);
	ASSERT3P(dn->dn_dbuf, ==, db);
	ASSERT3U(dn->dn_object, ==, object);
	dbuf_rele(db, FTAG);

	*dnp = dn;
	return (0);
	}

	/*
	* Return held dnode if the object is allocated, NULL if not.
	*/
	int
	dnode_hold(objset_t os, uint64_t object, void tag, dnode_t **dnp)
	{
	return (dnode_hold_impl(os, object, DNODE_MUST_BE_ALLOCATED, 0, tag,
	dnp));
	}

	/*
	* Can only add a reference if there is already at least one
	* reference on the dnode. Returns FALSE if unable to add a
	* new reference.
	*/
	boolean_t
	dnode_add_ref(dnode_t dn, void tag)
	{
	mutex_enter(&dn->dn_mtx);
	if (zfs_refcount_is_zero(&dn->dn_holds)) {
	mutex_exit(&dn->dn_mtx);
	return (FALSE);
	}
	VERIFY(1 < zfs_refcount_add(&dn->dn_holds, tag));
	mutex_exit(&dn->dn_mtx);
	return (TRUE);
	}

	void
	dnode_rele(dnode_t dn, void tag)
	{
	mutex_enter(&dn->dn_mtx);
	dnode_rele_and_unlock(dn, tag, B_FALSE);
	}

	void
	dnode_rele_and_unlock(dnode_t dn, void tag, boolean_t evicting)
	{
	uint64_t refs;
	/* Get while the hold prevents the dnode from moving. */
	dmu_buf_impl_t *db = dn->dn_dbuf;
	dnode_handle_t *dnh = dn->dn_handle;

	refs = zfs_refcount_remove(&dn->dn_holds, tag);
	if (refs == 0)
	cv_broadcast(&dn->dn_nodnholds);
	mutex_exit(&dn->dn_mtx);
	/* dnode could get destroyed at this point, so don't use it anymore */

	/*
	* It's unsafe to release the last hold on a dnode by dnode_rele() or
	* indirectly by dbuf_rele() while relying on the dnode handle to
	* prevent the dnode from moving, since releasing the last hold could
	* result in the dnode's parent dbuf evicting its dnode handles. For
	* that reason anyone calling dnode_rele() or dbuf_rele() without some
	* other direct or indirect hold on the dnode must first drop the dnode
	* handle.
	*/
	ASSERT(refs > 0 \|\| dnh->dnh_zrlock.zr_owner != curthread);

	/* NOTE: the DNODE_DNODE does not have a dn_dbuf */
	if (refs == 0 && db != NULL) {
	/*
	* Another thread could add a hold to the dnode handle in
	* dnode_hold_impl() while holding the parent dbuf. Since the
	* hold on the parent dbuf prevents the handle from being
	* destroyed, the hold on the handle is OK. We can't yet assert
	* that the handle has zero references, but that will be
	* asserted anyway when the handle gets destroyed.
	*/
	mutex_enter(&db->db_mtx);
	dbuf_rele_and_unlock(db, dnh, evicting);
	}
	}

	/*
	* Test whether we can create a dnode at the specified location.
	*/
	int
	dnode_try_claim(objset_t *os, uint64_t object, int slots)
	{
	return (dnode_hold_impl(os, object, DNODE_MUST_BE_FREE \| DNODE_DRY_RUN,
	slots, NULL, NULL));
	}

	void
	dnode_setdirty(dnode_t dn, dmu_tx_t tx)
	{
	objset_t *os = dn->dn_objset;
	uint64_t txg = tx->tx_txg;

	if (DMU_OBJECT_IS_SPECIAL(dn->dn_object)) {
	dsl_dataset_dirty(os->os_dsl_dataset, tx);
	return;
	}

	DNODE_VERIFY(dn);

	#ifdef ZFS_DEBUG
	mutex_enter(&dn->dn_mtx);
	ASSERT(dn->dn_phys->dn_type \|\| dn->dn_allocated_txg);
	ASSERT(dn->dn_free_txg == 0 \|\| dn->dn_free_txg >= txg);
	mutex_exit(&dn->dn_mtx);
	#endif

	/*
	* Determine old uid/gid when necessary
	*/
	dmu_objset_userquota_get_ids(dn, B_TRUE, tx);

	multilist_t *dirtylist = os->os_dirty_dnodes[txg & TXG_MASK];
	multilist_sublist_t *mls = multilist_sublist_lock_obj(dirtylist, dn);

	/*
	* If we are already marked dirty, we're done.
	*/
	if (multilist_link_active(&dn->dn_dirty_link[txg & TXG_MASK])) {
	multilist_sublist_unlock(mls);
	return;
	}

	ASSERT(!zfs_refcount_is_zero(&dn->dn_holds) \|\|
	!avl_is_empty(&dn->dn_dbufs));
	ASSERT(dn->dn_datablksz != 0);
	ASSERT0(dn->dn_next_bonuslen[txg & TXG_MASK]);
	ASSERT0(dn->dn_next_blksz[txg & TXG_MASK]);
	ASSERT0(dn->dn_next_bonustype[txg & TXG_MASK]);

	dprintf_ds(os->os_dsl_dataset, "obj=%llu txg=%llu\n",
	dn->dn_object, txg);

	multilist_sublist_insert_head(mls, dn);

	multilist_sublist_unlock(mls);

	/*
	* The dnode maintains a hold on its containing dbuf as
	* long as there are holds on it. Each instantiated child
	* dbuf maintains a hold on the dnode. When the last child
	* drops its hold, the dnode will drop its hold on the
	* containing dbuf. We add a "dirty hold" here so that the
	* dnode will hang around after we finish processing its
	* children.
	*/
	VERIFY(dnode_add_ref(dn, (void *)(uintptr_t)tx->tx_txg));

	(void) dbuf_dirty(dn->dn_dbuf, tx);

	dsl_dataset_dirty(os->os_dsl_dataset, tx);
	}

	void
	dnode_free(dnode_t dn, dmu_tx_t tx)
	{
	mutex_enter(&dn->dn_mtx);
	if (dn->dn_type == DMU_OT_NONE \|\| dn->dn_free_txg) {
	mutex_exit(&dn->dn_mtx);
	return;
	}
	dn->dn_free_txg = tx->tx_txg;
	mutex_exit(&dn->dn_mtx);

	dnode_setdirty(dn, tx);
	}

	/*
	* Try to change the block size for the indicated dnode. This can only
	* succeed if there are no blocks allocated or dirty beyond first block
	*/
	int
	dnode_set_blksz(dnode_t dn, uint64_t size, int ibs, dmu_tx_t tx)
	{
	dmu_buf_impl_t *db;
	int err;

	ASSERT3U(size, <=, spa_maxblocksize(dmu_objset_spa(dn->dn_objset)));
	if (size == 0)
	size = SPA_MINBLOCKSIZE;
	else
	size = P2ROUNDUP(size, SPA_MINBLOCKSIZE);

	if (ibs == dn->dn_indblkshift)
	ibs = 0;

	if (size >> SPA_MINBLOCKSHIFT == dn->dn_datablkszsec && ibs == 0)
	return (0);

	rw_enter(&dn->dn_struct_rwlock, RW_WRITER);

	/* Check for any allocated blocks beyond the first */
	if (dn->dn_maxblkid != 0)
	goto fail;

	mutex_enter(&dn->dn_dbufs_mtx);
	for (db = avl_first(&dn->dn_dbufs); db != NULL;
	db = AVL_NEXT(&dn->dn_dbufs, db)) {
	if (db->db_blkid != 0 && db->db_blkid != DMU_BONUS_BLKID &&
	db->db_blkid != DMU_SPILL_BLKID) {
	mutex_exit(&dn->dn_dbufs_mtx);
	goto fail;
	}
	}
	mutex_exit(&dn->dn_dbufs_mtx);

	if (ibs && dn->dn_nlevels != 1)
	goto fail;

	/* resize the old block */
	err = dbuf_hold_impl(dn, 0, 0, TRUE, FALSE, FTAG, &db);
	if (err == 0) {
	dbuf_new_size(db, size, tx);
	} else if (err != ENOENT) {
	goto fail;
	}

	dnode_setdblksz(dn, size);
	dnode_setdirty(dn, tx);
	dn->dn_next_blksz[tx->tx_txg&TXG_MASK] = size;
	if (ibs) {
	dn->dn_indblkshift = ibs;
	dn->dn_next_indblkshift[tx->tx_txg&TXG_MASK] = ibs;
	}
	/* release after we have fixed the blocksize in the dnode */
	if (db)
	dbuf_rele(db, FTAG);

	rw_exit(&dn->dn_struct_rwlock);
	return (0);

	fail:
	rw_exit(&dn->dn_struct_rwlock);
	return (SET_ERROR(ENOTSUP));
	}

	static void
	dnode_set_nlevels_impl(dnode_t dn, int new_nlevels, dmu_tx_t tx)
	{
	uint64_t txgoff = tx->tx_txg & TXG_MASK;
	int old_nlevels = dn->dn_nlevels;
	dmu_buf_impl_t *db;
	list_t *list;
	dbuf_dirty_record_t new, dr, *dr_next;

	ASSERT(RW_WRITE_HELD(&dn->dn_struct_rwlock));

	ASSERT3U(new_nlevels, >, dn->dn_nlevels);
	dn->dn_nlevels = new_nlevels;

	ASSERT3U(new_nlevels, >, dn->dn_next_nlevels[txgoff]);
	dn->dn_next_nlevels[txgoff] = new_nlevels;

	/* dirty the left indirects */
	db = dbuf_hold_level(dn, old_nlevels, 0, FTAG);
	ASSERT(db != NULL);
	new = dbuf_dirty(db, tx);
	dbuf_rele(db, FTAG);

	/* transfer the dirty records to the new indirect */
	mutex_enter(&dn->dn_mtx);
	mutex_enter(&new->dt.di.dr_mtx);
	list = &dn->dn_dirty_records[txgoff];
	for (dr = list_head(list); dr; dr = dr_next) {
	dr_next = list_next(&dn->dn_dirty_records[txgoff], dr);

	IMPLY(dr->dr_dbuf == NULL, old_nlevels == 1);
	if (dr->dr_dbuf == NULL \|\|
	(dr->dr_dbuf->db_level == old_nlevels - 1 &&
	dr->dr_dbuf->db_blkid != DMU_BONUS_BLKID &&
	dr->dr_dbuf->db_blkid != DMU_SPILL_BLKID)) {
	list_remove(&dn->dn_dirty_records[txgoff], dr);
	list_insert_tail(&new->dt.di.dr_children, dr);
	dr->dr_parent = new;
	}
	}
	mutex_exit(&new->dt.di.dr_mtx);
	mutex_exit(&dn->dn_mtx);
	}

	int
	dnode_set_nlevels(dnode_t dn, int nlevels, dmu_tx_t tx)
	{
	int ret = 0;

	rw_enter(&dn->dn_struct_rwlock, RW_WRITER);

	if (dn->dn_nlevels == nlevels) {
	ret = 0;
	goto out;
	} else if (nlevels < dn->dn_nlevels) {
	ret = SET_ERROR(EINVAL);
	goto out;
	}

	dnode_set_nlevels_impl(dn, nlevels, tx);

	out:
	rw_exit(&dn->dn_struct_rwlock);
	return (ret);
	}

	/* read-holding callers must not rely on the lock being continuously held */
	void
	dnode_new_blkid(dnode_t dn, uint64_t blkid, dmu_tx_t tx, boolean_t have_read,
	boolean_t force)
	{
	int epbs, new_nlevels;
	uint64_t sz;

	ASSERT(blkid != DMU_BONUS_BLKID);

	ASSERT(have_read ?
	RW_READ_HELD(&dn->dn_struct_rwlock) :
	RW_WRITE_HELD(&dn->dn_struct_rwlock));

	/*
	* if we have a read-lock, check to see if we need to do any work
	* before upgrading to a write-lock.
	*/
	if (have_read) {
	if (blkid <= dn->dn_maxblkid)
	return;

	if (!rw_tryupgrade(&dn->dn_struct_rwlock)) {
	rw_exit(&dn->dn_struct_rwlock);
	rw_enter(&dn->dn_struct_rwlock, RW_WRITER);
	}
	}

	/*
	* Raw sends (indicated by the force flag) require that we take the
	* given blkid even if the value is lower than the current value.
	*/
	if (!force && blkid <= dn->dn_maxblkid)
	goto out;

	/*
	* We use the (otherwise unused) top bit of dn_next_maxblkid[txgoff]
	* to indicate that this field is set. This allows us to set the
	* maxblkid to 0 on an existing object in dnode_sync().
	*/
	dn->dn_maxblkid = blkid;
	dn->dn_next_maxblkid[tx->tx_txg & TXG_MASK] =
	blkid \| DMU_NEXT_MAXBLKID_SET;

	/*
	* Compute the number of levels necessary to support the new maxblkid.
	* Raw sends will ensure nlevels is set correctly for us.
	*/
	new_nlevels = 1;
	epbs = dn->dn_indblkshift - SPA_BLKPTRSHIFT;
	for (sz = dn->dn_nblkptr;
	sz <= blkid && sz >= dn->dn_nblkptr; sz <<= epbs)
	new_nlevels++;

	ASSERT3U(new_nlevels, <=, DN_MAX_LEVELS);

	if (!force) {
	if (new_nlevels > dn->dn_nlevels)
	dnode_set_nlevels_impl(dn, new_nlevels, tx);
	} else {
	ASSERT3U(dn->dn_nlevels, >=, new_nlevels);
	}

	out:
	if (have_read)
	rw_downgrade(&dn->dn_struct_rwlock);
	}

	static void
	dnode_dirty_l1(dnode_t dn, uint64_t l1blkid, dmu_tx_t tx)
	{
	dmu_buf_impl_t *db = dbuf_hold_level(dn, 1, l1blkid, FTAG);
	if (db != NULL) {
	dmu_buf_will_dirty(&db->db, tx);
	dbuf_rele(db, FTAG);
	}
	}

	/*
	* Dirty all the in-core level-1 dbufs in the range specified by start_blkid
	* and end_blkid.
	*/
	static void
	dnode_dirty_l1range(dnode_t *dn, uint64_t start_blkid, uint64_t end_blkid,
	dmu_tx_t *tx)
	{
	dmu_buf_impl_t *db_search;
	dmu_buf_impl_t *db;
	avl_index_t where;

	db_search = kmem_zalloc(sizeof (dmu_buf_impl_t), KM_SLEEP);

	mutex_enter(&dn->dn_dbufs_mtx);

	db_search->db_level = 1;
	db_search->db_blkid = start_blkid + 1;
	db_search->db_state = DB_SEARCH;
	for (;;) {

	db = avl_find(&dn->dn_dbufs, db_search, &where);
	if (db == NULL)
	db = avl_nearest(&dn->dn_dbufs, where, AVL_AFTER);

	if (db == NULL \|\| db->db_level != 1 \|\|
	db->db_blkid >= end_blkid) {
	break;
	}

	/*
	* Setup the next blkid we want to search for.
	*/
	db_search->db_blkid = db->db_blkid + 1;
	ASSERT3U(db->db_blkid, >=, start_blkid);

	/*
	* If the dbuf transitions to DB_EVICTING while we're trying
	* to dirty it, then we will be unable to discover it in
	* the dbuf hash table. This will result in a call to
	* dbuf_create() which needs to acquire the dn_dbufs_mtx
	* lock. To avoid a deadlock, we drop the lock before
	* dirtying the level-1 dbuf.
	*/
	mutex_exit(&dn->dn_dbufs_mtx);
	dnode_dirty_l1(dn, db->db_blkid, tx);
	mutex_enter(&dn->dn_dbufs_mtx);
	}

	#ifdef ZFS_DEBUG
	/*
	* Walk all the in-core level-1 dbufs and verify they have been dirtied.
	*/
	db_search->db_level = 1;
	db_search->db_blkid = start_blkid + 1;
	db_search->db_state = DB_SEARCH;
	db = avl_find(&dn->dn_dbufs, db_search, &where);
	if (db == NULL)
	db = avl_nearest(&dn->dn_dbufs, where, AVL_AFTER);
	for (; db != NULL; db = AVL_NEXT(&dn->dn_dbufs, db)) {
	if (db->db_level != 1 \|\| db->db_blkid >= end_blkid)
	break;
	if (db->db_state != DB_EVICTING)
	ASSERT(db->db_dirtycnt > 0);
	}
	#endif
	kmem_free(db_search, sizeof (dmu_buf_impl_t));
	mutex_exit(&dn->dn_dbufs_mtx);
	}

	void
	dnode_set_dirtyctx(dnode_t dn, dmu_tx_t tx, void *tag)
	{
	/*
	* Don't set dirtyctx to SYNC if we're just modifying this as we
	* initialize the objset.
	*/
	if (dn->dn_dirtyctx == DN_UNDIRTIED) {
	dsl_dataset_t *ds = dn->dn_objset->os_dsl_dataset;

	if (ds != NULL) {
	rrw_enter(&ds->ds_bp_rwlock, RW_READER, tag);
	}
	if (!BP_IS_HOLE(dn->dn_objset->os_rootbp)) {
	if (dmu_tx_is_syncing(tx))
	dn->dn_dirtyctx = DN_DIRTY_SYNC;
	else
	dn->dn_dirtyctx = DN_DIRTY_OPEN;
	dn->dn_dirtyctx_firstset = tag;
	}
	if (ds != NULL) {
	rrw_exit(&ds->ds_bp_rwlock, tag);
	}
	}
	}

	void
	dnode_free_range(dnode_t dn, uint64_t off, uint64_t len, dmu_tx_t tx)
	{
	dmu_buf_impl_t *db;
	uint64_t blkoff, blkid, nblks;
	int blksz, blkshift, head, tail;
	int trunc = FALSE;
	int epbs;

	blksz = dn->dn_datablksz;
	blkshift = dn->dn_datablkshift;
	epbs = dn->dn_indblkshift - SPA_BLKPTRSHIFT;

	if (len == DMU_OBJECT_END) {
	len = UINT64_MAX - off;
	trunc = TRUE;
	}

	/*
	* First, block align the region to free:
	*/
	if (ISP2(blksz)) {
	head = P2NPHASE(off, blksz);
	blkoff = P2PHASE(off, blksz);
	if ((off >> blkshift) > dn->dn_maxblkid)
	return;
	} else {
	ASSERT(dn->dn_maxblkid == 0);
	if (off == 0 && len >= blksz) {
	/*
	* Freeing the whole block; fast-track this request.
	*/
	blkid = 0;
	nblks = 1;
	if (dn->dn_nlevels > 1) {
	rw_enter(&dn->dn_struct_rwlock, RW_WRITER);
	dnode_dirty_l1(dn, 0, tx);
	rw_exit(&dn->dn_struct_rwlock);
	}
	goto done;
	} else if (off >= blksz) {
	/* Freeing past end-of-data */
	return;
	} else {
	/* Freeing part of the block. */
	head = blksz - off;
	ASSERT3U(head, >, 0);
	}
	blkoff = off;
	}
	/* zero out any partial block data at the start of the range */
	if (head) {
	int res;
	ASSERT3U(blkoff + head, ==, blksz);
	if (len < head)
	head = len;
	rw_enter(&dn->dn_struct_rwlock, RW_READER);
	res = dbuf_hold_impl(dn, 0, dbuf_whichblock(dn, 0, off),
	TRUE, FALSE, FTAG, &db);
	rw_exit(&dn->dn_struct_rwlock);
	if (res == 0) {
	caddr_t data;
	boolean_t dirty;

	db_lock_type_t dblt = dmu_buf_lock_parent(db, RW_READER,
	FTAG);
	/* don't dirty if it isn't on disk and isn't dirty */
	dirty = !list_is_empty(&db->db_dirty_records) \|\|
	(db->db_blkptr && !BP_IS_HOLE(db->db_blkptr));
	dmu_buf_unlock_parent(db, dblt, FTAG);
	if (dirty) {
	dmu_buf_will_dirty(&db->db, tx);
	data = db->db.db_data;
	bzero(data + blkoff, head);
	}
	dbuf_rele(db, FTAG);
	}
	off += head;
	len -= head;
	}

	/* If the range was less than one block, we're done */
	if (len == 0)
	return;

	/* If the remaining range is past end of file, we're done */
	if ((off >> blkshift) > dn->dn_maxblkid)
	return;

	ASSERT(ISP2(blksz));
	if (trunc)
	tail = 0;
	else
	tail = P2PHASE(len, blksz);

	ASSERT0(P2PHASE(off, blksz));
	/* zero out any partial block data at the end of the range */
	if (tail) {
	int res;
	if (len < tail)
	tail = len;
	rw_enter(&dn->dn_struct_rwlock, RW_READER);
	res = dbuf_hold_impl(dn, 0, dbuf_whichblock(dn, 0, off+len),
	TRUE, FALSE, FTAG, &db);
	rw_exit(&dn->dn_struct_rwlock);
	if (res == 0) {
	boolean_t dirty;
	/* don't dirty if not on disk and not dirty */
	db_lock_type_t type = dmu_buf_lock_parent(db, RW_READER,
	FTAG);
	dirty = !list_is_empty(&db->db_dirty_records) \|\|
	(db->db_blkptr && !BP_IS_HOLE(db->db_blkptr));
	dmu_buf_unlock_parent(db, type, FTAG);
	if (dirty) {
	dmu_buf_will_dirty(&db->db, tx);
	bzero(db->db.db_data, tail);
	}
	dbuf_rele(db, FTAG);
	}
	len -= tail;
	}

	/* If the range did not include a full block, we are done */
	if (len == 0)
	return;

	ASSERT(IS_P2ALIGNED(off, blksz));
	ASSERT(trunc \|\| IS_P2ALIGNED(len, blksz));
	blkid = off >> blkshift;
	nblks = len >> blkshift;
	if (trunc)
	nblks += 1;

	/*
	* Dirty all the indirect blocks in this range. Note that only
	* the first and last indirect blocks can actually be written
	* (if they were partially freed) -- they must be dirtied, even if
	* they do not exist on disk yet. The interior blocks will
	* be freed by free_children(), so they will not actually be written.
	* Even though these interior blocks will not be written, we
	* dirty them for two reasons:
	*
	* - It ensures that the indirect blocks remain in memory until
	* syncing context. (They have already been prefetched by
	* dmu_tx_hold_free(), so we don't have to worry about reading
	* them serially here.)
	*
	* - The dirty space accounting will put pressure on the txg sync
	* mechanism to begin syncing, and to delay transactions if there
	* is a large amount of freeing. Even though these indirect
	* blocks will not be written, we could need to write the same
	* amount of space if we copy the freed BPs into deadlists.
	*/
	if (dn->dn_nlevels > 1) {
	rw_enter(&dn->dn_struct_rwlock, RW_WRITER);
	uint64_t first, last;

	first = blkid >> epbs;
	dnode_dirty_l1(dn, first, tx);
	if (trunc)
	last = dn->dn_maxblkid >> epbs;
	else
	last = (blkid + nblks - 1) >> epbs;
	if (last != first)
	dnode_dirty_l1(dn, last, tx);

	dnode_dirty_l1range(dn, first, last, tx);

	int shift = dn->dn_datablkshift + dn->dn_indblkshift -
	SPA_BLKPTRSHIFT;
	for (uint64_t i = first + 1; i < last; i++) {
	/*
	* Set i to the blockid of the next non-hole
	* level-1 indirect block at or after i. Note
	* that dnode_next_offset() operates in terms of
	* level-0-equivalent bytes.
	*/
	uint64_t ibyte = i << shift;
	int err = dnode_next_offset(dn, DNODE_FIND_HAVELOCK,
	&ibyte, 2, 1, 0);
	i = ibyte >> shift;
	if (i >= last)
	break;

	/*
	* Normally we should not see an error, either
	* from dnode_next_offset() or dbuf_hold_level()
	* (except for ESRCH from dnode_next_offset).
	* If there is an i/o error, then when we read
	* this block in syncing context, it will use
	* ZIO_FLAG_MUSTSUCCEED, and thus hang/panic according
	* to the "failmode" property. dnode_next_offset()
	* doesn't have a flag to indicate MUSTSUCCEED.
	*/
	if (err != 0)
	break;

	dnode_dirty_l1(dn, i, tx);
	}
	rw_exit(&dn->dn_struct_rwlock);
	}

	done:
	/*
	* Add this range to the dnode range list.
	* We will finish up this free operation in the syncing phase.
	*/
	mutex_enter(&dn->dn_mtx);
	{
	int txgoff = tx->tx_txg & TXG_MASK;
	if (dn->dn_free_ranges[txgoff] == NULL) {
	dn->dn_free_ranges[txgoff] = range_tree_create(NULL,
	RANGE_SEG64, NULL, 0, 0);
	}
	range_tree_clear(dn->dn_free_ranges[txgoff], blkid, nblks);
	range_tree_add(dn->dn_free_ranges[txgoff], blkid, nblks);
	}
	dprintf_dnode(dn, "blkid=%llu nblks=%llu txg=%llu\n",
	blkid, nblks, tx->tx_txg);
	mutex_exit(&dn->dn_mtx);

	dbuf_free_range(dn, blkid, blkid + nblks - 1, tx);
	dnode_setdirty(dn, tx);
	}

	static boolean_t
	dnode_spill_freed(dnode_t *dn)
	{
	int i;

	mutex_enter(&dn->dn_mtx);
	for (i = 0; i < TXG_SIZE; i++) {
	if (dn->dn_rm_spillblk[i] == DN_KILL_SPILLBLK)
	break;
	}
	mutex_exit(&dn->dn_mtx);
	return (i < TXG_SIZE);
	}

	/* return TRUE if this blkid was freed in a recent txg, or FALSE if it wasn't */
	uint64_t
	dnode_block_freed(dnode_t *dn, uint64_t blkid)
	{
	void *dp = spa_get_dsl(dn->dn_objset->os_spa);
	int i;

	if (blkid == DMU_BONUS_BLKID)
	return (FALSE);

	/*
	* If we're in the process of opening the pool, dp will not be
	* set yet, but there shouldn't be anything dirty.
	*/
	if (dp == NULL)
	return (FALSE);

	if (dn->dn_free_txg)
	return (TRUE);

	if (blkid == DMU_SPILL_BLKID)
	return (dnode_spill_freed(dn));

	mutex_enter(&dn->dn_mtx);
	for (i = 0; i < TXG_SIZE; i++) {
	if (dn->dn_free_ranges[i] != NULL &&
	range_tree_contains(dn->dn_free_ranges[i], blkid, 1))
	break;
	}
	mutex_exit(&dn->dn_mtx);
	return (i < TXG_SIZE);
	}

	/* call from syncing context when we actually write/free space for this dnode */
	void
	dnode_diduse_space(dnode_t *dn, int64_t delta)
	{
	uint64_t space;
	dprintf_dnode(dn, "dn=%p dnp=%p used=%llu delta=%lld\n",
	dn, dn->dn_phys,
	(u_longlong_t)dn->dn_phys->dn_used,
	(longlong_t)delta);

	mutex_enter(&dn->dn_mtx);
	space = DN_USED_BYTES(dn->dn_phys);
	if (delta > 0) {
	ASSERT3U(space + delta, >=, space); /* no overflow */
	} else {
	ASSERT3U(space, >=, -delta); /* no underflow */
	}
	space += delta;
	if (spa_version(dn->dn_objset->os_spa) < SPA_VERSION_DNODE_BYTES) {
	ASSERT((dn->dn_phys->dn_flags & DNODE_FLAG_USED_BYTES) == 0);
	ASSERT0(P2PHASE(space, 1<<DEV_BSHIFT));
	dn->dn_phys->dn_used = space >> DEV_BSHIFT;
	} else {
	dn->dn_phys->dn_used = space;
	dn->dn_phys->dn_flags \|= DNODE_FLAG_USED_BYTES;
	}
	mutex_exit(&dn->dn_mtx);
	}

	/*
	* Scans a block at the indicated "level" looking for a hole or data,
	* depending on 'flags'.
	*
	* If level > 0, then we are scanning an indirect block looking at its
	* pointers. If level == 0, then we are looking at a block of dnodes.
	*
	* If we don't find what we are looking for in the block, we return ESRCH.
	* Otherwise, return with *offset pointing to the beginning (if searching
	* forwards) or end (if searching backwards) of the range covered by the
	* block pointer we matched on (or dnode).
	*
	* The basic search algorithm used below by dnode_next_offset() is to
	* use this function to search up the block tree (widen the search) until
	* we find something (i.e., we don't return ESRCH) and then search back
	* down the tree (narrow the search) until we reach our original search
	* level.
	*/
	static int
	dnode_next_offset_level(dnode_t dn, int flags, uint64_t offset,
	int lvl, uint64_t blkfill, uint64_t txg)
	{
	dmu_buf_impl_t *db = NULL;
	void *data = NULL;
	uint64_t epbs = dn->dn_phys->dn_indblkshift - SPA_BLKPTRSHIFT;
	uint64_t epb = 1ULL << epbs;
	uint64_t minfill, maxfill;
	boolean_t hole;
	int i, inc, error, span;

	ASSERT(RW_LOCK_HELD(&dn->dn_struct_rwlock));

	hole = ((flags & DNODE_FIND_HOLE) != 0);
	inc = (flags & DNODE_FIND_BACKWARDS) ? -1 : 1;
	ASSERT(txg == 0 \|\| !hole);

	if (lvl == dn->dn_phys->dn_nlevels) {
	error = 0;
	epb = dn->dn_phys->dn_nblkptr;
	data = dn->dn_phys->dn_blkptr;
	} else {
	uint64_t blkid = dbuf_whichblock(dn, lvl, *offset);
	error = dbuf_hold_impl(dn, lvl, blkid, TRUE, FALSE, FTAG, &db);
	if (error) {
	if (error != ENOENT)
	return (error);
	if (hole)
	return (0);
	/*
	* This can only happen when we are searching up
	* the block tree for data. We don't really need to
	* adjust the offset, as we will just end up looking
	* at the pointer to this block in its parent, and its
	* going to be unallocated, so we will skip over it.
	*/
	return (SET_ERROR(ESRCH));
	}
	error = dbuf_read(db, NULL,
	DB_RF_CANFAIL \| DB_RF_HAVESTRUCT \|
	DB_RF_NO_DECRYPT \| DB_RF_NOPREFETCH);
	if (error) {
	dbuf_rele(db, FTAG);
	return (error);
	}
	data = db->db.db_data;
	rw_enter(&db->db_rwlock, RW_READER);
	}

	if (db != NULL && txg != 0 && (db->db_blkptr == NULL \|\|
	db->db_blkptr->blk_birth <= txg \|\|
	BP_IS_HOLE(db->db_blkptr))) {
	/*
	* This can only happen when we are searching up the tree
	* and these conditions mean that we need to keep climbing.
	*/
	error = SET_ERROR(ESRCH);
	} else if (lvl == 0) {
	dnode_phys_t *dnp = data;

	ASSERT(dn->dn_type == DMU_OT_DNODE);
	ASSERT(!(flags & DNODE_FIND_BACKWARDS));

	for (i = (*offset >> DNODE_SHIFT) & (blkfill - 1);
	i < blkfill; i += dnp[i].dn_extra_slots + 1) {
	if ((dnp[i].dn_type == DMU_OT_NONE) == hole)
	break;
	}

	if (i == blkfill)
	error = SET_ERROR(ESRCH);

	offset = (offset & ~(DNODE_BLOCK_SIZE - 1)) +
	(i << DNODE_SHIFT);
	} else {
	blkptr_t *bp = data;
	uint64_t start = *offset;
	span = (lvl - 1) * epbs + dn->dn_datablkshift;
	minfill = 0;
	maxfill = blkfill << ((lvl - 1) * epbs);

	if (hole)
	maxfill--;
	else
	minfill++;

	if (span >= 8 * sizeof (*offset)) {
	/* This only happens on the highest indirection level */
	ASSERT3U((lvl - 1), ==, dn->dn_phys->dn_nlevels - 1);
	*offset = 0;
	} else {
	offset = offset >> span;
	}

	for (i = BF64_GET(*offset, 0, epbs);
	i >= 0 && i < epb; i += inc) {
	if (BP_GET_FILL(&bp[i]) >= minfill &&
	BP_GET_FILL(&bp[i]) <= maxfill &&
	(hole \|\| bp[i].blk_birth > txg))
	break;
	if (inc > 0 \|\| *offset > 0)
	*offset += inc;
	}

	if (span >= 8 * sizeof (*offset)) {
	*offset = start;
	} else {
	offset = offset << span;
	}

	if (inc < 0) {
	/* traversing backwards; position offset at the end */
	ASSERT3U(*offset, <=, start);
	offset = MIN(offset + (1ULL << span) - 1, start);
	} else if (*offset < start) {
	*offset = start;
	}
	if (i < 0 \|\| i >= epb)
	error = SET_ERROR(ESRCH);
	}

	if (db != NULL) {
	rw_exit(&db->db_rwlock);
	dbuf_rele(db, FTAG);
	}

	return (error);
	}

	/*
	* Find the next hole, data, or sparse region at or after *offset.
	* The value 'blkfill' tells us how many items we expect to find
	* in an L0 data block; this value is 1 for normal objects,
	* DNODES_PER_BLOCK for the meta dnode, and some fraction of
	* DNODES_PER_BLOCK when searching for sparse regions thereof.
	*
	* Examples:
	*
	* dnode_next_offset(dn, flags, offset, 1, 1, 0);
	* Finds the next/previous hole/data in a file.
	* Used in dmu_offset_next().
	*
	* dnode_next_offset(mdn, flags, offset, 0, DNODES_PER_BLOCK, txg);
	* Finds the next free/allocated dnode an objset's meta-dnode.
	* Only finds objects that have new contents since txg (ie.
	* bonus buffer changes and content removal are ignored).
	* Used in dmu_object_next().
	*
	* dnode_next_offset(mdn, DNODE_FIND_HOLE, offset, 2, DNODES_PER_BLOCK >> 2, 0);
	* Finds the next L2 meta-dnode bp that's at most 1/4 full.
	* Used in dmu_object_alloc().
	*/
	int
	dnode_next_offset(dnode_t dn, int flags, uint64_t offset,
	int minlvl, uint64_t blkfill, uint64_t txg)
	{
	uint64_t initial_offset = *offset;
	int lvl, maxlvl;
	int error = 0;

	if (!(flags & DNODE_FIND_HAVELOCK))
	rw_enter(&dn->dn_struct_rwlock, RW_READER);

	if (dn->dn_phys->dn_nlevels == 0) {
	error = SET_ERROR(ESRCH);
	goto out;
	}

	if (dn->dn_datablkshift == 0) {
	if (*offset < dn->dn_datablksz) {
	if (flags & DNODE_FIND_HOLE)
	*offset = dn->dn_datablksz;
	} else {
	error = SET_ERROR(ESRCH);
	}
	goto out;
	}

	maxlvl = dn->dn_phys->dn_nlevels;

	for (lvl = minlvl; lvl <= maxlvl; lvl++) {
	error = dnode_next_offset_level(dn,
	flags, offset, lvl, blkfill, txg);
	if (error != ESRCH)
	break;
	}

	while (error == 0 && --lvl >= minlvl) {
	error = dnode_next_offset_level(dn,
	flags, offset, lvl, blkfill, txg);
	}

	/*
	* There's always a "virtual hole" at the end of the object, even
	* if all BP's which physically exist are non-holes.
	*/
	if ((flags & DNODE_FIND_HOLE) && error == ESRCH && txg == 0 &&
	minlvl == 1 && blkfill == 1 && !(flags & DNODE_FIND_BACKWARDS)) {
	error = 0;
	}

	if (error == 0 && (flags & DNODE_FIND_BACKWARDS ?
	initial_offset < offset : initial_offset > offset))
	error = SET_ERROR(ESRCH);
	out:
	if (!(flags & DNODE_FIND_HAVELOCK))
	rw_exit(&dn->dn_struct_rwlock);

	return (error);
	}

	#if defined(_KERNEL)
	EXPORT_SYMBOL(dnode_hold);
	EXPORT_SYMBOL(dnode_rele);
	EXPORT_SYMBOL(dnode_set_nlevels);
	EXPORT_SYMBOL(dnode_set_blksz);
	EXPORT_SYMBOL(dnode_free_range);
	EXPORT_SYMBOL(dnode_evict_dbufs);
	EXPORT_SYMBOL(dnode_evict_bonus);
	#endif
	diff --git a/sys/contrib/openzfs/module/zfs/dsl_bookmark.c b/sys/contrib/openzfs/module/zfs/dsl_bookmark.c
	index 2faf1af52991..bead7da2237f 100644
	--- a/sys/contrib/openzfs/module/zfs/dsl_bookmark.c
	+++ b/sys/contrib/openzfs/module/zfs/dsl_bookmark.c
	@@ -1,1734 +1,1734 @@
	/*
	* CDDL HEADER START
	*
	* This file and its contents are supplied under the terms of the
	* Common Development and Distribution License ("CDDL"), version 1.0.
	* You may only use this file in accordance with the terms of version
	* 1.0 of the CDDL.
	*
	* A full copy of the text of the CDDL should have accompanied this
	* source. A copy of the CDDL is also available via the Internet at
	* http://www.illumos.org/license/CDDL.
	*
	* CDDL HEADER END
	*/

	/*
	* Copyright (c) 2013, 2018 by Delphix. All rights reserved.
	* Copyright 2017 Nexenta Systems, Inc.
	* Copyright 2019, 2020 by Christian Schwarz. All rights reserved.
	*/

	#include <sys/zfs_context.h>
	#include <sys/dsl_dataset.h>
	#include <sys/dsl_dir.h>
	#include <sys/dsl_prop.h>
	#include <sys/dsl_synctask.h>
	#include <sys/dsl_destroy.h>
	#include <sys/dmu_impl.h>
	#include <sys/dmu_tx.h>
	#include <sys/arc.h>
	#include <sys/zap.h>
	#include <sys/zfeature.h>
	#include <sys/spa.h>
	#include <sys/dsl_bookmark.h>
	#include <zfs_namecheck.h>
	#include <sys/dmu_send.h>

	static int
	dsl_bookmark_hold_ds(dsl_pool_t dp, const char fullname,
	dsl_dataset_t *dsp, void tag, char **shortnamep)
	{
	char buf[ZFS_MAX_DATASET_NAME_LEN];
	char *hashp;

	if (strlen(fullname) >= ZFS_MAX_DATASET_NAME_LEN)
	return (SET_ERROR(ENAMETOOLONG));
	hashp = strchr(fullname, '#');
	if (hashp == NULL)
	return (SET_ERROR(EINVAL));

	*shortnamep = hashp + 1;
	if (zfs_component_namecheck(*shortnamep, NULL, NULL))
	return (SET_ERROR(EINVAL));
	(void) strlcpy(buf, fullname, hashp - fullname + 1);
	return (dsl_dataset_hold(dp, buf, tag, dsp));
	}

	/*
	* When reading BOOKMARK_V1 bookmarks, the BOOKMARK_V2 fields are guaranteed
	* to be zeroed.
	*
	* Returns ESRCH if bookmark is not found.
	* Note, we need to use the ZAP rather than the AVL to look up bookmarks
	* by name, because only the ZAP honors the casesensitivity setting.
	*/
	int
	dsl_bookmark_lookup_impl(dsl_dataset_t ds, const char shortname,
	zfs_bookmark_phys_t *bmark_phys)
	{
	objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
	uint64_t bmark_zapobj = ds->ds_bookmarks_obj;
	matchtype_t mt = 0;
	int err;

	if (bmark_zapobj == 0)
	return (SET_ERROR(ESRCH));

	if (dsl_dataset_phys(ds)->ds_flags & DS_FLAG_CI_DATASET)
	mt = MT_NORMALIZE;

	/*
	* Zero out the bookmark in case the one stored on disk
	* is in an older, shorter format.
	*/
	bzero(bmark_phys, sizeof (*bmark_phys));

	err = zap_lookup_norm(mos, bmark_zapobj, shortname, sizeof (uint64_t),
	sizeof (*bmark_phys) / sizeof (uint64_t), bmark_phys, mt, NULL, 0,
	NULL);

	return (err == ENOENT ? SET_ERROR(ESRCH) : err);
	}

	/*
	* If later_ds is non-NULL, this will return EXDEV if the specified bookmark
	* does not represents an earlier point in later_ds's timeline. However,
	* bmp will still be filled in if we return EXDEV.
	*
	* Returns ENOENT if the dataset containing the bookmark does not exist.
	* Returns ESRCH if the dataset exists but the bookmark was not found in it.
	*/
	int
	dsl_bookmark_lookup(dsl_pool_t dp, const char fullname,
	dsl_dataset_t later_ds, zfs_bookmark_phys_t bmp)
	{
	char *shortname;
	dsl_dataset_t *ds;
	int error;

	error = dsl_bookmark_hold_ds(dp, fullname, &ds, FTAG, &shortname);
	if (error != 0)
	return (error);

	error = dsl_bookmark_lookup_impl(ds, shortname, bmp);
	if (error == 0 && later_ds != NULL) {
	if (!dsl_dataset_is_before(later_ds, ds, bmp->zbm_creation_txg))
	error = SET_ERROR(EXDEV);
	}
	dsl_dataset_rele(ds, FTAG);
	return (error);
	}

	/*
	* Validates that
	* - bmark is a full dataset path of a bookmark (bookmark_namecheck)
	* - source is a full path of a snapshot or bookmark
	* ({bookmark,snapshot}_namecheck)
	*
	* Returns 0 if valid, -1 otherwise.
	*/
	static int
	dsl_bookmark_create_nvl_validate_pair(const char bmark, const char source)
	{
	if (bookmark_namecheck(bmark, NULL, NULL) != 0)
	return (-1);

	int is_bmark, is_snap;
	is_bmark = bookmark_namecheck(source, NULL, NULL) == 0;
	is_snap = snapshot_namecheck(source, NULL, NULL) == 0;
	if (!is_bmark && !is_snap)
	return (-1);

	return (0);
	}

	/*
	* Check that the given nvlist corresponds to the following schema:
	* { newbookmark -> source, ... }
	* where
	* - each pair passes dsl_bookmark_create_nvl_validate_pair
	* - all newbookmarks are in the same pool
	* - all newbookmarks have unique names
	*
	* Note that this function is only validates above schema. Callers must ensure
	* that the bookmarks can be created, e.g. that sources exist.
	*
	* Returns 0 if the nvlist adheres to above schema.
	* Returns -1 if it doesn't.
	*/
	int
	dsl_bookmark_create_nvl_validate(nvlist_t *bmarks)
	{
	char *first;
	size_t first_len;

	first = NULL;
	for (nvpair_t *pair = nvlist_next_nvpair(bmarks, NULL);
	pair != NULL; pair = nvlist_next_nvpair(bmarks, pair)) {

	char *bmark = nvpair_name(pair);
	char *source;

	/* list structure: values must be snapshots XOR bookmarks */
	if (nvpair_value_string(pair, &source) != 0)
	return (-1);
	if (dsl_bookmark_create_nvl_validate_pair(bmark, source) != 0)
	return (-1);

	/* same pool check */
	if (first == NULL) {
	char *cp = strpbrk(bmark, "/#");
	if (cp == NULL)
	return (-1);
	first = bmark;
	first_len = cp - bmark;
	}
	if (strncmp(first, bmark, first_len) != 0)
	return (-1);
	switch (*(bmark + first_len)) {
	case '/': /* fallthrough */
	case '#':
	break;
	default:
	return (-1);
	}

	/* unique newbookmark names; todo: O(n^2) */
	for (nvpair_t *pair2 = nvlist_next_nvpair(bmarks, pair);
	pair2 != NULL; pair2 = nvlist_next_nvpair(bmarks, pair2)) {
	if (strcmp(nvpair_name(pair), nvpair_name(pair2)) == 0)
	return (-1);
	}

	}
	return (0);
	}

	/*
	* expects that newbm and source have been validated using
	* dsl_bookmark_create_nvl_validate_pair
	*/
	static int
	dsl_bookmark_create_check_impl(dsl_pool_t *dp,
	const char newbm, const char source)
	{
	ASSERT0(dsl_bookmark_create_nvl_validate_pair(newbm, source));
	/* defer source namecheck until we know it's a snapshot or bookmark */

	int error;
	dsl_dataset_t *newbm_ds;
	char *newbm_short;
	zfs_bookmark_phys_t bmark_phys;

	error = dsl_bookmark_hold_ds(dp, newbm, &newbm_ds, FTAG, &newbm_short);
	if (error != 0)
	return (error);

	/* Verify that the new bookmark does not already exist */
	error = dsl_bookmark_lookup_impl(newbm_ds, newbm_short, &bmark_phys);
	switch (error) {
	case ESRCH:
	/* happy path: new bmark doesn't exist, proceed after switch */
	error = 0;
	break;
	case 0:
	error = SET_ERROR(EEXIST);
	goto eholdnewbmds;
	default:
	- /* dsl_bookmark_lookup_impl already did SET_ERRROR */
	+ /* dsl_bookmark_lookup_impl already did SET_ERROR */
	goto eholdnewbmds;
	}

	/* error is retval of the following if-cascade */
	if (strchr(source, '@') != NULL) {
	dsl_dataset_t *source_snap_ds;
	ASSERT3S(snapshot_namecheck(source, NULL, NULL), ==, 0);
	error = dsl_dataset_hold(dp, source, FTAG, &source_snap_ds);
	if (error == 0) {
	VERIFY(source_snap_ds->ds_is_snapshot);
	/*
	* Verify that source snapshot is an earlier point in
	* newbm_ds's timeline (source may be newbm_ds's origin)
	*/
	if (!dsl_dataset_is_before(newbm_ds, source_snap_ds, 0))
	error = SET_ERROR(
	ZFS_ERR_BOOKMARK_SOURCE_NOT_ANCESTOR);
	dsl_dataset_rele(source_snap_ds, FTAG);
	}
	} else if (strchr(source, '#') != NULL) {
	zfs_bookmark_phys_t source_phys;
	ASSERT3S(bookmark_namecheck(source, NULL, NULL), ==, 0);
	/*
	* Source must exists and be an earlier point in newbm_ds's
	* timeline (newbm_ds's origin may be a snap of source's ds)
	*/
	error = dsl_bookmark_lookup(dp, source, newbm_ds, &source_phys);
	switch (error) {
	case 0:
	break; /* happy path */
	case EXDEV:
	error = SET_ERROR(ZFS_ERR_BOOKMARK_SOURCE_NOT_ANCESTOR);
	break;
	default:
	- /* dsl_bookmark_lookup already did SET_ERRROR */
	+ /* dsl_bookmark_lookup already did SET_ERROR */
	break;
	}
	} else {
	/*
	* dsl_bookmark_create_nvl_validate validates that source is
	* either snapshot or bookmark
	*/
	panic("unreachable code: %s", source);
	}

	eholdnewbmds:
	dsl_dataset_rele(newbm_ds, FTAG);
	return (error);
	}

	int
	dsl_bookmark_create_check(void arg, dmu_tx_t tx)
	{
	dsl_bookmark_create_arg_t *dbca = arg;
	int rv = 0;
	int schema_err = 0;
	ASSERT3P(dbca, !=, NULL);
	ASSERT3P(dbca->dbca_bmarks, !=, NULL);
	/* dbca->dbca_errors is allowed to be NULL */

	dsl_pool_t *dp = dmu_tx_pool(tx);

	if (!spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_BOOKMARKS))
	return (SET_ERROR(ENOTSUP));

	if (dsl_bookmark_create_nvl_validate(dbca->dbca_bmarks) != 0)
	rv = schema_err = SET_ERROR(EINVAL);

	for (nvpair_t *pair = nvlist_next_nvpair(dbca->dbca_bmarks, NULL);
	pair != NULL; pair = nvlist_next_nvpair(dbca->dbca_bmarks, pair)) {
	char *new = nvpair_name(pair);

	int error = schema_err;
	if (error == 0) {
	char *source = fnvpair_value_string(pair);
	error = dsl_bookmark_create_check_impl(dp, new, source);
	if (error != 0)
	error = SET_ERROR(error);
	}

	if (error != 0) {
	rv = error;
	if (dbca->dbca_errors != NULL)
	fnvlist_add_int32(dbca->dbca_errors,
	new, error);
	}
	}

	return (rv);
	}

	static dsl_bookmark_node_t *
	dsl_bookmark_node_alloc(char *shortname)
	{
	dsl_bookmark_node_t dbn = kmem_alloc(sizeof (dbn), KM_SLEEP);
	dbn->dbn_name = spa_strdup(shortname);
	dbn->dbn_dirty = B_FALSE;
	mutex_init(&dbn->dbn_lock, NULL, MUTEX_DEFAULT, NULL);
	return (dbn);
	}

	/*
	* Set the fields in the zfs_bookmark_phys_t based on the specified snapshot.
	*/
	static void
	dsl_bookmark_set_phys(zfs_bookmark_phys_t zbm, dsl_dataset_t snap)
	{
	spa_t *spa = dsl_dataset_get_spa(snap);
	objset_t *mos = spa_get_dsl(spa)->dp_meta_objset;
	dsl_dataset_phys_t *dsp = dsl_dataset_phys(snap);
	zbm->zbm_guid = dsp->ds_guid;
	zbm->zbm_creation_txg = dsp->ds_creation_txg;
	zbm->zbm_creation_time = dsp->ds_creation_time;
	zbm->zbm_redaction_obj = 0;

	/*
	* If the dataset is encrypted create a larger bookmark to
	* accommodate the IVset guid. The IVset guid was added
	* after the encryption feature to prevent a problem with
	* raw sends. If we encounter an encrypted dataset without
	* an IVset guid we fall back to a normal bookmark.
	*/
	if (snap->ds_dir->dd_crypto_obj != 0 &&
	spa_feature_is_enabled(spa, SPA_FEATURE_BOOKMARK_V2)) {
	(void) zap_lookup(mos, snap->ds_object,
	DS_FIELD_IVSET_GUID, sizeof (uint64_t), 1,
	&zbm->zbm_ivset_guid);
	}

	if (spa_feature_is_enabled(spa, SPA_FEATURE_BOOKMARK_WRITTEN)) {
	zbm->zbm_flags = ZBM_FLAG_SNAPSHOT_EXISTS \| ZBM_FLAG_HAS_FBN;
	zbm->zbm_referenced_bytes_refd = dsp->ds_referenced_bytes;
	zbm->zbm_compressed_bytes_refd = dsp->ds_compressed_bytes;
	zbm->zbm_uncompressed_bytes_refd = dsp->ds_uncompressed_bytes;

	dsl_dataset_t *nextds;
	VERIFY0(dsl_dataset_hold_obj(snap->ds_dir->dd_pool,
	dsp->ds_next_snap_obj, FTAG, &nextds));
	dsl_deadlist_space(&nextds->ds_deadlist,
	&zbm->zbm_referenced_freed_before_next_snap,
	&zbm->zbm_compressed_freed_before_next_snap,
	&zbm->zbm_uncompressed_freed_before_next_snap);
	dsl_dataset_rele(nextds, FTAG);
	} else {
	bzero(&zbm->zbm_flags,
	sizeof (zfs_bookmark_phys_t) -
	offsetof(zfs_bookmark_phys_t, zbm_flags));
	}
	}

	/*
	* Add dsl_bookmark_node_t `dbn` to the given dataset and increment appropriate
	* SPA feature counters.
	*/
	void
	dsl_bookmark_node_add(dsl_dataset_t hds, dsl_bookmark_node_t dbn,
	dmu_tx_t *tx)
	{
	dsl_pool_t *dp = dmu_tx_pool(tx);
	objset_t *mos = dp->dp_meta_objset;

	if (hds->ds_bookmarks_obj == 0) {
	hds->ds_bookmarks_obj = zap_create_norm(mos,
	U8_TEXTPREP_TOUPPER, DMU_OTN_ZAP_METADATA, DMU_OT_NONE, 0,
	tx);
	spa_feature_incr(dp->dp_spa, SPA_FEATURE_BOOKMARKS, tx);

	dsl_dataset_zapify(hds, tx);
	VERIFY0(zap_add(mos, hds->ds_object,
	DS_FIELD_BOOKMARK_NAMES,
	sizeof (hds->ds_bookmarks_obj), 1,
	&hds->ds_bookmarks_obj, tx));
	}

	avl_add(&hds->ds_bookmarks, dbn);

	/*
	* To maintain backwards compatibility with software that doesn't
	* understand SPA_FEATURE_BOOKMARK_V2, we need to use the smallest
	* possible bookmark size.
	*/
	uint64_t bookmark_phys_size = BOOKMARK_PHYS_SIZE_V1;
	if (spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_BOOKMARK_V2) &&
	(dbn->dbn_phys.zbm_ivset_guid != 0 \|\| dbn->dbn_phys.zbm_flags &
	ZBM_FLAG_HAS_FBN \|\| dbn->dbn_phys.zbm_redaction_obj != 0)) {
	bookmark_phys_size = BOOKMARK_PHYS_SIZE_V2;
	spa_feature_incr(dp->dp_spa, SPA_FEATURE_BOOKMARK_V2, tx);
	}

	__attribute__((unused)) zfs_bookmark_phys_t zero_phys = { 0 };
	ASSERT0(bcmp(((char *)&dbn->dbn_phys) + bookmark_phys_size,
	&zero_phys, sizeof (zfs_bookmark_phys_t) - bookmark_phys_size));

	VERIFY0(zap_add(mos, hds->ds_bookmarks_obj, dbn->dbn_name,
	sizeof (uint64_t), bookmark_phys_size / sizeof (uint64_t),
	&dbn->dbn_phys, tx));
	}

	/*
	* If redaction_list is non-null, we create a redacted bookmark and redaction
	* list, and store the object number of the redaction list in redact_obj.
	*/
	static void
	dsl_bookmark_create_sync_impl_snap(const char bookmark, const char snapshot,
	dmu_tx_t tx, uint64_t num_redact_snaps, uint64_t redact_snaps, void *tag,
	redaction_list_t **redaction_list)
	{
	dsl_pool_t *dp = dmu_tx_pool(tx);
	objset_t *mos = dp->dp_meta_objset;
	dsl_dataset_t snapds, bmark_fs;
	char *shortname;
	boolean_t bookmark_redacted;
	uint64_t *dsredactsnaps;
	uint64_t dsnumsnaps;

	VERIFY0(dsl_dataset_hold(dp, snapshot, FTAG, &snapds));
	VERIFY0(dsl_bookmark_hold_ds(dp, bookmark, &bmark_fs, FTAG,
	&shortname));

	dsl_bookmark_node_t *dbn = dsl_bookmark_node_alloc(shortname);
	dsl_bookmark_set_phys(&dbn->dbn_phys, snapds);

	bookmark_redacted = dsl_dataset_get_uint64_array_feature(snapds,
	SPA_FEATURE_REDACTED_DATASETS, &dsnumsnaps, &dsredactsnaps);
	if (redaction_list != NULL \|\| bookmark_redacted) {
	redaction_list_t *local_rl;
	if (bookmark_redacted) {
	redact_snaps = dsredactsnaps;
	num_redact_snaps = dsnumsnaps;
	}
	dbn->dbn_phys.zbm_redaction_obj = dmu_object_alloc(mos,
	DMU_OTN_UINT64_METADATA, SPA_OLD_MAXBLOCKSIZE,
	DMU_OTN_UINT64_METADATA, sizeof (redaction_list_phys_t) +
	num_redact_snaps * sizeof (uint64_t), tx);
	spa_feature_incr(dp->dp_spa,
	SPA_FEATURE_REDACTION_BOOKMARKS, tx);

	VERIFY0(dsl_redaction_list_hold_obj(dp,
	dbn->dbn_phys.zbm_redaction_obj, tag, &local_rl));
	dsl_redaction_list_long_hold(dp, local_rl, tag);

	ASSERT3U((local_rl)->rl_dbuf->db_size, >=,
	sizeof (redaction_list_phys_t) + num_redact_snaps *
	sizeof (uint64_t));
	dmu_buf_will_dirty(local_rl->rl_dbuf, tx);
	bcopy(redact_snaps, local_rl->rl_phys->rlp_snaps,
	sizeof (uint64_t) * num_redact_snaps);
	local_rl->rl_phys->rlp_num_snaps = num_redact_snaps;
	if (bookmark_redacted) {
	ASSERT3P(redaction_list, ==, NULL);
	local_rl->rl_phys->rlp_last_blkid = UINT64_MAX;
	local_rl->rl_phys->rlp_last_object = UINT64_MAX;
	dsl_redaction_list_long_rele(local_rl, tag);
	dsl_redaction_list_rele(local_rl, tag);
	} else {
	*redaction_list = local_rl;
	}
	}

	if (dbn->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN) {
	spa_feature_incr(dp->dp_spa,
	SPA_FEATURE_BOOKMARK_WRITTEN, tx);
	}

	dsl_bookmark_node_add(bmark_fs, dbn, tx);

	spa_history_log_internal_ds(bmark_fs, "bookmark", tx,
	"name=%s creation_txg=%llu target_snap=%llu redact_obj=%llu",
	shortname, (longlong_t)dbn->dbn_phys.zbm_creation_txg,
	(longlong_t)snapds->ds_object,
	(longlong_t)dbn->dbn_phys.zbm_redaction_obj);

	dsl_dataset_rele(bmark_fs, FTAG);
	dsl_dataset_rele(snapds, FTAG);
	}


	static void
	dsl_bookmark_create_sync_impl_book(
	const char new_name, const char source_name, dmu_tx_t *tx)
	{
	dsl_pool_t *dp = dmu_tx_pool(tx);
	dsl_dataset_t bmark_fs_source, bmark_fs_new;
	char source_shortname, new_shortname;
	zfs_bookmark_phys_t source_phys;

	VERIFY0(dsl_bookmark_hold_ds(dp, source_name, &bmark_fs_source, FTAG,
	&source_shortname));
	VERIFY0(dsl_bookmark_hold_ds(dp, new_name, &bmark_fs_new, FTAG,
	&new_shortname));

	/*
	* create a copy of the source bookmark by copying most of its members
	*
	* Caveat: bookmarking a redaction bookmark yields a normal bookmark
	* -----------------------------------------------------------------
	* Reasoning:
	* - The zbm_redaction_obj would be referred to by both source and new
	* bookmark, but would be destroyed once either source or new is
	- * destroyed, resulting in use-after-free of the referrred object.
	+ * destroyed, resulting in use-after-free of the referred object.
	* - User expectation when issuing the `zfs bookmark` command is that
	* a normal bookmark of the source is created
	*
	* Design Alternatives For Full Redaction Bookmark Copying:
	* - reference-count the redaction object => would require on-disk
	* format change for existing redaction objects
	* - Copy the redaction object => cannot be done in syncing context
	* because the redaction object might be too large
	*/

	VERIFY0(dsl_bookmark_lookup_impl(bmark_fs_source, source_shortname,
	&source_phys));
	dsl_bookmark_node_t *new_dbn = dsl_bookmark_node_alloc(new_shortname);

	memcpy(&new_dbn->dbn_phys, &source_phys, sizeof (source_phys));
	new_dbn->dbn_phys.zbm_redaction_obj = 0;

	/* update feature counters */
	if (new_dbn->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN) {
	spa_feature_incr(dp->dp_spa,
	SPA_FEATURE_BOOKMARK_WRITTEN, tx);
	}
	/* no need for redaction bookmark counter; nulled zbm_redaction_obj */
	/* dsl_bookmark_node_add bumps bookmarks and v2-bookmarks counter */

	/*
	* write new bookmark
	*
	* Note that dsl_bookmark_lookup_impl guarantees that, if source is a
	* v1 bookmark, the v2-only fields are zeroed.
	* And dsl_bookmark_node_add writes back a v1-sized bookmark if
	* v2 bookmarks are disabled and/or v2-only fields are zeroed.
	* => bookmark copying works on pre-bookmark-v2 pools
	*/
	dsl_bookmark_node_add(bmark_fs_new, new_dbn, tx);

	spa_history_log_internal_ds(bmark_fs_source, "bookmark", tx,
	"name=%s creation_txg=%llu source_guid=%llu",
	new_shortname, (longlong_t)new_dbn->dbn_phys.zbm_creation_txg,
	(longlong_t)source_phys.zbm_guid);

	dsl_dataset_rele(bmark_fs_source, FTAG);
	dsl_dataset_rele(bmark_fs_new, FTAG);
	}

	void
	dsl_bookmark_create_sync(void arg, dmu_tx_t tx)
	{
	dsl_bookmark_create_arg_t *dbca = arg;

	ASSERT(spa_feature_is_enabled(dmu_tx_pool(tx)->dp_spa,
	SPA_FEATURE_BOOKMARKS));

	for (nvpair_t *pair = nvlist_next_nvpair(dbca->dbca_bmarks, NULL);
	pair != NULL; pair = nvlist_next_nvpair(dbca->dbca_bmarks, pair)) {

	char *new = nvpair_name(pair);
	char *source = fnvpair_value_string(pair);

	if (strchr(source, '@') != NULL) {
	dsl_bookmark_create_sync_impl_snap(new, source, tx,
	0, NULL, NULL, NULL);
	} else if (strchr(source, '#') != NULL) {
	dsl_bookmark_create_sync_impl_book(new, source, tx);
	} else {
	panic("unreachable code");
	}

	}
	}

	/*
	* The bookmarks must all be in the same pool.
	*/
	int
	dsl_bookmark_create(nvlist_t bmarks, nvlist_t errors)
	{
	nvpair_t *pair;
	dsl_bookmark_create_arg_t dbca;

	pair = nvlist_next_nvpair(bmarks, NULL);
	if (pair == NULL)
	return (0);

	dbca.dbca_bmarks = bmarks;
	dbca.dbca_errors = errors;

	return (dsl_sync_task(nvpair_name(pair), dsl_bookmark_create_check,
	dsl_bookmark_create_sync, &dbca,
	fnvlist_num_pairs(bmarks), ZFS_SPACE_CHECK_NORMAL));
	}

	static int
	dsl_bookmark_create_redacted_check(void arg, dmu_tx_t tx)
	{
	dsl_bookmark_create_redacted_arg_t *dbcra = arg;
	dsl_pool_t *dp = dmu_tx_pool(tx);
	int rv = 0;

	if (!spa_feature_is_enabled(dp->dp_spa,
	SPA_FEATURE_REDACTION_BOOKMARKS))
	return (SET_ERROR(ENOTSUP));
	/*
	* If the list of redact snaps will not fit in the bonus buffer with
	* the furthest reached object and offset, fail.
	*/
	if (dbcra->dbcra_numsnaps > (dmu_bonus_max() -
	sizeof (redaction_list_phys_t)) / sizeof (uint64_t))
	return (SET_ERROR(E2BIG));

	if (dsl_bookmark_create_nvl_validate_pair(
	dbcra->dbcra_bmark, dbcra->dbcra_snap) != 0)
	return (SET_ERROR(EINVAL));

	rv = dsl_bookmark_create_check_impl(dp,
	dbcra->dbcra_bmark, dbcra->dbcra_snap);
	return (rv);
	}

	static void
	dsl_bookmark_create_redacted_sync(void arg, dmu_tx_t tx)
	{
	dsl_bookmark_create_redacted_arg_t *dbcra = arg;
	dsl_bookmark_create_sync_impl_snap(dbcra->dbcra_bmark,
	dbcra->dbcra_snap, tx, dbcra->dbcra_numsnaps, dbcra->dbcra_snaps,
	dbcra->dbcra_tag, dbcra->dbcra_rl);
	}

	int
	dsl_bookmark_create_redacted(const char bookmark, const char snapshot,
	uint64_t numsnaps, uint64_t snapguids, void tag, redaction_list_t **rl)
	{
	dsl_bookmark_create_redacted_arg_t dbcra;

	dbcra.dbcra_bmark = bookmark;
	dbcra.dbcra_snap = snapshot;
	dbcra.dbcra_rl = rl;
	dbcra.dbcra_numsnaps = numsnaps;
	dbcra.dbcra_snaps = snapguids;
	dbcra.dbcra_tag = tag;

	return (dsl_sync_task(bookmark, dsl_bookmark_create_redacted_check,
	dsl_bookmark_create_redacted_sync, &dbcra, 5,
	ZFS_SPACE_CHECK_NORMAL));
	}

	/*
	* Retrieve the list of properties given in the 'props' nvlist for a bookmark.
	* If 'props' is NULL, retrieves all properties.
	*/
	static void
	dsl_bookmark_fetch_props(dsl_pool_t dp, zfs_bookmark_phys_t bmark_phys,
	nvlist_t props, nvlist_t out_props)
	{
	ASSERT3P(dp, !=, NULL);
	ASSERT3P(bmark_phys, !=, NULL);
	ASSERT3P(out_props, !=, NULL);
	ASSERT(RRW_LOCK_HELD(&dp->dp_config_rwlock));

	if (props == NULL \|\| nvlist_exists(props,
	zfs_prop_to_name(ZFS_PROP_GUID))) {
	dsl_prop_nvlist_add_uint64(out_props,
	ZFS_PROP_GUID, bmark_phys->zbm_guid);
	}
	if (props == NULL \|\| nvlist_exists(props,
	zfs_prop_to_name(ZFS_PROP_CREATETXG))) {
	dsl_prop_nvlist_add_uint64(out_props,
	ZFS_PROP_CREATETXG, bmark_phys->zbm_creation_txg);
	}
	if (props == NULL \|\| nvlist_exists(props,
	zfs_prop_to_name(ZFS_PROP_CREATION))) {
	dsl_prop_nvlist_add_uint64(out_props,
	ZFS_PROP_CREATION, bmark_phys->zbm_creation_time);
	}
	if (props == NULL \|\| nvlist_exists(props,
	zfs_prop_to_name(ZFS_PROP_IVSET_GUID))) {
	dsl_prop_nvlist_add_uint64(out_props,
	ZFS_PROP_IVSET_GUID, bmark_phys->zbm_ivset_guid);
	}
	if (bmark_phys->zbm_flags & ZBM_FLAG_HAS_FBN) {
	if (props == NULL \|\| nvlist_exists(props,
	zfs_prop_to_name(ZFS_PROP_REFERENCED))) {
	dsl_prop_nvlist_add_uint64(out_props,
	ZFS_PROP_REFERENCED,
	bmark_phys->zbm_referenced_bytes_refd);
	}
	if (props == NULL \|\| nvlist_exists(props,
	zfs_prop_to_name(ZFS_PROP_LOGICALREFERENCED))) {
	dsl_prop_nvlist_add_uint64(out_props,
	ZFS_PROP_LOGICALREFERENCED,
	bmark_phys->zbm_uncompressed_bytes_refd);
	}
	if (props == NULL \|\| nvlist_exists(props,
	zfs_prop_to_name(ZFS_PROP_REFRATIO))) {
	uint64_t ratio =
	bmark_phys->zbm_compressed_bytes_refd == 0 ? 100 :
	bmark_phys->zbm_uncompressed_bytes_refd * 100 /
	bmark_phys->zbm_compressed_bytes_refd;
	dsl_prop_nvlist_add_uint64(out_props,
	ZFS_PROP_REFRATIO, ratio);
	}
	}

	if ((props == NULL \|\| nvlist_exists(props, "redact_snaps") \|\|
	nvlist_exists(props, "redact_complete")) &&
	bmark_phys->zbm_redaction_obj != 0) {
	redaction_list_t *rl;
	int err = dsl_redaction_list_hold_obj(dp,
	bmark_phys->zbm_redaction_obj, FTAG, &rl);
	if (err == 0) {
	if (nvlist_exists(props, "redact_snaps")) {
	nvlist_t *nvl;
	nvl = fnvlist_alloc();
	fnvlist_add_uint64_array(nvl, ZPROP_VALUE,
	rl->rl_phys->rlp_snaps,
	rl->rl_phys->rlp_num_snaps);
	fnvlist_add_nvlist(out_props, "redact_snaps",
	nvl);
	nvlist_free(nvl);
	}
	if (nvlist_exists(props, "redact_complete")) {
	nvlist_t *nvl;
	nvl = fnvlist_alloc();
	fnvlist_add_boolean_value(nvl, ZPROP_VALUE,
	rl->rl_phys->rlp_last_blkid == UINT64_MAX &&
	rl->rl_phys->rlp_last_object == UINT64_MAX);
	fnvlist_add_nvlist(out_props, "redact_complete",
	nvl);
	nvlist_free(nvl);
	}
	dsl_redaction_list_rele(rl, FTAG);
	}
	}
	}

	int
	dsl_get_bookmarks_impl(dsl_dataset_t ds, nvlist_t props, nvlist_t *outnvl)
	{
	dsl_pool_t *dp = ds->ds_dir->dd_pool;

	ASSERT(dsl_pool_config_held(dp));

	if (dsl_dataset_is_snapshot(ds))
	return (SET_ERROR(EINVAL));

	for (dsl_bookmark_node_t *dbn = avl_first(&ds->ds_bookmarks);
	dbn != NULL; dbn = AVL_NEXT(&ds->ds_bookmarks, dbn)) {
	nvlist_t *out_props = fnvlist_alloc();

	dsl_bookmark_fetch_props(dp, &dbn->dbn_phys, props, out_props);

	fnvlist_add_nvlist(outnvl, dbn->dbn_name, out_props);
	fnvlist_free(out_props);
	}
	return (0);
	}

	/*
	* Comparison func for ds_bookmarks AVL tree. We sort the bookmarks by
	* their TXG, then by their FBN-ness. The "FBN-ness" component ensures
	* that all bookmarks at the same TXG that HAS_FBN are adjacent, which
	* dsl_bookmark_destroy_sync_impl() depends on. Note that there may be
	* multiple bookmarks at the same TXG (with the same FBN-ness). In this
	* case we differentiate them by an arbitrary metric (in this case,
	* their names).
	*/
	static int
	dsl_bookmark_compare(const void l, const void r)
	{
	const dsl_bookmark_node_t *ldbn = l;
	const dsl_bookmark_node_t *rdbn = r;

	int64_t cmp = TREE_CMP(ldbn->dbn_phys.zbm_creation_txg,
	rdbn->dbn_phys.zbm_creation_txg);
	if (likely(cmp))
	return (cmp);
	cmp = TREE_CMP((ldbn->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN),
	(rdbn->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN));
	if (likely(cmp))
	return (cmp);
	cmp = strcmp(ldbn->dbn_name, rdbn->dbn_name);
	return (TREE_ISIGN(cmp));
	}

	/*
	* Cache this (head) dataset's bookmarks in the ds_bookmarks AVL tree.
	*/
	int
	dsl_bookmark_init_ds(dsl_dataset_t *ds)
	{
	dsl_pool_t *dp = ds->ds_dir->dd_pool;
	objset_t *mos = dp->dp_meta_objset;

	ASSERT(!ds->ds_is_snapshot);

	avl_create(&ds->ds_bookmarks, dsl_bookmark_compare,
	sizeof (dsl_bookmark_node_t),
	offsetof(dsl_bookmark_node_t, dbn_node));

	if (!dsl_dataset_is_zapified(ds))
	return (0);

	int zaperr = zap_lookup(mos, ds->ds_object, DS_FIELD_BOOKMARK_NAMES,
	sizeof (ds->ds_bookmarks_obj), 1, &ds->ds_bookmarks_obj);
	if (zaperr == ENOENT)
	return (0);
	if (zaperr != 0)
	return (zaperr);

	if (ds->ds_bookmarks_obj == 0)
	return (0);

	int err = 0;
	zap_cursor_t zc;
	zap_attribute_t attr;

	for (zap_cursor_init(&zc, mos, ds->ds_bookmarks_obj);
	(err = zap_cursor_retrieve(&zc, &attr)) == 0;
	zap_cursor_advance(&zc)) {
	dsl_bookmark_node_t *dbn =
	dsl_bookmark_node_alloc(attr.za_name);

	err = dsl_bookmark_lookup_impl(ds,
	dbn->dbn_name, &dbn->dbn_phys);
	ASSERT3U(err, !=, ENOENT);
	if (err != 0) {
	kmem_free(dbn, sizeof (*dbn));
	break;
	}
	avl_add(&ds->ds_bookmarks, dbn);
	}
	zap_cursor_fini(&zc);
	if (err == ENOENT)
	err = 0;
	return (err);
	}

	void
	dsl_bookmark_fini_ds(dsl_dataset_t *ds)
	{
	void *cookie = NULL;
	dsl_bookmark_node_t *dbn;

	if (ds->ds_is_snapshot)
	return;

	while ((dbn = avl_destroy_nodes(&ds->ds_bookmarks, &cookie)) != NULL) {
	spa_strfree(dbn->dbn_name);
	mutex_destroy(&dbn->dbn_lock);
	kmem_free(dbn, sizeof (*dbn));
	}
	avl_destroy(&ds->ds_bookmarks);
	}

	/*
	* Retrieve the bookmarks that exist in the specified dataset, and the
	* requested properties of each bookmark.
	*
	* The "props" nvlist specifies which properties are requested.
	* See lzc_get_bookmarks() for the list of valid properties.
	*/
	int
	dsl_get_bookmarks(const char dsname, nvlist_t props, nvlist_t *outnvl)
	{
	dsl_pool_t *dp;
	dsl_dataset_t *ds;
	int err;

	err = dsl_pool_hold(dsname, FTAG, &dp);
	if (err != 0)
	return (err);
	err = dsl_dataset_hold(dp, dsname, FTAG, &ds);
	if (err != 0) {
	dsl_pool_rele(dp, FTAG);
	return (err);
	}

	err = dsl_get_bookmarks_impl(ds, props, outnvl);

	dsl_dataset_rele(ds, FTAG);
	dsl_pool_rele(dp, FTAG);
	return (err);
	}

	/*
	* Retrieve all properties for a single bookmark in the given dataset.
	*/
	int
	dsl_get_bookmark_props(const char dsname, const char bmname, nvlist_t *props)
	{
	dsl_pool_t *dp;
	dsl_dataset_t *ds;
	zfs_bookmark_phys_t bmark_phys = { 0 };
	int err;

	err = dsl_pool_hold(dsname, FTAG, &dp);
	if (err != 0)
	return (err);
	err = dsl_dataset_hold(dp, dsname, FTAG, &ds);
	if (err != 0) {
	dsl_pool_rele(dp, FTAG);
	return (err);
	}

	err = dsl_bookmark_lookup_impl(ds, bmname, &bmark_phys);
	if (err != 0)
	goto out;

	dsl_bookmark_fetch_props(dp, &bmark_phys, NULL, props);
	out:
	dsl_dataset_rele(ds, FTAG);
	dsl_pool_rele(dp, FTAG);
	return (err);
	}

	typedef struct dsl_bookmark_destroy_arg {
	nvlist_t *dbda_bmarks;
	nvlist_t *dbda_success;
	nvlist_t *dbda_errors;
	} dsl_bookmark_destroy_arg_t;

	static void
	dsl_bookmark_destroy_sync_impl(dsl_dataset_t ds, const char name,
	dmu_tx_t *tx)
	{
	objset_t *mos = ds->ds_dir->dd_pool->dp_meta_objset;
	uint64_t bmark_zapobj = ds->ds_bookmarks_obj;
	matchtype_t mt = 0;
	uint64_t int_size, num_ints;
	/*
	* 'search' must be zeroed so that dbn_flags (which is used in
	* dsl_bookmark_compare()) will be zeroed even if the on-disk
	* (in ZAP) bookmark is shorter than offsetof(dbn_flags).
	*/
	dsl_bookmark_node_t search = { 0 };
	char realname[ZFS_MAX_DATASET_NAME_LEN];

	/*
	* Find the real name of this bookmark, which may be different
	* from the given name if the dataset is case-insensitive. Then
	* use the real name to find the node in the ds_bookmarks AVL tree.
	*/

	if (dsl_dataset_phys(ds)->ds_flags & DS_FLAG_CI_DATASET)
	mt = MT_NORMALIZE;

	VERIFY0(zap_length(mos, bmark_zapobj, name, &int_size, &num_ints));

	ASSERT3U(int_size, ==, sizeof (uint64_t));

	if (num_ints * int_size > BOOKMARK_PHYS_SIZE_V1) {
	spa_feature_decr(dmu_objset_spa(mos),
	SPA_FEATURE_BOOKMARK_V2, tx);
	}
	VERIFY0(zap_lookup_norm(mos, bmark_zapobj, name, sizeof (uint64_t),
	num_ints, &search.dbn_phys, mt, realname, sizeof (realname), NULL));

	search.dbn_name = realname;
	dsl_bookmark_node_t *dbn = avl_find(&ds->ds_bookmarks, &search, NULL);
	ASSERT(dbn != NULL);

	if (dbn->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN) {
	/*
	* If this bookmark HAS_FBN, and it is before the most
	* recent snapshot, then its TXG is a key in the head's
	* deadlist (and all clones' heads' deadlists). If this is
	* the last thing keeping the key (i.e. there are no more
	* bookmarks with HAS_FBN at this TXG, and there is no
	* snapshot at this TXG), then remove the key.
	*
	* Note that this algorithm depends on ds_bookmarks being
	* sorted such that all bookmarks at the same TXG with
	* HAS_FBN are adjacent (with no non-HAS_FBN bookmarks
	* at the same TXG in between them). If this were not
	* the case, we would need to examine all bookmarks
	* at this TXG, rather than just the adjacent ones.
	*/

	dsl_bookmark_node_t *dbn_prev =
	AVL_PREV(&ds->ds_bookmarks, dbn);
	dsl_bookmark_node_t *dbn_next =
	AVL_NEXT(&ds->ds_bookmarks, dbn);

	boolean_t more_bookmarks_at_this_txg =
	(dbn_prev != NULL && dbn_prev->dbn_phys.zbm_creation_txg ==
	dbn->dbn_phys.zbm_creation_txg &&
	(dbn_prev->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN)) \|\|
	(dbn_next != NULL && dbn_next->dbn_phys.zbm_creation_txg ==
	dbn->dbn_phys.zbm_creation_txg &&
	(dbn_next->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN));

	if (!(dbn->dbn_phys.zbm_flags & ZBM_FLAG_SNAPSHOT_EXISTS) &&
	!more_bookmarks_at_this_txg &&
	dbn->dbn_phys.zbm_creation_txg <
	dsl_dataset_phys(ds)->ds_prev_snap_txg) {
	dsl_dir_remove_clones_key(ds->ds_dir,
	dbn->dbn_phys.zbm_creation_txg, tx);
	dsl_deadlist_remove_key(&ds->ds_deadlist,
	dbn->dbn_phys.zbm_creation_txg, tx);
	}

	spa_feature_decr(dmu_objset_spa(mos),
	SPA_FEATURE_BOOKMARK_WRITTEN, tx);
	}

	if (dbn->dbn_phys.zbm_redaction_obj != 0) {
	VERIFY0(dmu_object_free(mos,
	dbn->dbn_phys.zbm_redaction_obj, tx));
	spa_feature_decr(dmu_objset_spa(mos),
	SPA_FEATURE_REDACTION_BOOKMARKS, tx);
	}

	avl_remove(&ds->ds_bookmarks, dbn);
	spa_strfree(dbn->dbn_name);
	mutex_destroy(&dbn->dbn_lock);
	kmem_free(dbn, sizeof (*dbn));

	VERIFY0(zap_remove_norm(mos, bmark_zapobj, name, mt, tx));
	}

	static int
	dsl_bookmark_destroy_check(void arg, dmu_tx_t tx)
	{
	dsl_bookmark_destroy_arg_t *dbda = arg;
	dsl_pool_t *dp = dmu_tx_pool(tx);
	int rv = 0;

	ASSERT(nvlist_empty(dbda->dbda_success));
	ASSERT(nvlist_empty(dbda->dbda_errors));

	if (!spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_BOOKMARKS))
	return (0);

	for (nvpair_t *pair = nvlist_next_nvpair(dbda->dbda_bmarks, NULL);
	pair != NULL; pair = nvlist_next_nvpair(dbda->dbda_bmarks, pair)) {
	const char *fullname = nvpair_name(pair);
	dsl_dataset_t *ds;
	zfs_bookmark_phys_t bm;
	int error;
	char *shortname;

	error = dsl_bookmark_hold_ds(dp, fullname, &ds,
	FTAG, &shortname);
	if (error == ENOENT) {
	/* ignore it; the bookmark is "already destroyed" */
	continue;
	}
	if (error == 0) {
	error = dsl_bookmark_lookup_impl(ds, shortname, &bm);
	dsl_dataset_rele(ds, FTAG);
	if (error == ESRCH) {
	/*
	* ignore it; the bookmark is
	* "already destroyed"
	*/
	continue;
	}
	if (error == 0 && bm.zbm_redaction_obj != 0) {
	redaction_list_t *rl = NULL;
	error = dsl_redaction_list_hold_obj(tx->tx_pool,
	bm.zbm_redaction_obj, FTAG, &rl);
	if (error == ENOENT) {
	error = 0;
	} else if (error == 0 &&
	dsl_redaction_list_long_held(rl)) {
	error = SET_ERROR(EBUSY);
	}
	if (rl != NULL) {
	dsl_redaction_list_rele(rl, FTAG);
	}
	}
	}
	if (error == 0) {
	if (dmu_tx_is_syncing(tx)) {
	fnvlist_add_boolean(dbda->dbda_success,
	fullname);
	}
	} else {
	fnvlist_add_int32(dbda->dbda_errors, fullname, error);
	rv = error;
	}
	}
	return (rv);
	}

	static void
	dsl_bookmark_destroy_sync(void arg, dmu_tx_t tx)
	{
	dsl_bookmark_destroy_arg_t *dbda = arg;
	dsl_pool_t *dp = dmu_tx_pool(tx);
	objset_t *mos = dp->dp_meta_objset;

	for (nvpair_t *pair = nvlist_next_nvpair(dbda->dbda_success, NULL);
	pair != NULL; pair = nvlist_next_nvpair(dbda->dbda_success, pair)) {
	dsl_dataset_t *ds;
	char *shortname;
	uint64_t zap_cnt;

	VERIFY0(dsl_bookmark_hold_ds(dp, nvpair_name(pair),
	&ds, FTAG, &shortname));
	dsl_bookmark_destroy_sync_impl(ds, shortname, tx);

	/*
	* If all of this dataset's bookmarks have been destroyed,
	* free the zap object and decrement the feature's use count.
	*/
	VERIFY0(zap_count(mos, ds->ds_bookmarks_obj, &zap_cnt));
	if (zap_cnt == 0) {
	dmu_buf_will_dirty(ds->ds_dbuf, tx);
	VERIFY0(zap_destroy(mos, ds->ds_bookmarks_obj, tx));
	ds->ds_bookmarks_obj = 0;
	spa_feature_decr(dp->dp_spa, SPA_FEATURE_BOOKMARKS, tx);
	VERIFY0(zap_remove(mos, ds->ds_object,
	DS_FIELD_BOOKMARK_NAMES, tx));
	}

	spa_history_log_internal_ds(ds, "remove bookmark", tx,
	"name=%s", shortname);

	dsl_dataset_rele(ds, FTAG);
	}
	}

	/*
	* The bookmarks must all be in the same pool.
	*/
	int
	dsl_bookmark_destroy(nvlist_t bmarks, nvlist_t errors)
	{
	int rv;
	dsl_bookmark_destroy_arg_t dbda;
	nvpair_t *pair = nvlist_next_nvpair(bmarks, NULL);
	if (pair == NULL)
	return (0);

	dbda.dbda_bmarks = bmarks;
	dbda.dbda_errors = errors;
	dbda.dbda_success = fnvlist_alloc();

	rv = dsl_sync_task(nvpair_name(pair), dsl_bookmark_destroy_check,
	dsl_bookmark_destroy_sync, &dbda, fnvlist_num_pairs(bmarks),
	ZFS_SPACE_CHECK_RESERVED);
	fnvlist_free(dbda.dbda_success);
	return (rv);
	}

	/* Return B_TRUE if there are any long holds on this dataset. */
	boolean_t
	dsl_redaction_list_long_held(redaction_list_t *rl)
	{
	return (!zfs_refcount_is_zero(&rl->rl_longholds));
	}

	void
	dsl_redaction_list_long_hold(dsl_pool_t dp, redaction_list_t rl, void *tag)
	{
	ASSERT(dsl_pool_config_held(dp));
	(void) zfs_refcount_add(&rl->rl_longholds, tag);
	}

	void
	dsl_redaction_list_long_rele(redaction_list_t rl, void tag)
	{
	(void) zfs_refcount_remove(&rl->rl_longholds, tag);
	}

	/* ARGSUSED */
	static void
	redaction_list_evict_sync(void *rlu)
	{
	redaction_list_t *rl = rlu;
	zfs_refcount_destroy(&rl->rl_longholds);

	kmem_free(rl, sizeof (redaction_list_t));
	}

	void
	dsl_redaction_list_rele(redaction_list_t rl, void tag)
	{
	dmu_buf_rele(rl->rl_dbuf, tag);
	}

	int
	dsl_redaction_list_hold_obj(dsl_pool_t dp, uint64_t rlobj, void tag,
	redaction_list_t **rlp)
	{
	objset_t *mos = dp->dp_meta_objset;
	dmu_buf_t *dbuf;
	redaction_list_t *rl;
	int err;

	ASSERT(dsl_pool_config_held(dp));

	err = dmu_bonus_hold(mos, rlobj, tag, &dbuf);
	if (err != 0)
	return (err);

	rl = dmu_buf_get_user(dbuf);
	if (rl == NULL) {
	redaction_list_t *winner = NULL;

	rl = kmem_zalloc(sizeof (redaction_list_t), KM_SLEEP);
	rl->rl_dbuf = dbuf;
	rl->rl_object = rlobj;
	rl->rl_phys = dbuf->db_data;
	rl->rl_mos = dp->dp_meta_objset;
	zfs_refcount_create(&rl->rl_longholds);
	dmu_buf_init_user(&rl->rl_dbu, redaction_list_evict_sync, NULL,
	&rl->rl_dbuf);
	if ((winner = dmu_buf_set_user_ie(dbuf, &rl->rl_dbu)) != NULL) {
	kmem_free(rl, sizeof (*rl));
	rl = winner;
	}
	}
	*rlp = rl;
	return (0);
	}

	/*
	* Snapshot ds is being destroyed.
	*
	* Adjust the "freed_before_next" of any bookmarks between this snap
	* and the previous snapshot, because their "next snapshot" is changing.
	*
	* If there are any bookmarks with HAS_FBN at this snapshot, remove
	* their HAS_SNAP flag (note: there can be at most one snapshot of
	* each filesystem at a given txg), and return B_TRUE. In this case
	* the caller can not remove the key in the deadlist at this TXG, because
	* the HAS_FBN bookmarks require the key be there.
	*
	* Returns B_FALSE if there are no bookmarks with HAS_FBN at this
	* snapshot's TXG. In this case the caller can remove the key in the
	* deadlist at this TXG.
	*/
	boolean_t
	dsl_bookmark_ds_destroyed(dsl_dataset_t ds, dmu_tx_t tx)
	{
	dsl_pool_t *dp = ds->ds_dir->dd_pool;

	dsl_dataset_t head, next;
	VERIFY0(dsl_dataset_hold_obj(dp,
	dsl_dir_phys(ds->ds_dir)->dd_head_dataset_obj, FTAG, &head));
	VERIFY0(dsl_dataset_hold_obj(dp,
	dsl_dataset_phys(ds)->ds_next_snap_obj, FTAG, &next));

	/*
	* Find the first bookmark that HAS_FBN at or after the
	* previous snapshot.
	*/
	dsl_bookmark_node_t search = { 0 };
	avl_index_t idx;
	search.dbn_phys.zbm_creation_txg =
	dsl_dataset_phys(ds)->ds_prev_snap_txg;
	search.dbn_phys.zbm_flags = ZBM_FLAG_HAS_FBN;
	/*
	* The empty-string name can't be in the AVL, and it compares
	* before any entries with this TXG.
	*/
	search.dbn_name = "";
	VERIFY3P(avl_find(&head->ds_bookmarks, &search, &idx), ==, NULL);
	dsl_bookmark_node_t *dbn =
	avl_nearest(&head->ds_bookmarks, idx, AVL_AFTER);

	/*
	* Iterate over all bookmarks that are at or after the previous
	* snapshot, and before this (being deleted) snapshot. Adjust
	* their FBN based on their new next snapshot.
	*/
	for (; dbn != NULL && dbn->dbn_phys.zbm_creation_txg <
	dsl_dataset_phys(ds)->ds_creation_txg;
	dbn = AVL_NEXT(&head->ds_bookmarks, dbn)) {
	if (!(dbn->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN))
	continue;
	/*
	* Increase our FBN by the amount of space that was live
	* (referenced) at the time of this bookmark (i.e.
	* birth <= zbm_creation_txg), and killed between this
	* (being deleted) snapshot and the next snapshot (i.e.
	* on the next snapshot's deadlist). (Space killed before
	* this are already on our FBN.)
	*/
	uint64_t referenced, compressed, uncompressed;
	dsl_deadlist_space_range(&next->ds_deadlist,
	0, dbn->dbn_phys.zbm_creation_txg,
	&referenced, &compressed, &uncompressed);
	dbn->dbn_phys.zbm_referenced_freed_before_next_snap +=
	referenced;
	dbn->dbn_phys.zbm_compressed_freed_before_next_snap +=
	compressed;
	dbn->dbn_phys.zbm_uncompressed_freed_before_next_snap +=
	uncompressed;
	VERIFY0(zap_update(dp->dp_meta_objset, head->ds_bookmarks_obj,
	dbn->dbn_name, sizeof (uint64_t),
	sizeof (zfs_bookmark_phys_t) / sizeof (uint64_t),
	&dbn->dbn_phys, tx));
	}
	dsl_dataset_rele(next, FTAG);

	/*
	* There may be several bookmarks at this txg (the TXG of the
	* snapshot being deleted). We need to clear the SNAPSHOT_EXISTS
	* flag on all of them, and return TRUE if there is at least 1
	* bookmark here with HAS_FBN (thus preventing the deadlist
	* key from being removed).
	*/
	boolean_t rv = B_FALSE;
	for (; dbn != NULL && dbn->dbn_phys.zbm_creation_txg ==
	dsl_dataset_phys(ds)->ds_creation_txg;
	dbn = AVL_NEXT(&head->ds_bookmarks, dbn)) {
	if (!(dbn->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN)) {
	ASSERT(!(dbn->dbn_phys.zbm_flags &
	ZBM_FLAG_SNAPSHOT_EXISTS));
	continue;
	}
	ASSERT(dbn->dbn_phys.zbm_flags & ZBM_FLAG_SNAPSHOT_EXISTS);
	dbn->dbn_phys.zbm_flags &= ~ZBM_FLAG_SNAPSHOT_EXISTS;
	VERIFY0(zap_update(dp->dp_meta_objset, head->ds_bookmarks_obj,
	dbn->dbn_name, sizeof (uint64_t),
	sizeof (zfs_bookmark_phys_t) / sizeof (uint64_t),
	&dbn->dbn_phys, tx));
	rv = B_TRUE;
	}
	dsl_dataset_rele(head, FTAG);
	return (rv);
	}

	/*
	* A snapshot is being created of this (head) dataset.
	*
	* We don't keep keys in the deadlist for the most recent snapshot, or any
	* bookmarks at or after it, because there can't be any blocks on the
	* deadlist in this range. Now that the most recent snapshot is after
	* all bookmarks, we need to add these keys. Note that the caller always
	* adds a key at the previous snapshot, so we only add keys for bookmarks
	* after that.
	*/
	void
	dsl_bookmark_snapshotted(dsl_dataset_t ds, dmu_tx_t tx)
	{
	uint64_t last_key_added = UINT64_MAX;
	for (dsl_bookmark_node_t *dbn = avl_last(&ds->ds_bookmarks);
	dbn != NULL && dbn->dbn_phys.zbm_creation_txg >
	dsl_dataset_phys(ds)->ds_prev_snap_txg;
	dbn = AVL_PREV(&ds->ds_bookmarks, dbn)) {
	uint64_t creation_txg = dbn->dbn_phys.zbm_creation_txg;
	ASSERT3U(creation_txg, <=, last_key_added);
	/*
	* Note, there may be multiple bookmarks at this TXG,
	* and we only want to add the key for this TXG once.
	* The ds_bookmarks AVL is sorted by TXG, so we will visit
	* these bookmarks in sequence.
	*/
	if ((dbn->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN) &&
	creation_txg != last_key_added) {
	dsl_deadlist_add_key(&ds->ds_deadlist,
	creation_txg, tx);
	last_key_added = creation_txg;
	}
	}
	}

	/*
	* The next snapshot of the origin dataset has changed, due to
	* promote or clone swap. If there are any bookmarks at this dataset,
	* we need to update their zbm_*_freed_before_next_snap to reflect this.
	* The head dataset has the relevant bookmarks in ds_bookmarks.
	*/
	void
	dsl_bookmark_next_changed(dsl_dataset_t head, dsl_dataset_t origin,
	dmu_tx_t *tx)
	{
	dsl_pool_t *dp = dmu_tx_pool(tx);

	/*
	* Find the first bookmark that HAS_FBN at the origin snapshot.
	*/
	dsl_bookmark_node_t search = { 0 };
	avl_index_t idx;
	search.dbn_phys.zbm_creation_txg =
	dsl_dataset_phys(origin)->ds_creation_txg;
	search.dbn_phys.zbm_flags = ZBM_FLAG_HAS_FBN;
	/*
	* The empty-string name can't be in the AVL, and it compares
	* before any entries with this TXG.
	*/
	search.dbn_name = "";
	VERIFY3P(avl_find(&head->ds_bookmarks, &search, &idx), ==, NULL);
	dsl_bookmark_node_t *dbn =
	avl_nearest(&head->ds_bookmarks, idx, AVL_AFTER);

	/*
	* Iterate over all bookmarks that are at the origin txg.
	* Adjust their FBN based on their new next snapshot.
	*/
	for (; dbn != NULL && dbn->dbn_phys.zbm_creation_txg ==
	dsl_dataset_phys(origin)->ds_creation_txg &&
	(dbn->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN);
	dbn = AVL_NEXT(&head->ds_bookmarks, dbn)) {

	/*
	* Bookmark is at the origin, therefore its
	* "next dataset" is changing, so we need
	* to reset its FBN by recomputing it in
	* dsl_bookmark_set_phys().
	*/
	ASSERT3U(dbn->dbn_phys.zbm_guid, ==,
	dsl_dataset_phys(origin)->ds_guid);
	ASSERT3U(dbn->dbn_phys.zbm_referenced_bytes_refd, ==,
	dsl_dataset_phys(origin)->ds_referenced_bytes);
	ASSERT(dbn->dbn_phys.zbm_flags &
	ZBM_FLAG_SNAPSHOT_EXISTS);
	/*
	* Save and restore the zbm_redaction_obj, which
	* is zeroed by dsl_bookmark_set_phys().
	*/
	uint64_t redaction_obj =
	dbn->dbn_phys.zbm_redaction_obj;
	dsl_bookmark_set_phys(&dbn->dbn_phys, origin);
	dbn->dbn_phys.zbm_redaction_obj = redaction_obj;

	VERIFY0(zap_update(dp->dp_meta_objset, head->ds_bookmarks_obj,
	dbn->dbn_name, sizeof (uint64_t),
	sizeof (zfs_bookmark_phys_t) / sizeof (uint64_t),
	&dbn->dbn_phys, tx));
	}
	}

	/*
	* This block is no longer referenced by this (head) dataset.
	*
	* Adjust the FBN of any bookmarks that reference this block, whose "next"
	* is the head dataset.
	*/
	/* ARGSUSED */
	void
	dsl_bookmark_block_killed(dsl_dataset_t ds, const blkptr_t bp, dmu_tx_t *tx)
	{
	/*
	* Iterate over bookmarks whose "next" is the head dataset.
	*/
	for (dsl_bookmark_node_t *dbn = avl_last(&ds->ds_bookmarks);
	dbn != NULL && dbn->dbn_phys.zbm_creation_txg >=
	dsl_dataset_phys(ds)->ds_prev_snap_txg;
	dbn = AVL_PREV(&ds->ds_bookmarks, dbn)) {
	/*
	* If the block was live (referenced) at the time of this
	* bookmark, add its space to the bookmark's FBN.
	*/
	if (bp->blk_birth <= dbn->dbn_phys.zbm_creation_txg &&
	(dbn->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN)) {
	mutex_enter(&dbn->dbn_lock);
	dbn->dbn_phys.zbm_referenced_freed_before_next_snap +=
	bp_get_dsize_sync(dsl_dataset_get_spa(ds), bp);
	dbn->dbn_phys.zbm_compressed_freed_before_next_snap +=
	BP_GET_PSIZE(bp);
	dbn->dbn_phys.zbm_uncompressed_freed_before_next_snap +=
	BP_GET_UCSIZE(bp);
	/*
	* Changing the ZAP object here would be too
	* expensive. Also, we may be called from the zio
	* interrupt thread, which can't block on i/o.
	* Therefore, we mark this bookmark as dirty and
	* modify the ZAP once per txg, in
	* dsl_bookmark_sync_done().
	*/
	dbn->dbn_dirty = B_TRUE;
	mutex_exit(&dbn->dbn_lock);
	}
	}
	}

	void
	dsl_bookmark_sync_done(dsl_dataset_t ds, dmu_tx_t tx)
	{
	dsl_pool_t *dp = dmu_tx_pool(tx);

	if (dsl_dataset_is_snapshot(ds))
	return;

	/*
	* We only dirty bookmarks that are at or after the most recent
	* snapshot. We can't create snapshots between
	* dsl_bookmark_block_killed() and dsl_bookmark_sync_done(), so we
	* don't need to look at any bookmarks before ds_prev_snap_txg.
	*/
	for (dsl_bookmark_node_t *dbn = avl_last(&ds->ds_bookmarks);
	dbn != NULL && dbn->dbn_phys.zbm_creation_txg >=
	dsl_dataset_phys(ds)->ds_prev_snap_txg;
	dbn = AVL_PREV(&ds->ds_bookmarks, dbn)) {
	if (dbn->dbn_dirty) {
	/*
	* We only dirty nodes with HAS_FBN, therefore
	* we can always use the current bookmark struct size.
	*/
	ASSERT(dbn->dbn_phys.zbm_flags & ZBM_FLAG_HAS_FBN);
	VERIFY0(zap_update(dp->dp_meta_objset,
	ds->ds_bookmarks_obj,
	dbn->dbn_name, sizeof (uint64_t),
	sizeof (zfs_bookmark_phys_t) / sizeof (uint64_t),
	&dbn->dbn_phys, tx));
	dbn->dbn_dirty = B_FALSE;
	}
	}
	#ifdef ZFS_DEBUG
	for (dsl_bookmark_node_t *dbn = avl_first(&ds->ds_bookmarks);
	dbn != NULL; dbn = AVL_NEXT(&ds->ds_bookmarks, dbn)) {
	ASSERT(!dbn->dbn_dirty);
	}
	#endif
	}

	/*
	* Return the TXG of the most recent bookmark (or 0 if there are no bookmarks).
	*/
	uint64_t
	dsl_bookmark_latest_txg(dsl_dataset_t *ds)
	{
	ASSERT(dsl_pool_config_held(ds->ds_dir->dd_pool));
	dsl_bookmark_node_t *dbn = avl_last(&ds->ds_bookmarks);
	if (dbn == NULL)
	return (0);
	return (dbn->dbn_phys.zbm_creation_txg);
	}

	/*
	* Compare the redact_block_phys_t to the bookmark. If the last block in the
	* redact_block_phys_t is before the bookmark, return -1. If the first block in
	* the redact_block_phys_t is after the bookmark, return 1. Otherwise, the
	* bookmark is inside the range of the redact_block_phys_t, and we return 0.
	*/
	static int
	redact_block_zb_compare(redact_block_phys_t *first,
	zbookmark_phys_t *second)
	{
	/*
	* If the block_phys is for a previous object, or the last block in the
	* block_phys is strictly before the block in the bookmark, the
	* block_phys is earlier.
	*/
	if (first->rbp_object < second->zb_object \|\|
	(first->rbp_object == second->zb_object &&
	first->rbp_blkid + (redact_block_get_count(first) - 1) <
	second->zb_blkid)) {
	return (-1);
	}

	/*
	* If the bookmark is for a previous object, or the block in the
	* bookmark is strictly before the first block in the block_phys, the
	* bookmark is earlier.
	*/
	if (first->rbp_object > second->zb_object \|\|
	(first->rbp_object == second->zb_object &&
	first->rbp_blkid > second->zb_blkid)) {
	return (1);
	}

	return (0);
	}

	/*
	* Traverse the redaction list in the provided object, and call the callback for
	* each entry we find. Don't call the callback for any records before resume.
	*/
	int
	dsl_redaction_list_traverse(redaction_list_t rl, zbookmark_phys_t resume,
	rl_traverse_callback_t cb, void *arg)
	{
	objset_t *mos = rl->rl_mos;
	int err = 0;

	if (rl->rl_phys->rlp_last_object != UINT64_MAX \|\|
	rl->rl_phys->rlp_last_blkid != UINT64_MAX) {
	/*
	* When we finish a send, we update the last object and offset
	* to UINT64_MAX. If a send fails partway through, the last
	* object and offset will have some other value, indicating how
	* far the send got. The redaction list must be complete before
	* it can be traversed, so return EINVAL if the last object and
	* blkid are not set to UINT64_MAX.
	*/
	return (SET_ERROR(EINVAL));
	}

	/*
	* This allows us to skip the binary search and resume checking logic
	* below, if we're not resuming a redacted send.
	*/
	if (ZB_IS_ZERO(resume))
	resume = NULL;

	/*
	* Binary search for the point to resume from.
	*/
	uint64_t maxidx = rl->rl_phys->rlp_num_entries - 1;
	uint64_t minidx = 0;
	while (resume != NULL && maxidx > minidx) {
	redact_block_phys_t rbp = { 0 };
	ASSERT3U(maxidx, >, minidx);
	uint64_t mididx = minidx + ((maxidx - minidx) / 2);
	err = dmu_read(mos, rl->rl_object, mididx * sizeof (rbp),
	sizeof (rbp), &rbp, DMU_READ_NO_PREFETCH);
	if (err != 0)
	break;

	int cmp = redact_block_zb_compare(&rbp, resume);

	if (cmp == 0) {
	minidx = mididx;
	break;
	} else if (cmp > 0) {
	maxidx =
	(mididx == minidx ? minidx : mididx - 1);
	} else {
	minidx = mididx + 1;
	}
	}

	unsigned int bufsize = SPA_OLD_MAXBLOCKSIZE;
	redact_block_phys_t *buf = zio_data_buf_alloc(bufsize);

	unsigned int entries_per_buf = bufsize / sizeof (redact_block_phys_t);
	uint64_t start_block = minidx / entries_per_buf;
	err = dmu_read(mos, rl->rl_object, start_block * bufsize, bufsize, buf,
	DMU_READ_PREFETCH);

	for (uint64_t curidx = minidx;
	err == 0 && curidx < rl->rl_phys->rlp_num_entries;
	curidx++) {
	/*
	* We read in the redaction list one block at a time. Once we
	* finish with all the entries in a given block, we read in a
	* new one. The predictive prefetcher will take care of any
	* prefetching, and this code shouldn't be the bottleneck, so we
	* don't need to do manual prefetching.
	*/
	if (curidx % entries_per_buf == 0) {
	err = dmu_read(mos, rl->rl_object, curidx *
	sizeof (*buf), bufsize, buf,
	DMU_READ_PREFETCH);
	if (err != 0)
	break;
	}
	redact_block_phys_t *rb = &buf[curidx % entries_per_buf];
	/*
	* If resume is non-null, we should either not send the data, or
	* null out resume so we don't have to keep doing these
	* comparisons.
	*/
	if (resume != NULL) {
	/*
	* It is possible that after the binary search we got
	* a record before the resume point. There's two cases
	* where this can occur. If the record is the last
	* redaction record, and the resume point is after the
	* end of the redacted data, curidx will be the last
	* redaction record. In that case, the loop will end
	* after this iteration. The second case is if the
	* resume point is between two redaction records, the
	* binary search can return either the record before
	* or after the resume point. In that case, the next
	* iteration will be greater than the resume point.
	*/
	if (redact_block_zb_compare(rb, resume) < 0) {
	ASSERT3U(curidx, ==, minidx);
	continue;
	} else {
	/*
	* If the place to resume is in the middle of
	* the range described by this
	* redact_block_phys, then modify the
	* redact_block_phys in memory so we generate
	* the right records.
	*/
	if (resume->zb_object == rb->rbp_object &&
	resume->zb_blkid > rb->rbp_blkid) {
	uint64_t diff = resume->zb_blkid -
	rb->rbp_blkid;
	rb->rbp_blkid = resume->zb_blkid;
	redact_block_set_count(rb,
	redact_block_get_count(rb) - diff);
	}
	resume = NULL;
	}
	}

	if (cb(rb, arg) != 0) {
	err = EINTR;
	break;
	}
	}

	zio_data_buf_free(buf, bufsize);
	return (err);
	}
	diff --git a/sys/contrib/openzfs/module/zfs/dsl_crypt.c b/sys/contrib/openzfs/module/zfs/dsl_crypt.c
	index e38ec0cae827..26d4c2fe7e33 100644
	--- a/sys/contrib/openzfs/module/zfs/dsl_crypt.c
	+++ b/sys/contrib/openzfs/module/zfs/dsl_crypt.c
	@@ -1,2863 +1,2868 @@
	/*
	* CDDL HEADER START
	*
	* This file and its contents are supplied under the terms of the
	* Common Development and Distribution License ("CDDL"), version 1.0.
	* You may only use this file in accordance with the terms of version
	* 1.0 of the CDDL.
	*
	* A full copy of the text of the CDDL should have accompanied this
	* source. A copy of the CDDL is also available via the Internet at
	* http://www.illumos.org/license/CDDL.
	*
	* CDDL HEADER END
	*/

	/*
	* Copyright (c) 2017, Datto, Inc. All rights reserved.
	* Copyright (c) 2018 by Delphix. All rights reserved.
	*/

	#include <sys/dsl_crypt.h>
	#include <sys/dsl_pool.h>
	#include <sys/zap.h>
	#include <sys/zil.h>
	#include <sys/dsl_dir.h>
	#include <sys/dsl_prop.h>
	#include <sys/spa_impl.h>
	#include <sys/dmu_objset.h>
	#include <sys/zvol.h>

	/*
	* This file's primary purpose is for managing master encryption keys in
	* memory and on disk. For more info on how these keys are used, see the
	* block comment in zio_crypt.c.
	*
	* All master keys are stored encrypted on disk in the form of the DSL
	* Crypto Key ZAP object. The binary key data in this object is always
	* randomly generated and is encrypted with the user's wrapping key. This
	* layer of indirection allows the user to change their key without
	* needing to re-encrypt the entire dataset. The ZAP also holds on to the
	* (non-encrypted) encryption algorithm identifier, IV, and MAC needed to
	* safely decrypt the master key. For more info on the user's key see the
	* block comment in libzfs_crypto.c
	*
	* In-memory encryption keys are managed through the spa_keystore. The
	* keystore consists of 3 AVL trees, which are as follows:
	*
	* The Wrapping Key Tree:
	* The wrapping key (wkey) tree stores the user's keys that are fed into the
	* kernel through 'zfs load-key' and related commands. Datasets inherit their
	* parent's wkey by default, so these structures are refcounted. The wrapping
	* keys remain in memory until they are explicitly unloaded (with
	* "zfs unload-key"). Unloading is only possible when no datasets are using
	* them (refcount=0).
	*
	* The DSL Crypto Key Tree:
	* The DSL Crypto Keys (DCK) are the in-memory representation of decrypted
	* master keys. They are used by the functions in zio_crypt.c to perform
	* encryption, decryption, and authentication. Snapshots and clones of a given
	* dataset will share a DSL Crypto Key, so they are also refcounted. Once the
	* refcount on a key hits zero, it is immediately zeroed out and freed.
	*
	* The Crypto Key Mapping Tree:
	* The zio layer needs to lookup master keys by their dataset object id. Since
	* the DSL Crypto Keys can belong to multiple datasets, we maintain a tree of
	* dsl_key_mapping_t's which essentially just map the dataset object id to its
	* appropriate DSL Crypto Key. The management for creating and destroying these
	* mappings hooks into the code for owning and disowning datasets. Usually,
	* there will only be one active dataset owner, but there are times
	* (particularly during dataset creation and destruction) when this may not be
	* true or the dataset may not be initialized enough to own. As a result, this
	* object is also refcounted.
	*/

	/*
	* This tunable allows datasets to be raw received even if the stream does
	* not include IVset guids or if the guids don't match. This is used as part
	* of the resolution for ZPOOL_ERRATA_ZOL_8308_ENCRYPTION.
	*/
	int zfs_disable_ivset_guid_check = 0;

	static void
	dsl_wrapping_key_hold(dsl_wrapping_key_t wkey, void tag)
	{
	(void) zfs_refcount_add(&wkey->wk_refcnt, tag);
	}

	static void
	dsl_wrapping_key_rele(dsl_wrapping_key_t wkey, void tag)
	{
	(void) zfs_refcount_remove(&wkey->wk_refcnt, tag);
	}

	static void
	dsl_wrapping_key_free(dsl_wrapping_key_t *wkey)
	{
	ASSERT0(zfs_refcount_count(&wkey->wk_refcnt));

	if (wkey->wk_key.ck_data) {
	bzero(wkey->wk_key.ck_data,
	CRYPTO_BITS2BYTES(wkey->wk_key.ck_length));
	kmem_free(wkey->wk_key.ck_data,
	CRYPTO_BITS2BYTES(wkey->wk_key.ck_length));
	}

	zfs_refcount_destroy(&wkey->wk_refcnt);
	kmem_free(wkey, sizeof (dsl_wrapping_key_t));
	}

	static void
	dsl_wrapping_key_create(uint8_t *wkeydata, zfs_keyformat_t keyformat,
	uint64_t salt, uint64_t iters, dsl_wrapping_key_t **wkey_out)
	{
	dsl_wrapping_key_t *wkey;

	/* allocate the wrapping key */
	wkey = kmem_alloc(sizeof (dsl_wrapping_key_t), KM_SLEEP);

	/* allocate and initialize the underlying crypto key */
	wkey->wk_key.ck_data = kmem_alloc(WRAPPING_KEY_LEN, KM_SLEEP);

	wkey->wk_key.ck_format = CRYPTO_KEY_RAW;
	wkey->wk_key.ck_length = CRYPTO_BYTES2BITS(WRAPPING_KEY_LEN);
	bcopy(wkeydata, wkey->wk_key.ck_data, WRAPPING_KEY_LEN);

	/* initialize the rest of the struct */
	zfs_refcount_create(&wkey->wk_refcnt);
	wkey->wk_keyformat = keyformat;
	wkey->wk_salt = salt;
	wkey->wk_iters = iters;

	*wkey_out = wkey;
	}

	int
	dsl_crypto_params_create_nvlist(dcp_cmd_t cmd, nvlist_t *props,
	nvlist_t crypto_args, dsl_crypto_params_t *dcp_out)
	{
	int ret;
	uint64_t crypt = ZIO_CRYPT_INHERIT;
	uint64_t keyformat = ZFS_KEYFORMAT_NONE;
	uint64_t salt = 0, iters = 0;
	dsl_crypto_params_t *dcp = NULL;
	dsl_wrapping_key_t *wkey = NULL;
	uint8_t *wkeydata = NULL;
	uint_t wkeydata_len = 0;
	char *keylocation = NULL;

	dcp = kmem_zalloc(sizeof (dsl_crypto_params_t), KM_SLEEP);
	dcp->cp_cmd = cmd;

	/* get relevant arguments from the nvlists */
	if (props != NULL) {
	(void) nvlist_lookup_uint64(props,
	zfs_prop_to_name(ZFS_PROP_ENCRYPTION), &crypt);
	(void) nvlist_lookup_uint64(props,
	zfs_prop_to_name(ZFS_PROP_KEYFORMAT), &keyformat);
	(void) nvlist_lookup_string(props,
	zfs_prop_to_name(ZFS_PROP_KEYLOCATION), &keylocation);
	(void) nvlist_lookup_uint64(props,
	zfs_prop_to_name(ZFS_PROP_PBKDF2_SALT), &salt);
	(void) nvlist_lookup_uint64(props,
	zfs_prop_to_name(ZFS_PROP_PBKDF2_ITERS), &iters);

	dcp->cp_crypt = crypt;
	}

	if (crypto_args != NULL) {
	(void) nvlist_lookup_uint8_array(crypto_args, "wkeydata",
	&wkeydata, &wkeydata_len);
	}

	/* check for valid command */
	if (dcp->cp_cmd >= DCP_CMD_MAX) {
	ret = SET_ERROR(EINVAL);
	goto error;
	} else {
	dcp->cp_cmd = cmd;
	}

	/* check for valid crypt */
	if (dcp->cp_crypt >= ZIO_CRYPT_FUNCTIONS) {
	ret = SET_ERROR(EINVAL);
	goto error;
	} else {
	dcp->cp_crypt = crypt;
	}

	/* check for valid keyformat */
	if (keyformat >= ZFS_KEYFORMAT_FORMATS) {
	ret = SET_ERROR(EINVAL);
	goto error;
	}

	/* check for a valid keylocation (of any kind) and copy it in */
	if (keylocation != NULL) {
	if (!zfs_prop_valid_keylocation(keylocation, B_FALSE)) {
	ret = SET_ERROR(EINVAL);
	goto error;
	}

	dcp->cp_keylocation = spa_strdup(keylocation);
	}

	/* check wrapping key length, if given */
	if (wkeydata != NULL && wkeydata_len != WRAPPING_KEY_LEN) {
	ret = SET_ERROR(EINVAL);
	goto error;
	}

	/* if the user asked for the default crypt, determine that now */
	if (dcp->cp_crypt == ZIO_CRYPT_ON)
	dcp->cp_crypt = ZIO_CRYPT_ON_VALUE;

	/* create the wrapping key from the raw data */
	if (wkeydata != NULL) {
	/* create the wrapping key with the verified parameters */
	dsl_wrapping_key_create(wkeydata, keyformat, salt,
	iters, &wkey);
	dcp->cp_wkey = wkey;
	}

	/*
	* Remove the encryption properties from the nvlist since they are not
	* maintained through the DSL.
	*/
	(void) nvlist_remove_all(props, zfs_prop_to_name(ZFS_PROP_ENCRYPTION));
	(void) nvlist_remove_all(props, zfs_prop_to_name(ZFS_PROP_KEYFORMAT));
	(void) nvlist_remove_all(props, zfs_prop_to_name(ZFS_PROP_PBKDF2_SALT));
	(void) nvlist_remove_all(props,
	zfs_prop_to_name(ZFS_PROP_PBKDF2_ITERS));

	*dcp_out = dcp;

	return (0);

	error:
	kmem_free(dcp, sizeof (dsl_crypto_params_t));
	*dcp_out = NULL;
	return (ret);
	}

	void
	dsl_crypto_params_free(dsl_crypto_params_t *dcp, boolean_t unload)
	{
	if (dcp == NULL)
	return;

	if (dcp->cp_keylocation != NULL)
	spa_strfree(dcp->cp_keylocation);
	if (unload && dcp->cp_wkey != NULL)
	dsl_wrapping_key_free(dcp->cp_wkey);

	kmem_free(dcp, sizeof (dsl_crypto_params_t));
	}

	static int
	spa_crypto_key_compare(const void a, const void b)
	{
	const dsl_crypto_key_t *dcka = a;
	const dsl_crypto_key_t *dckb = b;

	if (dcka->dck_obj < dckb->dck_obj)
	return (-1);
	if (dcka->dck_obj > dckb->dck_obj)
	return (1);
	return (0);
	}

	static int
	spa_key_mapping_compare(const void a, const void b)
	{
	const dsl_key_mapping_t *kma = a;
	const dsl_key_mapping_t *kmb = b;

	if (kma->km_dsobj < kmb->km_dsobj)
	return (-1);
	if (kma->km_dsobj > kmb->km_dsobj)
	return (1);
	return (0);
	}

	static int
	spa_wkey_compare(const void a, const void b)
	{
	const dsl_wrapping_key_t *wka = a;
	const dsl_wrapping_key_t *wkb = b;

	if (wka->wk_ddobj < wkb->wk_ddobj)
	return (-1);
	if (wka->wk_ddobj > wkb->wk_ddobj)
	return (1);
	return (0);
	}

	void
	spa_keystore_init(spa_keystore_t *sk)
	{
	rw_init(&sk->sk_dk_lock, NULL, RW_DEFAULT, NULL);
	rw_init(&sk->sk_km_lock, NULL, RW_DEFAULT, NULL);
	rw_init(&sk->sk_wkeys_lock, NULL, RW_DEFAULT, NULL);
	avl_create(&sk->sk_dsl_keys, spa_crypto_key_compare,
	sizeof (dsl_crypto_key_t),
	offsetof(dsl_crypto_key_t, dck_avl_link));
	avl_create(&sk->sk_key_mappings, spa_key_mapping_compare,
	sizeof (dsl_key_mapping_t),
	offsetof(dsl_key_mapping_t, km_avl_link));
	avl_create(&sk->sk_wkeys, spa_wkey_compare, sizeof (dsl_wrapping_key_t),
	offsetof(dsl_wrapping_key_t, wk_avl_link));
	}

	void
	spa_keystore_fini(spa_keystore_t *sk)
	{
	dsl_wrapping_key_t *wkey;
	void *cookie = NULL;

	ASSERT(avl_is_empty(&sk->sk_dsl_keys));
	ASSERT(avl_is_empty(&sk->sk_key_mappings));

	while ((wkey = avl_destroy_nodes(&sk->sk_wkeys, &cookie)) != NULL)
	dsl_wrapping_key_free(wkey);

	avl_destroy(&sk->sk_wkeys);
	avl_destroy(&sk->sk_key_mappings);
	avl_destroy(&sk->sk_dsl_keys);
	rw_destroy(&sk->sk_wkeys_lock);
	rw_destroy(&sk->sk_km_lock);
	rw_destroy(&sk->sk_dk_lock);
	}

	static int
	dsl_dir_get_encryption_root_ddobj(dsl_dir_t dd, uint64_t rddobj)
	{
	if (dd->dd_crypto_obj == 0)
	return (SET_ERROR(ENOENT));

	return (zap_lookup(dd->dd_pool->dp_meta_objset, dd->dd_crypto_obj,
	DSL_CRYPTO_KEY_ROOT_DDOBJ, 8, 1, rddobj));
	}

	static int
	dsl_dir_get_encryption_version(dsl_dir_t dd, uint64_t version)
	{
	*version = 0;

	if (dd->dd_crypto_obj == 0)
	return (SET_ERROR(ENOENT));

	/* version 0 is implied by ENOENT */
	(void) zap_lookup(dd->dd_pool->dp_meta_objset, dd->dd_crypto_obj,
	DSL_CRYPTO_KEY_VERSION, 8, 1, version);

	return (0);
	}

	boolean_t
	dsl_dir_incompatible_encryption_version(dsl_dir_t *dd)
	{
	int ret;
	uint64_t version = 0;

	ret = dsl_dir_get_encryption_version(dd, &version);
	if (ret != 0)
	return (B_FALSE);

	return (version != ZIO_CRYPT_KEY_CURRENT_VERSION);
	}

	static int
	spa_keystore_wkey_hold_ddobj_impl(spa_t *spa, uint64_t ddobj,
	void tag, dsl_wrapping_key_t *wkey_out)
	{
	int ret;
	dsl_wrapping_key_t search_wkey;
	dsl_wrapping_key_t *found_wkey;

	ASSERT(RW_LOCK_HELD(&spa->spa_keystore.sk_wkeys_lock));

	/* init the search wrapping key */
	search_wkey.wk_ddobj = ddobj;

	/* lookup the wrapping key */
	found_wkey = avl_find(&spa->spa_keystore.sk_wkeys, &search_wkey, NULL);
	if (!found_wkey) {
	ret = SET_ERROR(ENOENT);
	goto error;
	}

	/* increment the refcount */
	dsl_wrapping_key_hold(found_wkey, tag);

	*wkey_out = found_wkey;
	return (0);

	error:
	*wkey_out = NULL;
	return (ret);
	}

	static int
	spa_keystore_wkey_hold_dd(spa_t spa, dsl_dir_t dd, void *tag,
	dsl_wrapping_key_t **wkey_out)
	{
	int ret;
	dsl_wrapping_key_t *wkey;
	uint64_t rddobj;
	boolean_t locked = B_FALSE;

	if (!RW_WRITE_HELD(&spa->spa_keystore.sk_wkeys_lock)) {
	rw_enter(&spa->spa_keystore.sk_wkeys_lock, RW_READER);
	locked = B_TRUE;
	}

	/* get the ddobj that the keylocation property was inherited from */
	ret = dsl_dir_get_encryption_root_ddobj(dd, &rddobj);
	if (ret != 0)
	goto error;

	/* lookup the wkey in the avl tree */
	ret = spa_keystore_wkey_hold_ddobj_impl(spa, rddobj, tag, &wkey);
	if (ret != 0)
	goto error;

	/* unlock the wkey tree if we locked it */
	if (locked)
	rw_exit(&spa->spa_keystore.sk_wkeys_lock);

	*wkey_out = wkey;
	return (0);

	error:
	if (locked)
	rw_exit(&spa->spa_keystore.sk_wkeys_lock);

	*wkey_out = NULL;
	return (ret);
	}

	int
	dsl_crypto_can_set_keylocation(const char dsname, const char keylocation)
	{
	int ret = 0;
	dsl_dir_t *dd = NULL;
	dsl_pool_t *dp = NULL;
	uint64_t rddobj;

	/* hold the dsl dir */
	ret = dsl_pool_hold(dsname, FTAG, &dp);
	if (ret != 0)
	goto out;

	ret = dsl_dir_hold(dp, dsname, FTAG, &dd, NULL);
	if (ret != 0) {
	dd = NULL;
	goto out;
	}

	/* if dd is not encrypted, the value may only be "none" */
	if (dd->dd_crypto_obj == 0) {
	if (strcmp(keylocation, "none") != 0) {
	ret = SET_ERROR(EACCES);
	goto out;
	}

	ret = 0;
	goto out;
	}

	/* check for a valid keylocation for encrypted datasets */
	if (!zfs_prop_valid_keylocation(keylocation, B_TRUE)) {
	ret = SET_ERROR(EINVAL);
	goto out;
	}

	/* check that this is an encryption root */
	ret = dsl_dir_get_encryption_root_ddobj(dd, &rddobj);
	if (ret != 0)
	goto out;

	if (rddobj != dd->dd_object) {
	ret = SET_ERROR(EACCES);
	goto out;
	}

	dsl_dir_rele(dd, FTAG);
	dsl_pool_rele(dp, FTAG);

	return (0);

	out:
	if (dd != NULL)
	dsl_dir_rele(dd, FTAG);
	if (dp != NULL)
	dsl_pool_rele(dp, FTAG);

	return (ret);
	}

	static void
	dsl_crypto_key_free(dsl_crypto_key_t *dck)
	{
	ASSERT(zfs_refcount_count(&dck->dck_holds) == 0);

	/* destroy the zio_crypt_key_t */
	zio_crypt_key_destroy(&dck->dck_key);

	/* free the refcount, wrapping key, and lock */
	zfs_refcount_destroy(&dck->dck_holds);
	if (dck->dck_wkey)
	dsl_wrapping_key_rele(dck->dck_wkey, dck);

	/* free the key */
	kmem_free(dck, sizeof (dsl_crypto_key_t));
	}

	static void
	dsl_crypto_key_rele(dsl_crypto_key_t dck, void tag)
	{
	if (zfs_refcount_remove(&dck->dck_holds, tag) == 0)
	dsl_crypto_key_free(dck);
	}

	static int
	dsl_crypto_key_open(objset_t mos, dsl_wrapping_key_t wkey,
	uint64_t dckobj, void tag, dsl_crypto_key_t *dck_out)
	{
	int ret;
	uint64_t crypt = 0, guid = 0, version = 0;
	uint8_t raw_keydata[MASTER_KEY_MAX_LEN];
	uint8_t raw_hmac_keydata[SHA512_HMAC_KEYLEN];
	uint8_t iv[WRAPPING_IV_LEN];
	uint8_t mac[WRAPPING_MAC_LEN];
	dsl_crypto_key_t *dck;

	/* allocate and initialize the key */
	dck = kmem_zalloc(sizeof (dsl_crypto_key_t), KM_SLEEP);

	/* fetch all of the values we need from the ZAP */
	ret = zap_lookup(mos, dckobj, DSL_CRYPTO_KEY_CRYPTO_SUITE, 8, 1,
	&crypt);
	if (ret != 0)
	goto error;

	ret = zap_lookup(mos, dckobj, DSL_CRYPTO_KEY_GUID, 8, 1, &guid);
	if (ret != 0)
	goto error;

	ret = zap_lookup(mos, dckobj, DSL_CRYPTO_KEY_MASTER_KEY, 1,
	MASTER_KEY_MAX_LEN, raw_keydata);
	if (ret != 0)
	goto error;

	ret = zap_lookup(mos, dckobj, DSL_CRYPTO_KEY_HMAC_KEY, 1,
	SHA512_HMAC_KEYLEN, raw_hmac_keydata);
	if (ret != 0)
	goto error;

	ret = zap_lookup(mos, dckobj, DSL_CRYPTO_KEY_IV, 1, WRAPPING_IV_LEN,
	iv);
	if (ret != 0)
	goto error;

	ret = zap_lookup(mos, dckobj, DSL_CRYPTO_KEY_MAC, 1, WRAPPING_MAC_LEN,
	mac);
	if (ret != 0)
	goto error;

	/* the initial on-disk format for encryption did not have a version */
	(void) zap_lookup(mos, dckobj, DSL_CRYPTO_KEY_VERSION, 8, 1, &version);

	/*
	* Unwrap the keys. If there is an error return EACCES to indicate
	* an authentication failure.
	*/
	ret = zio_crypt_key_unwrap(&wkey->wk_key, crypt, version, guid,
	raw_keydata, raw_hmac_keydata, iv, mac, &dck->dck_key);
	if (ret != 0) {
	ret = SET_ERROR(EACCES);
	goto error;
	}

	/* finish initializing the dsl_crypto_key_t */
	zfs_refcount_create(&dck->dck_holds);
	dsl_wrapping_key_hold(wkey, dck);
	dck->dck_wkey = wkey;
	dck->dck_obj = dckobj;
	zfs_refcount_add(&dck->dck_holds, tag);

	*dck_out = dck;
	return (0);

	error:
	if (dck != NULL) {
	bzero(dck, sizeof (dsl_crypto_key_t));
	kmem_free(dck, sizeof (dsl_crypto_key_t));
	}

	*dck_out = NULL;
	return (ret);
	}

	static int
	spa_keystore_dsl_key_hold_impl(spa_t spa, uint64_t dckobj, void tag,
	dsl_crypto_key_t **dck_out)
	{
	int ret;
	dsl_crypto_key_t search_dck;
	dsl_crypto_key_t *found_dck;

	ASSERT(RW_LOCK_HELD(&spa->spa_keystore.sk_dk_lock));

	/* init the search key */
	search_dck.dck_obj = dckobj;

	/* find the matching key in the keystore */
	found_dck = avl_find(&spa->spa_keystore.sk_dsl_keys, &search_dck, NULL);
	if (!found_dck) {
	ret = SET_ERROR(ENOENT);
	goto error;
	}

	/* increment the refcount */
	zfs_refcount_add(&found_dck->dck_holds, tag);

	*dck_out = found_dck;
	return (0);

	error:
	*dck_out = NULL;
	return (ret);
	}

	static int
	spa_keystore_dsl_key_hold_dd(spa_t spa, dsl_dir_t dd, void *tag,
	dsl_crypto_key_t **dck_out)
	{
	int ret;
	avl_index_t where;
	dsl_crypto_key_t dck_io = NULL, dck_ks = NULL;
	dsl_wrapping_key_t *wkey = NULL;
	uint64_t dckobj = dd->dd_crypto_obj;

	/* Lookup the key in the tree of currently loaded keys */
	rw_enter(&spa->spa_keystore.sk_dk_lock, RW_READER);
	ret = spa_keystore_dsl_key_hold_impl(spa, dckobj, tag, &dck_ks);
	rw_exit(&spa->spa_keystore.sk_dk_lock);
	if (ret == 0) {
	*dck_out = dck_ks;
	return (0);
	}

	/* Lookup the wrapping key from the keystore */
	ret = spa_keystore_wkey_hold_dd(spa, dd, FTAG, &wkey);
	if (ret != 0) {
	*dck_out = NULL;
	return (SET_ERROR(EACCES));
	}

	/* Read the key from disk */
	ret = dsl_crypto_key_open(spa->spa_meta_objset, wkey, dckobj,
	tag, &dck_io);
	if (ret != 0) {
	dsl_wrapping_key_rele(wkey, FTAG);
	*dck_out = NULL;
	return (ret);
	}

	/*
	* Add the key to the keystore. It may already exist if it was
	* added while performing the read from disk. In this case discard
	* it and return the key from the keystore.
	*/
	rw_enter(&spa->spa_keystore.sk_dk_lock, RW_WRITER);
	ret = spa_keystore_dsl_key_hold_impl(spa, dckobj, tag, &dck_ks);
	if (ret != 0) {
	avl_find(&spa->spa_keystore.sk_dsl_keys, dck_io, &where);
	avl_insert(&spa->spa_keystore.sk_dsl_keys, dck_io, where);
	*dck_out = dck_io;
	} else {
	dsl_crypto_key_free(dck_io);
	*dck_out = dck_ks;
	}

	/* Release the wrapping key (the dsl key now has a reference to it) */
	dsl_wrapping_key_rele(wkey, FTAG);
	rw_exit(&spa->spa_keystore.sk_dk_lock);

	return (0);
	}

	void
	spa_keystore_dsl_key_rele(spa_t spa, dsl_crypto_key_t dck, void *tag)
	{
	rw_enter(&spa->spa_keystore.sk_dk_lock, RW_WRITER);

	if (zfs_refcount_remove(&dck->dck_holds, tag) == 0) {
	avl_remove(&spa->spa_keystore.sk_dsl_keys, dck);
	dsl_crypto_key_free(dck);
	}

	rw_exit(&spa->spa_keystore.sk_dk_lock);
	}

	int
	spa_keystore_load_wkey_impl(spa_t spa, dsl_wrapping_key_t wkey)
	{
	int ret;
	avl_index_t where;
	dsl_wrapping_key_t *found_wkey;

	rw_enter(&spa->spa_keystore.sk_wkeys_lock, RW_WRITER);

	/* insert the wrapping key into the keystore */
	found_wkey = avl_find(&spa->spa_keystore.sk_wkeys, wkey, &where);
	if (found_wkey != NULL) {
	ret = SET_ERROR(EEXIST);
	goto error_unlock;
	}
	avl_insert(&spa->spa_keystore.sk_wkeys, wkey, where);

	rw_exit(&spa->spa_keystore.sk_wkeys_lock);

	return (0);

	error_unlock:
	rw_exit(&spa->spa_keystore.sk_wkeys_lock);
	return (ret);
	}

	int
	spa_keystore_load_wkey(const char dsname, dsl_crypto_params_t dcp,
	boolean_t noop)
	{
	int ret;
	dsl_dir_t *dd = NULL;
	dsl_crypto_key_t *dck = NULL;
	dsl_wrapping_key_t *wkey = dcp->cp_wkey;
	dsl_pool_t *dp = NULL;
	uint64_t rddobj, keyformat, salt, iters;

	/*
	* We don't validate the wrapping key's keyformat, salt, or iters
	* since they will never be needed after the DCK has been wrapped.
	*/
	if (dcp->cp_wkey == NULL \|\|
	dcp->cp_cmd != DCP_CMD_NONE \|\|
	dcp->cp_crypt != ZIO_CRYPT_INHERIT \|\|
	dcp->cp_keylocation != NULL)
	return (SET_ERROR(EINVAL));

	ret = dsl_pool_hold(dsname, FTAG, &dp);
	if (ret != 0)
	goto error;

	if (!spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_ENCRYPTION)) {
	ret = SET_ERROR(ENOTSUP);
	goto error;
	}

	/* hold the dsl dir */
	ret = dsl_dir_hold(dp, dsname, FTAG, &dd, NULL);
	if (ret != 0) {
	dd = NULL;
	goto error;
	}

	/* confirm that dd is the encryption root */
	ret = dsl_dir_get_encryption_root_ddobj(dd, &rddobj);
	if (ret != 0 \|\| rddobj != dd->dd_object) {
	ret = SET_ERROR(EINVAL);
	goto error;
	}

	/* initialize the wkey's ddobj */
	wkey->wk_ddobj = dd->dd_object;

	/* verify that the wkey is correct by opening its dsl key */
	ret = dsl_crypto_key_open(dp->dp_meta_objset, wkey,
	dd->dd_crypto_obj, FTAG, &dck);
	if (ret != 0)
	goto error;

	/* initialize the wkey encryption parameters from the DSL Crypto Key */
	ret = zap_lookup(dp->dp_meta_objset, dd->dd_crypto_obj,
	zfs_prop_to_name(ZFS_PROP_KEYFORMAT), 8, 1, &keyformat);
	if (ret != 0)
	goto error;

	ret = zap_lookup(dp->dp_meta_objset, dd->dd_crypto_obj,
	zfs_prop_to_name(ZFS_PROP_PBKDF2_SALT), 8, 1, &salt);
	if (ret != 0)
	goto error;

	ret = zap_lookup(dp->dp_meta_objset, dd->dd_crypto_obj,
	zfs_prop_to_name(ZFS_PROP_PBKDF2_ITERS), 8, 1, &iters);
	if (ret != 0)
	goto error;

	ASSERT3U(keyformat, <, ZFS_KEYFORMAT_FORMATS);
	ASSERT3U(keyformat, !=, ZFS_KEYFORMAT_NONE);
	IMPLY(keyformat == ZFS_KEYFORMAT_PASSPHRASE, iters != 0);
	IMPLY(keyformat == ZFS_KEYFORMAT_PASSPHRASE, salt != 0);
	IMPLY(keyformat != ZFS_KEYFORMAT_PASSPHRASE, iters == 0);
	IMPLY(keyformat != ZFS_KEYFORMAT_PASSPHRASE, salt == 0);

	wkey->wk_keyformat = keyformat;
	wkey->wk_salt = salt;
	wkey->wk_iters = iters;

	/*
	* At this point we have verified the wkey and confirmed that it can
	* be used to decrypt a DSL Crypto Key. We can simply cleanup and
	* return if this is all the user wanted to do.
	*/
	if (noop)
	goto error;

	/* insert the wrapping key into the keystore */
	ret = spa_keystore_load_wkey_impl(dp->dp_spa, wkey);
	if (ret != 0)
	goto error;

	dsl_crypto_key_rele(dck, FTAG);
	dsl_dir_rele(dd, FTAG);
	dsl_pool_rele(dp, FTAG);

	/* create any zvols under this ds */
	zvol_create_minors_recursive(dsname);

	return (0);

	error:
	if (dck != NULL)
	dsl_crypto_key_rele(dck, FTAG);
	if (dd != NULL)
	dsl_dir_rele(dd, FTAG);
	if (dp != NULL)
	dsl_pool_rele(dp, FTAG);

	return (ret);
	}

	int
	spa_keystore_unload_wkey_impl(spa_t *spa, uint64_t ddobj)
	{
	int ret;
	dsl_wrapping_key_t search_wkey;
	dsl_wrapping_key_t *found_wkey;

	/* init the search wrapping key */
	search_wkey.wk_ddobj = ddobj;

	rw_enter(&spa->spa_keystore.sk_wkeys_lock, RW_WRITER);

	/* remove the wrapping key from the keystore */
	found_wkey = avl_find(&spa->spa_keystore.sk_wkeys,
	&search_wkey, NULL);
	if (!found_wkey) {
	ret = SET_ERROR(EACCES);
	goto error_unlock;
	} else if (zfs_refcount_count(&found_wkey->wk_refcnt) != 0) {
	ret = SET_ERROR(EBUSY);
	goto error_unlock;
	}
	avl_remove(&spa->spa_keystore.sk_wkeys, found_wkey);

	rw_exit(&spa->spa_keystore.sk_wkeys_lock);

	/* free the wrapping key */
	dsl_wrapping_key_free(found_wkey);

	return (0);

	error_unlock:
	rw_exit(&spa->spa_keystore.sk_wkeys_lock);
	return (ret);
	}

	int
	spa_keystore_unload_wkey(const char *dsname)
	{
	int ret = 0;
	dsl_dir_t *dd = NULL;
	dsl_pool_t *dp = NULL;
	spa_t *spa = NULL;

	ret = spa_open(dsname, &spa, FTAG);
	if (ret != 0)
	return (ret);

	/*
	* Wait for any outstanding txg IO to complete, releasing any
	* remaining references on the wkey.
	*/
	if (spa_mode(spa) != SPA_MODE_READ)
	txg_wait_synced(spa->spa_dsl_pool, 0);

	spa_close(spa, FTAG);

	/* hold the dsl dir */
	ret = dsl_pool_hold(dsname, FTAG, &dp);
	if (ret != 0)
	goto error;

	if (!spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_ENCRYPTION)) {
	ret = (SET_ERROR(ENOTSUP));
	goto error;
	}

	ret = dsl_dir_hold(dp, dsname, FTAG, &dd, NULL);
	if (ret != 0) {
	dd = NULL;
	goto error;
	}

	/* unload the wkey */
	ret = spa_keystore_unload_wkey_impl(dp->dp_spa, dd->dd_object);
	if (ret != 0)
	goto error;

	dsl_dir_rele(dd, FTAG);
	dsl_pool_rele(dp, FTAG);

	/* remove any zvols under this ds */
	zvol_remove_minors(dp->dp_spa, dsname, B_TRUE);

	return (0);

	error:
	if (dd != NULL)
	dsl_dir_rele(dd, FTAG);
	if (dp != NULL)
	dsl_pool_rele(dp, FTAG);

	return (ret);
	}

	void
	key_mapping_add_ref(dsl_key_mapping_t km, void tag)
	{
	ASSERT3U(zfs_refcount_count(&km->km_refcnt), >=, 1);
	zfs_refcount_add(&km->km_refcnt, tag);
	}

	/*
	* The locking here is a little tricky to ensure we don't cause unnecessary
	* performance problems. We want to release a key mapping whenever someone
	* decrements the refcount to 0, but freeing the mapping requires removing
	* it from the spa_keystore, which requires holding sk_km_lock as a writer.
	* Most of the time we don't want to hold this lock as a writer, since the
	* same lock is held as a reader for each IO that needs to encrypt / decrypt
	* data for any dataset and in practice we will only actually free the
	* mapping after unmounting a dataset.
	*/
	void
	key_mapping_rele(spa_t spa, dsl_key_mapping_t km, void *tag)
	{
	ASSERT3U(zfs_refcount_count(&km->km_refcnt), >=, 1);

	if (zfs_refcount_remove(&km->km_refcnt, tag) != 0)
	return;

	/*
	* We think we are going to need to free the mapping. Add a
	* reference to prevent most other releasers from thinking
	* this might be their responsibility. This is inherently
	* racy, so we will confirm that we are legitimately the
	* last holder once we have the sk_km_lock as a writer.
	*/
	zfs_refcount_add(&km->km_refcnt, FTAG);

	rw_enter(&spa->spa_keystore.sk_km_lock, RW_WRITER);
	if (zfs_refcount_remove(&km->km_refcnt, FTAG) != 0) {
	rw_exit(&spa->spa_keystore.sk_km_lock);
	return;
	}

	avl_remove(&spa->spa_keystore.sk_key_mappings, km);
	rw_exit(&spa->spa_keystore.sk_km_lock);

	spa_keystore_dsl_key_rele(spa, km->km_key, km);
	zfs_refcount_destroy(&km->km_refcnt);
	kmem_free(km, sizeof (dsl_key_mapping_t));
	}

	int
	spa_keystore_create_mapping(spa_t spa, dsl_dataset_t ds, void *tag,
	dsl_key_mapping_t **km_out)
	{
	int ret;
	avl_index_t where;
	dsl_key_mapping_t km, found_km;
	boolean_t should_free = B_FALSE;

	/* Allocate and initialize the mapping */
	km = kmem_zalloc(sizeof (dsl_key_mapping_t), KM_SLEEP);
	zfs_refcount_create(&km->km_refcnt);

	ret = spa_keystore_dsl_key_hold_dd(spa, ds->ds_dir, km, &km->km_key);
	if (ret != 0) {
	zfs_refcount_destroy(&km->km_refcnt);
	kmem_free(km, sizeof (dsl_key_mapping_t));

	if (km_out != NULL)
	*km_out = NULL;
	return (ret);
	}

	km->km_dsobj = ds->ds_object;

	rw_enter(&spa->spa_keystore.sk_km_lock, RW_WRITER);

	/*
	* If a mapping already exists, simply increment its refcount and
	* cleanup the one we made. We want to allocate / free outside of
	* the lock because this lock is also used by the zio layer to lookup
	* key mappings. Otherwise, use the one we created. Normally, there will
	* only be one active reference at a time (the objset owner), but there
	* are times when there could be multiple async users.
	*/
	found_km = avl_find(&spa->spa_keystore.sk_key_mappings, km, &where);
	if (found_km != NULL) {
	should_free = B_TRUE;
	zfs_refcount_add(&found_km->km_refcnt, tag);
	if (km_out != NULL)
	*km_out = found_km;
	} else {
	zfs_refcount_add(&km->km_refcnt, tag);
	avl_insert(&spa->spa_keystore.sk_key_mappings, km, where);
	if (km_out != NULL)
	*km_out = km;
	}

	rw_exit(&spa->spa_keystore.sk_km_lock);

	if (should_free) {
	spa_keystore_dsl_key_rele(spa, km->km_key, km);
	zfs_refcount_destroy(&km->km_refcnt);
	kmem_free(km, sizeof (dsl_key_mapping_t));
	}

	return (0);
	}

	int
	spa_keystore_remove_mapping(spa_t spa, uint64_t dsobj, void tag)
	{
	int ret;
	dsl_key_mapping_t search_km;
	dsl_key_mapping_t *found_km;

	/* init the search key mapping */
	search_km.km_dsobj = dsobj;

	rw_enter(&spa->spa_keystore.sk_km_lock, RW_READER);

	/* find the matching mapping */
	found_km = avl_find(&spa->spa_keystore.sk_key_mappings,
	&search_km, NULL);
	if (found_km == NULL) {
	ret = SET_ERROR(ENOENT);
	goto error_unlock;
	}

	rw_exit(&spa->spa_keystore.sk_km_lock);

	key_mapping_rele(spa, found_km, tag);

	return (0);

	error_unlock:
	rw_exit(&spa->spa_keystore.sk_km_lock);
	return (ret);
	}

	/*
	* This function is primarily used by the zio and arc layer to lookup
	* DSL Crypto Keys for encryption. Callers must release the key with
	* spa_keystore_dsl_key_rele(). The function may also be called with
	* dck_out == NULL and tag == NULL to simply check that a key exists
	* without getting a reference to it.
	*/
	int
	spa_keystore_lookup_key(spa_t spa, uint64_t dsobj, void tag,
	dsl_crypto_key_t **dck_out)
	{
	int ret;
	dsl_key_mapping_t search_km;
	dsl_key_mapping_t *found_km;

	ASSERT((tag != NULL && dck_out != NULL) \|\|
	(tag == NULL && dck_out == NULL));

	/* init the search key mapping */
	search_km.km_dsobj = dsobj;

	rw_enter(&spa->spa_keystore.sk_km_lock, RW_READER);

	/* remove the mapping from the tree */
	found_km = avl_find(&spa->spa_keystore.sk_key_mappings, &search_km,
	NULL);
	if (found_km == NULL) {
	ret = SET_ERROR(ENOENT);
	goto error_unlock;
	}

	if (found_km && tag)
	zfs_refcount_add(&found_km->km_key->dck_holds, tag);

	rw_exit(&spa->spa_keystore.sk_km_lock);

	if (dck_out != NULL)
	*dck_out = found_km->km_key;
	return (0);

	error_unlock:
	rw_exit(&spa->spa_keystore.sk_km_lock);

	if (dck_out != NULL)
	*dck_out = NULL;
	return (ret);
	}

	static int
	dmu_objset_check_wkey_loaded(dsl_dir_t *dd)
	{
	int ret;
	dsl_wrapping_key_t *wkey = NULL;

	ret = spa_keystore_wkey_hold_dd(dd->dd_pool->dp_spa, dd, FTAG,
	&wkey);
	if (ret != 0)
	return (SET_ERROR(EACCES));

	dsl_wrapping_key_rele(wkey, FTAG);

	return (0);
	}

	static zfs_keystatus_t
	dsl_dataset_get_keystatus(dsl_dir_t *dd)
	{
	/* check if this dd has a has a dsl key */
	if (dd->dd_crypto_obj == 0)
	return (ZFS_KEYSTATUS_NONE);

	return (dmu_objset_check_wkey_loaded(dd) == 0 ?
	ZFS_KEYSTATUS_AVAILABLE : ZFS_KEYSTATUS_UNAVAILABLE);
	}

	static int
	dsl_dir_get_crypt(dsl_dir_t dd, uint64_t crypt)
	{
	if (dd->dd_crypto_obj == 0) {
	*crypt = ZIO_CRYPT_OFF;
	return (0);
	}

	return (zap_lookup(dd->dd_pool->dp_meta_objset, dd->dd_crypto_obj,
	DSL_CRYPTO_KEY_CRYPTO_SUITE, 8, 1, crypt));
	}

	static void
	dsl_crypto_key_sync_impl(objset_t *mos, uint64_t dckobj, uint64_t crypt,
	uint64_t root_ddobj, uint64_t guid, uint8_t iv, uint8_t mac,
	uint8_t keydata, uint8_t hmac_keydata, uint64_t keyformat,
	uint64_t salt, uint64_t iters, dmu_tx_t *tx)
	{
	VERIFY0(zap_update(mos, dckobj, DSL_CRYPTO_KEY_CRYPTO_SUITE, 8, 1,
	&crypt, tx));
	VERIFY0(zap_update(mos, dckobj, DSL_CRYPTO_KEY_ROOT_DDOBJ, 8, 1,
	&root_ddobj, tx));
	VERIFY0(zap_update(mos, dckobj, DSL_CRYPTO_KEY_GUID, 8, 1,
	&guid, tx));
	VERIFY0(zap_update(mos, dckobj, DSL_CRYPTO_KEY_IV, 1, WRAPPING_IV_LEN,
	iv, tx));
	VERIFY0(zap_update(mos, dckobj, DSL_CRYPTO_KEY_MAC, 1, WRAPPING_MAC_LEN,
	mac, tx));
	VERIFY0(zap_update(mos, dckobj, DSL_CRYPTO_KEY_MASTER_KEY, 1,
	MASTER_KEY_MAX_LEN, keydata, tx));
	VERIFY0(zap_update(mos, dckobj, DSL_CRYPTO_KEY_HMAC_KEY, 1,
	SHA512_HMAC_KEYLEN, hmac_keydata, tx));
	VERIFY0(zap_update(mos, dckobj, zfs_prop_to_name(ZFS_PROP_KEYFORMAT),
	8, 1, &keyformat, tx));
	VERIFY0(zap_update(mos, dckobj, zfs_prop_to_name(ZFS_PROP_PBKDF2_SALT),
	8, 1, &salt, tx));
	VERIFY0(zap_update(mos, dckobj, zfs_prop_to_name(ZFS_PROP_PBKDF2_ITERS),
	8, 1, &iters, tx));
	}

	static void
	dsl_crypto_key_sync(dsl_crypto_key_t dck, dmu_tx_t tx)
	{
	zio_crypt_key_t *key = &dck->dck_key;
	dsl_wrapping_key_t *wkey = dck->dck_wkey;
	uint8_t keydata[MASTER_KEY_MAX_LEN];
	uint8_t hmac_keydata[SHA512_HMAC_KEYLEN];
	uint8_t iv[WRAPPING_IV_LEN];
	uint8_t mac[WRAPPING_MAC_LEN];

	ASSERT(dmu_tx_is_syncing(tx));
	ASSERT3U(key->zk_crypt, <, ZIO_CRYPT_FUNCTIONS);

	/* encrypt and store the keys along with the IV and MAC */
	VERIFY0(zio_crypt_key_wrap(&dck->dck_wkey->wk_key, key, iv, mac,
	keydata, hmac_keydata));

	/* update the ZAP with the obtained values */
	dsl_crypto_key_sync_impl(tx->tx_pool->dp_meta_objset, dck->dck_obj,
	key->zk_crypt, wkey->wk_ddobj, key->zk_guid, iv, mac, keydata,
	hmac_keydata, wkey->wk_keyformat, wkey->wk_salt, wkey->wk_iters,
	tx);
	}

	typedef struct spa_keystore_change_key_args {
	const char *skcka_dsname;
	dsl_crypto_params_t *skcka_cp;
	} spa_keystore_change_key_args_t;

	static int
	spa_keystore_change_key_check(void arg, dmu_tx_t tx)
	{
	int ret;
	dsl_dir_t *dd = NULL;
	dsl_pool_t *dp = dmu_tx_pool(tx);
	spa_keystore_change_key_args_t *skcka = arg;
	dsl_crypto_params_t *dcp = skcka->skcka_cp;
	uint64_t rddobj;

	/* check for the encryption feature */
	if (!spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_ENCRYPTION)) {
	ret = SET_ERROR(ENOTSUP);
	goto error;
	}

	/* check for valid key change command */
	if (dcp->cp_cmd != DCP_CMD_NEW_KEY &&
	dcp->cp_cmd != DCP_CMD_INHERIT &&
	dcp->cp_cmd != DCP_CMD_FORCE_NEW_KEY &&
	dcp->cp_cmd != DCP_CMD_FORCE_INHERIT) {
	ret = SET_ERROR(EINVAL);
	goto error;
	}

	/* hold the dd */
	ret = dsl_dir_hold(dp, skcka->skcka_dsname, FTAG, &dd, NULL);
	if (ret != 0) {
	dd = NULL;
	goto error;
	}

	/* verify that the dataset is encrypted */
	if (dd->dd_crypto_obj == 0) {
	ret = SET_ERROR(EINVAL);
	goto error;
	}

	/* clones must always use their origin's key */
	if (dsl_dir_is_clone(dd)) {
	ret = SET_ERROR(EINVAL);
	goto error;
	}

	/* lookup the ddobj we are inheriting the keylocation from */
	ret = dsl_dir_get_encryption_root_ddobj(dd, &rddobj);
	if (ret != 0)
	goto error;

	/* Handle inheritance */
	if (dcp->cp_cmd == DCP_CMD_INHERIT \|\|
	dcp->cp_cmd == DCP_CMD_FORCE_INHERIT) {
	/* no other encryption params should be given */
	if (dcp->cp_crypt != ZIO_CRYPT_INHERIT \|\|
	dcp->cp_keylocation != NULL \|\|
	dcp->cp_wkey != NULL) {
	ret = SET_ERROR(EINVAL);
	goto error;
	}

	/* check that this is an encryption root */
	if (dd->dd_object != rddobj) {
	ret = SET_ERROR(EINVAL);
	goto error;
	}

	/* check that the parent is encrypted */
	if (dd->dd_parent->dd_crypto_obj == 0) {
	ret = SET_ERROR(EINVAL);
	goto error;
	}

	/* if we are rewrapping check that both keys are loaded */
	if (dcp->cp_cmd == DCP_CMD_INHERIT) {
	ret = dmu_objset_check_wkey_loaded(dd);
	if (ret != 0)
	goto error;

	ret = dmu_objset_check_wkey_loaded(dd->dd_parent);
	if (ret != 0)
	goto error;
	}

	dsl_dir_rele(dd, FTAG);
	return (0);
	}

	/* handle forcing an encryption root without rewrapping */
	if (dcp->cp_cmd == DCP_CMD_FORCE_NEW_KEY) {
	/* no other encryption params should be given */
	if (dcp->cp_crypt != ZIO_CRYPT_INHERIT \|\|
	dcp->cp_keylocation != NULL \|\|
	dcp->cp_wkey != NULL) {
	ret = SET_ERROR(EINVAL);
	goto error;
	}

	/* check that this is not an encryption root */
	if (dd->dd_object == rddobj) {
	ret = SET_ERROR(EINVAL);
	goto error;
	}

	dsl_dir_rele(dd, FTAG);
	return (0);
	}

	/* crypt cannot be changed after creation */
	if (dcp->cp_crypt != ZIO_CRYPT_INHERIT) {
	ret = SET_ERROR(EINVAL);
	goto error;
	}

	/* we are not inheritting our parent's wkey so we need one ourselves */
	if (dcp->cp_wkey == NULL) {
	ret = SET_ERROR(EINVAL);
	goto error;
	}

	/* check for a valid keyformat for the new wrapping key */
	if (dcp->cp_wkey->wk_keyformat >= ZFS_KEYFORMAT_FORMATS \|\|
	dcp->cp_wkey->wk_keyformat == ZFS_KEYFORMAT_NONE) {
	ret = SET_ERROR(EINVAL);
	goto error;
	}

	/*
	* If this dataset is not currently an encryption root we need a new
	* keylocation for this dataset's new wrapping key. Otherwise we can
	* just keep the one we already had.
	*/
	if (dd->dd_object != rddobj && dcp->cp_keylocation == NULL) {
	ret = SET_ERROR(EINVAL);
	goto error;
	}

	/* check that the keylocation is valid if it is not NULL */
	if (dcp->cp_keylocation != NULL &&
	!zfs_prop_valid_keylocation(dcp->cp_keylocation, B_TRUE)) {
	ret = SET_ERROR(EINVAL);
	goto error;
	}

	/* passphrases require pbkdf2 salt and iters */
	if (dcp->cp_wkey->wk_keyformat == ZFS_KEYFORMAT_PASSPHRASE) {
	if (dcp->cp_wkey->wk_salt == 0 \|\|
	dcp->cp_wkey->wk_iters < MIN_PBKDF2_ITERATIONS) {
	ret = SET_ERROR(EINVAL);
	goto error;
	}
	} else {
	if (dcp->cp_wkey->wk_salt != 0 \|\| dcp->cp_wkey->wk_iters != 0) {
	ret = SET_ERROR(EINVAL);
	goto error;
	}
	}

	/* make sure the dd's wkey is loaded */
	ret = dmu_objset_check_wkey_loaded(dd);
	if (ret != 0)
	goto error;

	dsl_dir_rele(dd, FTAG);

	return (0);

	error:
	if (dd != NULL)
	dsl_dir_rele(dd, FTAG);

	return (ret);
	}

	/*
	* This function deals with the intricacies of updating wrapping
	* key references and encryption roots recursively in the event
	* of a call to 'zfs change-key' or 'zfs promote'. The 'skip'
	* parameter should always be set to B_FALSE when called
	* externally.
	*/
	static void
	spa_keystore_change_key_sync_impl(uint64_t rddobj, uint64_t ddobj,
	uint64_t new_rddobj, dsl_wrapping_key_t *wkey, boolean_t skip,
	dmu_tx_t *tx)
	{
	int ret;
	zap_cursor_t *zc;
	zap_attribute_t *za;
	dsl_pool_t *dp = dmu_tx_pool(tx);
	dsl_dir_t *dd = NULL;
	dsl_crypto_key_t *dck = NULL;
	uint64_t curr_rddobj;

	ASSERT(RW_WRITE_HELD(&dp->dp_spa->spa_keystore.sk_wkeys_lock));

	/* hold the dd */
	VERIFY0(dsl_dir_hold_obj(dp, ddobj, NULL, FTAG, &dd));

	/* ignore special dsl dirs */
	if (dd->dd_myname[0] == '$' \|\| dd->dd_myname[0] == '%') {
	dsl_dir_rele(dd, FTAG);
	return;
	}

	ret = dsl_dir_get_encryption_root_ddobj(dd, &curr_rddobj);
	VERIFY(ret == 0 \|\| ret == ENOENT);

	/*
	* Stop recursing if this dsl dir didn't inherit from the root
	* or if this dd is a clone.
	*/
	if (ret == ENOENT \|\|
	(!skip && (curr_rddobj != rddobj \|\| dsl_dir_is_clone(dd)))) {
	dsl_dir_rele(dd, FTAG);
	return;
	}

	/*
	* If we don't have a wrapping key just update the dck to reflect the
	* new encryption root. Otherwise rewrap the entire dck and re-sync it
	* to disk. If skip is set, we don't do any of this work.
	*/
	if (!skip) {
	if (wkey == NULL) {
	VERIFY0(zap_update(dp->dp_meta_objset,
	dd->dd_crypto_obj,
	DSL_CRYPTO_KEY_ROOT_DDOBJ, 8, 1,
	&new_rddobj, tx));
	} else {
	VERIFY0(spa_keystore_dsl_key_hold_dd(dp->dp_spa, dd,
	FTAG, &dck));
	dsl_wrapping_key_hold(wkey, dck);
	dsl_wrapping_key_rele(dck->dck_wkey, dck);
	dck->dck_wkey = wkey;
	dsl_crypto_key_sync(dck, tx);
	spa_keystore_dsl_key_rele(dp->dp_spa, dck, FTAG);
	}
	}

	zc = kmem_alloc(sizeof (zap_cursor_t), KM_SLEEP);
	za = kmem_alloc(sizeof (zap_attribute_t), KM_SLEEP);

	/* Recurse into all child dsl dirs. */
	for (zap_cursor_init(zc, dp->dp_meta_objset,
	dsl_dir_phys(dd)->dd_child_dir_zapobj);
	zap_cursor_retrieve(zc, za) == 0;
	zap_cursor_advance(zc)) {
	spa_keystore_change_key_sync_impl(rddobj,
	za->za_first_integer, new_rddobj, wkey, B_FALSE, tx);
	}
	zap_cursor_fini(zc);

	/*
	* Recurse into all dsl dirs of clones. We utilize the skip parameter
	* here so that we don't attempt to process the clones directly. This
	* is because the clone and its origin share the same dck, which has
	* already been updated.
	*/
	for (zap_cursor_init(zc, dp->dp_meta_objset,
	dsl_dir_phys(dd)->dd_clones);
	zap_cursor_retrieve(zc, za) == 0;
	zap_cursor_advance(zc)) {
	dsl_dataset_t *clone;

	VERIFY0(dsl_dataset_hold_obj(dp, za->za_first_integer,
	FTAG, &clone));
	spa_keystore_change_key_sync_impl(rddobj,
	clone->ds_dir->dd_object, new_rddobj, wkey, B_TRUE, tx);
	dsl_dataset_rele(clone, FTAG);
	}
	zap_cursor_fini(zc);

	kmem_free(za, sizeof (zap_attribute_t));
	kmem_free(zc, sizeof (zap_cursor_t));

	dsl_dir_rele(dd, FTAG);
	}

	static void
	spa_keystore_change_key_sync(void arg, dmu_tx_t tx)
	{
	dsl_dataset_t *ds;
	avl_index_t where;
	dsl_pool_t *dp = dmu_tx_pool(tx);
	spa_t *spa = dp->dp_spa;
	spa_keystore_change_key_args_t *skcka = arg;
	dsl_crypto_params_t *dcp = skcka->skcka_cp;
	dsl_wrapping_key_t wkey = NULL, found_wkey;
	dsl_wrapping_key_t wkey_search;
	char *keylocation = dcp->cp_keylocation;
	uint64_t rddobj, new_rddobj;

	/* create and initialize the wrapping key */
	VERIFY0(dsl_dataset_hold(dp, skcka->skcka_dsname, FTAG, &ds));
	ASSERT(!ds->ds_is_snapshot);

	if (dcp->cp_cmd == DCP_CMD_NEW_KEY \|\|
	dcp->cp_cmd == DCP_CMD_FORCE_NEW_KEY) {
	/*
	* We are changing to a new wkey. Set additional properties
	* which can be sent along with this ioctl. Note that this
	* command can set keylocation even if it can't normally be
	* set via 'zfs set' due to a non-local keylocation.
	*/
	if (dcp->cp_cmd == DCP_CMD_NEW_KEY) {
	wkey = dcp->cp_wkey;
	wkey->wk_ddobj = ds->ds_dir->dd_object;
	} else {
	keylocation = "prompt";
	}

	if (keylocation != NULL) {
	dsl_prop_set_sync_impl(ds,
	zfs_prop_to_name(ZFS_PROP_KEYLOCATION),
	ZPROP_SRC_LOCAL, 1, strlen(keylocation) + 1,
	keylocation, tx);
	}

	VERIFY0(dsl_dir_get_encryption_root_ddobj(ds->ds_dir, &rddobj));
	new_rddobj = ds->ds_dir->dd_object;
	} else {
	/*
	* We are inheritting the parent's wkey. Unset any local
	* keylocation and grab a reference to the wkey.
	*/
	if (dcp->cp_cmd == DCP_CMD_INHERIT) {
	VERIFY0(spa_keystore_wkey_hold_dd(spa,
	ds->ds_dir->dd_parent, FTAG, &wkey));
	}

	dsl_prop_set_sync_impl(ds,
	zfs_prop_to_name(ZFS_PROP_KEYLOCATION), ZPROP_SRC_NONE,
	0, 0, NULL, tx);

	rddobj = ds->ds_dir->dd_object;
	VERIFY0(dsl_dir_get_encryption_root_ddobj(ds->ds_dir->dd_parent,
	&new_rddobj));
	}

	if (wkey == NULL) {
	ASSERT(dcp->cp_cmd == DCP_CMD_FORCE_INHERIT \|\|
	dcp->cp_cmd == DCP_CMD_FORCE_NEW_KEY);
	}

	rw_enter(&spa->spa_keystore.sk_wkeys_lock, RW_WRITER);

	/* recurse through all children and rewrap their keys */
	spa_keystore_change_key_sync_impl(rddobj, ds->ds_dir->dd_object,
	new_rddobj, wkey, B_FALSE, tx);

	/*
	* All references to the old wkey should be released now (if it
	* existed). Replace the wrapping key.
	*/
	wkey_search.wk_ddobj = ds->ds_dir->dd_object;
	found_wkey = avl_find(&spa->spa_keystore.sk_wkeys, &wkey_search, NULL);
	if (found_wkey != NULL) {
	ASSERT0(zfs_refcount_count(&found_wkey->wk_refcnt));
	avl_remove(&spa->spa_keystore.sk_wkeys, found_wkey);
	dsl_wrapping_key_free(found_wkey);
	}

	if (dcp->cp_cmd == DCP_CMD_NEW_KEY) {
	avl_find(&spa->spa_keystore.sk_wkeys, wkey, &where);
	avl_insert(&spa->spa_keystore.sk_wkeys, wkey, where);
	} else if (wkey != NULL) {
	dsl_wrapping_key_rele(wkey, FTAG);
	}

	rw_exit(&spa->spa_keystore.sk_wkeys_lock);

	dsl_dataset_rele(ds, FTAG);
	}

	int
	spa_keystore_change_key(const char dsname, dsl_crypto_params_t dcp)
	{
	spa_keystore_change_key_args_t skcka;

	/* initialize the args struct */
	skcka.skcka_dsname = dsname;
	skcka.skcka_cp = dcp;

	/*
	* Perform the actual work in syncing context. The blocks modified
	* here could be calculated but it would require holding the pool
	* lock and traversing all of the datasets that will have their keys
	* changed.
	*/
	return (dsl_sync_task(dsname, spa_keystore_change_key_check,
	spa_keystore_change_key_sync, &skcka, 15,
	ZFS_SPACE_CHECK_RESERVED));
	}

	int
	dsl_dir_rename_crypt_check(dsl_dir_t dd, dsl_dir_t newparent)
	{
	int ret;
	uint64_t curr_rddobj, parent_rddobj;

	if (dd->dd_crypto_obj == 0)
	return (0);

	ret = dsl_dir_get_encryption_root_ddobj(dd, &curr_rddobj);
	if (ret != 0)
	goto error;

	/*
	* if this is not an encryption root, we must make sure we are not
	* moving dd to a new encryption root
	*/
	if (dd->dd_object != curr_rddobj) {
	ret = dsl_dir_get_encryption_root_ddobj(newparent,
	&parent_rddobj);
	if (ret != 0)
	goto error;

	if (parent_rddobj != curr_rddobj) {
	ret = SET_ERROR(EACCES);
	goto error;
	}
	}

	return (0);

	error:
	return (ret);
	}

	/*
	* Check to make sure that a promote from targetdd to origindd will not require
	* any key rewraps.
	*/
	int
	dsl_dataset_promote_crypt_check(dsl_dir_t target, dsl_dir_t origin)
	{
	int ret;
	uint64_t rddobj, op_rddobj, tp_rddobj;

	/* If the dataset is not encrypted we don't need to check anything */
	if (origin->dd_crypto_obj == 0)
	return (0);

	/*
	* If we are not changing the first origin snapshot in a chain
	* the encryption root won't change either.
	*/
	if (dsl_dir_is_clone(origin))
	return (0);

	/*
	* If the origin is the encryption root we will update
	* the DSL Crypto Key to point to the target instead.
	*/
	ret = dsl_dir_get_encryption_root_ddobj(origin, &rddobj);
	if (ret != 0)
	return (ret);

	if (rddobj == origin->dd_object)
	return (0);

	/*
	* The origin is inheriting its encryption root from its parent.
	* Check that the parent of the target has the same encryption root.
	*/
	ret = dsl_dir_get_encryption_root_ddobj(origin->dd_parent, &op_rddobj);
	if (ret == ENOENT)
	return (SET_ERROR(EACCES));
	else if (ret != 0)
	return (ret);

	ret = dsl_dir_get_encryption_root_ddobj(target->dd_parent, &tp_rddobj);
	if (ret == ENOENT)
	return (SET_ERROR(EACCES));
	else if (ret != 0)
	return (ret);

	if (op_rddobj != tp_rddobj)
	return (SET_ERROR(EACCES));

	return (0);
	}

	void
	dsl_dataset_promote_crypt_sync(dsl_dir_t target, dsl_dir_t origin,
	dmu_tx_t *tx)
	{
	uint64_t rddobj;
	dsl_pool_t *dp = target->dd_pool;
	dsl_dataset_t *targetds;
	dsl_dataset_t *originds;
	char *keylocation;

	if (origin->dd_crypto_obj == 0)
	return;
	if (dsl_dir_is_clone(origin))
	return;

	VERIFY0(dsl_dir_get_encryption_root_ddobj(origin, &rddobj));

	if (rddobj != origin->dd_object)
	return;

	/*
	* If the target is being promoted to the encryption root update the
	* DSL Crypto Key and keylocation to reflect that. We also need to
	* update the DSL Crypto Keys of all children inheritting their
	* encryption root to point to the new target. Otherwise, the check
	* function ensured that the encryption root will not change.
	*/
	keylocation = kmem_alloc(ZAP_MAXVALUELEN, KM_SLEEP);

	VERIFY0(dsl_dataset_hold_obj(dp,
	dsl_dir_phys(target)->dd_head_dataset_obj, FTAG, &targetds));
	VERIFY0(dsl_dataset_hold_obj(dp,
	dsl_dir_phys(origin)->dd_head_dataset_obj, FTAG, &originds));

	VERIFY0(dsl_prop_get_dd(origin, zfs_prop_to_name(ZFS_PROP_KEYLOCATION),
	1, ZAP_MAXVALUELEN, keylocation, NULL, B_FALSE));
	dsl_prop_set_sync_impl(targetds, zfs_prop_to_name(ZFS_PROP_KEYLOCATION),
	ZPROP_SRC_LOCAL, 1, strlen(keylocation) + 1, keylocation, tx);
	dsl_prop_set_sync_impl(originds, zfs_prop_to_name(ZFS_PROP_KEYLOCATION),
	ZPROP_SRC_NONE, 0, 0, NULL, tx);

	rw_enter(&dp->dp_spa->spa_keystore.sk_wkeys_lock, RW_WRITER);
	spa_keystore_change_key_sync_impl(rddobj, origin->dd_object,
	target->dd_object, NULL, B_FALSE, tx);
	rw_exit(&dp->dp_spa->spa_keystore.sk_wkeys_lock);

	dsl_dataset_rele(targetds, FTAG);
	dsl_dataset_rele(originds, FTAG);
	kmem_free(keylocation, ZAP_MAXVALUELEN);
	}

	int
	dmu_objset_create_crypt_check(dsl_dir_t parentdd, dsl_crypto_params_t dcp,
	boolean_t *will_encrypt)
	{
	int ret;
	uint64_t pcrypt, crypt;
	dsl_crypto_params_t dummy_dcp = { 0 };

	if (will_encrypt != NULL)
	*will_encrypt = B_FALSE;

	if (dcp == NULL)
	dcp = &dummy_dcp;

	if (dcp->cp_cmd != DCP_CMD_NONE)
	return (SET_ERROR(EINVAL));

	if (parentdd != NULL) {
	ret = dsl_dir_get_crypt(parentdd, &pcrypt);
	if (ret != 0)
	return (ret);
	} else {
	pcrypt = ZIO_CRYPT_OFF;
	}

	crypt = (dcp->cp_crypt == ZIO_CRYPT_INHERIT) ? pcrypt : dcp->cp_crypt;

	ASSERT3U(pcrypt, !=, ZIO_CRYPT_INHERIT);
	ASSERT3U(crypt, !=, ZIO_CRYPT_INHERIT);

	/* check for valid dcp with no encryption (inherited or local) */
	if (crypt == ZIO_CRYPT_OFF) {
	/* Must not specify encryption params */
	if (dcp->cp_wkey != NULL \|\|
	(dcp->cp_keylocation != NULL &&
	strcmp(dcp->cp_keylocation, "none") != 0))
	return (SET_ERROR(EINVAL));

	return (0);
	}

	if (will_encrypt != NULL)
	*will_encrypt = B_TRUE;

	/*
	* We will now definitely be encrypting. Check the feature flag. When
	* creating the pool the caller will check this for us since we won't
	* technically have the feature activated yet.
	*/
	if (parentdd != NULL &&
	!spa_feature_is_enabled(parentdd->dd_pool->dp_spa,
	SPA_FEATURE_ENCRYPTION)) {
	return (SET_ERROR(EOPNOTSUPP));
	}

	/* Check for errata #4 (encryption enabled, bookmark_v2 disabled) */
	if (parentdd != NULL &&
	!spa_feature_is_enabled(parentdd->dd_pool->dp_spa,
	SPA_FEATURE_BOOKMARK_V2)) {
	return (SET_ERROR(EOPNOTSUPP));
	}

	/* handle inheritance */
	if (dcp->cp_wkey == NULL) {
	ASSERT3P(parentdd, !=, NULL);

	/* key must be fully unspecified */
	if (dcp->cp_keylocation != NULL)
	return (SET_ERROR(EINVAL));

	/* parent must have a key to inherit */
	if (pcrypt == ZIO_CRYPT_OFF)
	return (SET_ERROR(EINVAL));

	/* check for parent key */
	ret = dmu_objset_check_wkey_loaded(parentdd);
	if (ret != 0)
	return (ret);

	return (0);
	}

	/* At this point we should have a fully specified key. Check location */
	if (dcp->cp_keylocation == NULL \|\|
	!zfs_prop_valid_keylocation(dcp->cp_keylocation, B_TRUE))
	return (SET_ERROR(EINVAL));

	/* Must have fully specified keyformat */
	switch (dcp->cp_wkey->wk_keyformat) {
	case ZFS_KEYFORMAT_HEX:
	case ZFS_KEYFORMAT_RAW:
	/* requires no pbkdf2 iters and salt */
	if (dcp->cp_wkey->wk_salt != 0 \|\| dcp->cp_wkey->wk_iters != 0)
	return (SET_ERROR(EINVAL));
	break;
	case ZFS_KEYFORMAT_PASSPHRASE:
	/* requires pbkdf2 iters and salt */
	if (dcp->cp_wkey->wk_salt == 0 \|\|
	dcp->cp_wkey->wk_iters < MIN_PBKDF2_ITERATIONS)
	return (SET_ERROR(EINVAL));
	break;
	case ZFS_KEYFORMAT_NONE:
	default:
	/* keyformat must be specified and valid */
	return (SET_ERROR(EINVAL));
	}

	return (0);
	}

	void
	dsl_dataset_create_crypt_sync(uint64_t dsobj, dsl_dir_t *dd,
	dsl_dataset_t origin, dsl_crypto_params_t dcp, dmu_tx_t *tx)
	{
	dsl_pool_t *dp = dd->dd_pool;
	uint64_t crypt;
	dsl_wrapping_key_t *wkey;

	/* clones always use their origin's wrapping key */
	if (dsl_dir_is_clone(dd)) {
	ASSERT3P(dcp, ==, NULL);

	/*
	* If this is an encrypted clone we just need to clone the
	* dck into dd. Zapify the dd so we can do that.
	*/
	if (origin->ds_dir->dd_crypto_obj != 0) {
	dmu_buf_will_dirty(dd->dd_dbuf, tx);
	dsl_dir_zapify(dd, tx);

	dd->dd_crypto_obj =
	dsl_crypto_key_clone_sync(origin->ds_dir, tx);
	VERIFY0(zap_add(dp->dp_meta_objset, dd->dd_object,
	DD_FIELD_CRYPTO_KEY_OBJ, sizeof (uint64_t), 1,
	&dd->dd_crypto_obj, tx));
	}

	return;
	}

	/*
	* A NULL dcp at this point indicates this is the origin dataset
	* which does not have an objset to encrypt. Raw receives will handle
	* encryption separately later. In both cases we can simply return.
	*/
	if (dcp == NULL \|\| dcp->cp_cmd == DCP_CMD_RAW_RECV)
	return;

	crypt = dcp->cp_crypt;
	wkey = dcp->cp_wkey;

	/* figure out the effective crypt */
	if (crypt == ZIO_CRYPT_INHERIT && dd->dd_parent != NULL)
	VERIFY0(dsl_dir_get_crypt(dd->dd_parent, &crypt));

	/* if we aren't doing encryption just return */
	if (crypt == ZIO_CRYPT_OFF \|\| crypt == ZIO_CRYPT_INHERIT)
	return;

	/* zapify the dd so that we can add the crypto key obj to it */
	dmu_buf_will_dirty(dd->dd_dbuf, tx);
	dsl_dir_zapify(dd, tx);

	/* use the new key if given or inherit from the parent */
	if (wkey == NULL) {
	VERIFY0(spa_keystore_wkey_hold_dd(dp->dp_spa,
	dd->dd_parent, FTAG, &wkey));
	} else {
	wkey->wk_ddobj = dd->dd_object;
	}

	ASSERT3P(wkey, !=, NULL);

	/* Create or clone the DSL crypto key and activate the feature */
	dd->dd_crypto_obj = dsl_crypto_key_create_sync(crypt, wkey, tx);
	VERIFY0(zap_add(dp->dp_meta_objset, dd->dd_object,
	DD_FIELD_CRYPTO_KEY_OBJ, sizeof (uint64_t), 1, &dd->dd_crypto_obj,
	tx));
	dsl_dataset_activate_feature(dsobj, SPA_FEATURE_ENCRYPTION,
	(void *)B_TRUE, tx);

	/*
	* If we inherited the wrapping key we release our reference now.
	* Otherwise, this is a new key and we need to load it into the
	* keystore.
	*/
	if (dcp->cp_wkey == NULL) {
	dsl_wrapping_key_rele(wkey, FTAG);
	} else {
	VERIFY0(spa_keystore_load_wkey_impl(dp->dp_spa, wkey));
	}
	}

	typedef struct dsl_crypto_recv_key_arg {
	uint64_t dcrka_dsobj;
	uint64_t dcrka_fromobj;
	dmu_objset_type_t dcrka_ostype;
	nvlist_t *dcrka_nvl;
	boolean_t dcrka_do_key;
	} dsl_crypto_recv_key_arg_t;

	static int
	dsl_crypto_recv_raw_objset_check(dsl_dataset_t ds, dsl_dataset_t fromds,
	dmu_objset_type_t ostype, nvlist_t nvl, dmu_tx_t tx)
	{
	int ret;
	objset_t *os;
	dnode_t *mdn;
	uint8_t *buf = NULL;
	uint_t len;
	uint64_t intval, nlevels, blksz, ibs;
	uint64_t nblkptr, maxblkid;

	if (ostype != DMU_OST_ZFS && ostype != DMU_OST_ZVOL)
	return (SET_ERROR(EINVAL));

	/* raw receives also need info about the structure of the metadnode */
	ret = nvlist_lookup_uint64(nvl, "mdn_compress", &intval);
	if (ret != 0 \|\| intval >= ZIO_COMPRESS_LEGACY_FUNCTIONS)
	return (SET_ERROR(EINVAL));

	ret = nvlist_lookup_uint64(nvl, "mdn_checksum", &intval);
	if (ret != 0 \|\| intval >= ZIO_CHECKSUM_LEGACY_FUNCTIONS)
	return (SET_ERROR(EINVAL));

	ret = nvlist_lookup_uint64(nvl, "mdn_nlevels", &nlevels);
	if (ret != 0 \|\| nlevels > DN_MAX_LEVELS)
	return (SET_ERROR(EINVAL));

	ret = nvlist_lookup_uint64(nvl, "mdn_blksz", &blksz);
	if (ret != 0 \|\| blksz < SPA_MINBLOCKSIZE)
	return (SET_ERROR(EINVAL));
	else if (blksz > spa_maxblocksize(tx->tx_pool->dp_spa))
	return (SET_ERROR(ENOTSUP));

	ret = nvlist_lookup_uint64(nvl, "mdn_indblkshift", &ibs);
	if (ret != 0 \|\| ibs < DN_MIN_INDBLKSHIFT \|\| ibs > DN_MAX_INDBLKSHIFT)
	return (SET_ERROR(ENOTSUP));

	ret = nvlist_lookup_uint64(nvl, "mdn_nblkptr", &nblkptr);
	if (ret != 0 \|\| nblkptr != DN_MAX_NBLKPTR)
	return (SET_ERROR(ENOTSUP));

	ret = nvlist_lookup_uint64(nvl, "mdn_maxblkid", &maxblkid);
	if (ret != 0)
	return (SET_ERROR(EINVAL));

	ret = nvlist_lookup_uint8_array(nvl, "portable_mac", &buf, &len);
	if (ret != 0 \|\| len != ZIO_OBJSET_MAC_LEN)
	return (SET_ERROR(EINVAL));

	ret = dmu_objset_from_ds(ds, &os);
	if (ret != 0)
	return (ret);

	+ /*
	+ * Useraccounting is not portable and must be done with the keys loaded.
	+ * Therefore, whenever we do any kind of receive the useraccounting
	+ * must not be present.
	+ */
	+ ASSERT0(os->os_flags & OBJSET_FLAG_USERACCOUNTING_COMPLETE);
	+ ASSERT0(os->os_flags & OBJSET_FLAG_USEROBJACCOUNTING_COMPLETE);
	+
	mdn = DMU_META_DNODE(os);

	/*
	* If we already created the objset, make sure its unchangeable
	* properties match the ones received in the nvlist.
	*/
	rrw_enter(&ds->ds_bp_rwlock, RW_READER, FTAG);
	if (!BP_IS_HOLE(dsl_dataset_get_blkptr(ds)) &&
	(mdn->dn_nlevels != nlevels \|\| mdn->dn_datablksz != blksz \|\|
	mdn->dn_indblkshift != ibs \|\| mdn->dn_nblkptr != nblkptr)) {
	rrw_exit(&ds->ds_bp_rwlock, FTAG);
	return (SET_ERROR(EINVAL));
	}
	rrw_exit(&ds->ds_bp_rwlock, FTAG);

	/*
	* Check that the ivset guid of the fromds matches the one from the
	* send stream. Older versions of the encryption code did not have
	* an ivset guid on the from dataset and did not send one in the
	* stream. For these streams we provide the
	* zfs_disable_ivset_guid_check tunable to allow these datasets to
	* be received with a generated ivset guid.
	*/
	if (fromds != NULL && !zfs_disable_ivset_guid_check) {
	uint64_t from_ivset_guid = 0;
	intval = 0;

	(void) nvlist_lookup_uint64(nvl, "from_ivset_guid", &intval);
	(void) zap_lookup(tx->tx_pool->dp_meta_objset,
	fromds->ds_object, DS_FIELD_IVSET_GUID,
	sizeof (from_ivset_guid), 1, &from_ivset_guid);

	if (intval == 0 \|\| from_ivset_guid == 0)
	return (SET_ERROR(ZFS_ERR_FROM_IVSET_GUID_MISSING));

	if (intval != from_ivset_guid)
	return (SET_ERROR(ZFS_ERR_FROM_IVSET_GUID_MISMATCH));
	}

	return (0);
	}

	static void
	dsl_crypto_recv_raw_objset_sync(dsl_dataset_t *ds, dmu_objset_type_t ostype,
	nvlist_t nvl, dmu_tx_t tx)
	{
	dsl_pool_t *dp = tx->tx_pool;
	objset_t *os;
	dnode_t *mdn;
	zio_t *zio;
	uint8_t *portable_mac;
	uint_t len;
	uint64_t compress, checksum, nlevels, blksz, ibs, maxblkid;
	boolean_t newds = B_FALSE;

	VERIFY0(dmu_objset_from_ds(ds, &os));
	mdn = DMU_META_DNODE(os);

	/*
	* Fetch the values we need from the nvlist. "to_ivset_guid" must
	* be set on the snapshot, which doesn't exist yet. The receive
	* code will take care of this for us later.
	*/
	compress = fnvlist_lookup_uint64(nvl, "mdn_compress");
	checksum = fnvlist_lookup_uint64(nvl, "mdn_checksum");
	nlevels = fnvlist_lookup_uint64(nvl, "mdn_nlevels");
	blksz = fnvlist_lookup_uint64(nvl, "mdn_blksz");
	ibs = fnvlist_lookup_uint64(nvl, "mdn_indblkshift");
	maxblkid = fnvlist_lookup_uint64(nvl, "mdn_maxblkid");
	VERIFY0(nvlist_lookup_uint8_array(nvl, "portable_mac", &portable_mac,
	&len));

	/* if we haven't created an objset for the ds yet, do that now */
	rrw_enter(&ds->ds_bp_rwlock, RW_READER, FTAG);
	if (BP_IS_HOLE(dsl_dataset_get_blkptr(ds))) {
	(void) dmu_objset_create_impl_dnstats(dp->dp_spa, ds,
	dsl_dataset_get_blkptr(ds), ostype, nlevels, blksz,
	ibs, tx);
	newds = B_TRUE;
	}
	rrw_exit(&ds->ds_bp_rwlock, FTAG);

	/*
	* Set the portable MAC. The local MAC will always be zero since the
	* incoming data will all be portable and user accounting will be
	* deferred until the next mount. Afterwards, flag the os to be
	* written out raw next time.
	*/
	arc_release(os->os_phys_buf, &os->os_phys_buf);
	bcopy(portable_mac, os->os_phys->os_portable_mac, ZIO_OBJSET_MAC_LEN);
	- os->os_phys->os_flags &= ~OBJSET_FLAG_USERACCOUNTING_COMPLETE;
	- os->os_phys->os_flags &= ~OBJSET_FLAG_USEROBJACCOUNTING_COMPLETE;
	- os->os_flags = os->os_phys->os_flags;
	bzero(os->os_phys->os_local_mac, ZIO_OBJSET_MAC_LEN);
	os->os_next_write_raw[tx->tx_txg & TXG_MASK] = B_TRUE;

	/* set metadnode compression and checksum */
	mdn->dn_compress = compress;
	mdn->dn_checksum = checksum;

	rw_enter(&mdn->dn_struct_rwlock, RW_WRITER);
	dnode_new_blkid(mdn, maxblkid, tx, B_FALSE, B_TRUE);
	rw_exit(&mdn->dn_struct_rwlock);

	/*
	* We can't normally dirty the dataset in syncing context unless
	* we are creating a new dataset. In this case, we perform a
	* pseudo txg sync here instead.
	*/
	if (newds) {
	dsl_dataset_dirty(ds, tx);
	} else {
	zio = zio_root(dp->dp_spa, NULL, NULL, ZIO_FLAG_MUSTSUCCEED);
	dsl_dataset_sync(ds, zio, tx);
	VERIFY0(zio_wait(zio));

	/* dsl_dataset_sync_done will drop this reference. */
	dmu_buf_add_ref(ds->ds_dbuf, ds);
	dsl_dataset_sync_done(ds, tx);
	}
	}

	int
	dsl_crypto_recv_raw_key_check(dsl_dataset_t ds, nvlist_t nvl, dmu_tx_t *tx)
	{
	int ret;
	objset_t *mos = tx->tx_pool->dp_meta_objset;
	uint8_t *buf = NULL;
	uint_t len;
	uint64_t intval, key_guid, version;
	boolean_t is_passphrase = B_FALSE;

	ASSERT(dsl_dataset_phys(ds)->ds_flags & DS_FLAG_INCONSISTENT);

	/*
	* Read and check all the encryption values from the nvlist. We need
	* all of the fields of a DSL Crypto Key, as well as a fully specified
	* wrapping key.
	*/
	ret = nvlist_lookup_uint64(nvl, DSL_CRYPTO_KEY_CRYPTO_SUITE, &intval);
	if (ret != 0 \|\| intval >= ZIO_CRYPT_FUNCTIONS \|\|
	intval <= ZIO_CRYPT_OFF)
	return (SET_ERROR(EINVAL));

	ret = nvlist_lookup_uint64(nvl, DSL_CRYPTO_KEY_GUID, &intval);
	if (ret != 0)
	return (SET_ERROR(EINVAL));

	/*
	* If this is an incremental receive make sure the given key guid
	* matches the one we already have.
	*/
	if (ds->ds_dir->dd_crypto_obj != 0) {
	ret = zap_lookup(mos, ds->ds_dir->dd_crypto_obj,
	DSL_CRYPTO_KEY_GUID, 8, 1, &key_guid);
	if (ret != 0)
	return (ret);
	if (intval != key_guid)
	return (SET_ERROR(EACCES));
	}

	ret = nvlist_lookup_uint8_array(nvl, DSL_CRYPTO_KEY_MASTER_KEY,
	&buf, &len);
	if (ret != 0 \|\| len != MASTER_KEY_MAX_LEN)
	return (SET_ERROR(EINVAL));

	ret = nvlist_lookup_uint8_array(nvl, DSL_CRYPTO_KEY_HMAC_KEY,
	&buf, &len);
	if (ret != 0 \|\| len != SHA512_HMAC_KEYLEN)
	return (SET_ERROR(EINVAL));

	ret = nvlist_lookup_uint8_array(nvl, DSL_CRYPTO_KEY_IV, &buf, &len);
	if (ret != 0 \|\| len != WRAPPING_IV_LEN)
	return (SET_ERROR(EINVAL));

	ret = nvlist_lookup_uint8_array(nvl, DSL_CRYPTO_KEY_MAC, &buf, &len);
	if (ret != 0 \|\| len != WRAPPING_MAC_LEN)
	return (SET_ERROR(EINVAL));

	/*
	* We don't support receiving old on-disk formats. The version 0
	* implementation protected several fields in an objset that were
	* not always portable during a raw receive. As a result, we call
	* the old version an on-disk errata #3.
	*/
	ret = nvlist_lookup_uint64(nvl, DSL_CRYPTO_KEY_VERSION, &version);
	if (ret != 0 \|\| version != ZIO_CRYPT_KEY_CURRENT_VERSION)
	return (SET_ERROR(ENOTSUP));

	ret = nvlist_lookup_uint64(nvl, zfs_prop_to_name(ZFS_PROP_KEYFORMAT),
	&intval);
	if (ret != 0 \|\| intval >= ZFS_KEYFORMAT_FORMATS \|\|
	intval == ZFS_KEYFORMAT_NONE)
	return (SET_ERROR(EINVAL));

	is_passphrase = (intval == ZFS_KEYFORMAT_PASSPHRASE);

	/*
	* for raw receives we allow any number of pbkdf2iters since there
	* won't be a chance for the user to change it.
	*/
	ret = nvlist_lookup_uint64(nvl, zfs_prop_to_name(ZFS_PROP_PBKDF2_ITERS),
	&intval);
	if (ret != 0 \|\| (is_passphrase == (intval == 0)))
	return (SET_ERROR(EINVAL));

	ret = nvlist_lookup_uint64(nvl, zfs_prop_to_name(ZFS_PROP_PBKDF2_SALT),
	&intval);
	if (ret != 0 \|\| (is_passphrase == (intval == 0)))
	return (SET_ERROR(EINVAL));

	return (0);
	}

	void
	dsl_crypto_recv_raw_key_sync(dsl_dataset_t ds, nvlist_t nvl, dmu_tx_t *tx)
	{
	dsl_pool_t *dp = tx->tx_pool;
	objset_t *mos = dp->dp_meta_objset;
	dsl_dir_t *dd = ds->ds_dir;
	uint_t len;
	uint64_t rddobj, one = 1;
	uint8_t keydata, hmac_keydata, iv, mac;
	uint64_t crypt, key_guid, keyformat, iters, salt;
	uint64_t version = ZIO_CRYPT_KEY_CURRENT_VERSION;
	char *keylocation = "prompt";

	/* lookup the values we need to create the DSL Crypto Key */
	crypt = fnvlist_lookup_uint64(nvl, DSL_CRYPTO_KEY_CRYPTO_SUITE);
	key_guid = fnvlist_lookup_uint64(nvl, DSL_CRYPTO_KEY_GUID);
	keyformat = fnvlist_lookup_uint64(nvl,
	zfs_prop_to_name(ZFS_PROP_KEYFORMAT));
	iters = fnvlist_lookup_uint64(nvl,
	zfs_prop_to_name(ZFS_PROP_PBKDF2_ITERS));
	salt = fnvlist_lookup_uint64(nvl,
	zfs_prop_to_name(ZFS_PROP_PBKDF2_SALT));
	VERIFY0(nvlist_lookup_uint8_array(nvl, DSL_CRYPTO_KEY_MASTER_KEY,
	&keydata, &len));
	VERIFY0(nvlist_lookup_uint8_array(nvl, DSL_CRYPTO_KEY_HMAC_KEY,
	&hmac_keydata, &len));
	VERIFY0(nvlist_lookup_uint8_array(nvl, DSL_CRYPTO_KEY_IV, &iv, &len));
	VERIFY0(nvlist_lookup_uint8_array(nvl, DSL_CRYPTO_KEY_MAC, &mac, &len));

	/* if this is a new dataset setup the DSL Crypto Key. */
	if (dd->dd_crypto_obj == 0) {
	/* zapify the dsl dir so we can add the key object to it */
	dmu_buf_will_dirty(dd->dd_dbuf, tx);
	dsl_dir_zapify(dd, tx);

	/* create the DSL Crypto Key on disk and activate the feature */
	dd->dd_crypto_obj = zap_create(mos,
	DMU_OTN_ZAP_METADATA, DMU_OT_NONE, 0, tx);
	VERIFY0(zap_update(tx->tx_pool->dp_meta_objset,
	dd->dd_crypto_obj, DSL_CRYPTO_KEY_REFCOUNT,
	sizeof (uint64_t), 1, &one, tx));
	VERIFY0(zap_update(tx->tx_pool->dp_meta_objset,
	dd->dd_crypto_obj, DSL_CRYPTO_KEY_VERSION,
	sizeof (uint64_t), 1, &version, tx));

	dsl_dataset_activate_feature(ds->ds_object,
	SPA_FEATURE_ENCRYPTION, (void *)B_TRUE, tx);
	ds->ds_feature[SPA_FEATURE_ENCRYPTION] = (void *)B_TRUE;

	/* save the dd_crypto_obj on disk */
	VERIFY0(zap_add(mos, dd->dd_object, DD_FIELD_CRYPTO_KEY_OBJ,
	sizeof (uint64_t), 1, &dd->dd_crypto_obj, tx));

	/*
	* Set the keylocation to prompt by default. If keylocation
	* has been provided via the properties, this will be overridden
	* later.
	*/
	dsl_prop_set_sync_impl(ds,
	zfs_prop_to_name(ZFS_PROP_KEYLOCATION),
	ZPROP_SRC_LOCAL, 1, strlen(keylocation) + 1,
	keylocation, tx);

	rddobj = dd->dd_object;
	} else {
	VERIFY0(dsl_dir_get_encryption_root_ddobj(dd, &rddobj));
	}

	/* sync the key data to the ZAP object on disk */
	dsl_crypto_key_sync_impl(mos, dd->dd_crypto_obj, crypt,
	rddobj, key_guid, iv, mac, keydata, hmac_keydata, keyformat, salt,
	iters, tx);
	}

	static int
	dsl_crypto_recv_key_check(void arg, dmu_tx_t tx)
	{
	int ret;
	dsl_crypto_recv_key_arg_t *dcrka = arg;
	dsl_dataset_t ds = NULL, fromds = NULL;

	ret = dsl_dataset_hold_obj(tx->tx_pool, dcrka->dcrka_dsobj,
	FTAG, &ds);
	if (ret != 0)
	goto out;

	if (dcrka->dcrka_fromobj != 0) {
	ret = dsl_dataset_hold_obj(tx->tx_pool, dcrka->dcrka_fromobj,
	FTAG, &fromds);
	if (ret != 0)
	goto out;
	}

	ret = dsl_crypto_recv_raw_objset_check(ds, fromds,
	dcrka->dcrka_ostype, dcrka->dcrka_nvl, tx);
	if (ret != 0)
	goto out;

	/*
	* We run this check even if we won't be doing this part of
	* the receive now so that we don't make the user wait until
	* the receive finishes to fail.
	*/
	ret = dsl_crypto_recv_raw_key_check(ds, dcrka->dcrka_nvl, tx);
	if (ret != 0)
	goto out;

	out:
	if (ds != NULL)
	dsl_dataset_rele(ds, FTAG);
	if (fromds != NULL)
	dsl_dataset_rele(fromds, FTAG);
	return (ret);
	}

	static void
	dsl_crypto_recv_key_sync(void arg, dmu_tx_t tx)
	{
	dsl_crypto_recv_key_arg_t *dcrka = arg;
	dsl_dataset_t *ds;

	VERIFY0(dsl_dataset_hold_obj(tx->tx_pool, dcrka->dcrka_dsobj,
	FTAG, &ds));
	dsl_crypto_recv_raw_objset_sync(ds, dcrka->dcrka_ostype,
	dcrka->dcrka_nvl, tx);
	if (dcrka->dcrka_do_key)
	dsl_crypto_recv_raw_key_sync(ds, dcrka->dcrka_nvl, tx);
	dsl_dataset_rele(ds, FTAG);
	}

	/*
	* This function is used to sync an nvlist representing a DSL Crypto Key and
	* the associated encryption parameters. The key will be written exactly as is
	* without wrapping it.
	*/
	int
	dsl_crypto_recv_raw(const char *poolname, uint64_t dsobj, uint64_t fromobj,
	dmu_objset_type_t ostype, nvlist_t *nvl, boolean_t do_key)
	{
	dsl_crypto_recv_key_arg_t dcrka;

	dcrka.dcrka_dsobj = dsobj;
	dcrka.dcrka_fromobj = fromobj;
	dcrka.dcrka_ostype = ostype;
	dcrka.dcrka_nvl = nvl;
	dcrka.dcrka_do_key = do_key;

	return (dsl_sync_task(poolname, dsl_crypto_recv_key_check,
	dsl_crypto_recv_key_sync, &dcrka, 1, ZFS_SPACE_CHECK_NORMAL));
	}

	int
	dsl_crypto_populate_key_nvlist(objset_t *os, uint64_t from_ivset_guid,
	nvlist_t **nvl_out)
	{
	int ret;
	dsl_dataset_t *ds = os->os_dsl_dataset;
	dnode_t *mdn;
	uint64_t rddobj;
	nvlist_t *nvl = NULL;
	uint64_t dckobj = ds->ds_dir->dd_crypto_obj;
	dsl_dir_t *rdd = NULL;
	dsl_pool_t *dp = ds->ds_dir->dd_pool;
	objset_t *mos = dp->dp_meta_objset;
	uint64_t crypt = 0, key_guid = 0, format = 0;
	uint64_t iters = 0, salt = 0, version = 0;
	uint64_t to_ivset_guid = 0;
	uint8_t raw_keydata[MASTER_KEY_MAX_LEN];
	uint8_t raw_hmac_keydata[SHA512_HMAC_KEYLEN];
	uint8_t iv[WRAPPING_IV_LEN];
	uint8_t mac[WRAPPING_MAC_LEN];

	ASSERT(dckobj != 0);

	mdn = DMU_META_DNODE(os);

	nvl = fnvlist_alloc();

	/* lookup values from the DSL Crypto Key */
	ret = zap_lookup(mos, dckobj, DSL_CRYPTO_KEY_CRYPTO_SUITE, 8, 1,
	&crypt);
	if (ret != 0)
	goto error;

	ret = zap_lookup(mos, dckobj, DSL_CRYPTO_KEY_GUID, 8, 1, &key_guid);
	if (ret != 0)
	goto error;

	ret = zap_lookup(mos, dckobj, DSL_CRYPTO_KEY_MASTER_KEY, 1,
	MASTER_KEY_MAX_LEN, raw_keydata);
	if (ret != 0)
	goto error;

	ret = zap_lookup(mos, dckobj, DSL_CRYPTO_KEY_HMAC_KEY, 1,
	SHA512_HMAC_KEYLEN, raw_hmac_keydata);
	if (ret != 0)
	goto error;

	ret = zap_lookup(mos, dckobj, DSL_CRYPTO_KEY_IV, 1, WRAPPING_IV_LEN,
	iv);
	if (ret != 0)
	goto error;

	ret = zap_lookup(mos, dckobj, DSL_CRYPTO_KEY_MAC, 1, WRAPPING_MAC_LEN,
	mac);
	if (ret != 0)
	goto error;

	/* see zfs_disable_ivset_guid_check tunable for errata info */
	ret = zap_lookup(mos, ds->ds_object, DS_FIELD_IVSET_GUID, 8, 1,
	&to_ivset_guid);
	if (ret != 0)
	ASSERT3U(dp->dp_spa->spa_errata, !=, 0);

	/*
	* We don't support raw sends of legacy on-disk formats. See the
	* comment in dsl_crypto_recv_key_check() for details.
	*/
	ret = zap_lookup(mos, dckobj, DSL_CRYPTO_KEY_VERSION, 8, 1, &version);
	if (ret != 0 \|\| version != ZIO_CRYPT_KEY_CURRENT_VERSION) {
	dp->dp_spa->spa_errata = ZPOOL_ERRATA_ZOL_6845_ENCRYPTION;
	ret = SET_ERROR(ENOTSUP);
	goto error;
	}

	/*
	* Lookup wrapping key properties. An early version of the code did
	* not correctly add these values to the wrapping key or the DSL
	* Crypto Key on disk for non encryption roots, so to be safe we
	* always take the slightly circuitous route of looking it up from
	* the encryption root's key.
	*/
	ret = dsl_dir_get_encryption_root_ddobj(ds->ds_dir, &rddobj);
	if (ret != 0)
	goto error;

	dsl_pool_config_enter(dp, FTAG);

	ret = dsl_dir_hold_obj(dp, rddobj, NULL, FTAG, &rdd);
	if (ret != 0)
	goto error_unlock;

	ret = zap_lookup(dp->dp_meta_objset, rdd->dd_crypto_obj,
	zfs_prop_to_name(ZFS_PROP_KEYFORMAT), 8, 1, &format);
	if (ret != 0)
	goto error_unlock;

	if (format == ZFS_KEYFORMAT_PASSPHRASE) {
	ret = zap_lookup(dp->dp_meta_objset, rdd->dd_crypto_obj,
	zfs_prop_to_name(ZFS_PROP_PBKDF2_ITERS), 8, 1, &iters);
	if (ret != 0)
	goto error_unlock;

	ret = zap_lookup(dp->dp_meta_objset, rdd->dd_crypto_obj,
	zfs_prop_to_name(ZFS_PROP_PBKDF2_SALT), 8, 1, &salt);
	if (ret != 0)
	goto error_unlock;
	}

	dsl_dir_rele(rdd, FTAG);
	dsl_pool_config_exit(dp, FTAG);

	fnvlist_add_uint64(nvl, DSL_CRYPTO_KEY_CRYPTO_SUITE, crypt);
	fnvlist_add_uint64(nvl, DSL_CRYPTO_KEY_GUID, key_guid);
	fnvlist_add_uint64(nvl, DSL_CRYPTO_KEY_VERSION, version);
	VERIFY0(nvlist_add_uint8_array(nvl, DSL_CRYPTO_KEY_MASTER_KEY,
	raw_keydata, MASTER_KEY_MAX_LEN));
	VERIFY0(nvlist_add_uint8_array(nvl, DSL_CRYPTO_KEY_HMAC_KEY,
	raw_hmac_keydata, SHA512_HMAC_KEYLEN));
	VERIFY0(nvlist_add_uint8_array(nvl, DSL_CRYPTO_KEY_IV, iv,
	WRAPPING_IV_LEN));
	VERIFY0(nvlist_add_uint8_array(nvl, DSL_CRYPTO_KEY_MAC, mac,
	WRAPPING_MAC_LEN));
	VERIFY0(nvlist_add_uint8_array(nvl, "portable_mac",
	os->os_phys->os_portable_mac, ZIO_OBJSET_MAC_LEN));
	fnvlist_add_uint64(nvl, zfs_prop_to_name(ZFS_PROP_KEYFORMAT), format);
	fnvlist_add_uint64(nvl, zfs_prop_to_name(ZFS_PROP_PBKDF2_ITERS), iters);
	fnvlist_add_uint64(nvl, zfs_prop_to_name(ZFS_PROP_PBKDF2_SALT), salt);
	fnvlist_add_uint64(nvl, "mdn_checksum", mdn->dn_checksum);
	fnvlist_add_uint64(nvl, "mdn_compress", mdn->dn_compress);
	fnvlist_add_uint64(nvl, "mdn_nlevels", mdn->dn_nlevels);
	fnvlist_add_uint64(nvl, "mdn_blksz", mdn->dn_datablksz);
	fnvlist_add_uint64(nvl, "mdn_indblkshift", mdn->dn_indblkshift);
	fnvlist_add_uint64(nvl, "mdn_nblkptr", mdn->dn_nblkptr);
	fnvlist_add_uint64(nvl, "mdn_maxblkid", mdn->dn_maxblkid);
	fnvlist_add_uint64(nvl, "to_ivset_guid", to_ivset_guid);
	fnvlist_add_uint64(nvl, "from_ivset_guid", from_ivset_guid);

	*nvl_out = nvl;
	return (0);

	error_unlock:
	dsl_pool_config_exit(dp, FTAG);
	error:
	if (rdd != NULL)
	dsl_dir_rele(rdd, FTAG);
	nvlist_free(nvl);

	*nvl_out = NULL;
	return (ret);
	}

	uint64_t
	dsl_crypto_key_create_sync(uint64_t crypt, dsl_wrapping_key_t *wkey,
	dmu_tx_t *tx)
	{
	dsl_crypto_key_t dck;
	uint64_t version = ZIO_CRYPT_KEY_CURRENT_VERSION;
	uint64_t one = 1ULL;

	ASSERT(dmu_tx_is_syncing(tx));
	ASSERT3U(crypt, <, ZIO_CRYPT_FUNCTIONS);
	ASSERT3U(crypt, >, ZIO_CRYPT_OFF);

	/* create the DSL Crypto Key ZAP object */
	dck.dck_obj = zap_create(tx->tx_pool->dp_meta_objset,
	DMU_OTN_ZAP_METADATA, DMU_OT_NONE, 0, tx);

	/* fill in the key (on the stack) and sync it to disk */
	dck.dck_wkey = wkey;
	VERIFY0(zio_crypt_key_init(crypt, &dck.dck_key));

	dsl_crypto_key_sync(&dck, tx);
	VERIFY0(zap_update(tx->tx_pool->dp_meta_objset, dck.dck_obj,
	DSL_CRYPTO_KEY_REFCOUNT, sizeof (uint64_t), 1, &one, tx));
	VERIFY0(zap_update(tx->tx_pool->dp_meta_objset, dck.dck_obj,
	DSL_CRYPTO_KEY_VERSION, sizeof (uint64_t), 1, &version, tx));

	zio_crypt_key_destroy(&dck.dck_key);
	bzero(&dck.dck_key, sizeof (zio_crypt_key_t));

	return (dck.dck_obj);
	}

	uint64_t
	dsl_crypto_key_clone_sync(dsl_dir_t origindd, dmu_tx_t tx)
	{
	objset_t *mos = tx->tx_pool->dp_meta_objset;

	ASSERT(dmu_tx_is_syncing(tx));

	VERIFY0(zap_increment(mos, origindd->dd_crypto_obj,
	DSL_CRYPTO_KEY_REFCOUNT, 1, tx));

	return (origindd->dd_crypto_obj);
	}

	void
	dsl_crypto_key_destroy_sync(uint64_t dckobj, dmu_tx_t *tx)
	{
	objset_t *mos = tx->tx_pool->dp_meta_objset;
	uint64_t refcnt;

	/* Decrement the refcount, destroy if this is the last reference */
	VERIFY0(zap_lookup(mos, dckobj, DSL_CRYPTO_KEY_REFCOUNT,
	sizeof (uint64_t), 1, &refcnt));

	if (refcnt != 1) {
	VERIFY0(zap_increment(mos, dckobj, DSL_CRYPTO_KEY_REFCOUNT,
	-1, tx));
	} else {
	VERIFY0(zap_destroy(mos, dckobj, tx));
	}
	}

	void
	dsl_dataset_crypt_stats(dsl_dataset_t ds, nvlist_t nv)
	{
	uint64_t intval;
	dsl_dir_t *dd = ds->ds_dir;
	dsl_dir_t *enc_root;
	char buf[ZFS_MAX_DATASET_NAME_LEN];

	if (dd->dd_crypto_obj == 0)
	return;

	intval = dsl_dataset_get_keystatus(dd);
	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_KEYSTATUS, intval);

	if (dsl_dir_get_crypt(dd, &intval) == 0)
	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_ENCRYPTION, intval);
	if (zap_lookup(dd->dd_pool->dp_meta_objset, dd->dd_crypto_obj,
	DSL_CRYPTO_KEY_GUID, 8, 1, &intval) == 0) {
	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_KEY_GUID, intval);
	}
	if (zap_lookup(dd->dd_pool->dp_meta_objset, dd->dd_crypto_obj,
	zfs_prop_to_name(ZFS_PROP_KEYFORMAT), 8, 1, &intval) == 0) {
	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_KEYFORMAT, intval);
	}
	if (zap_lookup(dd->dd_pool->dp_meta_objset, dd->dd_crypto_obj,
	zfs_prop_to_name(ZFS_PROP_PBKDF2_SALT), 8, 1, &intval) == 0) {
	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_PBKDF2_SALT, intval);
	}
	if (zap_lookup(dd->dd_pool->dp_meta_objset, dd->dd_crypto_obj,
	zfs_prop_to_name(ZFS_PROP_PBKDF2_ITERS), 8, 1, &intval) == 0) {
	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_PBKDF2_ITERS, intval);
	}
	if (zap_lookup(dd->dd_pool->dp_meta_objset, ds->ds_object,
	DS_FIELD_IVSET_GUID, 8, 1, &intval) == 0) {
	dsl_prop_nvlist_add_uint64(nv, ZFS_PROP_IVSET_GUID, intval);
	}

	if (dsl_dir_get_encryption_root_ddobj(dd, &intval) == 0) {
	if (dsl_dir_hold_obj(dd->dd_pool, intval, NULL, FTAG,
	&enc_root) == 0) {
	dsl_dir_name(enc_root, buf);
	dsl_dir_rele(enc_root, FTAG);
	dsl_prop_nvlist_add_string(nv,
	ZFS_PROP_ENCRYPTION_ROOT, buf);
	}
	}
	}

	int
	spa_crypt_get_salt(spa_t spa, uint64_t dsobj, uint8_t salt)
	{
	int ret;
	dsl_crypto_key_t *dck = NULL;

	/* look up the key from the spa's keystore */
	ret = spa_keystore_lookup_key(spa, dsobj, FTAG, &dck);
	if (ret != 0)
	goto error;

	ret = zio_crypt_key_get_salt(&dck->dck_key, salt);
	if (ret != 0)
	goto error;

	spa_keystore_dsl_key_rele(spa, dck, FTAG);
	return (0);

	error:
	if (dck != NULL)
	spa_keystore_dsl_key_rele(spa, dck, FTAG);
	return (ret);
	}

	/*
	* Objset blocks are a special case for MAC generation. These blocks have 2
	* 256-bit MACs which are embedded within the block itself, rather than a
	* single 128 bit MAC. As a result, this function handles encoding and decoding
	* the MACs on its own, unlike other functions in this file.
	*/
	int
	spa_do_crypt_objset_mac_abd(boolean_t generate, spa_t *spa, uint64_t dsobj,
	abd_t *abd, uint_t datalen, boolean_t byteswap)
	{
	int ret;
	dsl_crypto_key_t *dck = NULL;
	void *buf = abd_borrow_buf_copy(abd, datalen);
	objset_phys_t *osp = buf;
	uint8_t portable_mac[ZIO_OBJSET_MAC_LEN];
	uint8_t local_mac[ZIO_OBJSET_MAC_LEN];

	/* look up the key from the spa's keystore */
	ret = spa_keystore_lookup_key(spa, dsobj, FTAG, &dck);
	if (ret != 0)
	goto error;

	/* calculate both HMACs */
	ret = zio_crypt_do_objset_hmacs(&dck->dck_key, buf, datalen,
	byteswap, portable_mac, local_mac);
	if (ret != 0)
	goto error;

	spa_keystore_dsl_key_rele(spa, dck, FTAG);

	/* if we are generating encode the HMACs in the objset_phys_t */
	if (generate) {
	bcopy(portable_mac, osp->os_portable_mac, ZIO_OBJSET_MAC_LEN);
	bcopy(local_mac, osp->os_local_mac, ZIO_OBJSET_MAC_LEN);
	abd_return_buf_copy(abd, buf, datalen);
	return (0);
	}

	if (bcmp(portable_mac, osp->os_portable_mac, ZIO_OBJSET_MAC_LEN) != 0 \|\|
	bcmp(local_mac, osp->os_local_mac, ZIO_OBJSET_MAC_LEN) != 0) {
	abd_return_buf(abd, buf, datalen);
	return (SET_ERROR(ECKSUM));
	}

	abd_return_buf(abd, buf, datalen);

	return (0);

	error:
	if (dck != NULL)
	spa_keystore_dsl_key_rele(spa, dck, FTAG);
	abd_return_buf(abd, buf, datalen);
	return (ret);
	}

	int
	spa_do_crypt_mac_abd(boolean_t generate, spa_t spa, uint64_t dsobj, abd_t abd,
	uint_t datalen, uint8_t *mac)
	{
	int ret;
	dsl_crypto_key_t *dck = NULL;
	uint8_t *buf = abd_borrow_buf_copy(abd, datalen);
	uint8_t digestbuf[ZIO_DATA_MAC_LEN];

	/* look up the key from the spa's keystore */
	ret = spa_keystore_lookup_key(spa, dsobj, FTAG, &dck);
	if (ret != 0)
	goto error;

	/* perform the hmac */
	ret = zio_crypt_do_hmac(&dck->dck_key, buf, datalen,
	digestbuf, ZIO_DATA_MAC_LEN);
	if (ret != 0)
	goto error;

	abd_return_buf(abd, buf, datalen);
	spa_keystore_dsl_key_rele(spa, dck, FTAG);

	/*
	* Truncate and fill in mac buffer if we were asked to generate a MAC.
	* Otherwise verify that the MAC matched what we expected.
	*/
	if (generate) {
	bcopy(digestbuf, mac, ZIO_DATA_MAC_LEN);
	return (0);
	}

	if (bcmp(digestbuf, mac, ZIO_DATA_MAC_LEN) != 0)
	return (SET_ERROR(ECKSUM));

	return (0);

	error:
	if (dck != NULL)
	spa_keystore_dsl_key_rele(spa, dck, FTAG);
	abd_return_buf(abd, buf, datalen);
	return (ret);
	}

	/*
	* This function serves as a multiplexer for encryption and decryption of
	* all blocks (except the L2ARC). For encryption, it will populate the IV,
	* salt, MAC, and cabd (the ciphertext). On decryption it will simply use
	* these fields to populate pabd (the plaintext).
	*/
	int
	spa_do_crypt_abd(boolean_t encrypt, spa_t spa, const zbookmark_phys_t zb,
	dmu_object_type_t ot, boolean_t dedup, boolean_t bswap, uint8_t *salt,
	uint8_t iv, uint8_t mac, uint_t datalen, abd_t pabd, abd_t cabd,
	boolean_t *no_crypt)
	{
	int ret;
	dsl_crypto_key_t *dck = NULL;
	uint8_t plainbuf = NULL, cipherbuf = NULL;

	ASSERT(spa_feature_is_active(spa, SPA_FEATURE_ENCRYPTION));

	/* look up the key from the spa's keystore */
	ret = spa_keystore_lookup_key(spa, zb->zb_objset, FTAG, &dck);
	if (ret != 0) {
	ret = SET_ERROR(EACCES);
	return (ret);
	}

	if (encrypt) {
	plainbuf = abd_borrow_buf_copy(pabd, datalen);
	cipherbuf = abd_borrow_buf(cabd, datalen);
	} else {
	plainbuf = abd_borrow_buf(pabd, datalen);
	cipherbuf = abd_borrow_buf_copy(cabd, datalen);
	}

	/*
	* Both encryption and decryption functions need a salt for key
	* generation and an IV. When encrypting a non-dedup block, we
	* generate the salt and IV randomly to be stored by the caller. Dedup
	* blocks perform a (more expensive) HMAC of the plaintext to obtain
	* the salt and the IV. ZIL blocks have their salt and IV generated
	* at allocation time in zio_alloc_zil(). On decryption, we simply use
	* the provided values.
	*/
	if (encrypt && ot != DMU_OT_INTENT_LOG && !dedup) {
	ret = zio_crypt_key_get_salt(&dck->dck_key, salt);
	if (ret != 0)
	goto error;

	ret = zio_crypt_generate_iv(iv);
	if (ret != 0)
	goto error;
	} else if (encrypt && dedup) {
	ret = zio_crypt_generate_iv_salt_dedup(&dck->dck_key,
	plainbuf, datalen, iv, salt);
	if (ret != 0)
	goto error;
	}

	/* call lower level function to perform encryption / decryption */
	ret = zio_do_crypt_data(encrypt, &dck->dck_key, ot, bswap, salt, iv,
	mac, datalen, plainbuf, cipherbuf, no_crypt);

	/*
	* Handle injected decryption faults. Unfortunately, we cannot inject
	* faults for dnode blocks because we might trigger the panic in
	* dbuf_prepare_encrypted_dnode_leaf(), which exists because syncing
	* context is not prepared to handle malicious decryption failures.
	*/
	if (zio_injection_enabled && !encrypt && ot != DMU_OT_DNODE && ret == 0)
	ret = zio_handle_decrypt_injection(spa, zb, ot, ECKSUM);
	if (ret != 0)
	goto error;

	if (encrypt) {
	abd_return_buf(pabd, plainbuf, datalen);
	abd_return_buf_copy(cabd, cipherbuf, datalen);
	} else {
	abd_return_buf_copy(pabd, plainbuf, datalen);
	abd_return_buf(cabd, cipherbuf, datalen);
	}

	spa_keystore_dsl_key_rele(spa, dck, FTAG);

	return (0);

	error:
	if (encrypt) {
	/* zero out any state we might have changed while encrypting */
	bzero(salt, ZIO_DATA_SALT_LEN);
	bzero(iv, ZIO_DATA_IV_LEN);
	bzero(mac, ZIO_DATA_MAC_LEN);
	abd_return_buf(pabd, plainbuf, datalen);
	abd_return_buf_copy(cabd, cipherbuf, datalen);
	} else {
	abd_return_buf_copy(pabd, plainbuf, datalen);
	abd_return_buf(cabd, cipherbuf, datalen);
	}

	spa_keystore_dsl_key_rele(spa, dck, FTAG);

	return (ret);
	}

	ZFS_MODULE_PARAM(zfs, zfs_, disable_ivset_guid_check, INT, ZMOD_RW,
	"Set to allow raw receives without IVset guids");
	diff --git a/sys/contrib/openzfs/module/zfs/dsl_scan.c b/sys/contrib/openzfs/module/zfs/dsl_scan.c
	index a54cd6ca800e..cc1cbcdb9778 100644
	--- a/sys/contrib/openzfs/module/zfs/dsl_scan.c
	+++ b/sys/contrib/openzfs/module/zfs/dsl_scan.c
	@@ -1,4426 +1,4426 @@
	/*
	* 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) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2011, 2021 by Delphix. All rights reserved.
	* Copyright 2016 Gary Mills
	* Copyright (c) 2017, 2019, Datto Inc. All rights reserved.
	* Copyright (c) 2015, Nexenta Systems, Inc. All rights reserved.
	* Copyright 2019 Joyent, Inc.
	*/

	#include <sys/dsl_scan.h>
	#include <sys/dsl_pool.h>
	#include <sys/dsl_dataset.h>
	#include <sys/dsl_prop.h>
	#include <sys/dsl_dir.h>
	#include <sys/dsl_synctask.h>
	#include <sys/dnode.h>
	#include <sys/dmu_tx.h>
	#include <sys/dmu_objset.h>
	#include <sys/arc.h>
	#include <sys/zap.h>
	#include <sys/zio.h>
	#include <sys/zfs_context.h>
	#include <sys/fs/zfs.h>
	#include <sys/zfs_znode.h>
	#include <sys/spa_impl.h>
	#include <sys/vdev_impl.h>
	#include <sys/zil_impl.h>
	#include <sys/zio_checksum.h>
	#include <sys/ddt.h>
	#include <sys/sa.h>
	#include <sys/sa_impl.h>
	#include <sys/zfeature.h>
	#include <sys/abd.h>
	#include <sys/range_tree.h>
	#ifdef _KERNEL
	#include <sys/zfs_vfsops.h>
	#endif

	/*
	* Grand theory statement on scan queue sorting
	*
	* Scanning is implemented by recursively traversing all indirection levels
	* in an object and reading all blocks referenced from said objects. This
	* results in us approximately traversing the object from lowest logical
	* offset to the highest. For best performance, we would want the logical
	* blocks to be physically contiguous. However, this is frequently not the
	* case with pools given the allocation patterns of copy-on-write filesystems.
	* So instead, we put the I/Os into a reordering queue and issue them in a
	* way that will most benefit physical disks (LBA-order).
	*
	* Queue management:
	*
	* Ideally, we would want to scan all metadata and queue up all block I/O
	* prior to starting to issue it, because that allows us to do an optimal
	* sorting job. This can however consume large amounts of memory. Therefore
	* we continuously monitor the size of the queues and constrain them to 5%
	* (zfs_scan_mem_lim_fact) of physmem. If the queues grow larger than this
	* limit, we clear out a few of the largest extents at the head of the queues
	* to make room for more scanning. Hopefully, these extents will be fairly
	* large and contiguous, allowing us to approach sequential I/O throughput
	* even without a fully sorted tree.
	*
	* Metadata scanning takes place in dsl_scan_visit(), which is called from
	* dsl_scan_sync() every spa_sync(). If we have either fully scanned all
	* metadata on the pool, or we need to make room in memory because our
	* queues are too large, dsl_scan_visit() is postponed and
	* scan_io_queues_run() is called from dsl_scan_sync() instead. This implies
	* that metadata scanning and queued I/O issuing are mutually exclusive. This
	* allows us to provide maximum sequential I/O throughput for the majority of
	* I/O's issued since sequential I/O performance is significantly negatively
	* impacted if it is interleaved with random I/O.
	*
	* Implementation Notes
	*
	* One side effect of the queued scanning algorithm is that the scanning code
	* needs to be notified whenever a block is freed. This is needed to allow
	* the scanning code to remove these I/Os from the issuing queue. Additionally,
	* we do not attempt to queue gang blocks to be issued sequentially since this
	* is very hard to do and would have an extremely limited performance benefit.
	* Instead, we simply issue gang I/Os as soon as we find them using the legacy
	* algorithm.
	*
	* Backwards compatibility
	*
	* This new algorithm is backwards compatible with the legacy on-disk data
	* structures (and therefore does not require a new feature flag).
	* Periodically during scanning (see zfs_scan_checkpoint_intval), the scan
	* will stop scanning metadata (in logical order) and wait for all outstanding
	* sorted I/O to complete. Once this is done, we write out a checkpoint
	* bookmark, indicating that we have scanned everything logically before it.
	* If the pool is imported on a machine without the new sorting algorithm,
	* the scan simply resumes from the last checkpoint using the legacy algorithm.
	*/

	typedef int (scan_cb_t)(dsl_pool_t , const blkptr_t ,
	const zbookmark_phys_t *);

	static scan_cb_t dsl_scan_scrub_cb;

	static int scan_ds_queue_compare(const void a, const void b);
	static int scan_prefetch_queue_compare(const void a, const void b);
	static void scan_ds_queue_clear(dsl_scan_t *scn);
	static void scan_ds_prefetch_queue_clear(dsl_scan_t *scn);
	static boolean_t scan_ds_queue_contains(dsl_scan_t *scn, uint64_t dsobj,
	uint64_t *txg);
	static void scan_ds_queue_insert(dsl_scan_t *scn, uint64_t dsobj, uint64_t txg);
	static void scan_ds_queue_remove(dsl_scan_t *scn, uint64_t dsobj);
	static void scan_ds_queue_sync(dsl_scan_t scn, dmu_tx_t tx);
	static uint64_t dsl_scan_count_leaves(vdev_t *vd);

	extern int zfs_vdev_async_write_active_min_dirty_percent;

	/*
	* By default zfs will check to ensure it is not over the hard memory
	* limit before each txg. If finer-grained control of this is needed
	* this value can be set to 1 to enable checking before scanning each
	* block.
	*/
	int zfs_scan_strict_mem_lim = B_FALSE;

	/*
	* Maximum number of parallelly executed bytes per leaf vdev. We attempt
	* to strike a balance here between keeping the vdev queues full of I/Os
	* at all times and not overflowing the queues to cause long latency,
	* which would cause long txg sync times. No matter what, we will not
	* overload the drives with I/O, since that is protected by
	* zfs_vdev_scrub_max_active.
	*/
	unsigned long zfs_scan_vdev_limit = 4 << 20;

	int zfs_scan_issue_strategy = 0;
	int zfs_scan_legacy = B_FALSE; /* don't queue & sort zios, go direct */
	unsigned long zfs_scan_max_ext_gap = 2 << 20; /* in bytes */

	/*
	* fill_weight is non-tunable at runtime, so we copy it at module init from
	* zfs_scan_fill_weight. Runtime adjustments to zfs_scan_fill_weight would
	* break queue sorting.
	*/
	int zfs_scan_fill_weight = 3;
	static uint64_t fill_weight;

	/* See dsl_scan_should_clear() for details on the memory limit tunables */
	uint64_t zfs_scan_mem_lim_min = 16 << 20; /* bytes */
	uint64_t zfs_scan_mem_lim_soft_max = 128 << 20; /* bytes */
	int zfs_scan_mem_lim_fact = 20; /* fraction of physmem */
	int zfs_scan_mem_lim_soft_fact = 20; /* fraction of mem lim above */

	int zfs_scrub_min_time_ms = 1000; /* min millisecs to scrub per txg */
	int zfs_obsolete_min_time_ms = 500; /* min millisecs to obsolete per txg */
	int zfs_free_min_time_ms = 1000; /* min millisecs to free per txg */
	int zfs_resilver_min_time_ms = 3000; /* min millisecs to resilver per txg */
	int zfs_scan_checkpoint_intval = 7200; /* in seconds */
	int zfs_scan_suspend_progress = 0; /* set to prevent scans from progressing */
	int zfs_no_scrub_io = B_FALSE; /* set to disable scrub i/o */
	int zfs_no_scrub_prefetch = B_FALSE; /* set to disable scrub prefetch */
	enum ddt_class zfs_scrub_ddt_class_max = DDT_CLASS_DUPLICATE;
	/* max number of blocks to free in a single TXG */
	unsigned long zfs_async_block_max_blocks = ULONG_MAX;
	/* max number of dedup blocks to free in a single TXG */
	unsigned long zfs_max_async_dedup_frees = 100000;

	int zfs_resilver_disable_defer = 0; /* set to disable resilver deferring */

	/*
	* We wait a few txgs after importing a pool to begin scanning so that
	* the import / mounting code isn't held up by scrub / resilver IO.
	* Unfortunately, it is a bit difficult to determine exactly how long
	* this will take since userspace will trigger fs mounts asynchronously
	* and the kernel will create zvol minors asynchronously. As a result,
	* the value provided here is a bit arbitrary, but represents a
	* reasonable estimate of how many txgs it will take to finish fully
	* importing a pool
	*/
	#define SCAN_IMPORT_WAIT_TXGS 5

	#define DSL_SCAN_IS_SCRUB_RESILVER(scn) \
	((scn)->scn_phys.scn_func == POOL_SCAN_SCRUB \|\| \
	(scn)->scn_phys.scn_func == POOL_SCAN_RESILVER)

	/*
	* Enable/disable the processing of the free_bpobj object.
	*/
	int zfs_free_bpobj_enabled = 1;

	/* the order has to match pool_scan_type */
	static scan_cb_t *scan_funcs[POOL_SCAN_FUNCS] = {
	NULL,
	dsl_scan_scrub_cb, /* POOL_SCAN_SCRUB */
	dsl_scan_scrub_cb, /* POOL_SCAN_RESILVER */
	};

	/* In core node for the scn->scn_queue. Represents a dataset to be scanned */
	typedef struct {
	uint64_t sds_dsobj;
	uint64_t sds_txg;
	avl_node_t sds_node;
	} scan_ds_t;

	/*
	* This controls what conditions are placed on dsl_scan_sync_state():
	* SYNC_OPTIONAL) write out scn_phys iff scn_bytes_pending == 0
	* SYNC_MANDATORY) write out scn_phys always. scn_bytes_pending must be 0.
	* SYNC_CACHED) if scn_bytes_pending == 0, write out scn_phys. Otherwise
	* write out the scn_phys_cached version.
	* See dsl_scan_sync_state for details.
	*/
	typedef enum {
	SYNC_OPTIONAL,
	SYNC_MANDATORY,
	SYNC_CACHED
	} state_sync_type_t;

	/*
	* This struct represents the minimum information needed to reconstruct a
	* zio for sequential scanning. This is useful because many of these will
	* accumulate in the sequential IO queues before being issued, so saving
	* memory matters here.
	*/
	typedef struct scan_io {
	/* fields from blkptr_t */
	uint64_t sio_blk_prop;
	uint64_t sio_phys_birth;
	uint64_t sio_birth;
	zio_cksum_t sio_cksum;
	uint32_t sio_nr_dvas;

	/* fields from zio_t */
	uint32_t sio_flags;
	zbookmark_phys_t sio_zb;

	/* members for queue sorting */
	union {
	avl_node_t sio_addr_node; /* link into issuing queue */
	list_node_t sio_list_node; /* link for issuing to disk */
	} sio_nodes;

	/*
	* There may be up to SPA_DVAS_PER_BP DVAs here from the bp,
	* depending on how many were in the original bp. Only the
	* first DVA is really used for sorting and issuing purposes.
	* The other DVAs (if provided) simply exist so that the zio
	* layer can find additional copies to repair from in the
	* event of an error. This array must go at the end of the
	* struct to allow this for the variable number of elements.
	*/
	dva_t sio_dva[0];
	} scan_io_t;

	#define SIO_SET_OFFSET(sio, x) DVA_SET_OFFSET(&(sio)->sio_dva[0], x)
	#define SIO_SET_ASIZE(sio, x) DVA_SET_ASIZE(&(sio)->sio_dva[0], x)
	#define SIO_GET_OFFSET(sio) DVA_GET_OFFSET(&(sio)->sio_dva[0])
	#define SIO_GET_ASIZE(sio) DVA_GET_ASIZE(&(sio)->sio_dva[0])
	#define SIO_GET_END_OFFSET(sio) \
	(SIO_GET_OFFSET(sio) + SIO_GET_ASIZE(sio))
	#define SIO_GET_MUSED(sio) \
	(sizeof (scan_io_t) + ((sio)->sio_nr_dvas * sizeof (dva_t)))

	struct dsl_scan_io_queue {
	dsl_scan_t q_scn; / associated dsl_scan_t */
	vdev_t q_vd; / top-level vdev that this queue represents */

	/* trees used for sorting I/Os and extents of I/Os */
	range_tree_t *q_exts_by_addr;
	zfs_btree_t q_exts_by_size;
	avl_tree_t q_sios_by_addr;
	uint64_t q_sio_memused;

	/* members for zio rate limiting */
	uint64_t q_maxinflight_bytes;
	uint64_t q_inflight_bytes;
	kcondvar_t q_zio_cv; /* used under vd->vdev_scan_io_queue_lock */

	/* per txg statistics */
	uint64_t q_total_seg_size_this_txg;
	uint64_t q_segs_this_txg;
	uint64_t q_total_zio_size_this_txg;
	uint64_t q_zios_this_txg;
	};

	/* private data for dsl_scan_prefetch_cb() */
	typedef struct scan_prefetch_ctx {
	zfs_refcount_t spc_refcnt; /* refcount for memory management */
	dsl_scan_t spc_scn; / dsl_scan_t for the pool */
	boolean_t spc_root; /* is this prefetch for an objset? */
	uint8_t spc_indblkshift; /* dn_indblkshift of current dnode */
	uint16_t spc_datablkszsec; /* dn_idatablkszsec of current dnode */
	} scan_prefetch_ctx_t;

	/* private data for dsl_scan_prefetch() */
	typedef struct scan_prefetch_issue_ctx {
	avl_node_t spic_avl_node; /* link into scn->scn_prefetch_queue */
	scan_prefetch_ctx_t spic_spc; / spc for the callback */
	blkptr_t spic_bp; /* bp to prefetch */
	zbookmark_phys_t spic_zb; /* bookmark to prefetch */
	} scan_prefetch_issue_ctx_t;

	static void scan_exec_io(dsl_pool_t dp, const blkptr_t bp, int zio_flags,
	const zbookmark_phys_t zb, dsl_scan_io_queue_t queue);
	static void scan_io_queue_insert_impl(dsl_scan_io_queue_t *queue,
	scan_io_t *sio);

	static dsl_scan_io_queue_t scan_io_queue_create(vdev_t vd);
	static void scan_io_queues_destroy(dsl_scan_t *scn);

	static kmem_cache_t *sio_cache[SPA_DVAS_PER_BP];

	/* sio->sio_nr_dvas must be set so we know which cache to free from */
	static void
	sio_free(scan_io_t *sio)
	{
	ASSERT3U(sio->sio_nr_dvas, >, 0);
	ASSERT3U(sio->sio_nr_dvas, <=, SPA_DVAS_PER_BP);

	kmem_cache_free(sio_cache[sio->sio_nr_dvas - 1], sio);
	}

	/* It is up to the caller to set sio->sio_nr_dvas for freeing */
	static scan_io_t *
	sio_alloc(unsigned short nr_dvas)
	{
	ASSERT3U(nr_dvas, >, 0);
	ASSERT3U(nr_dvas, <=, SPA_DVAS_PER_BP);

	return (kmem_cache_alloc(sio_cache[nr_dvas - 1], KM_SLEEP));
	}

	void
	scan_init(void)
	{
	/*
	* This is used in ext_size_compare() to weight segments
	* based on how sparse they are. This cannot be changed
	* mid-scan and the tree comparison functions don't currently
	* have a mechanism for passing additional context to the
	* compare functions. Thus we store this value globally and
	* we only allow it to be set at module initialization time
	*/
	fill_weight = zfs_scan_fill_weight;

	for (int i = 0; i < SPA_DVAS_PER_BP; i++) {
	char name[36];

	(void) snprintf(name, sizeof (name), "sio_cache_%d", i);
	sio_cache[i] = kmem_cache_create(name,
	(sizeof (scan_io_t) + ((i + 1) * sizeof (dva_t))),
	0, NULL, NULL, NULL, NULL, NULL, 0);
	}
	}

	void
	scan_fini(void)
	{
	for (int i = 0; i < SPA_DVAS_PER_BP; i++) {
	kmem_cache_destroy(sio_cache[i]);
	}
	}

	static inline boolean_t
	dsl_scan_is_running(const dsl_scan_t *scn)
	{
	return (scn->scn_phys.scn_state == DSS_SCANNING);
	}

	boolean_t
	dsl_scan_resilvering(dsl_pool_t *dp)
	{
	return (dsl_scan_is_running(dp->dp_scan) &&
	dp->dp_scan->scn_phys.scn_func == POOL_SCAN_RESILVER);
	}

	static inline void
	sio2bp(const scan_io_t sio, blkptr_t bp)
	{
	bzero(bp, sizeof (*bp));
	bp->blk_prop = sio->sio_blk_prop;
	bp->blk_phys_birth = sio->sio_phys_birth;
	bp->blk_birth = sio->sio_birth;
	bp->blk_fill = 1; /* we always only work with data pointers */
	bp->blk_cksum = sio->sio_cksum;

	ASSERT3U(sio->sio_nr_dvas, >, 0);
	ASSERT3U(sio->sio_nr_dvas, <=, SPA_DVAS_PER_BP);

	bcopy(sio->sio_dva, bp->blk_dva, sio->sio_nr_dvas * sizeof (dva_t));
	}

	static inline void
	bp2sio(const blkptr_t bp, scan_io_t sio, int dva_i)
	{
	sio->sio_blk_prop = bp->blk_prop;
	sio->sio_phys_birth = bp->blk_phys_birth;
	sio->sio_birth = bp->blk_birth;
	sio->sio_cksum = bp->blk_cksum;
	sio->sio_nr_dvas = BP_GET_NDVAS(bp);

	/*
	* Copy the DVAs to the sio. We need all copies of the block so
	* that the self healing code can use the alternate copies if the
	* first is corrupted. We want the DVA at index dva_i to be first
	* in the sio since this is the primary one that we want to issue.
	*/
	for (int i = 0, j = dva_i; i < sio->sio_nr_dvas; i++, j++) {
	sio->sio_dva[i] = bp->blk_dva[j % sio->sio_nr_dvas];
	}
	}

	int
	dsl_scan_init(dsl_pool_t *dp, uint64_t txg)
	{
	int err;
	dsl_scan_t *scn;
	spa_t *spa = dp->dp_spa;
	uint64_t f;

	scn = dp->dp_scan = kmem_zalloc(sizeof (dsl_scan_t), KM_SLEEP);
	scn->scn_dp = dp;

	/*
	* It's possible that we're resuming a scan after a reboot so
	* make sure that the scan_async_destroying flag is initialized
	* appropriately.
	*/
	ASSERT(!scn->scn_async_destroying);
	scn->scn_async_destroying = spa_feature_is_active(dp->dp_spa,
	SPA_FEATURE_ASYNC_DESTROY);

	/*
	* Calculate the max number of in-flight bytes for pool-wide
	* scanning operations (minimum 1MB). Limits for the issuing
	* phase are done per top-level vdev and are handled separately.
	*/
	scn->scn_maxinflight_bytes = MAX(zfs_scan_vdev_limit *
	dsl_scan_count_leaves(spa->spa_root_vdev), 1ULL << 20);

	avl_create(&scn->scn_queue, scan_ds_queue_compare, sizeof (scan_ds_t),
	offsetof(scan_ds_t, sds_node));
	avl_create(&scn->scn_prefetch_queue, scan_prefetch_queue_compare,
	sizeof (scan_prefetch_issue_ctx_t),
	offsetof(scan_prefetch_issue_ctx_t, spic_avl_node));

	err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
	"scrub_func", sizeof (uint64_t), 1, &f);
	if (err == 0) {
	/*
	* There was an old-style scrub in progress. Restart a
	* new-style scrub from the beginning.
	*/
	scn->scn_restart_txg = txg;
	zfs_dbgmsg("old-style scrub was in progress; "
	"restarting new-style scrub in txg %llu",
	(longlong_t)scn->scn_restart_txg);

	/*
	* Load the queue obj from the old location so that it
	* can be freed by dsl_scan_done().
	*/
	(void) zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
	"scrub_queue", sizeof (uint64_t), 1,
	&scn->scn_phys.scn_queue_obj);
	} else {
	err = zap_lookup(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
	DMU_POOL_SCAN, sizeof (uint64_t), SCAN_PHYS_NUMINTS,
	&scn->scn_phys);
	/*
	* Detect if the pool contains the signature of #2094. If it
	* does properly update the scn->scn_phys structure and notify
	* the administrator by setting an errata for the pool.
	*/
	if (err == EOVERFLOW) {
	uint64_t zaptmp[SCAN_PHYS_NUMINTS + 1];
	VERIFY3S(SCAN_PHYS_NUMINTS, ==, 24);
	VERIFY3S(offsetof(dsl_scan_phys_t, scn_flags), ==,
	(23 * sizeof (uint64_t)));

	err = zap_lookup(dp->dp_meta_objset,
	DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_SCAN,
	sizeof (uint64_t), SCAN_PHYS_NUMINTS + 1, &zaptmp);
	if (err == 0) {
	uint64_t overflow = zaptmp[SCAN_PHYS_NUMINTS];

	if (overflow & ~DSL_SCAN_FLAGS_MASK \|\|
	scn->scn_async_destroying) {
	spa->spa_errata =
	ZPOOL_ERRATA_ZOL_2094_ASYNC_DESTROY;
	return (EOVERFLOW);
	}

	bcopy(zaptmp, &scn->scn_phys,
	SCAN_PHYS_NUMINTS * sizeof (uint64_t));
	scn->scn_phys.scn_flags = overflow;

	/* Required scrub already in progress. */
	if (scn->scn_phys.scn_state == DSS_FINISHED \|\|
	scn->scn_phys.scn_state == DSS_CANCELED)
	spa->spa_errata =
	ZPOOL_ERRATA_ZOL_2094_SCRUB;
	}
	}

	if (err == ENOENT)
	return (0);
	else if (err)
	return (err);

	/*
	* We might be restarting after a reboot, so jump the issued
	* counter to how far we've scanned. We know we're consistent
	* up to here.
	*/
	scn->scn_issued_before_pass = scn->scn_phys.scn_examined;

	if (dsl_scan_is_running(scn) &&
	spa_prev_software_version(dp->dp_spa) < SPA_VERSION_SCAN) {
	/*
	* A new-type scrub was in progress on an old
	* pool, and the pool was accessed by old
	* software. Restart from the beginning, since
	* the old software may have changed the pool in
	* the meantime.
	*/
	scn->scn_restart_txg = txg;
	zfs_dbgmsg("new-style scrub was modified "
	"by old software; restarting in txg %llu",
	(longlong_t)scn->scn_restart_txg);
	} else if (dsl_scan_resilvering(dp)) {
	/*
	* If a resilver is in progress and there are already
	* errors, restart it instead of finishing this scan and
	* then restarting it. If there haven't been any errors
	* then remember that the incore DTL is valid.
	*/
	if (scn->scn_phys.scn_errors > 0) {
	scn->scn_restart_txg = txg;
	zfs_dbgmsg("resilver can't excise DTL_MISSING "
	"when finished; restarting in txg %llu",
	(u_longlong_t)scn->scn_restart_txg);
	} else {
	/* it's safe to excise DTL when finished */
	spa->spa_scrub_started = B_TRUE;
	}
	}
	}

	bcopy(&scn->scn_phys, &scn->scn_phys_cached, sizeof (scn->scn_phys));

	/* reload the queue into the in-core state */
	if (scn->scn_phys.scn_queue_obj != 0) {
	zap_cursor_t zc;
	zap_attribute_t za;

	for (zap_cursor_init(&zc, dp->dp_meta_objset,
	scn->scn_phys.scn_queue_obj);
	zap_cursor_retrieve(&zc, &za) == 0;
	(void) zap_cursor_advance(&zc)) {
	scan_ds_queue_insert(scn,
	zfs_strtonum(za.za_name, NULL),
	za.za_first_integer);
	}
	zap_cursor_fini(&zc);
	}

	spa_scan_stat_init(spa);
	return (0);
	}

	void
	dsl_scan_fini(dsl_pool_t *dp)
	{
	if (dp->dp_scan != NULL) {
	dsl_scan_t *scn = dp->dp_scan;

	if (scn->scn_taskq != NULL)
	taskq_destroy(scn->scn_taskq);

	scan_ds_queue_clear(scn);
	avl_destroy(&scn->scn_queue);
	scan_ds_prefetch_queue_clear(scn);
	avl_destroy(&scn->scn_prefetch_queue);

	kmem_free(dp->dp_scan, sizeof (dsl_scan_t));
	dp->dp_scan = NULL;
	}
	}

	static boolean_t
	dsl_scan_restarting(dsl_scan_t scn, dmu_tx_t tx)
	{
	return (scn->scn_restart_txg != 0 &&
	scn->scn_restart_txg <= tx->tx_txg);
	}

	boolean_t
	dsl_scan_resilver_scheduled(dsl_pool_t *dp)
	{
	return ((dp->dp_scan && dp->dp_scan->scn_restart_txg != 0) \|\|
	(spa_async_tasks(dp->dp_spa) & SPA_ASYNC_RESILVER));
	}

	boolean_t
	dsl_scan_scrubbing(const dsl_pool_t *dp)
	{
	dsl_scan_phys_t *scn_phys = &dp->dp_scan->scn_phys;

	return (scn_phys->scn_state == DSS_SCANNING &&
	scn_phys->scn_func == POOL_SCAN_SCRUB);
	}

	boolean_t
	dsl_scan_is_paused_scrub(const dsl_scan_t *scn)
	{
	return (dsl_scan_scrubbing(scn->scn_dp) &&
	scn->scn_phys.scn_flags & DSF_SCRUB_PAUSED);
	}

	/*
	* Writes out a persistent dsl_scan_phys_t record to the pool directory.
	* Because we can be running in the block sorting algorithm, we do not always
	* want to write out the record, only when it is "safe" to do so. This safety
	* condition is achieved by making sure that the sorting queues are empty
	* (scn_bytes_pending == 0). When this condition is not true, the sync'd state
	* is inconsistent with how much actual scanning progress has been made. The
	* kind of sync to be performed is specified by the sync_type argument. If the
	* sync is optional, we only sync if the queues are empty. If the sync is
	* mandatory, we do a hard ASSERT to make sure that the queues are empty. The
	* third possible state is a "cached" sync. This is done in response to:
	* 1) The dataset that was in the last sync'd dsl_scan_phys_t having been
	* destroyed, so we wouldn't be able to restart scanning from it.
	* 2) The snapshot that was in the last sync'd dsl_scan_phys_t having been
	* superseded by a newer snapshot.
	* 3) The dataset that was in the last sync'd dsl_scan_phys_t having been
	* swapped with its clone.
	* In all cases, a cached sync simply rewrites the last record we've written,
	* just slightly modified. For the modifications that are performed to the
	* last written dsl_scan_phys_t, see dsl_scan_ds_destroyed,
	* dsl_scan_ds_snapshotted and dsl_scan_ds_clone_swapped.
	*/
	static void
	dsl_scan_sync_state(dsl_scan_t scn, dmu_tx_t tx, state_sync_type_t sync_type)
	{
	int i;
	spa_t *spa = scn->scn_dp->dp_spa;

	ASSERT(sync_type != SYNC_MANDATORY \|\| scn->scn_bytes_pending == 0);
	if (scn->scn_bytes_pending == 0) {
	for (i = 0; i < spa->spa_root_vdev->vdev_children; i++) {
	vdev_t *vd = spa->spa_root_vdev->vdev_child[i];
	dsl_scan_io_queue_t *q = vd->vdev_scan_io_queue;

	if (q == NULL)
	continue;

	mutex_enter(&vd->vdev_scan_io_queue_lock);
	ASSERT3P(avl_first(&q->q_sios_by_addr), ==, NULL);
	ASSERT3P(zfs_btree_first(&q->q_exts_by_size, NULL), ==,
	NULL);
	ASSERT3P(range_tree_first(q->q_exts_by_addr), ==, NULL);
	mutex_exit(&vd->vdev_scan_io_queue_lock);
	}

	if (scn->scn_phys.scn_queue_obj != 0)
	scan_ds_queue_sync(scn, tx);
	VERIFY0(zap_update(scn->scn_dp->dp_meta_objset,
	DMU_POOL_DIRECTORY_OBJECT,
	DMU_POOL_SCAN, sizeof (uint64_t), SCAN_PHYS_NUMINTS,
	&scn->scn_phys, tx));
	bcopy(&scn->scn_phys, &scn->scn_phys_cached,
	sizeof (scn->scn_phys));

	if (scn->scn_checkpointing)
	zfs_dbgmsg("finish scan checkpoint");

	scn->scn_checkpointing = B_FALSE;
	scn->scn_last_checkpoint = ddi_get_lbolt();
	} else if (sync_type == SYNC_CACHED) {
	VERIFY0(zap_update(scn->scn_dp->dp_meta_objset,
	DMU_POOL_DIRECTORY_OBJECT,
	DMU_POOL_SCAN, sizeof (uint64_t), SCAN_PHYS_NUMINTS,
	&scn->scn_phys_cached, tx));
	}
	}

	/* ARGSUSED */
	-static int
	+int
	dsl_scan_setup_check(void arg, dmu_tx_t tx)
	{
	dsl_scan_t *scn = dmu_tx_pool(tx)->dp_scan;
	vdev_t *rvd = scn->scn_dp->dp_spa->spa_root_vdev;

	if (dsl_scan_is_running(scn) \|\| vdev_rebuild_active(rvd))
	return (SET_ERROR(EBUSY));

	return (0);
	}

	void
	dsl_scan_setup_sync(void arg, dmu_tx_t tx)
	{
	dsl_scan_t *scn = dmu_tx_pool(tx)->dp_scan;
	pool_scan_func_t *funcp = arg;
	dmu_object_type_t ot = 0;
	dsl_pool_t *dp = scn->scn_dp;
	spa_t *spa = dp->dp_spa;

	ASSERT(!dsl_scan_is_running(scn));
	ASSERT(funcp > POOL_SCAN_NONE && funcp < POOL_SCAN_FUNCS);
	bzero(&scn->scn_phys, sizeof (scn->scn_phys));
	scn->scn_phys.scn_func = *funcp;
	scn->scn_phys.scn_state = DSS_SCANNING;
	scn->scn_phys.scn_min_txg = 0;
	scn->scn_phys.scn_max_txg = tx->tx_txg;
	scn->scn_phys.scn_ddt_class_max = DDT_CLASSES - 1; /* the entire DDT */
	scn->scn_phys.scn_start_time = gethrestime_sec();
	scn->scn_phys.scn_errors = 0;
	scn->scn_phys.scn_to_examine = spa->spa_root_vdev->vdev_stat.vs_alloc;
	scn->scn_issued_before_pass = 0;
	scn->scn_restart_txg = 0;
	scn->scn_done_txg = 0;
	scn->scn_last_checkpoint = 0;
	scn->scn_checkpointing = B_FALSE;
	spa_scan_stat_init(spa);

	if (DSL_SCAN_IS_SCRUB_RESILVER(scn)) {
	scn->scn_phys.scn_ddt_class_max = zfs_scrub_ddt_class_max;

	/* rewrite all disk labels */
	vdev_config_dirty(spa->spa_root_vdev);

	if (vdev_resilver_needed(spa->spa_root_vdev,
	&scn->scn_phys.scn_min_txg, &scn->scn_phys.scn_max_txg)) {
	nvlist_t *aux = fnvlist_alloc();
	fnvlist_add_string(aux, ZFS_EV_RESILVER_TYPE,
	"healing");
	spa_event_notify(spa, NULL, aux,
	ESC_ZFS_RESILVER_START);
	nvlist_free(aux);
	} else {
	spa_event_notify(spa, NULL, NULL, ESC_ZFS_SCRUB_START);
	}

	spa->spa_scrub_started = B_TRUE;
	/*
	* If this is an incremental scrub, limit the DDT scrub phase
	* to just the auto-ditto class (for correctness); the rest
	* of the scrub should go faster using top-down pruning.
	*/
	if (scn->scn_phys.scn_min_txg > TXG_INITIAL)
	scn->scn_phys.scn_ddt_class_max = DDT_CLASS_DITTO;

	/*
	* When starting a resilver clear any existing rebuild state.
	* This is required to prevent stale rebuild status from
	* being reported when a rebuild is run, then a resilver and
	* finally a scrub. In which case only the scrub status
	* should be reported by 'zpool status'.
	*/
	if (scn->scn_phys.scn_func == POOL_SCAN_RESILVER) {
	vdev_t *rvd = spa->spa_root_vdev;
	for (uint64_t i = 0; i < rvd->vdev_children; i++) {
	vdev_t *vd = rvd->vdev_child[i];
	vdev_rebuild_clear_sync(
	(void *)(uintptr_t)vd->vdev_id, tx);
	}
	}
	}

	/* back to the generic stuff */

	if (dp->dp_blkstats == NULL) {
	dp->dp_blkstats =
	vmem_alloc(sizeof (zfs_all_blkstats_t), KM_SLEEP);
	mutex_init(&dp->dp_blkstats->zab_lock, NULL,
	MUTEX_DEFAULT, NULL);
	}
	bzero(&dp->dp_blkstats->zab_type, sizeof (dp->dp_blkstats->zab_type));

	if (spa_version(spa) < SPA_VERSION_DSL_SCRUB)
	ot = DMU_OT_ZAP_OTHER;

	scn->scn_phys.scn_queue_obj = zap_create(dp->dp_meta_objset,
	ot ? ot : DMU_OT_SCAN_QUEUE, DMU_OT_NONE, 0, tx);

	bcopy(&scn->scn_phys, &scn->scn_phys_cached, sizeof (scn->scn_phys));

	dsl_scan_sync_state(scn, tx, SYNC_MANDATORY);

	spa_history_log_internal(spa, "scan setup", tx,
	"func=%u mintxg=%llu maxtxg=%llu",
	*funcp, (u_longlong_t)scn->scn_phys.scn_min_txg,
	(u_longlong_t)scn->scn_phys.scn_max_txg);
	}

	/*
	* Called by the ZFS_IOC_POOL_SCAN ioctl to start a scrub or resilver.
	* Can also be called to resume a paused scrub.
	*/
	int
	dsl_scan(dsl_pool_t *dp, pool_scan_func_t func)
	{
	spa_t *spa = dp->dp_spa;
	dsl_scan_t *scn = dp->dp_scan;

	/*
	* Purge all vdev caches and probe all devices. We do this here
	* rather than in sync context because this requires a writer lock
	* on the spa_config lock, which we can't do from sync context. The
	* spa_scrub_reopen flag indicates that vdev_open() should not
	* attempt to start another scrub.
	*/
	spa_vdev_state_enter(spa, SCL_NONE);
	spa->spa_scrub_reopen = B_TRUE;
	vdev_reopen(spa->spa_root_vdev);
	spa->spa_scrub_reopen = B_FALSE;
	(void) spa_vdev_state_exit(spa, NULL, 0);

	if (func == POOL_SCAN_RESILVER) {
	dsl_scan_restart_resilver(spa->spa_dsl_pool, 0);
	return (0);
	}

	if (func == POOL_SCAN_SCRUB && dsl_scan_is_paused_scrub(scn)) {
	/* got scrub start cmd, resume paused scrub */
	int err = dsl_scrub_set_pause_resume(scn->scn_dp,
	POOL_SCRUB_NORMAL);
	if (err == 0) {
	spa_event_notify(spa, NULL, NULL, ESC_ZFS_SCRUB_RESUME);
	return (SET_ERROR(ECANCELED));
	}

	return (SET_ERROR(err));
	}

	return (dsl_sync_task(spa_name(spa), dsl_scan_setup_check,
	dsl_scan_setup_sync, &func, 0, ZFS_SPACE_CHECK_EXTRA_RESERVED));
	}

	/* ARGSUSED */
	static void
	dsl_scan_done(dsl_scan_t scn, boolean_t complete, dmu_tx_t tx)
	{
	static const char *old_names[] = {
	"scrub_bookmark",
	"scrub_ddt_bookmark",
	"scrub_ddt_class_max",
	"scrub_queue",
	"scrub_min_txg",
	"scrub_max_txg",
	"scrub_func",
	"scrub_errors",
	NULL
	};

	dsl_pool_t *dp = scn->scn_dp;
	spa_t *spa = dp->dp_spa;
	int i;

	/* Remove any remnants of an old-style scrub. */
	for (i = 0; old_names[i]; i++) {
	(void) zap_remove(dp->dp_meta_objset,
	DMU_POOL_DIRECTORY_OBJECT, old_names[i], tx);
	}

	if (scn->scn_phys.scn_queue_obj != 0) {
	VERIFY0(dmu_object_free(dp->dp_meta_objset,
	scn->scn_phys.scn_queue_obj, tx));
	scn->scn_phys.scn_queue_obj = 0;
	}
	scan_ds_queue_clear(scn);
	scan_ds_prefetch_queue_clear(scn);

	scn->scn_phys.scn_flags &= ~DSF_SCRUB_PAUSED;

	/*
	* If we were "restarted" from a stopped state, don't bother
	* with anything else.
	*/
	if (!dsl_scan_is_running(scn)) {
	ASSERT(!scn->scn_is_sorted);
	return;
	}

	if (scn->scn_is_sorted) {
	scan_io_queues_destroy(scn);
	scn->scn_is_sorted = B_FALSE;

	if (scn->scn_taskq != NULL) {
	taskq_destroy(scn->scn_taskq);
	scn->scn_taskq = NULL;
	}
	}

	scn->scn_phys.scn_state = complete ? DSS_FINISHED : DSS_CANCELED;

	spa_notify_waiters(spa);

	if (dsl_scan_restarting(scn, tx))
	spa_history_log_internal(spa, "scan aborted, restarting", tx,
	"errors=%llu", (u_longlong_t)spa_get_errlog_size(spa));
	else if (!complete)
	spa_history_log_internal(spa, "scan cancelled", tx,
	"errors=%llu", (u_longlong_t)spa_get_errlog_size(spa));
	else
	spa_history_log_internal(spa, "scan done", tx,
	"errors=%llu", (u_longlong_t)spa_get_errlog_size(spa));

	if (DSL_SCAN_IS_SCRUB_RESILVER(scn)) {
	spa->spa_scrub_active = B_FALSE;

	/*
	* If the scrub/resilver completed, update all DTLs to
	* reflect this. Whether it succeeded or not, vacate
	* all temporary scrub DTLs.
	*
	* As the scrub does not currently support traversing
	* data that have been freed but are part of a checkpoint,
	* we don't mark the scrub as done in the DTLs as faults
	* may still exist in those vdevs.
	*/
	if (complete &&
	!spa_feature_is_active(spa, SPA_FEATURE_POOL_CHECKPOINT)) {
	vdev_dtl_reassess(spa->spa_root_vdev, tx->tx_txg,
	scn->scn_phys.scn_max_txg, B_TRUE, B_FALSE);

	if (scn->scn_phys.scn_min_txg) {
	nvlist_t *aux = fnvlist_alloc();
	fnvlist_add_string(aux, ZFS_EV_RESILVER_TYPE,
	"healing");
	spa_event_notify(spa, NULL, aux,
	ESC_ZFS_RESILVER_FINISH);
	nvlist_free(aux);
	} else {
	spa_event_notify(spa, NULL, NULL,
	ESC_ZFS_SCRUB_FINISH);
	}
	} else {
	vdev_dtl_reassess(spa->spa_root_vdev, tx->tx_txg,
	0, B_TRUE, B_FALSE);
	}
	spa_errlog_rotate(spa);

	/*
	* Don't clear flag until after vdev_dtl_reassess to ensure that
	* DTL_MISSING will get updated when possible.
	*/
	spa->spa_scrub_started = B_FALSE;

	/*
	* We may have finished replacing a device.
	* Let the async thread assess this and handle the detach.
	*/
	spa_async_request(spa, SPA_ASYNC_RESILVER_DONE);

	/*
	* Clear any resilver_deferred flags in the config.
	* If there are drives that need resilvering, kick
	* off an asynchronous request to start resilver.
	* vdev_clear_resilver_deferred() may update the config
	* before the resilver can restart. In the event of
	* a crash during this period, the spa loading code
	* will find the drives that need to be resilvered
	* and start the resilver then.
	*/
	if (spa_feature_is_enabled(spa, SPA_FEATURE_RESILVER_DEFER) &&
	vdev_clear_resilver_deferred(spa->spa_root_vdev, tx)) {
	spa_history_log_internal(spa,
	"starting deferred resilver", tx, "errors=%llu",
	(u_longlong_t)spa_get_errlog_size(spa));
	spa_async_request(spa, SPA_ASYNC_RESILVER);
	}

	/* Clear recent error events (i.e. duplicate events tracking) */
	if (complete)
	zfs_ereport_clear(spa, NULL);
	}

	scn->scn_phys.scn_end_time = gethrestime_sec();

	if (spa->spa_errata == ZPOOL_ERRATA_ZOL_2094_SCRUB)
	spa->spa_errata = 0;

	ASSERT(!dsl_scan_is_running(scn));
	}

	/* ARGSUSED */
	static int
	dsl_scan_cancel_check(void arg, dmu_tx_t tx)
	{
	dsl_scan_t *scn = dmu_tx_pool(tx)->dp_scan;

	if (!dsl_scan_is_running(scn))
	return (SET_ERROR(ENOENT));
	return (0);
	}

	/* ARGSUSED */
	static void
	dsl_scan_cancel_sync(void arg, dmu_tx_t tx)
	{
	dsl_scan_t *scn = dmu_tx_pool(tx)->dp_scan;

	dsl_scan_done(scn, B_FALSE, tx);
	dsl_scan_sync_state(scn, tx, SYNC_MANDATORY);
	spa_event_notify(scn->scn_dp->dp_spa, NULL, NULL, ESC_ZFS_SCRUB_ABORT);
	}

	int
	dsl_scan_cancel(dsl_pool_t *dp)
	{
	return (dsl_sync_task(spa_name(dp->dp_spa), dsl_scan_cancel_check,
	dsl_scan_cancel_sync, NULL, 3, ZFS_SPACE_CHECK_RESERVED));
	}

	static int
	dsl_scrub_pause_resume_check(void arg, dmu_tx_t tx)
	{
	pool_scrub_cmd_t *cmd = arg;
	dsl_pool_t *dp = dmu_tx_pool(tx);
	dsl_scan_t *scn = dp->dp_scan;

	if (*cmd == POOL_SCRUB_PAUSE) {
	/* can't pause a scrub when there is no in-progress scrub */
	if (!dsl_scan_scrubbing(dp))
	return (SET_ERROR(ENOENT));

	/* can't pause a paused scrub */
	if (dsl_scan_is_paused_scrub(scn))
	return (SET_ERROR(EBUSY));
	} else if (*cmd != POOL_SCRUB_NORMAL) {
	return (SET_ERROR(ENOTSUP));
	}

	return (0);
	}

	static void
	dsl_scrub_pause_resume_sync(void arg, dmu_tx_t tx)
	{
	pool_scrub_cmd_t *cmd = arg;
	dsl_pool_t *dp = dmu_tx_pool(tx);
	spa_t *spa = dp->dp_spa;
	dsl_scan_t *scn = dp->dp_scan;

	if (*cmd == POOL_SCRUB_PAUSE) {
	/* can't pause a scrub when there is no in-progress scrub */
	spa->spa_scan_pass_scrub_pause = gethrestime_sec();
	scn->scn_phys.scn_flags \|= DSF_SCRUB_PAUSED;
	scn->scn_phys_cached.scn_flags \|= DSF_SCRUB_PAUSED;
	dsl_scan_sync_state(scn, tx, SYNC_CACHED);
	spa_event_notify(spa, NULL, NULL, ESC_ZFS_SCRUB_PAUSED);
	spa_notify_waiters(spa);
	} else {
	ASSERT3U(*cmd, ==, POOL_SCRUB_NORMAL);
	if (dsl_scan_is_paused_scrub(scn)) {
	/*
	* We need to keep track of how much time we spend
	* paused per pass so that we can adjust the scrub rate
	* shown in the output of 'zpool status'
	*/
	spa->spa_scan_pass_scrub_spent_paused +=
	gethrestime_sec() - spa->spa_scan_pass_scrub_pause;
	spa->spa_scan_pass_scrub_pause = 0;
	scn->scn_phys.scn_flags &= ~DSF_SCRUB_PAUSED;
	scn->scn_phys_cached.scn_flags &= ~DSF_SCRUB_PAUSED;
	dsl_scan_sync_state(scn, tx, SYNC_CACHED);
	}
	}
	}

	/*
	* Set scrub pause/resume state if it makes sense to do so
	*/
	int
	dsl_scrub_set_pause_resume(const dsl_pool_t *dp, pool_scrub_cmd_t cmd)
	{
	return (dsl_sync_task(spa_name(dp->dp_spa),
	dsl_scrub_pause_resume_check, dsl_scrub_pause_resume_sync, &cmd, 3,
	ZFS_SPACE_CHECK_RESERVED));
	}


	/* start a new scan, or restart an existing one. */
	void
	dsl_scan_restart_resilver(dsl_pool_t *dp, uint64_t txg)
	{
	if (txg == 0) {
	dmu_tx_t *tx;
	tx = dmu_tx_create_dd(dp->dp_mos_dir);
	VERIFY(0 == dmu_tx_assign(tx, TXG_WAIT));

	txg = dmu_tx_get_txg(tx);
	dp->dp_scan->scn_restart_txg = txg;
	dmu_tx_commit(tx);
	} else {
	dp->dp_scan->scn_restart_txg = txg;
	}
	zfs_dbgmsg("restarting resilver txg=%llu", (longlong_t)txg);
	}

	void
	dsl_free(dsl_pool_t dp, uint64_t txg, const blkptr_t bp)
	{
	zio_free(dp->dp_spa, txg, bp);
	}

	void
	dsl_free_sync(zio_t pio, dsl_pool_t dp, uint64_t txg, const blkptr_t *bpp)
	{
	ASSERT(dsl_pool_sync_context(dp));
	zio_nowait(zio_free_sync(pio, dp->dp_spa, txg, bpp, pio->io_flags));
	}

	static int
	scan_ds_queue_compare(const void a, const void b)
	{
	const scan_ds_t sds_a = a, sds_b = b;

	if (sds_a->sds_dsobj < sds_b->sds_dsobj)
	return (-1);
	if (sds_a->sds_dsobj == sds_b->sds_dsobj)
	return (0);
	return (1);
	}

	static void
	scan_ds_queue_clear(dsl_scan_t *scn)
	{
	void *cookie = NULL;
	scan_ds_t *sds;
	while ((sds = avl_destroy_nodes(&scn->scn_queue, &cookie)) != NULL) {
	kmem_free(sds, sizeof (*sds));
	}
	}

	static boolean_t
	scan_ds_queue_contains(dsl_scan_t scn, uint64_t dsobj, uint64_t txg)
	{
	scan_ds_t srch, *sds;

	srch.sds_dsobj = dsobj;
	sds = avl_find(&scn->scn_queue, &srch, NULL);
	if (sds != NULL && txg != NULL)
	*txg = sds->sds_txg;
	return (sds != NULL);
	}

	static void
	scan_ds_queue_insert(dsl_scan_t *scn, uint64_t dsobj, uint64_t txg)
	{
	scan_ds_t *sds;
	avl_index_t where;

	sds = kmem_zalloc(sizeof (*sds), KM_SLEEP);
	sds->sds_dsobj = dsobj;
	sds->sds_txg = txg;

	VERIFY3P(avl_find(&scn->scn_queue, sds, &where), ==, NULL);
	avl_insert(&scn->scn_queue, sds, where);
	}

	static void
	scan_ds_queue_remove(dsl_scan_t *scn, uint64_t dsobj)
	{
	scan_ds_t srch, *sds;

	srch.sds_dsobj = dsobj;

	sds = avl_find(&scn->scn_queue, &srch, NULL);
	VERIFY(sds != NULL);
	avl_remove(&scn->scn_queue, sds);
	kmem_free(sds, sizeof (*sds));
	}

	static void
	scan_ds_queue_sync(dsl_scan_t scn, dmu_tx_t tx)
	{
	dsl_pool_t *dp = scn->scn_dp;
	spa_t *spa = dp->dp_spa;
	dmu_object_type_t ot = (spa_version(spa) >= SPA_VERSION_DSL_SCRUB) ?
	DMU_OT_SCAN_QUEUE : DMU_OT_ZAP_OTHER;

	ASSERT0(scn->scn_bytes_pending);
	ASSERT(scn->scn_phys.scn_queue_obj != 0);

	VERIFY0(dmu_object_free(dp->dp_meta_objset,
	scn->scn_phys.scn_queue_obj, tx));
	scn->scn_phys.scn_queue_obj = zap_create(dp->dp_meta_objset, ot,
	DMU_OT_NONE, 0, tx);
	for (scan_ds_t *sds = avl_first(&scn->scn_queue);
	sds != NULL; sds = AVL_NEXT(&scn->scn_queue, sds)) {
	VERIFY0(zap_add_int_key(dp->dp_meta_objset,
	scn->scn_phys.scn_queue_obj, sds->sds_dsobj,
	sds->sds_txg, tx));
	}
	}

	/*
	* Computes the memory limit state that we're currently in. A sorted scan
	* needs quite a bit of memory to hold the sorting queue, so we need to
	* reasonably constrain the size so it doesn't impact overall system
	* performance. We compute two limits:
	* 1) Hard memory limit: if the amount of memory used by the sorting
	* queues on a pool gets above this value, we stop the metadata
	* scanning portion and start issuing the queued up and sorted
	* I/Os to reduce memory usage.
	* This limit is calculated as a fraction of physmem (by default 5%).
	* We constrain the lower bound of the hard limit to an absolute
	* minimum of zfs_scan_mem_lim_min (default: 16 MiB). We also constrain
	* the upper bound to 5% of the total pool size - no chance we'll
	* ever need that much memory, but just to keep the value in check.
	* 2) Soft memory limit: once we hit the hard memory limit, we start
	* issuing I/O to reduce queue memory usage, but we don't want to
	* completely empty out the queues, since we might be able to find I/Os
	* that will fill in the gaps of our non-sequential IOs at some point
	* in the future. So we stop the issuing of I/Os once the amount of
	* memory used drops below the soft limit (at which point we stop issuing
	* I/O and start scanning metadata again).
	*
	* This limit is calculated by subtracting a fraction of the hard
	* limit from the hard limit. By default this fraction is 5%, so
	* the soft limit is 95% of the hard limit. We cap the size of the
	* difference between the hard and soft limits at an absolute
	* maximum of zfs_scan_mem_lim_soft_max (default: 128 MiB) - this is
	* sufficient to not cause too frequent switching between the
	* metadata scan and I/O issue (even at 2k recordsize, 128 MiB's
	* worth of queues is about 1.2 GiB of on-pool data, so scanning
	* that should take at least a decent fraction of a second).
	*/
	static boolean_t
	dsl_scan_should_clear(dsl_scan_t *scn)
	{
	spa_t *spa = scn->scn_dp->dp_spa;
	vdev_t *rvd = scn->scn_dp->dp_spa->spa_root_vdev;
	uint64_t alloc, mlim_hard, mlim_soft, mused;

	alloc = metaslab_class_get_alloc(spa_normal_class(spa));
	alloc += metaslab_class_get_alloc(spa_special_class(spa));
	alloc += metaslab_class_get_alloc(spa_dedup_class(spa));

	mlim_hard = MAX((physmem / zfs_scan_mem_lim_fact) * PAGESIZE,
	zfs_scan_mem_lim_min);
	mlim_hard = MIN(mlim_hard, alloc / 20);
	mlim_soft = mlim_hard - MIN(mlim_hard / zfs_scan_mem_lim_soft_fact,
	zfs_scan_mem_lim_soft_max);
	mused = 0;
	for (uint64_t i = 0; i < rvd->vdev_children; i++) {
	vdev_t *tvd = rvd->vdev_child[i];
	dsl_scan_io_queue_t *queue;

	mutex_enter(&tvd->vdev_scan_io_queue_lock);
	queue = tvd->vdev_scan_io_queue;
	if (queue != NULL) {
	/* # extents in exts_by_size = # in exts_by_addr */
	mused += zfs_btree_numnodes(&queue->q_exts_by_size) *
	sizeof (range_seg_gap_t) + queue->q_sio_memused;
	}
	mutex_exit(&tvd->vdev_scan_io_queue_lock);
	}

	dprintf("current scan memory usage: %llu bytes\n", (longlong_t)mused);

	if (mused == 0)
	ASSERT0(scn->scn_bytes_pending);

	/*
	* If we are above our hard limit, we need to clear out memory.
	* If we are below our soft limit, we need to accumulate sequential IOs.
	* Otherwise, we should keep doing whatever we are currently doing.
	*/
	if (mused >= mlim_hard)
	return (B_TRUE);
	else if (mused < mlim_soft)
	return (B_FALSE);
	else
	return (scn->scn_clearing);
	}

	static boolean_t
	dsl_scan_check_suspend(dsl_scan_t scn, const zbookmark_phys_t zb)
	{
	/* we never skip user/group accounting objects */
	if (zb && (int64_t)zb->zb_object < 0)
	return (B_FALSE);

	if (scn->scn_suspending)
	return (B_TRUE); /* we're already suspending */

	if (!ZB_IS_ZERO(&scn->scn_phys.scn_bookmark))
	return (B_FALSE); /* we're resuming */

	/* We only know how to resume from level-0 and objset blocks. */
	if (zb && (zb->zb_level != 0 && zb->zb_level != ZB_ROOT_LEVEL))
	return (B_FALSE);

	/*
	* We suspend if:
	* - we have scanned for at least the minimum time (default 1 sec
	* for scrub, 3 sec for resilver), and either we have sufficient
	* dirty data that we are starting to write more quickly
	* (default 30%), someone is explicitly waiting for this txg
	* to complete, or we have used up all of the time in the txg
	* timeout (default 5 sec).
	* or
	* - the spa is shutting down because this pool is being exported
	* or the machine is rebooting.
	* or
	* - the scan queue has reached its memory use limit
	*/
	uint64_t curr_time_ns = gethrtime();
	uint64_t scan_time_ns = curr_time_ns - scn->scn_sync_start_time;
	uint64_t sync_time_ns = curr_time_ns -
	scn->scn_dp->dp_spa->spa_sync_starttime;
	int dirty_pct = scn->scn_dp->dp_dirty_total * 100 / zfs_dirty_data_max;
	int mintime = (scn->scn_phys.scn_func == POOL_SCAN_RESILVER) ?
	zfs_resilver_min_time_ms : zfs_scrub_min_time_ms;

	if ((NSEC2MSEC(scan_time_ns) > mintime &&
	(dirty_pct >= zfs_vdev_async_write_active_min_dirty_percent \|\|
	txg_sync_waiting(scn->scn_dp) \|\|
	NSEC2SEC(sync_time_ns) >= zfs_txg_timeout)) \|\|
	spa_shutting_down(scn->scn_dp->dp_spa) \|\|
	(zfs_scan_strict_mem_lim && dsl_scan_should_clear(scn))) {
	if (zb && zb->zb_level == ZB_ROOT_LEVEL) {
	dprintf("suspending at first available bookmark "
	"%llx/%llx/%llx/%llx\n",
	(longlong_t)zb->zb_objset,
	(longlong_t)zb->zb_object,
	(longlong_t)zb->zb_level,
	(longlong_t)zb->zb_blkid);
	SET_BOOKMARK(&scn->scn_phys.scn_bookmark,
	zb->zb_objset, 0, 0, 0);
	} else if (zb != NULL) {
	dprintf("suspending at bookmark %llx/%llx/%llx/%llx\n",
	(longlong_t)zb->zb_objset,
	(longlong_t)zb->zb_object,
	(longlong_t)zb->zb_level,
	(longlong_t)zb->zb_blkid);
	scn->scn_phys.scn_bookmark = *zb;
	} else {
	#ifdef ZFS_DEBUG
	dsl_scan_phys_t *scnp = &scn->scn_phys;
	dprintf("suspending at at DDT bookmark "
	"%llx/%llx/%llx/%llx\n",
	(longlong_t)scnp->scn_ddt_bookmark.ddb_class,
	(longlong_t)scnp->scn_ddt_bookmark.ddb_type,
	(longlong_t)scnp->scn_ddt_bookmark.ddb_checksum,
	(longlong_t)scnp->scn_ddt_bookmark.ddb_cursor);
	#endif
	}
	scn->scn_suspending = B_TRUE;
	return (B_TRUE);
	}
	return (B_FALSE);
	}

	typedef struct zil_scan_arg {
	dsl_pool_t *zsa_dp;
	zil_header_t *zsa_zh;
	} zil_scan_arg_t;

	/* ARGSUSED */
	static int
	dsl_scan_zil_block(zilog_t zilog, const blkptr_t bp, void *arg,
	uint64_t claim_txg)
	{
	zil_scan_arg_t *zsa = arg;
	dsl_pool_t *dp = zsa->zsa_dp;
	dsl_scan_t *scn = dp->dp_scan;
	zil_header_t *zh = zsa->zsa_zh;
	zbookmark_phys_t zb;

	ASSERT(!BP_IS_REDACTED(bp));
	if (BP_IS_HOLE(bp) \|\| bp->blk_birth <= scn->scn_phys.scn_cur_min_txg)
	return (0);

	/*
	* One block ("stubby") can be allocated a long time ago; we
	* want to visit that one because it has been allocated
	* (on-disk) even if it hasn't been claimed (even though for
	* scrub there's nothing to do to it).
	*/
	if (claim_txg == 0 && bp->blk_birth >= spa_min_claim_txg(dp->dp_spa))
	return (0);

	SET_BOOKMARK(&zb, zh->zh_log.blk_cksum.zc_word[ZIL_ZC_OBJSET],
	ZB_ZIL_OBJECT, ZB_ZIL_LEVEL, bp->blk_cksum.zc_word[ZIL_ZC_SEQ]);

	VERIFY(0 == scan_funcs[scn->scn_phys.scn_func](dp, bp, &zb));
	return (0);
	}

	/* ARGSUSED */
	static int
	dsl_scan_zil_record(zilog_t zilog, const lr_t lrc, void *arg,
	uint64_t claim_txg)
	{
	if (lrc->lrc_txtype == TX_WRITE) {
	zil_scan_arg_t *zsa = arg;
	dsl_pool_t *dp = zsa->zsa_dp;
	dsl_scan_t *scn = dp->dp_scan;
	zil_header_t *zh = zsa->zsa_zh;
	const lr_write_t lr = (const lr_write_t )lrc;
	const blkptr_t *bp = &lr->lr_blkptr;
	zbookmark_phys_t zb;

	ASSERT(!BP_IS_REDACTED(bp));
	if (BP_IS_HOLE(bp) \|\|
	bp->blk_birth <= scn->scn_phys.scn_cur_min_txg)
	return (0);

	/*
	* birth can be < claim_txg if this record's txg is
	* already txg sync'ed (but this log block contains
	* other records that are not synced)
	*/
	if (claim_txg == 0 \|\| bp->blk_birth < claim_txg)
	return (0);

	SET_BOOKMARK(&zb, zh->zh_log.blk_cksum.zc_word[ZIL_ZC_OBJSET],
	lr->lr_foid, ZB_ZIL_LEVEL,
	lr->lr_offset / BP_GET_LSIZE(bp));

	VERIFY(0 == scan_funcs[scn->scn_phys.scn_func](dp, bp, &zb));
	}
	return (0);
	}

	static void
	dsl_scan_zil(dsl_pool_t dp, zil_header_t zh)
	{
	uint64_t claim_txg = zh->zh_claim_txg;
	zil_scan_arg_t zsa = { dp, zh };
	zilog_t *zilog;

	ASSERT(spa_writeable(dp->dp_spa));

	/*
	* We only want to visit blocks that have been claimed but not yet
	* replayed (or, in read-only mode, blocks that would be claimed).
	*/
	if (claim_txg == 0)
	return;

	zilog = zil_alloc(dp->dp_meta_objset, zh);

	(void) zil_parse(zilog, dsl_scan_zil_block, dsl_scan_zil_record, &zsa,
	claim_txg, B_FALSE);

	zil_free(zilog);
	}

	/*
	* We compare scan_prefetch_issue_ctx_t's based on their bookmarks. The idea
	* here is to sort the AVL tree by the order each block will be needed.
	*/
	static int
	scan_prefetch_queue_compare(const void a, const void b)
	{
	const scan_prefetch_issue_ctx_t spic_a = a, spic_b = b;
	const scan_prefetch_ctx_t *spc_a = spic_a->spic_spc;
	const scan_prefetch_ctx_t *spc_b = spic_b->spic_spc;

	return (zbookmark_compare(spc_a->spc_datablkszsec,
	spc_a->spc_indblkshift, spc_b->spc_datablkszsec,
	spc_b->spc_indblkshift, &spic_a->spic_zb, &spic_b->spic_zb));
	}

	static void
	scan_prefetch_ctx_rele(scan_prefetch_ctx_t spc, void tag)
	{
	if (zfs_refcount_remove(&spc->spc_refcnt, tag) == 0) {
	zfs_refcount_destroy(&spc->spc_refcnt);
	kmem_free(spc, sizeof (scan_prefetch_ctx_t));
	}
	}

	static scan_prefetch_ctx_t *
	scan_prefetch_ctx_create(dsl_scan_t scn, dnode_phys_t dnp, void *tag)
	{
	scan_prefetch_ctx_t *spc;

	spc = kmem_alloc(sizeof (scan_prefetch_ctx_t), KM_SLEEP);
	zfs_refcount_create(&spc->spc_refcnt);
	zfs_refcount_add(&spc->spc_refcnt, tag);
	spc->spc_scn = scn;
	if (dnp != NULL) {
	spc->spc_datablkszsec = dnp->dn_datablkszsec;
	spc->spc_indblkshift = dnp->dn_indblkshift;
	spc->spc_root = B_FALSE;
	} else {
	spc->spc_datablkszsec = 0;
	spc->spc_indblkshift = 0;
	spc->spc_root = B_TRUE;
	}

	return (spc);
	}

	static void
	scan_prefetch_ctx_add_ref(scan_prefetch_ctx_t spc, void tag)
	{
	zfs_refcount_add(&spc->spc_refcnt, tag);
	}

	static void
	scan_ds_prefetch_queue_clear(dsl_scan_t *scn)
	{
	spa_t *spa = scn->scn_dp->dp_spa;
	void *cookie = NULL;
	scan_prefetch_issue_ctx_t *spic = NULL;

	mutex_enter(&spa->spa_scrub_lock);
	while ((spic = avl_destroy_nodes(&scn->scn_prefetch_queue,
	&cookie)) != NULL) {
	scan_prefetch_ctx_rele(spic->spic_spc, scn);
	kmem_free(spic, sizeof (scan_prefetch_issue_ctx_t));
	}
	mutex_exit(&spa->spa_scrub_lock);
	}

	static boolean_t
	dsl_scan_check_prefetch_resume(scan_prefetch_ctx_t *spc,
	const zbookmark_phys_t *zb)
	{
	zbookmark_phys_t *last_zb = &spc->spc_scn->scn_prefetch_bookmark;
	dnode_phys_t tmp_dnp;
	dnode_phys_t *dnp = (spc->spc_root) ? NULL : &tmp_dnp;

	if (zb->zb_objset != last_zb->zb_objset)
	return (B_TRUE);
	if ((int64_t)zb->zb_object < 0)
	return (B_FALSE);

	tmp_dnp.dn_datablkszsec = spc->spc_datablkszsec;
	tmp_dnp.dn_indblkshift = spc->spc_indblkshift;

	if (zbookmark_subtree_completed(dnp, zb, last_zb))
	return (B_TRUE);

	return (B_FALSE);
	}

	static void
	dsl_scan_prefetch(scan_prefetch_ctx_t spc, blkptr_t bp, zbookmark_phys_t *zb)
	{
	avl_index_t idx;
	dsl_scan_t *scn = spc->spc_scn;
	spa_t *spa = scn->scn_dp->dp_spa;
	scan_prefetch_issue_ctx_t *spic;

	if (zfs_no_scrub_prefetch \|\| BP_IS_REDACTED(bp))
	return;

	if (BP_IS_HOLE(bp) \|\| bp->blk_birth <= scn->scn_phys.scn_cur_min_txg \|\|
	(BP_GET_LEVEL(bp) == 0 && BP_GET_TYPE(bp) != DMU_OT_DNODE &&
	BP_GET_TYPE(bp) != DMU_OT_OBJSET))
	return;

	if (dsl_scan_check_prefetch_resume(spc, zb))
	return;

	scan_prefetch_ctx_add_ref(spc, scn);
	spic = kmem_alloc(sizeof (scan_prefetch_issue_ctx_t), KM_SLEEP);
	spic->spic_spc = spc;
	spic->spic_bp = *bp;
	spic->spic_zb = *zb;

	/*
	* Add the IO to the queue of blocks to prefetch. This allows us to
	* prioritize blocks that we will need first for the main traversal
	* thread.
	*/
	mutex_enter(&spa->spa_scrub_lock);
	if (avl_find(&scn->scn_prefetch_queue, spic, &idx) != NULL) {
	/* this block is already queued for prefetch */
	kmem_free(spic, sizeof (scan_prefetch_issue_ctx_t));
	scan_prefetch_ctx_rele(spc, scn);
	mutex_exit(&spa->spa_scrub_lock);
	return;
	}

	avl_insert(&scn->scn_prefetch_queue, spic, idx);
	cv_broadcast(&spa->spa_scrub_io_cv);
	mutex_exit(&spa->spa_scrub_lock);
	}

	static void
	dsl_scan_prefetch_dnode(dsl_scan_t scn, dnode_phys_t dnp,
	uint64_t objset, uint64_t object)
	{
	int i;
	zbookmark_phys_t zb;
	scan_prefetch_ctx_t *spc;

	if (dnp->dn_nblkptr == 0 && !(dnp->dn_flags & DNODE_FLAG_SPILL_BLKPTR))
	return;

	SET_BOOKMARK(&zb, objset, object, 0, 0);

	spc = scan_prefetch_ctx_create(scn, dnp, FTAG);

	for (i = 0; i < dnp->dn_nblkptr; i++) {
	zb.zb_level = BP_GET_LEVEL(&dnp->dn_blkptr[i]);
	zb.zb_blkid = i;
	dsl_scan_prefetch(spc, &dnp->dn_blkptr[i], &zb);
	}

	if (dnp->dn_flags & DNODE_FLAG_SPILL_BLKPTR) {
	zb.zb_level = 0;
	zb.zb_blkid = DMU_SPILL_BLKID;
	dsl_scan_prefetch(spc, DN_SPILL_BLKPTR(dnp), &zb);
	}

	scan_prefetch_ctx_rele(spc, FTAG);
	}

	static void
	dsl_scan_prefetch_cb(zio_t zio, const zbookmark_phys_t zb, const blkptr_t *bp,
	arc_buf_t buf, void private)
	{
	scan_prefetch_ctx_t *spc = private;
	dsl_scan_t *scn = spc->spc_scn;
	spa_t *spa = scn->scn_dp->dp_spa;

	/* broadcast that the IO has completed for rate limiting purposes */
	mutex_enter(&spa->spa_scrub_lock);
	ASSERT3U(spa->spa_scrub_inflight, >=, BP_GET_PSIZE(bp));
	spa->spa_scrub_inflight -= BP_GET_PSIZE(bp);
	cv_broadcast(&spa->spa_scrub_io_cv);
	mutex_exit(&spa->spa_scrub_lock);

	/* if there was an error or we are done prefetching, just cleanup */
	if (buf == NULL \|\| scn->scn_prefetch_stop)
	goto out;

	if (BP_GET_LEVEL(bp) > 0) {
	int i;
	blkptr_t *cbp;
	int epb = BP_GET_LSIZE(bp) >> SPA_BLKPTRSHIFT;
	zbookmark_phys_t czb;

	for (i = 0, cbp = buf->b_data; i < epb; i++, cbp++) {
	SET_BOOKMARK(&czb, zb->zb_objset, zb->zb_object,
	zb->zb_level - 1, zb->zb_blkid * epb + i);
	dsl_scan_prefetch(spc, cbp, &czb);
	}
	} else if (BP_GET_TYPE(bp) == DMU_OT_DNODE) {
	dnode_phys_t *cdnp;
	int i;
	int epb = BP_GET_LSIZE(bp) >> DNODE_SHIFT;

	for (i = 0, cdnp = buf->b_data; i < epb;
	i += cdnp->dn_extra_slots + 1,
	cdnp += cdnp->dn_extra_slots + 1) {
	dsl_scan_prefetch_dnode(scn, cdnp,
	zb->zb_objset, zb->zb_blkid * epb + i);
	}
	} else if (BP_GET_TYPE(bp) == DMU_OT_OBJSET) {
	objset_phys_t *osp = buf->b_data;

	dsl_scan_prefetch_dnode(scn, &osp->os_meta_dnode,
	zb->zb_objset, DMU_META_DNODE_OBJECT);

	if (OBJSET_BUF_HAS_USERUSED(buf)) {
	dsl_scan_prefetch_dnode(scn,
	&osp->os_groupused_dnode, zb->zb_objset,
	DMU_GROUPUSED_OBJECT);
	dsl_scan_prefetch_dnode(scn,
	&osp->os_userused_dnode, zb->zb_objset,
	DMU_USERUSED_OBJECT);
	}
	}

	out:
	if (buf != NULL)
	arc_buf_destroy(buf, private);
	scan_prefetch_ctx_rele(spc, scn);
	}

	/* ARGSUSED */
	static void
	dsl_scan_prefetch_thread(void *arg)
	{
	dsl_scan_t *scn = arg;
	spa_t *spa = scn->scn_dp->dp_spa;
	scan_prefetch_issue_ctx_t *spic;

	/* loop until we are told to stop */
	while (!scn->scn_prefetch_stop) {
	arc_flags_t flags = ARC_FLAG_NOWAIT \|
	ARC_FLAG_PRESCIENT_PREFETCH \| ARC_FLAG_PREFETCH;
	int zio_flags = ZIO_FLAG_CANFAIL \| ZIO_FLAG_SCAN_THREAD;

	mutex_enter(&spa->spa_scrub_lock);

	/*
	* Wait until we have an IO to issue and are not above our
	* maximum in flight limit.
	*/
	while (!scn->scn_prefetch_stop &&
	(avl_numnodes(&scn->scn_prefetch_queue) == 0 \|\|
	spa->spa_scrub_inflight >= scn->scn_maxinflight_bytes)) {
	cv_wait(&spa->spa_scrub_io_cv, &spa->spa_scrub_lock);
	}

	/* recheck if we should stop since we waited for the cv */
	if (scn->scn_prefetch_stop) {
	mutex_exit(&spa->spa_scrub_lock);
	break;
	}

	/* remove the prefetch IO from the tree */
	spic = avl_first(&scn->scn_prefetch_queue);
	spa->spa_scrub_inflight += BP_GET_PSIZE(&spic->spic_bp);
	avl_remove(&scn->scn_prefetch_queue, spic);

	mutex_exit(&spa->spa_scrub_lock);

	if (BP_IS_PROTECTED(&spic->spic_bp)) {
	ASSERT(BP_GET_TYPE(&spic->spic_bp) == DMU_OT_DNODE \|\|
	BP_GET_TYPE(&spic->spic_bp) == DMU_OT_OBJSET);
	ASSERT3U(BP_GET_LEVEL(&spic->spic_bp), ==, 0);
	zio_flags \|= ZIO_FLAG_RAW;
	}

	/* issue the prefetch asynchronously */
	(void) arc_read(scn->scn_zio_root, scn->scn_dp->dp_spa,
	&spic->spic_bp, dsl_scan_prefetch_cb, spic->spic_spc,
	ZIO_PRIORITY_SCRUB, zio_flags, &flags, &spic->spic_zb);

	kmem_free(spic, sizeof (scan_prefetch_issue_ctx_t));
	}

	ASSERT(scn->scn_prefetch_stop);

	/* free any prefetches we didn't get to complete */
	mutex_enter(&spa->spa_scrub_lock);
	while ((spic = avl_first(&scn->scn_prefetch_queue)) != NULL) {
	avl_remove(&scn->scn_prefetch_queue, spic);
	scan_prefetch_ctx_rele(spic->spic_spc, scn);
	kmem_free(spic, sizeof (scan_prefetch_issue_ctx_t));
	}
	ASSERT0(avl_numnodes(&scn->scn_prefetch_queue));
	mutex_exit(&spa->spa_scrub_lock);
	}

	static boolean_t
	dsl_scan_check_resume(dsl_scan_t scn, const dnode_phys_t dnp,
	const zbookmark_phys_t *zb)
	{
	/*
	* We never skip over user/group accounting objects (obj<0)
	*/
	if (!ZB_IS_ZERO(&scn->scn_phys.scn_bookmark) &&
	(int64_t)zb->zb_object >= 0) {
	/*
	* If we already visited this bp & everything below (in
	* a prior txg sync), don't bother doing it again.
	*/
	if (zbookmark_subtree_completed(dnp, zb,
	&scn->scn_phys.scn_bookmark))
	return (B_TRUE);

	/*
	* If we found the block we're trying to resume from, or
	* we went past it to a different object, zero it out to
	* indicate that it's OK to start checking for suspending
	* again.
	*/
	if (bcmp(zb, &scn->scn_phys.scn_bookmark, sizeof (*zb)) == 0 \|\|
	zb->zb_object > scn->scn_phys.scn_bookmark.zb_object) {
	dprintf("resuming at %llx/%llx/%llx/%llx\n",
	(longlong_t)zb->zb_objset,
	(longlong_t)zb->zb_object,
	(longlong_t)zb->zb_level,
	(longlong_t)zb->zb_blkid);
	bzero(&scn->scn_phys.scn_bookmark, sizeof (*zb));
	}
	}
	return (B_FALSE);
	}

	static void dsl_scan_visitbp(blkptr_t bp, const zbookmark_phys_t zb,
	dnode_phys_t dnp, dsl_dataset_t ds, dsl_scan_t *scn,
	dmu_objset_type_t ostype, dmu_tx_t *tx);
	inline __attribute__((always_inline)) static void dsl_scan_visitdnode(
	dsl_scan_t , dsl_dataset_t ds, dmu_objset_type_t ostype,
	dnode_phys_t dnp, uint64_t object, dmu_tx_t tx);

	/*
	* Return nonzero on i/o error.
	* Return new buf to write out in *bufp.
	*/
	inline __attribute__((always_inline)) static int
	dsl_scan_recurse(dsl_scan_t scn, dsl_dataset_t ds, dmu_objset_type_t ostype,
	dnode_phys_t dnp, const blkptr_t bp,
	const zbookmark_phys_t zb, dmu_tx_t tx)
	{
	dsl_pool_t *dp = scn->scn_dp;
	int zio_flags = ZIO_FLAG_CANFAIL \| ZIO_FLAG_SCAN_THREAD;
	int err;

	ASSERT(!BP_IS_REDACTED(bp));

	if (BP_GET_LEVEL(bp) > 0) {
	arc_flags_t flags = ARC_FLAG_WAIT;
	int i;
	blkptr_t *cbp;
	int epb = BP_GET_LSIZE(bp) >> SPA_BLKPTRSHIFT;
	arc_buf_t *buf;

	err = arc_read(NULL, dp->dp_spa, bp, arc_getbuf_func, &buf,
	ZIO_PRIORITY_SCRUB, zio_flags, &flags, zb);
	if (err) {
	scn->scn_phys.scn_errors++;
	return (err);
	}
	for (i = 0, cbp = buf->b_data; i < epb; i++, cbp++) {
	zbookmark_phys_t czb;

	SET_BOOKMARK(&czb, zb->zb_objset, zb->zb_object,
	zb->zb_level - 1,
	zb->zb_blkid * epb + i);
	dsl_scan_visitbp(cbp, &czb, dnp,
	ds, scn, ostype, tx);
	}
	arc_buf_destroy(buf, &buf);
	} else if (BP_GET_TYPE(bp) == DMU_OT_DNODE) {
	arc_flags_t flags = ARC_FLAG_WAIT;
	dnode_phys_t *cdnp;
	int i;
	int epb = BP_GET_LSIZE(bp) >> DNODE_SHIFT;
	arc_buf_t *buf;

	if (BP_IS_PROTECTED(bp)) {
	ASSERT3U(BP_GET_COMPRESS(bp), ==, ZIO_COMPRESS_OFF);
	zio_flags \|= ZIO_FLAG_RAW;
	}

	err = arc_read(NULL, dp->dp_spa, bp, arc_getbuf_func, &buf,
	ZIO_PRIORITY_SCRUB, zio_flags, &flags, zb);
	if (err) {
	scn->scn_phys.scn_errors++;
	return (err);
	}
	for (i = 0, cdnp = buf->b_data; i < epb;
	i += cdnp->dn_extra_slots + 1,
	cdnp += cdnp->dn_extra_slots + 1) {
	dsl_scan_visitdnode(scn, ds, ostype,
	cdnp, zb->zb_blkid * epb + i, tx);
	}

	arc_buf_destroy(buf, &buf);
	} else if (BP_GET_TYPE(bp) == DMU_OT_OBJSET) {
	arc_flags_t flags = ARC_FLAG_WAIT;
	objset_phys_t *osp;
	arc_buf_t *buf;

	err = arc_read(NULL, dp->dp_spa, bp, arc_getbuf_func, &buf,
	ZIO_PRIORITY_SCRUB, zio_flags, &flags, zb);
	if (err) {
	scn->scn_phys.scn_errors++;
	return (err);
	}

	osp = buf->b_data;

	dsl_scan_visitdnode(scn, ds, osp->os_type,
	&osp->os_meta_dnode, DMU_META_DNODE_OBJECT, tx);

	if (OBJSET_BUF_HAS_USERUSED(buf)) {
	/*
	* We also always visit user/group/project accounting
	* objects, and never skip them, even if we are
	* suspending. This is necessary so that the
	* space deltas from this txg get integrated.
	*/
	if (OBJSET_BUF_HAS_PROJECTUSED(buf))
	dsl_scan_visitdnode(scn, ds, osp->os_type,
	&osp->os_projectused_dnode,
	DMU_PROJECTUSED_OBJECT, tx);
	dsl_scan_visitdnode(scn, ds, osp->os_type,
	&osp->os_groupused_dnode,
	DMU_GROUPUSED_OBJECT, tx);
	dsl_scan_visitdnode(scn, ds, osp->os_type,
	&osp->os_userused_dnode,
	DMU_USERUSED_OBJECT, tx);
	}
	arc_buf_destroy(buf, &buf);
	}

	return (0);
	}

	inline __attribute__((always_inline)) static void
	dsl_scan_visitdnode(dsl_scan_t scn, dsl_dataset_t ds,
	dmu_objset_type_t ostype, dnode_phys_t *dnp,
	uint64_t object, dmu_tx_t *tx)
	{
	int j;

	for (j = 0; j < dnp->dn_nblkptr; j++) {
	zbookmark_phys_t czb;

	SET_BOOKMARK(&czb, ds ? ds->ds_object : 0, object,
	dnp->dn_nlevels - 1, j);
	dsl_scan_visitbp(&dnp->dn_blkptr[j],
	&czb, dnp, ds, scn, ostype, tx);
	}

	if (dnp->dn_flags & DNODE_FLAG_SPILL_BLKPTR) {
	zbookmark_phys_t czb;
	SET_BOOKMARK(&czb, ds ? ds->ds_object : 0, object,
	0, DMU_SPILL_BLKID);
	dsl_scan_visitbp(DN_SPILL_BLKPTR(dnp),
	&czb, dnp, ds, scn, ostype, tx);
	}
	}

	/*
	* The arguments are in this order because mdb can only print the
	* first 5; we want them to be useful.
	*/
	static void
	dsl_scan_visitbp(blkptr_t bp, const zbookmark_phys_t zb,
	dnode_phys_t dnp, dsl_dataset_t ds, dsl_scan_t *scn,
	dmu_objset_type_t ostype, dmu_tx_t *tx)
	{
	dsl_pool_t *dp = scn->scn_dp;
	blkptr_t *bp_toread = NULL;

	if (dsl_scan_check_suspend(scn, zb))
	return;

	if (dsl_scan_check_resume(scn, dnp, zb))
	return;

	scn->scn_visited_this_txg++;

	/*
	* This debugging is commented out to conserve stack space. This
	* function is called recursively and the debugging adds several
	* bytes to the stack for each call. It can be commented back in
	* if required to debug an issue in dsl_scan_visitbp().
	*
	* dprintf_bp(bp,
	* "visiting ds=%p/%llu zb=%llx/%llx/%llx/%llx bp=%p",
	* ds, ds ? ds->ds_object : 0,
	* zb->zb_objset, zb->zb_object, zb->zb_level, zb->zb_blkid,
	* bp);
	*/

	if (BP_IS_HOLE(bp)) {
	scn->scn_holes_this_txg++;
	return;
	}

	if (BP_IS_REDACTED(bp)) {
	ASSERT(dsl_dataset_feature_is_active(ds,
	SPA_FEATURE_REDACTED_DATASETS));
	return;
	}

	if (bp->blk_birth <= scn->scn_phys.scn_cur_min_txg) {
	scn->scn_lt_min_this_txg++;
	return;
	}

	bp_toread = kmem_alloc(sizeof (blkptr_t), KM_SLEEP);
	bp_toread = bp;

	if (dsl_scan_recurse(scn, ds, ostype, dnp, bp_toread, zb, tx) != 0)
	goto out;

	/*
	* If dsl_scan_ddt() has already visited this block, it will have
	* already done any translations or scrubbing, so don't call the
	* callback again.
	*/
	if (ddt_class_contains(dp->dp_spa,
	scn->scn_phys.scn_ddt_class_max, bp)) {
	scn->scn_ddt_contained_this_txg++;
	goto out;
	}

	/*
	* If this block is from the future (after cur_max_txg), then we
	* are doing this on behalf of a deleted snapshot, and we will
	* revisit the future block on the next pass of this dataset.
	* Don't scan it now unless we need to because something
	* under it was modified.
	*/
	if (BP_PHYSICAL_BIRTH(bp) > scn->scn_phys.scn_cur_max_txg) {
	scn->scn_gt_max_this_txg++;
	goto out;
	}

	scan_funcs[scn->scn_phys.scn_func](dp, bp, zb);

	out:
	kmem_free(bp_toread, sizeof (blkptr_t));
	}

	static void
	dsl_scan_visit_rootbp(dsl_scan_t scn, dsl_dataset_t ds, blkptr_t *bp,
	dmu_tx_t *tx)
	{
	zbookmark_phys_t zb;
	scan_prefetch_ctx_t *spc;

	SET_BOOKMARK(&zb, ds ? ds->ds_object : DMU_META_OBJSET,
	ZB_ROOT_OBJECT, ZB_ROOT_LEVEL, ZB_ROOT_BLKID);

	if (ZB_IS_ZERO(&scn->scn_phys.scn_bookmark)) {
	SET_BOOKMARK(&scn->scn_prefetch_bookmark,
	zb.zb_objset, 0, 0, 0);
	} else {
	scn->scn_prefetch_bookmark = scn->scn_phys.scn_bookmark;
	}

	scn->scn_objsets_visited_this_txg++;

	spc = scan_prefetch_ctx_create(scn, NULL, FTAG);
	dsl_scan_prefetch(spc, bp, &zb);
	scan_prefetch_ctx_rele(spc, FTAG);

	dsl_scan_visitbp(bp, &zb, NULL, ds, scn, DMU_OST_NONE, tx);

	dprintf_ds(ds, "finished scan%s", "");
	}

	static void
	ds_destroyed_scn_phys(dsl_dataset_t ds, dsl_scan_phys_t scn_phys)
	{
	if (scn_phys->scn_bookmark.zb_objset == ds->ds_object) {
	if (ds->ds_is_snapshot) {
	/*
	* Note:
	* - scn_cur_{min,max}_txg stays the same.
	* - Setting the flag is not really necessary if
	* scn_cur_max_txg == scn_max_txg, because there
	* is nothing after this snapshot that we care
	* about. However, we set it anyway and then
	* ignore it when we retraverse it in
	* dsl_scan_visitds().
	*/
	scn_phys->scn_bookmark.zb_objset =
	dsl_dataset_phys(ds)->ds_next_snap_obj;
	zfs_dbgmsg("destroying ds %llu; currently traversing; "
	"reset zb_objset to %llu",
	(u_longlong_t)ds->ds_object,
	(u_longlong_t)dsl_dataset_phys(ds)->
	ds_next_snap_obj);
	scn_phys->scn_flags \|= DSF_VISIT_DS_AGAIN;
	} else {
	SET_BOOKMARK(&scn_phys->scn_bookmark,
	ZB_DESTROYED_OBJSET, 0, 0, 0);
	zfs_dbgmsg("destroying ds %llu; currently traversing; "
	"reset bookmark to -1,0,0,0",
	(u_longlong_t)ds->ds_object);
	}
	}
	}

	/*
	* Invoked when a dataset is destroyed. We need to make sure that:
	*
	* 1) If it is the dataset that was currently being scanned, we write
	* a new dsl_scan_phys_t and marking the objset reference in it
	* as destroyed.
	* 2) Remove it from the work queue, if it was present.
	*
	* If the dataset was actually a snapshot, instead of marking the dataset
	* as destroyed, we instead substitute the next snapshot in line.
	*/
	void
	dsl_scan_ds_destroyed(dsl_dataset_t ds, dmu_tx_t tx)
	{
	dsl_pool_t *dp = ds->ds_dir->dd_pool;
	dsl_scan_t *scn = dp->dp_scan;
	uint64_t mintxg;

	if (!dsl_scan_is_running(scn))
	return;

	ds_destroyed_scn_phys(ds, &scn->scn_phys);
	ds_destroyed_scn_phys(ds, &scn->scn_phys_cached);

	if (scan_ds_queue_contains(scn, ds->ds_object, &mintxg)) {
	scan_ds_queue_remove(scn, ds->ds_object);
	if (ds->ds_is_snapshot)
	scan_ds_queue_insert(scn,
	dsl_dataset_phys(ds)->ds_next_snap_obj, mintxg);
	}

	if (zap_lookup_int_key(dp->dp_meta_objset, scn->scn_phys.scn_queue_obj,
	ds->ds_object, &mintxg) == 0) {
	ASSERT3U(dsl_dataset_phys(ds)->ds_num_children, <=, 1);
	VERIFY3U(0, ==, zap_remove_int(dp->dp_meta_objset,
	scn->scn_phys.scn_queue_obj, ds->ds_object, tx));
	if (ds->ds_is_snapshot) {
	/*
	* We keep the same mintxg; it could be >
	* ds_creation_txg if the previous snapshot was
	* deleted too.
	*/
	VERIFY(zap_add_int_key(dp->dp_meta_objset,
	scn->scn_phys.scn_queue_obj,
	dsl_dataset_phys(ds)->ds_next_snap_obj,
	mintxg, tx) == 0);
	zfs_dbgmsg("destroying ds %llu; in queue; "
	"replacing with %llu",
	(u_longlong_t)ds->ds_object,
	(u_longlong_t)dsl_dataset_phys(ds)->
	ds_next_snap_obj);
	} else {
	zfs_dbgmsg("destroying ds %llu; in queue; removing",
	(u_longlong_t)ds->ds_object);
	}
	}

	/*
	* dsl_scan_sync() should be called after this, and should sync
	* out our changed state, but just to be safe, do it here.
	*/
	dsl_scan_sync_state(scn, tx, SYNC_CACHED);
	}

	static void
	ds_snapshotted_bookmark(dsl_dataset_t ds, zbookmark_phys_t scn_bookmark)
	{
	if (scn_bookmark->zb_objset == ds->ds_object) {
	scn_bookmark->zb_objset =
	dsl_dataset_phys(ds)->ds_prev_snap_obj;
	zfs_dbgmsg("snapshotting ds %llu; currently traversing; "
	"reset zb_objset to %llu",
	(u_longlong_t)ds->ds_object,
	(u_longlong_t)dsl_dataset_phys(ds)->ds_prev_snap_obj);
	}
	}

	/*
	* Called when a dataset is snapshotted. If we were currently traversing
	* this snapshot, we reset our bookmark to point at the newly created
	* snapshot. We also modify our work queue to remove the old snapshot and
	* replace with the new one.
	*/
	void
	dsl_scan_ds_snapshotted(dsl_dataset_t ds, dmu_tx_t tx)
	{
	dsl_pool_t *dp = ds->ds_dir->dd_pool;
	dsl_scan_t *scn = dp->dp_scan;
	uint64_t mintxg;

	if (!dsl_scan_is_running(scn))
	return;

	ASSERT(dsl_dataset_phys(ds)->ds_prev_snap_obj != 0);

	ds_snapshotted_bookmark(ds, &scn->scn_phys.scn_bookmark);
	ds_snapshotted_bookmark(ds, &scn->scn_phys_cached.scn_bookmark);

	if (scan_ds_queue_contains(scn, ds->ds_object, &mintxg)) {
	scan_ds_queue_remove(scn, ds->ds_object);
	scan_ds_queue_insert(scn,
	dsl_dataset_phys(ds)->ds_prev_snap_obj, mintxg);
	}

	if (zap_lookup_int_key(dp->dp_meta_objset, scn->scn_phys.scn_queue_obj,
	ds->ds_object, &mintxg) == 0) {
	VERIFY3U(0, ==, zap_remove_int(dp->dp_meta_objset,
	scn->scn_phys.scn_queue_obj, ds->ds_object, tx));
	VERIFY(zap_add_int_key(dp->dp_meta_objset,
	scn->scn_phys.scn_queue_obj,
	dsl_dataset_phys(ds)->ds_prev_snap_obj, mintxg, tx) == 0);
	zfs_dbgmsg("snapshotting ds %llu; in queue; "
	"replacing with %llu",
	(u_longlong_t)ds->ds_object,
	(u_longlong_t)dsl_dataset_phys(ds)->ds_prev_snap_obj);
	}

	dsl_scan_sync_state(scn, tx, SYNC_CACHED);
	}

	static void
	ds_clone_swapped_bookmark(dsl_dataset_t ds1, dsl_dataset_t ds2,
	zbookmark_phys_t *scn_bookmark)
	{
	if (scn_bookmark->zb_objset == ds1->ds_object) {
	scn_bookmark->zb_objset = ds2->ds_object;
	zfs_dbgmsg("clone_swap ds %llu; currently traversing; "
	"reset zb_objset to %llu",
	(u_longlong_t)ds1->ds_object,
	(u_longlong_t)ds2->ds_object);
	} else if (scn_bookmark->zb_objset == ds2->ds_object) {
	scn_bookmark->zb_objset = ds1->ds_object;
	zfs_dbgmsg("clone_swap ds %llu; currently traversing; "
	"reset zb_objset to %llu",
	(u_longlong_t)ds2->ds_object,
	(u_longlong_t)ds1->ds_object);
	}
	}

	/*
	* Called when an origin dataset and its clone are swapped. If we were
	* currently traversing the dataset, we need to switch to traversing the
	* newly promoted clone.
	*/
	void
	dsl_scan_ds_clone_swapped(dsl_dataset_t ds1, dsl_dataset_t ds2, dmu_tx_t *tx)
	{
	dsl_pool_t *dp = ds1->ds_dir->dd_pool;
	dsl_scan_t *scn = dp->dp_scan;
	uint64_t mintxg1, mintxg2;
	boolean_t ds1_queued, ds2_queued;

	if (!dsl_scan_is_running(scn))
	return;

	ds_clone_swapped_bookmark(ds1, ds2, &scn->scn_phys.scn_bookmark);
	ds_clone_swapped_bookmark(ds1, ds2, &scn->scn_phys_cached.scn_bookmark);

	/*
	* Handle the in-memory scan queue.
	*/
	ds1_queued = scan_ds_queue_contains(scn, ds1->ds_object, &mintxg1);
	ds2_queued = scan_ds_queue_contains(scn, ds2->ds_object, &mintxg2);

	/* Sanity checking. */
	if (ds1_queued) {
	ASSERT3U(mintxg1, ==, dsl_dataset_phys(ds1)->ds_prev_snap_txg);
	ASSERT3U(mintxg1, ==, dsl_dataset_phys(ds2)->ds_prev_snap_txg);
	}
	if (ds2_queued) {
	ASSERT3U(mintxg2, ==, dsl_dataset_phys(ds1)->ds_prev_snap_txg);
	ASSERT3U(mintxg2, ==, dsl_dataset_phys(ds2)->ds_prev_snap_txg);
	}

	if (ds1_queued && ds2_queued) {
	/*
	* If both are queued, we don't need to do anything.
	* The swapping code below would not handle this case correctly,
	* since we can't insert ds2 if it is already there. That's
	* because scan_ds_queue_insert() prohibits a duplicate insert
	* and panics.
	*/
	} else if (ds1_queued) {
	scan_ds_queue_remove(scn, ds1->ds_object);
	scan_ds_queue_insert(scn, ds2->ds_object, mintxg1);
	} else if (ds2_queued) {
	scan_ds_queue_remove(scn, ds2->ds_object);
	scan_ds_queue_insert(scn, ds1->ds_object, mintxg2);
	}

	/*
	* Handle the on-disk scan queue.
	* The on-disk state is an out-of-date version of the in-memory state,
	* so the in-memory and on-disk values for ds1_queued and ds2_queued may
	* be different. Therefore we need to apply the swap logic to the
	* on-disk state independently of the in-memory state.
	*/
	ds1_queued = zap_lookup_int_key(dp->dp_meta_objset,
	scn->scn_phys.scn_queue_obj, ds1->ds_object, &mintxg1) == 0;
	ds2_queued = zap_lookup_int_key(dp->dp_meta_objset,
	scn->scn_phys.scn_queue_obj, ds2->ds_object, &mintxg2) == 0;

	/* Sanity checking. */
	if (ds1_queued) {
	ASSERT3U(mintxg1, ==, dsl_dataset_phys(ds1)->ds_prev_snap_txg);
	ASSERT3U(mintxg1, ==, dsl_dataset_phys(ds2)->ds_prev_snap_txg);
	}
	if (ds2_queued) {
	ASSERT3U(mintxg2, ==, dsl_dataset_phys(ds1)->ds_prev_snap_txg);
	ASSERT3U(mintxg2, ==, dsl_dataset_phys(ds2)->ds_prev_snap_txg);
	}

	if (ds1_queued && ds2_queued) {
	/*
	* If both are queued, we don't need to do anything.
	* Alternatively, we could check for EEXIST from
	* zap_add_int_key() and back out to the original state, but
	* that would be more work than checking for this case upfront.
	*/
	} else if (ds1_queued) {
	VERIFY3S(0, ==, zap_remove_int(dp->dp_meta_objset,
	scn->scn_phys.scn_queue_obj, ds1->ds_object, tx));
	VERIFY3S(0, ==, zap_add_int_key(dp->dp_meta_objset,
	scn->scn_phys.scn_queue_obj, ds2->ds_object, mintxg1, tx));
	zfs_dbgmsg("clone_swap ds %llu; in queue; "
	"replacing with %llu",
	(u_longlong_t)ds1->ds_object,
	(u_longlong_t)ds2->ds_object);
	} else if (ds2_queued) {
	VERIFY3S(0, ==, zap_remove_int(dp->dp_meta_objset,
	scn->scn_phys.scn_queue_obj, ds2->ds_object, tx));
	VERIFY3S(0, ==, zap_add_int_key(dp->dp_meta_objset,
	scn->scn_phys.scn_queue_obj, ds1->ds_object, mintxg2, tx));
	zfs_dbgmsg("clone_swap ds %llu; in queue; "
	"replacing with %llu",
	(u_longlong_t)ds2->ds_object,
	(u_longlong_t)ds1->ds_object);
	}

	dsl_scan_sync_state(scn, tx, SYNC_CACHED);
	}

	/* ARGSUSED */
	static int
	enqueue_clones_cb(dsl_pool_t dp, dsl_dataset_t hds, void *arg)
	{
	uint64_t originobj = (uint64_t )arg;
	dsl_dataset_t *ds;
	int err;
	dsl_scan_t *scn = dp->dp_scan;

	if (dsl_dir_phys(hds->ds_dir)->dd_origin_obj != originobj)
	return (0);

	err = dsl_dataset_hold_obj(dp, hds->ds_object, FTAG, &ds);
	if (err)
	return (err);

	while (dsl_dataset_phys(ds)->ds_prev_snap_obj != originobj) {
	dsl_dataset_t *prev;
	err = dsl_dataset_hold_obj(dp,
	dsl_dataset_phys(ds)->ds_prev_snap_obj, FTAG, &prev);

	dsl_dataset_rele(ds, FTAG);
	if (err)
	return (err);
	ds = prev;
	}
	scan_ds_queue_insert(scn, ds->ds_object,
	dsl_dataset_phys(ds)->ds_prev_snap_txg);
	dsl_dataset_rele(ds, FTAG);
	return (0);
	}

	static void
	dsl_scan_visitds(dsl_scan_t scn, uint64_t dsobj, dmu_tx_t tx)
	{
	dsl_pool_t *dp = scn->scn_dp;
	dsl_dataset_t *ds;

	VERIFY3U(0, ==, dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds));

	if (scn->scn_phys.scn_cur_min_txg >=
	scn->scn_phys.scn_max_txg) {
	/*
	* This can happen if this snapshot was created after the
	* scan started, and we already completed a previous snapshot
	* that was created after the scan started. This snapshot
	* only references blocks with:
	*
	* birth < our ds_creation_txg
	* cur_min_txg is no less than ds_creation_txg.
	* We have already visited these blocks.
	* or
	* birth > scn_max_txg
	* The scan requested not to visit these blocks.
	*
	* Subsequent snapshots (and clones) can reference our
	* blocks, or blocks with even higher birth times.
	* Therefore we do not need to visit them either,
	* so we do not add them to the work queue.
	*
	* Note that checking for cur_min_txg >= cur_max_txg
	* is not sufficient, because in that case we may need to
	* visit subsequent snapshots. This happens when min_txg > 0,
	* which raises cur_min_txg. In this case we will visit
	* this dataset but skip all of its blocks, because the
	* rootbp's birth time is < cur_min_txg. Then we will
	* add the next snapshots/clones to the work queue.
	*/
	char *dsname = kmem_alloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP);
	dsl_dataset_name(ds, dsname);
	zfs_dbgmsg("scanning dataset %llu (%s) is unnecessary because "
	"cur_min_txg (%llu) >= max_txg (%llu)",
	(longlong_t)dsobj, dsname,
	(longlong_t)scn->scn_phys.scn_cur_min_txg,
	(longlong_t)scn->scn_phys.scn_max_txg);
	kmem_free(dsname, MAXNAMELEN);

	goto out;
	}

	/*
	* Only the ZIL in the head (non-snapshot) is valid. Even though
	* snapshots can have ZIL block pointers (which may be the same
	* BP as in the head), they must be ignored. In addition, $ORIGIN
	* doesn't have a objset (i.e. its ds_bp is a hole) so we don't
	* need to look for a ZIL in it either. So we traverse the ZIL here,
	* rather than in scan_recurse(), because the regular snapshot
	* block-sharing rules don't apply to it.
	*/
	if (!dsl_dataset_is_snapshot(ds) &&
	(dp->dp_origin_snap == NULL \|\|
	ds->ds_dir != dp->dp_origin_snap->ds_dir)) {
	objset_t *os;
	if (dmu_objset_from_ds(ds, &os) != 0) {
	goto out;
	}
	dsl_scan_zil(dp, &os->os_zil_header);
	}

	/*
	* Iterate over the bps in this ds.
	*/
	dmu_buf_will_dirty(ds->ds_dbuf, tx);
	rrw_enter(&ds->ds_bp_rwlock, RW_READER, FTAG);
	dsl_scan_visit_rootbp(scn, ds, &dsl_dataset_phys(ds)->ds_bp, tx);
	rrw_exit(&ds->ds_bp_rwlock, FTAG);

	char *dsname = kmem_alloc(ZFS_MAX_DATASET_NAME_LEN, KM_SLEEP);
	dsl_dataset_name(ds, dsname);
	zfs_dbgmsg("scanned dataset %llu (%s) with min=%llu max=%llu; "
	"suspending=%u",
	(longlong_t)dsobj, dsname,
	(longlong_t)scn->scn_phys.scn_cur_min_txg,
	(longlong_t)scn->scn_phys.scn_cur_max_txg,
	(int)scn->scn_suspending);
	kmem_free(dsname, ZFS_MAX_DATASET_NAME_LEN);

	if (scn->scn_suspending)
	goto out;

	/*
	* We've finished this pass over this dataset.
	*/

	/*
	* If we did not completely visit this dataset, do another pass.
	*/
	if (scn->scn_phys.scn_flags & DSF_VISIT_DS_AGAIN) {
	zfs_dbgmsg("incomplete pass; visiting again");
	scn->scn_phys.scn_flags &= ~DSF_VISIT_DS_AGAIN;
	scan_ds_queue_insert(scn, ds->ds_object,
	scn->scn_phys.scn_cur_max_txg);
	goto out;
	}

	/*
	* Add descendant datasets to work queue.
	*/
	if (dsl_dataset_phys(ds)->ds_next_snap_obj != 0) {
	scan_ds_queue_insert(scn,
	dsl_dataset_phys(ds)->ds_next_snap_obj,
	dsl_dataset_phys(ds)->ds_creation_txg);
	}
	if (dsl_dataset_phys(ds)->ds_num_children > 1) {
	boolean_t usenext = B_FALSE;
	if (dsl_dataset_phys(ds)->ds_next_clones_obj != 0) {
	uint64_t count;
	/*
	* A bug in a previous version of the code could
	* cause upgrade_clones_cb() to not set
	* ds_next_snap_obj when it should, leading to a
	* missing entry. Therefore we can only use the
	* next_clones_obj when its count is correct.
	*/
	int err = zap_count(dp->dp_meta_objset,
	dsl_dataset_phys(ds)->ds_next_clones_obj, &count);
	if (err == 0 &&
	count == dsl_dataset_phys(ds)->ds_num_children - 1)
	usenext = B_TRUE;
	}

	if (usenext) {
	zap_cursor_t zc;
	zap_attribute_t za;
	for (zap_cursor_init(&zc, dp->dp_meta_objset,
	dsl_dataset_phys(ds)->ds_next_clones_obj);
	zap_cursor_retrieve(&zc, &za) == 0;
	(void) zap_cursor_advance(&zc)) {
	scan_ds_queue_insert(scn,
	zfs_strtonum(za.za_name, NULL),
	dsl_dataset_phys(ds)->ds_creation_txg);
	}
	zap_cursor_fini(&zc);
	} else {
	VERIFY0(dmu_objset_find_dp(dp, dp->dp_root_dir_obj,
	enqueue_clones_cb, &ds->ds_object,
	DS_FIND_CHILDREN));
	}
	}

	out:
	dsl_dataset_rele(ds, FTAG);
	}

	/* ARGSUSED */
	static int
	enqueue_cb(dsl_pool_t dp, dsl_dataset_t hds, void *arg)
	{
	dsl_dataset_t *ds;
	int err;
	dsl_scan_t *scn = dp->dp_scan;

	err = dsl_dataset_hold_obj(dp, hds->ds_object, FTAG, &ds);
	if (err)
	return (err);

	while (dsl_dataset_phys(ds)->ds_prev_snap_obj != 0) {
	dsl_dataset_t *prev;
	err = dsl_dataset_hold_obj(dp,
	dsl_dataset_phys(ds)->ds_prev_snap_obj, FTAG, &prev);
	if (err) {
	dsl_dataset_rele(ds, FTAG);
	return (err);
	}

	/*
	* If this is a clone, we don't need to worry about it for now.
	*/
	if (dsl_dataset_phys(prev)->ds_next_snap_obj != ds->ds_object) {
	dsl_dataset_rele(ds, FTAG);
	dsl_dataset_rele(prev, FTAG);
	return (0);
	}
	dsl_dataset_rele(ds, FTAG);
	ds = prev;
	}

	scan_ds_queue_insert(scn, ds->ds_object,
	dsl_dataset_phys(ds)->ds_prev_snap_txg);
	dsl_dataset_rele(ds, FTAG);
	return (0);
	}

	/* ARGSUSED */
	void
	dsl_scan_ddt_entry(dsl_scan_t *scn, enum zio_checksum checksum,
	ddt_entry_t dde, dmu_tx_t tx)
	{
	const ddt_key_t *ddk = &dde->dde_key;
	ddt_phys_t *ddp = dde->dde_phys;
	blkptr_t bp;
	zbookmark_phys_t zb = { 0 };
	int p;

	if (!dsl_scan_is_running(scn))
	return;

	/*
	* This function is special because it is the only thing
	* that can add scan_io_t's to the vdev scan queues from
	* outside dsl_scan_sync(). For the most part this is ok
	* as long as it is called from within syncing context.
	* However, dsl_scan_sync() expects that no new sio's will
	* be added between when all the work for a scan is done
	* and the next txg when the scan is actually marked as
	* completed. This check ensures we do not issue new sio's
	* during this period.
	*/
	if (scn->scn_done_txg != 0)
	return;

	for (p = 0; p < DDT_PHYS_TYPES; p++, ddp++) {
	if (ddp->ddp_phys_birth == 0 \|\|
	ddp->ddp_phys_birth > scn->scn_phys.scn_max_txg)
	continue;
	ddt_bp_create(checksum, ddk, ddp, &bp);

	scn->scn_visited_this_txg++;
	scan_funcs[scn->scn_phys.scn_func](scn->scn_dp, &bp, &zb);
	}
	}

	/*
	* Scrub/dedup interaction.
	*
	* If there are N references to a deduped block, we don't want to scrub it
	* N times -- ideally, we should scrub it exactly once.
	*
	* We leverage the fact that the dde's replication class (enum ddt_class)
	* is ordered from highest replication class (DDT_CLASS_DITTO) to lowest
	* (DDT_CLASS_UNIQUE) so that we may walk the DDT in that order.
	*
	* To prevent excess scrubbing, the scrub begins by walking the DDT
	* to find all blocks with refcnt > 1, and scrubs each of these once.
	* Since there are two replication classes which contain blocks with
	* refcnt > 1, we scrub the highest replication class (DDT_CLASS_DITTO) first.
	* Finally the top-down scrub begins, only visiting blocks with refcnt == 1.
	*
	* There would be nothing more to say if a block's refcnt couldn't change
	* during a scrub, but of course it can so we must account for changes
	* in a block's replication class.
	*
	* Here's an example of what can occur:
	*
	* If a block has refcnt > 1 during the DDT scrub phase, but has refcnt == 1
	* when visited during the top-down scrub phase, it will be scrubbed twice.
	* This negates our scrub optimization, but is otherwise harmless.
	*
	* If a block has refcnt == 1 during the DDT scrub phase, but has refcnt > 1
	* on each visit during the top-down scrub phase, it will never be scrubbed.
	* To catch this, ddt_sync_entry() notifies the scrub code whenever a block's
	* reference class transitions to a higher level (i.e DDT_CLASS_UNIQUE to
	* DDT_CLASS_DUPLICATE); if it transitions from refcnt == 1 to refcnt > 1
	* while a scrub is in progress, it scrubs the block right then.
	*/
	static void
	dsl_scan_ddt(dsl_scan_t scn, dmu_tx_t tx)
	{
	ddt_bookmark_t *ddb = &scn->scn_phys.scn_ddt_bookmark;
	ddt_entry_t dde;
	int error;
	uint64_t n = 0;

	bzero(&dde, sizeof (ddt_entry_t));

	while ((error = ddt_walk(scn->scn_dp->dp_spa, ddb, &dde)) == 0) {
	ddt_t *ddt;

	if (ddb->ddb_class > scn->scn_phys.scn_ddt_class_max)
	break;
	dprintf("visiting ddb=%llu/%llu/%llu/%llx\n",
	(longlong_t)ddb->ddb_class,
	(longlong_t)ddb->ddb_type,
	(longlong_t)ddb->ddb_checksum,
	(longlong_t)ddb->ddb_cursor);

	/* There should be no pending changes to the dedup table */
	ddt = scn->scn_dp->dp_spa->spa_ddt[ddb->ddb_checksum];
	ASSERT(avl_first(&ddt->ddt_tree) == NULL);

	dsl_scan_ddt_entry(scn, ddb->ddb_checksum, &dde, tx);
	n++;

	if (dsl_scan_check_suspend(scn, NULL))
	break;
	}

	zfs_dbgmsg("scanned %llu ddt entries with class_max = %u; "
	"suspending=%u", (longlong_t)n,
	(int)scn->scn_phys.scn_ddt_class_max, (int)scn->scn_suspending);

	ASSERT(error == 0 \|\| error == ENOENT);
	ASSERT(error != ENOENT \|\|
	ddb->ddb_class > scn->scn_phys.scn_ddt_class_max);
	}

	static uint64_t
	dsl_scan_ds_maxtxg(dsl_dataset_t *ds)
	{
	uint64_t smt = ds->ds_dir->dd_pool->dp_scan->scn_phys.scn_max_txg;
	if (ds->ds_is_snapshot)
	return (MIN(smt, dsl_dataset_phys(ds)->ds_creation_txg));
	return (smt);
	}

	static void
	dsl_scan_visit(dsl_scan_t scn, dmu_tx_t tx)
	{
	scan_ds_t *sds;
	dsl_pool_t *dp = scn->scn_dp;

	if (scn->scn_phys.scn_ddt_bookmark.ddb_class <=
	scn->scn_phys.scn_ddt_class_max) {
	scn->scn_phys.scn_cur_min_txg = scn->scn_phys.scn_min_txg;
	scn->scn_phys.scn_cur_max_txg = scn->scn_phys.scn_max_txg;
	dsl_scan_ddt(scn, tx);
	if (scn->scn_suspending)
	return;
	}

	if (scn->scn_phys.scn_bookmark.zb_objset == DMU_META_OBJSET) {
	/* First do the MOS & ORIGIN */

	scn->scn_phys.scn_cur_min_txg = scn->scn_phys.scn_min_txg;
	scn->scn_phys.scn_cur_max_txg = scn->scn_phys.scn_max_txg;
	dsl_scan_visit_rootbp(scn, NULL,
	&dp->dp_meta_rootbp, tx);
	spa_set_rootblkptr(dp->dp_spa, &dp->dp_meta_rootbp);
	if (scn->scn_suspending)
	return;

	if (spa_version(dp->dp_spa) < SPA_VERSION_DSL_SCRUB) {
	VERIFY0(dmu_objset_find_dp(dp, dp->dp_root_dir_obj,
	enqueue_cb, NULL, DS_FIND_CHILDREN));
	} else {
	dsl_scan_visitds(scn,
	dp->dp_origin_snap->ds_object, tx);
	}
	ASSERT(!scn->scn_suspending);
	} else if (scn->scn_phys.scn_bookmark.zb_objset !=
	ZB_DESTROYED_OBJSET) {
	uint64_t dsobj = scn->scn_phys.scn_bookmark.zb_objset;
	/*
	* If we were suspended, continue from here. Note if the
	* ds we were suspended on was deleted, the zb_objset may
	* be -1, so we will skip this and find a new objset
	* below.
	*/
	dsl_scan_visitds(scn, dsobj, tx);
	if (scn->scn_suspending)
	return;
	}

	/*
	* In case we suspended right at the end of the ds, zero the
	* bookmark so we don't think that we're still trying to resume.
	*/
	bzero(&scn->scn_phys.scn_bookmark, sizeof (zbookmark_phys_t));

	/*
	* Keep pulling things out of the dataset avl queue. Updates to the
	* persistent zap-object-as-queue happen only at checkpoints.
	*/
	while ((sds = avl_first(&scn->scn_queue)) != NULL) {
	dsl_dataset_t *ds;
	uint64_t dsobj = sds->sds_dsobj;
	uint64_t txg = sds->sds_txg;

	/* dequeue and free the ds from the queue */
	scan_ds_queue_remove(scn, dsobj);
	sds = NULL;

	/* set up min / max txg */
	VERIFY3U(0, ==, dsl_dataset_hold_obj(dp, dsobj, FTAG, &ds));
	if (txg != 0) {
	scn->scn_phys.scn_cur_min_txg =
	MAX(scn->scn_phys.scn_min_txg, txg);
	} else {
	scn->scn_phys.scn_cur_min_txg =
	MAX(scn->scn_phys.scn_min_txg,
	dsl_dataset_phys(ds)->ds_prev_snap_txg);
	}
	scn->scn_phys.scn_cur_max_txg = dsl_scan_ds_maxtxg(ds);
	dsl_dataset_rele(ds, FTAG);

	dsl_scan_visitds(scn, dsobj, tx);
	if (scn->scn_suspending)
	return;
	}

	/* No more objsets to fetch, we're done */
	scn->scn_phys.scn_bookmark.zb_objset = ZB_DESTROYED_OBJSET;
	ASSERT0(scn->scn_suspending);
	}

	static uint64_t
	dsl_scan_count_leaves(vdev_t *vd)
	{
	uint64_t i, leaves = 0;

	/* we only count leaves that belong to the main pool and are readable */
	if (vd->vdev_islog \|\| vd->vdev_isspare \|\|
	vd->vdev_isl2cache \|\| !vdev_readable(vd))
	return (0);

	if (vd->vdev_ops->vdev_op_leaf)
	return (1);

	for (i = 0; i < vd->vdev_children; i++) {
	leaves += dsl_scan_count_leaves(vd->vdev_child[i]);
	}

	return (leaves);
	}

	static void
	scan_io_queues_update_zio_stats(dsl_scan_io_queue_t q, const blkptr_t bp)
	{
	int i;
	uint64_t cur_size = 0;

	for (i = 0; i < BP_GET_NDVAS(bp); i++) {
	cur_size += DVA_GET_ASIZE(&bp->blk_dva[i]);
	}

	q->q_total_zio_size_this_txg += cur_size;
	q->q_zios_this_txg++;
	}

	static void
	scan_io_queues_update_seg_stats(dsl_scan_io_queue_t *q, uint64_t start,
	uint64_t end)
	{
	q->q_total_seg_size_this_txg += end - start;
	q->q_segs_this_txg++;
	}

	static boolean_t
	scan_io_queue_check_suspend(dsl_scan_t *scn)
	{
	/* See comment in dsl_scan_check_suspend() */
	uint64_t curr_time_ns = gethrtime();
	uint64_t scan_time_ns = curr_time_ns - scn->scn_sync_start_time;
	uint64_t sync_time_ns = curr_time_ns -
	scn->scn_dp->dp_spa->spa_sync_starttime;
	int dirty_pct = scn->scn_dp->dp_dirty_total * 100 / zfs_dirty_data_max;
	int mintime = (scn->scn_phys.scn_func == POOL_SCAN_RESILVER) ?
	zfs_resilver_min_time_ms : zfs_scrub_min_time_ms;

	return ((NSEC2MSEC(scan_time_ns) > mintime &&
	(dirty_pct >= zfs_vdev_async_write_active_min_dirty_percent \|\|
	txg_sync_waiting(scn->scn_dp) \|\|
	NSEC2SEC(sync_time_ns) >= zfs_txg_timeout)) \|\|
	spa_shutting_down(scn->scn_dp->dp_spa));
	}

	/*
	* Given a list of scan_io_t's in io_list, this issues the I/Os out to
	* disk. This consumes the io_list and frees the scan_io_t's. This is
	* called when emptying queues, either when we're up against the memory
	* limit or when we have finished scanning. Returns B_TRUE if we stopped
	* processing the list before we finished. Any sios that were not issued
	* will remain in the io_list.
	*/
	static boolean_t
	scan_io_queue_issue(dsl_scan_io_queue_t queue, list_t io_list)
	{
	dsl_scan_t *scn = queue->q_scn;
	scan_io_t *sio;
	int64_t bytes_issued = 0;
	boolean_t suspended = B_FALSE;

	while ((sio = list_head(io_list)) != NULL) {
	blkptr_t bp;

	if (scan_io_queue_check_suspend(scn)) {
	suspended = B_TRUE;
	break;
	}

	sio2bp(sio, &bp);
	bytes_issued += SIO_GET_ASIZE(sio);
	scan_exec_io(scn->scn_dp, &bp, sio->sio_flags,
	&sio->sio_zb, queue);
	(void) list_remove_head(io_list);
	scan_io_queues_update_zio_stats(queue, &bp);
	sio_free(sio);
	}

	atomic_add_64(&scn->scn_bytes_pending, -bytes_issued);

	return (suspended);
	}

	/*
	* This function removes sios from an IO queue which reside within a given
	* range_seg_t and inserts them (in offset order) into a list. Note that
	* we only ever return a maximum of 32 sios at once. If there are more sios
	* to process within this segment that did not make it onto the list we
	* return B_TRUE and otherwise B_FALSE.
	*/
	static boolean_t
	scan_io_queue_gather(dsl_scan_io_queue_t queue, range_seg_t rs, list_t *list)
	{
	scan_io_t srch_sio, sio, *next_sio;
	avl_index_t idx;
	uint_t num_sios = 0;
	int64_t bytes_issued = 0;

	ASSERT(rs != NULL);
	ASSERT(MUTEX_HELD(&queue->q_vd->vdev_scan_io_queue_lock));

	srch_sio = sio_alloc(1);
	srch_sio->sio_nr_dvas = 1;
	SIO_SET_OFFSET(srch_sio, rs_get_start(rs, queue->q_exts_by_addr));

	/*
	* The exact start of the extent might not contain any matching zios,
	* so if that's the case, examine the next one in the tree.
	*/
	sio = avl_find(&queue->q_sios_by_addr, srch_sio, &idx);
	sio_free(srch_sio);

	if (sio == NULL)
	sio = avl_nearest(&queue->q_sios_by_addr, idx, AVL_AFTER);

	while (sio != NULL && SIO_GET_OFFSET(sio) < rs_get_end(rs,
	queue->q_exts_by_addr) && num_sios <= 32) {
	ASSERT3U(SIO_GET_OFFSET(sio), >=, rs_get_start(rs,
	queue->q_exts_by_addr));
	ASSERT3U(SIO_GET_END_OFFSET(sio), <=, rs_get_end(rs,
	queue->q_exts_by_addr));

	next_sio = AVL_NEXT(&queue->q_sios_by_addr, sio);
	avl_remove(&queue->q_sios_by_addr, sio);
	queue->q_sio_memused -= SIO_GET_MUSED(sio);

	bytes_issued += SIO_GET_ASIZE(sio);
	num_sios++;
	list_insert_tail(list, sio);
	sio = next_sio;
	}

	/*
	* We limit the number of sios we process at once to 32 to avoid
	* biting off more than we can chew. If we didn't take everything
	* in the segment we update it to reflect the work we were able to
	* complete. Otherwise, we remove it from the range tree entirely.
	*/
	if (sio != NULL && SIO_GET_OFFSET(sio) < rs_get_end(rs,
	queue->q_exts_by_addr)) {
	range_tree_adjust_fill(queue->q_exts_by_addr, rs,
	-bytes_issued);
	range_tree_resize_segment(queue->q_exts_by_addr, rs,
	SIO_GET_OFFSET(sio), rs_get_end(rs,
	queue->q_exts_by_addr) - SIO_GET_OFFSET(sio));

	return (B_TRUE);
	} else {
	uint64_t rstart = rs_get_start(rs, queue->q_exts_by_addr);
	uint64_t rend = rs_get_end(rs, queue->q_exts_by_addr);
	range_tree_remove(queue->q_exts_by_addr, rstart, rend - rstart);
	return (B_FALSE);
	}
	}

	/*
	* This is called from the queue emptying thread and selects the next
	* extent from which we are to issue I/Os. The behavior of this function
	* depends on the state of the scan, the current memory consumption and
	* whether or not we are performing a scan shutdown.
	* 1) We select extents in an elevator algorithm (LBA-order) if the scan
	* needs to perform a checkpoint
	* 2) We select the largest available extent if we are up against the
	* memory limit.
	* 3) Otherwise we don't select any extents.
	*/
	static range_seg_t *
	scan_io_queue_fetch_ext(dsl_scan_io_queue_t *queue)
	{
	dsl_scan_t *scn = queue->q_scn;
	range_tree_t *rt = queue->q_exts_by_addr;

	ASSERT(MUTEX_HELD(&queue->q_vd->vdev_scan_io_queue_lock));
	ASSERT(scn->scn_is_sorted);

	/* handle tunable overrides */
	if (scn->scn_checkpointing \|\| scn->scn_clearing) {
	if (zfs_scan_issue_strategy == 1) {
	return (range_tree_first(rt));
	} else if (zfs_scan_issue_strategy == 2) {
	/*
	* We need to get the original entry in the by_addr
	* tree so we can modify it.
	*/
	range_seg_t *size_rs =
	zfs_btree_first(&queue->q_exts_by_size, NULL);
	if (size_rs == NULL)
	return (NULL);
	uint64_t start = rs_get_start(size_rs, rt);
	uint64_t size = rs_get_end(size_rs, rt) - start;
	range_seg_t *addr_rs = range_tree_find(rt, start,
	size);
	ASSERT3P(addr_rs, !=, NULL);
	ASSERT3U(rs_get_start(size_rs, rt), ==,
	rs_get_start(addr_rs, rt));
	ASSERT3U(rs_get_end(size_rs, rt), ==,
	rs_get_end(addr_rs, rt));
	return (addr_rs);
	}
	}

	/*
	* During normal clearing, we want to issue our largest segments
	* first, keeping IO as sequential as possible, and leaving the
	* smaller extents for later with the hope that they might eventually
	* grow to larger sequential segments. However, when the scan is
	* checkpointing, no new extents will be added to the sorting queue,
	* so the way we are sorted now is as good as it will ever get.
	* In this case, we instead switch to issuing extents in LBA order.
	*/
	if (scn->scn_checkpointing) {
	return (range_tree_first(rt));
	} else if (scn->scn_clearing) {
	/*
	* We need to get the original entry in the by_addr
	* tree so we can modify it.
	*/
	range_seg_t *size_rs = zfs_btree_first(&queue->q_exts_by_size,
	NULL);
	if (size_rs == NULL)
	return (NULL);
	uint64_t start = rs_get_start(size_rs, rt);
	uint64_t size = rs_get_end(size_rs, rt) - start;
	range_seg_t *addr_rs = range_tree_find(rt, start, size);
	ASSERT3P(addr_rs, !=, NULL);
	ASSERT3U(rs_get_start(size_rs, rt), ==, rs_get_start(addr_rs,
	rt));
	ASSERT3U(rs_get_end(size_rs, rt), ==, rs_get_end(addr_rs, rt));
	return (addr_rs);
	} else {
	return (NULL);
	}
	}

	static void
	scan_io_queues_run_one(void *arg)
	{
	dsl_scan_io_queue_t *queue = arg;
	kmutex_t *q_lock = &queue->q_vd->vdev_scan_io_queue_lock;
	boolean_t suspended = B_FALSE;
	range_seg_t *rs = NULL;
	scan_io_t *sio = NULL;
	list_t sio_list;
	uint64_t bytes_per_leaf = zfs_scan_vdev_limit;
	uint64_t nr_leaves = dsl_scan_count_leaves(queue->q_vd);

	ASSERT(queue->q_scn->scn_is_sorted);

	list_create(&sio_list, sizeof (scan_io_t),
	offsetof(scan_io_t, sio_nodes.sio_list_node));
	mutex_enter(q_lock);

	/* calculate maximum in-flight bytes for this txg (min 1MB) */
	queue->q_maxinflight_bytes =
	MAX(nr_leaves * bytes_per_leaf, 1ULL << 20);

	/* reset per-queue scan statistics for this txg */
	queue->q_total_seg_size_this_txg = 0;
	queue->q_segs_this_txg = 0;
	queue->q_total_zio_size_this_txg = 0;
	queue->q_zios_this_txg = 0;

	/* loop until we run out of time or sios */
	while ((rs = scan_io_queue_fetch_ext(queue)) != NULL) {
	uint64_t seg_start = 0, seg_end = 0;
	boolean_t more_left = B_TRUE;

	ASSERT(list_is_empty(&sio_list));

	/* loop while we still have sios left to process in this rs */
	while (more_left) {
	scan_io_t first_sio, last_sio;

	/*
	* We have selected which extent needs to be
	* processed next. Gather up the corresponding sios.
	*/
	more_left = scan_io_queue_gather(queue, rs, &sio_list);
	ASSERT(!list_is_empty(&sio_list));
	first_sio = list_head(&sio_list);
	last_sio = list_tail(&sio_list);

	seg_end = SIO_GET_END_OFFSET(last_sio);
	if (seg_start == 0)
	seg_start = SIO_GET_OFFSET(first_sio);

	/*
	* Issuing sios can take a long time so drop the
	* queue lock. The sio queue won't be updated by
	* other threads since we're in syncing context so
	* we can be sure that our trees will remain exactly
	* as we left them.
	*/
	mutex_exit(q_lock);
	suspended = scan_io_queue_issue(queue, &sio_list);
	mutex_enter(q_lock);

	if (suspended)
	break;
	}

	/* update statistics for debugging purposes */
	scan_io_queues_update_seg_stats(queue, seg_start, seg_end);

	if (suspended)
	break;
	}

	/*
	* If we were suspended in the middle of processing,
	* requeue any unfinished sios and exit.
	*/
	while ((sio = list_head(&sio_list)) != NULL) {
	list_remove(&sio_list, sio);
	scan_io_queue_insert_impl(queue, sio);
	}

	mutex_exit(q_lock);
	list_destroy(&sio_list);
	}

	/*
	* Performs an emptying run on all scan queues in the pool. This just
	* punches out one thread per top-level vdev, each of which processes
	* only that vdev's scan queue. We can parallelize the I/O here because
	* we know that each queue's I/Os only affect its own top-level vdev.
	*
	* This function waits for the queue runs to complete, and must be
	* called from dsl_scan_sync (or in general, syncing context).
	*/
	static void
	scan_io_queues_run(dsl_scan_t *scn)
	{
	spa_t *spa = scn->scn_dp->dp_spa;

	ASSERT(scn->scn_is_sorted);
	ASSERT(spa_config_held(spa, SCL_CONFIG, RW_READER));

	if (scn->scn_bytes_pending == 0)
	return;

	if (scn->scn_taskq == NULL) {
	int nthreads = spa->spa_root_vdev->vdev_children;

	/*
	* We need to make this taskq always execute as many
	* threads in parallel as we have top-level vdevs and no
	* less, otherwise strange serialization of the calls to
	* scan_io_queues_run_one can occur during spa_sync runs
	* and that significantly impacts performance.
	*/
	scn->scn_taskq = taskq_create("dsl_scan_iss", nthreads,
	minclsyspri, nthreads, nthreads, TASKQ_PREPOPULATE);
	}

	for (uint64_t i = 0; i < spa->spa_root_vdev->vdev_children; i++) {
	vdev_t *vd = spa->spa_root_vdev->vdev_child[i];

	mutex_enter(&vd->vdev_scan_io_queue_lock);
	if (vd->vdev_scan_io_queue != NULL) {
	VERIFY(taskq_dispatch(scn->scn_taskq,
	scan_io_queues_run_one, vd->vdev_scan_io_queue,
	TQ_SLEEP) != TASKQID_INVALID);
	}
	mutex_exit(&vd->vdev_scan_io_queue_lock);
	}

	/*
	* Wait for the queues to finish issuing their IOs for this run
	* before we return. There may still be IOs in flight at this
	* point.
	*/
	taskq_wait(scn->scn_taskq);
	}

	static boolean_t
	dsl_scan_async_block_should_pause(dsl_scan_t *scn)
	{
	uint64_t elapsed_nanosecs;

	if (zfs_recover)
	return (B_FALSE);

	if (zfs_async_block_max_blocks != 0 &&
	scn->scn_visited_this_txg >= zfs_async_block_max_blocks) {
	return (B_TRUE);
	}

	if (zfs_max_async_dedup_frees != 0 &&
	scn->scn_dedup_frees_this_txg >= zfs_max_async_dedup_frees) {
	return (B_TRUE);
	}

	elapsed_nanosecs = gethrtime() - scn->scn_sync_start_time;
	return (elapsed_nanosecs / NANOSEC > zfs_txg_timeout \|\|
	(NSEC2MSEC(elapsed_nanosecs) > scn->scn_async_block_min_time_ms &&
	txg_sync_waiting(scn->scn_dp)) \|\|
	spa_shutting_down(scn->scn_dp->dp_spa));
	}

	static int
	dsl_scan_free_block_cb(void arg, const blkptr_t bp, dmu_tx_t *tx)
	{
	dsl_scan_t *scn = arg;

	if (!scn->scn_is_bptree \|\|
	(BP_GET_LEVEL(bp) == 0 && BP_GET_TYPE(bp) != DMU_OT_OBJSET)) {
	if (dsl_scan_async_block_should_pause(scn))
	return (SET_ERROR(ERESTART));
	}

	zio_nowait(zio_free_sync(scn->scn_zio_root, scn->scn_dp->dp_spa,
	dmu_tx_get_txg(tx), bp, 0));
	dsl_dir_diduse_space(tx->tx_pool->dp_free_dir, DD_USED_HEAD,
	-bp_get_dsize_sync(scn->scn_dp->dp_spa, bp),
	-BP_GET_PSIZE(bp), -BP_GET_UCSIZE(bp), tx);
	scn->scn_visited_this_txg++;
	if (BP_GET_DEDUP(bp))
	scn->scn_dedup_frees_this_txg++;
	return (0);
	}

	static void
	dsl_scan_update_stats(dsl_scan_t *scn)
	{
	spa_t *spa = scn->scn_dp->dp_spa;
	uint64_t i;
	uint64_t seg_size_total = 0, zio_size_total = 0;
	uint64_t seg_count_total = 0, zio_count_total = 0;

	for (i = 0; i < spa->spa_root_vdev->vdev_children; i++) {
	vdev_t *vd = spa->spa_root_vdev->vdev_child[i];
	dsl_scan_io_queue_t *queue = vd->vdev_scan_io_queue;

	if (queue == NULL)
	continue;

	seg_size_total += queue->q_total_seg_size_this_txg;
	zio_size_total += queue->q_total_zio_size_this_txg;
	seg_count_total += queue->q_segs_this_txg;
	zio_count_total += queue->q_zios_this_txg;
	}

	if (seg_count_total == 0 \|\| zio_count_total == 0) {
	scn->scn_avg_seg_size_this_txg = 0;
	scn->scn_avg_zio_size_this_txg = 0;
	scn->scn_segs_this_txg = 0;
	scn->scn_zios_this_txg = 0;
	return;
	}

	scn->scn_avg_seg_size_this_txg = seg_size_total / seg_count_total;
	scn->scn_avg_zio_size_this_txg = zio_size_total / zio_count_total;
	scn->scn_segs_this_txg = seg_count_total;
	scn->scn_zios_this_txg = zio_count_total;
	}

	static int
	bpobj_dsl_scan_free_block_cb(void arg, const blkptr_t bp, boolean_t bp_freed,
	dmu_tx_t *tx)
	{
	ASSERT(!bp_freed);
	return (dsl_scan_free_block_cb(arg, bp, tx));
	}

	static int
	dsl_scan_obsolete_block_cb(void arg, const blkptr_t bp, boolean_t bp_freed,
	dmu_tx_t *tx)
	{
	ASSERT(!bp_freed);
	dsl_scan_t *scn = arg;
	const dva_t *dva = &bp->blk_dva[0];

	if (dsl_scan_async_block_should_pause(scn))
	return (SET_ERROR(ERESTART));

	spa_vdev_indirect_mark_obsolete(scn->scn_dp->dp_spa,
	DVA_GET_VDEV(dva), DVA_GET_OFFSET(dva),
	DVA_GET_ASIZE(dva), tx);
	scn->scn_visited_this_txg++;
	return (0);
	}

	boolean_t
	dsl_scan_active(dsl_scan_t *scn)
	{
	spa_t *spa = scn->scn_dp->dp_spa;
	uint64_t used = 0, comp, uncomp;
	boolean_t clones_left;

	if (spa->spa_load_state != SPA_LOAD_NONE)
	return (B_FALSE);
	if (spa_shutting_down(spa))
	return (B_FALSE);
	if ((dsl_scan_is_running(scn) && !dsl_scan_is_paused_scrub(scn)) \|\|
	(scn->scn_async_destroying && !scn->scn_async_stalled))
	return (B_TRUE);

	if (spa_version(scn->scn_dp->dp_spa) >= SPA_VERSION_DEADLISTS) {
	(void) bpobj_space(&scn->scn_dp->dp_free_bpobj,
	&used, &comp, &uncomp);
	}
	clones_left = spa_livelist_delete_check(spa);
	return ((used != 0) \|\| (clones_left));
	}

	static boolean_t
	dsl_scan_check_deferred(vdev_t *vd)
	{
	boolean_t need_resilver = B_FALSE;

	for (int c = 0; c < vd->vdev_children; c++) {
	need_resilver \|=
	dsl_scan_check_deferred(vd->vdev_child[c]);
	}

	if (!vdev_is_concrete(vd) \|\| vd->vdev_aux \|\|
	!vd->vdev_ops->vdev_op_leaf)
	return (need_resilver);

	if (!vd->vdev_resilver_deferred)
	need_resilver = B_TRUE;

	return (need_resilver);
	}

	static boolean_t
	dsl_scan_need_resilver(spa_t spa, const dva_t dva, size_t psize,
	uint64_t phys_birth)
	{
	vdev_t *vd;

	vd = vdev_lookup_top(spa, DVA_GET_VDEV(dva));

	if (vd->vdev_ops == &vdev_indirect_ops) {
	/*
	* The indirect vdev can point to multiple
	* vdevs. For simplicity, always create
	* the resilver zio_t. zio_vdev_io_start()
	* will bypass the child resilver i/o's if
	* they are on vdevs that don't have DTL's.
	*/
	return (B_TRUE);
	}

	if (DVA_GET_GANG(dva)) {
	/*
	* Gang members may be spread across multiple
	* vdevs, so the best estimate we have is the
	* scrub range, which has already been checked.
	* XXX -- it would be better to change our
	* allocation policy to ensure that all
	* gang members reside on the same vdev.
	*/
	return (B_TRUE);
	}

	/*
	* Check if the top-level vdev must resilver this offset.
	* When the offset does not intersect with a dirty leaf DTL
	* then it may be possible to skip the resilver IO. The psize
	* is provided instead of asize to simplify the check for RAIDZ.
	*/
	if (!vdev_dtl_need_resilver(vd, dva, psize, phys_birth))
	return (B_FALSE);

	/*
	* Check that this top-level vdev has a device under it which
	* is resilvering and is not deferred.
	*/
	if (!dsl_scan_check_deferred(vd))
	return (B_FALSE);

	return (B_TRUE);
	}

	static int
	dsl_process_async_destroys(dsl_pool_t dp, dmu_tx_t tx)
	{
	dsl_scan_t *scn = dp->dp_scan;
	spa_t *spa = dp->dp_spa;
	int err = 0;

	if (spa_suspend_async_destroy(spa))
	return (0);

	if (zfs_free_bpobj_enabled &&
	spa_version(spa) >= SPA_VERSION_DEADLISTS) {
	scn->scn_is_bptree = B_FALSE;
	scn->scn_async_block_min_time_ms = zfs_free_min_time_ms;
	scn->scn_zio_root = zio_root(spa, NULL,
	NULL, ZIO_FLAG_MUSTSUCCEED);
	err = bpobj_iterate(&dp->dp_free_bpobj,
	bpobj_dsl_scan_free_block_cb, scn, tx);
	VERIFY0(zio_wait(scn->scn_zio_root));
	scn->scn_zio_root = NULL;

	if (err != 0 && err != ERESTART)
	zfs_panic_recover("error %u from bpobj_iterate()", err);
	}

	if (err == 0 && spa_feature_is_active(spa, SPA_FEATURE_ASYNC_DESTROY)) {
	ASSERT(scn->scn_async_destroying);
	scn->scn_is_bptree = B_TRUE;
	scn->scn_zio_root = zio_root(spa, NULL,
	NULL, ZIO_FLAG_MUSTSUCCEED);
	err = bptree_iterate(dp->dp_meta_objset,
	dp->dp_bptree_obj, B_TRUE, dsl_scan_free_block_cb, scn, tx);
	VERIFY0(zio_wait(scn->scn_zio_root));
	scn->scn_zio_root = NULL;

	if (err == EIO \|\| err == ECKSUM) {
	err = 0;
	} else if (err != 0 && err != ERESTART) {
	zfs_panic_recover("error %u from "
	"traverse_dataset_destroyed()", err);
	}

	if (bptree_is_empty(dp->dp_meta_objset, dp->dp_bptree_obj)) {
	/* finished; deactivate async destroy feature */
	spa_feature_decr(spa, SPA_FEATURE_ASYNC_DESTROY, tx);
	ASSERT(!spa_feature_is_active(spa,
	SPA_FEATURE_ASYNC_DESTROY));
	VERIFY0(zap_remove(dp->dp_meta_objset,
	DMU_POOL_DIRECTORY_OBJECT,
	DMU_POOL_BPTREE_OBJ, tx));
	VERIFY0(bptree_free(dp->dp_meta_objset,
	dp->dp_bptree_obj, tx));
	dp->dp_bptree_obj = 0;
	scn->scn_async_destroying = B_FALSE;
	scn->scn_async_stalled = B_FALSE;
	} else {
	/*
	* If we didn't make progress, mark the async
	* destroy as stalled, so that we will not initiate
	* a spa_sync() on its behalf. Note that we only
	* check this if we are not finished, because if the
	* bptree had no blocks for us to visit, we can
	* finish without "making progress".
	*/
	scn->scn_async_stalled =
	(scn->scn_visited_this_txg == 0);
	}
	}
	if (scn->scn_visited_this_txg) {
	zfs_dbgmsg("freed %llu blocks in %llums from "
	"free_bpobj/bptree txg %llu; err=%u",
	(longlong_t)scn->scn_visited_this_txg,
	(longlong_t)
	NSEC2MSEC(gethrtime() - scn->scn_sync_start_time),
	(longlong_t)tx->tx_txg, err);
	scn->scn_visited_this_txg = 0;
	scn->scn_dedup_frees_this_txg = 0;

	/*
	* Write out changes to the DDT that may be required as a
	* result of the blocks freed. This ensures that the DDT
	* is clean when a scrub/resilver runs.
	*/
	ddt_sync(spa, tx->tx_txg);
	}
	if (err != 0)
	return (err);
	if (dp->dp_free_dir != NULL && !scn->scn_async_destroying &&
	zfs_free_leak_on_eio &&
	(dsl_dir_phys(dp->dp_free_dir)->dd_used_bytes != 0 \|\|
	dsl_dir_phys(dp->dp_free_dir)->dd_compressed_bytes != 0 \|\|
	dsl_dir_phys(dp->dp_free_dir)->dd_uncompressed_bytes != 0)) {
	/*
	* We have finished background destroying, but there is still
	* some space left in the dp_free_dir. Transfer this leaked
	* space to the dp_leak_dir.
	*/
	if (dp->dp_leak_dir == NULL) {
	rrw_enter(&dp->dp_config_rwlock, RW_WRITER, FTAG);
	(void) dsl_dir_create_sync(dp, dp->dp_root_dir,
	LEAK_DIR_NAME, tx);
	VERIFY0(dsl_pool_open_special_dir(dp,
	LEAK_DIR_NAME, &dp->dp_leak_dir));
	rrw_exit(&dp->dp_config_rwlock, FTAG);
	}
	dsl_dir_diduse_space(dp->dp_leak_dir, DD_USED_HEAD,
	dsl_dir_phys(dp->dp_free_dir)->dd_used_bytes,
	dsl_dir_phys(dp->dp_free_dir)->dd_compressed_bytes,
	dsl_dir_phys(dp->dp_free_dir)->dd_uncompressed_bytes, tx);
	dsl_dir_diduse_space(dp->dp_free_dir, DD_USED_HEAD,
	-dsl_dir_phys(dp->dp_free_dir)->dd_used_bytes,
	-dsl_dir_phys(dp->dp_free_dir)->dd_compressed_bytes,
	-dsl_dir_phys(dp->dp_free_dir)->dd_uncompressed_bytes, tx);
	}

	if (dp->dp_free_dir != NULL && !scn->scn_async_destroying &&
	!spa_livelist_delete_check(spa)) {
	/* finished; verify that space accounting went to zero */
	ASSERT0(dsl_dir_phys(dp->dp_free_dir)->dd_used_bytes);
	ASSERT0(dsl_dir_phys(dp->dp_free_dir)->dd_compressed_bytes);
	ASSERT0(dsl_dir_phys(dp->dp_free_dir)->dd_uncompressed_bytes);
	}

	spa_notify_waiters(spa);

	EQUIV(bpobj_is_open(&dp->dp_obsolete_bpobj),
	0 == zap_contains(dp->dp_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
	DMU_POOL_OBSOLETE_BPOBJ));
	if (err == 0 && bpobj_is_open(&dp->dp_obsolete_bpobj)) {
	ASSERT(spa_feature_is_active(dp->dp_spa,
	SPA_FEATURE_OBSOLETE_COUNTS));

	scn->scn_is_bptree = B_FALSE;
	scn->scn_async_block_min_time_ms = zfs_obsolete_min_time_ms;
	err = bpobj_iterate(&dp->dp_obsolete_bpobj,
	dsl_scan_obsolete_block_cb, scn, tx);
	if (err != 0 && err != ERESTART)
	zfs_panic_recover("error %u from bpobj_iterate()", err);

	if (bpobj_is_empty(&dp->dp_obsolete_bpobj))
	dsl_pool_destroy_obsolete_bpobj(dp, tx);
	}
	return (0);
	}

	/*
	* This is the primary entry point for scans that is called from syncing
	* context. Scans must happen entirely during syncing context so that we
	* can guarantee that blocks we are currently scanning will not change out
	* from under us. While a scan is active, this function controls how quickly
	* transaction groups proceed, instead of the normal handling provided by
	* txg_sync_thread().
	*/
	void
	dsl_scan_sync(dsl_pool_t dp, dmu_tx_t tx)
	{
	int err = 0;
	dsl_scan_t *scn = dp->dp_scan;
	spa_t *spa = dp->dp_spa;
	state_sync_type_t sync_type = SYNC_OPTIONAL;

	if (spa->spa_resilver_deferred &&
	!spa_feature_is_active(dp->dp_spa, SPA_FEATURE_RESILVER_DEFER))
	spa_feature_incr(spa, SPA_FEATURE_RESILVER_DEFER, tx);

	/*
	* Check for scn_restart_txg before checking spa_load_state, so
	* that we can restart an old-style scan while the pool is being
	* imported (see dsl_scan_init). We also restart scans if there
	* is a deferred resilver and the user has manually disabled
	* deferred resilvers via the tunable.
	*/
	if (dsl_scan_restarting(scn, tx) \|\|
	(spa->spa_resilver_deferred && zfs_resilver_disable_defer)) {
	pool_scan_func_t func = POOL_SCAN_SCRUB;
	dsl_scan_done(scn, B_FALSE, tx);
	if (vdev_resilver_needed(spa->spa_root_vdev, NULL, NULL))
	func = POOL_SCAN_RESILVER;
	zfs_dbgmsg("restarting scan func=%u txg=%llu",
	func, (longlong_t)tx->tx_txg);
	dsl_scan_setup_sync(&func, tx);
	}

	/*
	* Only process scans in sync pass 1.
	*/
	if (spa_sync_pass(spa) > 1)
	return;

	/*
	* If the spa is shutting down, then stop scanning. This will
	* ensure that the scan does not dirty any new data during the
	* shutdown phase.
	*/
	if (spa_shutting_down(spa))
	return;

	/*
	* If the scan is inactive due to a stalled async destroy, try again.
	*/
	if (!scn->scn_async_stalled && !dsl_scan_active(scn))
	return;

	/* reset scan statistics */
	scn->scn_visited_this_txg = 0;
	scn->scn_dedup_frees_this_txg = 0;
	scn->scn_holes_this_txg = 0;
	scn->scn_lt_min_this_txg = 0;
	scn->scn_gt_max_this_txg = 0;
	scn->scn_ddt_contained_this_txg = 0;
	scn->scn_objsets_visited_this_txg = 0;
	scn->scn_avg_seg_size_this_txg = 0;
	scn->scn_segs_this_txg = 0;
	scn->scn_avg_zio_size_this_txg = 0;
	scn->scn_zios_this_txg = 0;
	scn->scn_suspending = B_FALSE;
	scn->scn_sync_start_time = gethrtime();
	spa->spa_scrub_active = B_TRUE;

	/*
	* First process the async destroys. If we suspend, don't do
	* any scrubbing or resilvering. This ensures that there are no
	* async destroys while we are scanning, so the scan code doesn't
	* have to worry about traversing it. It is also faster to free the
	* blocks than to scrub them.
	*/
	err = dsl_process_async_destroys(dp, tx);
	if (err != 0)
	return;

	if (!dsl_scan_is_running(scn) \|\| dsl_scan_is_paused_scrub(scn))
	return;

	/*
	* Wait a few txgs after importing to begin scanning so that
	* we can get the pool imported quickly.
	*/
	if (spa->spa_syncing_txg < spa->spa_first_txg + SCAN_IMPORT_WAIT_TXGS)
	return;

	/*
	* zfs_scan_suspend_progress can be set to disable scan progress.
	* We don't want to spin the txg_sync thread, so we add a delay
	* here to simulate the time spent doing a scan. This is mostly
	* useful for testing and debugging.
	*/
	if (zfs_scan_suspend_progress) {
	uint64_t scan_time_ns = gethrtime() - scn->scn_sync_start_time;
	int mintime = (scn->scn_phys.scn_func == POOL_SCAN_RESILVER) ?
	zfs_resilver_min_time_ms : zfs_scrub_min_time_ms;

	while (zfs_scan_suspend_progress &&
	!txg_sync_waiting(scn->scn_dp) &&
	!spa_shutting_down(scn->scn_dp->dp_spa) &&
	NSEC2MSEC(scan_time_ns) < mintime) {
	delay(hz);
	scan_time_ns = gethrtime() - scn->scn_sync_start_time;
	}
	return;
	}

	/*
	* It is possible to switch from unsorted to sorted at any time,
	* but afterwards the scan will remain sorted unless reloaded from
	* a checkpoint after a reboot.
	*/
	if (!zfs_scan_legacy) {
	scn->scn_is_sorted = B_TRUE;
	if (scn->scn_last_checkpoint == 0)
	scn->scn_last_checkpoint = ddi_get_lbolt();
	}

	/*
	* For sorted scans, determine what kind of work we will be doing
	* this txg based on our memory limitations and whether or not we
	* need to perform a checkpoint.
	*/
	if (scn->scn_is_sorted) {
	/*
	* If we are over our checkpoint interval, set scn_clearing
	* so that we can begin checkpointing immediately. The
	* checkpoint allows us to save a consistent bookmark
	* representing how much data we have scrubbed so far.
	* Otherwise, use the memory limit to determine if we should
	* scan for metadata or start issue scrub IOs. We accumulate
	* metadata until we hit our hard memory limit at which point
	* we issue scrub IOs until we are at our soft memory limit.
	*/
	if (scn->scn_checkpointing \|\|
	ddi_get_lbolt() - scn->scn_last_checkpoint >
	SEC_TO_TICK(zfs_scan_checkpoint_intval)) {
	if (!scn->scn_checkpointing)
	zfs_dbgmsg("begin scan checkpoint");

	scn->scn_checkpointing = B_TRUE;
	scn->scn_clearing = B_TRUE;
	} else {
	boolean_t should_clear = dsl_scan_should_clear(scn);
	if (should_clear && !scn->scn_clearing) {
	zfs_dbgmsg("begin scan clearing");
	scn->scn_clearing = B_TRUE;
	} else if (!should_clear && scn->scn_clearing) {
	zfs_dbgmsg("finish scan clearing");
	scn->scn_clearing = B_FALSE;
	}
	}
	} else {
	ASSERT0(scn->scn_checkpointing);
	ASSERT0(scn->scn_clearing);
	}

	if (!scn->scn_clearing && scn->scn_done_txg == 0) {
	/* Need to scan metadata for more blocks to scrub */
	dsl_scan_phys_t *scnp = &scn->scn_phys;
	taskqid_t prefetch_tqid;
	uint64_t bytes_per_leaf = zfs_scan_vdev_limit;
	uint64_t nr_leaves = dsl_scan_count_leaves(spa->spa_root_vdev);

	/*
	* Recalculate the max number of in-flight bytes for pool-wide
	* scanning operations (minimum 1MB). Limits for the issuing
	* phase are done per top-level vdev and are handled separately.
	*/
	scn->scn_maxinflight_bytes =
	MAX(nr_leaves * bytes_per_leaf, 1ULL << 20);

	if (scnp->scn_ddt_bookmark.ddb_class <=
	scnp->scn_ddt_class_max) {
	ASSERT(ZB_IS_ZERO(&scnp->scn_bookmark));
	zfs_dbgmsg("doing scan sync txg %llu; "
	"ddt bm=%llu/%llu/%llu/%llx",
	(longlong_t)tx->tx_txg,
	(longlong_t)scnp->scn_ddt_bookmark.ddb_class,
	(longlong_t)scnp->scn_ddt_bookmark.ddb_type,
	(longlong_t)scnp->scn_ddt_bookmark.ddb_checksum,
	(longlong_t)scnp->scn_ddt_bookmark.ddb_cursor);
	} else {
	zfs_dbgmsg("doing scan sync txg %llu; "
	"bm=%llu/%llu/%llu/%llu",
	(longlong_t)tx->tx_txg,
	(longlong_t)scnp->scn_bookmark.zb_objset,
	(longlong_t)scnp->scn_bookmark.zb_object,
	(longlong_t)scnp->scn_bookmark.zb_level,
	(longlong_t)scnp->scn_bookmark.zb_blkid);
	}

	scn->scn_zio_root = zio_root(dp->dp_spa, NULL,
	NULL, ZIO_FLAG_CANFAIL);

	scn->scn_prefetch_stop = B_FALSE;
	prefetch_tqid = taskq_dispatch(dp->dp_sync_taskq,
	dsl_scan_prefetch_thread, scn, TQ_SLEEP);
	ASSERT(prefetch_tqid != TASKQID_INVALID);

	dsl_pool_config_enter(dp, FTAG);
	dsl_scan_visit(scn, tx);
	dsl_pool_config_exit(dp, FTAG);

	mutex_enter(&dp->dp_spa->spa_scrub_lock);
	scn->scn_prefetch_stop = B_TRUE;
	cv_broadcast(&spa->spa_scrub_io_cv);
	mutex_exit(&dp->dp_spa->spa_scrub_lock);

	taskq_wait_id(dp->dp_sync_taskq, prefetch_tqid);
	(void) zio_wait(scn->scn_zio_root);
	scn->scn_zio_root = NULL;

	zfs_dbgmsg("scan visited %llu blocks in %llums "
	"(%llu os's, %llu holes, %llu < mintxg, "
	"%llu in ddt, %llu > maxtxg)",
	(longlong_t)scn->scn_visited_this_txg,
	(longlong_t)NSEC2MSEC(gethrtime() -
	scn->scn_sync_start_time),
	(longlong_t)scn->scn_objsets_visited_this_txg,
	(longlong_t)scn->scn_holes_this_txg,
	(longlong_t)scn->scn_lt_min_this_txg,
	(longlong_t)scn->scn_ddt_contained_this_txg,
	(longlong_t)scn->scn_gt_max_this_txg);

	if (!scn->scn_suspending) {
	ASSERT0(avl_numnodes(&scn->scn_queue));
	scn->scn_done_txg = tx->tx_txg + 1;
	if (scn->scn_is_sorted) {
	scn->scn_checkpointing = B_TRUE;
	scn->scn_clearing = B_TRUE;
	}
	zfs_dbgmsg("scan complete txg %llu",
	(longlong_t)tx->tx_txg);
	}
	} else if (scn->scn_is_sorted && scn->scn_bytes_pending != 0) {
	ASSERT(scn->scn_clearing);

	/* need to issue scrubbing IOs from per-vdev queues */
	scn->scn_zio_root = zio_root(dp->dp_spa, NULL,
	NULL, ZIO_FLAG_CANFAIL);
	scan_io_queues_run(scn);
	(void) zio_wait(scn->scn_zio_root);
	scn->scn_zio_root = NULL;

	/* calculate and dprintf the current memory usage */
	(void) dsl_scan_should_clear(scn);
	dsl_scan_update_stats(scn);

	zfs_dbgmsg("scan issued %llu blocks (%llu segs) in %llums "
	"(avg_block_size = %llu, avg_seg_size = %llu)",
	(longlong_t)scn->scn_zios_this_txg,
	(longlong_t)scn->scn_segs_this_txg,
	(longlong_t)NSEC2MSEC(gethrtime() -
	scn->scn_sync_start_time),
	(longlong_t)scn->scn_avg_zio_size_this_txg,
	(longlong_t)scn->scn_avg_seg_size_this_txg);
	} else if (scn->scn_done_txg != 0 && scn->scn_done_txg <= tx->tx_txg) {
	/* Finished with everything. Mark the scrub as complete */
	zfs_dbgmsg("scan issuing complete txg %llu",
	(longlong_t)tx->tx_txg);
	ASSERT3U(scn->scn_done_txg, !=, 0);
	ASSERT0(spa->spa_scrub_inflight);
	ASSERT0(scn->scn_bytes_pending);
	dsl_scan_done(scn, B_TRUE, tx);
	sync_type = SYNC_MANDATORY;
	}

	dsl_scan_sync_state(scn, tx, sync_type);
	}

	static void
	count_block(dsl_scan_t scn, zfs_all_blkstats_t zab, const blkptr_t *bp)
	{
	int i;

	/*
	* Don't count embedded bp's, since we already did the work of
	* scanning these when we scanned the containing block.
	*/
	if (BP_IS_EMBEDDED(bp))
	return;

	/*
	* Update the spa's stats on how many bytes we have issued.
	* Sequential scrubs create a zio for each DVA of the bp. Each
	* of these will include all DVAs for repair purposes, but the
	* zio code will only try the first one unless there is an issue.
	* Therefore, we should only count the first DVA for these IOs.
	*/
	if (scn->scn_is_sorted) {
	atomic_add_64(&scn->scn_dp->dp_spa->spa_scan_pass_issued,
	DVA_GET_ASIZE(&bp->blk_dva[0]));
	} else {
	spa_t *spa = scn->scn_dp->dp_spa;

	for (i = 0; i < BP_GET_NDVAS(bp); i++) {
	atomic_add_64(&spa->spa_scan_pass_issued,
	DVA_GET_ASIZE(&bp->blk_dva[i]));
	}
	}

	/*
	* If we resume after a reboot, zab will be NULL; don't record
	* incomplete stats in that case.
	*/
	if (zab == NULL)
	return;

	mutex_enter(&zab->zab_lock);

	for (i = 0; i < 4; i++) {
	int l = (i < 2) ? BP_GET_LEVEL(bp) : DN_MAX_LEVELS;
	int t = (i & 1) ? BP_GET_TYPE(bp) : DMU_OT_TOTAL;

	if (t & DMU_OT_NEWTYPE)
	t = DMU_OT_OTHER;
	zfs_blkstat_t *zb = &zab->zab_type[l][t];
	int equal;

	zb->zb_count++;
	zb->zb_asize += BP_GET_ASIZE(bp);
	zb->zb_lsize += BP_GET_LSIZE(bp);
	zb->zb_psize += BP_GET_PSIZE(bp);
	zb->zb_gangs += BP_COUNT_GANG(bp);

	switch (BP_GET_NDVAS(bp)) {
	case 2:
	if (DVA_GET_VDEV(&bp->blk_dva[0]) ==
	DVA_GET_VDEV(&bp->blk_dva[1]))
	zb->zb_ditto_2_of_2_samevdev++;
	break;
	case 3:
	equal = (DVA_GET_VDEV(&bp->blk_dva[0]) ==
	DVA_GET_VDEV(&bp->blk_dva[1])) +
	(DVA_GET_VDEV(&bp->blk_dva[0]) ==
	DVA_GET_VDEV(&bp->blk_dva[2])) +
	(DVA_GET_VDEV(&bp->blk_dva[1]) ==
	DVA_GET_VDEV(&bp->blk_dva[2]));
	if (equal == 1)
	zb->zb_ditto_2_of_3_samevdev++;
	else if (equal == 3)
	zb->zb_ditto_3_of_3_samevdev++;
	break;
	}
	}

	mutex_exit(&zab->zab_lock);
	}

	static void
	scan_io_queue_insert_impl(dsl_scan_io_queue_t queue, scan_io_t sio)
	{
	avl_index_t idx;
	int64_t asize = SIO_GET_ASIZE(sio);
	dsl_scan_t *scn = queue->q_scn;

	ASSERT(MUTEX_HELD(&queue->q_vd->vdev_scan_io_queue_lock));

	if (avl_find(&queue->q_sios_by_addr, sio, &idx) != NULL) {
	/* block is already scheduled for reading */
	atomic_add_64(&scn->scn_bytes_pending, -asize);
	sio_free(sio);
	return;
	}
	avl_insert(&queue->q_sios_by_addr, sio, idx);
	queue->q_sio_memused += SIO_GET_MUSED(sio);
	range_tree_add(queue->q_exts_by_addr, SIO_GET_OFFSET(sio), asize);
	}

	/*
	* Given all the info we got from our metadata scanning process, we
	* construct a scan_io_t and insert it into the scan sorting queue. The
	* I/O must already be suitable for us to process. This is controlled
	* by dsl_scan_enqueue().
	*/
	static void
	scan_io_queue_insert(dsl_scan_io_queue_t queue, const blkptr_t bp, int dva_i,
	int zio_flags, const zbookmark_phys_t *zb)
	{
	dsl_scan_t *scn = queue->q_scn;
	scan_io_t *sio = sio_alloc(BP_GET_NDVAS(bp));

	ASSERT0(BP_IS_GANG(bp));
	ASSERT(MUTEX_HELD(&queue->q_vd->vdev_scan_io_queue_lock));

	bp2sio(bp, sio, dva_i);
	sio->sio_flags = zio_flags;
	sio->sio_zb = *zb;

	/*
	* Increment the bytes pending counter now so that we can't
	* get an integer underflow in case the worker processes the
	* zio before we get to incrementing this counter.
	*/
	atomic_add_64(&scn->scn_bytes_pending, SIO_GET_ASIZE(sio));

	scan_io_queue_insert_impl(queue, sio);
	}

	/*
	* Given a set of I/O parameters as discovered by the metadata traversal
	* process, attempts to place the I/O into the sorted queues (if allowed),
	* or immediately executes the I/O.
	*/
	static void
	dsl_scan_enqueue(dsl_pool_t dp, const blkptr_t bp, int zio_flags,
	const zbookmark_phys_t *zb)
	{
	spa_t *spa = dp->dp_spa;

	ASSERT(!BP_IS_EMBEDDED(bp));

	/*
	* Gang blocks are hard to issue sequentially, so we just issue them
	* here immediately instead of queuing them.
	*/
	if (!dp->dp_scan->scn_is_sorted \|\| BP_IS_GANG(bp)) {
	scan_exec_io(dp, bp, zio_flags, zb, NULL);
	return;
	}

	for (int i = 0; i < BP_GET_NDVAS(bp); i++) {
	dva_t dva;
	vdev_t *vdev;

	dva = bp->blk_dva[i];
	vdev = vdev_lookup_top(spa, DVA_GET_VDEV(&dva));
	ASSERT(vdev != NULL);

	mutex_enter(&vdev->vdev_scan_io_queue_lock);
	if (vdev->vdev_scan_io_queue == NULL)
	vdev->vdev_scan_io_queue = scan_io_queue_create(vdev);
	ASSERT(dp->dp_scan != NULL);
	scan_io_queue_insert(vdev->vdev_scan_io_queue, bp,
	i, zio_flags, zb);
	mutex_exit(&vdev->vdev_scan_io_queue_lock);
	}
	}

	static int
	dsl_scan_scrub_cb(dsl_pool_t *dp,
	const blkptr_t bp, const zbookmark_phys_t zb)
	{
	dsl_scan_t *scn = dp->dp_scan;
	spa_t *spa = dp->dp_spa;
	uint64_t phys_birth = BP_PHYSICAL_BIRTH(bp);
	size_t psize = BP_GET_PSIZE(bp);
	boolean_t needs_io = B_FALSE;
	int zio_flags = ZIO_FLAG_SCAN_THREAD \| ZIO_FLAG_RAW \| ZIO_FLAG_CANFAIL;


	if (phys_birth <= scn->scn_phys.scn_min_txg \|\|
	phys_birth >= scn->scn_phys.scn_max_txg) {
	count_block(scn, dp->dp_blkstats, bp);
	return (0);
	}

	/* Embedded BP's have phys_birth==0, so we reject them above. */
	ASSERT(!BP_IS_EMBEDDED(bp));

	ASSERT(DSL_SCAN_IS_SCRUB_RESILVER(scn));
	if (scn->scn_phys.scn_func == POOL_SCAN_SCRUB) {
	zio_flags \|= ZIO_FLAG_SCRUB;
	needs_io = B_TRUE;
	} else {
	ASSERT3U(scn->scn_phys.scn_func, ==, POOL_SCAN_RESILVER);
	zio_flags \|= ZIO_FLAG_RESILVER;
	needs_io = B_FALSE;
	}

	/* If it's an intent log block, failure is expected. */
	if (zb->zb_level == ZB_ZIL_LEVEL)
	zio_flags \|= ZIO_FLAG_SPECULATIVE;

	for (int d = 0; d < BP_GET_NDVAS(bp); d++) {
	const dva_t *dva = &bp->blk_dva[d];

	/*
	* Keep track of how much data we've examined so that
	* zpool(8) status can make useful progress reports.
	*/
	scn->scn_phys.scn_examined += DVA_GET_ASIZE(dva);
	spa->spa_scan_pass_exam += DVA_GET_ASIZE(dva);

	/* if it's a resilver, this may not be in the target range */
	if (!needs_io)
	needs_io = dsl_scan_need_resilver(spa, dva, psize,
	phys_birth);
	}

	if (needs_io && !zfs_no_scrub_io) {
	dsl_scan_enqueue(dp, bp, zio_flags, zb);
	} else {
	count_block(scn, dp->dp_blkstats, bp);
	}

	/* do not relocate this block */
	return (0);
	}

	static void
	dsl_scan_scrub_done(zio_t *zio)
	{
	spa_t *spa = zio->io_spa;
	blkptr_t *bp = zio->io_bp;
	dsl_scan_io_queue_t *queue = zio->io_private;

	abd_free(zio->io_abd);

	if (queue == NULL) {
	mutex_enter(&spa->spa_scrub_lock);
	ASSERT3U(spa->spa_scrub_inflight, >=, BP_GET_PSIZE(bp));
	spa->spa_scrub_inflight -= BP_GET_PSIZE(bp);
	cv_broadcast(&spa->spa_scrub_io_cv);
	mutex_exit(&spa->spa_scrub_lock);
	} else {
	mutex_enter(&queue->q_vd->vdev_scan_io_queue_lock);
	ASSERT3U(queue->q_inflight_bytes, >=, BP_GET_PSIZE(bp));
	queue->q_inflight_bytes -= BP_GET_PSIZE(bp);
	cv_broadcast(&queue->q_zio_cv);
	mutex_exit(&queue->q_vd->vdev_scan_io_queue_lock);
	}

	if (zio->io_error && (zio->io_error != ECKSUM \|\|
	!(zio->io_flags & ZIO_FLAG_SPECULATIVE))) {
	atomic_inc_64(&spa->spa_dsl_pool->dp_scan->scn_phys.scn_errors);
	}
	}

	/*
	* Given a scanning zio's information, executes the zio. The zio need
	* not necessarily be only sortable, this function simply executes the
	* zio, no matter what it is. The optional queue argument allows the
	* caller to specify that they want per top level vdev IO rate limiting
	* instead of the legacy global limiting.
	*/
	static void
	scan_exec_io(dsl_pool_t dp, const blkptr_t bp, int zio_flags,
	const zbookmark_phys_t zb, dsl_scan_io_queue_t queue)
	{
	spa_t *spa = dp->dp_spa;
	dsl_scan_t *scn = dp->dp_scan;
	size_t size = BP_GET_PSIZE(bp);
	abd_t *data = abd_alloc_for_io(size, B_FALSE);

	ASSERT3U(scn->scn_maxinflight_bytes, >, 0);

	if (queue == NULL) {
	mutex_enter(&spa->spa_scrub_lock);
	while (spa->spa_scrub_inflight >= scn->scn_maxinflight_bytes)
	cv_wait(&spa->spa_scrub_io_cv, &spa->spa_scrub_lock);
	spa->spa_scrub_inflight += BP_GET_PSIZE(bp);
	mutex_exit(&spa->spa_scrub_lock);
	} else {
	kmutex_t *q_lock = &queue->q_vd->vdev_scan_io_queue_lock;

	mutex_enter(q_lock);
	while (queue->q_inflight_bytes >= queue->q_maxinflight_bytes)
	cv_wait(&queue->q_zio_cv, q_lock);
	queue->q_inflight_bytes += BP_GET_PSIZE(bp);
	mutex_exit(q_lock);
	}

	count_block(scn, dp->dp_blkstats, bp);
	zio_nowait(zio_read(scn->scn_zio_root, spa, bp, data, size,
	dsl_scan_scrub_done, queue, ZIO_PRIORITY_SCRUB, zio_flags, zb));
	}

	/*
	* This is the primary extent sorting algorithm. We balance two parameters:
	* 1) how many bytes of I/O are in an extent
	* 2) how well the extent is filled with I/O (as a fraction of its total size)
	* Since we allow extents to have gaps between their constituent I/Os, it's
	* possible to have a fairly large extent that contains the same amount of
	* I/O bytes than a much smaller extent, which just packs the I/O more tightly.
	* The algorithm sorts based on a score calculated from the extent's size,
	* the relative fill volume (in %) and a "fill weight" parameter that controls
	* the split between whether we prefer larger extents or more well populated
	* extents:
	*
	* SCORE = FILL_IN_BYTES + (FILL_IN_PERCENT * FILL_IN_BYTES * FILL_WEIGHT)
	*
	* Example:
	* 1) assume extsz = 64 MiB
	* 2) assume fill = 32 MiB (extent is half full)
	* 3) assume fill_weight = 3
	* 4) SCORE = 32M + (((32M * 100) / 64M) * 3 * 32M) / 100
	* SCORE = 32M + (50 * 3 * 32M) / 100
	* SCORE = 32M + (4800M / 100)
	* SCORE = 32M + 48M
	* ^ ^
	* \| +--- final total relative fill-based score
	* +--------- final total fill-based score
	* SCORE = 80M
	*
	* As can be seen, at fill_ratio=3, the algorithm is slightly biased towards
	* extents that are more completely filled (in a 3:2 ratio) vs just larger.
	* Note that as an optimization, we replace multiplication and division by
	* 100 with bitshifting by 7 (which effectively multiplies and divides by 128).
	*/
	static int
	ext_size_compare(const void x, const void y)
	{
	const range_seg_gap_t rsa = x, rsb = y;

	uint64_t sa = rsa->rs_end - rsa->rs_start;
	uint64_t sb = rsb->rs_end - rsb->rs_start;
	uint64_t score_a, score_b;

	score_a = rsa->rs_fill + ((((rsa->rs_fill << 7) / sa) *
	fill_weight * rsa->rs_fill) >> 7);
	score_b = rsb->rs_fill + ((((rsb->rs_fill << 7) / sb) *
	fill_weight * rsb->rs_fill) >> 7);

	if (score_a > score_b)
	return (-1);
	if (score_a == score_b) {
	if (rsa->rs_start < rsb->rs_start)
	return (-1);
	if (rsa->rs_start == rsb->rs_start)
	return (0);
	return (1);
	}
	return (1);
	}

	/*
	* Comparator for the q_sios_by_addr tree. Sorting is simply performed
	* based on LBA-order (from lowest to highest).
	*/
	static int
	sio_addr_compare(const void x, const void y)
	{
	const scan_io_t a = x, b = y;

	return (TREE_CMP(SIO_GET_OFFSET(a), SIO_GET_OFFSET(b)));
	}

	/* IO queues are created on demand when they are needed. */
	static dsl_scan_io_queue_t *
	scan_io_queue_create(vdev_t *vd)
	{
	dsl_scan_t *scn = vd->vdev_spa->spa_dsl_pool->dp_scan;
	dsl_scan_io_queue_t q = kmem_zalloc(sizeof (q), KM_SLEEP);

	q->q_scn = scn;
	q->q_vd = vd;
	q->q_sio_memused = 0;
	cv_init(&q->q_zio_cv, NULL, CV_DEFAULT, NULL);
	q->q_exts_by_addr = range_tree_create_impl(&rt_btree_ops, RANGE_SEG_GAP,
	&q->q_exts_by_size, 0, 0, ext_size_compare, zfs_scan_max_ext_gap);
	avl_create(&q->q_sios_by_addr, sio_addr_compare,
	sizeof (scan_io_t), offsetof(scan_io_t, sio_nodes.sio_addr_node));

	return (q);
	}

	/*
	* Destroys a scan queue and all segments and scan_io_t's contained in it.
	* No further execution of I/O occurs, anything pending in the queue is
	* simply freed without being executed.
	*/
	void
	dsl_scan_io_queue_destroy(dsl_scan_io_queue_t *queue)
	{
	dsl_scan_t *scn = queue->q_scn;
	scan_io_t *sio;
	void *cookie = NULL;
	int64_t bytes_dequeued = 0;

	ASSERT(MUTEX_HELD(&queue->q_vd->vdev_scan_io_queue_lock));

	while ((sio = avl_destroy_nodes(&queue->q_sios_by_addr, &cookie)) !=
	NULL) {
	ASSERT(range_tree_contains(queue->q_exts_by_addr,
	SIO_GET_OFFSET(sio), SIO_GET_ASIZE(sio)));
	bytes_dequeued += SIO_GET_ASIZE(sio);
	queue->q_sio_memused -= SIO_GET_MUSED(sio);
	sio_free(sio);
	}

	ASSERT0(queue->q_sio_memused);
	atomic_add_64(&scn->scn_bytes_pending, -bytes_dequeued);
	range_tree_vacate(queue->q_exts_by_addr, NULL, queue);
	range_tree_destroy(queue->q_exts_by_addr);
	avl_destroy(&queue->q_sios_by_addr);
	cv_destroy(&queue->q_zio_cv);

	kmem_free(queue, sizeof (*queue));
	}

	/*
	* Properly transfers a dsl_scan_queue_t from `svd' to `tvd'. This is
	* called on behalf of vdev_top_transfer when creating or destroying
	* a mirror vdev due to zpool attach/detach.
	*/
	void
	dsl_scan_io_queue_vdev_xfer(vdev_t svd, vdev_t tvd)
	{
	mutex_enter(&svd->vdev_scan_io_queue_lock);
	mutex_enter(&tvd->vdev_scan_io_queue_lock);

	VERIFY3P(tvd->vdev_scan_io_queue, ==, NULL);
	tvd->vdev_scan_io_queue = svd->vdev_scan_io_queue;
	svd->vdev_scan_io_queue = NULL;
	if (tvd->vdev_scan_io_queue != NULL)
	tvd->vdev_scan_io_queue->q_vd = tvd;

	mutex_exit(&tvd->vdev_scan_io_queue_lock);
	mutex_exit(&svd->vdev_scan_io_queue_lock);
	}

	static void
	scan_io_queues_destroy(dsl_scan_t *scn)
	{
	vdev_t *rvd = scn->scn_dp->dp_spa->spa_root_vdev;

	for (uint64_t i = 0; i < rvd->vdev_children; i++) {
	vdev_t *tvd = rvd->vdev_child[i];

	mutex_enter(&tvd->vdev_scan_io_queue_lock);
	if (tvd->vdev_scan_io_queue != NULL)
	dsl_scan_io_queue_destroy(tvd->vdev_scan_io_queue);
	tvd->vdev_scan_io_queue = NULL;
	mutex_exit(&tvd->vdev_scan_io_queue_lock);
	}
	}

	static void
	dsl_scan_freed_dva(spa_t spa, const blkptr_t bp, int dva_i)
	{
	dsl_pool_t *dp = spa->spa_dsl_pool;
	dsl_scan_t *scn = dp->dp_scan;
	vdev_t *vdev;
	kmutex_t *q_lock;
	dsl_scan_io_queue_t *queue;
	scan_io_t srch_sio, sio;
	avl_index_t idx;
	uint64_t start, size;

	vdev = vdev_lookup_top(spa, DVA_GET_VDEV(&bp->blk_dva[dva_i]));
	ASSERT(vdev != NULL);
	q_lock = &vdev->vdev_scan_io_queue_lock;
	queue = vdev->vdev_scan_io_queue;

	mutex_enter(q_lock);
	if (queue == NULL) {
	mutex_exit(q_lock);
	return;
	}

	srch_sio = sio_alloc(BP_GET_NDVAS(bp));
	bp2sio(bp, srch_sio, dva_i);
	start = SIO_GET_OFFSET(srch_sio);
	size = SIO_GET_ASIZE(srch_sio);

	/*
	* We can find the zio in two states:
	* 1) Cold, just sitting in the queue of zio's to be issued at
	* some point in the future. In this case, all we do is
	* remove the zio from the q_sios_by_addr tree, decrement
	* its data volume from the containing range_seg_t and
	* resort the q_exts_by_size tree to reflect that the
	* range_seg_t has lost some of its 'fill'. We don't shorten
	* the range_seg_t - this is usually rare enough not to be
	* worth the extra hassle of trying keep track of precise
	* extent boundaries.
	* 2) Hot, where the zio is currently in-flight in
	* dsl_scan_issue_ios. In this case, we can't simply
	* reach in and stop the in-flight zio's, so we instead
	* block the caller. Eventually, dsl_scan_issue_ios will
	* be done with issuing the zio's it gathered and will
	* signal us.
	*/
	sio = avl_find(&queue->q_sios_by_addr, srch_sio, &idx);
	sio_free(srch_sio);

	if (sio != NULL) {
	int64_t asize = SIO_GET_ASIZE(sio);
	blkptr_t tmpbp;

	/* Got it while it was cold in the queue */
	ASSERT3U(start, ==, SIO_GET_OFFSET(sio));
	ASSERT3U(size, ==, asize);
	avl_remove(&queue->q_sios_by_addr, sio);
	queue->q_sio_memused -= SIO_GET_MUSED(sio);

	ASSERT(range_tree_contains(queue->q_exts_by_addr, start, size));
	range_tree_remove_fill(queue->q_exts_by_addr, start, size);

	/*
	* We only update scn_bytes_pending in the cold path,
	* otherwise it will already have been accounted for as
	* part of the zio's execution.
	*/
	atomic_add_64(&scn->scn_bytes_pending, -asize);

	/* count the block as though we issued it */
	sio2bp(sio, &tmpbp);
	count_block(scn, dp->dp_blkstats, &tmpbp);

	sio_free(sio);
	}
	mutex_exit(q_lock);
	}

	/*
	* Callback invoked when a zio_free() zio is executing. This needs to be
	* intercepted to prevent the zio from deallocating a particular portion
	* of disk space and it then getting reallocated and written to, while we
	* still have it queued up for processing.
	*/
	void
	dsl_scan_freed(spa_t spa, const blkptr_t bp)
	{
	dsl_pool_t *dp = spa->spa_dsl_pool;
	dsl_scan_t *scn = dp->dp_scan;

	ASSERT(!BP_IS_EMBEDDED(bp));
	ASSERT(scn != NULL);
	if (!dsl_scan_is_running(scn))
	return;

	for (int i = 0; i < BP_GET_NDVAS(bp); i++)
	dsl_scan_freed_dva(spa, bp, i);
	}

	/*
	* Check if a vdev needs resilvering (non-empty DTL), if so, and resilver has
	* not started, start it. Otherwise, only restart if max txg in DTL range is
	* greater than the max txg in the current scan. If the DTL max is less than
	* the scan max, then the vdev has not missed any new data since the resilver
	* started, so a restart is not needed.
	*/
	void
	dsl_scan_assess_vdev(dsl_pool_t dp, vdev_t vd)
	{
	uint64_t min, max;

	if (!vdev_resilver_needed(vd, &min, &max))
	return;

	if (!dsl_scan_resilvering(dp)) {
	spa_async_request(dp->dp_spa, SPA_ASYNC_RESILVER);
	return;
	}

	if (max <= dp->dp_scan->scn_phys.scn_max_txg)
	return;

	/* restart is needed, check if it can be deferred */
	if (spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_RESILVER_DEFER))
	vdev_defer_resilver(vd);
	else
	spa_async_request(dp->dp_spa, SPA_ASYNC_RESILVER);
	}

	/* BEGIN CSTYLED */
	ZFS_MODULE_PARAM(zfs, zfs_, scan_vdev_limit, ULONG, ZMOD_RW,
	"Max bytes in flight per leaf vdev for scrubs and resilvers");

	ZFS_MODULE_PARAM(zfs, zfs_, scrub_min_time_ms, INT, ZMOD_RW,
	"Min millisecs to scrub per txg");

	ZFS_MODULE_PARAM(zfs, zfs_, obsolete_min_time_ms, INT, ZMOD_RW,
	"Min millisecs to obsolete per txg");

	ZFS_MODULE_PARAM(zfs, zfs_, free_min_time_ms, INT, ZMOD_RW,
	"Min millisecs to free per txg");

	ZFS_MODULE_PARAM(zfs, zfs_, resilver_min_time_ms, INT, ZMOD_RW,
	"Min millisecs to resilver per txg");

	ZFS_MODULE_PARAM(zfs, zfs_, scan_suspend_progress, INT, ZMOD_RW,
	"Set to prevent scans from progressing");

	ZFS_MODULE_PARAM(zfs, zfs_, no_scrub_io, INT, ZMOD_RW,
	"Set to disable scrub I/O");

	ZFS_MODULE_PARAM(zfs, zfs_, no_scrub_prefetch, INT, ZMOD_RW,
	"Set to disable scrub prefetching");

	ZFS_MODULE_PARAM(zfs, zfs_, async_block_max_blocks, ULONG, ZMOD_RW,
	"Max number of blocks freed in one txg");

	ZFS_MODULE_PARAM(zfs, zfs_, max_async_dedup_frees, ULONG, ZMOD_RW,
	"Max number of dedup blocks freed in one txg");

	ZFS_MODULE_PARAM(zfs, zfs_, free_bpobj_enabled, INT, ZMOD_RW,
	"Enable processing of the free_bpobj");

	ZFS_MODULE_PARAM(zfs, zfs_, scan_mem_lim_fact, INT, ZMOD_RW,
	"Fraction of RAM for scan hard limit");

	ZFS_MODULE_PARAM(zfs, zfs_, scan_issue_strategy, INT, ZMOD_RW,
	"IO issuing strategy during scrubbing. "
	"0 = default, 1 = LBA, 2 = size");

	ZFS_MODULE_PARAM(zfs, zfs_, scan_legacy, INT, ZMOD_RW,
	"Scrub using legacy non-sequential method");

	ZFS_MODULE_PARAM(zfs, zfs_, scan_checkpoint_intval, INT, ZMOD_RW,
	"Scan progress on-disk checkpointing interval");

	ZFS_MODULE_PARAM(zfs, zfs_, scan_max_ext_gap, ULONG, ZMOD_RW,
	"Max gap in bytes between sequential scrub / resilver I/Os");

	ZFS_MODULE_PARAM(zfs, zfs_, scan_mem_lim_soft_fact, INT, ZMOD_RW,
	"Fraction of hard limit used as soft limit");

	ZFS_MODULE_PARAM(zfs, zfs_, scan_strict_mem_lim, INT, ZMOD_RW,
	"Tunable to attempt to reduce lock contention");

	ZFS_MODULE_PARAM(zfs, zfs_, scan_fill_weight, INT, ZMOD_RW,
	"Tunable to adjust bias towards more filled segments during scans");

	ZFS_MODULE_PARAM(zfs, zfs_, resilver_disable_defer, INT, ZMOD_RW,
	"Process all resilvers immediately");
	/* END CSTYLED */
	diff --git a/sys/contrib/openzfs/module/zfs/fm.c b/sys/contrib/openzfs/module/zfs/fm.c
	index 3070cab1e49d..dff7d8ece4be 100644
	--- a/sys/contrib/openzfs/module/zfs/fm.c
	+++ b/sys/contrib/openzfs/module/zfs/fm.c
	@@ -1,1685 +1,1368 @@
	/*
	* 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) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
	*/

	/*
	* Fault Management Architecture (FMA) Resource and Protocol Support
	*
	* The routines contained herein provide services to support kernel subsystems
	* in publishing fault management telemetry (see PSARC 2002/412 and 2003/089).
	*
	* Name-Value Pair Lists
	*
	* The embodiment of an FMA protocol element (event, fmri or authority) is a
	* name-value pair list (nvlist_t). FMA-specific nvlist constructor and
	* destructor functions, fm_nvlist_create() and fm_nvlist_destroy(), are used
	* to create an nvpair list using custom allocators. Callers may choose to
	* allocate either from the kernel memory allocator, or from a preallocated
	* buffer, useful in constrained contexts like high-level interrupt routines.
	*
	* Protocol Event and FMRI Construction
	*
	* Convenience routines are provided to construct nvlist events according to
	* the FMA Event Protocol and Naming Schema specification for ereports and
	* FMRIs for the dev, cpu, hc, mem, legacy hc and de schemes.
	*
	* ENA Manipulation
	*
	* Routines to generate ENA formats 0, 1 and 2 are available as well as
	* routines to increment formats 1 and 2. Individual fields within the
	* ENA are extractable via fm_ena_time_get(), fm_ena_id_get(),
	* fm_ena_format_get() and fm_ena_gen_get().
	*/

	#include <sys/types.h>
	#include <sys/time.h>
	#include <sys/list.h>
	#include <sys/nvpair.h>
	#include <sys/cmn_err.h>
	#include <sys/sysmacros.h>
	#include <sys/sunddi.h>
	#include <sys/systeminfo.h>
	#include <sys/fm/util.h>
	#include <sys/fm/protocol.h>
	#include <sys/kstat.h>
	#include <sys/zfs_context.h>
	#ifdef _KERNEL
	#include <sys/atomic.h>
	#include <sys/condvar.h>
	-#include <sys/console.h>
	#include <sys/zfs_ioctl.h>

	-int zfs_zevent_len_max = 0;
	-int zfs_zevent_cols = 80;
	-int zfs_zevent_console = 0;
	+int zfs_zevent_len_max = 512;

	static int zevent_len_cur = 0;
	static int zevent_waiters = 0;
	static int zevent_flags = 0;

	/* Num events rate limited since the last time zfs_zevent_next() was called */
	static uint64_t ratelimit_dropped = 0;

	/*
	* The EID (Event IDentifier) is used to uniquely tag a zevent when it is
	* posted. The posted EIDs are monotonically increasing but not persistent.
	* They will be reset to the initial value (1) each time the kernel module is
	* loaded.
	*/
	static uint64_t zevent_eid = 0;

	static kmutex_t zevent_lock;
	static list_t zevent_list;
	static kcondvar_t zevent_cv;
	#endif /* _KERNEL */


	/*
	* Common fault management kstats to record event generation failures
	*/

	struct erpt_kstat {
	kstat_named_t erpt_dropped; /* num erpts dropped on post */
	kstat_named_t erpt_set_failed; /* num erpt set failures */
	kstat_named_t fmri_set_failed; /* num fmri set failures */
	kstat_named_t payload_set_failed; /* num payload set failures */
	kstat_named_t erpt_duplicates; /* num duplicate erpts */
	};

	static struct erpt_kstat erpt_kstat_data = {
	{ "erpt-dropped", KSTAT_DATA_UINT64 },
	{ "erpt-set-failed", KSTAT_DATA_UINT64 },
	{ "fmri-set-failed", KSTAT_DATA_UINT64 },
	{ "payload-set-failed", KSTAT_DATA_UINT64 },
	{ "erpt-duplicates", KSTAT_DATA_UINT64 }
	};

	kstat_t *fm_ksp;

	#ifdef _KERNEL

	-/*
	- * Formatting utility function for fm_nvprintr. We attempt to wrap chunks of
	- * output so they aren't split across console lines, and return the end column.
	- */
	-/PRINTFLIKE4/
	-static int
	-fm_printf(int depth, int c, int cols, const char *format, ...)
	-{
	- va_list ap;
	- int width;
	- char c1;
	-
	- va_start(ap, format);
	- width = vsnprintf(&c1, sizeof (c1), format, ap);
	- va_end(ap);
	-
	- if (c + width >= cols) {
	- console_printf("\n");
	- c = 0;
	- if (format[0] != ' ' && depth > 0) {
	- console_printf(" ");
	- c++;
	- }
	- }
	-
	- va_start(ap, format);
	- console_vprintf(format, ap);
	- va_end(ap);
	-
	- return ((c + width) % cols);
	-}
	-
	-/*
	- * Recursively print an nvlist in the specified column width and return the
	- * column we end up in. This function is called recursively by fm_nvprint(),
	- * below. We generically format the entire nvpair using hexadecimal
	- * integers and strings, and elide any integer arrays. Arrays are basically
	- * used for cache dumps right now, so we suppress them so as not to overwhelm
	- * the amount of console output we produce at panic time. This can be further
	- * enhanced as FMA technology grows based upon the needs of consumers. All
	- * FMA telemetry is logged using the dump device transport, so the console
	- * output serves only as a fallback in case this procedure is unsuccessful.
	- */
	-static int
	-fm_nvprintr(nvlist_t *nvl, int d, int c, int cols)
	-{
	- nvpair_t *nvp;
	-
	- for (nvp = nvlist_next_nvpair(nvl, NULL);
	- nvp != NULL; nvp = nvlist_next_nvpair(nvl, nvp)) {
	-
	- data_type_t type = nvpair_type(nvp);
	- const char *name = nvpair_name(nvp);
	-
	- boolean_t b;
	- uint8_t i8;
	- uint16_t i16;
	- uint32_t i32;
	- uint64_t i64;
	- char *str;
	- nvlist_t *cnv;
	-
	- if (strcmp(name, FM_CLASS) == 0)
	- continue; /* already printed by caller */
	-
	- c = fm_printf(d, c, cols, " %s=", name);
	-
	- switch (type) {
	- case DATA_TYPE_BOOLEAN:
	- c = fm_printf(d + 1, c, cols, " 1");
	- break;
	-
	- case DATA_TYPE_BOOLEAN_VALUE:
	- (void) nvpair_value_boolean_value(nvp, &b);
	- c = fm_printf(d + 1, c, cols, b ? "1" : "0");
	- break;
	-
	- case DATA_TYPE_BYTE:
	- (void) nvpair_value_byte(nvp, &i8);
	- c = fm_printf(d + 1, c, cols, "0x%x", i8);
	- break;
	-
	- case DATA_TYPE_INT8:
	- (void) nvpair_value_int8(nvp, (void *)&i8);
	- c = fm_printf(d + 1, c, cols, "0x%x", i8);
	- break;
	-
	- case DATA_TYPE_UINT8:
	- (void) nvpair_value_uint8(nvp, &i8);
	- c = fm_printf(d + 1, c, cols, "0x%x", i8);
	- break;
	-
	- case DATA_TYPE_INT16:
	- (void) nvpair_value_int16(nvp, (void *)&i16);
	- c = fm_printf(d + 1, c, cols, "0x%x", i16);
	- break;
	-
	- case DATA_TYPE_UINT16:
	- (void) nvpair_value_uint16(nvp, &i16);
	- c = fm_printf(d + 1, c, cols, "0x%x", i16);
	- break;
	-
	- case DATA_TYPE_INT32:
	- (void) nvpair_value_int32(nvp, (void *)&i32);
	- c = fm_printf(d + 1, c, cols, "0x%x", i32);
	- break;
	-
	- case DATA_TYPE_UINT32:
	- (void) nvpair_value_uint32(nvp, &i32);
	- c = fm_printf(d + 1, c, cols, "0x%x", i32);
	- break;
	-
	- case DATA_TYPE_INT64:
	- (void) nvpair_value_int64(nvp, (void *)&i64);
	- c = fm_printf(d + 1, c, cols, "0x%llx",
	- (u_longlong_t)i64);
	- break;
	-
	- case DATA_TYPE_UINT64:
	- (void) nvpair_value_uint64(nvp, &i64);
	- c = fm_printf(d + 1, c, cols, "0x%llx",
	- (u_longlong_t)i64);
	- break;
	-
	- case DATA_TYPE_HRTIME:
	- (void) nvpair_value_hrtime(nvp, (void *)&i64);
	- c = fm_printf(d + 1, c, cols, "0x%llx",
	- (u_longlong_t)i64);
	- break;
	-
	- case DATA_TYPE_STRING:
	- (void) nvpair_value_string(nvp, &str);
	- c = fm_printf(d + 1, c, cols, "\"%s\"",
	- str ? str : "<NULL>");
	- break;
	-
	- case DATA_TYPE_NVLIST:
	- c = fm_printf(d + 1, c, cols, "[");
	- (void) nvpair_value_nvlist(nvp, &cnv);
	- c = fm_nvprintr(cnv, d + 1, c, cols);
	- c = fm_printf(d + 1, c, cols, " ]");
	- break;
	-
	- case DATA_TYPE_NVLIST_ARRAY: {
	- nvlist_t **val;
	- uint_t i, nelem;
	-
	- c = fm_printf(d + 1, c, cols, "[");
	- (void) nvpair_value_nvlist_array(nvp, &val, &nelem);
	- for (i = 0; i < nelem; i++) {
	- c = fm_nvprintr(val[i], d + 1, c, cols);
	- }
	- c = fm_printf(d + 1, c, cols, " ]");
	- }
	- break;
	-
	- case DATA_TYPE_INT8_ARRAY: {
	- int8_t *val;
	- uint_t i, nelem;
	-
	- c = fm_printf(d + 1, c, cols, "[ ");
	- (void) nvpair_value_int8_array(nvp, &val, &nelem);
	- for (i = 0; i < nelem; i++)
	- c = fm_printf(d + 1, c, cols, "0x%llx ",
	- (u_longlong_t)val[i]);
	-
	- c = fm_printf(d + 1, c, cols, "]");
	- break;
	- }
	-
	- case DATA_TYPE_UINT8_ARRAY: {
	- uint8_t *val;
	- uint_t i, nelem;
	-
	- c = fm_printf(d + 1, c, cols, "[ ");
	- (void) nvpair_value_uint8_array(nvp, &val, &nelem);
	- for (i = 0; i < nelem; i++)
	- c = fm_printf(d + 1, c, cols, "0x%llx ",
	- (u_longlong_t)val[i]);
	-
	- c = fm_printf(d + 1, c, cols, "]");
	- break;
	- }
	-
	- case DATA_TYPE_INT16_ARRAY: {
	- int16_t *val;
	- uint_t i, nelem;
	-
	- c = fm_printf(d + 1, c, cols, "[ ");
	- (void) nvpair_value_int16_array(nvp, &val, &nelem);
	- for (i = 0; i < nelem; i++)
	- c = fm_printf(d + 1, c, cols, "0x%llx ",
	- (u_longlong_t)val[i]);
	-
	- c = fm_printf(d + 1, c, cols, "]");
	- break;
	- }
	-
	- case DATA_TYPE_UINT16_ARRAY: {
	- uint16_t *val;
	- uint_t i, nelem;
	-
	- c = fm_printf(d + 1, c, cols, "[ ");
	- (void) nvpair_value_uint16_array(nvp, &val, &nelem);
	- for (i = 0; i < nelem; i++)
	- c = fm_printf(d + 1, c, cols, "0x%llx ",
	- (u_longlong_t)val[i]);
	-
	- c = fm_printf(d + 1, c, cols, "]");
	- break;
	- }
	-
	- case DATA_TYPE_INT32_ARRAY: {
	- int32_t *val;
	- uint_t i, nelem;
	-
	- c = fm_printf(d + 1, c, cols, "[ ");
	- (void) nvpair_value_int32_array(nvp, &val, &nelem);
	- for (i = 0; i < nelem; i++)
	- c = fm_printf(d + 1, c, cols, "0x%llx ",
	- (u_longlong_t)val[i]);
	-
	- c = fm_printf(d + 1, c, cols, "]");
	- break;
	- }
	-
	- case DATA_TYPE_UINT32_ARRAY: {
	- uint32_t *val;
	- uint_t i, nelem;
	-
	- c = fm_printf(d + 1, c, cols, "[ ");
	- (void) nvpair_value_uint32_array(nvp, &val, &nelem);
	- for (i = 0; i < nelem; i++)
	- c = fm_printf(d + 1, c, cols, "0x%llx ",
	- (u_longlong_t)val[i]);
	-
	- c = fm_printf(d + 1, c, cols, "]");
	- break;
	- }
	-
	- case DATA_TYPE_INT64_ARRAY: {
	- int64_t *val;
	- uint_t i, nelem;
	-
	- c = fm_printf(d + 1, c, cols, "[ ");
	- (void) nvpair_value_int64_array(nvp, &val, &nelem);
	- for (i = 0; i < nelem; i++)
	- c = fm_printf(d + 1, c, cols, "0x%llx ",
	- (u_longlong_t)val[i]);
	-
	- c = fm_printf(d + 1, c, cols, "]");
	- break;
	- }
	-
	- case DATA_TYPE_UINT64_ARRAY: {
	- uint64_t *val;
	- uint_t i, nelem;
	-
	- c = fm_printf(d + 1, c, cols, "[ ");
	- (void) nvpair_value_uint64_array(nvp, &val, &nelem);
	- for (i = 0; i < nelem; i++)
	- c = fm_printf(d + 1, c, cols, "0x%llx ",
	- (u_longlong_t)val[i]);
	-
	- c = fm_printf(d + 1, c, cols, "]");
	- break;
	- }
	-
	- case DATA_TYPE_STRING_ARRAY:
	- case DATA_TYPE_BOOLEAN_ARRAY:
	- case DATA_TYPE_BYTE_ARRAY:
	- c = fm_printf(d + 1, c, cols, "[...]");
	- break;
	-
	- case DATA_TYPE_UNKNOWN:
	- case DATA_TYPE_DONTCARE:
	- c = fm_printf(d + 1, c, cols, "<unknown>");
	- break;
	- }
	- }
	-
	- return (c);
	-}
	-
	-void
	-fm_nvprint(nvlist_t *nvl)
	-{
	- char *class;
	- int c = 0;
	-
	- console_printf("\n");
	-
	- if (nvlist_lookup_string(nvl, FM_CLASS, &class) == 0)
	- c = fm_printf(0, c, zfs_zevent_cols, "%s", class);
	-
	- if (fm_nvprintr(nvl, 0, c, zfs_zevent_cols) != 0)
	- console_printf("\n");
	-
	- console_printf("\n");
	-}
	-
	static zevent_t *
	zfs_zevent_alloc(void)
	{
	zevent_t *ev;

	ev = kmem_zalloc(sizeof (zevent_t), KM_SLEEP);

	list_create(&ev->ev_ze_list, sizeof (zfs_zevent_t),
	offsetof(zfs_zevent_t, ze_node));
	list_link_init(&ev->ev_node);

	return (ev);
	}

	static void
	zfs_zevent_free(zevent_t *ev)
	{
	/* Run provided cleanup callback */
	ev->ev_cb(ev->ev_nvl, ev->ev_detector);

	list_destroy(&ev->ev_ze_list);
	kmem_free(ev, sizeof (zevent_t));
	}

	static void
	zfs_zevent_drain(zevent_t *ev)
	{
	zfs_zevent_t *ze;

	ASSERT(MUTEX_HELD(&zevent_lock));
	list_remove(&zevent_list, ev);

	/* Remove references to this event in all private file data */
	while ((ze = list_head(&ev->ev_ze_list)) != NULL) {
	list_remove(&ev->ev_ze_list, ze);
	ze->ze_zevent = NULL;
	ze->ze_dropped++;
	}

	zfs_zevent_free(ev);
	}

	void
	zfs_zevent_drain_all(int *count)
	{
	zevent_t *ev;

	mutex_enter(&zevent_lock);
	while ((ev = list_head(&zevent_list)) != NULL)
	zfs_zevent_drain(ev);

	*count = zevent_len_cur;
	zevent_len_cur = 0;
	mutex_exit(&zevent_lock);
	}

	/*
	* New zevents are inserted at the head. If the maximum queue
	* length is exceeded a zevent will be drained from the tail.
	* As part of this any user space processes which currently have
	* a reference to this zevent_t in their private data will have
	* this reference set to NULL.
	*/
	static void
	zfs_zevent_insert(zevent_t *ev)
	{
	ASSERT(MUTEX_HELD(&zevent_lock));
	list_insert_head(&zevent_list, ev);

	if (zevent_len_cur >= zfs_zevent_len_max)
	zfs_zevent_drain(list_tail(&zevent_list));
	else
	zevent_len_cur++;
	}

	/*
	* Post a zevent. The cb will be called when nvl and detector are no longer
	* needed, i.e.:
	* - An error happened and a zevent can't be posted. In this case, cb is called
	* before zfs_zevent_post() returns.
	* - The event is being drained and freed.
	*/
	int
	zfs_zevent_post(nvlist_t nvl, nvlist_t detector, zevent_cb_t *cb)
	{
	inode_timespec_t tv;
	int64_t tv_array[2];
	uint64_t eid;
	size_t nvl_size = 0;
	zevent_t *ev;
	int error;

	ASSERT(cb != NULL);

	gethrestime(&tv);
	tv_array[0] = tv.tv_sec;
	tv_array[1] = tv.tv_nsec;

	error = nvlist_add_int64_array(nvl, FM_EREPORT_TIME, tv_array, 2);
	if (error) {
	atomic_inc_64(&erpt_kstat_data.erpt_set_failed.value.ui64);
	goto out;
	}

	eid = atomic_inc_64_nv(&zevent_eid);
	error = nvlist_add_uint64(nvl, FM_EREPORT_EID, eid);
	if (error) {
	atomic_inc_64(&erpt_kstat_data.erpt_set_failed.value.ui64);
	goto out;
	}

	error = nvlist_size(nvl, &nvl_size, NV_ENCODE_NATIVE);
	if (error) {
	atomic_inc_64(&erpt_kstat_data.erpt_dropped.value.ui64);
	goto out;
	}

	if (nvl_size > ERPT_DATA_SZ \|\| nvl_size == 0) {
	atomic_inc_64(&erpt_kstat_data.erpt_dropped.value.ui64);
	error = EOVERFLOW;
	goto out;
	}

	- if (zfs_zevent_console)
	- fm_nvprint(nvl);
	-
	ev = zfs_zevent_alloc();
	if (ev == NULL) {
	atomic_inc_64(&erpt_kstat_data.erpt_dropped.value.ui64);
	error = ENOMEM;
	goto out;
	}

	ev->ev_nvl = nvl;
	ev->ev_detector = detector;
	ev->ev_cb = cb;
	ev->ev_eid = eid;

	mutex_enter(&zevent_lock);
	zfs_zevent_insert(ev);
	cv_broadcast(&zevent_cv);
	mutex_exit(&zevent_lock);

	out:
	if (error)
	cb(nvl, detector);

	return (error);
	}

	void
	zfs_zevent_track_duplicate(void)
	{
	atomic_inc_64(&erpt_kstat_data.erpt_duplicates.value.ui64);
	}

	static int
	zfs_zevent_minor_to_state(minor_t minor, zfs_zevent_t **ze)
	{
	*ze = zfsdev_get_state(minor, ZST_ZEVENT);
	if (*ze == NULL)
	return (SET_ERROR(EBADF));

	return (0);
	}

	int
	zfs_zevent_fd_hold(int fd, minor_t minorp, zfs_zevent_t *ze)
	{
	int error;

	error = zfsdev_getminor(fd, minorp);
	if (error == 0)
	error = zfs_zevent_minor_to_state(*minorp, ze);

	if (error)
	zfs_zevent_fd_rele(fd);

	return (error);
	}

	void
	zfs_zevent_fd_rele(int fd)
	{
	zfs_file_put(fd);
	}

	/*
	* Get the next zevent in the stream and place a copy in 'event'. This
	* may fail with ENOMEM if the encoded nvlist size exceeds the passed
	* 'event_size'. In this case the stream pointer is not advanced and
	* and 'event_size' is set to the minimum required buffer size.
	*/
	int
	zfs_zevent_next(zfs_zevent_t ze, nvlist_t event, uint64_t event_size,
	uint64_t *dropped)
	{
	zevent_t *ev;
	size_t size;
	int error = 0;

	mutex_enter(&zevent_lock);
	if (ze->ze_zevent == NULL) {
	/* New stream start at the beginning/tail */
	ev = list_tail(&zevent_list);
	if (ev == NULL) {
	error = ENOENT;
	goto out;
	}
	} else {
	/*
	* Existing stream continue with the next element and remove
	* ourselves from the wait queue for the previous element
	*/
	ev = list_prev(&zevent_list, ze->ze_zevent);
	if (ev == NULL) {
	error = ENOENT;
	goto out;
	}
	}

	VERIFY(nvlist_size(ev->ev_nvl, &size, NV_ENCODE_NATIVE) == 0);
	if (size > *event_size) {
	*event_size = size;
	error = ENOMEM;
	goto out;
	}

	if (ze->ze_zevent)
	list_remove(&ze->ze_zevent->ev_ze_list, ze);

	ze->ze_zevent = ev;
	list_insert_head(&ev->ev_ze_list, ze);
	(void) nvlist_dup(ev->ev_nvl, event, KM_SLEEP);
	*dropped = ze->ze_dropped;

	#ifdef _KERNEL
	/* Include events dropped due to rate limiting */
	- *dropped += ratelimit_dropped;
	- ratelimit_dropped = 0;
	+ *dropped += atomic_swap_64(&ratelimit_dropped, 0);
	#endif
	ze->ze_dropped = 0;
	out:
	mutex_exit(&zevent_lock);

	return (error);
	}

	/*
	* Wait in an interruptible state for any new events.
	*/
	int
	zfs_zevent_wait(zfs_zevent_t *ze)
	{
	int error = EAGAIN;

	mutex_enter(&zevent_lock);
	zevent_waiters++;

	while (error == EAGAIN) {
	if (zevent_flags & ZEVENT_SHUTDOWN) {
	error = SET_ERROR(ESHUTDOWN);
	break;
	}

	error = cv_wait_sig(&zevent_cv, &zevent_lock);
	if (signal_pending(current)) {
	error = SET_ERROR(EINTR);
	break;
	} else if (!list_is_empty(&zevent_list)) {
	error = 0;
	continue;
	} else {
	error = EAGAIN;
	}
	}

	zevent_waiters--;
	mutex_exit(&zevent_lock);

	return (error);
	}

	/*
	* The caller may seek to a specific EID by passing that EID. If the EID
	* is still available in the posted list of events the cursor is positioned
	* there. Otherwise ENOENT is returned and the cursor is not moved.
	*
	* There are two reserved EIDs which may be passed and will never fail.
	* ZEVENT_SEEK_START positions the cursor at the start of the list, and
	* ZEVENT_SEEK_END positions the cursor at the end of the list.
	*/
	int
	zfs_zevent_seek(zfs_zevent_t *ze, uint64_t eid)
	{
	zevent_t *ev;
	int error = 0;

	mutex_enter(&zevent_lock);

	if (eid == ZEVENT_SEEK_START) {
	if (ze->ze_zevent)
	list_remove(&ze->ze_zevent->ev_ze_list, ze);

	ze->ze_zevent = NULL;
	goto out;
	}

	if (eid == ZEVENT_SEEK_END) {
	if (ze->ze_zevent)
	list_remove(&ze->ze_zevent->ev_ze_list, ze);

	ev = list_head(&zevent_list);
	if (ev) {
	ze->ze_zevent = ev;
	list_insert_head(&ev->ev_ze_list, ze);
	} else {
	ze->ze_zevent = NULL;
	}

	goto out;
	}

	for (ev = list_tail(&zevent_list); ev != NULL;
	ev = list_prev(&zevent_list, ev)) {
	if (ev->ev_eid == eid) {
	if (ze->ze_zevent)
	list_remove(&ze->ze_zevent->ev_ze_list, ze);

	ze->ze_zevent = ev;
	list_insert_head(&ev->ev_ze_list, ze);
	break;
	}
	}

	if (ev == NULL)
	error = ENOENT;

	out:
	mutex_exit(&zevent_lock);

	return (error);
	}

	void
	zfs_zevent_init(zfs_zevent_t **zep)
	{
	zfs_zevent_t *ze;

	ze = *zep = kmem_zalloc(sizeof (zfs_zevent_t), KM_SLEEP);
	list_link_init(&ze->ze_node);
	}

	void
	zfs_zevent_destroy(zfs_zevent_t *ze)
	{
	mutex_enter(&zevent_lock);
	if (ze->ze_zevent)
	list_remove(&ze->ze_zevent->ev_ze_list, ze);
	mutex_exit(&zevent_lock);

	kmem_free(ze, sizeof (zfs_zevent_t));
	}
	#endif /* _KERNEL */

	/*
	* Wrappers for FM nvlist allocators
	*/
	/* ARGSUSED */
	static void *
	i_fm_alloc(nv_alloc_t *nva, size_t size)
	{
	return (kmem_zalloc(size, KM_SLEEP));
	}

	/* ARGSUSED */
	static void
	i_fm_free(nv_alloc_t nva, void buf, size_t size)
	{
	kmem_free(buf, size);
	}

	const nv_alloc_ops_t fm_mem_alloc_ops = {
	.nv_ao_init = NULL,
	.nv_ao_fini = NULL,
	.nv_ao_alloc = i_fm_alloc,
	.nv_ao_free = i_fm_free,
	.nv_ao_reset = NULL
	};

	/*
	* Create and initialize a new nv_alloc_t for a fixed buffer, buf. A pointer
	* to the newly allocated nv_alloc_t structure is returned upon success or NULL
	* is returned to indicate that the nv_alloc structure could not be created.
	*/
	nv_alloc_t *
	fm_nva_xcreate(char *buf, size_t bufsz)
	{
	nv_alloc_t *nvhdl = kmem_zalloc(sizeof (nv_alloc_t), KM_SLEEP);

	if (bufsz == 0 \|\| nv_alloc_init(nvhdl, nv_fixed_ops, buf, bufsz) != 0) {
	kmem_free(nvhdl, sizeof (nv_alloc_t));
	return (NULL);
	}

	return (nvhdl);
	}

	/*
	* Destroy a previously allocated nv_alloc structure. The fixed buffer
	* associated with nva must be freed by the caller.
	*/
	void
	fm_nva_xdestroy(nv_alloc_t *nva)
	{
	nv_alloc_fini(nva);
	kmem_free(nva, sizeof (nv_alloc_t));
	}

	/*
	* Create a new nv list. A pointer to a new nv list structure is returned
	* upon success or NULL is returned to indicate that the structure could
	* not be created. The newly created nv list is created and managed by the
	* operations installed in nva. If nva is NULL, the default FMA nva
	* operations are installed and used.
	*
	* When called from the kernel and nva == NULL, this function must be called
	* from passive kernel context with no locks held that can prevent a
	* sleeping memory allocation from occurring. Otherwise, this function may
	* be called from other kernel contexts as long a valid nva created via
	* fm_nva_create() is supplied.
	*/
	nvlist_t *
	fm_nvlist_create(nv_alloc_t *nva)
	{
	int hdl_alloced = 0;
	nvlist_t *nvl;
	nv_alloc_t *nvhdl;

	if (nva == NULL) {
	nvhdl = kmem_zalloc(sizeof (nv_alloc_t), KM_SLEEP);

	if (nv_alloc_init(nvhdl, &fm_mem_alloc_ops, NULL, 0) != 0) {
	kmem_free(nvhdl, sizeof (nv_alloc_t));
	return (NULL);
	}
	hdl_alloced = 1;
	} else {
	nvhdl = nva;
	}

	if (nvlist_xalloc(&nvl, NV_UNIQUE_NAME, nvhdl) != 0) {
	if (hdl_alloced) {
	nv_alloc_fini(nvhdl);
	kmem_free(nvhdl, sizeof (nv_alloc_t));
	}
	return (NULL);
	}

	return (nvl);
	}

	/*
	* Destroy a previously allocated nvlist structure. flag indicates whether
	* or not the associated nva structure should be freed (FM_NVA_FREE) or
	* retained (FM_NVA_RETAIN). Retaining the nv alloc structure allows
	* it to be re-used for future nvlist creation operations.
	*/
	void
	fm_nvlist_destroy(nvlist_t *nvl, int flag)
	{
	nv_alloc_t *nva = nvlist_lookup_nv_alloc(nvl);

	nvlist_free(nvl);

	if (nva != NULL) {
	if (flag == FM_NVA_FREE)
	fm_nva_xdestroy(nva);
	}
	}

	int
	i_fm_payload_set(nvlist_t payload, const char name, va_list ap)
	{
	int nelem, ret = 0;
	data_type_t type;

	while (ret == 0 && name != NULL) {
	type = va_arg(ap, data_type_t);
	switch (type) {
	case DATA_TYPE_BYTE:
	ret = nvlist_add_byte(payload, name,
	va_arg(ap, uint_t));
	break;
	case DATA_TYPE_BYTE_ARRAY:
	nelem = va_arg(ap, int);
	ret = nvlist_add_byte_array(payload, name,
	va_arg(ap, uchar_t *), nelem);
	break;
	case DATA_TYPE_BOOLEAN_VALUE:
	ret = nvlist_add_boolean_value(payload, name,
	va_arg(ap, boolean_t));
	break;
	case DATA_TYPE_BOOLEAN_ARRAY:
	nelem = va_arg(ap, int);
	ret = nvlist_add_boolean_array(payload, name,
	va_arg(ap, boolean_t *), nelem);
	break;
	case DATA_TYPE_INT8:
	ret = nvlist_add_int8(payload, name,
	va_arg(ap, int));
	break;
	case DATA_TYPE_INT8_ARRAY:
	nelem = va_arg(ap, int);
	ret = nvlist_add_int8_array(payload, name,
	va_arg(ap, int8_t *), nelem);
	break;
	case DATA_TYPE_UINT8:
	ret = nvlist_add_uint8(payload, name,
	va_arg(ap, uint_t));
	break;
	case DATA_TYPE_UINT8_ARRAY:
	nelem = va_arg(ap, int);
	ret = nvlist_add_uint8_array(payload, name,
	va_arg(ap, uint8_t *), nelem);
	break;
	case DATA_TYPE_INT16:
	ret = nvlist_add_int16(payload, name,
	va_arg(ap, int));
	break;
	case DATA_TYPE_INT16_ARRAY:
	nelem = va_arg(ap, int);
	ret = nvlist_add_int16_array(payload, name,
	va_arg(ap, int16_t *), nelem);
	break;
	case DATA_TYPE_UINT16:
	ret = nvlist_add_uint16(payload, name,
	va_arg(ap, uint_t));
	break;
	case DATA_TYPE_UINT16_ARRAY:
	nelem = va_arg(ap, int);
	ret = nvlist_add_uint16_array(payload, name,
	va_arg(ap, uint16_t *), nelem);
	break;
	case DATA_TYPE_INT32:
	ret = nvlist_add_int32(payload, name,
	va_arg(ap, int32_t));
	break;
	case DATA_TYPE_INT32_ARRAY:
	nelem = va_arg(ap, int);
	ret = nvlist_add_int32_array(payload, name,
	va_arg(ap, int32_t *), nelem);
	break;
	case DATA_TYPE_UINT32:
	ret = nvlist_add_uint32(payload, name,
	va_arg(ap, uint32_t));
	break;
	case DATA_TYPE_UINT32_ARRAY:
	nelem = va_arg(ap, int);
	ret = nvlist_add_uint32_array(payload, name,
	va_arg(ap, uint32_t *), nelem);
	break;
	case DATA_TYPE_INT64:
	ret = nvlist_add_int64(payload, name,
	va_arg(ap, int64_t));
	break;
	case DATA_TYPE_INT64_ARRAY:
	nelem = va_arg(ap, int);
	ret = nvlist_add_int64_array(payload, name,
	va_arg(ap, int64_t *), nelem);
	break;
	case DATA_TYPE_UINT64:
	ret = nvlist_add_uint64(payload, name,
	va_arg(ap, uint64_t));
	break;
	case DATA_TYPE_UINT64_ARRAY:
	nelem = va_arg(ap, int);
	ret = nvlist_add_uint64_array(payload, name,
	va_arg(ap, uint64_t *), nelem);
	break;
	case DATA_TYPE_STRING:
	ret = nvlist_add_string(payload, name,
	va_arg(ap, char *));
	break;
	case DATA_TYPE_STRING_ARRAY:
	nelem = va_arg(ap, int);
	ret = nvlist_add_string_array(payload, name,
	va_arg(ap, char **), nelem);
	break;
	case DATA_TYPE_NVLIST:
	ret = nvlist_add_nvlist(payload, name,
	va_arg(ap, nvlist_t *));
	break;
	case DATA_TYPE_NVLIST_ARRAY:
	nelem = va_arg(ap, int);
	ret = nvlist_add_nvlist_array(payload, name,
	va_arg(ap, nvlist_t **), nelem);
	break;
	default:
	ret = EINVAL;
	}

	name = va_arg(ap, char *);
	}
	return (ret);
	}

	void
	fm_payload_set(nvlist_t *payload, ...)
	{
	int ret;
	const char *name;
	va_list ap;

	va_start(ap, payload);
	name = va_arg(ap, char *);
	ret = i_fm_payload_set(payload, name, ap);
	va_end(ap);

	if (ret)
	atomic_inc_64(&erpt_kstat_data.payload_set_failed.value.ui64);
	}

	/*
	* Set-up and validate the members of an ereport event according to:
	*
	* Member name Type Value
	* ====================================================
	* class string ereport
	* version uint8_t 0
	* ena uint64_t <ena>
	* detector nvlist_t <detector>
	* ereport-payload nvlist_t <var args>
	*
	* We don't actually add a 'version' member to the payload. Really,
	* the version quoted to us by our caller is that of the category 1
	* "ereport" event class (and we require FM_EREPORT_VERS0) but
	* the payload version of the actual leaf class event under construction
	* may be something else. Callers should supply a version in the varargs,
	* or (better) we could take two version arguments - one for the
	* ereport category 1 classification (expect FM_EREPORT_VERS0) and one
	* for the leaf class.
	*/
	void
	fm_ereport_set(nvlist_t ereport, int version, const char erpt_class,
	uint64_t ena, const nvlist_t *detector, ...)
	{
	char ereport_class[FM_MAX_CLASS];
	const char *name;
	va_list ap;
	int ret;

	if (version != FM_EREPORT_VERS0) {
	atomic_inc_64(&erpt_kstat_data.erpt_set_failed.value.ui64);
	return;
	}

	(void) snprintf(ereport_class, FM_MAX_CLASS, "%s.%s",
	FM_EREPORT_CLASS, erpt_class);
	if (nvlist_add_string(ereport, FM_CLASS, ereport_class) != 0) {
	atomic_inc_64(&erpt_kstat_data.erpt_set_failed.value.ui64);
	return;
	}

	if (nvlist_add_uint64(ereport, FM_EREPORT_ENA, ena)) {
	atomic_inc_64(&erpt_kstat_data.erpt_set_failed.value.ui64);
	}

	if (nvlist_add_nvlist(ereport, FM_EREPORT_DETECTOR,
	(nvlist_t *)detector) != 0) {
	atomic_inc_64(&erpt_kstat_data.erpt_set_failed.value.ui64);
	}

	va_start(ap, detector);
	name = va_arg(ap, const char *);
	ret = i_fm_payload_set(ereport, name, ap);
	va_end(ap);

	if (ret)
	atomic_inc_64(&erpt_kstat_data.erpt_set_failed.value.ui64);
	}

	/*
	* Set-up and validate the members of an hc fmri according to;
	*
	* Member name Type Value
	* ===================================================
	* version uint8_t 0
	* auth nvlist_t <auth>
	* hc-name string <name>
	* hc-id string <id>
	*
	* Note that auth and hc-id are optional members.
	*/

	#define HC_MAXPAIRS 20
	#define HC_MAXNAMELEN 50

	static int
	fm_fmri_hc_set_common(nvlist_t fmri, int version, const nvlist_t auth)
	{
	if (version != FM_HC_SCHEME_VERSION) {
	atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
	return (0);
	}

	if (nvlist_add_uint8(fmri, FM_VERSION, version) != 0 \|\|
	nvlist_add_string(fmri, FM_FMRI_SCHEME, FM_FMRI_SCHEME_HC) != 0) {
	atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
	return (0);
	}

	if (auth != NULL && nvlist_add_nvlist(fmri, FM_FMRI_AUTHORITY,
	(nvlist_t *)auth) != 0) {
	atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
	return (0);
	}

	return (1);
	}

	void
	fm_fmri_hc_set(nvlist_t fmri, int version, const nvlist_t auth,
	nvlist_t *snvl, int npairs, ...)
	{
	nv_alloc_t *nva = nvlist_lookup_nv_alloc(fmri);
	nvlist_t *pairs[HC_MAXPAIRS];
	va_list ap;
	int i;

	if (!fm_fmri_hc_set_common(fmri, version, auth))
	return;

	npairs = MIN(npairs, HC_MAXPAIRS);

	va_start(ap, npairs);
	for (i = 0; i < npairs; i++) {
	const char name = va_arg(ap, const char );
	uint32_t id = va_arg(ap, uint32_t);
	char idstr[11];

	(void) snprintf(idstr, sizeof (idstr), "%u", id);

	pairs[i] = fm_nvlist_create(nva);
	if (nvlist_add_string(pairs[i], FM_FMRI_HC_NAME, name) != 0 \|\|
	nvlist_add_string(pairs[i], FM_FMRI_HC_ID, idstr) != 0) {
	atomic_inc_64(
	&erpt_kstat_data.fmri_set_failed.value.ui64);
	}
	}
	va_end(ap);

	if (nvlist_add_nvlist_array(fmri, FM_FMRI_HC_LIST, pairs, npairs) != 0)
	atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);

	for (i = 0; i < npairs; i++)
	fm_nvlist_destroy(pairs[i], FM_NVA_RETAIN);

	if (snvl != NULL) {
	if (nvlist_add_nvlist(fmri, FM_FMRI_HC_SPECIFIC, snvl) != 0) {
	atomic_inc_64(
	&erpt_kstat_data.fmri_set_failed.value.ui64);
	}
	}
	}

	void
	fm_fmri_hc_create(nvlist_t fmri, int version, const nvlist_t auth,
	nvlist_t snvl, nvlist_t bboard, int npairs, ...)
	{
	nv_alloc_t *nva = nvlist_lookup_nv_alloc(fmri);
	nvlist_t *pairs[HC_MAXPAIRS];
	nvlist_t **hcl;
	uint_t n;
	int i, j;
	va_list ap;
	char hcname, hcid;

	if (!fm_fmri_hc_set_common(fmri, version, auth))
	return;

	/*
	* copy the bboard nvpairs to the pairs array
	*/
	if (nvlist_lookup_nvlist_array(bboard, FM_FMRI_HC_LIST, &hcl, &n)
	!= 0) {
	atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
	return;
	}

	for (i = 0; i < n; i++) {
	if (nvlist_lookup_string(hcl[i], FM_FMRI_HC_NAME,
	&hcname) != 0) {
	atomic_inc_64(
	&erpt_kstat_data.fmri_set_failed.value.ui64);
	return;
	}
	if (nvlist_lookup_string(hcl[i], FM_FMRI_HC_ID, &hcid) != 0) {
	atomic_inc_64(
	&erpt_kstat_data.fmri_set_failed.value.ui64);
	return;
	}

	pairs[i] = fm_nvlist_create(nva);
	if (nvlist_add_string(pairs[i], FM_FMRI_HC_NAME, hcname) != 0 \|\|
	nvlist_add_string(pairs[i], FM_FMRI_HC_ID, hcid) != 0) {
	for (j = 0; j <= i; j++) {
	if (pairs[j] != NULL)
	fm_nvlist_destroy(pairs[j],
	FM_NVA_RETAIN);
	}
	atomic_inc_64(
	&erpt_kstat_data.fmri_set_failed.value.ui64);
	return;
	}
	}

	/*
	* create the pairs from passed in pairs
	*/
	npairs = MIN(npairs, HC_MAXPAIRS);

	va_start(ap, npairs);
	for (i = n; i < npairs + n; i++) {
	const char name = va_arg(ap, const char );
	uint32_t id = va_arg(ap, uint32_t);
	char idstr[11];
	(void) snprintf(idstr, sizeof (idstr), "%u", id);
	pairs[i] = fm_nvlist_create(nva);
	if (nvlist_add_string(pairs[i], FM_FMRI_HC_NAME, name) != 0 \|\|
	nvlist_add_string(pairs[i], FM_FMRI_HC_ID, idstr) != 0) {
	for (j = 0; j <= i; j++) {
	if (pairs[j] != NULL)
	fm_nvlist_destroy(pairs[j],
	FM_NVA_RETAIN);
	}
	atomic_inc_64(
	&erpt_kstat_data.fmri_set_failed.value.ui64);
	return;
	}
	}
	va_end(ap);

	/*
	* Create the fmri hc list
	*/
	if (nvlist_add_nvlist_array(fmri, FM_FMRI_HC_LIST, pairs,
	npairs + n) != 0) {
	atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
	return;
	}

	for (i = 0; i < npairs + n; i++) {
	fm_nvlist_destroy(pairs[i], FM_NVA_RETAIN);
	}

	if (snvl != NULL) {
	if (nvlist_add_nvlist(fmri, FM_FMRI_HC_SPECIFIC, snvl) != 0) {
	atomic_inc_64(
	&erpt_kstat_data.fmri_set_failed.value.ui64);
	return;
	}
	}
	}

	/*
	* Set-up and validate the members of an dev fmri according to:
	*
	* Member name Type Value
	* ====================================================
	* version uint8_t 0
	* auth nvlist_t <auth>
	* devpath string <devpath>
	* [devid] string <devid>
	* [target-port-l0id] string <target-port-lun0-id>
	*
	* Note that auth and devid are optional members.
	*/
	void
	fm_fmri_dev_set(nvlist_t fmri_dev, int version, const nvlist_t auth,
	const char devpath, const char devid, const char *tpl0)
	{
	int err = 0;

	if (version != DEV_SCHEME_VERSION0) {
	atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
	return;
	}

	err \|= nvlist_add_uint8(fmri_dev, FM_VERSION, version);
	err \|= nvlist_add_string(fmri_dev, FM_FMRI_SCHEME, FM_FMRI_SCHEME_DEV);

	if (auth != NULL) {
	err \|= nvlist_add_nvlist(fmri_dev, FM_FMRI_AUTHORITY,
	(nvlist_t *)auth);
	}

	err \|= nvlist_add_string(fmri_dev, FM_FMRI_DEV_PATH, devpath);

	if (devid != NULL)
	err \|= nvlist_add_string(fmri_dev, FM_FMRI_DEV_ID, devid);

	if (tpl0 != NULL)
	err \|= nvlist_add_string(fmri_dev, FM_FMRI_DEV_TGTPTLUN0, tpl0);

	if (err)
	atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);

	}

	/*
	* Set-up and validate the members of an cpu fmri according to:
	*
	* Member name Type Value
	* ====================================================
	* version uint8_t 0
	* auth nvlist_t <auth>
	* cpuid uint32_t <cpu_id>
	* cpumask uint8_t <cpu_mask>
	* serial uint64_t <serial_id>
	*
	* Note that auth, cpumask, serial are optional members.
	*
	*/
	void
	fm_fmri_cpu_set(nvlist_t fmri_cpu, int version, const nvlist_t auth,
	uint32_t cpu_id, uint8_t cpu_maskp, const char serial_idp)
	{
	uint64_t *failedp = &erpt_kstat_data.fmri_set_failed.value.ui64;

	if (version < CPU_SCHEME_VERSION1) {
	atomic_inc_64(failedp);
	return;
	}

	if (nvlist_add_uint8(fmri_cpu, FM_VERSION, version) != 0) {
	atomic_inc_64(failedp);
	return;
	}

	if (nvlist_add_string(fmri_cpu, FM_FMRI_SCHEME,
	FM_FMRI_SCHEME_CPU) != 0) {
	atomic_inc_64(failedp);
	return;
	}

	if (auth != NULL && nvlist_add_nvlist(fmri_cpu, FM_FMRI_AUTHORITY,
	(nvlist_t *)auth) != 0)
	atomic_inc_64(failedp);

	if (nvlist_add_uint32(fmri_cpu, FM_FMRI_CPU_ID, cpu_id) != 0)
	atomic_inc_64(failedp);

	if (cpu_maskp != NULL && nvlist_add_uint8(fmri_cpu, FM_FMRI_CPU_MASK,
	*cpu_maskp) != 0)
	atomic_inc_64(failedp);

	if (serial_idp == NULL \|\| nvlist_add_string(fmri_cpu,
	FM_FMRI_CPU_SERIAL_ID, (char *)serial_idp) != 0)
	atomic_inc_64(failedp);
	}

	/*
	* Set-up and validate the members of a mem according to:
	*
	* Member name Type Value
	* ====================================================
	* version uint8_t 0
	* auth nvlist_t <auth> [optional]
	* unum string <unum>
	* serial string <serial> [optional*]
	* offset uint64_t <offset> [optional]
	*
	* * serial is required if offset is present
	*/
	void
	fm_fmri_mem_set(nvlist_t fmri, int version, const nvlist_t auth,
	const char unum, const char serial, uint64_t offset)
	{
	if (version != MEM_SCHEME_VERSION0) {
	atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
	return;
	}

	if (!serial && (offset != (uint64_t)-1)) {
	atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
	return;
	}

	if (nvlist_add_uint8(fmri, FM_VERSION, version) != 0) {
	atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
	return;
	}

	if (nvlist_add_string(fmri, FM_FMRI_SCHEME, FM_FMRI_SCHEME_MEM) != 0) {
	atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
	return;
	}

	if (auth != NULL) {
	if (nvlist_add_nvlist(fmri, FM_FMRI_AUTHORITY,
	(nvlist_t *)auth) != 0) {
	atomic_inc_64(
	&erpt_kstat_data.fmri_set_failed.value.ui64);
	}
	}

	if (nvlist_add_string(fmri, FM_FMRI_MEM_UNUM, unum) != 0) {
	atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
	}

	if (serial != NULL) {
	if (nvlist_add_string_array(fmri, FM_FMRI_MEM_SERIAL_ID,
	(char **)&serial, 1) != 0) {
	atomic_inc_64(
	&erpt_kstat_data.fmri_set_failed.value.ui64);
	}
	if (offset != (uint64_t)-1 && nvlist_add_uint64(fmri,
	FM_FMRI_MEM_OFFSET, offset) != 0) {
	atomic_inc_64(
	&erpt_kstat_data.fmri_set_failed.value.ui64);
	}
	}
	}

	void
	fm_fmri_zfs_set(nvlist_t *fmri, int version, uint64_t pool_guid,
	uint64_t vdev_guid)
	{
	if (version != ZFS_SCHEME_VERSION0) {
	atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
	return;
	}

	if (nvlist_add_uint8(fmri, FM_VERSION, version) != 0) {
	atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
	return;
	}

	if (nvlist_add_string(fmri, FM_FMRI_SCHEME, FM_FMRI_SCHEME_ZFS) != 0) {
	atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
	return;
	}

	if (nvlist_add_uint64(fmri, FM_FMRI_ZFS_POOL, pool_guid) != 0) {
	atomic_inc_64(&erpt_kstat_data.fmri_set_failed.value.ui64);
	}

	if (vdev_guid != 0) {
	if (nvlist_add_uint64(fmri, FM_FMRI_ZFS_VDEV, vdev_guid) != 0) {
	atomic_inc_64(
	&erpt_kstat_data.fmri_set_failed.value.ui64);
	}
	}
	}

	uint64_t
	fm_ena_increment(uint64_t ena)
	{
	uint64_t new_ena;

	switch (ENA_FORMAT(ena)) {
	case FM_ENA_FMT1:
	new_ena = ena + (1 << ENA_FMT1_GEN_SHFT);
	break;
	case FM_ENA_FMT2:
	new_ena = ena + (1 << ENA_FMT2_GEN_SHFT);
	break;
	default:
	new_ena = 0;
	}

	return (new_ena);
	}

	uint64_t
	fm_ena_generate_cpu(uint64_t timestamp, processorid_t cpuid, uchar_t format)
	{
	uint64_t ena = 0;

	switch (format) {
	case FM_ENA_FMT1:
	if (timestamp) {
	ena = (uint64_t)((format & ENA_FORMAT_MASK) \|
	((cpuid << ENA_FMT1_CPUID_SHFT) &
	ENA_FMT1_CPUID_MASK) \|
	((timestamp << ENA_FMT1_TIME_SHFT) &
	ENA_FMT1_TIME_MASK));
	} else {
	ena = (uint64_t)((format & ENA_FORMAT_MASK) \|
	((cpuid << ENA_FMT1_CPUID_SHFT) &
	ENA_FMT1_CPUID_MASK) \|
	((gethrtime() << ENA_FMT1_TIME_SHFT) &
	ENA_FMT1_TIME_MASK));
	}
	break;
	case FM_ENA_FMT2:
	ena = (uint64_t)((format & ENA_FORMAT_MASK) \|
	((timestamp << ENA_FMT2_TIME_SHFT) & ENA_FMT2_TIME_MASK));
	break;
	default:
	break;
	}

	return (ena);
	}

	uint64_t
	fm_ena_generate(uint64_t timestamp, uchar_t format)
	{
	uint64_t ena;

	kpreempt_disable();
	ena = fm_ena_generate_cpu(timestamp, getcpuid(), format);
	kpreempt_enable();

	return (ena);
	}

	uint64_t
	fm_ena_generation_get(uint64_t ena)
	{
	uint64_t gen;

	switch (ENA_FORMAT(ena)) {
	case FM_ENA_FMT1:
	gen = (ena & ENA_FMT1_GEN_MASK) >> ENA_FMT1_GEN_SHFT;
	break;
	case FM_ENA_FMT2:
	gen = (ena & ENA_FMT2_GEN_MASK) >> ENA_FMT2_GEN_SHFT;
	break;
	default:
	gen = 0;
	break;
	}

	return (gen);
	}

	uchar_t
	fm_ena_format_get(uint64_t ena)
	{

	return (ENA_FORMAT(ena));
	}

	uint64_t
	fm_ena_id_get(uint64_t ena)
	{
	uint64_t id;

	switch (ENA_FORMAT(ena)) {
	case FM_ENA_FMT1:
	id = (ena & ENA_FMT1_ID_MASK) >> ENA_FMT1_ID_SHFT;
	break;
	case FM_ENA_FMT2:
	id = (ena & ENA_FMT2_ID_MASK) >> ENA_FMT2_ID_SHFT;
	break;
	default:
	id = 0;
	}

	return (id);
	}

	uint64_t
	fm_ena_time_get(uint64_t ena)
	{
	uint64_t time;

	switch (ENA_FORMAT(ena)) {
	case FM_ENA_FMT1:
	time = (ena & ENA_FMT1_TIME_MASK) >> ENA_FMT1_TIME_SHFT;
	break;
	case FM_ENA_FMT2:
	time = (ena & ENA_FMT2_TIME_MASK) >> ENA_FMT2_TIME_SHFT;
	break;
	default:
	time = 0;
	}

	return (time);
	}

	#ifdef _KERNEL
	/*
	* Helper function to increment ereport dropped count. Used by the event
	* rate limiting code to give feedback to the user about how many events were
	* rate limited by including them in the 'dropped' count.
	*/
	void
	fm_erpt_dropped_increment(void)
	{
	atomic_inc_64(&ratelimit_dropped);
	}

	void
	fm_init(void)
	{
	zevent_len_cur = 0;
	zevent_flags = 0;

	- if (zfs_zevent_len_max == 0)
	- zfs_zevent_len_max = ERPT_MAX_ERRS * MAX(max_ncpus, 4);
	-
	/* Initialize zevent allocation and generation kstats */
	fm_ksp = kstat_create("zfs", 0, "fm", "misc", KSTAT_TYPE_NAMED,
	sizeof (struct erpt_kstat) / sizeof (kstat_named_t),
	KSTAT_FLAG_VIRTUAL);

	if (fm_ksp != NULL) {
	fm_ksp->ks_data = &erpt_kstat_data;
	kstat_install(fm_ksp);
	} else {
	cmn_err(CE_NOTE, "failed to create fm/misc kstat\n");
	}

	mutex_init(&zevent_lock, NULL, MUTEX_DEFAULT, NULL);
	list_create(&zevent_list, sizeof (zevent_t),
	offsetof(zevent_t, ev_node));
	cv_init(&zevent_cv, NULL, CV_DEFAULT, NULL);

	zfs_ereport_init();
	}

	void
	fm_fini(void)
	{
	int count;

	zfs_ereport_fini();

	zfs_zevent_drain_all(&count);

	mutex_enter(&zevent_lock);
	cv_broadcast(&zevent_cv);

	zevent_flags \|= ZEVENT_SHUTDOWN;
	while (zevent_waiters > 0) {
	mutex_exit(&zevent_lock);
	schedule();
	mutex_enter(&zevent_lock);
	}
	mutex_exit(&zevent_lock);

	cv_destroy(&zevent_cv);
	list_destroy(&zevent_list);
	mutex_destroy(&zevent_lock);

	if (fm_ksp != NULL) {
	kstat_delete(fm_ksp);
	fm_ksp = NULL;
	}
	}
	#endif /* _KERNEL */

	ZFS_MODULE_PARAM(zfs_zevent, zfs_zevent_, len_max, INT, ZMOD_RW,
	"Max event queue length");
	-
	-ZFS_MODULE_PARAM(zfs_zevent, zfs_zevent_, cols, INT, ZMOD_RW,
	- "Max event column width");
	-
	-ZFS_MODULE_PARAM(zfs_zevent, zfs_zevent_, console, INT, ZMOD_RW,
	- "Log events to the console");
	diff --git a/sys/contrib/openzfs/module/zfs/spa.c b/sys/contrib/openzfs/module/zfs/spa.c
	index 5170c9ca226f..26995575adaa 100644
	--- a/sys/contrib/openzfs/module/zfs/spa.c
	+++ b/sys/contrib/openzfs/module/zfs/spa.c
	@@ -1,9885 +1,9929 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2011, 2020 by Delphix. All rights reserved.
	* Copyright (c) 2018, Nexenta Systems, Inc. All rights reserved.
	* Copyright (c) 2014 Spectra Logic Corporation, All rights reserved.
	* Copyright 2013 Saso Kiselkov. 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 2018 Joyent, Inc.
	* Copyright (c) 2017, 2019, Datto Inc. All rights reserved.
	* Copyright 2017 Joyent, Inc.
	* Copyright (c) 2017, Intel Corporation.
	* Copyright (c) 2021, Colm Buckley <colm@tuatha.org>
	*/

	/*
	* SPA: Storage Pool Allocator
	*
	* This file contains all the routines used when modifying on-disk SPA state.
	* This includes opening, importing, destroying, exporting a pool, and syncing a
	* pool.
	*/

	#include <sys/zfs_context.h>
	#include <sys/fm/fs/zfs.h>
	#include <sys/spa_impl.h>
	#include <sys/zio.h>
	#include <sys/zio_checksum.h>
	#include <sys/dmu.h>
	#include <sys/dmu_tx.h>
	#include <sys/zap.h>
	#include <sys/zil.h>
	#include <sys/ddt.h>
	#include <sys/vdev_impl.h>
	#include <sys/vdev_removal.h>
	#include <sys/vdev_indirect_mapping.h>
	#include <sys/vdev_indirect_births.h>
	#include <sys/vdev_initialize.h>
	#include <sys/vdev_rebuild.h>
	#include <sys/vdev_trim.h>
	#include <sys/vdev_disk.h>
	#include <sys/vdev_draid.h>
	#include <sys/metaslab.h>
	#include <sys/metaslab_impl.h>
	#include <sys/mmp.h>
	#include <sys/uberblock_impl.h>
	#include <sys/txg.h>
	#include <sys/avl.h>
	#include <sys/bpobj.h>
	#include <sys/dmu_traverse.h>
	#include <sys/dmu_objset.h>
	#include <sys/unique.h>
	#include <sys/dsl_pool.h>
	#include <sys/dsl_dataset.h>
	#include <sys/dsl_dir.h>
	#include <sys/dsl_prop.h>
	#include <sys/dsl_synctask.h>
	#include <sys/fs/zfs.h>
	#include <sys/arc.h>
	#include <sys/callb.h>
	#include <sys/systeminfo.h>
	#include <sys/spa_boot.h>
	#include <sys/zfs_ioctl.h>
	#include <sys/dsl_scan.h>
	#include <sys/zfeature.h>
	#include <sys/dsl_destroy.h>
	#include <sys/zvol.h>

	#ifdef _KERNEL
	#include <sys/fm/protocol.h>
	#include <sys/fm/util.h>
	#include <sys/callb.h>
	#include <sys/zone.h>
	#include <sys/vmsystm.h>
	#endif /* _KERNEL */

	#include "zfs_prop.h"
	#include "zfs_comutil.h"

	/*
	* The interval, in seconds, at which failed configuration cache file writes
	* should be retried.
	*/
	int zfs_ccw_retry_interval = 300;

	typedef enum zti_modes {
	ZTI_MODE_FIXED, /* value is # of threads (min 1) */
	ZTI_MODE_BATCH, /* cpu-intensive; value is ignored */
	+ ZTI_MODE_SCALE, /* Taskqs scale with CPUs. */
	ZTI_MODE_NULL, /* don't create a taskq */
	ZTI_NMODES
	} zti_modes_t;

	#define ZTI_P(n, q) { ZTI_MODE_FIXED, (n), (q) }
	#define ZTI_PCT(n) { ZTI_MODE_ONLINE_PERCENT, (n), 1 }
	#define ZTI_BATCH { ZTI_MODE_BATCH, 0, 1 }
	+#define ZTI_SCALE { ZTI_MODE_SCALE, 0, 1 }
	#define ZTI_NULL { ZTI_MODE_NULL, 0, 0 }

	#define ZTI_N(n) ZTI_P(n, 1)
	#define ZTI_ONE ZTI_N(1)

	typedef struct zio_taskq_info {
	zti_modes_t zti_mode;
	uint_t zti_value;
	uint_t zti_count;
	} zio_taskq_info_t;

	static const char *const zio_taskq_types[ZIO_TASKQ_TYPES] = {
	"iss", "iss_h", "int", "int_h"
	};

	/*
	* This table defines the taskq settings for each ZFS I/O type. When
	* initializing a pool, we use this table to create an appropriately sized
	* taskq. Some operations are low volume and therefore have a small, static
	* number of threads assigned to their taskqs using the ZTI_N(#) or ZTI_ONE
	* macros. Other operations process a large amount of data; the ZTI_BATCH
	* macro causes us to create a taskq oriented for throughput. Some operations
	* are so high frequency and short-lived that the taskq itself can become a
	* point of lock contention. The ZTI_P(#, #) macro indicates that we need an
	* additional degree of parallelism specified by the number of threads per-
	* taskq and the number of taskqs; when dispatching an event in this case, the
	- * particular taskq is chosen at random.
	+ * particular taskq is chosen at random. ZTI_SCALE is similar to ZTI_BATCH,
	+ * but with number of taskqs also scaling with number of CPUs.
	*
	* The different taskq priorities are to handle the different contexts (issue
	* and interrupt) and then to reserve threads for ZIO_PRIORITY_NOW I/Os that
	* need to be handled with minimum delay.
	*/
	const zio_taskq_info_t zio_taskqs[ZIO_TYPES][ZIO_TASKQ_TYPES] = {
	/* ISSUE ISSUE_HIGH INTR INTR_HIGH */
	{ ZTI_ONE, ZTI_NULL, ZTI_ONE, ZTI_NULL }, /* NULL */
	- { ZTI_N(8), ZTI_NULL, ZTI_P(12, 8), ZTI_NULL }, /* READ */
	- { ZTI_BATCH, ZTI_N(5), ZTI_P(12, 8), ZTI_N(5) }, /* WRITE */
	- { ZTI_P(12, 8), ZTI_NULL, ZTI_ONE, ZTI_NULL }, /* FREE */
	+ { ZTI_N(8), ZTI_NULL, ZTI_SCALE, ZTI_NULL }, /* READ */
	+ { ZTI_BATCH, ZTI_N(5), ZTI_SCALE, ZTI_N(5) }, /* WRITE */
	+ { ZTI_SCALE, ZTI_NULL, ZTI_ONE, ZTI_NULL }, /* FREE */
	{ ZTI_ONE, ZTI_NULL, ZTI_ONE, ZTI_NULL }, /* CLAIM */
	{ ZTI_ONE, ZTI_NULL, ZTI_ONE, ZTI_NULL }, /* IOCTL */
	{ ZTI_N(4), ZTI_NULL, ZTI_ONE, ZTI_NULL }, /* TRIM */
	};

	static void spa_sync_version(void arg, dmu_tx_t tx);
	static void spa_sync_props(void arg, dmu_tx_t tx);
	static boolean_t spa_has_active_shared_spare(spa_t *spa);
	static int spa_load_impl(spa_t spa, spa_import_type_t type, char *ereport);
	static void spa_vdev_resilver_done(spa_t *spa);

	-uint_t zio_taskq_batch_pct = 75; /* 1 thread per cpu in pset */
	+uint_t zio_taskq_batch_pct = 80; /* 1 thread per cpu in pset */
	+uint_t zio_taskq_batch_tpq; /* threads per taskq */
	boolean_t zio_taskq_sysdc = B_TRUE; /* use SDC scheduling class */
	uint_t zio_taskq_basedc = 80; /* base duty cycle */

	boolean_t spa_create_process = B_TRUE; /* no process ==> no sysdc */

	/*
	* Report any spa_load_verify errors found, but do not fail spa_load.
	* This is used by zdb to analyze non-idle pools.
	*/
	boolean_t spa_load_verify_dryrun = B_FALSE;

	/*
	* This (illegal) pool name is used when temporarily importing a spa_t in order
	* to get the vdev stats associated with the imported devices.
	*/
	#define TRYIMPORT_NAME "$import"

	/*
	* For debugging purposes: print out vdev tree during pool import.
	*/
	int spa_load_print_vdev_tree = B_FALSE;

	/*
	* A non-zero value for zfs_max_missing_tvds means that we allow importing
	* pools with missing top-level vdevs. This is strictly intended for advanced
	* pool recovery cases since missing data is almost inevitable. Pools with
	* missing devices can only be imported read-only for safety reasons, and their
	* fail-mode will be automatically set to "continue".
	*
	* With 1 missing vdev we should be able to import the pool and mount all
	* datasets. User data that was not modified after the missing device has been
	* added should be recoverable. This means that snapshots created prior to the
	* addition of that device should be completely intact.
	*
	* With 2 missing vdevs, some datasets may fail to mount since there are
	* dataset statistics that are stored as regular metadata. Some data might be
	* recoverable if those vdevs were added recently.
	*
	* With 3 or more missing vdevs, the pool is severely damaged and MOS entries
	* may be missing entirely. Chances of data recovery are very low. Note that
	* there are also risks of performing an inadvertent rewind as we might be
	* missing all the vdevs with the latest uberblocks.
	*/
	unsigned long zfs_max_missing_tvds = 0;

	/*
	* The parameters below are similar to zfs_max_missing_tvds but are only
	* intended for a preliminary open of the pool with an untrusted config which
	* might be incomplete or out-dated.
	*
	* We are more tolerant for pools opened from a cachefile since we could have
	* an out-dated cachefile where a device removal was not registered.
	* We could have set the limit arbitrarily high but in the case where devices
	* are really missing we would want to return the proper error codes; we chose
	* SPA_DVAS_PER_BP - 1 so that some copies of the MOS would still be available
	* and we get a chance to retrieve the trusted config.
	*/
	uint64_t zfs_max_missing_tvds_cachefile = SPA_DVAS_PER_BP - 1;

	/*
	* In the case where config was assembled by scanning device paths (/dev/dsks
	* by default) we are less tolerant since all the existing devices should have
	* been detected and we want spa_load to return the right error codes.
	*/
	uint64_t zfs_max_missing_tvds_scan = 0;

	/*
	* Debugging aid that pauses spa_sync() towards the end.
	*/
	boolean_t zfs_pause_spa_sync = B_FALSE;

	/*
	* Variables to indicate the livelist condense zthr func should wait at certain
	* points for the livelist to be removed - used to test condense/destroy races
	*/
	int zfs_livelist_condense_zthr_pause = 0;
	int zfs_livelist_condense_sync_pause = 0;

	/*
	* Variables to track whether or not condense cancellation has been
	* triggered in testing.
	*/
	int zfs_livelist_condense_sync_cancel = 0;
	int zfs_livelist_condense_zthr_cancel = 0;

	/*
	* Variable to track whether or not extra ALLOC blkptrs were added to a
	* livelist entry while it was being condensed (caused by the way we track
	* remapped blkptrs in dbuf_remap_impl)
	*/
	int zfs_livelist_condense_new_alloc = 0;

	/*
	* ==========================================================================
	* SPA properties routines
	* ==========================================================================
	*/

	/*
	* Add a (source=src, propname=propval) list to an nvlist.
	*/
	static void
	spa_prop_add_list(nvlist_t nvl, zpool_prop_t prop, char strval,
	uint64_t intval, zprop_source_t src)
	{
	const char *propname = zpool_prop_to_name(prop);
	nvlist_t *propval;

	VERIFY(nvlist_alloc(&propval, NV_UNIQUE_NAME, KM_SLEEP) == 0);
	VERIFY(nvlist_add_uint64(propval, ZPROP_SOURCE, src) == 0);

	if (strval != NULL)
	VERIFY(nvlist_add_string(propval, ZPROP_VALUE, strval) == 0);
	else
	VERIFY(nvlist_add_uint64(propval, ZPROP_VALUE, intval) == 0);

	VERIFY(nvlist_add_nvlist(nvl, propname, propval) == 0);
	nvlist_free(propval);
	}

	/*
	* Get property values from the spa configuration.
	*/
	static void
	spa_prop_get_config(spa_t spa, nvlist_t *nvp)
	{
	vdev_t *rvd = spa->spa_root_vdev;
	dsl_pool_t *pool = spa->spa_dsl_pool;
	uint64_t size, alloc, cap, version;
	const zprop_source_t src = ZPROP_SRC_NONE;
	spa_config_dirent_t *dp;
	metaslab_class_t *mc = spa_normal_class(spa);

	ASSERT(MUTEX_HELD(&spa->spa_props_lock));

	if (rvd != NULL) {
	alloc = metaslab_class_get_alloc(mc);
	alloc += metaslab_class_get_alloc(spa_special_class(spa));
	alloc += metaslab_class_get_alloc(spa_dedup_class(spa));
	alloc += metaslab_class_get_alloc(spa_embedded_log_class(spa));

	size = metaslab_class_get_space(mc);
	size += metaslab_class_get_space(spa_special_class(spa));
	size += metaslab_class_get_space(spa_dedup_class(spa));
	size += metaslab_class_get_space(spa_embedded_log_class(spa));

	spa_prop_add_list(*nvp, ZPOOL_PROP_NAME, spa_name(spa), 0, src);
	spa_prop_add_list(*nvp, ZPOOL_PROP_SIZE, NULL, size, src);
	spa_prop_add_list(*nvp, ZPOOL_PROP_ALLOCATED, NULL, alloc, src);
	spa_prop_add_list(*nvp, ZPOOL_PROP_FREE, NULL,
	size - alloc, src);
	spa_prop_add_list(*nvp, ZPOOL_PROP_CHECKPOINT, NULL,
	spa->spa_checkpoint_info.sci_dspace, src);

	spa_prop_add_list(*nvp, ZPOOL_PROP_FRAGMENTATION, NULL,
	metaslab_class_fragmentation(mc), src);
	spa_prop_add_list(*nvp, ZPOOL_PROP_EXPANDSZ, NULL,
	metaslab_class_expandable_space(mc), src);
	spa_prop_add_list(*nvp, ZPOOL_PROP_READONLY, NULL,
	(spa_mode(spa) == SPA_MODE_READ), src);

	cap = (size == 0) ? 0 : (alloc * 100 / size);
	spa_prop_add_list(*nvp, ZPOOL_PROP_CAPACITY, NULL, cap, src);

	spa_prop_add_list(*nvp, ZPOOL_PROP_DEDUPRATIO, NULL,
	ddt_get_pool_dedup_ratio(spa), src);

	spa_prop_add_list(*nvp, ZPOOL_PROP_HEALTH, NULL,
	rvd->vdev_state, src);

	version = spa_version(spa);
	if (version == zpool_prop_default_numeric(ZPOOL_PROP_VERSION)) {
	spa_prop_add_list(*nvp, ZPOOL_PROP_VERSION, NULL,
	version, ZPROP_SRC_DEFAULT);
	} else {
	spa_prop_add_list(*nvp, ZPOOL_PROP_VERSION, NULL,
	version, ZPROP_SRC_LOCAL);
	}
	spa_prop_add_list(*nvp, ZPOOL_PROP_LOAD_GUID,
	NULL, spa_load_guid(spa), src);
	}

	if (pool != NULL) {
	/*
	* The $FREE directory was introduced in SPA_VERSION_DEADLISTS,
	* when opening pools before this version freedir will be NULL.
	*/
	if (pool->dp_free_dir != NULL) {
	spa_prop_add_list(*nvp, ZPOOL_PROP_FREEING, NULL,
	dsl_dir_phys(pool->dp_free_dir)->dd_used_bytes,
	src);
	} else {
	spa_prop_add_list(*nvp, ZPOOL_PROP_FREEING,
	NULL, 0, src);
	}

	if (pool->dp_leak_dir != NULL) {
	spa_prop_add_list(*nvp, ZPOOL_PROP_LEAKED, NULL,
	dsl_dir_phys(pool->dp_leak_dir)->dd_used_bytes,
	src);
	} else {
	spa_prop_add_list(*nvp, ZPOOL_PROP_LEAKED,
	NULL, 0, src);
	}
	}

	spa_prop_add_list(*nvp, ZPOOL_PROP_GUID, NULL, spa_guid(spa), src);

	if (spa->spa_comment != NULL) {
	spa_prop_add_list(*nvp, ZPOOL_PROP_COMMENT, spa->spa_comment,
	0, ZPROP_SRC_LOCAL);
	}

	if (spa->spa_compatibility != NULL) {
	spa_prop_add_list(*nvp, ZPOOL_PROP_COMPATIBILITY,
	spa->spa_compatibility, 0, ZPROP_SRC_LOCAL);
	}

	if (spa->spa_root != NULL)
	spa_prop_add_list(*nvp, ZPOOL_PROP_ALTROOT, spa->spa_root,
	0, ZPROP_SRC_LOCAL);

	if (spa_feature_is_enabled(spa, SPA_FEATURE_LARGE_BLOCKS)) {
	spa_prop_add_list(*nvp, ZPOOL_PROP_MAXBLOCKSIZE, NULL,
	MIN(zfs_max_recordsize, SPA_MAXBLOCKSIZE), ZPROP_SRC_NONE);
	} else {
	spa_prop_add_list(*nvp, ZPOOL_PROP_MAXBLOCKSIZE, NULL,
	SPA_OLD_MAXBLOCKSIZE, ZPROP_SRC_NONE);
	}

	if (spa_feature_is_enabled(spa, SPA_FEATURE_LARGE_DNODE)) {
	spa_prop_add_list(*nvp, ZPOOL_PROP_MAXDNODESIZE, NULL,
	DNODE_MAX_SIZE, ZPROP_SRC_NONE);
	} else {
	spa_prop_add_list(*nvp, ZPOOL_PROP_MAXDNODESIZE, NULL,
	DNODE_MIN_SIZE, ZPROP_SRC_NONE);
	}

	if ((dp = list_head(&spa->spa_config_list)) != NULL) {
	if (dp->scd_path == NULL) {
	spa_prop_add_list(*nvp, ZPOOL_PROP_CACHEFILE,
	"none", 0, ZPROP_SRC_LOCAL);
	} else if (strcmp(dp->scd_path, spa_config_path) != 0) {
	spa_prop_add_list(*nvp, ZPOOL_PROP_CACHEFILE,
	dp->scd_path, 0, ZPROP_SRC_LOCAL);
	}
	}
	}

	/*
	* Get zpool property values.
	*/
	int
	spa_prop_get(spa_t spa, nvlist_t *nvp)
	{
	objset_t *mos = spa->spa_meta_objset;
	zap_cursor_t zc;
	zap_attribute_t za;
	dsl_pool_t *dp;
	int err;

	err = nvlist_alloc(nvp, NV_UNIQUE_NAME, KM_SLEEP);
	if (err)
	return (err);

	dp = spa_get_dsl(spa);
	dsl_pool_config_enter(dp, FTAG);
	mutex_enter(&spa->spa_props_lock);

	/*
	* Get properties from the spa config.
	*/
	spa_prop_get_config(spa, nvp);

	/* If no pool property object, no more prop to get. */
	if (mos == NULL \|\| spa->spa_pool_props_object == 0)
	goto out;

	/*
	* Get properties from the MOS pool property object.
	*/
	for (zap_cursor_init(&zc, mos, spa->spa_pool_props_object);
	(err = zap_cursor_retrieve(&zc, &za)) == 0;
	zap_cursor_advance(&zc)) {
	uint64_t intval = 0;
	char *strval = NULL;
	zprop_source_t src = ZPROP_SRC_DEFAULT;
	zpool_prop_t prop;

	if ((prop = zpool_name_to_prop(za.za_name)) == ZPOOL_PROP_INVAL)
	continue;

	switch (za.za_integer_length) {
	case 8:
	/* integer property */
	if (za.za_first_integer !=
	zpool_prop_default_numeric(prop))
	src = ZPROP_SRC_LOCAL;

	if (prop == ZPOOL_PROP_BOOTFS) {
	dsl_dataset_t *ds = NULL;

	err = dsl_dataset_hold_obj(dp,
	za.za_first_integer, FTAG, &ds);
	if (err != 0)
	break;

	strval = kmem_alloc(ZFS_MAX_DATASET_NAME_LEN,
	KM_SLEEP);
	dsl_dataset_name(ds, strval);
	dsl_dataset_rele(ds, FTAG);
	} else {
	strval = NULL;
	intval = za.za_first_integer;
	}

	spa_prop_add_list(*nvp, prop, strval, intval, src);

	if (strval != NULL)
	kmem_free(strval, ZFS_MAX_DATASET_NAME_LEN);

	break;

	case 1:
	/* string property */
	strval = kmem_alloc(za.za_num_integers, KM_SLEEP);
	err = zap_lookup(mos, spa->spa_pool_props_object,
	za.za_name, 1, za.za_num_integers, strval);
	if (err) {
	kmem_free(strval, za.za_num_integers);
	break;
	}
	spa_prop_add_list(*nvp, prop, strval, 0, src);
	kmem_free(strval, za.za_num_integers);
	break;

	default:
	break;
	}
	}
	zap_cursor_fini(&zc);
	out:
	mutex_exit(&spa->spa_props_lock);
	dsl_pool_config_exit(dp, FTAG);
	if (err && err != ENOENT) {
	nvlist_free(*nvp);
	*nvp = NULL;
	return (err);
	}

	return (0);
	}

	/*
	* Validate the given pool properties nvlist and modify the list
	* for the property values to be set.
	*/
	static int
	spa_prop_validate(spa_t spa, nvlist_t props)
	{
	nvpair_t *elem;
	int error = 0, reset_bootfs = 0;
	uint64_t objnum = 0;
	boolean_t has_feature = B_FALSE;

	elem = NULL;
	while ((elem = nvlist_next_nvpair(props, elem)) != NULL) {
	uint64_t intval;
	char strval, slash, check, fname;
	const char *propname = nvpair_name(elem);
	zpool_prop_t prop = zpool_name_to_prop(propname);

	switch (prop) {
	case ZPOOL_PROP_INVAL:
	if (!zpool_prop_feature(propname)) {
	error = SET_ERROR(EINVAL);
	break;
	}

	/*
	* Sanitize the input.
	*/
	if (nvpair_type(elem) != DATA_TYPE_UINT64) {
	error = SET_ERROR(EINVAL);
	break;
	}

	if (nvpair_value_uint64(elem, &intval) != 0) {
	error = SET_ERROR(EINVAL);
	break;
	}

	if (intval != 0) {
	error = SET_ERROR(EINVAL);
	break;
	}

	fname = strchr(propname, '@') + 1;
	if (zfeature_lookup_name(fname, NULL) != 0) {
	error = SET_ERROR(EINVAL);
	break;
	}

	has_feature = B_TRUE;
	break;

	case ZPOOL_PROP_VERSION:
	error = nvpair_value_uint64(elem, &intval);
	if (!error &&
	(intval < spa_version(spa) \|\|
	intval > SPA_VERSION_BEFORE_FEATURES \|\|
	has_feature))
	error = SET_ERROR(EINVAL);
	break;

	case ZPOOL_PROP_DELEGATION:
	case ZPOOL_PROP_AUTOREPLACE:
	case ZPOOL_PROP_LISTSNAPS:
	case ZPOOL_PROP_AUTOEXPAND:
	case ZPOOL_PROP_AUTOTRIM:
	error = nvpair_value_uint64(elem, &intval);
	if (!error && intval > 1)
	error = SET_ERROR(EINVAL);
	break;

	case ZPOOL_PROP_MULTIHOST:
	error = nvpair_value_uint64(elem, &intval);
	if (!error && intval > 1)
	error = SET_ERROR(EINVAL);

	if (!error) {
	uint32_t hostid = zone_get_hostid(NULL);
	if (hostid)
	spa->spa_hostid = hostid;
	else
	error = SET_ERROR(ENOTSUP);
	}

	break;

	case ZPOOL_PROP_BOOTFS:
	/*
	* If the pool version is less than SPA_VERSION_BOOTFS,
	* or the pool is still being created (version == 0),
	* the bootfs property cannot be set.
	*/
	if (spa_version(spa) < SPA_VERSION_BOOTFS) {
	error = SET_ERROR(ENOTSUP);
	break;
	}

	/*
	* Make sure the vdev config is bootable
	*/
	if (!vdev_is_bootable(spa->spa_root_vdev)) {
	error = SET_ERROR(ENOTSUP);
	break;
	}

	reset_bootfs = 1;

	error = nvpair_value_string(elem, &strval);

	if (!error) {
	objset_t *os;

	if (strval == NULL \|\| strval[0] == '\0') {
	objnum = zpool_prop_default_numeric(
	ZPOOL_PROP_BOOTFS);
	break;
	}

	error = dmu_objset_hold(strval, FTAG, &os);
	if (error != 0)
	break;

	/* Must be ZPL. */
	if (dmu_objset_type(os) != DMU_OST_ZFS) {
	error = SET_ERROR(ENOTSUP);
	} else {
	objnum = dmu_objset_id(os);
	}
	dmu_objset_rele(os, FTAG);
	}
	break;

	case ZPOOL_PROP_FAILUREMODE:
	error = nvpair_value_uint64(elem, &intval);
	if (!error && intval > ZIO_FAILURE_MODE_PANIC)
	error = SET_ERROR(EINVAL);

	/*
	* This is a special case which only occurs when
	* the pool has completely failed. This allows
	* the user to change the in-core failmode property
	* without syncing it out to disk (I/Os might
	* currently be blocked). We do this by returning
	* EIO to the caller (spa_prop_set) to trick it
	* into thinking we encountered a property validation
	* error.
	*/
	if (!error && spa_suspended(spa)) {
	spa->spa_failmode = intval;
	error = SET_ERROR(EIO);
	}
	break;

	case ZPOOL_PROP_CACHEFILE:
	if ((error = nvpair_value_string(elem, &strval)) != 0)
	break;

	if (strval[0] == '\0')
	break;

	if (strcmp(strval, "none") == 0)
	break;

	if (strval[0] != '/') {
	error = SET_ERROR(EINVAL);
	break;
	}

	slash = strrchr(strval, '/');
	ASSERT(slash != NULL);

	if (slash[1] == '\0' \|\| strcmp(slash, "/.") == 0 \|\|
	strcmp(slash, "/..") == 0)
	error = SET_ERROR(EINVAL);
	break;

	case ZPOOL_PROP_COMMENT:
	if ((error = nvpair_value_string(elem, &strval)) != 0)
	break;
	for (check = strval; *check != '\0'; check++) {
	if (!isprint(*check)) {
	error = SET_ERROR(EINVAL);
	break;
	}
	}
	if (strlen(strval) > ZPROP_MAX_COMMENT)
	error = SET_ERROR(E2BIG);
	break;

	default:
	break;
	}

	if (error)
	break;
	}

	(void) nvlist_remove_all(props,
	zpool_prop_to_name(ZPOOL_PROP_DEDUPDITTO));

	if (!error && reset_bootfs) {
	error = nvlist_remove(props,
	zpool_prop_to_name(ZPOOL_PROP_BOOTFS), DATA_TYPE_STRING);

	if (!error) {
	error = nvlist_add_uint64(props,
	zpool_prop_to_name(ZPOOL_PROP_BOOTFS), objnum);
	}
	}

	return (error);
	}

	void
	spa_configfile_set(spa_t spa, nvlist_t nvp, boolean_t need_sync)
	{
	char *cachefile;
	spa_config_dirent_t *dp;

	if (nvlist_lookup_string(nvp, zpool_prop_to_name(ZPOOL_PROP_CACHEFILE),
	&cachefile) != 0)
	return;

	dp = kmem_alloc(sizeof (spa_config_dirent_t),
	KM_SLEEP);

	if (cachefile[0] == '\0')
	dp->scd_path = spa_strdup(spa_config_path);
	else if (strcmp(cachefile, "none") == 0)
	dp->scd_path = NULL;
	else
	dp->scd_path = spa_strdup(cachefile);

	list_insert_head(&spa->spa_config_list, dp);
	if (need_sync)
	spa_async_request(spa, SPA_ASYNC_CONFIG_UPDATE);
	}

	int
	spa_prop_set(spa_t spa, nvlist_t nvp)
	{
	int error;
	nvpair_t *elem = NULL;
	boolean_t need_sync = B_FALSE;

	if ((error = spa_prop_validate(spa, nvp)) != 0)
	return (error);

	while ((elem = nvlist_next_nvpair(nvp, elem)) != NULL) {
	zpool_prop_t prop = zpool_name_to_prop(nvpair_name(elem));

	if (prop == ZPOOL_PROP_CACHEFILE \|\|
	prop == ZPOOL_PROP_ALTROOT \|\|
	prop == ZPOOL_PROP_READONLY)
	continue;

	if (prop == ZPOOL_PROP_VERSION \|\| prop == ZPOOL_PROP_INVAL) {
	uint64_t ver;

	if (prop == ZPOOL_PROP_VERSION) {
	VERIFY(nvpair_value_uint64(elem, &ver) == 0);
	} else {
	ASSERT(zpool_prop_feature(nvpair_name(elem)));
	ver = SPA_VERSION_FEATURES;
	need_sync = B_TRUE;
	}

	/* Save time if the version is already set. */
	if (ver == spa_version(spa))
	continue;

	/*
	* In addition to the pool directory object, we might
	* create the pool properties object, the features for
	* read object, the features for write object, or the
	* feature descriptions object.
	*/
	error = dsl_sync_task(spa->spa_name, NULL,
	spa_sync_version, &ver,
	6, ZFS_SPACE_CHECK_RESERVED);
	if (error)
	return (error);
	continue;
	}

	need_sync = B_TRUE;
	break;
	}

	if (need_sync) {
	return (dsl_sync_task(spa->spa_name, NULL, spa_sync_props,
	nvp, 6, ZFS_SPACE_CHECK_RESERVED));
	}

	return (0);
	}

	/*
	* If the bootfs property value is dsobj, clear it.
	*/
	void
	spa_prop_clear_bootfs(spa_t spa, uint64_t dsobj, dmu_tx_t tx)
	{
	if (spa->spa_bootfs == dsobj && spa->spa_pool_props_object != 0) {
	VERIFY(zap_remove(spa->spa_meta_objset,
	spa->spa_pool_props_object,
	zpool_prop_to_name(ZPOOL_PROP_BOOTFS), tx) == 0);
	spa->spa_bootfs = 0;
	}
	}

	/ARGSUSED/
	static int
	spa_change_guid_check(void arg, dmu_tx_t tx)
	{
	uint64_t *newguid __maybe_unused = arg;
	spa_t *spa = dmu_tx_pool(tx)->dp_spa;
	vdev_t *rvd = spa->spa_root_vdev;
	uint64_t vdev_state;

	if (spa_feature_is_active(spa, SPA_FEATURE_POOL_CHECKPOINT)) {
	int error = (spa_has_checkpoint(spa)) ?
	ZFS_ERR_CHECKPOINT_EXISTS : ZFS_ERR_DISCARDING_CHECKPOINT;
	return (SET_ERROR(error));
	}

	spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
	vdev_state = rvd->vdev_state;
	spa_config_exit(spa, SCL_STATE, FTAG);

	if (vdev_state != VDEV_STATE_HEALTHY)
	return (SET_ERROR(ENXIO));

	ASSERT3U(spa_guid(spa), !=, *newguid);

	return (0);
	}

	static void
	spa_change_guid_sync(void arg, dmu_tx_t tx)
	{
	uint64_t *newguid = arg;
	spa_t *spa = dmu_tx_pool(tx)->dp_spa;
	uint64_t oldguid;
	vdev_t *rvd = spa->spa_root_vdev;

	oldguid = spa_guid(spa);

	spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
	rvd->vdev_guid = *newguid;
	rvd->vdev_guid_sum += (*newguid - oldguid);
	vdev_config_dirty(rvd);
	spa_config_exit(spa, SCL_STATE, FTAG);

	spa_history_log_internal(spa, "guid change", tx, "old=%llu new=%llu",
	(u_longlong_t)oldguid, (u_longlong_t)*newguid);
	}

	/*
	* Change the GUID for the pool. This is done so that we can later
	* re-import a pool built from a clone of our own vdevs. We will modify
	* the root vdev's guid, our own pool guid, and then mark all of our
	* vdevs dirty. Note that we must make sure that all our vdevs are
	* online when we do this, or else any vdevs that weren't present
	* would be orphaned from our pool. We are also going to issue a
	* sysevent to update any watchers.
	*/
	int
	spa_change_guid(spa_t *spa)
	{
	int error;
	uint64_t guid;

	mutex_enter(&spa->spa_vdev_top_lock);
	mutex_enter(&spa_namespace_lock);
	guid = spa_generate_guid(NULL);

	error = dsl_sync_task(spa->spa_name, spa_change_guid_check,
	spa_change_guid_sync, &guid, 5, ZFS_SPACE_CHECK_RESERVED);

	if (error == 0) {
	spa_write_cachefile(spa, B_FALSE, B_TRUE);
	spa_event_notify(spa, NULL, NULL, ESC_ZFS_POOL_REGUID);
	}

	mutex_exit(&spa_namespace_lock);
	mutex_exit(&spa->spa_vdev_top_lock);

	return (error);
	}

	/*
	* ==========================================================================
	* SPA state manipulation (open/create/destroy/import/export)
	* ==========================================================================
	*/

	static int
	spa_error_entry_compare(const void a, const void b)
	{
	const spa_error_entry_t sa = (const spa_error_entry_t )a;
	const spa_error_entry_t sb = (const spa_error_entry_t )b;
	int ret;

	ret = memcmp(&sa->se_bookmark, &sb->se_bookmark,
	sizeof (zbookmark_phys_t));

	return (TREE_ISIGN(ret));
	}

	/*
	* Utility function which retrieves copies of the current logs and
	* re-initializes them in the process.
	*/
	void
	spa_get_errlists(spa_t spa, avl_tree_t last, avl_tree_t *scrub)
	{
	ASSERT(MUTEX_HELD(&spa->spa_errlist_lock));

	bcopy(&spa->spa_errlist_last, last, sizeof (avl_tree_t));
	bcopy(&spa->spa_errlist_scrub, scrub, sizeof (avl_tree_t));

	avl_create(&spa->spa_errlist_scrub,
	spa_error_entry_compare, sizeof (spa_error_entry_t),
	offsetof(spa_error_entry_t, se_avl));
	avl_create(&spa->spa_errlist_last,
	spa_error_entry_compare, sizeof (spa_error_entry_t),
	offsetof(spa_error_entry_t, se_avl));
	}

	static void
	spa_taskqs_init(spa_t *spa, zio_type_t t, zio_taskq_type_t q)
	{
	const zio_taskq_info_t *ztip = &zio_taskqs[t][q];
	enum zti_modes mode = ztip->zti_mode;
	uint_t value = ztip->zti_value;
	uint_t count = ztip->zti_count;
	spa_taskqs_t *tqs = &spa->spa_zio_taskq[t][q];
	- uint_t flags = 0;
	+ uint_t cpus, flags = TASKQ_DYNAMIC;
	boolean_t batch = B_FALSE;

	- if (mode == ZTI_MODE_NULL) {
	- tqs->stqs_count = 0;
	- tqs->stqs_taskq = NULL;
	- return;
	- }
	-
	- ASSERT3U(count, >, 0);
	-
	- tqs->stqs_count = count;
	- tqs->stqs_taskq = kmem_alloc(count * sizeof (taskq_t *), KM_SLEEP);
	-
	switch (mode) {
	case ZTI_MODE_FIXED:
	- ASSERT3U(value, >=, 1);
	- value = MAX(value, 1);
	- flags \|= TASKQ_DYNAMIC;
	+ ASSERT3U(value, >, 0);
	break;

	case ZTI_MODE_BATCH:
	batch = B_TRUE;
	flags \|= TASKQ_THREADS_CPU_PCT;
	value = MIN(zio_taskq_batch_pct, 100);
	break;

	+ case ZTI_MODE_SCALE:
	+ flags \|= TASKQ_THREADS_CPU_PCT;
	+ /*
	+ * We want more taskqs to reduce lock contention, but we want
	+ * less for better request ordering and CPU utilization.
	+ */
	+ cpus = MAX(1, boot_ncpus * zio_taskq_batch_pct / 100);
	+ if (zio_taskq_batch_tpq > 0) {
	+ count = MAX(1, (cpus + zio_taskq_batch_tpq / 2) /
	+ zio_taskq_batch_tpq);
	+ } else {
	+ /*
	+ * Prefer 6 threads per taskq, but no more taskqs
	+ * than threads in them on large systems. For 80%:
	+ *
	+ * taskq taskq total
	+ * cpus taskqs percent threads threads
	+ * ------- ------- ------- ------- -------
	+ * 1 1 80% 1 1
	+ * 2 1 80% 1 1
	+ * 4 1 80% 3 3
	+ * 8 2 40% 3 6
	+ * 16 3 27% 4 12
	+ * 32 5 16% 5 25
	+ * 64 7 11% 7 49
	+ * 128 10 8% 10 100
	+ * 256 14 6% 15 210
	+ */
	+ count = 1 + cpus / 6;
	+ while (count * count > cpus)
	+ count--;
	+ }
	+ /* Limit each taskq within 100% to not trigger assertion. */
	+ count = MAX(count, (zio_taskq_batch_pct + 99) / 100);
	+ value = (zio_taskq_batch_pct + count / 2) / count;
	+ break;
	+
	+ case ZTI_MODE_NULL:
	+ tqs->stqs_count = 0;
	+ tqs->stqs_taskq = NULL;
	+ return;
	+
	default:
	panic("unrecognized mode for %s_%s taskq (%u:%u) in "
	"spa_activate()",
	zio_type_name[t], zio_taskq_types[q], mode, value);
	break;
	}

	+ ASSERT3U(count, >, 0);
	+ tqs->stqs_count = count;
	+ tqs->stqs_taskq = kmem_alloc(count * sizeof (taskq_t *), KM_SLEEP);
	+
	for (uint_t i = 0; i < count; i++) {
	taskq_t *tq;
	char name[32];

	- (void) snprintf(name, sizeof (name), "%s_%s",
	- zio_type_name[t], zio_taskq_types[q]);
	+ if (count > 1)
	+ (void) snprintf(name, sizeof (name), "%s_%s_%u",
	+ zio_type_name[t], zio_taskq_types[q], i);
	+ else
	+ (void) snprintf(name, sizeof (name), "%s_%s",
	+ zio_type_name[t], zio_taskq_types[q]);

	if (zio_taskq_sysdc && spa->spa_proc != &p0) {
	if (batch)
	flags \|= TASKQ_DC_BATCH;

	tq = taskq_create_sysdc(name, value, 50, INT_MAX,
	spa->spa_proc, zio_taskq_basedc, flags);
	} else {
	pri_t pri = maxclsyspri;
	/*
	* The write issue taskq can be extremely CPU
	* intensive. Run it at slightly less important
	* priority than the other taskqs.
	*
	* Under Linux and FreeBSD this means incrementing
	* the priority value as opposed to platforms like
	* illumos where it should be decremented.
	*
	* On FreeBSD, if priorities divided by four (RQ_PPQ)
	* are equal then a difference between them is
	* insignificant.
	*/
	if (t == ZIO_TYPE_WRITE && q == ZIO_TASKQ_ISSUE) {
	#if defined(__linux__)
	pri++;
	#elif defined(__FreeBSD__)
	pri += 4;
	#else
	#error "unknown OS"
	#endif
	}
	tq = taskq_create_proc(name, value, pri, 50,
	INT_MAX, spa->spa_proc, flags);
	}

	tqs->stqs_taskq[i] = tq;
	}
	}

	static void
	spa_taskqs_fini(spa_t *spa, zio_type_t t, zio_taskq_type_t q)
	{
	spa_taskqs_t *tqs = &spa->spa_zio_taskq[t][q];

	if (tqs->stqs_taskq == NULL) {
	ASSERT3U(tqs->stqs_count, ==, 0);
	return;
	}

	for (uint_t i = 0; i < tqs->stqs_count; i++) {
	ASSERT3P(tqs->stqs_taskq[i], !=, NULL);
	taskq_destroy(tqs->stqs_taskq[i]);
	}

	kmem_free(tqs->stqs_taskq, tqs->stqs_count * sizeof (taskq_t *));
	tqs->stqs_taskq = NULL;
	}

	/*
	* Dispatch a task to the appropriate taskq for the ZFS I/O type and priority.
	* Note that a type may have multiple discrete taskqs to avoid lock contention
	* on the taskq itself. In that case we choose which taskq at random by using
	* the low bits of gethrtime().
	*/
	void
	spa_taskq_dispatch_ent(spa_t *spa, zio_type_t t, zio_taskq_type_t q,
	task_func_t func, void arg, uint_t flags, taskq_ent_t *ent)
	{
	spa_taskqs_t *tqs = &spa->spa_zio_taskq[t][q];
	taskq_t *tq;

	ASSERT3P(tqs->stqs_taskq, !=, NULL);
	ASSERT3U(tqs->stqs_count, !=, 0);

	if (tqs->stqs_count == 1) {
	tq = tqs->stqs_taskq[0];
	} else {
	tq = tqs->stqs_taskq[((uint64_t)gethrtime()) % tqs->stqs_count];
	}

	taskq_dispatch_ent(tq, func, arg, flags, ent);
	}

	/*
	* Same as spa_taskq_dispatch_ent() but block on the task until completion.
	*/
	void
	spa_taskq_dispatch_sync(spa_t *spa, zio_type_t t, zio_taskq_type_t q,
	task_func_t func, void arg, uint_t flags)
	{
	spa_taskqs_t *tqs = &spa->spa_zio_taskq[t][q];
	taskq_t *tq;
	taskqid_t id;

	ASSERT3P(tqs->stqs_taskq, !=, NULL);
	ASSERT3U(tqs->stqs_count, !=, 0);

	if (tqs->stqs_count == 1) {
	tq = tqs->stqs_taskq[0];
	} else {
	tq = tqs->stqs_taskq[((uint64_t)gethrtime()) % tqs->stqs_count];
	}

	id = taskq_dispatch(tq, func, arg, flags);
	if (id)
	taskq_wait_id(tq, id);
	}

	static void
	spa_create_zio_taskqs(spa_t *spa)
	{
	for (int t = 0; t < ZIO_TYPES; t++) {
	for (int q = 0; q < ZIO_TASKQ_TYPES; q++) {
	spa_taskqs_init(spa, t, q);
	}
	}
	}

	/*
	* Disabled until spa_thread() can be adapted for Linux.
	*/
	#undef HAVE_SPA_THREAD

	#if defined(_KERNEL) && defined(HAVE_SPA_THREAD)
	static void
	spa_thread(void *arg)
	{
	psetid_t zio_taskq_psrset_bind = PS_NONE;
	callb_cpr_t cprinfo;

	spa_t *spa = arg;
	user_t *pu = PTOU(curproc);

	CALLB_CPR_INIT(&cprinfo, &spa->spa_proc_lock, callb_generic_cpr,
	spa->spa_name);

	ASSERT(curproc != &p0);
	(void) snprintf(pu->u_psargs, sizeof (pu->u_psargs),
	"zpool-%s", spa->spa_name);
	(void) strlcpy(pu->u_comm, pu->u_psargs, sizeof (pu->u_comm));

	/* bind this thread to the requested psrset */
	if (zio_taskq_psrset_bind != PS_NONE) {
	pool_lock();
	mutex_enter(&cpu_lock);
	mutex_enter(&pidlock);
	mutex_enter(&curproc->p_lock);

	if (cpupart_bind_thread(curthread, zio_taskq_psrset_bind,
	0, NULL, NULL) == 0) {
	curthread->t_bind_pset = zio_taskq_psrset_bind;
	} else {
	cmn_err(CE_WARN,
	"Couldn't bind process for zfs pool \"%s\" to "
	"pset %d\n", spa->spa_name, zio_taskq_psrset_bind);
	}

	mutex_exit(&curproc->p_lock);
	mutex_exit(&pidlock);
	mutex_exit(&cpu_lock);
	pool_unlock();
	}

	if (zio_taskq_sysdc) {
	sysdc_thread_enter(curthread, 100, 0);
	}

	spa->spa_proc = curproc;
	spa->spa_did = curthread->t_did;

	spa_create_zio_taskqs(spa);

	mutex_enter(&spa->spa_proc_lock);
	ASSERT(spa->spa_proc_state == SPA_PROC_CREATED);

	spa->spa_proc_state = SPA_PROC_ACTIVE;
	cv_broadcast(&spa->spa_proc_cv);

	CALLB_CPR_SAFE_BEGIN(&cprinfo);
	while (spa->spa_proc_state == SPA_PROC_ACTIVE)
	cv_wait(&spa->spa_proc_cv, &spa->spa_proc_lock);
	CALLB_CPR_SAFE_END(&cprinfo, &spa->spa_proc_lock);

	ASSERT(spa->spa_proc_state == SPA_PROC_DEACTIVATE);
	spa->spa_proc_state = SPA_PROC_GONE;
	spa->spa_proc = &p0;
	cv_broadcast(&spa->spa_proc_cv);
	CALLB_CPR_EXIT(&cprinfo); /* drops spa_proc_lock */

	mutex_enter(&curproc->p_lock);
	lwp_exit();
	}
	#endif

	/*
	* Activate an uninitialized pool.
	*/
	static void
	spa_activate(spa_t *spa, spa_mode_t mode)
	{
	ASSERT(spa->spa_state == POOL_STATE_UNINITIALIZED);

	spa->spa_state = POOL_STATE_ACTIVE;
	spa->spa_mode = mode;

	spa->spa_normal_class = metaslab_class_create(spa, zfs_metaslab_ops);
	spa->spa_log_class = metaslab_class_create(spa, zfs_metaslab_ops);
	spa->spa_embedded_log_class =
	metaslab_class_create(spa, zfs_metaslab_ops);
	spa->spa_special_class = metaslab_class_create(spa, zfs_metaslab_ops);
	spa->spa_dedup_class = metaslab_class_create(spa, zfs_metaslab_ops);

	/* Try to create a covering process */
	mutex_enter(&spa->spa_proc_lock);
	ASSERT(spa->spa_proc_state == SPA_PROC_NONE);
	ASSERT(spa->spa_proc == &p0);
	spa->spa_did = 0;

	#ifdef HAVE_SPA_THREAD
	/* Only create a process if we're going to be around a while. */
	if (spa_create_process && strcmp(spa->spa_name, TRYIMPORT_NAME) != 0) {
	if (newproc(spa_thread, (caddr_t)spa, syscid, maxclsyspri,
	NULL, 0) == 0) {
	spa->spa_proc_state = SPA_PROC_CREATED;
	while (spa->spa_proc_state == SPA_PROC_CREATED) {
	cv_wait(&spa->spa_proc_cv,
	&spa->spa_proc_lock);
	}
	ASSERT(spa->spa_proc_state == SPA_PROC_ACTIVE);
	ASSERT(spa->spa_proc != &p0);
	ASSERT(spa->spa_did != 0);
	} else {
	#ifdef _KERNEL
	cmn_err(CE_WARN,
	"Couldn't create process for zfs pool \"%s\"\n",
	spa->spa_name);
	#endif
	}
	}
	#endif /* HAVE_SPA_THREAD */
	mutex_exit(&spa->spa_proc_lock);

	/* If we didn't create a process, we need to create our taskqs. */
	if (spa->spa_proc == &p0) {
	spa_create_zio_taskqs(spa);
	}

	for (size_t i = 0; i < TXG_SIZE; i++) {
	spa->spa_txg_zio[i] = zio_root(spa, NULL, NULL,
	ZIO_FLAG_CANFAIL);
	}

	list_create(&spa->spa_config_dirty_list, sizeof (vdev_t),
	offsetof(vdev_t, vdev_config_dirty_node));
	list_create(&spa->spa_evicting_os_list, sizeof (objset_t),
	offsetof(objset_t, os_evicting_node));
	list_create(&spa->spa_state_dirty_list, sizeof (vdev_t),
	offsetof(vdev_t, vdev_state_dirty_node));

	txg_list_create(&spa->spa_vdev_txg_list, spa,
	offsetof(struct vdev, vdev_txg_node));

	avl_create(&spa->spa_errlist_scrub,
	spa_error_entry_compare, sizeof (spa_error_entry_t),
	offsetof(spa_error_entry_t, se_avl));
	avl_create(&spa->spa_errlist_last,
	spa_error_entry_compare, sizeof (spa_error_entry_t),
	offsetof(spa_error_entry_t, se_avl));

	spa_keystore_init(&spa->spa_keystore);

	/*
	* This taskq is used to perform zvol-minor-related tasks
	* asynchronously. This has several advantages, including easy
	* resolution of various deadlocks.
	*
	* The taskq must be single threaded to ensure tasks are always
	* processed in the order in which they were dispatched.
	*
	* A taskq per pool allows one to keep the pools independent.
	* This way if one pool is suspended, it will not impact another.
	*
	* The preferred location to dispatch a zvol minor task is a sync
	* task. In this context, there is easy access to the spa_t and minimal
	* error handling is required because the sync task must succeed.
	*/
	spa->spa_zvol_taskq = taskq_create("z_zvol", 1, defclsyspri,
	1, INT_MAX, 0);

	/*
	* Taskq dedicated to prefetcher threads: this is used to prevent the
	* pool traverse code from monopolizing the global (and limited)
	* system_taskq by inappropriately scheduling long running tasks on it.
	*/
	spa->spa_prefetch_taskq = taskq_create("z_prefetch", 100,
	defclsyspri, 1, INT_MAX, TASKQ_DYNAMIC \| TASKQ_THREADS_CPU_PCT);

	/*
	* The taskq to upgrade datasets in this pool. Currently used by
	* feature SPA_FEATURE_USEROBJ_ACCOUNTING/SPA_FEATURE_PROJECT_QUOTA.
	*/
	spa->spa_upgrade_taskq = taskq_create("z_upgrade", 100,
	defclsyspri, 1, INT_MAX, TASKQ_DYNAMIC \| TASKQ_THREADS_CPU_PCT);
	}

	/*
	* Opposite of spa_activate().
	*/
	static void
	spa_deactivate(spa_t *spa)
	{
	ASSERT(spa->spa_sync_on == B_FALSE);
	ASSERT(spa->spa_dsl_pool == NULL);
	ASSERT(spa->spa_root_vdev == NULL);
	ASSERT(spa->spa_async_zio_root == NULL);
	ASSERT(spa->spa_state != POOL_STATE_UNINITIALIZED);

	spa_evicting_os_wait(spa);

	if (spa->spa_zvol_taskq) {
	taskq_destroy(spa->spa_zvol_taskq);
	spa->spa_zvol_taskq = NULL;
	}

	if (spa->spa_prefetch_taskq) {
	taskq_destroy(spa->spa_prefetch_taskq);
	spa->spa_prefetch_taskq = NULL;
	}

	if (spa->spa_upgrade_taskq) {
	taskq_destroy(spa->spa_upgrade_taskq);
	spa->spa_upgrade_taskq = NULL;
	}

	txg_list_destroy(&spa->spa_vdev_txg_list);

	list_destroy(&spa->spa_config_dirty_list);
	list_destroy(&spa->spa_evicting_os_list);
	list_destroy(&spa->spa_state_dirty_list);

	taskq_cancel_id(system_delay_taskq, spa->spa_deadman_tqid);

	for (int t = 0; t < ZIO_TYPES; t++) {
	for (int q = 0; q < ZIO_TASKQ_TYPES; q++) {
	spa_taskqs_fini(spa, t, q);
	}
	}

	for (size_t i = 0; i < TXG_SIZE; i++) {
	ASSERT3P(spa->spa_txg_zio[i], !=, NULL);
	VERIFY0(zio_wait(spa->spa_txg_zio[i]));
	spa->spa_txg_zio[i] = NULL;
	}

	metaslab_class_destroy(spa->spa_normal_class);
	spa->spa_normal_class = NULL;

	metaslab_class_destroy(spa->spa_log_class);
	spa->spa_log_class = NULL;

	metaslab_class_destroy(spa->spa_embedded_log_class);
	spa->spa_embedded_log_class = NULL;

	metaslab_class_destroy(spa->spa_special_class);
	spa->spa_special_class = NULL;

	metaslab_class_destroy(spa->spa_dedup_class);
	spa->spa_dedup_class = NULL;

	/*
	* If this was part of an import or the open otherwise failed, we may
	* still have errors left in the queues. Empty them just in case.
	*/
	spa_errlog_drain(spa);
	avl_destroy(&spa->spa_errlist_scrub);
	avl_destroy(&spa->spa_errlist_last);

	spa_keystore_fini(&spa->spa_keystore);

	spa->spa_state = POOL_STATE_UNINITIALIZED;

	mutex_enter(&spa->spa_proc_lock);
	if (spa->spa_proc_state != SPA_PROC_NONE) {
	ASSERT(spa->spa_proc_state == SPA_PROC_ACTIVE);
	spa->spa_proc_state = SPA_PROC_DEACTIVATE;
	cv_broadcast(&spa->spa_proc_cv);
	while (spa->spa_proc_state == SPA_PROC_DEACTIVATE) {
	ASSERT(spa->spa_proc != &p0);
	cv_wait(&spa->spa_proc_cv, &spa->spa_proc_lock);
	}
	ASSERT(spa->spa_proc_state == SPA_PROC_GONE);
	spa->spa_proc_state = SPA_PROC_NONE;
	}
	ASSERT(spa->spa_proc == &p0);
	mutex_exit(&spa->spa_proc_lock);

	/*
	* We want to make sure spa_thread() has actually exited the ZFS
	* module, so that the module can't be unloaded out from underneath
	* it.
	*/
	if (spa->spa_did != 0) {
	thread_join(spa->spa_did);
	spa->spa_did = 0;
	}
	}

	/*
	* Verify a pool configuration, and construct the vdev tree appropriately. This
	* will create all the necessary vdevs in the appropriate layout, with each vdev
	* in the CLOSED state. This will prep the pool before open/creation/import.
	* All vdev validation is done by the vdev_alloc() routine.
	*/
	int
	spa_config_parse(spa_t spa, vdev_t vdp, nvlist_t nv, vdev_t *parent,
	uint_t id, int atype)
	{
	nvlist_t **child;
	uint_t children;
	int error;

	if ((error = vdev_alloc(spa, vdp, nv, parent, id, atype)) != 0)
	return (error);

	if ((*vdp)->vdev_ops->vdev_op_leaf)
	return (0);

	error = nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
	&child, &children);

	if (error == ENOENT)
	return (0);

	if (error) {
	vdev_free(*vdp);
	*vdp = NULL;
	return (SET_ERROR(EINVAL));
	}

	for (int c = 0; c < children; c++) {
	vdev_t *vd;
	if ((error = spa_config_parse(spa, &vd, child[c], *vdp, c,
	atype)) != 0) {
	vdev_free(*vdp);
	*vdp = NULL;
	return (error);
	}
	}

	ASSERT(*vdp != NULL);

	return (0);
	}

	static boolean_t
	spa_should_flush_logs_on_unload(spa_t *spa)
	{
	if (!spa_feature_is_active(spa, SPA_FEATURE_LOG_SPACEMAP))
	return (B_FALSE);

	if (!spa_writeable(spa))
	return (B_FALSE);

	if (!spa->spa_sync_on)
	return (B_FALSE);

	if (spa_state(spa) != POOL_STATE_EXPORTED)
	return (B_FALSE);

	if (zfs_keep_log_spacemaps_at_export)
	return (B_FALSE);

	return (B_TRUE);
	}

	/*
	* Opens a transaction that will set the flag that will instruct
	* spa_sync to attempt to flush all the metaslabs for that txg.
	*/
	static void
	spa_unload_log_sm_flush_all(spa_t *spa)
	{
	dmu_tx_t *tx = dmu_tx_create_dd(spa_get_dsl(spa)->dp_mos_dir);
	VERIFY0(dmu_tx_assign(tx, TXG_WAIT));

	ASSERT3U(spa->spa_log_flushall_txg, ==, 0);
	spa->spa_log_flushall_txg = dmu_tx_get_txg(tx);

	dmu_tx_commit(tx);
	txg_wait_synced(spa_get_dsl(spa), spa->spa_log_flushall_txg);
	}

	static void
	spa_unload_log_sm_metadata(spa_t *spa)
	{
	void *cookie = NULL;
	spa_log_sm_t *sls;
	while ((sls = avl_destroy_nodes(&spa->spa_sm_logs_by_txg,
	&cookie)) != NULL) {
	VERIFY0(sls->sls_mscount);
	kmem_free(sls, sizeof (spa_log_sm_t));
	}

	for (log_summary_entry_t *e = list_head(&spa->spa_log_summary);
	e != NULL; e = list_head(&spa->spa_log_summary)) {
	VERIFY0(e->lse_mscount);
	list_remove(&spa->spa_log_summary, e);
	kmem_free(e, sizeof (log_summary_entry_t));
	}

	spa->spa_unflushed_stats.sus_nblocks = 0;
	spa->spa_unflushed_stats.sus_memused = 0;
	spa->spa_unflushed_stats.sus_blocklimit = 0;
	}

	static void
	spa_destroy_aux_threads(spa_t *spa)
	{
	if (spa->spa_condense_zthr != NULL) {
	zthr_destroy(spa->spa_condense_zthr);
	spa->spa_condense_zthr = NULL;
	}
	if (spa->spa_checkpoint_discard_zthr != NULL) {
	zthr_destroy(spa->spa_checkpoint_discard_zthr);
	spa->spa_checkpoint_discard_zthr = NULL;
	}
	if (spa->spa_livelist_delete_zthr != NULL) {
	zthr_destroy(spa->spa_livelist_delete_zthr);
	spa->spa_livelist_delete_zthr = NULL;
	}
	if (spa->spa_livelist_condense_zthr != NULL) {
	zthr_destroy(spa->spa_livelist_condense_zthr);
	spa->spa_livelist_condense_zthr = NULL;
	}
	}

	/*
	* Opposite of spa_load().
	*/
	static void
	spa_unload(spa_t *spa)
	{
	ASSERT(MUTEX_HELD(&spa_namespace_lock));
	ASSERT(spa_state(spa) != POOL_STATE_UNINITIALIZED);

	spa_import_progress_remove(spa_guid(spa));
	spa_load_note(spa, "UNLOADING");

	spa_wake_waiters(spa);

	/*
	* If the log space map feature is enabled and the pool is getting
	* exported (but not destroyed), we want to spend some time flushing
	* as many metaslabs as we can in an attempt to destroy log space
	* maps and save import time.
	*/
	if (spa_should_flush_logs_on_unload(spa))
	spa_unload_log_sm_flush_all(spa);

	/*
	* Stop async tasks.
	*/
	spa_async_suspend(spa);

	if (spa->spa_root_vdev) {
	vdev_t *root_vdev = spa->spa_root_vdev;
	vdev_initialize_stop_all(root_vdev, VDEV_INITIALIZE_ACTIVE);
	vdev_trim_stop_all(root_vdev, VDEV_TRIM_ACTIVE);
	vdev_autotrim_stop_all(spa);
	vdev_rebuild_stop_all(spa);
	}

	/*
	* Stop syncing.
	*/
	if (spa->spa_sync_on) {
	txg_sync_stop(spa->spa_dsl_pool);
	spa->spa_sync_on = B_FALSE;
	}

	/*
	* This ensures that there is no async metaslab prefetching
	* while we attempt to unload the spa.
	*/
	if (spa->spa_root_vdev != NULL) {
	for (int c = 0; c < spa->spa_root_vdev->vdev_children; c++) {
	vdev_t *vc = spa->spa_root_vdev->vdev_child[c];
	if (vc->vdev_mg != NULL)
	taskq_wait(vc->vdev_mg->mg_taskq);
	}
	}

	if (spa->spa_mmp.mmp_thread)
	mmp_thread_stop(spa);

	/*
	* Wait for any outstanding async I/O to complete.
	*/
	if (spa->spa_async_zio_root != NULL) {
	for (int i = 0; i < max_ncpus; i++)
	(void) zio_wait(spa->spa_async_zio_root[i]);
	kmem_free(spa->spa_async_zio_root, max_ncpus * sizeof (void *));
	spa->spa_async_zio_root = NULL;
	}

	if (spa->spa_vdev_removal != NULL) {
	spa_vdev_removal_destroy(spa->spa_vdev_removal);
	spa->spa_vdev_removal = NULL;
	}

	spa_destroy_aux_threads(spa);

	spa_condense_fini(spa);

	bpobj_close(&spa->spa_deferred_bpobj);

	spa_config_enter(spa, SCL_ALL, spa, RW_WRITER);

	/*
	* Close all vdevs.
	*/
	if (spa->spa_root_vdev)
	vdev_free(spa->spa_root_vdev);
	ASSERT(spa->spa_root_vdev == NULL);

	/*
	* Close the dsl pool.
	*/
	if (spa->spa_dsl_pool) {
	dsl_pool_close(spa->spa_dsl_pool);
	spa->spa_dsl_pool = NULL;
	spa->spa_meta_objset = NULL;
	}

	ddt_unload(spa);
	spa_unload_log_sm_metadata(spa);

	/*
	* Drop and purge level 2 cache
	*/
	spa_l2cache_drop(spa);

	for (int i = 0; i < spa->spa_spares.sav_count; i++)
	vdev_free(spa->spa_spares.sav_vdevs[i]);
	if (spa->spa_spares.sav_vdevs) {
	kmem_free(spa->spa_spares.sav_vdevs,
	spa->spa_spares.sav_count * sizeof (void *));
	spa->spa_spares.sav_vdevs = NULL;
	}
	if (spa->spa_spares.sav_config) {
	nvlist_free(spa->spa_spares.sav_config);
	spa->spa_spares.sav_config = NULL;
	}
	spa->spa_spares.sav_count = 0;

	for (int i = 0; i < spa->spa_l2cache.sav_count; i++) {
	vdev_clear_stats(spa->spa_l2cache.sav_vdevs[i]);
	vdev_free(spa->spa_l2cache.sav_vdevs[i]);
	}
	if (spa->spa_l2cache.sav_vdevs) {
	kmem_free(spa->spa_l2cache.sav_vdevs,
	spa->spa_l2cache.sav_count * sizeof (void *));
	spa->spa_l2cache.sav_vdevs = NULL;
	}
	if (spa->spa_l2cache.sav_config) {
	nvlist_free(spa->spa_l2cache.sav_config);
	spa->spa_l2cache.sav_config = NULL;
	}
	spa->spa_l2cache.sav_count = 0;

	spa->spa_async_suspended = 0;

	spa->spa_indirect_vdevs_loaded = B_FALSE;

	if (spa->spa_comment != NULL) {
	spa_strfree(spa->spa_comment);
	spa->spa_comment = NULL;
	}
	if (spa->spa_compatibility != NULL) {
	spa_strfree(spa->spa_compatibility);
	spa->spa_compatibility = NULL;
	}

	spa_config_exit(spa, SCL_ALL, spa);
	}

	/*
	* Load (or re-load) the current list of vdevs describing the active spares for
	* this pool. When this is called, we have some form of basic information in
	* 'spa_spares.sav_config'. We parse this into vdevs, try to open them, and
	* then re-generate a more complete list including status information.
	*/
	void
	spa_load_spares(spa_t *spa)
	{
	nvlist_t **spares;
	uint_t nspares;
	int i;
	vdev_t vd, tvd;

	#ifndef _KERNEL
	/*
	* zdb opens both the current state of the pool and the
	* checkpointed state (if present), with a different spa_t.
	*
	* As spare vdevs are shared among open pools, we skip loading
	* them when we load the checkpointed state of the pool.
	*/
	if (!spa_writeable(spa))
	return;
	#endif

	ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);

	/*
	* First, close and free any existing spare vdevs.
	*/
	for (i = 0; i < spa->spa_spares.sav_count; i++) {
	vd = spa->spa_spares.sav_vdevs[i];

	/* Undo the call to spa_activate() below */
	if ((tvd = spa_lookup_by_guid(spa, vd->vdev_guid,
	B_FALSE)) != NULL && tvd->vdev_isspare)
	spa_spare_remove(tvd);
	vdev_close(vd);
	vdev_free(vd);
	}

	if (spa->spa_spares.sav_vdevs)
	kmem_free(spa->spa_spares.sav_vdevs,
	spa->spa_spares.sav_count * sizeof (void *));

	if (spa->spa_spares.sav_config == NULL)
	nspares = 0;
	else
	VERIFY(nvlist_lookup_nvlist_array(spa->spa_spares.sav_config,
	ZPOOL_CONFIG_SPARES, &spares, &nspares) == 0);

	spa->spa_spares.sav_count = (int)nspares;
	spa->spa_spares.sav_vdevs = NULL;

	if (nspares == 0)
	return;

	/*
	* Construct the array of vdevs, opening them to get status in the
	* process. For each spare, there is potentially two different vdev_t
	* structures associated with it: one in the list of spares (used only
	* for basic validation purposes) and one in the active vdev
	* configuration (if it's spared in). During this phase we open and
	* validate each vdev on the spare list. If the vdev also exists in the
	* active configuration, then we also mark this vdev as an active spare.
	*/
	spa->spa_spares.sav_vdevs = kmem_zalloc(nspares * sizeof (void *),
	KM_SLEEP);
	for (i = 0; i < spa->spa_spares.sav_count; i++) {
	VERIFY(spa_config_parse(spa, &vd, spares[i], NULL, 0,
	VDEV_ALLOC_SPARE) == 0);
	ASSERT(vd != NULL);

	spa->spa_spares.sav_vdevs[i] = vd;

	if ((tvd = spa_lookup_by_guid(spa, vd->vdev_guid,
	B_FALSE)) != NULL) {
	if (!tvd->vdev_isspare)
	spa_spare_add(tvd);

	/*
	* We only mark the spare active if we were successfully
	* able to load the vdev. Otherwise, importing a pool
	* with a bad active spare would result in strange
	* behavior, because multiple pool would think the spare
	* is actively in use.
	*
	* There is a vulnerability here to an equally bizarre
	* circumstance, where a dead active spare is later
	* brought back to life (onlined or otherwise). Given
	* the rarity of this scenario, and the extra complexity
	* it adds, we ignore the possibility.
	*/
	if (!vdev_is_dead(tvd))
	spa_spare_activate(tvd);
	}

	vd->vdev_top = vd;
	vd->vdev_aux = &spa->spa_spares;

	if (vdev_open(vd) != 0)
	continue;

	if (vdev_validate_aux(vd) == 0)
	spa_spare_add(vd);
	}

	/*
	* Recompute the stashed list of spares, with status information
	* this time.
	*/
	VERIFY(nvlist_remove(spa->spa_spares.sav_config, ZPOOL_CONFIG_SPARES,
	DATA_TYPE_NVLIST_ARRAY) == 0);

	spares = kmem_alloc(spa->spa_spares.sav_count * sizeof (void *),
	KM_SLEEP);
	for (i = 0; i < spa->spa_spares.sav_count; i++)
	spares[i] = vdev_config_generate(spa,
	spa->spa_spares.sav_vdevs[i], B_TRUE, VDEV_CONFIG_SPARE);
	VERIFY(nvlist_add_nvlist_array(spa->spa_spares.sav_config,
	ZPOOL_CONFIG_SPARES, spares, spa->spa_spares.sav_count) == 0);
	for (i = 0; i < spa->spa_spares.sav_count; i++)
	nvlist_free(spares[i]);
	kmem_free(spares, spa->spa_spares.sav_count * sizeof (void *));
	}

	/*
	* Load (or re-load) the current list of vdevs describing the active l2cache for
	* this pool. When this is called, we have some form of basic information in
	* 'spa_l2cache.sav_config'. We parse this into vdevs, try to open them, and
	* then re-generate a more complete list including status information.
	* Devices which are already active have their details maintained, and are
	* not re-opened.
	*/
	void
	spa_load_l2cache(spa_t *spa)
	{
	nvlist_t **l2cache = NULL;
	uint_t nl2cache;
	int i, j, oldnvdevs;
	uint64_t guid;
	vdev_t vd, oldvdevs, *newvdevs;
	spa_aux_vdev_t *sav = &spa->spa_l2cache;

	#ifndef _KERNEL
	/*
	* zdb opens both the current state of the pool and the
	* checkpointed state (if present), with a different spa_t.
	*
	* As L2 caches are part of the ARC which is shared among open
	* pools, we skip loading them when we load the checkpointed
	* state of the pool.
	*/
	if (!spa_writeable(spa))
	return;
	#endif

	ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);

	oldvdevs = sav->sav_vdevs;
	oldnvdevs = sav->sav_count;
	sav->sav_vdevs = NULL;
	sav->sav_count = 0;

	if (sav->sav_config == NULL) {
	nl2cache = 0;
	newvdevs = NULL;
	goto out;
	}

	VERIFY(nvlist_lookup_nvlist_array(sav->sav_config,
	ZPOOL_CONFIG_L2CACHE, &l2cache, &nl2cache) == 0);
	newvdevs = kmem_alloc(nl2cache * sizeof (void *), KM_SLEEP);

	/*
	* Process new nvlist of vdevs.
	*/
	for (i = 0; i < nl2cache; i++) {
	VERIFY(nvlist_lookup_uint64(l2cache[i], ZPOOL_CONFIG_GUID,
	&guid) == 0);

	newvdevs[i] = NULL;
	for (j = 0; j < oldnvdevs; j++) {
	vd = oldvdevs[j];
	if (vd != NULL && guid == vd->vdev_guid) {
	/*
	* Retain previous vdev for add/remove ops.
	*/
	newvdevs[i] = vd;
	oldvdevs[j] = NULL;
	break;
	}
	}

	if (newvdevs[i] == NULL) {
	/*
	* Create new vdev
	*/
	VERIFY(spa_config_parse(spa, &vd, l2cache[i], NULL, 0,
	VDEV_ALLOC_L2CACHE) == 0);
	ASSERT(vd != NULL);
	newvdevs[i] = vd;

	/*
	* Commit this vdev as an l2cache device,
	* even if it fails to open.
	*/
	spa_l2cache_add(vd);

	vd->vdev_top = vd;
	vd->vdev_aux = sav;

	spa_l2cache_activate(vd);

	if (vdev_open(vd) != 0)
	continue;

	(void) vdev_validate_aux(vd);

	if (!vdev_is_dead(vd))
	l2arc_add_vdev(spa, vd);

	/*
	* Upon cache device addition to a pool or pool
	* creation with a cache device or if the header
	* of the device is invalid we issue an async
	* TRIM command for the whole device which will
	* execute if l2arc_trim_ahead > 0.
	*/
	spa_async_request(spa, SPA_ASYNC_L2CACHE_TRIM);
	}
	}

	sav->sav_vdevs = newvdevs;
	sav->sav_count = (int)nl2cache;

	/*
	* Recompute the stashed list of l2cache devices, with status
	* information this time.
	*/
	VERIFY(nvlist_remove(sav->sav_config, ZPOOL_CONFIG_L2CACHE,
	DATA_TYPE_NVLIST_ARRAY) == 0);

	if (sav->sav_count > 0)
	l2cache = kmem_alloc(sav->sav_count * sizeof (void *),
	KM_SLEEP);
	for (i = 0; i < sav->sav_count; i++)
	l2cache[i] = vdev_config_generate(spa,
	sav->sav_vdevs[i], B_TRUE, VDEV_CONFIG_L2CACHE);
	VERIFY(nvlist_add_nvlist_array(sav->sav_config,
	ZPOOL_CONFIG_L2CACHE, l2cache, sav->sav_count) == 0);

	out:
	/*
	* Purge vdevs that were dropped
	*/
	for (i = 0; i < oldnvdevs; i++) {
	uint64_t pool;

	vd = oldvdevs[i];
	if (vd != NULL) {
	ASSERT(vd->vdev_isl2cache);

	if (spa_l2cache_exists(vd->vdev_guid, &pool) &&
	pool != 0ULL && l2arc_vdev_present(vd))
	l2arc_remove_vdev(vd);
	vdev_clear_stats(vd);
	vdev_free(vd);
	}
	}

	if (oldvdevs)
	kmem_free(oldvdevs, oldnvdevs * sizeof (void *));

	for (i = 0; i < sav->sav_count; i++)
	nvlist_free(l2cache[i]);
	if (sav->sav_count)
	kmem_free(l2cache, sav->sav_count * sizeof (void *));
	}

	static int
	load_nvlist(spa_t spa, uint64_t obj, nvlist_t *value)
	{
	dmu_buf_t *db;
	char *packed = NULL;
	size_t nvsize = 0;
	int error;
	*value = NULL;

	error = dmu_bonus_hold(spa->spa_meta_objset, obj, FTAG, &db);
	if (error)
	return (error);

	nvsize = (uint64_t )db->db_data;
	dmu_buf_rele(db, FTAG);

	packed = vmem_alloc(nvsize, KM_SLEEP);
	error = dmu_read(spa->spa_meta_objset, obj, 0, nvsize, packed,
	DMU_READ_PREFETCH);
	if (error == 0)
	error = nvlist_unpack(packed, nvsize, value, 0);
	vmem_free(packed, nvsize);

	return (error);
	}

	/*
	* Concrete top-level vdevs that are not missing and are not logs. At every
	* spa_sync we write new uberblocks to at least SPA_SYNC_MIN_VDEVS core tvds.
	*/
	static uint64_t
	spa_healthy_core_tvds(spa_t *spa)
	{
	vdev_t *rvd = spa->spa_root_vdev;
	uint64_t tvds = 0;

	for (uint64_t i = 0; i < rvd->vdev_children; i++) {
	vdev_t *vd = rvd->vdev_child[i];
	if (vd->vdev_islog)
	continue;
	if (vdev_is_concrete(vd) && !vdev_is_dead(vd))
	tvds++;
	}

	return (tvds);
	}

	/*
	* Checks to see if the given vdev could not be opened, in which case we post a
	* sysevent to notify the autoreplace code that the device has been removed.
	*/
	static void
	spa_check_removed(vdev_t *vd)
	{
	for (uint64_t c = 0; c < vd->vdev_children; c++)
	spa_check_removed(vd->vdev_child[c]);

	if (vd->vdev_ops->vdev_op_leaf && vdev_is_dead(vd) &&
	vdev_is_concrete(vd)) {
	zfs_post_autoreplace(vd->vdev_spa, vd);
	spa_event_notify(vd->vdev_spa, vd, NULL, ESC_ZFS_VDEV_CHECK);
	}
	}

	static int
	spa_check_for_missing_logs(spa_t *spa)
	{
	vdev_t *rvd = spa->spa_root_vdev;

	/*
	* If we're doing a normal import, then build up any additional
	* diagnostic information about missing log devices.
	* We'll pass this up to the user for further processing.
	*/
	if (!(spa->spa_import_flags & ZFS_IMPORT_MISSING_LOG)) {
	nvlist_t *child, nv;
	uint64_t idx = 0;

	child = kmem_alloc(rvd->vdev_children * sizeof (nvlist_t *),
	KM_SLEEP);
	VERIFY(nvlist_alloc(&nv, NV_UNIQUE_NAME, KM_SLEEP) == 0);

	for (uint64_t c = 0; c < rvd->vdev_children; c++) {
	vdev_t *tvd = rvd->vdev_child[c];

	/*
	* We consider a device as missing only if it failed
	* to open (i.e. offline or faulted is not considered
	* as missing).
	*/
	if (tvd->vdev_islog &&
	tvd->vdev_state == VDEV_STATE_CANT_OPEN) {
	child[idx++] = vdev_config_generate(spa, tvd,
	B_FALSE, VDEV_CONFIG_MISSING);
	}
	}

	if (idx > 0) {
	fnvlist_add_nvlist_array(nv,
	ZPOOL_CONFIG_CHILDREN, child, idx);
	fnvlist_add_nvlist(spa->spa_load_info,
	ZPOOL_CONFIG_MISSING_DEVICES, nv);

	for (uint64_t i = 0; i < idx; i++)
	nvlist_free(child[i]);
	}
	nvlist_free(nv);
	kmem_free(child, rvd->vdev_children * sizeof (char **));

	if (idx > 0) {
	spa_load_failed(spa, "some log devices are missing");
	vdev_dbgmsg_print_tree(rvd, 2);
	return (SET_ERROR(ENXIO));
	}
	} else {
	for (uint64_t c = 0; c < rvd->vdev_children; c++) {
	vdev_t *tvd = rvd->vdev_child[c];

	if (tvd->vdev_islog &&
	tvd->vdev_state == VDEV_STATE_CANT_OPEN) {
	spa_set_log_state(spa, SPA_LOG_CLEAR);
	spa_load_note(spa, "some log devices are "
	"missing, ZIL is dropped.");
	vdev_dbgmsg_print_tree(rvd, 2);
	break;
	}
	}
	}

	return (0);
	}

	/*
	* Check for missing log devices
	*/
	static boolean_t
	spa_check_logs(spa_t *spa)
	{
	boolean_t rv = B_FALSE;
	dsl_pool_t *dp = spa_get_dsl(spa);

	switch (spa->spa_log_state) {
	default:
	break;
	case SPA_LOG_MISSING:
	/* need to recheck in case slog has been restored */
	case SPA_LOG_UNKNOWN:
	rv = (dmu_objset_find_dp(dp, dp->dp_root_dir_obj,
	zil_check_log_chain, NULL, DS_FIND_CHILDREN) != 0);
	if (rv)
	spa_set_log_state(spa, SPA_LOG_MISSING);
	break;
	}
	return (rv);
	}

	/*
	* Passivate any log vdevs (note, does not apply to embedded log metaslabs).
	*/
	static boolean_t
	spa_passivate_log(spa_t *spa)
	{
	vdev_t *rvd = spa->spa_root_vdev;
	boolean_t slog_found = B_FALSE;

	ASSERT(spa_config_held(spa, SCL_ALLOC, RW_WRITER));

	for (int c = 0; c < rvd->vdev_children; c++) {
	vdev_t *tvd = rvd->vdev_child[c];

	if (tvd->vdev_islog) {
	ASSERT3P(tvd->vdev_log_mg, ==, NULL);
	metaslab_group_passivate(tvd->vdev_mg);
	slog_found = B_TRUE;
	}
	}

	return (slog_found);
	}

	/*
	* Activate any log vdevs (note, does not apply to embedded log metaslabs).
	*/
	static void
	spa_activate_log(spa_t *spa)
	{
	vdev_t *rvd = spa->spa_root_vdev;

	ASSERT(spa_config_held(spa, SCL_ALLOC, RW_WRITER));

	for (int c = 0; c < rvd->vdev_children; c++) {
	vdev_t *tvd = rvd->vdev_child[c];

	if (tvd->vdev_islog) {
	ASSERT3P(tvd->vdev_log_mg, ==, NULL);
	metaslab_group_activate(tvd->vdev_mg);
	}
	}
	}

	int
	spa_reset_logs(spa_t *spa)
	{
	int error;

	error = dmu_objset_find(spa_name(spa), zil_reset,
	NULL, DS_FIND_CHILDREN);
	if (error == 0) {
	/*
	* We successfully offlined the log device, sync out the
	* current txg so that the "stubby" block can be removed
	* by zil_sync().
	*/
	txg_wait_synced(spa->spa_dsl_pool, 0);
	}
	return (error);
	}

	static void
	spa_aux_check_removed(spa_aux_vdev_t *sav)
	{
	for (int i = 0; i < sav->sav_count; i++)
	spa_check_removed(sav->sav_vdevs[i]);
	}

	void
	spa_claim_notify(zio_t *zio)
	{
	spa_t *spa = zio->io_spa;

	if (zio->io_error)
	return;

	mutex_enter(&spa->spa_props_lock); /* any mutex will do */
	if (spa->spa_claim_max_txg < zio->io_bp->blk_birth)
	spa->spa_claim_max_txg = zio->io_bp->blk_birth;
	mutex_exit(&spa->spa_props_lock);
	}

	typedef struct spa_load_error {
	uint64_t sle_meta_count;
	uint64_t sle_data_count;
	} spa_load_error_t;

	static void
	spa_load_verify_done(zio_t *zio)
	{
	blkptr_t *bp = zio->io_bp;
	spa_load_error_t *sle = zio->io_private;
	dmu_object_type_t type = BP_GET_TYPE(bp);
	int error = zio->io_error;
	spa_t *spa = zio->io_spa;

	abd_free(zio->io_abd);
	if (error) {
	if ((BP_GET_LEVEL(bp) != 0 \|\| DMU_OT_IS_METADATA(type)) &&
	type != DMU_OT_INTENT_LOG)
	atomic_inc_64(&sle->sle_meta_count);
	else
	atomic_inc_64(&sle->sle_data_count);
	}

	mutex_enter(&spa->spa_scrub_lock);
	spa->spa_load_verify_bytes -= BP_GET_PSIZE(bp);
	cv_broadcast(&spa->spa_scrub_io_cv);
	mutex_exit(&spa->spa_scrub_lock);
	}

	/*
	* Maximum number of inflight bytes is the log2 fraction of the arc size.
	* By default, we set it to 1/16th of the arc.
	*/
	int spa_load_verify_shift = 4;
	int spa_load_verify_metadata = B_TRUE;
	int spa_load_verify_data = B_TRUE;

	/ARGSUSED/
	static int
	spa_load_verify_cb(spa_t spa, zilog_t zilog, const blkptr_t *bp,
	const zbookmark_phys_t zb, const dnode_phys_t dnp, void *arg)
	{
	if (zb->zb_level == ZB_DNODE_LEVEL \|\| BP_IS_HOLE(bp) \|\|
	BP_IS_EMBEDDED(bp) \|\| BP_IS_REDACTED(bp))
	return (0);
	/*
	* Note: normally this routine will not be called if
	* spa_load_verify_metadata is not set. However, it may be useful
	* to manually set the flag after the traversal has begun.
	*/
	if (!spa_load_verify_metadata)
	return (0);
	if (!BP_IS_METADATA(bp) && !spa_load_verify_data)
	return (0);

	uint64_t maxinflight_bytes =
	arc_target_bytes() >> spa_load_verify_shift;
	zio_t *rio = arg;
	size_t size = BP_GET_PSIZE(bp);

	mutex_enter(&spa->spa_scrub_lock);
	while (spa->spa_load_verify_bytes >= maxinflight_bytes)
	cv_wait(&spa->spa_scrub_io_cv, &spa->spa_scrub_lock);
	spa->spa_load_verify_bytes += size;
	mutex_exit(&spa->spa_scrub_lock);

	zio_nowait(zio_read(rio, spa, bp, abd_alloc_for_io(size, B_FALSE), size,
	spa_load_verify_done, rio->io_private, ZIO_PRIORITY_SCRUB,
	ZIO_FLAG_SPECULATIVE \| ZIO_FLAG_CANFAIL \|
	ZIO_FLAG_SCRUB \| ZIO_FLAG_RAW, zb));
	return (0);
	}

	/* ARGSUSED */
	static int
	verify_dataset_name_len(dsl_pool_t dp, dsl_dataset_t ds, void *arg)
	{
	if (dsl_dataset_namelen(ds) >= ZFS_MAX_DATASET_NAME_LEN)
	return (SET_ERROR(ENAMETOOLONG));

	return (0);
	}

	static int
	spa_load_verify(spa_t *spa)
	{
	zio_t *rio;
	spa_load_error_t sle = { 0 };
	zpool_load_policy_t policy;
	boolean_t verify_ok = B_FALSE;
	int error = 0;

	zpool_get_load_policy(spa->spa_config, &policy);

	if (policy.zlp_rewind & ZPOOL_NEVER_REWIND)
	return (0);

	dsl_pool_config_enter(spa->spa_dsl_pool, FTAG);
	error = dmu_objset_find_dp(spa->spa_dsl_pool,
	spa->spa_dsl_pool->dp_root_dir_obj, verify_dataset_name_len, NULL,
	DS_FIND_CHILDREN);
	dsl_pool_config_exit(spa->spa_dsl_pool, FTAG);
	if (error != 0)
	return (error);

	rio = zio_root(spa, NULL, &sle,
	ZIO_FLAG_CANFAIL \| ZIO_FLAG_SPECULATIVE);

	if (spa_load_verify_metadata) {
	if (spa->spa_extreme_rewind) {
	spa_load_note(spa, "performing a complete scan of the "
	"pool since extreme rewind is on. This may take "
	"a very long time.\n (spa_load_verify_data=%u, "
	"spa_load_verify_metadata=%u)",
	spa_load_verify_data, spa_load_verify_metadata);
	}

	error = traverse_pool(spa, spa->spa_verify_min_txg,
	TRAVERSE_PRE \| TRAVERSE_PREFETCH_METADATA \|
	TRAVERSE_NO_DECRYPT, spa_load_verify_cb, rio);
	}

	(void) zio_wait(rio);
	ASSERT0(spa->spa_load_verify_bytes);

	spa->spa_load_meta_errors = sle.sle_meta_count;
	spa->spa_load_data_errors = sle.sle_data_count;

	if (sle.sle_meta_count != 0 \|\| sle.sle_data_count != 0) {
	spa_load_note(spa, "spa_load_verify found %llu metadata errors "
	"and %llu data errors", (u_longlong_t)sle.sle_meta_count,
	(u_longlong_t)sle.sle_data_count);
	}

	if (spa_load_verify_dryrun \|\|
	(!error && sle.sle_meta_count <= policy.zlp_maxmeta &&
	sle.sle_data_count <= policy.zlp_maxdata)) {
	int64_t loss = 0;

	verify_ok = B_TRUE;
	spa->spa_load_txg = spa->spa_uberblock.ub_txg;
	spa->spa_load_txg_ts = spa->spa_uberblock.ub_timestamp;

	loss = spa->spa_last_ubsync_txg_ts - spa->spa_load_txg_ts;
	VERIFY(nvlist_add_uint64(spa->spa_load_info,
	ZPOOL_CONFIG_LOAD_TIME, spa->spa_load_txg_ts) == 0);
	VERIFY(nvlist_add_int64(spa->spa_load_info,
	ZPOOL_CONFIG_REWIND_TIME, loss) == 0);
	VERIFY(nvlist_add_uint64(spa->spa_load_info,
	ZPOOL_CONFIG_LOAD_DATA_ERRORS, sle.sle_data_count) == 0);
	} else {
	spa->spa_load_max_txg = spa->spa_uberblock.ub_txg;
	}

	if (spa_load_verify_dryrun)
	return (0);

	if (error) {
	if (error != ENXIO && error != EIO)
	error = SET_ERROR(EIO);
	return (error);
	}

	return (verify_ok ? 0 : EIO);
	}

	/*
	* Find a value in the pool props object.
	*/
	static void
	spa_prop_find(spa_t spa, zpool_prop_t prop, uint64_t val)
	{
	(void) zap_lookup(spa->spa_meta_objset, spa->spa_pool_props_object,
	zpool_prop_to_name(prop), sizeof (uint64_t), 1, val);
	}

	/*
	* Find a value in the pool directory object.
	*/
	static int
	spa_dir_prop(spa_t spa, const char name, uint64_t *val, boolean_t log_enoent)
	{
	int error = zap_lookup(spa->spa_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
	name, sizeof (uint64_t), 1, val);

	if (error != 0 && (error != ENOENT \|\| log_enoent)) {
	spa_load_failed(spa, "couldn't get '%s' value in MOS directory "
	"[error=%d]", name, error);
	}

	return (error);
	}

	static int
	spa_vdev_err(vdev_t *vdev, vdev_aux_t aux, int err)
	{
	vdev_set_state(vdev, B_TRUE, VDEV_STATE_CANT_OPEN, aux);
	return (SET_ERROR(err));
	}

	boolean_t
	spa_livelist_delete_check(spa_t *spa)
	{
	return (spa->spa_livelists_to_delete != 0);
	}

	/* ARGSUSED */
	static boolean_t
	spa_livelist_delete_cb_check(void arg, zthr_t z)
	{
	spa_t *spa = arg;
	return (spa_livelist_delete_check(spa));
	}

	static int
	delete_blkptr_cb(void arg, const blkptr_t bp, dmu_tx_t *tx)
	{
	spa_t *spa = arg;
	zio_free(spa, tx->tx_txg, bp);
	dsl_dir_diduse_space(tx->tx_pool->dp_free_dir, DD_USED_HEAD,
	-bp_get_dsize_sync(spa, bp),
	-BP_GET_PSIZE(bp), -BP_GET_UCSIZE(bp), tx);
	return (0);
	}

	static int
	dsl_get_next_livelist_obj(objset_t os, uint64_t zap_obj, uint64_t llp)
	{
	int err;
	zap_cursor_t zc;
	zap_attribute_t za;
	zap_cursor_init(&zc, os, zap_obj);
	err = zap_cursor_retrieve(&zc, &za);
	zap_cursor_fini(&zc);
	if (err == 0)
	*llp = za.za_first_integer;
	return (err);
	}

	/*
	* Components of livelist deletion that must be performed in syncing
	* context: freeing block pointers and updating the pool-wide data
	* structures to indicate how much work is left to do
	*/
	typedef struct sublist_delete_arg {
	spa_t *spa;
	dsl_deadlist_t *ll;
	uint64_t key;
	bplist_t *to_free;
	} sublist_delete_arg_t;

	static void
	sublist_delete_sync(void arg, dmu_tx_t tx)
	{
	sublist_delete_arg_t *sda = arg;
	spa_t *spa = sda->spa;
	dsl_deadlist_t *ll = sda->ll;
	uint64_t key = sda->key;
	bplist_t *to_free = sda->to_free;

	bplist_iterate(to_free, delete_blkptr_cb, spa, tx);
	dsl_deadlist_remove_entry(ll, key, tx);
	}

	typedef struct livelist_delete_arg {
	spa_t *spa;
	uint64_t ll_obj;
	uint64_t zap_obj;
	} livelist_delete_arg_t;

	static void
	livelist_delete_sync(void arg, dmu_tx_t tx)
	{
	livelist_delete_arg_t *lda = arg;
	spa_t *spa = lda->spa;
	uint64_t ll_obj = lda->ll_obj;
	uint64_t zap_obj = lda->zap_obj;
	objset_t *mos = spa->spa_meta_objset;
	uint64_t count;

	/* free the livelist and decrement the feature count */
	VERIFY0(zap_remove_int(mos, zap_obj, ll_obj, tx));
	dsl_deadlist_free(mos, ll_obj, tx);
	spa_feature_decr(spa, SPA_FEATURE_LIVELIST, tx);
	VERIFY0(zap_count(mos, zap_obj, &count));
	if (count == 0) {
	/* no more livelists to delete */
	VERIFY0(zap_remove(mos, DMU_POOL_DIRECTORY_OBJECT,
	DMU_POOL_DELETED_CLONES, tx));
	VERIFY0(zap_destroy(mos, zap_obj, tx));
	spa->spa_livelists_to_delete = 0;
	spa_notify_waiters(spa);
	}
	}

	/*
	* Load in the value for the livelist to be removed and open it. Then,
	* load its first sublist and determine which block pointers should actually
	* be freed. Then, call a synctask which performs the actual frees and updates
	* the pool-wide livelist data.
	*/
	/* ARGSUSED */
	static void
	spa_livelist_delete_cb(void arg, zthr_t z)
	{
	spa_t *spa = arg;
	uint64_t ll_obj = 0, count;
	objset_t *mos = spa->spa_meta_objset;
	uint64_t zap_obj = spa->spa_livelists_to_delete;
	/*
	* Determine the next livelist to delete. This function should only
	* be called if there is at least one deleted clone.
	*/
	VERIFY0(dsl_get_next_livelist_obj(mos, zap_obj, &ll_obj));
	VERIFY0(zap_count(mos, ll_obj, &count));
	if (count > 0) {
	dsl_deadlist_t *ll;
	dsl_deadlist_entry_t *dle;
	bplist_t to_free;
	ll = kmem_zalloc(sizeof (dsl_deadlist_t), KM_SLEEP);
	dsl_deadlist_open(ll, mos, ll_obj);
	dle = dsl_deadlist_first(ll);
	ASSERT3P(dle, !=, NULL);
	bplist_create(&to_free);
	int err = dsl_process_sub_livelist(&dle->dle_bpobj, &to_free,
	z, NULL);
	if (err == 0) {
	sublist_delete_arg_t sync_arg = {
	.spa = spa,
	.ll = ll,
	.key = dle->dle_mintxg,
	.to_free = &to_free
	};
	zfs_dbgmsg("deleting sublist (id %llu) from"
	" livelist %llu, %d remaining",
	dle->dle_bpobj.bpo_object, ll_obj, count - 1);
	VERIFY0(dsl_sync_task(spa_name(spa), NULL,
	sublist_delete_sync, &sync_arg, 0,
	ZFS_SPACE_CHECK_DESTROY));
	} else {
	VERIFY3U(err, ==, EINTR);
	}
	bplist_clear(&to_free);
	bplist_destroy(&to_free);
	dsl_deadlist_close(ll);
	kmem_free(ll, sizeof (dsl_deadlist_t));
	} else {
	livelist_delete_arg_t sync_arg = {
	.spa = spa,
	.ll_obj = ll_obj,
	.zap_obj = zap_obj
	};
	zfs_dbgmsg("deletion of livelist %llu completed", ll_obj);
	VERIFY0(dsl_sync_task(spa_name(spa), NULL, livelist_delete_sync,
	&sync_arg, 0, ZFS_SPACE_CHECK_DESTROY));
	}
	}

	static void
	spa_start_livelist_destroy_thread(spa_t *spa)
	{
	ASSERT3P(spa->spa_livelist_delete_zthr, ==, NULL);
	spa->spa_livelist_delete_zthr =
	zthr_create("z_livelist_destroy",
	spa_livelist_delete_cb_check, spa_livelist_delete_cb, spa);
	}

	typedef struct livelist_new_arg {
	bplist_t *allocs;
	bplist_t *frees;
	} livelist_new_arg_t;

	static int
	livelist_track_new_cb(void arg, const blkptr_t bp, boolean_t bp_freed,
	dmu_tx_t *tx)
	{
	ASSERT(tx == NULL);
	livelist_new_arg_t *lna = arg;
	if (bp_freed) {
	bplist_append(lna->frees, bp);
	} else {
	bplist_append(lna->allocs, bp);
	zfs_livelist_condense_new_alloc++;
	}
	return (0);
	}

	typedef struct livelist_condense_arg {
	spa_t *spa;
	bplist_t to_keep;
	uint64_t first_size;
	uint64_t next_size;
	} livelist_condense_arg_t;

	static void
	spa_livelist_condense_sync(void arg, dmu_tx_t tx)
	{
	livelist_condense_arg_t *lca = arg;
	spa_t *spa = lca->spa;
	bplist_t new_frees;
	dsl_dataset_t *ds = spa->spa_to_condense.ds;

	/* Have we been cancelled? */
	if (spa->spa_to_condense.cancelled) {
	zfs_livelist_condense_sync_cancel++;
	goto out;
	}

	dsl_deadlist_entry_t *first = spa->spa_to_condense.first;
	dsl_deadlist_entry_t *next = spa->spa_to_condense.next;
	dsl_deadlist_t *ll = &ds->ds_dir->dd_livelist;

	/*
	* It's possible that the livelist was changed while the zthr was
	* running. Therefore, we need to check for new blkptrs in the two
	* entries being condensed and continue to track them in the livelist.
	* Because of the way we handle remapped blkptrs (see dbuf_remap_impl),
	* it's possible that the newly added blkptrs are FREEs or ALLOCs so
	* we need to sort them into two different bplists.
	*/
	uint64_t first_obj = first->dle_bpobj.bpo_object;
	uint64_t next_obj = next->dle_bpobj.bpo_object;
	uint64_t cur_first_size = first->dle_bpobj.bpo_phys->bpo_num_blkptrs;
	uint64_t cur_next_size = next->dle_bpobj.bpo_phys->bpo_num_blkptrs;

	bplist_create(&new_frees);
	livelist_new_arg_t new_bps = {
	.allocs = &lca->to_keep,
	.frees = &new_frees,
	};

	if (cur_first_size > lca->first_size) {
	VERIFY0(livelist_bpobj_iterate_from_nofree(&first->dle_bpobj,
	livelist_track_new_cb, &new_bps, lca->first_size));
	}
	if (cur_next_size > lca->next_size) {
	VERIFY0(livelist_bpobj_iterate_from_nofree(&next->dle_bpobj,
	livelist_track_new_cb, &new_bps, lca->next_size));
	}

	dsl_deadlist_clear_entry(first, ll, tx);
	ASSERT(bpobj_is_empty(&first->dle_bpobj));
	dsl_deadlist_remove_entry(ll, next->dle_mintxg, tx);

	bplist_iterate(&lca->to_keep, dsl_deadlist_insert_alloc_cb, ll, tx);
	bplist_iterate(&new_frees, dsl_deadlist_insert_free_cb, ll, tx);
	bplist_destroy(&new_frees);

	char dsname[ZFS_MAX_DATASET_NAME_LEN];
	dsl_dataset_name(ds, dsname);
	zfs_dbgmsg("txg %llu condensing livelist of %s (id %llu), bpobj %llu "
	"(%llu blkptrs) and bpobj %llu (%llu blkptrs) -> bpobj %llu "
	"(%llu blkptrs)", tx->tx_txg, dsname, ds->ds_object, first_obj,
	cur_first_size, next_obj, cur_next_size,
	first->dle_bpobj.bpo_object,
	first->dle_bpobj.bpo_phys->bpo_num_blkptrs);
	out:
	dmu_buf_rele(ds->ds_dbuf, spa);
	spa->spa_to_condense.ds = NULL;
	bplist_clear(&lca->to_keep);
	bplist_destroy(&lca->to_keep);
	kmem_free(lca, sizeof (livelist_condense_arg_t));
	spa->spa_to_condense.syncing = B_FALSE;
	}

	static void
	spa_livelist_condense_cb(void arg, zthr_t t)
	{
	while (zfs_livelist_condense_zthr_pause &&
	!(zthr_has_waiters(t) \|\| zthr_iscancelled(t)))
	delay(1);

	spa_t *spa = arg;
	dsl_deadlist_entry_t *first = spa->spa_to_condense.first;
	dsl_deadlist_entry_t *next = spa->spa_to_condense.next;
	uint64_t first_size, next_size;

	livelist_condense_arg_t *lca =
	kmem_alloc(sizeof (livelist_condense_arg_t), KM_SLEEP);
	bplist_create(&lca->to_keep);

	/*
	* Process the livelists (matching FREEs and ALLOCs) in open context
	* so we have minimal work in syncing context to condense.
	*
	* We save bpobj sizes (first_size and next_size) to use later in
	* syncing context to determine if entries were added to these sublists
	* while in open context. This is possible because the clone is still
	* active and open for normal writes and we want to make sure the new,
	* unprocessed blockpointers are inserted into the livelist normally.
	*
	* Note that dsl_process_sub_livelist() both stores the size number of
	* blockpointers and iterates over them while the bpobj's lock held, so
	* the sizes returned to us are consistent which what was actually
	* processed.
	*/
	int err = dsl_process_sub_livelist(&first->dle_bpobj, &lca->to_keep, t,
	&first_size);
	if (err == 0)
	err = dsl_process_sub_livelist(&next->dle_bpobj, &lca->to_keep,
	t, &next_size);

	if (err == 0) {
	while (zfs_livelist_condense_sync_pause &&
	!(zthr_has_waiters(t) \|\| zthr_iscancelled(t)))
	delay(1);

	dmu_tx_t *tx = dmu_tx_create_dd(spa_get_dsl(spa)->dp_mos_dir);
	dmu_tx_mark_netfree(tx);
	dmu_tx_hold_space(tx, 1);
	err = dmu_tx_assign(tx, TXG_NOWAIT \| TXG_NOTHROTTLE);
	if (err == 0) {
	/*
	* Prevent the condense zthr restarting before
	* the synctask completes.
	*/
	spa->spa_to_condense.syncing = B_TRUE;
	lca->spa = spa;
	lca->first_size = first_size;
	lca->next_size = next_size;
	dsl_sync_task_nowait(spa_get_dsl(spa),
	spa_livelist_condense_sync, lca, tx);
	dmu_tx_commit(tx);
	return;
	}
	}
	/*
	* Condensing can not continue: either it was externally stopped or
	* we were unable to assign to a tx because the pool has run out of
	* space. In the second case, we'll just end up trying to condense
	* again in a later txg.
	*/
	ASSERT(err != 0);
	bplist_clear(&lca->to_keep);
	bplist_destroy(&lca->to_keep);
	kmem_free(lca, sizeof (livelist_condense_arg_t));
	dmu_buf_rele(spa->spa_to_condense.ds->ds_dbuf, spa);
	spa->spa_to_condense.ds = NULL;
	if (err == EINTR)
	zfs_livelist_condense_zthr_cancel++;
	}

	/* ARGSUSED */
	/*
	* Check that there is something to condense but that a condense is not
	* already in progress and that condensing has not been cancelled.
	*/
	static boolean_t
	spa_livelist_condense_cb_check(void arg, zthr_t z)
	{
	spa_t *spa = arg;
	if ((spa->spa_to_condense.ds != NULL) &&
	(spa->spa_to_condense.syncing == B_FALSE) &&
	(spa->spa_to_condense.cancelled == B_FALSE)) {
	return (B_TRUE);
	}
	return (B_FALSE);
	}

	static void
	spa_start_livelist_condensing_thread(spa_t *spa)
	{
	spa->spa_to_condense.ds = NULL;
	spa->spa_to_condense.first = NULL;
	spa->spa_to_condense.next = NULL;
	spa->spa_to_condense.syncing = B_FALSE;
	spa->spa_to_condense.cancelled = B_FALSE;

	ASSERT3P(spa->spa_livelist_condense_zthr, ==, NULL);
	spa->spa_livelist_condense_zthr =
	zthr_create("z_livelist_condense",
	spa_livelist_condense_cb_check,
	spa_livelist_condense_cb, spa);
	}

	static void
	spa_spawn_aux_threads(spa_t *spa)
	{
	ASSERT(spa_writeable(spa));

	ASSERT(MUTEX_HELD(&spa_namespace_lock));

	spa_start_indirect_condensing_thread(spa);
	spa_start_livelist_destroy_thread(spa);
	spa_start_livelist_condensing_thread(spa);

	ASSERT3P(spa->spa_checkpoint_discard_zthr, ==, NULL);
	spa->spa_checkpoint_discard_zthr =
	zthr_create("z_checkpoint_discard",
	spa_checkpoint_discard_thread_check,
	spa_checkpoint_discard_thread, spa);
	}

	/*
	* Fix up config after a partly-completed split. This is done with the
	* ZPOOL_CONFIG_SPLIT nvlist. Both the splitting pool and the split-off
	* pool have that entry in their config, but only the splitting one contains
	* a list of all the guids of the vdevs that are being split off.
	*
	* This function determines what to do with that list: either rejoin
	* all the disks to the pool, or complete the splitting process. To attempt
	* the rejoin, each disk that is offlined is marked online again, and
	* we do a reopen() call. If the vdev label for every disk that was
	* marked online indicates it was successfully split off (VDEV_AUX_SPLIT_POOL)
	* then we call vdev_split() on each disk, and complete the split.
	*
	* Otherwise we leave the config alone, with all the vdevs in place in
	* the original pool.
	*/
	static void
	spa_try_repair(spa_t spa, nvlist_t config)
	{
	uint_t extracted;
	uint64_t *glist;
	uint_t i, gcount;
	nvlist_t *nvl;
	vdev_t **vd;
	boolean_t attempt_reopen;

	if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_SPLIT, &nvl) != 0)
	return;

	/* check that the config is complete */
	if (nvlist_lookup_uint64_array(nvl, ZPOOL_CONFIG_SPLIT_LIST,
	&glist, &gcount) != 0)
	return;

	vd = kmem_zalloc(gcount * sizeof (vdev_t *), KM_SLEEP);

	/* attempt to online all the vdevs & validate */
	attempt_reopen = B_TRUE;
	for (i = 0; i < gcount; i++) {
	if (glist[i] == 0) /* vdev is hole */
	continue;

	vd[i] = spa_lookup_by_guid(spa, glist[i], B_FALSE);
	if (vd[i] == NULL) {
	/*
	* Don't bother attempting to reopen the disks;
	* just do the split.
	*/
	attempt_reopen = B_FALSE;
	} else {
	/* attempt to re-online it */
	vd[i]->vdev_offline = B_FALSE;
	}
	}

	if (attempt_reopen) {
	vdev_reopen(spa->spa_root_vdev);

	/* check each device to see what state it's in */
	for (extracted = 0, i = 0; i < gcount; i++) {
	if (vd[i] != NULL &&
	vd[i]->vdev_stat.vs_aux != VDEV_AUX_SPLIT_POOL)
	break;
	++extracted;
	}
	}

	/*
	* If every disk has been moved to the new pool, or if we never
	* even attempted to look at them, then we split them off for
	* good.
	*/
	if (!attempt_reopen \|\| gcount == extracted) {
	for (i = 0; i < gcount; i++)
	if (vd[i] != NULL)
	vdev_split(vd[i]);
	vdev_reopen(spa->spa_root_vdev);
	}

	kmem_free(vd, gcount * sizeof (vdev_t *));
	}

	static int
	spa_load(spa_t *spa, spa_load_state_t state, spa_import_type_t type)
	{
	char *ereport = FM_EREPORT_ZFS_POOL;
	int error;

	spa->spa_load_state = state;
	(void) spa_import_progress_set_state(spa_guid(spa),
	spa_load_state(spa));

	gethrestime(&spa->spa_loaded_ts);
	error = spa_load_impl(spa, type, &ereport);

	/*
	* Don't count references from objsets that are already closed
	* and are making their way through the eviction process.
	*/
	spa_evicting_os_wait(spa);
	spa->spa_minref = zfs_refcount_count(&spa->spa_refcount);
	if (error) {
	if (error != EEXIST) {
	spa->spa_loaded_ts.tv_sec = 0;
	spa->spa_loaded_ts.tv_nsec = 0;
	}
	if (error != EBADF) {
	(void) zfs_ereport_post(ereport, spa,
	NULL, NULL, NULL, 0);
	}
	}
	spa->spa_load_state = error ? SPA_LOAD_ERROR : SPA_LOAD_NONE;
	spa->spa_ena = 0;

	(void) spa_import_progress_set_state(spa_guid(spa),
	spa_load_state(spa));

	return (error);
	}

	#ifdef ZFS_DEBUG
	/*
	* Count the number of per-vdev ZAPs associated with all of the vdevs in the
	* vdev tree rooted in the given vd, and ensure that each ZAP is present in the
	* spa's per-vdev ZAP list.
	*/
	static uint64_t
	vdev_count_verify_zaps(vdev_t *vd)
	{
	spa_t *spa = vd->vdev_spa;
	uint64_t total = 0;

	if (vd->vdev_top_zap != 0) {
	total++;
	ASSERT0(zap_lookup_int(spa->spa_meta_objset,
	spa->spa_all_vdev_zaps, vd->vdev_top_zap));
	}
	if (vd->vdev_leaf_zap != 0) {
	total++;
	ASSERT0(zap_lookup_int(spa->spa_meta_objset,
	spa->spa_all_vdev_zaps, vd->vdev_leaf_zap));
	}

	for (uint64_t i = 0; i < vd->vdev_children; i++) {
	total += vdev_count_verify_zaps(vd->vdev_child[i]);
	}

	return (total);
	}
	#endif

	/*
	* Determine whether the activity check is required.
	*/
	static boolean_t
	spa_activity_check_required(spa_t spa, uberblock_t ub, nvlist_t *label,
	nvlist_t *config)
	{
	uint64_t state = 0;
	uint64_t hostid = 0;
	uint64_t tryconfig_txg = 0;
	uint64_t tryconfig_timestamp = 0;
	uint16_t tryconfig_mmp_seq = 0;
	nvlist_t *nvinfo;

	if (nvlist_exists(config, ZPOOL_CONFIG_LOAD_INFO)) {
	nvinfo = fnvlist_lookup_nvlist(config, ZPOOL_CONFIG_LOAD_INFO);
	(void) nvlist_lookup_uint64(nvinfo, ZPOOL_CONFIG_MMP_TXG,
	&tryconfig_txg);
	(void) nvlist_lookup_uint64(config, ZPOOL_CONFIG_TIMESTAMP,
	&tryconfig_timestamp);
	(void) nvlist_lookup_uint16(nvinfo, ZPOOL_CONFIG_MMP_SEQ,
	&tryconfig_mmp_seq);
	}

	(void) nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_STATE, &state);

	/*
	* Disable the MMP activity check - This is used by zdb which
	* is intended to be used on potentially active pools.
	*/
	if (spa->spa_import_flags & ZFS_IMPORT_SKIP_MMP)
	return (B_FALSE);

	/*
	* Skip the activity check when the MMP feature is disabled.
	*/
	if (ub->ub_mmp_magic == MMP_MAGIC && ub->ub_mmp_delay == 0)
	return (B_FALSE);

	/*
	* If the tryconfig_ values are nonzero, they are the results of an
	* earlier tryimport. If they all match the uberblock we just found,
	* then the pool has not changed and we return false so we do not test
	* a second time.
	*/
	if (tryconfig_txg && tryconfig_txg == ub->ub_txg &&
	tryconfig_timestamp && tryconfig_timestamp == ub->ub_timestamp &&
	tryconfig_mmp_seq && tryconfig_mmp_seq ==
	(MMP_SEQ_VALID(ub) ? MMP_SEQ(ub) : 0))
	return (B_FALSE);

	/*
	* Allow the activity check to be skipped when importing the pool
	* on the same host which last imported it. Since the hostid from
	* configuration may be stale use the one read from the label.
	*/
	if (nvlist_exists(label, ZPOOL_CONFIG_HOSTID))
	hostid = fnvlist_lookup_uint64(label, ZPOOL_CONFIG_HOSTID);

	if (hostid == spa_get_hostid(spa))
	return (B_FALSE);

	/*
	* Skip the activity test when the pool was cleanly exported.
	*/
	if (state != POOL_STATE_ACTIVE)
	return (B_FALSE);

	return (B_TRUE);
	}

	/*
	* Nanoseconds the activity check must watch for changes on-disk.
	*/
	static uint64_t
	spa_activity_check_duration(spa_t spa, uberblock_t ub)
	{
	uint64_t import_intervals = MAX(zfs_multihost_import_intervals, 1);
	uint64_t multihost_interval = MSEC2NSEC(
	MMP_INTERVAL_OK(zfs_multihost_interval));
	uint64_t import_delay = MAX(NANOSEC, import_intervals *
	multihost_interval);

	/*
	* Local tunables determine a minimum duration except for the case
	* where we know when the remote host will suspend the pool if MMP
	* writes do not land.
	*
	* See Big Theory comment at the top of mmp.c for the reasoning behind
	* these cases and times.
	*/

	ASSERT(MMP_IMPORT_SAFETY_FACTOR >= 100);

	if (MMP_INTERVAL_VALID(ub) && MMP_FAIL_INT_VALID(ub) &&
	MMP_FAIL_INT(ub) > 0) {

	/* MMP on remote host will suspend pool after failed writes */
	import_delay = MMP_FAIL_INT(ub) * MSEC2NSEC(MMP_INTERVAL(ub)) *
	MMP_IMPORT_SAFETY_FACTOR / 100;

	zfs_dbgmsg("fail_intvals>0 import_delay=%llu ub_mmp "
	"mmp_fails=%llu ub_mmp mmp_interval=%llu "
	"import_intervals=%u", import_delay, MMP_FAIL_INT(ub),
	MMP_INTERVAL(ub), import_intervals);

	} else if (MMP_INTERVAL_VALID(ub) && MMP_FAIL_INT_VALID(ub) &&
	MMP_FAIL_INT(ub) == 0) {

	/* MMP on remote host will never suspend pool */
	import_delay = MAX(import_delay, (MSEC2NSEC(MMP_INTERVAL(ub)) +
	ub->ub_mmp_delay) * import_intervals);

	zfs_dbgmsg("fail_intvals=0 import_delay=%llu ub_mmp "
	"mmp_interval=%llu ub_mmp_delay=%llu "
	"import_intervals=%u", import_delay, MMP_INTERVAL(ub),
	ub->ub_mmp_delay, import_intervals);

	} else if (MMP_VALID(ub)) {
	/*
	* zfs-0.7 compatibility case
	*/

	import_delay = MAX(import_delay, (multihost_interval +
	ub->ub_mmp_delay) * import_intervals);

	zfs_dbgmsg("import_delay=%llu ub_mmp_delay=%llu "
	"import_intervals=%u leaves=%u", import_delay,
	ub->ub_mmp_delay, import_intervals,
	vdev_count_leaves(spa));
	} else {
	/* Using local tunings is the only reasonable option */
	zfs_dbgmsg("pool last imported on non-MMP aware "
	"host using import_delay=%llu multihost_interval=%llu "
	"import_intervals=%u", import_delay, multihost_interval,
	import_intervals);
	}

	return (import_delay);
	}

	/*
	* Perform the import activity check. If the user canceled the import or
	* we detected activity then fail.
	*/
	static int
	spa_activity_check(spa_t spa, uberblock_t ub, nvlist_t *config)
	{
	uint64_t txg = ub->ub_txg;
	uint64_t timestamp = ub->ub_timestamp;
	uint64_t mmp_config = ub->ub_mmp_config;
	uint16_t mmp_seq = MMP_SEQ_VALID(ub) ? MMP_SEQ(ub) : 0;
	uint64_t import_delay;
	hrtime_t import_expire;
	nvlist_t *mmp_label = NULL;
	vdev_t *rvd = spa->spa_root_vdev;
	kcondvar_t cv;
	kmutex_t mtx;
	int error = 0;

	cv_init(&cv, NULL, CV_DEFAULT, NULL);
	mutex_init(&mtx, NULL, MUTEX_DEFAULT, NULL);
	mutex_enter(&mtx);

	/*
	* If ZPOOL_CONFIG_MMP_TXG is present an activity check was performed
	* during the earlier tryimport. If the txg recorded there is 0 then
	* the pool is known to be active on another host.
	*
	* Otherwise, the pool might be in use on another host. Check for
	* changes in the uberblocks on disk if necessary.
	*/
	if (nvlist_exists(config, ZPOOL_CONFIG_LOAD_INFO)) {
	nvlist_t *nvinfo = fnvlist_lookup_nvlist(config,
	ZPOOL_CONFIG_LOAD_INFO);

	if (nvlist_exists(nvinfo, ZPOOL_CONFIG_MMP_TXG) &&
	fnvlist_lookup_uint64(nvinfo, ZPOOL_CONFIG_MMP_TXG) == 0) {
	vdev_uberblock_load(rvd, ub, &mmp_label);
	error = SET_ERROR(EREMOTEIO);
	goto out;
	}
	}

	import_delay = spa_activity_check_duration(spa, ub);

	/* Add a small random factor in case of simultaneous imports (0-25%) */
	import_delay += import_delay * spa_get_random(250) / 1000;

	import_expire = gethrtime() + import_delay;

	while (gethrtime() < import_expire) {
	(void) spa_import_progress_set_mmp_check(spa_guid(spa),
	NSEC2SEC(import_expire - gethrtime()));

	vdev_uberblock_load(rvd, ub, &mmp_label);

	if (txg != ub->ub_txg \|\| timestamp != ub->ub_timestamp \|\|
	mmp_seq != (MMP_SEQ_VALID(ub) ? MMP_SEQ(ub) : 0)) {
	zfs_dbgmsg("multihost activity detected "
	"txg %llu ub_txg %llu "
	"timestamp %llu ub_timestamp %llu "
	"mmp_config %#llx ub_mmp_config %#llx",
	txg, ub->ub_txg, timestamp, ub->ub_timestamp,
	mmp_config, ub->ub_mmp_config);

	error = SET_ERROR(EREMOTEIO);
	break;
	}

	if (mmp_label) {
	nvlist_free(mmp_label);
	mmp_label = NULL;
	}

	error = cv_timedwait_sig(&cv, &mtx, ddi_get_lbolt() + hz);
	if (error != -1) {
	error = SET_ERROR(EINTR);
	break;
	}
	error = 0;
	}

	out:
	mutex_exit(&mtx);
	mutex_destroy(&mtx);
	cv_destroy(&cv);

	/*
	* If the pool is determined to be active store the status in the
	* spa->spa_load_info nvlist. If the remote hostname or hostid are
	* available from configuration read from disk store them as well.
	* This allows 'zpool import' to generate a more useful message.
	*
	* ZPOOL_CONFIG_MMP_STATE - observed pool status (mandatory)
	* ZPOOL_CONFIG_MMP_HOSTNAME - hostname from the active pool
	* ZPOOL_CONFIG_MMP_HOSTID - hostid from the active pool
	*/
	if (error == EREMOTEIO) {
	char *hostname = "<unknown>";
	uint64_t hostid = 0;

	if (mmp_label) {
	if (nvlist_exists(mmp_label, ZPOOL_CONFIG_HOSTNAME)) {
	hostname = fnvlist_lookup_string(mmp_label,
	ZPOOL_CONFIG_HOSTNAME);
	fnvlist_add_string(spa->spa_load_info,
	ZPOOL_CONFIG_MMP_HOSTNAME, hostname);
	}

	if (nvlist_exists(mmp_label, ZPOOL_CONFIG_HOSTID)) {
	hostid = fnvlist_lookup_uint64(mmp_label,
	ZPOOL_CONFIG_HOSTID);
	fnvlist_add_uint64(spa->spa_load_info,
	ZPOOL_CONFIG_MMP_HOSTID, hostid);
	}
	}

	fnvlist_add_uint64(spa->spa_load_info,
	ZPOOL_CONFIG_MMP_STATE, MMP_STATE_ACTIVE);
	fnvlist_add_uint64(spa->spa_load_info,
	ZPOOL_CONFIG_MMP_TXG, 0);

	error = spa_vdev_err(rvd, VDEV_AUX_ACTIVE, EREMOTEIO);
	}

	if (mmp_label)
	nvlist_free(mmp_label);

	return (error);
	}

	static int
	spa_verify_host(spa_t spa, nvlist_t mos_config)
	{
	uint64_t hostid;
	char *hostname;
	uint64_t myhostid = 0;

	if (!spa_is_root(spa) && nvlist_lookup_uint64(mos_config,
	ZPOOL_CONFIG_HOSTID, &hostid) == 0) {
	hostname = fnvlist_lookup_string(mos_config,
	ZPOOL_CONFIG_HOSTNAME);

	myhostid = zone_get_hostid(NULL);

	if (hostid != 0 && myhostid != 0 && hostid != myhostid) {
	cmn_err(CE_WARN, "pool '%s' could not be "
	"loaded as it was last accessed by "
	"another system (host: %s hostid: 0x%llx). "
	"See: https://openzfs.github.io/openzfs-docs/msg/"
	"ZFS-8000-EY",
	spa_name(spa), hostname, (u_longlong_t)hostid);
	spa_load_failed(spa, "hostid verification failed: pool "
	"last accessed by host: %s (hostid: 0x%llx)",
	hostname, (u_longlong_t)hostid);
	return (SET_ERROR(EBADF));
	}
	}

	return (0);
	}

	static int
	spa_ld_parse_config(spa_t *spa, spa_import_type_t type)
	{
	int error = 0;
	nvlist_t nvtree, nvl, *config = spa->spa_config;
	int parse;
	vdev_t *rvd;
	uint64_t pool_guid;
	char *comment;
	char *compatibility;

	/*
	* Versioning wasn't explicitly added to the label until later, so if
	* it's not present treat it as the initial version.
	*/
	if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_VERSION,
	&spa->spa_ubsync.ub_version) != 0)
	spa->spa_ubsync.ub_version = SPA_VERSION_INITIAL;

	if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, &pool_guid)) {
	spa_load_failed(spa, "invalid config provided: '%s' missing",
	ZPOOL_CONFIG_POOL_GUID);
	return (SET_ERROR(EINVAL));
	}

	/*
	* If we are doing an import, ensure that the pool is not already
	* imported by checking if its pool guid already exists in the
	* spa namespace.
	*
	* The only case that we allow an already imported pool to be
	* imported again, is when the pool is checkpointed and we want to
	* look at its checkpointed state from userland tools like zdb.
	*/
	#ifdef _KERNEL
	if ((spa->spa_load_state == SPA_LOAD_IMPORT \|\|
	spa->spa_load_state == SPA_LOAD_TRYIMPORT) &&
	spa_guid_exists(pool_guid, 0)) {
	#else
	if ((spa->spa_load_state == SPA_LOAD_IMPORT \|\|
	spa->spa_load_state == SPA_LOAD_TRYIMPORT) &&
	spa_guid_exists(pool_guid, 0) &&
	!spa_importing_readonly_checkpoint(spa)) {
	#endif
	spa_load_failed(spa, "a pool with guid %llu is already open",
	(u_longlong_t)pool_guid);
	return (SET_ERROR(EEXIST));
	}

	spa->spa_config_guid = pool_guid;

	nvlist_free(spa->spa_load_info);
	spa->spa_load_info = fnvlist_alloc();

	ASSERT(spa->spa_comment == NULL);
	if (nvlist_lookup_string(config, ZPOOL_CONFIG_COMMENT, &comment) == 0)
	spa->spa_comment = spa_strdup(comment);

	ASSERT(spa->spa_compatibility == NULL);
	if (nvlist_lookup_string(config, ZPOOL_CONFIG_COMPATIBILITY,
	&compatibility) == 0)
	spa->spa_compatibility = spa_strdup(compatibility);

	(void) nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_TXG,
	&spa->spa_config_txg);

	if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_SPLIT, &nvl) == 0)
	spa->spa_config_splitting = fnvlist_dup(nvl);

	if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, &nvtree)) {
	spa_load_failed(spa, "invalid config provided: '%s' missing",
	ZPOOL_CONFIG_VDEV_TREE);
	return (SET_ERROR(EINVAL));
	}

	/*
	* Create "The Godfather" zio to hold all async IOs
	*/
	spa->spa_async_zio_root = kmem_alloc(max_ncpus * sizeof (void *),
	KM_SLEEP);
	for (int i = 0; i < max_ncpus; i++) {
	spa->spa_async_zio_root[i] = zio_root(spa, NULL, NULL,
	ZIO_FLAG_CANFAIL \| ZIO_FLAG_SPECULATIVE \|
	ZIO_FLAG_GODFATHER);
	}

	/*
	* Parse the configuration into a vdev tree. We explicitly set the
	* value that will be returned by spa_version() since parsing the
	* configuration requires knowing the version number.
	*/
	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
	parse = (type == SPA_IMPORT_EXISTING ?
	VDEV_ALLOC_LOAD : VDEV_ALLOC_SPLIT);
	error = spa_config_parse(spa, &rvd, nvtree, NULL, 0, parse);
	spa_config_exit(spa, SCL_ALL, FTAG);

	if (error != 0) {
	spa_load_failed(spa, "unable to parse config [error=%d]",
	error);
	return (error);
	}

	ASSERT(spa->spa_root_vdev == rvd);
	ASSERT3U(spa->spa_min_ashift, >=, SPA_MINBLOCKSHIFT);
	ASSERT3U(spa->spa_max_ashift, <=, SPA_MAXBLOCKSHIFT);

	if (type != SPA_IMPORT_ASSEMBLE) {
	ASSERT(spa_guid(spa) == pool_guid);
	}

	return (0);
	}

	/*
	* Recursively open all vdevs in the vdev tree. This function is called twice:
	* first with the untrusted config, then with the trusted config.
	*/
	static int
	spa_ld_open_vdevs(spa_t *spa)
	{
	int error = 0;

	/*
	* spa_missing_tvds_allowed defines how many top-level vdevs can be
	* missing/unopenable for the root vdev to be still considered openable.
	*/
	if (spa->spa_trust_config) {
	spa->spa_missing_tvds_allowed = zfs_max_missing_tvds;
	} else if (spa->spa_config_source == SPA_CONFIG_SRC_CACHEFILE) {
	spa->spa_missing_tvds_allowed = zfs_max_missing_tvds_cachefile;
	} else if (spa->spa_config_source == SPA_CONFIG_SRC_SCAN) {
	spa->spa_missing_tvds_allowed = zfs_max_missing_tvds_scan;
	} else {
	spa->spa_missing_tvds_allowed = 0;
	}

	spa->spa_missing_tvds_allowed =
	MAX(zfs_max_missing_tvds, spa->spa_missing_tvds_allowed);

	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
	error = vdev_open(spa->spa_root_vdev);
	spa_config_exit(spa, SCL_ALL, FTAG);

	if (spa->spa_missing_tvds != 0) {
	spa_load_note(spa, "vdev tree has %lld missing top-level "
	"vdevs.", (u_longlong_t)spa->spa_missing_tvds);
	if (spa->spa_trust_config && (spa->spa_mode & SPA_MODE_WRITE)) {
	/*
	* Although theoretically we could allow users to open
	* incomplete pools in RW mode, we'd need to add a lot
	* of extra logic (e.g. adjust pool space to account
	* for missing vdevs).
	* This limitation also prevents users from accidentally
	* opening the pool in RW mode during data recovery and
	* damaging it further.
	*/
	spa_load_note(spa, "pools with missing top-level "
	"vdevs can only be opened in read-only mode.");
	error = SET_ERROR(ENXIO);
	} else {
	spa_load_note(spa, "current settings allow for maximum "
	"%lld missing top-level vdevs at this stage.",
	(u_longlong_t)spa->spa_missing_tvds_allowed);
	}
	}
	if (error != 0) {
	spa_load_failed(spa, "unable to open vdev tree [error=%d]",
	error);
	}
	if (spa->spa_missing_tvds != 0 \|\| error != 0)
	vdev_dbgmsg_print_tree(spa->spa_root_vdev, 2);

	return (error);
	}

	/*
	* We need to validate the vdev labels against the configuration that
	* we have in hand. This function is called twice: first with an untrusted
	* config, then with a trusted config. The validation is more strict when the
	* config is trusted.
	*/
	static int
	spa_ld_validate_vdevs(spa_t *spa)
	{
	int error = 0;
	vdev_t *rvd = spa->spa_root_vdev;

	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
	error = vdev_validate(rvd);
	spa_config_exit(spa, SCL_ALL, FTAG);

	if (error != 0) {
	spa_load_failed(spa, "vdev_validate failed [error=%d]", error);
	return (error);
	}

	if (rvd->vdev_state <= VDEV_STATE_CANT_OPEN) {
	spa_load_failed(spa, "cannot open vdev tree after invalidating "
	"some vdevs");
	vdev_dbgmsg_print_tree(rvd, 2);
	return (SET_ERROR(ENXIO));
	}

	return (0);
	}

	static void
	spa_ld_select_uberblock_done(spa_t spa, uberblock_t ub)
	{
	spa->spa_state = POOL_STATE_ACTIVE;
	spa->spa_ubsync = spa->spa_uberblock;
	spa->spa_verify_min_txg = spa->spa_extreme_rewind ?
	TXG_INITIAL - 1 : spa_last_synced_txg(spa) - TXG_DEFER_SIZE - 1;
	spa->spa_first_txg = spa->spa_last_ubsync_txg ?
	spa->spa_last_ubsync_txg : spa_last_synced_txg(spa) + 1;
	spa->spa_claim_max_txg = spa->spa_first_txg;
	spa->spa_prev_software_version = ub->ub_software_version;
	}

	static int
	spa_ld_select_uberblock(spa_t *spa, spa_import_type_t type)
	{
	vdev_t *rvd = spa->spa_root_vdev;
	nvlist_t *label;
	uberblock_t *ub = &spa->spa_uberblock;
	boolean_t activity_check = B_FALSE;

	/*
	* If we are opening the checkpointed state of the pool by
	* rewinding to it, at this point we will have written the
	* checkpointed uberblock to the vdev labels, so searching
	* the labels will find the right uberblock. However, if
	* we are opening the checkpointed state read-only, we have
	* not modified the labels. Therefore, we must ignore the
	* labels and continue using the spa_uberblock that was set
	* by spa_ld_checkpoint_rewind.
	*
	* Note that it would be fine to ignore the labels when
	* rewinding (opening writeable) as well. However, if we
	* crash just after writing the labels, we will end up
	* searching the labels. Doing so in the common case means
	* that this code path gets exercised normally, rather than
	* just in the edge case.
	*/
	if (ub->ub_checkpoint_txg != 0 &&
	spa_importing_readonly_checkpoint(spa)) {
	spa_ld_select_uberblock_done(spa, ub);
	return (0);
	}

	/*
	* Find the best uberblock.
	*/
	vdev_uberblock_load(rvd, ub, &label);

	/*
	* If we weren't able to find a single valid uberblock, return failure.
	*/
	if (ub->ub_txg == 0) {
	nvlist_free(label);
	spa_load_failed(spa, "no valid uberblock found");
	return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, ENXIO));
	}

	if (spa->spa_load_max_txg != UINT64_MAX) {
	(void) spa_import_progress_set_max_txg(spa_guid(spa),
	(u_longlong_t)spa->spa_load_max_txg);
	}
	spa_load_note(spa, "using uberblock with txg=%llu",
	(u_longlong_t)ub->ub_txg);


	/*
	* For pools which have the multihost property on determine if the
	* pool is truly inactive and can be safely imported. Prevent
	* hosts which don't have a hostid set from importing the pool.
	*/
	activity_check = spa_activity_check_required(spa, ub, label,
	spa->spa_config);
	if (activity_check) {
	if (ub->ub_mmp_magic == MMP_MAGIC && ub->ub_mmp_delay &&
	spa_get_hostid(spa) == 0) {
	nvlist_free(label);
	fnvlist_add_uint64(spa->spa_load_info,
	ZPOOL_CONFIG_MMP_STATE, MMP_STATE_NO_HOSTID);
	return (spa_vdev_err(rvd, VDEV_AUX_ACTIVE, EREMOTEIO));
	}

	int error = spa_activity_check(spa, ub, spa->spa_config);
	if (error) {
	nvlist_free(label);
	return (error);
	}

	fnvlist_add_uint64(spa->spa_load_info,
	ZPOOL_CONFIG_MMP_STATE, MMP_STATE_INACTIVE);
	fnvlist_add_uint64(spa->spa_load_info,
	ZPOOL_CONFIG_MMP_TXG, ub->ub_txg);
	fnvlist_add_uint16(spa->spa_load_info,
	ZPOOL_CONFIG_MMP_SEQ,
	(MMP_SEQ_VALID(ub) ? MMP_SEQ(ub) : 0));
	}

	/*
	* If the pool has an unsupported version we can't open it.
	*/
	if (!SPA_VERSION_IS_SUPPORTED(ub->ub_version)) {
	nvlist_free(label);
	spa_load_failed(spa, "version %llu is not supported",
	(u_longlong_t)ub->ub_version);
	return (spa_vdev_err(rvd, VDEV_AUX_VERSION_NEWER, ENOTSUP));
	}

	if (ub->ub_version >= SPA_VERSION_FEATURES) {
	nvlist_t *features;

	/*
	* If we weren't able to find what's necessary for reading the
	* MOS in the label, return failure.
	*/
	if (label == NULL) {
	spa_load_failed(spa, "label config unavailable");
	return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA,
	ENXIO));
	}

	if (nvlist_lookup_nvlist(label, ZPOOL_CONFIG_FEATURES_FOR_READ,
	&features) != 0) {
	nvlist_free(label);
	spa_load_failed(spa, "invalid label: '%s' missing",
	ZPOOL_CONFIG_FEATURES_FOR_READ);
	return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA,
	ENXIO));
	}

	/*
	* Update our in-core representation with the definitive values
	* from the label.
	*/
	nvlist_free(spa->spa_label_features);
	VERIFY(nvlist_dup(features, &spa->spa_label_features, 0) == 0);
	}

	nvlist_free(label);

	/*
	* Look through entries in the label nvlist's features_for_read. If
	* there is a feature listed there which we don't understand then we
	* cannot open a pool.
	*/
	if (ub->ub_version >= SPA_VERSION_FEATURES) {
	nvlist_t *unsup_feat;

	VERIFY(nvlist_alloc(&unsup_feat, NV_UNIQUE_NAME, KM_SLEEP) ==
	0);

	for (nvpair_t *nvp = nvlist_next_nvpair(spa->spa_label_features,
	NULL); nvp != NULL;
	nvp = nvlist_next_nvpair(spa->spa_label_features, nvp)) {
	if (!zfeature_is_supported(nvpair_name(nvp))) {
	VERIFY(nvlist_add_string(unsup_feat,
	nvpair_name(nvp), "") == 0);
	}
	}

	if (!nvlist_empty(unsup_feat)) {
	VERIFY(nvlist_add_nvlist(spa->spa_load_info,
	ZPOOL_CONFIG_UNSUP_FEAT, unsup_feat) == 0);
	nvlist_free(unsup_feat);
	spa_load_failed(spa, "some features are unsupported");
	return (spa_vdev_err(rvd, VDEV_AUX_UNSUP_FEAT,
	ENOTSUP));
	}

	nvlist_free(unsup_feat);
	}

	if (type != SPA_IMPORT_ASSEMBLE && spa->spa_config_splitting) {
	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
	spa_try_repair(spa, spa->spa_config);
	spa_config_exit(spa, SCL_ALL, FTAG);
	nvlist_free(spa->spa_config_splitting);
	spa->spa_config_splitting = NULL;
	}

	/*
	* Initialize internal SPA structures.
	*/
	spa_ld_select_uberblock_done(spa, ub);

	return (0);
	}

	static int
	spa_ld_open_rootbp(spa_t *spa)
	{
	int error = 0;
	vdev_t *rvd = spa->spa_root_vdev;

	error = dsl_pool_init(spa, spa->spa_first_txg, &spa->spa_dsl_pool);
	if (error != 0) {
	spa_load_failed(spa, "unable to open rootbp in dsl_pool_init "
	"[error=%d]", error);
	return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
	}
	spa->spa_meta_objset = spa->spa_dsl_pool->dp_meta_objset;

	return (0);
	}

	static int
	spa_ld_trusted_config(spa_t *spa, spa_import_type_t type,
	boolean_t reloading)
	{
	vdev_t mrvd, rvd = spa->spa_root_vdev;
	nvlist_t nv, mos_config, *policy;
	int error = 0, copy_error;
	uint64_t healthy_tvds, healthy_tvds_mos;
	uint64_t mos_config_txg;

	if (spa_dir_prop(spa, DMU_POOL_CONFIG, &spa->spa_config_object, B_TRUE)
	!= 0)
	return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));

	/*
	* If we're assembling a pool from a split, the config provided is
	* already trusted so there is nothing to do.
	*/
	if (type == SPA_IMPORT_ASSEMBLE)
	return (0);

	healthy_tvds = spa_healthy_core_tvds(spa);

	if (load_nvlist(spa, spa->spa_config_object, &mos_config)
	!= 0) {
	spa_load_failed(spa, "unable to retrieve MOS config");
	return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
	}

	/*
	* If we are doing an open, pool owner wasn't verified yet, thus do
	* the verification here.
	*/
	if (spa->spa_load_state == SPA_LOAD_OPEN) {
	error = spa_verify_host(spa, mos_config);
	if (error != 0) {
	nvlist_free(mos_config);
	return (error);
	}
	}

	nv = fnvlist_lookup_nvlist(mos_config, ZPOOL_CONFIG_VDEV_TREE);

	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);

	/*
	* Build a new vdev tree from the trusted config
	*/
	error = spa_config_parse(spa, &mrvd, nv, NULL, 0, VDEV_ALLOC_LOAD);
	if (error != 0) {
	nvlist_free(mos_config);
	spa_config_exit(spa, SCL_ALL, FTAG);
	spa_load_failed(spa, "spa_config_parse failed [error=%d]",
	error);
	return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, error));
	}

	/*
	* Vdev paths in the MOS may be obsolete. If the untrusted config was
	* obtained by scanning /dev/dsk, then it will have the right vdev
	* paths. We update the trusted MOS config with this information.
	* We first try to copy the paths with vdev_copy_path_strict, which
	* succeeds only when both configs have exactly the same vdev tree.
	* If that fails, we fall back to a more flexible method that has a
	* best effort policy.
	*/
	copy_error = vdev_copy_path_strict(rvd, mrvd);
	if (copy_error != 0 \|\| spa_load_print_vdev_tree) {
	spa_load_note(spa, "provided vdev tree:");
	vdev_dbgmsg_print_tree(rvd, 2);
	spa_load_note(spa, "MOS vdev tree:");
	vdev_dbgmsg_print_tree(mrvd, 2);
	}
	if (copy_error != 0) {
	spa_load_note(spa, "vdev_copy_path_strict failed, falling "
	"back to vdev_copy_path_relaxed");
	vdev_copy_path_relaxed(rvd, mrvd);
	}

	vdev_close(rvd);
	vdev_free(rvd);
	spa->spa_root_vdev = mrvd;
	rvd = mrvd;
	spa_config_exit(spa, SCL_ALL, FTAG);

	/*
	* We will use spa_config if we decide to reload the spa or if spa_load
	* fails and we rewind. We must thus regenerate the config using the
	* MOS information with the updated paths. ZPOOL_LOAD_POLICY is used to
	* pass settings on how to load the pool and is not stored in the MOS.
	* We copy it over to our new, trusted config.
	*/
	mos_config_txg = fnvlist_lookup_uint64(mos_config,
	ZPOOL_CONFIG_POOL_TXG);
	nvlist_free(mos_config);
	mos_config = spa_config_generate(spa, NULL, mos_config_txg, B_FALSE);
	if (nvlist_lookup_nvlist(spa->spa_config, ZPOOL_LOAD_POLICY,
	&policy) == 0)
	fnvlist_add_nvlist(mos_config, ZPOOL_LOAD_POLICY, policy);
	spa_config_set(spa, mos_config);
	spa->spa_config_source = SPA_CONFIG_SRC_MOS;

	/*
	* Now that we got the config from the MOS, we should be more strict
	* in checking blkptrs and can make assumptions about the consistency
	* of the vdev tree. spa_trust_config must be set to true before opening
	* vdevs in order for them to be writeable.
	*/
	spa->spa_trust_config = B_TRUE;

	/*
	* Open and validate the new vdev tree
	*/
	error = spa_ld_open_vdevs(spa);
	if (error != 0)
	return (error);

	error = spa_ld_validate_vdevs(spa);
	if (error != 0)
	return (error);

	if (copy_error != 0 \|\| spa_load_print_vdev_tree) {
	spa_load_note(spa, "final vdev tree:");
	vdev_dbgmsg_print_tree(rvd, 2);
	}

	if (spa->spa_load_state != SPA_LOAD_TRYIMPORT &&
	!spa->spa_extreme_rewind && zfs_max_missing_tvds == 0) {
	/*
	* Sanity check to make sure that we are indeed loading the
	* latest uberblock. If we missed SPA_SYNC_MIN_VDEVS tvds
	* in the config provided and they happened to be the only ones
	* to have the latest uberblock, we could involuntarily perform
	* an extreme rewind.
	*/
	healthy_tvds_mos = spa_healthy_core_tvds(spa);
	if (healthy_tvds_mos - healthy_tvds >=
	SPA_SYNC_MIN_VDEVS) {
	spa_load_note(spa, "config provided misses too many "
	"top-level vdevs compared to MOS (%lld vs %lld). ",
	(u_longlong_t)healthy_tvds,
	(u_longlong_t)healthy_tvds_mos);
	spa_load_note(spa, "vdev tree:");
	vdev_dbgmsg_print_tree(rvd, 2);
	if (reloading) {
	spa_load_failed(spa, "config was already "
	"provided from MOS. Aborting.");
	return (spa_vdev_err(rvd,
	VDEV_AUX_CORRUPT_DATA, EIO));
	}
	spa_load_note(spa, "spa must be reloaded using MOS "
	"config");
	return (SET_ERROR(EAGAIN));
	}
	}

	error = spa_check_for_missing_logs(spa);
	if (error != 0)
	return (spa_vdev_err(rvd, VDEV_AUX_BAD_GUID_SUM, ENXIO));

	if (rvd->vdev_guid_sum != spa->spa_uberblock.ub_guid_sum) {
	spa_load_failed(spa, "uberblock guid sum doesn't match MOS "
	"guid sum (%llu != %llu)",
	(u_longlong_t)spa->spa_uberblock.ub_guid_sum,
	(u_longlong_t)rvd->vdev_guid_sum);
	return (spa_vdev_err(rvd, VDEV_AUX_BAD_GUID_SUM,
	ENXIO));
	}

	return (0);
	}

	static int
	spa_ld_open_indirect_vdev_metadata(spa_t *spa)
	{
	int error = 0;
	vdev_t *rvd = spa->spa_root_vdev;

	/*
	* Everything that we read before spa_remove_init() must be stored
	* on concreted vdevs. Therefore we do this as early as possible.
	*/
	error = spa_remove_init(spa);
	if (error != 0) {
	spa_load_failed(spa, "spa_remove_init failed [error=%d]",
	error);
	return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
	}

	/*
	* Retrieve information needed to condense indirect vdev mappings.
	*/
	error = spa_condense_init(spa);
	if (error != 0) {
	spa_load_failed(spa, "spa_condense_init failed [error=%d]",
	error);
	return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, error));
	}

	return (0);
	}

	static int
	spa_ld_check_features(spa_t spa, boolean_t missing_feat_writep)
	{
	int error = 0;
	vdev_t *rvd = spa->spa_root_vdev;

	if (spa_version(spa) >= SPA_VERSION_FEATURES) {
	boolean_t missing_feat_read = B_FALSE;
	nvlist_t unsup_feat, enabled_feat;

	if (spa_dir_prop(spa, DMU_POOL_FEATURES_FOR_READ,
	&spa->spa_feat_for_read_obj, B_TRUE) != 0) {
	return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
	}

	if (spa_dir_prop(spa, DMU_POOL_FEATURES_FOR_WRITE,
	&spa->spa_feat_for_write_obj, B_TRUE) != 0) {
	return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
	}

	if (spa_dir_prop(spa, DMU_POOL_FEATURE_DESCRIPTIONS,
	&spa->spa_feat_desc_obj, B_TRUE) != 0) {
	return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
	}

	enabled_feat = fnvlist_alloc();
	unsup_feat = fnvlist_alloc();

	if (!spa_features_check(spa, B_FALSE,
	unsup_feat, enabled_feat))
	missing_feat_read = B_TRUE;

	if (spa_writeable(spa) \|\|
	spa->spa_load_state == SPA_LOAD_TRYIMPORT) {
	if (!spa_features_check(spa, B_TRUE,
	unsup_feat, enabled_feat)) {
	*missing_feat_writep = B_TRUE;
	}
	}

	fnvlist_add_nvlist(spa->spa_load_info,
	ZPOOL_CONFIG_ENABLED_FEAT, enabled_feat);

	if (!nvlist_empty(unsup_feat)) {
	fnvlist_add_nvlist(spa->spa_load_info,
	ZPOOL_CONFIG_UNSUP_FEAT, unsup_feat);
	}

	fnvlist_free(enabled_feat);
	fnvlist_free(unsup_feat);

	if (!missing_feat_read) {
	fnvlist_add_boolean(spa->spa_load_info,
	ZPOOL_CONFIG_CAN_RDONLY);
	}

	/*
	* If the state is SPA_LOAD_TRYIMPORT, our objective is
	* twofold: to determine whether the pool is available for
	* import in read-write mode and (if it is not) whether the
	* pool is available for import in read-only mode. If the pool
	* is available for import in read-write mode, it is displayed
	* as available in userland; if it is not available for import
	* in read-only mode, it is displayed as unavailable in
	* userland. If the pool is available for import in read-only
	* mode but not read-write mode, it is displayed as unavailable
	* in userland with a special note that the pool is actually
	* available for open in read-only mode.
	*
	* As a result, if the state is SPA_LOAD_TRYIMPORT and we are
	* missing a feature for write, we must first determine whether
	* the pool can be opened read-only before returning to
	* userland in order to know whether to display the
	* abovementioned note.
	*/
	if (missing_feat_read \|\| (*missing_feat_writep &&
	spa_writeable(spa))) {
	spa_load_failed(spa, "pool uses unsupported features");
	return (spa_vdev_err(rvd, VDEV_AUX_UNSUP_FEAT,
	ENOTSUP));
	}

	/*
	* Load refcounts for ZFS features from disk into an in-memory
	* cache during SPA initialization.
	*/
	for (spa_feature_t i = 0; i < SPA_FEATURES; i++) {
	uint64_t refcount;

	error = feature_get_refcount_from_disk(spa,
	&spa_feature_table[i], &refcount);
	if (error == 0) {
	spa->spa_feat_refcount_cache[i] = refcount;
	} else if (error == ENOTSUP) {
	spa->spa_feat_refcount_cache[i] =
	SPA_FEATURE_DISABLED;
	} else {
	spa_load_failed(spa, "error getting refcount "
	"for feature %s [error=%d]",
	spa_feature_table[i].fi_guid, error);
	return (spa_vdev_err(rvd,
	VDEV_AUX_CORRUPT_DATA, EIO));
	}
	}
	}

	if (spa_feature_is_active(spa, SPA_FEATURE_ENABLED_TXG)) {
	if (spa_dir_prop(spa, DMU_POOL_FEATURE_ENABLED_TXG,
	&spa->spa_feat_enabled_txg_obj, B_TRUE) != 0)
	return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
	}

	/*
	* Encryption was added before bookmark_v2, even though bookmark_v2
	* is now a dependency. If this pool has encryption enabled without
	* bookmark_v2, trigger an errata message.
	*/
	if (spa_feature_is_enabled(spa, SPA_FEATURE_ENCRYPTION) &&
	!spa_feature_is_enabled(spa, SPA_FEATURE_BOOKMARK_V2)) {
	spa->spa_errata = ZPOOL_ERRATA_ZOL_8308_ENCRYPTION;
	}

	return (0);
	}

	static int
	spa_ld_load_special_directories(spa_t *spa)
	{
	int error = 0;
	vdev_t *rvd = spa->spa_root_vdev;

	spa->spa_is_initializing = B_TRUE;
	error = dsl_pool_open(spa->spa_dsl_pool);
	spa->spa_is_initializing = B_FALSE;
	if (error != 0) {
	spa_load_failed(spa, "dsl_pool_open failed [error=%d]", error);
	return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
	}

	return (0);
	}

	static int
	spa_ld_get_props(spa_t *spa)
	{
	int error = 0;
	uint64_t obj;
	vdev_t *rvd = spa->spa_root_vdev;

	/* Grab the checksum salt from the MOS. */
	error = zap_lookup(spa->spa_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
	DMU_POOL_CHECKSUM_SALT, 1,
	sizeof (spa->spa_cksum_salt.zcs_bytes),
	spa->spa_cksum_salt.zcs_bytes);
	if (error == ENOENT) {
	/* Generate a new salt for subsequent use */
	(void) random_get_pseudo_bytes(spa->spa_cksum_salt.zcs_bytes,
	sizeof (spa->spa_cksum_salt.zcs_bytes));
	} else if (error != 0) {
	spa_load_failed(spa, "unable to retrieve checksum salt from "
	"MOS [error=%d]", error);
	return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
	}

	if (spa_dir_prop(spa, DMU_POOL_SYNC_BPOBJ, &obj, B_TRUE) != 0)
	return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
	error = bpobj_open(&spa->spa_deferred_bpobj, spa->spa_meta_objset, obj);
	if (error != 0) {
	spa_load_failed(spa, "error opening deferred-frees bpobj "
	"[error=%d]", error);
	return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
	}

	/*
	* Load the bit that tells us to use the new accounting function
	* (raid-z deflation). If we have an older pool, this will not
	* be present.
	*/
	error = spa_dir_prop(spa, DMU_POOL_DEFLATE, &spa->spa_deflate, B_FALSE);
	if (error != 0 && error != ENOENT)
	return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));

	error = spa_dir_prop(spa, DMU_POOL_CREATION_VERSION,
	&spa->spa_creation_version, B_FALSE);
	if (error != 0 && error != ENOENT)
	return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));

	/*
	* Load the persistent error log. If we have an older pool, this will
	* not be present.
	*/
	error = spa_dir_prop(spa, DMU_POOL_ERRLOG_LAST, &spa->spa_errlog_last,
	B_FALSE);
	if (error != 0 && error != ENOENT)
	return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));

	error = spa_dir_prop(spa, DMU_POOL_ERRLOG_SCRUB,
	&spa->spa_errlog_scrub, B_FALSE);
	if (error != 0 && error != ENOENT)
	return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));

	/*
	* Load the livelist deletion field. If a livelist is queued for
	* deletion, indicate that in the spa
	*/
	error = spa_dir_prop(spa, DMU_POOL_DELETED_CLONES,
	&spa->spa_livelists_to_delete, B_FALSE);
	if (error != 0 && error != ENOENT)
	return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));

	/*
	* Load the history object. If we have an older pool, this
	* will not be present.
	*/
	error = spa_dir_prop(spa, DMU_POOL_HISTORY, &spa->spa_history, B_FALSE);
	if (error != 0 && error != ENOENT)
	return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));

	/*
	* Load the per-vdev ZAP map. If we have an older pool, this will not
	* be present; in this case, defer its creation to a later time to
	* avoid dirtying the MOS this early / out of sync context. See
	* spa_sync_config_object.
	*/

	/* The sentinel is only available in the MOS config. */
	nvlist_t *mos_config;
	if (load_nvlist(spa, spa->spa_config_object, &mos_config) != 0) {
	spa_load_failed(spa, "unable to retrieve MOS config");
	return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
	}

	error = spa_dir_prop(spa, DMU_POOL_VDEV_ZAP_MAP,
	&spa->spa_all_vdev_zaps, B_FALSE);

	if (error == ENOENT) {
	VERIFY(!nvlist_exists(mos_config,
	ZPOOL_CONFIG_HAS_PER_VDEV_ZAPS));
	spa->spa_avz_action = AVZ_ACTION_INITIALIZE;
	ASSERT0(vdev_count_verify_zaps(spa->spa_root_vdev));
	} else if (error != 0) {
	return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
	} else if (!nvlist_exists(mos_config, ZPOOL_CONFIG_HAS_PER_VDEV_ZAPS)) {
	/*
	* An older version of ZFS overwrote the sentinel value, so
	* we have orphaned per-vdev ZAPs in the MOS. Defer their
	* destruction to later; see spa_sync_config_object.
	*/
	spa->spa_avz_action = AVZ_ACTION_DESTROY;
	/*
	* We're assuming that no vdevs have had their ZAPs created
	* before this. Better be sure of it.
	*/
	ASSERT0(vdev_count_verify_zaps(spa->spa_root_vdev));
	}
	nvlist_free(mos_config);

	spa->spa_delegation = zpool_prop_default_numeric(ZPOOL_PROP_DELEGATION);

	error = spa_dir_prop(spa, DMU_POOL_PROPS, &spa->spa_pool_props_object,
	B_FALSE);
	if (error && error != ENOENT)
	return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));

	if (error == 0) {
	uint64_t autoreplace;

	spa_prop_find(spa, ZPOOL_PROP_BOOTFS, &spa->spa_bootfs);
	spa_prop_find(spa, ZPOOL_PROP_AUTOREPLACE, &autoreplace);
	spa_prop_find(spa, ZPOOL_PROP_DELEGATION, &spa->spa_delegation);
	spa_prop_find(spa, ZPOOL_PROP_FAILUREMODE, &spa->spa_failmode);
	spa_prop_find(spa, ZPOOL_PROP_AUTOEXPAND, &spa->spa_autoexpand);
	spa_prop_find(spa, ZPOOL_PROP_MULTIHOST, &spa->spa_multihost);
	spa_prop_find(spa, ZPOOL_PROP_AUTOTRIM, &spa->spa_autotrim);
	spa->spa_autoreplace = (autoreplace != 0);
	}

	/*
	* If we are importing a pool with missing top-level vdevs,
	* we enforce that the pool doesn't panic or get suspended on
	* error since the likelihood of missing data is extremely high.
	*/
	if (spa->spa_missing_tvds > 0 &&
	spa->spa_failmode != ZIO_FAILURE_MODE_CONTINUE &&
	spa->spa_load_state != SPA_LOAD_TRYIMPORT) {
	spa_load_note(spa, "forcing failmode to 'continue' "
	"as some top level vdevs are missing");
	spa->spa_failmode = ZIO_FAILURE_MODE_CONTINUE;
	}

	return (0);
	}

	static int
	spa_ld_open_aux_vdevs(spa_t *spa, spa_import_type_t type)
	{
	int error = 0;
	vdev_t *rvd = spa->spa_root_vdev;

	/*
	* If we're assembling the pool from the split-off vdevs of
	* an existing pool, we don't want to attach the spares & cache
	* devices.
	*/

	/*
	* Load any hot spares for this pool.
	*/
	error = spa_dir_prop(spa, DMU_POOL_SPARES, &spa->spa_spares.sav_object,
	B_FALSE);
	if (error != 0 && error != ENOENT)
	return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
	if (error == 0 && type != SPA_IMPORT_ASSEMBLE) {
	ASSERT(spa_version(spa) >= SPA_VERSION_SPARES);
	if (load_nvlist(spa, spa->spa_spares.sav_object,
	&spa->spa_spares.sav_config) != 0) {
	spa_load_failed(spa, "error loading spares nvlist");
	return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
	}

	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
	spa_load_spares(spa);
	spa_config_exit(spa, SCL_ALL, FTAG);
	} else if (error == 0) {
	spa->spa_spares.sav_sync = B_TRUE;
	}

	/*
	* Load any level 2 ARC devices for this pool.
	*/
	error = spa_dir_prop(spa, DMU_POOL_L2CACHE,
	&spa->spa_l2cache.sav_object, B_FALSE);
	if (error != 0 && error != ENOENT)
	return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
	if (error == 0 && type != SPA_IMPORT_ASSEMBLE) {
	ASSERT(spa_version(spa) >= SPA_VERSION_L2CACHE);
	if (load_nvlist(spa, spa->spa_l2cache.sav_object,
	&spa->spa_l2cache.sav_config) != 0) {
	spa_load_failed(spa, "error loading l2cache nvlist");
	return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
	}

	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
	spa_load_l2cache(spa);
	spa_config_exit(spa, SCL_ALL, FTAG);
	} else if (error == 0) {
	spa->spa_l2cache.sav_sync = B_TRUE;
	}

	return (0);
	}

	static int
	spa_ld_load_vdev_metadata(spa_t *spa)
	{
	int error = 0;
	vdev_t *rvd = spa->spa_root_vdev;

	/*
	* If the 'multihost' property is set, then never allow a pool to
	* be imported when the system hostid is zero. The exception to
	* this rule is zdb which is always allowed to access pools.
	*/
	if (spa_multihost(spa) && spa_get_hostid(spa) == 0 &&
	(spa->spa_import_flags & ZFS_IMPORT_SKIP_MMP) == 0) {
	fnvlist_add_uint64(spa->spa_load_info,
	ZPOOL_CONFIG_MMP_STATE, MMP_STATE_NO_HOSTID);
	return (spa_vdev_err(rvd, VDEV_AUX_ACTIVE, EREMOTEIO));
	}

	/*
	* If the 'autoreplace' property is set, then post a resource notifying
	* the ZFS DE that it should not issue any faults for unopenable
	* devices. We also iterate over the vdevs, and post a sysevent for any
	* unopenable vdevs so that the normal autoreplace handler can take
	* over.
	*/
	if (spa->spa_autoreplace && spa->spa_load_state != SPA_LOAD_TRYIMPORT) {
	spa_check_removed(spa->spa_root_vdev);
	/*
	* For the import case, this is done in spa_import(), because
	* at this point we're using the spare definitions from
	* the MOS config, not necessarily from the userland config.
	*/
	if (spa->spa_load_state != SPA_LOAD_IMPORT) {
	spa_aux_check_removed(&spa->spa_spares);
	spa_aux_check_removed(&spa->spa_l2cache);
	}
	}

	/*
	* Load the vdev metadata such as metaslabs, DTLs, spacemap object, etc.
	*/
	error = vdev_load(rvd);
	if (error != 0) {
	spa_load_failed(spa, "vdev_load failed [error=%d]", error);
	return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, error));
	}

	error = spa_ld_log_spacemaps(spa);
	if (error != 0) {
	spa_load_failed(spa, "spa_ld_log_sm_data failed [error=%d]",
	error);
	return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, error));
	}

	/*
	* Propagate the leaf DTLs we just loaded all the way up the vdev tree.
	*/
	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
	vdev_dtl_reassess(rvd, 0, 0, B_FALSE, B_FALSE);
	spa_config_exit(spa, SCL_ALL, FTAG);

	return (0);
	}

	static int
	spa_ld_load_dedup_tables(spa_t *spa)
	{
	int error = 0;
	vdev_t *rvd = spa->spa_root_vdev;

	error = ddt_load(spa);
	if (error != 0) {
	spa_load_failed(spa, "ddt_load failed [error=%d]", error);
	return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA, EIO));
	}

	return (0);
	}

	static int
	spa_ld_verify_logs(spa_t spa, spa_import_type_t type, char *ereport)
	{
	vdev_t *rvd = spa->spa_root_vdev;

	if (type != SPA_IMPORT_ASSEMBLE && spa_writeable(spa)) {
	boolean_t missing = spa_check_logs(spa);
	if (missing) {
	if (spa->spa_missing_tvds != 0) {
	spa_load_note(spa, "spa_check_logs failed "
	"so dropping the logs");
	} else {
	*ereport = FM_EREPORT_ZFS_LOG_REPLAY;
	spa_load_failed(spa, "spa_check_logs failed");
	return (spa_vdev_err(rvd, VDEV_AUX_BAD_LOG,
	ENXIO));
	}
	}
	}

	return (0);
	}

	static int
	spa_ld_verify_pool_data(spa_t *spa)
	{
	int error = 0;
	vdev_t *rvd = spa->spa_root_vdev;

	/*
	* We've successfully opened the pool, verify that we're ready
	* to start pushing transactions.
	*/
	if (spa->spa_load_state != SPA_LOAD_TRYIMPORT) {
	error = spa_load_verify(spa);
	if (error != 0) {
	spa_load_failed(spa, "spa_load_verify failed "
	"[error=%d]", error);
	return (spa_vdev_err(rvd, VDEV_AUX_CORRUPT_DATA,
	error));
	}
	}

	return (0);
	}

	static void
	spa_ld_claim_log_blocks(spa_t *spa)
	{
	dmu_tx_t *tx;
	dsl_pool_t *dp = spa_get_dsl(spa);

	/*
	* Claim log blocks that haven't been committed yet.
	* This must all happen in a single txg.
	* Note: spa_claim_max_txg is updated by spa_claim_notify(),
	* invoked from zil_claim_log_block()'s i/o done callback.
	* Price of rollback is that we abandon the log.
	*/
	spa->spa_claiming = B_TRUE;

	tx = dmu_tx_create_assigned(dp, spa_first_txg(spa));
	(void) dmu_objset_find_dp(dp, dp->dp_root_dir_obj,
	zil_claim, tx, DS_FIND_CHILDREN);
	dmu_tx_commit(tx);

	spa->spa_claiming = B_FALSE;

	spa_set_log_state(spa, SPA_LOG_GOOD);
	}

	static void
	spa_ld_check_for_config_update(spa_t *spa, uint64_t config_cache_txg,
	boolean_t update_config_cache)
	{
	vdev_t *rvd = spa->spa_root_vdev;
	int need_update = B_FALSE;

	/*
	* If the config cache is stale, or we have uninitialized
	* metaslabs (see spa_vdev_add()), then update the config.
	*
	* If this is a verbatim import, trust the current
	* in-core spa_config and update the disk labels.
	*/
	if (update_config_cache \|\| config_cache_txg != spa->spa_config_txg \|\|
	spa->spa_load_state == SPA_LOAD_IMPORT \|\|
	spa->spa_load_state == SPA_LOAD_RECOVER \|\|
	(spa->spa_import_flags & ZFS_IMPORT_VERBATIM))
	need_update = B_TRUE;

	for (int c = 0; c < rvd->vdev_children; c++)
	if (rvd->vdev_child[c]->vdev_ms_array == 0)
	need_update = B_TRUE;

	/*
	* Update the config cache asynchronously in case we're the
	* root pool, in which case the config cache isn't writable yet.
	*/
	if (need_update)
	spa_async_request(spa, SPA_ASYNC_CONFIG_UPDATE);
	}

	static void
	spa_ld_prepare_for_reload(spa_t *spa)
	{
	spa_mode_t mode = spa->spa_mode;
	int async_suspended = spa->spa_async_suspended;

	spa_unload(spa);
	spa_deactivate(spa);
	spa_activate(spa, mode);

	/*
	* We save the value of spa_async_suspended as it gets reset to 0 by
	* spa_unload(). We want to restore it back to the original value before
	* returning as we might be calling spa_async_resume() later.
	*/
	spa->spa_async_suspended = async_suspended;
	}

	static int
	spa_ld_read_checkpoint_txg(spa_t *spa)
	{
	uberblock_t checkpoint;
	int error = 0;

	ASSERT0(spa->spa_checkpoint_txg);
	ASSERT(MUTEX_HELD(&spa_namespace_lock));

	error = zap_lookup(spa->spa_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
	DMU_POOL_ZPOOL_CHECKPOINT, sizeof (uint64_t),
	sizeof (uberblock_t) / sizeof (uint64_t), &checkpoint);

	if (error == ENOENT)
	return (0);

	if (error != 0)
	return (error);

	ASSERT3U(checkpoint.ub_txg, !=, 0);
	ASSERT3U(checkpoint.ub_checkpoint_txg, !=, 0);
	ASSERT3U(checkpoint.ub_timestamp, !=, 0);
	spa->spa_checkpoint_txg = checkpoint.ub_txg;
	spa->spa_checkpoint_info.sci_timestamp = checkpoint.ub_timestamp;

	return (0);
	}

	static int
	spa_ld_mos_init(spa_t *spa, spa_import_type_t type)
	{
	int error = 0;

	ASSERT(MUTEX_HELD(&spa_namespace_lock));
	ASSERT(spa->spa_config_source != SPA_CONFIG_SRC_NONE);

	/*
	* Never trust the config that is provided unless we are assembling
	* a pool following a split.
	* This means don't trust blkptrs and the vdev tree in general. This
	* also effectively puts the spa in read-only mode since
	* spa_writeable() checks for spa_trust_config to be true.
	* We will later load a trusted config from the MOS.
	*/
	if (type != SPA_IMPORT_ASSEMBLE)
	spa->spa_trust_config = B_FALSE;

	/*
	* Parse the config provided to create a vdev tree.
	*/
	error = spa_ld_parse_config(spa, type);
	if (error != 0)
	return (error);

	spa_import_progress_add(spa);

	/*
	* Now that we have the vdev tree, try to open each vdev. This involves
	* opening the underlying physical device, retrieving its geometry and
	* probing the vdev with a dummy I/O. The state of each vdev will be set
	* based on the success of those operations. After this we'll be ready
	* to read from the vdevs.
	*/
	error = spa_ld_open_vdevs(spa);
	if (error != 0)
	return (error);

	/*
	* Read the label of each vdev and make sure that the GUIDs stored
	* there match the GUIDs in the config provided.
	* If we're assembling a new pool that's been split off from an
	* existing pool, the labels haven't yet been updated so we skip
	* validation for now.
	*/
	if (type != SPA_IMPORT_ASSEMBLE) {
	error = spa_ld_validate_vdevs(spa);
	if (error != 0)
	return (error);
	}

	/*
	* Read all vdev labels to find the best uberblock (i.e. latest,
	* unless spa_load_max_txg is set) and store it in spa_uberblock. We
	* get the list of features required to read blkptrs in the MOS from
	* the vdev label with the best uberblock and verify that our version
	* of zfs supports them all.
	*/
	error = spa_ld_select_uberblock(spa, type);
	if (error != 0)
	return (error);

	/*
	* Pass that uberblock to the dsl_pool layer which will open the root
	* blkptr. This blkptr points to the latest version of the MOS and will
	* allow us to read its contents.
	*/
	error = spa_ld_open_rootbp(spa);
	if (error != 0)
	return (error);

	return (0);
	}

	static int
	spa_ld_checkpoint_rewind(spa_t *spa)
	{
	uberblock_t checkpoint;
	int error = 0;

	ASSERT(MUTEX_HELD(&spa_namespace_lock));
	ASSERT(spa->spa_import_flags & ZFS_IMPORT_CHECKPOINT);

	error = zap_lookup(spa->spa_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
	DMU_POOL_ZPOOL_CHECKPOINT, sizeof (uint64_t),
	sizeof (uberblock_t) / sizeof (uint64_t), &checkpoint);

	if (error != 0) {
	spa_load_failed(spa, "unable to retrieve checkpointed "
	"uberblock from the MOS config [error=%d]", error);

	if (error == ENOENT)
	error = ZFS_ERR_NO_CHECKPOINT;

	return (error);
	}

	ASSERT3U(checkpoint.ub_txg, <, spa->spa_uberblock.ub_txg);
	ASSERT3U(checkpoint.ub_txg, ==, checkpoint.ub_checkpoint_txg);

	/*
	* We need to update the txg and timestamp of the checkpointed
	* uberblock to be higher than the latest one. This ensures that
	* the checkpointed uberblock is selected if we were to close and
	* reopen the pool right after we've written it in the vdev labels.
	* (also see block comment in vdev_uberblock_compare)
	*/
	checkpoint.ub_txg = spa->spa_uberblock.ub_txg + 1;
	checkpoint.ub_timestamp = gethrestime_sec();

	/*
	* Set current uberblock to be the checkpointed uberblock.
	*/
	spa->spa_uberblock = checkpoint;

	/*
	* If we are doing a normal rewind, then the pool is open for
	* writing and we sync the "updated" checkpointed uberblock to
	* disk. Once this is done, we've basically rewound the whole
	* pool and there is no way back.
	*
	* There are cases when we don't want to attempt and sync the
	* checkpointed uberblock to disk because we are opening a
	* pool as read-only. Specifically, verifying the checkpointed
	* state with zdb, and importing the checkpointed state to get
	* a "preview" of its content.
	*/
	if (spa_writeable(spa)) {
	vdev_t *rvd = spa->spa_root_vdev;

	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
	vdev_t *svd[SPA_SYNC_MIN_VDEVS] = { NULL };
	int svdcount = 0;
	int children = rvd->vdev_children;
	int c0 = spa_get_random(children);

	for (int c = 0; c < children; c++) {
	vdev_t *vd = rvd->vdev_child[(c0 + c) % children];

	/* Stop when revisiting the first vdev */
	if (c > 0 && svd[0] == vd)
	break;

	if (vd->vdev_ms_array == 0 \|\| vd->vdev_islog \|\|
	!vdev_is_concrete(vd))
	continue;

	svd[svdcount++] = vd;
	if (svdcount == SPA_SYNC_MIN_VDEVS)
	break;
	}
	error = vdev_config_sync(svd, svdcount, spa->spa_first_txg);
	if (error == 0)
	spa->spa_last_synced_guid = rvd->vdev_guid;
	spa_config_exit(spa, SCL_ALL, FTAG);

	if (error != 0) {
	spa_load_failed(spa, "failed to write checkpointed "
	"uberblock to the vdev labels [error=%d]", error);
	return (error);
	}
	}

	return (0);
	}

	static int
	spa_ld_mos_with_trusted_config(spa_t *spa, spa_import_type_t type,
	boolean_t *update_config_cache)
	{
	int error;

	/*
	* Parse the config for pool, open and validate vdevs,
	* select an uberblock, and use that uberblock to open
	* the MOS.
	*/
	error = spa_ld_mos_init(spa, type);
	if (error != 0)
	return (error);

	/*
	* Retrieve the trusted config stored in the MOS and use it to create
	* a new, exact version of the vdev tree, then reopen all vdevs.
	*/
	error = spa_ld_trusted_config(spa, type, B_FALSE);
	if (error == EAGAIN) {
	if (update_config_cache != NULL)
	*update_config_cache = B_TRUE;

	/*
	* Redo the loading process with the trusted config if it is
	* too different from the untrusted config.
	*/
	spa_ld_prepare_for_reload(spa);
	spa_load_note(spa, "RELOADING");
	error = spa_ld_mos_init(spa, type);
	if (error != 0)
	return (error);

	error = spa_ld_trusted_config(spa, type, B_TRUE);
	if (error != 0)
	return (error);

	} else if (error != 0) {
	return (error);
	}

	return (0);
	}

	/*
	* Load an existing storage pool, using the config provided. This config
	* describes which vdevs are part of the pool and is later validated against
	* partial configs present in each vdev's label and an entire copy of the
	* config stored in the MOS.
	*/
	static int
	spa_load_impl(spa_t spa, spa_import_type_t type, char *ereport)
	{
	int error = 0;
	boolean_t missing_feat_write = B_FALSE;
	boolean_t checkpoint_rewind =
	(spa->spa_import_flags & ZFS_IMPORT_CHECKPOINT);
	boolean_t update_config_cache = B_FALSE;

	ASSERT(MUTEX_HELD(&spa_namespace_lock));
	ASSERT(spa->spa_config_source != SPA_CONFIG_SRC_NONE);

	spa_load_note(spa, "LOADING");

	error = spa_ld_mos_with_trusted_config(spa, type, &update_config_cache);
	if (error != 0)
	return (error);

	/*
	* If we are rewinding to the checkpoint then we need to repeat
	* everything we've done so far in this function but this time
	* selecting the checkpointed uberblock and using that to open
	* the MOS.
	*/
	if (checkpoint_rewind) {
	/*
	* If we are rewinding to the checkpoint update config cache
	* anyway.
	*/
	update_config_cache = B_TRUE;

	/*
	* Extract the checkpointed uberblock from the current MOS
	* and use this as the pool's uberblock from now on. If the
	* pool is imported as writeable we also write the checkpoint
	* uberblock to the labels, making the rewind permanent.
	*/
	error = spa_ld_checkpoint_rewind(spa);
	if (error != 0)
	return (error);

	/*
	* Redo the loading process again with the
	* checkpointed uberblock.
	*/
	spa_ld_prepare_for_reload(spa);
	spa_load_note(spa, "LOADING checkpointed uberblock");
	error = spa_ld_mos_with_trusted_config(spa, type, NULL);
	if (error != 0)
	return (error);
	}

	/*
	* Retrieve the checkpoint txg if the pool has a checkpoint.
	*/
	error = spa_ld_read_checkpoint_txg(spa);
	if (error != 0)
	return (error);

	/*
	* Retrieve the mapping of indirect vdevs. Those vdevs were removed
	* from the pool and their contents were re-mapped to other vdevs. Note
	* that everything that we read before this step must have been
	* rewritten on concrete vdevs after the last device removal was
	* initiated. Otherwise we could be reading from indirect vdevs before
	* we have loaded their mappings.
	*/
	error = spa_ld_open_indirect_vdev_metadata(spa);
	if (error != 0)
	return (error);

	/*
	* Retrieve the full list of active features from the MOS and check if
	* they are all supported.
	*/
	error = spa_ld_check_features(spa, &missing_feat_write);
	if (error != 0)
	return (error);

	/*
	* Load several special directories from the MOS needed by the dsl_pool
	* layer.
	*/
	error = spa_ld_load_special_directories(spa);
	if (error != 0)
	return (error);

	/*
	* Retrieve pool properties from the MOS.
	*/
	error = spa_ld_get_props(spa);
	if (error != 0)
	return (error);

	/*
	* Retrieve the list of auxiliary devices - cache devices and spares -
	* and open them.
	*/
	error = spa_ld_open_aux_vdevs(spa, type);
	if (error != 0)
	return (error);

	/*
	* Load the metadata for all vdevs. Also check if unopenable devices
	* should be autoreplaced.
	*/
	error = spa_ld_load_vdev_metadata(spa);
	if (error != 0)
	return (error);

	error = spa_ld_load_dedup_tables(spa);
	if (error != 0)
	return (error);

	/*
	* Verify the logs now to make sure we don't have any unexpected errors
	* when we claim log blocks later.
	*/
	error = spa_ld_verify_logs(spa, type, ereport);
	if (error != 0)
	return (error);

	if (missing_feat_write) {
	ASSERT(spa->spa_load_state == SPA_LOAD_TRYIMPORT);

	/*
	* At this point, we know that we can open the pool in
	* read-only mode but not read-write mode. We now have enough
	* information and can return to userland.
	*/
	return (spa_vdev_err(spa->spa_root_vdev, VDEV_AUX_UNSUP_FEAT,
	ENOTSUP));
	}

	/*
	* Traverse the last txgs to make sure the pool was left off in a safe
	* state. When performing an extreme rewind, we verify the whole pool,
	* which can take a very long time.
	*/
	error = spa_ld_verify_pool_data(spa);
	if (error != 0)
	return (error);

	/*
	* Calculate the deflated space for the pool. This must be done before
	* we write anything to the pool because we'd need to update the space
	* accounting using the deflated sizes.
	*/
	spa_update_dspace(spa);

	/*
	* We have now retrieved all the information we needed to open the
	* pool. If we are importing the pool in read-write mode, a few
	* additional steps must be performed to finish the import.
	*/
	if (spa_writeable(spa) && (spa->spa_load_state == SPA_LOAD_RECOVER \|\|
	spa->spa_load_max_txg == UINT64_MAX)) {
	uint64_t config_cache_txg = spa->spa_config_txg;

	ASSERT(spa->spa_load_state != SPA_LOAD_TRYIMPORT);

	/*
	* In case of a checkpoint rewind, log the original txg
	* of the checkpointed uberblock.
	*/
	if (checkpoint_rewind) {
	spa_history_log_internal(spa, "checkpoint rewind",
	NULL, "rewound state to txg=%llu",
	(u_longlong_t)spa->spa_uberblock.ub_checkpoint_txg);
	}

	/*
	* Traverse the ZIL and claim all blocks.
	*/
	spa_ld_claim_log_blocks(spa);

	/*
	* Kick-off the syncing thread.
	*/
	spa->spa_sync_on = B_TRUE;
	txg_sync_start(spa->spa_dsl_pool);
	mmp_thread_start(spa);

	/*
	* Wait for all claims to sync. We sync up to the highest
	* claimed log block birth time so that claimed log blocks
	* don't appear to be from the future. spa_claim_max_txg
	* will have been set for us by ZIL traversal operations
	* performed above.
	*/
	txg_wait_synced(spa->spa_dsl_pool, spa->spa_claim_max_txg);

	/*
	* Check if we need to request an update of the config. On the
	* next sync, we would update the config stored in vdev labels
	* and the cachefile (by default /etc/zfs/zpool.cache).
	*/
	spa_ld_check_for_config_update(spa, config_cache_txg,
	update_config_cache);

	/*
	* Check if a rebuild was in progress and if so resume it.
	* Then check all DTLs to see if anything needs resilvering.
	* The resilver will be deferred if a rebuild was started.
	*/
	if (vdev_rebuild_active(spa->spa_root_vdev)) {
	vdev_rebuild_restart(spa);
	} else if (!dsl_scan_resilvering(spa->spa_dsl_pool) &&
	vdev_resilver_needed(spa->spa_root_vdev, NULL, NULL)) {
	spa_async_request(spa, SPA_ASYNC_RESILVER);
	}

	/*
	* Log the fact that we booted up (so that we can detect if
	* we rebooted in the middle of an operation).
	*/
	spa_history_log_version(spa, "open", NULL);

	spa_restart_removal(spa);
	spa_spawn_aux_threads(spa);

	/*
	* Delete any inconsistent datasets.
	*
	* Note:
	* Since we may be issuing deletes for clones here,
	* we make sure to do so after we've spawned all the
	* auxiliary threads above (from which the livelist
	* deletion zthr is part of).
	*/
	(void) dmu_objset_find(spa_name(spa),
	dsl_destroy_inconsistent, NULL, DS_FIND_CHILDREN);

	/*
	* Clean up any stale temporary dataset userrefs.
	*/
	dsl_pool_clean_tmp_userrefs(spa->spa_dsl_pool);

	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
	vdev_initialize_restart(spa->spa_root_vdev);
	vdev_trim_restart(spa->spa_root_vdev);
	vdev_autotrim_restart(spa);
	spa_config_exit(spa, SCL_CONFIG, FTAG);
	}

	spa_import_progress_remove(spa_guid(spa));
	spa_async_request(spa, SPA_ASYNC_L2CACHE_REBUILD);

	spa_load_note(spa, "LOADED");

	return (0);
	}

	static int
	spa_load_retry(spa_t *spa, spa_load_state_t state)
	{
	spa_mode_t mode = spa->spa_mode;

	spa_unload(spa);
	spa_deactivate(spa);

	spa->spa_load_max_txg = spa->spa_uberblock.ub_txg - 1;

	spa_activate(spa, mode);
	spa_async_suspend(spa);

	spa_load_note(spa, "spa_load_retry: rewind, max txg: %llu",
	(u_longlong_t)spa->spa_load_max_txg);

	return (spa_load(spa, state, SPA_IMPORT_EXISTING));
	}

	/*
	* If spa_load() fails this function will try loading prior txg's. If
	* 'state' is SPA_LOAD_RECOVER and one of these loads succeeds the pool
	* will be rewound to that txg. If 'state' is not SPA_LOAD_RECOVER this
	* function will not rewind the pool and will return the same error as
	* spa_load().
	*/
	static int
	spa_load_best(spa_t *spa, spa_load_state_t state, uint64_t max_request,
	int rewind_flags)
	{
	nvlist_t *loadinfo = NULL;
	nvlist_t *config = NULL;
	int load_error, rewind_error;
	uint64_t safe_rewind_txg;
	uint64_t min_txg;

	if (spa->spa_load_txg && state == SPA_LOAD_RECOVER) {
	spa->spa_load_max_txg = spa->spa_load_txg;
	spa_set_log_state(spa, SPA_LOG_CLEAR);
	} else {
	spa->spa_load_max_txg = max_request;
	if (max_request != UINT64_MAX)
	spa->spa_extreme_rewind = B_TRUE;
	}

	load_error = rewind_error = spa_load(spa, state, SPA_IMPORT_EXISTING);
	if (load_error == 0)
	return (0);
	if (load_error == ZFS_ERR_NO_CHECKPOINT) {
	/*
	* When attempting checkpoint-rewind on a pool with no
	* checkpoint, we should not attempt to load uberblocks
	* from previous txgs when spa_load fails.
	*/
	ASSERT(spa->spa_import_flags & ZFS_IMPORT_CHECKPOINT);
	spa_import_progress_remove(spa_guid(spa));
	return (load_error);
	}

	if (spa->spa_root_vdev != NULL)
	config = spa_config_generate(spa, NULL, -1ULL, B_TRUE);

	spa->spa_last_ubsync_txg = spa->spa_uberblock.ub_txg;
	spa->spa_last_ubsync_txg_ts = spa->spa_uberblock.ub_timestamp;

	if (rewind_flags & ZPOOL_NEVER_REWIND) {
	nvlist_free(config);
	spa_import_progress_remove(spa_guid(spa));
	return (load_error);
	}

	if (state == SPA_LOAD_RECOVER) {
	/* Price of rolling back is discarding txgs, including log */
	spa_set_log_state(spa, SPA_LOG_CLEAR);
	} else {
	/*
	* If we aren't rolling back save the load info from our first
	* import attempt so that we can restore it after attempting
	* to rewind.
	*/
	loadinfo = spa->spa_load_info;
	spa->spa_load_info = fnvlist_alloc();
	}

	spa->spa_load_max_txg = spa->spa_last_ubsync_txg;
	safe_rewind_txg = spa->spa_last_ubsync_txg - TXG_DEFER_SIZE;
	min_txg = (rewind_flags & ZPOOL_EXTREME_REWIND) ?
	TXG_INITIAL : safe_rewind_txg;

	/*
	* Continue as long as we're finding errors, we're still within
	* the acceptable rewind range, and we're still finding uberblocks
	*/
	while (rewind_error && spa->spa_uberblock.ub_txg >= min_txg &&
	spa->spa_uberblock.ub_txg <= spa->spa_load_max_txg) {
	if (spa->spa_load_max_txg < safe_rewind_txg)
	spa->spa_extreme_rewind = B_TRUE;
	rewind_error = spa_load_retry(spa, state);
	}

	spa->spa_extreme_rewind = B_FALSE;
	spa->spa_load_max_txg = UINT64_MAX;

	if (config && (rewind_error \|\| state != SPA_LOAD_RECOVER))
	spa_config_set(spa, config);
	else
	nvlist_free(config);

	if (state == SPA_LOAD_RECOVER) {
	ASSERT3P(loadinfo, ==, NULL);
	spa_import_progress_remove(spa_guid(spa));
	return (rewind_error);
	} else {
	/* Store the rewind info as part of the initial load info */
	fnvlist_add_nvlist(loadinfo, ZPOOL_CONFIG_REWIND_INFO,
	spa->spa_load_info);

	/* Restore the initial load info */
	fnvlist_free(spa->spa_load_info);
	spa->spa_load_info = loadinfo;

	spa_import_progress_remove(spa_guid(spa));
	return (load_error);
	}
	}

	/*
	* Pool Open/Import
	*
	* The import case is identical to an open except that the configuration is sent
	* down from userland, instead of grabbed from the configuration cache. For the
	* case of an open, the pool configuration will exist in the
	* POOL_STATE_UNINITIALIZED state.
	*
	* The stats information (gen/count/ustats) is used to gather vdev statistics at
	* the same time open the pool, without having to keep around the spa_t in some
	* ambiguous state.
	*/
	static int
	spa_open_common(const char pool, spa_t spapp, void tag, nvlist_t *nvpolicy,
	nvlist_t **config)
	{
	spa_t *spa;
	spa_load_state_t state = SPA_LOAD_OPEN;
	int error;
	int locked = B_FALSE;
	int firstopen = B_FALSE;

	*spapp = NULL;

	/*
	* As disgusting as this is, we need to support recursive calls to this
	* function because dsl_dir_open() is called during spa_load(), and ends
	* up calling spa_open() again. The real fix is to figure out how to
	* avoid dsl_dir_open() calling this in the first place.
	*/
	if (MUTEX_NOT_HELD(&spa_namespace_lock)) {
	mutex_enter(&spa_namespace_lock);
	locked = B_TRUE;
	}

	if ((spa = spa_lookup(pool)) == NULL) {
	if (locked)
	mutex_exit(&spa_namespace_lock);
	return (SET_ERROR(ENOENT));
	}

	if (spa->spa_state == POOL_STATE_UNINITIALIZED) {
	zpool_load_policy_t policy;

	firstopen = B_TRUE;

	zpool_get_load_policy(nvpolicy ? nvpolicy : spa->spa_config,
	&policy);
	if (policy.zlp_rewind & ZPOOL_DO_REWIND)
	state = SPA_LOAD_RECOVER;

	spa_activate(spa, spa_mode_global);

	if (state != SPA_LOAD_RECOVER)
	spa->spa_last_ubsync_txg = spa->spa_load_txg = 0;
	spa->spa_config_source = SPA_CONFIG_SRC_CACHEFILE;

	zfs_dbgmsg("spa_open_common: opening %s", pool);
	error = spa_load_best(spa, state, policy.zlp_txg,
	policy.zlp_rewind);

	if (error == EBADF) {
	/*
	* If vdev_validate() returns failure (indicated by
	* EBADF), it indicates that one of the vdevs indicates
	* that the pool has been exported or destroyed. If
	* this is the case, the config cache is out of sync and
	* we should remove the pool from the namespace.
	*/
	spa_unload(spa);
	spa_deactivate(spa);
	spa_write_cachefile(spa, B_TRUE, B_TRUE);
	spa_remove(spa);
	if (locked)
	mutex_exit(&spa_namespace_lock);
	return (SET_ERROR(ENOENT));
	}

	if (error) {
	/*
	* We can't open the pool, but we still have useful
	* information: the state of each vdev after the
	* attempted vdev_open(). Return this to the user.
	*/
	if (config != NULL && spa->spa_config) {
	VERIFY(nvlist_dup(spa->spa_config, config,
	KM_SLEEP) == 0);
	VERIFY(nvlist_add_nvlist(*config,
	ZPOOL_CONFIG_LOAD_INFO,
	spa->spa_load_info) == 0);
	}
	spa_unload(spa);
	spa_deactivate(spa);
	spa->spa_last_open_failed = error;
	if (locked)
	mutex_exit(&spa_namespace_lock);
	*spapp = NULL;
	return (error);
	}
	}

	spa_open_ref(spa, tag);

	if (config != NULL)
	*config = spa_config_generate(spa, NULL, -1ULL, B_TRUE);

	/*
	* If we've recovered the pool, pass back any information we
	* gathered while doing the load.
	*/
	if (state == SPA_LOAD_RECOVER) {
	VERIFY(nvlist_add_nvlist(*config, ZPOOL_CONFIG_LOAD_INFO,
	spa->spa_load_info) == 0);
	}

	if (locked) {
	spa->spa_last_open_failed = 0;
	spa->spa_last_ubsync_txg = 0;
	spa->spa_load_txg = 0;
	mutex_exit(&spa_namespace_lock);
	}

	if (firstopen)
	zvol_create_minors_recursive(spa_name(spa));

	*spapp = spa;

	return (0);
	}

	int
	spa_open_rewind(const char name, spa_t spapp, void tag, nvlist_t *policy,
	nvlist_t **config)
	{
	return (spa_open_common(name, spapp, tag, policy, config));
	}

	int
	spa_open(const char name, spa_t spapp, void tag)
	{
	return (spa_open_common(name, spapp, tag, NULL, NULL));
	}

	/*
	* Lookup the given spa_t, incrementing the inject count in the process,
	* preventing it from being exported or destroyed.
	*/
	spa_t *
	spa_inject_addref(char *name)
	{
	spa_t *spa;

	mutex_enter(&spa_namespace_lock);
	if ((spa = spa_lookup(name)) == NULL) {
	mutex_exit(&spa_namespace_lock);
	return (NULL);
	}
	spa->spa_inject_ref++;
	mutex_exit(&spa_namespace_lock);

	return (spa);
	}

	void
	spa_inject_delref(spa_t *spa)
	{
	mutex_enter(&spa_namespace_lock);
	spa->spa_inject_ref--;
	mutex_exit(&spa_namespace_lock);
	}

	/*
	* Add spares device information to the nvlist.
	*/
	static void
	spa_add_spares(spa_t spa, nvlist_t config)
	{
	nvlist_t **spares;
	uint_t i, nspares;
	nvlist_t *nvroot;
	uint64_t guid;
	vdev_stat_t *vs;
	uint_t vsc;
	uint64_t pool;

	ASSERT(spa_config_held(spa, SCL_CONFIG, RW_READER));

	if (spa->spa_spares.sav_count == 0)
	return;

	VERIFY(nvlist_lookup_nvlist(config,
	ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0);
	VERIFY(nvlist_lookup_nvlist_array(spa->spa_spares.sav_config,
	ZPOOL_CONFIG_SPARES, &spares, &nspares) == 0);
	if (nspares != 0) {
	VERIFY(nvlist_add_nvlist_array(nvroot,
	ZPOOL_CONFIG_SPARES, spares, nspares) == 0);
	VERIFY(nvlist_lookup_nvlist_array(nvroot,
	ZPOOL_CONFIG_SPARES, &spares, &nspares) == 0);

	/*
	* Go through and find any spares which have since been
	* repurposed as an active spare. If this is the case, update
	* their status appropriately.
	*/
	for (i = 0; i < nspares; i++) {
	VERIFY(nvlist_lookup_uint64(spares[i],
	ZPOOL_CONFIG_GUID, &guid) == 0);
	if (spa_spare_exists(guid, &pool, NULL) &&
	pool != 0ULL) {
	VERIFY(nvlist_lookup_uint64_array(
	spares[i], ZPOOL_CONFIG_VDEV_STATS,
	(uint64_t **)&vs, &vsc) == 0);
	vs->vs_state = VDEV_STATE_CANT_OPEN;
	vs->vs_aux = VDEV_AUX_SPARED;
	}
	}
	}
	}

	/*
	* Add l2cache device information to the nvlist, including vdev stats.
	*/
	static void
	spa_add_l2cache(spa_t spa, nvlist_t config)
	{
	nvlist_t **l2cache;
	uint_t i, j, nl2cache;
	nvlist_t *nvroot;
	uint64_t guid;
	vdev_t *vd;
	vdev_stat_t *vs;
	uint_t vsc;

	ASSERT(spa_config_held(spa, SCL_CONFIG, RW_READER));

	if (spa->spa_l2cache.sav_count == 0)
	return;

	VERIFY(nvlist_lookup_nvlist(config,
	ZPOOL_CONFIG_VDEV_TREE, &nvroot) == 0);
	VERIFY(nvlist_lookup_nvlist_array(spa->spa_l2cache.sav_config,
	ZPOOL_CONFIG_L2CACHE, &l2cache, &nl2cache) == 0);
	if (nl2cache != 0) {
	VERIFY(nvlist_add_nvlist_array(nvroot,
	ZPOOL_CONFIG_L2CACHE, l2cache, nl2cache) == 0);
	VERIFY(nvlist_lookup_nvlist_array(nvroot,
	ZPOOL_CONFIG_L2CACHE, &l2cache, &nl2cache) == 0);

	/*
	* Update level 2 cache device stats.
	*/

	for (i = 0; i < nl2cache; i++) {
	VERIFY(nvlist_lookup_uint64(l2cache[i],
	ZPOOL_CONFIG_GUID, &guid) == 0);

	vd = NULL;
	for (j = 0; j < spa->spa_l2cache.sav_count; j++) {
	if (guid ==
	spa->spa_l2cache.sav_vdevs[j]->vdev_guid) {
	vd = spa->spa_l2cache.sav_vdevs[j];
	break;
	}
	}
	ASSERT(vd != NULL);

	VERIFY(nvlist_lookup_uint64_array(l2cache[i],
	ZPOOL_CONFIG_VDEV_STATS, (uint64_t **)&vs, &vsc)
	== 0);
	vdev_get_stats(vd, vs);
	vdev_config_generate_stats(vd, l2cache[i]);

	}
	}
	}

	static void
	spa_feature_stats_from_disk(spa_t spa, nvlist_t features)
	{
	zap_cursor_t zc;
	zap_attribute_t za;

	if (spa->spa_feat_for_read_obj != 0) {
	for (zap_cursor_init(&zc, spa->spa_meta_objset,
	spa->spa_feat_for_read_obj);
	zap_cursor_retrieve(&zc, &za) == 0;
	zap_cursor_advance(&zc)) {
	ASSERT(za.za_integer_length == sizeof (uint64_t) &&
	za.za_num_integers == 1);
	VERIFY0(nvlist_add_uint64(features, za.za_name,
	za.za_first_integer));
	}
	zap_cursor_fini(&zc);
	}

	if (spa->spa_feat_for_write_obj != 0) {
	for (zap_cursor_init(&zc, spa->spa_meta_objset,
	spa->spa_feat_for_write_obj);
	zap_cursor_retrieve(&zc, &za) == 0;
	zap_cursor_advance(&zc)) {
	ASSERT(za.za_integer_length == sizeof (uint64_t) &&
	za.za_num_integers == 1);
	VERIFY0(nvlist_add_uint64(features, za.za_name,
	za.za_first_integer));
	}
	zap_cursor_fini(&zc);
	}
	}

	static void
	spa_feature_stats_from_cache(spa_t spa, nvlist_t features)
	{
	int i;

	for (i = 0; i < SPA_FEATURES; i++) {
	zfeature_info_t feature = spa_feature_table[i];
	uint64_t refcount;

	if (feature_get_refcount(spa, &feature, &refcount) != 0)
	continue;

	VERIFY0(nvlist_add_uint64(features, feature.fi_guid, refcount));
	}
	}

	/*
	* Store a list of pool features and their reference counts in the
	* config.
	*
	* The first time this is called on a spa, allocate a new nvlist, fetch
	* the pool features and reference counts from disk, then save the list
	* in the spa. In subsequent calls on the same spa use the saved nvlist
	* and refresh its values from the cached reference counts. This
	* ensures we don't block here on I/O on a suspended pool so 'zpool
	* clear' can resume the pool.
	*/
	static void
	spa_add_feature_stats(spa_t spa, nvlist_t config)
	{
	nvlist_t *features;

	ASSERT(spa_config_held(spa, SCL_CONFIG, RW_READER));

	mutex_enter(&spa->spa_feat_stats_lock);
	features = spa->spa_feat_stats;

	if (features != NULL) {
	spa_feature_stats_from_cache(spa, features);
	} else {
	VERIFY0(nvlist_alloc(&features, NV_UNIQUE_NAME, KM_SLEEP));
	spa->spa_feat_stats = features;
	spa_feature_stats_from_disk(spa, features);
	}

	VERIFY0(nvlist_add_nvlist(config, ZPOOL_CONFIG_FEATURE_STATS,
	features));

	mutex_exit(&spa->spa_feat_stats_lock);
	}

	int
	spa_get_stats(const char name, nvlist_t *config,
	char *altroot, size_t buflen)
	{
	int error;
	spa_t *spa;

	*config = NULL;
	error = spa_open_common(name, &spa, FTAG, NULL, config);

	if (spa != NULL) {
	/*
	* This still leaves a window of inconsistency where the spares
	* or l2cache devices could change and the config would be
	* self-inconsistent.
	*/
	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);

	if (*config != NULL) {
	uint64_t loadtimes[2];

	loadtimes[0] = spa->spa_loaded_ts.tv_sec;
	loadtimes[1] = spa->spa_loaded_ts.tv_nsec;
	VERIFY(nvlist_add_uint64_array(*config,
	ZPOOL_CONFIG_LOADED_TIME, loadtimes, 2) == 0);

	VERIFY(nvlist_add_uint64(*config,
	ZPOOL_CONFIG_ERRCOUNT,
	spa_get_errlog_size(spa)) == 0);

	if (spa_suspended(spa)) {
	VERIFY(nvlist_add_uint64(*config,
	ZPOOL_CONFIG_SUSPENDED,
	spa->spa_failmode) == 0);
	VERIFY(nvlist_add_uint64(*config,
	ZPOOL_CONFIG_SUSPENDED_REASON,
	spa->spa_suspended) == 0);
	}

	spa_add_spares(spa, *config);
	spa_add_l2cache(spa, *config);
	spa_add_feature_stats(spa, *config);
	}
	}

	/*
	* We want to get the alternate root even for faulted pools, so we cheat
	* and call spa_lookup() directly.
	*/
	if (altroot) {
	if (spa == NULL) {
	mutex_enter(&spa_namespace_lock);
	spa = spa_lookup(name);
	if (spa)
	spa_altroot(spa, altroot, buflen);
	else
	altroot[0] = '\0';
	spa = NULL;
	mutex_exit(&spa_namespace_lock);
	} else {
	spa_altroot(spa, altroot, buflen);
	}
	}

	if (spa != NULL) {
	spa_config_exit(spa, SCL_CONFIG, FTAG);
	spa_close(spa, FTAG);
	}

	return (error);
	}

	/*
	* Validate that the auxiliary device array is well formed. We must have an
	* array of nvlists, each which describes a valid leaf vdev. If this is an
	* import (mode is VDEV_ALLOC_SPARE), then we allow corrupted spares to be
	* specified, as long as they are well-formed.
	*/
	static int
	spa_validate_aux_devs(spa_t spa, nvlist_t nvroot, uint64_t crtxg, int mode,
	spa_aux_vdev_t sav, const char config, uint64_t version,
	vdev_labeltype_t label)
	{
	nvlist_t **dev;
	uint_t i, ndev;
	vdev_t *vd;
	int error;

	ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);

	/*
	* It's acceptable to have no devs specified.
	*/
	if (nvlist_lookup_nvlist_array(nvroot, config, &dev, &ndev) != 0)
	return (0);

	if (ndev == 0)
	return (SET_ERROR(EINVAL));

	/*
	* Make sure the pool is formatted with a version that supports this
	* device type.
	*/
	if (spa_version(spa) < version)
	return (SET_ERROR(ENOTSUP));

	/*
	* Set the pending device list so we correctly handle device in-use
	* checking.
	*/
	sav->sav_pending = dev;
	sav->sav_npending = ndev;

	for (i = 0; i < ndev; i++) {
	if ((error = spa_config_parse(spa, &vd, dev[i], NULL, 0,
	mode)) != 0)
	goto out;

	if (!vd->vdev_ops->vdev_op_leaf) {
	vdev_free(vd);
	error = SET_ERROR(EINVAL);
	goto out;
	}

	vd->vdev_top = vd;

	if ((error = vdev_open(vd)) == 0 &&
	(error = vdev_label_init(vd, crtxg, label)) == 0) {
	VERIFY(nvlist_add_uint64(dev[i], ZPOOL_CONFIG_GUID,
	vd->vdev_guid) == 0);
	}

	vdev_free(vd);

	if (error &&
	(mode != VDEV_ALLOC_SPARE && mode != VDEV_ALLOC_L2CACHE))
	goto out;
	else
	error = 0;
	}

	out:
	sav->sav_pending = NULL;
	sav->sav_npending = 0;
	return (error);
	}

	static int
	spa_validate_aux(spa_t spa, nvlist_t nvroot, uint64_t crtxg, int mode)
	{
	int error;

	ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);

	if ((error = spa_validate_aux_devs(spa, nvroot, crtxg, mode,
	&spa->spa_spares, ZPOOL_CONFIG_SPARES, SPA_VERSION_SPARES,
	VDEV_LABEL_SPARE)) != 0) {
	return (error);
	}

	return (spa_validate_aux_devs(spa, nvroot, crtxg, mode,
	&spa->spa_l2cache, ZPOOL_CONFIG_L2CACHE, SPA_VERSION_L2CACHE,
	VDEV_LABEL_L2CACHE));
	}

	static void
	spa_set_aux_vdevs(spa_aux_vdev_t sav, nvlist_t *devs, int ndevs,
	const char *config)
	{
	int i;

	if (sav->sav_config != NULL) {
	nvlist_t **olddevs;
	uint_t oldndevs;
	nvlist_t **newdevs;

	/*
	* Generate new dev list by concatenating with the
	* current dev list.
	*/
	VERIFY(nvlist_lookup_nvlist_array(sav->sav_config, config,
	&olddevs, &oldndevs) == 0);

	newdevs = kmem_alloc(sizeof (void )
	(ndevs + oldndevs), KM_SLEEP);
	for (i = 0; i < oldndevs; i++)
	VERIFY(nvlist_dup(olddevs[i], &newdevs[i],
	KM_SLEEP) == 0);
	for (i = 0; i < ndevs; i++)
	VERIFY(nvlist_dup(devs[i], &newdevs[i + oldndevs],
	KM_SLEEP) == 0);

	VERIFY(nvlist_remove(sav->sav_config, config,
	DATA_TYPE_NVLIST_ARRAY) == 0);

	VERIFY(nvlist_add_nvlist_array(sav->sav_config,
	config, newdevs, ndevs + oldndevs) == 0);
	for (i = 0; i < oldndevs + ndevs; i++)
	nvlist_free(newdevs[i]);
	kmem_free(newdevs, (oldndevs + ndevs) * sizeof (void *));
	} else {
	/*
	* Generate a new dev list.
	*/
	VERIFY(nvlist_alloc(&sav->sav_config, NV_UNIQUE_NAME,
	KM_SLEEP) == 0);
	VERIFY(nvlist_add_nvlist_array(sav->sav_config, config,
	devs, ndevs) == 0);
	}
	}

	/*
	* Stop and drop level 2 ARC devices
	*/
	void
	spa_l2cache_drop(spa_t *spa)
	{
	vdev_t *vd;
	int i;
	spa_aux_vdev_t *sav = &spa->spa_l2cache;

	for (i = 0; i < sav->sav_count; i++) {
	uint64_t pool;

	vd = sav->sav_vdevs[i];
	ASSERT(vd != NULL);

	if (spa_l2cache_exists(vd->vdev_guid, &pool) &&
	pool != 0ULL && l2arc_vdev_present(vd))
	l2arc_remove_vdev(vd);
	}
	}

	/*
	* Verify encryption parameters for spa creation. If we are encrypting, we must
	* have the encryption feature flag enabled.
	*/
	static int
	spa_create_check_encryption_params(dsl_crypto_params_t *dcp,
	boolean_t has_encryption)
	{
	if (dcp->cp_crypt != ZIO_CRYPT_OFF &&
	dcp->cp_crypt != ZIO_CRYPT_INHERIT &&
	!has_encryption)
	return (SET_ERROR(ENOTSUP));

	return (dmu_objset_create_crypt_check(NULL, dcp, NULL));
	}

	/*
	* Pool Creation
	*/
	int
	spa_create(const char pool, nvlist_t nvroot, nvlist_t *props,
	nvlist_t zplprops, dsl_crypto_params_t dcp)
	{
	spa_t *spa;
	char *altroot = NULL;
	vdev_t *rvd;
	dsl_pool_t *dp;
	dmu_tx_t *tx;
	int error = 0;
	uint64_t txg = TXG_INITIAL;
	nvlist_t spares, l2cache;
	uint_t nspares, nl2cache;
	uint64_t version, obj, ndraid = 0;
	boolean_t has_features;
	boolean_t has_encryption;
	boolean_t has_allocclass;
	spa_feature_t feat;
	char *feat_name;
	char *poolname;
	nvlist_t *nvl;

	if (props == NULL \|\|
	nvlist_lookup_string(props, "tname", &poolname) != 0)
	poolname = (char *)pool;

	/*
	* If this pool already exists, return failure.
	*/
	mutex_enter(&spa_namespace_lock);
	if (spa_lookup(poolname) != NULL) {
	mutex_exit(&spa_namespace_lock);
	return (SET_ERROR(EEXIST));
	}

	/*
	* Allocate a new spa_t structure.
	*/
	nvl = fnvlist_alloc();
	fnvlist_add_string(nvl, ZPOOL_CONFIG_POOL_NAME, pool);
	(void) nvlist_lookup_string(props,
	zpool_prop_to_name(ZPOOL_PROP_ALTROOT), &altroot);
	spa = spa_add(poolname, nvl, altroot);
	fnvlist_free(nvl);
	spa_activate(spa, spa_mode_global);

	if (props && (error = spa_prop_validate(spa, props))) {
	spa_deactivate(spa);
	spa_remove(spa);
	mutex_exit(&spa_namespace_lock);
	return (error);
	}

	/*
	* Temporary pool names should never be written to disk.
	*/
	if (poolname != pool)
	spa->spa_import_flags \|= ZFS_IMPORT_TEMP_NAME;

	has_features = B_FALSE;
	has_encryption = B_FALSE;
	has_allocclass = B_FALSE;
	for (nvpair_t *elem = nvlist_next_nvpair(props, NULL);
	elem != NULL; elem = nvlist_next_nvpair(props, elem)) {
	if (zpool_prop_feature(nvpair_name(elem))) {
	has_features = B_TRUE;

	feat_name = strchr(nvpair_name(elem), '@') + 1;
	VERIFY0(zfeature_lookup_name(feat_name, &feat));
	if (feat == SPA_FEATURE_ENCRYPTION)
	has_encryption = B_TRUE;
	if (feat == SPA_FEATURE_ALLOCATION_CLASSES)
	has_allocclass = B_TRUE;
	}
	}

	/* verify encryption params, if they were provided */
	if (dcp != NULL) {
	error = spa_create_check_encryption_params(dcp, has_encryption);
	if (error != 0) {
	spa_deactivate(spa);
	spa_remove(spa);
	mutex_exit(&spa_namespace_lock);
	return (error);
	}
	}
	if (!has_allocclass && zfs_special_devs(nvroot, NULL)) {
	spa_deactivate(spa);
	spa_remove(spa);
	mutex_exit(&spa_namespace_lock);
	return (ENOTSUP);
	}

	if (has_features \|\| nvlist_lookup_uint64(props,
	zpool_prop_to_name(ZPOOL_PROP_VERSION), &version) != 0) {
	version = SPA_VERSION;
	}
	ASSERT(SPA_VERSION_IS_SUPPORTED(version));

	spa->spa_first_txg = txg;
	spa->spa_uberblock.ub_txg = txg - 1;
	spa->spa_uberblock.ub_version = version;
	spa->spa_ubsync = spa->spa_uberblock;
	spa->spa_load_state = SPA_LOAD_CREATE;
	spa->spa_removing_phys.sr_state = DSS_NONE;
	spa->spa_removing_phys.sr_removing_vdev = -1;
	spa->spa_removing_phys.sr_prev_indirect_vdev = -1;
	spa->spa_indirect_vdevs_loaded = B_TRUE;

	/*
	* Create "The Godfather" zio to hold all async IOs
	*/
	spa->spa_async_zio_root = kmem_alloc(max_ncpus * sizeof (void *),
	KM_SLEEP);
	for (int i = 0; i < max_ncpus; i++) {
	spa->spa_async_zio_root[i] = zio_root(spa, NULL, NULL,
	ZIO_FLAG_CANFAIL \| ZIO_FLAG_SPECULATIVE \|
	ZIO_FLAG_GODFATHER);
	}

	/*
	* Create the root vdev.
	*/
	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);

	error = spa_config_parse(spa, &rvd, nvroot, NULL, 0, VDEV_ALLOC_ADD);

	ASSERT(error != 0 \|\| rvd != NULL);
	ASSERT(error != 0 \|\| spa->spa_root_vdev == rvd);

	if (error == 0 && !zfs_allocatable_devs(nvroot))
	error = SET_ERROR(EINVAL);

	if (error == 0 &&
	(error = vdev_create(rvd, txg, B_FALSE)) == 0 &&
	(error = vdev_draid_spare_create(nvroot, rvd, &ndraid, 0)) == 0 &&
	(error = spa_validate_aux(spa, nvroot, txg, VDEV_ALLOC_ADD)) == 0) {
	/*
	* instantiate the metaslab groups (this will dirty the vdevs)
	* we can no longer error exit past this point
	*/
	for (int c = 0; error == 0 && c < rvd->vdev_children; c++) {
	vdev_t *vd = rvd->vdev_child[c];

	vdev_metaslab_set_size(vd);
	vdev_expand(vd, txg);
	}
	}

	spa_config_exit(spa, SCL_ALL, FTAG);

	if (error != 0) {
	spa_unload(spa);
	spa_deactivate(spa);
	spa_remove(spa);
	mutex_exit(&spa_namespace_lock);
	return (error);
	}

	/*
	* Get the list of spares, if specified.
	*/
	if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES,
	&spares, &nspares) == 0) {
	VERIFY(nvlist_alloc(&spa->spa_spares.sav_config, NV_UNIQUE_NAME,
	KM_SLEEP) == 0);
	VERIFY(nvlist_add_nvlist_array(spa->spa_spares.sav_config,
	ZPOOL_CONFIG_SPARES, spares, nspares) == 0);
	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
	spa_load_spares(spa);
	spa_config_exit(spa, SCL_ALL, FTAG);
	spa->spa_spares.sav_sync = B_TRUE;
	}

	/*
	* Get the list of level 2 cache devices, if specified.
	*/
	if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE,
	&l2cache, &nl2cache) == 0) {
	VERIFY(nvlist_alloc(&spa->spa_l2cache.sav_config,
	NV_UNIQUE_NAME, KM_SLEEP) == 0);
	VERIFY(nvlist_add_nvlist_array(spa->spa_l2cache.sav_config,
	ZPOOL_CONFIG_L2CACHE, l2cache, nl2cache) == 0);
	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
	spa_load_l2cache(spa);
	spa_config_exit(spa, SCL_ALL, FTAG);
	spa->spa_l2cache.sav_sync = B_TRUE;
	}

	spa->spa_is_initializing = B_TRUE;
	spa->spa_dsl_pool = dp = dsl_pool_create(spa, zplprops, dcp, txg);
	spa->spa_is_initializing = B_FALSE;

	/*
	* Create DDTs (dedup tables).
	*/
	ddt_create(spa);

	spa_update_dspace(spa);

	tx = dmu_tx_create_assigned(dp, txg);

	/*
	* Create the pool's history object.
	*/
	if (version >= SPA_VERSION_ZPOOL_HISTORY && !spa->spa_history)
	spa_history_create_obj(spa, tx);

	spa_event_notify(spa, NULL, NULL, ESC_ZFS_POOL_CREATE);
	spa_history_log_version(spa, "create", tx);

	/*
	* Create the pool config object.
	*/
	spa->spa_config_object = dmu_object_alloc(spa->spa_meta_objset,
	DMU_OT_PACKED_NVLIST, SPA_CONFIG_BLOCKSIZE,
	DMU_OT_PACKED_NVLIST_SIZE, sizeof (uint64_t), tx);

	if (zap_add(spa->spa_meta_objset,
	DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_CONFIG,
	sizeof (uint64_t), 1, &spa->spa_config_object, tx) != 0) {
	cmn_err(CE_PANIC, "failed to add pool config");
	}

	if (zap_add(spa->spa_meta_objset,
	DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_CREATION_VERSION,
	sizeof (uint64_t), 1, &version, tx) != 0) {
	cmn_err(CE_PANIC, "failed to add pool version");
	}

	/* Newly created pools with the right version are always deflated. */
	if (version >= SPA_VERSION_RAIDZ_DEFLATE) {
	spa->spa_deflate = TRUE;
	if (zap_add(spa->spa_meta_objset,
	DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_DEFLATE,
	sizeof (uint64_t), 1, &spa->spa_deflate, tx) != 0) {
	cmn_err(CE_PANIC, "failed to add deflate");
	}
	}

	/*
	* Create the deferred-free bpobj. Turn off compression
	* because sync-to-convergence takes longer if the blocksize
	* keeps changing.
	*/
	obj = bpobj_alloc(spa->spa_meta_objset, 1 << 14, tx);
	dmu_object_set_compress(spa->spa_meta_objset, obj,
	ZIO_COMPRESS_OFF, tx);
	if (zap_add(spa->spa_meta_objset,
	DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_SYNC_BPOBJ,
	sizeof (uint64_t), 1, &obj, tx) != 0) {
	cmn_err(CE_PANIC, "failed to add bpobj");
	}
	VERIFY3U(0, ==, bpobj_open(&spa->spa_deferred_bpobj,
	spa->spa_meta_objset, obj));

	/*
	* Generate some random noise for salted checksums to operate on.
	*/
	(void) random_get_pseudo_bytes(spa->spa_cksum_salt.zcs_bytes,
	sizeof (spa->spa_cksum_salt.zcs_bytes));

	/*
	* Set pool properties.
	*/
	spa->spa_bootfs = zpool_prop_default_numeric(ZPOOL_PROP_BOOTFS);
	spa->spa_delegation = zpool_prop_default_numeric(ZPOOL_PROP_DELEGATION);
	spa->spa_failmode = zpool_prop_default_numeric(ZPOOL_PROP_FAILUREMODE);
	spa->spa_autoexpand = zpool_prop_default_numeric(ZPOOL_PROP_AUTOEXPAND);
	spa->spa_multihost = zpool_prop_default_numeric(ZPOOL_PROP_MULTIHOST);
	spa->spa_autotrim = zpool_prop_default_numeric(ZPOOL_PROP_AUTOTRIM);

	if (props != NULL) {
	spa_configfile_set(spa, props, B_FALSE);
	spa_sync_props(props, tx);
	}

	for (int i = 0; i < ndraid; i++)
	spa_feature_incr(spa, SPA_FEATURE_DRAID, tx);

	dmu_tx_commit(tx);

	spa->spa_sync_on = B_TRUE;
	txg_sync_start(dp);
	mmp_thread_start(spa);
	txg_wait_synced(dp, txg);

	spa_spawn_aux_threads(spa);

	spa_write_cachefile(spa, B_FALSE, B_TRUE);

	/*
	* Don't count references from objsets that are already closed
	* and are making their way through the eviction process.
	*/
	spa_evicting_os_wait(spa);
	spa->spa_minref = zfs_refcount_count(&spa->spa_refcount);
	spa->spa_load_state = SPA_LOAD_NONE;

	mutex_exit(&spa_namespace_lock);

	return (0);
	}

	/*
	* Import a non-root pool into the system.
	*/
	int
	spa_import(char pool, nvlist_t config, nvlist_t *props, uint64_t flags)
	{
	spa_t *spa;
	char *altroot = NULL;
	spa_load_state_t state = SPA_LOAD_IMPORT;
	zpool_load_policy_t policy;
	spa_mode_t mode = spa_mode_global;
	uint64_t readonly = B_FALSE;
	int error;
	nvlist_t *nvroot;
	nvlist_t spares, l2cache;
	uint_t nspares, nl2cache;

	/*
	* If a pool with this name exists, return failure.
	*/
	mutex_enter(&spa_namespace_lock);
	if (spa_lookup(pool) != NULL) {
	mutex_exit(&spa_namespace_lock);
	return (SET_ERROR(EEXIST));
	}

	/*
	* Create and initialize the spa structure.
	*/
	(void) nvlist_lookup_string(props,
	zpool_prop_to_name(ZPOOL_PROP_ALTROOT), &altroot);
	(void) nvlist_lookup_uint64(props,
	zpool_prop_to_name(ZPOOL_PROP_READONLY), &readonly);
	if (readonly)
	mode = SPA_MODE_READ;
	spa = spa_add(pool, config, altroot);
	spa->spa_import_flags = flags;

	/*
	* Verbatim import - Take a pool and insert it into the namespace
	* as if it had been loaded at boot.
	*/
	if (spa->spa_import_flags & ZFS_IMPORT_VERBATIM) {
	if (props != NULL)
	spa_configfile_set(spa, props, B_FALSE);

	spa_write_cachefile(spa, B_FALSE, B_TRUE);
	spa_event_notify(spa, NULL, NULL, ESC_ZFS_POOL_IMPORT);
	zfs_dbgmsg("spa_import: verbatim import of %s", pool);
	mutex_exit(&spa_namespace_lock);
	return (0);
	}

	spa_activate(spa, mode);

	/*
	* Don't start async tasks until we know everything is healthy.
	*/
	spa_async_suspend(spa);

	zpool_get_load_policy(config, &policy);
	if (policy.zlp_rewind & ZPOOL_DO_REWIND)
	state = SPA_LOAD_RECOVER;

	spa->spa_config_source = SPA_CONFIG_SRC_TRYIMPORT;

	if (state != SPA_LOAD_RECOVER) {
	spa->spa_last_ubsync_txg = spa->spa_load_txg = 0;
	zfs_dbgmsg("spa_import: importing %s", pool);
	} else {
	zfs_dbgmsg("spa_import: importing %s, max_txg=%lld "
	"(RECOVERY MODE)", pool, (longlong_t)policy.zlp_txg);
	}
	error = spa_load_best(spa, state, policy.zlp_txg, policy.zlp_rewind);

	/*
	* Propagate anything learned while loading the pool and pass it
	* back to caller (i.e. rewind info, missing devices, etc).
	*/
	VERIFY(nvlist_add_nvlist(config, ZPOOL_CONFIG_LOAD_INFO,
	spa->spa_load_info) == 0);

	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
	/*
	* Toss any existing sparelist, as it doesn't have any validity
	* anymore, and conflicts with spa_has_spare().
	*/
	if (spa->spa_spares.sav_config) {
	nvlist_free(spa->spa_spares.sav_config);
	spa->spa_spares.sav_config = NULL;
	spa_load_spares(spa);
	}
	if (spa->spa_l2cache.sav_config) {
	nvlist_free(spa->spa_l2cache.sav_config);
	spa->spa_l2cache.sav_config = NULL;
	spa_load_l2cache(spa);
	}

	VERIFY(nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE,
	&nvroot) == 0);
	spa_config_exit(spa, SCL_ALL, FTAG);

	if (props != NULL)
	spa_configfile_set(spa, props, B_FALSE);

	if (error != 0 \|\| (props && spa_writeable(spa) &&
	(error = spa_prop_set(spa, props)))) {
	spa_unload(spa);
	spa_deactivate(spa);
	spa_remove(spa);
	mutex_exit(&spa_namespace_lock);
	return (error);
	}

	spa_async_resume(spa);

	/*
	* Override any spares and level 2 cache devices as specified by
	* the user, as these may have correct device names/devids, etc.
	*/
	if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES,
	&spares, &nspares) == 0) {
	if (spa->spa_spares.sav_config)
	VERIFY(nvlist_remove(spa->spa_spares.sav_config,
	ZPOOL_CONFIG_SPARES, DATA_TYPE_NVLIST_ARRAY) == 0);
	else
	VERIFY(nvlist_alloc(&spa->spa_spares.sav_config,
	NV_UNIQUE_NAME, KM_SLEEP) == 0);
	VERIFY(nvlist_add_nvlist_array(spa->spa_spares.sav_config,
	ZPOOL_CONFIG_SPARES, spares, nspares) == 0);
	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
	spa_load_spares(spa);
	spa_config_exit(spa, SCL_ALL, FTAG);
	spa->spa_spares.sav_sync = B_TRUE;
	}
	if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE,
	&l2cache, &nl2cache) == 0) {
	if (spa->spa_l2cache.sav_config)
	VERIFY(nvlist_remove(spa->spa_l2cache.sav_config,
	ZPOOL_CONFIG_L2CACHE, DATA_TYPE_NVLIST_ARRAY) == 0);
	else
	VERIFY(nvlist_alloc(&spa->spa_l2cache.sav_config,
	NV_UNIQUE_NAME, KM_SLEEP) == 0);
	VERIFY(nvlist_add_nvlist_array(spa->spa_l2cache.sav_config,
	ZPOOL_CONFIG_L2CACHE, l2cache, nl2cache) == 0);
	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
	spa_load_l2cache(spa);
	spa_config_exit(spa, SCL_ALL, FTAG);
	spa->spa_l2cache.sav_sync = B_TRUE;
	}

	/*
	* Check for any removed devices.
	*/
	if (spa->spa_autoreplace) {
	spa_aux_check_removed(&spa->spa_spares);
	spa_aux_check_removed(&spa->spa_l2cache);
	}

	if (spa_writeable(spa)) {
	/*
	* Update the config cache to include the newly-imported pool.
	*/
	spa_config_update(spa, SPA_CONFIG_UPDATE_POOL);
	}

	/*
	* It's possible that the pool was expanded while it was exported.
	* We kick off an async task to handle this for us.
	*/
	spa_async_request(spa, SPA_ASYNC_AUTOEXPAND);

	spa_history_log_version(spa, "import", NULL);

	spa_event_notify(spa, NULL, NULL, ESC_ZFS_POOL_IMPORT);

	mutex_exit(&spa_namespace_lock);

	zvol_create_minors_recursive(pool);

	return (0);
	}

	nvlist_t *
	spa_tryimport(nvlist_t *tryconfig)
	{
	nvlist_t *config = NULL;
	char poolname, cachefile;
	spa_t *spa;
	uint64_t state;
	int error;
	zpool_load_policy_t policy;

	if (nvlist_lookup_string(tryconfig, ZPOOL_CONFIG_POOL_NAME, &poolname))
	return (NULL);

	if (nvlist_lookup_uint64(tryconfig, ZPOOL_CONFIG_POOL_STATE, &state))
	return (NULL);

	/*
	* Create and initialize the spa structure.
	*/
	mutex_enter(&spa_namespace_lock);
	spa = spa_add(TRYIMPORT_NAME, tryconfig, NULL);
	spa_activate(spa, SPA_MODE_READ);

	/*
	* Rewind pool if a max txg was provided.
	*/
	zpool_get_load_policy(spa->spa_config, &policy);
	if (policy.zlp_txg != UINT64_MAX) {
	spa->spa_load_max_txg = policy.zlp_txg;
	spa->spa_extreme_rewind = B_TRUE;
	zfs_dbgmsg("spa_tryimport: importing %s, max_txg=%lld",
	poolname, (longlong_t)policy.zlp_txg);
	} else {
	zfs_dbgmsg("spa_tryimport: importing %s", poolname);
	}

	if (nvlist_lookup_string(tryconfig, ZPOOL_CONFIG_CACHEFILE, &cachefile)
	== 0) {
	zfs_dbgmsg("spa_tryimport: using cachefile '%s'", cachefile);
	spa->spa_config_source = SPA_CONFIG_SRC_CACHEFILE;
	} else {
	spa->spa_config_source = SPA_CONFIG_SRC_SCAN;
	}

	error = spa_load(spa, SPA_LOAD_TRYIMPORT, SPA_IMPORT_EXISTING);

	/*
	* If 'tryconfig' was at least parsable, return the current config.
	*/
	if (spa->spa_root_vdev != NULL) {
	config = spa_config_generate(spa, NULL, -1ULL, B_TRUE);
	VERIFY(nvlist_add_string(config, ZPOOL_CONFIG_POOL_NAME,
	poolname) == 0);
	VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_POOL_STATE,
	state) == 0);
	VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_TIMESTAMP,
	spa->spa_uberblock.ub_timestamp) == 0);
	VERIFY(nvlist_add_nvlist(config, ZPOOL_CONFIG_LOAD_INFO,
	spa->spa_load_info) == 0);
	VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_ERRATA,
	spa->spa_errata) == 0);

	/*
	* If the bootfs property exists on this pool then we
	* copy it out so that external consumers can tell which
	* pools are bootable.
	*/
	if ((!error \|\| error == EEXIST) && spa->spa_bootfs) {
	char *tmpname = kmem_alloc(MAXPATHLEN, KM_SLEEP);

	/*
	* We have to play games with the name since the
	* pool was opened as TRYIMPORT_NAME.
	*/
	if (dsl_dsobj_to_dsname(spa_name(spa),
	spa->spa_bootfs, tmpname) == 0) {
	char *cp;
	char *dsname;

	dsname = kmem_alloc(MAXPATHLEN, KM_SLEEP);

	cp = strchr(tmpname, '/');
	if (cp == NULL) {
	(void) strlcpy(dsname, tmpname,
	MAXPATHLEN);
	} else {
	(void) snprintf(dsname, MAXPATHLEN,
	"%s/%s", poolname, ++cp);
	}
	VERIFY(nvlist_add_string(config,
	ZPOOL_CONFIG_BOOTFS, dsname) == 0);
	kmem_free(dsname, MAXPATHLEN);
	}
	kmem_free(tmpname, MAXPATHLEN);
	}

	/*
	* Add the list of hot spares and level 2 cache devices.
	*/
	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
	spa_add_spares(spa, config);
	spa_add_l2cache(spa, config);
	spa_config_exit(spa, SCL_CONFIG, FTAG);
	}

	spa_unload(spa);
	spa_deactivate(spa);
	spa_remove(spa);
	mutex_exit(&spa_namespace_lock);

	return (config);
	}

	/*
	* Pool export/destroy
	*
	* The act of destroying or exporting a pool is very simple. We make sure there
	* is no more pending I/O and any references to the pool are gone. Then, we
	* update the pool state and sync all the labels to disk, removing the
	* configuration from the cache afterwards. If the 'hardforce' flag is set, then
	* we don't sync the labels or remove the configuration cache.
	*/
	static int
	spa_export_common(const char pool, int new_state, nvlist_t *oldconfig,
	boolean_t force, boolean_t hardforce)
	{
	int error;
	spa_t *spa;

	if (oldconfig)
	*oldconfig = NULL;

	if (!(spa_mode_global & SPA_MODE_WRITE))
	return (SET_ERROR(EROFS));

	mutex_enter(&spa_namespace_lock);
	if ((spa = spa_lookup(pool)) == NULL) {
	mutex_exit(&spa_namespace_lock);
	return (SET_ERROR(ENOENT));
	}

	if (spa->spa_is_exporting) {
	/* the pool is being exported by another thread */
	mutex_exit(&spa_namespace_lock);
	return (SET_ERROR(ZFS_ERR_EXPORT_IN_PROGRESS));
	}
	spa->spa_is_exporting = B_TRUE;

	/*
	* Put a hold on the pool, drop the namespace lock, stop async tasks,
	* reacquire the namespace lock, and see if we can export.
	*/
	spa_open_ref(spa, FTAG);
	mutex_exit(&spa_namespace_lock);
	spa_async_suspend(spa);
	if (spa->spa_zvol_taskq) {
	zvol_remove_minors(spa, spa_name(spa), B_TRUE);
	taskq_wait(spa->spa_zvol_taskq);
	}
	mutex_enter(&spa_namespace_lock);
	spa_close(spa, FTAG);

	if (spa->spa_state == POOL_STATE_UNINITIALIZED)
	goto export_spa;
	/*
	* The pool will be in core if it's openable, in which case we can
	* modify its state. Objsets may be open only because they're dirty,
	* so we have to force it to sync before checking spa_refcnt.
	*/
	if (spa->spa_sync_on) {
	txg_wait_synced(spa->spa_dsl_pool, 0);
	spa_evicting_os_wait(spa);
	}

	/*
	* A pool cannot be exported or destroyed if there are active
	* references. If we are resetting a pool, allow references by
	* fault injection handlers.
	*/
	if (!spa_refcount_zero(spa) \|\| (spa->spa_inject_ref != 0)) {
	error = SET_ERROR(EBUSY);
	goto fail;
	}

	if (spa->spa_sync_on) {
	/*
	* A pool cannot be exported if it has an active shared spare.
	* This is to prevent other pools stealing the active spare
	* from an exported pool. At user's own will, such pool can
	* be forcedly exported.
	*/
	if (!force && new_state == POOL_STATE_EXPORTED &&
	spa_has_active_shared_spare(spa)) {
	error = SET_ERROR(EXDEV);
	goto fail;
	}

	/*
	* We're about to export or destroy this pool. Make sure
	* we stop all initialization and trim activity here before
	* we set the spa_final_txg. This will ensure that all
	* dirty data resulting from the initialization is
	* committed to disk before we unload the pool.
	*/
	if (spa->spa_root_vdev != NULL) {
	vdev_t *rvd = spa->spa_root_vdev;
	vdev_initialize_stop_all(rvd, VDEV_INITIALIZE_ACTIVE);
	vdev_trim_stop_all(rvd, VDEV_TRIM_ACTIVE);
	vdev_autotrim_stop_all(spa);
	vdev_rebuild_stop_all(spa);
	}

	/*
	* We want this to be reflected on every label,
	* so mark them all dirty. spa_unload() will do the
	* final sync that pushes these changes out.
	*/
	if (new_state != POOL_STATE_UNINITIALIZED && !hardforce) {
	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
	spa->spa_state = new_state;
	spa->spa_final_txg = spa_last_synced_txg(spa) +
	TXG_DEFER_SIZE + 1;
	vdev_config_dirty(spa->spa_root_vdev);
	spa_config_exit(spa, SCL_ALL, FTAG);
	}
	}

	export_spa:
	if (new_state == POOL_STATE_DESTROYED)
	spa_event_notify(spa, NULL, NULL, ESC_ZFS_POOL_DESTROY);
	else if (new_state == POOL_STATE_EXPORTED)
	spa_event_notify(spa, NULL, NULL, ESC_ZFS_POOL_EXPORT);

	if (spa->spa_state != POOL_STATE_UNINITIALIZED) {
	spa_unload(spa);
	spa_deactivate(spa);
	}

	if (oldconfig && spa->spa_config)
	VERIFY(nvlist_dup(spa->spa_config, oldconfig, 0) == 0);

	if (new_state != POOL_STATE_UNINITIALIZED) {
	if (!hardforce)
	spa_write_cachefile(spa, B_TRUE, B_TRUE);
	spa_remove(spa);
	} else {
	/*
	* If spa_remove() is not called for this spa_t and
	* there is any possibility that it can be reused,
	* we make sure to reset the exporting flag.
	*/
	spa->spa_is_exporting = B_FALSE;
	}

	mutex_exit(&spa_namespace_lock);
	return (0);

	fail:
	spa->spa_is_exporting = B_FALSE;
	spa_async_resume(spa);
	mutex_exit(&spa_namespace_lock);
	return (error);
	}

	/*
	* Destroy a storage pool.
	*/
	int
	spa_destroy(const char *pool)
	{
	return (spa_export_common(pool, POOL_STATE_DESTROYED, NULL,
	B_FALSE, B_FALSE));
	}

	/*
	* Export a storage pool.
	*/
	int
	spa_export(const char pool, nvlist_t *oldconfig, boolean_t force,
	boolean_t hardforce)
	{
	return (spa_export_common(pool, POOL_STATE_EXPORTED, oldconfig,
	force, hardforce));
	}

	/*
	* Similar to spa_export(), this unloads the spa_t without actually removing it
	* from the namespace in any way.
	*/
	int
	spa_reset(const char *pool)
	{
	return (spa_export_common(pool, POOL_STATE_UNINITIALIZED, NULL,
	B_FALSE, B_FALSE));
	}

	/*
	* ==========================================================================
	* Device manipulation
	* ==========================================================================
	*/

	/*
	* This is called as a synctask to increment the draid feature flag
	*/
	static void
	spa_draid_feature_incr(void arg, dmu_tx_t tx)
	{
	spa_t *spa = dmu_tx_pool(tx)->dp_spa;
	int draid = (int)(uintptr_t)arg;

	for (int c = 0; c < draid; c++)
	spa_feature_incr(spa, SPA_FEATURE_DRAID, tx);
	}

	/*
	* Add a device to a storage pool.
	*/
	int
	spa_vdev_add(spa_t spa, nvlist_t nvroot)
	{
	uint64_t txg, ndraid = 0;
	int error;
	vdev_t *rvd = spa->spa_root_vdev;
	vdev_t vd, tvd;
	nvlist_t spares, l2cache;
	uint_t nspares, nl2cache;

	ASSERT(spa_writeable(spa));

	txg = spa_vdev_enter(spa);

	if ((error = spa_config_parse(spa, &vd, nvroot, NULL, 0,
	VDEV_ALLOC_ADD)) != 0)
	return (spa_vdev_exit(spa, NULL, txg, error));

	spa->spa_pending_vdev = vd; /* spa_vdev_exit() will clear this */

	if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES, &spares,
	&nspares) != 0)
	nspares = 0;

	if (nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_L2CACHE, &l2cache,
	&nl2cache) != 0)
	nl2cache = 0;

	if (vd->vdev_children == 0 && nspares == 0 && nl2cache == 0)
	return (spa_vdev_exit(spa, vd, txg, EINVAL));

	if (vd->vdev_children != 0 &&
	(error = vdev_create(vd, txg, B_FALSE)) != 0) {
	return (spa_vdev_exit(spa, vd, txg, error));
	}

	/*
	* The virtual dRAID spares must be added after vdev tree is created
	- * and the vdev guids are generated. The guid of their assoicated
	+ * and the vdev guids are generated. The guid of their associated
	* dRAID is stored in the config and used when opening the spare.
	*/
	if ((error = vdev_draid_spare_create(nvroot, vd, &ndraid,
	rvd->vdev_children)) == 0) {
	if (ndraid > 0 && nvlist_lookup_nvlist_array(nvroot,
	ZPOOL_CONFIG_SPARES, &spares, &nspares) != 0)
	nspares = 0;
	} else {
	return (spa_vdev_exit(spa, vd, txg, error));
	}

	/*
	* We must validate the spares and l2cache devices after checking the
	* children. Otherwise, vdev_inuse() will blindly overwrite the spare.
	*/
	if ((error = spa_validate_aux(spa, nvroot, txg, VDEV_ALLOC_ADD)) != 0)
	return (spa_vdev_exit(spa, vd, txg, error));

	/*
	* If we are in the middle of a device removal, we can only add
	* devices which match the existing devices in the pool.
	* If we are in the middle of a removal, or have some indirect
	* vdevs, we can not add raidz or dRAID top levels.
	*/
	if (spa->spa_vdev_removal != NULL \|\|
	spa->spa_removing_phys.sr_prev_indirect_vdev != -1) {
	for (int c = 0; c < vd->vdev_children; c++) {
	tvd = vd->vdev_child[c];
	if (spa->spa_vdev_removal != NULL &&
	tvd->vdev_ashift != spa->spa_max_ashift) {
	return (spa_vdev_exit(spa, vd, txg, EINVAL));
	}
	/* Fail if top level vdev is raidz or a dRAID */
	if (vdev_get_nparity(tvd) != 0)
	return (spa_vdev_exit(spa, vd, txg, EINVAL));

	/*
	* Need the top level mirror to be
	* a mirror of leaf vdevs only
	*/
	if (tvd->vdev_ops == &vdev_mirror_ops) {
	for (uint64_t cid = 0;
	cid < tvd->vdev_children; cid++) {
	vdev_t *cvd = tvd->vdev_child[cid];
	if (!cvd->vdev_ops->vdev_op_leaf) {
	return (spa_vdev_exit(spa, vd,
	txg, EINVAL));
	}
	}
	}
	}
	}

	for (int c = 0; c < vd->vdev_children; c++) {
	tvd = vd->vdev_child[c];
	vdev_remove_child(vd, tvd);
	tvd->vdev_id = rvd->vdev_children;
	vdev_add_child(rvd, tvd);
	vdev_config_dirty(tvd);
	}

	if (nspares != 0) {
	spa_set_aux_vdevs(&spa->spa_spares, spares, nspares,
	ZPOOL_CONFIG_SPARES);
	spa_load_spares(spa);
	spa->spa_spares.sav_sync = B_TRUE;
	}

	if (nl2cache != 0) {
	spa_set_aux_vdevs(&spa->spa_l2cache, l2cache, nl2cache,
	ZPOOL_CONFIG_L2CACHE);
	spa_load_l2cache(spa);
	spa->spa_l2cache.sav_sync = B_TRUE;
	}

	/*
	* We can't increment a feature while holding spa_vdev so we
	* have to do it in a synctask.
	*/
	if (ndraid != 0) {
	dmu_tx_t *tx;

	tx = dmu_tx_create_assigned(spa->spa_dsl_pool, txg);
	dsl_sync_task_nowait(spa->spa_dsl_pool, spa_draid_feature_incr,
	(void *)(uintptr_t)ndraid, tx);
	dmu_tx_commit(tx);
	}

	/*
	* We have to be careful when adding new vdevs to an existing pool.
	* If other threads start allocating from these vdevs before we
	* sync the config cache, and we lose power, then upon reboot we may
	* fail to open the pool because there are DVAs that the config cache
	* can't translate. Therefore, we first add the vdevs without
	* initializing metaslabs; sync the config cache (via spa_vdev_exit());
	* and then let spa_config_update() initialize the new metaslabs.
	*
	* spa_load() checks for added-but-not-initialized vdevs, so that
	* if we lose power at any point in this sequence, the remaining
	* steps will be completed the next time we load the pool.
	*/
	(void) spa_vdev_exit(spa, vd, txg, 0);

	mutex_enter(&spa_namespace_lock);
	spa_config_update(spa, SPA_CONFIG_UPDATE_POOL);
	spa_event_notify(spa, NULL, NULL, ESC_ZFS_VDEV_ADD);
	mutex_exit(&spa_namespace_lock);

	return (0);
	}

	/*
	* Attach a device to a mirror. The arguments are the path to any device
	* in the mirror, and the nvroot for the new device. If the path specifies
	* a device that is not mirrored, we automatically insert the mirror vdev.
	*
	* If 'replacing' is specified, the new device is intended to replace the
	* existing device; in this case the two devices are made into their own
	* mirror using the 'replacing' vdev, which is functionally identical to
	* the mirror vdev (it actually reuses all the same ops) but has a few
	* extra rules: you can't attach to it after it's been created, and upon
	* completion of resilvering, the first disk (the one being replaced)
	* is automatically detached.
	*
	* If 'rebuild' is specified, then sequential reconstruction (a.ka. rebuild)
	* should be performed instead of traditional healing reconstruction. From
	* an administrators perspective these are both resilver operations.
	*/
	int
	spa_vdev_attach(spa_t spa, uint64_t guid, nvlist_t nvroot, int replacing,
	int rebuild)
	{
	uint64_t txg, dtl_max_txg;
	vdev_t *rvd = spa->spa_root_vdev;
	vdev_t oldvd, newvd, newrootvd, pvd, *tvd;
	vdev_ops_t *pvops;
	char oldvdpath, newvdpath;
	int newvd_isspare;
	int error;

	ASSERT(spa_writeable(spa));

	txg = spa_vdev_enter(spa);

	oldvd = spa_lookup_by_guid(spa, guid, B_FALSE);

	ASSERT(MUTEX_HELD(&spa_namespace_lock));
	if (spa_feature_is_active(spa, SPA_FEATURE_POOL_CHECKPOINT)) {
	error = (spa_has_checkpoint(spa)) ?
	ZFS_ERR_CHECKPOINT_EXISTS : ZFS_ERR_DISCARDING_CHECKPOINT;
	return (spa_vdev_exit(spa, NULL, txg, error));
	}

	if (rebuild) {
	if (!spa_feature_is_enabled(spa, SPA_FEATURE_DEVICE_REBUILD))
	return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));

	if (dsl_scan_resilvering(spa_get_dsl(spa)))
	return (spa_vdev_exit(spa, NULL, txg,
	ZFS_ERR_RESILVER_IN_PROGRESS));
	} else {
	if (vdev_rebuild_active(rvd))
	return (spa_vdev_exit(spa, NULL, txg,
	ZFS_ERR_REBUILD_IN_PROGRESS));
	}

	if (spa->spa_vdev_removal != NULL)
	return (spa_vdev_exit(spa, NULL, txg, EBUSY));

	if (oldvd == NULL)
	return (spa_vdev_exit(spa, NULL, txg, ENODEV));

	if (!oldvd->vdev_ops->vdev_op_leaf)
	return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));

	pvd = oldvd->vdev_parent;

	if ((error = spa_config_parse(spa, &newrootvd, nvroot, NULL, 0,
	VDEV_ALLOC_ATTACH)) != 0)
	return (spa_vdev_exit(spa, NULL, txg, EINVAL));

	if (newrootvd->vdev_children != 1)
	return (spa_vdev_exit(spa, newrootvd, txg, EINVAL));

	newvd = newrootvd->vdev_child[0];

	if (!newvd->vdev_ops->vdev_op_leaf)
	return (spa_vdev_exit(spa, newrootvd, txg, EINVAL));

	if ((error = vdev_create(newrootvd, txg, replacing)) != 0)
	return (spa_vdev_exit(spa, newrootvd, txg, error));

	/*
	* Spares can't replace logs
	*/
	if (oldvd->vdev_top->vdev_islog && newvd->vdev_isspare)
	return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));

	/*
	* A dRAID spare can only replace a child of its parent dRAID vdev.
	*/
	if (newvd->vdev_ops == &vdev_draid_spare_ops &&
	oldvd->vdev_top != vdev_draid_spare_get_parent(newvd)) {
	return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
	}

	if (rebuild) {
	/*
	* For rebuilds, the top vdev must support reconstruction
	* using only space maps. This means the only allowable
	* vdevs types are the root vdev, a mirror, or dRAID.
	*/
	tvd = pvd;
	if (pvd->vdev_top != NULL)
	tvd = pvd->vdev_top;

	if (tvd->vdev_ops != &vdev_mirror_ops &&
	tvd->vdev_ops != &vdev_root_ops &&
	tvd->vdev_ops != &vdev_draid_ops) {
	return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
	}
	}

	if (!replacing) {
	/*
	* For attach, the only allowable parent is a mirror or the root
	* vdev.
	*/
	if (pvd->vdev_ops != &vdev_mirror_ops &&
	pvd->vdev_ops != &vdev_root_ops)
	return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));

	pvops = &vdev_mirror_ops;
	} else {
	/*
	* Active hot spares can only be replaced by inactive hot
	* spares.
	*/
	if (pvd->vdev_ops == &vdev_spare_ops &&
	oldvd->vdev_isspare &&
	!spa_has_spare(spa, newvd->vdev_guid))
	return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));

	/*
	* If the source is a hot spare, and the parent isn't already a
	* spare, then we want to create a new hot spare. Otherwise, we
	* want to create a replacing vdev. The user is not allowed to
	* attach to a spared vdev child unless the 'isspare' state is
	* the same (spare replaces spare, non-spare replaces
	* non-spare).
	*/
	if (pvd->vdev_ops == &vdev_replacing_ops &&
	spa_version(spa) < SPA_VERSION_MULTI_REPLACE) {
	return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
	} else if (pvd->vdev_ops == &vdev_spare_ops &&
	newvd->vdev_isspare != oldvd->vdev_isspare) {
	return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));
	}

	if (newvd->vdev_isspare)
	pvops = &vdev_spare_ops;
	else
	pvops = &vdev_replacing_ops;
	}

	/*
	* Make sure the new device is big enough.
	*/
	if (newvd->vdev_asize < vdev_get_min_asize(oldvd))
	return (spa_vdev_exit(spa, newrootvd, txg, EOVERFLOW));

	/*
	* The new device cannot have a higher alignment requirement
	* than the top-level vdev.
	*/
	if (newvd->vdev_ashift > oldvd->vdev_top->vdev_ashift)
	return (spa_vdev_exit(spa, newrootvd, txg, ENOTSUP));

	/*
	* If this is an in-place replacement, update oldvd's path and devid
	* to make it distinguishable from newvd, and unopenable from now on.
	*/
	if (strcmp(oldvd->vdev_path, newvd->vdev_path) == 0) {
	spa_strfree(oldvd->vdev_path);
	oldvd->vdev_path = kmem_alloc(strlen(newvd->vdev_path) + 5,
	KM_SLEEP);
	(void) snprintf(oldvd->vdev_path, strlen(newvd->vdev_path) + 5,
	"%s/%s", newvd->vdev_path, "old");
	if (oldvd->vdev_devid != NULL) {
	spa_strfree(oldvd->vdev_devid);
	oldvd->vdev_devid = NULL;
	}
	}

	/*
	* If the parent is not a mirror, or if we're replacing, insert the new
	* mirror/replacing/spare vdev above oldvd.
	*/
	if (pvd->vdev_ops != pvops)
	pvd = vdev_add_parent(oldvd, pvops);

	ASSERT(pvd->vdev_top->vdev_parent == rvd);
	ASSERT(pvd->vdev_ops == pvops);
	ASSERT(oldvd->vdev_parent == pvd);

	/*
	* Extract the new device from its root and add it to pvd.
	*/
	vdev_remove_child(newrootvd, newvd);
	newvd->vdev_id = pvd->vdev_children;
	newvd->vdev_crtxg = oldvd->vdev_crtxg;
	vdev_add_child(pvd, newvd);

	/*
	* Reevaluate the parent vdev state.
	*/
	vdev_propagate_state(pvd);

	tvd = newvd->vdev_top;
	ASSERT(pvd->vdev_top == tvd);
	ASSERT(tvd->vdev_parent == rvd);

	vdev_config_dirty(tvd);

	/*
	* Set newvd's DTL to [TXG_INITIAL, dtl_max_txg) so that we account
	* for any dmu_sync-ed blocks. It will propagate upward when
	* spa_vdev_exit() calls vdev_dtl_reassess().
	*/
	dtl_max_txg = txg + TXG_CONCURRENT_STATES;

	vdev_dtl_dirty(newvd, DTL_MISSING,
	TXG_INITIAL, dtl_max_txg - TXG_INITIAL);

	if (newvd->vdev_isspare) {
	spa_spare_activate(newvd);
	spa_event_notify(spa, newvd, NULL, ESC_ZFS_VDEV_SPARE);
	}

	oldvdpath = spa_strdup(oldvd->vdev_path);
	newvdpath = spa_strdup(newvd->vdev_path);
	newvd_isspare = newvd->vdev_isspare;

	/*
	* Mark newvd's DTL dirty in this txg.
	*/
	vdev_dirty(tvd, VDD_DTL, newvd, txg);

	/*
	* Schedule the resilver or rebuild to restart in the future. We do
	* this to ensure that dmu_sync-ed blocks have been stitched into the
	* respective datasets.
	*/
	if (rebuild) {
	newvd->vdev_rebuild_txg = txg;

	vdev_rebuild(tvd);
	} else {
	newvd->vdev_resilver_txg = txg;

	if (dsl_scan_resilvering(spa_get_dsl(spa)) &&
	spa_feature_is_enabled(spa, SPA_FEATURE_RESILVER_DEFER)) {
	vdev_defer_resilver(newvd);
	} else {
	dsl_scan_restart_resilver(spa->spa_dsl_pool,
	dtl_max_txg);
	}
	}

	if (spa->spa_bootfs)
	spa_event_notify(spa, newvd, NULL, ESC_ZFS_BOOTFS_VDEV_ATTACH);

	spa_event_notify(spa, newvd, NULL, ESC_ZFS_VDEV_ATTACH);

	/*
	* Commit the config
	*/
	(void) spa_vdev_exit(spa, newrootvd, dtl_max_txg, 0);

	spa_history_log_internal(spa, "vdev attach", NULL,
	"%s vdev=%s %s vdev=%s",
	replacing && newvd_isspare ? "spare in" :
	replacing ? "replace" : "attach", newvdpath,
	replacing ? "for" : "to", oldvdpath);

	spa_strfree(oldvdpath);
	spa_strfree(newvdpath);

	return (0);
	}

	/*
	* Detach a device from a mirror or replacing vdev.
	*
	* If 'replace_done' is specified, only detach if the parent
	* is a replacing vdev.
	*/
	int
	spa_vdev_detach(spa_t *spa, uint64_t guid, uint64_t pguid, int replace_done)
	{
	uint64_t txg;
	int error;
	vdev_t *rvd __maybe_unused = spa->spa_root_vdev;
	vdev_t vd, pvd, cvd, tvd;
	boolean_t unspare = B_FALSE;
	uint64_t unspare_guid = 0;
	char *vdpath;

	ASSERT(spa_writeable(spa));

	txg = spa_vdev_detach_enter(spa, guid);

	vd = spa_lookup_by_guid(spa, guid, B_FALSE);

	/*
	* Besides being called directly from the userland through the
	* ioctl interface, spa_vdev_detach() can be potentially called
	* at the end of spa_vdev_resilver_done().
	*
	* In the regular case, when we have a checkpoint this shouldn't
	* happen as we never empty the DTLs of a vdev during the scrub
	* [see comment in dsl_scan_done()]. Thus spa_vdev_resilvering_done()
	* should never get here when we have a checkpoint.
	*
	* That said, even in a case when we checkpoint the pool exactly
	* as spa_vdev_resilver_done() calls this function everything
	* should be fine as the resilver will return right away.
	*/
	ASSERT(MUTEX_HELD(&spa_namespace_lock));
	if (spa_feature_is_active(spa, SPA_FEATURE_POOL_CHECKPOINT)) {
	error = (spa_has_checkpoint(spa)) ?
	ZFS_ERR_CHECKPOINT_EXISTS : ZFS_ERR_DISCARDING_CHECKPOINT;
	return (spa_vdev_exit(spa, NULL, txg, error));
	}

	if (vd == NULL)
	return (spa_vdev_exit(spa, NULL, txg, ENODEV));

	if (!vd->vdev_ops->vdev_op_leaf)
	return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));

	pvd = vd->vdev_parent;

	/*
	* If the parent/child relationship is not as expected, don't do it.
	* Consider M(A,R(B,C)) -- that is, a mirror of A with a replacing
	* vdev that's replacing B with C. The user's intent in replacing
	* is to go from M(A,B) to M(A,C). If the user decides to cancel
	* the replace by detaching C, the expected behavior is to end up
	* M(A,B). But suppose that right after deciding to detach C,
	* the replacement of B completes. We would have M(A,C), and then
	* ask to detach C, which would leave us with just A -- not what
	* the user wanted. To prevent this, we make sure that the
	* parent/child relationship hasn't changed -- in this example,
	* that C's parent is still the replacing vdev R.
	*/
	if (pvd->vdev_guid != pguid && pguid != 0)
	return (spa_vdev_exit(spa, NULL, txg, EBUSY));

	/*
	* Only 'replacing' or 'spare' vdevs can be replaced.
	*/
	if (replace_done && pvd->vdev_ops != &vdev_replacing_ops &&
	pvd->vdev_ops != &vdev_spare_ops)
	return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));

	ASSERT(pvd->vdev_ops != &vdev_spare_ops \|\|
	spa_version(spa) >= SPA_VERSION_SPARES);

	/*
	* Only mirror, replacing, and spare vdevs support detach.
	*/
	if (pvd->vdev_ops != &vdev_replacing_ops &&
	pvd->vdev_ops != &vdev_mirror_ops &&
	pvd->vdev_ops != &vdev_spare_ops)
	return (spa_vdev_exit(spa, NULL, txg, ENOTSUP));

	/*
	* If this device has the only valid copy of some data,
	* we cannot safely detach it.
	*/
	if (vdev_dtl_required(vd))
	return (spa_vdev_exit(spa, NULL, txg, EBUSY));

	ASSERT(pvd->vdev_children >= 2);

	/*
	* If we are detaching the second disk from a replacing vdev, then
	* check to see if we changed the original vdev's path to have "/old"
	* at the end in spa_vdev_attach(). If so, undo that change now.
	*/
	if (pvd->vdev_ops == &vdev_replacing_ops && vd->vdev_id > 0 &&
	vd->vdev_path != NULL) {
	size_t len = strlen(vd->vdev_path);

	for (int c = 0; c < pvd->vdev_children; c++) {
	cvd = pvd->vdev_child[c];

	if (cvd == vd \|\| cvd->vdev_path == NULL)
	continue;

	if (strncmp(cvd->vdev_path, vd->vdev_path, len) == 0 &&
	strcmp(cvd->vdev_path + len, "/old") == 0) {
	spa_strfree(cvd->vdev_path);
	cvd->vdev_path = spa_strdup(vd->vdev_path);
	break;
	}
	}
	}

	/*
	* If we are detaching the original disk from a normal spare, then it
	* implies that the spare should become a real disk, and be removed
	* from the active spare list for the pool. dRAID spares on the
	* other hand are coupled to the pool and thus should never be removed
	* from the spares list.
	*/
	if (pvd->vdev_ops == &vdev_spare_ops && vd->vdev_id == 0) {
	vdev_t *last_cvd = pvd->vdev_child[pvd->vdev_children - 1];

	if (last_cvd->vdev_isspare &&
	last_cvd->vdev_ops != &vdev_draid_spare_ops) {
	unspare = B_TRUE;
	}
	}

	/*
	* Erase the disk labels so the disk can be used for other things.
	* This must be done after all other error cases are handled,
	* but before we disembowel vd (so we can still do I/O to it).
	* But if we can't do it, don't treat the error as fatal --
	* it may be that the unwritability of the disk is the reason
	* it's being detached!
	*/
	error = vdev_label_init(vd, 0, VDEV_LABEL_REMOVE);

	/*
	* Remove vd from its parent and compact the parent's children.
	*/
	vdev_remove_child(pvd, vd);
	vdev_compact_children(pvd);

	/*
	* Remember one of the remaining children so we can get tvd below.
	*/
	cvd = pvd->vdev_child[pvd->vdev_children - 1];

	/*
	* If we need to remove the remaining child from the list of hot spares,
	* do it now, marking the vdev as no longer a spare in the process.
	* We must do this before vdev_remove_parent(), because that can
	* change the GUID if it creates a new toplevel GUID. For a similar
	* reason, we must remove the spare now, in the same txg as the detach;
	* otherwise someone could attach a new sibling, change the GUID, and
	* the subsequent attempt to spa_vdev_remove(unspare_guid) would fail.
	*/
	if (unspare) {
	ASSERT(cvd->vdev_isspare);
	spa_spare_remove(cvd);
	unspare_guid = cvd->vdev_guid;
	(void) spa_vdev_remove(spa, unspare_guid, B_TRUE);
	cvd->vdev_unspare = B_TRUE;
	}

	/*
	* If the parent mirror/replacing vdev only has one child,
	* the parent is no longer needed. Remove it from the tree.
	*/
	if (pvd->vdev_children == 1) {
	if (pvd->vdev_ops == &vdev_spare_ops)
	cvd->vdev_unspare = B_FALSE;
	vdev_remove_parent(cvd);
	}

	/*
	* We don't set tvd until now because the parent we just removed
	* may have been the previous top-level vdev.
	*/
	tvd = cvd->vdev_top;
	ASSERT(tvd->vdev_parent == rvd);

	/*
	* Reevaluate the parent vdev state.
	*/
	vdev_propagate_state(cvd);

	/*
	* If the 'autoexpand' property is set on the pool then automatically
	* try to expand the size of the pool. For example if the device we
	* just detached was smaller than the others, it may be possible to
	* add metaslabs (i.e. grow the pool). We need to reopen the vdev
	* first so that we can obtain the updated sizes of the leaf vdevs.
	*/
	if (spa->spa_autoexpand) {
	vdev_reopen(tvd);
	vdev_expand(tvd, txg);
	}

	vdev_config_dirty(tvd);

	/*
	* Mark vd's DTL as dirty in this txg. vdev_dtl_sync() will see that
	* vd->vdev_detached is set and free vd's DTL object in syncing context.
	* But first make sure we're not on any other txg's DTL list, to
	* prevent vd from being accessed after it's freed.
	*/
	vdpath = spa_strdup(vd->vdev_path ? vd->vdev_path : "none");
	for (int t = 0; t < TXG_SIZE; t++)
	(void) txg_list_remove_this(&tvd->vdev_dtl_list, vd, t);
	vd->vdev_detached = B_TRUE;
	vdev_dirty(tvd, VDD_DTL, vd, txg);

	spa_event_notify(spa, vd, NULL, ESC_ZFS_VDEV_REMOVE);
	spa_notify_waiters(spa);

	/* hang on to the spa before we release the lock */
	spa_open_ref(spa, FTAG);

	error = spa_vdev_exit(spa, vd, txg, 0);

	spa_history_log_internal(spa, "detach", NULL,
	"vdev=%s", vdpath);
	spa_strfree(vdpath);

	/*
	* If this was the removal of the original device in a hot spare vdev,
	* then we want to go through and remove the device from the hot spare
	* list of every other pool.
	*/
	if (unspare) {
	spa_t *altspa = NULL;

	mutex_enter(&spa_namespace_lock);
	while ((altspa = spa_next(altspa)) != NULL) {
	if (altspa->spa_state != POOL_STATE_ACTIVE \|\|
	altspa == spa)
	continue;

	spa_open_ref(altspa, FTAG);
	mutex_exit(&spa_namespace_lock);
	(void) spa_vdev_remove(altspa, unspare_guid, B_TRUE);
	mutex_enter(&spa_namespace_lock);
	spa_close(altspa, FTAG);
	}
	mutex_exit(&spa_namespace_lock);

	/* search the rest of the vdevs for spares to remove */
	spa_vdev_resilver_done(spa);
	}

	/* all done with the spa; OK to release */
	mutex_enter(&spa_namespace_lock);
	spa_close(spa, FTAG);
	mutex_exit(&spa_namespace_lock);

	return (error);
	}

	static int
	spa_vdev_initialize_impl(spa_t *spa, uint64_t guid, uint64_t cmd_type,
	list_t *vd_list)
	{
	ASSERT(MUTEX_HELD(&spa_namespace_lock));

	spa_config_enter(spa, SCL_CONFIG \| SCL_STATE, FTAG, RW_READER);

	/* Look up vdev and ensure it's a leaf. */
	vdev_t *vd = spa_lookup_by_guid(spa, guid, B_FALSE);
	if (vd == NULL \|\| vd->vdev_detached) {
	spa_config_exit(spa, SCL_CONFIG \| SCL_STATE, FTAG);
	return (SET_ERROR(ENODEV));
	} else if (!vd->vdev_ops->vdev_op_leaf \|\| !vdev_is_concrete(vd)) {
	spa_config_exit(spa, SCL_CONFIG \| SCL_STATE, FTAG);
	return (SET_ERROR(EINVAL));
	} else if (!vdev_writeable(vd)) {
	spa_config_exit(spa, SCL_CONFIG \| SCL_STATE, FTAG);
	return (SET_ERROR(EROFS));
	}
	mutex_enter(&vd->vdev_initialize_lock);
	spa_config_exit(spa, SCL_CONFIG \| SCL_STATE, FTAG);

	/*
	* When we activate an initialize action we check to see
	* if the vdev_initialize_thread is NULL. We do this instead
	* of using the vdev_initialize_state since there might be
	* a previous initialization process which has completed but
	* the thread is not exited.
	*/
	if (cmd_type == POOL_INITIALIZE_START &&
	(vd->vdev_initialize_thread != NULL \|\|
	vd->vdev_top->vdev_removing)) {
	mutex_exit(&vd->vdev_initialize_lock);
	return (SET_ERROR(EBUSY));
	} else if (cmd_type == POOL_INITIALIZE_CANCEL &&
	(vd->vdev_initialize_state != VDEV_INITIALIZE_ACTIVE &&
	vd->vdev_initialize_state != VDEV_INITIALIZE_SUSPENDED)) {
	mutex_exit(&vd->vdev_initialize_lock);
	return (SET_ERROR(ESRCH));
	} else if (cmd_type == POOL_INITIALIZE_SUSPEND &&
	vd->vdev_initialize_state != VDEV_INITIALIZE_ACTIVE) {
	mutex_exit(&vd->vdev_initialize_lock);
	return (SET_ERROR(ESRCH));
	}

	switch (cmd_type) {
	case POOL_INITIALIZE_START:
	vdev_initialize(vd);
	break;
	case POOL_INITIALIZE_CANCEL:
	vdev_initialize_stop(vd, VDEV_INITIALIZE_CANCELED, vd_list);
	break;
	case POOL_INITIALIZE_SUSPEND:
	vdev_initialize_stop(vd, VDEV_INITIALIZE_SUSPENDED, vd_list);
	break;
	default:
	panic("invalid cmd_type %llu", (unsigned long long)cmd_type);
	}
	mutex_exit(&vd->vdev_initialize_lock);

	return (0);
	}

	int
	spa_vdev_initialize(spa_t spa, nvlist_t nv, uint64_t cmd_type,
	nvlist_t *vdev_errlist)
	{
	int total_errors = 0;
	list_t vd_list;

	list_create(&vd_list, sizeof (vdev_t),
	offsetof(vdev_t, vdev_initialize_node));

	/*
	* We hold the namespace lock through the whole function
	* to prevent any changes to the pool while we're starting or
	* stopping initialization. The config and state locks are held so that
	* we can properly assess the vdev state before we commit to
	* the initializing operation.
	*/
	mutex_enter(&spa_namespace_lock);

	for (nvpair_t *pair = nvlist_next_nvpair(nv, NULL);
	pair != NULL; pair = nvlist_next_nvpair(nv, pair)) {
	uint64_t vdev_guid = fnvpair_value_uint64(pair);

	int error = spa_vdev_initialize_impl(spa, vdev_guid, cmd_type,
	&vd_list);
	if (error != 0) {
	char guid_as_str[MAXNAMELEN];

	(void) snprintf(guid_as_str, sizeof (guid_as_str),
	"%llu", (unsigned long long)vdev_guid);
	fnvlist_add_int64(vdev_errlist, guid_as_str, error);
	total_errors++;
	}
	}

	/* Wait for all initialize threads to stop. */
	vdev_initialize_stop_wait(spa, &vd_list);

	/* Sync out the initializing state */
	txg_wait_synced(spa->spa_dsl_pool, 0);
	mutex_exit(&spa_namespace_lock);

	list_destroy(&vd_list);

	return (total_errors);
	}

	static int
	spa_vdev_trim_impl(spa_t *spa, uint64_t guid, uint64_t cmd_type,
	uint64_t rate, boolean_t partial, boolean_t secure, list_t *vd_list)
	{
	ASSERT(MUTEX_HELD(&spa_namespace_lock));

	spa_config_enter(spa, SCL_CONFIG \| SCL_STATE, FTAG, RW_READER);

	/* Look up vdev and ensure it's a leaf. */
	vdev_t *vd = spa_lookup_by_guid(spa, guid, B_FALSE);
	if (vd == NULL \|\| vd->vdev_detached) {
	spa_config_exit(spa, SCL_CONFIG \| SCL_STATE, FTAG);
	return (SET_ERROR(ENODEV));
	} else if (!vd->vdev_ops->vdev_op_leaf \|\| !vdev_is_concrete(vd)) {
	spa_config_exit(spa, SCL_CONFIG \| SCL_STATE, FTAG);
	return (SET_ERROR(EINVAL));
	} else if (!vdev_writeable(vd)) {
	spa_config_exit(spa, SCL_CONFIG \| SCL_STATE, FTAG);
	return (SET_ERROR(EROFS));
	} else if (!vd->vdev_has_trim) {
	spa_config_exit(spa, SCL_CONFIG \| SCL_STATE, FTAG);
	return (SET_ERROR(EOPNOTSUPP));
	} else if (secure && !vd->vdev_has_securetrim) {
	spa_config_exit(spa, SCL_CONFIG \| SCL_STATE, FTAG);
	return (SET_ERROR(EOPNOTSUPP));
	}
	mutex_enter(&vd->vdev_trim_lock);
	spa_config_exit(spa, SCL_CONFIG \| SCL_STATE, FTAG);

	/*
	* When we activate a TRIM action we check to see if the
	* vdev_trim_thread is NULL. We do this instead of using the
	* vdev_trim_state since there might be a previous TRIM process
	* which has completed but the thread is not exited.
	*/
	if (cmd_type == POOL_TRIM_START &&
	(vd->vdev_trim_thread != NULL \|\| vd->vdev_top->vdev_removing)) {
	mutex_exit(&vd->vdev_trim_lock);
	return (SET_ERROR(EBUSY));
	} else if (cmd_type == POOL_TRIM_CANCEL &&
	(vd->vdev_trim_state != VDEV_TRIM_ACTIVE &&
	vd->vdev_trim_state != VDEV_TRIM_SUSPENDED)) {
	mutex_exit(&vd->vdev_trim_lock);
	return (SET_ERROR(ESRCH));
	} else if (cmd_type == POOL_TRIM_SUSPEND &&
	vd->vdev_trim_state != VDEV_TRIM_ACTIVE) {
	mutex_exit(&vd->vdev_trim_lock);
	return (SET_ERROR(ESRCH));
	}

	switch (cmd_type) {
	case POOL_TRIM_START:
	vdev_trim(vd, rate, partial, secure);
	break;
	case POOL_TRIM_CANCEL:
	vdev_trim_stop(vd, VDEV_TRIM_CANCELED, vd_list);
	break;
	case POOL_TRIM_SUSPEND:
	vdev_trim_stop(vd, VDEV_TRIM_SUSPENDED, vd_list);
	break;
	default:
	panic("invalid cmd_type %llu", (unsigned long long)cmd_type);
	}
	mutex_exit(&vd->vdev_trim_lock);

	return (0);
	}

	/*
	* Initiates a manual TRIM for the requested vdevs. This kicks off individual
	* TRIM threads for each child vdev. These threads pass over all of the free
	* space in the vdev's metaslabs and issues TRIM commands for that space.
	*/
	int
	spa_vdev_trim(spa_t spa, nvlist_t nv, uint64_t cmd_type, uint64_t rate,
	boolean_t partial, boolean_t secure, nvlist_t *vdev_errlist)
	{
	int total_errors = 0;
	list_t vd_list;

	list_create(&vd_list, sizeof (vdev_t),
	offsetof(vdev_t, vdev_trim_node));

	/*
	* We hold the namespace lock through the whole function
	* to prevent any changes to the pool while we're starting or
	* stopping TRIM. The config and state locks are held so that
	* we can properly assess the vdev state before we commit to
	* the TRIM operation.
	*/
	mutex_enter(&spa_namespace_lock);

	for (nvpair_t *pair = nvlist_next_nvpair(nv, NULL);
	pair != NULL; pair = nvlist_next_nvpair(nv, pair)) {
	uint64_t vdev_guid = fnvpair_value_uint64(pair);

	int error = spa_vdev_trim_impl(spa, vdev_guid, cmd_type,
	rate, partial, secure, &vd_list);
	if (error != 0) {
	char guid_as_str[MAXNAMELEN];

	(void) snprintf(guid_as_str, sizeof (guid_as_str),
	"%llu", (unsigned long long)vdev_guid);
	fnvlist_add_int64(vdev_errlist, guid_as_str, error);
	total_errors++;
	}
	}

	/* Wait for all TRIM threads to stop. */
	vdev_trim_stop_wait(spa, &vd_list);

	/* Sync out the TRIM state */
	txg_wait_synced(spa->spa_dsl_pool, 0);
	mutex_exit(&spa_namespace_lock);

	list_destroy(&vd_list);

	return (total_errors);
	}

	/*
	* Split a set of devices from their mirrors, and create a new pool from them.
	*/
	int
	spa_vdev_split_mirror(spa_t spa, char newname, nvlist_t *config,
	nvlist_t *props, boolean_t exp)
	{
	int error = 0;
	uint64_t txg, *glist;
	spa_t *newspa;
	uint_t c, children, lastlog;
	nvlist_t *child, nvl, *tmp;
	dmu_tx_t *tx;
	char *altroot = NULL;
	vdev_t rvd, vml = NULL; / vdev modify list */
	boolean_t activate_slog;

	ASSERT(spa_writeable(spa));

	txg = spa_vdev_enter(spa);

	ASSERT(MUTEX_HELD(&spa_namespace_lock));
	if (spa_feature_is_active(spa, SPA_FEATURE_POOL_CHECKPOINT)) {
	error = (spa_has_checkpoint(spa)) ?
	ZFS_ERR_CHECKPOINT_EXISTS : ZFS_ERR_DISCARDING_CHECKPOINT;
	return (spa_vdev_exit(spa, NULL, txg, error));
	}

	/* clear the log and flush everything up to now */
	activate_slog = spa_passivate_log(spa);
	(void) spa_vdev_config_exit(spa, NULL, txg, 0, FTAG);
	error = spa_reset_logs(spa);
	txg = spa_vdev_config_enter(spa);

	if (activate_slog)
	spa_activate_log(spa);

	if (error != 0)
	return (spa_vdev_exit(spa, NULL, txg, error));

	/* check new spa name before going any further */
	if (spa_lookup(newname) != NULL)
	return (spa_vdev_exit(spa, NULL, txg, EEXIST));

	/*
	* scan through all the children to ensure they're all mirrors
	*/
	if (nvlist_lookup_nvlist(config, ZPOOL_CONFIG_VDEV_TREE, &nvl) != 0 \|\|
	nvlist_lookup_nvlist_array(nvl, ZPOOL_CONFIG_CHILDREN, &child,
	&children) != 0)
	return (spa_vdev_exit(spa, NULL, txg, EINVAL));

	/* first, check to ensure we've got the right child count */
	rvd = spa->spa_root_vdev;
	lastlog = 0;
	for (c = 0; c < rvd->vdev_children; c++) {
	vdev_t *vd = rvd->vdev_child[c];

	/* don't count the holes & logs as children */
	if (vd->vdev_islog \|\| (vd->vdev_ops != &vdev_indirect_ops &&
	!vdev_is_concrete(vd))) {
	if (lastlog == 0)
	lastlog = c;
	continue;
	}

	lastlog = 0;
	}
	if (children != (lastlog != 0 ? lastlog : rvd->vdev_children))
	return (spa_vdev_exit(spa, NULL, txg, EINVAL));

	/* next, ensure no spare or cache devices are part of the split */
	if (nvlist_lookup_nvlist(nvl, ZPOOL_CONFIG_SPARES, &tmp) == 0 \|\|
	nvlist_lookup_nvlist(nvl, ZPOOL_CONFIG_L2CACHE, &tmp) == 0)
	return (spa_vdev_exit(spa, NULL, txg, EINVAL));

	vml = kmem_zalloc(children * sizeof (vdev_t *), KM_SLEEP);
	glist = kmem_zalloc(children * sizeof (uint64_t), KM_SLEEP);

	/* then, loop over each vdev and validate it */
	for (c = 0; c < children; c++) {
	uint64_t is_hole = 0;

	(void) nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_IS_HOLE,
	&is_hole);

	if (is_hole != 0) {
	if (spa->spa_root_vdev->vdev_child[c]->vdev_ishole \|\|
	spa->spa_root_vdev->vdev_child[c]->vdev_islog) {
	continue;
	} else {
	error = SET_ERROR(EINVAL);
	break;
	}
	}

	/* deal with indirect vdevs */
	if (spa->spa_root_vdev->vdev_child[c]->vdev_ops ==
	&vdev_indirect_ops)
	continue;

	/* which disk is going to be split? */
	if (nvlist_lookup_uint64(child[c], ZPOOL_CONFIG_GUID,
	&glist[c]) != 0) {
	error = SET_ERROR(EINVAL);
	break;
	}

	/* look it up in the spa */
	vml[c] = spa_lookup_by_guid(spa, glist[c], B_FALSE);
	if (vml[c] == NULL) {
	error = SET_ERROR(ENODEV);
	break;
	}

	/* make sure there's nothing stopping the split */
	if (vml[c]->vdev_parent->vdev_ops != &vdev_mirror_ops \|\|
	vml[c]->vdev_islog \|\|
	!vdev_is_concrete(vml[c]) \|\|
	vml[c]->vdev_isspare \|\|
	vml[c]->vdev_isl2cache \|\|
	!vdev_writeable(vml[c]) \|\|
	vml[c]->vdev_children != 0 \|\|
	vml[c]->vdev_state != VDEV_STATE_HEALTHY \|\|
	c != spa->spa_root_vdev->vdev_child[c]->vdev_id) {
	error = SET_ERROR(EINVAL);
	break;
	}

	if (vdev_dtl_required(vml[c]) \|\|
	vdev_resilver_needed(vml[c], NULL, NULL)) {
	error = SET_ERROR(EBUSY);
	break;
	}

	/* we need certain info from the top level */
	VERIFY(nvlist_add_uint64(child[c], ZPOOL_CONFIG_METASLAB_ARRAY,
	vml[c]->vdev_top->vdev_ms_array) == 0);
	VERIFY(nvlist_add_uint64(child[c], ZPOOL_CONFIG_METASLAB_SHIFT,
	vml[c]->vdev_top->vdev_ms_shift) == 0);
	VERIFY(nvlist_add_uint64(child[c], ZPOOL_CONFIG_ASIZE,
	vml[c]->vdev_top->vdev_asize) == 0);
	VERIFY(nvlist_add_uint64(child[c], ZPOOL_CONFIG_ASHIFT,
	vml[c]->vdev_top->vdev_ashift) == 0);

	/* transfer per-vdev ZAPs */
	ASSERT3U(vml[c]->vdev_leaf_zap, !=, 0);
	VERIFY0(nvlist_add_uint64(child[c],
	ZPOOL_CONFIG_VDEV_LEAF_ZAP, vml[c]->vdev_leaf_zap));

	ASSERT3U(vml[c]->vdev_top->vdev_top_zap, !=, 0);
	VERIFY0(nvlist_add_uint64(child[c],
	ZPOOL_CONFIG_VDEV_TOP_ZAP,
	vml[c]->vdev_parent->vdev_top_zap));
	}

	if (error != 0) {
	kmem_free(vml, children * sizeof (vdev_t *));
	kmem_free(glist, children * sizeof (uint64_t));
	return (spa_vdev_exit(spa, NULL, txg, error));
	}

	/* stop writers from using the disks */
	for (c = 0; c < children; c++) {
	if (vml[c] != NULL)
	vml[c]->vdev_offline = B_TRUE;
	}
	vdev_reopen(spa->spa_root_vdev);

	/*
	* Temporarily record the splitting vdevs in the spa config. This
	* will disappear once the config is regenerated.
	*/
	VERIFY(nvlist_alloc(&nvl, NV_UNIQUE_NAME, KM_SLEEP) == 0);
	VERIFY(nvlist_add_uint64_array(nvl, ZPOOL_CONFIG_SPLIT_LIST,
	glist, children) == 0);
	kmem_free(glist, children * sizeof (uint64_t));

	mutex_enter(&spa->spa_props_lock);
	VERIFY(nvlist_add_nvlist(spa->spa_config, ZPOOL_CONFIG_SPLIT,
	nvl) == 0);
	mutex_exit(&spa->spa_props_lock);
	spa->spa_config_splitting = nvl;
	vdev_config_dirty(spa->spa_root_vdev);

	/* configure and create the new pool */
	VERIFY(nvlist_add_string(config, ZPOOL_CONFIG_POOL_NAME, newname) == 0);
	VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_POOL_STATE,
	exp ? POOL_STATE_EXPORTED : POOL_STATE_ACTIVE) == 0);
	VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_VERSION,
	spa_version(spa)) == 0);
	VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_POOL_TXG,
	spa->spa_config_txg) == 0);
	VERIFY(nvlist_add_uint64(config, ZPOOL_CONFIG_POOL_GUID,
	spa_generate_guid(NULL)) == 0);
	VERIFY0(nvlist_add_boolean(config, ZPOOL_CONFIG_HAS_PER_VDEV_ZAPS));
	(void) nvlist_lookup_string(props,
	zpool_prop_to_name(ZPOOL_PROP_ALTROOT), &altroot);

	/* add the new pool to the namespace */
	newspa = spa_add(newname, config, altroot);
	newspa->spa_avz_action = AVZ_ACTION_REBUILD;
	newspa->spa_config_txg = spa->spa_config_txg;
	spa_set_log_state(newspa, SPA_LOG_CLEAR);

	/* release the spa config lock, retaining the namespace lock */
	spa_vdev_config_exit(spa, NULL, txg, 0, FTAG);

	if (zio_injection_enabled)
	zio_handle_panic_injection(spa, FTAG, 1);

	spa_activate(newspa, spa_mode_global);
	spa_async_suspend(newspa);

	/*
	* Temporarily stop the initializing and TRIM activity. We set the
	* state to ACTIVE so that we know to resume initializing or TRIM
	* once the split has completed.
	*/
	list_t vd_initialize_list;
	list_create(&vd_initialize_list, sizeof (vdev_t),
	offsetof(vdev_t, vdev_initialize_node));

	list_t vd_trim_list;
	list_create(&vd_trim_list, sizeof (vdev_t),
	offsetof(vdev_t, vdev_trim_node));

	for (c = 0; c < children; c++) {
	if (vml[c] != NULL && vml[c]->vdev_ops != &vdev_indirect_ops) {
	mutex_enter(&vml[c]->vdev_initialize_lock);
	vdev_initialize_stop(vml[c],
	VDEV_INITIALIZE_ACTIVE, &vd_initialize_list);
	mutex_exit(&vml[c]->vdev_initialize_lock);

	mutex_enter(&vml[c]->vdev_trim_lock);
	vdev_trim_stop(vml[c], VDEV_TRIM_ACTIVE, &vd_trim_list);
	mutex_exit(&vml[c]->vdev_trim_lock);
	}
	}

	vdev_initialize_stop_wait(spa, &vd_initialize_list);
	vdev_trim_stop_wait(spa, &vd_trim_list);

	list_destroy(&vd_initialize_list);
	list_destroy(&vd_trim_list);

	newspa->spa_config_source = SPA_CONFIG_SRC_SPLIT;
	newspa->spa_is_splitting = B_TRUE;

	/* create the new pool from the disks of the original pool */
	error = spa_load(newspa, SPA_LOAD_IMPORT, SPA_IMPORT_ASSEMBLE);
	if (error)
	goto out;

	/* if that worked, generate a real config for the new pool */
	if (newspa->spa_root_vdev != NULL) {
	VERIFY(nvlist_alloc(&newspa->spa_config_splitting,
	NV_UNIQUE_NAME, KM_SLEEP) == 0);
	VERIFY(nvlist_add_uint64(newspa->spa_config_splitting,
	ZPOOL_CONFIG_SPLIT_GUID, spa_guid(spa)) == 0);
	spa_config_set(newspa, spa_config_generate(newspa, NULL, -1ULL,
	B_TRUE));
	}

	/* set the props */
	if (props != NULL) {
	spa_configfile_set(newspa, props, B_FALSE);
	error = spa_prop_set(newspa, props);
	if (error)
	goto out;
	}

	/* flush everything */
	txg = spa_vdev_config_enter(newspa);
	vdev_config_dirty(newspa->spa_root_vdev);
	(void) spa_vdev_config_exit(newspa, NULL, txg, 0, FTAG);

	if (zio_injection_enabled)
	zio_handle_panic_injection(spa, FTAG, 2);

	spa_async_resume(newspa);

	/* finally, update the original pool's config */
	txg = spa_vdev_config_enter(spa);
	tx = dmu_tx_create_dd(spa_get_dsl(spa)->dp_mos_dir);
	error = dmu_tx_assign(tx, TXG_WAIT);
	if (error != 0)
	dmu_tx_abort(tx);
	for (c = 0; c < children; c++) {
	if (vml[c] != NULL && vml[c]->vdev_ops != &vdev_indirect_ops) {
	vdev_t *tvd = vml[c]->vdev_top;

	/*
	* Need to be sure the detachable VDEV is not
	* on any other txg's DTL list to prevent it
	* from being accessed after it's freed.
	*/
	for (int t = 0; t < TXG_SIZE; t++) {
	(void) txg_list_remove_this(
	&tvd->vdev_dtl_list, vml[c], t);
	}

	vdev_split(vml[c]);
	if (error == 0)
	spa_history_log_internal(spa, "detach", tx,
	"vdev=%s", vml[c]->vdev_path);

	vdev_free(vml[c]);
	}
	}
	spa->spa_avz_action = AVZ_ACTION_REBUILD;
	vdev_config_dirty(spa->spa_root_vdev);
	spa->spa_config_splitting = NULL;
	nvlist_free(nvl);
	if (error == 0)
	dmu_tx_commit(tx);
	(void) spa_vdev_exit(spa, NULL, txg, 0);

	if (zio_injection_enabled)
	zio_handle_panic_injection(spa, FTAG, 3);

	/* split is complete; log a history record */
	spa_history_log_internal(newspa, "split", NULL,
	"from pool %s", spa_name(spa));

	newspa->spa_is_splitting = B_FALSE;
	kmem_free(vml, children * sizeof (vdev_t *));

	/* if we're not going to mount the filesystems in userland, export */
	if (exp)
	error = spa_export_common(newname, POOL_STATE_EXPORTED, NULL,
	B_FALSE, B_FALSE);

	return (error);

	out:
	spa_unload(newspa);
	spa_deactivate(newspa);
	spa_remove(newspa);

	txg = spa_vdev_config_enter(spa);

	/* re-online all offlined disks */
	for (c = 0; c < children; c++) {
	if (vml[c] != NULL)
	vml[c]->vdev_offline = B_FALSE;
	}

	/* restart initializing or trimming disks as necessary */
	spa_async_request(spa, SPA_ASYNC_INITIALIZE_RESTART);
	spa_async_request(spa, SPA_ASYNC_TRIM_RESTART);
	spa_async_request(spa, SPA_ASYNC_AUTOTRIM_RESTART);

	vdev_reopen(spa->spa_root_vdev);

	nvlist_free(spa->spa_config_splitting);
	spa->spa_config_splitting = NULL;
	(void) spa_vdev_exit(spa, NULL, txg, error);

	kmem_free(vml, children * sizeof (vdev_t *));
	return (error);
	}

	/*
	* Find any device that's done replacing, or a vdev marked 'unspare' that's
	* currently spared, so we can detach it.
	*/
	static vdev_t *
	spa_vdev_resilver_done_hunt(vdev_t *vd)
	{
	vdev_t newvd, oldvd;

	for (int c = 0; c < vd->vdev_children; c++) {
	oldvd = spa_vdev_resilver_done_hunt(vd->vdev_child[c]);
	if (oldvd != NULL)
	return (oldvd);
	}

	/*
	* Check for a completed replacement. We always consider the first
	* vdev in the list to be the oldest vdev, and the last one to be
	* the newest (see spa_vdev_attach() for how that works). In
	* the case where the newest vdev is faulted, we will not automatically
	* remove it after a resilver completes. This is OK as it will require
	* user intervention to determine which disk the admin wishes to keep.
	*/
	if (vd->vdev_ops == &vdev_replacing_ops) {
	ASSERT(vd->vdev_children > 1);

	newvd = vd->vdev_child[vd->vdev_children - 1];
	oldvd = vd->vdev_child[0];

	if (vdev_dtl_empty(newvd, DTL_MISSING) &&
	vdev_dtl_empty(newvd, DTL_OUTAGE) &&
	!vdev_dtl_required(oldvd))
	return (oldvd);
	}

	/*
	* Check for a completed resilver with the 'unspare' flag set.
	* Also potentially update faulted state.
	*/
	if (vd->vdev_ops == &vdev_spare_ops) {
	vdev_t *first = vd->vdev_child[0];
	vdev_t *last = vd->vdev_child[vd->vdev_children - 1];

	if (last->vdev_unspare) {
	oldvd = first;
	newvd = last;
	} else if (first->vdev_unspare) {
	oldvd = last;
	newvd = first;
	} else {
	oldvd = NULL;
	}

	if (oldvd != NULL &&
	vdev_dtl_empty(newvd, DTL_MISSING) &&
	vdev_dtl_empty(newvd, DTL_OUTAGE) &&
	!vdev_dtl_required(oldvd))
	return (oldvd);

	vdev_propagate_state(vd);

	/*
	* If there are more than two spares attached to a disk,
	* and those spares are not required, then we want to
	* attempt to free them up now so that they can be used
	* by other pools. Once we're back down to a single
	* disk+spare, we stop removing them.
	*/
	if (vd->vdev_children > 2) {
	newvd = vd->vdev_child[1];

	if (newvd->vdev_isspare && last->vdev_isspare &&
	vdev_dtl_empty(last, DTL_MISSING) &&
	vdev_dtl_empty(last, DTL_OUTAGE) &&
	!vdev_dtl_required(newvd))
	return (newvd);
	}
	}

	return (NULL);
	}

	static void
	spa_vdev_resilver_done(spa_t *spa)
	{
	vdev_t vd, pvd, *ppvd;
	uint64_t guid, sguid, pguid, ppguid;

	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);

	while ((vd = spa_vdev_resilver_done_hunt(spa->spa_root_vdev)) != NULL) {
	pvd = vd->vdev_parent;
	ppvd = pvd->vdev_parent;
	guid = vd->vdev_guid;
	pguid = pvd->vdev_guid;
	ppguid = ppvd->vdev_guid;
	sguid = 0;
	/*
	* If we have just finished replacing a hot spared device, then
	* we need to detach the parent's first child (the original hot
	* spare) as well.
	*/
	if (ppvd->vdev_ops == &vdev_spare_ops && pvd->vdev_id == 0 &&
	ppvd->vdev_children == 2) {
	ASSERT(pvd->vdev_ops == &vdev_replacing_ops);
	sguid = ppvd->vdev_child[1]->vdev_guid;
	}
	ASSERT(vd->vdev_resilver_txg == 0 \|\| !vdev_dtl_required(vd));

	spa_config_exit(spa, SCL_ALL, FTAG);
	if (spa_vdev_detach(spa, guid, pguid, B_TRUE) != 0)
	return;
	if (sguid && spa_vdev_detach(spa, sguid, ppguid, B_TRUE) != 0)
	return;
	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);
	}

	spa_config_exit(spa, SCL_ALL, FTAG);

	/*
	* If a detach was not performed above replace waiters will not have
	* been notified. In which case we must do so now.
	*/
	spa_notify_waiters(spa);
	}

	/*
	* Update the stored path or FRU for this vdev.
	*/
	static int
	spa_vdev_set_common(spa_t spa, uint64_t guid, const char value,
	boolean_t ispath)
	{
	vdev_t *vd;
	boolean_t sync = B_FALSE;

	ASSERT(spa_writeable(spa));

	spa_vdev_state_enter(spa, SCL_ALL);

	if ((vd = spa_lookup_by_guid(spa, guid, B_TRUE)) == NULL)
	return (spa_vdev_state_exit(spa, NULL, ENOENT));

	if (!vd->vdev_ops->vdev_op_leaf)
	return (spa_vdev_state_exit(spa, NULL, ENOTSUP));

	if (ispath) {
	if (strcmp(value, vd->vdev_path) != 0) {
	spa_strfree(vd->vdev_path);
	vd->vdev_path = spa_strdup(value);
	sync = B_TRUE;
	}
	} else {
	if (vd->vdev_fru == NULL) {
	vd->vdev_fru = spa_strdup(value);
	sync = B_TRUE;
	} else if (strcmp(value, vd->vdev_fru) != 0) {
	spa_strfree(vd->vdev_fru);
	vd->vdev_fru = spa_strdup(value);
	sync = B_TRUE;
	}
	}

	return (spa_vdev_state_exit(spa, sync ? vd : NULL, 0));
	}

	int
	spa_vdev_setpath(spa_t spa, uint64_t guid, const char newpath)
	{
	return (spa_vdev_set_common(spa, guid, newpath, B_TRUE));
	}

	int
	spa_vdev_setfru(spa_t spa, uint64_t guid, const char newfru)
	{
	return (spa_vdev_set_common(spa, guid, newfru, B_FALSE));
	}

	/*
	* ==========================================================================
	* SPA Scanning
	* ==========================================================================
	*/
	int
	spa_scrub_pause_resume(spa_t *spa, pool_scrub_cmd_t cmd)
	{
	ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == 0);

	if (dsl_scan_resilvering(spa->spa_dsl_pool))
	return (SET_ERROR(EBUSY));

	return (dsl_scrub_set_pause_resume(spa->spa_dsl_pool, cmd));
	}

	int
	spa_scan_stop(spa_t *spa)
	{
	ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == 0);
	if (dsl_scan_resilvering(spa->spa_dsl_pool))
	return (SET_ERROR(EBUSY));
	return (dsl_scan_cancel(spa->spa_dsl_pool));
	}

	int
	spa_scan(spa_t *spa, pool_scan_func_t func)
	{
	ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == 0);

	if (func >= POOL_SCAN_FUNCS \|\| func == POOL_SCAN_NONE)
	return (SET_ERROR(ENOTSUP));

	if (func == POOL_SCAN_RESILVER &&
	!spa_feature_is_enabled(spa, SPA_FEATURE_RESILVER_DEFER))
	return (SET_ERROR(ENOTSUP));

	/*
	* If a resilver was requested, but there is no DTL on a
	* writeable leaf device, we have nothing to do.
	*/
	if (func == POOL_SCAN_RESILVER &&
	!vdev_resilver_needed(spa->spa_root_vdev, NULL, NULL)) {
	spa_async_request(spa, SPA_ASYNC_RESILVER_DONE);
	return (0);
	}

	return (dsl_scan(spa->spa_dsl_pool, func));
	}

	/*
	* ==========================================================================
	* SPA async task processing
	* ==========================================================================
	*/

	static void
	spa_async_remove(spa_t spa, vdev_t vd)
	{
	if (vd->vdev_remove_wanted) {
	vd->vdev_remove_wanted = B_FALSE;
	vd->vdev_delayed_close = B_FALSE;
	vdev_set_state(vd, B_FALSE, VDEV_STATE_REMOVED, VDEV_AUX_NONE);

	/*
	* We want to clear the stats, but we don't want to do a full
	* vdev_clear() as that will cause us to throw away
	* degraded/faulted state as well as attempt to reopen the
	* device, all of which is a waste.
	*/
	vd->vdev_stat.vs_read_errors = 0;
	vd->vdev_stat.vs_write_errors = 0;
	vd->vdev_stat.vs_checksum_errors = 0;

	vdev_state_dirty(vd->vdev_top);

	/* Tell userspace that the vdev is gone. */
	zfs_post_remove(spa, vd);
	}

	for (int c = 0; c < vd->vdev_children; c++)
	spa_async_remove(spa, vd->vdev_child[c]);
	}

	static void
	spa_async_probe(spa_t spa, vdev_t vd)
	{
	if (vd->vdev_probe_wanted) {
	vd->vdev_probe_wanted = B_FALSE;
	vdev_reopen(vd); /* vdev_open() does the actual probe */
	}

	for (int c = 0; c < vd->vdev_children; c++)
	spa_async_probe(spa, vd->vdev_child[c]);
	}

	static void
	spa_async_autoexpand(spa_t spa, vdev_t vd)
	{
	if (!spa->spa_autoexpand)
	return;

	for (int c = 0; c < vd->vdev_children; c++) {
	vdev_t *cvd = vd->vdev_child[c];
	spa_async_autoexpand(spa, cvd);
	}

	if (!vd->vdev_ops->vdev_op_leaf \|\| vd->vdev_physpath == NULL)
	return;

	spa_event_notify(vd->vdev_spa, vd, NULL, ESC_ZFS_VDEV_AUTOEXPAND);
	}

	static void
	spa_async_thread(void *arg)
	{
	spa_t spa = (spa_t )arg;
	dsl_pool_t *dp = spa->spa_dsl_pool;
	int tasks;

	ASSERT(spa->spa_sync_on);

	mutex_enter(&spa->spa_async_lock);
	tasks = spa->spa_async_tasks;
	spa->spa_async_tasks = 0;
	mutex_exit(&spa->spa_async_lock);

	/*
	* See if the config needs to be updated.
	*/
	if (tasks & SPA_ASYNC_CONFIG_UPDATE) {
	uint64_t old_space, new_space;

	mutex_enter(&spa_namespace_lock);
	old_space = metaslab_class_get_space(spa_normal_class(spa));
	old_space += metaslab_class_get_space(spa_special_class(spa));
	old_space += metaslab_class_get_space(spa_dedup_class(spa));
	old_space += metaslab_class_get_space(
	spa_embedded_log_class(spa));

	spa_config_update(spa, SPA_CONFIG_UPDATE_POOL);

	new_space = metaslab_class_get_space(spa_normal_class(spa));
	new_space += metaslab_class_get_space(spa_special_class(spa));
	new_space += metaslab_class_get_space(spa_dedup_class(spa));
	new_space += metaslab_class_get_space(
	spa_embedded_log_class(spa));
	mutex_exit(&spa_namespace_lock);

	/*
	* If the pool grew as a result of the config update,
	* then log an internal history event.
	*/
	if (new_space != old_space) {
	spa_history_log_internal(spa, "vdev online", NULL,
	"pool '%s' size: %llu(+%llu)",
	spa_name(spa), (u_longlong_t)new_space,
	(u_longlong_t)(new_space - old_space));
	}
	}

	/*
	* See if any devices need to be marked REMOVED.
	*/
	if (tasks & SPA_ASYNC_REMOVE) {
	spa_vdev_state_enter(spa, SCL_NONE);
	spa_async_remove(spa, spa->spa_root_vdev);
	for (int i = 0; i < spa->spa_l2cache.sav_count; i++)
	spa_async_remove(spa, spa->spa_l2cache.sav_vdevs[i]);
	for (int i = 0; i < spa->spa_spares.sav_count; i++)
	spa_async_remove(spa, spa->spa_spares.sav_vdevs[i]);
	(void) spa_vdev_state_exit(spa, NULL, 0);
	}

	if ((tasks & SPA_ASYNC_AUTOEXPAND) && !spa_suspended(spa)) {
	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
	spa_async_autoexpand(spa, spa->spa_root_vdev);
	spa_config_exit(spa, SCL_CONFIG, FTAG);
	}

	/*
	* See if any devices need to be probed.
	*/
	if (tasks & SPA_ASYNC_PROBE) {
	spa_vdev_state_enter(spa, SCL_NONE);
	spa_async_probe(spa, spa->spa_root_vdev);
	(void) spa_vdev_state_exit(spa, NULL, 0);
	}

	/*
	* If any devices are done replacing, detach them.
	*/
	if (tasks & SPA_ASYNC_RESILVER_DONE \|\|
	tasks & SPA_ASYNC_REBUILD_DONE) {
	spa_vdev_resilver_done(spa);
	}

	/*
	* Kick off a resilver.
	*/
	if (tasks & SPA_ASYNC_RESILVER &&
	!vdev_rebuild_active(spa->spa_root_vdev) &&
	(!dsl_scan_resilvering(dp) \|\|
	!spa_feature_is_enabled(dp->dp_spa, SPA_FEATURE_RESILVER_DEFER)))
	dsl_scan_restart_resilver(dp, 0);

	if (tasks & SPA_ASYNC_INITIALIZE_RESTART) {
	mutex_enter(&spa_namespace_lock);
	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
	vdev_initialize_restart(spa->spa_root_vdev);
	spa_config_exit(spa, SCL_CONFIG, FTAG);
	mutex_exit(&spa_namespace_lock);
	}

	if (tasks & SPA_ASYNC_TRIM_RESTART) {
	mutex_enter(&spa_namespace_lock);
	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
	vdev_trim_restart(spa->spa_root_vdev);
	spa_config_exit(spa, SCL_CONFIG, FTAG);
	mutex_exit(&spa_namespace_lock);
	}

	if (tasks & SPA_ASYNC_AUTOTRIM_RESTART) {
	mutex_enter(&spa_namespace_lock);
	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
	vdev_autotrim_restart(spa);
	spa_config_exit(spa, SCL_CONFIG, FTAG);
	mutex_exit(&spa_namespace_lock);
	}

	/*
	* Kick off L2 cache whole device TRIM.
	*/
	if (tasks & SPA_ASYNC_L2CACHE_TRIM) {
	mutex_enter(&spa_namespace_lock);
	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
	vdev_trim_l2arc(spa);
	spa_config_exit(spa, SCL_CONFIG, FTAG);
	mutex_exit(&spa_namespace_lock);
	}

	/*
	* Kick off L2 cache rebuilding.
	*/
	if (tasks & SPA_ASYNC_L2CACHE_REBUILD) {
	mutex_enter(&spa_namespace_lock);
	spa_config_enter(spa, SCL_L2ARC, FTAG, RW_READER);
	l2arc_spa_rebuild_start(spa);
	spa_config_exit(spa, SCL_L2ARC, FTAG);
	mutex_exit(&spa_namespace_lock);
	}

	/*
	* Let the world know that we're done.
	*/
	mutex_enter(&spa->spa_async_lock);
	spa->spa_async_thread = NULL;
	cv_broadcast(&spa->spa_async_cv);
	mutex_exit(&spa->spa_async_lock);
	thread_exit();
	}

	void
	spa_async_suspend(spa_t *spa)
	{
	mutex_enter(&spa->spa_async_lock);
	spa->spa_async_suspended++;
	while (spa->spa_async_thread != NULL)
	cv_wait(&spa->spa_async_cv, &spa->spa_async_lock);
	mutex_exit(&spa->spa_async_lock);

	spa_vdev_remove_suspend(spa);

	zthr_t *condense_thread = spa->spa_condense_zthr;
	if (condense_thread != NULL)
	zthr_cancel(condense_thread);

	zthr_t *discard_thread = spa->spa_checkpoint_discard_zthr;
	if (discard_thread != NULL)
	zthr_cancel(discard_thread);

	zthr_t *ll_delete_thread = spa->spa_livelist_delete_zthr;
	if (ll_delete_thread != NULL)
	zthr_cancel(ll_delete_thread);

	zthr_t *ll_condense_thread = spa->spa_livelist_condense_zthr;
	if (ll_condense_thread != NULL)
	zthr_cancel(ll_condense_thread);
	}

	void
	spa_async_resume(spa_t *spa)
	{
	mutex_enter(&spa->spa_async_lock);
	ASSERT(spa->spa_async_suspended != 0);
	spa->spa_async_suspended--;
	mutex_exit(&spa->spa_async_lock);
	spa_restart_removal(spa);

	zthr_t *condense_thread = spa->spa_condense_zthr;
	if (condense_thread != NULL)
	zthr_resume(condense_thread);

	zthr_t *discard_thread = spa->spa_checkpoint_discard_zthr;
	if (discard_thread != NULL)
	zthr_resume(discard_thread);

	zthr_t *ll_delete_thread = spa->spa_livelist_delete_zthr;
	if (ll_delete_thread != NULL)
	zthr_resume(ll_delete_thread);

	zthr_t *ll_condense_thread = spa->spa_livelist_condense_zthr;
	if (ll_condense_thread != NULL)
	zthr_resume(ll_condense_thread);
	}

	static boolean_t
	spa_async_tasks_pending(spa_t *spa)
	{
	uint_t non_config_tasks;
	uint_t config_task;
	boolean_t config_task_suspended;

	non_config_tasks = spa->spa_async_tasks & ~SPA_ASYNC_CONFIG_UPDATE;
	config_task = spa->spa_async_tasks & SPA_ASYNC_CONFIG_UPDATE;
	if (spa->spa_ccw_fail_time == 0) {
	config_task_suspended = B_FALSE;
	} else {
	config_task_suspended =
	(gethrtime() - spa->spa_ccw_fail_time) <
	((hrtime_t)zfs_ccw_retry_interval * NANOSEC);
	}

	return (non_config_tasks \|\| (config_task && !config_task_suspended));
	}

	static void
	spa_async_dispatch(spa_t *spa)
	{
	mutex_enter(&spa->spa_async_lock);
	if (spa_async_tasks_pending(spa) &&
	!spa->spa_async_suspended &&
	spa->spa_async_thread == NULL)
	spa->spa_async_thread = thread_create(NULL, 0,
	spa_async_thread, spa, 0, &p0, TS_RUN, maxclsyspri);
	mutex_exit(&spa->spa_async_lock);
	}

	void
	spa_async_request(spa_t *spa, int task)
	{
	zfs_dbgmsg("spa=%s async request task=%u", spa->spa_name, task);
	mutex_enter(&spa->spa_async_lock);
	spa->spa_async_tasks \|= task;
	mutex_exit(&spa->spa_async_lock);
	}

	int
	spa_async_tasks(spa_t *spa)
	{
	return (spa->spa_async_tasks);
	}

	/*
	* ==========================================================================
	* SPA syncing routines
	* ==========================================================================
	*/


	static int
	bpobj_enqueue_cb(void arg, const blkptr_t bp, boolean_t bp_freed,
	dmu_tx_t *tx)
	{
	bpobj_t *bpo = arg;
	bpobj_enqueue(bpo, bp, bp_freed, tx);
	return (0);
	}

	int
	bpobj_enqueue_alloc_cb(void arg, const blkptr_t bp, dmu_tx_t *tx)
	{
	return (bpobj_enqueue_cb(arg, bp, B_FALSE, tx));
	}

	int
	bpobj_enqueue_free_cb(void arg, const blkptr_t bp, dmu_tx_t *tx)
	{
	return (bpobj_enqueue_cb(arg, bp, B_TRUE, tx));
	}

	static int
	spa_free_sync_cb(void arg, const blkptr_t bp, dmu_tx_t *tx)
	{
	zio_t *pio = arg;

	zio_nowait(zio_free_sync(pio, pio->io_spa, dmu_tx_get_txg(tx), bp,
	pio->io_flags));
	return (0);
	}

	static int
	bpobj_spa_free_sync_cb(void arg, const blkptr_t bp, boolean_t bp_freed,
	dmu_tx_t *tx)
	{
	ASSERT(!bp_freed);
	return (spa_free_sync_cb(arg, bp, tx));
	}

	/*
	* Note: this simple function is not inlined to make it easier to dtrace the
	* amount of time spent syncing frees.
	*/
	static void
	spa_sync_frees(spa_t spa, bplist_t bpl, dmu_tx_t *tx)
	{
	zio_t *zio = zio_root(spa, NULL, NULL, 0);
	bplist_iterate(bpl, spa_free_sync_cb, zio, tx);
	VERIFY(zio_wait(zio) == 0);
	}

	/*
	* Note: this simple function is not inlined to make it easier to dtrace the
	* amount of time spent syncing deferred frees.
	*/
	static void
	spa_sync_deferred_frees(spa_t spa, dmu_tx_t tx)
	{
	if (spa_sync_pass(spa) != 1)
	return;

	/*
	* Note:
	* If the log space map feature is active, we stop deferring
	* frees to the next TXG and therefore running this function
	* would be considered a no-op as spa_deferred_bpobj should
	* not have any entries.
	*
	* That said we run this function anyway (instead of returning
	* immediately) for the edge-case scenario where we just
	* activated the log space map feature in this TXG but we have
	* deferred frees from the previous TXG.
	*/
	zio_t *zio = zio_root(spa, NULL, NULL, 0);
	VERIFY3U(bpobj_iterate(&spa->spa_deferred_bpobj,
	bpobj_spa_free_sync_cb, zio, tx), ==, 0);
	VERIFY0(zio_wait(zio));
	}

	static void
	spa_sync_nvlist(spa_t spa, uint64_t obj, nvlist_t nv, dmu_tx_t *tx)
	{
	char *packed = NULL;
	size_t bufsize;
	size_t nvsize = 0;
	dmu_buf_t *db;

	VERIFY(nvlist_size(nv, &nvsize, NV_ENCODE_XDR) == 0);

	/*
	* Write full (SPA_CONFIG_BLOCKSIZE) blocks of configuration
	* information. This avoids the dmu_buf_will_dirty() path and
	* saves us a pre-read to get data we don't actually care about.
	*/
	bufsize = P2ROUNDUP((uint64_t)nvsize, SPA_CONFIG_BLOCKSIZE);
	packed = vmem_alloc(bufsize, KM_SLEEP);

	VERIFY(nvlist_pack(nv, &packed, &nvsize, NV_ENCODE_XDR,
	KM_SLEEP) == 0);
	bzero(packed + nvsize, bufsize - nvsize);

	dmu_write(spa->spa_meta_objset, obj, 0, bufsize, packed, tx);

	vmem_free(packed, bufsize);

	VERIFY(0 == dmu_bonus_hold(spa->spa_meta_objset, obj, FTAG, &db));
	dmu_buf_will_dirty(db, tx);
	(uint64_t )db->db_data = nvsize;
	dmu_buf_rele(db, FTAG);
	}

	static void
	spa_sync_aux_dev(spa_t spa, spa_aux_vdev_t sav, dmu_tx_t *tx,
	const char config, const char entry)
	{
	nvlist_t *nvroot;
	nvlist_t **list;
	int i;

	if (!sav->sav_sync)
	return;

	/*
	* Update the MOS nvlist describing the list of available devices.
	* spa_validate_aux() will have already made sure this nvlist is
	* valid and the vdevs are labeled appropriately.
	*/
	if (sav->sav_object == 0) {
	sav->sav_object = dmu_object_alloc(spa->spa_meta_objset,
	DMU_OT_PACKED_NVLIST, 1 << 14, DMU_OT_PACKED_NVLIST_SIZE,
	sizeof (uint64_t), tx);
	VERIFY(zap_update(spa->spa_meta_objset,
	DMU_POOL_DIRECTORY_OBJECT, entry, sizeof (uint64_t), 1,
	&sav->sav_object, tx) == 0);
	}

	VERIFY(nvlist_alloc(&nvroot, NV_UNIQUE_NAME, KM_SLEEP) == 0);
	if (sav->sav_count == 0) {
	VERIFY(nvlist_add_nvlist_array(nvroot, config, NULL, 0) == 0);
	} else {
	list = kmem_alloc(sav->sav_countsizeof (void ), KM_SLEEP);
	for (i = 0; i < sav->sav_count; i++)
	list[i] = vdev_config_generate(spa, sav->sav_vdevs[i],
	B_FALSE, VDEV_CONFIG_L2CACHE);
	VERIFY(nvlist_add_nvlist_array(nvroot, config, list,
	sav->sav_count) == 0);
	for (i = 0; i < sav->sav_count; i++)
	nvlist_free(list[i]);
	kmem_free(list, sav->sav_count * sizeof (void *));
	}

	spa_sync_nvlist(spa, sav->sav_object, nvroot, tx);
	nvlist_free(nvroot);

	sav->sav_sync = B_FALSE;
	}

	/*
	* Rebuild spa's all-vdev ZAP from the vdev ZAPs indicated in each vdev_t.
	* The all-vdev ZAP must be empty.
	*/
	static void
	spa_avz_build(vdev_t vd, uint64_t avz, dmu_tx_t tx)
	{
	spa_t *spa = vd->vdev_spa;

	if (vd->vdev_top_zap != 0) {
	VERIFY0(zap_add_int(spa->spa_meta_objset, avz,
	vd->vdev_top_zap, tx));
	}
	if (vd->vdev_leaf_zap != 0) {
	VERIFY0(zap_add_int(spa->spa_meta_objset, avz,
	vd->vdev_leaf_zap, tx));
	}
	for (uint64_t i = 0; i < vd->vdev_children; i++) {
	spa_avz_build(vd->vdev_child[i], avz, tx);
	}
	}

	static void
	spa_sync_config_object(spa_t spa, dmu_tx_t tx)
	{
	nvlist_t *config;

	/*
	* If the pool is being imported from a pre-per-vdev-ZAP version of ZFS,
	* its config may not be dirty but we still need to build per-vdev ZAPs.
	* Similarly, if the pool is being assembled (e.g. after a split), we
	* need to rebuild the AVZ although the config may not be dirty.
	*/
	if (list_is_empty(&spa->spa_config_dirty_list) &&
	spa->spa_avz_action == AVZ_ACTION_NONE)
	return;

	spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);

	ASSERT(spa->spa_avz_action == AVZ_ACTION_NONE \|\|
	spa->spa_avz_action == AVZ_ACTION_INITIALIZE \|\|
	spa->spa_all_vdev_zaps != 0);

	if (spa->spa_avz_action == AVZ_ACTION_REBUILD) {
	/* Make and build the new AVZ */
	uint64_t new_avz = zap_create(spa->spa_meta_objset,
	DMU_OTN_ZAP_METADATA, DMU_OT_NONE, 0, tx);
	spa_avz_build(spa->spa_root_vdev, new_avz, tx);

	/* Diff old AVZ with new one */
	zap_cursor_t zc;
	zap_attribute_t za;

	for (zap_cursor_init(&zc, spa->spa_meta_objset,
	spa->spa_all_vdev_zaps);
	zap_cursor_retrieve(&zc, &za) == 0;
	zap_cursor_advance(&zc)) {
	uint64_t vdzap = za.za_first_integer;
	if (zap_lookup_int(spa->spa_meta_objset, new_avz,
	vdzap) == ENOENT) {
	/*
	* ZAP is listed in old AVZ but not in new one;
	* destroy it
	*/
	VERIFY0(zap_destroy(spa->spa_meta_objset, vdzap,
	tx));
	}
	}

	zap_cursor_fini(&zc);

	/* Destroy the old AVZ */
	VERIFY0(zap_destroy(spa->spa_meta_objset,
	spa->spa_all_vdev_zaps, tx));

	/* Replace the old AVZ in the dir obj with the new one */
	VERIFY0(zap_update(spa->spa_meta_objset,
	DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_VDEV_ZAP_MAP,
	sizeof (new_avz), 1, &new_avz, tx));

	spa->spa_all_vdev_zaps = new_avz;
	} else if (spa->spa_avz_action == AVZ_ACTION_DESTROY) {
	zap_cursor_t zc;
	zap_attribute_t za;

	/* Walk through the AVZ and destroy all listed ZAPs */
	for (zap_cursor_init(&zc, spa->spa_meta_objset,
	spa->spa_all_vdev_zaps);
	zap_cursor_retrieve(&zc, &za) == 0;
	zap_cursor_advance(&zc)) {
	uint64_t zap = za.za_first_integer;
	VERIFY0(zap_destroy(spa->spa_meta_objset, zap, tx));
	}

	zap_cursor_fini(&zc);

	/* Destroy and unlink the AVZ itself */
	VERIFY0(zap_destroy(spa->spa_meta_objset,
	spa->spa_all_vdev_zaps, tx));
	VERIFY0(zap_remove(spa->spa_meta_objset,
	DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_VDEV_ZAP_MAP, tx));
	spa->spa_all_vdev_zaps = 0;
	}

	if (spa->spa_all_vdev_zaps == 0) {
	spa->spa_all_vdev_zaps = zap_create_link(spa->spa_meta_objset,
	DMU_OTN_ZAP_METADATA, DMU_POOL_DIRECTORY_OBJECT,
	DMU_POOL_VDEV_ZAP_MAP, tx);
	}
	spa->spa_avz_action = AVZ_ACTION_NONE;

	/* Create ZAPs for vdevs that don't have them. */
	vdev_construct_zaps(spa->spa_root_vdev, tx);

	config = spa_config_generate(spa, spa->spa_root_vdev,
	dmu_tx_get_txg(tx), B_FALSE);

	/*
	* If we're upgrading the spa version then make sure that
	* the config object gets updated with the correct version.
	*/
	if (spa->spa_ubsync.ub_version < spa->spa_uberblock.ub_version)
	fnvlist_add_uint64(config, ZPOOL_CONFIG_VERSION,
	spa->spa_uberblock.ub_version);

	spa_config_exit(spa, SCL_STATE, FTAG);

	nvlist_free(spa->spa_config_syncing);
	spa->spa_config_syncing = config;

	spa_sync_nvlist(spa, spa->spa_config_object, config, tx);
	}

	static void
	spa_sync_version(void arg, dmu_tx_t tx)
	{
	uint64_t *versionp = arg;
	uint64_t version = *versionp;
	spa_t *spa = dmu_tx_pool(tx)->dp_spa;

	/*
	* Setting the version is special cased when first creating the pool.
	*/
	ASSERT(tx->tx_txg != TXG_INITIAL);

	ASSERT(SPA_VERSION_IS_SUPPORTED(version));
	ASSERT(version >= spa_version(spa));

	spa->spa_uberblock.ub_version = version;
	vdev_config_dirty(spa->spa_root_vdev);
	spa_history_log_internal(spa, "set", tx, "version=%lld",
	(longlong_t)version);
	}

	/*
	* Set zpool properties.
	*/
	static void
	spa_sync_props(void arg, dmu_tx_t tx)
	{
	nvlist_t *nvp = arg;
	spa_t *spa = dmu_tx_pool(tx)->dp_spa;
	objset_t *mos = spa->spa_meta_objset;
	nvpair_t *elem = NULL;

	mutex_enter(&spa->spa_props_lock);

	while ((elem = nvlist_next_nvpair(nvp, elem))) {
	uint64_t intval;
	char strval, fname;
	zpool_prop_t prop;
	const char *propname;
	zprop_type_t proptype;
	spa_feature_t fid;

	switch (prop = zpool_name_to_prop(nvpair_name(elem))) {
	case ZPOOL_PROP_INVAL:
	/*
	* We checked this earlier in spa_prop_validate().
	*/
	ASSERT(zpool_prop_feature(nvpair_name(elem)));

	fname = strchr(nvpair_name(elem), '@') + 1;
	VERIFY0(zfeature_lookup_name(fname, &fid));

	spa_feature_enable(spa, fid, tx);
	spa_history_log_internal(spa, "set", tx,
	"%s=enabled", nvpair_name(elem));
	break;

	case ZPOOL_PROP_VERSION:
	intval = fnvpair_value_uint64(elem);
	/*
	* The version is synced separately before other
	* properties and should be correct by now.
	*/
	ASSERT3U(spa_version(spa), >=, intval);
	break;

	case ZPOOL_PROP_ALTROOT:
	/*
	* 'altroot' is a non-persistent property. It should
	* have been set temporarily at creation or import time.
	*/
	ASSERT(spa->spa_root != NULL);
	break;

	case ZPOOL_PROP_READONLY:
	case ZPOOL_PROP_CACHEFILE:
	/*
	* 'readonly' and 'cachefile' are also non-persistent
	* properties.
	*/
	break;
	case ZPOOL_PROP_COMMENT:
	strval = fnvpair_value_string(elem);
	if (spa->spa_comment != NULL)
	spa_strfree(spa->spa_comment);
	spa->spa_comment = spa_strdup(strval);
	/*
	* We need to dirty the configuration on all the vdevs
	* so that their labels get updated. It's unnecessary
	* to do this for pool creation since the vdev's
	* configuration has already been dirtied.
	*/
	if (tx->tx_txg != TXG_INITIAL)
	vdev_config_dirty(spa->spa_root_vdev);
	spa_history_log_internal(spa, "set", tx,
	"%s=%s", nvpair_name(elem), strval);
	break;
	case ZPOOL_PROP_COMPATIBILITY:
	strval = fnvpair_value_string(elem);
	if (spa->spa_compatibility != NULL)
	spa_strfree(spa->spa_compatibility);
	spa->spa_compatibility = spa_strdup(strval);
	/*
	* Dirty the configuration on vdevs as above.
	*/
	if (tx->tx_txg != TXG_INITIAL)
	vdev_config_dirty(spa->spa_root_vdev);
	spa_history_log_internal(spa, "set", tx,
	"%s=%s", nvpair_name(elem), strval);
	break;

	default:
	/*
	* Set pool property values in the poolprops mos object.
	*/
	if (spa->spa_pool_props_object == 0) {
	spa->spa_pool_props_object =
	zap_create_link(mos, DMU_OT_POOL_PROPS,
	DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_PROPS,
	tx);
	}

	/* normalize the property name */
	propname = zpool_prop_to_name(prop);
	proptype = zpool_prop_get_type(prop);

	if (nvpair_type(elem) == DATA_TYPE_STRING) {
	ASSERT(proptype == PROP_TYPE_STRING);
	strval = fnvpair_value_string(elem);
	VERIFY0(zap_update(mos,
	spa->spa_pool_props_object, propname,
	1, strlen(strval) + 1, strval, tx));
	spa_history_log_internal(spa, "set", tx,
	"%s=%s", nvpair_name(elem), strval);
	} else if (nvpair_type(elem) == DATA_TYPE_UINT64) {
	intval = fnvpair_value_uint64(elem);

	if (proptype == PROP_TYPE_INDEX) {
	const char *unused;
	VERIFY0(zpool_prop_index_to_string(
	prop, intval, &unused));
	}
	VERIFY0(zap_update(mos,
	spa->spa_pool_props_object, propname,
	8, 1, &intval, tx));
	spa_history_log_internal(spa, "set", tx,
	"%s=%lld", nvpair_name(elem),
	(longlong_t)intval);
	} else {
	ASSERT(0); /* not allowed */
	}

	switch (prop) {
	case ZPOOL_PROP_DELEGATION:
	spa->spa_delegation = intval;
	break;
	case ZPOOL_PROP_BOOTFS:
	spa->spa_bootfs = intval;
	break;
	case ZPOOL_PROP_FAILUREMODE:
	spa->spa_failmode = intval;
	break;
	case ZPOOL_PROP_AUTOTRIM:
	spa->spa_autotrim = intval;
	spa_async_request(spa,
	SPA_ASYNC_AUTOTRIM_RESTART);
	break;
	case ZPOOL_PROP_AUTOEXPAND:
	spa->spa_autoexpand = intval;
	if (tx->tx_txg != TXG_INITIAL)
	spa_async_request(spa,
	SPA_ASYNC_AUTOEXPAND);
	break;
	case ZPOOL_PROP_MULTIHOST:
	spa->spa_multihost = intval;
	break;
	default:
	break;
	}
	}

	}

	mutex_exit(&spa->spa_props_lock);
	}

	/*
	* Perform one-time upgrade on-disk changes. spa_version() does not
	* reflect the new version this txg, so there must be no changes this
	* txg to anything that the upgrade code depends on after it executes.
	* Therefore this must be called after dsl_pool_sync() does the sync
	* tasks.
	*/
	static void
	spa_sync_upgrades(spa_t spa, dmu_tx_t tx)
	{
	if (spa_sync_pass(spa) != 1)
	return;

	dsl_pool_t *dp = spa->spa_dsl_pool;
	rrw_enter(&dp->dp_config_rwlock, RW_WRITER, FTAG);

	if (spa->spa_ubsync.ub_version < SPA_VERSION_ORIGIN &&
	spa->spa_uberblock.ub_version >= SPA_VERSION_ORIGIN) {
	dsl_pool_create_origin(dp, tx);

	/* Keeping the origin open increases spa_minref */
	spa->spa_minref += 3;
	}

	if (spa->spa_ubsync.ub_version < SPA_VERSION_NEXT_CLONES &&
	spa->spa_uberblock.ub_version >= SPA_VERSION_NEXT_CLONES) {
	dsl_pool_upgrade_clones(dp, tx);
	}

	if (spa->spa_ubsync.ub_version < SPA_VERSION_DIR_CLONES &&
	spa->spa_uberblock.ub_version >= SPA_VERSION_DIR_CLONES) {
	dsl_pool_upgrade_dir_clones(dp, tx);

	/* Keeping the freedir open increases spa_minref */
	spa->spa_minref += 3;
	}

	if (spa->spa_ubsync.ub_version < SPA_VERSION_FEATURES &&
	spa->spa_uberblock.ub_version >= SPA_VERSION_FEATURES) {
	spa_feature_create_zap_objects(spa, tx);
	}

	/*
	* LZ4_COMPRESS feature's behaviour was changed to activate_on_enable
	* when possibility to use lz4 compression for metadata was added
	* Old pools that have this feature enabled must be upgraded to have
	* this feature active
	*/
	if (spa->spa_uberblock.ub_version >= SPA_VERSION_FEATURES) {
	boolean_t lz4_en = spa_feature_is_enabled(spa,
	SPA_FEATURE_LZ4_COMPRESS);
	boolean_t lz4_ac = spa_feature_is_active(spa,
	SPA_FEATURE_LZ4_COMPRESS);

	if (lz4_en && !lz4_ac)
	spa_feature_incr(spa, SPA_FEATURE_LZ4_COMPRESS, tx);
	}

	/*
	* If we haven't written the salt, do so now. Note that the
	* feature may not be activated yet, but that's fine since
	* the presence of this ZAP entry is backwards compatible.
	*/
	if (zap_contains(spa->spa_meta_objset, DMU_POOL_DIRECTORY_OBJECT,
	DMU_POOL_CHECKSUM_SALT) == ENOENT) {
	VERIFY0(zap_add(spa->spa_meta_objset,
	DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_CHECKSUM_SALT, 1,
	sizeof (spa->spa_cksum_salt.zcs_bytes),
	spa->spa_cksum_salt.zcs_bytes, tx));
	}

	rrw_exit(&dp->dp_config_rwlock, FTAG);
	}

	static void
	vdev_indirect_state_sync_verify(vdev_t *vd)
	{
	vdev_indirect_mapping_t *vim __maybe_unused = vd->vdev_indirect_mapping;
	vdev_indirect_births_t *vib __maybe_unused = vd->vdev_indirect_births;

	if (vd->vdev_ops == &vdev_indirect_ops) {
	ASSERT(vim != NULL);
	ASSERT(vib != NULL);
	}

	uint64_t obsolete_sm_object = 0;
	ASSERT0(vdev_obsolete_sm_object(vd, &obsolete_sm_object));
	if (obsolete_sm_object != 0) {
	ASSERT(vd->vdev_obsolete_sm != NULL);
	ASSERT(vd->vdev_removing \|\|
	vd->vdev_ops == &vdev_indirect_ops);
	ASSERT(vdev_indirect_mapping_num_entries(vim) > 0);
	ASSERT(vdev_indirect_mapping_bytes_mapped(vim) > 0);
	ASSERT3U(obsolete_sm_object, ==,
	space_map_object(vd->vdev_obsolete_sm));
	ASSERT3U(vdev_indirect_mapping_bytes_mapped(vim), >=,
	space_map_allocated(vd->vdev_obsolete_sm));
	}
	ASSERT(vd->vdev_obsolete_segments != NULL);

	/*
	* Since frees / remaps to an indirect vdev can only
	* happen in syncing context, the obsolete segments
	* tree must be empty when we start syncing.
	*/
	ASSERT0(range_tree_space(vd->vdev_obsolete_segments));
	}

	/*
	* Set the top-level vdev's max queue depth. Evaluate each top-level's
	* async write queue depth in case it changed. The max queue depth will
	* not change in the middle of syncing out this txg.
	*/
	static void
	spa_sync_adjust_vdev_max_queue_depth(spa_t *spa)
	{
	ASSERT(spa_writeable(spa));

	vdev_t *rvd = spa->spa_root_vdev;
	uint32_t max_queue_depth = zfs_vdev_async_write_max_active *
	zfs_vdev_queue_depth_pct / 100;
	metaslab_class_t *normal = spa_normal_class(spa);
	metaslab_class_t *special = spa_special_class(spa);
	metaslab_class_t *dedup = spa_dedup_class(spa);

	uint64_t slots_per_allocator = 0;
	for (int c = 0; c < rvd->vdev_children; c++) {
	vdev_t *tvd = rvd->vdev_child[c];

	metaslab_group_t *mg = tvd->vdev_mg;
	if (mg == NULL \|\| !metaslab_group_initialized(mg))
	continue;

	metaslab_class_t *mc = mg->mg_class;
	if (mc != normal && mc != special && mc != dedup)
	continue;

	/*
	* It is safe to do a lock-free check here because only async
	* allocations look at mg_max_alloc_queue_depth, and async
	* allocations all happen from spa_sync().
	*/
	for (int i = 0; i < mg->mg_allocators; i++) {
	ASSERT0(zfs_refcount_count(
	&(mg->mg_allocator[i].mga_alloc_queue_depth)));
	}
	mg->mg_max_alloc_queue_depth = max_queue_depth;

	for (int i = 0; i < mg->mg_allocators; i++) {
	mg->mg_allocator[i].mga_cur_max_alloc_queue_depth =
	zfs_vdev_def_queue_depth;
	}
	slots_per_allocator += zfs_vdev_def_queue_depth;
	}

	for (int i = 0; i < spa->spa_alloc_count; i++) {
	ASSERT0(zfs_refcount_count(&normal->mc_allocator[i].
	mca_alloc_slots));
	ASSERT0(zfs_refcount_count(&special->mc_allocator[i].
	mca_alloc_slots));
	ASSERT0(zfs_refcount_count(&dedup->mc_allocator[i].
	mca_alloc_slots));
	normal->mc_allocator[i].mca_alloc_max_slots =
	slots_per_allocator;
	special->mc_allocator[i].mca_alloc_max_slots =
	slots_per_allocator;
	dedup->mc_allocator[i].mca_alloc_max_slots =
	slots_per_allocator;
	}
	normal->mc_alloc_throttle_enabled = zio_dva_throttle_enabled;
	special->mc_alloc_throttle_enabled = zio_dva_throttle_enabled;
	dedup->mc_alloc_throttle_enabled = zio_dva_throttle_enabled;
	}

	static void
	spa_sync_condense_indirect(spa_t spa, dmu_tx_t tx)
	{
	ASSERT(spa_writeable(spa));

	vdev_t *rvd = spa->spa_root_vdev;
	for (int c = 0; c < rvd->vdev_children; c++) {
	vdev_t *vd = rvd->vdev_child[c];
	vdev_indirect_state_sync_verify(vd);

	if (vdev_indirect_should_condense(vd)) {
	spa_condense_indirect_start_sync(vd, tx);
	break;
	}
	}
	}

	static void
	spa_sync_iterate_to_convergence(spa_t spa, dmu_tx_t tx)
	{
	objset_t *mos = spa->spa_meta_objset;
	dsl_pool_t *dp = spa->spa_dsl_pool;
	uint64_t txg = tx->tx_txg;
	bplist_t *free_bpl = &spa->spa_free_bplist[txg & TXG_MASK];

	do {
	int pass = ++spa->spa_sync_pass;

	spa_sync_config_object(spa, tx);
	spa_sync_aux_dev(spa, &spa->spa_spares, tx,
	ZPOOL_CONFIG_SPARES, DMU_POOL_SPARES);
	spa_sync_aux_dev(spa, &spa->spa_l2cache, tx,
	ZPOOL_CONFIG_L2CACHE, DMU_POOL_L2CACHE);
	spa_errlog_sync(spa, txg);
	dsl_pool_sync(dp, txg);

	if (pass < zfs_sync_pass_deferred_free \|\|
	spa_feature_is_active(spa, SPA_FEATURE_LOG_SPACEMAP)) {
	/*
	* If the log space map feature is active we don't
	* care about deferred frees and the deferred bpobj
	* as the log space map should effectively have the
	* same results (i.e. appending only to one object).
	*/
	spa_sync_frees(spa, free_bpl, tx);
	} else {
	/*
	* We can not defer frees in pass 1, because
	* we sync the deferred frees later in pass 1.
	*/
	ASSERT3U(pass, >, 1);
	bplist_iterate(free_bpl, bpobj_enqueue_alloc_cb,
	&spa->spa_deferred_bpobj, tx);
	}

	ddt_sync(spa, txg);
	dsl_scan_sync(dp, tx);
	svr_sync(spa, tx);
	spa_sync_upgrades(spa, tx);

	spa_flush_metaslabs(spa, tx);

	vdev_t *vd = NULL;
	while ((vd = txg_list_remove(&spa->spa_vdev_txg_list, txg))
	!= NULL)
	vdev_sync(vd, txg);

	/*
	* Note: We need to check if the MOS is dirty because we could
	* have marked the MOS dirty without updating the uberblock
	* (e.g. if we have sync tasks but no dirty user data). We need
	* to check the uberblock's rootbp because it is updated if we
	* have synced out dirty data (though in this case the MOS will
	* most likely also be dirty due to second order effects, we
	* don't want to rely on that here).
	*/
	if (pass == 1 &&
	spa->spa_uberblock.ub_rootbp.blk_birth < txg &&
	!dmu_objset_is_dirty(mos, txg)) {
	/*
	* Nothing changed on the first pass, therefore this
	* TXG is a no-op. Avoid syncing deferred frees, so
	* that we can keep this TXG as a no-op.
	*/
	ASSERT(txg_list_empty(&dp->dp_dirty_datasets, txg));
	ASSERT(txg_list_empty(&dp->dp_dirty_dirs, txg));
	ASSERT(txg_list_empty(&dp->dp_sync_tasks, txg));
	ASSERT(txg_list_empty(&dp->dp_early_sync_tasks, txg));
	break;
	}

	spa_sync_deferred_frees(spa, tx);
	} while (dmu_objset_is_dirty(mos, txg));
	}

	/*
	* Rewrite the vdev configuration (which includes the uberblock) to
	* commit the transaction group.
	*
	* If there are no dirty vdevs, we sync the uberblock to a few random
	* top-level vdevs that are known to be visible in the config cache
	* (see spa_vdev_add() for a complete description). If there are dirty
	* vdevs, sync the uberblock to all vdevs.
	*/
	static void
	spa_sync_rewrite_vdev_config(spa_t spa, dmu_tx_t tx)
	{
	vdev_t *rvd = spa->spa_root_vdev;
	uint64_t txg = tx->tx_txg;

	for (;;) {
	int error = 0;

	/*
	* We hold SCL_STATE to prevent vdev open/close/etc.
	* while we're attempting to write the vdev labels.
	*/
	spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);

	if (list_is_empty(&spa->spa_config_dirty_list)) {
	vdev_t *svd[SPA_SYNC_MIN_VDEVS] = { NULL };
	int svdcount = 0;
	int children = rvd->vdev_children;
	int c0 = spa_get_random(children);

	for (int c = 0; c < children; c++) {
	vdev_t *vd =
	rvd->vdev_child[(c0 + c) % children];

	/* Stop when revisiting the first vdev */
	if (c > 0 && svd[0] == vd)
	break;

	if (vd->vdev_ms_array == 0 \|\|
	vd->vdev_islog \|\|
	!vdev_is_concrete(vd))
	continue;

	svd[svdcount++] = vd;
	if (svdcount == SPA_SYNC_MIN_VDEVS)
	break;
	}
	error = vdev_config_sync(svd, svdcount, txg);
	} else {
	error = vdev_config_sync(rvd->vdev_child,
	rvd->vdev_children, txg);
	}

	if (error == 0)
	spa->spa_last_synced_guid = rvd->vdev_guid;

	spa_config_exit(spa, SCL_STATE, FTAG);

	if (error == 0)
	break;
	zio_suspend(spa, NULL, ZIO_SUSPEND_IOERR);
	zio_resume_wait(spa);
	}
	}

	/*
	* Sync the specified transaction group. New blocks may be dirtied as
	* part of the process, so we iterate until it converges.
	*/
	void
	spa_sync(spa_t *spa, uint64_t txg)
	{
	vdev_t *vd = NULL;

	VERIFY(spa_writeable(spa));

	/*
	* Wait for i/os issued in open context that need to complete
	* before this txg syncs.
	*/
	(void) zio_wait(spa->spa_txg_zio[txg & TXG_MASK]);
	spa->spa_txg_zio[txg & TXG_MASK] = zio_root(spa, NULL, NULL,
	ZIO_FLAG_CANFAIL);

	/*
	* Lock out configuration changes.
	*/
	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);

	spa->spa_syncing_txg = txg;
	spa->spa_sync_pass = 0;

	for (int i = 0; i < spa->spa_alloc_count; i++) {
	mutex_enter(&spa->spa_alloc_locks[i]);
	VERIFY0(avl_numnodes(&spa->spa_alloc_trees[i]));
	mutex_exit(&spa->spa_alloc_locks[i]);
	}

	/*
	* If there are any pending vdev state changes, convert them
	* into config changes that go out with this transaction group.
	*/
	spa_config_enter(spa, SCL_STATE, FTAG, RW_READER);
	while (list_head(&spa->spa_state_dirty_list) != NULL) {
	/*
	* We need the write lock here because, for aux vdevs,
	* calling vdev_config_dirty() modifies sav_config.
	* This is ugly and will become unnecessary when we
	* eliminate the aux vdev wart by integrating all vdevs
	* into the root vdev tree.
	*/
	spa_config_exit(spa, SCL_CONFIG \| SCL_STATE, FTAG);
	spa_config_enter(spa, SCL_CONFIG \| SCL_STATE, FTAG, RW_WRITER);
	while ((vd = list_head(&spa->spa_state_dirty_list)) != NULL) {
	vdev_state_clean(vd);
	vdev_config_dirty(vd);
	}
	spa_config_exit(spa, SCL_CONFIG \| SCL_STATE, FTAG);
	spa_config_enter(spa, SCL_CONFIG \| SCL_STATE, FTAG, RW_READER);
	}
	spa_config_exit(spa, SCL_STATE, FTAG);

	dsl_pool_t *dp = spa->spa_dsl_pool;
	dmu_tx_t *tx = dmu_tx_create_assigned(dp, txg);

	spa->spa_sync_starttime = gethrtime();
	taskq_cancel_id(system_delay_taskq, spa->spa_deadman_tqid);
	spa->spa_deadman_tqid = taskq_dispatch_delay(system_delay_taskq,
	spa_deadman, spa, TQ_SLEEP, ddi_get_lbolt() +
	NSEC_TO_TICK(spa->spa_deadman_synctime));

	/*
	* If we are upgrading to SPA_VERSION_RAIDZ_DEFLATE this txg,
	* set spa_deflate if we have no raid-z vdevs.
	*/
	if (spa->spa_ubsync.ub_version < SPA_VERSION_RAIDZ_DEFLATE &&
	spa->spa_uberblock.ub_version >= SPA_VERSION_RAIDZ_DEFLATE) {
	vdev_t *rvd = spa->spa_root_vdev;

	int i;
	for (i = 0; i < rvd->vdev_children; i++) {
	vd = rvd->vdev_child[i];
	if (vd->vdev_deflate_ratio != SPA_MINBLOCKSIZE)
	break;
	}
	if (i == rvd->vdev_children) {
	spa->spa_deflate = TRUE;
	VERIFY0(zap_add(spa->spa_meta_objset,
	DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_DEFLATE,
	sizeof (uint64_t), 1, &spa->spa_deflate, tx));
	}
	}

	spa_sync_adjust_vdev_max_queue_depth(spa);

	spa_sync_condense_indirect(spa, tx);

	spa_sync_iterate_to_convergence(spa, tx);

	#ifdef ZFS_DEBUG
	if (!list_is_empty(&spa->spa_config_dirty_list)) {
	/*
	* Make sure that the number of ZAPs for all the vdevs matches
	* the number of ZAPs in the per-vdev ZAP list. This only gets
	* called if the config is dirty; otherwise there may be
	* outstanding AVZ operations that weren't completed in
	* spa_sync_config_object.
	*/
	uint64_t all_vdev_zap_entry_count;
	ASSERT0(zap_count(spa->spa_meta_objset,
	spa->spa_all_vdev_zaps, &all_vdev_zap_entry_count));
	ASSERT3U(vdev_count_verify_zaps(spa->spa_root_vdev), ==,
	all_vdev_zap_entry_count);
	}
	#endif

	if (spa->spa_vdev_removal != NULL) {
	ASSERT0(spa->spa_vdev_removal->svr_bytes_done[txg & TXG_MASK]);
	}

	spa_sync_rewrite_vdev_config(spa, tx);
	dmu_tx_commit(tx);

	taskq_cancel_id(system_delay_taskq, spa->spa_deadman_tqid);
	spa->spa_deadman_tqid = 0;

	/*
	* Clear the dirty config list.
	*/
	while ((vd = list_head(&spa->spa_config_dirty_list)) != NULL)
	vdev_config_clean(vd);

	/*
	* Now that the new config has synced transactionally,
	* let it become visible to the config cache.
	*/
	if (spa->spa_config_syncing != NULL) {
	spa_config_set(spa, spa->spa_config_syncing);
	spa->spa_config_txg = txg;
	spa->spa_config_syncing = NULL;
	}

	dsl_pool_sync_done(dp, txg);

	for (int i = 0; i < spa->spa_alloc_count; i++) {
	mutex_enter(&spa->spa_alloc_locks[i]);
	VERIFY0(avl_numnodes(&spa->spa_alloc_trees[i]));
	mutex_exit(&spa->spa_alloc_locks[i]);
	}

	/*
	* Update usable space statistics.
	*/
	while ((vd = txg_list_remove(&spa->spa_vdev_txg_list, TXG_CLEAN(txg)))
	!= NULL)
	vdev_sync_done(vd, txg);

	metaslab_class_evict_old(spa->spa_normal_class, txg);
	metaslab_class_evict_old(spa->spa_log_class, txg);

	spa_sync_close_syncing_log_sm(spa);

	spa_update_dspace(spa);

	/*
	* It had better be the case that we didn't dirty anything
	* since vdev_config_sync().
	*/
	ASSERT(txg_list_empty(&dp->dp_dirty_datasets, txg));
	ASSERT(txg_list_empty(&dp->dp_dirty_dirs, txg));
	ASSERT(txg_list_empty(&spa->spa_vdev_txg_list, txg));

	while (zfs_pause_spa_sync)
	delay(1);

	spa->spa_sync_pass = 0;

	/*
	* Update the last synced uberblock here. We want to do this at
	* the end of spa_sync() so that consumers of spa_last_synced_txg()
	* will be guaranteed that all the processing associated with
	* that txg has been completed.
	*/
	spa->spa_ubsync = spa->spa_uberblock;
	spa_config_exit(spa, SCL_CONFIG, FTAG);

	spa_handle_ignored_writes(spa);

	/*
	* If any async tasks have been requested, kick them off.
	*/
	spa_async_dispatch(spa);
	}

	/*
	* Sync all pools. We don't want to hold the namespace lock across these
	* operations, so we take a reference on the spa_t and drop the lock during the
	* sync.
	*/
	void
	spa_sync_allpools(void)
	{
	spa_t *spa = NULL;
	mutex_enter(&spa_namespace_lock);
	while ((spa = spa_next(spa)) != NULL) {
	if (spa_state(spa) != POOL_STATE_ACTIVE \|\|
	!spa_writeable(spa) \|\| spa_suspended(spa))
	continue;
	spa_open_ref(spa, FTAG);
	mutex_exit(&spa_namespace_lock);
	txg_wait_synced(spa_get_dsl(spa), 0);
	mutex_enter(&spa_namespace_lock);
	spa_close(spa, FTAG);
	}
	mutex_exit(&spa_namespace_lock);
	}

	/*
	* ==========================================================================
	* Miscellaneous routines
	* ==========================================================================
	*/

	/*
	* Remove all pools in the system.
	*/
	void
	spa_evict_all(void)
	{
	spa_t *spa;

	/*
	* Remove all cached state. All pools should be closed now,
	* so every spa in the AVL tree should be unreferenced.
	*/
	mutex_enter(&spa_namespace_lock);
	while ((spa = spa_next(NULL)) != NULL) {
	/*
	* Stop async tasks. The async thread may need to detach
	* a device that's been replaced, which requires grabbing
	* spa_namespace_lock, so we must drop it here.
	*/
	spa_open_ref(spa, FTAG);
	mutex_exit(&spa_namespace_lock);
	spa_async_suspend(spa);
	mutex_enter(&spa_namespace_lock);
	spa_close(spa, FTAG);

	if (spa->spa_state != POOL_STATE_UNINITIALIZED) {
	spa_unload(spa);
	spa_deactivate(spa);
	}
	spa_remove(spa);
	}
	mutex_exit(&spa_namespace_lock);
	}

	vdev_t *
	spa_lookup_by_guid(spa_t *spa, uint64_t guid, boolean_t aux)
	{
	vdev_t *vd;
	int i;

	if ((vd = vdev_lookup_by_guid(spa->spa_root_vdev, guid)) != NULL)
	return (vd);

	if (aux) {
	for (i = 0; i < spa->spa_l2cache.sav_count; i++) {
	vd = spa->spa_l2cache.sav_vdevs[i];
	if (vd->vdev_guid == guid)
	return (vd);
	}

	for (i = 0; i < spa->spa_spares.sav_count; i++) {
	vd = spa->spa_spares.sav_vdevs[i];
	if (vd->vdev_guid == guid)
	return (vd);
	}
	}

	return (NULL);
	}

	void
	spa_upgrade(spa_t *spa, uint64_t version)
	{
	ASSERT(spa_writeable(spa));

	spa_config_enter(spa, SCL_ALL, FTAG, RW_WRITER);

	/*
	* This should only be called for a non-faulted pool, and since a
	* future version would result in an unopenable pool, this shouldn't be
	* possible.
	*/
	ASSERT(SPA_VERSION_IS_SUPPORTED(spa->spa_uberblock.ub_version));
	ASSERT3U(version, >=, spa->spa_uberblock.ub_version);

	spa->spa_uberblock.ub_version = version;
	vdev_config_dirty(spa->spa_root_vdev);

	spa_config_exit(spa, SCL_ALL, FTAG);

	txg_wait_synced(spa_get_dsl(spa), 0);
	}

	boolean_t
	spa_has_spare(spa_t *spa, uint64_t guid)
	{
	int i;
	uint64_t spareguid;
	spa_aux_vdev_t *sav = &spa->spa_spares;

	for (i = 0; i < sav->sav_count; i++)
	if (sav->sav_vdevs[i]->vdev_guid == guid)
	return (B_TRUE);

	for (i = 0; i < sav->sav_npending; i++) {
	if (nvlist_lookup_uint64(sav->sav_pending[i], ZPOOL_CONFIG_GUID,
	&spareguid) == 0 && spareguid == guid)
	return (B_TRUE);
	}

	return (B_FALSE);
	}

	/*
	* Check if a pool has an active shared spare device.
	* Note: reference count of an active spare is 2, as a spare and as a replace
	*/
	static boolean_t
	spa_has_active_shared_spare(spa_t *spa)
	{
	int i, refcnt;
	uint64_t pool;
	spa_aux_vdev_t *sav = &spa->spa_spares;

	for (i = 0; i < sav->sav_count; i++) {
	if (spa_spare_exists(sav->sav_vdevs[i]->vdev_guid, &pool,
	&refcnt) && pool != 0ULL && pool == spa_guid(spa) &&
	refcnt > 2)
	return (B_TRUE);
	}

	return (B_FALSE);
	}

	uint64_t
	spa_total_metaslabs(spa_t *spa)
	{
	vdev_t *rvd = spa->spa_root_vdev;

	uint64_t m = 0;
	for (uint64_t c = 0; c < rvd->vdev_children; c++) {
	vdev_t *vd = rvd->vdev_child[c];
	if (!vdev_is_concrete(vd))
	continue;
	m += vd->vdev_ms_count;
	}
	return (m);
	}

	/*
	* Notify any waiting threads that some activity has switched from being in-
	* progress to not-in-progress so that the thread can wake up and determine
	* whether it is finished waiting.
	*/
	void
	spa_notify_waiters(spa_t *spa)
	{
	/*
	* Acquiring spa_activities_lock here prevents the cv_broadcast from
	* happening between the waiting thread's check and cv_wait.
	*/
	mutex_enter(&spa->spa_activities_lock);
	cv_broadcast(&spa->spa_activities_cv);
	mutex_exit(&spa->spa_activities_lock);
	}

	/*
	* Notify any waiting threads that the pool is exporting, and then block until
	* they are finished using the spa_t.
	*/
	void
	spa_wake_waiters(spa_t *spa)
	{
	mutex_enter(&spa->spa_activities_lock);
	spa->spa_waiters_cancel = B_TRUE;
	cv_broadcast(&spa->spa_activities_cv);
	while (spa->spa_waiters != 0)
	cv_wait(&spa->spa_waiters_cv, &spa->spa_activities_lock);
	spa->spa_waiters_cancel = B_FALSE;
	mutex_exit(&spa->spa_activities_lock);
	}

	/* Whether the vdev or any of its descendants are being initialized/trimmed. */
	static boolean_t
	spa_vdev_activity_in_progress_impl(vdev_t *vd, zpool_wait_activity_t activity)
	{
	spa_t *spa = vd->vdev_spa;

	ASSERT(spa_config_held(spa, SCL_CONFIG \| SCL_STATE, RW_READER));
	ASSERT(MUTEX_HELD(&spa->spa_activities_lock));
	ASSERT(activity == ZPOOL_WAIT_INITIALIZE \|\|
	activity == ZPOOL_WAIT_TRIM);

	kmutex_t *lock = activity == ZPOOL_WAIT_INITIALIZE ?
	&vd->vdev_initialize_lock : &vd->vdev_trim_lock;

	mutex_exit(&spa->spa_activities_lock);
	mutex_enter(lock);
	mutex_enter(&spa->spa_activities_lock);

	boolean_t in_progress = (activity == ZPOOL_WAIT_INITIALIZE) ?
	(vd->vdev_initialize_state == VDEV_INITIALIZE_ACTIVE) :
	(vd->vdev_trim_state == VDEV_TRIM_ACTIVE);
	mutex_exit(lock);

	if (in_progress)
	return (B_TRUE);

	for (int i = 0; i < vd->vdev_children; i++) {
	if (spa_vdev_activity_in_progress_impl(vd->vdev_child[i],
	activity))
	return (B_TRUE);
	}

	return (B_FALSE);
	}

	/*
	* If use_guid is true, this checks whether the vdev specified by guid is
	* being initialized/trimmed. Otherwise, it checks whether any vdev in the pool
	* is being initialized/trimmed. The caller must hold the config lock and
	* spa_activities_lock.
	*/
	static int
	spa_vdev_activity_in_progress(spa_t *spa, boolean_t use_guid, uint64_t guid,
	zpool_wait_activity_t activity, boolean_t *in_progress)
	{
	mutex_exit(&spa->spa_activities_lock);
	spa_config_enter(spa, SCL_CONFIG \| SCL_STATE, FTAG, RW_READER);
	mutex_enter(&spa->spa_activities_lock);

	vdev_t *vd;
	if (use_guid) {
	vd = spa_lookup_by_guid(spa, guid, B_FALSE);
	if (vd == NULL \|\| !vd->vdev_ops->vdev_op_leaf) {
	spa_config_exit(spa, SCL_CONFIG \| SCL_STATE, FTAG);
	return (EINVAL);
	}
	} else {
	vd = spa->spa_root_vdev;
	}

	*in_progress = spa_vdev_activity_in_progress_impl(vd, activity);

	spa_config_exit(spa, SCL_CONFIG \| SCL_STATE, FTAG);
	return (0);
	}

	/*
	* Locking for waiting threads
	* ---------------------------
	*
	* Waiting threads need a way to check whether a given activity is in progress,
	* and then, if it is, wait for it to complete. Each activity will have some
	* in-memory representation of the relevant on-disk state which can be used to
	* determine whether or not the activity is in progress. The in-memory state and
	* the locking used to protect it will be different for each activity, and may
	* not be suitable for use with a cvar (e.g., some state is protected by the
	* config lock). To allow waiting threads to wait without any races, another
	* lock, spa_activities_lock, is used.
	*
	* When the state is checked, both the activity-specific lock (if there is one)
	* and spa_activities_lock are held. In some cases, the activity-specific lock
	* is acquired explicitly (e.g. the config lock). In others, the locking is
	* internal to some check (e.g. bpobj_is_empty). After checking, the waiting
	* thread releases the activity-specific lock and, if the activity is in
	* progress, then cv_waits using spa_activities_lock.
	*
	* The waiting thread is woken when another thread, one completing some
	* activity, updates the state of the activity and then calls
	* spa_notify_waiters, which will cv_broadcast. This 'completing' thread only
	* needs to hold its activity-specific lock when updating the state, and this
	* lock can (but doesn't have to) be dropped before calling spa_notify_waiters.
	*
	* Because spa_notify_waiters acquires spa_activities_lock before broadcasting,
	* and because it is held when the waiting thread checks the state of the
	* activity, it can never be the case that the completing thread both updates
	* the activity state and cv_broadcasts in between the waiting thread's check
	* and cv_wait. Thus, a waiting thread can never miss a wakeup.
	*
	* In order to prevent deadlock, when the waiting thread does its check, in some
	* cases it will temporarily drop spa_activities_lock in order to acquire the
	* activity-specific lock. The order in which spa_activities_lock and the
	* activity specific lock are acquired in the waiting thread is determined by
	* the order in which they are acquired in the completing thread; if the
	* completing thread calls spa_notify_waiters with the activity-specific lock
	* held, then the waiting thread must also acquire the activity-specific lock
	* first.
	*/

	static int
	spa_activity_in_progress(spa_t *spa, zpool_wait_activity_t activity,
	boolean_t use_tag, uint64_t tag, boolean_t *in_progress)
	{
	int error = 0;

	ASSERT(MUTEX_HELD(&spa->spa_activities_lock));

	switch (activity) {
	case ZPOOL_WAIT_CKPT_DISCARD:
	*in_progress =
	(spa_feature_is_active(spa, SPA_FEATURE_POOL_CHECKPOINT) &&
	zap_contains(spa_meta_objset(spa),
	DMU_POOL_DIRECTORY_OBJECT, DMU_POOL_ZPOOL_CHECKPOINT) ==
	ENOENT);
	break;
	case ZPOOL_WAIT_FREE:
	*in_progress = ((spa_version(spa) >= SPA_VERSION_DEADLISTS &&
	!bpobj_is_empty(&spa->spa_dsl_pool->dp_free_bpobj)) \|\|
	spa_feature_is_active(spa, SPA_FEATURE_ASYNC_DESTROY) \|\|
	spa_livelist_delete_check(spa));
	break;
	case ZPOOL_WAIT_INITIALIZE:
	case ZPOOL_WAIT_TRIM:
	error = spa_vdev_activity_in_progress(spa, use_tag, tag,
	activity, in_progress);
	break;
	case ZPOOL_WAIT_REPLACE:
	mutex_exit(&spa->spa_activities_lock);
	spa_config_enter(spa, SCL_CONFIG \| SCL_STATE, FTAG, RW_READER);
	mutex_enter(&spa->spa_activities_lock);

	*in_progress = vdev_replace_in_progress(spa->spa_root_vdev);
	spa_config_exit(spa, SCL_CONFIG \| SCL_STATE, FTAG);
	break;
	case ZPOOL_WAIT_REMOVE:
	*in_progress = (spa->spa_removing_phys.sr_state ==
	DSS_SCANNING);
	break;
	case ZPOOL_WAIT_RESILVER:
	if ((*in_progress = vdev_rebuild_active(spa->spa_root_vdev)))
	break;
	/* fall through */
	case ZPOOL_WAIT_SCRUB:
	{
	boolean_t scanning, paused, is_scrub;
	dsl_scan_t *scn = spa->spa_dsl_pool->dp_scan;

	is_scrub = (scn->scn_phys.scn_func == POOL_SCAN_SCRUB);
	scanning = (scn->scn_phys.scn_state == DSS_SCANNING);
	paused = dsl_scan_is_paused_scrub(scn);
	*in_progress = (scanning && !paused &&
	is_scrub == (activity == ZPOOL_WAIT_SCRUB));
	break;
	}
	default:
	panic("unrecognized value for activity %d", activity);
	}

	return (error);
	}

	static int
	spa_wait_common(const char *pool, zpool_wait_activity_t activity,
	boolean_t use_tag, uint64_t tag, boolean_t *waited)
	{
	/*
	* The tag is used to distinguish between instances of an activity.
	* 'initialize' and 'trim' are the only activities that we use this for.
	* The other activities can only have a single instance in progress in a
	* pool at one time, making the tag unnecessary.
	*
	* There can be multiple devices being replaced at once, but since they
	* all finish once resilvering finishes, we don't bother keeping track
	* of them individually, we just wait for them all to finish.
	*/
	if (use_tag && activity != ZPOOL_WAIT_INITIALIZE &&
	activity != ZPOOL_WAIT_TRIM)
	return (EINVAL);

	if (activity < 0 \|\| activity >= ZPOOL_WAIT_NUM_ACTIVITIES)
	return (EINVAL);

	spa_t *spa;
	int error = spa_open(pool, &spa, FTAG);
	if (error != 0)
	return (error);

	/*
	* Increment the spa's waiter count so that we can call spa_close and
	* still ensure that the spa_t doesn't get freed before this thread is
	* finished with it when the pool is exported. We want to call spa_close
	* before we start waiting because otherwise the additional ref would
	* prevent the pool from being exported or destroyed throughout the
	* potentially long wait.
	*/
	mutex_enter(&spa->spa_activities_lock);
	spa->spa_waiters++;
	spa_close(spa, FTAG);

	*waited = B_FALSE;
	for (;;) {
	boolean_t in_progress;
	error = spa_activity_in_progress(spa, activity, use_tag, tag,
	&in_progress);

	if (error \|\| !in_progress \|\| spa->spa_waiters_cancel)
	break;

	*waited = B_TRUE;

	if (cv_wait_sig(&spa->spa_activities_cv,
	&spa->spa_activities_lock) == 0) {
	error = EINTR;
	break;
	}
	}

	spa->spa_waiters--;
	cv_signal(&spa->spa_waiters_cv);
	mutex_exit(&spa->spa_activities_lock);

	return (error);
	}

	/*
	* Wait for a particular instance of the specified activity to complete, where
	* the instance is identified by 'tag'
	*/
	int
	spa_wait_tag(const char *pool, zpool_wait_activity_t activity, uint64_t tag,
	boolean_t *waited)
	{
	return (spa_wait_common(pool, activity, B_TRUE, tag, waited));
	}

	/*
	* Wait for all instances of the specified activity complete
	*/
	int
	spa_wait(const char pool, zpool_wait_activity_t activity, boolean_t waited)
	{

	return (spa_wait_common(pool, activity, B_FALSE, 0, waited));
	}

	sysevent_t *
	spa_event_create(spa_t spa, vdev_t vd, nvlist_t hist_nvl, const char name)
	{
	sysevent_t *ev = NULL;
	#ifdef _KERNEL
	nvlist_t *resource;

	resource = zfs_event_create(spa, vd, FM_SYSEVENT_CLASS, name, hist_nvl);
	if (resource) {
	ev = kmem_alloc(sizeof (sysevent_t), KM_SLEEP);
	ev->resource = resource;
	}
	#endif
	return (ev);
	}

	void
	spa_event_post(sysevent_t *ev)
	{
	#ifdef _KERNEL
	if (ev) {
	zfs_zevent_post(ev->resource, NULL, zfs_zevent_post_cb);
	kmem_free(ev, sizeof (*ev));
	}
	#endif
	}

	/*
	* Post a zevent corresponding to the given sysevent. The 'name' must be one
	* of the event definitions in sys/sysevent/eventdefs.h. The payload will be
	* filled in from the spa and (optionally) the vdev. This doesn't do anything
	* in the userland libzpool, as we don't want consumers to misinterpret ztest
	* or zdb as real changes.
	*/
	void
	spa_event_notify(spa_t spa, vdev_t vd, nvlist_t hist_nvl, const char name)
	{
	spa_event_post(spa_event_create(spa, vd, hist_nvl, name));
	}

	/* state manipulation functions */
	EXPORT_SYMBOL(spa_open);
	EXPORT_SYMBOL(spa_open_rewind);
	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);
	EXPORT_SYMBOL(spa_scan_stat_init);
	EXPORT_SYMBOL(spa_scan_get_stats);

	/* device manipulation */
	EXPORT_SYMBOL(spa_vdev_add);
	EXPORT_SYMBOL(spa_vdev_attach);
	EXPORT_SYMBOL(spa_vdev_detach);
	EXPORT_SYMBOL(spa_vdev_setpath);
	EXPORT_SYMBOL(spa_vdev_setfru);
	EXPORT_SYMBOL(spa_vdev_split_mirror);

	/* 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);

	/* scanning */
	EXPORT_SYMBOL(spa_scan);
	EXPORT_SYMBOL(spa_scan_stop);

	/* 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);

	/* asynchronous event notification */
	EXPORT_SYMBOL(spa_event_notify);

	/* BEGIN CSTYLED */
	ZFS_MODULE_PARAM(zfs_spa, spa_, load_verify_shift, INT, ZMOD_RW,
	- "log2(fraction of arc that can be used by inflight I/Os when "
	+ "log2 fraction of arc that can be used by inflight I/Os when "
	"verifying pool during import");

	ZFS_MODULE_PARAM(zfs_spa, spa_, load_verify_metadata, INT, ZMOD_RW,
	"Set to traverse metadata on pool import");

	ZFS_MODULE_PARAM(zfs_spa, spa_, load_verify_data, INT, ZMOD_RW,
	"Set to traverse data on pool import");

	ZFS_MODULE_PARAM(zfs_spa, spa_, load_print_vdev_tree, INT, ZMOD_RW,
	"Print vdev tree to zfs_dbgmsg during pool import");

	ZFS_MODULE_PARAM(zfs_zio, zio_, taskq_batch_pct, UINT, ZMOD_RD,
	"Percentage of CPUs to run an IO worker thread");

	+ZFS_MODULE_PARAM(zfs_zio, zio_, taskq_batch_tpq, UINT, ZMOD_RD,
	+ "Number of threads per IO worker taskqueue");
	+
	ZFS_MODULE_PARAM(zfs, zfs_, max_missing_tvds, ULONG, ZMOD_RW,
	"Allow importing pool with up to this number of missing top-level "
	"vdevs (in read-only mode)");

	ZFS_MODULE_PARAM(zfs_livelist_condense, zfs_livelist_condense_, zthr_pause, INT, ZMOD_RW,
	"Set the livelist condense zthr to pause");

	ZFS_MODULE_PARAM(zfs_livelist_condense, zfs_livelist_condense_, sync_pause, INT, ZMOD_RW,
	"Set the livelist condense synctask to pause");

	ZFS_MODULE_PARAM(zfs_livelist_condense, zfs_livelist_condense_, sync_cancel, INT, ZMOD_RW,
	"Whether livelist condensing was canceled in the synctask");

	ZFS_MODULE_PARAM(zfs_livelist_condense, zfs_livelist_condense_, zthr_cancel, INT, ZMOD_RW,
	"Whether livelist condensing was canceled in the zthr function");

	ZFS_MODULE_PARAM(zfs_livelist_condense, zfs_livelist_condense_, new_alloc, INT, ZMOD_RW,
	"Whether extra ALLOC blkptrs were added to a livelist entry while it "
	"was being condensed");
	/* END CSTYLED */
	diff --git a/sys/contrib/openzfs/module/zfs/spa_log_spacemap.c b/sys/contrib/openzfs/module/zfs/spa_log_spacemap.c
	index 5c55d32ec066..f4c2910ad7fe 100644
	--- a/sys/contrib/openzfs/module/zfs/spa_log_spacemap.c
	+++ b/sys/contrib/openzfs/module/zfs/spa_log_spacemap.c
	@@ -1,1322 +1,1322 @@
	/*
	* 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) 2018, 2019 by Delphix. All rights reserved.
	*/

	#include <sys/dmu_objset.h>
	#include <sys/metaslab.h>
	#include <sys/metaslab_impl.h>
	#include <sys/spa.h>
	#include <sys/spa_impl.h>
	#include <sys/spa_log_spacemap.h>
	#include <sys/vdev_impl.h>
	#include <sys/zap.h>

	/*
	* Log Space Maps
	*
	* Log space maps are an optimization in ZFS metadata allocations for pools
	* whose workloads are primarily random-writes. Random-write workloads are also
	* typically random-free, meaning that they are freeing from locations scattered
	* throughout the pool. This means that each TXG we will have to append some
	* FREE records to almost every metaslab. With log space maps, we hold their
	* changes in memory and log them altogether in one pool-wide space map on-disk
	* for persistence. As more blocks are accumulated in the log space maps and
	* more unflushed changes are accounted in memory, we flush a selected group
	* of metaslabs every TXG to relieve memory pressure and potential overheads
	* when loading the pool. Flushing a metaslab to disk relieves memory as we
	* flush any unflushed changes from memory to disk (i.e. the metaslab's space
	* map) and saves import time by making old log space maps obsolete and
	* eventually destroying them. [A log space map is said to be obsolete when all
	* its entries have made it to their corresponding metaslab space maps].
	*
	* == On disk data structures used ==
	*
	* - The pool has a new feature flag and a new entry in the MOS. The feature
	* is activated when we create the first log space map and remains active
	* for the lifetime of the pool. The new entry in the MOS Directory [refer
	* to DMU_POOL_LOG_SPACEMAP_ZAP] is populated with a ZAP whose key-value
	* pairs are of the form <key: txg, value: log space map object for that txg>.
	* This entry is our on-disk reference of the log space maps that exist in
	* the pool for each TXG and it is used during import to load all the
	* metaslab unflushed changes in memory. To see how this structure is first
	* created and later populated refer to spa_generate_syncing_log_sm(). To see
	* how it is used during import time refer to spa_ld_log_sm_metadata().
	*
	* - Each vdev has a new entry in its vdev_top_zap (see field
	* VDEV_TOP_ZAP_MS_UNFLUSHED_PHYS_TXGS) which holds the msp_unflushed_txg of
	* each metaslab in this vdev. This field is the on-disk counterpart of the
	* in-memory field ms_unflushed_txg which tells us from which TXG and onwards
	* the metaslab haven't had its changes flushed. During import, we use this
	* to ignore any entries in the space map log that are for this metaslab but
	* from a TXG before msp_unflushed_txg. At that point, we also populate its
	* in-memory counterpart and from there both fields are updated every time
	* we flush that metaslab.
	*
	* - A space map is created every TXG and, during that TXG, it is used to log
	* all incoming changes (the log space map). When created, the log space map
	* is referenced in memory by spa_syncing_log_sm and its object ID is inserted
	* to the space map ZAP mentioned above. The log space map is closed at the
	* end of the TXG and will be destroyed when it becomes fully obsolete. We
	* know when a log space map has become obsolete by looking at the oldest
	* (and smallest) ms_unflushed_txg in the pool. If the value of that is bigger
	* than the log space map's TXG, then it means that there is no metaslab who
	* doesn't have the changes from that log and we can therefore destroy it.
	* [see spa_cleanup_old_sm_logs()].
	*
	* == Important in-memory structures ==
	*
	* - The per-spa field spa_metaslabs_by_flushed sorts all the metaslabs in
	* the pool by their ms_unflushed_txg field. It is primarily used for three
	* reasons. First of all, it is used during flushing where we try to flush
	* metaslabs in-order from the oldest-flushed to the most recently flushed
	* every TXG. Secondly, it helps us to lookup the ms_unflushed_txg of the
	* oldest flushed metaslab to distinguish which log space maps have become
	* obsolete and which ones are still relevant. Finally it tells us which
	* metaslabs have unflushed changes in a pool where this feature was just
	* enabled, as we don't immediately add all of the pool's metaslabs but we
	* add them over time as they go through metaslab_sync(). The reason that
	* we do that is to ease these pools into the behavior of the flushing
	* algorithm (described later on).
	*
	* - The per-spa field spa_sm_logs_by_txg can be thought as the in-memory
	* counterpart of the space map ZAP mentioned above. It's an AVL tree whose
	* nodes represent the log space maps in the pool. This in-memory
	* representation of log space maps in the pool sorts the log space maps by
	* the TXG that they were created (which is also the TXG of their unflushed
	* changes). It also contains the following extra information for each
	* space map:
	* [1] The number of metaslabs that were last flushed on that TXG. This is
	* important because if that counter is zero and this is the oldest
	* log then it means that it is also obsolete.
	* [2] The number of blocks of that space map. This field is used by the
	* block heuristic of our flushing algorithm (described later on).
	* It represents how many blocks of metadata changes ZFS had to write
	* to disk for that TXG.
	*
	* - The per-spa field spa_log_summary is a list of entries that summarizes
	* the metaslab and block counts of all the nodes of the spa_sm_logs_by_txg
	* AVL tree mentioned above. The reason this exists is that our flushing
	* algorithm (described later) tries to estimate how many metaslabs to flush
	* in each TXG by iterating over all the log space maps and looking at their
	* block counts. Summarizing that information means that don't have to
	* iterate through each space map, minimizing the runtime overhead of the
	* flushing algorithm which would be induced in syncing context. In terms of
	* implementation the log summary is used as a queue:
	* * we modify or pop entries from its head when we flush metaslabs
	* * we modify or append entries to its tail when we sync changes.
	*
	* - Each metaslab has two new range trees that hold its unflushed changes,
	* ms_unflushed_allocs and ms_unflushed_frees. These are always disjoint.
	*
	* == Flushing algorithm ==
	*
	* The decision of how many metaslabs to flush on a give TXG is guided by
	* two heuristics:
	*
	* [1] The memory heuristic -
	* We keep track of the memory used by the unflushed trees from all the
	* metaslabs [see sus_memused of spa_unflushed_stats] and we ensure that it
	* stays below a certain threshold which is determined by an arbitrary hard
	* limit and an arbitrary percentage of the system's memory [see
	* spa_log_exceeds_memlimit()]. When we see that the memory usage of the
	* unflushed changes are passing that threshold, we flush metaslabs, which
	* empties their unflushed range trees, reducing the memory used.
	*
	* [2] The block heuristic -
	* We try to keep the total number of blocks in the log space maps in check
	* so the log doesn't grow indefinitely and we don't induce a lot of overhead
	* when loading the pool. At the same time we don't want to flush a lot of
	* metaslabs too often as this would defeat the purpose of the log space map.
	* As a result we set a limit in the amount of blocks that we think it's
	* acceptable for the log space maps to have and try not to cross it.
	* [see sus_blocklimit from spa_unflushed_stats].
	*
	* In order to stay below the block limit every TXG we have to estimate how
	* many metaslabs we need to flush based on the current rate of incoming blocks
	* and our history of log space map blocks. The main idea here is to answer
	* the question of how many metaslabs do we need to flush in order to get rid
	* at least an X amount of log space map blocks. We can answer this question
	* by iterating backwards from the oldest log space map to the newest one
	* and looking at their metaslab and block counts. At this point the log summary
	* mentioned above comes handy as it reduces the amount of things that we have
	* to iterate (even though it may reduce the preciseness of our estimates due
	* to its aggregation of data). So with that in mind, we project the incoming
	* rate of the current TXG into the future and attempt to approximate how many
	* metaslabs would we need to flush from now in order to avoid exceeding our
	* block limit in different points in the future (granted that we would keep
	* flushing the same number of metaslabs for every TXG). Then we take the
	* maximum number from all these estimates to be on the safe side. For the
	* exact implementation details of algorithm refer to
	* spa_estimate_metaslabs_to_flush.
	*/

	/*
	* This is used as the block size for the space maps used for the
	* log space map feature. These space maps benefit from a bigger
	* block size as we expect to be writing a lot of data to them at
	* once.
	*/
	unsigned long zfs_log_sm_blksz = 1ULL << 17;

	/*
	* Percentage of the overall system's memory that ZFS allows to be
	* used for unflushed changes (e.g. the sum of size of all the nodes
	* in the unflushed trees).
	*
	* Note that this value is calculated over 1000000 for finer granularity
	* (thus the _ppm suffix; reads as "parts per million"). As an example,
	* the default of 1000 allows 0.1% of memory to be used.
	*/
	unsigned long zfs_unflushed_max_mem_ppm = 1000;

	/*
	* Specific hard-limit in memory that ZFS allows to be used for
	* unflushed changes.
	*/
	unsigned long zfs_unflushed_max_mem_amt = 1ULL << 30;

	/*
	* The following tunable determines the number of blocks that can be used for
	* the log space maps. It is expressed as a percentage of the total number of
	* metaslabs in the pool (i.e. the default of 400 means that the number of log
	* blocks is capped at 4 times the number of metaslabs).
	*
	* This value exists to tune our flushing algorithm, with higher values
	* flushing metaslabs less often (doing less I/Os) per TXG versus lower values
	* flushing metaslabs more aggressively with the upside of saving overheads
	* when loading the pool. Another factor in this tradeoff is that flushing
	* less often can potentially lead to better utilization of the metaslab space
	* map's block size as we accumulate more changes per flush.
	*
	* Given that this tunable indirectly controls the flush rate (metaslabs
	* flushed per txg) and that's why making it a percentage in terms of the
	* number of metaslabs in the pool makes sense here.
	*
	* As a rule of thumb we default this tunable to 400% based on the following:
	*
	* 1] Assuming a constant flush rate and a constant incoming rate of log blocks
	* it is reasonable to expect that the amount of obsolete entries changes
	* linearly from txg to txg (e.g. the oldest log should have the most
	* obsolete entries, and the most recent one the least). With this we could
	* say that, at any given time, about half of the entries in the whole space
	* map log are obsolete. Thus for every two entries for a metaslab in the
	* log space map, only one of them is valid and actually makes it to the
	* metaslab's space map.
	* [factor of 2]
	* 2] Each entry in the log space map is guaranteed to be two words while
	* entries in metaslab space maps are generally single-word.
	* [an extra factor of 2 - 400% overall]
	* 3] Even if [1] and [2] are slightly less than 2 each, we haven't taken into
	* account any consolidation of segments from the log space map to the
	* unflushed range trees nor their history (e.g. a segment being allocated,
	* then freed, then allocated again means 3 log space map entries but 0
	* metaslab space map entries). Depending on the workload, we've seen ~1.8
	* non-obsolete log space map entries per metaslab entry, for a total of
	* ~600%. Since most of these estimates though are workload dependent, we
	* default on 400% to be conservative.
	*
	* Thus we could say that even in the worst
	* case of [1] and [2], the factor should end up being 4.
	*
	* That said, regardless of the number of metaslabs in the pool we need to
	* provide upper and lower bounds for the log block limit.
	* [see zfs_unflushed_log_block_{min,max}]
	*/
	unsigned long zfs_unflushed_log_block_pct = 400;

	/*
	* If the number of metaslabs is small and our incoming rate is high, we could
	* get into a situation that we are flushing all our metaslabs every TXG. Thus
	* we always allow at least this many log blocks.
	*/
	unsigned long zfs_unflushed_log_block_min = 1000;

	/*
	* If the log becomes too big, the import time of the pool can take a hit in
	* terms of performance. Thus we have a hard limit in the size of the log in
	* terms of blocks.
	*/
	unsigned long zfs_unflushed_log_block_max = (1ULL << 18);

	/*
	* Max # of rows allowed for the log_summary. The tradeoff here is accuracy and
	* stability of the flushing algorithm (longer summary) vs its runtime overhead
	* (smaller summary is faster to traverse).
	*/
	unsigned long zfs_max_logsm_summary_length = 10;

	/*
	* Tunable that sets the lower bound on the metaslabs to flush every TXG.
	*
	* Setting this to 0 has no effect since if the pool is idle we won't even be
	* creating log space maps and therefore we won't be flushing. On the other
	* hand if the pool has any incoming workload our block heuristic will start
	* flushing metaslabs anyway.
	*
	* The point of this tunable is to be used in extreme cases where we really
	* want to flush more metaslabs than our adaptable heuristic plans to flush.
	*/
	unsigned long zfs_min_metaslabs_to_flush = 1;

	/*
	* Tunable that specifies how far in the past do we want to look when trying to
	* estimate the incoming log blocks for the current TXG.
	*
	* Setting this too high may not only increase runtime but also minimize the
	* effect of the incoming rates from the most recent TXGs as we take the
	* average over all the blocks that we walk
	* [see spa_estimate_incoming_log_blocks].
	*/
	unsigned long zfs_max_log_walking = 5;

	/*
	* This tunable exists solely for testing purposes. It ensures that the log
	* spacemaps are not flushed and destroyed during export in order for the
	* relevant log spacemap import code paths to be tested (effectively simulating
	* a crash).
	*/
	int zfs_keep_log_spacemaps_at_export = 0;

	static uint64_t
	spa_estimate_incoming_log_blocks(spa_t *spa)
	{
	ASSERT3U(spa_sync_pass(spa), ==, 1);
	uint64_t steps = 0, sum = 0;
	for (spa_log_sm_t *sls = avl_last(&spa->spa_sm_logs_by_txg);
	sls != NULL && steps < zfs_max_log_walking;
	sls = AVL_PREV(&spa->spa_sm_logs_by_txg, sls)) {
	if (sls->sls_txg == spa_syncing_txg(spa)) {
	/*
	* skip the log created in this TXG as this would
	* make our estimations inaccurate.
	*/
	continue;
	}
	sum += sls->sls_nblocks;
	steps++;
	}
	return ((steps > 0) ? DIV_ROUND_UP(sum, steps) : 0);
	}

	uint64_t
	spa_log_sm_blocklimit(spa_t *spa)
	{
	return (spa->spa_unflushed_stats.sus_blocklimit);
	}

	void
	spa_log_sm_set_blocklimit(spa_t *spa)
	{
	if (!spa_feature_is_active(spa, SPA_FEATURE_LOG_SPACEMAP)) {
	ASSERT0(spa_log_sm_blocklimit(spa));
	return;
	}

	uint64_t calculated_limit =
	(spa_total_metaslabs(spa) * zfs_unflushed_log_block_pct) / 100;
	spa->spa_unflushed_stats.sus_blocklimit = MIN(MAX(calculated_limit,
	zfs_unflushed_log_block_min), zfs_unflushed_log_block_max);
	}

	uint64_t
	spa_log_sm_nblocks(spa_t *spa)
	{
	return (spa->spa_unflushed_stats.sus_nblocks);
	}

	/*
	* Ensure that the in-memory log space map structures and the summary
	* have the same block and metaslab counts.
	*/
	static void
	spa_log_summary_verify_counts(spa_t *spa)
	{
	ASSERT(spa_feature_is_active(spa, SPA_FEATURE_LOG_SPACEMAP));

	if ((zfs_flags & ZFS_DEBUG_LOG_SPACEMAP) == 0)
	return;

	uint64_t ms_in_avl = avl_numnodes(&spa->spa_metaslabs_by_flushed);

	uint64_t ms_in_summary = 0, blk_in_summary = 0;
	for (log_summary_entry_t *e = list_head(&spa->spa_log_summary);
	e; e = list_next(&spa->spa_log_summary, e)) {
	ms_in_summary += e->lse_mscount;
	blk_in_summary += e->lse_blkcount;
	}

	uint64_t ms_in_logs = 0, blk_in_logs = 0;
	for (spa_log_sm_t *sls = avl_first(&spa->spa_sm_logs_by_txg);
	sls; sls = AVL_NEXT(&spa->spa_sm_logs_by_txg, sls)) {
	ms_in_logs += sls->sls_mscount;
	blk_in_logs += sls->sls_nblocks;
	}

	VERIFY3U(ms_in_logs, ==, ms_in_summary);
	VERIFY3U(ms_in_logs, ==, ms_in_avl);
	VERIFY3U(blk_in_logs, ==, blk_in_summary);
	VERIFY3U(blk_in_logs, ==, spa_log_sm_nblocks(spa));
	}

	static boolean_t
	summary_entry_is_full(spa_t spa, log_summary_entry_t e)
	{
	uint64_t blocks_per_row = MAX(1,
	DIV_ROUND_UP(spa_log_sm_blocklimit(spa),
	zfs_max_logsm_summary_length));
	return (blocks_per_row <= e->lse_blkcount);
	}

	/*
	* Update the log summary information to reflect the fact that a metaslab
	* was flushed or destroyed (e.g due to device removal or pool export/destroy).
	*
	* We typically flush the oldest flushed metaslab so the first (and oldest)
	* entry of the summary is updated. However if that metaslab is getting loaded
	* we may flush the second oldest one which may be part of an entry later in
	* the summary. Moreover, if we call into this function from metaslab_fini()
	* the metaslabs probably won't be ordered by ms_unflushed_txg. Thus we ask
	* for a txg as an argument so we can locate the appropriate summary entry for
	* the metaslab.
	*/
	void
	spa_log_summary_decrement_mscount(spa_t *spa, uint64_t txg)
	{
	/*
	* We don't track summary data for read-only pools and this function
	* can be called from metaslab_fini(). In that case return immediately.
	*/
	if (!spa_writeable(spa))
	return;

	log_summary_entry_t *target = NULL;
	for (log_summary_entry_t *e = list_head(&spa->spa_log_summary);
	e != NULL; e = list_next(&spa->spa_log_summary, e)) {
	if (e->lse_start > txg)
	break;
	target = e;
	}

	if (target == NULL \|\| target->lse_mscount == 0) {
	/*
	* We didn't find a summary entry for this metaslab. We must be
	* at the teardown of a spa_load() attempt that got an error
	* while reading the log space maps.
	*/
	VERIFY3S(spa_load_state(spa), ==, SPA_LOAD_ERROR);
	return;
	}

	target->lse_mscount--;
	}

	/*
	* Update the log summary information to reflect the fact that we destroyed
	* old log space maps. Since we can only destroy the oldest log space maps,
	* we decrement the block count of the oldest summary entry and potentially
	* destroy it when that count hits 0.
	*
	* This function is called after a metaslab is flushed and typically that
	* metaslab is the oldest flushed, which means that this function will
	* typically decrement the block count of the first entry of the summary and
	* potentially free it if the block count gets to zero (its metaslab count
	* should be zero too at that point).
	*
	* There are certain scenarios though that don't work exactly like that so we
	* need to account for them:
	*
	* Scenario [1]: It is possible that after we flushed the oldest flushed
	* metaslab and we destroyed the oldest log space map, more recent logs had 0
	* metaslabs pointing to them so we got rid of them too. This can happen due
	* to metaslabs being destroyed through device removal, or because the oldest
	* flushed metaslab was loading but we kept flushing more recently flushed
	* metaslabs due to the memory pressure of unflushed changes. Because of that,
	* we always iterate from the beginning of the summary and if blocks_gone is
	* bigger than the block_count of the current entry we free that entry (we
	* expect its metaslab count to be zero), we decrement blocks_gone and on to
	* the next entry repeating this procedure until blocks_gone gets decremented
	* to 0. Doing this also works for the typical case mentioned above.
	*
	* Scenario [2]: The oldest flushed metaslab isn't necessarily accounted by
	* the first (and oldest) entry in the summary. If the first few entries of
	* the summary were only accounting metaslabs from a device that was just
	* removed, then the current oldest flushed metaslab could be accounted by an
	* entry somewhere in the middle of the summary. Moreover flushing that
	* metaslab will destroy all the log space maps older than its ms_unflushed_txg
	* because they became obsolete after the removal. Thus, iterating as we did
	* for scenario [1] works out for this case too.
	*
	* Scenario [3]: At times we decide to flush all the metaslabs in the pool
	* in one TXG (either because we are exporting the pool or because our flushing
	* heuristics decided to do so). When that happens all the log space maps get
	* destroyed except the one created for the current TXG which doesn't have
	* any log blocks yet. As log space maps get destroyed with every metaslab that
	* we flush, entries in the summary are also destroyed. This brings a weird
	* corner-case when we flush the last metaslab and the log space map of the
	* current TXG is in the same summary entry with other log space maps that
	* are older. When that happens we are eventually left with this one last
	* summary entry whose blocks are gone (blocks_gone equals the entry's block
	* count) but its metaslab count is non-zero (because it accounts all the
	* metaslabs in the pool as they all got flushed). Under this scenario we can't
	* free this last summary entry as it's referencing all the metaslabs in the
	* pool and its block count will get incremented at the end of this sync (when
	* we close the syncing log space map). Thus we just decrement its current
	* block count and leave it alone. In the case that the pool gets exported,
	* its metaslab count will be decremented over time as we call metaslab_fini()
	* for all the metaslabs in the pool and the entry will be freed at
	* spa_unload_log_sm_metadata().
	*/
	void
	spa_log_summary_decrement_blkcount(spa_t *spa, uint64_t blocks_gone)
	{
	for (log_summary_entry_t *e = list_head(&spa->spa_log_summary);
	e != NULL; e = list_head(&spa->spa_log_summary)) {
	if (e->lse_blkcount > blocks_gone) {
	/*
	* Assert that we stopped at an entry that is not
	* obsolete.
	*/
	ASSERT(e->lse_mscount != 0);

	e->lse_blkcount -= blocks_gone;
	blocks_gone = 0;
	break;
	} else if (e->lse_mscount == 0) {
	/* remove obsolete entry */
	blocks_gone -= e->lse_blkcount;
	list_remove(&spa->spa_log_summary, e);
	kmem_free(e, sizeof (log_summary_entry_t));
	} else {
	/* Verify that this is scenario [3] mentioned above. */
	VERIFY3U(blocks_gone, ==, e->lse_blkcount);

	/*
	* Assert that this is scenario [3] further by ensuring
	* that this is the only entry in the summary.
	*/
	VERIFY3P(e, ==, list_tail(&spa->spa_log_summary));
	ASSERT3P(e, ==, list_head(&spa->spa_log_summary));

	blocks_gone = e->lse_blkcount = 0;
	break;
	}
	}

	/*
	* Ensure that there is no way we are trying to remove more blocks
	* than the # of blocks in the summary.
	*/
	ASSERT0(blocks_gone);
	}

	void
	spa_log_sm_decrement_mscount(spa_t *spa, uint64_t txg)
	{
	spa_log_sm_t target = { .sls_txg = txg };
	spa_log_sm_t *sls = avl_find(&spa->spa_sm_logs_by_txg,
	&target, NULL);

	if (sls == NULL) {
	/*
	* We must be at the teardown of a spa_load() attempt that
	* got an error while reading the log space maps.
	*/
	VERIFY3S(spa_load_state(spa), ==, SPA_LOAD_ERROR);
	return;
	}

	ASSERT(sls->sls_mscount > 0);
	sls->sls_mscount--;
	}

	void
	spa_log_sm_increment_current_mscount(spa_t *spa)
	{
	spa_log_sm_t *last_sls = avl_last(&spa->spa_sm_logs_by_txg);
	ASSERT3U(last_sls->sls_txg, ==, spa_syncing_txg(spa));
	last_sls->sls_mscount++;
	}

	static void
	summary_add_data(spa_t *spa, uint64_t txg, uint64_t metaslabs_flushed,
	uint64_t nblocks)
	{
	log_summary_entry_t *e = list_tail(&spa->spa_log_summary);

	if (e == NULL \|\| summary_entry_is_full(spa, e)) {
	e = kmem_zalloc(sizeof (log_summary_entry_t), KM_SLEEP);
	e->lse_start = txg;
	list_insert_tail(&spa->spa_log_summary, e);
	}

	ASSERT3U(e->lse_start, <=, txg);
	e->lse_mscount += metaslabs_flushed;
	e->lse_blkcount += nblocks;
	}

	static void
	spa_log_summary_add_incoming_blocks(spa_t *spa, uint64_t nblocks)
	{
	summary_add_data(spa, spa_syncing_txg(spa), 0, nblocks);
	}

	void
	spa_log_summary_add_flushed_metaslab(spa_t *spa)
	{
	summary_add_data(spa, spa_syncing_txg(spa), 1, 0);
	}

	/*
	* This function attempts to estimate how many metaslabs should
	* we flush to satisfy our block heuristic for the log spacemap
	* for the upcoming TXGs.
	*
	* Specifically, it first tries to estimate the number of incoming
	* blocks in this TXG. Then by projecting that incoming rate to
	* future TXGs and using the log summary, it figures out how many
	* flushes we would need to do for future TXGs individually to
	* stay below our block limit and returns the maximum number of
	* flushes from those estimates.
	*/
	static uint64_t
	spa_estimate_metaslabs_to_flush(spa_t *spa)
	{
	ASSERT(spa_feature_is_active(spa, SPA_FEATURE_LOG_SPACEMAP));
	ASSERT3U(spa_sync_pass(spa), ==, 1);
	ASSERT(spa_log_sm_blocklimit(spa) != 0);

	/*
	* This variable contains the incoming rate that will be projected
	* and used for our flushing estimates in the future.
	*/
	uint64_t incoming = spa_estimate_incoming_log_blocks(spa);

	/*
	* At any point in time this variable tells us how many
	* TXGs in the future we are so we can make our estimations.
	*/
	uint64_t txgs_in_future = 1;

	/*
	* This variable tells us how much room do we have until we hit
	* our limit. When it goes negative, it means that we've exceeded
	* our limit and we need to flush.
	*
	* Note that since we start at the first TXG in the future (i.e.
	* txgs_in_future starts from 1) we already decrement this
	* variable by the incoming rate.
	*/
	int64_t available_blocks =
	spa_log_sm_blocklimit(spa) - spa_log_sm_nblocks(spa) - incoming;

	/*
	* This variable tells us the total number of flushes needed to
	* keep the log size within the limit when we reach txgs_in_future.
	*/
	uint64_t total_flushes = 0;

	/* Holds the current maximum of our estimates so far. */
	uint64_t max_flushes_pertxg =
	MIN(avl_numnodes(&spa->spa_metaslabs_by_flushed),
	zfs_min_metaslabs_to_flush);

	/*
	* For our estimations we only look as far in the future
	* as the summary allows us.
	*/
	for (log_summary_entry_t *e = list_head(&spa->spa_log_summary);
	e; e = list_next(&spa->spa_log_summary, e)) {

	/*
	* If there is still room before we exceed our limit
	* then keep skipping TXGs accumulating more blocks
	* based on the incoming rate until we exceed it.
	*/
	if (available_blocks >= 0) {
	uint64_t skip_txgs = (available_blocks / incoming) + 1;
	available_blocks -= (skip_txgs * incoming);
	txgs_in_future += skip_txgs;
	ASSERT3S(available_blocks, >=, -incoming);
	}

	/*
	* At this point we're far enough into the future where
	* the limit was just exceeded and we flush metaslabs
	* based on the current entry in the summary, updating
	* our available_blocks.
	*/
	ASSERT3S(available_blocks, <, 0);
	available_blocks += e->lse_blkcount;
	total_flushes += e->lse_mscount;

	/*
	* Keep the running maximum of the total_flushes that
	* we've done so far over the number of TXGs in the
	* future that we are. The idea here is to estimate
	* the average number of flushes that we should do
	* every TXG so that when we are that many TXGs in the
	* future we stay under the limit.
	*/
	max_flushes_pertxg = MAX(max_flushes_pertxg,
	DIV_ROUND_UP(total_flushes, txgs_in_future));
	ASSERT3U(avl_numnodes(&spa->spa_metaslabs_by_flushed), >=,
	max_flushes_pertxg);
	}
	return (max_flushes_pertxg);
	}

	uint64_t
	spa_log_sm_memused(spa_t *spa)
	{
	return (spa->spa_unflushed_stats.sus_memused);
	}

	static boolean_t
	spa_log_exceeds_memlimit(spa_t *spa)
	{
	if (spa_log_sm_memused(spa) > zfs_unflushed_max_mem_amt)
	return (B_TRUE);

	uint64_t system_mem_allowed = ((physmem * PAGESIZE) *
	zfs_unflushed_max_mem_ppm) / 1000000;
	if (spa_log_sm_memused(spa) > system_mem_allowed)
	return (B_TRUE);

	return (B_FALSE);
	}

	boolean_t
	spa_flush_all_logs_requested(spa_t *spa)
	{
	return (spa->spa_log_flushall_txg != 0);
	}

	void
	spa_flush_metaslabs(spa_t spa, dmu_tx_t tx)
	{
	uint64_t txg = dmu_tx_get_txg(tx);

	if (spa_sync_pass(spa) != 1)
	return;

	if (!spa_feature_is_active(spa, SPA_FEATURE_LOG_SPACEMAP))
	return;

	/*
	* If we don't have any metaslabs with unflushed changes
	* return immediately.
	*/
	if (avl_numnodes(&spa->spa_metaslabs_by_flushed) == 0)
	return;

	/*
	* During SPA export we leave a few empty TXGs to go by [see
	* spa_final_dirty_txg() to understand why]. For this specific
	* case, it is important to not flush any metaslabs as that
	* would dirty this TXG.
	*
	* That said, during one of these dirty TXGs that is less or
	* equal to spa_final_dirty(), spa_unload() will request that
	* we try to flush all the metaslabs for that TXG before
	* exporting the pool, thus we ensure that we didn't get a
	* request of flushing everything before we attempt to return
	* immediately.
	*/
	if (spa->spa_uberblock.ub_rootbp.blk_birth < txg &&
	!dmu_objset_is_dirty(spa_meta_objset(spa), txg) &&
	!spa_flush_all_logs_requested(spa))
	return;

	/*
	* We need to generate a log space map before flushing because this
	* will set up the in-memory data (i.e. node in spa_sm_logs_by_txg)
	* for this TXG's flushed metaslab count (aka sls_mscount which is
	* manipulated in many ways down the metaslab_flush() codepath).
	*
	* That is not to say that we may generate a log space map when we
	* don't need it. If we are flushing metaslabs, that means that we
	* were going to write changes to disk anyway, so even if we were
	* not flushing, a log space map would have been created anyway in
	* metaslab_sync().
	*/
	spa_generate_syncing_log_sm(spa, tx);

	/*
	* This variable tells us how many metaslabs we want to flush based
	* on the block-heuristic of our flushing algorithm (see block comment
	* of log space map feature). We also decrement this as we flush
	* metaslabs and attempt to destroy old log space maps.
	*/
	uint64_t want_to_flush;
	if (spa_flush_all_logs_requested(spa)) {
	ASSERT3S(spa_state(spa), ==, POOL_STATE_EXPORTED);
	want_to_flush = avl_numnodes(&spa->spa_metaslabs_by_flushed);
	} else {
	want_to_flush = spa_estimate_metaslabs_to_flush(spa);
	}

	ASSERT3U(avl_numnodes(&spa->spa_metaslabs_by_flushed), >=,
	want_to_flush);

	/* Used purely for verification purposes */
	uint64_t visited = 0;

	/*
	* Ideally we would only iterate through spa_metaslabs_by_flushed
	* using only one variable (curr). We can't do that because
	* metaslab_flush() mutates position of curr in the AVL when
	* it flushes that metaslab by moving it to the end of the tree.
	* Thus we always keep track of the original next node of the
	* current node (curr) in another variable (next).
	*/
	metaslab_t *next = NULL;
	for (metaslab_t *curr = avl_first(&spa->spa_metaslabs_by_flushed);
	curr != NULL; curr = next) {
	next = AVL_NEXT(&spa->spa_metaslabs_by_flushed, curr);

	/*
	* If this metaslab has been flushed this txg then we've done
	* a full circle over the metaslabs.
	*/
	if (metaslab_unflushed_txg(curr) == txg)
	break;

	/*
	* If we are done flushing for the block heuristic and the
	* unflushed changes don't exceed the memory limit just stop.
	*/
	if (want_to_flush == 0 && !spa_log_exceeds_memlimit(spa))
	break;

	mutex_enter(&curr->ms_sync_lock);
	mutex_enter(&curr->ms_lock);
	boolean_t flushed = metaslab_flush(curr, tx);
	mutex_exit(&curr->ms_lock);
	mutex_exit(&curr->ms_sync_lock);

	/*
	* If we failed to flush a metaslab (because it was loading),
	* then we are done with the block heuristic as it's not
	* possible to destroy any log space maps once you've skipped
	* a metaslab. In that case we just set our counter to 0 but
	* we continue looping in case there is still memory pressure
	* due to unflushed changes. Note that, flushing a metaslab
	* that is not the oldest flushed in the pool, will never
	* destroy any log space maps [see spa_cleanup_old_sm_logs()].
	*/
	if (!flushed) {
	want_to_flush = 0;
	} else if (want_to_flush > 0) {
	want_to_flush--;
	}

	visited++;
	}
	ASSERT3U(avl_numnodes(&spa->spa_metaslabs_by_flushed), >=, visited);
	}

	/*
	* Close the log space map for this TXG and update the block counts
	* for the log's in-memory structure and the summary.
	*/
	void
	spa_sync_close_syncing_log_sm(spa_t *spa)
	{
	if (spa_syncing_log_sm(spa) == NULL)
	return;
	ASSERT(spa_feature_is_active(spa, SPA_FEATURE_LOG_SPACEMAP));

	spa_log_sm_t *sls = avl_last(&spa->spa_sm_logs_by_txg);
	ASSERT3U(sls->sls_txg, ==, spa_syncing_txg(spa));

	sls->sls_nblocks = space_map_nblocks(spa_syncing_log_sm(spa));
	spa->spa_unflushed_stats.sus_nblocks += sls->sls_nblocks;

	/*
	* Note that we can't assert that sls_mscount is not 0,
	* because there is the case where the first metaslab
	* in spa_metaslabs_by_flushed is loading and we were
	* not able to flush any metaslabs the current TXG.
	*/
	ASSERT(sls->sls_nblocks != 0);

	spa_log_summary_add_incoming_blocks(spa, sls->sls_nblocks);
	spa_log_summary_verify_counts(spa);

	space_map_close(spa->spa_syncing_log_sm);
	spa->spa_syncing_log_sm = NULL;

	/*
	* At this point we tried to flush as many metaslabs as we
	* can as the pool is getting exported. Reset the "flush all"
	* so the last few TXGs before closing the pool can be empty
	* (e.g. not dirty).
	*/
	if (spa_flush_all_logs_requested(spa)) {
	ASSERT3S(spa_state(spa), ==, POOL_STATE_EXPORTED);
	spa->spa_log_flushall_txg = 0;
	}
	}

	void
	spa_cleanup_old_sm_logs(spa_t spa, dmu_tx_t tx)
	{
	objset_t *mos = spa_meta_objset(spa);

	uint64_t spacemap_zap;
	int error = zap_lookup(mos, DMU_POOL_DIRECTORY_OBJECT,
	DMU_POOL_LOG_SPACEMAP_ZAP, sizeof (spacemap_zap), 1, &spacemap_zap);
	if (error == ENOENT) {
	ASSERT(avl_is_empty(&spa->spa_sm_logs_by_txg));
	return;
	}
	VERIFY0(error);

	metaslab_t *oldest = avl_first(&spa->spa_metaslabs_by_flushed);
	uint64_t oldest_flushed_txg = metaslab_unflushed_txg(oldest);

	/* Free all log space maps older than the oldest_flushed_txg. */
	for (spa_log_sm_t *sls = avl_first(&spa->spa_sm_logs_by_txg);
	sls && sls->sls_txg < oldest_flushed_txg;
	sls = avl_first(&spa->spa_sm_logs_by_txg)) {
	ASSERT0(sls->sls_mscount);
	avl_remove(&spa->spa_sm_logs_by_txg, sls);
	space_map_free_obj(mos, sls->sls_sm_obj, tx);
	VERIFY0(zap_remove_int(mos, spacemap_zap, sls->sls_txg, tx));
	spa->spa_unflushed_stats.sus_nblocks -= sls->sls_nblocks;
	kmem_free(sls, sizeof (spa_log_sm_t));
	}
	}

	static spa_log_sm_t *
	spa_log_sm_alloc(uint64_t sm_obj, uint64_t txg)
	{
	spa_log_sm_t sls = kmem_zalloc(sizeof (sls), KM_SLEEP);
	sls->sls_sm_obj = sm_obj;
	sls->sls_txg = txg;
	return (sls);
	}

	void
	spa_generate_syncing_log_sm(spa_t spa, dmu_tx_t tx)
	{
	uint64_t txg = dmu_tx_get_txg(tx);
	objset_t *mos = spa_meta_objset(spa);

	if (spa_syncing_log_sm(spa) != NULL)
	return;

	if (!spa_feature_is_enabled(spa, SPA_FEATURE_LOG_SPACEMAP))
	return;

	uint64_t spacemap_zap;
	int error = zap_lookup(mos, DMU_POOL_DIRECTORY_OBJECT,
	DMU_POOL_LOG_SPACEMAP_ZAP, sizeof (spacemap_zap), 1, &spacemap_zap);
	if (error == ENOENT) {
	ASSERT(avl_is_empty(&spa->spa_sm_logs_by_txg));

	error = 0;
	spacemap_zap = zap_create(mos,
	DMU_OTN_ZAP_METADATA, DMU_OT_NONE, 0, tx);
	VERIFY0(zap_add(mos, DMU_POOL_DIRECTORY_OBJECT,
	DMU_POOL_LOG_SPACEMAP_ZAP, sizeof (spacemap_zap), 1,
	&spacemap_zap, tx));
	spa_feature_incr(spa, SPA_FEATURE_LOG_SPACEMAP, tx);
	}
	VERIFY0(error);

	uint64_t sm_obj;
	ASSERT3U(zap_lookup_int_key(mos, spacemap_zap, txg, &sm_obj),
	==, ENOENT);
	sm_obj = space_map_alloc(mos, zfs_log_sm_blksz, tx);
	VERIFY0(zap_add_int_key(mos, spacemap_zap, txg, sm_obj, tx));
	avl_add(&spa->spa_sm_logs_by_txg, spa_log_sm_alloc(sm_obj, txg));

	/*
	* We pass UINT64_MAX as the space map's representation size
	* and SPA_MINBLOCKSHIFT as the shift, to make the space map
	* accept any sorts of segments since there's no real advantage
	* to being more restrictive (given that we're already going
	* to be using 2-word entries).
	*/
	VERIFY0(space_map_open(&spa->spa_syncing_log_sm, mos, sm_obj,
	0, UINT64_MAX, SPA_MINBLOCKSHIFT));

	/*
	* If the log space map feature was just enabled, the blocklimit
	* has not yet been set.
	*/
	if (spa_log_sm_blocklimit(spa) == 0)
	spa_log_sm_set_blocklimit(spa);
	}

	/*
	* Find all the log space maps stored in the space map ZAP and sort
	* them by their TXG in spa_sm_logs_by_txg.
	*/
	static int
	spa_ld_log_sm_metadata(spa_t *spa)
	{
	int error;
	uint64_t spacemap_zap;

	ASSERT(avl_is_empty(&spa->spa_sm_logs_by_txg));

	error = zap_lookup(spa_meta_objset(spa), DMU_POOL_DIRECTORY_OBJECT,
	DMU_POOL_LOG_SPACEMAP_ZAP, sizeof (spacemap_zap), 1, &spacemap_zap);
	if (error == ENOENT) {
	/* the space map ZAP doesn't exist yet */
	return (0);
	} else if (error != 0) {
	spa_load_failed(spa, "spa_ld_log_sm_metadata(): failed at "
	"zap_lookup(DMU_POOL_DIRECTORY_OBJECT) [error %d]",
	error);
	return (error);
	}

	zap_cursor_t zc;
	zap_attribute_t za;
	for (zap_cursor_init(&zc, spa_meta_objset(spa), spacemap_zap);
	(error = zap_cursor_retrieve(&zc, &za)) == 0;
	zap_cursor_advance(&zc)) {
	uint64_t log_txg = zfs_strtonum(za.za_name, NULL);
	spa_log_sm_t *sls =
	spa_log_sm_alloc(za.za_first_integer, log_txg);
	avl_add(&spa->spa_sm_logs_by_txg, sls);
	}
	zap_cursor_fini(&zc);
	if (error != ENOENT) {
	spa_load_failed(spa, "spa_ld_log_sm_metadata(): failed at "
	"zap_cursor_retrieve(spacemap_zap) [error %d]",
	error);
	return (error);
	}

	for (metaslab_t *m = avl_first(&spa->spa_metaslabs_by_flushed);
	m; m = AVL_NEXT(&spa->spa_metaslabs_by_flushed, m)) {
	spa_log_sm_t target = { .sls_txg = metaslab_unflushed_txg(m) };
	spa_log_sm_t *sls = avl_find(&spa->spa_sm_logs_by_txg,
	&target, NULL);

	/*
	* At this point if sls is zero it means that a bug occurred
	* in ZFS the last time the pool was open or earlier in the
	* import code path. In general, we would have placed a
	* VERIFY() here or in this case just let the kernel panic
	* with NULL pointer dereference when incrementing sls_mscount,
	* but since this is the import code path we can be a bit more
	* lenient. Thus, for DEBUG bits we always cause a panic, while
	* in production we log the error and just fail the import.
	*/
	ASSERT(sls != NULL);
	if (sls == NULL) {
	spa_load_failed(spa, "spa_ld_log_sm_metadata(): bug "
	"encountered: could not find log spacemap for "
	"TXG %ld [error %d]",
	metaslab_unflushed_txg(m), ENOENT);
	return (ENOENT);
	}
	sls->sls_mscount++;
	}

	return (0);
	}

	typedef struct spa_ld_log_sm_arg {
	spa_t *slls_spa;
	uint64_t slls_txg;
	} spa_ld_log_sm_arg_t;

	static int
	spa_ld_log_sm_cb(space_map_entry_t sme, void arg)
	{
	uint64_t offset = sme->sme_offset;
	uint64_t size = sme->sme_run;
	uint32_t vdev_id = sme->sme_vdev;

	spa_ld_log_sm_arg_t *slls = arg;
	spa_t *spa = slls->slls_spa;

	vdev_t *vd = vdev_lookup_top(spa, vdev_id);

	/*
	* If the vdev has been removed (i.e. it is indirect or a hole)
	* skip this entry. The contents of this vdev have already moved
	* elsewhere.
	*/
	if (!vdev_is_concrete(vd))
	return (0);

	metaslab_t *ms = vd->vdev_ms[offset >> vd->vdev_ms_shift];
	ASSERT(!ms->ms_loaded);

	/*
	* If we have already flushed entries for this TXG to this
	* metaslab's space map, then ignore it. Note that we flush
	* before processing any allocations/frees for that TXG, so
	* the metaslab's space map only has entries from before
	* the unflushed TXG.
	*/
	if (slls->slls_txg < metaslab_unflushed_txg(ms))
	return (0);

	switch (sme->sme_type) {
	case SM_ALLOC:
	range_tree_remove_xor_add_segment(offset, offset + size,
	ms->ms_unflushed_frees, ms->ms_unflushed_allocs);
	break;
	case SM_FREE:
	range_tree_remove_xor_add_segment(offset, offset + size,
	ms->ms_unflushed_allocs, ms->ms_unflushed_frees);
	break;
	default:
	panic("invalid maptype_t");
	break;
	}
	return (0);
	}

	static int
	spa_ld_log_sm_data(spa_t *spa)
	{
	int error = 0;

	/*
	* If we are not going to do any writes there is no need
	* to read the log space maps.
	*/
	if (!spa_writeable(spa))
	return (0);

	ASSERT0(spa->spa_unflushed_stats.sus_nblocks);
	ASSERT0(spa->spa_unflushed_stats.sus_memused);

	hrtime_t read_logs_starttime = gethrtime();
	/* this is a no-op when we don't have space map logs */
	for (spa_log_sm_t *sls = avl_first(&spa->spa_sm_logs_by_txg);
	sls; sls = AVL_NEXT(&spa->spa_sm_logs_by_txg, sls)) {
	space_map_t *sm = NULL;
	error = space_map_open(&sm, spa_meta_objset(spa),
	sls->sls_sm_obj, 0, UINT64_MAX, SPA_MINBLOCKSHIFT);
	if (error != 0) {
	spa_load_failed(spa, "spa_ld_log_sm_data(): failed at "
	"space_map_open(obj=%llu) [error %d]",
	(u_longlong_t)sls->sls_sm_obj, error);
	goto out;
	}

	struct spa_ld_log_sm_arg vla = {
	.slls_spa = spa,
	.slls_txg = sls->sls_txg
	};
	error = space_map_iterate(sm, space_map_length(sm),
	spa_ld_log_sm_cb, &vla);
	if (error != 0) {
	space_map_close(sm);
	spa_load_failed(spa, "spa_ld_log_sm_data(): failed "
	"at space_map_iterate(obj=%llu) [error %d]",
	(u_longlong_t)sls->sls_sm_obj, error);
	goto out;
	}

	ASSERT0(sls->sls_nblocks);
	sls->sls_nblocks = space_map_nblocks(sm);
	spa->spa_unflushed_stats.sus_nblocks += sls->sls_nblocks;
	summary_add_data(spa, sls->sls_txg,
	sls->sls_mscount, sls->sls_nblocks);

	space_map_close(sm);
	}
	hrtime_t read_logs_endtime = gethrtime();
	spa_load_note(spa,
	"read %llu log space maps (%llu total blocks - blksz = %llu bytes) "
	"in %lld ms", (u_longlong_t)avl_numnodes(&spa->spa_sm_logs_by_txg),
	(u_longlong_t)spa_log_sm_nblocks(spa),
	(u_longlong_t)zfs_log_sm_blksz,
	(longlong_t)((read_logs_endtime - read_logs_starttime) / 1000000));

	out:
	/*
	* Now that the metaslabs contain their unflushed changes:
	* [1] recalculate their actual allocated space
	* [2] recalculate their weights
	* [3] sum up the memory usage of their unflushed range trees
	* [4] optionally load them, if debug_load is set
	*
	* Note that even in the case where we get here because of an
	* error (e.g. error != 0), we still want to update the fields
	* below in order to have a proper teardown in spa_unload().
	*/
	for (metaslab_t *m = avl_first(&spa->spa_metaslabs_by_flushed);
	m != NULL; m = AVL_NEXT(&spa->spa_metaslabs_by_flushed, m)) {
	mutex_enter(&m->ms_lock);
	m->ms_allocated_space = space_map_allocated(m->ms_sm) +
	range_tree_space(m->ms_unflushed_allocs) -
	range_tree_space(m->ms_unflushed_frees);

	vdev_t *vd = m->ms_group->mg_vd;
	metaslab_space_update(vd, m->ms_group->mg_class,
	range_tree_space(m->ms_unflushed_allocs), 0, 0);
	metaslab_space_update(vd, m->ms_group->mg_class,
	-range_tree_space(m->ms_unflushed_frees), 0, 0);

	ASSERT0(m->ms_weight & METASLAB_ACTIVE_MASK);
	metaslab_recalculate_weight_and_sort(m);

	spa->spa_unflushed_stats.sus_memused +=
	metaslab_unflushed_changes_memused(m);

	if (metaslab_debug_load && m->ms_sm != NULL) {
	VERIFY0(metaslab_load(m));
	metaslab_set_selected_txg(m, 0);
	}
	mutex_exit(&m->ms_lock);
	}

	return (error);
	}

	static int
	spa_ld_unflushed_txgs(vdev_t *vd)
	{
	spa_t *spa = vd->vdev_spa;
	objset_t *mos = spa_meta_objset(spa);

	if (vd->vdev_top_zap == 0)
	return (0);

	uint64_t object = 0;
	int error = zap_lookup(mos, vd->vdev_top_zap,
	VDEV_TOP_ZAP_MS_UNFLUSHED_PHYS_TXGS,
	sizeof (uint64_t), 1, &object);
	if (error == ENOENT)
	return (0);
	else if (error != 0) {
	spa_load_failed(spa, "spa_ld_unflushed_txgs(): failed at "
	"zap_lookup(vdev_top_zap=%llu) [error %d]",
	(u_longlong_t)vd->vdev_top_zap, error);
	return (error);
	}

	for (uint64_t m = 0; m < vd->vdev_ms_count; m++) {
	metaslab_t *ms = vd->vdev_ms[m];
	ASSERT(ms != NULL);

	metaslab_unflushed_phys_t entry;
	uint64_t entry_size = sizeof (entry);
	uint64_t entry_offset = ms->ms_id * entry_size;

	error = dmu_read(mos, object,
	entry_offset, entry_size, &entry, 0);
	if (error != 0) {
	spa_load_failed(spa, "spa_ld_unflushed_txgs(): "
	"failed at dmu_read(obj=%llu) [error %d]",
	(u_longlong_t)object, error);
	return (error);
	}

	ms->ms_unflushed_txg = entry.msp_unflushed_txg;
	if (ms->ms_unflushed_txg != 0) {
	mutex_enter(&spa->spa_flushed_ms_lock);
	avl_add(&spa->spa_metaslabs_by_flushed, ms);
	mutex_exit(&spa->spa_flushed_ms_lock);
	}
	}
	return (0);
	}

	/*
	* Read all the log space map entries into their respective
	* metaslab unflushed trees and keep them sorted by TXG in the
	* SPA's metadata. In addition, setup all the metadata for the
	* memory and the block heuristics.
	*/
	int
	spa_ld_log_spacemaps(spa_t *spa)
	{
	int error;

	spa_log_sm_set_blocklimit(spa);

	for (uint64_t c = 0; c < spa->spa_root_vdev->vdev_children; c++) {
	vdev_t *vd = spa->spa_root_vdev->vdev_child[c];
	error = spa_ld_unflushed_txgs(vd);
	if (error != 0)
	return (error);
	}

	error = spa_ld_log_sm_metadata(spa);
	if (error != 0)
	return (error);

	/*
	* Note: we don't actually expect anything to change at this point
	* but we grab the config lock so we don't fail any assertions
	* when using vdev_lookup_top().
	*/
	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
	error = spa_ld_log_sm_data(spa);
	spa_config_exit(spa, SCL_CONFIG, FTAG);

	return (error);
	}

	/* BEGIN CSTYLED */
	ZFS_MODULE_PARAM(zfs, zfs_, unflushed_max_mem_amt, ULONG, ZMOD_RW,
	"Specific hard-limit in memory that ZFS allows to be used for "
	"unflushed changes");

	ZFS_MODULE_PARAM(zfs, zfs_, unflushed_max_mem_ppm, ULONG, ZMOD_RW,
	"Percentage of the overall system memory that ZFS allows to be "
	"used for unflushed changes (value is calculated over 1000000 for "
	- "finer granularity");
	+ "finer granularity)");

	ZFS_MODULE_PARAM(zfs, zfs_, unflushed_log_block_max, ULONG, ZMOD_RW,
	"Hard limit (upper-bound) in the size of the space map log "
	"in terms of blocks.");

	ZFS_MODULE_PARAM(zfs, zfs_, unflushed_log_block_min, ULONG, ZMOD_RW,
	"Lower-bound limit for the maximum amount of blocks allowed in "
	"log spacemap (see zfs_unflushed_log_block_max)");

	ZFS_MODULE_PARAM(zfs, zfs_, unflushed_log_block_pct, ULONG, ZMOD_RW,
	"Tunable used to determine the number of blocks that can be used for "
	"the spacemap log, expressed as a percentage of the total number of "
	"metaslabs in the pool (e.g. 400 means the number of log blocks is "
	"capped at 4 times the number of metaslabs)");

	ZFS_MODULE_PARAM(zfs, zfs_, max_log_walking, ULONG, ZMOD_RW,
	"The number of past TXGs that the flushing algorithm of the log "
	"spacemap feature uses to estimate incoming log blocks");

	ZFS_MODULE_PARAM(zfs, zfs_, max_logsm_summary_length, ULONG, ZMOD_RW,
	"Maximum number of rows allowed in the summary of the spacemap log");

	ZFS_MODULE_PARAM(zfs, zfs_, min_metaslabs_to_flush, ULONG, ZMOD_RW,
	"Minimum number of metaslabs to flush per dirty TXG");

	ZFS_MODULE_PARAM(zfs, zfs_, keep_log_spacemaps_at_export, INT, ZMOD_RW,
	"Prevent the log spacemaps from being flushed and destroyed "
	"during pool export/destroy");
	/* END CSTYLED */
	diff --git a/sys/contrib/openzfs/module/zfs/vdev.c b/sys/contrib/openzfs/module/zfs/vdev.c
	index c536a1c6cda0..5e14d71f1946 100644
	--- a/sys/contrib/openzfs/module/zfs/vdev.c
	+++ b/sys/contrib/openzfs/module/zfs/vdev.c
	@@ -1,5421 +1,5425 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2011, 2021 by Delphix. All rights reserved.
	* Copyright 2017 Nexenta Systems, Inc.
	* Copyright (c) 2014 Integros [integros.com]
	* Copyright 2016 Toomas Soome <tsoome@me.com>
	* Copyright 2017 Joyent, Inc.
	* Copyright (c) 2017, Intel Corporation.
	* Copyright (c) 2019, Datto Inc. All rights reserved.
	+ * Copyright [2021] Hewlett Packard Enterprise Development LP
	*/

	#include <sys/zfs_context.h>
	#include <sys/fm/fs/zfs.h>
	#include <sys/spa.h>
	#include <sys/spa_impl.h>
	#include <sys/bpobj.h>
	#include <sys/dmu.h>
	#include <sys/dmu_tx.h>
	#include <sys/dsl_dir.h>
	#include <sys/vdev_impl.h>
	#include <sys/vdev_rebuild.h>
	#include <sys/vdev_draid.h>
	#include <sys/uberblock_impl.h>
	#include <sys/metaslab.h>
	#include <sys/metaslab_impl.h>
	#include <sys/space_map.h>
	#include <sys/space_reftree.h>
	#include <sys/zio.h>
	#include <sys/zap.h>
	#include <sys/fs/zfs.h>
	#include <sys/arc.h>
	#include <sys/zil.h>
	#include <sys/dsl_scan.h>
	#include <sys/vdev_raidz.h>
	#include <sys/abd.h>
	#include <sys/vdev_initialize.h>
	#include <sys/vdev_trim.h>
	#include <sys/zvol.h>
	#include <sys/zfs_ratelimit.h>

	/*
	* One metaslab from each (normal-class) vdev is used by the ZIL. These are
	* called "embedded slog metaslabs", are referenced by vdev_log_mg, and are
	* part of the spa_embedded_log_class. The metaslab with the most free space
	* in each vdev is selected for this purpose when the pool is opened (or a
	* vdev is added). See vdev_metaslab_init().
	*
	* Log blocks can be allocated from the following locations. Each one is tried
	* in order until the allocation succeeds:
	* 1. dedicated log vdevs, aka "slog" (spa_log_class)
	* 2. embedded slog metaslabs (spa_embedded_log_class)
	* 3. other metaslabs in normal vdevs (spa_normal_class)
	*
	* zfs_embedded_slog_min_ms disables the embedded slog if there are fewer
	* than this number of metaslabs in the vdev. This ensures that we don't set
	* aside an unreasonable amount of space for the ZIL. If set to less than
	* 1 << (spa_slop_shift + 1), on small pools the usable space may be reduced
	* (by more than 1<<spa_slop_shift) due to the embedded slog metaslab.
	*/
	int zfs_embedded_slog_min_ms = 64;

	/* default target for number of metaslabs per top-level vdev */
	int zfs_vdev_default_ms_count = 200;

	/* minimum number of metaslabs per top-level vdev */
	int zfs_vdev_min_ms_count = 16;

	/* practical upper limit of total metaslabs per top-level vdev */
	int zfs_vdev_ms_count_limit = 1ULL << 17;

	/* lower limit for metaslab size (512M) */
	int zfs_vdev_default_ms_shift = 29;

	/* upper limit for metaslab size (16G) */
	int zfs_vdev_max_ms_shift = 34;

	int vdev_validate_skip = B_FALSE;

	/*
	* Since the DTL space map of a vdev is not expected to have a lot of
	* entries, we default its block size to 4K.
	*/
	int zfs_vdev_dtl_sm_blksz = (1 << 12);

	/*
	* Rate limit slow IO (delay) events to this many per second.
	*/
	unsigned int zfs_slow_io_events_per_second = 20;

	/*
	* Rate limit checksum events after this many checksum errors per second.
	*/
	unsigned int zfs_checksum_events_per_second = 20;

	/*
	* Ignore errors during scrub/resilver. Allows to work around resilver
	* upon import when there are pool errors.
	*/
	int zfs_scan_ignore_errors = 0;

	/*
	* vdev-wide space maps that have lots of entries written to them at
	* the end of each transaction can benefit from a higher I/O bandwidth
	* (e.g. vdev_obsolete_sm), thus we default their block size to 128K.
	*/
	int zfs_vdev_standard_sm_blksz = (1 << 17);

	/*
	* Tunable parameter for debugging or performance analysis. Setting this
	* will cause pool corruption on power loss if a volatile out-of-order
	* write cache is enabled.
	*/
	int zfs_nocacheflush = 0;

	uint64_t zfs_vdev_max_auto_ashift = ASHIFT_MAX;
	uint64_t zfs_vdev_min_auto_ashift = ASHIFT_MIN;

	/PRINTFLIKE2/
	void
	vdev_dbgmsg(vdev_t vd, const char fmt, ...)
	{
	va_list adx;
	char buf[256];

	va_start(adx, fmt);
	(void) vsnprintf(buf, sizeof (buf), fmt, adx);
	va_end(adx);

	if (vd->vdev_path != NULL) {
	zfs_dbgmsg("%s vdev '%s': %s", vd->vdev_ops->vdev_op_type,
	vd->vdev_path, buf);
	} else {
	zfs_dbgmsg("%s-%llu vdev (guid %llu): %s",
	vd->vdev_ops->vdev_op_type,
	(u_longlong_t)vd->vdev_id,
	(u_longlong_t)vd->vdev_guid, buf);
	}
	}

	void
	vdev_dbgmsg_print_tree(vdev_t *vd, int indent)
	{
	char state[20];

	if (vd->vdev_ishole \|\| vd->vdev_ops == &vdev_missing_ops) {
	zfs_dbgmsg("%*svdev %u: %s", indent, "", vd->vdev_id,
	vd->vdev_ops->vdev_op_type);
	return;
	}

	switch (vd->vdev_state) {
	case VDEV_STATE_UNKNOWN:
	(void) snprintf(state, sizeof (state), "unknown");
	break;
	case VDEV_STATE_CLOSED:
	(void) snprintf(state, sizeof (state), "closed");
	break;
	case VDEV_STATE_OFFLINE:
	(void) snprintf(state, sizeof (state), "offline");
	break;
	case VDEV_STATE_REMOVED:
	(void) snprintf(state, sizeof (state), "removed");
	break;
	case VDEV_STATE_CANT_OPEN:
	(void) snprintf(state, sizeof (state), "can't open");
	break;
	case VDEV_STATE_FAULTED:
	(void) snprintf(state, sizeof (state), "faulted");
	break;
	case VDEV_STATE_DEGRADED:
	(void) snprintf(state, sizeof (state), "degraded");
	break;
	case VDEV_STATE_HEALTHY:
	(void) snprintf(state, sizeof (state), "healthy");
	break;
	default:
	(void) snprintf(state, sizeof (state), "<state %u>",
	(uint_t)vd->vdev_state);
	}

	zfs_dbgmsg("%*svdev %u: %s%s, guid: %llu, path: %s, %s", indent,
	"", (int)vd->vdev_id, vd->vdev_ops->vdev_op_type,
	vd->vdev_islog ? " (log)" : "",
	(u_longlong_t)vd->vdev_guid,
	vd->vdev_path ? vd->vdev_path : "N/A", state);

	for (uint64_t i = 0; i < vd->vdev_children; i++)
	vdev_dbgmsg_print_tree(vd->vdev_child[i], indent + 2);
	}

	/*
	* Virtual device management.
	*/

	static vdev_ops_t *vdev_ops_table[] = {
	&vdev_root_ops,
	&vdev_raidz_ops,
	&vdev_draid_ops,
	&vdev_draid_spare_ops,
	&vdev_mirror_ops,
	&vdev_replacing_ops,
	&vdev_spare_ops,
	&vdev_disk_ops,
	&vdev_file_ops,
	&vdev_missing_ops,
	&vdev_hole_ops,
	&vdev_indirect_ops,
	NULL
	};

	/*
	* Given a vdev type, return the appropriate ops vector.
	*/
	static vdev_ops_t *
	vdev_getops(const char *type)
	{
	vdev_ops_t ops, *opspp;

	for (opspp = vdev_ops_table; (ops = *opspp) != NULL; opspp++)
	if (strcmp(ops->vdev_op_type, type) == 0)
	break;

	return (ops);
	}

	/*
	* Given a vdev and a metaslab class, find which metaslab group we're
	* interested in. All vdevs may belong to two different metaslab classes.
	* Dedicated slog devices use only the primary metaslab group, rather than a
	* separate log group. For embedded slogs, the vdev_log_mg will be non-NULL.
	*/
	metaslab_group_t *
	vdev_get_mg(vdev_t vd, metaslab_class_t mc)
	{
	if (mc == spa_embedded_log_class(vd->vdev_spa) &&
	vd->vdev_log_mg != NULL)
	return (vd->vdev_log_mg);
	else
	return (vd->vdev_mg);
	}

	/* ARGSUSED */
	void
	vdev_default_xlate(vdev_t vd, const range_seg64_t logical_rs,
	range_seg64_t physical_rs, range_seg64_t remain_rs)
	{
	physical_rs->rs_start = logical_rs->rs_start;
	physical_rs->rs_end = logical_rs->rs_end;
	}

	/*
	* Derive the enumerated allocation bias from string input.
	* String origin is either the per-vdev zap or zpool(8).
	*/
	static vdev_alloc_bias_t
	vdev_derive_alloc_bias(const char *bias)
	{
	vdev_alloc_bias_t alloc_bias = VDEV_BIAS_NONE;

	if (strcmp(bias, VDEV_ALLOC_BIAS_LOG) == 0)
	alloc_bias = VDEV_BIAS_LOG;
	else if (strcmp(bias, VDEV_ALLOC_BIAS_SPECIAL) == 0)
	alloc_bias = VDEV_BIAS_SPECIAL;
	else if (strcmp(bias, VDEV_ALLOC_BIAS_DEDUP) == 0)
	alloc_bias = VDEV_BIAS_DEDUP;

	return (alloc_bias);
	}

	/*
	* Default asize function: return the MAX of psize with the asize of
	* all children. This is what's used by anything other than RAID-Z.
	*/
	uint64_t
	vdev_default_asize(vdev_t *vd, uint64_t psize)
	{
	uint64_t asize = P2ROUNDUP(psize, 1ULL << vd->vdev_top->vdev_ashift);
	uint64_t csize;

	for (int c = 0; c < vd->vdev_children; c++) {
	csize = vdev_psize_to_asize(vd->vdev_child[c], psize);
	asize = MAX(asize, csize);
	}

	return (asize);
	}

	uint64_t
	vdev_default_min_asize(vdev_t *vd)
	{
	return (vd->vdev_min_asize);
	}

	/*
	* Get the minimum allocatable size. We define the allocatable size as
	* the vdev's asize rounded to the nearest metaslab. This allows us to
	* replace or attach devices which don't have the same physical size but
	* can still satisfy the same number of allocations.
	*/
	uint64_t
	vdev_get_min_asize(vdev_t *vd)
	{
	vdev_t *pvd = vd->vdev_parent;

	/*
	* If our parent is NULL (inactive spare or cache) or is the root,
	* just return our own asize.
	*/
	if (pvd == NULL)
	return (vd->vdev_asize);

	/*
	* The top-level vdev just returns the allocatable size rounded
	* to the nearest metaslab.
	*/
	if (vd == vd->vdev_top)
	return (P2ALIGN(vd->vdev_asize, 1ULL << vd->vdev_ms_shift));

	return (pvd->vdev_ops->vdev_op_min_asize(pvd));
	}

	void
	vdev_set_min_asize(vdev_t *vd)
	{
	vd->vdev_min_asize = vdev_get_min_asize(vd);

	for (int c = 0; c < vd->vdev_children; c++)
	vdev_set_min_asize(vd->vdev_child[c]);
	}

	/*
	* Get the minimal allocation size for the top-level vdev.
	*/
	uint64_t
	vdev_get_min_alloc(vdev_t *vd)
	{
	uint64_t min_alloc = 1ULL << vd->vdev_ashift;

	if (vd->vdev_ops->vdev_op_min_alloc != NULL)
	min_alloc = vd->vdev_ops->vdev_op_min_alloc(vd);

	return (min_alloc);
	}

	/*
	* Get the parity level for a top-level vdev.
	*/
	uint64_t
	vdev_get_nparity(vdev_t *vd)
	{
	uint64_t nparity = 0;

	if (vd->vdev_ops->vdev_op_nparity != NULL)
	nparity = vd->vdev_ops->vdev_op_nparity(vd);

	return (nparity);
	}

	/*
	* Get the number of data disks for a top-level vdev.
	*/
	uint64_t
	vdev_get_ndisks(vdev_t *vd)
	{
	uint64_t ndisks = 1;

	if (vd->vdev_ops->vdev_op_ndisks != NULL)
	ndisks = vd->vdev_ops->vdev_op_ndisks(vd);

	return (ndisks);
	}

	vdev_t *
	vdev_lookup_top(spa_t *spa, uint64_t vdev)
	{
	vdev_t *rvd = spa->spa_root_vdev;

	ASSERT(spa_config_held(spa, SCL_ALL, RW_READER) != 0);

	if (vdev < rvd->vdev_children) {
	ASSERT(rvd->vdev_child[vdev] != NULL);
	return (rvd->vdev_child[vdev]);
	}

	return (NULL);
	}

	vdev_t *
	vdev_lookup_by_guid(vdev_t *vd, uint64_t guid)
	{
	vdev_t *mvd;

	if (vd->vdev_guid == guid)
	return (vd);

	for (int c = 0; c < vd->vdev_children; c++)
	if ((mvd = vdev_lookup_by_guid(vd->vdev_child[c], guid)) !=
	NULL)
	return (mvd);

	return (NULL);
	}

	static int
	vdev_count_leaves_impl(vdev_t *vd)
	{
	int n = 0;

	if (vd->vdev_ops->vdev_op_leaf)
	return (1);

	for (int c = 0; c < vd->vdev_children; c++)
	n += vdev_count_leaves_impl(vd->vdev_child[c]);

	return (n);
	}

	int
	vdev_count_leaves(spa_t *spa)
	{
	int rc;

	spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER);
	rc = vdev_count_leaves_impl(spa->spa_root_vdev);
	spa_config_exit(spa, SCL_VDEV, FTAG);

	return (rc);
	}

	void
	vdev_add_child(vdev_t pvd, vdev_t cvd)
	{
	size_t oldsize, newsize;
	uint64_t id = cvd->vdev_id;
	vdev_t **newchild;

	ASSERT(spa_config_held(cvd->vdev_spa, SCL_ALL, RW_WRITER) == SCL_ALL);
	ASSERT(cvd->vdev_parent == NULL);

	cvd->vdev_parent = pvd;

	if (pvd == NULL)
	return;

	ASSERT(id >= pvd->vdev_children \|\| pvd->vdev_child[id] == NULL);

	oldsize = pvd->vdev_children * sizeof (vdev_t *);
	pvd->vdev_children = MAX(pvd->vdev_children, id + 1);
	newsize = pvd->vdev_children * sizeof (vdev_t *);

	newchild = kmem_alloc(newsize, KM_SLEEP);
	if (pvd->vdev_child != NULL) {
	bcopy(pvd->vdev_child, newchild, oldsize);
	kmem_free(pvd->vdev_child, oldsize);
	}

	pvd->vdev_child = newchild;
	pvd->vdev_child[id] = cvd;

	cvd->vdev_top = (pvd->vdev_top ? pvd->vdev_top: cvd);
	ASSERT(cvd->vdev_top->vdev_parent->vdev_parent == NULL);

	/*
	* Walk up all ancestors to update guid sum.
	*/
	for (; pvd != NULL; pvd = pvd->vdev_parent)
	pvd->vdev_guid_sum += cvd->vdev_guid_sum;

	if (cvd->vdev_ops->vdev_op_leaf) {
	list_insert_head(&cvd->vdev_spa->spa_leaf_list, cvd);
	cvd->vdev_spa->spa_leaf_list_gen++;
	}
	}

	void
	vdev_remove_child(vdev_t pvd, vdev_t cvd)
	{
	int c;
	uint_t id = cvd->vdev_id;

	ASSERT(cvd->vdev_parent == pvd);

	if (pvd == NULL)
	return;

	ASSERT(id < pvd->vdev_children);
	ASSERT(pvd->vdev_child[id] == cvd);

	pvd->vdev_child[id] = NULL;
	cvd->vdev_parent = NULL;

	for (c = 0; c < pvd->vdev_children; c++)
	if (pvd->vdev_child[c])
	break;

	if (c == pvd->vdev_children) {
	kmem_free(pvd->vdev_child, c * sizeof (vdev_t *));
	pvd->vdev_child = NULL;
	pvd->vdev_children = 0;
	}

	if (cvd->vdev_ops->vdev_op_leaf) {
	spa_t *spa = cvd->vdev_spa;
	list_remove(&spa->spa_leaf_list, cvd);
	spa->spa_leaf_list_gen++;
	}

	/*
	* Walk up all ancestors to update guid sum.
	*/
	for (; pvd != NULL; pvd = pvd->vdev_parent)
	pvd->vdev_guid_sum -= cvd->vdev_guid_sum;
	}

	/*
	* Remove any holes in the child array.
	*/
	void
	vdev_compact_children(vdev_t *pvd)
	{
	vdev_t *newchild, cvd;
	int oldc = pvd->vdev_children;
	int newc;

	ASSERT(spa_config_held(pvd->vdev_spa, SCL_ALL, RW_WRITER) == SCL_ALL);

	if (oldc == 0)
	return;

	for (int c = newc = 0; c < oldc; c++)
	if (pvd->vdev_child[c])
	newc++;

	if (newc > 0) {
	newchild = kmem_zalloc(newc * sizeof (vdev_t *), KM_SLEEP);

	for (int c = newc = 0; c < oldc; c++) {
	if ((cvd = pvd->vdev_child[c]) != NULL) {
	newchild[newc] = cvd;
	cvd->vdev_id = newc++;
	}
	}
	} else {
	newchild = NULL;
	}

	kmem_free(pvd->vdev_child, oldc * sizeof (vdev_t *));
	pvd->vdev_child = newchild;
	pvd->vdev_children = newc;
	}

	/*
	* Allocate and minimally initialize a vdev_t.
	*/
	vdev_t *
	vdev_alloc_common(spa_t spa, uint_t id, uint64_t guid, vdev_ops_t ops)
	{
	vdev_t *vd;
	vdev_indirect_config_t *vic;

	vd = kmem_zalloc(sizeof (vdev_t), KM_SLEEP);
	vic = &vd->vdev_indirect_config;

	if (spa->spa_root_vdev == NULL) {
	ASSERT(ops == &vdev_root_ops);
	spa->spa_root_vdev = vd;
	spa->spa_load_guid = spa_generate_guid(NULL);
	}

	if (guid == 0 && ops != &vdev_hole_ops) {
	if (spa->spa_root_vdev == vd) {
	/*
	* The root vdev's guid will also be the pool guid,
	* which must be unique among all pools.
	*/
	guid = spa_generate_guid(NULL);
	} else {
	/*
	* Any other vdev's guid must be unique within the pool.
	*/
	guid = spa_generate_guid(spa);
	}
	ASSERT(!spa_guid_exists(spa_guid(spa), guid));
	}

	vd->vdev_spa = spa;
	vd->vdev_id = id;
	vd->vdev_guid = guid;
	vd->vdev_guid_sum = guid;
	vd->vdev_ops = ops;
	vd->vdev_state = VDEV_STATE_CLOSED;
	vd->vdev_ishole = (ops == &vdev_hole_ops);
	vic->vic_prev_indirect_vdev = UINT64_MAX;

	rw_init(&vd->vdev_indirect_rwlock, NULL, RW_DEFAULT, NULL);
	mutex_init(&vd->vdev_obsolete_lock, NULL, MUTEX_DEFAULT, NULL);
	vd->vdev_obsolete_segments = range_tree_create(NULL, RANGE_SEG64, NULL,
	0, 0);

	/*
	* Initialize rate limit structs for events. We rate limit ZIO delay
	* and checksum events so that we don't overwhelm ZED with thousands
	* of events when a disk is acting up.
	*/
	zfs_ratelimit_init(&vd->vdev_delay_rl, &zfs_slow_io_events_per_second,
	1);
	+ zfs_ratelimit_init(&vd->vdev_deadman_rl, &zfs_slow_io_events_per_second,
	+ 1);
	zfs_ratelimit_init(&vd->vdev_checksum_rl,
	&zfs_checksum_events_per_second, 1);

	list_link_init(&vd->vdev_config_dirty_node);
	list_link_init(&vd->vdev_state_dirty_node);
	list_link_init(&vd->vdev_initialize_node);
	list_link_init(&vd->vdev_leaf_node);
	list_link_init(&vd->vdev_trim_node);

	mutex_init(&vd->vdev_dtl_lock, NULL, MUTEX_NOLOCKDEP, NULL);
	mutex_init(&vd->vdev_stat_lock, NULL, MUTEX_DEFAULT, NULL);
	mutex_init(&vd->vdev_probe_lock, NULL, MUTEX_DEFAULT, NULL);
	mutex_init(&vd->vdev_scan_io_queue_lock, NULL, MUTEX_DEFAULT, NULL);

	mutex_init(&vd->vdev_initialize_lock, NULL, MUTEX_DEFAULT, NULL);
	mutex_init(&vd->vdev_initialize_io_lock, NULL, MUTEX_DEFAULT, NULL);
	cv_init(&vd->vdev_initialize_cv, NULL, CV_DEFAULT, NULL);
	cv_init(&vd->vdev_initialize_io_cv, NULL, CV_DEFAULT, NULL);

	mutex_init(&vd->vdev_trim_lock, NULL, MUTEX_DEFAULT, NULL);
	mutex_init(&vd->vdev_autotrim_lock, NULL, MUTEX_DEFAULT, NULL);
	mutex_init(&vd->vdev_trim_io_lock, NULL, MUTEX_DEFAULT, NULL);
	cv_init(&vd->vdev_trim_cv, NULL, CV_DEFAULT, NULL);
	cv_init(&vd->vdev_autotrim_cv, NULL, CV_DEFAULT, NULL);
	cv_init(&vd->vdev_trim_io_cv, NULL, CV_DEFAULT, NULL);

	mutex_init(&vd->vdev_rebuild_lock, NULL, MUTEX_DEFAULT, NULL);
	cv_init(&vd->vdev_rebuild_cv, NULL, CV_DEFAULT, NULL);

	for (int t = 0; t < DTL_TYPES; t++) {
	vd->vdev_dtl[t] = range_tree_create(NULL, RANGE_SEG64, NULL, 0,
	0);
	}

	txg_list_create(&vd->vdev_ms_list, spa,
	offsetof(struct metaslab, ms_txg_node));
	txg_list_create(&vd->vdev_dtl_list, spa,
	offsetof(struct vdev, vdev_dtl_node));
	vd->vdev_stat.vs_timestamp = gethrtime();
	vdev_queue_init(vd);
	vdev_cache_init(vd);

	return (vd);
	}

	/*
	* Allocate a new vdev. The 'alloctype' is used to control whether we are
	* creating a new vdev or loading an existing one - the behavior is slightly
	* different for each case.
	*/
	int
	vdev_alloc(spa_t spa, vdev_t vdp, nvlist_t nv, vdev_t *parent, uint_t id,
	int alloctype)
	{
	vdev_ops_t *ops;
	char *type;
	uint64_t guid = 0, islog;
	vdev_t *vd;
	vdev_indirect_config_t *vic;
	char *tmp = NULL;
	int rc;
	vdev_alloc_bias_t alloc_bias = VDEV_BIAS_NONE;
	boolean_t top_level = (parent && !parent->vdev_parent);

	ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);

	if (nvlist_lookup_string(nv, ZPOOL_CONFIG_TYPE, &type) != 0)
	return (SET_ERROR(EINVAL));

	if ((ops = vdev_getops(type)) == NULL)
	return (SET_ERROR(EINVAL));

	/*
	* If this is a load, get the vdev guid from the nvlist.
	* Otherwise, vdev_alloc_common() will generate one for us.
	*/
	if (alloctype == VDEV_ALLOC_LOAD) {
	uint64_t label_id;

	if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_ID, &label_id) \|\|
	label_id != id)
	return (SET_ERROR(EINVAL));

	if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &guid) != 0)
	return (SET_ERROR(EINVAL));
	} else if (alloctype == VDEV_ALLOC_SPARE) {
	if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &guid) != 0)
	return (SET_ERROR(EINVAL));
	} else if (alloctype == VDEV_ALLOC_L2CACHE) {
	if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &guid) != 0)
	return (SET_ERROR(EINVAL));
	} else if (alloctype == VDEV_ALLOC_ROOTPOOL) {
	if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_GUID, &guid) != 0)
	return (SET_ERROR(EINVAL));
	}

	/*
	* The first allocated vdev must be of type 'root'.
	*/
	if (ops != &vdev_root_ops && spa->spa_root_vdev == NULL)
	return (SET_ERROR(EINVAL));

	/*
	* Determine whether we're a log vdev.
	*/
	islog = 0;
	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_IS_LOG, &islog);
	if (islog && spa_version(spa) < SPA_VERSION_SLOGS)
	return (SET_ERROR(ENOTSUP));

	if (ops == &vdev_hole_ops && spa_version(spa) < SPA_VERSION_HOLES)
	return (SET_ERROR(ENOTSUP));

	if (top_level && alloctype == VDEV_ALLOC_ADD) {
	char *bias;

	/*
	* If creating a top-level vdev, check for allocation
	* classes input.
	*/
	if (nvlist_lookup_string(nv, ZPOOL_CONFIG_ALLOCATION_BIAS,
	&bias) == 0) {
	alloc_bias = vdev_derive_alloc_bias(bias);

	/* spa_vdev_add() expects feature to be enabled */
	if (spa->spa_load_state != SPA_LOAD_CREATE &&
	!spa_feature_is_enabled(spa,
	SPA_FEATURE_ALLOCATION_CLASSES)) {
	return (SET_ERROR(ENOTSUP));
	}
	}

	/* spa_vdev_add() expects feature to be enabled */
	if (ops == &vdev_draid_ops &&
	spa->spa_load_state != SPA_LOAD_CREATE &&
	!spa_feature_is_enabled(spa, SPA_FEATURE_DRAID)) {
	return (SET_ERROR(ENOTSUP));
	}
	}

	/*
	* Initialize the vdev specific data. This is done before calling
	* vdev_alloc_common() since it may fail and this simplifies the
	* error reporting and cleanup code paths.
	*/
	void *tsd = NULL;
	if (ops->vdev_op_init != NULL) {
	rc = ops->vdev_op_init(spa, nv, &tsd);
	if (rc != 0) {
	return (rc);
	}
	}

	vd = vdev_alloc_common(spa, id, guid, ops);
	vd->vdev_tsd = tsd;
	vd->vdev_islog = islog;

	if (top_level && alloc_bias != VDEV_BIAS_NONE)
	vd->vdev_alloc_bias = alloc_bias;

	if (nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &vd->vdev_path) == 0)
	vd->vdev_path = spa_strdup(vd->vdev_path);

	/*
	* ZPOOL_CONFIG_AUX_STATE = "external" means we previously forced a
	* fault on a vdev and want it to persist across imports (like with
	* zpool offline -f).
	*/
	rc = nvlist_lookup_string(nv, ZPOOL_CONFIG_AUX_STATE, &tmp);
	if (rc == 0 && tmp != NULL && strcmp(tmp, "external") == 0) {
	vd->vdev_stat.vs_aux = VDEV_AUX_EXTERNAL;
	vd->vdev_faulted = 1;
	vd->vdev_label_aux = VDEV_AUX_EXTERNAL;
	}

	if (nvlist_lookup_string(nv, ZPOOL_CONFIG_DEVID, &vd->vdev_devid) == 0)
	vd->vdev_devid = spa_strdup(vd->vdev_devid);
	if (nvlist_lookup_string(nv, ZPOOL_CONFIG_PHYS_PATH,
	&vd->vdev_physpath) == 0)
	vd->vdev_physpath = spa_strdup(vd->vdev_physpath);

	if (nvlist_lookup_string(nv, ZPOOL_CONFIG_VDEV_ENC_SYSFS_PATH,
	&vd->vdev_enc_sysfs_path) == 0)
	vd->vdev_enc_sysfs_path = spa_strdup(vd->vdev_enc_sysfs_path);

	if (nvlist_lookup_string(nv, ZPOOL_CONFIG_FRU, &vd->vdev_fru) == 0)
	vd->vdev_fru = spa_strdup(vd->vdev_fru);

	/*
	* Set the whole_disk property. If it's not specified, leave the value
	* as -1.
	*/
	if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_WHOLE_DISK,
	&vd->vdev_wholedisk) != 0)
	vd->vdev_wholedisk = -1ULL;

	vic = &vd->vdev_indirect_config;

	ASSERT0(vic->vic_mapping_object);
	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_INDIRECT_OBJECT,
	&vic->vic_mapping_object);
	ASSERT0(vic->vic_births_object);
	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_INDIRECT_BIRTHS,
	&vic->vic_births_object);
	ASSERT3U(vic->vic_prev_indirect_vdev, ==, UINT64_MAX);
	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_PREV_INDIRECT_VDEV,
	&vic->vic_prev_indirect_vdev);

	/*
	* Look for the 'not present' flag. This will only be set if the device
	* was not present at the time of import.
	*/
	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_NOT_PRESENT,
	&vd->vdev_not_present);

	/*
	* Get the alignment requirement.
	*/
	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_ASHIFT, &vd->vdev_ashift);

	/*
	* Retrieve the vdev creation time.
	*/
	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_CREATE_TXG,
	&vd->vdev_crtxg);

	/*
	* If we're a top-level vdev, try to load the allocation parameters.
	*/
	if (top_level &&
	(alloctype == VDEV_ALLOC_LOAD \|\| alloctype == VDEV_ALLOC_SPLIT)) {
	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_METASLAB_ARRAY,
	&vd->vdev_ms_array);
	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_METASLAB_SHIFT,
	&vd->vdev_ms_shift);
	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_ASIZE,
	&vd->vdev_asize);
	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_REMOVING,
	&vd->vdev_removing);
	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_VDEV_TOP_ZAP,
	&vd->vdev_top_zap);
	} else {
	ASSERT0(vd->vdev_top_zap);
	}

	if (top_level && alloctype != VDEV_ALLOC_ATTACH) {
	ASSERT(alloctype == VDEV_ALLOC_LOAD \|\|
	alloctype == VDEV_ALLOC_ADD \|\|
	alloctype == VDEV_ALLOC_SPLIT \|\|
	alloctype == VDEV_ALLOC_ROOTPOOL);
	/* Note: metaslab_group_create() is now deferred */
	}

	if (vd->vdev_ops->vdev_op_leaf &&
	(alloctype == VDEV_ALLOC_LOAD \|\| alloctype == VDEV_ALLOC_SPLIT)) {
	(void) nvlist_lookup_uint64(nv,
	ZPOOL_CONFIG_VDEV_LEAF_ZAP, &vd->vdev_leaf_zap);
	} else {
	ASSERT0(vd->vdev_leaf_zap);
	}

	/*
	* If we're a leaf vdev, try to load the DTL object and other state.
	*/

	if (vd->vdev_ops->vdev_op_leaf &&
	(alloctype == VDEV_ALLOC_LOAD \|\| alloctype == VDEV_ALLOC_L2CACHE \|\|
	alloctype == VDEV_ALLOC_ROOTPOOL)) {
	if (alloctype == VDEV_ALLOC_LOAD) {
	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_DTL,
	&vd->vdev_dtl_object);
	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_UNSPARE,
	&vd->vdev_unspare);
	}

	if (alloctype == VDEV_ALLOC_ROOTPOOL) {
	uint64_t spare = 0;

	if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_IS_SPARE,
	&spare) == 0 && spare)
	spa_spare_add(vd);
	}

	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_OFFLINE,
	&vd->vdev_offline);

	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_RESILVER_TXG,
	&vd->vdev_resilver_txg);

	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_REBUILD_TXG,
	&vd->vdev_rebuild_txg);

	if (nvlist_exists(nv, ZPOOL_CONFIG_RESILVER_DEFER))
	vdev_defer_resilver(vd);

	/*
	* In general, when importing a pool we want to ignore the
	* persistent fault state, as the diagnosis made on another
	* system may not be valid in the current context. The only
	* exception is if we forced a vdev to a persistently faulted
	* state with 'zpool offline -f'. The persistent fault will
	* remain across imports until cleared.
	*
	* Local vdevs will remain in the faulted state.
	*/
	if (spa_load_state(spa) == SPA_LOAD_OPEN \|\|
	spa_load_state(spa) == SPA_LOAD_IMPORT) {
	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_FAULTED,
	&vd->vdev_faulted);
	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_DEGRADED,
	&vd->vdev_degraded);
	(void) nvlist_lookup_uint64(nv, ZPOOL_CONFIG_REMOVED,
	&vd->vdev_removed);

	if (vd->vdev_faulted \|\| vd->vdev_degraded) {
	char *aux;

	vd->vdev_label_aux =
	VDEV_AUX_ERR_EXCEEDED;
	if (nvlist_lookup_string(nv,
	ZPOOL_CONFIG_AUX_STATE, &aux) == 0 &&
	strcmp(aux, "external") == 0)
	vd->vdev_label_aux = VDEV_AUX_EXTERNAL;
	else
	vd->vdev_faulted = 0ULL;
	}
	}
	}

	/*
	* Add ourselves to the parent's list of children.
	*/
	vdev_add_child(parent, vd);

	*vdp = vd;

	return (0);
	}

	void
	vdev_free(vdev_t *vd)
	{
	spa_t *spa = vd->vdev_spa;

	ASSERT3P(vd->vdev_initialize_thread, ==, NULL);
	ASSERT3P(vd->vdev_trim_thread, ==, NULL);
	ASSERT3P(vd->vdev_autotrim_thread, ==, NULL);
	ASSERT3P(vd->vdev_rebuild_thread, ==, NULL);

	/*
	* Scan queues are normally destroyed at the end of a scan. If the
	* queue exists here, that implies the vdev is being removed while
	* the scan is still running.
	*/
	if (vd->vdev_scan_io_queue != NULL) {
	mutex_enter(&vd->vdev_scan_io_queue_lock);
	dsl_scan_io_queue_destroy(vd->vdev_scan_io_queue);
	vd->vdev_scan_io_queue = NULL;
	mutex_exit(&vd->vdev_scan_io_queue_lock);
	}

	/*
	* vdev_free() implies closing the vdev first. This is simpler than
	* trying to ensure complicated semantics for all callers.
	*/
	vdev_close(vd);

	ASSERT(!list_link_active(&vd->vdev_config_dirty_node));
	ASSERT(!list_link_active(&vd->vdev_state_dirty_node));

	/*
	* Free all children.
	*/
	for (int c = 0; c < vd->vdev_children; c++)
	vdev_free(vd->vdev_child[c]);

	ASSERT(vd->vdev_child == NULL);
	ASSERT(vd->vdev_guid_sum == vd->vdev_guid);

	if (vd->vdev_ops->vdev_op_fini != NULL)
	vd->vdev_ops->vdev_op_fini(vd);

	/*
	* Discard allocation state.
	*/
	if (vd->vdev_mg != NULL) {
	vdev_metaslab_fini(vd);
	metaslab_group_destroy(vd->vdev_mg);
	vd->vdev_mg = NULL;
	}
	if (vd->vdev_log_mg != NULL) {
	ASSERT0(vd->vdev_ms_count);
	metaslab_group_destroy(vd->vdev_log_mg);
	vd->vdev_log_mg = NULL;
	}

	ASSERT0(vd->vdev_stat.vs_space);
	ASSERT0(vd->vdev_stat.vs_dspace);
	ASSERT0(vd->vdev_stat.vs_alloc);

	/*
	* Remove this vdev from its parent's child list.
	*/
	vdev_remove_child(vd->vdev_parent, vd);

	ASSERT(vd->vdev_parent == NULL);
	ASSERT(!list_link_active(&vd->vdev_leaf_node));

	/*
	* Clean up vdev structure.
	*/
	vdev_queue_fini(vd);
	vdev_cache_fini(vd);

	if (vd->vdev_path)
	spa_strfree(vd->vdev_path);
	if (vd->vdev_devid)
	spa_strfree(vd->vdev_devid);
	if (vd->vdev_physpath)
	spa_strfree(vd->vdev_physpath);

	if (vd->vdev_enc_sysfs_path)
	spa_strfree(vd->vdev_enc_sysfs_path);

	if (vd->vdev_fru)
	spa_strfree(vd->vdev_fru);

	if (vd->vdev_isspare)
	spa_spare_remove(vd);
	if (vd->vdev_isl2cache)
	spa_l2cache_remove(vd);

	txg_list_destroy(&vd->vdev_ms_list);
	txg_list_destroy(&vd->vdev_dtl_list);

	mutex_enter(&vd->vdev_dtl_lock);
	space_map_close(vd->vdev_dtl_sm);
	for (int t = 0; t < DTL_TYPES; t++) {
	range_tree_vacate(vd->vdev_dtl[t], NULL, NULL);
	range_tree_destroy(vd->vdev_dtl[t]);
	}
	mutex_exit(&vd->vdev_dtl_lock);

	EQUIV(vd->vdev_indirect_births != NULL,
	vd->vdev_indirect_mapping != NULL);
	if (vd->vdev_indirect_births != NULL) {
	vdev_indirect_mapping_close(vd->vdev_indirect_mapping);
	vdev_indirect_births_close(vd->vdev_indirect_births);
	}

	if (vd->vdev_obsolete_sm != NULL) {
	ASSERT(vd->vdev_removing \|\|
	vd->vdev_ops == &vdev_indirect_ops);
	space_map_close(vd->vdev_obsolete_sm);
	vd->vdev_obsolete_sm = NULL;
	}
	range_tree_destroy(vd->vdev_obsolete_segments);
	rw_destroy(&vd->vdev_indirect_rwlock);
	mutex_destroy(&vd->vdev_obsolete_lock);

	mutex_destroy(&vd->vdev_dtl_lock);
	mutex_destroy(&vd->vdev_stat_lock);
	mutex_destroy(&vd->vdev_probe_lock);
	mutex_destroy(&vd->vdev_scan_io_queue_lock);

	mutex_destroy(&vd->vdev_initialize_lock);
	mutex_destroy(&vd->vdev_initialize_io_lock);
	cv_destroy(&vd->vdev_initialize_io_cv);
	cv_destroy(&vd->vdev_initialize_cv);

	mutex_destroy(&vd->vdev_trim_lock);
	mutex_destroy(&vd->vdev_autotrim_lock);
	mutex_destroy(&vd->vdev_trim_io_lock);
	cv_destroy(&vd->vdev_trim_cv);
	cv_destroy(&vd->vdev_autotrim_cv);
	cv_destroy(&vd->vdev_trim_io_cv);

	mutex_destroy(&vd->vdev_rebuild_lock);
	cv_destroy(&vd->vdev_rebuild_cv);

	zfs_ratelimit_fini(&vd->vdev_delay_rl);
	+ zfs_ratelimit_fini(&vd->vdev_deadman_rl);
	zfs_ratelimit_fini(&vd->vdev_checksum_rl);

	if (vd == spa->spa_root_vdev)
	spa->spa_root_vdev = NULL;

	kmem_free(vd, sizeof (vdev_t));
	}

	/*
	* Transfer top-level vdev state from svd to tvd.
	*/
	static void
	vdev_top_transfer(vdev_t svd, vdev_t tvd)
	{
	spa_t *spa = svd->vdev_spa;
	metaslab_t *msp;
	vdev_t *vd;
	int t;

	ASSERT(tvd == tvd->vdev_top);

	tvd->vdev_pending_fastwrite = svd->vdev_pending_fastwrite;
	tvd->vdev_ms_array = svd->vdev_ms_array;
	tvd->vdev_ms_shift = svd->vdev_ms_shift;
	tvd->vdev_ms_count = svd->vdev_ms_count;
	tvd->vdev_top_zap = svd->vdev_top_zap;

	svd->vdev_ms_array = 0;
	svd->vdev_ms_shift = 0;
	svd->vdev_ms_count = 0;
	svd->vdev_top_zap = 0;

	if (tvd->vdev_mg)
	ASSERT3P(tvd->vdev_mg, ==, svd->vdev_mg);
	if (tvd->vdev_log_mg)
	ASSERT3P(tvd->vdev_log_mg, ==, svd->vdev_log_mg);
	tvd->vdev_mg = svd->vdev_mg;
	tvd->vdev_log_mg = svd->vdev_log_mg;
	tvd->vdev_ms = svd->vdev_ms;

	svd->vdev_mg = NULL;
	svd->vdev_log_mg = NULL;
	svd->vdev_ms = NULL;

	if (tvd->vdev_mg != NULL)
	tvd->vdev_mg->mg_vd = tvd;
	if (tvd->vdev_log_mg != NULL)
	tvd->vdev_log_mg->mg_vd = tvd;

	tvd->vdev_checkpoint_sm = svd->vdev_checkpoint_sm;
	svd->vdev_checkpoint_sm = NULL;

	tvd->vdev_alloc_bias = svd->vdev_alloc_bias;
	svd->vdev_alloc_bias = VDEV_BIAS_NONE;

	tvd->vdev_stat.vs_alloc = svd->vdev_stat.vs_alloc;
	tvd->vdev_stat.vs_space = svd->vdev_stat.vs_space;
	tvd->vdev_stat.vs_dspace = svd->vdev_stat.vs_dspace;

	svd->vdev_stat.vs_alloc = 0;
	svd->vdev_stat.vs_space = 0;
	svd->vdev_stat.vs_dspace = 0;

	/*
	* State which may be set on a top-level vdev that's in the
	* process of being removed.
	*/
	ASSERT0(tvd->vdev_indirect_config.vic_births_object);
	ASSERT0(tvd->vdev_indirect_config.vic_mapping_object);
	ASSERT3U(tvd->vdev_indirect_config.vic_prev_indirect_vdev, ==, -1ULL);
	ASSERT3P(tvd->vdev_indirect_mapping, ==, NULL);
	ASSERT3P(tvd->vdev_indirect_births, ==, NULL);
	ASSERT3P(tvd->vdev_obsolete_sm, ==, NULL);
	ASSERT0(tvd->vdev_removing);
	ASSERT0(tvd->vdev_rebuilding);
	tvd->vdev_removing = svd->vdev_removing;
	tvd->vdev_rebuilding = svd->vdev_rebuilding;
	tvd->vdev_rebuild_config = svd->vdev_rebuild_config;
	tvd->vdev_indirect_config = svd->vdev_indirect_config;
	tvd->vdev_indirect_mapping = svd->vdev_indirect_mapping;
	tvd->vdev_indirect_births = svd->vdev_indirect_births;
	range_tree_swap(&svd->vdev_obsolete_segments,
	&tvd->vdev_obsolete_segments);
	tvd->vdev_obsolete_sm = svd->vdev_obsolete_sm;
	svd->vdev_indirect_config.vic_mapping_object = 0;
	svd->vdev_indirect_config.vic_births_object = 0;
	svd->vdev_indirect_config.vic_prev_indirect_vdev = -1ULL;
	svd->vdev_indirect_mapping = NULL;
	svd->vdev_indirect_births = NULL;
	svd->vdev_obsolete_sm = NULL;
	svd->vdev_removing = 0;
	svd->vdev_rebuilding = 0;

	for (t = 0; t < TXG_SIZE; t++) {
	while ((msp = txg_list_remove(&svd->vdev_ms_list, t)) != NULL)
	(void) txg_list_add(&tvd->vdev_ms_list, msp, t);
	while ((vd = txg_list_remove(&svd->vdev_dtl_list, t)) != NULL)
	(void) txg_list_add(&tvd->vdev_dtl_list, vd, t);
	if (txg_list_remove_this(&spa->spa_vdev_txg_list, svd, t))
	(void) txg_list_add(&spa->spa_vdev_txg_list, tvd, t);
	}

	if (list_link_active(&svd->vdev_config_dirty_node)) {
	vdev_config_clean(svd);
	vdev_config_dirty(tvd);
	}

	if (list_link_active(&svd->vdev_state_dirty_node)) {
	vdev_state_clean(svd);
	vdev_state_dirty(tvd);
	}

	tvd->vdev_deflate_ratio = svd->vdev_deflate_ratio;
	svd->vdev_deflate_ratio = 0;

	tvd->vdev_islog = svd->vdev_islog;
	svd->vdev_islog = 0;

	dsl_scan_io_queue_vdev_xfer(svd, tvd);
	}

	static void
	vdev_top_update(vdev_t tvd, vdev_t vd)
	{
	if (vd == NULL)
	return;

	vd->vdev_top = tvd;

	for (int c = 0; c < vd->vdev_children; c++)
	vdev_top_update(tvd, vd->vdev_child[c]);
	}

	/*
	* Add a mirror/replacing vdev above an existing vdev. There is no need to
	* call .vdev_op_init() since mirror/replacing vdevs do not have private state.
	*/
	vdev_t *
	vdev_add_parent(vdev_t cvd, vdev_ops_t ops)
	{
	spa_t *spa = cvd->vdev_spa;
	vdev_t *pvd = cvd->vdev_parent;
	vdev_t *mvd;

	ASSERT(spa_config_held(spa, SCL_ALL, RW_WRITER) == SCL_ALL);

	mvd = vdev_alloc_common(spa, cvd->vdev_id, 0, ops);

	mvd->vdev_asize = cvd->vdev_asize;
	mvd->vdev_min_asize = cvd->vdev_min_asize;
	mvd->vdev_max_asize = cvd->vdev_max_asize;
	mvd->vdev_psize = cvd->vdev_psize;
	mvd->vdev_ashift = cvd->vdev_ashift;
	mvd->vdev_logical_ashift = cvd->vdev_logical_ashift;
	mvd->vdev_physical_ashift = cvd->vdev_physical_ashift;
	mvd->vdev_state = cvd->vdev_state;
	mvd->vdev_crtxg = cvd->vdev_crtxg;

	vdev_remove_child(pvd, cvd);
	vdev_add_child(pvd, mvd);
	cvd->vdev_id = mvd->vdev_children;
	vdev_add_child(mvd, cvd);
	vdev_top_update(cvd->vdev_top, cvd->vdev_top);

	if (mvd == mvd->vdev_top)
	vdev_top_transfer(cvd, mvd);

	return (mvd);
	}

	/*
	* Remove a 1-way mirror/replacing vdev from the tree.
	*/
	void
	vdev_remove_parent(vdev_t *cvd)
	{
	vdev_t *mvd = cvd->vdev_parent;
	vdev_t *pvd = mvd->vdev_parent;

	ASSERT(spa_config_held(cvd->vdev_spa, SCL_ALL, RW_WRITER) == SCL_ALL);

	ASSERT(mvd->vdev_children == 1);
	ASSERT(mvd->vdev_ops == &vdev_mirror_ops \|\|
	mvd->vdev_ops == &vdev_replacing_ops \|\|
	mvd->vdev_ops == &vdev_spare_ops);
	cvd->vdev_ashift = mvd->vdev_ashift;
	cvd->vdev_logical_ashift = mvd->vdev_logical_ashift;
	cvd->vdev_physical_ashift = mvd->vdev_physical_ashift;
	vdev_remove_child(mvd, cvd);
	vdev_remove_child(pvd, mvd);

	/*
	* If cvd will replace mvd as a top-level vdev, preserve mvd's guid.
	* Otherwise, we could have detached an offline device, and when we
	* go to import the pool we'll think we have two top-level vdevs,
	* instead of a different version of the same top-level vdev.
	*/
	if (mvd->vdev_top == mvd) {
	uint64_t guid_delta = mvd->vdev_guid - cvd->vdev_guid;
	cvd->vdev_orig_guid = cvd->vdev_guid;
	cvd->vdev_guid += guid_delta;
	cvd->vdev_guid_sum += guid_delta;

	/*
	* If pool not set for autoexpand, we need to also preserve
	* mvd's asize to prevent automatic expansion of cvd.
	* Otherwise if we are adjusting the mirror by attaching and
	* detaching children of non-uniform sizes, the mirror could
	* autoexpand, unexpectedly requiring larger devices to
	* re-establish the mirror.
	*/
	if (!cvd->vdev_spa->spa_autoexpand)
	cvd->vdev_asize = mvd->vdev_asize;
	}
	cvd->vdev_id = mvd->vdev_id;
	vdev_add_child(pvd, cvd);
	vdev_top_update(cvd->vdev_top, cvd->vdev_top);

	if (cvd == cvd->vdev_top)
	vdev_top_transfer(mvd, cvd);

	ASSERT(mvd->vdev_children == 0);
	vdev_free(mvd);
	}

	void
	vdev_metaslab_group_create(vdev_t *vd)
	{
	spa_t *spa = vd->vdev_spa;

	/*
	* metaslab_group_create was delayed until allocation bias was available
	*/
	if (vd->vdev_mg == NULL) {
	metaslab_class_t *mc;

	if (vd->vdev_islog && vd->vdev_alloc_bias == VDEV_BIAS_NONE)
	vd->vdev_alloc_bias = VDEV_BIAS_LOG;

	ASSERT3U(vd->vdev_islog, ==,
	(vd->vdev_alloc_bias == VDEV_BIAS_LOG));

	switch (vd->vdev_alloc_bias) {
	case VDEV_BIAS_LOG:
	mc = spa_log_class(spa);
	break;
	case VDEV_BIAS_SPECIAL:
	mc = spa_special_class(spa);
	break;
	case VDEV_BIAS_DEDUP:
	mc = spa_dedup_class(spa);
	break;
	default:
	mc = spa_normal_class(spa);
	}

	vd->vdev_mg = metaslab_group_create(mc, vd,
	spa->spa_alloc_count);

	if (!vd->vdev_islog) {
	vd->vdev_log_mg = metaslab_group_create(
	spa_embedded_log_class(spa), vd, 1);
	}

	/*
	* The spa ashift min/max only apply for the normal metaslab
	- * class. Class destination is late binding so ashift boundry
	+ * class. Class destination is late binding so ashift boundary
	* setting had to wait until now.
	*/
	if (vd->vdev_top == vd && vd->vdev_ashift != 0 &&
	mc == spa_normal_class(spa) && vd->vdev_aux == NULL) {
	if (vd->vdev_ashift > spa->spa_max_ashift)
	spa->spa_max_ashift = vd->vdev_ashift;
	if (vd->vdev_ashift < spa->spa_min_ashift)
	spa->spa_min_ashift = vd->vdev_ashift;

	uint64_t min_alloc = vdev_get_min_alloc(vd);
	if (min_alloc < spa->spa_min_alloc)
	spa->spa_min_alloc = min_alloc;
	}
	}
	}

	int
	vdev_metaslab_init(vdev_t *vd, uint64_t txg)
	{
	spa_t *spa = vd->vdev_spa;
	uint64_t oldc = vd->vdev_ms_count;
	uint64_t newc = vd->vdev_asize >> vd->vdev_ms_shift;
	metaslab_t **mspp;
	int error;
	boolean_t expanding = (oldc != 0);

	ASSERT(txg == 0 \|\| spa_config_held(spa, SCL_ALLOC, RW_WRITER));

	/*
	* This vdev is not being allocated from yet or is a hole.
	*/
	if (vd->vdev_ms_shift == 0)
	return (0);

	ASSERT(!vd->vdev_ishole);

	ASSERT(oldc <= newc);

	mspp = vmem_zalloc(newc * sizeof (*mspp), KM_SLEEP);

	if (expanding) {
	bcopy(vd->vdev_ms, mspp, oldc * sizeof (*mspp));
	vmem_free(vd->vdev_ms, oldc * sizeof (*mspp));
	}

	vd->vdev_ms = mspp;
	vd->vdev_ms_count = newc;

	for (uint64_t m = oldc; m < newc; m++) {
	uint64_t object = 0;
	/*
	* vdev_ms_array may be 0 if we are creating the "fake"
	* metaslabs for an indirect vdev for zdb's leak detection.
	* See zdb_leak_init().
	*/
	if (txg == 0 && vd->vdev_ms_array != 0) {
	error = dmu_read(spa->spa_meta_objset,
	vd->vdev_ms_array,
	m * sizeof (uint64_t), sizeof (uint64_t), &object,
	DMU_READ_PREFETCH);
	if (error != 0) {
	vdev_dbgmsg(vd, "unable to read the metaslab "
	"array [error=%d]", error);
	return (error);
	}
	}

	error = metaslab_init(vd->vdev_mg, m, object, txg,
	&(vd->vdev_ms[m]));
	if (error != 0) {
	vdev_dbgmsg(vd, "metaslab_init failed [error=%d]",
	error);
	return (error);
	}
	}

	/*
	* Find the emptiest metaslab on the vdev and mark it for use for
	* embedded slog by moving it from the regular to the log metaslab
	* group.
	*/
	if (vd->vdev_mg->mg_class == spa_normal_class(spa) &&
	vd->vdev_ms_count > zfs_embedded_slog_min_ms &&
	avl_is_empty(&vd->vdev_log_mg->mg_metaslab_tree)) {
	uint64_t slog_msid = 0;
	uint64_t smallest = UINT64_MAX;

	/*
	* Note, we only search the new metaslabs, because the old
	* (pre-existing) ones may be active (e.g. have non-empty
	* range_tree's), and we don't move them to the new
	* metaslab_t.
	*/
	for (uint64_t m = oldc; m < newc; m++) {
	uint64_t alloc =
	space_map_allocated(vd->vdev_ms[m]->ms_sm);
	if (alloc < smallest) {
	slog_msid = m;
	smallest = alloc;
	}
	}
	metaslab_t *slog_ms = vd->vdev_ms[slog_msid];
	/*
	* The metaslab was marked as dirty at the end of
	* metaslab_init(). Remove it from the dirty list so that we
	* can uninitialize and reinitialize it to the new class.
	*/
	if (txg != 0) {
	(void) txg_list_remove_this(&vd->vdev_ms_list,
	slog_ms, txg);
	}
	uint64_t sm_obj = space_map_object(slog_ms->ms_sm);
	metaslab_fini(slog_ms);
	VERIFY0(metaslab_init(vd->vdev_log_mg, slog_msid, sm_obj, txg,
	&vd->vdev_ms[slog_msid]));
	}

	if (txg == 0)
	spa_config_enter(spa, SCL_ALLOC, FTAG, RW_WRITER);

	/*
	* If the vdev is being removed we don't activate
	* the metaslabs since we want to ensure that no new
	* allocations are performed on this device.
	*/
	if (!expanding && !vd->vdev_removing) {
	metaslab_group_activate(vd->vdev_mg);
	if (vd->vdev_log_mg != NULL)
	metaslab_group_activate(vd->vdev_log_mg);
	}

	if (txg == 0)
	spa_config_exit(spa, SCL_ALLOC, FTAG);

	/*
	* Regardless whether this vdev was just added or it is being
	* expanded, the metaslab count has changed. Recalculate the
	* block limit.
	*/
	spa_log_sm_set_blocklimit(spa);

	return (0);
	}

	void
	vdev_metaslab_fini(vdev_t *vd)
	{
	if (vd->vdev_checkpoint_sm != NULL) {
	ASSERT(spa_feature_is_active(vd->vdev_spa,
	SPA_FEATURE_POOL_CHECKPOINT));
	space_map_close(vd->vdev_checkpoint_sm);
	/*
	* Even though we close the space map, we need to set its
	* pointer to NULL. The reason is that vdev_metaslab_fini()
	* may be called multiple times for certain operations
	* (i.e. when destroying a pool) so we need to ensure that
	* this clause never executes twice. This logic is similar
	* to the one used for the vdev_ms clause below.
	*/
	vd->vdev_checkpoint_sm = NULL;
	}

	if (vd->vdev_ms != NULL) {
	metaslab_group_t *mg = vd->vdev_mg;

	metaslab_group_passivate(mg);
	if (vd->vdev_log_mg != NULL) {
	ASSERT(!vd->vdev_islog);
	metaslab_group_passivate(vd->vdev_log_mg);
	}

	uint64_t count = vd->vdev_ms_count;
	for (uint64_t m = 0; m < count; m++) {
	metaslab_t *msp = vd->vdev_ms[m];
	if (msp != NULL)
	metaslab_fini(msp);
	}
	vmem_free(vd->vdev_ms, count * sizeof (metaslab_t *));
	vd->vdev_ms = NULL;
	vd->vdev_ms_count = 0;

	for (int i = 0; i < RANGE_TREE_HISTOGRAM_SIZE; i++) {
	ASSERT0(mg->mg_histogram[i]);
	if (vd->vdev_log_mg != NULL)
	ASSERT0(vd->vdev_log_mg->mg_histogram[i]);
	}
	}
	ASSERT0(vd->vdev_ms_count);
	ASSERT3U(vd->vdev_pending_fastwrite, ==, 0);
	}

	typedef struct vdev_probe_stats {
	boolean_t vps_readable;
	boolean_t vps_writeable;
	int vps_flags;
	} vdev_probe_stats_t;

	static void
	vdev_probe_done(zio_t *zio)
	{
	spa_t *spa = zio->io_spa;
	vdev_t *vd = zio->io_vd;
	vdev_probe_stats_t *vps = zio->io_private;

	ASSERT(vd->vdev_probe_zio != NULL);

	if (zio->io_type == ZIO_TYPE_READ) {
	if (zio->io_error == 0)
	vps->vps_readable = 1;
	if (zio->io_error == 0 && spa_writeable(spa)) {
	zio_nowait(zio_write_phys(vd->vdev_probe_zio, vd,
	zio->io_offset, zio->io_size, zio->io_abd,
	ZIO_CHECKSUM_OFF, vdev_probe_done, vps,
	ZIO_PRIORITY_SYNC_WRITE, vps->vps_flags, B_TRUE));
	} else {
	abd_free(zio->io_abd);
	}
	} else if (zio->io_type == ZIO_TYPE_WRITE) {
	if (zio->io_error == 0)
	vps->vps_writeable = 1;
	abd_free(zio->io_abd);
	} else if (zio->io_type == ZIO_TYPE_NULL) {
	zio_t *pio;
	zio_link_t *zl;

	vd->vdev_cant_read \|= !vps->vps_readable;
	vd->vdev_cant_write \|= !vps->vps_writeable;

	if (vdev_readable(vd) &&
	(vdev_writeable(vd) \|\| !spa_writeable(spa))) {
	zio->io_error = 0;
	} else {
	ASSERT(zio->io_error != 0);
	vdev_dbgmsg(vd, "failed probe");
	(void) zfs_ereport_post(FM_EREPORT_ZFS_PROBE_FAILURE,
	spa, vd, NULL, NULL, 0);
	zio->io_error = SET_ERROR(ENXIO);
	}

	mutex_enter(&vd->vdev_probe_lock);
	ASSERT(vd->vdev_probe_zio == zio);
	vd->vdev_probe_zio = NULL;
	mutex_exit(&vd->vdev_probe_lock);

	zl = NULL;
	while ((pio = zio_walk_parents(zio, &zl)) != NULL)
	if (!vdev_accessible(vd, pio))
	pio->io_error = SET_ERROR(ENXIO);

	kmem_free(vps, sizeof (*vps));
	}
	}

	/*
	* Determine whether this device is accessible.
	*
	* Read and write to several known locations: the pad regions of each
	* vdev label but the first, which we leave alone in case it contains
	* a VTOC.
	*/
	zio_t *
	vdev_probe(vdev_t vd, zio_t zio)
	{
	spa_t *spa = vd->vdev_spa;
	vdev_probe_stats_t *vps = NULL;
	zio_t *pio;

	ASSERT(vd->vdev_ops->vdev_op_leaf);

	/*
	* Don't probe the probe.
	*/
	if (zio && (zio->io_flags & ZIO_FLAG_PROBE))
	return (NULL);

	/*
	* To prevent 'probe storms' when a device fails, we create
	* just one probe i/o at a time. All zios that want to probe
	* this vdev will become parents of the probe io.
	*/
	mutex_enter(&vd->vdev_probe_lock);

	if ((pio = vd->vdev_probe_zio) == NULL) {
	vps = kmem_zalloc(sizeof (*vps), KM_SLEEP);

	vps->vps_flags = ZIO_FLAG_CANFAIL \| ZIO_FLAG_PROBE \|
	ZIO_FLAG_DONT_CACHE \| ZIO_FLAG_DONT_AGGREGATE \|
	ZIO_FLAG_TRYHARD;

	if (spa_config_held(spa, SCL_ZIO, RW_WRITER)) {
	/*
	* vdev_cant_read and vdev_cant_write can only
	* transition from TRUE to FALSE when we have the
	* SCL_ZIO lock as writer; otherwise they can only
	* transition from FALSE to TRUE. This ensures that
	* any zio looking at these values can assume that
	* failures persist for the life of the I/O. That's
	* important because when a device has intermittent
	* connectivity problems, we want to ensure that
	* they're ascribed to the device (ENXIO) and not
	* the zio (EIO).
	*
	* Since we hold SCL_ZIO as writer here, clear both
	* values so the probe can reevaluate from first
	* principles.
	*/
	vps->vps_flags \|= ZIO_FLAG_CONFIG_WRITER;
	vd->vdev_cant_read = B_FALSE;
	vd->vdev_cant_write = B_FALSE;
	}

	vd->vdev_probe_zio = pio = zio_null(NULL, spa, vd,
	vdev_probe_done, vps,
	vps->vps_flags \| ZIO_FLAG_DONT_PROPAGATE);

	/*
	* We can't change the vdev state in this context, so we
	* kick off an async task to do it on our behalf.
	*/
	if (zio != NULL) {
	vd->vdev_probe_wanted = B_TRUE;
	spa_async_request(spa, SPA_ASYNC_PROBE);
	}
	}

	if (zio != NULL)
	zio_add_child(zio, pio);

	mutex_exit(&vd->vdev_probe_lock);

	if (vps == NULL) {
	ASSERT(zio != NULL);
	return (NULL);
	}

	for (int l = 1; l < VDEV_LABELS; l++) {
	zio_nowait(zio_read_phys(pio, vd,
	vdev_label_offset(vd->vdev_psize, l,
	offsetof(vdev_label_t, vl_be)), VDEV_PAD_SIZE,
	abd_alloc_for_io(VDEV_PAD_SIZE, B_TRUE),
	ZIO_CHECKSUM_OFF, vdev_probe_done, vps,
	ZIO_PRIORITY_SYNC_READ, vps->vps_flags, B_TRUE));
	}

	if (zio == NULL)
	return (pio);

	zio_nowait(pio);
	return (NULL);
	}

	static void
	vdev_load_child(void *arg)
	{
	vdev_t *vd = arg;

	vd->vdev_load_error = vdev_load(vd);
	}

	static void
	vdev_open_child(void *arg)
	{
	vdev_t *vd = arg;

	vd->vdev_open_thread = curthread;
	vd->vdev_open_error = vdev_open(vd);
	vd->vdev_open_thread = NULL;
	}

	static boolean_t
	vdev_uses_zvols(vdev_t *vd)
	{
	#ifdef _KERNEL
	if (zvol_is_zvol(vd->vdev_path))
	return (B_TRUE);
	#endif

	for (int c = 0; c < vd->vdev_children; c++)
	if (vdev_uses_zvols(vd->vdev_child[c]))
	return (B_TRUE);

	return (B_FALSE);
	}

	/*
	* Returns B_TRUE if the passed child should be opened.
	*/
	static boolean_t
	vdev_default_open_children_func(vdev_t *vd)
	{
	return (B_TRUE);
	}

	/*
	* Open the requested child vdevs. If any of the leaf vdevs are using
	* a ZFS volume then do the opens in a single thread. This avoids a
	* deadlock when the current thread is holding the spa_namespace_lock.
	*/
	static void
	vdev_open_children_impl(vdev_t vd, vdev_open_children_func_t open_func)
	{
	int children = vd->vdev_children;

	taskq_t *tq = taskq_create("vdev_open", children, minclsyspri,
	children, children, TASKQ_PREPOPULATE);
	vd->vdev_nonrot = B_TRUE;

	for (int c = 0; c < children; c++) {
	vdev_t *cvd = vd->vdev_child[c];

	if (open_func(cvd) == B_FALSE)
	continue;

	if (tq == NULL \|\| vdev_uses_zvols(vd)) {
	cvd->vdev_open_error = vdev_open(cvd);
	} else {
	VERIFY(taskq_dispatch(tq, vdev_open_child,
	cvd, TQ_SLEEP) != TASKQID_INVALID);
	}

	vd->vdev_nonrot &= cvd->vdev_nonrot;
	}

	if (tq != NULL) {
	taskq_wait(tq);
	taskq_destroy(tq);
	}
	}

	/*
	* Open all child vdevs.
	*/
	void
	vdev_open_children(vdev_t *vd)
	{
	vdev_open_children_impl(vd, vdev_default_open_children_func);
	}

	/*
	* Conditionally open a subset of child vdevs.
	*/
	void
	vdev_open_children_subset(vdev_t vd, vdev_open_children_func_t open_func)
	{
	vdev_open_children_impl(vd, open_func);
	}

	/*
	* Compute the raidz-deflation ratio. Note, we hard-code
	* in 128k (1 << 17) because it is the "typical" blocksize.
	* Even though SPA_MAXBLOCKSIZE changed, this algorithm can not change,
	* otherwise it would inconsistently account for existing bp's.
	*/
	static void
	vdev_set_deflate_ratio(vdev_t *vd)
	{
	if (vd == vd->vdev_top && !vd->vdev_ishole && vd->vdev_ashift != 0) {
	vd->vdev_deflate_ratio = (1 << 17) /
	(vdev_psize_to_asize(vd, 1 << 17) >> SPA_MINBLOCKSHIFT);
	}
	}

	/*
	* Maximize performance by inflating the configured ashift for top level
	* vdevs to be as close to the physical ashift as possible while maintaining
	* administrator defined limits and ensuring it doesn't go below the
	* logical ashift.
	*/
	static void
	vdev_ashift_optimize(vdev_t *vd)
	{
	ASSERT(vd == vd->vdev_top);

	if (vd->vdev_ashift < vd->vdev_physical_ashift) {
	vd->vdev_ashift = MIN(
	MAX(zfs_vdev_max_auto_ashift, vd->vdev_ashift),
	MAX(zfs_vdev_min_auto_ashift,
	vd->vdev_physical_ashift));
	} else {
	/*
	* If the logical and physical ashifts are the same, then
	* we ensure that the top-level vdev's ashift is not smaller
	* than our minimum ashift value. For the unusual case
	* where logical ashift > physical ashift, we can't cap
	* the calculated ashift based on max ashift as that
	* would cause failures.
	* We still check if we need to increase it to match
	* the min ashift.
	*/
	vd->vdev_ashift = MAX(zfs_vdev_min_auto_ashift,
	vd->vdev_ashift);
	}
	}

	/*
	* Prepare a virtual device for access.
	*/
	int
	vdev_open(vdev_t *vd)
	{
	spa_t *spa = vd->vdev_spa;
	int error;
	uint64_t osize = 0;
	uint64_t max_osize = 0;
	uint64_t asize, max_asize, psize;
	uint64_t logical_ashift = 0;
	uint64_t physical_ashift = 0;

	ASSERT(vd->vdev_open_thread == curthread \|\|
	spa_config_held(spa, SCL_STATE_ALL, RW_WRITER) == SCL_STATE_ALL);
	ASSERT(vd->vdev_state == VDEV_STATE_CLOSED \|\|
	vd->vdev_state == VDEV_STATE_CANT_OPEN \|\|
	vd->vdev_state == VDEV_STATE_OFFLINE);

	vd->vdev_stat.vs_aux = VDEV_AUX_NONE;
	vd->vdev_cant_read = B_FALSE;
	vd->vdev_cant_write = B_FALSE;
	vd->vdev_min_asize = vdev_get_min_asize(vd);

	/*
	* If this vdev is not removed, check its fault status. If it's
	* faulted, bail out of the open.
	*/
	if (!vd->vdev_removed && vd->vdev_faulted) {
	ASSERT(vd->vdev_children == 0);
	ASSERT(vd->vdev_label_aux == VDEV_AUX_ERR_EXCEEDED \|\|
	vd->vdev_label_aux == VDEV_AUX_EXTERNAL);
	vdev_set_state(vd, B_TRUE, VDEV_STATE_FAULTED,
	vd->vdev_label_aux);
	return (SET_ERROR(ENXIO));
	} else if (vd->vdev_offline) {
	ASSERT(vd->vdev_children == 0);
	vdev_set_state(vd, B_TRUE, VDEV_STATE_OFFLINE, VDEV_AUX_NONE);
	return (SET_ERROR(ENXIO));
	}

	error = vd->vdev_ops->vdev_op_open(vd, &osize, &max_osize,
	&logical_ashift, &physical_ashift);
	/*
	* Physical volume size should never be larger than its max size, unless
	* the disk has shrunk while we were reading it or the device is buggy
	* or damaged: either way it's not safe for use, bail out of the open.
	*/
	if (osize > max_osize) {
	vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN,
	VDEV_AUX_OPEN_FAILED);
	return (SET_ERROR(ENXIO));
	}

	/*
	* Reset the vdev_reopening flag so that we actually close
	* the vdev on error.
	*/
	vd->vdev_reopening = B_FALSE;
	if (zio_injection_enabled && error == 0)
	error = zio_handle_device_injection(vd, NULL, SET_ERROR(ENXIO));

	if (error) {
	if (vd->vdev_removed &&
	vd->vdev_stat.vs_aux != VDEV_AUX_OPEN_FAILED)
	vd->vdev_removed = B_FALSE;

	if (vd->vdev_stat.vs_aux == VDEV_AUX_CHILDREN_OFFLINE) {
	vdev_set_state(vd, B_TRUE, VDEV_STATE_OFFLINE,
	vd->vdev_stat.vs_aux);
	} else {
	vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN,
	vd->vdev_stat.vs_aux);
	}
	return (error);
	}

	vd->vdev_removed = B_FALSE;

	/*
	* Recheck the faulted flag now that we have confirmed that
	* the vdev is accessible. If we're faulted, bail.
	*/
	if (vd->vdev_faulted) {
	ASSERT(vd->vdev_children == 0);
	ASSERT(vd->vdev_label_aux == VDEV_AUX_ERR_EXCEEDED \|\|
	vd->vdev_label_aux == VDEV_AUX_EXTERNAL);
	vdev_set_state(vd, B_TRUE, VDEV_STATE_FAULTED,
	vd->vdev_label_aux);
	return (SET_ERROR(ENXIO));
	}

	if (vd->vdev_degraded) {
	ASSERT(vd->vdev_children == 0);
	vdev_set_state(vd, B_TRUE, VDEV_STATE_DEGRADED,
	VDEV_AUX_ERR_EXCEEDED);
	} else {
	vdev_set_state(vd, B_TRUE, VDEV_STATE_HEALTHY, 0);
	}

	/*
	* For hole or missing vdevs we just return success.
	*/
	if (vd->vdev_ishole \|\| vd->vdev_ops == &vdev_missing_ops)
	return (0);

	for (int c = 0; c < vd->vdev_children; c++) {
	if (vd->vdev_child[c]->vdev_state != VDEV_STATE_HEALTHY) {
	vdev_set_state(vd, B_TRUE, VDEV_STATE_DEGRADED,
	VDEV_AUX_NONE);
	break;
	}
	}

	osize = P2ALIGN(osize, (uint64_t)sizeof (vdev_label_t));
	max_osize = P2ALIGN(max_osize, (uint64_t)sizeof (vdev_label_t));

	if (vd->vdev_children == 0) {
	if (osize < SPA_MINDEVSIZE) {
	vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN,
	VDEV_AUX_TOO_SMALL);
	return (SET_ERROR(EOVERFLOW));
	}
	psize = osize;
	asize = osize - (VDEV_LABEL_START_SIZE + VDEV_LABEL_END_SIZE);
	max_asize = max_osize - (VDEV_LABEL_START_SIZE +
	VDEV_LABEL_END_SIZE);
	} else {
	if (vd->vdev_parent != NULL && osize < SPA_MINDEVSIZE -
	(VDEV_LABEL_START_SIZE + VDEV_LABEL_END_SIZE)) {
	vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN,
	VDEV_AUX_TOO_SMALL);
	return (SET_ERROR(EOVERFLOW));
	}
	psize = 0;
	asize = osize;
	max_asize = max_osize;
	}

	/*
	* If the vdev was expanded, record this so that we can re-create the
	* uberblock rings in labels {2,3}, during the next sync.
	*/
	if ((psize > vd->vdev_psize) && (vd->vdev_psize != 0))
	vd->vdev_copy_uberblocks = B_TRUE;

	vd->vdev_psize = psize;

	/*
	* Make sure the allocatable size hasn't shrunk too much.
	*/
	if (asize < vd->vdev_min_asize) {
	vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN,
	VDEV_AUX_BAD_LABEL);
	return (SET_ERROR(EINVAL));
	}

	/*
	* We can always set the logical/physical ashift members since
	* their values are only used to calculate the vdev_ashift when
	* the device is first added to the config. These values should
	* not be used for anything else since they may change whenever
	* the device is reopened and we don't store them in the label.
	*/
	vd->vdev_physical_ashift =
	MAX(physical_ashift, vd->vdev_physical_ashift);
	vd->vdev_logical_ashift = MAX(logical_ashift,
	vd->vdev_logical_ashift);

	if (vd->vdev_asize == 0) {
	/*
	* This is the first-ever open, so use the computed values.
	* For compatibility, a different ashift can be requested.
	*/
	vd->vdev_asize = asize;
	vd->vdev_max_asize = max_asize;

	/*
	- * If the vdev_ashift was not overriden at creation time,
	+ * If the vdev_ashift was not overridden at creation time,
	* then set it the logical ashift and optimize the ashift.
	*/
	if (vd->vdev_ashift == 0) {
	vd->vdev_ashift = vd->vdev_logical_ashift;

	if (vd->vdev_logical_ashift > ASHIFT_MAX) {
	vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN,
	VDEV_AUX_ASHIFT_TOO_BIG);
	return (SET_ERROR(EDOM));
	}

	if (vd->vdev_top == vd) {
	vdev_ashift_optimize(vd);
	}
	}
	if (vd->vdev_ashift != 0 && (vd->vdev_ashift < ASHIFT_MIN \|\|
	vd->vdev_ashift > ASHIFT_MAX)) {
	vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN,
	VDEV_AUX_BAD_ASHIFT);
	return (SET_ERROR(EDOM));
	}
	} else {
	/*
	* Make sure the alignment required hasn't increased.
	*/
	if (vd->vdev_ashift > vd->vdev_top->vdev_ashift &&
	vd->vdev_ops->vdev_op_leaf) {
	(void) zfs_ereport_post(
	FM_EREPORT_ZFS_DEVICE_BAD_ASHIFT,
	spa, vd, NULL, NULL, 0);
	vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN,
	VDEV_AUX_BAD_LABEL);
	return (SET_ERROR(EDOM));
	}
	vd->vdev_max_asize = max_asize;
	}

	/*
	* If all children are healthy we update asize if either:
	* The asize has increased, due to a device expansion caused by dynamic
	* LUN growth or vdev replacement, and automatic expansion is enabled;
	* making the additional space available.
	*
	* The asize has decreased, due to a device shrink usually caused by a
	* vdev replace with a smaller device. This ensures that calculations
	* based of max_asize and asize e.g. esize are always valid. It's safe
	* to do this as we've already validated that asize is greater than
	* vdev_min_asize.
	*/
	if (vd->vdev_state == VDEV_STATE_HEALTHY &&
	((asize > vd->vdev_asize &&
	(vd->vdev_expanding \|\| spa->spa_autoexpand)) \|\|
	(asize < vd->vdev_asize)))
	vd->vdev_asize = asize;

	vdev_set_min_asize(vd);

	/*
	* Ensure we can issue some IO before declaring the
	* vdev open for business.
	*/
	if (vd->vdev_ops->vdev_op_leaf &&
	(error = zio_wait(vdev_probe(vd, NULL))) != 0) {
	vdev_set_state(vd, B_TRUE, VDEV_STATE_FAULTED,
	VDEV_AUX_ERR_EXCEEDED);
	return (error);
	}

	/*
	- * Track the the minimum allocation size.
	+ * Track the minimum allocation size.
	*/
	if (vd->vdev_top == vd && vd->vdev_ashift != 0 &&
	vd->vdev_islog == 0 && vd->vdev_aux == NULL) {
	uint64_t min_alloc = vdev_get_min_alloc(vd);
	if (min_alloc < spa->spa_min_alloc)
	spa->spa_min_alloc = min_alloc;
	}

	/*
	* If this is a leaf vdev, assess whether a resilver is needed.
	* But don't do this if we are doing a reopen for a scrub, since
	* this would just restart the scrub we are already doing.
	*/
	if (vd->vdev_ops->vdev_op_leaf && !spa->spa_scrub_reopen)
	dsl_scan_assess_vdev(spa->spa_dsl_pool, vd);

	return (0);
	}

	static void
	vdev_validate_child(void *arg)
	{
	vdev_t *vd = arg;

	vd->vdev_validate_thread = curthread;
	vd->vdev_validate_error = vdev_validate(vd);
	vd->vdev_validate_thread = NULL;
	}

	/*
	* Called once the vdevs are all opened, this routine validates the label
	* contents. This needs to be done before vdev_load() so that we don't
	* inadvertently do repair I/Os to the wrong device.
	*
	* This function will only return failure if one of the vdevs indicates that it
	* has since been destroyed or exported. This is only possible if
	* /etc/zfs/zpool.cache was readonly at the time. Otherwise, the vdev state
	* will be updated but the function will return 0.
	*/
	int
	vdev_validate(vdev_t *vd)
	{
	spa_t *spa = vd->vdev_spa;
	taskq_t *tq = NULL;
	nvlist_t *label;
	uint64_t guid = 0, aux_guid = 0, top_guid;
	uint64_t state;
	nvlist_t *nvl;
	uint64_t txg;
	int children = vd->vdev_children;

	if (vdev_validate_skip)
	return (0);

	if (children > 0) {
	tq = taskq_create("vdev_validate", children, minclsyspri,
	children, children, TASKQ_PREPOPULATE);
	}

	for (uint64_t c = 0; c < children; c++) {
	vdev_t *cvd = vd->vdev_child[c];

	if (tq == NULL \|\| vdev_uses_zvols(cvd)) {
	vdev_validate_child(cvd);
	} else {
	VERIFY(taskq_dispatch(tq, vdev_validate_child, cvd,
	TQ_SLEEP) != TASKQID_INVALID);
	}
	}
	if (tq != NULL) {
	taskq_wait(tq);
	taskq_destroy(tq);
	}
	for (int c = 0; c < children; c++) {
	int error = vd->vdev_child[c]->vdev_validate_error;

	if (error != 0)
	return (SET_ERROR(EBADF));
	}


	/*
	* If the device has already failed, or was marked offline, don't do
	* any further validation. Otherwise, label I/O will fail and we will
	* overwrite the previous state.
	*/
	if (!vd->vdev_ops->vdev_op_leaf \|\| !vdev_readable(vd))
	return (0);

	/*
	* If we are performing an extreme rewind, we allow for a label that
	* was modified at a point after the current txg.
	* If config lock is not held do not check for the txg. spa_sync could
	* be updating the vdev's label before updating spa_last_synced_txg.
	*/
	if (spa->spa_extreme_rewind \|\| spa_last_synced_txg(spa) == 0 \|\|
	spa_config_held(spa, SCL_CONFIG, RW_WRITER) != SCL_CONFIG)
	txg = UINT64_MAX;
	else
	txg = spa_last_synced_txg(spa);

	if ((label = vdev_label_read_config(vd, txg)) == NULL) {
	- vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN,
	+ vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN,
	VDEV_AUX_BAD_LABEL);
	vdev_dbgmsg(vd, "vdev_validate: failed reading config for "
	"txg %llu", (u_longlong_t)txg);
	return (0);
	}

	/*
	* Determine if this vdev has been split off into another
	* pool. If so, then refuse to open it.
	*/
	if (nvlist_lookup_uint64(label, ZPOOL_CONFIG_SPLIT_GUID,
	&aux_guid) == 0 && aux_guid == spa_guid(spa)) {
	vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN,
	VDEV_AUX_SPLIT_POOL);
	nvlist_free(label);
	vdev_dbgmsg(vd, "vdev_validate: vdev split into other pool");
	return (0);
	}

	if (nvlist_lookup_uint64(label, ZPOOL_CONFIG_POOL_GUID, &guid) != 0) {
	vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN,
	VDEV_AUX_CORRUPT_DATA);
	nvlist_free(label);
	vdev_dbgmsg(vd, "vdev_validate: '%s' missing from label",
	ZPOOL_CONFIG_POOL_GUID);
	return (0);
	}

	/*
	* If config is not trusted then ignore the spa guid check. This is
	* necessary because if the machine crashed during a re-guid the new
	* guid might have been written to all of the vdev labels, but not the
	* cached config. The check will be performed again once we have the
	* trusted config from the MOS.
	*/
	if (spa->spa_trust_config && guid != spa_guid(spa)) {
	vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN,
	VDEV_AUX_CORRUPT_DATA);
	nvlist_free(label);
	vdev_dbgmsg(vd, "vdev_validate: vdev label pool_guid doesn't "
	"match config (%llu != %llu)", (u_longlong_t)guid,
	(u_longlong_t)spa_guid(spa));
	return (0);
	}

	if (nvlist_lookup_nvlist(label, ZPOOL_CONFIG_VDEV_TREE, &nvl)
	!= 0 \|\| nvlist_lookup_uint64(nvl, ZPOOL_CONFIG_ORIG_GUID,
	&aux_guid) != 0)
	aux_guid = 0;

	if (nvlist_lookup_uint64(label, ZPOOL_CONFIG_GUID, &guid) != 0) {
	vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN,
	VDEV_AUX_CORRUPT_DATA);
	nvlist_free(label);
	vdev_dbgmsg(vd, "vdev_validate: '%s' missing from label",
	ZPOOL_CONFIG_GUID);
	return (0);
	}

	if (nvlist_lookup_uint64(label, ZPOOL_CONFIG_TOP_GUID, &top_guid)
	!= 0) {
	vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN,
	VDEV_AUX_CORRUPT_DATA);
	nvlist_free(label);
	vdev_dbgmsg(vd, "vdev_validate: '%s' missing from label",
	ZPOOL_CONFIG_TOP_GUID);
	return (0);
	}

	/*
	* If this vdev just became a top-level vdev because its sibling was
	* detached, it will have adopted the parent's vdev guid -- but the
	* label may or may not be on disk yet. Fortunately, either version
	* of the label will have the same top guid, so if we're a top-level
	* vdev, we can safely compare to that instead.
	* However, if the config comes from a cachefile that failed to update
	* after the detach, a top-level vdev will appear as a non top-level
	* vdev in the config. Also relax the constraints if we perform an
	* extreme rewind.
	*
	* If we split this vdev off instead, then we also check the
	* original pool's guid. We don't want to consider the vdev
	* corrupt if it is partway through a split operation.
	*/
	if (vd->vdev_guid != guid && vd->vdev_guid != aux_guid) {
	boolean_t mismatch = B_FALSE;
	if (spa->spa_trust_config && !spa->spa_extreme_rewind) {
	if (vd != vd->vdev_top \|\| vd->vdev_guid != top_guid)
	mismatch = B_TRUE;
	} else {
	if (vd->vdev_guid != top_guid &&
	vd->vdev_top->vdev_guid != guid)
	mismatch = B_TRUE;
	}

	if (mismatch) {
	vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN,
	VDEV_AUX_CORRUPT_DATA);
	nvlist_free(label);
	vdev_dbgmsg(vd, "vdev_validate: config guid "
	"doesn't match label guid");
	vdev_dbgmsg(vd, "CONFIG: guid %llu, top_guid %llu",
	(u_longlong_t)vd->vdev_guid,
	(u_longlong_t)vd->vdev_top->vdev_guid);
	vdev_dbgmsg(vd, "LABEL: guid %llu, top_guid %llu, "
	"aux_guid %llu", (u_longlong_t)guid,
	(u_longlong_t)top_guid, (u_longlong_t)aux_guid);
	return (0);
	}
	}

	if (nvlist_lookup_uint64(label, ZPOOL_CONFIG_POOL_STATE,
	&state) != 0) {
	vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN,
	VDEV_AUX_CORRUPT_DATA);
	nvlist_free(label);
	vdev_dbgmsg(vd, "vdev_validate: '%s' missing from label",
	ZPOOL_CONFIG_POOL_STATE);
	return (0);
	}

	nvlist_free(label);

	/*
	* If this is a verbatim import, no need to check the
	* state of the pool.
	*/
	if (!(spa->spa_import_flags & ZFS_IMPORT_VERBATIM) &&
	spa_load_state(spa) == SPA_LOAD_OPEN &&
	state != POOL_STATE_ACTIVE) {
	vdev_dbgmsg(vd, "vdev_validate: invalid pool state (%llu) "
	"for spa %s", (u_longlong_t)state, spa->spa_name);
	return (SET_ERROR(EBADF));
	}

	/*
	* If we were able to open and validate a vdev that was
	* previously marked permanently unavailable, clear that state
	* now.
	*/
	if (vd->vdev_not_present)
	vd->vdev_not_present = 0;

	return (0);
	}

	static void
	vdev_copy_path_impl(vdev_t svd, vdev_t dvd)
	{
	if (svd->vdev_path != NULL && dvd->vdev_path != NULL) {
	if (strcmp(svd->vdev_path, dvd->vdev_path) != 0) {
	zfs_dbgmsg("vdev_copy_path: vdev %llu: path changed "
	"from '%s' to '%s'", (u_longlong_t)dvd->vdev_guid,
	dvd->vdev_path, svd->vdev_path);
	spa_strfree(dvd->vdev_path);
	dvd->vdev_path = spa_strdup(svd->vdev_path);
	}
	} else if (svd->vdev_path != NULL) {
	dvd->vdev_path = spa_strdup(svd->vdev_path);
	zfs_dbgmsg("vdev_copy_path: vdev %llu: path set to '%s'",
	(u_longlong_t)dvd->vdev_guid, dvd->vdev_path);
	}
	}

	/*
	* Recursively copy vdev paths from one vdev to another. Source and destination
	* vdev trees must have same geometry otherwise return error. Intended to copy
	* paths from userland config into MOS config.
	*/
	int
	vdev_copy_path_strict(vdev_t svd, vdev_t dvd)
	{
	if ((svd->vdev_ops == &vdev_missing_ops) \|\|
	(svd->vdev_ishole && dvd->vdev_ishole) \|\|
	(dvd->vdev_ops == &vdev_indirect_ops))
	return (0);

	if (svd->vdev_ops != dvd->vdev_ops) {
	vdev_dbgmsg(svd, "vdev_copy_path: vdev type mismatch: %s != %s",
	svd->vdev_ops->vdev_op_type, dvd->vdev_ops->vdev_op_type);
	return (SET_ERROR(EINVAL));
	}

	if (svd->vdev_guid != dvd->vdev_guid) {
	vdev_dbgmsg(svd, "vdev_copy_path: guids mismatch (%llu != "
	"%llu)", (u_longlong_t)svd->vdev_guid,
	(u_longlong_t)dvd->vdev_guid);
	return (SET_ERROR(EINVAL));
	}

	if (svd->vdev_children != dvd->vdev_children) {
	vdev_dbgmsg(svd, "vdev_copy_path: children count mismatch: "
	"%llu != %llu", (u_longlong_t)svd->vdev_children,
	(u_longlong_t)dvd->vdev_children);
	return (SET_ERROR(EINVAL));
	}

	for (uint64_t i = 0; i < svd->vdev_children; i++) {
	int error = vdev_copy_path_strict(svd->vdev_child[i],
	dvd->vdev_child[i]);
	if (error != 0)
	return (error);
	}

	if (svd->vdev_ops->vdev_op_leaf)
	vdev_copy_path_impl(svd, dvd);

	return (0);
	}

	static void
	vdev_copy_path_search(vdev_t stvd, vdev_t dvd)
	{
	ASSERT(stvd->vdev_top == stvd);
	ASSERT3U(stvd->vdev_id, ==, dvd->vdev_top->vdev_id);

	for (uint64_t i = 0; i < dvd->vdev_children; i++) {
	vdev_copy_path_search(stvd, dvd->vdev_child[i]);
	}

	if (!dvd->vdev_ops->vdev_op_leaf \|\| !vdev_is_concrete(dvd))
	return;

	/*
	* The idea here is that while a vdev can shift positions within
	* a top vdev (when replacing, attaching mirror, etc.) it cannot
	* step outside of it.
	*/
	vdev_t *vd = vdev_lookup_by_guid(stvd, dvd->vdev_guid);

	if (vd == NULL \|\| vd->vdev_ops != dvd->vdev_ops)
	return;

	ASSERT(vd->vdev_ops->vdev_op_leaf);

	vdev_copy_path_impl(vd, dvd);
	}

	/*
	* Recursively copy vdev paths from one root vdev to another. Source and
	* destination vdev trees may differ in geometry. For each destination leaf
	* vdev, search a vdev with the same guid and top vdev id in the source.
	* Intended to copy paths from userland config into MOS config.
	*/
	void
	vdev_copy_path_relaxed(vdev_t srvd, vdev_t drvd)
	{
	uint64_t children = MIN(srvd->vdev_children, drvd->vdev_children);
	ASSERT(srvd->vdev_ops == &vdev_root_ops);
	ASSERT(drvd->vdev_ops == &vdev_root_ops);

	for (uint64_t i = 0; i < children; i++) {
	vdev_copy_path_search(srvd->vdev_child[i],
	drvd->vdev_child[i]);
	}
	}

	/*
	* Close a virtual device.
	*/
	void
	vdev_close(vdev_t *vd)
	{
	vdev_t *pvd = vd->vdev_parent;
	spa_t *spa __maybe_unused = vd->vdev_spa;

	ASSERT(vd != NULL);
	ASSERT(vd->vdev_open_thread == curthread \|\|
	spa_config_held(spa, SCL_STATE_ALL, RW_WRITER) == SCL_STATE_ALL);

	/*
	* If our parent is reopening, then we are as well, unless we are
	* going offline.
	*/
	if (pvd != NULL && pvd->vdev_reopening)
	vd->vdev_reopening = (pvd->vdev_reopening && !vd->vdev_offline);

	vd->vdev_ops->vdev_op_close(vd);

	vdev_cache_purge(vd);

	/*
	* We record the previous state before we close it, so that if we are
	* doing a reopen(), we don't generate FMA ereports if we notice that
	* it's still faulted.
	*/
	vd->vdev_prevstate = vd->vdev_state;

	if (vd->vdev_offline)
	vd->vdev_state = VDEV_STATE_OFFLINE;
	else
	vd->vdev_state = VDEV_STATE_CLOSED;
	vd->vdev_stat.vs_aux = VDEV_AUX_NONE;
	}

	void
	vdev_hold(vdev_t *vd)
	{
	spa_t *spa = vd->vdev_spa;

	ASSERT(spa_is_root(spa));
	if (spa->spa_state == POOL_STATE_UNINITIALIZED)
	return;

	for (int c = 0; c < vd->vdev_children; c++)
	vdev_hold(vd->vdev_child[c]);

	if (vd->vdev_ops->vdev_op_leaf && vd->vdev_ops->vdev_op_hold != NULL)
	vd->vdev_ops->vdev_op_hold(vd);
	}

	void
	vdev_rele(vdev_t *vd)
	{
	ASSERT(spa_is_root(vd->vdev_spa));
	for (int c = 0; c < vd->vdev_children; c++)
	vdev_rele(vd->vdev_child[c]);

	if (vd->vdev_ops->vdev_op_leaf && vd->vdev_ops->vdev_op_rele != NULL)
	vd->vdev_ops->vdev_op_rele(vd);
	}

	/*
	* Reopen all interior vdevs and any unopened leaves. We don't actually
	* reopen leaf vdevs which had previously been opened as they might deadlock
	* on the spa_config_lock. Instead we only obtain the leaf's physical size.
	* If the leaf has never been opened then open it, as usual.
	*/
	void
	vdev_reopen(vdev_t *vd)
	{
	spa_t *spa = vd->vdev_spa;

	ASSERT(spa_config_held(spa, SCL_STATE_ALL, RW_WRITER) == SCL_STATE_ALL);

	/* set the reopening flag unless we're taking the vdev offline */
	vd->vdev_reopening = !vd->vdev_offline;
	vdev_close(vd);
	(void) vdev_open(vd);

	/*
	* Call vdev_validate() here to make sure we have the same device.
	* Otherwise, a device with an invalid label could be successfully
	* opened in response to vdev_reopen().
	*/
	if (vd->vdev_aux) {
	(void) vdev_validate_aux(vd);
	if (vdev_readable(vd) && vdev_writeable(vd) &&
	vd->vdev_aux == &spa->spa_l2cache) {
	/*
	* In case the vdev is present we should evict all ARC
	* buffers and pointers to log blocks and reclaim their
	* space before restoring its contents to L2ARC.
	*/
	if (l2arc_vdev_present(vd)) {
	l2arc_rebuild_vdev(vd, B_TRUE);
	} else {
	l2arc_add_vdev(spa, vd);
	}
	spa_async_request(spa, SPA_ASYNC_L2CACHE_REBUILD);
	spa_async_request(spa, SPA_ASYNC_L2CACHE_TRIM);
	}
	} else {
	(void) vdev_validate(vd);
	}

	/*
	* Reassess parent vdev's health.
	*/
	vdev_propagate_state(vd);
	}

	int
	vdev_create(vdev_t *vd, uint64_t txg, boolean_t isreplacing)
	{
	int error;

	/*
	* Normally, partial opens (e.g. of a mirror) are allowed.
	* For a create, however, we want to fail the request if
	* there are any components we can't open.
	*/
	error = vdev_open(vd);

	if (error \|\| vd->vdev_state != VDEV_STATE_HEALTHY) {
	vdev_close(vd);
	return (error ? error : SET_ERROR(ENXIO));
	}

	/*
	* Recursively load DTLs and initialize all labels.
	*/
	if ((error = vdev_dtl_load(vd)) != 0 \|\|
	(error = vdev_label_init(vd, txg, isreplacing ?
	VDEV_LABEL_REPLACE : VDEV_LABEL_CREATE)) != 0) {
	vdev_close(vd);
	return (error);
	}

	return (0);
	}

	void
	vdev_metaslab_set_size(vdev_t *vd)
	{
	uint64_t asize = vd->vdev_asize;
	uint64_t ms_count = asize >> zfs_vdev_default_ms_shift;
	uint64_t ms_shift;

	/*
	* There are two dimensions to the metaslab sizing calculation:
	* the size of the metaslab and the count of metaslabs per vdev.
	*
	* The default values used below are a good balance between memory
	* usage (larger metaslab size means more memory needed for loaded
	* metaslabs; more metaslabs means more memory needed for the
	* metaslab_t structs), metaslab load time (larger metaslabs take
	* longer to load), and metaslab sync time (more metaslabs means
	* more time spent syncing all of them).
	*
	* In general, we aim for zfs_vdev_default_ms_count (200) metaslabs.
	* The range of the dimensions are as follows:
	*
	* 2^29 <= ms_size <= 2^34
	* 16 <= ms_count <= 131,072
	*
	* On the lower end of vdev sizes, we aim for metaslabs sizes of
	* at least 512MB (2^29) to minimize fragmentation effects when
	* testing with smaller devices. However, the count constraint
	* of at least 16 metaslabs will override this minimum size goal.
	*
	* On the upper end of vdev sizes, we aim for a maximum metaslab
	* size of 16GB. However, we will cap the total count to 2^17
	* metaslabs to keep our memory footprint in check and let the
	* metaslab size grow from there if that limit is hit.
	*
	* The net effect of applying above constrains is summarized below.
	*
	* vdev size metaslab count
	* --------------\|-----------------
	* < 8GB ~16
	* 8GB - 100GB one per 512MB
	* 100GB - 3TB ~200
	* 3TB - 2PB one per 16GB
	* > 2PB ~131,072
	* --------------------------------
	*
	* Finally, note that all of the above calculate the initial
	* number of metaslabs. Expanding a top-level vdev will result
	* in additional metaslabs being allocated making it possible
	* to exceed the zfs_vdev_ms_count_limit.
	*/

	if (ms_count < zfs_vdev_min_ms_count)
	ms_shift = highbit64(asize / zfs_vdev_min_ms_count);
	else if (ms_count > zfs_vdev_default_ms_count)
	ms_shift = highbit64(asize / zfs_vdev_default_ms_count);
	else
	ms_shift = zfs_vdev_default_ms_shift;

	if (ms_shift < SPA_MAXBLOCKSHIFT) {
	ms_shift = SPA_MAXBLOCKSHIFT;
	} else if (ms_shift > zfs_vdev_max_ms_shift) {
	ms_shift = zfs_vdev_max_ms_shift;
	/* cap the total count to constrain memory footprint */
	if ((asize >> ms_shift) > zfs_vdev_ms_count_limit)
	ms_shift = highbit64(asize / zfs_vdev_ms_count_limit);
	}

	vd->vdev_ms_shift = ms_shift;
	ASSERT3U(vd->vdev_ms_shift, >=, SPA_MAXBLOCKSHIFT);
	}

	void
	vdev_dirty(vdev_t vd, int flags, void arg, uint64_t txg)
	{
	ASSERT(vd == vd->vdev_top);
	/* indirect vdevs don't have metaslabs or dtls */
	ASSERT(vdev_is_concrete(vd) \|\| flags == 0);
	ASSERT(ISP2(flags));
	ASSERT(spa_writeable(vd->vdev_spa));

	if (flags & VDD_METASLAB)
	(void) txg_list_add(&vd->vdev_ms_list, arg, txg);

	if (flags & VDD_DTL)
	(void) txg_list_add(&vd->vdev_dtl_list, arg, txg);

	(void) txg_list_add(&vd->vdev_spa->spa_vdev_txg_list, vd, txg);
	}

	void
	vdev_dirty_leaves(vdev_t *vd, int flags, uint64_t txg)
	{
	for (int c = 0; c < vd->vdev_children; c++)
	vdev_dirty_leaves(vd->vdev_child[c], flags, txg);

	if (vd->vdev_ops->vdev_op_leaf)
	vdev_dirty(vd->vdev_top, flags, vd, txg);
	}

	/*
	* DTLs.
	*
	* A vdev's DTL (dirty time log) is the set of transaction groups for which
	* the vdev has less than perfect replication. There are four kinds of DTL:
	*
	* DTL_MISSING: txgs for which the vdev has no valid copies of the data
	*
	* DTL_PARTIAL: txgs for which data is available, but not fully replicated
	*
	* DTL_SCRUB: the txgs that could not be repaired by the last scrub; upon
	* scrub completion, DTL_SCRUB replaces DTL_MISSING in the range of
	* txgs that was scrubbed.
	*
	* DTL_OUTAGE: txgs which cannot currently be read, whether due to
	* persistent errors or just some device being offline.
	* Unlike the other three, the DTL_OUTAGE map is not generally
	* maintained; it's only computed when needed, typically to
	* determine whether a device can be detached.
	*
	* For leaf vdevs, DTL_MISSING and DTL_PARTIAL are identical: the device
	* either has the data or it doesn't.
	*
	* For interior vdevs such as mirror and RAID-Z the picture is more complex.
	* A vdev's DTL_PARTIAL is the union of its children's DTL_PARTIALs, because
	* if any child is less than fully replicated, then so is its parent.
	* A vdev's DTL_MISSING is a modified union of its children's DTL_MISSINGs,
	* comprising only those txgs which appear in 'maxfaults' or more children;
	* those are the txgs we don't have enough replication to read. For example,
	* double-parity RAID-Z can tolerate up to two missing devices (maxfaults == 2);
	* thus, its DTL_MISSING consists of the set of txgs that appear in more than
	* two child DTL_MISSING maps.
	*
	* It should be clear from the above that to compute the DTLs and outage maps
	* for all vdevs, it suffices to know just the leaf vdevs' DTL_MISSING maps.
	* Therefore, that is all we keep on disk. When loading the pool, or after
	* a configuration change, we generate all other DTLs from first principles.
	*/
	void
	vdev_dtl_dirty(vdev_t *vd, vdev_dtl_type_t t, uint64_t txg, uint64_t size)
	{
	range_tree_t *rt = vd->vdev_dtl[t];

	ASSERT(t < DTL_TYPES);
	ASSERT(vd != vd->vdev_spa->spa_root_vdev);
	ASSERT(spa_writeable(vd->vdev_spa));

	mutex_enter(&vd->vdev_dtl_lock);
	if (!range_tree_contains(rt, txg, size))
	range_tree_add(rt, txg, size);
	mutex_exit(&vd->vdev_dtl_lock);
	}

	boolean_t
	vdev_dtl_contains(vdev_t *vd, vdev_dtl_type_t t, uint64_t txg, uint64_t size)
	{
	range_tree_t *rt = vd->vdev_dtl[t];
	boolean_t dirty = B_FALSE;

	ASSERT(t < DTL_TYPES);
	ASSERT(vd != vd->vdev_spa->spa_root_vdev);

	/*
	* While we are loading the pool, the DTLs have not been loaded yet.
	* This isn't a problem but it can result in devices being tried
	* which are known to not have the data. In which case, the import
	* is relying on the checksum to ensure that we get the right data.
	* Note that while importing we are only reading the MOS, which is
	* always checksummed.
	*/
	mutex_enter(&vd->vdev_dtl_lock);
	if (!range_tree_is_empty(rt))
	dirty = range_tree_contains(rt, txg, size);
	mutex_exit(&vd->vdev_dtl_lock);

	return (dirty);
	}

	boolean_t
	vdev_dtl_empty(vdev_t *vd, vdev_dtl_type_t t)
	{
	range_tree_t *rt = vd->vdev_dtl[t];
	boolean_t empty;

	mutex_enter(&vd->vdev_dtl_lock);
	empty = range_tree_is_empty(rt);
	mutex_exit(&vd->vdev_dtl_lock);

	return (empty);
	}

	/*
	* Check if the txg falls within the range which must be
	* resilvered. DVAs outside this range can always be skipped.
	*/
	boolean_t
	vdev_default_need_resilver(vdev_t vd, const dva_t dva, size_t psize,
	uint64_t phys_birth)
	{
	/* Set by sequential resilver. */
	if (phys_birth == TXG_UNKNOWN)
	return (B_TRUE);

	return (vdev_dtl_contains(vd, DTL_PARTIAL, phys_birth, 1));
	}

	/*
	* Returns B_TRUE if the vdev determines the DVA needs to be resilvered.
	*/
	boolean_t
	vdev_dtl_need_resilver(vdev_t vd, const dva_t dva, size_t psize,
	uint64_t phys_birth)
	{
	ASSERT(vd != vd->vdev_spa->spa_root_vdev);

	if (vd->vdev_ops->vdev_op_need_resilver == NULL \|\|
	vd->vdev_ops->vdev_op_leaf)
	return (B_TRUE);

	return (vd->vdev_ops->vdev_op_need_resilver(vd, dva, psize,
	phys_birth));
	}

	/*
	* Returns the lowest txg in the DTL range.
	*/
	static uint64_t
	vdev_dtl_min(vdev_t *vd)
	{
	ASSERT(MUTEX_HELD(&vd->vdev_dtl_lock));
	ASSERT3U(range_tree_space(vd->vdev_dtl[DTL_MISSING]), !=, 0);
	ASSERT0(vd->vdev_children);

	return (range_tree_min(vd->vdev_dtl[DTL_MISSING]) - 1);
	}

	/*
	* Returns the highest txg in the DTL.
	*/
	static uint64_t
	vdev_dtl_max(vdev_t *vd)
	{
	ASSERT(MUTEX_HELD(&vd->vdev_dtl_lock));
	ASSERT3U(range_tree_space(vd->vdev_dtl[DTL_MISSING]), !=, 0);
	ASSERT0(vd->vdev_children);

	return (range_tree_max(vd->vdev_dtl[DTL_MISSING]));
	}

	/*
	* Determine if a resilvering vdev should remove any DTL entries from
	* its range. If the vdev was resilvering for the entire duration of the
	* scan then it should excise that range from its DTLs. Otherwise, this
	* vdev is considered partially resilvered and should leave its DTL
	* entries intact. The comment in vdev_dtl_reassess() describes how we
	* excise the DTLs.
	*/
	static boolean_t
	vdev_dtl_should_excise(vdev_t *vd, boolean_t rebuild_done)
	{
	ASSERT0(vd->vdev_children);

	if (vd->vdev_state < VDEV_STATE_DEGRADED)
	return (B_FALSE);

	if (vd->vdev_resilver_deferred)
	return (B_FALSE);

	if (range_tree_is_empty(vd->vdev_dtl[DTL_MISSING]))
	return (B_TRUE);

	if (rebuild_done) {
	vdev_rebuild_t *vr = &vd->vdev_top->vdev_rebuild_config;
	vdev_rebuild_phys_t *vrp = &vr->vr_rebuild_phys;

	/* Rebuild not initiated by attach */
	if (vd->vdev_rebuild_txg == 0)
	return (B_TRUE);

	/*
	* When a rebuild completes without error then all missing data
	* up to the rebuild max txg has been reconstructed and the DTL
	* is eligible for excision.
	*/
	if (vrp->vrp_rebuild_state == VDEV_REBUILD_COMPLETE &&
	vdev_dtl_max(vd) <= vrp->vrp_max_txg) {
	ASSERT3U(vrp->vrp_min_txg, <=, vdev_dtl_min(vd));
	ASSERT3U(vrp->vrp_min_txg, <, vd->vdev_rebuild_txg);
	ASSERT3U(vd->vdev_rebuild_txg, <=, vrp->vrp_max_txg);
	return (B_TRUE);
	}
	} else {
	dsl_scan_t *scn = vd->vdev_spa->spa_dsl_pool->dp_scan;
	dsl_scan_phys_t *scnp __maybe_unused = &scn->scn_phys;

	/* Resilver not initiated by attach */
	if (vd->vdev_resilver_txg == 0)
	return (B_TRUE);

	/*
	* When a resilver is initiated the scan will assign the
	* scn_max_txg value to the highest txg value that exists
	* in all DTLs. If this device's max DTL is not part of this
	* scan (i.e. it is not in the range (scn_min_txg, scn_max_txg]
	* then it is not eligible for excision.
	*/
	if (vdev_dtl_max(vd) <= scn->scn_phys.scn_max_txg) {
	ASSERT3U(scnp->scn_min_txg, <=, vdev_dtl_min(vd));
	ASSERT3U(scnp->scn_min_txg, <, vd->vdev_resilver_txg);
	ASSERT3U(vd->vdev_resilver_txg, <=, scnp->scn_max_txg);
	return (B_TRUE);
	}
	}

	return (B_FALSE);
	}

	/*
	* Reassess DTLs after a config change or scrub completion. If txg == 0 no
	* write operations will be issued to the pool.
	*/
	void
	vdev_dtl_reassess(vdev_t *vd, uint64_t txg, uint64_t scrub_txg,
	boolean_t scrub_done, boolean_t rebuild_done)
	{
	spa_t *spa = vd->vdev_spa;
	avl_tree_t reftree;
	int minref;

	ASSERT(spa_config_held(spa, SCL_ALL, RW_READER) != 0);

	for (int c = 0; c < vd->vdev_children; c++)
	vdev_dtl_reassess(vd->vdev_child[c], txg,
	scrub_txg, scrub_done, rebuild_done);

	if (vd == spa->spa_root_vdev \|\| !vdev_is_concrete(vd) \|\| vd->vdev_aux)
	return;

	if (vd->vdev_ops->vdev_op_leaf) {
	dsl_scan_t *scn = spa->spa_dsl_pool->dp_scan;
	vdev_rebuild_t *vr = &vd->vdev_top->vdev_rebuild_config;
	boolean_t check_excise = B_FALSE;
	boolean_t wasempty = B_TRUE;

	mutex_enter(&vd->vdev_dtl_lock);

	/*
	* If requested, pretend the scan or rebuild completed cleanly.
	*/
	if (zfs_scan_ignore_errors) {
	if (scn != NULL)
	scn->scn_phys.scn_errors = 0;
	if (vr != NULL)
	vr->vr_rebuild_phys.vrp_errors = 0;
	}

	if (scrub_txg != 0 &&
	!range_tree_is_empty(vd->vdev_dtl[DTL_MISSING])) {
	wasempty = B_FALSE;
	zfs_dbgmsg("guid:%llu txg:%llu scrub:%llu started:%d "
	"dtl:%llu/%llu errors:%llu",
	(u_longlong_t)vd->vdev_guid, (u_longlong_t)txg,
	(u_longlong_t)scrub_txg, spa->spa_scrub_started,
	(u_longlong_t)vdev_dtl_min(vd),
	(u_longlong_t)vdev_dtl_max(vd),
	(u_longlong_t)(scn ? scn->scn_phys.scn_errors : 0));
	}

	/*
	* If we've completed a scrub/resilver or a rebuild cleanly
	* then determine if this vdev should remove any DTLs. We
	* only want to excise regions on vdevs that were available
	* during the entire duration of this scan.
	*/
	if (rebuild_done &&
	vr != NULL && vr->vr_rebuild_phys.vrp_errors == 0) {
	check_excise = B_TRUE;
	} else {
	if (spa->spa_scrub_started \|\|
	(scn != NULL && scn->scn_phys.scn_errors == 0)) {
	check_excise = B_TRUE;
	}
	}

	if (scrub_txg && check_excise &&
	vdev_dtl_should_excise(vd, rebuild_done)) {
	/*
	* We completed a scrub, resilver or rebuild up to
	* scrub_txg. If we did it without rebooting, then
	* the scrub dtl will be valid, so excise the old
	* region and fold in the scrub dtl. Otherwise,
	* leave the dtl as-is if there was an error.
	*
	* There's little trick here: to excise the beginning
	* of the DTL_MISSING map, we put it into a reference
	* tree and then add a segment with refcnt -1 that
	* covers the range [0, scrub_txg). This means
	* that each txg in that range has refcnt -1 or 0.
	* We then add DTL_SCRUB with a refcnt of 2, so that
	* entries in the range [0, scrub_txg) will have a
	* positive refcnt -- either 1 or 2. We then convert
	* the reference tree into the new DTL_MISSING map.
	*/
	space_reftree_create(&reftree);
	space_reftree_add_map(&reftree,
	vd->vdev_dtl[DTL_MISSING], 1);
	space_reftree_add_seg(&reftree, 0, scrub_txg, -1);
	space_reftree_add_map(&reftree,
	vd->vdev_dtl[DTL_SCRUB], 2);
	space_reftree_generate_map(&reftree,
	vd->vdev_dtl[DTL_MISSING], 1);
	space_reftree_destroy(&reftree);

	if (!range_tree_is_empty(vd->vdev_dtl[DTL_MISSING])) {
	zfs_dbgmsg("update DTL_MISSING:%llu/%llu",
	(u_longlong_t)vdev_dtl_min(vd),
	(u_longlong_t)vdev_dtl_max(vd));
	} else if (!wasempty) {
	zfs_dbgmsg("DTL_MISSING is now empty");
	}
	}
	range_tree_vacate(vd->vdev_dtl[DTL_PARTIAL], NULL, NULL);
	range_tree_walk(vd->vdev_dtl[DTL_MISSING],
	range_tree_add, vd->vdev_dtl[DTL_PARTIAL]);
	if (scrub_done)
	range_tree_vacate(vd->vdev_dtl[DTL_SCRUB], NULL, NULL);
	range_tree_vacate(vd->vdev_dtl[DTL_OUTAGE], NULL, NULL);
	if (!vdev_readable(vd))
	range_tree_add(vd->vdev_dtl[DTL_OUTAGE], 0, -1ULL);
	else
	range_tree_walk(vd->vdev_dtl[DTL_MISSING],
	range_tree_add, vd->vdev_dtl[DTL_OUTAGE]);

	/*
	* If the vdev was resilvering or rebuilding and no longer
	* has any DTLs then reset the appropriate flag and dirty
	* the top level so that we persist the change.
	*/
	if (txg != 0 &&
	range_tree_is_empty(vd->vdev_dtl[DTL_MISSING]) &&
	range_tree_is_empty(vd->vdev_dtl[DTL_OUTAGE])) {
	if (vd->vdev_rebuild_txg != 0) {
	vd->vdev_rebuild_txg = 0;
	vdev_config_dirty(vd->vdev_top);
	} else if (vd->vdev_resilver_txg != 0) {
	vd->vdev_resilver_txg = 0;
	vdev_config_dirty(vd->vdev_top);
	}
	}

	mutex_exit(&vd->vdev_dtl_lock);

	if (txg != 0)
	vdev_dirty(vd->vdev_top, VDD_DTL, vd, txg);
	return;
	}

	mutex_enter(&vd->vdev_dtl_lock);
	for (int t = 0; t < DTL_TYPES; t++) {
	/* account for child's outage in parent's missing map */
	int s = (t == DTL_MISSING) ? DTL_OUTAGE: t;
	if (t == DTL_SCRUB)
	continue; /* leaf vdevs only */
	if (t == DTL_PARTIAL)
	minref = 1; /* i.e. non-zero */
	else if (vdev_get_nparity(vd) != 0)
	minref = vdev_get_nparity(vd) + 1; /* RAID-Z, dRAID */
	else
	minref = vd->vdev_children; /* any kind of mirror */
	space_reftree_create(&reftree);
	for (int c = 0; c < vd->vdev_children; c++) {
	vdev_t *cvd = vd->vdev_child[c];
	mutex_enter(&cvd->vdev_dtl_lock);
	space_reftree_add_map(&reftree, cvd->vdev_dtl[s], 1);
	mutex_exit(&cvd->vdev_dtl_lock);
	}
	space_reftree_generate_map(&reftree, vd->vdev_dtl[t], minref);
	space_reftree_destroy(&reftree);
	}
	mutex_exit(&vd->vdev_dtl_lock);
	}

	int
	vdev_dtl_load(vdev_t *vd)
	{
	spa_t *spa = vd->vdev_spa;
	objset_t *mos = spa->spa_meta_objset;
	range_tree_t *rt;
	int error = 0;

	if (vd->vdev_ops->vdev_op_leaf && vd->vdev_dtl_object != 0) {
	ASSERT(vdev_is_concrete(vd));

	error = space_map_open(&vd->vdev_dtl_sm, mos,
	vd->vdev_dtl_object, 0, -1ULL, 0);
	if (error)
	return (error);
	ASSERT(vd->vdev_dtl_sm != NULL);

	rt = range_tree_create(NULL, RANGE_SEG64, NULL, 0, 0);
	error = space_map_load(vd->vdev_dtl_sm, rt, SM_ALLOC);
	if (error == 0) {
	mutex_enter(&vd->vdev_dtl_lock);
	range_tree_walk(rt, range_tree_add,
	vd->vdev_dtl[DTL_MISSING]);
	mutex_exit(&vd->vdev_dtl_lock);
	}

	range_tree_vacate(rt, NULL, NULL);
	range_tree_destroy(rt);

	return (error);
	}

	for (int c = 0; c < vd->vdev_children; c++) {
	error = vdev_dtl_load(vd->vdev_child[c]);
	if (error != 0)
	break;
	}

	return (error);
	}

	static void
	vdev_zap_allocation_data(vdev_t vd, dmu_tx_t tx)
	{
	spa_t *spa = vd->vdev_spa;
	objset_t *mos = spa->spa_meta_objset;
	vdev_alloc_bias_t alloc_bias = vd->vdev_alloc_bias;
	const char *string;

	ASSERT(alloc_bias != VDEV_BIAS_NONE);

	string =
	(alloc_bias == VDEV_BIAS_LOG) ? VDEV_ALLOC_BIAS_LOG :
	(alloc_bias == VDEV_BIAS_SPECIAL) ? VDEV_ALLOC_BIAS_SPECIAL :
	(alloc_bias == VDEV_BIAS_DEDUP) ? VDEV_ALLOC_BIAS_DEDUP : NULL;

	ASSERT(string != NULL);
	VERIFY0(zap_add(mos, vd->vdev_top_zap, VDEV_TOP_ZAP_ALLOCATION_BIAS,
	1, strlen(string) + 1, string, tx));

	if (alloc_bias == VDEV_BIAS_SPECIAL \|\| alloc_bias == VDEV_BIAS_DEDUP) {
	spa_activate_allocation_classes(spa, tx);
	}
	}

	void
	vdev_destroy_unlink_zap(vdev_t vd, uint64_t zapobj, dmu_tx_t tx)
	{
	spa_t *spa = vd->vdev_spa;

	VERIFY0(zap_destroy(spa->spa_meta_objset, zapobj, tx));
	VERIFY0(zap_remove_int(spa->spa_meta_objset, spa->spa_all_vdev_zaps,
	zapobj, tx));
	}

	uint64_t
	vdev_create_link_zap(vdev_t vd, dmu_tx_t tx)
	{
	spa_t *spa = vd->vdev_spa;
	uint64_t zap = zap_create(spa->spa_meta_objset, DMU_OTN_ZAP_METADATA,
	DMU_OT_NONE, 0, tx);

	ASSERT(zap != 0);
	VERIFY0(zap_add_int(spa->spa_meta_objset, spa->spa_all_vdev_zaps,
	zap, tx));

	return (zap);
	}

	void
	vdev_construct_zaps(vdev_t vd, dmu_tx_t tx)
	{
	if (vd->vdev_ops != &vdev_hole_ops &&
	vd->vdev_ops != &vdev_missing_ops &&
	vd->vdev_ops != &vdev_root_ops &&
	!vd->vdev_top->vdev_removing) {
	if (vd->vdev_ops->vdev_op_leaf && vd->vdev_leaf_zap == 0) {
	vd->vdev_leaf_zap = vdev_create_link_zap(vd, tx);
	}
	if (vd == vd->vdev_top && vd->vdev_top_zap == 0) {
	vd->vdev_top_zap = vdev_create_link_zap(vd, tx);
	if (vd->vdev_alloc_bias != VDEV_BIAS_NONE)
	vdev_zap_allocation_data(vd, tx);
	}
	}

	for (uint64_t i = 0; i < vd->vdev_children; i++) {
	vdev_construct_zaps(vd->vdev_child[i], tx);
	}
	}

	static void
	vdev_dtl_sync(vdev_t *vd, uint64_t txg)
	{
	spa_t *spa = vd->vdev_spa;
	range_tree_t *rt = vd->vdev_dtl[DTL_MISSING];
	objset_t *mos = spa->spa_meta_objset;
	range_tree_t *rtsync;
	dmu_tx_t *tx;
	uint64_t object = space_map_object(vd->vdev_dtl_sm);

	ASSERT(vdev_is_concrete(vd));
	ASSERT(vd->vdev_ops->vdev_op_leaf);

	tx = dmu_tx_create_assigned(spa->spa_dsl_pool, txg);

	if (vd->vdev_detached \|\| vd->vdev_top->vdev_removing) {
	mutex_enter(&vd->vdev_dtl_lock);
	space_map_free(vd->vdev_dtl_sm, tx);
	space_map_close(vd->vdev_dtl_sm);
	vd->vdev_dtl_sm = NULL;
	mutex_exit(&vd->vdev_dtl_lock);

	/*
	* We only destroy the leaf ZAP for detached leaves or for
	* removed log devices. Removed data devices handle leaf ZAP
	* cleanup later, once cancellation is no longer possible.
	*/
	if (vd->vdev_leaf_zap != 0 && (vd->vdev_detached \|\|
	vd->vdev_top->vdev_islog)) {
	vdev_destroy_unlink_zap(vd, vd->vdev_leaf_zap, tx);
	vd->vdev_leaf_zap = 0;
	}

	dmu_tx_commit(tx);
	return;
	}

	if (vd->vdev_dtl_sm == NULL) {
	uint64_t new_object;

	new_object = space_map_alloc(mos, zfs_vdev_dtl_sm_blksz, tx);
	VERIFY3U(new_object, !=, 0);

	VERIFY0(space_map_open(&vd->vdev_dtl_sm, mos, new_object,
	0, -1ULL, 0));
	ASSERT(vd->vdev_dtl_sm != NULL);
	}

	rtsync = range_tree_create(NULL, RANGE_SEG64, NULL, 0, 0);

	mutex_enter(&vd->vdev_dtl_lock);
	range_tree_walk(rt, range_tree_add, rtsync);
	mutex_exit(&vd->vdev_dtl_lock);

	space_map_truncate(vd->vdev_dtl_sm, zfs_vdev_dtl_sm_blksz, tx);
	space_map_write(vd->vdev_dtl_sm, rtsync, SM_ALLOC, SM_NO_VDEVID, tx);
	range_tree_vacate(rtsync, NULL, NULL);

	range_tree_destroy(rtsync);

	/*
	* If the object for the space map has changed then dirty
	* the top level so that we update the config.
	*/
	if (object != space_map_object(vd->vdev_dtl_sm)) {
	vdev_dbgmsg(vd, "txg %llu, spa %s, DTL old object %llu, "
	"new object %llu", (u_longlong_t)txg, spa_name(spa),
	(u_longlong_t)object,
	(u_longlong_t)space_map_object(vd->vdev_dtl_sm));
	vdev_config_dirty(vd->vdev_top);
	}

	dmu_tx_commit(tx);
	}

	/*
	* Determine whether the specified vdev can be offlined/detached/removed
	* without losing data.
	*/
	boolean_t
	vdev_dtl_required(vdev_t *vd)
	{
	spa_t *spa = vd->vdev_spa;
	vdev_t *tvd = vd->vdev_top;
	uint8_t cant_read = vd->vdev_cant_read;
	boolean_t required;

	ASSERT(spa_config_held(spa, SCL_STATE_ALL, RW_WRITER) == SCL_STATE_ALL);

	if (vd == spa->spa_root_vdev \|\| vd == tvd)
	return (B_TRUE);

	/*
	* Temporarily mark the device as unreadable, and then determine
	* whether this results in any DTL outages in the top-level vdev.
	* If not, we can safely offline/detach/remove the device.
	*/
	vd->vdev_cant_read = B_TRUE;
	vdev_dtl_reassess(tvd, 0, 0, B_FALSE, B_FALSE);
	required = !vdev_dtl_empty(tvd, DTL_OUTAGE);
	vd->vdev_cant_read = cant_read;
	vdev_dtl_reassess(tvd, 0, 0, B_FALSE, B_FALSE);

	if (!required && zio_injection_enabled) {
	required = !!zio_handle_device_injection(vd, NULL,
	SET_ERROR(ECHILD));
	}

	return (required);
	}

	/*
	* Determine if resilver is needed, and if so the txg range.
	*/
	boolean_t
	vdev_resilver_needed(vdev_t vd, uint64_t minp, uint64_t *maxp)
	{
	boolean_t needed = B_FALSE;
	uint64_t thismin = UINT64_MAX;
	uint64_t thismax = 0;

	if (vd->vdev_children == 0) {
	mutex_enter(&vd->vdev_dtl_lock);
	if (!range_tree_is_empty(vd->vdev_dtl[DTL_MISSING]) &&
	vdev_writeable(vd)) {

	thismin = vdev_dtl_min(vd);
	thismax = vdev_dtl_max(vd);
	needed = B_TRUE;
	}
	mutex_exit(&vd->vdev_dtl_lock);
	} else {
	for (int c = 0; c < vd->vdev_children; c++) {
	vdev_t *cvd = vd->vdev_child[c];
	uint64_t cmin, cmax;

	if (vdev_resilver_needed(cvd, &cmin, &cmax)) {
	thismin = MIN(thismin, cmin);
	thismax = MAX(thismax, cmax);
	needed = B_TRUE;
	}
	}
	}

	if (needed && minp) {
	*minp = thismin;
	*maxp = thismax;
	}
	return (needed);
	}

	/*
	* Gets the checkpoint space map object from the vdev's ZAP. On success sm_obj
	* will contain either the checkpoint spacemap object or zero if none exists.
	* All other errors are returned to the caller.
	*/
	int
	vdev_checkpoint_sm_object(vdev_t vd, uint64_t sm_obj)
	{
	ASSERT0(spa_config_held(vd->vdev_spa, SCL_ALL, RW_WRITER));

	if (vd->vdev_top_zap == 0) {
	*sm_obj = 0;
	return (0);
	}

	int error = zap_lookup(spa_meta_objset(vd->vdev_spa), vd->vdev_top_zap,
	VDEV_TOP_ZAP_POOL_CHECKPOINT_SM, sizeof (uint64_t), 1, sm_obj);
	if (error == ENOENT) {
	*sm_obj = 0;
	error = 0;
	}

	return (error);
	}

	int
	vdev_load(vdev_t *vd)
	{
	int children = vd->vdev_children;
	int error = 0;
	taskq_t *tq = NULL;

	/*
	* It's only worthwhile to use the taskq for the root vdev, because the
	* slow part is metaslab_init, and that only happens for top-level
	* vdevs.
	*/
	if (vd->vdev_ops == &vdev_root_ops && vd->vdev_children > 0) {
	tq = taskq_create("vdev_load", children, minclsyspri,
	children, children, TASKQ_PREPOPULATE);
	}

	/*
	* Recursively load all children.
	*/
	for (int c = 0; c < vd->vdev_children; c++) {
	vdev_t *cvd = vd->vdev_child[c];

	if (tq == NULL \|\| vdev_uses_zvols(cvd)) {
	cvd->vdev_load_error = vdev_load(cvd);
	} else {
	VERIFY(taskq_dispatch(tq, vdev_load_child,
	cvd, TQ_SLEEP) != TASKQID_INVALID);
	}
	}

	if (tq != NULL) {
	taskq_wait(tq);
	taskq_destroy(tq);
	}

	for (int c = 0; c < vd->vdev_children; c++) {
	int error = vd->vdev_child[c]->vdev_load_error;

	if (error != 0)
	return (error);
	}

	vdev_set_deflate_ratio(vd);

	/*
	* On spa_load path, grab the allocation bias from our zap
	*/
	if (vd == vd->vdev_top && vd->vdev_top_zap != 0) {
	spa_t *spa = vd->vdev_spa;
	char bias_str[64];

	error = zap_lookup(spa->spa_meta_objset, vd->vdev_top_zap,
	VDEV_TOP_ZAP_ALLOCATION_BIAS, 1, sizeof (bias_str),
	bias_str);
	if (error == 0) {
	ASSERT(vd->vdev_alloc_bias == VDEV_BIAS_NONE);
	vd->vdev_alloc_bias = vdev_derive_alloc_bias(bias_str);
	} else if (error != ENOENT) {
	vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN,
	VDEV_AUX_CORRUPT_DATA);
	vdev_dbgmsg(vd, "vdev_load: zap_lookup(top_zap=%llu) "
	"failed [error=%d]", vd->vdev_top_zap, error);
	return (error);
	}
	}

	/*
	* Load any rebuild state from the top-level vdev zap.
	*/
	if (vd == vd->vdev_top && vd->vdev_top_zap != 0) {
	error = vdev_rebuild_load(vd);
	if (error && error != ENOTSUP) {
	vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN,
	VDEV_AUX_CORRUPT_DATA);
	vdev_dbgmsg(vd, "vdev_load: vdev_rebuild_load "
	"failed [error=%d]", error);
	return (error);
	}
	}

	/*
	* If this is a top-level vdev, initialize its metaslabs.
	*/
	if (vd == vd->vdev_top && vdev_is_concrete(vd)) {
	vdev_metaslab_group_create(vd);

	if (vd->vdev_ashift == 0 \|\| vd->vdev_asize == 0) {
	vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN,
	VDEV_AUX_CORRUPT_DATA);
	vdev_dbgmsg(vd, "vdev_load: invalid size. ashift=%llu, "
	"asize=%llu", (u_longlong_t)vd->vdev_ashift,
	(u_longlong_t)vd->vdev_asize);
	return (SET_ERROR(ENXIO));
	}

	error = vdev_metaslab_init(vd, 0);
	if (error != 0) {
	vdev_dbgmsg(vd, "vdev_load: metaslab_init failed "
	"[error=%d]", error);
	vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN,
	VDEV_AUX_CORRUPT_DATA);
	return (error);
	}

	uint64_t checkpoint_sm_obj;
	error = vdev_checkpoint_sm_object(vd, &checkpoint_sm_obj);
	if (error == 0 && checkpoint_sm_obj != 0) {
	objset_t *mos = spa_meta_objset(vd->vdev_spa);
	ASSERT(vd->vdev_asize != 0);
	ASSERT3P(vd->vdev_checkpoint_sm, ==, NULL);

	error = space_map_open(&vd->vdev_checkpoint_sm,
	mos, checkpoint_sm_obj, 0, vd->vdev_asize,
	vd->vdev_ashift);
	if (error != 0) {
	vdev_dbgmsg(vd, "vdev_load: space_map_open "
	"failed for checkpoint spacemap (obj %llu) "
	"[error=%d]",
	(u_longlong_t)checkpoint_sm_obj, error);
	return (error);
	}
	ASSERT3P(vd->vdev_checkpoint_sm, !=, NULL);

	/*
	* Since the checkpoint_sm contains free entries
	* exclusively we can use space_map_allocated() to
	* indicate the cumulative checkpointed space that
	* has been freed.
	*/
	vd->vdev_stat.vs_checkpoint_space =
	-space_map_allocated(vd->vdev_checkpoint_sm);
	vd->vdev_spa->spa_checkpoint_info.sci_dspace +=
	vd->vdev_stat.vs_checkpoint_space;
	} else if (error != 0) {
	vdev_dbgmsg(vd, "vdev_load: failed to retrieve "
	"checkpoint space map object from vdev ZAP "
	"[error=%d]", error);
	return (error);
	}
	}

	/*
	* If this is a leaf vdev, load its DTL.
	*/
	if (vd->vdev_ops->vdev_op_leaf && (error = vdev_dtl_load(vd)) != 0) {
	vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN,
	VDEV_AUX_CORRUPT_DATA);
	vdev_dbgmsg(vd, "vdev_load: vdev_dtl_load failed "
	"[error=%d]", error);
	return (error);
	}

	uint64_t obsolete_sm_object;
	error = vdev_obsolete_sm_object(vd, &obsolete_sm_object);
	if (error == 0 && obsolete_sm_object != 0) {
	objset_t *mos = vd->vdev_spa->spa_meta_objset;
	ASSERT(vd->vdev_asize != 0);
	ASSERT3P(vd->vdev_obsolete_sm, ==, NULL);

	if ((error = space_map_open(&vd->vdev_obsolete_sm, mos,
	obsolete_sm_object, 0, vd->vdev_asize, 0))) {
	vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN,
	VDEV_AUX_CORRUPT_DATA);
	vdev_dbgmsg(vd, "vdev_load: space_map_open failed for "
	"obsolete spacemap (obj %llu) [error=%d]",
	(u_longlong_t)obsolete_sm_object, error);
	return (error);
	}
	} else if (error != 0) {
	vdev_dbgmsg(vd, "vdev_load: failed to retrieve obsolete "
	"space map object from vdev ZAP [error=%d]", error);
	return (error);
	}

	return (0);
	}

	/*
	* The special vdev case is used for hot spares and l2cache devices. Its
	* sole purpose it to set the vdev state for the associated vdev. To do this,
	* we make sure that we can open the underlying device, then try to read the
	* label, and make sure that the label is sane and that it hasn't been
	* repurposed to another pool.
	*/
	int
	vdev_validate_aux(vdev_t *vd)
	{
	nvlist_t *label;
	uint64_t guid, version;
	uint64_t state;

	if (!vdev_readable(vd))
	return (0);

	if ((label = vdev_label_read_config(vd, -1ULL)) == NULL) {
	vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN,
	VDEV_AUX_CORRUPT_DATA);
	return (-1);
	}

	if (nvlist_lookup_uint64(label, ZPOOL_CONFIG_VERSION, &version) != 0 \|\|
	!SPA_VERSION_IS_SUPPORTED(version) \|\|
	nvlist_lookup_uint64(label, ZPOOL_CONFIG_GUID, &guid) != 0 \|\|
	guid != vd->vdev_guid \|\|
	nvlist_lookup_uint64(label, ZPOOL_CONFIG_POOL_STATE, &state) != 0) {
	vdev_set_state(vd, B_TRUE, VDEV_STATE_CANT_OPEN,
	VDEV_AUX_CORRUPT_DATA);
	nvlist_free(label);
	return (-1);
	}

	/*
	* We don't actually check the pool state here. If it's in fact in
	* use by another pool, we update this fact on the fly when requested.
	*/
	nvlist_free(label);
	return (0);
	}

	static void
	vdev_destroy_ms_flush_data(vdev_t vd, dmu_tx_t tx)
	{
	objset_t *mos = spa_meta_objset(vd->vdev_spa);

	if (vd->vdev_top_zap == 0)
	return;

	uint64_t object = 0;
	int err = zap_lookup(mos, vd->vdev_top_zap,
	VDEV_TOP_ZAP_MS_UNFLUSHED_PHYS_TXGS, sizeof (uint64_t), 1, &object);
	if (err == ENOENT)
	return;
	VERIFY0(err);

	VERIFY0(dmu_object_free(mos, object, tx));
	VERIFY0(zap_remove(mos, vd->vdev_top_zap,
	VDEV_TOP_ZAP_MS_UNFLUSHED_PHYS_TXGS, tx));
	}

	/*
	* Free the objects used to store this vdev's spacemaps, and the array
	* that points to them.
	*/
	void
	vdev_destroy_spacemaps(vdev_t vd, dmu_tx_t tx)
	{
	if (vd->vdev_ms_array == 0)
	return;

	objset_t *mos = vd->vdev_spa->spa_meta_objset;
	uint64_t array_count = vd->vdev_asize >> vd->vdev_ms_shift;
	size_t array_bytes = array_count * sizeof (uint64_t);
	uint64_t *smobj_array = kmem_alloc(array_bytes, KM_SLEEP);
	VERIFY0(dmu_read(mos, vd->vdev_ms_array, 0,
	array_bytes, smobj_array, 0));

	for (uint64_t i = 0; i < array_count; i++) {
	uint64_t smobj = smobj_array[i];
	if (smobj == 0)
	continue;

	space_map_free_obj(mos, smobj, tx);
	}

	kmem_free(smobj_array, array_bytes);
	VERIFY0(dmu_object_free(mos, vd->vdev_ms_array, tx));
	vdev_destroy_ms_flush_data(vd, tx);
	vd->vdev_ms_array = 0;
	}

	static void
	vdev_remove_empty_log(vdev_t *vd, uint64_t txg)
	{
	spa_t *spa = vd->vdev_spa;

	ASSERT(vd->vdev_islog);
	ASSERT(vd == vd->vdev_top);
	ASSERT3U(txg, ==, spa_syncing_txg(spa));

	dmu_tx_t *tx = dmu_tx_create_assigned(spa_get_dsl(spa), txg);

	vdev_destroy_spacemaps(vd, tx);
	if (vd->vdev_top_zap != 0) {
	vdev_destroy_unlink_zap(vd, vd->vdev_top_zap, tx);
	vd->vdev_top_zap = 0;
	}

	dmu_tx_commit(tx);
	}

	void
	vdev_sync_done(vdev_t *vd, uint64_t txg)
	{
	metaslab_t *msp;
	boolean_t reassess = !txg_list_empty(&vd->vdev_ms_list, TXG_CLEAN(txg));

	ASSERT(vdev_is_concrete(vd));

	while ((msp = txg_list_remove(&vd->vdev_ms_list, TXG_CLEAN(txg)))
	!= NULL)
	metaslab_sync_done(msp, txg);

	if (reassess) {
	metaslab_sync_reassess(vd->vdev_mg);
	if (vd->vdev_log_mg != NULL)
	metaslab_sync_reassess(vd->vdev_log_mg);
	}
	}

	void
	vdev_sync(vdev_t *vd, uint64_t txg)
	{
	spa_t *spa = vd->vdev_spa;
	vdev_t *lvd;
	metaslab_t *msp;

	ASSERT3U(txg, ==, spa->spa_syncing_txg);
	dmu_tx_t *tx = dmu_tx_create_assigned(spa->spa_dsl_pool, txg);
	if (range_tree_space(vd->vdev_obsolete_segments) > 0) {
	ASSERT(vd->vdev_removing \|\|
	vd->vdev_ops == &vdev_indirect_ops);

	vdev_indirect_sync_obsolete(vd, tx);

	/*
	* If the vdev is indirect, it can't have dirty
	* metaslabs or DTLs.
	*/
	if (vd->vdev_ops == &vdev_indirect_ops) {
	ASSERT(txg_list_empty(&vd->vdev_ms_list, txg));
	ASSERT(txg_list_empty(&vd->vdev_dtl_list, txg));
	dmu_tx_commit(tx);
	return;
	}
	}

	ASSERT(vdev_is_concrete(vd));

	if (vd->vdev_ms_array == 0 && vd->vdev_ms_shift != 0 &&
	!vd->vdev_removing) {
	ASSERT(vd == vd->vdev_top);
	ASSERT0(vd->vdev_indirect_config.vic_mapping_object);
	vd->vdev_ms_array = dmu_object_alloc(spa->spa_meta_objset,
	DMU_OT_OBJECT_ARRAY, 0, DMU_OT_NONE, 0, tx);
	ASSERT(vd->vdev_ms_array != 0);
	vdev_config_dirty(vd);
	}

	while ((msp = txg_list_remove(&vd->vdev_ms_list, txg)) != NULL) {
	metaslab_sync(msp, txg);
	(void) txg_list_add(&vd->vdev_ms_list, msp, TXG_CLEAN(txg));
	}

	while ((lvd = txg_list_remove(&vd->vdev_dtl_list, txg)) != NULL)
	vdev_dtl_sync(lvd, txg);

	/*
	* If this is an empty log device being removed, destroy the
	* metadata associated with it.
	*/
	if (vd->vdev_islog && vd->vdev_stat.vs_alloc == 0 && vd->vdev_removing)
	vdev_remove_empty_log(vd, txg);

	(void) txg_list_add(&spa->spa_vdev_txg_list, vd, TXG_CLEAN(txg));
	dmu_tx_commit(tx);
	}

	uint64_t
	vdev_psize_to_asize(vdev_t *vd, uint64_t psize)
	{
	return (vd->vdev_ops->vdev_op_asize(vd, psize));
	}

	/*
	* Mark the given vdev faulted. A faulted vdev behaves as if the device could
	* not be opened, and no I/O is attempted.
	*/
	int
	vdev_fault(spa_t *spa, uint64_t guid, vdev_aux_t aux)
	{
	vdev_t vd, tvd;

	spa_vdev_state_enter(spa, SCL_NONE);

	if ((vd = spa_lookup_by_guid(spa, guid, B_TRUE)) == NULL)
	return (spa_vdev_state_exit(spa, NULL, SET_ERROR(ENODEV)));

	if (!vd->vdev_ops->vdev_op_leaf)
	return (spa_vdev_state_exit(spa, NULL, SET_ERROR(ENOTSUP)));

	tvd = vd->vdev_top;

	/*
	* If user did a 'zpool offline -f' then make the fault persist across
	* reboots.
	*/
	if (aux == VDEV_AUX_EXTERNAL_PERSIST) {
	/*
	* There are two kinds of forced faults: temporary and
	* persistent. Temporary faults go away at pool import, while
	* persistent faults stay set. Both types of faults can be
	* cleared with a zpool clear.
	*
	* We tell if a vdev is persistently faulted by looking at the
	* ZPOOL_CONFIG_AUX_STATE nvpair. If it's set to "external" at
	* import then it's a persistent fault. Otherwise, it's
	* temporary. We get ZPOOL_CONFIG_AUX_STATE set to "external"
	* by setting vd.vdev_stat.vs_aux to VDEV_AUX_EXTERNAL. This
	* tells vdev_config_generate() (which gets run later) to set
	* ZPOOL_CONFIG_AUX_STATE to "external" in the nvlist.
	*/
	vd->vdev_stat.vs_aux = VDEV_AUX_EXTERNAL;
	vd->vdev_tmpoffline = B_FALSE;
	aux = VDEV_AUX_EXTERNAL;
	} else {
	vd->vdev_tmpoffline = B_TRUE;
	}

	/*
	* We don't directly use the aux state here, but if we do a
	* vdev_reopen(), we need this value to be present to remember why we
	* were faulted.
	*/
	vd->vdev_label_aux = aux;

	/*
	* Faulted state takes precedence over degraded.
	*/
	vd->vdev_delayed_close = B_FALSE;
	vd->vdev_faulted = 1ULL;
	vd->vdev_degraded = 0ULL;
	vdev_set_state(vd, B_FALSE, VDEV_STATE_FAULTED, aux);

	/*
	* If this device has the only valid copy of the data, then
	* back off and simply mark the vdev as degraded instead.
	*/
	if (!tvd->vdev_islog && vd->vdev_aux == NULL && vdev_dtl_required(vd)) {
	vd->vdev_degraded = 1ULL;
	vd->vdev_faulted = 0ULL;

	/*
	* If we reopen the device and it's not dead, only then do we
	* mark it degraded.
	*/
	vdev_reopen(tvd);

	if (vdev_readable(vd))
	vdev_set_state(vd, B_FALSE, VDEV_STATE_DEGRADED, aux);
	}

	return (spa_vdev_state_exit(spa, vd, 0));
	}

	/*
	* Mark the given vdev degraded. A degraded vdev is purely an indication to the
	* user that something is wrong. The vdev continues to operate as normal as far
	* as I/O is concerned.
	*/
	int
	vdev_degrade(spa_t *spa, uint64_t guid, vdev_aux_t aux)
	{
	vdev_t *vd;

	spa_vdev_state_enter(spa, SCL_NONE);

	if ((vd = spa_lookup_by_guid(spa, guid, B_TRUE)) == NULL)
	return (spa_vdev_state_exit(spa, NULL, SET_ERROR(ENODEV)));

	if (!vd->vdev_ops->vdev_op_leaf)
	return (spa_vdev_state_exit(spa, NULL, SET_ERROR(ENOTSUP)));

	/*
	* If the vdev is already faulted, then don't do anything.
	*/
	if (vd->vdev_faulted \|\| vd->vdev_degraded)
	return (spa_vdev_state_exit(spa, NULL, 0));

	vd->vdev_degraded = 1ULL;
	if (!vdev_is_dead(vd))
	vdev_set_state(vd, B_FALSE, VDEV_STATE_DEGRADED,
	aux);

	return (spa_vdev_state_exit(spa, vd, 0));
	}

	/*
	* Online the given vdev.
	*
	* If 'ZFS_ONLINE_UNSPARE' is set, it implies two things. First, any attached
	* spare device should be detached when the device finishes resilvering.
	* Second, the online should be treated like a 'test' online case, so no FMA
	* events are generated if the device fails to open.
	*/
	int
	vdev_online(spa_t spa, uint64_t guid, uint64_t flags, vdev_state_t newstate)
	{
	vdev_t vd, tvd, pvd, rvd = spa->spa_root_vdev;
	boolean_t wasoffline;
	vdev_state_t oldstate;

	spa_vdev_state_enter(spa, SCL_NONE);

	if ((vd = spa_lookup_by_guid(spa, guid, B_TRUE)) == NULL)
	return (spa_vdev_state_exit(spa, NULL, SET_ERROR(ENODEV)));

	if (!vd->vdev_ops->vdev_op_leaf)
	return (spa_vdev_state_exit(spa, NULL, SET_ERROR(ENOTSUP)));

	wasoffline = (vd->vdev_offline \|\| vd->vdev_tmpoffline);
	oldstate = vd->vdev_state;

	tvd = vd->vdev_top;
	vd->vdev_offline = B_FALSE;
	vd->vdev_tmpoffline = B_FALSE;
	vd->vdev_checkremove = !!(flags & ZFS_ONLINE_CHECKREMOVE);
	vd->vdev_forcefault = !!(flags & ZFS_ONLINE_FORCEFAULT);

	/* XXX - L2ARC 1.0 does not support expansion */
	if (!vd->vdev_aux) {
	for (pvd = vd; pvd != rvd; pvd = pvd->vdev_parent)
	pvd->vdev_expanding = !!((flags & ZFS_ONLINE_EXPAND) \|\|
	spa->spa_autoexpand);
	vd->vdev_expansion_time = gethrestime_sec();
	}

	vdev_reopen(tvd);
	vd->vdev_checkremove = vd->vdev_forcefault = B_FALSE;

	if (!vd->vdev_aux) {
	for (pvd = vd; pvd != rvd; pvd = pvd->vdev_parent)
	pvd->vdev_expanding = B_FALSE;
	}

	if (newstate)
	*newstate = vd->vdev_state;
	if ((flags & ZFS_ONLINE_UNSPARE) &&
	!vdev_is_dead(vd) && vd->vdev_parent &&
	vd->vdev_parent->vdev_ops == &vdev_spare_ops &&
	vd->vdev_parent->vdev_child[0] == vd)
	vd->vdev_unspare = B_TRUE;

	if ((flags & ZFS_ONLINE_EXPAND) \|\| spa->spa_autoexpand) {

	/* XXX - L2ARC 1.0 does not support expansion */
	if (vd->vdev_aux)
	return (spa_vdev_state_exit(spa, vd, ENOTSUP));
	spa_async_request(spa, SPA_ASYNC_CONFIG_UPDATE);
	}

	/* Restart initializing if necessary */
	mutex_enter(&vd->vdev_initialize_lock);
	if (vdev_writeable(vd) &&
	vd->vdev_initialize_thread == NULL &&
	vd->vdev_initialize_state == VDEV_INITIALIZE_ACTIVE) {
	(void) vdev_initialize(vd);
	}
	mutex_exit(&vd->vdev_initialize_lock);

	/*
	* Restart trimming if necessary. We do not restart trimming for cache
	* devices here. This is triggered by l2arc_rebuild_vdev()
	* asynchronously for the whole device or in l2arc_evict() as it evicts
	* space for upcoming writes.
	*/
	mutex_enter(&vd->vdev_trim_lock);
	if (vdev_writeable(vd) && !vd->vdev_isl2cache &&
	vd->vdev_trim_thread == NULL &&
	vd->vdev_trim_state == VDEV_TRIM_ACTIVE) {
	(void) vdev_trim(vd, vd->vdev_trim_rate, vd->vdev_trim_partial,
	vd->vdev_trim_secure);
	}
	mutex_exit(&vd->vdev_trim_lock);

	if (wasoffline \|\|
	(oldstate < VDEV_STATE_DEGRADED &&
	vd->vdev_state >= VDEV_STATE_DEGRADED))
	spa_event_notify(spa, vd, NULL, ESC_ZFS_VDEV_ONLINE);

	return (spa_vdev_state_exit(spa, vd, 0));
	}

	static int
	vdev_offline_locked(spa_t *spa, uint64_t guid, uint64_t flags)
	{
	vdev_t vd, tvd;
	int error = 0;
	uint64_t generation;
	metaslab_group_t *mg;

	top:
	spa_vdev_state_enter(spa, SCL_ALLOC);

	if ((vd = spa_lookup_by_guid(spa, guid, B_TRUE)) == NULL)
	return (spa_vdev_state_exit(spa, NULL, SET_ERROR(ENODEV)));

	if (!vd->vdev_ops->vdev_op_leaf)
	return (spa_vdev_state_exit(spa, NULL, SET_ERROR(ENOTSUP)));

	if (vd->vdev_ops == &vdev_draid_spare_ops)
	return (spa_vdev_state_exit(spa, NULL, ENOTSUP));

	tvd = vd->vdev_top;
	mg = tvd->vdev_mg;
	generation = spa->spa_config_generation + 1;

	/*
	* If the device isn't already offline, try to offline it.
	*/
	if (!vd->vdev_offline) {
	/*
	* If this device has the only valid copy of some data,
	* don't allow it to be offlined. Log devices are always
	* expendable.
	*/
	if (!tvd->vdev_islog && vd->vdev_aux == NULL &&
	vdev_dtl_required(vd))
	return (spa_vdev_state_exit(spa, NULL,
	SET_ERROR(EBUSY)));

	/*
	* If the top-level is a slog and it has had allocations
	* then proceed. We check that the vdev's metaslab group
	* is not NULL since it's possible that we may have just
	* added this vdev but not yet initialized its metaslabs.
	*/
	if (tvd->vdev_islog && mg != NULL) {
	/*
	* Prevent any future allocations.
	*/
	ASSERT3P(tvd->vdev_log_mg, ==, NULL);
	metaslab_group_passivate(mg);
	(void) spa_vdev_state_exit(spa, vd, 0);

	error = spa_reset_logs(spa);

	/*
	* If the log device was successfully reset but has
	* checkpointed data, do not offline it.
	*/
	if (error == 0 &&
	tvd->vdev_checkpoint_sm != NULL) {
	ASSERT3U(space_map_allocated(
	tvd->vdev_checkpoint_sm), !=, 0);
	error = ZFS_ERR_CHECKPOINT_EXISTS;
	}

	spa_vdev_state_enter(spa, SCL_ALLOC);

	/*
	* Check to see if the config has changed.
	*/
	if (error \|\| generation != spa->spa_config_generation) {
	metaslab_group_activate(mg);
	if (error)
	return (spa_vdev_state_exit(spa,
	vd, error));
	(void) spa_vdev_state_exit(spa, vd, 0);
	goto top;
	}
	ASSERT0(tvd->vdev_stat.vs_alloc);
	}

	/*
	* Offline this device and reopen its top-level vdev.
	* If the top-level vdev is a log device then just offline
	* it. Otherwise, if this action results in the top-level
	* vdev becoming unusable, undo it and fail the request.
	*/
	vd->vdev_offline = B_TRUE;
	vdev_reopen(tvd);

	if (!tvd->vdev_islog && vd->vdev_aux == NULL &&
	vdev_is_dead(tvd)) {
	vd->vdev_offline = B_FALSE;
	vdev_reopen(tvd);
	return (spa_vdev_state_exit(spa, NULL,
	SET_ERROR(EBUSY)));
	}

	/*
	* Add the device back into the metaslab rotor so that
	* once we online the device it's open for business.
	*/
	if (tvd->vdev_islog && mg != NULL)
	metaslab_group_activate(mg);
	}

	vd->vdev_tmpoffline = !!(flags & ZFS_OFFLINE_TEMPORARY);

	return (spa_vdev_state_exit(spa, vd, 0));
	}

	int
	vdev_offline(spa_t *spa, uint64_t guid, uint64_t flags)
	{
	int error;

	mutex_enter(&spa->spa_vdev_top_lock);
	error = vdev_offline_locked(spa, guid, flags);
	mutex_exit(&spa->spa_vdev_top_lock);

	return (error);
	}

	/*
	* Clear the error counts associated with this vdev. Unlike vdev_online() and
	* vdev_offline(), we assume the spa config is locked. We also clear all
	* children. If 'vd' is NULL, then the user wants to clear all vdevs.
	*/
	void
	vdev_clear(spa_t spa, vdev_t vd)
	{
	vdev_t *rvd = spa->spa_root_vdev;

	ASSERT(spa_config_held(spa, SCL_STATE_ALL, RW_WRITER) == SCL_STATE_ALL);

	if (vd == NULL)
	vd = rvd;

	vd->vdev_stat.vs_read_errors = 0;
	vd->vdev_stat.vs_write_errors = 0;
	vd->vdev_stat.vs_checksum_errors = 0;
	vd->vdev_stat.vs_slow_ios = 0;

	for (int c = 0; c < vd->vdev_children; c++)
	vdev_clear(spa, vd->vdev_child[c]);

	/*
	* It makes no sense to "clear" an indirect vdev.
	*/
	if (!vdev_is_concrete(vd))
	return;

	/*
	* If we're in the FAULTED state or have experienced failed I/O, then
	* clear the persistent state and attempt to reopen the device. We
	* also mark the vdev config dirty, so that the new faulted state is
	* written out to disk.
	*/
	if (vd->vdev_faulted \|\| vd->vdev_degraded \|\|
	!vdev_readable(vd) \|\| !vdev_writeable(vd)) {
	/*
	* When reopening in response to a clear event, it may be due to
	* a fmadm repair request. In this case, if the device is
	* still broken, we want to still post the ereport again.
	*/
	vd->vdev_forcefault = B_TRUE;

	vd->vdev_faulted = vd->vdev_degraded = 0ULL;
	vd->vdev_cant_read = B_FALSE;
	vd->vdev_cant_write = B_FALSE;
	vd->vdev_stat.vs_aux = 0;

	vdev_reopen(vd == rvd ? rvd : vd->vdev_top);

	vd->vdev_forcefault = B_FALSE;

	if (vd != rvd && vdev_writeable(vd->vdev_top))
	vdev_state_dirty(vd->vdev_top);

	/* If a resilver isn't required, check if vdevs can be culled */
	if (vd->vdev_aux == NULL && !vdev_is_dead(vd) &&
	!dsl_scan_resilvering(spa->spa_dsl_pool) &&
	!dsl_scan_resilver_scheduled(spa->spa_dsl_pool))
	spa_async_request(spa, SPA_ASYNC_RESILVER_DONE);

	spa_event_notify(spa, vd, NULL, ESC_ZFS_VDEV_CLEAR);
	}

	/*
	* When clearing a FMA-diagnosed fault, we always want to
	* unspare the device, as we assume that the original spare was
	* done in response to the FMA fault.
	*/
	if (!vdev_is_dead(vd) && vd->vdev_parent != NULL &&
	vd->vdev_parent->vdev_ops == &vdev_spare_ops &&
	vd->vdev_parent->vdev_child[0] == vd)
	vd->vdev_unspare = B_TRUE;

	/* Clear recent error events cache (i.e. duplicate events tracking) */
	zfs_ereport_clear(spa, vd);
	}

	boolean_t
	vdev_is_dead(vdev_t *vd)
	{
	/*
	* Holes and missing devices are always considered "dead".
	* This simplifies the code since we don't have to check for
	* these types of devices in the various code paths.
	* Instead we rely on the fact that we skip over dead devices
	* before issuing I/O to them.
	*/
	return (vd->vdev_state < VDEV_STATE_DEGRADED \|\|
	vd->vdev_ops == &vdev_hole_ops \|\|
	vd->vdev_ops == &vdev_missing_ops);
	}

	boolean_t
	vdev_readable(vdev_t *vd)
	{
	return (!vdev_is_dead(vd) && !vd->vdev_cant_read);
	}

	boolean_t
	vdev_writeable(vdev_t *vd)
	{
	return (!vdev_is_dead(vd) && !vd->vdev_cant_write &&
	vdev_is_concrete(vd));
	}

	boolean_t
	vdev_allocatable(vdev_t *vd)
	{
	uint64_t state = vd->vdev_state;

	/*
	* We currently allow allocations from vdevs which may be in the
	* process of reopening (i.e. VDEV_STATE_CLOSED). If the device
	* fails to reopen then we'll catch it later when we're holding
	* the proper locks. Note that we have to get the vdev state
	* in a local variable because although it changes atomically,
	* we're asking two separate questions about it.
	*/
	return (!(state < VDEV_STATE_DEGRADED && state != VDEV_STATE_CLOSED) &&
	!vd->vdev_cant_write && vdev_is_concrete(vd) &&
	vd->vdev_mg->mg_initialized);
	}

	boolean_t
	vdev_accessible(vdev_t vd, zio_t zio)
	{
	ASSERT(zio->io_vd == vd);

	if (vdev_is_dead(vd) \|\| vd->vdev_remove_wanted)
	return (B_FALSE);

	if (zio->io_type == ZIO_TYPE_READ)
	return (!vd->vdev_cant_read);

	if (zio->io_type == ZIO_TYPE_WRITE)
	return (!vd->vdev_cant_write);

	return (B_TRUE);
	}

	static void
	vdev_get_child_stat(vdev_t cvd, vdev_stat_t vs, vdev_stat_t *cvs)
	{
	/*
	* Exclude the dRAID spare when aggregating to avoid double counting
	* the ops and bytes. These IOs are counted by the physical leaves.
	*/
	if (cvd->vdev_ops == &vdev_draid_spare_ops)
	return;

	for (int t = 0; t < VS_ZIO_TYPES; t++) {
	vs->vs_ops[t] += cvs->vs_ops[t];
	vs->vs_bytes[t] += cvs->vs_bytes[t];
	}

	cvs->vs_scan_removing = cvd->vdev_removing;
	}

	/*
	* Get extended stats
	*/
	static void
	vdev_get_child_stat_ex(vdev_t cvd, vdev_stat_ex_t vsx, vdev_stat_ex_t *cvsx)
	{
	int t, b;
	for (t = 0; t < ZIO_TYPES; t++) {
	for (b = 0; b < ARRAY_SIZE(vsx->vsx_disk_histo[0]); b++)
	vsx->vsx_disk_histo[t][b] += cvsx->vsx_disk_histo[t][b];

	for (b = 0; b < ARRAY_SIZE(vsx->vsx_total_histo[0]); b++) {
	vsx->vsx_total_histo[t][b] +=
	cvsx->vsx_total_histo[t][b];
	}
	}

	for (t = 0; t < ZIO_PRIORITY_NUM_QUEUEABLE; t++) {
	for (b = 0; b < ARRAY_SIZE(vsx->vsx_queue_histo[0]); b++) {
	vsx->vsx_queue_histo[t][b] +=
	cvsx->vsx_queue_histo[t][b];
	}
	vsx->vsx_active_queue[t] += cvsx->vsx_active_queue[t];
	vsx->vsx_pend_queue[t] += cvsx->vsx_pend_queue[t];

	for (b = 0; b < ARRAY_SIZE(vsx->vsx_ind_histo[0]); b++)
	vsx->vsx_ind_histo[t][b] += cvsx->vsx_ind_histo[t][b];

	for (b = 0; b < ARRAY_SIZE(vsx->vsx_agg_histo[0]); b++)
	vsx->vsx_agg_histo[t][b] += cvsx->vsx_agg_histo[t][b];
	}

	}

	boolean_t
	vdev_is_spacemap_addressable(vdev_t *vd)
	{
	if (spa_feature_is_active(vd->vdev_spa, SPA_FEATURE_SPACEMAP_V2))
	return (B_TRUE);

	/*
	* If double-word space map entries are not enabled we assume
	* 47 bits of the space map entry are dedicated to the entry's
	* offset (see SM_OFFSET_BITS in space_map.h). We then use that
	* to calculate the maximum address that can be described by a
	* space map entry for the given device.
	*/
	uint64_t shift = vd->vdev_ashift + SM_OFFSET_BITS;

	if (shift >= 63) /* detect potential overflow */
	return (B_TRUE);

	return (vd->vdev_asize < (1ULL << shift));
	}

	/*
	* Get statistics for the given vdev.
	*/
	static void
	vdev_get_stats_ex_impl(vdev_t vd, vdev_stat_t vs, vdev_stat_ex_t *vsx)
	{
	int t;
	/*
	* If we're getting stats on the root vdev, aggregate the I/O counts
	* over all top-level vdevs (i.e. the direct children of the root).
	*/
	if (!vd->vdev_ops->vdev_op_leaf) {
	if (vs) {
	memset(vs->vs_ops, 0, sizeof (vs->vs_ops));
	memset(vs->vs_bytes, 0, sizeof (vs->vs_bytes));
	}
	if (vsx)
	memset(vsx, 0, sizeof (*vsx));

	for (int c = 0; c < vd->vdev_children; c++) {
	vdev_t *cvd = vd->vdev_child[c];
	vdev_stat_t *cvs = &cvd->vdev_stat;
	vdev_stat_ex_t *cvsx = &cvd->vdev_stat_ex;

	vdev_get_stats_ex_impl(cvd, cvs, cvsx);
	if (vs)
	vdev_get_child_stat(cvd, vs, cvs);
	if (vsx)
	vdev_get_child_stat_ex(cvd, vsx, cvsx);
	}
	} else {
	/*
	* We're a leaf. Just copy our ZIO active queue stats in. The
	* other leaf stats are updated in vdev_stat_update().
	*/
	if (!vsx)
	return;

	memcpy(vsx, &vd->vdev_stat_ex, sizeof (vd->vdev_stat_ex));

	for (t = 0; t < ARRAY_SIZE(vd->vdev_queue.vq_class); t++) {
	vsx->vsx_active_queue[t] =
	vd->vdev_queue.vq_class[t].vqc_active;
	vsx->vsx_pend_queue[t] = avl_numnodes(
	&vd->vdev_queue.vq_class[t].vqc_queued_tree);
	}
	}
	}

	void
	vdev_get_stats_ex(vdev_t vd, vdev_stat_t vs, vdev_stat_ex_t *vsx)
	{
	vdev_t *tvd = vd->vdev_top;
	mutex_enter(&vd->vdev_stat_lock);
	if (vs) {
	bcopy(&vd->vdev_stat, vs, sizeof (*vs));
	vs->vs_timestamp = gethrtime() - vs->vs_timestamp;
	vs->vs_state = vd->vdev_state;
	vs->vs_rsize = vdev_get_min_asize(vd);

	if (vd->vdev_ops->vdev_op_leaf) {
	vs->vs_rsize += VDEV_LABEL_START_SIZE +
	VDEV_LABEL_END_SIZE;
	/*
	* Report initializing progress. Since we don't
	* have the initializing locks held, this is only
	* an estimate (although a fairly accurate one).
	*/
	vs->vs_initialize_bytes_done =
	vd->vdev_initialize_bytes_done;
	vs->vs_initialize_bytes_est =
	vd->vdev_initialize_bytes_est;
	vs->vs_initialize_state = vd->vdev_initialize_state;
	vs->vs_initialize_action_time =
	vd->vdev_initialize_action_time;

	/*
	* Report manual TRIM progress. Since we don't have
	* the manual TRIM locks held, this is only an
	* estimate (although fairly accurate one).
	*/
	vs->vs_trim_notsup = !vd->vdev_has_trim;
	vs->vs_trim_bytes_done = vd->vdev_trim_bytes_done;
	vs->vs_trim_bytes_est = vd->vdev_trim_bytes_est;
	vs->vs_trim_state = vd->vdev_trim_state;
	vs->vs_trim_action_time = vd->vdev_trim_action_time;

	/* Set when there is a deferred resilver. */
	vs->vs_resilver_deferred = vd->vdev_resilver_deferred;
	}

	/*
	* Report expandable space on top-level, non-auxiliary devices
	* only. The expandable space is reported in terms of metaslab
	* sized units since that determines how much space the pool
	* can expand.
	*/
	if (vd->vdev_aux == NULL && tvd != NULL) {
	vs->vs_esize = P2ALIGN(
	vd->vdev_max_asize - vd->vdev_asize,
	1ULL << tvd->vdev_ms_shift);
	}

	vs->vs_configured_ashift = vd->vdev_top != NULL
	? vd->vdev_top->vdev_ashift : vd->vdev_ashift;
	vs->vs_logical_ashift = vd->vdev_logical_ashift;
	vs->vs_physical_ashift = vd->vdev_physical_ashift;

	/*
	* Report fragmentation and rebuild progress for top-level,
	* non-auxiliary, concrete devices.
	*/
	if (vd->vdev_aux == NULL && vd == vd->vdev_top &&
	vdev_is_concrete(vd)) {
	/*
	* The vdev fragmentation rating doesn't take into
	* account the embedded slog metaslab (vdev_log_mg).
	* Since it's only one metaslab, it would have a tiny
	* impact on the overall fragmentation.
	*/
	vs->vs_fragmentation = (vd->vdev_mg != NULL) ?
	vd->vdev_mg->mg_fragmentation : 0;
	}
	}

	vdev_get_stats_ex_impl(vd, vs, vsx);
	mutex_exit(&vd->vdev_stat_lock);
	}

	void
	vdev_get_stats(vdev_t vd, vdev_stat_t vs)
	{
	return (vdev_get_stats_ex(vd, vs, NULL));
	}

	void
	vdev_clear_stats(vdev_t *vd)
	{
	mutex_enter(&vd->vdev_stat_lock);
	vd->vdev_stat.vs_space = 0;
	vd->vdev_stat.vs_dspace = 0;
	vd->vdev_stat.vs_alloc = 0;
	mutex_exit(&vd->vdev_stat_lock);
	}

	void
	vdev_scan_stat_init(vdev_t *vd)
	{
	vdev_stat_t *vs = &vd->vdev_stat;

	for (int c = 0; c < vd->vdev_children; c++)
	vdev_scan_stat_init(vd->vdev_child[c]);

	mutex_enter(&vd->vdev_stat_lock);
	vs->vs_scan_processed = 0;
	mutex_exit(&vd->vdev_stat_lock);
	}

	void
	vdev_stat_update(zio_t *zio, uint64_t psize)
	{
	spa_t *spa = zio->io_spa;
	vdev_t *rvd = spa->spa_root_vdev;
	vdev_t *vd = zio->io_vd ? zio->io_vd : rvd;
	vdev_t *pvd;
	uint64_t txg = zio->io_txg;
	vdev_stat_t *vs = &vd->vdev_stat;
	vdev_stat_ex_t *vsx = &vd->vdev_stat_ex;
	zio_type_t type = zio->io_type;
	int flags = zio->io_flags;

	/*
	* If this i/o is a gang leader, it didn't do any actual work.
	*/
	if (zio->io_gang_tree)
	return;

	if (zio->io_error == 0) {
	/*
	* If this is a root i/o, don't count it -- we've already
	* counted the top-level vdevs, and vdev_get_stats() will
	* aggregate them when asked. This reduces contention on
	* the root vdev_stat_lock and implicitly handles blocks
	* that compress away to holes, for which there is no i/o.
	* (Holes never create vdev children, so all the counters
	* remain zero, which is what we want.)
	*
	* Note: this only applies to successful i/o (io_error == 0)
	* because unlike i/o counts, errors are not additive.
	* When reading a ditto block, for example, failure of
	* one top-level vdev does not imply a root-level error.
	*/
	if (vd == rvd)
	return;

	ASSERT(vd == zio->io_vd);

	if (flags & ZIO_FLAG_IO_BYPASS)
	return;

	mutex_enter(&vd->vdev_stat_lock);

	if (flags & ZIO_FLAG_IO_REPAIR) {
	/*
	* Repair is the result of a resilver issued by the
	* scan thread (spa_sync).
	*/
	if (flags & ZIO_FLAG_SCAN_THREAD) {
	dsl_scan_t *scn = spa->spa_dsl_pool->dp_scan;
	dsl_scan_phys_t *scn_phys = &scn->scn_phys;
	uint64_t *processed = &scn_phys->scn_processed;

	if (vd->vdev_ops->vdev_op_leaf)
	atomic_add_64(processed, psize);
	vs->vs_scan_processed += psize;
	}

	/*
	* Repair is the result of a rebuild issued by the
	* rebuild thread (vdev_rebuild_thread). To avoid
	* double counting repaired bytes the virtual dRAID
	* spare vdev is excluded from the processed bytes.
	*/
	if (zio->io_priority == ZIO_PRIORITY_REBUILD) {
	vdev_t *tvd = vd->vdev_top;
	vdev_rebuild_t *vr = &tvd->vdev_rebuild_config;
	vdev_rebuild_phys_t *vrp = &vr->vr_rebuild_phys;
	uint64_t *rebuilt = &vrp->vrp_bytes_rebuilt;

	if (vd->vdev_ops->vdev_op_leaf &&
	vd->vdev_ops != &vdev_draid_spare_ops) {
	atomic_add_64(rebuilt, psize);
	}
	vs->vs_rebuild_processed += psize;
	}

	if (flags & ZIO_FLAG_SELF_HEAL)
	vs->vs_self_healed += psize;
	}

	/*
	* The bytes/ops/histograms are recorded at the leaf level and
	* aggregated into the higher level vdevs in vdev_get_stats().
	*/
	if (vd->vdev_ops->vdev_op_leaf &&
	(zio->io_priority < ZIO_PRIORITY_NUM_QUEUEABLE)) {
	zio_type_t vs_type = type;
	zio_priority_t priority = zio->io_priority;

	/*
	* TRIM ops and bytes are reported to user space as
	* ZIO_TYPE_IOCTL. This is done to preserve the
	* vdev_stat_t structure layout for user space.
	*/
	if (type == ZIO_TYPE_TRIM)
	vs_type = ZIO_TYPE_IOCTL;

	/*
	* Solely for the purposes of 'zpool iostat -lqrw'
	- * reporting use the priority to catagorize the IO.
	+ * reporting use the priority to categorize the IO.
	* Only the following are reported to user space:
	*
	* ZIO_PRIORITY_SYNC_READ,
	* ZIO_PRIORITY_SYNC_WRITE,
	* ZIO_PRIORITY_ASYNC_READ,
	* ZIO_PRIORITY_ASYNC_WRITE,
	* ZIO_PRIORITY_SCRUB,
	* ZIO_PRIORITY_TRIM.
	*/
	if (priority == ZIO_PRIORITY_REBUILD) {
	priority = ((type == ZIO_TYPE_WRITE) ?
	ZIO_PRIORITY_ASYNC_WRITE :
	ZIO_PRIORITY_SCRUB);
	} else if (priority == ZIO_PRIORITY_INITIALIZING) {
	ASSERT3U(type, ==, ZIO_TYPE_WRITE);
	priority = ZIO_PRIORITY_ASYNC_WRITE;
	} else if (priority == ZIO_PRIORITY_REMOVAL) {
	priority = ((type == ZIO_TYPE_WRITE) ?
	ZIO_PRIORITY_ASYNC_WRITE :
	ZIO_PRIORITY_ASYNC_READ);
	}

	vs->vs_ops[vs_type]++;
	vs->vs_bytes[vs_type] += psize;

	if (flags & ZIO_FLAG_DELEGATED) {
	vsx->vsx_agg_histo[priority]
	[RQ_HISTO(zio->io_size)]++;
	} else {
	vsx->vsx_ind_histo[priority]
	[RQ_HISTO(zio->io_size)]++;
	}

	if (zio->io_delta && zio->io_delay) {
	vsx->vsx_queue_histo[priority]
	[L_HISTO(zio->io_delta - zio->io_delay)]++;
	vsx->vsx_disk_histo[type]
	[L_HISTO(zio->io_delay)]++;
	vsx->vsx_total_histo[type]
	[L_HISTO(zio->io_delta)]++;
	}
	}

	mutex_exit(&vd->vdev_stat_lock);
	return;
	}

	if (flags & ZIO_FLAG_SPECULATIVE)
	return;

	/*
	* If this is an I/O error that is going to be retried, then ignore the
	* error. Otherwise, the user may interpret B_FAILFAST I/O errors as
	* hard errors, when in reality they can happen for any number of
	* innocuous reasons (bus resets, MPxIO link failure, etc).
	*/
	if (zio->io_error == EIO &&
	!(zio->io_flags & ZIO_FLAG_IO_RETRY))
	return;

	/*
	* Intent logs writes won't propagate their error to the root
	* I/O so don't mark these types of failures as pool-level
	* errors.
	*/
	if (zio->io_vd == NULL && (zio->io_flags & ZIO_FLAG_DONT_PROPAGATE))
	return;

	if (type == ZIO_TYPE_WRITE && txg != 0 &&
	(!(flags & ZIO_FLAG_IO_REPAIR) \|\|
	(flags & ZIO_FLAG_SCAN_THREAD) \|\|
	spa->spa_claiming)) {
	/*
	* This is either a normal write (not a repair), or it's
	* a repair induced by the scrub thread, or it's a repair
	* made by zil_claim() during spa_load() in the first txg.
	* In the normal case, we commit the DTL change in the same
	* txg as the block was born. In the scrub-induced repair
	* case, we know that scrubs run in first-pass syncing context,
	* so we commit the DTL change in spa_syncing_txg(spa).
	* In the zil_claim() case, we commit in spa_first_txg(spa).
	*
	* We currently do not make DTL entries for failed spontaneous
	* self-healing writes triggered by normal (non-scrubbing)
	* reads, because we have no transactional context in which to
	* do so -- and it's not clear that it'd be desirable anyway.
	*/
	if (vd->vdev_ops->vdev_op_leaf) {
	uint64_t commit_txg = txg;
	if (flags & ZIO_FLAG_SCAN_THREAD) {
	ASSERT(flags & ZIO_FLAG_IO_REPAIR);
	ASSERT(spa_sync_pass(spa) == 1);
	vdev_dtl_dirty(vd, DTL_SCRUB, txg, 1);
	commit_txg = spa_syncing_txg(spa);
	} else if (spa->spa_claiming) {
	ASSERT(flags & ZIO_FLAG_IO_REPAIR);
	commit_txg = spa_first_txg(spa);
	}
	ASSERT(commit_txg >= spa_syncing_txg(spa));
	if (vdev_dtl_contains(vd, DTL_MISSING, txg, 1))
	return;
	for (pvd = vd; pvd != rvd; pvd = pvd->vdev_parent)
	vdev_dtl_dirty(pvd, DTL_PARTIAL, txg, 1);
	vdev_dirty(vd->vdev_top, VDD_DTL, vd, commit_txg);
	}
	if (vd != rvd)
	vdev_dtl_dirty(vd, DTL_MISSING, txg, 1);
	}
	}

	int64_t
	vdev_deflated_space(vdev_t *vd, int64_t space)
	{
	ASSERT((space & (SPA_MINBLOCKSIZE-1)) == 0);
	ASSERT(vd->vdev_deflate_ratio != 0 \|\| vd->vdev_isl2cache);

	return ((space >> SPA_MINBLOCKSHIFT) * vd->vdev_deflate_ratio);
	}

	/*
	* Update the in-core space usage stats for this vdev, its metaslab class,
	* and the root vdev.
	*/
	void
	vdev_space_update(vdev_t *vd, int64_t alloc_delta, int64_t defer_delta,
	int64_t space_delta)
	{
	int64_t dspace_delta;
	spa_t *spa = vd->vdev_spa;
	vdev_t *rvd = spa->spa_root_vdev;

	ASSERT(vd == vd->vdev_top);

	/*
	* Apply the inverse of the psize-to-asize (ie. RAID-Z) space-expansion
	* factor. We must calculate this here and not at the root vdev
	* because the root vdev's psize-to-asize is simply the max of its
	* children's, thus not accurate enough for us.
	*/
	dspace_delta = vdev_deflated_space(vd, space_delta);

	mutex_enter(&vd->vdev_stat_lock);
	/* ensure we won't underflow */
	if (alloc_delta < 0) {
	ASSERT3U(vd->vdev_stat.vs_alloc, >=, -alloc_delta);
	}

	vd->vdev_stat.vs_alloc += alloc_delta;
	vd->vdev_stat.vs_space += space_delta;
	vd->vdev_stat.vs_dspace += dspace_delta;
	mutex_exit(&vd->vdev_stat_lock);

	/* every class but log contributes to root space stats */
	if (vd->vdev_mg != NULL && !vd->vdev_islog) {
	ASSERT(!vd->vdev_isl2cache);
	mutex_enter(&rvd->vdev_stat_lock);
	rvd->vdev_stat.vs_alloc += alloc_delta;
	rvd->vdev_stat.vs_space += space_delta;
	rvd->vdev_stat.vs_dspace += dspace_delta;
	mutex_exit(&rvd->vdev_stat_lock);
	}
	/* Note: metaslab_class_space_update moved to metaslab_space_update */
	}

	/*
	* Mark a top-level vdev's config as dirty, placing it on the dirty list
	* so that it will be written out next time the vdev configuration is synced.
	* If the root vdev is specified (vdev_top == NULL), dirty all top-level vdevs.
	*/
	void
	vdev_config_dirty(vdev_t *vd)
	{
	spa_t *spa = vd->vdev_spa;
	vdev_t *rvd = spa->spa_root_vdev;
	int c;

	ASSERT(spa_writeable(spa));

	/*
	* If this is an aux vdev (as with l2cache and spare devices), then we
	* update the vdev config manually and set the sync flag.
	*/
	if (vd->vdev_aux != NULL) {
	spa_aux_vdev_t *sav = vd->vdev_aux;
	nvlist_t **aux;
	uint_t naux;

	for (c = 0; c < sav->sav_count; c++) {
	if (sav->sav_vdevs[c] == vd)
	break;
	}

	if (c == sav->sav_count) {
	/*
	* We're being removed. There's nothing more to do.
	*/
	ASSERT(sav->sav_sync == B_TRUE);
	return;
	}

	sav->sav_sync = B_TRUE;

	if (nvlist_lookup_nvlist_array(sav->sav_config,
	ZPOOL_CONFIG_L2CACHE, &aux, &naux) != 0) {
	VERIFY(nvlist_lookup_nvlist_array(sav->sav_config,
	ZPOOL_CONFIG_SPARES, &aux, &naux) == 0);
	}

	ASSERT(c < naux);

	/*
	* Setting the nvlist in the middle if the array is a little
	* sketchy, but it will work.
	*/
	nvlist_free(aux[c]);
	aux[c] = vdev_config_generate(spa, vd, B_TRUE, 0);

	return;
	}

	/*
	* The dirty list is protected by the SCL_CONFIG lock. The caller
	* must either hold SCL_CONFIG as writer, or must be the sync thread
	* (which holds SCL_CONFIG as reader). There's only one sync thread,
	* so this is sufficient to ensure mutual exclusion.
	*/
	ASSERT(spa_config_held(spa, SCL_CONFIG, RW_WRITER) \|\|
	(dsl_pool_sync_context(spa_get_dsl(spa)) &&
	spa_config_held(spa, SCL_CONFIG, RW_READER)));

	if (vd == rvd) {
	for (c = 0; c < rvd->vdev_children; c++)
	vdev_config_dirty(rvd->vdev_child[c]);
	} else {
	ASSERT(vd == vd->vdev_top);

	if (!list_link_active(&vd->vdev_config_dirty_node) &&
	vdev_is_concrete(vd)) {
	list_insert_head(&spa->spa_config_dirty_list, vd);
	}
	}
	}

	void
	vdev_config_clean(vdev_t *vd)
	{
	spa_t *spa = vd->vdev_spa;

	ASSERT(spa_config_held(spa, SCL_CONFIG, RW_WRITER) \|\|
	(dsl_pool_sync_context(spa_get_dsl(spa)) &&
	spa_config_held(spa, SCL_CONFIG, RW_READER)));

	ASSERT(list_link_active(&vd->vdev_config_dirty_node));
	list_remove(&spa->spa_config_dirty_list, vd);
	}

	/*
	* Mark a top-level vdev's state as dirty, so that the next pass of
	* spa_sync() can convert this into vdev_config_dirty(). We distinguish
	* the state changes from larger config changes because they require
	* much less locking, and are often needed for administrative actions.
	*/
	void
	vdev_state_dirty(vdev_t *vd)
	{
	spa_t *spa = vd->vdev_spa;

	ASSERT(spa_writeable(spa));
	ASSERT(vd == vd->vdev_top);

	/*
	* The state list is protected by the SCL_STATE lock. The caller
	* must either hold SCL_STATE as writer, or must be the sync thread
	* (which holds SCL_STATE as reader). There's only one sync thread,
	* so this is sufficient to ensure mutual exclusion.
	*/
	ASSERT(spa_config_held(spa, SCL_STATE, RW_WRITER) \|\|
	(dsl_pool_sync_context(spa_get_dsl(spa)) &&
	spa_config_held(spa, SCL_STATE, RW_READER)));

	if (!list_link_active(&vd->vdev_state_dirty_node) &&
	vdev_is_concrete(vd))
	list_insert_head(&spa->spa_state_dirty_list, vd);
	}

	void
	vdev_state_clean(vdev_t *vd)
	{
	spa_t *spa = vd->vdev_spa;

	ASSERT(spa_config_held(spa, SCL_STATE, RW_WRITER) \|\|
	(dsl_pool_sync_context(spa_get_dsl(spa)) &&
	spa_config_held(spa, SCL_STATE, RW_READER)));

	ASSERT(list_link_active(&vd->vdev_state_dirty_node));
	list_remove(&spa->spa_state_dirty_list, vd);
	}

	/*
	* Propagate vdev state up from children to parent.
	*/
	void
	vdev_propagate_state(vdev_t *vd)
	{
	spa_t *spa = vd->vdev_spa;
	vdev_t *rvd = spa->spa_root_vdev;
	int degraded = 0, faulted = 0;
	int corrupted = 0;
	vdev_t *child;

	if (vd->vdev_children > 0) {
	for (int c = 0; c < vd->vdev_children; c++) {
	child = vd->vdev_child[c];

	/*
	* Don't factor holes or indirect vdevs into the
	* decision.
	*/
	if (!vdev_is_concrete(child))
	continue;

	if (!vdev_readable(child) \|\|
	(!vdev_writeable(child) && spa_writeable(spa))) {
	/*
	* Root special: if there is a top-level log
	* device, treat the root vdev as if it were
	* degraded.
	*/
	if (child->vdev_islog && vd == rvd)
	degraded++;
	else
	faulted++;
	} else if (child->vdev_state <= VDEV_STATE_DEGRADED) {
	degraded++;
	}

	if (child->vdev_stat.vs_aux == VDEV_AUX_CORRUPT_DATA)
	corrupted++;
	}

	vd->vdev_ops->vdev_op_state_change(vd, faulted, degraded);

	/*
	* Root special: if there is a top-level vdev that cannot be
	* opened due to corrupted metadata, then propagate the root
	* vdev's aux state as 'corrupt' rather than 'insufficient
	* replicas'.
	*/
	if (corrupted && vd == rvd &&
	rvd->vdev_state == VDEV_STATE_CANT_OPEN)
	vdev_set_state(rvd, B_FALSE, VDEV_STATE_CANT_OPEN,
	VDEV_AUX_CORRUPT_DATA);
	}

	if (vd->vdev_parent)
	vdev_propagate_state(vd->vdev_parent);
	}

	/*
	* Set a vdev's state. If this is during an open, we don't update the parent
	* state, because we're in the process of opening children depth-first.
	* Otherwise, we propagate the change to the parent.
	*
	* If this routine places a device in a faulted state, an appropriate ereport is
	* generated.
	*/
	void
	vdev_set_state(vdev_t *vd, boolean_t isopen, vdev_state_t state, vdev_aux_t aux)
	{
	uint64_t save_state;
	spa_t *spa = vd->vdev_spa;

	if (state == vd->vdev_state) {
	/*
	* Since vdev_offline() code path is already in an offline
	* state we can miss a statechange event to OFFLINE. Check
	* the previous state to catch this condition.
	*/
	if (vd->vdev_ops->vdev_op_leaf &&
	(state == VDEV_STATE_OFFLINE) &&
	(vd->vdev_prevstate >= VDEV_STATE_FAULTED)) {
	/* post an offline state change */
	zfs_post_state_change(spa, vd, vd->vdev_prevstate);
	}
	vd->vdev_stat.vs_aux = aux;
	return;
	}

	save_state = vd->vdev_state;

	vd->vdev_state = state;
	vd->vdev_stat.vs_aux = aux;

	/*
	* If we are setting the vdev state to anything but an open state, then
	* always close the underlying device unless the device has requested
	* a delayed close (i.e. we're about to remove or fault the device).
	* Otherwise, we keep accessible but invalid devices open forever.
	* We don't call vdev_close() itself, because that implies some extra
	* checks (offline, etc) that we don't want here. This is limited to
	* leaf devices, because otherwise closing the device will affect other
	* children.
	*/
	if (!vd->vdev_delayed_close && vdev_is_dead(vd) &&
	vd->vdev_ops->vdev_op_leaf)
	vd->vdev_ops->vdev_op_close(vd);

	if (vd->vdev_removed &&
	state == VDEV_STATE_CANT_OPEN &&
	(aux == VDEV_AUX_OPEN_FAILED \|\| vd->vdev_checkremove)) {
	/*
	* If the previous state is set to VDEV_STATE_REMOVED, then this
	* device was previously marked removed and someone attempted to
	* reopen it. If this failed due to a nonexistent device, then
	* keep the device in the REMOVED state. We also let this be if
	* it is one of our special test online cases, which is only
	* attempting to online the device and shouldn't generate an FMA
	* fault.
	*/
	vd->vdev_state = VDEV_STATE_REMOVED;
	vd->vdev_stat.vs_aux = VDEV_AUX_NONE;
	} else if (state == VDEV_STATE_REMOVED) {
	vd->vdev_removed = B_TRUE;
	} else if (state == VDEV_STATE_CANT_OPEN) {
	/*
	* If we fail to open a vdev during an import or recovery, we
	* mark it as "not available", which signifies that it was
	* never there to begin with. Failure to open such a device
	* is not considered an error.
	*/
	if ((spa_load_state(spa) == SPA_LOAD_IMPORT \|\|
	spa_load_state(spa) == SPA_LOAD_RECOVER) &&
	vd->vdev_ops->vdev_op_leaf)
	vd->vdev_not_present = 1;

	/*
	* Post the appropriate ereport. If the 'prevstate' field is
	* set to something other than VDEV_STATE_UNKNOWN, it indicates
	* that this is part of a vdev_reopen(). In this case, we don't
	* want to post the ereport if the device was already in the
	* CANT_OPEN state beforehand.
	*
	* If the 'checkremove' flag is set, then this is an attempt to
	* online the device in response to an insertion event. If we
	* hit this case, then we have detected an insertion event for a
	* faulted or offline device that wasn't in the removed state.
	* In this scenario, we don't post an ereport because we are
	* about to replace the device, or attempt an online with
	* vdev_forcefault, which will generate the fault for us.
	*/
	if ((vd->vdev_prevstate != state \|\| vd->vdev_forcefault) &&
	!vd->vdev_not_present && !vd->vdev_checkremove &&
	vd != spa->spa_root_vdev) {
	const char *class;

	switch (aux) {
	case VDEV_AUX_OPEN_FAILED:
	class = FM_EREPORT_ZFS_DEVICE_OPEN_FAILED;
	break;
	case VDEV_AUX_CORRUPT_DATA:
	class = FM_EREPORT_ZFS_DEVICE_CORRUPT_DATA;
	break;
	case VDEV_AUX_NO_REPLICAS:
	class = FM_EREPORT_ZFS_DEVICE_NO_REPLICAS;
	break;
	case VDEV_AUX_BAD_GUID_SUM:
	class = FM_EREPORT_ZFS_DEVICE_BAD_GUID_SUM;
	break;
	case VDEV_AUX_TOO_SMALL:
	class = FM_EREPORT_ZFS_DEVICE_TOO_SMALL;
	break;
	case VDEV_AUX_BAD_LABEL:
	class = FM_EREPORT_ZFS_DEVICE_BAD_LABEL;
	break;
	case VDEV_AUX_BAD_ASHIFT:
	class = FM_EREPORT_ZFS_DEVICE_BAD_ASHIFT;
	break;
	default:
	class = FM_EREPORT_ZFS_DEVICE_UNKNOWN;
	}

	(void) zfs_ereport_post(class, spa, vd, NULL, NULL,
	save_state);
	}

	/* Erase any notion of persistent removed state */
	vd->vdev_removed = B_FALSE;
	} else {
	vd->vdev_removed = B_FALSE;
	}

	/*
	* Notify ZED of any significant state-change on a leaf vdev.
	*
	*/
	if (vd->vdev_ops->vdev_op_leaf) {
	/* preserve original state from a vdev_reopen() */
	if ((vd->vdev_prevstate != VDEV_STATE_UNKNOWN) &&
	(vd->vdev_prevstate != vd->vdev_state) &&
	(save_state <= VDEV_STATE_CLOSED))
	save_state = vd->vdev_prevstate;

	/* filter out state change due to initial vdev_open */
	if (save_state > VDEV_STATE_CLOSED)
	zfs_post_state_change(spa, vd, save_state);
	}

	if (!isopen && vd->vdev_parent)
	vdev_propagate_state(vd->vdev_parent);
	}

	boolean_t
	vdev_children_are_offline(vdev_t *vd)
	{
	ASSERT(!vd->vdev_ops->vdev_op_leaf);

	for (uint64_t i = 0; i < vd->vdev_children; i++) {
	if (vd->vdev_child[i]->vdev_state != VDEV_STATE_OFFLINE)
	return (B_FALSE);
	}

	return (B_TRUE);
	}

	/*
	* Check the vdev configuration to ensure that it's capable of supporting
	* a root pool. We do not support partial configuration.
	*/
	boolean_t
	vdev_is_bootable(vdev_t *vd)
	{
	if (!vd->vdev_ops->vdev_op_leaf) {
	const char *vdev_type = vd->vdev_ops->vdev_op_type;

	if (strcmp(vdev_type, VDEV_TYPE_MISSING) == 0)
	return (B_FALSE);
	}

	for (int c = 0; c < vd->vdev_children; c++) {
	if (!vdev_is_bootable(vd->vdev_child[c]))
	return (B_FALSE);
	}
	return (B_TRUE);
	}

	boolean_t
	vdev_is_concrete(vdev_t *vd)
	{
	vdev_ops_t *ops = vd->vdev_ops;
	if (ops == &vdev_indirect_ops \|\| ops == &vdev_hole_ops \|\|
	ops == &vdev_missing_ops \|\| ops == &vdev_root_ops) {
	return (B_FALSE);
	} else {
	return (B_TRUE);
	}
	}

	/*
	* Determine if a log device has valid content. If the vdev was
	* removed or faulted in the MOS config then we know that
	* the content on the log device has already been written to the pool.
	*/
	boolean_t
	vdev_log_state_valid(vdev_t *vd)
	{
	if (vd->vdev_ops->vdev_op_leaf && !vd->vdev_faulted &&
	!vd->vdev_removed)
	return (B_TRUE);

	for (int c = 0; c < vd->vdev_children; c++)
	if (vdev_log_state_valid(vd->vdev_child[c]))
	return (B_TRUE);

	return (B_FALSE);
	}

	/*
	* Expand a vdev if possible.
	*/
	void
	vdev_expand(vdev_t *vd, uint64_t txg)
	{
	ASSERT(vd->vdev_top == vd);
	ASSERT(spa_config_held(vd->vdev_spa, SCL_ALL, RW_WRITER) == SCL_ALL);
	ASSERT(vdev_is_concrete(vd));

	vdev_set_deflate_ratio(vd);

	if ((vd->vdev_asize >> vd->vdev_ms_shift) > vd->vdev_ms_count &&
	vdev_is_concrete(vd)) {
	vdev_metaslab_group_create(vd);
	VERIFY(vdev_metaslab_init(vd, txg) == 0);
	vdev_config_dirty(vd);
	}
	}

	/*
	* Split a vdev.
	*/
	void
	vdev_split(vdev_t *vd)
	{
	vdev_t cvd, pvd = vd->vdev_parent;

	vdev_remove_child(pvd, vd);
	vdev_compact_children(pvd);

	cvd = pvd->vdev_child[0];
	if (pvd->vdev_children == 1) {
	vdev_remove_parent(cvd);
	cvd->vdev_splitting = B_TRUE;
	}
	vdev_propagate_state(cvd);
	}

	void
	vdev_deadman(vdev_t vd, char tag)
	{
	for (int c = 0; c < vd->vdev_children; c++) {
	vdev_t *cvd = vd->vdev_child[c];

	vdev_deadman(cvd, tag);
	}

	if (vd->vdev_ops->vdev_op_leaf) {
	vdev_queue_t *vq = &vd->vdev_queue;

	mutex_enter(&vq->vq_lock);
	if (avl_numnodes(&vq->vq_active_tree) > 0) {
	spa_t *spa = vd->vdev_spa;
	zio_t *fio;
	uint64_t delta;

	zfs_dbgmsg("slow vdev: %s has %d active IOs",
	vd->vdev_path, avl_numnodes(&vq->vq_active_tree));

	/*
	* Look at the head of all the pending queues,
	* if any I/O has been outstanding for longer than
	* the spa_deadman_synctime invoke the deadman logic.
	*/
	fio = avl_first(&vq->vq_active_tree);
	delta = gethrtime() - fio->io_timestamp;
	if (delta > spa_deadman_synctime(spa))
	zio_deadman(fio, tag);
	}
	mutex_exit(&vq->vq_lock);
	}
	}

	void
	vdev_defer_resilver(vdev_t *vd)
	{
	ASSERT(vd->vdev_ops->vdev_op_leaf);

	vd->vdev_resilver_deferred = B_TRUE;
	vd->vdev_spa->spa_resilver_deferred = B_TRUE;
	}

	/*
	* Clears the resilver deferred flag on all leaf devs under vd. Returns
	* B_TRUE if we have devices that need to be resilvered and are available to
	* accept resilver I/Os.
	*/
	boolean_t
	vdev_clear_resilver_deferred(vdev_t vd, dmu_tx_t tx)
	{
	boolean_t resilver_needed = B_FALSE;
	spa_t *spa = vd->vdev_spa;

	for (int c = 0; c < vd->vdev_children; c++) {
	vdev_t *cvd = vd->vdev_child[c];
	resilver_needed \|= vdev_clear_resilver_deferred(cvd, tx);
	}

	if (vd == spa->spa_root_vdev &&
	spa_feature_is_active(spa, SPA_FEATURE_RESILVER_DEFER)) {
	spa_feature_decr(spa, SPA_FEATURE_RESILVER_DEFER, tx);
	vdev_config_dirty(vd);
	spa->spa_resilver_deferred = B_FALSE;
	return (resilver_needed);
	}

	if (!vdev_is_concrete(vd) \|\| vd->vdev_aux \|\|
	!vd->vdev_ops->vdev_op_leaf)
	return (resilver_needed);

	vd->vdev_resilver_deferred = B_FALSE;

	return (!vdev_is_dead(vd) && !vd->vdev_offline &&
	vdev_resilver_needed(vd, NULL, NULL));
	}

	boolean_t
	vdev_xlate_is_empty(range_seg64_t *rs)
	{
	return (rs->rs_start == rs->rs_end);
	}

	/*
	* Translate a logical range to the first contiguous physical range for the
	* specified vdev_t. This function is initially called with a leaf vdev and
	* will walk each parent vdev until it reaches a top-level vdev. Once the
	* top-level is reached the physical range is initialized and the recursive
	* function begins to unwind. As it unwinds it calls the parent's vdev
	* specific translation function to do the real conversion.
	*/
	void
	vdev_xlate(vdev_t vd, const range_seg64_t logical_rs,
	range_seg64_t physical_rs, range_seg64_t remain_rs)
	{
	/*
	* Walk up the vdev tree
	*/
	if (vd != vd->vdev_top) {
	vdev_xlate(vd->vdev_parent, logical_rs, physical_rs,
	remain_rs);
	} else {
	/*
	* We've reached the top-level vdev, initialize the physical
	* range to the logical range and set an empty remaining
	* range then start to unwind.
	*/
	physical_rs->rs_start = logical_rs->rs_start;
	physical_rs->rs_end = logical_rs->rs_end;

	remain_rs->rs_start = logical_rs->rs_start;
	remain_rs->rs_end = logical_rs->rs_start;

	return;
	}

	vdev_t *pvd = vd->vdev_parent;
	ASSERT3P(pvd, !=, NULL);
	ASSERT3P(pvd->vdev_ops->vdev_op_xlate, !=, NULL);

	/*
	* As this recursive function unwinds, translate the logical
	* range into its physical and any remaining components by calling
	* the vdev specific translate function.
	*/
	range_seg64_t intermediate = { 0 };
	pvd->vdev_ops->vdev_op_xlate(vd, physical_rs, &intermediate, remain_rs);

	physical_rs->rs_start = intermediate.rs_start;
	physical_rs->rs_end = intermediate.rs_end;
	}

	void
	vdev_xlate_walk(vdev_t vd, const range_seg64_t logical_rs,
	vdev_xlate_func_t func, void arg)
	{
	range_seg64_t iter_rs = *logical_rs;
	range_seg64_t physical_rs;
	range_seg64_t remain_rs;

	while (!vdev_xlate_is_empty(&iter_rs)) {

	vdev_xlate(vd, &iter_rs, &physical_rs, &remain_rs);

	/*
	* With raidz and dRAID, it's possible that the logical range
	* does not live on this leaf vdev. Only when there is a non-
	* zero physical size call the provided function.
	*/
	if (!vdev_xlate_is_empty(&physical_rs))
	func(arg, &physical_rs);

	iter_rs = remain_rs;
	}
	}

	/*
	* Look at the vdev tree and determine whether any devices are currently being
	* replaced.
	*/
	boolean_t
	vdev_replace_in_progress(vdev_t *vdev)
	{
	ASSERT(spa_config_held(vdev->vdev_spa, SCL_ALL, RW_READER) != 0);

	if (vdev->vdev_ops == &vdev_replacing_ops)
	return (B_TRUE);

	/*
	* A 'spare' vdev indicates that we have a replace in progress, unless
	* it has exactly two children, and the second, the hot spare, has
	* finished being resilvered.
	*/
	if (vdev->vdev_ops == &vdev_spare_ops && (vdev->vdev_children > 2 \|\|
	!vdev_dtl_empty(vdev->vdev_child[1], DTL_MISSING)))
	return (B_TRUE);

	for (int i = 0; i < vdev->vdev_children; i++) {
	if (vdev_replace_in_progress(vdev->vdev_child[i]))
	return (B_TRUE);
	}

	return (B_FALSE);
	}

	EXPORT_SYMBOL(vdev_fault);
	EXPORT_SYMBOL(vdev_degrade);
	EXPORT_SYMBOL(vdev_online);
	EXPORT_SYMBOL(vdev_offline);
	EXPORT_SYMBOL(vdev_clear);

	/* BEGIN CSTYLED */
	ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, default_ms_count, INT, ZMOD_RW,
	"Target number of metaslabs per top-level vdev");

	ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, default_ms_shift, INT, ZMOD_RW,
	"Default limit for metaslab size");

	ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, min_ms_count, INT, ZMOD_RW,
	"Minimum number of metaslabs per top-level vdev");

	ZFS_MODULE_PARAM(zfs_vdev, zfs_vdev_, ms_count_limit, INT, ZMOD_RW,
	"Practical upper limit of total metaslabs per top-level vdev");

	ZFS_MODULE_PARAM(zfs, zfs_, slow_io_events_per_second, UINT, ZMOD_RW,
	"Rate limit slow IO (delay) events to this many per second");

	ZFS_MODULE_PARAM(zfs, zfs_, checksum_events_per_second, UINT, ZMOD_RW,
	"Rate limit checksum events to this many checksum errors per second "
	"(do not set below zed threshold).");

	ZFS_MODULE_PARAM(zfs, zfs_, scan_ignore_errors, INT, ZMOD_RW,
	"Ignore errors during resilver/scrub");

	ZFS_MODULE_PARAM(zfs_vdev, vdev_, validate_skip, INT, ZMOD_RW,
	"Bypass vdev_validate()");

	ZFS_MODULE_PARAM(zfs, zfs_, nocacheflush, INT, ZMOD_RW,
	"Disable cache flushes");

	ZFS_MODULE_PARAM(zfs, zfs_, embedded_slog_min_ms, INT, ZMOD_RW,
	"Minimum number of metaslabs required to dedicate one for log blocks");

	ZFS_MODULE_PARAM_CALL(zfs_vdev, zfs_vdev_, min_auto_ashift,
	param_set_min_auto_ashift, param_get_ulong, ZMOD_RW,
	"Minimum ashift used when creating new top-level vdevs");

	ZFS_MODULE_PARAM_CALL(zfs_vdev, zfs_vdev_, max_auto_ashift,
	param_set_max_auto_ashift, param_get_ulong, ZMOD_RW,
	"Maximum ashift used when optimizing for logical -> physical sector "
	"size on new top-level vdevs");
	/* END CSTYLED */
	diff --git a/sys/contrib/openzfs/module/zfs/vdev_draid.c b/sys/contrib/openzfs/module/zfs/vdev_draid.c
	index fb2143e94689..20b1457f0ce8 100644
	--- a/sys/contrib/openzfs/module/zfs/vdev_draid.c
	+++ b/sys/contrib/openzfs/module/zfs/vdev_draid.c
	@@ -1,2742 +1,2783 @@
	/*
	* 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) 2018 Intel Corporation.
	* Copyright (c) 2020 by Lawrence Livermore National Security, LLC.
	*/

	#include <sys/zfs_context.h>
	#include <sys/spa.h>
	#include <sys/spa_impl.h>
	#include <sys/vdev_impl.h>
	#include <sys/vdev_draid.h>
	#include <sys/vdev_raidz.h>
	#include <sys/vdev_rebuild.h>
	#include <sys/abd.h>
	#include <sys/zio.h>
	#include <sys/nvpair.h>
	#include <sys/zio_checksum.h>
	#include <sys/fs/zfs.h>
	#include <sys/fm/fs/zfs.h>
	#include <zfs_fletcher.h>

	#ifdef ZFS_DEBUG
	#include <sys/vdev.h> /* For vdev_xlate() in vdev_draid_io_verify() */
	#endif

	/*
	* dRAID is a distributed spare implementation for ZFS. A dRAID vdev is
	* comprised of multiple raidz redundancy groups which are spread over the
	* dRAID children. To ensure an even distribution, and avoid hot spots, a
	* permutation mapping is applied to the order of the dRAID children.
	* This mixing effectively distributes the parity columns evenly over all
	* of the disks in the dRAID.
	*
	* This is beneficial because it means when resilvering all of the disks
	* can participate thereby increasing the available IOPs and bandwidth.
	* Furthermore, by reserving a small fraction of each child's total capacity
	* virtual distributed spare disks can be created. These spares similarly
	* benefit from the performance gains of spanning all of the children. The
	* consequence of which is that resilvering to a distributed spare can
	* substantially reduce the time required to restore full parity to pool
	* with a failed disks.
	*
	* === dRAID group layout ===
	*
	* First, let's define a "row" in the configuration to be a 16M chunk from
	* each physical drive at the same offset. This is the minimum allowable
	* size since it must be possible to store a full 16M block when there is
	* only a single data column. Next, we define a "group" to be a set of
	* sequential disks containing both the parity and data columns. We allow
	* groups to span multiple rows in order to align any group size to any
	* number of physical drives. Finally, a "slice" is comprised of the rows
	* which contain the target number of groups. The permutation mappings
	* are applied in a round robin fashion to each slice.
	*
	* Given D+P drives in a group (including parity drives) and C-S physical
	* drives (not including the spare drives), we can distribute the groups
	* across R rows without remainder by selecting the least common multiple
	* of D+P and C-S as the number of groups; i.e. ngroups = LCM(D+P, C-S).
	*
	* In the example below, there are C=14 physical drives in the configuration
	* with S=2 drives worth of spare capacity. Each group has a width of 9
	* which includes D=8 data and P=1 parity drive. There are 4 groups and
	* 3 rows per slice. Each group has a size of 144M (16M * 9) and a slice
	* size is 576M (144M * 4). When allocating from a dRAID each group is
	* filled before moving on to the next as show in slice0 below.
	*
	* data disks (8 data + 1 parity) spares (2)
	* +===+===+===+===+===+===+===+===+===+===+===+===+===+===+
	* ^ \| 2 \| 6 \| 1 \| 11\| 4 \| 0 \| 7 \| 10\| 8 \| 9 \| 13\| 5 \| 12\| 3 \| device map 0
	* \| +===+===+===+===+===+===+===+===+===+===+===+===+===+===+
	* \| \| group 0 \| group 1..\| \|
	* \| +-----------------------------------+-----------+-------\|
	* \| \| 0 1 2 3 4 5 6 7 8 \| 36 37 38\| \| r
	* \| \| 9 10 11 12 13 14 15 16 17\| 45 46 47\| \| o
	* \| \| 18 19 20 21 22 23 24 25 26\| 54 55 56\| \| w
	* \| 27 28 29 30 31 32 33 34 35\| 63 64 65\| \| 0
	* s +-----------------------+-----------------------+-------+
	* l \| ..group 1 \| group 2.. \| \|
	* i +-----------------------+-----------------------+-------+
	* c \| 39 40 41 42 43 44\| 72 73 74 75 76 77\| \| r
	* e \| 48 49 50 51 52 53\| 81 82 83 84 85 86\| \| o
	* 0 \| 57 58 59 60 61 62\| 90 91 92 93 94 95\| \| w
	* \| 66 67 68 69 70 71\| 99 100 101 102 103 104\| \| 1
	* \| +-----------+-----------+-----------------------+-------+
	* \| \|..group 2 \| group 3 \| \|
	* \| +-----------+-----------+-----------------------+-------+
	* \| \| 78 79 80\|108 109 110 111 112 113 114 115 116\| \| r
	* \| \| 87 88 89\|117 118 119 120 121 122 123 124 125\| \| o
	* \| \| 96 97 98\|126 127 128 129 130 131 132 133 134\| \| w
	* v \|105 106 107\|135 136 137 138 139 140 141 142 143\| \| 2
	* +===+===+===+===+===+===+===+===+===+===+===+===+===+===+
	* \| 9 \| 11\| 12\| 2 \| 4 \| 1 \| 3 \| 0 \| 10\| 13\| 8 \| 5 \| 6 \| 7 \| device map 1
	* s +===+===+===+===+===+===+===+===+===+===+===+===+===+===+
	* l \| group 4 \| group 5..\| \| row 3
	* i +-----------------------+-----------+-----------+-------\|
	* c \| ..group 5 \| group 6.. \| \| row 4
	* e +-----------+-----------+-----------------------+-------+
	* 1 \|..group 6 \| group 7 \| \| row 5
	* +===+===+===+===+===+===+===+===+===+===+===+===+===+===+
	* \| 3 \| 5 \| 10\| 8 \| 6 \| 11\| 12\| 0 \| 2 \| 4 \| 7 \| 1 \| 9 \| 13\| device map 2
	* s +===+===+===+===+===+===+===+===+===+===+===+===+===+===+
	* l \| group 8 \| group 9..\| \| row 6
	* i +-----------------------------------------------+-------\|
	* c \| ..group 9 \| group 10.. \| \| row 7
	* e +-----------------------+-----------------------+-------+
	* 2 \|..group 10 \| group 11 \| \| row 8
	* +-----------+-----------------------------------+-------+
	*
	* This layout has several advantages over requiring that each row contain
	* a whole number of groups.
	*
	* 1. The group count is not a relevant parameter when defining a dRAID
	* layout. Only the group width is needed, and all groups will have
	* the desired size.
	*
	* 2. All possible group widths (<= physical disk count) can be supported.
	*
	* 3. The logic within vdev_draid.c is simplified when the group width is
	* the same for all groups (although some of the logic around computing
	* permutation numbers and drive offsets is more complicated).
	*
	* N.B. The following array describes all valid dRAID permutation maps.
	* Each row is used to generate a permutation map for a different number
	* of children from a unique seed. The seeds were generated and carefully
	* evaluated by the 'draid' utility in order to provide balanced mappings.
	* In addition to the seed a checksum of the in-memory mapping is stored
	* for verification.
	*
	* The imbalance ratio of a given failure (e.g. 5 disks wide, child 3 failed,
	* with a given permutation map) is the ratio of the amounts of I/O that will
	* be sent to the least and most busy disks when resilvering. The average
	* imbalance ratio (of a given number of disks and permutation map) is the
	* average of the ratios of all possible single and double disk failures.
	*
	* In order to achieve a low imbalance ratio the number of permutations in
	* the mapping must be significantly larger than the number of children.
	* For dRAID the number of permutations has been limited to 512 to minimize
	* the map size. This does result in a gradually increasing imbalance ratio
	* as seen in the table below. Increasing the number of permutations for
	* larger child counts would reduce the imbalance ratio. However, in practice
	* when there are a large number of children each child is responsible for
	* fewer total IOs so it's less of a concern.
	*
	* Note these values are hard coded and must never be changed. Existing
	* pools depend on the same mapping always being generated in order to
	* read and write from the correct locations. Any change would make
	* existing pools completely inaccessible.
	*/
	static const draid_map_t draid_maps[VDEV_DRAID_MAX_MAPS] = {
	{ 2, 256, 0x89ef3dabbcc7de37, 0x00000000433d433d }, /* 1.000 */
	{ 3, 256, 0x89a57f3de98121b4, 0x00000000bcd8b7b5 }, /* 1.000 */
	{ 4, 256, 0xc9ea9ec82340c885, 0x00000001819d7c69 }, /* 1.000 */
	{ 5, 256, 0xf46733b7f4d47dfd, 0x00000002a1648d74 }, /* 1.010 */
	{ 6, 256, 0x88c3c62d8585b362, 0x00000003d3b0c2c4 }, /* 1.031 */
	{ 7, 256, 0x3a65d809b4d1b9d5, 0x000000055c4183ee }, /* 1.043 */
	{ 8, 256, 0xe98930e3c5d2e90a, 0x00000006edfb0329 }, /* 1.059 */
	{ 9, 256, 0x5a5430036b982ccb, 0x00000008ceaf6934 }, /* 1.056 */
	{ 10, 256, 0x92bf389e9eadac74, 0x0000000b26668c09 }, /* 1.072 */
	{ 11, 256, 0x74ccebf1dcf3ae80, 0x0000000dd691358c }, /* 1.083 */
	{ 12, 256, 0x8847e41a1a9f5671, 0x00000010a0c63c8e }, /* 1.097 */
	{ 13, 256, 0x7481b56debf0e637, 0x0000001424121fe4 }, /* 1.100 */
	{ 14, 256, 0x559b8c44065f8967, 0x00000016ab2ff079 }, /* 1.121 */
	{ 15, 256, 0x34c49545a2ee7f01, 0x0000001a6028efd6 }, /* 1.103 */
	{ 16, 256, 0xb85f4fa81a7698f7, 0x0000001e95ff5e66 }, /* 1.111 */
	{ 17, 256, 0x6353e47b7e47aba0, 0x00000021a81fa0fe }, /* 1.133 */
	{ 18, 256, 0xaa549746b1cbb81c, 0x00000026f02494c9 }, /* 1.131 */
	{ 19, 256, 0x892e343f2f31d690, 0x00000029eb392835 }, /* 1.130 */
	{ 20, 256, 0x76914824db98cc3f, 0x0000003004f31a7c }, /* 1.141 */
	{ 21, 256, 0x4b3cbabf9cfb1d0f, 0x00000036363a2408 }, /* 1.139 */
	{ 22, 256, 0xf45c77abb4f035d4, 0x00000038dd0f3e84 }, /* 1.150 */
	{ 23, 256, 0x5e18bd7f3fd4baf4, 0x0000003f0660391f }, /* 1.174 */
	{ 24, 256, 0xa7b3a4d285d6503b, 0x000000443dfc9ff6 }, /* 1.168 */
	{ 25, 256, 0x56ac7dd967521f5a, 0x0000004b03a87eb7 }, /* 1.180 */
	{ 26, 256, 0x3a42dfda4eb880f7, 0x000000522c719bba }, /* 1.226 */
	{ 27, 256, 0xd200d2fc6b54bf60, 0x0000005760b4fdf5 }, /* 1.228 */
	{ 28, 256, 0xc52605bbd486c546, 0x0000005e00d8f74c }, /* 1.217 */
	{ 29, 256, 0xc761779e63cd762f, 0x00000067be3cd85c }, /* 1.239 */
	{ 30, 256, 0xca577b1e07f85ca5, 0x0000006f5517f3e4 }, /* 1.238 */
	{ 31, 256, 0xfd50a593c518b3d4, 0x0000007370e7778f }, /* 1.273 */
	{ 32, 512, 0xc6c87ba5b042650b, 0x000000f7eb08a156 }, /* 1.191 */
	{ 33, 512, 0xc3880d0c9d458304, 0x0000010734b5d160 }, /* 1.199 */
	{ 34, 512, 0xe920927e4d8b2c97, 0x00000118c1edbce0 }, /* 1.195 */
	{ 35, 512, 0x8da7fcda87bde316, 0x0000012a3e9f9110 }, /* 1.201 */
	{ 36, 512, 0xcf09937491514a29, 0x0000013bd6a24bef }, /* 1.194 */
	{ 37, 512, 0x9b5abbf345cbd7cc, 0x0000014b9d90fac3 }, /* 1.237 */
	{ 38, 512, 0x506312a44668d6a9, 0x0000015e1b5f6148 }, /* 1.242 */
	{ 39, 512, 0x71659ede62b4755f, 0x00000173ef029bcd }, /* 1.231 */
	{ 40, 512, 0xa7fde73fb74cf2d7, 0x000001866fb72748 }, /* 1.233 */
	{ 41, 512, 0x19e8b461a1dea1d3, 0x000001a046f76b23 }, /* 1.271 */
	{ 42, 512, 0x031c9b868cc3e976, 0x000001afa64c49d3 }, /* 1.263 */
	{ 43, 512, 0xbaa5125faa781854, 0x000001c76789e278 }, /* 1.270 */
	{ 44, 512, 0x4ed55052550d721b, 0x000001d800ccd8eb }, /* 1.281 */
	{ 45, 512, 0x0fd63ddbdff90677, 0x000001f08ad59ed2 }, /* 1.282 */
	{ 46, 512, 0x36d66546de7fdd6f, 0x000002016f09574b }, /* 1.286 */
	{ 47, 512, 0x99f997e7eafb69d7, 0x0000021e42e47cb6 }, /* 1.329 */
	{ 48, 512, 0xbecd9c2571312c5d, 0x000002320fe2872b }, /* 1.286 */
	{ 49, 512, 0xd97371329e488a32, 0x0000024cd73f2ca7 }, /* 1.322 */
	{ 50, 512, 0x30e9b136670749ee, 0x000002681c83b0e0 }, /* 1.335 */
	{ 51, 512, 0x11ad6bc8f47aaeb4, 0x0000027e9261b5d5 }, /* 1.305 */
	{ 52, 512, 0x68e445300af432c1, 0x0000029aa0eb7dbf }, /* 1.330 */
	{ 53, 512, 0x910fb561657ea98c, 0x000002b3dca04853 }, /* 1.365 */
	{ 54, 512, 0xd619693d8ce5e7a5, 0x000002cc280e9c97 }, /* 1.334 */
	{ 55, 512, 0x24e281f564dbb60a, 0x000002e9fa842713 }, /* 1.364 */
	{ 56, 512, 0x947a7d3bdaab44c5, 0x000003046680f72e }, /* 1.374 */
	{ 57, 512, 0x2d44fec9c093e0de, 0x00000324198ba810 }, /* 1.363 */
	{ 58, 512, 0x87743c272d29bb4c, 0x0000033ec48c9ac9 }, /* 1.401 */
	{ 59, 512, 0x96aa3b6f67f5d923, 0x0000034faead902c }, /* 1.392 */
	{ 60, 512, 0x94a4f1faf520b0d3, 0x0000037d713ab005 }, /* 1.360 */
	{ 61, 512, 0xb13ed3a272f711a2, 0x00000397368f3cbd }, /* 1.396 */
	{ 62, 512, 0x3b1b11805fa4a64a, 0x000003b8a5e2840c }, /* 1.453 */
	{ 63, 512, 0x4c74caad9172ba71, 0x000003d4be280290 }, /* 1.437 */
	{ 64, 512, 0x035ff643923dd29e, 0x000003fad6c355e1 }, /* 1.402 */
	{ 65, 512, 0x768e9171b11abd3c, 0x0000040eb07fed20 }, /* 1.459 */
	{ 66, 512, 0x75880e6f78a13ddd, 0x000004433d6acf14 }, /* 1.423 */
	{ 67, 512, 0x910b9714f698a877, 0x00000451ea65d5db }, /* 1.447 */
	{ 68, 512, 0x87f5db6f9fdcf5c7, 0x000004732169e3f7 }, /* 1.450 */
	{ 69, 512, 0x836d4968fbaa3706, 0x000004954068a380 }, /* 1.455 */
	{ 70, 512, 0xc567d73a036421ab, 0x000004bd7cb7bd3d }, /* 1.463 */
	{ 71, 512, 0x619df40f240b8fed, 0x000004e376c2e972 }, /* 1.463 */
	{ 72, 512, 0x42763a680d5bed8e, 0x000005084275c680 }, /* 1.452 */
	{ 73, 512, 0x5866f064b3230431, 0x0000052906f2c9ab }, /* 1.498 */
	{ 74, 512, 0x9fa08548b1621a44, 0x0000054708019247 }, /* 1.526 */
	{ 75, 512, 0xb6053078ce0fc303, 0x00000572cc5c72b0 }, /* 1.491 */
	{ 76, 512, 0x4a7aad7bf3890923, 0x0000058e987bc8e9 }, /* 1.470 */
	{ 77, 512, 0xe165613fd75b5a53, 0x000005c20473a211 }, /* 1.527 */
	{ 78, 512, 0x3ff154ac878163a6, 0x000005d659194bf3 }, /* 1.509 */
	{ 79, 512, 0x24b93ade0aa8a532, 0x0000060a201c4f8e }, /* 1.569 */
	{ 80, 512, 0xc18e2d14cd9bb554, 0x0000062c55cfe48c }, /* 1.555 */
	{ 81, 512, 0x98cc78302feb58b6, 0x0000066656a07194 }, /* 1.509 */
	{ 82, 512, 0xc6c5fd5a2abc0543, 0x0000067cff94fbf8 }, /* 1.596 */
	{ 83, 512, 0xa7962f514acbba21, 0x000006ab7b5afa2e }, /* 1.568 */
	{ 84, 512, 0xba02545069ddc6dc, 0x000006d19861364f }, /* 1.541 */
	{ 85, 512, 0x447c73192c35073e, 0x000006fce315ce35 }, /* 1.623 */
	{ 86, 512, 0x48beef9e2d42b0c2, 0x00000720a8e38b6b }, /* 1.620 */
	{ 87, 512, 0x4874cf98541a35e0, 0x00000758382a2273 }, /* 1.597 */
	{ 88, 512, 0xad4cf8333a31127a, 0x00000781e1651b1b }, /* 1.575 */
	{ 89, 512, 0x47ae4859d57888c1, 0x000007b27edbe5bc }, /* 1.627 */
	{ 90, 512, 0x06f7723cfe5d1891, 0x000007dc2a96d8eb }, /* 1.596 */
	{ 91, 512, 0xd4e44218d660576d, 0x0000080ac46f02d5 }, /* 1.622 */
	{ 92, 512, 0x7066702b0d5be1f2, 0x00000832c96d154e }, /* 1.695 */
	{ 93, 512, 0x011209b4f9e11fb9, 0x0000085eefda104c }, /* 1.605 */
	{ 94, 512, 0x47ffba30a0b35708, 0x00000899badc32dc }, /* 1.625 */
	{ 95, 512, 0x1a95a6ac4538aaa8, 0x000008b6b69a42b2 }, /* 1.687 */
	{ 96, 512, 0xbda2b239bb2008eb, 0x000008f22d2de38a }, /* 1.621 */
	{ 97, 512, 0x7ffa0bea90355c6c, 0x0000092e5b23b816 }, /* 1.699 */
	{ 98, 512, 0x1d56ba34be426795, 0x0000094f482e5d1b }, /* 1.688 */
	{ 99, 512, 0x0aa89d45c502e93d, 0x00000977d94a98ce }, /* 1.642 */
	{ 100, 512, 0x54369449f6857774, 0x000009c06c9b34cc }, /* 1.683 */
	{ 101, 512, 0xf7d4dd8445b46765, 0x000009e5dc542259 }, /* 1.755 */
	{ 102, 512, 0xfa8866312f169469, 0x00000a16b54eae93 }, /* 1.692 */
	{ 103, 512, 0xd8a5aea08aef3ff9, 0x00000a381d2cbfe7 }, /* 1.747 */
	{ 104, 512, 0x66bcd2c3d5f9ef0e, 0x00000a8191817be7 }, /* 1.751 */
	{ 105, 512, 0x3fb13a47a012ec81, 0x00000ab562b9a254 }, /* 1.751 */
	{ 106, 512, 0x43100f01c9e5e3ca, 0x00000aeee84c185f }, /* 1.726 */
	{ 107, 512, 0xca09c50ccee2d054, 0x00000b1c359c047d }, /* 1.788 */
	{ 108, 512, 0xd7176732ac503f9b, 0x00000b578bc52a73 }, /* 1.740 */
	{ 109, 512, 0xed206e51f8d9422d, 0x00000b8083e0d960 }, /* 1.780 */
	{ 110, 512, 0x17ead5dc6ba0dcd6, 0x00000bcfb1a32ca8 }, /* 1.836 */
	{ 111, 512, 0x5f1dc21e38a969eb, 0x00000c0171becdd6 }, /* 1.778 */
	{ 112, 512, 0xddaa973de33ec528, 0x00000c3edaba4b95 }, /* 1.831 */
	{ 113, 512, 0x2a5eccd7735a3630, 0x00000c630664e7df }, /* 1.825 */
	{ 114, 512, 0xafcccee5c0b71446, 0x00000cb65392f6e4 }, /* 1.826 */
	{ 115, 512, 0x8fa30c5e7b147e27, 0x00000cd4db391e55 }, /* 1.843 */
	{ 116, 512, 0x5afe0711fdfafd82, 0x00000d08cb4ec35d }, /* 1.826 */
	{ 117, 512, 0x533a6090238afd4c, 0x00000d336f115d1b }, /* 1.803 */
	{ 118, 512, 0x90cf11b595e39a84, 0x00000d8e041c2048 }, /* 1.857 */
	{ 119, 512, 0x0d61a3b809444009, 0x00000dcb798afe35 }, /* 1.877 */
	{ 120, 512, 0x7f34da0f54b0d114, 0x00000df3922664e1 }, /* 1.849 */
	{ 121, 512, 0xa52258d5b72f6551, 0x00000e4d37a9872d }, /* 1.867 */
	{ 122, 512, 0xc1de54d7672878db, 0x00000e6583a94cf6 }, /* 1.978 */
	{ 123, 512, 0x1d03354316a414ab, 0x00000ebffc50308d }, /* 1.947 */
	{ 124, 512, 0xcebdcc377665412c, 0x00000edee1997cea }, /* 1.865 */
	{ 125, 512, 0x4ddd4c04b1a12344, 0x00000f21d64b373f }, /* 1.881 */
	{ 126, 512, 0x64fc8f94e3973658, 0x00000f8f87a8896b }, /* 1.882 */
	{ 127, 512, 0x68765f78034a334e, 0x00000fb8fe62197e }, /* 1.867 */
	{ 128, 512, 0xaf36b871a303e816, 0x00000fec6f3afb1e }, /* 1.972 */
	{ 129, 512, 0x2a4cbf73866c3a28, 0x00001027febfe4e5 }, /* 1.896 */
	{ 130, 512, 0x9cb128aacdcd3b2f, 0x0000106aa8ac569d }, /* 1.965 */
	{ 131, 512, 0x5511d41c55869124, 0x000010bbd755ddf1 }, /* 1.963 */
	{ 132, 512, 0x42f92461937f284a, 0x000010fb8bceb3b5 }, /* 1.925 */
	{ 133, 512, 0xe2d89a1cf6f1f287, 0x0000114cf5331e34 }, /* 1.862 */
	{ 134, 512, 0xdc631a038956200e, 0x0000116428d2adc5 }, /* 2.042 */
	{ 135, 512, 0xb2e5ac222cd236be, 0x000011ca88e4d4d2 }, /* 1.935 */
	{ 136, 512, 0xbc7d8236655d88e7, 0x000011e39cb94e66 }, /* 2.005 */
	{ 137, 512, 0x073e02d88d2d8e75, 0x0000123136c7933c }, /* 2.041 */
	{ 138, 512, 0x3ddb9c3873166be0, 0x00001280e4ec6d52 }, /* 1.997 */
	{ 139, 512, 0x7d3b1a845420e1b5, 0x000012c2e7cd6a44 }, /* 1.996 */
	{ 140, 512, 0x60102308aa7b2a6c, 0x000012fc490e6c7d }, /* 2.053 */
	{ 141, 512, 0xdb22bb2f9eb894aa, 0x00001343f5a85a1a }, /* 1.971 */
	{ 142, 512, 0xd853f879a13b1606, 0x000013bb7d5f9048 }, /* 2.018 */
	{ 143, 512, 0x001620a03f804b1d, 0x000013e74cc794fd }, /* 1.961 */
	{ 144, 512, 0xfdb52dda76fbf667, 0x00001442d2f22480 }, /* 2.046 */
	{ 145, 512, 0xa9160110f66e24ff, 0x0000144b899f9dbb }, /* 1.968 */
	{ 146, 512, 0x77306a30379ae03b, 0x000014cb98eb1f81 }, /* 2.143 */
	{ 147, 512, 0x14f5985d2752319d, 0x000014feab821fc9 }, /* 2.064 */
	{ 148, 512, 0xa4b8ff11de7863f8, 0x0000154a0e60b9c9 }, /* 2.023 */
	{ 149, 512, 0x44b345426455c1b3, 0x000015999c3c569c }, /* 2.136 */
	{ 150, 512, 0x272677826049b46c, 0x000015c9697f4b92 }, /* 2.063 */
	{ 151, 512, 0x2f9216e2cd74fe40, 0x0000162b1f7bbd39 }, /* 1.974 */
	{ 152, 512, 0x706ae3e763ad8771, 0x00001661371c55e1 }, /* 2.210 */
	{ 153, 512, 0xf7fd345307c2480e, 0x000016e251f28b6a }, /* 2.006 */
	{ 154, 512, 0x6e94e3d26b3139eb, 0x000016f2429bb8c6 }, /* 2.193 */
	{ 155, 512, 0x5458bbfbb781fcba, 0x0000173efdeca1b9 }, /* 2.163 */
	{ 156, 512, 0xa80e2afeccd93b33, 0x000017bfdcb78adc }, /* 2.046 */
	{ 157, 512, 0x1e4ccbb22796cf9d, 0x00001826fdcc39c9 }, /* 2.084 */
	{ 158, 512, 0x8fba4b676aaa3663, 0x00001841a1379480 }, /* 2.264 */
	{ 159, 512, 0xf82b843814b315fa, 0x000018886e19b8a3 }, /* 2.074 */
	{ 160, 512, 0x7f21e920ecf753a3, 0x0000191812ca0ea7 }, /* 2.282 */
	{ 161, 512, 0x48bb8ea2c4caa620, 0x0000192f310faccf }, /* 2.148 */
	{ 162, 512, 0x5cdb652b4952c91b, 0x0000199e1d7437c7 }, /* 2.355 */
	{ 163, 512, 0x6ac1ba6f78c06cd4, 0x000019cd11f82c70 }, /* 2.164 */
	{ 164, 512, 0x9faf5f9ca2669a56, 0x00001a18d5431f6a }, /* 2.393 */
	{ 165, 512, 0xaa57e9383eb01194, 0x00001a9e7d253d85 }, /* 2.178 */
	{ 166, 512, 0x896967bf495c34d2, 0x00001afb8319b9fc }, /* 2.334 */
	{ 167, 512, 0xdfad5f05de225f1b, 0x00001b3a59c3093b }, /* 2.266 */
	{ 168, 512, 0xfd299a99f9f2abdd, 0x00001bb6f1a10799 }, /* 2.304 */
	{ 169, 512, 0xdda239e798fe9fd4, 0x00001bfae0c9692d }, /* 2.218 */
	{ 170, 512, 0x5fca670414a32c3e, 0x00001c22129dbcff }, /* 2.377 */
	{ 171, 512, 0x1bb8934314b087de, 0x00001c955db36cd0 }, /* 2.155 */
	{ 172, 512, 0xd96394b4b082200d, 0x00001cfc8619b7e6 }, /* 2.404 */
	{ 173, 512, 0xb612a7735b1c8cbc, 0x00001d303acdd585 }, /* 2.205 */
	{ 174, 512, 0x28e7430fe5875fe1, 0x00001d7ed5b3697d }, /* 2.359 */
	{ 175, 512, 0x5038e89efdd981b9, 0x00001dc40ec35c59 }, /* 2.158 */
	{ 176, 512, 0x075fd78f1d14db7c, 0x00001e31c83b4a2b }, /* 2.614 */
	{ 177, 512, 0xc50fafdb5021be15, 0x00001e7cdac82fbc }, /* 2.239 */
	{ 178, 512, 0xe6dc7572ce7b91c7, 0x00001edd8bb454fc }, /* 2.493 */
	{ 179, 512, 0x21f7843e7beda537, 0x00001f3a8e019d6c }, /* 2.327 */
	{ 180, 512, 0xc83385e20b43ec82, 0x00001f70735ec137 }, /* 2.231 */
	{ 181, 512, 0xca818217dddb21fd, 0x0000201ca44c5a3c }, /* 2.237 */
	{ 182, 512, 0xe6035defea48f933, 0x00002038e3346658 }, /* 2.691 */
	{ 183, 512, 0x47262a4f953dac5a, 0x000020c2e554314e }, /* 2.170 */
	{ 184, 512, 0xe24c7246260873ea, 0x000021197e618d64 }, /* 2.600 */
	{ 185, 512, 0xeef6b57c9b58e9e1, 0x0000217ea48ecddc }, /* 2.391 */
	{ 186, 512, 0x2becd3346e386142, 0x000021c496d4a5f9 }, /* 2.677 */
	{ 187, 512, 0x63c6207bdf3b40a3, 0x0000220e0f2eec0c }, /* 2.410 */
	{ 188, 512, 0x3056ce8989767d4b, 0x0000228eb76cd137 }, /* 2.776 */
	{ 189, 512, 0x91af61c307cee780, 0x000022e17e2ea501 }, /* 2.266 */
	{ 190, 512, 0xda359da225f6d54f, 0x00002358a2debc19 }, /* 2.717 */
	{ 191, 512, 0x0a5f7a2a55607ba0, 0x0000238a79dac18c }, /* 2.474 */
	{ 192, 512, 0x27bb75bf5224638a, 0x00002403a58e2351 }, /* 2.673 */
	{ 193, 512, 0x1ebfdb94630f5d0f, 0x00002492a10cb339 }, /* 2.420 */
	{ 194, 512, 0x6eae5e51d9c5f6fb, 0x000024ce4bf98715 }, /* 2.898 */
	{ 195, 512, 0x08d903b4daedc2e0, 0x0000250d1e15886c }, /* 2.363 */
	{ 196, 512, 0xc722a2f7fa7cd686, 0x0000258a99ed0c9e }, /* 2.747 */
	{ 197, 512, 0x8f71faf0e54e361d, 0x000025dee11976f5 }, /* 2.531 */
	{ 198, 512, 0x87f64695c91a54e7, 0x0000264e00a43da0 }, /* 2.707 */
	{ 199, 512, 0xc719cbac2c336b92, 0x000026d327277ac1 }, /* 2.315 */
	{ 200, 512, 0xe7e647afaf771ade, 0x000027523a5c44bf }, /* 3.012 */
	{ 201, 512, 0x12d4b5c38ce8c946, 0x0000273898432545 }, /* 2.378 */
	{ 202, 512, 0xf2e0cd4067bdc94a, 0x000027e47bb2c935 }, /* 2.969 */
	{ 203, 512, 0x21b79f14d6d947d3, 0x0000281e64977f0d }, /* 2.594 */
	{ 204, 512, 0x515093f952f18cd6, 0x0000289691a473fd }, /* 2.763 */
	{ 205, 512, 0xd47b160a1b1022c8, 0x00002903e8b52411 }, /* 2.457 */
	{ 206, 512, 0xc02fc96684715a16, 0x0000297515608601 }, /* 3.057 */
	{ 207, 512, 0xef51e68efba72ed0, 0x000029ef73604804 }, /* 2.590 */
	{ 208, 512, 0x9e3be6e5448b4f33, 0x00002a2846ed074b }, /* 3.047 */
	{ 209, 512, 0x81d446c6d5fec063, 0x00002a92ca693455 }, /* 2.676 */
	{ 210, 512, 0xff215de8224e57d5, 0x00002b2271fe3729 }, /* 2.993 */
	{ 211, 512, 0xe2524d9ba8f69796, 0x00002b64b99c3ba2 }, /* 2.457 */
	{ 212, 512, 0xf6b28e26097b7e4b, 0x00002bd768b6e068 }, /* 3.182 */
	{ 213, 512, 0x893a487f30ce1644, 0x00002c67f722b4b2 }, /* 2.563 */
	{ 214, 512, 0x386566c3fc9871df, 0x00002cc1cf8b4037 }, /* 3.025 */
	{ 215, 512, 0x1e0ed78edf1f558a, 0x00002d3948d36c7f }, /* 2.730 */
	{ 216, 512, 0xe3bc20c31e61f113, 0x00002d6d6b12e025 }, /* 3.036 */
	{ 217, 512, 0xd6c3ad2e23021882, 0x00002deff7572241 }, /* 2.722 */
	{ 218, 512, 0xb4a9f95cf0f69c5a, 0x00002e67d537aa36 }, /* 3.356 */
	{ 219, 512, 0x6e98ed6f6c38e82f, 0x00002e9720626789 }, /* 2.697 */
	{ 220, 512, 0x2e01edba33fddac7, 0x00002f407c6b0198 }, /* 2.979 */
	{ 221, 512, 0x559d02e1f5f57ccc, 0x00002fb6a5ab4f24 }, /* 2.858 */
	{ 222, 512, 0xac18f5a916adcd8e, 0x0000304ae1c5c57e }, /* 3.258 */
	{ 223, 512, 0x15789fbaddb86f4b, 0x0000306f6e019c78 }, /* 2.693 */
	{ 224, 512, 0xf4a9c36d5bc4c408, 0x000030da40434213 }, /* 3.259 */
	{ 225, 512, 0xf640f90fd2727f44, 0x00003189ed37b90c }, /* 2.733 */
	{ 226, 512, 0xb5313d390d61884a, 0x000031e152616b37 }, /* 3.235 */
	{ 227, 512, 0x4bae6b3ce9160939, 0x0000321f40aeac42 }, /* 2.983 */
	{ 228, 512, 0x838c34480f1a66a1, 0x000032f389c0f78e }, /* 3.308 */
	{ 229, 512, 0xb1c4a52c8e3d6060, 0x0000330062a40284 }, /* 2.715 */
	{ 230, 512, 0xe0f1110c6d0ed822, 0x0000338be435644f }, /* 3.540 */
	{ 231, 512, 0x9f1a8ccdcea68d4b, 0x000034045a4e97e1 }, /* 2.779 */
	{ 232, 512, 0x3261ed62223f3099, 0x000034702cfc401c }, /* 3.084 */
	{ 233, 512, 0xf2191e2311022d65, 0x00003509dd19c9fc }, /* 2.987 */
	{ 234, 512, 0xf102a395c2033abc, 0x000035654dc96fae }, /* 3.341 */
	{ 235, 512, 0x11fe378f027906b6, 0x000035b5193b0264 }, /* 2.793 */
	{ 236, 512, 0xf777f2c026b337aa, 0x000036704f5d9297 }, /* 3.518 */
	{ 237, 512, 0x1b04e9c2ee143f32, 0x000036dfbb7af218 }, /* 2.962 */
	{ 238, 512, 0x2fcec95266f9352c, 0x00003785c8df24a9 }, /* 3.196 */
	{ 239, 512, 0xfe2b0e47e427dd85, 0x000037cbdf5da729 }, /* 2.914 */
	{ 240, 512, 0x72b49bf2225f6c6d, 0x0000382227c15855 }, /* 3.408 */
	{ 241, 512, 0x50486b43df7df9c7, 0x0000389b88be6453 }, /* 2.903 */
	{ 242, 512, 0x5192a3e53181c8ab, 0x000038ddf3d67263 }, /* 3.778 */
	{ 243, 512, 0xe9f5d8365296fd5e, 0x0000399f1c6c9e9c }, /* 3.026 */
	{ 244, 512, 0xc740263f0301efa8, 0x00003a147146512d }, /* 3.347 */
	{ 245, 512, 0x23cd0f2b5671e67d, 0x00003ab10bcc0d9d }, /* 3.212 */
	{ 246, 512, 0x002ccc7e5cd41390, 0x00003ad6cd14a6c0 }, /* 3.482 */
	{ 247, 512, 0x9aafb3c02544b31b, 0x00003b8cb8779fb0 }, /* 3.146 */
	{ 248, 512, 0x72ba07a78b121999, 0x00003c24142a5a3f }, /* 3.626 */
	{ 249, 512, 0x3d784aa58edfc7b4, 0x00003cd084817d99 }, /* 2.952 */
	{ 250, 512, 0xaab750424d8004af, 0x00003d506a8e098e }, /* 3.463 */
	{ 251, 512, 0x84403fcf8e6b5ca2, 0x00003d4c54c2aec4 }, /* 3.131 */
	{ 252, 512, 0x71eb7455ec98e207, 0x00003e655715cf2c }, /* 3.538 */
	{ 253, 512, 0xd752b4f19301595b, 0x00003ecd7b2ca5ac }, /* 2.974 */
	{ 254, 512, 0xc4674129750499de, 0x00003e99e86d3e95 }, /* 3.843 */
	{ 255, 512, 0x9772baff5cd12ef5, 0x00003f895c019841 }, /* 3.088 */
	};

	/*
	* Verify the map is valid. Each device index must appear exactly
	* once in every row, and the permutation array checksum must match.
	*/
	static int
	verify_perms(uint8_t *perms, uint64_t children, uint64_t nperms,
	uint64_t checksum)
	{
	int countssz = sizeof (uint16_t) * children;
	uint16_t *counts = kmem_zalloc(countssz, KM_SLEEP);

	for (int i = 0; i < nperms; i++) {
	for (int j = 0; j < children; j++) {
	uint8_t val = perms[(i * children) + j];

	if (val >= children \|\| counts[val] != i) {
	kmem_free(counts, countssz);
	return (EINVAL);
	}

	counts[val]++;
	}
	}

	if (checksum != 0) {
	int permssz = sizeof (uint8_t) * children * nperms;
	zio_cksum_t cksum;

	fletcher_4_native_varsize(perms, permssz, &cksum);

	if (checksum != cksum.zc_word[0]) {
	kmem_free(counts, countssz);
	return (ECKSUM);
	}
	}

	kmem_free(counts, countssz);

	return (0);
	}

	/*
	* Generate the permutation array for the draid_map_t. These maps control
	* the placement of all data in a dRAID. Therefore it's critical that the
	* seed always generates the same mapping. We provide our own pseudo-random
	* number generator for this purpose.
	*/
	int
	vdev_draid_generate_perms(const draid_map_t map, uint8_t *permsp)
	{
	VERIFY3U(map->dm_children, >=, VDEV_DRAID_MIN_CHILDREN);
	VERIFY3U(map->dm_children, <=, VDEV_DRAID_MAX_CHILDREN);
	VERIFY3U(map->dm_seed, !=, 0);
	VERIFY3U(map->dm_nperms, !=, 0);
	VERIFY3P(map->dm_perms, ==, NULL);

	#ifdef _KERNEL
	/*
	* The kernel code always provides both a map_seed and checksum.
	* Only the tests/zfs-tests/cmd/draid/draid.c utility will provide
	* a zero checksum when generating new candidate maps.
	*/
	VERIFY3U(map->dm_checksum, !=, 0);
	#endif
	uint64_t children = map->dm_children;
	uint64_t nperms = map->dm_nperms;
	int rowsz = sizeof (uint8_t) * children;
	int permssz = rowsz * nperms;
	uint8_t *perms;

	/* Allocate the permutation array */
	perms = vmem_alloc(permssz, KM_SLEEP);

	/* Setup an initial row with a known pattern */
	uint8_t *initial_row = kmem_alloc(rowsz, KM_SLEEP);
	for (int i = 0; i < children; i++)
	initial_row[i] = i;

	uint64_t draid_seed[2] = { VDEV_DRAID_SEED, map->dm_seed };
	uint8_t current_row, previous_row = initial_row;

	/*
	* Perform a Fisher-Yates shuffle of each row using the previous
	* row as the starting point. An initial_row with known pattern
	* is used as the input for the first row.
	*/
	for (int i = 0; i < nperms; i++) {
	current_row = &perms[i * children];
	memcpy(current_row, previous_row, rowsz);

	for (int j = children - 1; j > 0; j--) {
	uint64_t k = vdev_draid_rand(draid_seed) % (j + 1);
	uint8_t val = current_row[j];
	current_row[j] = current_row[k];
	current_row[k] = val;
	}

	previous_row = current_row;
	}

	kmem_free(initial_row, rowsz);

	int error = verify_perms(perms, children, nperms, map->dm_checksum);
	if (error) {
	vmem_free(perms, permssz);
	return (error);
	}

	*permsp = perms;

	return (0);
	}

	/*
	* Lookup the fixed draid_map_t for the requested number of children.
	*/
	int
	vdev_draid_lookup_map(uint64_t children, const draid_map_t **mapp)
	{
	for (int i = 0; i <= VDEV_DRAID_MAX_MAPS; i++) {
	if (draid_maps[i].dm_children == children) {
	*mapp = &draid_maps[i];
	return (0);
	}
	}

	return (ENOENT);
	}

	/*
	* Lookup the permutation array and iteration id for the provided offset.
	*/
	static void
	vdev_draid_get_perm(vdev_draid_config_t *vdc, uint64_t pindex,
	uint8_t *base, uint64_t iter)
	{
	uint64_t ncols = vdc->vdc_children;
	uint64_t poff = pindex % (vdc->vdc_nperms * ncols);

	base = vdc->vdc_perms + (poff / ncols) ncols;
	*iter = poff % ncols;
	}

	static inline uint64_t
	vdev_draid_permute_id(vdev_draid_config_t *vdc,
	uint8_t *base, uint64_t iter, uint64_t index)
	{
	return ((base[index] + iter) % vdc->vdc_children);
	}

	/*
	* Return the asize which is the psize rounded up to a full group width.
	* i.e. vdev_draid_psize_to_asize().
	*/
	static uint64_t
	vdev_draid_asize(vdev_t *vd, uint64_t psize)
	{
	vdev_draid_config_t *vdc = vd->vdev_tsd;
	uint64_t ashift = vd->vdev_ashift;

	ASSERT3P(vd->vdev_ops, ==, &vdev_draid_ops);

	uint64_t rows = ((psize - 1) / (vdc->vdc_ndata << ashift)) + 1;
	uint64_t asize = (rows * vdc->vdc_groupwidth) << ashift;

	ASSERT3U(asize, !=, 0);
	ASSERT3U(asize % (vdc->vdc_groupwidth), ==, 0);

	return (asize);
	}

	/*
	* Deflate the asize to the psize, this includes stripping parity.
	*/
	uint64_t
	vdev_draid_asize_to_psize(vdev_t *vd, uint64_t asize)
	{
	vdev_draid_config_t *vdc = vd->vdev_tsd;

	ASSERT0(asize % vdc->vdc_groupwidth);

	return ((asize / vdc->vdc_groupwidth) * vdc->vdc_ndata);
	}

	/*
	* Convert a logical offset to the corresponding group number.
	*/
	static uint64_t
	vdev_draid_offset_to_group(vdev_t *vd, uint64_t offset)
	{
	vdev_draid_config_t *vdc = vd->vdev_tsd;

	ASSERT3P(vd->vdev_ops, ==, &vdev_draid_ops);

	return (offset / vdc->vdc_groupsz);
	}

	/*
	* Convert a group number to the logical starting offset for that group.
	*/
	static uint64_t
	vdev_draid_group_to_offset(vdev_t *vd, uint64_t group)
	{
	vdev_draid_config_t *vdc = vd->vdev_tsd;

	ASSERT3P(vd->vdev_ops, ==, &vdev_draid_ops);

	return (group * vdc->vdc_groupsz);
	}

	/*
	* Full stripe writes. When writing, all columns (D+P) are required. Parity
	* is calculated over all the columns, including empty zero filled sectors,
	* and each is written to disk. While only the data columns are needed for
	* a normal read, all of the columns are required for reconstruction when
	* performing a sequential resilver.
	*
	* For "big columns" it's sufficient to map the correct range of the zio ABD.
	* Partial columns require allocating a gang ABD in order to zero fill the
	* empty sectors. When the column is empty a zero filled sector must be
	* mapped. In all cases the data ABDs must be the same size as the parity
	* ABDs (e.g. rc->rc_size == parity_size).
	*/
	static void
	vdev_draid_map_alloc_write(zio_t zio, uint64_t abd_offset, raidz_row_t rr)
	{
	uint64_t skip_size = 1ULL << zio->io_vd->vdev_top->vdev_ashift;
	uint64_t parity_size = rr->rr_col[0].rc_size;
	uint64_t abd_off = abd_offset;

	ASSERT3U(zio->io_type, ==, ZIO_TYPE_WRITE);
	ASSERT3U(parity_size, ==, abd_get_size(rr->rr_col[0].rc_abd));

	for (uint64_t c = rr->rr_firstdatacol; c < rr->rr_cols; c++) {
	raidz_col_t *rc = &rr->rr_col[c];

	if (rc->rc_size == 0) {
	/* empty data column (small write), add a skip sector */
	ASSERT3U(skip_size, ==, parity_size);
	rc->rc_abd = abd_get_zeros(skip_size);
	} else if (rc->rc_size == parity_size) {
	/* this is a "big column" */
	rc->rc_abd = abd_get_offset_struct(&rc->rc_abdstruct,
	zio->io_abd, abd_off, rc->rc_size);
	} else {
	/* short data column, add a skip sector */
	ASSERT3U(rc->rc_size + skip_size, ==, parity_size);
	rc->rc_abd = abd_alloc_gang();
	abd_gang_add(rc->rc_abd, abd_get_offset_size(
	zio->io_abd, abd_off, rc->rc_size), B_TRUE);
	abd_gang_add(rc->rc_abd, abd_get_zeros(skip_size),
	B_TRUE);
	}

	ASSERT3U(abd_get_size(rc->rc_abd), ==, parity_size);

	abd_off += rc->rc_size;
	rc->rc_size = parity_size;
	}

	IMPLY(abd_offset != 0, abd_off == zio->io_size);
	}

	/*
	* Scrub/resilver reads. In order to store the contents of the skip sectors
	* an additional ABD is allocated. The columns are handled in the same way
	* as a full stripe write except instead of using the zero ABD the newly
	* allocated skip ABD is used to back the skip sectors. In all cases the
	* data ABD must be the same size as the parity ABDs.
	*/
	static void
	vdev_draid_map_alloc_scrub(zio_t zio, uint64_t abd_offset, raidz_row_t rr)
	{
	uint64_t skip_size = 1ULL << zio->io_vd->vdev_top->vdev_ashift;
	uint64_t parity_size = rr->rr_col[0].rc_size;
	uint64_t abd_off = abd_offset;
	uint64_t skip_off = 0;

	ASSERT3U(zio->io_type, ==, ZIO_TYPE_READ);
	ASSERT3P(rr->rr_abd_empty, ==, NULL);

	if (rr->rr_nempty > 0) {
	rr->rr_abd_empty = abd_alloc_linear(rr->rr_nempty * skip_size,
	B_FALSE);
	}

	for (uint64_t c = rr->rr_firstdatacol; c < rr->rr_cols; c++) {
	raidz_col_t *rc = &rr->rr_col[c];

	if (rc->rc_size == 0) {
	/* empty data column (small read), add a skip sector */
	ASSERT3U(skip_size, ==, parity_size);
	ASSERT3U(rr->rr_nempty, !=, 0);
	rc->rc_abd = abd_get_offset_size(rr->rr_abd_empty,
	skip_off, skip_size);
	skip_off += skip_size;
	} else if (rc->rc_size == parity_size) {
	/* this is a "big column" */
	rc->rc_abd = abd_get_offset_struct(&rc->rc_abdstruct,
	zio->io_abd, abd_off, rc->rc_size);
	} else {
	/* short data column, add a skip sector */
	ASSERT3U(rc->rc_size + skip_size, ==, parity_size);
	ASSERT3U(rr->rr_nempty, !=, 0);
	rc->rc_abd = abd_alloc_gang();
	abd_gang_add(rc->rc_abd, abd_get_offset_size(
	zio->io_abd, abd_off, rc->rc_size), B_TRUE);
	abd_gang_add(rc->rc_abd, abd_get_offset_size(
	rr->rr_abd_empty, skip_off, skip_size), B_TRUE);
	skip_off += skip_size;
	}

	uint64_t abd_size = abd_get_size(rc->rc_abd);
	ASSERT3U(abd_size, ==, abd_get_size(rr->rr_col[0].rc_abd));

	/*
	* Increase rc_size so the skip ABD is included in subsequent
	* parity calculations.
	*/
	abd_off += rc->rc_size;
	rc->rc_size = abd_size;
	}

	IMPLY(abd_offset != 0, abd_off == zio->io_size);
	ASSERT3U(skip_off, ==, rr->rr_nempty * skip_size);
	}

	/*
	* Normal reads. In this common case only the columns containing data
	* are read in to the zio ABDs. Neither the parity columns or empty skip
	* sectors are read unless the checksum fails verification. In which case
	* vdev_raidz_read_all() will call vdev_draid_map_alloc_empty() to expand
	* the raid map in order to allow reconstruction using the parity data and
	* skip sectors.
	*/
	static void
	vdev_draid_map_alloc_read(zio_t zio, uint64_t abd_offset, raidz_row_t rr)
	{
	uint64_t abd_off = abd_offset;

	ASSERT3U(zio->io_type, ==, ZIO_TYPE_READ);

	for (uint64_t c = rr->rr_firstdatacol; c < rr->rr_cols; c++) {
	raidz_col_t *rc = &rr->rr_col[c];

	if (rc->rc_size > 0) {
	rc->rc_abd = abd_get_offset_struct(&rc->rc_abdstruct,
	zio->io_abd, abd_off, rc->rc_size);
	abd_off += rc->rc_size;
	}
	}

	IMPLY(abd_offset != 0, abd_off == zio->io_size);
	}

	/*
	* Converts a normal "read" raidz_row_t to a "scrub" raidz_row_t. The key
	* difference is that an ABD is allocated to back skip sectors so they may
	* be read in to memory, verified, and repaired if needed.
	*/
	void
	vdev_draid_map_alloc_empty(zio_t zio, raidz_row_t rr)
	{
	uint64_t skip_size = 1ULL << zio->io_vd->vdev_top->vdev_ashift;
	uint64_t parity_size = rr->rr_col[0].rc_size;
	uint64_t skip_off = 0;

	ASSERT3U(zio->io_type, ==, ZIO_TYPE_READ);
	ASSERT3P(rr->rr_abd_empty, ==, NULL);

	if (rr->rr_nempty > 0) {
	rr->rr_abd_empty = abd_alloc_linear(rr->rr_nempty * skip_size,
	B_FALSE);
	}

	for (uint64_t c = rr->rr_firstdatacol; c < rr->rr_cols; c++) {
	raidz_col_t *rc = &rr->rr_col[c];

	if (rc->rc_size == 0) {
	/* empty data column (small read), add a skip sector */
	ASSERT3U(skip_size, ==, parity_size);
	ASSERT3U(rr->rr_nempty, !=, 0);
	ASSERT3P(rc->rc_abd, ==, NULL);
	rc->rc_abd = abd_get_offset_size(rr->rr_abd_empty,
	skip_off, skip_size);
	skip_off += skip_size;
	} else if (rc->rc_size == parity_size) {
	/* this is a "big column", nothing to add */
	ASSERT3P(rc->rc_abd, !=, NULL);
	} else {
	- /* short data column, add a skip sector */
	+ /*
	+ * short data column, add a skip sector and clear
	+ * rc_tried to force the entire column to be re-read
	+ * thereby including the missing skip sector data
	+ * which is needed for reconstruction.
	+ */
	ASSERT3U(rc->rc_size + skip_size, ==, parity_size);
	ASSERT3U(rr->rr_nempty, !=, 0);
	ASSERT3P(rc->rc_abd, !=, NULL);
	ASSERT(!abd_is_gang(rc->rc_abd));
	abd_t *read_abd = rc->rc_abd;
	rc->rc_abd = abd_alloc_gang();
	abd_gang_add(rc->rc_abd, read_abd, B_TRUE);
	abd_gang_add(rc->rc_abd, abd_get_offset_size(
	rr->rr_abd_empty, skip_off, skip_size), B_TRUE);
	skip_off += skip_size;
	+ rc->rc_tried = 0;
	}

	/*
	* Increase rc_size so the empty ABD is included in subsequent
	* parity calculations.
	*/
	rc->rc_size = parity_size;
	}

	ASSERT3U(skip_off, ==, rr->rr_nempty * skip_size);
	}

	/*
	* Given a logical address within a dRAID configuration, return the physical
	* address on the first drive in the group that this address maps to
	* (at position 'start' in permutation number 'perm').
	*/
	static uint64_t
	vdev_draid_logical_to_physical(vdev_t *vd, uint64_t logical_offset,
	uint64_t perm, uint64_t start)
	{
	vdev_draid_config_t *vdc = vd->vdev_tsd;

	/* b is the dRAID (parent) sector offset. */
	uint64_t ashift = vd->vdev_top->vdev_ashift;
	uint64_t b_offset = logical_offset >> ashift;

	/*
	* The height of a row in units of the vdev's minimum sector size.
	* This is the amount of data written to each disk of each group
	* in a given permutation.
	*/
	uint64_t rowheight_sectors = VDEV_DRAID_ROWHEIGHT >> ashift;

	/*
	* We cycle through a disk permutation every groupsz * ngroups chunk
	* of address space. Note that ngroups * groupsz must be a multiple
	* of the number of data drives (ndisks) in order to guarantee
	* alignment. So, for example, if our row height is 16MB, our group
	* size is 10, and there are 13 data drives in the draid, then ngroups
	* will be 13, we will change permutation every 2.08GB and each
	* disk will have 160MB of data per chunk.
	*/
	uint64_t groupwidth = vdc->vdc_groupwidth;
	uint64_t ngroups = vdc->vdc_ngroups;
	uint64_t ndisks = vdc->vdc_ndisks;

	/*
	* groupstart is where the group this IO will land in "starts" in
	* the permutation array.
	*/
	uint64_t group = logical_offset / vdc->vdc_groupsz;
	uint64_t groupstart = (group * groupwidth) % ndisks;
	ASSERT3U(groupstart + groupwidth, <=, ndisks + groupstart);
	*start = groupstart;

	/* b_offset is the sector offset within a group chunk */
	b_offset = b_offset % (rowheight_sectors * groupwidth);
	ASSERT0(b_offset % groupwidth);

	/*
	* Find the starting byte offset on each child vdev:
	* - within a permutation there are ngroups groups spread over the
	* rows, where each row covers a slice portion of the disk
	* - each permutation has (groupwidth * ngroups) / ndisks rows
	* - so each permutation covers rows * slice portion of the disk
	* - so we need to find the row where this IO group target begins
	*/
	*perm = group / ngroups;
	uint64_t row = (perm ((groupwidth * ngroups) / ndisks)) +
	(((group % ngroups) * groupwidth) / ndisks);

	return (((rowheight_sectors * row) +
	(b_offset / groupwidth)) << ashift);
	}

	static uint64_t
	vdev_draid_map_alloc_row(zio_t zio, raidz_row_t *rrp, uint64_t io_offset,
	uint64_t abd_offset, uint64_t abd_size)
	{
	vdev_t *vd = zio->io_vd;
	vdev_draid_config_t *vdc = vd->vdev_tsd;
	uint64_t ashift = vd->vdev_top->vdev_ashift;
	uint64_t io_size = abd_size;
	uint64_t io_asize = vdev_draid_asize(vd, io_size);
	uint64_t group = vdev_draid_offset_to_group(vd, io_offset);
	uint64_t start_offset = vdev_draid_group_to_offset(vd, group + 1);

	/*
	* Limit the io_size to the space remaining in the group. A second
	* row in the raidz_map_t is created for the remainder.
	*/
	if (io_offset + io_asize > start_offset) {
	io_size = vdev_draid_asize_to_psize(vd,
	start_offset - io_offset);
	}

	/*
	* At most a block may span the logical end of one group and the start
	* of the next group. Therefore, at the end of a group the io_size must
	* span the group width evenly and the remainder must be aligned to the
	* start of the next group.
	*/
	IMPLY(abd_offset == 0 && io_size < zio->io_size,
	(io_asize >> ashift) % vdc->vdc_groupwidth == 0);
	IMPLY(abd_offset != 0,
	vdev_draid_group_to_offset(vd, group) == io_offset);

	/* Lookup starting byte offset on each child vdev */
	uint64_t groupstart, perm;
	uint64_t physical_offset = vdev_draid_logical_to_physical(vd,
	io_offset, &perm, &groupstart);

	/*
	* If there is less than groupwidth drives available after the group
	* start, the group is going to wrap onto the next row. 'wrap' is the
	* group disk number that starts on the next row.
	*/
	uint64_t ndisks = vdc->vdc_ndisks;
	uint64_t groupwidth = vdc->vdc_groupwidth;
	uint64_t wrap = groupwidth;

	if (groupstart + groupwidth > ndisks)
	wrap = ndisks - groupstart;

	/* The io size in units of the vdev's minimum sector size. */
	const uint64_t psize = io_size >> ashift;

	/*
	* "Quotient": The number of data sectors for this stripe on all but
	* the "big column" child vdevs that also contain "remainder" data.
	*/
	uint64_t q = psize / vdc->vdc_ndata;

	/*
	* "Remainder": The number of partial stripe data sectors in this I/O.
	* This will add a sector to some, but not all, child vdevs.
	*/
	uint64_t r = psize - q * vdc->vdc_ndata;

	/* The number of "big columns" - those which contain remainder data. */
	uint64_t bc = (r == 0 ? 0 : r + vdc->vdc_nparity);
	ASSERT3U(bc, <, groupwidth);

	/* The total number of data and parity sectors for this I/O. */
	uint64_t tot = psize + (vdc->vdc_nparity * (q + (r == 0 ? 0 : 1)));

	raidz_row_t *rr;
	rr = kmem_alloc(offsetof(raidz_row_t, rr_col[groupwidth]), KM_SLEEP);
	rr->rr_cols = groupwidth;
	rr->rr_scols = groupwidth;
	rr->rr_bigcols = bc;
	rr->rr_missingdata = 0;
	rr->rr_missingparity = 0;
	rr->rr_firstdatacol = vdc->vdc_nparity;
	rr->rr_abd_empty = NULL;
	#ifdef ZFS_DEBUG
	rr->rr_offset = io_offset;
	rr->rr_size = io_size;
	#endif
	*rrp = rr;

	uint8_t *base;
	uint64_t iter, asize = 0;
	vdev_draid_get_perm(vdc, perm, &base, &iter);
	for (uint64_t i = 0; i < groupwidth; i++) {
	raidz_col_t *rc = &rr->rr_col[i];
	uint64_t c = (groupstart + i) % ndisks;

	/* increment the offset if we wrap to the next row */
	if (i == wrap)
	physical_offset += VDEV_DRAID_ROWHEIGHT;

	rc->rc_devidx = vdev_draid_permute_id(vdc, base, iter, c);
	rc->rc_offset = physical_offset;
	rc->rc_abd = NULL;
	rc->rc_orig_data = NULL;
	rc->rc_error = 0;
	rc->rc_tried = 0;
	rc->rc_skipped = 0;
	- rc->rc_repair = 0;
	+ rc->rc_force_repair = 0;
	+ rc->rc_allow_repair = 1;
	rc->rc_need_orig_restore = B_FALSE;

	if (q == 0 && i >= bc)
	rc->rc_size = 0;
	else if (i < bc)
	rc->rc_size = (q + 1) << ashift;
	else
	rc->rc_size = q << ashift;

	asize += rc->rc_size;
	}

	ASSERT3U(asize, ==, tot << ashift);
	rr->rr_nempty = roundup(tot, groupwidth) - tot;
	IMPLY(bc > 0, rr->rr_nempty == groupwidth - bc);

	/* Allocate buffers for the parity columns */
	for (uint64_t c = 0; c < rr->rr_firstdatacol; c++) {
	raidz_col_t *rc = &rr->rr_col[c];
	rc->rc_abd = abd_alloc_linear(rc->rc_size, B_FALSE);
	}

	/*
	* Map buffers for data columns and allocate/map buffers for skip
	* sectors. There are three distinct cases for dRAID which are
	* required to support sequential rebuild.
	*/
	if (zio->io_type == ZIO_TYPE_WRITE) {
	vdev_draid_map_alloc_write(zio, abd_offset, rr);
	} else if ((rr->rr_nempty > 0) &&
	(zio->io_flags & (ZIO_FLAG_SCRUB \| ZIO_FLAG_RESILVER))) {
	vdev_draid_map_alloc_scrub(zio, abd_offset, rr);
	} else {
	ASSERT3U(zio->io_type, ==, ZIO_TYPE_READ);
	vdev_draid_map_alloc_read(zio, abd_offset, rr);
	}

	return (io_size);
	}

	/*
	* Allocate the raidz mapping to be applied to the dRAID I/O. The parity
	* calculations for dRAID are identical to raidz however there are a few
	* differences in the layout.
	*
	* - dRAID always allocates a full stripe width. Any extra sectors due
	* this padding are zero filled and written to disk. They will be read
	* back during a scrub or repair operation since they are included in
	* the parity calculation. This property enables sequential resilvering.
	*
	* - When the block at the logical offset spans redundancy groups then two
	* rows are allocated in the raidz_map_t. One row resides at the end of
	* the first group and the other at the start of the following group.
	*/
	static raidz_map_t *
	vdev_draid_map_alloc(zio_t *zio)
	{
	raidz_row_t *rr[2];
	uint64_t abd_offset = 0;
	uint64_t abd_size = zio->io_size;
	uint64_t io_offset = zio->io_offset;
	uint64_t size;
	int nrows = 1;

	size = vdev_draid_map_alloc_row(zio, &rr[0], io_offset,
	abd_offset, abd_size);
	if (size < abd_size) {
	vdev_t *vd = zio->io_vd;

	io_offset += vdev_draid_asize(vd, size);
	abd_offset += size;
	abd_size -= size;
	nrows++;

	ASSERT3U(io_offset, ==, vdev_draid_group_to_offset(
	vd, vdev_draid_offset_to_group(vd, io_offset)));
	ASSERT3U(abd_offset, <, zio->io_size);
	ASSERT3U(abd_size, !=, 0);

	size = vdev_draid_map_alloc_row(zio, &rr[1],
	io_offset, abd_offset, abd_size);
	VERIFY3U(size, ==, abd_size);
	}

	raidz_map_t *rm;
	rm = kmem_zalloc(offsetof(raidz_map_t, rm_row[nrows]), KM_SLEEP);
	rm->rm_ops = vdev_raidz_math_get_ops();
	rm->rm_nrows = nrows;
	rm->rm_row[0] = rr[0];
	if (nrows == 2)
	rm->rm_row[1] = rr[1];

	return (rm);
	}

	/*
	* Given an offset into a dRAID return the next group width aligned offset
	* which can be used to start an allocation.
	*/
	static uint64_t
	vdev_draid_get_astart(vdev_t *vd, const uint64_t start)
	{
	vdev_draid_config_t *vdc = vd->vdev_tsd;

	ASSERT3P(vd->vdev_ops, ==, &vdev_draid_ops);

	return (roundup(start, vdc->vdc_groupwidth << vd->vdev_ashift));
	}

	/*
	* Allocatable space for dRAID is (children - nspares) * sizeof(smallest child)
	* rounded down to the last full slice. So each child must provide at least
	* 1 / (children - nspares) of its asize.
	*/
	static uint64_t
	vdev_draid_min_asize(vdev_t *vd)
	{
	vdev_draid_config_t *vdc = vd->vdev_tsd;

	ASSERT3P(vd->vdev_ops, ==, &vdev_draid_ops);

	return ((vd->vdev_min_asize + vdc->vdc_ndisks - 1) / (vdc->vdc_ndisks));
	}

	/*
	* When using dRAID the minimum allocation size is determined by the number
	* of data disks in the redundancy group. Full stripes are always used.
	*/
	static uint64_t
	vdev_draid_min_alloc(vdev_t *vd)
	{
	vdev_draid_config_t *vdc = vd->vdev_tsd;

	ASSERT3P(vd->vdev_ops, ==, &vdev_draid_ops);

	return (vdc->vdc_ndata << vd->vdev_ashift);
	}

	/*
	* Returns true if the txg range does not exist on any leaf vdev.
	*
	* A dRAID spare does not fit into the DTL model. While it has child vdevs
	* there is no redundancy among them, and the effective child vdev is
	* determined by offset. Essentially we do a vdev_dtl_reassess() on the
	* fly by replacing a dRAID spare with the child vdev under the offset.
	* Note that it is a recursive process because the child vdev can be
	* another dRAID spare and so on.
	*/
	boolean_t
	vdev_draid_missing(vdev_t *vd, uint64_t physical_offset, uint64_t txg,
	uint64_t size)
	{
	if (vd->vdev_ops == &vdev_spare_ops \|\|
	vd->vdev_ops == &vdev_replacing_ops) {
	/*
	* Check all of the readable children, if any child
	* contains the txg range the data it is not missing.
	*/
	for (int c = 0; c < vd->vdev_children; c++) {
	vdev_t *cvd = vd->vdev_child[c];

	if (!vdev_readable(cvd))
	continue;

	if (!vdev_draid_missing(cvd, physical_offset,
	txg, size))
	return (B_FALSE);
	}

	return (B_TRUE);
	}

	if (vd->vdev_ops == &vdev_draid_spare_ops) {
	/*
	* When sequentially resilvering we don't have a proper
	* txg range so instead we must presume all txgs are
	* missing on this vdev until the resilver completes.
	*/
	if (vd->vdev_rebuild_txg != 0)
	return (B_TRUE);

	/*
	* DTL_MISSING is set for all prior txgs when a resilver
	* is started in spa_vdev_attach().
	*/
	if (vdev_dtl_contains(vd, DTL_MISSING, txg, size))
	return (B_TRUE);

	/*
	* Consult the DTL on the relevant vdev. Either a vdev
	* leaf or spare/replace mirror child may be returned so
	* we must recursively call vdev_draid_missing_impl().
	*/
	vd = vdev_draid_spare_get_child(vd, physical_offset);
	if (vd == NULL)
	return (B_TRUE);

	return (vdev_draid_missing(vd, physical_offset,
	txg, size));
	}

	return (vdev_dtl_contains(vd, DTL_MISSING, txg, size));
	}

	/*
	* Returns true if the txg is only partially replicated on the leaf vdevs.
	*/
	static boolean_t
	vdev_draid_partial(vdev_t *vd, uint64_t physical_offset, uint64_t txg,
	uint64_t size)
	{
	if (vd->vdev_ops == &vdev_spare_ops \|\|
	vd->vdev_ops == &vdev_replacing_ops) {
	/*
	* Check all of the readable children, if any child is
	* missing the txg range then it is partially replicated.
	*/
	for (int c = 0; c < vd->vdev_children; c++) {
	vdev_t *cvd = vd->vdev_child[c];

	if (!vdev_readable(cvd))
	continue;

	if (vdev_draid_partial(cvd, physical_offset, txg, size))
	return (B_TRUE);
	}

	return (B_FALSE);
	}

	if (vd->vdev_ops == &vdev_draid_spare_ops) {
	/*
	* When sequentially resilvering we don't have a proper
	* txg range so instead we must presume all txgs are
	* missing on this vdev until the resilver completes.
	*/
	if (vd->vdev_rebuild_txg != 0)
	return (B_TRUE);

	/*
	* DTL_MISSING is set for all prior txgs when a resilver
	* is started in spa_vdev_attach().
	*/
	if (vdev_dtl_contains(vd, DTL_MISSING, txg, size))
	return (B_TRUE);

	/*
	* Consult the DTL on the relevant vdev. Either a vdev
	* leaf or spare/replace mirror child may be returned so
	* we must recursively call vdev_draid_missing_impl().
	*/
	vd = vdev_draid_spare_get_child(vd, physical_offset);
	if (vd == NULL)
	return (B_TRUE);

	return (vdev_draid_partial(vd, physical_offset, txg, size));
	}

	return (vdev_dtl_contains(vd, DTL_MISSING, txg, size));
	}

	/*
	* Determine if the vdev is readable at the given offset.
	*/
	boolean_t
	vdev_draid_readable(vdev_t *vd, uint64_t physical_offset)
	{
	if (vd->vdev_ops == &vdev_draid_spare_ops) {
	vd = vdev_draid_spare_get_child(vd, physical_offset);
	if (vd == NULL)
	return (B_FALSE);
	}

	if (vd->vdev_ops == &vdev_spare_ops \|\|
	vd->vdev_ops == &vdev_replacing_ops) {

	for (int c = 0; c < vd->vdev_children; c++) {
	vdev_t *cvd = vd->vdev_child[c];

	if (!vdev_readable(cvd))
	continue;

	if (vdev_draid_readable(cvd, physical_offset))
	return (B_TRUE);
	}

	return (B_FALSE);
	}

	return (vdev_readable(vd));
	}

	/*
	* Returns the first distributed spare found under the provided vdev tree.
	*/
	static vdev_t *
	vdev_draid_find_spare(vdev_t *vd)
	{
	if (vd->vdev_ops == &vdev_draid_spare_ops)
	return (vd);

	for (int c = 0; c < vd->vdev_children; c++) {
	vdev_t *svd = vdev_draid_find_spare(vd->vdev_child[c]);
	if (svd != NULL)
	return (svd);
	}

	return (NULL);
	}

	/*
	* Returns B_TRUE if the passed in vdev is currently "faulted".
	* Faulted, in this context, means that the vdev represents a
	* replacing or sparing vdev tree.
	*/
	static boolean_t
	vdev_draid_faulted(vdev_t *vd, uint64_t physical_offset)
	{
	if (vd->vdev_ops == &vdev_draid_spare_ops) {
	vd = vdev_draid_spare_get_child(vd, physical_offset);
	if (vd == NULL)
	return (B_FALSE);

	/*
	* After resolving the distributed spare to a leaf vdev
	* check the parent to determine if it's "faulted".
	*/
	vd = vd->vdev_parent;
	}

	return (vd->vdev_ops == &vdev_replacing_ops \|\|
	vd->vdev_ops == &vdev_spare_ops);
	}

	/*
	* Determine if the dRAID block at the logical offset is degraded.
	* Used by sequential resilver.
	*/
	static boolean_t
	vdev_draid_group_degraded(vdev_t *vd, uint64_t offset)
	{
	vdev_draid_config_t *vdc = vd->vdev_tsd;

	ASSERT3P(vd->vdev_ops, ==, &vdev_draid_ops);
	ASSERT3U(vdev_draid_get_astart(vd, offset), ==, offset);

	uint64_t groupstart, perm;
	uint64_t physical_offset = vdev_draid_logical_to_physical(vd,
	offset, &perm, &groupstart);

	uint8_t *base;
	uint64_t iter;
	vdev_draid_get_perm(vdc, perm, &base, &iter);

	for (uint64_t i = 0; i < vdc->vdc_groupwidth; i++) {
	uint64_t c = (groupstart + i) % vdc->vdc_ndisks;
	uint64_t cid = vdev_draid_permute_id(vdc, base, iter, c);
	vdev_t *cvd = vd->vdev_child[cid];

	/* Group contains a faulted vdev. */
	if (vdev_draid_faulted(cvd, physical_offset))
	return (B_TRUE);

	/*
	* Always check groups with active distributed spares
	* because any vdev failure in the pool will affect them.
	*/
	if (vdev_draid_find_spare(cvd) != NULL)
	return (B_TRUE);
	}

	return (B_FALSE);
	}

	/*
	* Determine if the txg is missing. Used by healing resilver.
	*/
	static boolean_t
	vdev_draid_group_missing(vdev_t *vd, uint64_t offset, uint64_t txg,
	uint64_t size)
	{
	vdev_draid_config_t *vdc = vd->vdev_tsd;

	ASSERT3P(vd->vdev_ops, ==, &vdev_draid_ops);
	ASSERT3U(vdev_draid_get_astart(vd, offset), ==, offset);

	uint64_t groupstart, perm;
	uint64_t physical_offset = vdev_draid_logical_to_physical(vd,
	offset, &perm, &groupstart);

	uint8_t *base;
	uint64_t iter;
	vdev_draid_get_perm(vdc, perm, &base, &iter);

	for (uint64_t i = 0; i < vdc->vdc_groupwidth; i++) {
	uint64_t c = (groupstart + i) % vdc->vdc_ndisks;
	uint64_t cid = vdev_draid_permute_id(vdc, base, iter, c);
	vdev_t *cvd = vd->vdev_child[cid];

	/* Transaction group is known to be partially replicated. */
	if (vdev_draid_partial(cvd, physical_offset, txg, size))
	return (B_TRUE);

	/*
	* Always check groups with active distributed spares
	* because any vdev failure in the pool will affect them.
	*/
	if (vdev_draid_find_spare(cvd) != NULL)
	return (B_TRUE);
	}

	return (B_FALSE);
	}

	/*
	* Find the smallest child asize and largest sector size to calculate the
	* available capacity. Distributed spares are ignored since their capacity
	* is also based of the minimum child size in the top-level dRAID.
	*/
	static void
	vdev_draid_calculate_asize(vdev_t vd, uint64_t asizep, uint64_t *max_asizep,
	uint64_t logical_ashiftp, uint64_t physical_ashiftp)
	{
	uint64_t logical_ashift = 0, physical_ashift = 0;
	uint64_t asize = 0, max_asize = 0;

	ASSERT3P(vd->vdev_ops, ==, &vdev_draid_ops);

	for (int c = 0; c < vd->vdev_children; c++) {
	vdev_t *cvd = vd->vdev_child[c];

	if (cvd->vdev_ops == &vdev_draid_spare_ops)
	continue;

	asize = MIN(asize - 1, cvd->vdev_asize - 1) + 1;
	max_asize = MIN(max_asize - 1, cvd->vdev_max_asize - 1) + 1;
	logical_ashift = MAX(logical_ashift, cvd->vdev_ashift);
	physical_ashift = MAX(physical_ashift,
	cvd->vdev_physical_ashift);
	}

	*asizep = asize;
	*max_asizep = max_asize;
	*logical_ashiftp = logical_ashift;
	*physical_ashiftp = physical_ashift;
	}

	/*
	* Open spare vdevs.
	*/
	static boolean_t
	vdev_draid_open_spares(vdev_t *vd)
	{
	return (vd->vdev_ops == &vdev_draid_spare_ops \|\|
	vd->vdev_ops == &vdev_replacing_ops \|\|
	vd->vdev_ops == &vdev_spare_ops);
	}

	/*
	* Open all children, excluding spares.
	*/
	static boolean_t
	vdev_draid_open_children(vdev_t *vd)
	{
	return (!vdev_draid_open_spares(vd));
	}

	/*
	* Open a top-level dRAID vdev.
	*/
	static int
	vdev_draid_open(vdev_t vd, uint64_t asize, uint64_t *max_asize,
	uint64_t logical_ashift, uint64_t physical_ashift)
	{
	vdev_draid_config_t *vdc = vd->vdev_tsd;
	uint64_t nparity = vdc->vdc_nparity;
	int open_errors = 0;

	if (nparity > VDEV_DRAID_MAXPARITY \|\|
	vd->vdev_children < nparity + 1) {
	vd->vdev_stat.vs_aux = VDEV_AUX_BAD_LABEL;
	return (SET_ERROR(EINVAL));
	}

	/*
	* First open the normal children then the distributed spares. This
	* ordering is important to ensure the distributed spares calculate
	* the correct psize in the event that the dRAID vdevs were expanded.
	*/
	vdev_open_children_subset(vd, vdev_draid_open_children);
	vdev_open_children_subset(vd, vdev_draid_open_spares);

	/* Verify enough of the children are available to continue. */
	for (int c = 0; c < vd->vdev_children; c++) {
	if (vd->vdev_child[c]->vdev_open_error != 0) {
	if ((++open_errors) > nparity) {
	vd->vdev_stat.vs_aux = VDEV_AUX_NO_REPLICAS;
	return (SET_ERROR(ENXIO));
	}
	}
	}

	/*
	* Allocatable capacity is the sum of the space on all children less
	* the number of distributed spares rounded down to last full row
	* and then to the last full group. An additional 32MB of scratch
	* space is reserved at the end of each child for use by the dRAID
	* expansion feature.
	*/
	uint64_t child_asize, child_max_asize;
	vdev_draid_calculate_asize(vd, &child_asize, &child_max_asize,
	logical_ashift, physical_ashift);

	/*
	* Should be unreachable since the minimum child size is 64MB, but
	* we want to make sure an underflow absolutely cannot occur here.
	*/
	if (child_asize < VDEV_DRAID_REFLOW_RESERVE \|\|
	child_max_asize < VDEV_DRAID_REFLOW_RESERVE) {
	return (SET_ERROR(ENXIO));
	}

	child_asize = ((child_asize - VDEV_DRAID_REFLOW_RESERVE) /
	VDEV_DRAID_ROWHEIGHT) * VDEV_DRAID_ROWHEIGHT;
	child_max_asize = ((child_max_asize - VDEV_DRAID_REFLOW_RESERVE) /
	VDEV_DRAID_ROWHEIGHT) * VDEV_DRAID_ROWHEIGHT;

	asize = (((child_asize vdc->vdc_ndisks) / vdc->vdc_groupsz) *
	vdc->vdc_groupsz);
	max_asize = (((child_max_asize vdc->vdc_ndisks) / vdc->vdc_groupsz) *
	vdc->vdc_groupsz);

	return (0);
	}

	/*
	* Close a top-level dRAID vdev.
	*/
	static void
	vdev_draid_close(vdev_t *vd)
	{
	for (int c = 0; c < vd->vdev_children; c++) {
	if (vd->vdev_child[c] != NULL)
	vdev_close(vd->vdev_child[c]);
	}
	}

	/*
	* Return the maximum asize for a rebuild zio in the provided range
	* given the following constraints. A dRAID chunks may not:
	*
	* - Exceed the maximum allowed block size (SPA_MAXBLOCKSIZE), or
	* - Span dRAID redundancy groups.
	*/
	static uint64_t
	vdev_draid_rebuild_asize(vdev_t *vd, uint64_t start, uint64_t asize,
	uint64_t max_segment)
	{
	vdev_draid_config_t *vdc = vd->vdev_tsd;

	ASSERT3P(vd->vdev_ops, ==, &vdev_draid_ops);

	uint64_t ashift = vd->vdev_ashift;
	uint64_t ndata = vdc->vdc_ndata;
	uint64_t psize = MIN(P2ROUNDUP(max_segment * ndata, 1 << ashift),
	SPA_MAXBLOCKSIZE);

	ASSERT3U(vdev_draid_get_astart(vd, start), ==, start);
	ASSERT3U(asize % (vdc->vdc_groupwidth << ashift), ==, 0);

	/* Chunks must evenly span all data columns in the group. */
	psize = (((psize >> ashift) / ndata) * ndata) << ashift;
	uint64_t chunk_size = MIN(asize, vdev_psize_to_asize(vd, psize));

	/* Reduce the chunk size to the group space remaining. */
	uint64_t group = vdev_draid_offset_to_group(vd, start);
	uint64_t left = vdev_draid_group_to_offset(vd, group + 1) - start;
	chunk_size = MIN(chunk_size, left);

	ASSERT3U(chunk_size % (vdc->vdc_groupwidth << ashift), ==, 0);
	ASSERT3U(vdev_draid_offset_to_group(vd, start), ==,
	vdev_draid_offset_to_group(vd, start + chunk_size - 1));

	return (chunk_size);
	}

	/*
	* Align the start of the metaslab to the group width and slightly reduce
	* its size to a multiple of the group width. Since full stripe writes are
	* required by dRAID this space is unallocable. Furthermore, aligning the
	* metaslab start is important for vdev initialize and TRIM which both operate
	* on metaslab boundaries which vdev_xlate() expects to be aligned.
	*/
	static void
	vdev_draid_metaslab_init(vdev_t vd, uint64_t ms_start, uint64_t *ms_size)
	{
	vdev_draid_config_t *vdc = vd->vdev_tsd;

	ASSERT3P(vd->vdev_ops, ==, &vdev_draid_ops);

	uint64_t sz = vdc->vdc_groupwidth << vd->vdev_ashift;
	uint64_t astart = vdev_draid_get_astart(vd, *ms_start);
	uint64_t asize = ((ms_size - (astart - ms_start)) / sz) * sz;

	*ms_start = astart;
	*ms_size = asize;

	ASSERT0(*ms_start % sz);
	ASSERT0(*ms_size % sz);
	}

	/*
	* Add virtual dRAID spares to the list of valid spares. In order to accomplish
	* this the existing array must be freed and reallocated with the additional
	* entries.
	*/
	int
	vdev_draid_spare_create(nvlist_t nvroot, vdev_t vd, uint64_t *ndraidp,
	uint64_t next_vdev_id)
	{
	uint64_t draid_nspares = 0;
	uint64_t ndraid = 0;
	int error;

	for (uint64_t i = 0; i < vd->vdev_children; i++) {
	vdev_t *cvd = vd->vdev_child[i];

	if (cvd->vdev_ops == &vdev_draid_ops) {
	vdev_draid_config_t *vdc = cvd->vdev_tsd;
	draid_nspares += vdc->vdc_nspares;
	ndraid++;
	}
	}

	if (draid_nspares == 0) {
	*ndraidp = ndraid;
	return (0);
	}

	nvlist_t old_spares, new_spares;
	uint_t old_nspares;
	error = nvlist_lookup_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES,
	&old_spares, &old_nspares);
	if (error)
	old_nspares = 0;

	/* Allocate memory and copy of the existing spares. */
	new_spares = kmem_alloc(sizeof (nvlist_t )
	(draid_nspares + old_nspares), KM_SLEEP);
	for (uint_t i = 0; i < old_nspares; i++)
	new_spares[i] = fnvlist_dup(old_spares[i]);

	/* Add new distributed spares to ZPOOL_CONFIG_SPARES. */
	uint64_t n = old_nspares;
	for (uint64_t vdev_id = 0; vdev_id < vd->vdev_children; vdev_id++) {
	vdev_t *cvd = vd->vdev_child[vdev_id];
	char path[64];

	if (cvd->vdev_ops != &vdev_draid_ops)
	continue;

	vdev_draid_config_t *vdc = cvd->vdev_tsd;
	uint64_t nspares = vdc->vdc_nspares;
	uint64_t nparity = vdc->vdc_nparity;

	for (uint64_t spare_id = 0; spare_id < nspares; spare_id++) {
	bzero(path, sizeof (path));
	(void) snprintf(path, sizeof (path) - 1,
	"%s%llu-%llu-%llu", VDEV_TYPE_DRAID,
	(u_longlong_t)nparity,
	(u_longlong_t)next_vdev_id + vdev_id,
	(u_longlong_t)spare_id);

	nvlist_t *spare = fnvlist_alloc();
	fnvlist_add_string(spare, ZPOOL_CONFIG_PATH, path);
	fnvlist_add_string(spare, ZPOOL_CONFIG_TYPE,
	VDEV_TYPE_DRAID_SPARE);
	fnvlist_add_uint64(spare, ZPOOL_CONFIG_TOP_GUID,
	cvd->vdev_guid);
	fnvlist_add_uint64(spare, ZPOOL_CONFIG_SPARE_ID,
	spare_id);
	fnvlist_add_uint64(spare, ZPOOL_CONFIG_IS_LOG, 0);
	fnvlist_add_uint64(spare, ZPOOL_CONFIG_IS_SPARE, 1);
	fnvlist_add_uint64(spare, ZPOOL_CONFIG_WHOLE_DISK, 1);
	fnvlist_add_uint64(spare, ZPOOL_CONFIG_ASHIFT,
	cvd->vdev_ashift);

	new_spares[n] = spare;
	n++;
	}
	}

	if (n > 0) {
	(void) nvlist_remove_all(nvroot, ZPOOL_CONFIG_SPARES);
	fnvlist_add_nvlist_array(nvroot, ZPOOL_CONFIG_SPARES,
	new_spares, n);
	}

	for (int i = 0; i < n; i++)
	nvlist_free(new_spares[i]);

	kmem_free(new_spares, sizeof (new_spares) n);
	*ndraidp = ndraid;

	return (0);
	}

	/*
	* Determine if any portion of the provided block resides on a child vdev
	* with a dirty DTL and therefore needs to be resilvered.
	*/
	static boolean_t
	vdev_draid_need_resilver(vdev_t vd, const dva_t dva, size_t psize,
	uint64_t phys_birth)
	{
	uint64_t offset = DVA_GET_OFFSET(dva);
	uint64_t asize = vdev_draid_asize(vd, psize);

	if (phys_birth == TXG_UNKNOWN) {
	/*
	* Sequential resilver. There is no meaningful phys_birth
	* for this block, we can only determine if block resides
	* in a degraded group in which case it must be resilvered.
	*/
	ASSERT3U(vdev_draid_offset_to_group(vd, offset), ==,
	vdev_draid_offset_to_group(vd, offset + asize - 1));

	return (vdev_draid_group_degraded(vd, offset));
	} else {
	/*
	* Healing resilver. TXGs not in DTL_PARTIAL are intact,
	* as are blocks in non-degraded groups.
	*/
	if (!vdev_dtl_contains(vd, DTL_PARTIAL, phys_birth, 1))
	return (B_FALSE);

	if (vdev_draid_group_missing(vd, offset, phys_birth, 1))
	return (B_TRUE);

	/* The block may span groups in which case check both. */
	if (vdev_draid_offset_to_group(vd, offset) !=
	vdev_draid_offset_to_group(vd, offset + asize - 1)) {
	if (vdev_draid_group_missing(vd,
	offset + asize, phys_birth, 1))
	return (B_TRUE);
	}

	return (B_FALSE);
	}
	}

	static boolean_t
	vdev_draid_rebuilding(vdev_t *vd)
	{
	if (vd->vdev_ops->vdev_op_leaf && vd->vdev_rebuild_txg)
	return (B_TRUE);

	for (int i = 0; i < vd->vdev_children; i++) {
	if (vdev_draid_rebuilding(vd->vdev_child[i])) {
	return (B_TRUE);
	}
	}

	return (B_FALSE);
	}

	static void
	vdev_draid_io_verify(vdev_t vd, raidz_row_t rr, int col)
	{
	#ifdef ZFS_DEBUG
	range_seg64_t logical_rs, physical_rs, remain_rs;
	logical_rs.rs_start = rr->rr_offset;
	logical_rs.rs_end = logical_rs.rs_start +
	vdev_draid_asize(vd, rr->rr_size);

	raidz_col_t *rc = &rr->rr_col[col];
	vdev_t *cvd = vd->vdev_child[rc->rc_devidx];

	vdev_xlate(cvd, &logical_rs, &physical_rs, &remain_rs);
	ASSERT(vdev_xlate_is_empty(&remain_rs));
	ASSERT3U(rc->rc_offset, ==, physical_rs.rs_start);
	ASSERT3U(rc->rc_offset, <, physical_rs.rs_end);
	ASSERT3U(rc->rc_offset + rc->rc_size, ==, physical_rs.rs_end);
	#endif
	}

	/*
	* For write operations:
	* 1. Generate the parity data
	* 2. Create child zio write operations to each column's vdev, for both
	* data and parity. A gang ABD is allocated by vdev_draid_map_alloc()
	* if a skip sector needs to be added to a column.
	*/
	static void
	vdev_draid_io_start_write(zio_t zio, raidz_row_t rr)
	{
	vdev_t *vd = zio->io_vd;
	raidz_map_t *rm = zio->io_vsd;

	vdev_raidz_generate_parity_row(rm, rr);

	for (int c = 0; c < rr->rr_cols; c++) {
	raidz_col_t *rc = &rr->rr_col[c];

	/*
	* Empty columns are zero filled and included in the parity
	* calculation and therefore must be written.
	*/
	ASSERT3U(rc->rc_size, !=, 0);

	/* Verify physical to logical translation */
	vdev_draid_io_verify(vd, rr, c);

	zio_nowait(zio_vdev_child_io(zio, NULL,
	vd->vdev_child[rc->rc_devidx], rc->rc_offset,
	rc->rc_abd, rc->rc_size, zio->io_type, zio->io_priority,
	0, vdev_raidz_child_done, rc));
	}
	}

	/*
	* For read operations:
	* 1. The vdev_draid_map_alloc() function will create a minimal raidz
	* mapping for the read based on the zio->io_flags. There are two
	* possible mappings either 1) a normal read, or 2) a scrub/resilver.
	* 2. Create the zio read operations. This will include all parity
	* columns and skip sectors for a scrub/resilver.
	*/
	static void
	vdev_draid_io_start_read(zio_t zio, raidz_row_t rr)
	{
	vdev_t *vd = zio->io_vd;

	/* Sequential rebuild must do IO at redundancy group boundary. */
	IMPLY(zio->io_priority == ZIO_PRIORITY_REBUILD, rr->rr_nempty == 0);

	/*
	* Iterate over the columns in reverse order so that we hit the parity
	* last. Any errors along the way will force us to read the parity.
	* For scrub/resilver IOs which verify skip sectors, a gang ABD will
	* have been allocated to store them and rc->rc_size is increased.
	*/
	for (int c = rr->rr_cols - 1; c >= 0; c--) {
	raidz_col_t *rc = &rr->rr_col[c];
	vdev_t *cvd = vd->vdev_child[rc->rc_devidx];

	if (!vdev_draid_readable(cvd, rc->rc_offset)) {
	if (c >= rr->rr_firstdatacol)
	rr->rr_missingdata++;
	else
	rr->rr_missingparity++;
	rc->rc_error = SET_ERROR(ENXIO);
	rc->rc_tried = 1;
	rc->rc_skipped = 1;
	continue;
	}

	if (vdev_draid_missing(cvd, rc->rc_offset, zio->io_txg, 1)) {
	if (c >= rr->rr_firstdatacol)
	rr->rr_missingdata++;
	else
	rr->rr_missingparity++;
	rc->rc_error = SET_ERROR(ESTALE);
	rc->rc_skipped = 1;
	continue;
	}

	/*
	* Empty columns may be read during vdev_draid_io_done().
	* Only skip them after the readable and missing checks
	* verify they are available.
	*/
	if (rc->rc_size == 0) {
	rc->rc_skipped = 1;
	continue;
	}

	if (zio->io_flags & ZIO_FLAG_RESILVER) {
	vdev_t *svd;

	+ /*
	+ * Sequential rebuilds need to always consider the data
	+ * on the child being rebuilt to be stale. This is
	+ * important when all columns are available to aid
	+ * known reconstruction in identifing which columns
	+ * contain incorrect data.
	+ *
	+ * Furthermore, all repairs need to be constrained to
	+ * the devices being rebuilt because without a checksum
	+ * we cannot verify the data is actually correct and
	+ * performing an incorrect repair could result in
	+ * locking in damage and making the data unrecoverable.
	+ */
	+ if (zio->io_priority == ZIO_PRIORITY_REBUILD) {
	+ if (vdev_draid_rebuilding(cvd)) {
	+ if (c >= rr->rr_firstdatacol)
	+ rr->rr_missingdata++;
	+ else
	+ rr->rr_missingparity++;
	+ rc->rc_error = SET_ERROR(ESTALE);
	+ rc->rc_skipped = 1;
	+ rc->rc_allow_repair = 1;
	+ continue;
	+ } else {
	+ rc->rc_allow_repair = 0;
	+ }
	+ } else {
	+ rc->rc_allow_repair = 1;
	+ }
	+
	/*
	* If this child is a distributed spare then the
	* offset might reside on the vdev being replaced.
	* In which case this data must be written to the
	* new device. Failure to do so would result in
	* checksum errors when the old device is detached
	* and the pool is scrubbed.
	*/
	if ((svd = vdev_draid_find_spare(cvd)) != NULL) {
	svd = vdev_draid_spare_get_child(svd,
	rc->rc_offset);
	if (svd && (svd->vdev_ops == &vdev_spare_ops \|\|
	svd->vdev_ops == &vdev_replacing_ops)) {
	- rc->rc_repair = 1;
	+ rc->rc_force_repair = 1;
	+
	+ if (vdev_draid_rebuilding(svd))
	+ rc->rc_allow_repair = 1;
	}
	}

	/*
	* Always issue a repair IO to this child when its
	* a spare or replacing vdev with an active rebuild.
	*/
	if ((cvd->vdev_ops == &vdev_spare_ops \|\|
	cvd->vdev_ops == &vdev_replacing_ops) &&
	vdev_draid_rebuilding(cvd)) {
	- rc->rc_repair = 1;
	+ rc->rc_force_repair = 1;
	+ rc->rc_allow_repair = 1;
	}
	}
	}

	/*
	* Either a parity or data column is missing this means a repair
	* may be attempted by vdev_draid_io_done(). Expand the raid map
	* to read in empty columns which are needed along with the parity
	* during reconstruction.
	*/
	if ((rr->rr_missingdata > 0 \|\| rr->rr_missingparity > 0) &&
	rr->rr_nempty > 0 && rr->rr_abd_empty == NULL) {
	vdev_draid_map_alloc_empty(zio, rr);
	}

	for (int c = rr->rr_cols - 1; c >= 0; c--) {
	raidz_col_t *rc = &rr->rr_col[c];
	vdev_t *cvd = vd->vdev_child[rc->rc_devidx];

	if (rc->rc_error \|\| rc->rc_size == 0)
	continue;

	if (c >= rr->rr_firstdatacol \|\| rr->rr_missingdata > 0 \|\|
	(zio->io_flags & (ZIO_FLAG_SCRUB \| ZIO_FLAG_RESILVER))) {
	zio_nowait(zio_vdev_child_io(zio, NULL, cvd,
	rc->rc_offset, rc->rc_abd, rc->rc_size,
	zio->io_type, zio->io_priority, 0,
	vdev_raidz_child_done, rc));
	}
	}
	}

	/*
	* Start an IO operation to a dRAID vdev.
	*/
	static void
	vdev_draid_io_start(zio_t *zio)
	{
	vdev_t *vd __maybe_unused = zio->io_vd;

	ASSERT3P(vd->vdev_ops, ==, &vdev_draid_ops);
	ASSERT3U(zio->io_offset, ==, vdev_draid_get_astart(vd, zio->io_offset));

	raidz_map_t *rm = vdev_draid_map_alloc(zio);
	zio->io_vsd = rm;
	zio->io_vsd_ops = &vdev_raidz_vsd_ops;

	if (zio->io_type == ZIO_TYPE_WRITE) {
	for (int i = 0; i < rm->rm_nrows; i++) {
	vdev_draid_io_start_write(zio, rm->rm_row[i]);
	}
	} else {
	ASSERT(zio->io_type == ZIO_TYPE_READ);

	for (int i = 0; i < rm->rm_nrows; i++) {
	vdev_draid_io_start_read(zio, rm->rm_row[i]);
	}
	}

	zio_execute(zio);
	}

	/*
	* Complete an IO operation on a dRAID vdev. The raidz logic can be applied
	* to dRAID since the layout is fully described by the raidz_map_t.
	*/
	static void
	vdev_draid_io_done(zio_t *zio)
	{
	vdev_raidz_io_done(zio);
	}

	static void
	vdev_draid_state_change(vdev_t *vd, int faulted, int degraded)
	{
	vdev_draid_config_t *vdc = vd->vdev_tsd;
	ASSERT(vd->vdev_ops == &vdev_draid_ops);

	if (faulted > vdc->vdc_nparity)
	vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN,
	VDEV_AUX_NO_REPLICAS);
	else if (degraded + faulted != 0)
	vdev_set_state(vd, B_FALSE, VDEV_STATE_DEGRADED, VDEV_AUX_NONE);
	else
	vdev_set_state(vd, B_FALSE, VDEV_STATE_HEALTHY, VDEV_AUX_NONE);
	}

	static void
	vdev_draid_xlate(vdev_t cvd, const range_seg64_t logical_rs,
	range_seg64_t physical_rs, range_seg64_t remain_rs)
	{
	vdev_t *raidvd = cvd->vdev_parent;
	ASSERT(raidvd->vdev_ops == &vdev_draid_ops);

	vdev_draid_config_t *vdc = raidvd->vdev_tsd;
	uint64_t ashift = raidvd->vdev_top->vdev_ashift;

	/* Make sure the offsets are block-aligned */
	ASSERT0(logical_rs->rs_start % (1 << ashift));
	ASSERT0(logical_rs->rs_end % (1 << ashift));

	uint64_t logical_start = logical_rs->rs_start;
	uint64_t logical_end = logical_rs->rs_end;

	/*
	* Unaligned ranges must be skipped. All metaslabs are correctly
	* aligned so this should not happen, but this case is handled in
	* case it's needed by future callers.
	*/
	uint64_t astart = vdev_draid_get_astart(raidvd, logical_start);
	if (astart != logical_start) {
	physical_rs->rs_start = logical_start;
	physical_rs->rs_end = logical_start;
	remain_rs->rs_start = MIN(astart, logical_end);
	remain_rs->rs_end = logical_end;
	return;
	}

	/*
	* Unlike with mirrors and raidz a dRAID logical range can map
	* to multiple non-contiguous physical ranges. This is handled by
	* limiting the size of the logical range to a single group and
	* setting the remain argument such that it describes the remaining
	* unmapped logical range. This is stricter than absolutely
	* necessary but helps simplify the logic below.
	*/
	uint64_t group = vdev_draid_offset_to_group(raidvd, logical_start);
	uint64_t nextstart = vdev_draid_group_to_offset(raidvd, group + 1);
	if (logical_end > nextstart)
	logical_end = nextstart;

	/* Find the starting offset for each vdev in the group */
	uint64_t perm, groupstart;
	uint64_t start = vdev_draid_logical_to_physical(raidvd,
	logical_start, &perm, &groupstart);
	uint64_t end = start;

	uint8_t *base;
	uint64_t iter, id;
	vdev_draid_get_perm(vdc, perm, &base, &iter);

	/*
	* Check if the passed child falls within the group. If it does
	* update the start and end to reflect the physical range.
	* Otherwise, leave them unmodified which will result in an empty
	* (zero-length) physical range being returned.
	*/
	for (uint64_t i = 0; i < vdc->vdc_groupwidth; i++) {
	uint64_t c = (groupstart + i) % vdc->vdc_ndisks;

	if (c == 0 && i != 0) {
	/* the group wrapped, increment the start */
	start += VDEV_DRAID_ROWHEIGHT;
	end = start;
	}

	id = vdev_draid_permute_id(vdc, base, iter, c);
	if (id == cvd->vdev_id) {
	uint64_t b_size = (logical_end >> ashift) -
	(logical_start >> ashift);
	ASSERT3U(b_size, >, 0);
	end = start + ((((b_size - 1) /
	vdc->vdc_groupwidth) + 1) << ashift);
	break;
	}
	}
	physical_rs->rs_start = start;
	physical_rs->rs_end = end;

	/*
	* Only top-level vdevs are allowed to set remain_rs because
	* when .vdev_op_xlate() is called for their children the full
	* logical range is not provided by vdev_xlate().
	*/
	remain_rs->rs_start = logical_end;
	remain_rs->rs_end = logical_rs->rs_end;

	ASSERT3U(physical_rs->rs_start, <=, logical_start);
	ASSERT3U(physical_rs->rs_end - physical_rs->rs_start, <=,
	logical_end - logical_start);
	}

	/*
	* Add dRAID specific fields to the config nvlist.
	*/
	static void
	vdev_draid_config_generate(vdev_t vd, nvlist_t nv)
	{
	ASSERT3P(vd->vdev_ops, ==, &vdev_draid_ops);
	vdev_draid_config_t *vdc = vd->vdev_tsd;

	fnvlist_add_uint64(nv, ZPOOL_CONFIG_NPARITY, vdc->vdc_nparity);
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_DRAID_NDATA, vdc->vdc_ndata);
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_DRAID_NSPARES, vdc->vdc_nspares);
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_DRAID_NGROUPS, vdc->vdc_ngroups);
	}

	/*
	* Initialize private dRAID specific fields from the nvlist.
	*/
	static int
	vdev_draid_init(spa_t spa, nvlist_t nv, void **tsd)
	{
	uint64_t ndata, nparity, nspares, ngroups;
	int error;

	if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_DRAID_NDATA, &ndata))
	return (SET_ERROR(EINVAL));

	if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_NPARITY, &nparity) \|\|
	nparity == 0 \|\| nparity > VDEV_DRAID_MAXPARITY) {
	return (SET_ERROR(EINVAL));
	}

	uint_t children;
	nvlist_t **child;
	if (nvlist_lookup_nvlist_array(nv, ZPOOL_CONFIG_CHILDREN,
	&child, &children) != 0 \|\| children == 0 \|\|
	children > VDEV_DRAID_MAX_CHILDREN) {
	return (SET_ERROR(EINVAL));
	}

	if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_DRAID_NSPARES, &nspares) \|\|
	nspares > 100 \|\| nspares > (children - (ndata + nparity))) {
	return (SET_ERROR(EINVAL));
	}

	if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_DRAID_NGROUPS, &ngroups) \|\|
	ngroups == 0 \|\| ngroups > VDEV_DRAID_MAX_CHILDREN) {
	return (SET_ERROR(EINVAL));
	}

	/*
	* Validate the minimum number of children exist per group for the
	* specified parity level (draid1 >= 2, draid2 >= 3, draid3 >= 4).
	*/
	if (children < (ndata + nparity + nspares))
	return (SET_ERROR(EINVAL));

	/*
	* Create the dRAID configuration using the pool nvlist configuration
	* and the fixed mapping for the correct number of children.
	*/
	vdev_draid_config_t *vdc;
	const draid_map_t *map;

	error = vdev_draid_lookup_map(children, &map);
	if (error)
	return (SET_ERROR(EINVAL));

	vdc = kmem_zalloc(sizeof (*vdc), KM_SLEEP);
	vdc->vdc_ndata = ndata;
	vdc->vdc_nparity = nparity;
	vdc->vdc_nspares = nspares;
	vdc->vdc_children = children;
	vdc->vdc_ngroups = ngroups;
	vdc->vdc_nperms = map->dm_nperms;

	error = vdev_draid_generate_perms(map, &vdc->vdc_perms);
	if (error) {
	kmem_free(vdc, sizeof (*vdc));
	return (SET_ERROR(EINVAL));
	}

	/*
	* Derived constants.
	*/
	vdc->vdc_groupwidth = vdc->vdc_ndata + vdc->vdc_nparity;
	vdc->vdc_ndisks = vdc->vdc_children - vdc->vdc_nspares;
	vdc->vdc_groupsz = vdc->vdc_groupwidth * VDEV_DRAID_ROWHEIGHT;
	vdc->vdc_devslicesz = (vdc->vdc_groupsz * vdc->vdc_ngroups) /
	vdc->vdc_ndisks;

	ASSERT3U(vdc->vdc_groupwidth, >=, 2);
	ASSERT3U(vdc->vdc_groupwidth, <=, vdc->vdc_ndisks);
	ASSERT3U(vdc->vdc_groupsz, >=, 2 * VDEV_DRAID_ROWHEIGHT);
	ASSERT3U(vdc->vdc_devslicesz, >=, VDEV_DRAID_ROWHEIGHT);
	ASSERT3U(vdc->vdc_devslicesz % VDEV_DRAID_ROWHEIGHT, ==, 0);
	ASSERT3U((vdc->vdc_groupwidth * vdc->vdc_ngroups) %
	vdc->vdc_ndisks, ==, 0);

	*tsd = vdc;

	return (0);
	}

	static void
	vdev_draid_fini(vdev_t *vd)
	{
	vdev_draid_config_t *vdc = vd->vdev_tsd;

	vmem_free(vdc->vdc_perms, sizeof (uint8_t) *
	vdc->vdc_children * vdc->vdc_nperms);
	kmem_free(vdc, sizeof (*vdc));
	}

	static uint64_t
	vdev_draid_nparity(vdev_t *vd)
	{
	vdev_draid_config_t *vdc = vd->vdev_tsd;

	return (vdc->vdc_nparity);
	}

	static uint64_t
	vdev_draid_ndisks(vdev_t *vd)
	{
	vdev_draid_config_t *vdc = vd->vdev_tsd;

	return (vdc->vdc_ndisks);
	}

	vdev_ops_t vdev_draid_ops = {
	.vdev_op_init = vdev_draid_init,
	.vdev_op_fini = vdev_draid_fini,
	.vdev_op_open = vdev_draid_open,
	.vdev_op_close = vdev_draid_close,
	.vdev_op_asize = vdev_draid_asize,
	.vdev_op_min_asize = vdev_draid_min_asize,
	.vdev_op_min_alloc = vdev_draid_min_alloc,
	.vdev_op_io_start = vdev_draid_io_start,
	.vdev_op_io_done = vdev_draid_io_done,
	.vdev_op_state_change = vdev_draid_state_change,
	.vdev_op_need_resilver = vdev_draid_need_resilver,
	.vdev_op_hold = NULL,
	.vdev_op_rele = NULL,
	.vdev_op_remap = NULL,
	.vdev_op_xlate = vdev_draid_xlate,
	.vdev_op_rebuild_asize = vdev_draid_rebuild_asize,
	.vdev_op_metaslab_init = vdev_draid_metaslab_init,
	.vdev_op_config_generate = vdev_draid_config_generate,
	.vdev_op_nparity = vdev_draid_nparity,
	.vdev_op_ndisks = vdev_draid_ndisks,
	.vdev_op_type = VDEV_TYPE_DRAID,
	.vdev_op_leaf = B_FALSE,
	};


	/*
	* A dRAID distributed spare is a virtual leaf vdev which is included in the
	* parent dRAID configuration. The last N columns of the dRAID permutation
	* table are used to determine on which dRAID children a specific offset
	* should be written. These spare leaf vdevs can only be used to replace
	* faulted children in the same dRAID configuration.
	*/

	/*
	* Distributed spare state. All fields are set when the distributed spare is
	* first opened and are immutable.
	*/
	typedef struct {
	vdev_t vds_draid_vdev; / top-level parent dRAID vdev */
	uint64_t vds_top_guid; /* top-level parent dRAID guid */
	uint64_t vds_spare_id; /* spare id (0 - vdc->vdc_nspares-1) */
	} vdev_draid_spare_t;

	/*
	* Returns the parent dRAID vdev to which the distributed spare belongs.
	* This may be safely called even when the vdev is not open.
	*/
	vdev_t *
	vdev_draid_spare_get_parent(vdev_t *vd)
	{
	vdev_draid_spare_t *vds = vd->vdev_tsd;

	ASSERT3P(vd->vdev_ops, ==, &vdev_draid_spare_ops);

	if (vds->vds_draid_vdev != NULL)
	return (vds->vds_draid_vdev);

	return (vdev_lookup_by_guid(vd->vdev_spa->spa_root_vdev,
	vds->vds_top_guid));
	}

	/*
	* A dRAID space is active when it's the child of a vdev using the
	* vdev_spare_ops, vdev_replacing_ops or vdev_draid_ops.
	*/
	static boolean_t
	vdev_draid_spare_is_active(vdev_t *vd)
	{
	vdev_t *pvd = vd->vdev_parent;

	if (pvd != NULL && (pvd->vdev_ops == &vdev_spare_ops \|\|
	pvd->vdev_ops == &vdev_replacing_ops \|\|
	pvd->vdev_ops == &vdev_draid_ops)) {
	return (B_TRUE);
	} else {
	return (B_FALSE);
	}
	}

	/*
	* Given a dRAID distribute spare vdev, returns the physical child vdev
	* on which the provided offset resides. This may involve recursing through
	* multiple layers of distributed spares. Note that offset is relative to
	* this vdev.
	*/
	vdev_t *
	vdev_draid_spare_get_child(vdev_t *vd, uint64_t physical_offset)
	{
	vdev_draid_spare_t *vds = vd->vdev_tsd;

	ASSERT3P(vd->vdev_ops, ==, &vdev_draid_spare_ops);

	/* The vdev is closed */
	if (vds->vds_draid_vdev == NULL)
	return (NULL);

	vdev_t *tvd = vds->vds_draid_vdev;
	vdev_draid_config_t *vdc = tvd->vdev_tsd;

	ASSERT3P(tvd->vdev_ops, ==, &vdev_draid_ops);
	ASSERT3U(vds->vds_spare_id, <, vdc->vdc_nspares);

	uint8_t *base;
	uint64_t iter;
	uint64_t perm = physical_offset / vdc->vdc_devslicesz;

	vdev_draid_get_perm(vdc, perm, &base, &iter);

	uint64_t cid = vdev_draid_permute_id(vdc, base, iter,
	(tvd->vdev_children - 1) - vds->vds_spare_id);
	vdev_t *cvd = tvd->vdev_child[cid];

	if (cvd->vdev_ops == &vdev_draid_spare_ops)
	return (vdev_draid_spare_get_child(cvd, physical_offset));

	return (cvd);
	}

	/* ARGSUSED */
	static void
	vdev_draid_spare_close(vdev_t *vd)
	{
	vdev_draid_spare_t *vds = vd->vdev_tsd;
	vds->vds_draid_vdev = NULL;
	}

	/*
	* Opening a dRAID spare device is done by looking up the associated dRAID
	* top-level vdev guid from the spare configuration.
	*/
	static int
	vdev_draid_spare_open(vdev_t vd, uint64_t psize, uint64_t *max_psize,
	uint64_t logical_ashift, uint64_t physical_ashift)
	{
	vdev_draid_spare_t *vds = vd->vdev_tsd;
	vdev_t *rvd = vd->vdev_spa->spa_root_vdev;
	uint64_t asize, max_asize;

	vdev_t *tvd = vdev_lookup_by_guid(rvd, vds->vds_top_guid);
	if (tvd == NULL) {
	/*
	* When spa_vdev_add() is labeling new spares the
	* associated dRAID is not attached to the root vdev
	* nor does this spare have a parent. Simulate a valid
	* device in order to allow the label to be initialized
	* and the distributed spare added to the configuration.
	*/
	if (vd->vdev_parent == NULL) {
	psize = max_psize = SPA_MINDEVSIZE;
	logical_ashift = physical_ashift = ASHIFT_MIN;
	return (0);
	}

	return (SET_ERROR(EINVAL));
	}

	vdev_draid_config_t *vdc = tvd->vdev_tsd;
	if (tvd->vdev_ops != &vdev_draid_ops \|\| vdc == NULL)
	return (SET_ERROR(EINVAL));

	if (vds->vds_spare_id >= vdc->vdc_nspares)
	return (SET_ERROR(EINVAL));

	/*
	* Neither tvd->vdev_asize or tvd->vdev_max_asize can be used here
	* because the caller may be vdev_draid_open() in which case the
	* values are stale as they haven't yet been updated by vdev_open().
	* To avoid this always recalculate the dRAID asize and max_asize.
	*/
	vdev_draid_calculate_asize(tvd, &asize, &max_asize,
	logical_ashift, physical_ashift);

	*psize = asize + VDEV_LABEL_START_SIZE + VDEV_LABEL_END_SIZE;
	*max_psize = max_asize + VDEV_LABEL_START_SIZE + VDEV_LABEL_END_SIZE;

	vds->vds_draid_vdev = tvd;

	return (0);
	}

	/*
	* Completed distributed spare IO. Store the result in the parent zio
	* as if it had performed the operation itself. Only the first error is
	* preserved if there are multiple errors.
	*/
	static void
	vdev_draid_spare_child_done(zio_t *zio)
	{
	zio_t *pio = zio->io_private;

	/*
	* IOs are issued to non-writable vdevs in order to keep their
	* DTLs accurate. However, we don't want to propagate the
	* error in to the distributed spare's DTL. When resilvering
	* vdev_draid_need_resilver() will consult the relevant DTL
	* to determine if the data is missing and must be repaired.
	*/
	if (!vdev_writeable(zio->io_vd))
	return;

	if (pio->io_error == 0)
	pio->io_error = zio->io_error;
	}

	/*
	* Returns a valid label nvlist for the distributed spare vdev. This is
	* used to bypass the IO pipeline to avoid the complexity of constructing
	* a complete label with valid checksum to return when read.
	*/
	nvlist_t *
	vdev_draid_read_config_spare(vdev_t *vd)
	{
	spa_t *spa = vd->vdev_spa;
	spa_aux_vdev_t *sav = &spa->spa_spares;
	uint64_t guid = vd->vdev_guid;

	nvlist_t *nv = fnvlist_alloc();
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_IS_SPARE, 1);
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_CREATE_TXG, vd->vdev_crtxg);
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_VERSION, spa_version(spa));
	fnvlist_add_string(nv, ZPOOL_CONFIG_POOL_NAME, spa_name(spa));
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_POOL_GUID, spa_guid(spa));
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_POOL_TXG, spa->spa_config_txg);
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_TOP_GUID, vd->vdev_top->vdev_guid);
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_POOL_STATE,
	vdev_draid_spare_is_active(vd) ?
	POOL_STATE_ACTIVE : POOL_STATE_SPARE);

	/* Set the vdev guid based on the vdev list in sav_count. */
	for (int i = 0; i < sav->sav_count; i++) {
	if (sav->sav_vdevs[i]->vdev_ops == &vdev_draid_spare_ops &&
	strcmp(sav->sav_vdevs[i]->vdev_path, vd->vdev_path) == 0) {
	guid = sav->sav_vdevs[i]->vdev_guid;
	break;
	}
	}

	fnvlist_add_uint64(nv, ZPOOL_CONFIG_GUID, guid);

	return (nv);
	}

	/*
	* Handle any ioctl requested of the distributed spare. Only flushes
	* are supported in which case all children must be flushed.
	*/
	static int
	vdev_draid_spare_ioctl(zio_t *zio)
	{
	vdev_t *vd = zio->io_vd;
	int error = 0;

	if (zio->io_cmd == DKIOCFLUSHWRITECACHE) {
	for (int c = 0; c < vd->vdev_children; c++) {
	zio_nowait(zio_vdev_child_io(zio, NULL,
	vd->vdev_child[c], zio->io_offset, zio->io_abd,
	zio->io_size, zio->io_type, zio->io_priority, 0,
	vdev_draid_spare_child_done, zio));
	}
	} else {
	error = SET_ERROR(ENOTSUP);
	}

	return (error);
	}

	/*
	* Initiate an IO to the distributed spare. For normal IOs this entails using
	* the zio->io_offset and permutation table to calculate which child dRAID vdev
	* is responsible for the data. Then passing along the zio to that child to
	* perform the actual IO. The label ranges are not stored on disk and require
	* some special handling which is described below.
	*/
	static void
	vdev_draid_spare_io_start(zio_t *zio)
	{
	vdev_t cvd = NULL, vd = zio->io_vd;
	vdev_draid_spare_t *vds = vd->vdev_tsd;
	uint64_t offset = zio->io_offset - VDEV_LABEL_START_SIZE;

	/*
	* If the vdev is closed, it's likely in the REMOVED or FAULTED state.
	* Nothing to be done here but return failure.
	*/
	if (vds == NULL) {
	zio->io_error = ENXIO;
	zio_interrupt(zio);
	return;
	}

	switch (zio->io_type) {
	case ZIO_TYPE_IOCTL:
	zio->io_error = vdev_draid_spare_ioctl(zio);
	break;

	case ZIO_TYPE_WRITE:
	if (VDEV_OFFSET_IS_LABEL(vd, zio->io_offset)) {
	/*
	* Accept probe IOs and config writers to simulate the
	* existence of an on disk label. vdev_label_sync(),
	* vdev_uberblock_sync() and vdev_copy_uberblocks()
	* skip the distributed spares. This only leaves
	* vdev_label_init() which is allowed to succeed to
	* avoid adding special cases the function.
	*/
	if (zio->io_flags & ZIO_FLAG_PROBE \|\|
	zio->io_flags & ZIO_FLAG_CONFIG_WRITER) {
	zio->io_error = 0;
	} else {
	zio->io_error = SET_ERROR(EIO);
	}
	} else {
	cvd = vdev_draid_spare_get_child(vd, offset);

	if (cvd == NULL) {
	zio->io_error = SET_ERROR(ENXIO);
	} else {
	zio_nowait(zio_vdev_child_io(zio, NULL, cvd,
	offset, zio->io_abd, zio->io_size,
	zio->io_type, zio->io_priority, 0,
	vdev_draid_spare_child_done, zio));
	}
	}
	break;

	case ZIO_TYPE_READ:
	if (VDEV_OFFSET_IS_LABEL(vd, zio->io_offset)) {
	/*
	* Accept probe IOs to simulate the existence of a
	* label. vdev_label_read_config() bypasses the
	* pipeline to read the label configuration and
	* vdev_uberblock_load() skips distributed spares
	* when attempting to locate the best uberblock.
	*/
	if (zio->io_flags & ZIO_FLAG_PROBE) {
	zio->io_error = 0;
	} else {
	zio->io_error = SET_ERROR(EIO);
	}
	} else {
	cvd = vdev_draid_spare_get_child(vd, offset);

	if (cvd == NULL \|\| !vdev_readable(cvd)) {
	zio->io_error = SET_ERROR(ENXIO);
	} else {
	zio_nowait(zio_vdev_child_io(zio, NULL, cvd,
	offset, zio->io_abd, zio->io_size,
	zio->io_type, zio->io_priority, 0,
	vdev_draid_spare_child_done, zio));
	}
	}
	break;

	case ZIO_TYPE_TRIM:
	/* The vdev label ranges are never trimmed */
	ASSERT0(VDEV_OFFSET_IS_LABEL(vd, zio->io_offset));

	cvd = vdev_draid_spare_get_child(vd, offset);

	if (cvd == NULL \|\| !cvd->vdev_has_trim) {
	zio->io_error = SET_ERROR(ENXIO);
	} else {
	zio_nowait(zio_vdev_child_io(zio, NULL, cvd,
	offset, zio->io_abd, zio->io_size,
	zio->io_type, zio->io_priority, 0,
	vdev_draid_spare_child_done, zio));
	}
	break;

	default:
	zio->io_error = SET_ERROR(ENOTSUP);
	break;
	}

	zio_execute(zio);
	}

	/* ARGSUSED */
	static void
	vdev_draid_spare_io_done(zio_t *zio)
	{
	}

	/*
	* Lookup the full spare config in spa->spa_spares.sav_config and
	* return the top_guid and spare_id for the named spare.
	*/
	static int
	vdev_draid_spare_lookup(spa_t spa, nvlist_t nv, uint64_t *top_guidp,
	uint64_t *spare_idp)
	{
	nvlist_t **spares;
	uint_t nspares;
	int error;

	if ((spa->spa_spares.sav_config == NULL) \|\|
	(nvlist_lookup_nvlist_array(spa->spa_spares.sav_config,
	ZPOOL_CONFIG_SPARES, &spares, &nspares) != 0)) {
	return (SET_ERROR(ENOENT));
	}

	char *spare_name;
	error = nvlist_lookup_string(nv, ZPOOL_CONFIG_PATH, &spare_name);
	if (error != 0)
	return (SET_ERROR(EINVAL));

	for (int i = 0; i < nspares; i++) {
	nvlist_t *spare = spares[i];
	uint64_t top_guid, spare_id;
	char type, path;

	/* Skip non-distributed spares */
	error = nvlist_lookup_string(spare, ZPOOL_CONFIG_TYPE, &type);
	if (error != 0 \|\| strcmp(type, VDEV_TYPE_DRAID_SPARE) != 0)
	continue;

	/* Skip spares with the wrong name */
	error = nvlist_lookup_string(spare, ZPOOL_CONFIG_PATH, &path);
	if (error != 0 \|\| strcmp(path, spare_name) != 0)
	continue;

	/* Found the matching spare */
	error = nvlist_lookup_uint64(spare,
	ZPOOL_CONFIG_TOP_GUID, &top_guid);
	if (error == 0) {
	error = nvlist_lookup_uint64(spare,
	ZPOOL_CONFIG_SPARE_ID, &spare_id);
	}

	if (error != 0) {
	return (SET_ERROR(EINVAL));
	} else {
	*top_guidp = top_guid;
	*spare_idp = spare_id;
	return (0);
	}
	}

	return (SET_ERROR(ENOENT));
	}

	/*
	* Initialize private dRAID spare specific fields from the nvlist.
	*/
	static int
	vdev_draid_spare_init(spa_t spa, nvlist_t nv, void **tsd)
	{
	vdev_draid_spare_t *vds;
	uint64_t top_guid = 0;
	uint64_t spare_id;

	/*
	* In the normal case check the list of spares stored in the spa
	* to lookup the top_guid and spare_id for provided spare config.
	* When creating a new pool or adding vdevs the spare list is not
	* yet populated and the values are provided in the passed config.
	*/
	if (vdev_draid_spare_lookup(spa, nv, &top_guid, &spare_id) != 0) {
	if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_TOP_GUID,
	&top_guid) != 0)
	return (SET_ERROR(EINVAL));

	if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_SPARE_ID,
	&spare_id) != 0)
	return (SET_ERROR(EINVAL));
	}

	vds = kmem_alloc(sizeof (vdev_draid_spare_t), KM_SLEEP);
	vds->vds_draid_vdev = NULL;
	vds->vds_top_guid = top_guid;
	vds->vds_spare_id = spare_id;

	*tsd = vds;

	return (0);
	}

	static void
	vdev_draid_spare_fini(vdev_t *vd)
	{
	kmem_free(vd->vdev_tsd, sizeof (vdev_draid_spare_t));
	}

	static void
	vdev_draid_spare_config_generate(vdev_t vd, nvlist_t nv)
	{
	vdev_draid_spare_t *vds = vd->vdev_tsd;

	ASSERT3P(vd->vdev_ops, ==, &vdev_draid_spare_ops);

	fnvlist_add_uint64(nv, ZPOOL_CONFIG_TOP_GUID, vds->vds_top_guid);
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_SPARE_ID, vds->vds_spare_id);
	}

	vdev_ops_t vdev_draid_spare_ops = {
	.vdev_op_init = vdev_draid_spare_init,
	.vdev_op_fini = vdev_draid_spare_fini,
	.vdev_op_open = vdev_draid_spare_open,
	.vdev_op_close = vdev_draid_spare_close,
	.vdev_op_asize = vdev_default_asize,
	.vdev_op_min_asize = vdev_default_min_asize,
	.vdev_op_min_alloc = NULL,
	.vdev_op_io_start = vdev_draid_spare_io_start,
	.vdev_op_io_done = vdev_draid_spare_io_done,
	.vdev_op_state_change = NULL,
	.vdev_op_need_resilver = NULL,
	.vdev_op_hold = NULL,
	.vdev_op_rele = NULL,
	.vdev_op_remap = NULL,
	.vdev_op_xlate = vdev_default_xlate,
	.vdev_op_rebuild_asize = NULL,
	.vdev_op_metaslab_init = NULL,
	.vdev_op_config_generate = vdev_draid_spare_config_generate,
	.vdev_op_nparity = NULL,
	.vdev_op_ndisks = NULL,
	.vdev_op_type = VDEV_TYPE_DRAID_SPARE,
	.vdev_op_leaf = B_TRUE,
	};
	diff --git a/sys/contrib/openzfs/module/zfs/vdev_indirect.c b/sys/contrib/openzfs/module/zfs/vdev_indirect.c
	index bafb2c767b2e..6362683ae93d 100644
	--- a/sys/contrib/openzfs/module/zfs/vdev_indirect.c
	+++ b/sys/contrib/openzfs/module/zfs/vdev_indirect.c
	@@ -1,1908 +1,1911 @@
	/*
	* CDDL HEADER START
	*
	* This file and its contents are supplied under the terms of the
	* Common Development and Distribution License ("CDDL"), version 1.0.
	* You may only use this file in accordance with the terms of version
	* 1.0 of the CDDL.
	*
	* A full copy of the text of the CDDL should have accompanied this
	* source. A copy of the CDDL is also available via the Internet at
	* http://www.illumos.org/license/CDDL.
	*
	* CDDL HEADER END
	*/

	/*
	* Copyright (c) 2014, 2017 by Delphix. All rights reserved.
	* Copyright (c) 2019, loli10K <ezomori.nozomu@gmail.com>. All rights reserved.
	* Copyright (c) 2014, 2020 by Delphix. All rights reserved.
	*/

	#include <sys/zfs_context.h>
	#include <sys/spa.h>
	#include <sys/spa_impl.h>
	#include <sys/vdev_impl.h>
	#include <sys/fs/zfs.h>
	#include <sys/zio.h>
	#include <sys/zio_checksum.h>
	#include <sys/metaslab.h>
	#include <sys/dmu.h>
	#include <sys/vdev_indirect_mapping.h>
	#include <sys/dmu_tx.h>
	#include <sys/dsl_synctask.h>
	#include <sys/zap.h>
	#include <sys/abd.h>
	#include <sys/zthr.h>

	/*
	* An indirect vdev corresponds to a vdev that has been removed. Since
	* we cannot rewrite block pointers of snapshots, etc., we keep a
	* mapping from old location on the removed device to the new location
	* on another device in the pool and use this mapping whenever we need
	* to access the DVA. Unfortunately, this mapping did not respect
	* logical block boundaries when it was first created, and so a DVA on
	* this indirect vdev may be "split" into multiple sections that each
	* map to a different location. As a consequence, not all DVAs can be
	* translated to an equivalent new DVA. Instead we must provide a
	* "vdev_remap" operation that executes a callback on each contiguous
	* segment of the new location. This function is used in multiple ways:
	*
	* - i/os to this vdev use the callback to determine where the
	* data is now located, and issue child i/os for each segment's new
	* location.
	*
	* - frees and claims to this vdev use the callback to free or claim
	* each mapped segment. (Note that we don't actually need to claim
	* log blocks on indirect vdevs, because we don't allocate to
	* removing vdevs. However, zdb uses zio_claim() for its leak
	* detection.)
	*/

	/*
	* "Big theory statement" for how we mark blocks obsolete.
	*
	* When a block on an indirect vdev is freed or remapped, a section of
	* that vdev's mapping may no longer be referenced (aka "obsolete"). We
	* keep track of how much of each mapping entry is obsolete. When
	* an entry becomes completely obsolete, we can remove it, thus reducing
	* the memory used by the mapping. The complete picture of obsolescence
	* is given by the following data structures, described below:
	* - the entry-specific obsolete count
	* - the vdev-specific obsolete spacemap
	* - the pool-specific obsolete bpobj
	*
	* == On disk data structures used ==
	*
	* We track the obsolete space for the pool using several objects. Each
	* of these objects is created on demand and freed when no longer
	* needed, and is assumed to be empty if it does not exist.
	* SPA_FEATURE_OBSOLETE_COUNTS includes the count of these objects.
	*
	* - Each vic_mapping_object (associated with an indirect vdev) can
	* have a vimp_counts_object. This is an array of uint32_t's
	* with the same number of entries as the vic_mapping_object. When
	* the mapping is condensed, entries from the vic_obsolete_sm_object
	* (see below) are folded into the counts. Therefore, each
	* obsolete_counts entry tells us the number of bytes in the
	* corresponding mapping entry that were not referenced when the
	* mapping was last condensed.
	*
	* - Each indirect or removing vdev can have a vic_obsolete_sm_object.
	* This is a space map containing an alloc entry for every DVA that
	* has been obsoleted since the last time this indirect vdev was
	* condensed. We use this object in order to improve performance
	* when marking a DVA as obsolete. Instead of modifying an arbitrary
	* offset of the vimp_counts_object, we only need to append an entry
	* to the end of this object. When a DVA becomes obsolete, it is
	* added to the obsolete space map. This happens when the DVA is
	* freed, remapped and not referenced by a snapshot, or the last
	* snapshot referencing it is destroyed.
	*
	* - Each dataset can have a ds_remap_deadlist object. This is a
	* deadlist object containing all blocks that were remapped in this
	* dataset but referenced in a previous snapshot. Blocks can only
	* appear on this list if they were remapped (dsl_dataset_block_remapped);
	* blocks that were killed in a head dataset are put on the normal
	* ds_deadlist and marked obsolete when they are freed.
	*
	* - The pool can have a dp_obsolete_bpobj. This is a list of blocks
	* in the pool that need to be marked obsolete. When a snapshot is
	* destroyed, we move some of the ds_remap_deadlist to the obsolete
	* bpobj (see dsl_destroy_snapshot_handle_remaps()). We then
	* asynchronously process the obsolete bpobj, moving its entries to
	* the specific vdevs' obsolete space maps.
	*
	* == Summary of how we mark blocks as obsolete ==
	*
	* - When freeing a block: if any DVA is on an indirect vdev, append to
	* vic_obsolete_sm_object.
	* - When remapping a block, add dva to ds_remap_deadlist (if prev snap
	* references; otherwise append to vic_obsolete_sm_object).
	* - When freeing a snapshot: move parts of ds_remap_deadlist to
	* dp_obsolete_bpobj (same algorithm as ds_deadlist).
	* - When syncing the spa: process dp_obsolete_bpobj, moving ranges to
	* individual vdev's vic_obsolete_sm_object.
	*/

	/*
	* "Big theory statement" for how we condense indirect vdevs.
	*
	* Condensing an indirect vdev's mapping is the process of determining
	* the precise counts of obsolete space for each mapping entry (by
	* integrating the obsolete spacemap into the obsolete counts) and
	* writing out a new mapping that contains only referenced entries.
	*
	* We condense a vdev when we expect the mapping to shrink (see
	* vdev_indirect_should_condense()), but only perform one condense at a
	* time to limit the memory usage. In addition, we use a separate
	* open-context thread (spa_condense_indirect_thread) to incrementally
	* create the new mapping object in a way that minimizes the impact on
	* the rest of the system.
	*
	* == Generating a new mapping ==
	*
	* To generate a new mapping, we follow these steps:
	*
	* 1. Save the old obsolete space map and create a new mapping object
	* (see spa_condense_indirect_start_sync()). This initializes the
	* spa_condensing_indirect_phys with the "previous obsolete space map",
	* which is now read only. Newly obsolete DVAs will be added to a
	* new (initially empty) obsolete space map, and will not be
	* considered as part of this condense operation.
	*
	* 2. Construct in memory the precise counts of obsolete space for each
	* mapping entry, by incorporating the obsolete space map into the
	* counts. (See vdev_indirect_mapping_load_obsolete_{counts,spacemap}().)
	*
	* 3. Iterate through each mapping entry, writing to the new mapping any
	* entries that are not completely obsolete (i.e. which don't have
	* obsolete count == mapping length). (See
	* spa_condense_indirect_generate_new_mapping().)
	*
	* 4. Destroy the old mapping object and switch over to the new one
	* (spa_condense_indirect_complete_sync).
	*
	* == Restarting from failure ==
	*
	* To restart the condense when we import/open the pool, we must start
	* at the 2nd step above: reconstruct the precise counts in memory,
	* based on the space map + counts. Then in the 3rd step, we start
	* iterating where we left off: at vimp_max_offset of the new mapping
	* object.
	*/

	int zfs_condense_indirect_vdevs_enable = B_TRUE;

	/*
	* Condense if at least this percent of the bytes in the mapping is
	* obsolete. With the default of 25%, the amount of space mapped
	* will be reduced to 1% of its original size after at most 16
	* condenses. Higher values will condense less often (causing less
	* i/o); lower values will reduce the mapping size more quickly.
	*/
	-int zfs_indirect_condense_obsolete_pct = 25;
	+int zfs_condense_indirect_obsolete_pct = 25;

	/*
	* Condense if the obsolete space map takes up more than this amount of
	* space on disk (logically). This limits the amount of disk space
	* consumed by the obsolete space map; the default of 1GB is small enough
	* that we typically don't mind "wasting" it.
	*/
	unsigned long zfs_condense_max_obsolete_bytes = 1024 * 1024 * 1024;

	/*
	* Don't bother condensing if the mapping uses less than this amount of
	* memory. The default of 128KB is considered a "trivial" amount of
	* memory and not worth reducing.
	*/
	unsigned long zfs_condense_min_mapping_bytes = 128 * 1024;

	/*
	* This is used by the test suite so that it can ensure that certain
	* actions happen while in the middle of a condense (which might otherwise
	* complete too quickly). If used to reduce the performance impact of
	* condensing in production, a maximum value of 1 should be sufficient.
	*/
	int zfs_condense_indirect_commit_entry_delay_ms = 0;

	/*
	* If an indirect split block contains more than this many possible unique
	* combinations when being reconstructed, consider it too computationally
	* expensive to check them all. Instead, try at most 100 randomly-selected
	* combinations each time the block is accessed. This allows all segment
	* copies to participate fairly in the reconstruction when all combinations
	* cannot be checked and prevents repeated use of one bad copy.
	*/
	int zfs_reconstruct_indirect_combinations_max = 4096;

	/*
	* Enable to simulate damaged segments and validate reconstruction. This
	* is intentionally not exposed as a module parameter.
	*/
	unsigned long zfs_reconstruct_indirect_damage_fraction = 0;

	/*
	* The indirect_child_t represents the vdev that we will read from, when we
	* need to read all copies of the data (e.g. for scrub or reconstruction).
	* For plain (non-mirror) top-level vdevs (i.e. is_vdev is not a mirror),
	* ic_vdev is the same as is_vdev. However, for mirror top-level vdevs,
	* ic_vdev is a child of the mirror.
	*/
	typedef struct indirect_child {
	abd_t *ic_data;
	vdev_t *ic_vdev;

	/*
	* ic_duplicate is NULL when the ic_data contents are unique, when it
	* is determined to be a duplicate it references the primary child.
	*/
	struct indirect_child *ic_duplicate;
	list_node_t ic_node; /* node on is_unique_child */
	int ic_error; /* set when a child does not contain the data */
	} indirect_child_t;

	/*
	* The indirect_split_t represents one mapped segment of an i/o to the
	* indirect vdev. For non-split (contiguously-mapped) blocks, there will be
	* only one indirect_split_t, with is_split_offset==0 and is_size==io_size.
	* For split blocks, there will be several of these.
	*/
	typedef struct indirect_split {
	list_node_t is_node; /* link on iv_splits */

	/*
	* is_split_offset is the offset into the i/o.
	* This is the sum of the previous splits' is_size's.
	*/
	uint64_t is_split_offset;

	vdev_t is_vdev; / top-level vdev */
	uint64_t is_target_offset; /* offset on is_vdev */
	uint64_t is_size;
	int is_children; /* number of entries in is_child[] */
	int is_unique_children; /* number of entries in is_unique_child */
	list_t is_unique_child;

	/*
	* is_good_child is the child that we are currently using to
	* attempt reconstruction.
	*/
	indirect_child_t *is_good_child;

	indirect_child_t is_child[1]; /* variable-length */
	} indirect_split_t;

	/*
	* The indirect_vsd_t is associated with each i/o to the indirect vdev.
	* It is the "Vdev-Specific Data" in the zio_t's io_vsd.
	*/
	typedef struct indirect_vsd {
	boolean_t iv_split_block;
	boolean_t iv_reconstruct;
	uint64_t iv_unique_combinations;
	uint64_t iv_attempts;
	uint64_t iv_attempts_max;

	list_t iv_splits; /* list of indirect_split_t's */
	} indirect_vsd_t;

	static void
	vdev_indirect_map_free(zio_t *zio)
	{
	indirect_vsd_t *iv = zio->io_vsd;

	indirect_split_t *is;
	while ((is = list_head(&iv->iv_splits)) != NULL) {
	for (int c = 0; c < is->is_children; c++) {
	indirect_child_t *ic = &is->is_child[c];
	if (ic->ic_data != NULL)
	abd_free(ic->ic_data);
	}
	list_remove(&iv->iv_splits, is);

	indirect_child_t *ic;
	while ((ic = list_head(&is->is_unique_child)) != NULL)
	list_remove(&is->is_unique_child, ic);

	list_destroy(&is->is_unique_child);

	kmem_free(is,
	offsetof(indirect_split_t, is_child[is->is_children]));
	}
	kmem_free(iv, sizeof (*iv));
	}

	static const zio_vsd_ops_t vdev_indirect_vsd_ops = {
	.vsd_free = vdev_indirect_map_free,
	};

	/*
	* Mark the given offset and size as being obsolete.
	*/
	void
	vdev_indirect_mark_obsolete(vdev_t *vd, uint64_t offset, uint64_t size)
	{
	spa_t *spa = vd->vdev_spa;

	ASSERT3U(vd->vdev_indirect_config.vic_mapping_object, !=, 0);
	ASSERT(vd->vdev_removing \|\| vd->vdev_ops == &vdev_indirect_ops);
	ASSERT(size > 0);
	VERIFY(vdev_indirect_mapping_entry_for_offset(
	vd->vdev_indirect_mapping, offset) != NULL);

	if (spa_feature_is_enabled(spa, SPA_FEATURE_OBSOLETE_COUNTS)) {
	mutex_enter(&vd->vdev_obsolete_lock);
	range_tree_add(vd->vdev_obsolete_segments, offset, size);
	mutex_exit(&vd->vdev_obsolete_lock);
	vdev_dirty(vd, 0, NULL, spa_syncing_txg(spa));
	}
	}

	/*
	* Mark the DVA vdev_id:offset:size as being obsolete in the given tx. This
	* wrapper is provided because the DMU does not know about vdev_t's and
	* cannot directly call vdev_indirect_mark_obsolete.
	*/
	void
	spa_vdev_indirect_mark_obsolete(spa_t *spa, uint64_t vdev_id, uint64_t offset,
	uint64_t size, dmu_tx_t *tx)
	{
	vdev_t *vd = vdev_lookup_top(spa, vdev_id);
	ASSERT(dmu_tx_is_syncing(tx));

	/* The DMU can only remap indirect vdevs. */
	ASSERT3P(vd->vdev_ops, ==, &vdev_indirect_ops);
	vdev_indirect_mark_obsolete(vd, offset, size);
	}

	static spa_condensing_indirect_t *
	spa_condensing_indirect_create(spa_t *spa)
	{
	spa_condensing_indirect_phys_t *scip =
	&spa->spa_condensing_indirect_phys;
	spa_condensing_indirect_t sci = kmem_zalloc(sizeof (sci), KM_SLEEP);
	objset_t *mos = spa->spa_meta_objset;

	for (int i = 0; i < TXG_SIZE; i++) {
	list_create(&sci->sci_new_mapping_entries[i],
	sizeof (vdev_indirect_mapping_entry_t),
	offsetof(vdev_indirect_mapping_entry_t, vime_node));
	}

	sci->sci_new_mapping =
	vdev_indirect_mapping_open(mos, scip->scip_next_mapping_object);

	return (sci);
	}

	static void
	spa_condensing_indirect_destroy(spa_condensing_indirect_t *sci)
	{
	for (int i = 0; i < TXG_SIZE; i++)
	list_destroy(&sci->sci_new_mapping_entries[i]);

	if (sci->sci_new_mapping != NULL)
	vdev_indirect_mapping_close(sci->sci_new_mapping);

	kmem_free(sci, sizeof (*sci));
	}

	boolean_t
	vdev_indirect_should_condense(vdev_t *vd)
	{
	vdev_indirect_mapping_t *vim = vd->vdev_indirect_mapping;
	spa_t *spa = vd->vdev_spa;

	ASSERT(dsl_pool_sync_context(spa->spa_dsl_pool));

	if (!zfs_condense_indirect_vdevs_enable)
	return (B_FALSE);

	/*
	* We can only condense one indirect vdev at a time.
	*/
	if (spa->spa_condensing_indirect != NULL)
	return (B_FALSE);

	if (spa_shutting_down(spa))
	return (B_FALSE);

	/*
	* The mapping object size must not change while we are
	* condensing, so we can only condense indirect vdevs
	* (not vdevs that are still in the middle of being removed).
	*/
	if (vd->vdev_ops != &vdev_indirect_ops)
	return (B_FALSE);

	/*
	* If nothing new has been marked obsolete, there is no
	* point in condensing.
	*/
	uint64_t obsolete_sm_obj __maybe_unused;
	ASSERT0(vdev_obsolete_sm_object(vd, &obsolete_sm_obj));
	if (vd->vdev_obsolete_sm == NULL) {
	ASSERT0(obsolete_sm_obj);
	return (B_FALSE);
	}

	ASSERT(vd->vdev_obsolete_sm != NULL);

	ASSERT3U(obsolete_sm_obj, ==, space_map_object(vd->vdev_obsolete_sm));

	uint64_t bytes_mapped = vdev_indirect_mapping_bytes_mapped(vim);
	uint64_t bytes_obsolete = space_map_allocated(vd->vdev_obsolete_sm);
	uint64_t mapping_size = vdev_indirect_mapping_size(vim);
	uint64_t obsolete_sm_size = space_map_length(vd->vdev_obsolete_sm);

	ASSERT3U(bytes_obsolete, <=, bytes_mapped);

	/*
	* If a high percentage of the bytes that are mapped have become
	* obsolete, condense (unless the mapping is already small enough).
	* This has a good chance of reducing the amount of memory used
	* by the mapping.
	*/
	if (bytes_obsolete * 100 / bytes_mapped >=
	- zfs_indirect_condense_obsolete_pct &&
	+ zfs_condense_indirect_obsolete_pct &&
	mapping_size > zfs_condense_min_mapping_bytes) {
	zfs_dbgmsg("should condense vdev %llu because obsolete "
	"spacemap covers %d%% of %lluMB mapping",
	(u_longlong_t)vd->vdev_id,
	(int)(bytes_obsolete * 100 / bytes_mapped),
	(u_longlong_t)bytes_mapped / 1024 / 1024);
	return (B_TRUE);
	}

	/*
	* If the obsolete space map takes up too much space on disk,
	* condense in order to free up this disk space.
	*/
	if (obsolete_sm_size >= zfs_condense_max_obsolete_bytes) {
	zfs_dbgmsg("should condense vdev %llu because obsolete sm "
	"length %lluMB >= max size %lluMB",
	(u_longlong_t)vd->vdev_id,
	(u_longlong_t)obsolete_sm_size / 1024 / 1024,
	(u_longlong_t)zfs_condense_max_obsolete_bytes /
	1024 / 1024);
	return (B_TRUE);
	}

	return (B_FALSE);
	}

	/*
	* This sync task completes (finishes) a condense, deleting the old
	* mapping and replacing it with the new one.
	*/
	static void
	spa_condense_indirect_complete_sync(void arg, dmu_tx_t tx)
	{
	spa_condensing_indirect_t *sci = arg;
	spa_t *spa = dmu_tx_pool(tx)->dp_spa;
	spa_condensing_indirect_phys_t *scip =
	&spa->spa_condensing_indirect_phys;
	vdev_t *vd = vdev_lookup_top(spa, scip->scip_vdev);
	vdev_indirect_config_t *vic = &vd->vdev_indirect_config;
	objset_t *mos = spa->spa_meta_objset;
	vdev_indirect_mapping_t *old_mapping = vd->vdev_indirect_mapping;
	uint64_t old_count = vdev_indirect_mapping_num_entries(old_mapping);
	uint64_t new_count =
	vdev_indirect_mapping_num_entries(sci->sci_new_mapping);

	ASSERT(dmu_tx_is_syncing(tx));
	ASSERT3P(vd->vdev_ops, ==, &vdev_indirect_ops);
	ASSERT3P(sci, ==, spa->spa_condensing_indirect);
	for (int i = 0; i < TXG_SIZE; i++) {
	ASSERT(list_is_empty(&sci->sci_new_mapping_entries[i]));
	}
	ASSERT(vic->vic_mapping_object != 0);
	ASSERT3U(vd->vdev_id, ==, scip->scip_vdev);
	ASSERT(scip->scip_next_mapping_object != 0);
	ASSERT(scip->scip_prev_obsolete_sm_object != 0);

	/*
	* Reset vdev_indirect_mapping to refer to the new object.
	*/
	rw_enter(&vd->vdev_indirect_rwlock, RW_WRITER);
	vdev_indirect_mapping_close(vd->vdev_indirect_mapping);
	vd->vdev_indirect_mapping = sci->sci_new_mapping;
	rw_exit(&vd->vdev_indirect_rwlock);

	sci->sci_new_mapping = NULL;
	vdev_indirect_mapping_free(mos, vic->vic_mapping_object, tx);
	vic->vic_mapping_object = scip->scip_next_mapping_object;
	scip->scip_next_mapping_object = 0;

	space_map_free_obj(mos, scip->scip_prev_obsolete_sm_object, tx);
	spa_feature_decr(spa, SPA_FEATURE_OBSOLETE_COUNTS, tx);
	scip->scip_prev_obsolete_sm_object = 0;

	scip->scip_vdev = 0;

	VERIFY0(zap_remove(mos, DMU_POOL_DIRECTORY_OBJECT,
	DMU_POOL_CONDENSING_INDIRECT, tx));
	spa_condensing_indirect_destroy(spa->spa_condensing_indirect);
	spa->spa_condensing_indirect = NULL;

	zfs_dbgmsg("finished condense of vdev %llu in txg %llu: "
	"new mapping object %llu has %llu entries "
	"(was %llu entries)",
	vd->vdev_id, dmu_tx_get_txg(tx), vic->vic_mapping_object,
	new_count, old_count);

	vdev_config_dirty(spa->spa_root_vdev);
	}

	/*
	* This sync task appends entries to the new mapping object.
	*/
	static void
	spa_condense_indirect_commit_sync(void arg, dmu_tx_t tx)
	{
	spa_condensing_indirect_t *sci = arg;
	uint64_t txg = dmu_tx_get_txg(tx);
	spa_t *spa __maybe_unused = dmu_tx_pool(tx)->dp_spa;

	ASSERT(dmu_tx_is_syncing(tx));
	ASSERT3P(sci, ==, spa->spa_condensing_indirect);

	vdev_indirect_mapping_add_entries(sci->sci_new_mapping,
	&sci->sci_new_mapping_entries[txg & TXG_MASK], tx);
	ASSERT(list_is_empty(&sci->sci_new_mapping_entries[txg & TXG_MASK]));
	}

	/*
	* Open-context function to add one entry to the new mapping. The new
	* entry will be remembered and written from syncing context.
	*/
	static void
	spa_condense_indirect_commit_entry(spa_t *spa,
	vdev_indirect_mapping_entry_phys_t *vimep, uint32_t count)
	{
	spa_condensing_indirect_t *sci = spa->spa_condensing_indirect;

	ASSERT3U(count, <, DVA_GET_ASIZE(&vimep->vimep_dst));

	dmu_tx_t *tx = dmu_tx_create_dd(spa_get_dsl(spa)->dp_mos_dir);
	dmu_tx_hold_space(tx, sizeof (*vimep) + sizeof (count));
	VERIFY0(dmu_tx_assign(tx, TXG_WAIT));
	int txgoff = dmu_tx_get_txg(tx) & TXG_MASK;

	/*
	* If we are the first entry committed this txg, kick off the sync
	* task to write to the MOS on our behalf.
	*/
	if (list_is_empty(&sci->sci_new_mapping_entries[txgoff])) {
	dsl_sync_task_nowait(dmu_tx_pool(tx),
	spa_condense_indirect_commit_sync, sci, tx);
	}

	vdev_indirect_mapping_entry_t *vime =
	kmem_alloc(sizeof (*vime), KM_SLEEP);
	vime->vime_mapping = *vimep;
	vime->vime_obsolete_count = count;
	list_insert_tail(&sci->sci_new_mapping_entries[txgoff], vime);

	dmu_tx_commit(tx);
	}

	static void
	spa_condense_indirect_generate_new_mapping(vdev_t *vd,
	uint32_t obsolete_counts, uint64_t start_index, zthr_t zthr)
	{
	spa_t *spa = vd->vdev_spa;
	uint64_t mapi = start_index;
	vdev_indirect_mapping_t *old_mapping = vd->vdev_indirect_mapping;
	uint64_t old_num_entries =
	vdev_indirect_mapping_num_entries(old_mapping);

	ASSERT3P(vd->vdev_ops, ==, &vdev_indirect_ops);
	ASSERT3U(vd->vdev_id, ==, spa->spa_condensing_indirect_phys.scip_vdev);

	zfs_dbgmsg("starting condense of vdev %llu from index %llu",
	(u_longlong_t)vd->vdev_id,
	(u_longlong_t)mapi);

	while (mapi < old_num_entries) {

	if (zthr_iscancelled(zthr)) {
	zfs_dbgmsg("pausing condense of vdev %llu "
	"at index %llu", (u_longlong_t)vd->vdev_id,
	(u_longlong_t)mapi);
	break;
	}

	vdev_indirect_mapping_entry_phys_t *entry =
	&old_mapping->vim_entries[mapi];
	uint64_t entry_size = DVA_GET_ASIZE(&entry->vimep_dst);
	ASSERT3U(obsolete_counts[mapi], <=, entry_size);
	if (obsolete_counts[mapi] < entry_size) {
	spa_condense_indirect_commit_entry(spa, entry,
	obsolete_counts[mapi]);

	/*
	* This delay may be requested for testing, debugging,
	* or performance reasons.
	*/
	hrtime_t now = gethrtime();
	hrtime_t sleep_until = now + MSEC2NSEC(
	zfs_condense_indirect_commit_entry_delay_ms);
	zfs_sleep_until(sleep_until);
	}

	mapi++;
	}
	}

	/* ARGSUSED */
	static boolean_t
	spa_condense_indirect_thread_check(void arg, zthr_t zthr)
	{
	spa_t *spa = arg;

	return (spa->spa_condensing_indirect != NULL);
	}

	/* ARGSUSED */
	static void
	spa_condense_indirect_thread(void arg, zthr_t zthr)
	{
	spa_t *spa = arg;
	vdev_t *vd;

	ASSERT3P(spa->spa_condensing_indirect, !=, NULL);
	spa_config_enter(spa, SCL_VDEV, FTAG, RW_READER);
	vd = vdev_lookup_top(spa, spa->spa_condensing_indirect_phys.scip_vdev);
	ASSERT3P(vd, !=, NULL);
	spa_config_exit(spa, SCL_VDEV, FTAG);

	spa_condensing_indirect_t *sci = spa->spa_condensing_indirect;
	spa_condensing_indirect_phys_t *scip =
	&spa->spa_condensing_indirect_phys;
	uint32_t *counts;
	uint64_t start_index;
	vdev_indirect_mapping_t *old_mapping = vd->vdev_indirect_mapping;
	space_map_t *prev_obsolete_sm = NULL;

	ASSERT3U(vd->vdev_id, ==, scip->scip_vdev);
	ASSERT(scip->scip_next_mapping_object != 0);
	ASSERT(scip->scip_prev_obsolete_sm_object != 0);
	ASSERT3P(vd->vdev_ops, ==, &vdev_indirect_ops);

	for (int i = 0; i < TXG_SIZE; i++) {
	/*
	* The list must start out empty in order for the
	* _commit_sync() sync task to be properly registered
	* on the first call to _commit_entry(); so it's wise
	* to double check and ensure we actually are starting
	* with empty lists.
	*/
	ASSERT(list_is_empty(&sci->sci_new_mapping_entries[i]));
	}

	VERIFY0(space_map_open(&prev_obsolete_sm, spa->spa_meta_objset,
	scip->scip_prev_obsolete_sm_object, 0, vd->vdev_asize, 0));
	counts = vdev_indirect_mapping_load_obsolete_counts(old_mapping);
	if (prev_obsolete_sm != NULL) {
	vdev_indirect_mapping_load_obsolete_spacemap(old_mapping,
	counts, prev_obsolete_sm);
	}
	space_map_close(prev_obsolete_sm);

	/*
	* Generate new mapping. Determine what index to continue from
	* based on the max offset that we've already written in the
	* new mapping.
	*/
	uint64_t max_offset =
	vdev_indirect_mapping_max_offset(sci->sci_new_mapping);
	if (max_offset == 0) {
	/* We haven't written anything to the new mapping yet. */
	start_index = 0;
	} else {
	/*
	* Pick up from where we left off. _entry_for_offset()
	* returns a pointer into the vim_entries array. If
	* max_offset is greater than any of the mappings
	* contained in the table NULL will be returned and
	* that indicates we've exhausted our iteration of the
	* old_mapping.
	*/

	vdev_indirect_mapping_entry_phys_t *entry =
	vdev_indirect_mapping_entry_for_offset_or_next(old_mapping,
	max_offset);

	if (entry == NULL) {
	/*
	* We've already written the whole new mapping.
	* This special value will cause us to skip the
	* generate_new_mapping step and just do the sync
	* task to complete the condense.
	*/
	start_index = UINT64_MAX;
	} else {
	start_index = entry - old_mapping->vim_entries;
	ASSERT3U(start_index, <,
	vdev_indirect_mapping_num_entries(old_mapping));
	}
	}

	spa_condense_indirect_generate_new_mapping(vd, counts,
	start_index, zthr);

	vdev_indirect_mapping_free_obsolete_counts(old_mapping, counts);

	/*
	* If the zthr has received a cancellation signal while running
	* in generate_new_mapping() or at any point after that, then bail
	* early. We don't want to complete the condense if the spa is
	* shutting down.
	*/
	if (zthr_iscancelled(zthr))
	return;

	VERIFY0(dsl_sync_task(spa_name(spa), NULL,
	spa_condense_indirect_complete_sync, sci, 0,
	ZFS_SPACE_CHECK_EXTRA_RESERVED));
	}

	/*
	* Sync task to begin the condensing process.
	*/
	void
	spa_condense_indirect_start_sync(vdev_t vd, dmu_tx_t tx)
	{
	spa_t *spa = vd->vdev_spa;
	spa_condensing_indirect_phys_t *scip =
	&spa->spa_condensing_indirect_phys;

	ASSERT0(scip->scip_next_mapping_object);
	ASSERT0(scip->scip_prev_obsolete_sm_object);
	ASSERT0(scip->scip_vdev);
	ASSERT(dmu_tx_is_syncing(tx));
	ASSERT3P(vd->vdev_ops, ==, &vdev_indirect_ops);
	ASSERT(spa_feature_is_active(spa, SPA_FEATURE_OBSOLETE_COUNTS));
	ASSERT(vdev_indirect_mapping_num_entries(vd->vdev_indirect_mapping));

	uint64_t obsolete_sm_obj;
	VERIFY0(vdev_obsolete_sm_object(vd, &obsolete_sm_obj));
	ASSERT3U(obsolete_sm_obj, !=, 0);

	scip->scip_vdev = vd->vdev_id;
	scip->scip_next_mapping_object =
	vdev_indirect_mapping_alloc(spa->spa_meta_objset, tx);

	scip->scip_prev_obsolete_sm_object = obsolete_sm_obj;

	/*
	* We don't need to allocate a new space map object, since
	* vdev_indirect_sync_obsolete will allocate one when needed.
	*/
	space_map_close(vd->vdev_obsolete_sm);
	vd->vdev_obsolete_sm = NULL;
	VERIFY0(zap_remove(spa->spa_meta_objset, vd->vdev_top_zap,
	VDEV_TOP_ZAP_INDIRECT_OBSOLETE_SM, tx));

	VERIFY0(zap_add(spa->spa_dsl_pool->dp_meta_objset,
	DMU_POOL_DIRECTORY_OBJECT,
	DMU_POOL_CONDENSING_INDIRECT, sizeof (uint64_t),
	sizeof (*scip) / sizeof (uint64_t), scip, tx));

	ASSERT3P(spa->spa_condensing_indirect, ==, NULL);
	spa->spa_condensing_indirect = spa_condensing_indirect_create(spa);

	zfs_dbgmsg("starting condense of vdev %llu in txg %llu: "
	"posm=%llu nm=%llu",
	vd->vdev_id, dmu_tx_get_txg(tx),
	(u_longlong_t)scip->scip_prev_obsolete_sm_object,
	(u_longlong_t)scip->scip_next_mapping_object);

	zthr_wakeup(spa->spa_condense_zthr);
	}

	/*
	* Sync to the given vdev's obsolete space map any segments that are no longer
	* referenced as of the given txg.
	*
	* If the obsolete space map doesn't exist yet, create and open it.
	*/
	void
	vdev_indirect_sync_obsolete(vdev_t vd, dmu_tx_t tx)
	{
	spa_t *spa = vd->vdev_spa;
	vdev_indirect_config_t *vic __maybe_unused = &vd->vdev_indirect_config;

	ASSERT3U(vic->vic_mapping_object, !=, 0);
	ASSERT(range_tree_space(vd->vdev_obsolete_segments) > 0);
	ASSERT(vd->vdev_removing \|\| vd->vdev_ops == &vdev_indirect_ops);
	ASSERT(spa_feature_is_enabled(spa, SPA_FEATURE_OBSOLETE_COUNTS));

	uint64_t obsolete_sm_object;
	VERIFY0(vdev_obsolete_sm_object(vd, &obsolete_sm_object));
	if (obsolete_sm_object == 0) {
	obsolete_sm_object = space_map_alloc(spa->spa_meta_objset,
	zfs_vdev_standard_sm_blksz, tx);

	ASSERT(vd->vdev_top_zap != 0);
	VERIFY0(zap_add(vd->vdev_spa->spa_meta_objset, vd->vdev_top_zap,
	VDEV_TOP_ZAP_INDIRECT_OBSOLETE_SM,
	sizeof (obsolete_sm_object), 1, &obsolete_sm_object, tx));
	ASSERT0(vdev_obsolete_sm_object(vd, &obsolete_sm_object));
	ASSERT3U(obsolete_sm_object, !=, 0);

	spa_feature_incr(spa, SPA_FEATURE_OBSOLETE_COUNTS, tx);
	VERIFY0(space_map_open(&vd->vdev_obsolete_sm,
	spa->spa_meta_objset, obsolete_sm_object,
	0, vd->vdev_asize, 0));
	}

	ASSERT(vd->vdev_obsolete_sm != NULL);
	ASSERT3U(obsolete_sm_object, ==,
	space_map_object(vd->vdev_obsolete_sm));

	space_map_write(vd->vdev_obsolete_sm,
	vd->vdev_obsolete_segments, SM_ALLOC, SM_NO_VDEVID, tx);
	range_tree_vacate(vd->vdev_obsolete_segments, NULL, NULL);
	}

	int
	spa_condense_init(spa_t *spa)
	{
	int error = zap_lookup(spa->spa_meta_objset,
	DMU_POOL_DIRECTORY_OBJECT,
	DMU_POOL_CONDENSING_INDIRECT, sizeof (uint64_t),
	sizeof (spa->spa_condensing_indirect_phys) / sizeof (uint64_t),
	&spa->spa_condensing_indirect_phys);
	if (error == 0) {
	if (spa_writeable(spa)) {
	spa->spa_condensing_indirect =
	spa_condensing_indirect_create(spa);
	}
	return (0);
	} else if (error == ENOENT) {
	return (0);
	} else {
	return (error);
	}
	}

	void
	spa_condense_fini(spa_t *spa)
	{
	if (spa->spa_condensing_indirect != NULL) {
	spa_condensing_indirect_destroy(spa->spa_condensing_indirect);
	spa->spa_condensing_indirect = NULL;
	}
	}

	void
	spa_start_indirect_condensing_thread(spa_t *spa)
	{
	ASSERT3P(spa->spa_condense_zthr, ==, NULL);
	spa->spa_condense_zthr = zthr_create("z_indirect_condense",
	spa_condense_indirect_thread_check,
	spa_condense_indirect_thread, spa);
	}

	/*
	* Gets the obsolete spacemap object from the vdev's ZAP. On success sm_obj
	* will contain either the obsolete spacemap object or zero if none exists.
	* All other errors are returned to the caller.
	*/
	int
	vdev_obsolete_sm_object(vdev_t vd, uint64_t sm_obj)
	{
	ASSERT0(spa_config_held(vd->vdev_spa, SCL_ALL, RW_WRITER));

	if (vd->vdev_top_zap == 0) {
	*sm_obj = 0;
	return (0);
	}

	int error = zap_lookup(vd->vdev_spa->spa_meta_objset, vd->vdev_top_zap,
	VDEV_TOP_ZAP_INDIRECT_OBSOLETE_SM, sizeof (uint64_t), 1, sm_obj);
	if (error == ENOENT) {
	*sm_obj = 0;
	error = 0;
	}

	return (error);
	}

	/*
	* Gets the obsolete count are precise spacemap object from the vdev's ZAP.
	* On success are_precise will be set to reflect if the counts are precise.
	* All other errors are returned to the caller.
	*/
	int
	vdev_obsolete_counts_are_precise(vdev_t vd, boolean_t are_precise)
	{
	ASSERT0(spa_config_held(vd->vdev_spa, SCL_ALL, RW_WRITER));

	if (vd->vdev_top_zap == 0) {
	*are_precise = B_FALSE;
	return (0);
	}

	uint64_t val = 0;
	int error = zap_lookup(vd->vdev_spa->spa_meta_objset, vd->vdev_top_zap,
	VDEV_TOP_ZAP_OBSOLETE_COUNTS_ARE_PRECISE, sizeof (val), 1, &val);
	if (error == 0) {
	*are_precise = (val != 0);
	} else if (error == ENOENT) {
	*are_precise = B_FALSE;
	error = 0;
	}

	return (error);
	}

	/* ARGSUSED */
	static void
	vdev_indirect_close(vdev_t *vd)
	{
	}

	/* ARGSUSED */
	static int
	vdev_indirect_open(vdev_t vd, uint64_t psize, uint64_t *max_psize,
	uint64_t logical_ashift, uint64_t physical_ashift)
	{
	psize = max_psize = vd->vdev_asize +
	VDEV_LABEL_START_SIZE + VDEV_LABEL_END_SIZE;
	*logical_ashift = vd->vdev_ashift;
	*physical_ashift = vd->vdev_physical_ashift;
	return (0);
	}

	typedef struct remap_segment {
	vdev_t *rs_vd;
	uint64_t rs_offset;
	uint64_t rs_asize;
	uint64_t rs_split_offset;
	list_node_t rs_node;
	} remap_segment_t;

	static remap_segment_t *
	rs_alloc(vdev_t *vd, uint64_t offset, uint64_t asize, uint64_t split_offset)
	{
	remap_segment_t *rs = kmem_alloc(sizeof (remap_segment_t), KM_SLEEP);
	rs->rs_vd = vd;
	rs->rs_offset = offset;
	rs->rs_asize = asize;
	rs->rs_split_offset = split_offset;
	return (rs);
	}

	/*
	* Given an indirect vdev and an extent on that vdev, it duplicates the
	* physical entries of the indirect mapping that correspond to the extent
	* to a new array and returns a pointer to it. In addition, copied_entries
	* is populated with the number of mapping entries that were duplicated.
	*
	* Note that the function assumes that the caller holds vdev_indirect_rwlock.
	* This ensures that the mapping won't change due to condensing as we
	* copy over its contents.
	*
	* Finally, since we are doing an allocation, it is up to the caller to
	* free the array allocated in this function.
	*/
	static vdev_indirect_mapping_entry_phys_t *
	vdev_indirect_mapping_duplicate_adjacent_entries(vdev_t *vd, uint64_t offset,
	uint64_t asize, uint64_t *copied_entries)
	{
	vdev_indirect_mapping_entry_phys_t *duplicate_mappings = NULL;
	vdev_indirect_mapping_t *vim = vd->vdev_indirect_mapping;
	uint64_t entries = 0;

	ASSERT(RW_READ_HELD(&vd->vdev_indirect_rwlock));

	vdev_indirect_mapping_entry_phys_t *first_mapping =
	vdev_indirect_mapping_entry_for_offset(vim, offset);
	ASSERT3P(first_mapping, !=, NULL);

	vdev_indirect_mapping_entry_phys_t *m = first_mapping;
	while (asize > 0) {
	uint64_t size = DVA_GET_ASIZE(&m->vimep_dst);

	ASSERT3U(offset, >=, DVA_MAPPING_GET_SRC_OFFSET(m));
	ASSERT3U(offset, <, DVA_MAPPING_GET_SRC_OFFSET(m) + size);

	uint64_t inner_offset = offset - DVA_MAPPING_GET_SRC_OFFSET(m);
	uint64_t inner_size = MIN(asize, size - inner_offset);

	offset += inner_size;
	asize -= inner_size;
	entries++;
	m++;
	}

	size_t copy_length = entries * sizeof (*first_mapping);
	duplicate_mappings = kmem_alloc(copy_length, KM_SLEEP);
	bcopy(first_mapping, duplicate_mappings, copy_length);
	*copied_entries = entries;

	return (duplicate_mappings);
	}

	/*
	* Goes through the relevant indirect mappings until it hits a concrete vdev
	* and issues the callback. On the way to the concrete vdev, if any other
	* indirect vdevs are encountered, then the callback will also be called on
	* each of those indirect vdevs. For example, if the segment is mapped to
	* segment A on indirect vdev 1, and then segment A on indirect vdev 1 is
	* mapped to segment B on concrete vdev 2, then the callback will be called on
	* both vdev 1 and vdev 2.
	*
	* While the callback passed to vdev_indirect_remap() is called on every vdev
	* the function encounters, certain callbacks only care about concrete vdevs.
	* These types of callbacks should return immediately and explicitly when they
	* are called on an indirect vdev.
	*
	* Because there is a possibility that a DVA section in the indirect device
	* has been split into multiple sections in our mapping, we keep track
	* of the relevant contiguous segments of the new location (remap_segment_t)
	* in a stack. This way we can call the callback for each of the new sections
	* created by a single section of the indirect device. Note though, that in
	* this scenario the callbacks in each split block won't occur in-order in
	* terms of offset, so callers should not make any assumptions about that.
	*
	* For callbacks that don't handle split blocks and immediately return when
	* they encounter them (as is the case for remap_blkptr_cb), the caller can
	* assume that its callback will be applied from the first indirect vdev
	* encountered to the last one and then the concrete vdev, in that order.
	*/
	static void
	vdev_indirect_remap(vdev_t *vd, uint64_t offset, uint64_t asize,
	void (func)(uint64_t, vdev_t , uint64_t, uint64_t, void ), void arg)
	{
	list_t stack;
	spa_t *spa = vd->vdev_spa;

	list_create(&stack, sizeof (remap_segment_t),
	offsetof(remap_segment_t, rs_node));

	for (remap_segment_t *rs = rs_alloc(vd, offset, asize, 0);
	rs != NULL; rs = list_remove_head(&stack)) {
	vdev_t *v = rs->rs_vd;
	uint64_t num_entries = 0;

	ASSERT(spa_config_held(spa, SCL_ALL, RW_READER) != 0);
	ASSERT(rs->rs_asize > 0);

	/*
	* Note: As this function can be called from open context
	* (e.g. zio_read()), we need the following rwlock to
	* prevent the mapping from being changed by condensing.
	*
	* So we grab the lock and we make a copy of the entries
	* that are relevant to the extent that we are working on.
	* Once that is done, we drop the lock and iterate over
	* our copy of the mapping. Once we are done with the with
	* the remap segment and we free it, we also free our copy
	* of the indirect mapping entries that are relevant to it.
	*
	* This way we don't need to wait until the function is
	* finished with a segment, to condense it. In addition, we
	* don't need a recursive rwlock for the case that a call to
	* vdev_indirect_remap() needs to call itself (through the
	* codepath of its callback) for the same vdev in the middle
	* of its execution.
	*/
	rw_enter(&v->vdev_indirect_rwlock, RW_READER);
	ASSERT3P(v->vdev_indirect_mapping, !=, NULL);

	vdev_indirect_mapping_entry_phys_t *mapping =
	vdev_indirect_mapping_duplicate_adjacent_entries(v,
	rs->rs_offset, rs->rs_asize, &num_entries);
	ASSERT3P(mapping, !=, NULL);
	ASSERT3U(num_entries, >, 0);
	rw_exit(&v->vdev_indirect_rwlock);

	for (uint64_t i = 0; i < num_entries; i++) {
	/*
	* Note: the vdev_indirect_mapping can not change
	* while we are running. It only changes while the
	* removal is in progress, and then only from syncing
	* context. While a removal is in progress, this
	* function is only called for frees, which also only
	* happen from syncing context.
	*/
	vdev_indirect_mapping_entry_phys_t *m = &mapping[i];

	ASSERT3P(m, !=, NULL);
	ASSERT3U(rs->rs_asize, >, 0);

	uint64_t size = DVA_GET_ASIZE(&m->vimep_dst);
	uint64_t dst_offset = DVA_GET_OFFSET(&m->vimep_dst);
	uint64_t dst_vdev = DVA_GET_VDEV(&m->vimep_dst);

	ASSERT3U(rs->rs_offset, >=,
	DVA_MAPPING_GET_SRC_OFFSET(m));
	ASSERT3U(rs->rs_offset, <,
	DVA_MAPPING_GET_SRC_OFFSET(m) + size);
	ASSERT3U(dst_vdev, !=, v->vdev_id);

	uint64_t inner_offset = rs->rs_offset -
	DVA_MAPPING_GET_SRC_OFFSET(m);
	uint64_t inner_size =
	MIN(rs->rs_asize, size - inner_offset);

	vdev_t *dst_v = vdev_lookup_top(spa, dst_vdev);
	ASSERT3P(dst_v, !=, NULL);

	if (dst_v->vdev_ops == &vdev_indirect_ops) {
	list_insert_head(&stack,
	rs_alloc(dst_v, dst_offset + inner_offset,
	inner_size, rs->rs_split_offset));

	}

	if ((zfs_flags & ZFS_DEBUG_INDIRECT_REMAP) &&
	IS_P2ALIGNED(inner_size, 2 * SPA_MINBLOCKSIZE)) {
	/*
	* Note: This clause exists only solely for
	* testing purposes. We use it to ensure that
	* split blocks work and that the callbacks
	* using them yield the same result if issued
	* in reverse order.
	*/
	uint64_t inner_half = inner_size / 2;

	func(rs->rs_split_offset + inner_half, dst_v,
	dst_offset + inner_offset + inner_half,
	inner_half, arg);

	func(rs->rs_split_offset, dst_v,
	dst_offset + inner_offset,
	inner_half, arg);
	} else {
	func(rs->rs_split_offset, dst_v,
	dst_offset + inner_offset,
	inner_size, arg);
	}

	rs->rs_offset += inner_size;
	rs->rs_asize -= inner_size;
	rs->rs_split_offset += inner_size;
	}
	VERIFY0(rs->rs_asize);

	kmem_free(mapping, num_entries * sizeof (*mapping));
	kmem_free(rs, sizeof (remap_segment_t));
	}
	list_destroy(&stack);
	}

	static void
	vdev_indirect_child_io_done(zio_t *zio)
	{
	zio_t *pio = zio->io_private;

	mutex_enter(&pio->io_lock);
	pio->io_error = zio_worst_error(pio->io_error, zio->io_error);
	mutex_exit(&pio->io_lock);

	abd_free(zio->io_abd);
	}

	/*
	* This is a callback for vdev_indirect_remap() which allocates an
	* indirect_split_t for each split segment and adds it to iv_splits.
	*/
	static void
	vdev_indirect_gather_splits(uint64_t split_offset, vdev_t *vd, uint64_t offset,
	uint64_t size, void *arg)
	{
	zio_t *zio = arg;
	indirect_vsd_t *iv = zio->io_vsd;

	ASSERT3P(vd, !=, NULL);

	if (vd->vdev_ops == &vdev_indirect_ops)
	return;

	int n = 1;
	if (vd->vdev_ops == &vdev_mirror_ops)
	n = vd->vdev_children;

	indirect_split_t *is =
	kmem_zalloc(offsetof(indirect_split_t, is_child[n]), KM_SLEEP);

	is->is_children = n;
	is->is_size = size;
	is->is_split_offset = split_offset;
	is->is_target_offset = offset;
	is->is_vdev = vd;
	list_create(&is->is_unique_child, sizeof (indirect_child_t),
	offsetof(indirect_child_t, ic_node));

	/*
	* Note that we only consider multiple copies of the data for
	* mirror vdevs. We don't for "replacing" or "spare" vdevs, even
	* though they use the same ops as mirror, because there's only one
	* "good" copy under the replacing/spare.
	*/
	if (vd->vdev_ops == &vdev_mirror_ops) {
	for (int i = 0; i < n; i++) {
	is->is_child[i].ic_vdev = vd->vdev_child[i];
	list_link_init(&is->is_child[i].ic_node);
	}
	} else {
	is->is_child[0].ic_vdev = vd;
	}

	list_insert_tail(&iv->iv_splits, is);
	}

	static void
	vdev_indirect_read_split_done(zio_t *zio)
	{
	indirect_child_t *ic = zio->io_private;

	if (zio->io_error != 0) {
	/*
	* Clear ic_data to indicate that we do not have data for this
	* child.
	*/
	abd_free(ic->ic_data);
	ic->ic_data = NULL;
	}
	}

	/*
	* Issue reads for all copies (mirror children) of all splits.
	*/
	static void
	vdev_indirect_read_all(zio_t *zio)
	{
	indirect_vsd_t *iv = zio->io_vsd;

	ASSERT3U(zio->io_type, ==, ZIO_TYPE_READ);

	for (indirect_split_t *is = list_head(&iv->iv_splits);
	is != NULL; is = list_next(&iv->iv_splits, is)) {
	for (int i = 0; i < is->is_children; i++) {
	indirect_child_t *ic = &is->is_child[i];

	if (!vdev_readable(ic->ic_vdev))
	continue;

	/*
	* If a child is missing the data, set ic_error. Used
	* in vdev_indirect_repair(). We perform the read
	* nevertheless which provides the opportunity to
	* reconstruct the split block if at all possible.
	*/
	if (vdev_dtl_contains(ic->ic_vdev, DTL_MISSING,
	zio->io_txg, 1))
	ic->ic_error = SET_ERROR(ESTALE);

	ic->ic_data = abd_alloc_sametype(zio->io_abd,
	is->is_size);
	ic->ic_duplicate = NULL;

	zio_nowait(zio_vdev_child_io(zio, NULL,
	ic->ic_vdev, is->is_target_offset, ic->ic_data,
	is->is_size, zio->io_type, zio->io_priority, 0,
	vdev_indirect_read_split_done, ic));
	}
	}
	iv->iv_reconstruct = B_TRUE;
	}

	static void
	vdev_indirect_io_start(zio_t *zio)
	{
	spa_t *spa __maybe_unused = zio->io_spa;
	indirect_vsd_t iv = kmem_zalloc(sizeof (iv), KM_SLEEP);
	list_create(&iv->iv_splits,
	sizeof (indirect_split_t), offsetof(indirect_split_t, is_node));

	zio->io_vsd = iv;
	zio->io_vsd_ops = &vdev_indirect_vsd_ops;

	ASSERT(spa_config_held(spa, SCL_ALL, RW_READER) != 0);
	if (zio->io_type != ZIO_TYPE_READ) {
	ASSERT3U(zio->io_type, ==, ZIO_TYPE_WRITE);
	/*
	* Note: this code can handle other kinds of writes,
	* but we don't expect them.
	*/
	ASSERT((zio->io_flags & (ZIO_FLAG_SELF_HEAL \|
	ZIO_FLAG_RESILVER \| ZIO_FLAG_INDUCE_DAMAGE)) != 0);
	}

	vdev_indirect_remap(zio->io_vd, zio->io_offset, zio->io_size,
	vdev_indirect_gather_splits, zio);

	indirect_split_t *first = list_head(&iv->iv_splits);
	if (first->is_size == zio->io_size) {
	/*
	* This is not a split block; we are pointing to the entire
	* data, which will checksum the same as the original data.
	* Pass the BP down so that the child i/o can verify the
	* checksum, and try a different location if available
	* (e.g. on a mirror).
	*
	* While this special case could be handled the same as the
	* general (split block) case, doing it this way ensures
	* that the vast majority of blocks on indirect vdevs
	* (which are not split) are handled identically to blocks
	* on non-indirect vdevs. This allows us to be less strict
	* about performance in the general (but rare) case.
	*/
	ASSERT0(first->is_split_offset);
	ASSERT3P(list_next(&iv->iv_splits, first), ==, NULL);
	zio_nowait(zio_vdev_child_io(zio, zio->io_bp,
	first->is_vdev, first->is_target_offset,
	abd_get_offset(zio->io_abd, 0),
	zio->io_size, zio->io_type, zio->io_priority, 0,
	vdev_indirect_child_io_done, zio));
	} else {
	iv->iv_split_block = B_TRUE;
	if (zio->io_type == ZIO_TYPE_READ &&
	zio->io_flags & (ZIO_FLAG_SCRUB \| ZIO_FLAG_RESILVER)) {
	/*
	* Read all copies. Note that for simplicity,
	* we don't bother consulting the DTL in the
	* resilver case.
	*/
	vdev_indirect_read_all(zio);
	} else {
	/*
	* If this is a read zio, we read one copy of each
	* split segment, from the top-level vdev. Since
	* we don't know the checksum of each split
	* individually, the child zio can't ensure that
	* we get the right data. E.g. if it's a mirror,
	* it will just read from a random (healthy) leaf
	* vdev. We have to verify the checksum in
	* vdev_indirect_io_done().
	*
	* For write zios, the vdev code will ensure we write
	* to all children.
	*/
	for (indirect_split_t *is = list_head(&iv->iv_splits);
	is != NULL; is = list_next(&iv->iv_splits, is)) {
	zio_nowait(zio_vdev_child_io(zio, NULL,
	is->is_vdev, is->is_target_offset,
	abd_get_offset(zio->io_abd,
	is->is_split_offset), is->is_size,
	zio->io_type, zio->io_priority, 0,
	vdev_indirect_child_io_done, zio));
	}

	}
	}

	zio_execute(zio);
	}

	/*
	* Report a checksum error for a child.
	*/
	static void
	vdev_indirect_checksum_error(zio_t *zio,
	indirect_split_t is, indirect_child_t ic)
	{
	vdev_t *vd = ic->ic_vdev;

	if (zio->io_flags & ZIO_FLAG_SPECULATIVE)
	return;

	mutex_enter(&vd->vdev_stat_lock);
	vd->vdev_stat.vs_checksum_errors++;
	mutex_exit(&vd->vdev_stat_lock);

	zio_bad_cksum_t zbc = {{{ 0 }}};
	abd_t *bad_abd = ic->ic_data;
	abd_t *good_abd = is->is_good_child->ic_data;
	(void) zfs_ereport_post_checksum(zio->io_spa, vd, NULL, zio,
	is->is_target_offset, is->is_size, good_abd, bad_abd, &zbc);
	}

	/*
	* Issue repair i/os for any incorrect copies. We do this by comparing
	* each split segment's correct data (is_good_child's ic_data) with each
	* other copy of the data. If they differ, then we overwrite the bad data
	* with the good copy. The DTL is checked in vdev_indirect_read_all() and
	* if a vdev is missing a copy of the data we set ic_error and the read is
	* performed. This provides the opportunity to reconstruct the split block
	* if at all possible. ic_error is checked here and if set it suppresses
	* incrementing the checksum counter. Aside from this DTLs are not checked,
	* which simplifies this code and also issues the optimal number of writes
	* (based on which copies actually read bad data, as opposed to which we
	* think might be wrong). For the same reason, we always use
	* ZIO_FLAG_SELF_HEAL, to bypass the DTL check in zio_vdev_io_start().
	*/
	static void
	vdev_indirect_repair(zio_t *zio)
	{
	indirect_vsd_t *iv = zio->io_vsd;

	enum zio_flag flags = ZIO_FLAG_IO_REPAIR;

	if (!(zio->io_flags & (ZIO_FLAG_SCRUB \| ZIO_FLAG_RESILVER)))
	flags \|= ZIO_FLAG_SELF_HEAL;

	if (!spa_writeable(zio->io_spa))
	return;

	for (indirect_split_t *is = list_head(&iv->iv_splits);
	is != NULL; is = list_next(&iv->iv_splits, is)) {
	for (int c = 0; c < is->is_children; c++) {
	indirect_child_t *ic = &is->is_child[c];
	if (ic == is->is_good_child)
	continue;
	if (ic->ic_data == NULL)
	continue;
	if (ic->ic_duplicate == is->is_good_child)
	continue;

	zio_nowait(zio_vdev_child_io(zio, NULL,
	ic->ic_vdev, is->is_target_offset,
	is->is_good_child->ic_data, is->is_size,
	ZIO_TYPE_WRITE, ZIO_PRIORITY_ASYNC_WRITE,
	ZIO_FLAG_IO_REPAIR \| ZIO_FLAG_SELF_HEAL,
	NULL, NULL));

	/*
	* If ic_error is set the current child does not have
	* a copy of the data, so suppress incrementing the
	* checksum counter.
	*/
	if (ic->ic_error == ESTALE)
	continue;

	vdev_indirect_checksum_error(zio, is, ic);
	}
	}
	}

	/*
	* Report checksum errors on all children that we read from.
	*/
	static void
	vdev_indirect_all_checksum_errors(zio_t *zio)
	{
	indirect_vsd_t *iv = zio->io_vsd;

	if (zio->io_flags & ZIO_FLAG_SPECULATIVE)
	return;

	for (indirect_split_t *is = list_head(&iv->iv_splits);
	is != NULL; is = list_next(&iv->iv_splits, is)) {
	for (int c = 0; c < is->is_children; c++) {
	indirect_child_t *ic = &is->is_child[c];

	if (ic->ic_data == NULL)
	continue;

	vdev_t *vd = ic->ic_vdev;

	(void) zfs_ereport_post_checksum(zio->io_spa, vd,
	NULL, zio, is->is_target_offset, is->is_size,
	NULL, NULL, NULL);
	mutex_enter(&vd->vdev_stat_lock);
	vd->vdev_stat.vs_checksum_errors++;
	mutex_exit(&vd->vdev_stat_lock);
	}
	}
	}

	/*
	* Copy data from all the splits to a main zio then validate the checksum.
	* If then checksum is successfully validated return success.
	*/
	static int
	vdev_indirect_splits_checksum_validate(indirect_vsd_t iv, zio_t zio)
	{
	zio_bad_cksum_t zbc;

	for (indirect_split_t *is = list_head(&iv->iv_splits);
	is != NULL; is = list_next(&iv->iv_splits, is)) {

	ASSERT3P(is->is_good_child->ic_data, !=, NULL);
	ASSERT3P(is->is_good_child->ic_duplicate, ==, NULL);

	abd_copy_off(zio->io_abd, is->is_good_child->ic_data,
	is->is_split_offset, 0, is->is_size);
	}

	return (zio_checksum_error(zio, &zbc));
	}

	/*
	* There are relatively few possible combinations making it feasible to
	* deterministically check them all. We do this by setting the good_child
	* to the next unique split version. If we reach the end of the list then
	* "carry over" to the next unique split version (like counting in base
	* is_unique_children, but each digit can have a different base).
	*/
	static int
	vdev_indirect_splits_enumerate_all(indirect_vsd_t iv, zio_t zio)
	{
	boolean_t more = B_TRUE;

	iv->iv_attempts = 0;

	for (indirect_split_t *is = list_head(&iv->iv_splits);
	is != NULL; is = list_next(&iv->iv_splits, is))
	is->is_good_child = list_head(&is->is_unique_child);

	while (more == B_TRUE) {
	iv->iv_attempts++;
	more = B_FALSE;

	if (vdev_indirect_splits_checksum_validate(iv, zio) == 0)
	return (0);

	for (indirect_split_t *is = list_head(&iv->iv_splits);
	is != NULL; is = list_next(&iv->iv_splits, is)) {
	is->is_good_child = list_next(&is->is_unique_child,
	is->is_good_child);
	if (is->is_good_child != NULL) {
	more = B_TRUE;
	break;
	}

	is->is_good_child = list_head(&is->is_unique_child);
	}
	}

	ASSERT3S(iv->iv_attempts, <=, iv->iv_unique_combinations);

	return (SET_ERROR(ECKSUM));
	}

	/*
	* There are too many combinations to try all of them in a reasonable amount
	* of time. So try a fixed number of random combinations from the unique
	* split versions, after which we'll consider the block unrecoverable.
	*/
	static int
	vdev_indirect_splits_enumerate_randomly(indirect_vsd_t iv, zio_t zio)
	{
	iv->iv_attempts = 0;

	while (iv->iv_attempts < iv->iv_attempts_max) {
	iv->iv_attempts++;

	for (indirect_split_t *is = list_head(&iv->iv_splits);
	is != NULL; is = list_next(&iv->iv_splits, is)) {
	indirect_child_t *ic = list_head(&is->is_unique_child);
	int children = is->is_unique_children;

	for (int i = spa_get_random(children); i > 0; i--)
	ic = list_next(&is->is_unique_child, ic);

	ASSERT3P(ic, !=, NULL);
	is->is_good_child = ic;
	}

	if (vdev_indirect_splits_checksum_validate(iv, zio) == 0)
	return (0);
	}

	return (SET_ERROR(ECKSUM));
	}

	/*
	* This is a validation function for reconstruction. It randomly selects
	* a good combination, if one can be found, and then it intentionally
	* damages all other segment copes by zeroing them. This forces the
	* reconstruction algorithm to locate the one remaining known good copy.
	*/
	static int
	vdev_indirect_splits_damage(indirect_vsd_t iv, zio_t zio)
	{
	int error;

	/* Presume all the copies are unique for initial selection. */
	for (indirect_split_t *is = list_head(&iv->iv_splits);
	is != NULL; is = list_next(&iv->iv_splits, is)) {
	is->is_unique_children = 0;

	for (int i = 0; i < is->is_children; i++) {
	indirect_child_t *ic = &is->is_child[i];
	if (ic->ic_data != NULL) {
	is->is_unique_children++;
	list_insert_tail(&is->is_unique_child, ic);
	}
	}

	if (list_is_empty(&is->is_unique_child)) {
	error = SET_ERROR(EIO);
	goto out;
	}
	}

	/*
	* Set each is_good_child to a randomly-selected child which
	* is known to contain validated data.
	*/
	error = vdev_indirect_splits_enumerate_randomly(iv, zio);
	if (error)
	goto out;

	/*
	* Damage all but the known good copy by zeroing it. This will
	* result in two or less unique copies per indirect_child_t.
	* Both may need to be checked in order to reconstruct the block.
	* Set iv->iv_attempts_max such that all unique combinations will
	* enumerated, but limit the damage to at most 12 indirect splits.
	*/
	iv->iv_attempts_max = 1;

	for (indirect_split_t *is = list_head(&iv->iv_splits);
	is != NULL; is = list_next(&iv->iv_splits, is)) {
	for (int c = 0; c < is->is_children; c++) {
	indirect_child_t *ic = &is->is_child[c];

	if (ic == is->is_good_child)
	continue;
	if (ic->ic_data == NULL)
	continue;

	abd_zero(ic->ic_data, abd_get_size(ic->ic_data));
	}

	iv->iv_attempts_max *= 2;
	if (iv->iv_attempts_max >= (1ULL << 12)) {
	iv->iv_attempts_max = UINT64_MAX;
	break;
	}
	}

	out:
	/* Empty the unique children lists so they can be reconstructed. */
	for (indirect_split_t *is = list_head(&iv->iv_splits);
	is != NULL; is = list_next(&iv->iv_splits, is)) {
	indirect_child_t *ic;
	while ((ic = list_head(&is->is_unique_child)) != NULL)
	list_remove(&is->is_unique_child, ic);

	is->is_unique_children = 0;
	}

	return (error);
	}

	/*
	* This function is called when we have read all copies of the data and need
	* to try to find a combination of copies that gives us the right checksum.
	*
	* If we pointed to any mirror vdevs, this effectively does the job of the
	* mirror. The mirror vdev code can't do its own job because we don't know
	* the checksum of each split segment individually.
	*
	* We have to try every unique combination of copies of split segments, until
	* we find one that checksums correctly. Duplicate segment copies are first
	* identified and latter skipped during reconstruction. This optimization
	* reduces the search space and ensures that of the remaining combinations
	* at most one is correct.
	*
	* When the total number of combinations is small they can all be checked.
	* For example, if we have 3 segments in the split, and each points to a
	* 2-way mirror with unique copies, we will have the following pieces of data:
	*
	* \| mirror child
	* split \| [0] [1]
	* ======\|=====================
	* A \| data_A_0 data_A_1
	* B \| data_B_0 data_B_1
	* C \| data_C_0 data_C_1
	*
	* We will try the following (mirror children)^(number of splits) (2^3=8)
	* combinations, which is similar to bitwise-little-endian counting in
	* binary. In general each "digit" corresponds to a split segment, and the
	* base of each digit is is_children, which can be different for each
	* digit.
	*
	* "low bit" "high bit"
	* v v
	* data_A_0 data_B_0 data_C_0
	* data_A_1 data_B_0 data_C_0
	* data_A_0 data_B_1 data_C_0
	* data_A_1 data_B_1 data_C_0
	* data_A_0 data_B_0 data_C_1
	* data_A_1 data_B_0 data_C_1
	* data_A_0 data_B_1 data_C_1
	* data_A_1 data_B_1 data_C_1
	*
	* Note that the split segments may be on the same or different top-level
	* vdevs. In either case, we may need to try lots of combinations (see
	* zfs_reconstruct_indirect_combinations_max). This ensures that if a mirror
	* has small silent errors on all of its children, we can still reconstruct
	* the correct data, as long as those errors are at sufficiently-separated
	* offsets (specifically, separated by the largest block size - default of
	* 128KB, but up to 16MB).
	*/
	static void
	vdev_indirect_reconstruct_io_done(zio_t *zio)
	{
	indirect_vsd_t *iv = zio->io_vsd;
	boolean_t known_good = B_FALSE;
	int error;

	iv->iv_unique_combinations = 1;
	iv->iv_attempts_max = UINT64_MAX;

	if (zfs_reconstruct_indirect_combinations_max > 0)
	iv->iv_attempts_max = zfs_reconstruct_indirect_combinations_max;

	/*
	* If nonzero, every 1/x blocks will be damaged, in order to validate
	* reconstruction when there are split segments with damaged copies.
	* Known_good will be TRUE when reconstruction is known to be possible.
	*/
	if (zfs_reconstruct_indirect_damage_fraction != 0 &&
	spa_get_random(zfs_reconstruct_indirect_damage_fraction) == 0)
	known_good = (vdev_indirect_splits_damage(iv, zio) == 0);

	/*
	* Determine the unique children for a split segment and add them
	* to the is_unique_child list. By restricting reconstruction
	* to these children, only unique combinations will be considered.
	* This can vastly reduce the search space when there are a large
	* number of indirect splits.
	*/
	for (indirect_split_t *is = list_head(&iv->iv_splits);
	is != NULL; is = list_next(&iv->iv_splits, is)) {
	is->is_unique_children = 0;

	for (int i = 0; i < is->is_children; i++) {
	indirect_child_t *ic_i = &is->is_child[i];

	if (ic_i->ic_data == NULL \|\|
	ic_i->ic_duplicate != NULL)
	continue;

	for (int j = i + 1; j < is->is_children; j++) {
	indirect_child_t *ic_j = &is->is_child[j];

	if (ic_j->ic_data == NULL \|\|
	ic_j->ic_duplicate != NULL)
	continue;

	if (abd_cmp(ic_i->ic_data, ic_j->ic_data) == 0)
	ic_j->ic_duplicate = ic_i;
	}

	is->is_unique_children++;
	list_insert_tail(&is->is_unique_child, ic_i);
	}

	/* Reconstruction is impossible, no valid children */
	EQUIV(list_is_empty(&is->is_unique_child),
	is->is_unique_children == 0);
	if (list_is_empty(&is->is_unique_child)) {
	zio->io_error = EIO;
	vdev_indirect_all_checksum_errors(zio);
	zio_checksum_verified(zio);
	return;
	}

	iv->iv_unique_combinations *= is->is_unique_children;
	}

	if (iv->iv_unique_combinations <= iv->iv_attempts_max)
	error = vdev_indirect_splits_enumerate_all(iv, zio);
	else
	error = vdev_indirect_splits_enumerate_randomly(iv, zio);

	if (error != 0) {
	/* All attempted combinations failed. */
	ASSERT3B(known_good, ==, B_FALSE);
	zio->io_error = error;
	vdev_indirect_all_checksum_errors(zio);
	} else {
	/*
	* The checksum has been successfully validated. Issue
	* repair I/Os to any copies of splits which don't match
	* the validated version.
	*/
	ASSERT0(vdev_indirect_splits_checksum_validate(iv, zio));
	vdev_indirect_repair(zio);
	zio_checksum_verified(zio);
	}
	}

	static void
	vdev_indirect_io_done(zio_t *zio)
	{
	indirect_vsd_t *iv = zio->io_vsd;

	if (iv->iv_reconstruct) {
	/*
	* We have read all copies of the data (e.g. from mirrors),
	* either because this was a scrub/resilver, or because the
	* one-copy read didn't checksum correctly.
	*/
	vdev_indirect_reconstruct_io_done(zio);
	return;
	}

	if (!iv->iv_split_block) {
	/*
	* This was not a split block, so we passed the BP down,
	* and the checksum was handled by the (one) child zio.
	*/
	return;
	}

	zio_bad_cksum_t zbc;
	int ret = zio_checksum_error(zio, &zbc);
	if (ret == 0) {
	zio_checksum_verified(zio);
	return;
	}

	/*
	* The checksum didn't match. Read all copies of all splits, and
	* then we will try to reconstruct. The next time
	* vdev_indirect_io_done() is called, iv_reconstruct will be set.
	*/
	vdev_indirect_read_all(zio);

	zio_vdev_io_redone(zio);
	}

	vdev_ops_t vdev_indirect_ops = {
	.vdev_op_init = NULL,
	.vdev_op_fini = NULL,
	.vdev_op_open = vdev_indirect_open,
	.vdev_op_close = vdev_indirect_close,
	.vdev_op_asize = vdev_default_asize,
	.vdev_op_min_asize = vdev_default_min_asize,
	.vdev_op_min_alloc = NULL,
	.vdev_op_io_start = vdev_indirect_io_start,
	.vdev_op_io_done = vdev_indirect_io_done,
	.vdev_op_state_change = NULL,
	.vdev_op_need_resilver = NULL,
	.vdev_op_hold = NULL,
	.vdev_op_rele = NULL,
	.vdev_op_remap = vdev_indirect_remap,
	.vdev_op_xlate = NULL,
	.vdev_op_rebuild_asize = NULL,
	.vdev_op_metaslab_init = NULL,
	.vdev_op_config_generate = NULL,
	.vdev_op_nparity = NULL,
	.vdev_op_ndisks = NULL,
	.vdev_op_type = VDEV_TYPE_INDIRECT, /* name of this vdev type */
	.vdev_op_leaf = B_FALSE /* leaf vdev */
	};

	EXPORT_SYMBOL(spa_condense_fini);
	EXPORT_SYMBOL(spa_start_indirect_condensing_thread);
	EXPORT_SYMBOL(spa_condense_indirect_start_sync);
	EXPORT_SYMBOL(spa_condense_init);
	EXPORT_SYMBOL(spa_vdev_indirect_mark_obsolete);
	EXPORT_SYMBOL(vdev_indirect_mark_obsolete);
	EXPORT_SYMBOL(vdev_indirect_should_condense);
	EXPORT_SYMBOL(vdev_indirect_sync_obsolete);
	EXPORT_SYMBOL(vdev_obsolete_counts_are_precise);
	EXPORT_SYMBOL(vdev_obsolete_sm_object);

	/* BEGIN CSTYLED */
	ZFS_MODULE_PARAM(zfs_condense, zfs_condense_, indirect_vdevs_enable, INT, ZMOD_RW,
	"Whether to attempt condensing indirect vdev mappings");

	+ZFS_MODULE_PARAM(zfs_condense, zfs_condense_, indirect_obsolete_pct, INT, ZMOD_RW,
	+ "Minimum obsolete percent of bytes in the mapping to attempt condensing");
	+
	ZFS_MODULE_PARAM(zfs_condense, zfs_condense_, min_mapping_bytes, ULONG, ZMOD_RW,
	"Don't bother condensing if the mapping uses less than this amount of "
	"memory");

	ZFS_MODULE_PARAM(zfs_condense, zfs_condense_, max_obsolete_bytes, ULONG, ZMOD_RW,
	"Minimum size obsolete spacemap to attempt condensing");

	ZFS_MODULE_PARAM(zfs_condense, zfs_condense_, indirect_commit_entry_delay_ms, INT, ZMOD_RW,
	"Used by tests to ensure certain actions happen in the middle of a "
	"condense. A maximum value of 1 should be sufficient.");

	ZFS_MODULE_PARAM(zfs_reconstruct, zfs_reconstruct_, indirect_combinations_max, INT, ZMOD_RW,
	"Maximum number of combinations when reconstructing split segments");
	/* END CSTYLED */
	diff --git a/sys/contrib/openzfs/module/zfs/vdev_mirror.c b/sys/contrib/openzfs/module/zfs/vdev_mirror.c
	index f360a18c0041..106678a8708e 100644
	--- a/sys/contrib/openzfs/module/zfs/vdev_mirror.c
	+++ b/sys/contrib/openzfs/module/zfs/vdev_mirror.c
	@@ -1,971 +1,980 @@
	/*
	* 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 2010 Sun Microsystems, Inc. All rights reserved.
	* Use is subject to license terms.
	*/

	/*
	* Copyright (c) 2012, 2015 by Delphix. All rights reserved.
	*/

	#include <sys/zfs_context.h>
	#include <sys/spa.h>
	#include <sys/spa_impl.h>
	#include <sys/dsl_pool.h>
	#include <sys/dsl_scan.h>
	#include <sys/vdev_impl.h>
	#include <sys/vdev_draid.h>
	#include <sys/zio.h>
	#include <sys/abd.h>
	#include <sys/fs/zfs.h>

	/*
	* Vdev mirror kstats
	*/
	static kstat_t *mirror_ksp = NULL;

	typedef struct mirror_stats {
	kstat_named_t vdev_mirror_stat_rotating_linear;
	kstat_named_t vdev_mirror_stat_rotating_offset;
	kstat_named_t vdev_mirror_stat_rotating_seek;
	kstat_named_t vdev_mirror_stat_non_rotating_linear;
	kstat_named_t vdev_mirror_stat_non_rotating_seek;

	kstat_named_t vdev_mirror_stat_preferred_found;
	kstat_named_t vdev_mirror_stat_preferred_not_found;
	} mirror_stats_t;

	static mirror_stats_t mirror_stats = {
	/* New I/O follows directly the last I/O */
	{ "rotating_linear", KSTAT_DATA_UINT64 },
	/* New I/O is within zfs_vdev_mirror_rotating_seek_offset of the last */
	{ "rotating_offset", KSTAT_DATA_UINT64 },
	/* New I/O requires random seek */
	{ "rotating_seek", KSTAT_DATA_UINT64 },
	/* New I/O follows directly the last I/O (nonrot) */
	{ "non_rotating_linear", KSTAT_DATA_UINT64 },
	/* New I/O requires random seek (nonrot) */
	{ "non_rotating_seek", KSTAT_DATA_UINT64 },
	/* Preferred child vdev found */
	{ "preferred_found", KSTAT_DATA_UINT64 },
	/* Preferred child vdev not found or equal load */
	{ "preferred_not_found", KSTAT_DATA_UINT64 },

	};

	#define MIRROR_STAT(stat) (mirror_stats.stat.value.ui64)
	#define MIRROR_INCR(stat, val) atomic_add_64(&MIRROR_STAT(stat), val)
	#define MIRROR_BUMP(stat) MIRROR_INCR(stat, 1)

	void
	vdev_mirror_stat_init(void)
	{
	mirror_ksp = kstat_create("zfs", 0, "vdev_mirror_stats",
	"misc", KSTAT_TYPE_NAMED,
	sizeof (mirror_stats) / sizeof (kstat_named_t), KSTAT_FLAG_VIRTUAL);
	if (mirror_ksp != NULL) {
	mirror_ksp->ks_data = &mirror_stats;
	kstat_install(mirror_ksp);
	}
	}

	void
	vdev_mirror_stat_fini(void)
	{
	if (mirror_ksp != NULL) {
	kstat_delete(mirror_ksp);
	mirror_ksp = NULL;
	}
	}

	/*
	* Virtual device vector for mirroring.
	*/
	typedef struct mirror_child {
	vdev_t *mc_vd;
	uint64_t mc_offset;
	int mc_error;
	int mc_load;
	uint8_t mc_tried;
	uint8_t mc_skipped;
	uint8_t mc_speculative;
	uint8_t mc_rebuilding;
	} mirror_child_t;

	typedef struct mirror_map {
	int *mm_preferred;
	int mm_preferred_cnt;
	int mm_children;
	boolean_t mm_resilvering;
	boolean_t mm_rebuilding;
	boolean_t mm_root;
	mirror_child_t mm_child[];
	} mirror_map_t;

	static int vdev_mirror_shift = 21;

	/*
	* The load configuration settings below are tuned by default for
	* the case where all devices are of the same rotational type.
	*
	* If there is a mixture of rotating and non-rotating media, setting
	* zfs_vdev_mirror_non_rotating_seek_inc to 0 may well provide better results
	* as it will direct more reads to the non-rotating vdevs which are more likely
	* to have a higher performance.
	*/

	/* Rotating media load calculation configuration. */
	static int zfs_vdev_mirror_rotating_inc = 0;
	static int zfs_vdev_mirror_rotating_seek_inc = 5;
	static int zfs_vdev_mirror_rotating_seek_offset = 1 * 1024 * 1024;

	/* Non-rotating media load calculation configuration. */
	static int zfs_vdev_mirror_non_rotating_inc = 0;
	static int zfs_vdev_mirror_non_rotating_seek_inc = 1;

	static inline size_t
	vdev_mirror_map_size(int children)
	{
	return (offsetof(mirror_map_t, mm_child[children]) +
	sizeof (int) * children);
	}

	static inline mirror_map_t *
	vdev_mirror_map_alloc(int children, boolean_t resilvering, boolean_t root)
	{
	mirror_map_t *mm;

	mm = kmem_zalloc(vdev_mirror_map_size(children), KM_SLEEP);
	mm->mm_children = children;
	mm->mm_resilvering = resilvering;
	mm->mm_root = root;
	mm->mm_preferred = (int *)((uintptr_t)mm +
	offsetof(mirror_map_t, mm_child[children]));

	return (mm);
	}

	static void
	vdev_mirror_map_free(zio_t *zio)
	{
	mirror_map_t *mm = zio->io_vsd;

	kmem_free(mm, vdev_mirror_map_size(mm->mm_children));
	}

	static const zio_vsd_ops_t vdev_mirror_vsd_ops = {
	.vsd_free = vdev_mirror_map_free,
	};

	static int
	vdev_mirror_load(mirror_map_t mm, vdev_t vd, uint64_t zio_offset)
	{
	uint64_t last_offset;
	int64_t offset_diff;
	int load;

	/* All DVAs have equal weight at the root. */
	if (mm->mm_root)
	return (INT_MAX);

	/*
	* We don't return INT_MAX if the device is resilvering i.e.
	* vdev_resilver_txg != 0 as when tested performance was slightly
	* worse overall when resilvering with compared to without.
	*/

	/* Fix zio_offset for leaf vdevs */
	if (vd->vdev_ops->vdev_op_leaf)
	zio_offset += VDEV_LABEL_START_SIZE;

	/* Standard load based on pending queue length. */
	load = vdev_queue_length(vd);
	last_offset = vdev_queue_last_offset(vd);

	if (vd->vdev_nonrot) {
	/* Non-rotating media. */
	if (last_offset == zio_offset) {
	MIRROR_BUMP(vdev_mirror_stat_non_rotating_linear);
	return (load + zfs_vdev_mirror_non_rotating_inc);
	}

	/*
	* Apply a seek penalty even for non-rotating devices as
	* sequential I/O's can be aggregated into fewer operations on
	* the device, thus avoiding unnecessary per-command overhead
	* and boosting performance.
	*/
	MIRROR_BUMP(vdev_mirror_stat_non_rotating_seek);
	return (load + zfs_vdev_mirror_non_rotating_seek_inc);
	}

	/* Rotating media I/O's which directly follow the last I/O. */
	if (last_offset == zio_offset) {
	MIRROR_BUMP(vdev_mirror_stat_rotating_linear);
	return (load + zfs_vdev_mirror_rotating_inc);
	}

	/*
	* Apply half the seek increment to I/O's within seek offset
	* of the last I/O issued to this vdev as they should incur less
	* of a seek increment.
	*/
	offset_diff = (int64_t)(last_offset - zio_offset);
	if (ABS(offset_diff) < zfs_vdev_mirror_rotating_seek_offset) {
	MIRROR_BUMP(vdev_mirror_stat_rotating_offset);
	return (load + (zfs_vdev_mirror_rotating_seek_inc / 2));
	}

	/* Apply the full seek increment to all other I/O's. */
	MIRROR_BUMP(vdev_mirror_stat_rotating_seek);
	return (load + zfs_vdev_mirror_rotating_seek_inc);
	}

	static boolean_t
	vdev_mirror_rebuilding(vdev_t *vd)
	{
	if (vd->vdev_ops->vdev_op_leaf && vd->vdev_rebuild_txg)
	return (B_TRUE);

	for (int i = 0; i < vd->vdev_children; i++) {
	if (vdev_mirror_rebuilding(vd->vdev_child[i])) {
	return (B_TRUE);
	}
	}

	return (B_FALSE);
	}

	/*
	* Avoid inlining the function to keep vdev_mirror_io_start(), which
	* is this functions only caller, as small as possible on the stack.
	*/
	noinline static mirror_map_t *
	vdev_mirror_map_init(zio_t *zio)
	{
	mirror_map_t *mm = NULL;
	mirror_child_t *mc;
	vdev_t *vd = zio->io_vd;
	int c;

	if (vd == NULL) {
	dva_t *dva = zio->io_bp->blk_dva;
	spa_t *spa = zio->io_spa;
	dsl_scan_t *scn = spa->spa_dsl_pool->dp_scan;
	dva_t dva_copy[SPA_DVAS_PER_BP];

	/*
	* The sequential scrub code sorts and issues all DVAs
	* of a bp separately. Each of these IOs includes all
	* original DVA copies so that repairs can be performed
	* in the event of an error, but we only actually want
	* to check the first DVA since the others will be
	* checked by their respective sorted IOs. Only if we
	* hit an error will we try all DVAs upon retrying.
	*
	* Note: This check is safe even if the user switches
	* from a legacy scrub to a sequential one in the middle
	* of processing, since scn_is_sorted isn't updated until
	* all outstanding IOs from the previous scrub pass
	* complete.
	*/
	if ((zio->io_flags & ZIO_FLAG_SCRUB) &&
	!(zio->io_flags & ZIO_FLAG_IO_RETRY) &&
	dsl_scan_scrubbing(spa->spa_dsl_pool) &&
	scn->scn_is_sorted) {
	c = 1;
	} else {
	c = BP_GET_NDVAS(zio->io_bp);
	}

	/*
	* If the pool cannot be written to, then infer that some
	* DVAs might be invalid or point to vdevs that do not exist.
	* We skip them.
	*/
	if (!spa_writeable(spa)) {
	ASSERT3U(zio->io_type, ==, ZIO_TYPE_READ);
	int j = 0;
	for (int i = 0; i < c; i++) {
	if (zfs_dva_valid(spa, &dva[i], zio->io_bp))
	dva_copy[j++] = dva[i];
	}
	if (j == 0) {
	zio->io_vsd = NULL;
	zio->io_error = ENXIO;
	return (NULL);
	}
	if (j < c) {
	dva = dva_copy;
	c = j;
	}
	}

	mm = vdev_mirror_map_alloc(c, B_FALSE, B_TRUE);
	for (c = 0; c < mm->mm_children; c++) {
	mc = &mm->mm_child[c];

	mc->mc_vd = vdev_lookup_top(spa, DVA_GET_VDEV(&dva[c]));
	mc->mc_offset = DVA_GET_OFFSET(&dva[c]);
	if (mc->mc_vd == NULL) {
	kmem_free(mm, vdev_mirror_map_size(
	mm->mm_children));
	zio->io_vsd = NULL;
	zio->io_error = ENXIO;
	return (NULL);
	}
	}
	} else {
	/*
	* If we are resilvering, then we should handle scrub reads
	* differently; we shouldn't issue them to the resilvering
	* device because it might not have those blocks.
	*
	* We are resilvering iff:
	* 1) We are a replacing vdev (ie our name is "replacing-1" or
	* "spare-1" or something like that), and
	* 2) The pool is currently being resilvered.
	*
	* We cannot simply check vd->vdev_resilver_txg, because it's
	* not set in this path.
	*
	* Nor can we just check our vdev_ops; there are cases (such as
	* when a user types "zpool replace pool odev spare_dev" and
	* spare_dev is in the spare list, or when a spare device is
	* automatically used to replace a DEGRADED device) when
	* resilvering is complete but both the original vdev and the
	* spare vdev remain in the pool. That behavior is intentional.
	* It helps implement the policy that a spare should be
	* automatically removed from the pool after the user replaces
	* the device that originally failed.
	*
	* If a spa load is in progress, then spa_dsl_pool may be
	* uninitialized. But we shouldn't be resilvering during a spa
	* load anyway.
	*/
	boolean_t replacing = (vd->vdev_ops == &vdev_replacing_ops \|\|
	vd->vdev_ops == &vdev_spare_ops) &&
	spa_load_state(vd->vdev_spa) == SPA_LOAD_NONE &&
	dsl_scan_resilvering(vd->vdev_spa->spa_dsl_pool);
	mm = vdev_mirror_map_alloc(vd->vdev_children, replacing,
	B_FALSE);
	for (c = 0; c < mm->mm_children; c++) {
	mc = &mm->mm_child[c];
	mc->mc_vd = vd->vdev_child[c];
	mc->mc_offset = zio->io_offset;

	if (vdev_mirror_rebuilding(mc->mc_vd))
	mm->mm_rebuilding = mc->mc_rebuilding = B_TRUE;
	}
	}

	return (mm);
	}

	static int
	vdev_mirror_open(vdev_t vd, uint64_t asize, uint64_t *max_asize,
	uint64_t logical_ashift, uint64_t physical_ashift)
	{
	int numerrors = 0;
	int lasterror = 0;

	if (vd->vdev_children == 0) {
	vd->vdev_stat.vs_aux = VDEV_AUX_BAD_LABEL;
	return (SET_ERROR(EINVAL));
	}

	vdev_open_children(vd);

	for (int c = 0; c < vd->vdev_children; c++) {
	vdev_t *cvd = vd->vdev_child[c];

	if (cvd->vdev_open_error) {
	lasterror = cvd->vdev_open_error;
	numerrors++;
	continue;
	}

	asize = MIN(asize - 1, cvd->vdev_asize - 1) + 1;
	max_asize = MIN(max_asize - 1, cvd->vdev_max_asize - 1) + 1;
	logical_ashift = MAX(logical_ashift, cvd->vdev_ashift);
	physical_ashift = MAX(physical_ashift,
	cvd->vdev_physical_ashift);
	}

	if (numerrors == vd->vdev_children) {
	if (vdev_children_are_offline(vd))
	vd->vdev_stat.vs_aux = VDEV_AUX_CHILDREN_OFFLINE;
	else
	vd->vdev_stat.vs_aux = VDEV_AUX_NO_REPLICAS;
	return (lasterror);
	}

	return (0);
	}

	static void
	vdev_mirror_close(vdev_t *vd)
	{
	for (int c = 0; c < vd->vdev_children; c++)
	vdev_close(vd->vdev_child[c]);
	}

	static void
	vdev_mirror_child_done(zio_t *zio)
	{
	mirror_child_t *mc = zio->io_private;

	mc->mc_error = zio->io_error;
	mc->mc_tried = 1;
	mc->mc_skipped = 0;
	}

	static void
	vdev_mirror_scrub_done(zio_t *zio)
	{
	mirror_child_t *mc = zio->io_private;

	if (zio->io_error == 0) {
	zio_t *pio;
	zio_link_t *zl = NULL;

	mutex_enter(&zio->io_lock);
	while ((pio = zio_walk_parents(zio, &zl)) != NULL) {
	mutex_enter(&pio->io_lock);
	ASSERT3U(zio->io_size, >=, pio->io_size);
	abd_copy(pio->io_abd, zio->io_abd, pio->io_size);
	mutex_exit(&pio->io_lock);
	}
	mutex_exit(&zio->io_lock);
	}

	abd_free(zio->io_abd);

	mc->mc_error = zio->io_error;
	mc->mc_tried = 1;
	mc->mc_skipped = 0;
	}

	/*
	* Check the other, lower-index DVAs to see if they're on the same
	* vdev as the child we picked. If they are, use them since they
	* are likely to have been allocated from the primary metaslab in
	* use at the time, and hence are more likely to have locality with
	* single-copy data.
	*/
	static int
	vdev_mirror_dva_select(zio_t *zio, int p)
	{
	dva_t *dva = zio->io_bp->blk_dva;
	mirror_map_t *mm = zio->io_vsd;
	int preferred;
	int c;

	preferred = mm->mm_preferred[p];
	for (p--; p >= 0; p--) {
	c = mm->mm_preferred[p];
	if (DVA_GET_VDEV(&dva[c]) == DVA_GET_VDEV(&dva[preferred]))
	preferred = c;
	}
	return (preferred);
	}

	static int
	vdev_mirror_preferred_child_randomize(zio_t *zio)
	{
	mirror_map_t *mm = zio->io_vsd;
	int p;

	if (mm->mm_root) {
	p = spa_get_random(mm->mm_preferred_cnt);
	return (vdev_mirror_dva_select(zio, p));
	}

	/*
	* To ensure we don't always favour the first matching vdev,
	* which could lead to wear leveling issues on SSD's, we
	* use the I/O offset as a pseudo random seed into the vdevs
	* which have the lowest load.
	*/
	p = (zio->io_offset >> vdev_mirror_shift) % mm->mm_preferred_cnt;
	return (mm->mm_preferred[p]);
	}

	static boolean_t
	vdev_mirror_child_readable(mirror_child_t *mc)
	{
	vdev_t *vd = mc->mc_vd;

	if (vd->vdev_top != NULL && vd->vdev_top->vdev_ops == &vdev_draid_ops)
	return (vdev_draid_readable(vd, mc->mc_offset));
	else
	return (vdev_readable(vd));
	}

	static boolean_t
	vdev_mirror_child_missing(mirror_child_t *mc, uint64_t txg, uint64_t size)
	{
	vdev_t *vd = mc->mc_vd;

	if (vd->vdev_top != NULL && vd->vdev_top->vdev_ops == &vdev_draid_ops)
	return (vdev_draid_missing(vd, mc->mc_offset, txg, size));
	else
	return (vdev_dtl_contains(vd, DTL_MISSING, txg, size));
	}

	/*
	* Try to find a vdev whose DTL doesn't contain the block we want to read
	* preferring vdevs based on determined load. If we can't, try the read on
	* any vdev we haven't already tried.
	*
	* Distributed spares are an exception to the above load rule. They are
	* always preferred in order to detect gaps in the distributed spare which
	* are created when another disk in the dRAID fails. In order to restore
	* redundancy those gaps must be read to trigger the required repair IO.
	*/
	static int
	vdev_mirror_child_select(zio_t *zio)
	{
	mirror_map_t *mm = zio->io_vsd;
	uint64_t txg = zio->io_txg;
	int c, lowest_load;

	ASSERT(zio->io_bp == NULL \|\| BP_PHYSICAL_BIRTH(zio->io_bp) == txg);

	lowest_load = INT_MAX;
	mm->mm_preferred_cnt = 0;
	for (c = 0; c < mm->mm_children; c++) {
	mirror_child_t *mc;

	mc = &mm->mm_child[c];
	if (mc->mc_tried \|\| mc->mc_skipped)
	continue;

	if (mc->mc_vd == NULL \|\|
	!vdev_mirror_child_readable(mc)) {
	mc->mc_error = SET_ERROR(ENXIO);
	mc->mc_tried = 1; /* don't even try */
	mc->mc_skipped = 1;
	continue;
	}

	if (vdev_mirror_child_missing(mc, txg, 1)) {
	mc->mc_error = SET_ERROR(ESTALE);
	mc->mc_skipped = 1;
	mc->mc_speculative = 1;
	continue;
	}

	if (mc->mc_vd->vdev_ops == &vdev_draid_spare_ops) {
	mm->mm_preferred[0] = c;
	mm->mm_preferred_cnt = 1;
	break;
	}

	mc->mc_load = vdev_mirror_load(mm, mc->mc_vd, mc->mc_offset);
	if (mc->mc_load > lowest_load)
	continue;

	if (mc->mc_load < lowest_load) {
	lowest_load = mc->mc_load;
	mm->mm_preferred_cnt = 0;
	}
	mm->mm_preferred[mm->mm_preferred_cnt] = c;
	mm->mm_preferred_cnt++;
	}

	if (mm->mm_preferred_cnt == 1) {
	MIRROR_BUMP(vdev_mirror_stat_preferred_found);
	return (mm->mm_preferred[0]);
	}

	if (mm->mm_preferred_cnt > 1) {
	MIRROR_BUMP(vdev_mirror_stat_preferred_not_found);
	return (vdev_mirror_preferred_child_randomize(zio));
	}

	/*
	* Every device is either missing or has this txg in its DTL.
	* Look for any child we haven't already tried before giving up.
	*/
	for (c = 0; c < mm->mm_children; c++) {
	if (!mm->mm_child[c].mc_tried)
	return (c);
	}

	/*
	* Every child failed. There's no place left to look.
	*/
	return (-1);
	}

	static void
	vdev_mirror_io_start(zio_t *zio)
	{
	mirror_map_t *mm;
	mirror_child_t *mc;
	int c, children;

	mm = vdev_mirror_map_init(zio);
	zio->io_vsd = mm;
	zio->io_vsd_ops = &vdev_mirror_vsd_ops;

	if (mm == NULL) {
	ASSERT(!spa_trust_config(zio->io_spa));
	ASSERT(zio->io_type == ZIO_TYPE_READ);
	zio_execute(zio);
	return;
	}

	if (zio->io_type == ZIO_TYPE_READ) {
	if (zio->io_bp != NULL &&
	(zio->io_flags & ZIO_FLAG_SCRUB) && !mm->mm_resilvering) {
	/*
	* For scrubbing reads (if we can verify the
	* checksum here, as indicated by io_bp being
	* non-NULL) we need to allocate a read buffer for
	* each child and issue reads to all children. If
	* any child succeeds, it will copy its data into
	* zio->io_data in vdev_mirror_scrub_done.
	*/
	for (c = 0; c < mm->mm_children; c++) {
	mc = &mm->mm_child[c];
	+
	+ /* Don't issue ZIOs to offline children */
	+ if (!vdev_mirror_child_readable(mc)) {
	+ mc->mc_error = SET_ERROR(ENXIO);
	+ mc->mc_tried = 1;
	+ mc->mc_skipped = 1;
	+ continue;
	+ }
	+
	zio_nowait(zio_vdev_child_io(zio, zio->io_bp,
	mc->mc_vd, mc->mc_offset,
	abd_alloc_sametype(zio->io_abd,
	zio->io_size), zio->io_size,
	zio->io_type, zio->io_priority, 0,
	vdev_mirror_scrub_done, mc));
	}
	zio_execute(zio);
	return;
	}
	/*
	* For normal reads just pick one child.
	*/
	c = vdev_mirror_child_select(zio);
	children = (c >= 0);
	} else {
	ASSERT(zio->io_type == ZIO_TYPE_WRITE);

	/*
	* Writes go to all children.
	*/
	c = 0;
	children = mm->mm_children;
	}

	while (children--) {
	mc = &mm->mm_child[c];
	c++;

	/*
	* When sequentially resilvering only issue write repair
	* IOs to the vdev which is being rebuilt since performance
	* is limited by the slowest child. This is an issue for
	* faster replacement devices such as distributed spares.
	*/
	if ((zio->io_priority == ZIO_PRIORITY_REBUILD) &&
	(zio->io_flags & ZIO_FLAG_IO_REPAIR) &&
	!(zio->io_flags & ZIO_FLAG_SCRUB) &&
	mm->mm_rebuilding && !mc->mc_rebuilding) {
	continue;
	}

	zio_nowait(zio_vdev_child_io(zio, zio->io_bp,
	mc->mc_vd, mc->mc_offset, zio->io_abd, zio->io_size,
	zio->io_type, zio->io_priority, 0,
	vdev_mirror_child_done, mc));
	}

	zio_execute(zio);
	}

	static int
	vdev_mirror_worst_error(mirror_map_t *mm)
	{
	int error[2] = { 0, 0 };

	for (int c = 0; c < mm->mm_children; c++) {
	mirror_child_t *mc = &mm->mm_child[c];
	int s = mc->mc_speculative;
	error[s] = zio_worst_error(error[s], mc->mc_error);
	}

	return (error[0] ? error[0] : error[1]);
	}

	static void
	vdev_mirror_io_done(zio_t *zio)
	{
	mirror_map_t *mm = zio->io_vsd;
	mirror_child_t *mc;
	int c;
	int good_copies = 0;
	int unexpected_errors = 0;

	if (mm == NULL)
	return;

	for (c = 0; c < mm->mm_children; c++) {
	mc = &mm->mm_child[c];

	if (mc->mc_error) {
	if (!mc->mc_skipped)
	unexpected_errors++;
	} else if (mc->mc_tried) {
	good_copies++;
	}
	}

	if (zio->io_type == ZIO_TYPE_WRITE) {
	/*
	* XXX -- for now, treat partial writes as success.
	*
	* Now that we support write reallocation, it would be better
	* to treat partial failure as real failure unless there are
	* no non-degraded top-level vdevs left, and not update DTLs
	* if we intend to reallocate.
	*/
	/* XXPOLICY */
	if (good_copies != mm->mm_children) {
	/*
	* Always require at least one good copy.
	*
	* For ditto blocks (io_vd == NULL), require
	* all copies to be good.
	*
	* XXX -- for replacing vdevs, there's no great answer.
	* If the old device is really dead, we may not even
	* be able to access it -- so we only want to
	* require good writes to the new device. But if
	* the new device turns out to be flaky, we want
	* to be able to detach it -- which requires all
	* writes to the old device to have succeeded.
	*/
	if (good_copies == 0 \|\| zio->io_vd == NULL)
	zio->io_error = vdev_mirror_worst_error(mm);
	}
	return;
	}

	ASSERT(zio->io_type == ZIO_TYPE_READ);

	/*
	* If we don't have a good copy yet, keep trying other children.
	*/
	/* XXPOLICY */
	if (good_copies == 0 && (c = vdev_mirror_child_select(zio)) != -1) {
	ASSERT(c >= 0 && c < mm->mm_children);
	mc = &mm->mm_child[c];
	zio_vdev_io_redone(zio);
	zio_nowait(zio_vdev_child_io(zio, zio->io_bp,
	mc->mc_vd, mc->mc_offset, zio->io_abd, zio->io_size,
	ZIO_TYPE_READ, zio->io_priority, 0,
	vdev_mirror_child_done, mc));
	return;
	}

	/* XXPOLICY */
	if (good_copies == 0) {
	zio->io_error = vdev_mirror_worst_error(mm);
	ASSERT(zio->io_error != 0);
	}

	if (good_copies && spa_writeable(zio->io_spa) &&
	(unexpected_errors \|\|
	(zio->io_flags & ZIO_FLAG_RESILVER) \|\|
	((zio->io_flags & ZIO_FLAG_SCRUB) && mm->mm_resilvering))) {
	/*
	* Use the good data we have in hand to repair damaged children.
	*/
	for (c = 0; c < mm->mm_children; c++) {
	/*
	* Don't rewrite known good children.
	* Not only is it unnecessary, it could
	* actually be harmful: if the system lost
	* power while rewriting the only good copy,
	* there would be no good copies left!
	*/
	mc = &mm->mm_child[c];

	if (mc->mc_error == 0) {
	vdev_ops_t *ops = mc->mc_vd->vdev_ops;

	if (mc->mc_tried)
	continue;
	/*
	* We didn't try this child. We need to
	* repair it if:
	* 1. it's a scrub (in which case we have
	* tried everything that was healthy)
	* - or -
	* 2. it's an indirect or distributed spare
	* vdev (in which case it could point to any
	* other vdev, which might have a bad DTL)
	* - or -
	* 3. the DTL indicates that this data is
	* missing from this vdev
	*/
	if (!(zio->io_flags & ZIO_FLAG_SCRUB) &&
	ops != &vdev_indirect_ops &&
	ops != &vdev_draid_spare_ops &&
	!vdev_dtl_contains(mc->mc_vd, DTL_PARTIAL,
	zio->io_txg, 1))
	continue;
	mc->mc_error = SET_ERROR(ESTALE);
	}

	zio_nowait(zio_vdev_child_io(zio, zio->io_bp,
	mc->mc_vd, mc->mc_offset,
	zio->io_abd, zio->io_size, ZIO_TYPE_WRITE,
	zio->io_priority == ZIO_PRIORITY_REBUILD ?
	ZIO_PRIORITY_REBUILD : ZIO_PRIORITY_ASYNC_WRITE,
	ZIO_FLAG_IO_REPAIR \| (unexpected_errors ?
	ZIO_FLAG_SELF_HEAL : 0), NULL, NULL));
	}
	}
	}

	static void
	vdev_mirror_state_change(vdev_t *vd, int faulted, int degraded)
	{
	if (faulted == vd->vdev_children) {
	if (vdev_children_are_offline(vd)) {
	vdev_set_state(vd, B_FALSE, VDEV_STATE_OFFLINE,
	VDEV_AUX_CHILDREN_OFFLINE);
	} else {
	vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN,
	VDEV_AUX_NO_REPLICAS);
	}
	} else if (degraded + faulted != 0) {
	vdev_set_state(vd, B_FALSE, VDEV_STATE_DEGRADED, VDEV_AUX_NONE);
	} else {
	vdev_set_state(vd, B_FALSE, VDEV_STATE_HEALTHY, VDEV_AUX_NONE);
	}
	}

	/*
	* Return the maximum asize for a rebuild zio in the provided range.
	*/
	static uint64_t
	vdev_mirror_rebuild_asize(vdev_t *vd, uint64_t start, uint64_t asize,
	uint64_t max_segment)
	{
	uint64_t psize = MIN(P2ROUNDUP(max_segment, 1 << vd->vdev_ashift),
	SPA_MAXBLOCKSIZE);

	return (MIN(asize, vdev_psize_to_asize(vd, psize)));
	}

	vdev_ops_t vdev_mirror_ops = {
	.vdev_op_init = NULL,
	.vdev_op_fini = NULL,
	.vdev_op_open = vdev_mirror_open,
	.vdev_op_close = vdev_mirror_close,
	.vdev_op_asize = vdev_default_asize,
	.vdev_op_min_asize = vdev_default_min_asize,
	.vdev_op_min_alloc = NULL,
	.vdev_op_io_start = vdev_mirror_io_start,
	.vdev_op_io_done = vdev_mirror_io_done,
	.vdev_op_state_change = vdev_mirror_state_change,
	.vdev_op_need_resilver = vdev_default_need_resilver,
	.vdev_op_hold = NULL,
	.vdev_op_rele = NULL,
	.vdev_op_remap = NULL,
	.vdev_op_xlate = vdev_default_xlate,
	.vdev_op_rebuild_asize = vdev_mirror_rebuild_asize,
	.vdev_op_metaslab_init = NULL,
	.vdev_op_config_generate = NULL,
	.vdev_op_nparity = NULL,
	.vdev_op_ndisks = NULL,
	.vdev_op_type = VDEV_TYPE_MIRROR, /* name of this vdev type */
	.vdev_op_leaf = B_FALSE /* not a leaf vdev */
	};

	vdev_ops_t vdev_replacing_ops = {
	.vdev_op_init = NULL,
	.vdev_op_fini = NULL,
	.vdev_op_open = vdev_mirror_open,
	.vdev_op_close = vdev_mirror_close,
	.vdev_op_asize = vdev_default_asize,
	.vdev_op_min_asize = vdev_default_min_asize,
	.vdev_op_min_alloc = NULL,
	.vdev_op_io_start = vdev_mirror_io_start,
	.vdev_op_io_done = vdev_mirror_io_done,
	.vdev_op_state_change = vdev_mirror_state_change,
	.vdev_op_need_resilver = vdev_default_need_resilver,
	.vdev_op_hold = NULL,
	.vdev_op_rele = NULL,
	.vdev_op_remap = NULL,
	.vdev_op_xlate = vdev_default_xlate,
	.vdev_op_rebuild_asize = vdev_mirror_rebuild_asize,
	.vdev_op_metaslab_init = NULL,
	.vdev_op_config_generate = NULL,
	.vdev_op_nparity = NULL,
	.vdev_op_ndisks = NULL,
	.vdev_op_type = VDEV_TYPE_REPLACING, /* name of this vdev type */
	.vdev_op_leaf = B_FALSE /* not a leaf vdev */
	};

	vdev_ops_t vdev_spare_ops = {
	.vdev_op_init = NULL,
	.vdev_op_fini = NULL,
	.vdev_op_open = vdev_mirror_open,
	.vdev_op_close = vdev_mirror_close,
	.vdev_op_asize = vdev_default_asize,
	.vdev_op_min_asize = vdev_default_min_asize,
	.vdev_op_min_alloc = NULL,
	.vdev_op_io_start = vdev_mirror_io_start,
	.vdev_op_io_done = vdev_mirror_io_done,
	.vdev_op_state_change = vdev_mirror_state_change,
	.vdev_op_need_resilver = vdev_default_need_resilver,
	.vdev_op_hold = NULL,
	.vdev_op_rele = NULL,
	.vdev_op_remap = NULL,
	.vdev_op_xlate = vdev_default_xlate,
	.vdev_op_rebuild_asize = vdev_mirror_rebuild_asize,
	.vdev_op_metaslab_init = NULL,
	.vdev_op_config_generate = NULL,
	.vdev_op_nparity = NULL,
	.vdev_op_ndisks = NULL,
	.vdev_op_type = VDEV_TYPE_SPARE, /* name of this vdev type */
	.vdev_op_leaf = B_FALSE /* not a leaf vdev */
	};

	/* BEGIN CSTYLED */
	ZFS_MODULE_PARAM(zfs_vdev_mirror, zfs_vdev_mirror_, rotating_inc, INT, ZMOD_RW,
	"Rotating media load increment for non-seeking I/O's");

	ZFS_MODULE_PARAM(zfs_vdev_mirror, zfs_vdev_mirror_, rotating_seek_inc, INT, ZMOD_RW,
	"Rotating media load increment for seeking I/O's");

	ZFS_MODULE_PARAM(zfs_vdev_mirror, zfs_vdev_mirror_, rotating_seek_offset, INT, ZMOD_RW,
	"Offset in bytes from the last I/O which triggers "
	"a reduced rotating media seek increment");

	ZFS_MODULE_PARAM(zfs_vdev_mirror, zfs_vdev_mirror_, non_rotating_inc, INT, ZMOD_RW,
	"Non-rotating media load increment for non-seeking I/O's");

	ZFS_MODULE_PARAM(zfs_vdev_mirror, zfs_vdev_mirror_, non_rotating_seek_inc, INT, ZMOD_RW,
	"Non-rotating media load increment for seeking I/O's");
	/* END CSTYLED */
	diff --git a/sys/contrib/openzfs/module/zfs/vdev_raidz.c b/sys/contrib/openzfs/module/zfs/vdev_raidz.c
	index db753ec16fd3..1feebf7089b4 100644
	--- a/sys/contrib/openzfs/module/zfs/vdev_raidz.c
	+++ b/sys/contrib/openzfs/module/zfs/vdev_raidz.c
	@@ -1,2547 +1,2550 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2012, 2020 by Delphix. All rights reserved.
	* Copyright (c) 2016 Gvozden Nešković. All rights reserved.
	*/

	#include <sys/zfs_context.h>
	#include <sys/spa.h>
	#include <sys/vdev_impl.h>
	#include <sys/zio.h>
	#include <sys/zio_checksum.h>
	#include <sys/abd.h>
	#include <sys/fs/zfs.h>
	#include <sys/fm/fs/zfs.h>
	#include <sys/vdev_raidz.h>
	#include <sys/vdev_raidz_impl.h>
	#include <sys/vdev_draid.h>

	#ifdef ZFS_DEBUG
	#include <sys/vdev.h> /* For vdev_xlate() in vdev_raidz_io_verify() */
	#endif

	/*
	* Virtual device vector for RAID-Z.
	*
	* This vdev supports single, double, and triple parity. For single parity,
	* we use a simple XOR of all the data columns. For double or triple parity,
	* we use a special case of Reed-Solomon coding. This extends the
	* technique described in "The mathematics of RAID-6" by H. Peter Anvin by
	* drawing on the system described in "A Tutorial on Reed-Solomon Coding for
	* Fault-Tolerance in RAID-like Systems" by James S. Plank on which the
	* former is also based. The latter is designed to provide higher performance
	* for writes.
	*
	* Note that the Plank paper claimed to support arbitrary N+M, but was then
	* amended six years later identifying a critical flaw that invalidates its
	* claims. Nevertheless, the technique can be adapted to work for up to
	* triple parity. For additional parity, the amendment "Note: Correction to
	* the 1997 Tutorial on Reed-Solomon Coding" by James S. Plank and Ying Ding
	* is viable, but the additional complexity means that write performance will
	* suffer.
	*
	* All of the methods above operate on a Galois field, defined over the
	* integers mod 2^N. In our case we choose N=8 for GF(8) so that all elements
	* can be expressed with a single byte. Briefly, the operations on the
	* field are defined as follows:
	*
	* o addition (+) is represented by a bitwise XOR
	* o subtraction (-) is therefore identical to addition: A + B = A - B
	* o multiplication of A by 2 is defined by the following bitwise expression:
	*
	* (A * 2)_7 = A_6
	* (A * 2)_6 = A_5
	* (A * 2)_5 = A_4
	* (A * 2)_4 = A_3 + A_7
	* (A * 2)_3 = A_2 + A_7
	* (A * 2)_2 = A_1 + A_7
	* (A * 2)_1 = A_0
	* (A * 2)_0 = A_7
	*
	* In C, multiplying by 2 is therefore ((a << 1) ^ ((a & 0x80) ? 0x1d : 0)).
	* As an aside, this multiplication is derived from the error correcting
	* primitive polynomial x^8 + x^4 + x^3 + x^2 + 1.
	*
	* Observe that any number in the field (except for 0) can be expressed as a
	* power of 2 -- a generator for the field. We store a table of the powers of
	* 2 and logs base 2 for quick look ups, and exploit the fact that A * B can
	* be rewritten as 2^(log_2(A) + log_2(B)) (where '+' is normal addition rather
	* than field addition). The inverse of a field element A (A^-1) is therefore
	* A ^ (255 - 1) = A^254.
	*
	* The up-to-three parity columns, P, Q, R over several data columns,
	* D_0, ... D_n-1, can be expressed by field operations:
	*
	* P = D_0 + D_1 + ... + D_n-2 + D_n-1
	* Q = 2^n-1 * D_0 + 2^n-2 * D_1 + ... + 2^1 * D_n-2 + 2^0 * D_n-1
	* = ((...((D_0) * 2 + D_1) * 2 + ...) * 2 + D_n-2) * 2 + D_n-1
	* R = 4^n-1 * D_0 + 4^n-2 * D_1 + ... + 4^1 * D_n-2 + 4^0 * D_n-1
	* = ((...((D_0) * 4 + D_1) * 4 + ...) * 4 + D_n-2) * 4 + D_n-1
	*
	* We chose 1, 2, and 4 as our generators because 1 corresponds to the trivial
	* XOR operation, and 2 and 4 can be computed quickly and generate linearly-
	* independent coefficients. (There are no additional coefficients that have
	* this property which is why the uncorrected Plank method breaks down.)
	*
	* See the reconstruction code below for how P, Q and R can used individually
	* or in concert to recover missing data columns.
	*/

	#define VDEV_RAIDZ_P 0
	#define VDEV_RAIDZ_Q 1
	#define VDEV_RAIDZ_R 2

	#define VDEV_RAIDZ_MUL_2(x) (((x) << 1) ^ (((x) & 0x80) ? 0x1d : 0))
	#define VDEV_RAIDZ_MUL_4(x) (VDEV_RAIDZ_MUL_2(VDEV_RAIDZ_MUL_2(x)))

	/*
	* We provide a mechanism to perform the field multiplication operation on a
	* 64-bit value all at once rather than a byte at a time. This works by
	* creating a mask from the top bit in each byte and using that to
	* conditionally apply the XOR of 0x1d.
	*/
	#define VDEV_RAIDZ_64MUL_2(x, mask) \
	{ \
	(mask) = (x) & 0x8080808080808080ULL; \
	(mask) = ((mask) << 1) - ((mask) >> 7); \
	(x) = (((x) << 1) & 0xfefefefefefefefeULL) ^ \
	((mask) & 0x1d1d1d1d1d1d1d1dULL); \
	}

	#define VDEV_RAIDZ_64MUL_4(x, mask) \
	{ \
	VDEV_RAIDZ_64MUL_2((x), mask); \
	VDEV_RAIDZ_64MUL_2((x), mask); \
	}

	static void
	vdev_raidz_row_free(raidz_row_t *rr)
	{
	for (int c = 0; c < rr->rr_cols; c++) {
	raidz_col_t *rc = &rr->rr_col[c];

	if (rc->rc_size != 0)
	abd_free(rc->rc_abd);
	if (rc->rc_orig_data != NULL)
	abd_free(rc->rc_orig_data);
	}

	if (rr->rr_abd_empty != NULL)
	abd_free(rr->rr_abd_empty);

	kmem_free(rr, offsetof(raidz_row_t, rr_col[rr->rr_scols]));
	}

	void
	vdev_raidz_map_free(raidz_map_t *rm)
	{
	for (int i = 0; i < rm->rm_nrows; i++)
	vdev_raidz_row_free(rm->rm_row[i]);

	kmem_free(rm, offsetof(raidz_map_t, rm_row[rm->rm_nrows]));
	}

	static void
	vdev_raidz_map_free_vsd(zio_t *zio)
	{
	raidz_map_t *rm = zio->io_vsd;

	vdev_raidz_map_free(rm);
	}

	const zio_vsd_ops_t vdev_raidz_vsd_ops = {
	.vsd_free = vdev_raidz_map_free_vsd,
	};

	/*
	* Divides the IO evenly across all child vdevs; usually, dcols is
	* the number of children in the target vdev.
	*
	* Avoid inlining the function to keep vdev_raidz_io_start(), which
	* is this functions only caller, as small as possible on the stack.
	*/
	noinline raidz_map_t *
	vdev_raidz_map_alloc(zio_t *zio, uint64_t ashift, uint64_t dcols,
	uint64_t nparity)
	{
	raidz_row_t *rr;
	/* The starting RAIDZ (parent) vdev sector of the block. */
	uint64_t b = zio->io_offset >> ashift;
	/* The zio's size in units of the vdev's minimum sector size. */
	uint64_t s = zio->io_size >> ashift;
	/* The first column for this stripe. */
	uint64_t f = b % dcols;
	/* The starting byte offset on each child vdev. */
	uint64_t o = (b / dcols) << ashift;
	uint64_t q, r, c, bc, col, acols, scols, coff, devidx, asize, tot;

	raidz_map_t *rm =
	kmem_zalloc(offsetof(raidz_map_t, rm_row[1]), KM_SLEEP);
	rm->rm_nrows = 1;

	/*
	* "Quotient": The number of data sectors for this stripe on all but
	* the "big column" child vdevs that also contain "remainder" data.
	*/
	q = s / (dcols - nparity);

	/*
	* "Remainder": The number of partial stripe data sectors in this I/O.
	* This will add a sector to some, but not all, child vdevs.
	*/
	r = s - q * (dcols - nparity);

	/* The number of "big columns" - those which contain remainder data. */
	bc = (r == 0 ? 0 : r + nparity);

	/*
	* The total number of data and parity sectors associated with
	* this I/O.
	*/
	tot = s + nparity * (q + (r == 0 ? 0 : 1));

	/*
	* acols: The columns that will be accessed.
	* scols: The columns that will be accessed or skipped.
	*/
	if (q == 0) {
	/* Our I/O request doesn't span all child vdevs. */
	acols = bc;
	scols = MIN(dcols, roundup(bc, nparity + 1));
	} else {
	acols = dcols;
	scols = dcols;
	}

	ASSERT3U(acols, <=, scols);

	rr = kmem_alloc(offsetof(raidz_row_t, rr_col[scols]), KM_SLEEP);
	rm->rm_row[0] = rr;

	rr->rr_cols = acols;
	rr->rr_scols = scols;
	rr->rr_bigcols = bc;
	rr->rr_missingdata = 0;
	rr->rr_missingparity = 0;
	rr->rr_firstdatacol = nparity;
	rr->rr_abd_empty = NULL;
	rr->rr_nempty = 0;
	#ifdef ZFS_DEBUG
	rr->rr_offset = zio->io_offset;
	rr->rr_size = zio->io_size;
	#endif

	asize = 0;

	for (c = 0; c < scols; c++) {
	raidz_col_t *rc = &rr->rr_col[c];
	col = f + c;
	coff = o;
	if (col >= dcols) {
	col -= dcols;
	coff += 1ULL << ashift;
	}
	rc->rc_devidx = col;
	rc->rc_offset = coff;
	rc->rc_abd = NULL;
	rc->rc_orig_data = NULL;
	rc->rc_error = 0;
	rc->rc_tried = 0;
	rc->rc_skipped = 0;
	- rc->rc_repair = 0;
	+ rc->rc_force_repair = 0;
	+ rc->rc_allow_repair = 1;
	rc->rc_need_orig_restore = B_FALSE;

	if (c >= acols)
	rc->rc_size = 0;
	else if (c < bc)
	rc->rc_size = (q + 1) << ashift;
	else
	rc->rc_size = q << ashift;

	asize += rc->rc_size;
	}

	ASSERT3U(asize, ==, tot << ashift);
	rm->rm_nskip = roundup(tot, nparity + 1) - tot;
	rm->rm_skipstart = bc;

	for (c = 0; c < rr->rr_firstdatacol; c++)
	rr->rr_col[c].rc_abd =
	abd_alloc_linear(rr->rr_col[c].rc_size, B_FALSE);

	for (uint64_t off = 0; c < acols; c++) {
	raidz_col_t *rc = &rr->rr_col[c];
	rc->rc_abd = abd_get_offset_struct(&rc->rc_abdstruct,
	zio->io_abd, off, rc->rc_size);
	off += rc->rc_size;
	}

	/*
	* If all data stored spans all columns, there's a danger that parity
	* will always be on the same device and, since parity isn't read
	* during normal operation, that device's I/O bandwidth won't be
	* used effectively. We therefore switch the parity every 1MB.
	*
	* ... at least that was, ostensibly, the theory. As a practical
	* matter unless we juggle the parity between all devices evenly, we
	* won't see any benefit. Further, occasional writes that aren't a
	* multiple of the LCM of the number of children and the minimum
	* stripe width are sufficient to avoid pessimal behavior.
	* Unfortunately, this decision created an implicit on-disk format
	* requirement that we need to support for all eternity, but only
	* for single-parity RAID-Z.
	*
	* If we intend to skip a sector in the zeroth column for padding
	* we must make sure to note this swap. We will never intend to
	* skip the first column since at least one data and one parity
	* column must appear in each row.
	*/
	ASSERT(rr->rr_cols >= 2);
	ASSERT(rr->rr_col[0].rc_size == rr->rr_col[1].rc_size);

	if (rr->rr_firstdatacol == 1 && (zio->io_offset & (1ULL << 20))) {
	devidx = rr->rr_col[0].rc_devidx;
	o = rr->rr_col[0].rc_offset;
	rr->rr_col[0].rc_devidx = rr->rr_col[1].rc_devidx;
	rr->rr_col[0].rc_offset = rr->rr_col[1].rc_offset;
	rr->rr_col[1].rc_devidx = devidx;
	rr->rr_col[1].rc_offset = o;

	if (rm->rm_skipstart == 0)
	rm->rm_skipstart = 1;
	}

	/* init RAIDZ parity ops */
	rm->rm_ops = vdev_raidz_math_get_ops();

	return (rm);
	}

	struct pqr_struct {
	uint64_t *p;
	uint64_t *q;
	uint64_t *r;
	};

	static int
	vdev_raidz_p_func(void buf, size_t size, void private)
	{
	struct pqr_struct *pqr = private;
	const uint64_t *src = buf;
	int i, cnt = size / sizeof (src[0]);

	ASSERT(pqr->p && !pqr->q && !pqr->r);

	for (i = 0; i < cnt; i++, src++, pqr->p++)
	pqr->p ^= src;

	return (0);
	}

	static int
	vdev_raidz_pq_func(void buf, size_t size, void private)
	{
	struct pqr_struct *pqr = private;
	const uint64_t *src = buf;
	uint64_t mask;
	int i, cnt = size / sizeof (src[0]);

	ASSERT(pqr->p && pqr->q && !pqr->r);

	for (i = 0; i < cnt; i++, src++, pqr->p++, pqr->q++) {
	pqr->p ^= src;
	VDEV_RAIDZ_64MUL_2(*pqr->q, mask);
	pqr->q ^= src;
	}

	return (0);
	}

	static int
	vdev_raidz_pqr_func(void buf, size_t size, void private)
	{
	struct pqr_struct *pqr = private;
	const uint64_t *src = buf;
	uint64_t mask;
	int i, cnt = size / sizeof (src[0]);

	ASSERT(pqr->p && pqr->q && pqr->r);

	for (i = 0; i < cnt; i++, src++, pqr->p++, pqr->q++, pqr->r++) {
	pqr->p ^= src;
	VDEV_RAIDZ_64MUL_2(*pqr->q, mask);
	pqr->q ^= src;
	VDEV_RAIDZ_64MUL_4(*pqr->r, mask);
	pqr->r ^= src;
	}

	return (0);
	}

	static void
	vdev_raidz_generate_parity_p(raidz_row_t *rr)
	{
	uint64_t *p = abd_to_buf(rr->rr_col[VDEV_RAIDZ_P].rc_abd);

	for (int c = rr->rr_firstdatacol; c < rr->rr_cols; c++) {
	abd_t *src = rr->rr_col[c].rc_abd;

	if (c == rr->rr_firstdatacol) {
	abd_copy_to_buf(p, src, rr->rr_col[c].rc_size);
	} else {
	struct pqr_struct pqr = { p, NULL, NULL };
	(void) abd_iterate_func(src, 0, rr->rr_col[c].rc_size,
	vdev_raidz_p_func, &pqr);
	}
	}
	}

	static void
	vdev_raidz_generate_parity_pq(raidz_row_t *rr)
	{
	uint64_t *p = abd_to_buf(rr->rr_col[VDEV_RAIDZ_P].rc_abd);
	uint64_t *q = abd_to_buf(rr->rr_col[VDEV_RAIDZ_Q].rc_abd);
	uint64_t pcnt = rr->rr_col[VDEV_RAIDZ_P].rc_size / sizeof (p[0]);
	ASSERT(rr->rr_col[VDEV_RAIDZ_P].rc_size ==
	rr->rr_col[VDEV_RAIDZ_Q].rc_size);

	for (int c = rr->rr_firstdatacol; c < rr->rr_cols; c++) {
	abd_t *src = rr->rr_col[c].rc_abd;

	uint64_t ccnt = rr->rr_col[c].rc_size / sizeof (p[0]);

	if (c == rr->rr_firstdatacol) {
	ASSERT(ccnt == pcnt \|\| ccnt == 0);
	abd_copy_to_buf(p, src, rr->rr_col[c].rc_size);
	(void) memcpy(q, p, rr->rr_col[c].rc_size);

	for (uint64_t i = ccnt; i < pcnt; i++) {
	p[i] = 0;
	q[i] = 0;
	}
	} else {
	struct pqr_struct pqr = { p, q, NULL };

	ASSERT(ccnt <= pcnt);
	(void) abd_iterate_func(src, 0, rr->rr_col[c].rc_size,
	vdev_raidz_pq_func, &pqr);

	/*
	* Treat short columns as though they are full of 0s.
	* Note that there's therefore nothing needed for P.
	*/
	uint64_t mask;
	for (uint64_t i = ccnt; i < pcnt; i++) {
	VDEV_RAIDZ_64MUL_2(q[i], mask);
	}
	}
	}
	}

	static void
	vdev_raidz_generate_parity_pqr(raidz_row_t *rr)
	{
	uint64_t *p = abd_to_buf(rr->rr_col[VDEV_RAIDZ_P].rc_abd);
	uint64_t *q = abd_to_buf(rr->rr_col[VDEV_RAIDZ_Q].rc_abd);
	uint64_t *r = abd_to_buf(rr->rr_col[VDEV_RAIDZ_R].rc_abd);
	uint64_t pcnt = rr->rr_col[VDEV_RAIDZ_P].rc_size / sizeof (p[0]);
	ASSERT(rr->rr_col[VDEV_RAIDZ_P].rc_size ==
	rr->rr_col[VDEV_RAIDZ_Q].rc_size);
	ASSERT(rr->rr_col[VDEV_RAIDZ_P].rc_size ==
	rr->rr_col[VDEV_RAIDZ_R].rc_size);

	for (int c = rr->rr_firstdatacol; c < rr->rr_cols; c++) {
	abd_t *src = rr->rr_col[c].rc_abd;

	uint64_t ccnt = rr->rr_col[c].rc_size / sizeof (p[0]);

	if (c == rr->rr_firstdatacol) {
	ASSERT(ccnt == pcnt \|\| ccnt == 0);
	abd_copy_to_buf(p, src, rr->rr_col[c].rc_size);
	(void) memcpy(q, p, rr->rr_col[c].rc_size);
	(void) memcpy(r, p, rr->rr_col[c].rc_size);

	for (uint64_t i = ccnt; i < pcnt; i++) {
	p[i] = 0;
	q[i] = 0;
	r[i] = 0;
	}
	} else {
	struct pqr_struct pqr = { p, q, r };

	ASSERT(ccnt <= pcnt);
	(void) abd_iterate_func(src, 0, rr->rr_col[c].rc_size,
	vdev_raidz_pqr_func, &pqr);

	/*
	* Treat short columns as though they are full of 0s.
	* Note that there's therefore nothing needed for P.
	*/
	uint64_t mask;
	for (uint64_t i = ccnt; i < pcnt; i++) {
	VDEV_RAIDZ_64MUL_2(q[i], mask);
	VDEV_RAIDZ_64MUL_4(r[i], mask);
	}
	}
	}
	}

	/*
	* Generate RAID parity in the first virtual columns according to the number of
	* parity columns available.
	*/
	void
	vdev_raidz_generate_parity_row(raidz_map_t rm, raidz_row_t rr)
	{
	ASSERT3U(rr->rr_cols, !=, 0);

	/* Generate using the new math implementation */
	if (vdev_raidz_math_generate(rm, rr) != RAIDZ_ORIGINAL_IMPL)
	return;

	switch (rr->rr_firstdatacol) {
	case 1:
	vdev_raidz_generate_parity_p(rr);
	break;
	case 2:
	vdev_raidz_generate_parity_pq(rr);
	break;
	case 3:
	vdev_raidz_generate_parity_pqr(rr);
	break;
	default:
	cmn_err(CE_PANIC, "invalid RAID-Z configuration");
	}
	}

	void
	vdev_raidz_generate_parity(raidz_map_t *rm)
	{
	for (int i = 0; i < rm->rm_nrows; i++) {
	raidz_row_t *rr = rm->rm_row[i];
	vdev_raidz_generate_parity_row(rm, rr);
	}
	}

	/* ARGSUSED */
	static int
	vdev_raidz_reconst_p_func(void dbuf, void sbuf, size_t size, void *private)
	{
	uint64_t *dst = dbuf;
	uint64_t *src = sbuf;
	int cnt = size / sizeof (src[0]);

	for (int i = 0; i < cnt; i++) {
	dst[i] ^= src[i];
	}

	return (0);
	}

	/* ARGSUSED */
	static int
	vdev_raidz_reconst_q_pre_func(void dbuf, void sbuf, size_t size,
	void *private)
	{
	uint64_t *dst = dbuf;
	uint64_t *src = sbuf;
	uint64_t mask;
	int cnt = size / sizeof (dst[0]);

	for (int i = 0; i < cnt; i++, dst++, src++) {
	VDEV_RAIDZ_64MUL_2(*dst, mask);
	dst ^= src;
	}

	return (0);
	}

	/* ARGSUSED */
	static int
	vdev_raidz_reconst_q_pre_tail_func(void buf, size_t size, void private)
	{
	uint64_t *dst = buf;
	uint64_t mask;
	int cnt = size / sizeof (dst[0]);

	for (int i = 0; i < cnt; i++, dst++) {
	/* same operation as vdev_raidz_reconst_q_pre_func() on dst */
	VDEV_RAIDZ_64MUL_2(*dst, mask);
	}

	return (0);
	}

	struct reconst_q_struct {
	uint64_t *q;
	int exp;
	};

	static int
	vdev_raidz_reconst_q_post_func(void buf, size_t size, void private)
	{
	struct reconst_q_struct *rq = private;
	uint64_t *dst = buf;
	int cnt = size / sizeof (dst[0]);

	for (int i = 0; i < cnt; i++, dst++, rq->q++) {
	int j;
	uint8_t *b;

	dst ^= rq->q;
	for (j = 0, b = (uint8_t *)dst; j < 8; j++, b++) {
	b = vdev_raidz_exp2(b, rq->exp);
	}
	}

	return (0);
	}

	struct reconst_pq_struct {
	uint8_t *p;
	uint8_t *q;
	uint8_t *pxy;
	uint8_t *qxy;
	int aexp;
	int bexp;
	};

	static int
	vdev_raidz_reconst_pq_func(void xbuf, void ybuf, size_t size, void *private)
	{
	struct reconst_pq_struct *rpq = private;
	uint8_t *xd = xbuf;
	uint8_t *yd = ybuf;

	for (int i = 0; i < size;
	i++, rpq->p++, rpq->q++, rpq->pxy++, rpq->qxy++, xd++, yd++) {
	xd = vdev_raidz_exp2(rpq->p ^ *rpq->pxy, rpq->aexp) ^
	vdev_raidz_exp2(rpq->q ^ rpq->qxy, rpq->bexp);
	yd = rpq->p ^ rpq->pxy ^ xd;
	}

	return (0);
	}

	static int
	vdev_raidz_reconst_pq_tail_func(void xbuf, size_t size, void private)
	{
	struct reconst_pq_struct *rpq = private;
	uint8_t *xd = xbuf;

	for (int i = 0; i < size;
	i++, rpq->p++, rpq->q++, rpq->pxy++, rpq->qxy++, xd++) {
	/* same operation as vdev_raidz_reconst_pq_func() on xd */
	xd = vdev_raidz_exp2(rpq->p ^ *rpq->pxy, rpq->aexp) ^
	vdev_raidz_exp2(rpq->q ^ rpq->qxy, rpq->bexp);
	}

	return (0);
	}

	static void
	vdev_raidz_reconstruct_p(raidz_row_t rr, int tgts, int ntgts)
	{
	int x = tgts[0];
	abd_t dst, src;

	ASSERT3U(ntgts, ==, 1);
	ASSERT3U(x, >=, rr->rr_firstdatacol);
	ASSERT3U(x, <, rr->rr_cols);

	ASSERT3U(rr->rr_col[x].rc_size, <=, rr->rr_col[VDEV_RAIDZ_P].rc_size);

	src = rr->rr_col[VDEV_RAIDZ_P].rc_abd;
	dst = rr->rr_col[x].rc_abd;

	abd_copy_from_buf(dst, abd_to_buf(src), rr->rr_col[x].rc_size);

	for (int c = rr->rr_firstdatacol; c < rr->rr_cols; c++) {
	uint64_t size = MIN(rr->rr_col[x].rc_size,
	rr->rr_col[c].rc_size);

	src = rr->rr_col[c].rc_abd;

	if (c == x)
	continue;

	(void) abd_iterate_func2(dst, src, 0, 0, size,
	vdev_raidz_reconst_p_func, NULL);
	}
	}

	static void
	vdev_raidz_reconstruct_q(raidz_row_t rr, int tgts, int ntgts)
	{
	int x = tgts[0];
	int c, exp;
	abd_t dst, src;

	ASSERT(ntgts == 1);

	ASSERT(rr->rr_col[x].rc_size <= rr->rr_col[VDEV_RAIDZ_Q].rc_size);

	for (c = rr->rr_firstdatacol; c < rr->rr_cols; c++) {
	uint64_t size = (c == x) ? 0 : MIN(rr->rr_col[x].rc_size,
	rr->rr_col[c].rc_size);

	src = rr->rr_col[c].rc_abd;
	dst = rr->rr_col[x].rc_abd;

	if (c == rr->rr_firstdatacol) {
	abd_copy(dst, src, size);
	if (rr->rr_col[x].rc_size > size) {
	abd_zero_off(dst, size,
	rr->rr_col[x].rc_size - size);
	}
	} else {
	ASSERT3U(size, <=, rr->rr_col[x].rc_size);
	(void) abd_iterate_func2(dst, src, 0, 0, size,
	vdev_raidz_reconst_q_pre_func, NULL);
	(void) abd_iterate_func(dst,
	size, rr->rr_col[x].rc_size - size,
	vdev_raidz_reconst_q_pre_tail_func, NULL);
	}
	}

	src = rr->rr_col[VDEV_RAIDZ_Q].rc_abd;
	dst = rr->rr_col[x].rc_abd;
	exp = 255 - (rr->rr_cols - 1 - x);

	struct reconst_q_struct rq = { abd_to_buf(src), exp };
	(void) abd_iterate_func(dst, 0, rr->rr_col[x].rc_size,
	vdev_raidz_reconst_q_post_func, &rq);
	}

	static void
	vdev_raidz_reconstruct_pq(raidz_row_t rr, int tgts, int ntgts)
	{
	uint8_t p, q, pxy, qxy, tmp, a, b, aexp, bexp;
	abd_t pdata, qdata;
	uint64_t xsize, ysize;
	int x = tgts[0];
	int y = tgts[1];
	abd_t xd, yd;

	ASSERT(ntgts == 2);
	ASSERT(x < y);
	ASSERT(x >= rr->rr_firstdatacol);
	ASSERT(y < rr->rr_cols);

	ASSERT(rr->rr_col[x].rc_size >= rr->rr_col[y].rc_size);

	/*
	* Move the parity data aside -- we're going to compute parity as
	* though columns x and y were full of zeros -- Pxy and Qxy. We want to
	* reuse the parity generation mechanism without trashing the actual
	* parity so we make those columns appear to be full of zeros by
	* setting their lengths to zero.
	*/
	pdata = rr->rr_col[VDEV_RAIDZ_P].rc_abd;
	qdata = rr->rr_col[VDEV_RAIDZ_Q].rc_abd;
	xsize = rr->rr_col[x].rc_size;
	ysize = rr->rr_col[y].rc_size;

	rr->rr_col[VDEV_RAIDZ_P].rc_abd =
	abd_alloc_linear(rr->rr_col[VDEV_RAIDZ_P].rc_size, B_TRUE);
	rr->rr_col[VDEV_RAIDZ_Q].rc_abd =
	abd_alloc_linear(rr->rr_col[VDEV_RAIDZ_Q].rc_size, B_TRUE);
	rr->rr_col[x].rc_size = 0;
	rr->rr_col[y].rc_size = 0;

	vdev_raidz_generate_parity_pq(rr);

	rr->rr_col[x].rc_size = xsize;
	rr->rr_col[y].rc_size = ysize;

	p = abd_to_buf(pdata);
	q = abd_to_buf(qdata);
	pxy = abd_to_buf(rr->rr_col[VDEV_RAIDZ_P].rc_abd);
	qxy = abd_to_buf(rr->rr_col[VDEV_RAIDZ_Q].rc_abd);
	xd = rr->rr_col[x].rc_abd;
	yd = rr->rr_col[y].rc_abd;

	/*
	* We now have:
	* Pxy = P + D_x + D_y
	* Qxy = Q + 2^(ndevs - 1 - x) * D_x + 2^(ndevs - 1 - y) * D_y
	*
	* We can then solve for D_x:
	* D_x = A * (P + Pxy) + B * (Q + Qxy)
	* where
	* A = 2^(x - y) * (2^(x - y) + 1)^-1
	* B = 2^(ndevs - 1 - x) * (2^(x - y) + 1)^-1
	*
	* With D_x in hand, we can easily solve for D_y:
	* D_y = P + Pxy + D_x
	*/

	a = vdev_raidz_pow2[255 + x - y];
	b = vdev_raidz_pow2[255 - (rr->rr_cols - 1 - x)];
	tmp = 255 - vdev_raidz_log2[a ^ 1];

	aexp = vdev_raidz_log2[vdev_raidz_exp2(a, tmp)];
	bexp = vdev_raidz_log2[vdev_raidz_exp2(b, tmp)];

	ASSERT3U(xsize, >=, ysize);
	struct reconst_pq_struct rpq = { p, q, pxy, qxy, aexp, bexp };

	(void) abd_iterate_func2(xd, yd, 0, 0, ysize,
	vdev_raidz_reconst_pq_func, &rpq);
	(void) abd_iterate_func(xd, ysize, xsize - ysize,
	vdev_raidz_reconst_pq_tail_func, &rpq);

	abd_free(rr->rr_col[VDEV_RAIDZ_P].rc_abd);
	abd_free(rr->rr_col[VDEV_RAIDZ_Q].rc_abd);

	/*
	* Restore the saved parity data.
	*/
	rr->rr_col[VDEV_RAIDZ_P].rc_abd = pdata;
	rr->rr_col[VDEV_RAIDZ_Q].rc_abd = qdata;
	}

	/* BEGIN CSTYLED */
	/*
	* In the general case of reconstruction, we must solve the system of linear
	* equations defined by the coefficients used to generate parity as well as
	* the contents of the data and parity disks. This can be expressed with
	* vectors for the original data (D) and the actual data (d) and parity (p)
	* and a matrix composed of the identity matrix (I) and a dispersal matrix (V):
	*
	* __ __ __ __
	* \| \| __ __ \| p_0 \|
	* \| V \| \| D_0 \| \| p_m-1 \|
	* \| \| x \| : \| = \| d_0 \|
	* \| I \| \| D_n-1 \| \| : \|
	* \| \| ~~ ~~ \| d_n-1 \|
	* ~~ ~~ ~~ ~~
	*
	* I is simply a square identity matrix of size n, and V is a vandermonde
	* matrix defined by the coefficients we chose for the various parity columns
	* (1, 2, 4). Note that these values were chosen both for simplicity, speedy
	* computation as well as linear separability.
	*
	* __ __ __ __
	* \| 1 .. 1 1 1 \| \| p_0 \|
	* \| 2^n-1 .. 4 2 1 \| __ __ \| : \|
	* \| 4^n-1 .. 16 4 1 \| \| D_0 \| \| p_m-1 \|
	* \| 1 .. 0 0 0 \| \| D_1 \| \| d_0 \|
	* \| 0 .. 0 0 0 \| x \| D_2 \| = \| d_1 \|
	* \| : : : : \| \| : \| \| d_2 \|
	* \| 0 .. 1 0 0 \| \| D_n-1 \| \| : \|
	* \| 0 .. 0 1 0 \| ~~ ~~ \| : \|
	* \| 0 .. 0 0 1 \| \| d_n-1 \|
	* ~~ ~~ ~~ ~~
	*
	* Note that I, V, d, and p are known. To compute D, we must invert the
	* matrix and use the known data and parity values to reconstruct the unknown
	* data values. We begin by removing the rows in V\|I and d\|p that correspond
	* to failed or missing columns; we then make V\|I square (n x n) and d\|p
	* sized n by removing rows corresponding to unused parity from the bottom up
	* to generate (V\|I)' and (d\|p)'. We can then generate the inverse of (V\|I)'
	* using Gauss-Jordan elimination. In the example below we use m=3 parity
	* columns, n=8 data columns, with errors in d_1, d_2, and p_1:
	* __ __
	* \| 1 1 1 1 1 1 1 1 \|
	* \| 128 64 32 16 8 4 2 1 \| <-----+-+-- missing disks
	* \| 19 205 116 29 64 16 4 1 \| / /
	* \| 1 0 0 0 0 0 0 0 \| / /
	* \| 0 1 0 0 0 0 0 0 \| <--' /
	* (V\|I) = \| 0 0 1 0 0 0 0 0 \| <---'
	* \| 0 0 0 1 0 0 0 0 \|
	* \| 0 0 0 0 1 0 0 0 \|
	* \| 0 0 0 0 0 1 0 0 \|
	* \| 0 0 0 0 0 0 1 0 \|
	* \| 0 0 0 0 0 0 0 1 \|
	* ~~ ~~
	* __ __
	* \| 1 1 1 1 1 1 1 1 \|
	* \| 128 64 32 16 8 4 2 1 \|
	* \| 19 205 116 29 64 16 4 1 \|
	* \| 1 0 0 0 0 0 0 0 \|
	* \| 0 1 0 0 0 0 0 0 \|
	* (V\|I)' = \| 0 0 1 0 0 0 0 0 \|
	* \| 0 0 0 1 0 0 0 0 \|
	* \| 0 0 0 0 1 0 0 0 \|
	* \| 0 0 0 0 0 1 0 0 \|
	* \| 0 0 0 0 0 0 1 0 \|
	* \| 0 0 0 0 0 0 0 1 \|
	* ~~ ~~
	*
	* Here we employ Gauss-Jordan elimination to find the inverse of (V\|I)'. We
	* have carefully chosen the seed values 1, 2, and 4 to ensure that this
	* matrix is not singular.
	* __ __
	* \| 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 \|
	* \| 19 205 116 29 64 16 4 1 0 1 0 0 0 0 0 0 \|
	* \| 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 \|
	* \| 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 \|
	* \| 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 \|
	* \| 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 \|
	* \| 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 \|
	* \| 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 \|
	* ~~ ~~
	* __ __
	* \| 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 \|
	* \| 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 \|
	* \| 19 205 116 29 64 16 4 1 0 1 0 0 0 0 0 0 \|
	* \| 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 \|
	* \| 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 \|
	* \| 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 \|
	* \| 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 \|
	* \| 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 \|
	* ~~ ~~
	* __ __
	* \| 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 \|
	* \| 0 1 1 0 0 0 0 0 1 0 1 1 1 1 1 1 \|
	* \| 0 205 116 0 0 0 0 0 0 1 19 29 64 16 4 1 \|
	* \| 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 \|
	* \| 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 \|
	* \| 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 \|
	* \| 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 \|
	* \| 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 \|
	* ~~ ~~
	* __ __
	* \| 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 \|
	* \| 0 1 1 0 0 0 0 0 1 0 1 1 1 1 1 1 \|
	* \| 0 0 185 0 0 0 0 0 205 1 222 208 141 221 201 204 \|
	* \| 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 \|
	* \| 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 \|
	* \| 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 \|
	* \| 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 \|
	* \| 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 \|
	* ~~ ~~
	* __ __
	* \| 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 \|
	* \| 0 1 1 0 0 0 0 0 1 0 1 1 1 1 1 1 \|
	* \| 0 0 1 0 0 0 0 0 166 100 4 40 158 168 216 209 \|
	* \| 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 \|
	* \| 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 \|
	* \| 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 \|
	* \| 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 \|
	* \| 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 \|
	* ~~ ~~
	* __ __
	* \| 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 \|
	* \| 0 1 0 0 0 0 0 0 167 100 5 41 159 169 217 208 \|
	* \| 0 0 1 0 0 0 0 0 166 100 4 40 158 168 216 209 \|
	* \| 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 \|
	* \| 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 \|
	* \| 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 \|
	* \| 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 \|
	* \| 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 \|
	* ~~ ~~
	* __ __
	* \| 0 0 1 0 0 0 0 0 \|
	* \| 167 100 5 41 159 169 217 208 \|
	* \| 166 100 4 40 158 168 216 209 \|
	* (V\|I)'^-1 = \| 0 0 0 1 0 0 0 0 \|
	* \| 0 0 0 0 1 0 0 0 \|
	* \| 0 0 0 0 0 1 0 0 \|
	* \| 0 0 0 0 0 0 1 0 \|
	* \| 0 0 0 0 0 0 0 1 \|
	* ~~ ~~
	*
	* We can then simply compute D = (V\|I)'^-1 x (d\|p)' to discover the values
	* of the missing data.
	*
	* As is apparent from the example above, the only non-trivial rows in the
	* inverse matrix correspond to the data disks that we're trying to
	* reconstruct. Indeed, those are the only rows we need as the others would
	* only be useful for reconstructing data known or assumed to be valid. For
	* that reason, we only build the coefficients in the rows that correspond to
	* targeted columns.
	*/
	/* END CSTYLED */

	static void
	vdev_raidz_matrix_init(raidz_row_t rr, int n, int nmap, int map,
	uint8_t **rows)
	{
	int i, j;
	int pow;

	ASSERT(n == rr->rr_cols - rr->rr_firstdatacol);

	/*
	* Fill in the missing rows of interest.
	*/
	for (i = 0; i < nmap; i++) {
	ASSERT3S(0, <=, map[i]);
	ASSERT3S(map[i], <=, 2);

	pow = map[i] * n;
	if (pow > 255)
	pow -= 255;
	ASSERT(pow <= 255);

	for (j = 0; j < n; j++) {
	pow -= map[i];
	if (pow < 0)
	pow += 255;
	rows[i][j] = vdev_raidz_pow2[pow];
	}
	}
	}

	static void
	vdev_raidz_matrix_invert(raidz_row_t rr, int n, int nmissing, int missing,
	uint8_t rows, uint8_t invrows, const uint8_t *used)
	{
	int i, j, ii, jj;
	uint8_t log;

	/*
	* Assert that the first nmissing entries from the array of used
	* columns correspond to parity columns and that subsequent entries
	* correspond to data columns.
	*/
	for (i = 0; i < nmissing; i++) {
	ASSERT3S(used[i], <, rr->rr_firstdatacol);
	}
	for (; i < n; i++) {
	ASSERT3S(used[i], >=, rr->rr_firstdatacol);
	}

	/*
	* First initialize the storage where we'll compute the inverse rows.
	*/
	for (i = 0; i < nmissing; i++) {
	for (j = 0; j < n; j++) {
	invrows[i][j] = (i == j) ? 1 : 0;
	}
	}

	/*
	* Subtract all trivial rows from the rows of consequence.
	*/
	for (i = 0; i < nmissing; i++) {
	for (j = nmissing; j < n; j++) {
	ASSERT3U(used[j], >=, rr->rr_firstdatacol);
	jj = used[j] - rr->rr_firstdatacol;
	ASSERT3S(jj, <, n);
	invrows[i][j] = rows[i][jj];
	rows[i][jj] = 0;
	}
	}

	/*
	* For each of the rows of interest, we must normalize it and subtract
	* a multiple of it from the other rows.
	*/
	for (i = 0; i < nmissing; i++) {
	for (j = 0; j < missing[i]; j++) {
	ASSERT0(rows[i][j]);
	}
	ASSERT3U(rows[i][missing[i]], !=, 0);

	/*
	* Compute the inverse of the first element and multiply each
	* element in the row by that value.
	*/
	log = 255 - vdev_raidz_log2[rows[i][missing[i]]];

	for (j = 0; j < n; j++) {
	rows[i][j] = vdev_raidz_exp2(rows[i][j], log);
	invrows[i][j] = vdev_raidz_exp2(invrows[i][j], log);
	}

	for (ii = 0; ii < nmissing; ii++) {
	if (i == ii)
	continue;

	ASSERT3U(rows[ii][missing[i]], !=, 0);

	log = vdev_raidz_log2[rows[ii][missing[i]]];

	for (j = 0; j < n; j++) {
	rows[ii][j] ^=
	vdev_raidz_exp2(rows[i][j], log);
	invrows[ii][j] ^=
	vdev_raidz_exp2(invrows[i][j], log);
	}
	}
	}

	/*
	* Verify that the data that is left in the rows are properly part of
	* an identity matrix.
	*/
	for (i = 0; i < nmissing; i++) {
	for (j = 0; j < n; j++) {
	if (j == missing[i]) {
	ASSERT3U(rows[i][j], ==, 1);
	} else {
	ASSERT0(rows[i][j]);
	}
	}
	}
	}

	static void
	vdev_raidz_matrix_reconstruct(raidz_row_t *rr, int n, int nmissing,
	int missing, uint8_t invrows, const uint8_t used)
	{
	int i, j, x, cc, c;
	uint8_t *src;
	uint64_t ccount;
	uint8_t *dst[VDEV_RAIDZ_MAXPARITY] = { NULL };
	uint64_t dcount[VDEV_RAIDZ_MAXPARITY] = { 0 };
	uint8_t log = 0;
	uint8_t val;
	int ll;
	uint8_t *invlog[VDEV_RAIDZ_MAXPARITY];
	uint8_t p, pp;
	size_t psize;

	psize = sizeof (invlog[0][0]) * n * nmissing;
	p = kmem_alloc(psize, KM_SLEEP);

	for (pp = p, i = 0; i < nmissing; i++) {
	invlog[i] = pp;
	pp += n;
	}

	for (i = 0; i < nmissing; i++) {
	for (j = 0; j < n; j++) {
	ASSERT3U(invrows[i][j], !=, 0);
	invlog[i][j] = vdev_raidz_log2[invrows[i][j]];
	}
	}

	for (i = 0; i < n; i++) {
	c = used[i];
	ASSERT3U(c, <, rr->rr_cols);

	ccount = rr->rr_col[c].rc_size;
	ASSERT(ccount >= rr->rr_col[missing[0]].rc_size \|\| i > 0);
	if (ccount == 0)
	continue;
	src = abd_to_buf(rr->rr_col[c].rc_abd);
	for (j = 0; j < nmissing; j++) {
	cc = missing[j] + rr->rr_firstdatacol;
	ASSERT3U(cc, >=, rr->rr_firstdatacol);
	ASSERT3U(cc, <, rr->rr_cols);
	ASSERT3U(cc, !=, c);

	dcount[j] = rr->rr_col[cc].rc_size;
	if (dcount[j] != 0)
	dst[j] = abd_to_buf(rr->rr_col[cc].rc_abd);
	}

	for (x = 0; x < ccount; x++, src++) {
	if (*src != 0)
	log = vdev_raidz_log2[*src];

	for (cc = 0; cc < nmissing; cc++) {
	if (x >= dcount[cc])
	continue;

	if (*src == 0) {
	val = 0;
	} else {
	if ((ll = log + invlog[cc][i]) >= 255)
	ll -= 255;
	val = vdev_raidz_pow2[ll];
	}

	if (i == 0)
	dst[cc][x] = val;
	else
	dst[cc][x] ^= val;
	}
	}
	}

	kmem_free(p, psize);
	}

	static void
	vdev_raidz_reconstruct_general(raidz_row_t rr, int tgts, int ntgts)
	{
	int n, i, c, t, tt;
	int nmissing_rows;
	int missing_rows[VDEV_RAIDZ_MAXPARITY];
	int parity_map[VDEV_RAIDZ_MAXPARITY];
	uint8_t p, pp;
	size_t psize;
	uint8_t *rows[VDEV_RAIDZ_MAXPARITY];
	uint8_t *invrows[VDEV_RAIDZ_MAXPARITY];
	uint8_t *used;

	abd_t **bufs = NULL;

	/*
	* Matrix reconstruction can't use scatter ABDs yet, so we allocate
	* temporary linear ABDs if any non-linear ABDs are found.
	*/
	for (i = rr->rr_firstdatacol; i < rr->rr_cols; i++) {
	if (!abd_is_linear(rr->rr_col[i].rc_abd)) {
	bufs = kmem_alloc(rr->rr_cols * sizeof (abd_t *),
	KM_PUSHPAGE);

	for (c = rr->rr_firstdatacol; c < rr->rr_cols; c++) {
	raidz_col_t *col = &rr->rr_col[c];

	bufs[c] = col->rc_abd;
	if (bufs[c] != NULL) {
	col->rc_abd = abd_alloc_linear(
	col->rc_size, B_TRUE);
	abd_copy(col->rc_abd, bufs[c],
	col->rc_size);
	}
	}

	break;
	}
	}

	n = rr->rr_cols - rr->rr_firstdatacol;

	/*
	* Figure out which data columns are missing.
	*/
	nmissing_rows = 0;
	for (t = 0; t < ntgts; t++) {
	if (tgts[t] >= rr->rr_firstdatacol) {
	missing_rows[nmissing_rows++] =
	tgts[t] - rr->rr_firstdatacol;
	}
	}

	/*
	* Figure out which parity columns to use to help generate the missing
	* data columns.
	*/
	for (tt = 0, c = 0, i = 0; i < nmissing_rows; c++) {
	ASSERT(tt < ntgts);
	ASSERT(c < rr->rr_firstdatacol);

	/*
	* Skip any targeted parity columns.
	*/
	if (c == tgts[tt]) {
	tt++;
	continue;
	}

	parity_map[i] = c;
	i++;
	}

	psize = (sizeof (rows[0][0]) + sizeof (invrows[0][0])) *
	nmissing_rows * n + sizeof (used[0]) * n;
	p = kmem_alloc(psize, KM_SLEEP);

	for (pp = p, i = 0; i < nmissing_rows; i++) {
	rows[i] = pp;
	pp += n;
	invrows[i] = pp;
	pp += n;
	}
	used = pp;

	for (i = 0; i < nmissing_rows; i++) {
	used[i] = parity_map[i];
	}

	for (tt = 0, c = rr->rr_firstdatacol; c < rr->rr_cols; c++) {
	if (tt < nmissing_rows &&
	c == missing_rows[tt] + rr->rr_firstdatacol) {
	tt++;
	continue;
	}

	ASSERT3S(i, <, n);
	used[i] = c;
	i++;
	}

	/*
	* Initialize the interesting rows of the matrix.
	*/
	vdev_raidz_matrix_init(rr, n, nmissing_rows, parity_map, rows);

	/*
	* Invert the matrix.
	*/
	vdev_raidz_matrix_invert(rr, n, nmissing_rows, missing_rows, rows,
	invrows, used);

	/*
	* Reconstruct the missing data using the generated matrix.
	*/
	vdev_raidz_matrix_reconstruct(rr, n, nmissing_rows, missing_rows,
	invrows, used);

	kmem_free(p, psize);

	/*
	* copy back from temporary linear abds and free them
	*/
	if (bufs) {
	for (c = rr->rr_firstdatacol; c < rr->rr_cols; c++) {
	raidz_col_t *col = &rr->rr_col[c];

	if (bufs[c] != NULL) {
	abd_copy(bufs[c], col->rc_abd, col->rc_size);
	abd_free(col->rc_abd);
	}
	col->rc_abd = bufs[c];
	}
	kmem_free(bufs, rr->rr_cols * sizeof (abd_t *));
	}
	}

	static void
	vdev_raidz_reconstruct_row(raidz_map_t rm, raidz_row_t rr,
	const int *t, int nt)
	{
	int tgts[VDEV_RAIDZ_MAXPARITY], *dt;
	int ntgts;
	int i, c, ret;
	int nbadparity, nbaddata;
	int parity_valid[VDEV_RAIDZ_MAXPARITY];

	nbadparity = rr->rr_firstdatacol;
	nbaddata = rr->rr_cols - nbadparity;
	ntgts = 0;
	for (i = 0, c = 0; c < rr->rr_cols; c++) {
	if (c < rr->rr_firstdatacol)
	parity_valid[c] = B_FALSE;

	if (i < nt && c == t[i]) {
	tgts[ntgts++] = c;
	i++;
	} else if (rr->rr_col[c].rc_error != 0) {
	tgts[ntgts++] = c;
	} else if (c >= rr->rr_firstdatacol) {
	nbaddata--;
	} else {
	parity_valid[c] = B_TRUE;
	nbadparity--;
	}
	}

	ASSERT(ntgts >= nt);
	ASSERT(nbaddata >= 0);
	ASSERT(nbaddata + nbadparity == ntgts);

	dt = &tgts[nbadparity];

	/* Reconstruct using the new math implementation */
	ret = vdev_raidz_math_reconstruct(rm, rr, parity_valid, dt, nbaddata);
	if (ret != RAIDZ_ORIGINAL_IMPL)
	return;

	/*
	* See if we can use any of our optimized reconstruction routines.
	*/
	switch (nbaddata) {
	case 1:
	if (parity_valid[VDEV_RAIDZ_P]) {
	vdev_raidz_reconstruct_p(rr, dt, 1);
	return;
	}

	ASSERT(rr->rr_firstdatacol > 1);

	if (parity_valid[VDEV_RAIDZ_Q]) {
	vdev_raidz_reconstruct_q(rr, dt, 1);
	return;
	}

	ASSERT(rr->rr_firstdatacol > 2);
	break;

	case 2:
	ASSERT(rr->rr_firstdatacol > 1);

	if (parity_valid[VDEV_RAIDZ_P] &&
	parity_valid[VDEV_RAIDZ_Q]) {
	vdev_raidz_reconstruct_pq(rr, dt, 2);
	return;
	}

	ASSERT(rr->rr_firstdatacol > 2);

	break;
	}

	vdev_raidz_reconstruct_general(rr, tgts, ntgts);
	}

	static int
	vdev_raidz_open(vdev_t vd, uint64_t asize, uint64_t *max_asize,
	uint64_t logical_ashift, uint64_t physical_ashift)
	{
	vdev_raidz_t *vdrz = vd->vdev_tsd;
	uint64_t nparity = vdrz->vd_nparity;
	int c;
	int lasterror = 0;
	int numerrors = 0;

	ASSERT(nparity > 0);

	if (nparity > VDEV_RAIDZ_MAXPARITY \|\|
	vd->vdev_children < nparity + 1) {
	vd->vdev_stat.vs_aux = VDEV_AUX_BAD_LABEL;
	return (SET_ERROR(EINVAL));
	}

	vdev_open_children(vd);

	for (c = 0; c < vd->vdev_children; c++) {
	vdev_t *cvd = vd->vdev_child[c];

	if (cvd->vdev_open_error != 0) {
	lasterror = cvd->vdev_open_error;
	numerrors++;
	continue;
	}

	asize = MIN(asize - 1, cvd->vdev_asize - 1) + 1;
	max_asize = MIN(max_asize - 1, cvd->vdev_max_asize - 1) + 1;
	logical_ashift = MAX(logical_ashift, cvd->vdev_ashift);
	physical_ashift = MAX(physical_ashift,
	cvd->vdev_physical_ashift);
	}

	asize = vd->vdev_children;
	max_asize = vd->vdev_children;

	if (numerrors > nparity) {
	vd->vdev_stat.vs_aux = VDEV_AUX_NO_REPLICAS;
	return (lasterror);
	}

	return (0);
	}

	static void
	vdev_raidz_close(vdev_t *vd)
	{
	for (int c = 0; c < vd->vdev_children; c++) {
	if (vd->vdev_child[c] != NULL)
	vdev_close(vd->vdev_child[c]);
	}
	}

	static uint64_t
	vdev_raidz_asize(vdev_t *vd, uint64_t psize)
	{
	vdev_raidz_t *vdrz = vd->vdev_tsd;
	uint64_t asize;
	uint64_t ashift = vd->vdev_top->vdev_ashift;
	uint64_t cols = vdrz->vd_logical_width;
	uint64_t nparity = vdrz->vd_nparity;

	asize = ((psize - 1) >> ashift) + 1;
	asize += nparity * ((asize + cols - nparity - 1) / (cols - nparity));
	asize = roundup(asize, nparity + 1) << ashift;

	return (asize);
	}

	/*
	* The allocatable space for a raidz vdev is N * sizeof(smallest child)
	* so each child must provide at least 1/Nth of its asize.
	*/
	static uint64_t
	vdev_raidz_min_asize(vdev_t *vd)
	{
	return ((vd->vdev_min_asize + vd->vdev_children - 1) /
	vd->vdev_children);
	}

	void
	vdev_raidz_child_done(zio_t *zio)
	{
	raidz_col_t *rc = zio->io_private;

	rc->rc_error = zio->io_error;
	rc->rc_tried = 1;
	rc->rc_skipped = 0;
	}

	static void
	vdev_raidz_io_verify(vdev_t vd, raidz_row_t rr, int col)
	{
	#ifdef ZFS_DEBUG
	vdev_t *tvd = vd->vdev_top;

	range_seg64_t logical_rs, physical_rs, remain_rs;
	logical_rs.rs_start = rr->rr_offset;
	logical_rs.rs_end = logical_rs.rs_start +
	vdev_raidz_asize(vd, rr->rr_size);

	raidz_col_t *rc = &rr->rr_col[col];
	vdev_t *cvd = vd->vdev_child[rc->rc_devidx];

	vdev_xlate(cvd, &logical_rs, &physical_rs, &remain_rs);
	ASSERT(vdev_xlate_is_empty(&remain_rs));
	ASSERT3U(rc->rc_offset, ==, physical_rs.rs_start);
	ASSERT3U(rc->rc_offset, <, physical_rs.rs_end);
	/*
	* It would be nice to assert that rs_end is equal
	* to rc_offset + rc_size but there might be an
	* optional I/O at the end that is not accounted in
	* rc_size.
	*/
	if (physical_rs.rs_end > rc->rc_offset + rc->rc_size) {
	ASSERT3U(physical_rs.rs_end, ==, rc->rc_offset +
	rc->rc_size + (1 << tvd->vdev_ashift));
	} else {
	ASSERT3U(physical_rs.rs_end, ==, rc->rc_offset + rc->rc_size);
	}
	#endif
	}

	static void
	vdev_raidz_io_start_write(zio_t zio, raidz_row_t rr, uint64_t ashift)
	{
	vdev_t *vd = zio->io_vd;
	raidz_map_t *rm = zio->io_vsd;
	int c, i;

	vdev_raidz_generate_parity_row(rm, rr);

	for (int c = 0; c < rr->rr_cols; c++) {
	raidz_col_t *rc = &rr->rr_col[c];
	if (rc->rc_size == 0)
	continue;

	/* Verify physical to logical translation */
	vdev_raidz_io_verify(vd, rr, c);

	zio_nowait(zio_vdev_child_io(zio, NULL,
	vd->vdev_child[rc->rc_devidx], rc->rc_offset,
	rc->rc_abd, rc->rc_size, zio->io_type, zio->io_priority,
	0, vdev_raidz_child_done, rc));
	}

	/*
	* Generate optional I/Os for skip sectors to improve aggregation
	* contiguity.
	*/
	for (c = rm->rm_skipstart, i = 0; i < rm->rm_nskip; c++, i++) {
	ASSERT(c <= rr->rr_scols);
	if (c == rr->rr_scols)
	c = 0;

	raidz_col_t *rc = &rr->rr_col[c];
	vdev_t *cvd = vd->vdev_child[rc->rc_devidx];

	zio_nowait(zio_vdev_child_io(zio, NULL, cvd,
	rc->rc_offset + rc->rc_size, NULL, 1ULL << ashift,
	zio->io_type, zio->io_priority,
	ZIO_FLAG_NODATA \| ZIO_FLAG_OPTIONAL, NULL, NULL));
	}
	}

	static void
	vdev_raidz_io_start_read(zio_t zio, raidz_row_t rr)
	{
	vdev_t *vd = zio->io_vd;

	/*
	* Iterate over the columns in reverse order so that we hit the parity
	* last -- any errors along the way will force us to read the parity.
	*/
	for (int c = rr->rr_cols - 1; c >= 0; c--) {
	raidz_col_t *rc = &rr->rr_col[c];
	if (rc->rc_size == 0)
	continue;
	vdev_t *cvd = vd->vdev_child[rc->rc_devidx];
	if (!vdev_readable(cvd)) {
	if (c >= rr->rr_firstdatacol)
	rr->rr_missingdata++;
	else
	rr->rr_missingparity++;
	rc->rc_error = SET_ERROR(ENXIO);
	rc->rc_tried = 1; /* don't even try */
	rc->rc_skipped = 1;
	continue;
	}
	if (vdev_dtl_contains(cvd, DTL_MISSING, zio->io_txg, 1)) {
	if (c >= rr->rr_firstdatacol)
	rr->rr_missingdata++;
	else
	rr->rr_missingparity++;
	rc->rc_error = SET_ERROR(ESTALE);
	rc->rc_skipped = 1;
	continue;
	}
	if (c >= rr->rr_firstdatacol \|\| rr->rr_missingdata > 0 \|\|
	(zio->io_flags & (ZIO_FLAG_SCRUB \| ZIO_FLAG_RESILVER))) {
	zio_nowait(zio_vdev_child_io(zio, NULL, cvd,
	rc->rc_offset, rc->rc_abd, rc->rc_size,
	zio->io_type, zio->io_priority, 0,
	vdev_raidz_child_done, rc));
	}
	}
	}

	/*
	* Start an IO operation on a RAIDZ VDev
	*
	* Outline:
	* - For write operations:
	* 1. Generate the parity data
	* 2. Create child zio write operations to each column's vdev, for both
	* data and parity.
	* 3. If the column skips any sectors for padding, create optional dummy
	* write zio children for those areas to improve aggregation continuity.
	* - For read operations:
	* 1. Create child zio read operations to each data column's vdev to read
	* the range of data required for zio.
	* 2. If this is a scrub or resilver operation, or if any of the data
	* vdevs have had errors, then create zio read operations to the parity
	* columns' VDevs as well.
	*/
	static void
	vdev_raidz_io_start(zio_t *zio)
	{
	vdev_t *vd = zio->io_vd;
	vdev_t *tvd = vd->vdev_top;
	vdev_raidz_t *vdrz = vd->vdev_tsd;

	raidz_map_t *rm = vdev_raidz_map_alloc(zio, tvd->vdev_ashift,
	vdrz->vd_logical_width, vdrz->vd_nparity);
	zio->io_vsd = rm;
	zio->io_vsd_ops = &vdev_raidz_vsd_ops;

	/*
	* Until raidz expansion is implemented all maps for a raidz vdev
	* contain a single row.
	*/
	ASSERT3U(rm->rm_nrows, ==, 1);
	raidz_row_t *rr = rm->rm_row[0];

	if (zio->io_type == ZIO_TYPE_WRITE) {
	vdev_raidz_io_start_write(zio, rr, tvd->vdev_ashift);
	} else {
	ASSERT(zio->io_type == ZIO_TYPE_READ);
	vdev_raidz_io_start_read(zio, rr);
	}

	zio_execute(zio);
	}

	/*
	* Report a checksum error for a child of a RAID-Z device.
	*/
	static void
	raidz_checksum_error(zio_t zio, raidz_col_t rc, abd_t *bad_data)
	{
	vdev_t *vd = zio->io_vd->vdev_child[rc->rc_devidx];

	if (!(zio->io_flags & ZIO_FLAG_SPECULATIVE) &&
	zio->io_priority != ZIO_PRIORITY_REBUILD) {
	zio_bad_cksum_t zbc;
	raidz_map_t *rm = zio->io_vsd;

	zbc.zbc_has_cksum = 0;
	zbc.zbc_injected = rm->rm_ecksuminjected;

	(void) zfs_ereport_post_checksum(zio->io_spa, vd,
	&zio->io_bookmark, zio, rc->rc_offset, rc->rc_size,
	rc->rc_abd, bad_data, &zbc);
	mutex_enter(&vd->vdev_stat_lock);
	vd->vdev_stat.vs_checksum_errors++;
	mutex_exit(&vd->vdev_stat_lock);
	}
	}

	/*
	* We keep track of whether or not there were any injected errors, so that
	* any ereports we generate can note it.
	*/
	static int
	raidz_checksum_verify(zio_t *zio)
	{
	zio_bad_cksum_t zbc;
	raidz_map_t *rm = zio->io_vsd;

	bzero(&zbc, sizeof (zio_bad_cksum_t));

	int ret = zio_checksum_error(zio, &zbc);
	if (ret != 0 && zbc.zbc_injected != 0)
	rm->rm_ecksuminjected = 1;

	return (ret);
	}

	/*
	* Generate the parity from the data columns. If we tried and were able to
	* read the parity without error, verify that the generated parity matches the
	* data we read. If it doesn't, we fire off a checksum error. Return the
	* number of such failures.
	*/
	static int
	raidz_parity_verify(zio_t zio, raidz_row_t rr)
	{
	abd_t *orig[VDEV_RAIDZ_MAXPARITY];
	int c, ret = 0;
	raidz_map_t *rm = zio->io_vsd;
	raidz_col_t *rc;

	blkptr_t *bp = zio->io_bp;
	enum zio_checksum checksum = (bp == NULL ? zio->io_prop.zp_checksum :
	(BP_IS_GANG(bp) ? ZIO_CHECKSUM_GANG_HEADER : BP_GET_CHECKSUM(bp)));

	if (checksum == ZIO_CHECKSUM_NOPARITY)
	return (ret);

	for (c = 0; c < rr->rr_firstdatacol; c++) {
	rc = &rr->rr_col[c];
	if (!rc->rc_tried \|\| rc->rc_error != 0)
	continue;

	orig[c] = abd_alloc_sametype(rc->rc_abd, rc->rc_size);
	abd_copy(orig[c], rc->rc_abd, rc->rc_size);
	}

	/*
	* Regenerates parity even for !tried\|\|rc_error!=0 columns. This
	* isn't harmful but it does have the side effect of fixing stuff
	* we didn't realize was necessary (i.e. even if we return 0).
	*/
	vdev_raidz_generate_parity_row(rm, rr);

	for (c = 0; c < rr->rr_firstdatacol; c++) {
	rc = &rr->rr_col[c];

	if (!rc->rc_tried \|\| rc->rc_error != 0)
	continue;

	if (abd_cmp(orig[c], rc->rc_abd) != 0) {
	raidz_checksum_error(zio, rc, orig[c]);
	rc->rc_error = SET_ERROR(ECKSUM);
	ret++;
	}
	abd_free(orig[c]);
	}

	return (ret);
	}

	static int
	vdev_raidz_worst_error(raidz_row_t *rr)
	{
	int error = 0;

	for (int c = 0; c < rr->rr_cols; c++)
	error = zio_worst_error(error, rr->rr_col[c].rc_error);

	return (error);
	}

	static void
	vdev_raidz_io_done_verified(zio_t zio, raidz_row_t rr)
	{
	int unexpected_errors = 0;
	int parity_errors = 0;
	int parity_untried = 0;
	int data_errors = 0;

	ASSERT3U(zio->io_type, ==, ZIO_TYPE_READ);

	for (int c = 0; c < rr->rr_cols; c++) {
	raidz_col_t *rc = &rr->rr_col[c];

	if (rc->rc_error) {
	if (c < rr->rr_firstdatacol)
	parity_errors++;
	else
	data_errors++;

	if (!rc->rc_skipped)
	unexpected_errors++;
	} else if (c < rr->rr_firstdatacol && !rc->rc_tried) {
	parity_untried++;
	}
	}

	/*
	* If we read more parity disks than were used for
	* reconstruction, confirm that the other parity disks produced
	* correct data.
	*
	* Note that we also regenerate parity when resilvering so we
	* can write it out to failed devices later.
	*/
	if (parity_errors + parity_untried <
	rr->rr_firstdatacol - data_errors \|\|
	(zio->io_flags & ZIO_FLAG_RESILVER)) {
	int n = raidz_parity_verify(zio, rr);
	unexpected_errors += n;
	ASSERT3U(parity_errors + n, <=, rr->rr_firstdatacol);
	}

	if (zio->io_error == 0 && spa_writeable(zio->io_spa) &&
	(unexpected_errors > 0 \|\| (zio->io_flags & ZIO_FLAG_RESILVER))) {
	/*
	* Use the good data we have in hand to repair damaged children.
	*/
	for (int c = 0; c < rr->rr_cols; c++) {
	raidz_col_t *rc = &rr->rr_col[c];
	vdev_t *vd = zio->io_vd;
	vdev_t *cvd = vd->vdev_child[rc->rc_devidx];

	- if ((rc->rc_error == 0 \|\| rc->rc_size == 0) &&
	- (rc->rc_repair == 0)) {
	+ if (!rc->rc_allow_repair) {
	+ continue;
	+ } else if (!rc->rc_force_repair &&
	+ (rc->rc_error == 0 \|\| rc->rc_size == 0)) {
	continue;
	}

	zio_nowait(zio_vdev_child_io(zio, NULL, cvd,
	rc->rc_offset, rc->rc_abd, rc->rc_size,
	ZIO_TYPE_WRITE,
	zio->io_priority == ZIO_PRIORITY_REBUILD ?
	ZIO_PRIORITY_REBUILD : ZIO_PRIORITY_ASYNC_WRITE,
	ZIO_FLAG_IO_REPAIR \| (unexpected_errors ?
	ZIO_FLAG_SELF_HEAL : 0), NULL, NULL));
	}
	}
	}

	static void
	raidz_restore_orig_data(raidz_map_t *rm)
	{
	for (int i = 0; i < rm->rm_nrows; i++) {
	raidz_row_t *rr = rm->rm_row[i];
	for (int c = 0; c < rr->rr_cols; c++) {
	raidz_col_t *rc = &rr->rr_col[c];
	if (rc->rc_need_orig_restore) {
	abd_copy(rc->rc_abd,
	rc->rc_orig_data, rc->rc_size);
	rc->rc_need_orig_restore = B_FALSE;
	}
	}
	}
	}

	/*
	* returns EINVAL if reconstruction of the block will not be possible
	* returns ECKSUM if this specific reconstruction failed
	* returns 0 on successful reconstruction
	*/
	static int
	raidz_reconstruct(zio_t zio, int ltgts, int ntgts, int nparity)
	{
	raidz_map_t *rm = zio->io_vsd;

	/* Reconstruct each row */
	for (int r = 0; r < rm->rm_nrows; r++) {
	raidz_row_t *rr = rm->rm_row[r];
	int my_tgts[VDEV_RAIDZ_MAXPARITY]; /* value is child id */
	int t = 0;
	int dead = 0;
	int dead_data = 0;

	for (int c = 0; c < rr->rr_cols; c++) {
	raidz_col_t *rc = &rr->rr_col[c];
	ASSERT0(rc->rc_need_orig_restore);
	if (rc->rc_error != 0) {
	dead++;
	if (c >= nparity)
	dead_data++;
	continue;
	}
	if (rc->rc_size == 0)
	continue;
	for (int lt = 0; lt < ntgts; lt++) {
	if (rc->rc_devidx == ltgts[lt]) {
	if (rc->rc_orig_data == NULL) {
	rc->rc_orig_data =
	abd_alloc_linear(
	rc->rc_size, B_TRUE);
	abd_copy(rc->rc_orig_data,
	rc->rc_abd, rc->rc_size);
	}
	rc->rc_need_orig_restore = B_TRUE;

	dead++;
	if (c >= nparity)
	dead_data++;
	my_tgts[t++] = c;
	break;
	}
	}
	}
	if (dead > nparity) {
	/* reconstruction not possible */
	raidz_restore_orig_data(rm);
	return (EINVAL);
	}
	if (dead_data > 0)
	vdev_raidz_reconstruct_row(rm, rr, my_tgts, t);
	}

	/* Check for success */
	if (raidz_checksum_verify(zio) == 0) {

	/* Reconstruction succeeded - report errors */
	for (int i = 0; i < rm->rm_nrows; i++) {
	raidz_row_t *rr = rm->rm_row[i];

	for (int c = 0; c < rr->rr_cols; c++) {
	raidz_col_t *rc = &rr->rr_col[c];
	if (rc->rc_need_orig_restore) {
	/*
	* Note: if this is a parity column,
	* we don't really know if it's wrong.
	* We need to let
	* vdev_raidz_io_done_verified() check
	* it, and if we set rc_error, it will
	* think that it is a "known" error
	* that doesn't need to be checked
	* or corrected.
	*/
	if (rc->rc_error == 0 &&
	c >= rr->rr_firstdatacol) {
	raidz_checksum_error(zio,
	rc, rc->rc_orig_data);
	rc->rc_error =
	SET_ERROR(ECKSUM);
	}
	rc->rc_need_orig_restore = B_FALSE;
	}
	}

	vdev_raidz_io_done_verified(zio, rr);
	}

	zio_checksum_verified(zio);

	return (0);
	}

	/* Reconstruction failed - restore original data */
	raidz_restore_orig_data(rm);
	return (ECKSUM);
	}

	/*
	* Iterate over all combinations of N bad vdevs and attempt a reconstruction.
	* Note that the algorithm below is non-optimal because it doesn't take into
	* account how reconstruction is actually performed. For example, with
	* triple-parity RAID-Z the reconstruction procedure is the same if column 4
	* is targeted as invalid as if columns 1 and 4 are targeted since in both
	* cases we'd only use parity information in column 0.
	*
	* The order that we find the various possible combinations of failed
	* disks is dictated by these rules:
	* - Examine each "slot" (the "i" in tgts[i])
	* - Try to increment this slot (tgts[i] = tgts[i] + 1)
	* - if we can't increment because it runs into the next slot,
	* reset our slot to the minimum, and examine the next slot
	*
	* For example, with a 6-wide RAIDZ3, and no known errors (so we have to choose
	* 3 columns to reconstruct), we will generate the following sequence:
	*
	* STATE ACTION
	* 0 1 2 special case: skip since these are all parity
	* 0 1 3 first slot: reset to 0; middle slot: increment to 2
	* 0 2 3 first slot: increment to 1
	* 1 2 3 first: reset to 0; middle: reset to 1; last: increment to 4
	* 0 1 4 first: reset to 0; middle: increment to 2
	* 0 2 4 first: increment to 1
	* 1 2 4 first: reset to 0; middle: increment to 3
	* 0 3 4 first: increment to 1
	* 1 3 4 first: increment to 2
	* 2 3 4 first: reset to 0; middle: reset to 1; last: increment to 5
	* 0 1 5 first: reset to 0; middle: increment to 2
	* 0 2 5 first: increment to 1
	* 1 2 5 first: reset to 0; middle: increment to 3
	* 0 3 5 first: increment to 1
	* 1 3 5 first: increment to 2
	* 2 3 5 first: reset to 0; middle: increment to 4
	* 0 4 5 first: increment to 1
	* 1 4 5 first: increment to 2
	* 2 4 5 first: increment to 3
	* 3 4 5 done
	*
	- * This strategy works for dRAID but is less effecient when there are a large
	+ * This strategy works for dRAID but is less efficient when there are a large
	* number of child vdevs and therefore permutations to check. Furthermore,
	* since the raidz_map_t rows likely do not overlap reconstruction would be
	* possible as long as there are no more than nparity data errors per row.
	* These additional permutations are not currently checked but could be as
	* a future improvement.
	*/
	static int
	vdev_raidz_combrec(zio_t *zio)
	{
	int nparity = vdev_get_nparity(zio->io_vd);
	raidz_map_t *rm = zio->io_vsd;

	/* Check if there's enough data to attempt reconstrution. */
	for (int i = 0; i < rm->rm_nrows; i++) {
	raidz_row_t *rr = rm->rm_row[i];
	int total_errors = 0;

	for (int c = 0; c < rr->rr_cols; c++) {
	if (rr->rr_col[c].rc_error)
	total_errors++;
	}

	if (total_errors > nparity)
	return (vdev_raidz_worst_error(rr));
	}

	for (int num_failures = 1; num_failures <= nparity; num_failures++) {
	int tstore[VDEV_RAIDZ_MAXPARITY + 2];
	int ltgts = &tstore[1]; / value is logical child ID */

	/* Determine number of logical children, n */
	int n = zio->io_vd->vdev_children;

	ASSERT3U(num_failures, <=, nparity);
	ASSERT3U(num_failures, <=, VDEV_RAIDZ_MAXPARITY);

	/* Handle corner cases in combrec logic */
	ltgts[-1] = -1;
	for (int i = 0; i < num_failures; i++) {
	ltgts[i] = i;
	}
	ltgts[num_failures] = n;

	for (;;) {
	int err = raidz_reconstruct(zio, ltgts, num_failures,
	nparity);
	if (err == EINVAL) {
	/*
	* Reconstruction not possible with this #
	* failures; try more failures.
	*/
	break;
	} else if (err == 0)
	return (0);

	/* Compute next targets to try */
	for (int t = 0; ; t++) {
	ASSERT3U(t, <, num_failures);
	ltgts[t]++;
	if (ltgts[t] == n) {
	/* try more failures */
	ASSERT3U(t, ==, num_failures - 1);
	break;
	}

	ASSERT3U(ltgts[t], <, n);
	ASSERT3U(ltgts[t], <=, ltgts[t + 1]);

	/*
	* If that spot is available, we're done here.
	* Try the next combination.
	*/
	if (ltgts[t] != ltgts[t + 1])
	break;

	/*
	* Otherwise, reset this tgt to the minimum,
	* and move on to the next tgt.
	*/
	ltgts[t] = ltgts[t - 1] + 1;
	ASSERT3U(ltgts[t], ==, t);
	}

	/* Increase the number of failures and keep trying. */
	if (ltgts[num_failures - 1] == n)
	break;
	}
	}

	return (ECKSUM);
	}

	void
	vdev_raidz_reconstruct(raidz_map_t rm, const int t, int nt)
	{
	for (uint64_t row = 0; row < rm->rm_nrows; row++) {
	raidz_row_t *rr = rm->rm_row[row];
	vdev_raidz_reconstruct_row(rm, rr, t, nt);
	}
	}

	/*
	* Complete a write IO operation on a RAIDZ VDev
	*
	* Outline:
	* 1. Check for errors on the child IOs.
	* 2. Return, setting an error code if too few child VDevs were written
	* to reconstruct the data later. Note that partial writes are
	* considered successful if they can be reconstructed at all.
	*/
	static void
	vdev_raidz_io_done_write_impl(zio_t zio, raidz_row_t rr)
	{
	int total_errors = 0;

	ASSERT3U(rr->rr_missingparity, <=, rr->rr_firstdatacol);
	ASSERT3U(rr->rr_missingdata, <=, rr->rr_cols - rr->rr_firstdatacol);
	ASSERT3U(zio->io_type, ==, ZIO_TYPE_WRITE);

	for (int c = 0; c < rr->rr_cols; c++) {
	raidz_col_t *rc = &rr->rr_col[c];

	if (rc->rc_error) {
	ASSERT(rc->rc_error != ECKSUM); /* child has no bp */

	total_errors++;
	}
	}

	/*
	* Treat partial writes as a success. If we couldn't write enough
	* columns to reconstruct the data, the I/O failed. Otherwise,
	* good enough.
	*
	* Now that we support write reallocation, it would be better
	* to treat partial failure as real failure unless there are
	* no non-degraded top-level vdevs left, and not update DTLs
	* if we intend to reallocate.
	*/
	if (total_errors > rr->rr_firstdatacol) {
	zio->io_error = zio_worst_error(zio->io_error,
	vdev_raidz_worst_error(rr));
	}
	}

	static void
	vdev_raidz_io_done_reconstruct_known_missing(zio_t zio, raidz_map_t rm,
	raidz_row_t *rr)
	{
	int parity_errors = 0;
	int parity_untried = 0;
	int data_errors = 0;
	int total_errors = 0;

	ASSERT3U(rr->rr_missingparity, <=, rr->rr_firstdatacol);
	ASSERT3U(rr->rr_missingdata, <=, rr->rr_cols - rr->rr_firstdatacol);
	ASSERT3U(zio->io_type, ==, ZIO_TYPE_READ);

	for (int c = 0; c < rr->rr_cols; c++) {
	raidz_col_t *rc = &rr->rr_col[c];

	if (rc->rc_error) {
	ASSERT(rc->rc_error != ECKSUM); /* child has no bp */

	if (c < rr->rr_firstdatacol)
	parity_errors++;
	else
	data_errors++;

	total_errors++;
	} else if (c < rr->rr_firstdatacol && !rc->rc_tried) {
	parity_untried++;
	}
	}

	/*
	* If there were data errors and the number of errors we saw was
	* correctable -- less than or equal to the number of parity disks read
	* -- reconstruct based on the missing data.
	*/
	if (data_errors != 0 &&
	total_errors <= rr->rr_firstdatacol - parity_untried) {
	/*
	* We either attempt to read all the parity columns or
	* none of them. If we didn't try to read parity, we
	* wouldn't be here in the correctable case. There must
	* also have been fewer parity errors than parity
	* columns or, again, we wouldn't be in this code path.
	*/
	ASSERT(parity_untried == 0);
	ASSERT(parity_errors < rr->rr_firstdatacol);

	/*
	* Identify the data columns that reported an error.
	*/
	int n = 0;
	int tgts[VDEV_RAIDZ_MAXPARITY];
	for (int c = rr->rr_firstdatacol; c < rr->rr_cols; c++) {
	raidz_col_t *rc = &rr->rr_col[c];
	if (rc->rc_error != 0) {
	ASSERT(n < VDEV_RAIDZ_MAXPARITY);
	tgts[n++] = c;
	}
	}

	ASSERT(rr->rr_firstdatacol >= n);

	vdev_raidz_reconstruct_row(rm, rr, tgts, n);
	}
	}

	/*
	* Return the number of reads issued.
	*/
	static int
	vdev_raidz_read_all(zio_t zio, raidz_row_t rr)
	{
	vdev_t *vd = zio->io_vd;
	int nread = 0;

	rr->rr_missingdata = 0;
	rr->rr_missingparity = 0;

	/*
	* If this rows contains empty sectors which are not required
	* for a normal read then allocate an ABD for them now so they
	* may be read, verified, and any needed repairs performed.
	*/
	if (rr->rr_nempty && rr->rr_abd_empty == NULL)
	vdev_draid_map_alloc_empty(zio, rr);

	for (int c = 0; c < rr->rr_cols; c++) {
	raidz_col_t *rc = &rr->rr_col[c];
	if (rc->rc_tried \|\| rc->rc_size == 0)
	continue;

	zio_nowait(zio_vdev_child_io(zio, NULL,
	vd->vdev_child[rc->rc_devidx],
	rc->rc_offset, rc->rc_abd, rc->rc_size,
	zio->io_type, zio->io_priority, 0,
	vdev_raidz_child_done, rc));
	nread++;
	}
	return (nread);
	}

	/*
	* We're here because either there were too many errors to even attempt
	* reconstruction (total_errors == rm_first_datacol), or vdev_*_combrec()
	* failed. In either case, there is enough bad data to prevent reconstruction.
	* Start checksum ereports for all children which haven't failed.
	*/
	static void
	vdev_raidz_io_done_unrecoverable(zio_t *zio)
	{
	raidz_map_t *rm = zio->io_vsd;

	for (int i = 0; i < rm->rm_nrows; i++) {
	raidz_row_t *rr = rm->rm_row[i];

	for (int c = 0; c < rr->rr_cols; c++) {
	raidz_col_t *rc = &rr->rr_col[c];
	vdev_t *cvd = zio->io_vd->vdev_child[rc->rc_devidx];

	if (rc->rc_error != 0)
	continue;

	zio_bad_cksum_t zbc;
	zbc.zbc_has_cksum = 0;
	zbc.zbc_injected = rm->rm_ecksuminjected;

	(void) zfs_ereport_start_checksum(zio->io_spa,
	cvd, &zio->io_bookmark, zio, rc->rc_offset,
	rc->rc_size, &zbc);
	mutex_enter(&cvd->vdev_stat_lock);
	cvd->vdev_stat.vs_checksum_errors++;
	mutex_exit(&cvd->vdev_stat_lock);
	}
	}
	}

	void
	vdev_raidz_io_done(zio_t *zio)
	{
	raidz_map_t *rm = zio->io_vsd;

	if (zio->io_type == ZIO_TYPE_WRITE) {
	for (int i = 0; i < rm->rm_nrows; i++) {
	vdev_raidz_io_done_write_impl(zio, rm->rm_row[i]);
	}
	} else {
	for (int i = 0; i < rm->rm_nrows; i++) {
	raidz_row_t *rr = rm->rm_row[i];
	vdev_raidz_io_done_reconstruct_known_missing(zio,
	rm, rr);
	}

	if (raidz_checksum_verify(zio) == 0) {
	for (int i = 0; i < rm->rm_nrows; i++) {
	raidz_row_t *rr = rm->rm_row[i];
	vdev_raidz_io_done_verified(zio, rr);
	}
	zio_checksum_verified(zio);
	} else {
	/*
	* A sequential resilver has no checksum which makes
	* combinatoral reconstruction impossible. This code
	* path is unreachable since raidz_checksum_verify()
	* has no checksum to verify and must succeed.
	*/
	ASSERT3U(zio->io_priority, !=, ZIO_PRIORITY_REBUILD);

	/*
	* This isn't a typical situation -- either we got a
	* read error or a child silently returned bad data.
	* Read every block so we can try again with as much
	* data and parity as we can track down. If we've
	* already been through once before, all children will
	* be marked as tried so we'll proceed to combinatorial
	* reconstruction.
	*/
	int nread = 0;
	for (int i = 0; i < rm->rm_nrows; i++) {
	nread += vdev_raidz_read_all(zio,
	rm->rm_row[i]);
	}
	if (nread != 0) {
	/*
	* Normally our stage is VDEV_IO_DONE, but if
	* we've already called redone(), it will have
	* changed to VDEV_IO_START, in which case we
	* don't want to call redone() again.
	*/
	if (zio->io_stage != ZIO_STAGE_VDEV_IO_START)
	zio_vdev_io_redone(zio);
	return;
	}

	zio->io_error = vdev_raidz_combrec(zio);
	if (zio->io_error == ECKSUM &&
	!(zio->io_flags & ZIO_FLAG_SPECULATIVE)) {
	vdev_raidz_io_done_unrecoverable(zio);
	}
	}
	}
	}

	static void
	vdev_raidz_state_change(vdev_t *vd, int faulted, int degraded)
	{
	vdev_raidz_t *vdrz = vd->vdev_tsd;
	if (faulted > vdrz->vd_nparity)
	vdev_set_state(vd, B_FALSE, VDEV_STATE_CANT_OPEN,
	VDEV_AUX_NO_REPLICAS);
	else if (degraded + faulted != 0)
	vdev_set_state(vd, B_FALSE, VDEV_STATE_DEGRADED, VDEV_AUX_NONE);
	else
	vdev_set_state(vd, B_FALSE, VDEV_STATE_HEALTHY, VDEV_AUX_NONE);
	}

	/*
	* Determine if any portion of the provided block resides on a child vdev
	* with a dirty DTL and therefore needs to be resilvered. The function
	* assumes that at least one DTL is dirty which implies that full stripe
	* width blocks must be resilvered.
	*/
	static boolean_t
	vdev_raidz_need_resilver(vdev_t vd, const dva_t dva, size_t psize,
	uint64_t phys_birth)
	{
	vdev_raidz_t *vdrz = vd->vdev_tsd;
	uint64_t dcols = vd->vdev_children;
	uint64_t nparity = vdrz->vd_nparity;
	uint64_t ashift = vd->vdev_top->vdev_ashift;
	/* The starting RAIDZ (parent) vdev sector of the block. */
	uint64_t b = DVA_GET_OFFSET(dva) >> ashift;
	/* The zio's size in units of the vdev's minimum sector size. */
	uint64_t s = ((psize - 1) >> ashift) + 1;
	/* The first column for this stripe. */
	uint64_t f = b % dcols;

	/* Unreachable by sequential resilver. */
	ASSERT3U(phys_birth, !=, TXG_UNKNOWN);

	if (!vdev_dtl_contains(vd, DTL_PARTIAL, phys_birth, 1))
	return (B_FALSE);

	if (s + nparity >= dcols)
	return (B_TRUE);

	for (uint64_t c = 0; c < s + nparity; c++) {
	uint64_t devidx = (f + c) % dcols;
	vdev_t *cvd = vd->vdev_child[devidx];

	/*
	* dsl_scan_need_resilver() already checked vd with
	* vdev_dtl_contains(). So here just check cvd with
	* vdev_dtl_empty(), cheaper and a good approximation.
	*/
	if (!vdev_dtl_empty(cvd, DTL_PARTIAL))
	return (B_TRUE);
	}

	return (B_FALSE);
	}

	static void
	vdev_raidz_xlate(vdev_t cvd, const range_seg64_t logical_rs,
	range_seg64_t physical_rs, range_seg64_t remain_rs)
	{
	vdev_t *raidvd = cvd->vdev_parent;
	ASSERT(raidvd->vdev_ops == &vdev_raidz_ops);

	uint64_t width = raidvd->vdev_children;
	uint64_t tgt_col = cvd->vdev_id;
	uint64_t ashift = raidvd->vdev_top->vdev_ashift;

	/* make sure the offsets are block-aligned */
	ASSERT0(logical_rs->rs_start % (1 << ashift));
	ASSERT0(logical_rs->rs_end % (1 << ashift));
	uint64_t b_start = logical_rs->rs_start >> ashift;
	uint64_t b_end = logical_rs->rs_end >> ashift;

	uint64_t start_row = 0;
	if (b_start > tgt_col) /* avoid underflow */
	start_row = ((b_start - tgt_col - 1) / width) + 1;

	uint64_t end_row = 0;
	if (b_end > tgt_col)
	end_row = ((b_end - tgt_col - 1) / width) + 1;

	physical_rs->rs_start = start_row << ashift;
	physical_rs->rs_end = end_row << ashift;

	ASSERT3U(physical_rs->rs_start, <=, logical_rs->rs_start);
	ASSERT3U(physical_rs->rs_end - physical_rs->rs_start, <=,
	logical_rs->rs_end - logical_rs->rs_start);
	}

	/*
	* Initialize private RAIDZ specific fields from the nvlist.
	*/
	static int
	vdev_raidz_init(spa_t spa, nvlist_t nv, void **tsd)
	{
	vdev_raidz_t *vdrz;
	uint64_t nparity;

	uint_t children;
	nvlist_t **child;
	int error = nvlist_lookup_nvlist_array(nv,
	ZPOOL_CONFIG_CHILDREN, &child, &children);
	if (error != 0)
	return (SET_ERROR(EINVAL));

	if (nvlist_lookup_uint64(nv, ZPOOL_CONFIG_NPARITY, &nparity) == 0) {
	if (nparity == 0 \|\| nparity > VDEV_RAIDZ_MAXPARITY)
	return (SET_ERROR(EINVAL));

	/*
	* Previous versions could only support 1 or 2 parity
	* device.
	*/
	if (nparity > 1 && spa_version(spa) < SPA_VERSION_RAIDZ2)
	return (SET_ERROR(EINVAL));
	else if (nparity > 2 && spa_version(spa) < SPA_VERSION_RAIDZ3)
	return (SET_ERROR(EINVAL));
	} else {
	/*
	* We require the parity to be specified for SPAs that
	* support multiple parity levels.
	*/
	if (spa_version(spa) >= SPA_VERSION_RAIDZ2)
	return (SET_ERROR(EINVAL));

	/*
	* Otherwise, we default to 1 parity device for RAID-Z.
	*/
	nparity = 1;
	}

	vdrz = kmem_zalloc(sizeof (*vdrz), KM_SLEEP);
	vdrz->vd_logical_width = children;
	vdrz->vd_nparity = nparity;

	*tsd = vdrz;

	return (0);
	}

	static void
	vdev_raidz_fini(vdev_t *vd)
	{
	kmem_free(vd->vdev_tsd, sizeof (vdev_raidz_t));
	}

	/*
	* Add RAIDZ specific fields to the config nvlist.
	*/
	static void
	vdev_raidz_config_generate(vdev_t vd, nvlist_t nv)
	{
	ASSERT3P(vd->vdev_ops, ==, &vdev_raidz_ops);
	vdev_raidz_t *vdrz = vd->vdev_tsd;

	/*
	* Make sure someone hasn't managed to sneak a fancy new vdev
	* into a crufty old storage pool.
	*/
	ASSERT(vdrz->vd_nparity == 1 \|\|
	(vdrz->vd_nparity <= 2 &&
	spa_version(vd->vdev_spa) >= SPA_VERSION_RAIDZ2) \|\|
	(vdrz->vd_nparity <= 3 &&
	spa_version(vd->vdev_spa) >= SPA_VERSION_RAIDZ3));

	/*
	* Note that we'll add these even on storage pools where they
	* aren't strictly required -- older software will just ignore
	* it.
	*/
	fnvlist_add_uint64(nv, ZPOOL_CONFIG_NPARITY, vdrz->vd_nparity);
	}

	static uint64_t
	vdev_raidz_nparity(vdev_t *vd)
	{
	vdev_raidz_t *vdrz = vd->vdev_tsd;
	return (vdrz->vd_nparity);
	}

	static uint64_t
	vdev_raidz_ndisks(vdev_t *vd)
	{
	return (vd->vdev_children);
	}

	vdev_ops_t vdev_raidz_ops = {
	.vdev_op_init = vdev_raidz_init,
	.vdev_op_fini = vdev_raidz_fini,
	.vdev_op_open = vdev_raidz_open,
	.vdev_op_close = vdev_raidz_close,
	.vdev_op_asize = vdev_raidz_asize,
	.vdev_op_min_asize = vdev_raidz_min_asize,
	.vdev_op_min_alloc = NULL,
	.vdev_op_io_start = vdev_raidz_io_start,
	.vdev_op_io_done = vdev_raidz_io_done,
	.vdev_op_state_change = vdev_raidz_state_change,
	.vdev_op_need_resilver = vdev_raidz_need_resilver,
	.vdev_op_hold = NULL,
	.vdev_op_rele = NULL,
	.vdev_op_remap = NULL,
	.vdev_op_xlate = vdev_raidz_xlate,
	.vdev_op_rebuild_asize = NULL,
	.vdev_op_metaslab_init = NULL,
	.vdev_op_config_generate = vdev_raidz_config_generate,
	.vdev_op_nparity = vdev_raidz_nparity,
	.vdev_op_ndisks = vdev_raidz_ndisks,
	.vdev_op_type = VDEV_TYPE_RAIDZ, /* name of this vdev type */
	.vdev_op_leaf = B_FALSE /* not a leaf vdev */
	};
	diff --git a/sys/contrib/openzfs/module/zfs/vdev_rebuild.c b/sys/contrib/openzfs/module/zfs/vdev_rebuild.c
	index a77ff99faa92..4d7de0c6c44c 100644
	--- a/sys/contrib/openzfs/module/zfs/vdev_rebuild.c
	+++ b/sys/contrib/openzfs/module/zfs/vdev_rebuild.c
	@@ -1,1150 +1,1150 @@
	/*
	* 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) 2018, Intel Corporation.
	* Copyright (c) 2020 by Lawrence Livermore National Security, LLC.
	*/

	#include <sys/vdev_impl.h>
	#include <sys/vdev_draid.h>
	#include <sys/dsl_scan.h>
	#include <sys/spa_impl.h>
	#include <sys/metaslab_impl.h>
	#include <sys/vdev_rebuild.h>
	#include <sys/zio.h>
	#include <sys/dmu_tx.h>
	#include <sys/arc.h>
	#include <sys/zap.h>

	/*
	* This file contains the sequential reconstruction implementation for
	* resilvering. This form of resilvering is internally referred to as device
	* rebuild to avoid conflating it with the traditional healing reconstruction
	* performed by the dsl scan code.
	*
	* When replacing a device, or scrubbing the pool, ZFS has historically used
	* a process called resilvering which is a form of healing reconstruction.
	* This approach has the advantage that as blocks are read from disk their
	* checksums can be immediately verified and the data repaired. Unfortunately,
	* it also results in a random IO pattern to the disk even when extra care
	* is taken to sequentialize the IO as much as possible. This substantially
	* increases the time required to resilver the pool and restore redundancy.
	*
	* For mirrored devices it's possible to implement an alternate sequential
	* reconstruction strategy when resilvering. Sequential reconstruction
	* behaves like a traditional RAID rebuild and reconstructs a device in LBA
	* order without verifying the checksum. After this phase completes a second
	* scrub phase is started to verify all of the checksums. This two phase
	* process will take longer than the healing reconstruction described above.
	* However, it has that advantage that after the reconstruction first phase
	* completes redundancy has been restored. At this point the pool can incur
	* another device failure without risking data loss.
	*
	* There are a few noteworthy limitations and other advantages of resilvering
	* using sequential reconstruction vs healing reconstruction.
	*
	* Limitations:
	*
	* - Sequential reconstruction is not possible on RAIDZ due to its
	* variable stripe width. Note dRAID uses a fixed stripe width which
	* avoids this issue, but comes at the expense of some usable capacity.
	*
	* - Block checksums are not verified during sequential reconstruction.
	* Similar to traditional RAID the parity/mirror data is reconstructed
	* but cannot be immediately double checked. For this reason when the
	* last active resilver completes the pool is automatically scrubbed
	* by default.
	*
	* - Deferred resilvers using sequential reconstruction are not currently
	* supported. When adding another vdev to an active top-level resilver
	* it must be restarted.
	*
	* Advantages:
	*
	* - Sequential reconstruction is performed in LBA order which may be faster
	- * than healing reconstruction particularly when using using HDDs (or
	+ * than healing reconstruction particularly when using HDDs (or
	* especially with SMR devices). Only allocated capacity is resilvered.
	*
	* - Sequential reconstruction is not constrained by ZFS block boundaries.
	* This allows it to issue larger IOs to disk which span multiple blocks
	* allowing all of these logical blocks to be repaired with a single IO.
	*
	* - Unlike a healing resilver or scrub which are pool wide operations,
	* sequential reconstruction is handled by the top-level vdevs. This
	* allows for it to be started or canceled on a top-level vdev without
	* impacting any other top-level vdevs in the pool.
	*
	* - Data only referenced by a pool checkpoint will be repaired because
	* that space is reflected in the space maps. This differs for a
	* healing resilver or scrub which will not repair that data.
	*/


	/*
	* Size of rebuild reads; defaults to 1MiB per data disk and is capped at
	* SPA_MAXBLOCKSIZE.
	*/
	unsigned long zfs_rebuild_max_segment = 1024 * 1024;

	/*
	* Maximum number of parallelly executed bytes per leaf vdev caused by a
	* sequential resilver. We attempt to strike a balance here between keeping
	* the vdev queues full of I/Os at all times and not overflowing the queues
	* to cause long latency, which would cause long txg sync times.
	*
	* A large default value can be safely used here because the default target
	* segment size is also large (zfs_rebuild_max_segment=1M). This helps keep
	* the queue depth short.
	*
	* 32MB was selected as the default value to achieve good performance with
	* a large 90-drive dRAID HDD configuration (draid2:8d:90c:2s). A sequential
	* rebuild was unable to saturate all of the drives using smaller values.
	* With a value of 32MB the sequential resilver write rate was measured at
	* 800MB/s sustained while rebuilding to a distributed spare.
	*/
	unsigned long zfs_rebuild_vdev_limit = 32 << 20;

	/*
	* Automatically start a pool scrub when the last active sequential resilver
	* completes in order to verify the checksums of all blocks which have been
	* resilvered. This option is enabled by default and is strongly recommended.
	*/
	int zfs_rebuild_scrub_enabled = 1;

	/*
	* For vdev_rebuild_initiate_sync() and vdev_rebuild_reset_sync().
	*/
	static void vdev_rebuild_thread(void *arg);

	/*
	* Clear the per-vdev rebuild bytes value for a vdev tree.
	*/
	static void
	clear_rebuild_bytes(vdev_t *vd)
	{
	vdev_stat_t *vs = &vd->vdev_stat;

	for (uint64_t i = 0; i < vd->vdev_children; i++)
	clear_rebuild_bytes(vd->vdev_child[i]);

	mutex_enter(&vd->vdev_stat_lock);
	vs->vs_rebuild_processed = 0;
	mutex_exit(&vd->vdev_stat_lock);
	}

	/*
	* Determines whether a vdev_rebuild_thread() should be stopped.
	*/
	static boolean_t
	vdev_rebuild_should_stop(vdev_t *vd)
	{
	return (!vdev_writeable(vd) \|\| vd->vdev_removing \|\|
	vd->vdev_rebuild_exit_wanted \|\|
	vd->vdev_rebuild_cancel_wanted \|\|
	vd->vdev_rebuild_reset_wanted);
	}

	/*
	* Determine if the rebuild should be canceled. This may happen when all
	* vdevs with MISSING DTLs are detached.
	*/
	static boolean_t
	vdev_rebuild_should_cancel(vdev_t *vd)
	{
	vdev_rebuild_t *vr = &vd->vdev_rebuild_config;
	vdev_rebuild_phys_t *vrp = &vr->vr_rebuild_phys;

	if (!vdev_resilver_needed(vd, &vrp->vrp_min_txg, &vrp->vrp_max_txg))
	return (B_TRUE);

	return (B_FALSE);
	}

	/*
	* The sync task for updating the on-disk state of a rebuild. This is
	* scheduled by vdev_rebuild_range().
	*/
	static void
	vdev_rebuild_update_sync(void arg, dmu_tx_t tx)
	{
	int vdev_id = (uintptr_t)arg;
	spa_t *spa = dmu_tx_pool(tx)->dp_spa;
	vdev_t *vd = vdev_lookup_top(spa, vdev_id);
	vdev_rebuild_t *vr = &vd->vdev_rebuild_config;
	vdev_rebuild_phys_t *vrp = &vr->vr_rebuild_phys;
	uint64_t txg = dmu_tx_get_txg(tx);

	mutex_enter(&vd->vdev_rebuild_lock);

	if (vr->vr_scan_offset[txg & TXG_MASK] > 0) {
	vrp->vrp_last_offset = vr->vr_scan_offset[txg & TXG_MASK];
	vr->vr_scan_offset[txg & TXG_MASK] = 0;
	}

	vrp->vrp_scan_time_ms = vr->vr_prev_scan_time_ms +
	NSEC2MSEC(gethrtime() - vr->vr_pass_start_time);

	VERIFY0(zap_update(vd->vdev_spa->spa_meta_objset, vd->vdev_top_zap,
	VDEV_TOP_ZAP_VDEV_REBUILD_PHYS, sizeof (uint64_t),
	REBUILD_PHYS_ENTRIES, vrp, tx));

	mutex_exit(&vd->vdev_rebuild_lock);
	}

	/*
	* Initialize the on-disk state for a new rebuild, start the rebuild thread.
	*/
	static void
	vdev_rebuild_initiate_sync(void arg, dmu_tx_t tx)
	{
	int vdev_id = (uintptr_t)arg;
	spa_t *spa = dmu_tx_pool(tx)->dp_spa;
	vdev_t *vd = vdev_lookup_top(spa, vdev_id);
	vdev_rebuild_t *vr = &vd->vdev_rebuild_config;
	vdev_rebuild_phys_t *vrp = &vr->vr_rebuild_phys;

	ASSERT(vd->vdev_rebuilding);

	spa_feature_incr(vd->vdev_spa, SPA_FEATURE_DEVICE_REBUILD, tx);

	mutex_enter(&vd->vdev_rebuild_lock);
	bzero(vrp, sizeof (uint64_t) * REBUILD_PHYS_ENTRIES);
	vrp->vrp_rebuild_state = VDEV_REBUILD_ACTIVE;
	vrp->vrp_min_txg = 0;
	vrp->vrp_max_txg = dmu_tx_get_txg(tx);
	vrp->vrp_start_time = gethrestime_sec();
	vrp->vrp_scan_time_ms = 0;
	vr->vr_prev_scan_time_ms = 0;

	/*
	* Rebuilds are currently only used when replacing a device, in which
	* case there must be DTL_MISSING entries. In the future, we could
	* allow rebuilds to be used in a way similar to a scrub. This would
	* be useful because it would allow us to rebuild the space used by
	* pool checkpoints.
	*/
	VERIFY(vdev_resilver_needed(vd, &vrp->vrp_min_txg, &vrp->vrp_max_txg));

	VERIFY0(zap_update(vd->vdev_spa->spa_meta_objset, vd->vdev_top_zap,
	VDEV_TOP_ZAP_VDEV_REBUILD_PHYS, sizeof (uint64_t),
	REBUILD_PHYS_ENTRIES, vrp, tx));

	spa_history_log_internal(spa, "rebuild", tx,
	"vdev_id=%llu vdev_guid=%llu started",
	(u_longlong_t)vd->vdev_id, (u_longlong_t)vd->vdev_guid);

	ASSERT3P(vd->vdev_rebuild_thread, ==, NULL);
	vd->vdev_rebuild_thread = thread_create(NULL, 0,
	vdev_rebuild_thread, vd, 0, &p0, TS_RUN, maxclsyspri);

	mutex_exit(&vd->vdev_rebuild_lock);
	}

	static void
	vdev_rebuild_log_notify(spa_t spa, vdev_t vd, char *name)
	{
	nvlist_t *aux = fnvlist_alloc();

	fnvlist_add_string(aux, ZFS_EV_RESILVER_TYPE, "sequential");
	spa_event_notify(spa, vd, aux, name);
	nvlist_free(aux);
	}

	/*
	* Called to request that a new rebuild be started. The feature will remain
	* active for the duration of the rebuild, then revert to the enabled state.
	*/
	static void
	vdev_rebuild_initiate(vdev_t *vd)
	{
	spa_t *spa = vd->vdev_spa;

	ASSERT(vd->vdev_top == vd);
	ASSERT(MUTEX_HELD(&vd->vdev_rebuild_lock));
	ASSERT(!vd->vdev_rebuilding);

	dmu_tx_t *tx = dmu_tx_create_dd(spa_get_dsl(spa)->dp_mos_dir);
	VERIFY0(dmu_tx_assign(tx, TXG_WAIT));

	vd->vdev_rebuilding = B_TRUE;

	dsl_sync_task_nowait(spa_get_dsl(spa), vdev_rebuild_initiate_sync,
	(void *)(uintptr_t)vd->vdev_id, tx);
	dmu_tx_commit(tx);

	vdev_rebuild_log_notify(spa, vd, ESC_ZFS_RESILVER_START);
	}

	/*
	* Update the on-disk state to completed when a rebuild finishes.
	*/
	static void
	vdev_rebuild_complete_sync(void arg, dmu_tx_t tx)
	{
	int vdev_id = (uintptr_t)arg;
	spa_t *spa = dmu_tx_pool(tx)->dp_spa;
	vdev_t *vd = vdev_lookup_top(spa, vdev_id);
	vdev_rebuild_t *vr = &vd->vdev_rebuild_config;
	vdev_rebuild_phys_t *vrp = &vr->vr_rebuild_phys;

	mutex_enter(&vd->vdev_rebuild_lock);
	vrp->vrp_rebuild_state = VDEV_REBUILD_COMPLETE;
	vrp->vrp_end_time = gethrestime_sec();

	VERIFY0(zap_update(vd->vdev_spa->spa_meta_objset, vd->vdev_top_zap,
	VDEV_TOP_ZAP_VDEV_REBUILD_PHYS, sizeof (uint64_t),
	REBUILD_PHYS_ENTRIES, vrp, tx));

	vdev_dtl_reassess(vd, tx->tx_txg, vrp->vrp_max_txg, B_TRUE, B_TRUE);
	spa_feature_decr(vd->vdev_spa, SPA_FEATURE_DEVICE_REBUILD, tx);

	spa_history_log_internal(spa, "rebuild", tx,
	"vdev_id=%llu vdev_guid=%llu complete",
	(u_longlong_t)vd->vdev_id, (u_longlong_t)vd->vdev_guid);
	vdev_rebuild_log_notify(spa, vd, ESC_ZFS_RESILVER_FINISH);

	/* Handles detaching of spares */
	spa_async_request(spa, SPA_ASYNC_REBUILD_DONE);
	vd->vdev_rebuilding = B_FALSE;
	mutex_exit(&vd->vdev_rebuild_lock);

	/*
	* While we're in syncing context take the opportunity to
	* setup the scrub when there are no more active rebuilds.
	*/
	- if (!vdev_rebuild_active(spa->spa_root_vdev) &&
	+ pool_scan_func_t func = POOL_SCAN_SCRUB;
	+ if (dsl_scan_setup_check(&func, tx) == 0 &&
	zfs_rebuild_scrub_enabled) {
	- pool_scan_func_t func = POOL_SCAN_SCRUB;
	dsl_scan_setup_sync(&func, tx);
	}

	cv_broadcast(&vd->vdev_rebuild_cv);

	/* Clear recent error events (i.e. duplicate events tracking) */
	zfs_ereport_clear(spa, NULL);
	}

	/*
	* Update the on-disk state to canceled when a rebuild finishes.
	*/
	static void
	vdev_rebuild_cancel_sync(void arg, dmu_tx_t tx)
	{
	int vdev_id = (uintptr_t)arg;
	spa_t *spa = dmu_tx_pool(tx)->dp_spa;
	vdev_t *vd = vdev_lookup_top(spa, vdev_id);
	vdev_rebuild_t *vr = &vd->vdev_rebuild_config;
	vdev_rebuild_phys_t *vrp = &vr->vr_rebuild_phys;

	mutex_enter(&vd->vdev_rebuild_lock);
	vrp->vrp_rebuild_state = VDEV_REBUILD_CANCELED;
	vrp->vrp_end_time = gethrestime_sec();

	VERIFY0(zap_update(vd->vdev_spa->spa_meta_objset, vd->vdev_top_zap,
	VDEV_TOP_ZAP_VDEV_REBUILD_PHYS, sizeof (uint64_t),
	REBUILD_PHYS_ENTRIES, vrp, tx));

	spa_feature_decr(vd->vdev_spa, SPA_FEATURE_DEVICE_REBUILD, tx);

	spa_history_log_internal(spa, "rebuild", tx,
	"vdev_id=%llu vdev_guid=%llu canceled",
	(u_longlong_t)vd->vdev_id, (u_longlong_t)vd->vdev_guid);
	vdev_rebuild_log_notify(spa, vd, ESC_ZFS_RESILVER_FINISH);

	vd->vdev_rebuild_cancel_wanted = B_FALSE;
	vd->vdev_rebuilding = B_FALSE;
	mutex_exit(&vd->vdev_rebuild_lock);

	spa_notify_waiters(spa);
	cv_broadcast(&vd->vdev_rebuild_cv);
	}

	/*
	* Resets the progress of a running rebuild. This will occur when a new
	* vdev is added to rebuild.
	*/
	static void
	vdev_rebuild_reset_sync(void arg, dmu_tx_t tx)
	{
	int vdev_id = (uintptr_t)arg;
	spa_t *spa = dmu_tx_pool(tx)->dp_spa;
	vdev_t *vd = vdev_lookup_top(spa, vdev_id);
	vdev_rebuild_t *vr = &vd->vdev_rebuild_config;
	vdev_rebuild_phys_t *vrp = &vr->vr_rebuild_phys;

	mutex_enter(&vd->vdev_rebuild_lock);

	ASSERT(vrp->vrp_rebuild_state == VDEV_REBUILD_ACTIVE);
	ASSERT3P(vd->vdev_rebuild_thread, ==, NULL);

	vrp->vrp_last_offset = 0;
	vrp->vrp_min_txg = 0;
	vrp->vrp_max_txg = dmu_tx_get_txg(tx);
	vrp->vrp_bytes_scanned = 0;
	vrp->vrp_bytes_issued = 0;
	vrp->vrp_bytes_rebuilt = 0;
	vrp->vrp_bytes_est = 0;
	vrp->vrp_scan_time_ms = 0;
	vr->vr_prev_scan_time_ms = 0;

	/* See vdev_rebuild_initiate_sync comment */
	VERIFY(vdev_resilver_needed(vd, &vrp->vrp_min_txg, &vrp->vrp_max_txg));

	VERIFY0(zap_update(vd->vdev_spa->spa_meta_objset, vd->vdev_top_zap,
	VDEV_TOP_ZAP_VDEV_REBUILD_PHYS, sizeof (uint64_t),
	REBUILD_PHYS_ENTRIES, vrp, tx));

	spa_history_log_internal(spa, "rebuild", tx,
	"vdev_id=%llu vdev_guid=%llu reset",
	(u_longlong_t)vd->vdev_id, (u_longlong_t)vd->vdev_guid);

	vd->vdev_rebuild_reset_wanted = B_FALSE;
	ASSERT(vd->vdev_rebuilding);

	vd->vdev_rebuild_thread = thread_create(NULL, 0,
	vdev_rebuild_thread, vd, 0, &p0, TS_RUN, maxclsyspri);

	mutex_exit(&vd->vdev_rebuild_lock);
	}

	/*
	* Clear the last rebuild status.
	*/
	void
	vdev_rebuild_clear_sync(void arg, dmu_tx_t tx)
	{
	int vdev_id = (uintptr_t)arg;
	spa_t *spa = dmu_tx_pool(tx)->dp_spa;
	vdev_t *vd = vdev_lookup_top(spa, vdev_id);
	vdev_rebuild_t *vr = &vd->vdev_rebuild_config;
	vdev_rebuild_phys_t *vrp = &vr->vr_rebuild_phys;
	objset_t *mos = spa_meta_objset(spa);

	mutex_enter(&vd->vdev_rebuild_lock);

	if (!spa_feature_is_enabled(spa, SPA_FEATURE_DEVICE_REBUILD) \|\|
	vrp->vrp_rebuild_state == VDEV_REBUILD_ACTIVE) {
	mutex_exit(&vd->vdev_rebuild_lock);
	return;
	}

	clear_rebuild_bytes(vd);
	bzero(vrp, sizeof (uint64_t) * REBUILD_PHYS_ENTRIES);

	if (vd->vdev_top_zap != 0 && zap_contains(mos, vd->vdev_top_zap,
	VDEV_TOP_ZAP_VDEV_REBUILD_PHYS) == 0) {
	VERIFY0(zap_update(mos, vd->vdev_top_zap,
	VDEV_TOP_ZAP_VDEV_REBUILD_PHYS, sizeof (uint64_t),
	REBUILD_PHYS_ENTRIES, vrp, tx));
	}

	mutex_exit(&vd->vdev_rebuild_lock);
	}

	/*
	* The zio_done_func_t callback for each rebuild I/O issued. It's responsible
	* for updating the rebuild stats and limiting the number of in flight I/Os.
	*/
	static void
	vdev_rebuild_cb(zio_t *zio)
	{
	vdev_rebuild_t *vr = zio->io_private;
	vdev_rebuild_phys_t *vrp = &vr->vr_rebuild_phys;
	vdev_t *vd = vr->vr_top_vdev;

	mutex_enter(&vr->vr_io_lock);
	if (zio->io_error == ENXIO && !vdev_writeable(vd)) {
	/*
	* The I/O failed because the top-level vdev was unavailable.
	* Attempt to roll back to the last completed offset, in order
	* resume from the correct location if the pool is resumed.
	* (This works because spa_sync waits on spa_txg_zio before
	* it runs sync tasks.)
	*/
	uint64_t *off = &vr->vr_scan_offset[zio->io_txg & TXG_MASK];
	off = MIN(off, zio->io_offset);
	} else if (zio->io_error) {
	vrp->vrp_errors++;
	}

	abd_free(zio->io_abd);

	ASSERT3U(vr->vr_bytes_inflight, >, 0);
	vr->vr_bytes_inflight -= zio->io_size;
	cv_broadcast(&vr->vr_io_cv);
	mutex_exit(&vr->vr_io_lock);

	spa_config_exit(vd->vdev_spa, SCL_STATE_ALL, vd);
	}

	/*
	* Initialize a block pointer that can be used to read the given segment
	* for sequential rebuild.
	*/
	static void
	vdev_rebuild_blkptr_init(blkptr_t bp, vdev_t vd, uint64_t start,
	uint64_t asize)
	{
	ASSERT(vd->vdev_ops == &vdev_draid_ops \|\|
	vd->vdev_ops == &vdev_mirror_ops \|\|
	vd->vdev_ops == &vdev_replacing_ops \|\|
	vd->vdev_ops == &vdev_spare_ops);

	uint64_t psize = vd->vdev_ops == &vdev_draid_ops ?
	vdev_draid_asize_to_psize(vd, asize) : asize;

	BP_ZERO(bp);

	DVA_SET_VDEV(&bp->blk_dva[0], vd->vdev_id);
	DVA_SET_OFFSET(&bp->blk_dva[0], start);
	DVA_SET_GANG(&bp->blk_dva[0], 0);
	DVA_SET_ASIZE(&bp->blk_dva[0], asize);

	BP_SET_BIRTH(bp, TXG_INITIAL, TXG_INITIAL);
	BP_SET_LSIZE(bp, psize);
	BP_SET_PSIZE(bp, psize);
	BP_SET_COMPRESS(bp, ZIO_COMPRESS_OFF);
	BP_SET_CHECKSUM(bp, ZIO_CHECKSUM_OFF);
	BP_SET_TYPE(bp, DMU_OT_NONE);
	BP_SET_LEVEL(bp, 0);
	BP_SET_DEDUP(bp, 0);
	BP_SET_BYTEORDER(bp, ZFS_HOST_BYTEORDER);
	}

	/*
	* Issues a rebuild I/O and takes care of rate limiting the number of queued
	* rebuild I/Os. The provided start and size must be properly aligned for the
	* top-level vdev type being rebuilt.
	*/
	static int
	vdev_rebuild_range(vdev_rebuild_t *vr, uint64_t start, uint64_t size)
	{
	uint64_t ms_id __maybe_unused = vr->vr_scan_msp->ms_id;
	vdev_t *vd = vr->vr_top_vdev;
	spa_t *spa = vd->vdev_spa;
	blkptr_t blk;

	ASSERT3U(ms_id, ==, start >> vd->vdev_ms_shift);
	ASSERT3U(ms_id, ==, (start + size - 1) >> vd->vdev_ms_shift);

	vr->vr_pass_bytes_scanned += size;
	vr->vr_rebuild_phys.vrp_bytes_scanned += size;

	/*
	* Rebuild the data in this range by constructing a special block
	* pointer. It has no relation to any existing blocks in the pool.
	* However, by disabling checksum verification and issuing a scrub IO
	* we can reconstruct and repair any children with missing data.
	*/
	vdev_rebuild_blkptr_init(&blk, vd, start, size);
	uint64_t psize = BP_GET_PSIZE(&blk);

	if (!vdev_dtl_need_resilver(vd, &blk.blk_dva[0], psize, TXG_UNKNOWN))
	return (0);

	mutex_enter(&vr->vr_io_lock);

	/* Limit in flight rebuild I/Os */
	while (vr->vr_bytes_inflight >= vr->vr_bytes_inflight_max)
	cv_wait(&vr->vr_io_cv, &vr->vr_io_lock);

	vr->vr_bytes_inflight += psize;
	mutex_exit(&vr->vr_io_lock);

	dmu_tx_t *tx = dmu_tx_create_dd(spa_get_dsl(spa)->dp_mos_dir);
	VERIFY0(dmu_tx_assign(tx, TXG_WAIT));
	uint64_t txg = dmu_tx_get_txg(tx);

	spa_config_enter(spa, SCL_STATE_ALL, vd, RW_READER);
	mutex_enter(&vd->vdev_rebuild_lock);

	/* This is the first I/O for this txg. */
	if (vr->vr_scan_offset[txg & TXG_MASK] == 0) {
	vr->vr_scan_offset[txg & TXG_MASK] = start;
	dsl_sync_task_nowait(spa_get_dsl(spa),
	vdev_rebuild_update_sync,
	(void *)(uintptr_t)vd->vdev_id, tx);
	}

	/* When exiting write out our progress. */
	if (vdev_rebuild_should_stop(vd)) {
	mutex_enter(&vr->vr_io_lock);
	vr->vr_bytes_inflight -= psize;
	mutex_exit(&vr->vr_io_lock);
	spa_config_exit(vd->vdev_spa, SCL_STATE_ALL, vd);
	mutex_exit(&vd->vdev_rebuild_lock);
	dmu_tx_commit(tx);
	return (SET_ERROR(EINTR));
	}
	mutex_exit(&vd->vdev_rebuild_lock);
	dmu_tx_commit(tx);

	vr->vr_scan_offset[txg & TXG_MASK] = start + size;
	vr->vr_pass_bytes_issued += size;
	vr->vr_rebuild_phys.vrp_bytes_issued += size;

	zio_nowait(zio_read(spa->spa_txg_zio[txg & TXG_MASK], spa, &blk,
	abd_alloc(psize, B_FALSE), psize, vdev_rebuild_cb, vr,
	ZIO_PRIORITY_REBUILD, ZIO_FLAG_RAW \| ZIO_FLAG_CANFAIL \|
	ZIO_FLAG_RESILVER, NULL));

	return (0);
	}

	/*
	* Issues rebuild I/Os for all ranges in the provided vr->vr_tree range tree.
	*/
	static int
	vdev_rebuild_ranges(vdev_rebuild_t *vr)
	{
	vdev_t *vd = vr->vr_top_vdev;
	zfs_btree_t *t = &vr->vr_scan_tree->rt_root;
	zfs_btree_index_t idx;
	int error;

	for (range_seg_t *rs = zfs_btree_first(t, &idx); rs != NULL;
	rs = zfs_btree_next(t, &idx, &idx)) {
	uint64_t start = rs_get_start(rs, vr->vr_scan_tree);
	uint64_t size = rs_get_end(rs, vr->vr_scan_tree) - start;

	/*
	* zfs_scan_suspend_progress can be set to disable rebuild
	* progress for testing. See comment in dsl_scan_sync().
	*/
	while (zfs_scan_suspend_progress &&
	!vdev_rebuild_should_stop(vd)) {
	delay(hz);
	}

	while (size > 0) {
	uint64_t chunk_size;

	/*
	* Split range into legally-sized logical chunks
	* given the constraints of the top-level vdev
	* being rebuilt (dRAID or mirror).
	*/
	ASSERT3P(vd->vdev_ops, !=, NULL);
	chunk_size = vd->vdev_ops->vdev_op_rebuild_asize(vd,
	start, size, zfs_rebuild_max_segment);

	error = vdev_rebuild_range(vr, start, chunk_size);
	if (error != 0)
	return (error);

	size -= chunk_size;
	start += chunk_size;
	}
	}

	return (0);
	}

	/*
	* Calculates the estimated capacity which remains to be scanned. Since
	* we traverse the pool in metaslab order only allocated capacity beyond
	* the vrp_last_offset need be considered. All lower offsets must have
	* already been rebuilt and are thus already included in vrp_bytes_scanned.
	*/
	static void
	vdev_rebuild_update_bytes_est(vdev_t *vd, uint64_t ms_id)
	{
	vdev_rebuild_t *vr = &vd->vdev_rebuild_config;
	vdev_rebuild_phys_t *vrp = &vr->vr_rebuild_phys;
	uint64_t bytes_est = vrp->vrp_bytes_scanned;

	if (vrp->vrp_last_offset < vd->vdev_ms[ms_id]->ms_start)
	return;

	for (uint64_t i = ms_id; i < vd->vdev_ms_count; i++) {
	metaslab_t *msp = vd->vdev_ms[i];

	mutex_enter(&msp->ms_lock);
	bytes_est += metaslab_allocated_space(msp);
	mutex_exit(&msp->ms_lock);
	}

	vrp->vrp_bytes_est = bytes_est;
	}

	/*
	* Load from disk the top-level vdev's rebuild information.
	*/
	int
	vdev_rebuild_load(vdev_t *vd)
	{
	vdev_rebuild_t *vr = &vd->vdev_rebuild_config;
	vdev_rebuild_phys_t *vrp = &vr->vr_rebuild_phys;
	spa_t *spa = vd->vdev_spa;
	int err = 0;

	mutex_enter(&vd->vdev_rebuild_lock);
	vd->vdev_rebuilding = B_FALSE;

	if (!spa_feature_is_enabled(spa, SPA_FEATURE_DEVICE_REBUILD)) {
	bzero(vrp, sizeof (uint64_t) * REBUILD_PHYS_ENTRIES);
	mutex_exit(&vd->vdev_rebuild_lock);
	return (SET_ERROR(ENOTSUP));
	}

	ASSERT(vd->vdev_top == vd);

	err = zap_lookup(spa->spa_meta_objset, vd->vdev_top_zap,
	VDEV_TOP_ZAP_VDEV_REBUILD_PHYS, sizeof (uint64_t),
	REBUILD_PHYS_ENTRIES, vrp);

	/*
	* A missing or damaged VDEV_TOP_ZAP_VDEV_REBUILD_PHYS should
	* not prevent a pool from being imported. Clear the rebuild
	* status allowing a new resilver/rebuild to be started.
	*/
	if (err == ENOENT \|\| err == EOVERFLOW \|\| err == ECKSUM) {
	bzero(vrp, sizeof (uint64_t) * REBUILD_PHYS_ENTRIES);
	} else if (err) {
	mutex_exit(&vd->vdev_rebuild_lock);
	return (err);
	}

	vr->vr_prev_scan_time_ms = vrp->vrp_scan_time_ms;
	vr->vr_top_vdev = vd;

	mutex_exit(&vd->vdev_rebuild_lock);

	return (0);
	}

	/*
	* Each scan thread is responsible for rebuilding a top-level vdev. The
	* rebuild progress in tracked on-disk in VDEV_TOP_ZAP_VDEV_REBUILD_PHYS.
	*/
	static void
	vdev_rebuild_thread(void *arg)
	{
	vdev_t *vd = arg;
	spa_t *spa = vd->vdev_spa;
	int error = 0;

	/*
	* If there's a scrub in process request that it be stopped. This
	* is not required for a correct rebuild, but we do want rebuilds to
	* emulate the resilver behavior as much as possible.
	*/
	dsl_pool_t *dsl = spa_get_dsl(spa);
	if (dsl_scan_scrubbing(dsl))
	dsl_scan_cancel(dsl);

	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
	mutex_enter(&vd->vdev_rebuild_lock);

	ASSERT3P(vd->vdev_top, ==, vd);
	ASSERT3P(vd->vdev_rebuild_thread, !=, NULL);
	ASSERT(vd->vdev_rebuilding);
	ASSERT(spa_feature_is_active(spa, SPA_FEATURE_DEVICE_REBUILD));
	ASSERT3B(vd->vdev_rebuild_cancel_wanted, ==, B_FALSE);
	ASSERT3B(vd->vdev_rebuild_reset_wanted, ==, B_FALSE);

	vdev_rebuild_t *vr = &vd->vdev_rebuild_config;
	vdev_rebuild_phys_t *vrp = &vr->vr_rebuild_phys;
	vr->vr_top_vdev = vd;
	vr->vr_scan_msp = NULL;
	vr->vr_scan_tree = range_tree_create(NULL, RANGE_SEG64, NULL, 0, 0);
	mutex_init(&vr->vr_io_lock, NULL, MUTEX_DEFAULT, NULL);
	cv_init(&vr->vr_io_cv, NULL, CV_DEFAULT, NULL);

	vr->vr_pass_start_time = gethrtime();
	vr->vr_pass_bytes_scanned = 0;
	vr->vr_pass_bytes_issued = 0;

	vr->vr_bytes_inflight_max = MAX(1ULL << 20,
	zfs_rebuild_vdev_limit * vd->vdev_children);

	uint64_t update_est_time = gethrtime();
	vdev_rebuild_update_bytes_est(vd, 0);

	clear_rebuild_bytes(vr->vr_top_vdev);

	mutex_exit(&vd->vdev_rebuild_lock);

	/*
	* Systematically walk the metaslabs and issue rebuild I/Os for
	* all ranges in the allocated space map.
	*/
	for (uint64_t i = 0; i < vd->vdev_ms_count; i++) {
	metaslab_t *msp = vd->vdev_ms[i];
	vr->vr_scan_msp = msp;

	/*
	* Removal of vdevs from the vdev tree may eliminate the need
	* for the rebuild, in which case it should be canceled. The
	* vdev_rebuild_cancel_wanted flag is set until the sync task
	* completes. This may be after the rebuild thread exits.
	*/
	if (vdev_rebuild_should_cancel(vd)) {
	vd->vdev_rebuild_cancel_wanted = B_TRUE;
	error = EINTR;
	break;
	}

	ASSERT0(range_tree_space(vr->vr_scan_tree));

	/* Disable any new allocations to this metaslab */
	spa_config_exit(spa, SCL_CONFIG, FTAG);
	metaslab_disable(msp);

	mutex_enter(&msp->ms_sync_lock);
	mutex_enter(&msp->ms_lock);

	/*
	* If there are outstanding allocations wait for them to be
	* synced. This is needed to ensure all allocated ranges are
	* on disk and therefore will be rebuilt.
	*/
	for (int j = 0; j < TXG_SIZE; j++) {
	if (range_tree_space(msp->ms_allocating[j])) {
	mutex_exit(&msp->ms_lock);
	mutex_exit(&msp->ms_sync_lock);
	txg_wait_synced(dsl, 0);
	mutex_enter(&msp->ms_sync_lock);
	mutex_enter(&msp->ms_lock);
	break;
	}
	}

	/*
	* When a metaslab has been allocated from read its allocated
	* ranges from the space map object into the vr_scan_tree.
	* Then add inflight / unflushed ranges and remove inflight /
	* unflushed frees. This is the minimum range to be rebuilt.
	*/
	if (msp->ms_sm != NULL) {
	VERIFY0(space_map_load(msp->ms_sm,
	vr->vr_scan_tree, SM_ALLOC));

	for (int i = 0; i < TXG_SIZE; i++) {
	ASSERT0(range_tree_space(
	msp->ms_allocating[i]));
	}

	range_tree_walk(msp->ms_unflushed_allocs,
	range_tree_add, vr->vr_scan_tree);
	range_tree_walk(msp->ms_unflushed_frees,
	range_tree_remove, vr->vr_scan_tree);

	/*
	* Remove ranges which have already been rebuilt based
	* on the last offset. This can happen when restarting
	* a scan after exporting and re-importing the pool.
	*/
	range_tree_clear(vr->vr_scan_tree, 0,
	vrp->vrp_last_offset);
	}

	mutex_exit(&msp->ms_lock);
	mutex_exit(&msp->ms_sync_lock);

	/*
	* To provide an accurate estimate re-calculate the estimated
	* size every 5 minutes to account for recent allocations and
	* frees made to space maps which have not yet been rebuilt.
	*/
	if (gethrtime() > update_est_time + SEC2NSEC(300)) {
	update_est_time = gethrtime();
	vdev_rebuild_update_bytes_est(vd, i);
	}

	/*
	* Walk the allocated space map and issue the rebuild I/O.
	*/
	error = vdev_rebuild_ranges(vr);
	range_tree_vacate(vr->vr_scan_tree, NULL, NULL);

	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);
	metaslab_enable(msp, B_FALSE, B_FALSE);

	if (error != 0)
	break;
	}

	range_tree_destroy(vr->vr_scan_tree);
	spa_config_exit(spa, SCL_CONFIG, FTAG);

	/* Wait for any remaining rebuild I/O to complete */
	mutex_enter(&vr->vr_io_lock);
	while (vr->vr_bytes_inflight > 0)
	cv_wait(&vr->vr_io_cv, &vr->vr_io_lock);

	mutex_exit(&vr->vr_io_lock);

	mutex_destroy(&vr->vr_io_lock);
	cv_destroy(&vr->vr_io_cv);

	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_READER);

	dsl_pool_t *dp = spa_get_dsl(spa);
	dmu_tx_t *tx = dmu_tx_create_dd(dp->dp_mos_dir);
	VERIFY0(dmu_tx_assign(tx, TXG_WAIT));

	mutex_enter(&vd->vdev_rebuild_lock);
	if (error == 0) {
	/*
	* After a successful rebuild clear the DTLs of all ranges
	* which were missing when the rebuild was started. These
	* ranges must have been rebuilt as a consequence of rebuilding
	* all allocated space. Note that unlike a scrub or resilver
	* the rebuild operation will reconstruct data only referenced
	* by a pool checkpoint. See the dsl_scan_done() comments.
	*/
	dsl_sync_task_nowait(dp, vdev_rebuild_complete_sync,
	(void *)(uintptr_t)vd->vdev_id, tx);
	} else if (vd->vdev_rebuild_cancel_wanted) {
	/*
	* The rebuild operation was canceled. This will occur when
	* a device participating in the rebuild is detached.
	*/
	dsl_sync_task_nowait(dp, vdev_rebuild_cancel_sync,
	(void *)(uintptr_t)vd->vdev_id, tx);
	} else if (vd->vdev_rebuild_reset_wanted) {
	/*
	* Reset the running rebuild without canceling and restarting
	* it. This will occur when a new device is attached and must
	* participate in the rebuild.
	*/
	dsl_sync_task_nowait(dp, vdev_rebuild_reset_sync,
	(void *)(uintptr_t)vd->vdev_id, tx);
	} else {
	/*
	* The rebuild operation should be suspended. This may occur
	* when detaching a child vdev or when exporting the pool. The
	* rebuild is left in the active state so it will be resumed.
	*/
	ASSERT(vrp->vrp_rebuild_state == VDEV_REBUILD_ACTIVE);
	vd->vdev_rebuilding = B_FALSE;
	}

	dmu_tx_commit(tx);

	vd->vdev_rebuild_thread = NULL;
	mutex_exit(&vd->vdev_rebuild_lock);
	spa_config_exit(spa, SCL_CONFIG, FTAG);

	cv_broadcast(&vd->vdev_rebuild_cv);

	thread_exit();
	}

	/*
	* Returns B_TRUE if any top-level vdev are rebuilding.
	*/
	boolean_t
	vdev_rebuild_active(vdev_t *vd)
	{
	spa_t *spa = vd->vdev_spa;
	boolean_t ret = B_FALSE;

	if (vd == spa->spa_root_vdev) {
	for (uint64_t i = 0; i < vd->vdev_children; i++) {
	ret = vdev_rebuild_active(vd->vdev_child[i]);
	if (ret)
	return (ret);
	}
	} else if (vd->vdev_top_zap != 0) {
	vdev_rebuild_t *vr = &vd->vdev_rebuild_config;
	vdev_rebuild_phys_t *vrp = &vr->vr_rebuild_phys;

	mutex_enter(&vd->vdev_rebuild_lock);
	ret = (vrp->vrp_rebuild_state == VDEV_REBUILD_ACTIVE);
	mutex_exit(&vd->vdev_rebuild_lock);
	}

	return (ret);
	}

	/*
	* Start a rebuild operation. The rebuild may be restarted when the
	* top-level vdev is currently actively rebuilding.
	*/
	void
	vdev_rebuild(vdev_t *vd)
	{
	vdev_rebuild_t *vr = &vd->vdev_rebuild_config;
	vdev_rebuild_phys_t *vrp __maybe_unused = &vr->vr_rebuild_phys;

	ASSERT(vd->vdev_top == vd);
	ASSERT(vdev_is_concrete(vd));
	ASSERT(!vd->vdev_removing);
	ASSERT(spa_feature_is_enabled(vd->vdev_spa,
	SPA_FEATURE_DEVICE_REBUILD));

	mutex_enter(&vd->vdev_rebuild_lock);
	if (vd->vdev_rebuilding) {
	ASSERT3U(vrp->vrp_rebuild_state, ==, VDEV_REBUILD_ACTIVE);

	/*
	* Signal a running rebuild operation that it should restart
	* from the beginning because a new device was attached. The
	* vdev_rebuild_reset_wanted flag is set until the sync task
	* completes. This may be after the rebuild thread exits.
	*/
	if (!vd->vdev_rebuild_reset_wanted)
	vd->vdev_rebuild_reset_wanted = B_TRUE;
	} else {
	vdev_rebuild_initiate(vd);
	}
	mutex_exit(&vd->vdev_rebuild_lock);
	}

	static void
	vdev_rebuild_restart_impl(vdev_t *vd)
	{
	spa_t *spa = vd->vdev_spa;

	if (vd == spa->spa_root_vdev) {
	for (uint64_t i = 0; i < vd->vdev_children; i++)
	vdev_rebuild_restart_impl(vd->vdev_child[i]);

	} else if (vd->vdev_top_zap != 0) {
	vdev_rebuild_t *vr = &vd->vdev_rebuild_config;
	vdev_rebuild_phys_t *vrp = &vr->vr_rebuild_phys;

	mutex_enter(&vd->vdev_rebuild_lock);
	if (vrp->vrp_rebuild_state == VDEV_REBUILD_ACTIVE &&
	vdev_writeable(vd) && !vd->vdev_rebuilding) {
	ASSERT(spa_feature_is_active(spa,
	SPA_FEATURE_DEVICE_REBUILD));
	vd->vdev_rebuilding = B_TRUE;
	vd->vdev_rebuild_thread = thread_create(NULL, 0,
	vdev_rebuild_thread, vd, 0, &p0, TS_RUN,
	maxclsyspri);
	}
	mutex_exit(&vd->vdev_rebuild_lock);
	}
	}

	/*
	* Conditionally restart all of the vdev_rebuild_thread's for a pool. The
	* feature flag must be active and the rebuild in the active state. This
	* cannot be used to start a new rebuild.
	*/
	void
	vdev_rebuild_restart(spa_t *spa)
	{
	ASSERT(MUTEX_HELD(&spa_namespace_lock));

	vdev_rebuild_restart_impl(spa->spa_root_vdev);
	}

	/*
	* Stop and wait for all of the vdev_rebuild_thread's associated with the
	* vdev tree provide to be terminated (canceled or stopped).
	*/
	void
	vdev_rebuild_stop_wait(vdev_t *vd)
	{
	spa_t *spa = vd->vdev_spa;

	ASSERT(MUTEX_HELD(&spa_namespace_lock));

	if (vd == spa->spa_root_vdev) {
	for (uint64_t i = 0; i < vd->vdev_children; i++)
	vdev_rebuild_stop_wait(vd->vdev_child[i]);

	} else if (vd->vdev_top_zap != 0) {
	ASSERT(vd == vd->vdev_top);

	mutex_enter(&vd->vdev_rebuild_lock);
	if (vd->vdev_rebuild_thread != NULL) {
	vd->vdev_rebuild_exit_wanted = B_TRUE;
	while (vd->vdev_rebuilding) {
	cv_wait(&vd->vdev_rebuild_cv,
	&vd->vdev_rebuild_lock);
	}
	vd->vdev_rebuild_exit_wanted = B_FALSE;
	}
	mutex_exit(&vd->vdev_rebuild_lock);
	}
	}

	/*
	* Stop all rebuild operations but leave them in the active state so they
	* will be resumed when importing the pool.
	*/
	void
	vdev_rebuild_stop_all(spa_t *spa)
	{
	vdev_rebuild_stop_wait(spa->spa_root_vdev);
	}

	/*
	* Rebuild statistics reported per top-level vdev.
	*/
	int
	vdev_rebuild_get_stats(vdev_t tvd, vdev_rebuild_stat_t vrs)
	{
	spa_t *spa = tvd->vdev_spa;

	if (!spa_feature_is_enabled(spa, SPA_FEATURE_DEVICE_REBUILD))
	return (SET_ERROR(ENOTSUP));

	if (tvd != tvd->vdev_top \|\| tvd->vdev_top_zap == 0)
	return (SET_ERROR(EINVAL));

	int error = zap_contains(spa_meta_objset(spa),
	tvd->vdev_top_zap, VDEV_TOP_ZAP_VDEV_REBUILD_PHYS);

	if (error == ENOENT) {
	bzero(vrs, sizeof (vdev_rebuild_stat_t));
	vrs->vrs_state = VDEV_REBUILD_NONE;
	error = 0;
	} else if (error == 0) {
	vdev_rebuild_t *vr = &tvd->vdev_rebuild_config;
	vdev_rebuild_phys_t *vrp = &vr->vr_rebuild_phys;

	mutex_enter(&tvd->vdev_rebuild_lock);
	vrs->vrs_state = vrp->vrp_rebuild_state;
	vrs->vrs_start_time = vrp->vrp_start_time;
	vrs->vrs_end_time = vrp->vrp_end_time;
	vrs->vrs_scan_time_ms = vrp->vrp_scan_time_ms;
	vrs->vrs_bytes_scanned = vrp->vrp_bytes_scanned;
	vrs->vrs_bytes_issued = vrp->vrp_bytes_issued;
	vrs->vrs_bytes_rebuilt = vrp->vrp_bytes_rebuilt;
	vrs->vrs_bytes_est = vrp->vrp_bytes_est;
	vrs->vrs_errors = vrp->vrp_errors;
	vrs->vrs_pass_time_ms = NSEC2MSEC(gethrtime() -
	vr->vr_pass_start_time);
	vrs->vrs_pass_bytes_scanned = vr->vr_pass_bytes_scanned;
	vrs->vrs_pass_bytes_issued = vr->vr_pass_bytes_issued;
	mutex_exit(&tvd->vdev_rebuild_lock);
	}

	return (error);
	}

	/* BEGIN CSTYLED */
	ZFS_MODULE_PARAM(zfs, zfs_, rebuild_max_segment, ULONG, ZMOD_RW,
	"Max segment size in bytes of rebuild reads");

	ZFS_MODULE_PARAM(zfs, zfs_, rebuild_vdev_limit, ULONG, ZMOD_RW,
	"Max bytes in flight per leaf vdev for sequential resilvers");

	ZFS_MODULE_PARAM(zfs, zfs_, rebuild_scrub_enabled, INT, ZMOD_RW,
	"Automatically scrub after sequential resilver completes");
	/* END CSTYLED */
	diff --git a/sys/contrib/openzfs/module/zfs/zfs_fm.c b/sys/contrib/openzfs/module/zfs/zfs_fm.c
	index f0f953405cb2..60e631567a89 100644
	--- a/sys/contrib/openzfs/module/zfs/zfs_fm.c
	+++ b/sys/contrib/openzfs/module/zfs/zfs_fm.c
	@@ -1,1456 +1,1458 @@
	/*
	* 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 2009 Sun Microsystems, Inc. All rights reserved.
	* Use is subject to license terms.
	*/

	/*
	* Copyright (c) 2012,2021 by Delphix. All rights reserved.
	*/

	#include <sys/spa.h>
	#include <sys/spa_impl.h>
	#include <sys/vdev.h>
	#include <sys/vdev_impl.h>
	#include <sys/zio.h>
	#include <sys/zio_checksum.h>

	#include <sys/fm/fs/zfs.h>
	#include <sys/fm/protocol.h>
	#include <sys/fm/util.h>
	#include <sys/sysevent.h>

	/*
	* This general routine is responsible for generating all the different ZFS
	* ereports. The payload is dependent on the class, and which arguments are
	* supplied to the function:
	*
	* EREPORT POOL VDEV IO
	* block X X X
	* data X X
	* device X X
	* pool X
	*
	* If we are in a loading state, all errors are chained together by the same
	* SPA-wide ENA (Error Numeric Association).
	*
	* For isolated I/O requests, we get the ENA from the zio_t. The propagation
	* gets very complicated due to RAID-Z, gang blocks, and vdev caching. We want
	* to chain together all ereports associated with a logical piece of data. For
	* read I/Os, there are basically three 'types' of I/O, which form a roughly
	* layered diagram:
	*
	* +---------------+
	* \| Aggregate I/O \| No associated logical data or device
	* +---------------+
	* \|
	* V
	* +---------------+ Reads associated with a piece of logical data.
	* \| Read I/O \| This includes reads on behalf of RAID-Z,
	* +---------------+ mirrors, gang blocks, retries, etc.
	* \|
	* V
	* +---------------+ Reads associated with a particular device, but
	* \| Physical I/O \| no logical data. Issued as part of vdev caching
	* +---------------+ and I/O aggregation.
	*
	* Note that 'physical I/O' here is not the same terminology as used in the rest
	* of ZIO. Typically, 'physical I/O' simply means that there is no attached
	* blockpointer. But I/O with no associated block pointer can still be related
	* to a logical piece of data (i.e. RAID-Z requests).
	*
	* Purely physical I/O always have unique ENAs. They are not related to a
	* particular piece of logical data, and therefore cannot be chained together.
	* We still generate an ereport, but the DE doesn't correlate it with any
	* logical piece of data. When such an I/O fails, the delegated I/O requests
	* will issue a retry, which will trigger the 'real' ereport with the correct
	* ENA.
	*
	* We keep track of the ENA for a ZIO chain through the 'io_logical' member.
	* When a new logical I/O is issued, we set this to point to itself. Child I/Os
	* then inherit this pointer, so that when it is first set subsequent failures
	* will use the same ENA. For vdev cache fill and queue aggregation I/O,
	* this pointer is set to NULL, and no ereport will be generated (since it
	* doesn't actually correspond to any particular device or piece of data,
	* and the caller will always retry without caching or queueing anyway).
	*
	* For checksum errors, we want to include more information about the actual
	* error which occurs. Accordingly, we build an ereport when the error is
	* noticed, but instead of sending it in immediately, we hang it off of the
	* io_cksum_report field of the logical IO. When the logical IO completes
	* (successfully or not), zfs_ereport_finish_checksum() is called with the
	* good and bad versions of the buffer (if available), and we annotate the
	* ereport with information about the differences.
	*/

	#ifdef _KERNEL
	/*
	* Duplicate ereport Detection
	*
	* Some ereports are retained momentarily for detecting duplicates. These
	* are kept in a recent_events_node_t in both a time-ordered list and an AVL
	* tree of recent unique ereports.
	*
	* The lifespan of these recent ereports is bounded (15 mins) and a cleaner
	* task is used to purge stale entries.
	*/
	static list_t recent_events_list;
	static avl_tree_t recent_events_tree;
	static kmutex_t recent_events_lock;
	static taskqid_t recent_events_cleaner_tqid;

	/*
	* Each node is about 128 bytes so 2,000 would consume 1/4 MiB.
	*
	* This setting can be changed dynamically and setting it to zero
	* disables duplicate detection.
	*/
	unsigned int zfs_zevent_retain_max = 2000;

	/*
	* The lifespan for a recent ereport entry. The default of 15 minutes is
	* intended to outlive the zfs diagnosis engine's threshold of 10 errors
	* over a period of 10 minutes.
	*/
	unsigned int zfs_zevent_retain_expire_secs = 900;

	typedef enum zfs_subclass {
	ZSC_IO,
	ZSC_DATA,
	ZSC_CHECKSUM
	} zfs_subclass_t;

	typedef struct {
	/* common criteria */
	uint64_t re_pool_guid;
	uint64_t re_vdev_guid;
	int re_io_error;
	uint64_t re_io_size;
	uint64_t re_io_offset;
	zfs_subclass_t re_subclass;
	zio_priority_t re_io_priority;

	/* logical zio criteria (optional) */
	zbookmark_phys_t re_io_bookmark;

	/* internal state */
	avl_node_t re_tree_link;
	list_node_t re_list_link;
	uint64_t re_timestamp;
	} recent_events_node_t;

	static int
	recent_events_compare(const void a, const void b)
	{
	const recent_events_node_t *node1 = a;
	const recent_events_node_t *node2 = b;
	int cmp;

	/*
	* The comparison order here is somewhat arbitrary.
	* What's important is that if every criteria matches, then it
	* is a duplicate (i.e. compare returns 0)
	*/
	if ((cmp = TREE_CMP(node1->re_subclass, node2->re_subclass)) != 0)
	return (cmp);
	if ((cmp = TREE_CMP(node1->re_pool_guid, node2->re_pool_guid)) != 0)
	return (cmp);
	if ((cmp = TREE_CMP(node1->re_vdev_guid, node2->re_vdev_guid)) != 0)
	return (cmp);
	if ((cmp = TREE_CMP(node1->re_io_error, node2->re_io_error)) != 0)
	return (cmp);
	if ((cmp = TREE_CMP(node1->re_io_priority, node2->re_io_priority)) != 0)
	return (cmp);
	if ((cmp = TREE_CMP(node1->re_io_size, node2->re_io_size)) != 0)
	return (cmp);
	if ((cmp = TREE_CMP(node1->re_io_offset, node2->re_io_offset)) != 0)
	return (cmp);

	const zbookmark_phys_t *zb1 = &node1->re_io_bookmark;
	const zbookmark_phys_t *zb2 = &node2->re_io_bookmark;

	if ((cmp = TREE_CMP(zb1->zb_objset, zb2->zb_objset)) != 0)
	return (cmp);
	if ((cmp = TREE_CMP(zb1->zb_object, zb2->zb_object)) != 0)
	return (cmp);
	if ((cmp = TREE_CMP(zb1->zb_level, zb2->zb_level)) != 0)
	return (cmp);
	if ((cmp = TREE_CMP(zb1->zb_blkid, zb2->zb_blkid)) != 0)
	return (cmp);

	return (0);
	}

	static void zfs_ereport_schedule_cleaner(void);

	/*
	* background task to clean stale recent event nodes.
	*/
	/ARGSUSED/
	static void
	zfs_ereport_cleaner(void *arg)
	{
	recent_events_node_t *entry;
	uint64_t now = gethrtime();

	/*
	* purge expired entries
	*/
	mutex_enter(&recent_events_lock);
	while ((entry = list_tail(&recent_events_list)) != NULL) {
	uint64_t age = NSEC2SEC(now - entry->re_timestamp);
	if (age <= zfs_zevent_retain_expire_secs)
	break;

	/* remove expired node */
	avl_remove(&recent_events_tree, entry);
	list_remove(&recent_events_list, entry);
	kmem_free(entry, sizeof (*entry));
	}

	/* Restart the cleaner if more entries remain */
	recent_events_cleaner_tqid = 0;
	if (!list_is_empty(&recent_events_list))
	zfs_ereport_schedule_cleaner();

	mutex_exit(&recent_events_lock);
	}

	static void
	zfs_ereport_schedule_cleaner(void)
	{
	ASSERT(MUTEX_HELD(&recent_events_lock));

	uint64_t timeout = SEC2NSEC(zfs_zevent_retain_expire_secs + 1);

	recent_events_cleaner_tqid = taskq_dispatch_delay(
	system_delay_taskq, zfs_ereport_cleaner, NULL, TQ_SLEEP,
	ddi_get_lbolt() + NSEC_TO_TICK(timeout));
	}

	/*
	* Clear entries for a given vdev or all vdevs in a pool when vdev == NULL
	*/
	void
	zfs_ereport_clear(spa_t spa, vdev_t vd)
	{
	uint64_t vdev_guid, pool_guid;
	int cnt = 0;

	ASSERT(vd != NULL \|\| spa != NULL);
	if (vd == NULL) {
	vdev_guid = 0;
	pool_guid = spa_guid(spa);
	} else {
	vdev_guid = vd->vdev_guid;
	pool_guid = 0;
	}

	mutex_enter(&recent_events_lock);

	recent_events_node_t *next = list_head(&recent_events_list);
	while (next != NULL) {
	recent_events_node_t *entry = next;

	next = list_next(&recent_events_list, next);

	if (entry->re_vdev_guid == vdev_guid \|\|
	entry->re_pool_guid == pool_guid) {
	avl_remove(&recent_events_tree, entry);
	list_remove(&recent_events_list, entry);
	kmem_free(entry, sizeof (*entry));
	cnt++;
	}
	}

	mutex_exit(&recent_events_lock);
	}

	/*
	* Check if an ereport would be a duplicate of one recently posted.
	*
	* An ereport is considered a duplicate if the set of criteria in
	* recent_events_node_t all match.
	*
	* Only FM_EREPORT_ZFS_IO, FM_EREPORT_ZFS_DATA, and FM_EREPORT_ZFS_CHECKSUM
	* are candidates for duplicate checking.
	*/
	static boolean_t
	zfs_ereport_is_duplicate(const char subclass, spa_t spa, vdev_t *vd,
	const zbookmark_phys_t zb, zio_t zio, uint64_t offset, uint64_t size)
	{
	recent_events_node_t search = {0}, *entry;

	if (vd == NULL \|\| zio == NULL)
	return (B_FALSE);

	if (zfs_zevent_retain_max == 0)
	return (B_FALSE);

	if (strcmp(subclass, FM_EREPORT_ZFS_IO) == 0)
	search.re_subclass = ZSC_IO;
	else if (strcmp(subclass, FM_EREPORT_ZFS_DATA) == 0)
	search.re_subclass = ZSC_DATA;
	else if (strcmp(subclass, FM_EREPORT_ZFS_CHECKSUM) == 0)
	search.re_subclass = ZSC_CHECKSUM;
	else
	return (B_FALSE);

	search.re_pool_guid = spa_guid(spa);
	search.re_vdev_guid = vd->vdev_guid;
	search.re_io_error = zio->io_error;
	search.re_io_priority = zio->io_priority;
	/* if size is supplied use it over what's in zio */
	if (size) {
	search.re_io_size = size;
	search.re_io_offset = offset;
	} else {
	search.re_io_size = zio->io_size;
	search.re_io_offset = zio->io_offset;
	}

	/* grab optional logical zio criteria */
	if (zb != NULL) {
	search.re_io_bookmark.zb_objset = zb->zb_objset;
	search.re_io_bookmark.zb_object = zb->zb_object;
	search.re_io_bookmark.zb_level = zb->zb_level;
	search.re_io_bookmark.zb_blkid = zb->zb_blkid;
	}

	uint64_t now = gethrtime();

	mutex_enter(&recent_events_lock);

	/* check if we have seen this one recently */
	entry = avl_find(&recent_events_tree, &search, NULL);
	if (entry != NULL) {
	uint64_t age = NSEC2SEC(now - entry->re_timestamp);

	/*
	* There is still an active cleaner (since we're here).
	* Reset the last seen time for this duplicate entry
	* so that its lifespand gets extended.
	*/
	list_remove(&recent_events_list, entry);
	list_insert_head(&recent_events_list, entry);
	entry->re_timestamp = now;

	zfs_zevent_track_duplicate();
	mutex_exit(&recent_events_lock);

	return (age <= zfs_zevent_retain_expire_secs);
	}

	if (avl_numnodes(&recent_events_tree) >= zfs_zevent_retain_max) {
	/* recycle oldest node */
	entry = list_tail(&recent_events_list);
	ASSERT(entry != NULL);
	list_remove(&recent_events_list, entry);
	avl_remove(&recent_events_tree, entry);
	} else {
	entry = kmem_alloc(sizeof (recent_events_node_t), KM_SLEEP);
	}

	/* record this as a recent ereport */
	*entry = search;
	avl_add(&recent_events_tree, entry);
	list_insert_head(&recent_events_list, entry);
	entry->re_timestamp = now;

	/* Start a cleaner if not already scheduled */
	if (recent_events_cleaner_tqid == 0)
	zfs_ereport_schedule_cleaner();

	mutex_exit(&recent_events_lock);
	return (B_FALSE);
	}

	void
	zfs_zevent_post_cb(nvlist_t nvl, nvlist_t detector)
	{
	if (nvl)
	fm_nvlist_destroy(nvl, FM_NVA_FREE);

	if (detector)
	fm_nvlist_destroy(detector, FM_NVA_FREE);
	}

	/*
	- * We want to rate limit ZIO delay and checksum events so as to not
	- * flood ZED when a disk is acting up.
	+ * We want to rate limit ZIO delay, deadman, and checksum events so as to not
	+ * flood zevent consumers when a disk is acting up.
	*
	* Returns 1 if we're ratelimiting, 0 if not.
	*/
	static int
	zfs_is_ratelimiting_event(const char subclass, vdev_t vd)
	{
	int rc = 0;
	/*
	- * __ratelimit() returns 1 if we're not ratelimiting and 0 if we
	+ * zfs_ratelimit() returns 1 if we're not ratelimiting and 0 if we
	* are. Invert it to get our return value.
	*/
	if (strcmp(subclass, FM_EREPORT_ZFS_DELAY) == 0) {
	rc = !zfs_ratelimit(&vd->vdev_delay_rl);
	+ } else if (strcmp(subclass, FM_EREPORT_ZFS_DEADMAN) == 0) {
	+ rc = !zfs_ratelimit(&vd->vdev_deadman_rl);
	} else if (strcmp(subclass, FM_EREPORT_ZFS_CHECKSUM) == 0) {
	rc = !zfs_ratelimit(&vd->vdev_checksum_rl);
	}

	if (rc) {
	/* We're rate limiting */
	fm_erpt_dropped_increment();
	}

	return (rc);
	}

	/*
	* Return B_TRUE if the event actually posted, B_FALSE if not.
	*/
	static boolean_t
	zfs_ereport_start(nvlist_t ereport_out, nvlist_t detector_out,
	const char subclass, spa_t spa, vdev_t vd, const zbookmark_phys_t zb,
	zio_t *zio, uint64_t stateoroffset, uint64_t size)
	{
	nvlist_t ereport, detector;

	uint64_t ena;
	char class[64];

	if ((ereport = fm_nvlist_create(NULL)) == NULL)
	return (B_FALSE);

	if ((detector = fm_nvlist_create(NULL)) == NULL) {
	fm_nvlist_destroy(ereport, FM_NVA_FREE);
	return (B_FALSE);
	}

	/*
	* Serialize ereport generation
	*/
	mutex_enter(&spa->spa_errlist_lock);

	/*
	* Determine the ENA to use for this event. If we are in a loading
	* state, use a SPA-wide ENA. Otherwise, if we are in an I/O state, use
	* a root zio-wide ENA. Otherwise, simply use a unique ENA.
	*/
	if (spa_load_state(spa) != SPA_LOAD_NONE) {
	if (spa->spa_ena == 0)
	spa->spa_ena = fm_ena_generate(0, FM_ENA_FMT1);
	ena = spa->spa_ena;
	} else if (zio != NULL && zio->io_logical != NULL) {
	if (zio->io_logical->io_ena == 0)
	zio->io_logical->io_ena =
	fm_ena_generate(0, FM_ENA_FMT1);
	ena = zio->io_logical->io_ena;
	} else {
	ena = fm_ena_generate(0, FM_ENA_FMT1);
	}

	/*
	* Construct the full class, detector, and other standard FMA fields.
	*/
	(void) snprintf(class, sizeof (class), "%s.%s",
	ZFS_ERROR_CLASS, subclass);

	fm_fmri_zfs_set(detector, FM_ZFS_SCHEME_VERSION, spa_guid(spa),
	vd != NULL ? vd->vdev_guid : 0);

	fm_ereport_set(ereport, FM_EREPORT_VERSION, class, ena, detector, NULL);

	/*
	* Construct the per-ereport payload, depending on which parameters are
	* passed in.
	*/

	/*
	* Generic payload members common to all ereports.
	*/
	fm_payload_set(ereport,
	FM_EREPORT_PAYLOAD_ZFS_POOL, DATA_TYPE_STRING, spa_name(spa),
	FM_EREPORT_PAYLOAD_ZFS_POOL_GUID, DATA_TYPE_UINT64, spa_guid(spa),
	FM_EREPORT_PAYLOAD_ZFS_POOL_STATE, DATA_TYPE_UINT64,
	(uint64_t)spa_state(spa),
	FM_EREPORT_PAYLOAD_ZFS_POOL_CONTEXT, DATA_TYPE_INT32,
	(int32_t)spa_load_state(spa), NULL);

	fm_payload_set(ereport, FM_EREPORT_PAYLOAD_ZFS_POOL_FAILMODE,
	DATA_TYPE_STRING,
	spa_get_failmode(spa) == ZIO_FAILURE_MODE_WAIT ?
	FM_EREPORT_FAILMODE_WAIT :
	spa_get_failmode(spa) == ZIO_FAILURE_MODE_CONTINUE ?
	FM_EREPORT_FAILMODE_CONTINUE : FM_EREPORT_FAILMODE_PANIC,
	NULL);

	if (vd != NULL) {
	vdev_t *pvd = vd->vdev_parent;
	vdev_queue_t *vq = &vd->vdev_queue;
	vdev_stat_t *vs = &vd->vdev_stat;
	vdev_t *spare_vd;
	uint64_t *spare_guids;
	char **spare_paths;
	int i, spare_count;

	fm_payload_set(ereport, FM_EREPORT_PAYLOAD_ZFS_VDEV_GUID,
	DATA_TYPE_UINT64, vd->vdev_guid,
	FM_EREPORT_PAYLOAD_ZFS_VDEV_TYPE,
	DATA_TYPE_STRING, vd->vdev_ops->vdev_op_type, NULL);
	if (vd->vdev_path != NULL)
	fm_payload_set(ereport,
	FM_EREPORT_PAYLOAD_ZFS_VDEV_PATH,
	DATA_TYPE_STRING, vd->vdev_path, NULL);
	if (vd->vdev_devid != NULL)
	fm_payload_set(ereport,
	FM_EREPORT_PAYLOAD_ZFS_VDEV_DEVID,
	DATA_TYPE_STRING, vd->vdev_devid, NULL);
	if (vd->vdev_fru != NULL)
	fm_payload_set(ereport,
	FM_EREPORT_PAYLOAD_ZFS_VDEV_FRU,
	DATA_TYPE_STRING, vd->vdev_fru, NULL);
	if (vd->vdev_enc_sysfs_path != NULL)
	fm_payload_set(ereport,
	FM_EREPORT_PAYLOAD_ZFS_VDEV_ENC_SYSFS_PATH,
	DATA_TYPE_STRING, vd->vdev_enc_sysfs_path, NULL);
	if (vd->vdev_ashift)
	fm_payload_set(ereport,
	FM_EREPORT_PAYLOAD_ZFS_VDEV_ASHIFT,
	DATA_TYPE_UINT64, vd->vdev_ashift, NULL);

	if (vq != NULL) {
	fm_payload_set(ereport,
	FM_EREPORT_PAYLOAD_ZFS_VDEV_COMP_TS,
	DATA_TYPE_UINT64, vq->vq_io_complete_ts, NULL);
	fm_payload_set(ereport,
	FM_EREPORT_PAYLOAD_ZFS_VDEV_DELTA_TS,
	DATA_TYPE_UINT64, vq->vq_io_delta_ts, NULL);
	}

	if (vs != NULL) {
	fm_payload_set(ereport,
	FM_EREPORT_PAYLOAD_ZFS_VDEV_READ_ERRORS,
	DATA_TYPE_UINT64, vs->vs_read_errors,
	FM_EREPORT_PAYLOAD_ZFS_VDEV_WRITE_ERRORS,
	DATA_TYPE_UINT64, vs->vs_write_errors,
	FM_EREPORT_PAYLOAD_ZFS_VDEV_CKSUM_ERRORS,
	DATA_TYPE_UINT64, vs->vs_checksum_errors,
	FM_EREPORT_PAYLOAD_ZFS_VDEV_DELAYS,
	DATA_TYPE_UINT64, vs->vs_slow_ios,
	NULL);
	}

	if (pvd != NULL) {
	fm_payload_set(ereport,
	FM_EREPORT_PAYLOAD_ZFS_PARENT_GUID,
	DATA_TYPE_UINT64, pvd->vdev_guid,
	FM_EREPORT_PAYLOAD_ZFS_PARENT_TYPE,
	DATA_TYPE_STRING, pvd->vdev_ops->vdev_op_type,
	NULL);
	if (pvd->vdev_path)
	fm_payload_set(ereport,
	FM_EREPORT_PAYLOAD_ZFS_PARENT_PATH,
	DATA_TYPE_STRING, pvd->vdev_path, NULL);
	if (pvd->vdev_devid)
	fm_payload_set(ereport,
	FM_EREPORT_PAYLOAD_ZFS_PARENT_DEVID,
	DATA_TYPE_STRING, pvd->vdev_devid, NULL);
	}

	spare_count = spa->spa_spares.sav_count;
	spare_paths = kmem_zalloc(sizeof (char ) spare_count,
	KM_SLEEP);
	spare_guids = kmem_zalloc(sizeof (uint64_t) * spare_count,
	KM_SLEEP);

	for (i = 0; i < spare_count; i++) {
	spare_vd = spa->spa_spares.sav_vdevs[i];
	if (spare_vd) {
	spare_paths[i] = spare_vd->vdev_path;
	spare_guids[i] = spare_vd->vdev_guid;
	}
	}

	fm_payload_set(ereport, FM_EREPORT_PAYLOAD_ZFS_VDEV_SPARE_PATHS,
	DATA_TYPE_STRING_ARRAY, spare_count, spare_paths,
	FM_EREPORT_PAYLOAD_ZFS_VDEV_SPARE_GUIDS,
	DATA_TYPE_UINT64_ARRAY, spare_count, spare_guids, NULL);

	kmem_free(spare_guids, sizeof (uint64_t) * spare_count);
	kmem_free(spare_paths, sizeof (char ) spare_count);
	}

	if (zio != NULL) {
	/*
	* Payload common to all I/Os.
	*/
	fm_payload_set(ereport, FM_EREPORT_PAYLOAD_ZFS_ZIO_ERR,
	DATA_TYPE_INT32, zio->io_error, NULL);
	fm_payload_set(ereport, FM_EREPORT_PAYLOAD_ZFS_ZIO_FLAGS,
	DATA_TYPE_INT32, zio->io_flags, NULL);
	fm_payload_set(ereport, FM_EREPORT_PAYLOAD_ZFS_ZIO_STAGE,
	DATA_TYPE_UINT32, zio->io_stage, NULL);
	fm_payload_set(ereport, FM_EREPORT_PAYLOAD_ZFS_ZIO_PIPELINE,
	DATA_TYPE_UINT32, zio->io_pipeline, NULL);
	fm_payload_set(ereport, FM_EREPORT_PAYLOAD_ZFS_ZIO_DELAY,
	DATA_TYPE_UINT64, zio->io_delay, NULL);
	fm_payload_set(ereport, FM_EREPORT_PAYLOAD_ZFS_ZIO_TIMESTAMP,
	DATA_TYPE_UINT64, zio->io_timestamp, NULL);
	fm_payload_set(ereport, FM_EREPORT_PAYLOAD_ZFS_ZIO_DELTA,
	DATA_TYPE_UINT64, zio->io_delta, NULL);
	fm_payload_set(ereport, FM_EREPORT_PAYLOAD_ZFS_ZIO_PRIORITY,
	DATA_TYPE_UINT32, zio->io_priority, NULL);

	/*
	* If the 'size' parameter is non-zero, it indicates this is a
	* RAID-Z or other I/O where the physical offset and length are
	* provided for us, instead of within the zio_t.
	*/
	if (vd != NULL) {
	if (size)
	fm_payload_set(ereport,
	FM_EREPORT_PAYLOAD_ZFS_ZIO_OFFSET,
	DATA_TYPE_UINT64, stateoroffset,
	FM_EREPORT_PAYLOAD_ZFS_ZIO_SIZE,
	DATA_TYPE_UINT64, size, NULL);
	else
	fm_payload_set(ereport,
	FM_EREPORT_PAYLOAD_ZFS_ZIO_OFFSET,
	DATA_TYPE_UINT64, zio->io_offset,
	FM_EREPORT_PAYLOAD_ZFS_ZIO_SIZE,
	DATA_TYPE_UINT64, zio->io_size, NULL);
	}
	} else if (vd != NULL) {
	/*
	* If we have a vdev but no zio, this is a device fault, and the
	* 'stateoroffset' parameter indicates the previous state of the
	* vdev.
	*/
	fm_payload_set(ereport,
	FM_EREPORT_PAYLOAD_ZFS_PREV_STATE,
	DATA_TYPE_UINT64, stateoroffset, NULL);
	}

	/*
	* Payload for I/Os with corresponding logical information.
	*/
	if (zb != NULL && (zio == NULL \|\| zio->io_logical != NULL)) {
	fm_payload_set(ereport,
	FM_EREPORT_PAYLOAD_ZFS_ZIO_OBJSET,
	DATA_TYPE_UINT64, zb->zb_objset,
	FM_EREPORT_PAYLOAD_ZFS_ZIO_OBJECT,
	DATA_TYPE_UINT64, zb->zb_object,
	FM_EREPORT_PAYLOAD_ZFS_ZIO_LEVEL,
	DATA_TYPE_INT64, zb->zb_level,
	FM_EREPORT_PAYLOAD_ZFS_ZIO_BLKID,
	DATA_TYPE_UINT64, zb->zb_blkid, NULL);
	}

	mutex_exit(&spa->spa_errlist_lock);

	*ereport_out = ereport;
	*detector_out = detector;
	return (B_TRUE);
	}

	/* if it's <= 128 bytes, save the corruption directly */
	#define ZFM_MAX_INLINE (128 / sizeof (uint64_t))

	#define MAX_RANGES 16

	typedef struct zfs_ecksum_info {
	/* histograms of set and cleared bits by bit number in a 64-bit word */
	uint32_t zei_histogram_set[sizeof (uint64_t) * NBBY];
	uint32_t zei_histogram_cleared[sizeof (uint64_t) * NBBY];

	/* inline arrays of bits set and cleared. */
	uint64_t zei_bits_set[ZFM_MAX_INLINE];
	uint64_t zei_bits_cleared[ZFM_MAX_INLINE];

	/*
	* for each range, the number of bits set and cleared. The Hamming
	* distance between the good and bad buffers is the sum of them all.
	*/
	uint32_t zei_range_sets[MAX_RANGES];
	uint32_t zei_range_clears[MAX_RANGES];

	struct zei_ranges {
	uint32_t zr_start;
	uint32_t zr_end;
	} zei_ranges[MAX_RANGES];

	size_t zei_range_count;
	uint32_t zei_mingap;
	uint32_t zei_allowed_mingap;

	} zfs_ecksum_info_t;

	static void
	update_histogram(uint64_t value_arg, uint32_t hist, uint32_t count)
	{
	size_t i;
	size_t bits = 0;
	uint64_t value = BE_64(value_arg);

	/* We store the bits in big-endian (largest-first) order */
	for (i = 0; i < 64; i++) {
	if (value & (1ull << i)) {
	hist[63 - i]++;
	++bits;
	}
	}
	/* update the count of bits changed */
	*count += bits;
	}

	/*
	* We've now filled up the range array, and need to increase "mingap" and
	* shrink the range list accordingly. zei_mingap is always the smallest
	* distance between array entries, so we set the new_allowed_gap to be
	* one greater than that. We then go through the list, joining together
	* any ranges which are closer than the new_allowed_gap.
	*
	* By construction, there will be at least one. We also update zei_mingap
	* to the new smallest gap, to prepare for our next invocation.
	*/
	static void
	zei_shrink_ranges(zfs_ecksum_info_t *eip)
	{
	uint32_t mingap = UINT32_MAX;
	uint32_t new_allowed_gap = eip->zei_mingap + 1;

	size_t idx, output;
	size_t max = eip->zei_range_count;

	struct zei_ranges *r = eip->zei_ranges;

	ASSERT3U(eip->zei_range_count, >, 0);
	ASSERT3U(eip->zei_range_count, <=, MAX_RANGES);

	output = idx = 0;
	while (idx < max - 1) {
	uint32_t start = r[idx].zr_start;
	uint32_t end = r[idx].zr_end;

	while (idx < max - 1) {
	idx++;

	uint32_t nstart = r[idx].zr_start;
	uint32_t nend = r[idx].zr_end;

	uint32_t gap = nstart - end;
	if (gap < new_allowed_gap) {
	end = nend;
	continue;
	}
	if (gap < mingap)
	mingap = gap;
	break;
	}
	r[output].zr_start = start;
	r[output].zr_end = end;
	output++;
	}
	ASSERT3U(output, <, eip->zei_range_count);
	eip->zei_range_count = output;
	eip->zei_mingap = mingap;
	eip->zei_allowed_mingap = new_allowed_gap;
	}

	static void
	zei_add_range(zfs_ecksum_info_t *eip, int start, int end)
	{
	struct zei_ranges *r = eip->zei_ranges;
	size_t count = eip->zei_range_count;

	if (count >= MAX_RANGES) {
	zei_shrink_ranges(eip);
	count = eip->zei_range_count;
	}
	if (count == 0) {
	eip->zei_mingap = UINT32_MAX;
	eip->zei_allowed_mingap = 1;
	} else {
	int gap = start - r[count - 1].zr_end;

	if (gap < eip->zei_allowed_mingap) {
	r[count - 1].zr_end = end;
	return;
	}
	if (gap < eip->zei_mingap)
	eip->zei_mingap = gap;
	}
	r[count].zr_start = start;
	r[count].zr_end = end;
	eip->zei_range_count++;
	}

	static size_t
	zei_range_total_size(zfs_ecksum_info_t *eip)
	{
	struct zei_ranges *r = eip->zei_ranges;
	size_t count = eip->zei_range_count;
	size_t result = 0;
	size_t idx;

	for (idx = 0; idx < count; idx++)
	result += (r[idx].zr_end - r[idx].zr_start);

	return (result);
	}

	static zfs_ecksum_info_t *
	annotate_ecksum(nvlist_t ereport, zio_bad_cksum_t info,
	const abd_t goodabd, const abd_t badabd, size_t size,
	boolean_t drop_if_identical)
	{
	const uint64_t *good;
	const uint64_t *bad;

	uint64_t allset = 0;
	uint64_t allcleared = 0;

	size_t nui64s = size / sizeof (uint64_t);

	size_t inline_size;
	int no_inline = 0;
	size_t idx;
	size_t range;

	size_t offset = 0;
	ssize_t start = -1;

	zfs_ecksum_info_t eip = kmem_zalloc(sizeof (eip), KM_SLEEP);

	/* don't do any annotation for injected checksum errors */
	if (info != NULL && info->zbc_injected)
	return (eip);

	if (info != NULL && info->zbc_has_cksum) {
	fm_payload_set(ereport,
	FM_EREPORT_PAYLOAD_ZFS_CKSUM_EXPECTED,
	DATA_TYPE_UINT64_ARRAY,
	sizeof (info->zbc_expected) / sizeof (uint64_t),
	(uint64_t *)&info->zbc_expected,
	FM_EREPORT_PAYLOAD_ZFS_CKSUM_ACTUAL,
	DATA_TYPE_UINT64_ARRAY,
	sizeof (info->zbc_actual) / sizeof (uint64_t),
	(uint64_t *)&info->zbc_actual,
	FM_EREPORT_PAYLOAD_ZFS_CKSUM_ALGO,
	DATA_TYPE_STRING,
	info->zbc_checksum_name,
	NULL);

	if (info->zbc_byteswapped) {
	fm_payload_set(ereport,
	FM_EREPORT_PAYLOAD_ZFS_CKSUM_BYTESWAP,
	DATA_TYPE_BOOLEAN, 1,
	NULL);
	}
	}

	if (badabd == NULL \|\| goodabd == NULL)
	return (eip);

	ASSERT3U(nui64s, <=, UINT32_MAX);
	ASSERT3U(size, ==, nui64s * sizeof (uint64_t));
	ASSERT3U(size, <=, SPA_MAXBLOCKSIZE);
	ASSERT3U(size, <=, UINT32_MAX);

	good = (const uint64_t ) abd_borrow_buf_copy((abd_t )goodabd, size);
	bad = (const uint64_t ) abd_borrow_buf_copy((abd_t )badabd, size);

	/* build up the range list by comparing the two buffers. */
	for (idx = 0; idx < nui64s; idx++) {
	if (good[idx] == bad[idx]) {
	if (start == -1)
	continue;

	zei_add_range(eip, start, idx);
	start = -1;
	} else {
	if (start != -1)
	continue;

	start = idx;
	}
	}
	if (start != -1)
	zei_add_range(eip, start, idx);

	/* See if it will fit in our inline buffers */
	inline_size = zei_range_total_size(eip);
	if (inline_size > ZFM_MAX_INLINE)
	no_inline = 1;

	/*
	* If there is no change and we want to drop if the buffers are
	* identical, do so.
	*/
	if (inline_size == 0 && drop_if_identical) {
	kmem_free(eip, sizeof (*eip));
	abd_return_buf((abd_t )goodabd, (void )good, size);
	abd_return_buf((abd_t )badabd, (void )bad, size);
	return (NULL);
	}

	/*
	* Now walk through the ranges, filling in the details of the
	* differences. Also convert our uint64_t-array offsets to byte
	* offsets.
	*/
	for (range = 0; range < eip->zei_range_count; range++) {
	size_t start = eip->zei_ranges[range].zr_start;
	size_t end = eip->zei_ranges[range].zr_end;

	for (idx = start; idx < end; idx++) {
	uint64_t set, cleared;

	// bits set in bad, but not in good
	set = ((~good[idx]) & bad[idx]);
	// bits set in good, but not in bad
	cleared = (good[idx] & (~bad[idx]));

	allset \|= set;
	allcleared \|= cleared;

	if (!no_inline) {
	ASSERT3U(offset, <, inline_size);
	eip->zei_bits_set[offset] = set;
	eip->zei_bits_cleared[offset] = cleared;
	offset++;
	}

	update_histogram(set, eip->zei_histogram_set,
	&eip->zei_range_sets[range]);
	update_histogram(cleared, eip->zei_histogram_cleared,
	&eip->zei_range_clears[range]);
	}

	/* convert to byte offsets */
	eip->zei_ranges[range].zr_start *= sizeof (uint64_t);
	eip->zei_ranges[range].zr_end *= sizeof (uint64_t);
	}

	abd_return_buf((abd_t )goodabd, (void )good, size);
	abd_return_buf((abd_t )badabd, (void )bad, size);

	eip->zei_allowed_mingap *= sizeof (uint64_t);
	inline_size *= sizeof (uint64_t);

	/* fill in ereport */
	fm_payload_set(ereport,
	FM_EREPORT_PAYLOAD_ZFS_BAD_OFFSET_RANGES,
	DATA_TYPE_UINT32_ARRAY, 2 * eip->zei_range_count,
	(uint32_t *)eip->zei_ranges,
	FM_EREPORT_PAYLOAD_ZFS_BAD_RANGE_MIN_GAP,
	DATA_TYPE_UINT32, eip->zei_allowed_mingap,
	FM_EREPORT_PAYLOAD_ZFS_BAD_RANGE_SETS,
	DATA_TYPE_UINT32_ARRAY, eip->zei_range_count, eip->zei_range_sets,
	FM_EREPORT_PAYLOAD_ZFS_BAD_RANGE_CLEARS,
	DATA_TYPE_UINT32_ARRAY, eip->zei_range_count, eip->zei_range_clears,
	NULL);

	if (!no_inline) {
	fm_payload_set(ereport,
	FM_EREPORT_PAYLOAD_ZFS_BAD_SET_BITS,
	DATA_TYPE_UINT8_ARRAY,
	inline_size, (uint8_t *)eip->zei_bits_set,
	FM_EREPORT_PAYLOAD_ZFS_BAD_CLEARED_BITS,
	DATA_TYPE_UINT8_ARRAY,
	inline_size, (uint8_t *)eip->zei_bits_cleared,
	NULL);
	} else {
	fm_payload_set(ereport,
	FM_EREPORT_PAYLOAD_ZFS_BAD_SET_HISTOGRAM,
	DATA_TYPE_UINT32_ARRAY,
	NBBY * sizeof (uint64_t), eip->zei_histogram_set,
	FM_EREPORT_PAYLOAD_ZFS_BAD_CLEARED_HISTOGRAM,
	DATA_TYPE_UINT32_ARRAY,
	NBBY * sizeof (uint64_t), eip->zei_histogram_cleared,
	NULL);
	}
	return (eip);
	}
	#else
	/ARGSUSED/
	void
	zfs_ereport_clear(spa_t spa, vdev_t vd)
	{
	}
	#endif

	/*
	* Make sure our event is still valid for the given zio/vdev/pool. For example,
	* we don't want to keep logging events for a faulted or missing vdev.
	*/
	boolean_t
	zfs_ereport_is_valid(const char subclass, spa_t spa, vdev_t vd, zio_t zio)
	{
	#ifdef _KERNEL
	/*
	* If we are doing a spa_tryimport() or in recovery mode,
	* ignore errors.
	*/
	if (spa_load_state(spa) == SPA_LOAD_TRYIMPORT \|\|
	spa_load_state(spa) == SPA_LOAD_RECOVER)
	return (B_FALSE);

	/*
	* If we are in the middle of opening a pool, and the previous attempt
	* failed, don't bother logging any new ereports - we're just going to
	* get the same diagnosis anyway.
	*/
	if (spa_load_state(spa) != SPA_LOAD_NONE &&
	spa->spa_last_open_failed)
	return (B_FALSE);

	if (zio != NULL) {
	/*
	* If this is not a read or write zio, ignore the error. This
	* can occur if the DKIOCFLUSHWRITECACHE ioctl fails.
	*/
	if (zio->io_type != ZIO_TYPE_READ &&
	zio->io_type != ZIO_TYPE_WRITE)
	return (B_FALSE);

	if (vd != NULL) {
	/*
	* If the vdev has already been marked as failing due
	* to a failed probe, then ignore any subsequent I/O
	* errors, as the DE will automatically fault the vdev
	* on the first such failure. This also catches cases
	* where vdev_remove_wanted is set and the device has
	* not yet been asynchronously placed into the REMOVED
	* state.
	*/
	if (zio->io_vd == vd && !vdev_accessible(vd, zio))
	return (B_FALSE);

	/*
	* Ignore checksum errors for reads from DTL regions of
	* leaf vdevs.
	*/
	if (zio->io_type == ZIO_TYPE_READ &&
	zio->io_error == ECKSUM &&
	vd->vdev_ops->vdev_op_leaf &&
	vdev_dtl_contains(vd, DTL_MISSING, zio->io_txg, 1))
	return (B_FALSE);
	}
	}

	/*
	* For probe failure, we want to avoid posting ereports if we've
	* already removed the device in the meantime.
	*/
	if (vd != NULL &&
	strcmp(subclass, FM_EREPORT_ZFS_PROBE_FAILURE) == 0 &&
	(vd->vdev_remove_wanted \|\| vd->vdev_state == VDEV_STATE_REMOVED))
	return (B_FALSE);

	/* Ignore bogus delay events (like from ioctls or unqueued IOs) */
	if ((strcmp(subclass, FM_EREPORT_ZFS_DELAY) == 0) &&
	(zio != NULL) && (!zio->io_timestamp)) {
	return (B_FALSE);
	}
	#endif
	return (B_TRUE);
	}

	/*
	* Post an ereport for the given subclass
	*
	* Returns
	* - 0 if an event was posted
	* - EINVAL if there was a problem posting event
	* - EBUSY if the event was rate limited
	* - EALREADY if the event was already posted (duplicate)
	*/
	int
	zfs_ereport_post(const char subclass, spa_t spa, vdev_t *vd,
	const zbookmark_phys_t zb, zio_t zio, uint64_t state)
	{
	int rc = 0;
	#ifdef _KERNEL
	nvlist_t *ereport = NULL;
	nvlist_t *detector = NULL;

	if (!zfs_ereport_is_valid(subclass, spa, vd, zio))
	return (EINVAL);

	if (zfs_ereport_is_duplicate(subclass, spa, vd, zb, zio, 0, 0))
	return (SET_ERROR(EALREADY));

	if (zfs_is_ratelimiting_event(subclass, vd))
	return (SET_ERROR(EBUSY));

	if (!zfs_ereport_start(&ereport, &detector, subclass, spa, vd,
	zb, zio, state, 0))
	return (SET_ERROR(EINVAL)); /* couldn't post event */

	if (ereport == NULL)
	return (SET_ERROR(EINVAL));

	/* Cleanup is handled by the callback function */
	rc = zfs_zevent_post(ereport, detector, zfs_zevent_post_cb);
	#endif
	return (rc);
	}

	/*
	* Prepare a checksum ereport
	*
	* Returns
	* - 0 if an event was posted
	* - EINVAL if there was a problem posting event
	* - EBUSY if the event was rate limited
	* - EALREADY if the event was already posted (duplicate)
	*/
	int
	zfs_ereport_start_checksum(spa_t spa, vdev_t vd, const zbookmark_phys_t *zb,
	struct zio zio, uint64_t offset, uint64_t length, zio_bad_cksum_t info)
	{
	zio_cksum_report_t *report;

	#ifdef _KERNEL
	if (!zfs_ereport_is_valid(FM_EREPORT_ZFS_CHECKSUM, spa, vd, zio))
	return (SET_ERROR(EINVAL));

	if (zfs_ereport_is_duplicate(FM_EREPORT_ZFS_CHECKSUM, spa, vd, zb, zio,
	offset, length))
	return (SET_ERROR(EALREADY));

	if (zfs_is_ratelimiting_event(FM_EREPORT_ZFS_CHECKSUM, vd))
	return (SET_ERROR(EBUSY));
	#endif

	report = kmem_zalloc(sizeof (*report), KM_SLEEP);

	zio_vsd_default_cksum_report(zio, report);

	/* copy the checksum failure information if it was provided */
	if (info != NULL) {
	report->zcr_ckinfo = kmem_zalloc(sizeof (*info), KM_SLEEP);
	bcopy(info, report->zcr_ckinfo, sizeof (*info));
	}

	report->zcr_sector = 1ULL << vd->vdev_top->vdev_ashift;
	report->zcr_align =
	vdev_psize_to_asize(vd->vdev_top, report->zcr_sector);
	report->zcr_length = length;

	#ifdef _KERNEL
	(void) zfs_ereport_start(&report->zcr_ereport, &report->zcr_detector,
	FM_EREPORT_ZFS_CHECKSUM, spa, vd, zb, zio, offset, length);

	if (report->zcr_ereport == NULL) {
	zfs_ereport_free_checksum(report);
	return (0);
	}
	#endif

	mutex_enter(&spa->spa_errlist_lock);
	report->zcr_next = zio->io_logical->io_cksum_report;
	zio->io_logical->io_cksum_report = report;
	mutex_exit(&spa->spa_errlist_lock);
	return (0);
	}

	void
	zfs_ereport_finish_checksum(zio_cksum_report_t report, const abd_t good_data,
	const abd_t *bad_data, boolean_t drop_if_identical)
	{
	#ifdef _KERNEL
	zfs_ecksum_info_t *info;

	info = annotate_ecksum(report->zcr_ereport, report->zcr_ckinfo,
	good_data, bad_data, report->zcr_length, drop_if_identical);
	if (info != NULL)
	zfs_zevent_post(report->zcr_ereport,
	report->zcr_detector, zfs_zevent_post_cb);
	else
	zfs_zevent_post_cb(report->zcr_ereport, report->zcr_detector);

	report->zcr_ereport = report->zcr_detector = NULL;
	if (info != NULL)
	kmem_free(info, sizeof (*info));
	#endif
	}

	void
	zfs_ereport_free_checksum(zio_cksum_report_t *rpt)
	{
	#ifdef _KERNEL
	if (rpt->zcr_ereport != NULL) {
	fm_nvlist_destroy(rpt->zcr_ereport,
	FM_NVA_FREE);
	fm_nvlist_destroy(rpt->zcr_detector,
	FM_NVA_FREE);
	}
	#endif
	rpt->zcr_free(rpt->zcr_cbdata, rpt->zcr_cbinfo);

	if (rpt->zcr_ckinfo != NULL)
	kmem_free(rpt->zcr_ckinfo, sizeof (*rpt->zcr_ckinfo));

	kmem_free(rpt, sizeof (*rpt));
	}

	/*
	* Post a checksum ereport
	*
	* Returns
	* - 0 if an event was posted
	* - EINVAL if there was a problem posting event
	* - EBUSY if the event was rate limited
	* - EALREADY if the event was already posted (duplicate)
	*/
	int
	zfs_ereport_post_checksum(spa_t spa, vdev_t vd, const zbookmark_phys_t *zb,
	struct zio *zio, uint64_t offset, uint64_t length,
	const abd_t good_data, const abd_t bad_data, zio_bad_cksum_t *zbc)
	{
	int rc = 0;
	#ifdef _KERNEL
	nvlist_t *ereport = NULL;
	nvlist_t *detector = NULL;
	zfs_ecksum_info_t *info;

	if (!zfs_ereport_is_valid(FM_EREPORT_ZFS_CHECKSUM, spa, vd, zio))
	return (SET_ERROR(EINVAL));

	if (zfs_ereport_is_duplicate(FM_EREPORT_ZFS_CHECKSUM, spa, vd, zb, zio,
	offset, length))
	return (SET_ERROR(EALREADY));

	if (zfs_is_ratelimiting_event(FM_EREPORT_ZFS_CHECKSUM, vd))
	return (SET_ERROR(EBUSY));

	if (!zfs_ereport_start(&ereport, &detector, FM_EREPORT_ZFS_CHECKSUM,
	spa, vd, zb, zio, offset, length) \|\| (ereport == NULL)) {
	return (SET_ERROR(EINVAL));
	}

	info = annotate_ecksum(ereport, zbc, good_data, bad_data, length,
	B_FALSE);

	if (info != NULL) {
	rc = zfs_zevent_post(ereport, detector, zfs_zevent_post_cb);
	kmem_free(info, sizeof (*info));
	}
	#endif
	return (rc);
	}

	/*
	* The 'sysevent.fs.zfs.*' events are signals posted to notify user space of
	* change in the pool. All sysevents are listed in sys/sysevent/eventdefs.h
	* and are designed to be consumed by the ZFS Event Daemon (ZED). For
	* additional details refer to the zed(8) man page.
	*/
	nvlist_t *
	zfs_event_create(spa_t spa, vdev_t vd, const char type, const char name,
	nvlist_t *aux)
	{
	nvlist_t *resource = NULL;
	#ifdef _KERNEL
	char class[64];

	if (spa_load_state(spa) == SPA_LOAD_TRYIMPORT)
	return (NULL);

	if ((resource = fm_nvlist_create(NULL)) == NULL)
	return (NULL);

	(void) snprintf(class, sizeof (class), "%s.%s.%s", type,
	ZFS_ERROR_CLASS, name);
	VERIFY0(nvlist_add_uint8(resource, FM_VERSION, FM_RSRC_VERSION));
	VERIFY0(nvlist_add_string(resource, FM_CLASS, class));
	VERIFY0(nvlist_add_string(resource,
	FM_EREPORT_PAYLOAD_ZFS_POOL, spa_name(spa)));
	VERIFY0(nvlist_add_uint64(resource,
	FM_EREPORT_PAYLOAD_ZFS_POOL_GUID, spa_guid(spa)));
	VERIFY0(nvlist_add_uint64(resource,
	FM_EREPORT_PAYLOAD_ZFS_POOL_STATE, spa_state(spa)));
	VERIFY0(nvlist_add_int32(resource,
	FM_EREPORT_PAYLOAD_ZFS_POOL_CONTEXT, spa_load_state(spa)));

	if (vd) {
	VERIFY0(nvlist_add_uint64(resource,
	FM_EREPORT_PAYLOAD_ZFS_VDEV_GUID, vd->vdev_guid));
	VERIFY0(nvlist_add_uint64(resource,
	FM_EREPORT_PAYLOAD_ZFS_VDEV_STATE, vd->vdev_state));
	if (vd->vdev_path != NULL)
	VERIFY0(nvlist_add_string(resource,
	FM_EREPORT_PAYLOAD_ZFS_VDEV_PATH, vd->vdev_path));
	if (vd->vdev_devid != NULL)
	VERIFY0(nvlist_add_string(resource,
	FM_EREPORT_PAYLOAD_ZFS_VDEV_DEVID, vd->vdev_devid));
	if (vd->vdev_fru != NULL)
	VERIFY0(nvlist_add_string(resource,
	FM_EREPORT_PAYLOAD_ZFS_VDEV_FRU, vd->vdev_fru));
	if (vd->vdev_enc_sysfs_path != NULL)
	VERIFY0(nvlist_add_string(resource,
	FM_EREPORT_PAYLOAD_ZFS_VDEV_ENC_SYSFS_PATH,
	vd->vdev_enc_sysfs_path));
	}

	/* also copy any optional payload data */
	if (aux) {
	nvpair_t *elem = NULL;

	while ((elem = nvlist_next_nvpair(aux, elem)) != NULL)
	(void) nvlist_add_nvpair(resource, elem);
	}

	#endif
	return (resource);
	}

	static void
	zfs_post_common(spa_t spa, vdev_t vd, const char type, const char name,
	nvlist_t *aux)
	{
	#ifdef _KERNEL
	nvlist_t *resource;

	resource = zfs_event_create(spa, vd, type, name, aux);
	if (resource)
	zfs_zevent_post(resource, NULL, zfs_zevent_post_cb);
	#endif
	}

	/*
	* The 'resource.fs.zfs.removed' event is an internal signal that the given vdev
	* has been removed from the system. This will cause the DE to ignore any
	* recent I/O errors, inferring that they are due to the asynchronous device
	* removal.
	*/
	void
	zfs_post_remove(spa_t spa, vdev_t vd)
	{
	zfs_post_common(spa, vd, FM_RSRC_CLASS, FM_RESOURCE_REMOVED, NULL);
	}

	/*
	* The 'resource.fs.zfs.autoreplace' event is an internal signal that the pool
	* has the 'autoreplace' property set, and therefore any broken vdevs will be
	* handled by higher level logic, and no vdev fault should be generated.
	*/
	void
	zfs_post_autoreplace(spa_t spa, vdev_t vd)
	{
	zfs_post_common(spa, vd, FM_RSRC_CLASS, FM_RESOURCE_AUTOREPLACE, NULL);
	}

	/*
	* The 'resource.fs.zfs.statechange' event is an internal signal that the
	* given vdev has transitioned its state to DEGRADED or HEALTHY. This will
	* cause the retire agent to repair any outstanding fault management cases
	* open because the device was not found (fault.fs.zfs.device).
	*/
	void
	zfs_post_state_change(spa_t spa, vdev_t vd, uint64_t laststate)
	{
	#ifdef _KERNEL
	nvlist_t *aux;

	/*
	* Add optional supplemental keys to payload
	*/
	aux = fm_nvlist_create(NULL);
	if (vd && aux) {
	if (vd->vdev_physpath) {
	(void) nvlist_add_string(aux,
	FM_EREPORT_PAYLOAD_ZFS_VDEV_PHYSPATH,
	vd->vdev_physpath);
	}
	if (vd->vdev_enc_sysfs_path) {
	(void) nvlist_add_string(aux,
	FM_EREPORT_PAYLOAD_ZFS_VDEV_ENC_SYSFS_PATH,
	vd->vdev_enc_sysfs_path);
	}

	(void) nvlist_add_uint64(aux,
	FM_EREPORT_PAYLOAD_ZFS_VDEV_LASTSTATE, laststate);
	}

	zfs_post_common(spa, vd, FM_RSRC_CLASS, FM_RESOURCE_STATECHANGE,
	aux);

	if (aux)
	fm_nvlist_destroy(aux, FM_NVA_FREE);
	#endif
	}

	#ifdef _KERNEL
	void
	zfs_ereport_init(void)
	{
	mutex_init(&recent_events_lock, NULL, MUTEX_DEFAULT, NULL);
	list_create(&recent_events_list, sizeof (recent_events_node_t),
	offsetof(recent_events_node_t, re_list_link));
	avl_create(&recent_events_tree, recent_events_compare,
	sizeof (recent_events_node_t), offsetof(recent_events_node_t,
	re_tree_link));
	}

	/*
	* This 'early' fini needs to run before zfs_fini() which on Linux waits
	* for the system_delay_taskq to drain.
	*/
	void
	zfs_ereport_taskq_fini(void)
	{
	mutex_enter(&recent_events_lock);
	if (recent_events_cleaner_tqid != 0) {
	taskq_cancel_id(system_delay_taskq, recent_events_cleaner_tqid);
	recent_events_cleaner_tqid = 0;
	}
	mutex_exit(&recent_events_lock);
	}

	void
	zfs_ereport_fini(void)
	{
	recent_events_node_t *entry;

	while ((entry = list_head(&recent_events_list)) != NULL) {
	avl_remove(&recent_events_tree, entry);
	list_remove(&recent_events_list, entry);
	kmem_free(entry, sizeof (*entry));
	}
	avl_destroy(&recent_events_tree);
	list_destroy(&recent_events_list);
	mutex_destroy(&recent_events_lock);
	}

	EXPORT_SYMBOL(zfs_ereport_post);
	EXPORT_SYMBOL(zfs_ereport_is_valid);
	EXPORT_SYMBOL(zfs_ereport_post_checksum);
	EXPORT_SYMBOL(zfs_post_remove);
	EXPORT_SYMBOL(zfs_post_autoreplace);
	EXPORT_SYMBOL(zfs_post_state_change);

	ZFS_MODULE_PARAM(zfs_zevent, zfs_zevent_, retain_max, UINT, ZMOD_RW,
	"Maximum recent zevents records to retain for duplicate checking");
	ZFS_MODULE_PARAM(zfs_zevent, zfs_zevent_, retain_expire_secs, UINT, ZMOD_RW,
	"Expiration time for recent zevents records");
	#endif /* _KERNEL */
	diff --git a/sys/contrib/openzfs/module/zfs/zfs_ioctl.c b/sys/contrib/openzfs/module/zfs/zfs_ioctl.c
	index 5f291d067bef..7f929df16757 100644
	--- a/sys/contrib/openzfs/module/zfs/zfs_ioctl.c
	+++ b/sys/contrib/openzfs/module/zfs/zfs_ioctl.c
	@@ -1,7688 +1,7688 @@
	/*
	* 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) 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, 2020 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) 2019, 2020 by Christian Schwarz. All rights reserved.
	* Copyright (c) 2019, Klara Inc.
	* Copyright (c) 2019, Allan Jude
	*/

	/*
	* ZFS ioctls.
	*
	* This file handles the ioctls to /dev/zfs, used for configuring ZFS storage
	* pools and filesystems, e.g. with /sbin/zfs and /sbin/zpool.
	*
	* There are two ways that we handle ioctls: the legacy way where almost
	* all of the logic is in the ioctl callback, and the new way where most
	* of the marshalling is handled in the common entry point, zfsdev_ioctl().
	*
	* Non-legacy ioctls should be registered by calling
	* zfs_ioctl_register() from zfs_ioctl_init(). The ioctl is invoked
	* from userland by lzc_ioctl().
	*
	* The registration arguments are as follows:
	*
	* const char *name
	* The name of the ioctl. This is used for history logging. If the
	* ioctl returns successfully (the callback returns 0), and allow_log
	* is true, then a history log entry will be recorded with the input &
	* output nvlists. The log entry can be printed with "zpool history -i".
	*
	* zfs_ioc_t ioc
	* The ioctl request number, which userland will pass to ioctl(2).
	* We want newer versions of libzfs and libzfs_core to run against
	* existing zfs kernel modules (i.e. a deferred reboot after an update).
	* Therefore the ioctl numbers cannot change from release to release.
	*
	* zfs_secpolicy_func_t *secpolicy
	* This function will be called before the zfs_ioc_func_t, to
	* determine if this operation is permitted. It should return EPERM
	* on failure, and 0 on success. Checks include determining if the
	* dataset is visible in this zone, and if the user has either all
	* zfs privileges in the zone (SYS_MOUNT), or has been granted permission
	* to do this operation on this dataset with "zfs allow".
	*
	* zfs_ioc_namecheck_t namecheck
	* This specifies what to expect in the zfs_cmd_t:zc_name -- a pool
	* name, a dataset name, or nothing. If the name is not well-formed,
	* the ioctl will fail and the callback will not be called.
	* Therefore, the callback can assume that the name is well-formed
	* (e.g. is null-terminated, doesn't have more than one '@' character,
	* doesn't have invalid characters).
	*
	* zfs_ioc_poolcheck_t pool_check
	* This specifies requirements on the pool state. If the pool does
	* not meet them (is suspended or is readonly), the ioctl will fail
	* and the callback will not be called. If any checks are specified
	* (i.e. it is not POOL_CHECK_NONE), namecheck must not be NO_NAME.
	* Multiple checks can be or-ed together (e.g. POOL_CHECK_SUSPENDED \|
	* POOL_CHECK_READONLY).
	*
	* zfs_ioc_key_t *nvl_keys
	* The list of expected/allowable innvl input keys. This list is used
	* to validate the nvlist input to the ioctl.
	*
	* boolean_t smush_outnvlist
	* If smush_outnvlist is true, then the output is presumed to be a
	* list of errors, and it will be "smushed" down to fit into the
	* caller's buffer, by removing some entries and replacing them with a
	* single "N_MORE_ERRORS" entry indicating how many were removed. See
	* nvlist_smush() for details. If smush_outnvlist is false, and the
	* outnvlist does not fit into the userland-provided buffer, then the
	* ioctl will fail with ENOMEM.
	*
	* zfs_ioc_func_t *func
	* The callback function that will perform the operation.
	*
	* The callback should return 0 on success, or an error number on
	* failure. If the function fails, the userland ioctl will return -1,
	* and errno will be set to the callback's return value. The callback
	* will be called with the following arguments:
	*
	* const char *name
	* The name of the pool or dataset to operate on, from
	* zfs_cmd_t:zc_name. The 'namecheck' argument specifies the
	* expected type (pool, dataset, or none).
	*
	* nvlist_t *innvl
	* The input nvlist, deserialized from zfs_cmd_t:zc_nvlist_src. Or
	* NULL if no input nvlist was provided. Changes to this nvlist are
	* ignored. If the input nvlist could not be deserialized, the
	* ioctl will fail and the callback will not be called.
	*
	* nvlist_t *outnvl
	* The output nvlist, initially empty. The callback can fill it in,
	* and it will be returned to userland by serializing it into
	* zfs_cmd_t:zc_nvlist_dst. If it is non-empty, and serialization
	* fails (e.g. because the caller didn't supply a large enough
	* buffer), then the overall ioctl will fail. See the
	* 'smush_nvlist' argument above for additional behaviors.
	*
	* There are two typical uses of the output nvlist:
	* - To return state, e.g. property values. In this case,
	* smush_outnvlist should be false. If the buffer was not large
	* enough, the caller will reallocate a larger buffer and try
	* the ioctl again.
	*
	* - To return multiple errors from an ioctl which makes on-disk
	* changes. In this case, smush_outnvlist should be true.
	* Ioctls which make on-disk modifications should generally not
	* use the outnvl if they succeed, because the caller can not
	* distinguish between the operation failing, and
	* deserialization failing.
	*
	* IOCTL Interface Errors
	*
	* The following ioctl input errors can be returned:
	* ZFS_ERR_IOC_CMD_UNAVAIL the ioctl number is not supported by kernel
	* ZFS_ERR_IOC_ARG_UNAVAIL an input argument is not supported by kernel
	* ZFS_ERR_IOC_ARG_REQUIRED a required input argument is missing
	* ZFS_ERR_IOC_ARG_BADTYPE an input argument has an invalid type
	*/

	#include <sys/types.h>
	#include <sys/param.h>
	#include <sys/errno.h>
	#include <sys/uio_impl.h>
	#include <sys/file.h>
	#include <sys/kmem.h>
	#include <sys/cmn_err.h>
	#include <sys/stat.h>
	#include <sys/zfs_ioctl.h>
	#include <sys/zfs_quota.h>
	#include <sys/zfs_vfsops.h>
	#include <sys/zfs_znode.h>
	#include <sys/zap.h>
	#include <sys/spa.h>
	#include <sys/spa_impl.h>
	#include <sys/vdev.h>
	#include <sys/vdev_impl.h>
	#include <sys/dmu.h>
	#include <sys/dsl_dir.h>
	#include <sys/dsl_dataset.h>
	#include <sys/dsl_prop.h>
	#include <sys/dsl_deleg.h>
	#include <sys/dmu_objset.h>
	#include <sys/dmu_impl.h>
	#include <sys/dmu_redact.h>
	#include <sys/dmu_tx.h>
	#include <sys/sunddi.h>
	#include <sys/policy.h>
	#include <sys/zone.h>
	#include <sys/nvpair.h>
	#include <sys/pathname.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/dsl_scan.h>
	#include <sys/fm/util.h>
	#include <sys/dsl_crypt.h>
	#include <sys/rrwlock.h>
	#include <sys/zfs_file.h>

	#include <sys/dmu_recv.h>
	#include <sys/dmu_send.h>
	#include <sys/dmu_recv.h>
	#include <sys/dsl_destroy.h>
	#include <sys/dsl_bookmark.h>
	#include <sys/dsl_userhold.h>
	#include <sys/zfeature.h>
	#include <sys/zcp.h>
	#include <sys/zio_checksum.h>
	#include <sys/vdev_removal.h>
	#include <sys/vdev_impl.h>
	#include <sys/vdev_initialize.h>
	#include <sys/vdev_trim.h>

	#include "zfs_namecheck.h"
	#include "zfs_prop.h"
	#include "zfs_deleg.h"
	#include "zfs_comutil.h"

	#include <sys/lua/lua.h>
	#include <sys/lua/lauxlib.h>
	#include <sys/zfs_ioctl_impl.h>

	kmutex_t zfsdev_state_lock;
	zfsdev_state_t *zfsdev_state_list;

	/*
	* Limit maximum nvlist size. We don't want users passing in insane values
	* for zc->zc_nvlist_src_size, since we will need to allocate that much memory.
	* Defaults to 0=auto which is handled by platform code.
	*/
	unsigned long zfs_max_nvlist_src_size = 0;

	/*
	* When logging the output nvlist of an ioctl in the on-disk history, limit
	- * the logged size to this many bytes. This must be less then DMU_MAX_ACCESS.
	+ * the logged size to this many bytes. This must be less than DMU_MAX_ACCESS.
	* This applies primarily to zfs_ioc_channel_program().
	*/
	unsigned long zfs_history_output_max = 1024 * 1024;

	uint_t zfs_fsyncer_key;
	uint_t zfs_allow_log_key;

	/* DATA_TYPE_ANY is used when zkey_type can vary. */
	#define DATA_TYPE_ANY DATA_TYPE_UNKNOWN

	typedef struct zfs_ioc_vec {
	zfs_ioc_legacy_func_t *zvec_legacy_func;
	zfs_ioc_func_t *zvec_func;
	zfs_secpolicy_func_t *zvec_secpolicy;
	zfs_ioc_namecheck_t zvec_namecheck;
	boolean_t zvec_allow_log;
	zfs_ioc_poolcheck_t zvec_pool_check;
	boolean_t zvec_smush_outnvlist;
	const char *zvec_name;
	const zfs_ioc_key_t *zvec_nvl_keys;
	size_t zvec_nvl_key_count;
	} zfs_ioc_vec_t;

	/* This array is indexed by zfs_userquota_prop_t */
	static const char *userquota_perms[] = {
	ZFS_DELEG_PERM_USERUSED,
	ZFS_DELEG_PERM_USERQUOTA,
	ZFS_DELEG_PERM_GROUPUSED,
	ZFS_DELEG_PERM_GROUPQUOTA,
	ZFS_DELEG_PERM_USEROBJUSED,
	ZFS_DELEG_PERM_USEROBJQUOTA,
	ZFS_DELEG_PERM_GROUPOBJUSED,
	ZFS_DELEG_PERM_GROUPOBJQUOTA,
	ZFS_DELEG_PERM_PROJECTUSED,
	ZFS_DELEG_PERM_PROJECTQUOTA,
	ZFS_DELEG_PERM_PROJECTOBJUSED,
	ZFS_DELEG_PERM_PROJECTOBJQUOTA,
	};

	static int zfs_ioc_userspace_upgrade(zfs_cmd_t *zc);
	static int zfs_ioc_id_quota_upgrade(zfs_cmd_t *zc);
	static int zfs_check_settable(const char name, nvpair_t property,
	cred_t *cr);
	static int zfs_check_clearable(const char dataset, nvlist_t props,
	nvlist_t **errors);
	static int zfs_fill_zplprops_root(uint64_t, nvlist_t , nvlist_t ,
	boolean_t *);
	int zfs_set_prop_nvlist(const char , zprop_source_t, nvlist_t , nvlist_t *);
	static int get_nvlist(uint64_t nvl, uint64_t size, int iflag, nvlist_t **nvp);

	static void
	history_str_free(char *buf)
	{
	kmem_free(buf, HIS_MAX_RECORD_LEN);
	}

	static char *
	history_str_get(zfs_cmd_t *zc)
	{
	char *buf;

	if (zc->zc_history == 0)
	return (NULL);

	buf = kmem_alloc(HIS_MAX_RECORD_LEN, KM_SLEEP);
	if (copyinstr((void *)(uintptr_t)zc->zc_history,
	buf, HIS_MAX_RECORD_LEN, NULL) != 0) {
	history_str_free(buf);
	return (NULL);
	}

	buf[HIS_MAX_RECORD_LEN -1] = '\0';

	return (buf);
	}

	/*
	* Return non-zero if the spa version is less than requested version.
	*/
	static int
	zfs_earlier_version(const char *name, int version)
	{
	spa_t *spa;

	if (spa_open(name, &spa, FTAG) == 0) {
	if (spa_version(spa) < version) {
	spa_close(spa, FTAG);
	return (1);
	}
	spa_close(spa, FTAG);
	}
	return (0);
	}

	/*
	* Return TRUE if the ZPL version is less than requested version.
	*/
	static boolean_t
	zpl_earlier_version(const char *name, int version)
	{
	objset_t *os;
	boolean_t rc = B_TRUE;

	if (dmu_objset_hold(name, FTAG, &os) == 0) {
	uint64_t zplversion;

	if (dmu_objset_type(os) != DMU_OST_ZFS) {
	dmu_objset_rele(os, FTAG);
	return (B_TRUE);
	}
	/* XXX reading from non-owned objset */
	if (zfs_get_zplprop(os, ZFS_PROP_VERSION, &zplversion) == 0)
	rc = zplversion < version;
	dmu_objset_rele(os, FTAG);
	}
	return (rc);
	}

	static void
	zfs_log_history(zfs_cmd_t *zc)
	{
	spa_t *spa;
	char *buf;

	if ((buf = history_str_get(zc)) == NULL)
	return;

	if (spa_open(zc->zc_name, &spa, FTAG) == 0) {
	if (spa_version(spa) >= SPA_VERSION_ZPOOL_HISTORY)
	(void) spa_history_log(spa, buf);
	spa_close(spa, FTAG);
	}
	history_str_free(buf);
	}

	/*
	* Policy for top-level read operations (list pools). Requires no privileges,
	* and can be used in the local zone, as there is no associated dataset.
	*/
	/* ARGSUSED */
	static int
	zfs_secpolicy_none(zfs_cmd_t zc, nvlist_t innvl, cred_t *cr)
	{
	return (0);
	}

	/*
	* Policy for dataset read operations (list children, get statistics). Requires
	* no privileges, but must be visible in the local zone.
	*/
	/* ARGSUSED */
	static int
	zfs_secpolicy_read(zfs_cmd_t zc, nvlist_t innvl, cred_t *cr)
	{
	if (INGLOBALZONE(curproc) \|\|
	zone_dataset_visible(zc->zc_name, NULL))
	return (0);

	return (SET_ERROR(ENOENT));
	}

	static int
	zfs_dozonecheck_impl(const char dataset, uint64_t zoned, cred_t cr)
	{
	int writable = 1;

	/*
	* The dataset must be visible by this zone -- check this first
	* so they don't see EPERM on something they shouldn't know about.
	*/
	if (!INGLOBALZONE(curproc) &&
	!zone_dataset_visible(dataset, &writable))
	return (SET_ERROR(ENOENT));

	if (INGLOBALZONE(curproc)) {
	/*
	* If the fs is zoned, only root can access it from the
	* global zone.
	*/
	if (secpolicy_zfs(cr) && zoned)
	return (SET_ERROR(EPERM));
	} else {
	/*
	* If we are in a local zone, the 'zoned' property must be set.
	*/
	if (!zoned)
	return (SET_ERROR(EPERM));

	/* must be writable by this zone */
	if (!writable)
	return (SET_ERROR(EPERM));
	}
	return (0);
	}

	static int
	zfs_dozonecheck(const char dataset, cred_t cr)
	{
	uint64_t zoned;

	if (dsl_prop_get_integer(dataset, zfs_prop_to_name(ZFS_PROP_ZONED),
	&zoned, NULL))
	return (SET_ERROR(ENOENT));

	return (zfs_dozonecheck_impl(dataset, zoned, cr));
	}

	static int
	zfs_dozonecheck_ds(const char dataset, dsl_dataset_t ds, cred_t *cr)
	{
	uint64_t zoned;

	if (dsl_prop_get_int_ds(ds, zfs_prop_to_name(ZFS_PROP_ZONED), &zoned))
	return (SET_ERROR(ENOENT));

	return (zfs_dozonecheck_impl(dataset, zoned, cr));
	}

	static int
	zfs_secpolicy_write_perms_ds(const char name, dsl_dataset_t ds,
	const char perm, cred_t cr)
	{
	int error;

	error = zfs_dozonecheck_ds(name, ds, cr);
	if (error == 0) {
	error = secpolicy_zfs(cr);
	if (error != 0)
	error = dsl_deleg_access_impl(ds, perm, cr);
	}
	return (error);
	}

	static int
	zfs_secpolicy_write_perms(const char name, const char perm, cred_t *cr)
	{
	int error;
	dsl_dataset_t *ds;
	dsl_pool_t *dp;

	/*
	* First do a quick check for root in the global zone, which
	* is allowed to do all write_perms. This ensures that zfs_ioc_*
	* will get to handle nonexistent datasets.
	*/
	if (INGLOBALZONE(curproc) && secpolicy_zfs(cr) == 0)
	return (0);

	error = dsl_pool_hold(name, FTAG, &dp);
	if (error != 0)
	return (error);

	error = dsl_dataset_hold(dp, name, FTAG, &ds);
	if (error != 0) {
	dsl_pool_rele(dp, FTAG);
	return (error);
	}

	error = zfs_secpolicy_write_perms_ds(name, ds, perm, cr);

	dsl_dataset_rele(ds, FTAG);
	dsl_pool_rele(dp, FTAG);
	return (error);
	}

	/*
	* Policy for setting the security label property.
	*
	* Returns 0 for success, non-zero for access and other errors.
	*/
	static int
	zfs_set_slabel_policy(const char name, const char strval, cred_t *cr)
	{
	#ifdef HAVE_MLSLABEL
	char ds_hexsl[MAXNAMELEN];
	bslabel_t ds_sl, new_sl;
	boolean_t new_default = FALSE;
	uint64_t zoned;
	int needed_priv = -1;
	int error;

	/* First get the existing dataset label. */
	error = dsl_prop_get(name, zfs_prop_to_name(ZFS_PROP_MLSLABEL),
	1, sizeof (ds_hexsl), &ds_hexsl, NULL);
	if (error != 0)
	return (SET_ERROR(EPERM));

	if (strcasecmp(strval, ZFS_MLSLABEL_DEFAULT) == 0)
	new_default = TRUE;

	/* The label must be translatable */
	if (!new_default && (hexstr_to_label(strval, &new_sl) != 0))
	return (SET_ERROR(EINVAL));

	/*
	* In a non-global zone, disallow attempts to set a label that
	* doesn't match that of the zone; otherwise no other checks
	* are needed.
	*/
	if (!INGLOBALZONE(curproc)) {
	if (new_default \|\| !blequal(&new_sl, CR_SL(CRED())))
	return (SET_ERROR(EPERM));
	return (0);
	}

	/*
	* For global-zone datasets (i.e., those whose zoned property is
	* "off", verify that the specified new label is valid for the
	* global zone.
	*/
	if (dsl_prop_get_integer(name,
	zfs_prop_to_name(ZFS_PROP_ZONED), &zoned, NULL))
	return (SET_ERROR(EPERM));
	if (!zoned) {
	if (zfs_check_global_label(name, strval) != 0)
	return (SET_ERROR(EPERM));
	}

	/*
	* If the existing dataset label is nondefault, check if the
	* dataset is mounted (label cannot be changed while mounted).
	* Get the zfsvfs_t; if there isn't one, then the dataset isn't
	* mounted (or isn't a dataset, doesn't exist, ...).
	*/
	if (strcasecmp(ds_hexsl, ZFS_MLSLABEL_DEFAULT) != 0) {
	objset_t *os;
	static const char *setsl_tag = "setsl_tag";

	/*
	* Try to own the dataset; abort if there is any error,
	* (e.g., already mounted, in use, or other error).
	*/
	error = dmu_objset_own(name, DMU_OST_ZFS, B_TRUE, B_TRUE,
	setsl_tag, &os);
	if (error != 0)
	return (SET_ERROR(EPERM));

	dmu_objset_disown(os, B_TRUE, setsl_tag);

	if (new_default) {
	needed_priv = PRIV_FILE_DOWNGRADE_SL;
	goto out_check;
	}

	if (hexstr_to_label(strval, &new_sl) != 0)
	return (SET_ERROR(EPERM));

	if (blstrictdom(&ds_sl, &new_sl))
	needed_priv = PRIV_FILE_DOWNGRADE_SL;
	else if (blstrictdom(&new_sl, &ds_sl))
	needed_priv = PRIV_FILE_UPGRADE_SL;
	} else {
	/* dataset currently has a default label */
	if (!new_default)
	needed_priv = PRIV_FILE_UPGRADE_SL;
	}

	out_check:
	if (needed_priv != -1)
	return (PRIV_POLICY(cr, needed_priv, B_FALSE, EPERM, NULL));
	return (0);
	#else
	return (SET_ERROR(ENOTSUP));
	#endif /* HAVE_MLSLABEL */
	}

	static int
	zfs_secpolicy_setprop(const char dsname, zfs_prop_t prop, nvpair_t propval,
	cred_t *cr)
	{
	char *strval;

	/*
	* Check permissions for special properties.
	*/
	switch (prop) {
	default:
	break;
	case ZFS_PROP_ZONED:
	/*
	* Disallow setting of 'zoned' from within a local zone.
	*/
	if (!INGLOBALZONE(curproc))
	return (SET_ERROR(EPERM));
	break;

	case ZFS_PROP_QUOTA:
	case ZFS_PROP_FILESYSTEM_LIMIT:
	case ZFS_PROP_SNAPSHOT_LIMIT:
	if (!INGLOBALZONE(curproc)) {
	uint64_t zoned;
	char setpoint[ZFS_MAX_DATASET_NAME_LEN];
	/*
	* Unprivileged users are allowed to modify the
	* limit on things under (ie. contained by)
	* the thing they own.
	*/
	if (dsl_prop_get_integer(dsname,
	zfs_prop_to_name(ZFS_PROP_ZONED), &zoned, setpoint))
	return (SET_ERROR(EPERM));
	if (!zoned \|\| strlen(dsname) <= strlen(setpoint))
	return (SET_ERROR(EPERM));
	}
	break;

	case ZFS_PROP_MLSLABEL:
	if (!is_system_labeled())
	return (SET_ERROR(EPERM));

	if (nvpair_value_string(propval, &strval) == 0) {
	int err;

	err = zfs_set_slabel_policy(dsname, strval, CRED());
	if (err != 0)
	return (err);
	}
	break;
	}

	return (zfs_secpolicy_write_perms(dsname, zfs_prop_to_name(prop), cr));
	}

	/* ARGSUSED */
	static int
	zfs_secpolicy_set_fsacl(zfs_cmd_t zc, nvlist_t innvl, cred_t *cr)
	{
	int error;

	error = zfs_dozonecheck(zc->zc_name, cr);
	if (error != 0)
	return (error);

	/*
	* permission to set permissions will be evaluated later in
	* dsl_deleg_can_allow()
	*/
	return (0);
	}

	/* ARGSUSED */
	static int
	zfs_secpolicy_rollback(zfs_cmd_t zc, nvlist_t innvl, cred_t *cr)
	{
	return (zfs_secpolicy_write_perms(zc->zc_name,
	ZFS_DELEG_PERM_ROLLBACK, cr));
	}

	/* ARGSUSED */
	static int
	zfs_secpolicy_send(zfs_cmd_t zc, nvlist_t innvl, cred_t *cr)
	{
	dsl_pool_t *dp;
	dsl_dataset_t *ds;
	const char *cp;
	int error;

	/*
	* Generate the current snapshot name from the given objsetid, then
	* use that name for the secpolicy/zone checks.
	*/
	cp = strchr(zc->zc_name, '@');
	if (cp == NULL)
	return (SET_ERROR(EINVAL));
	error = dsl_pool_hold(zc->zc_name, FTAG, &dp);
	if (error != 0)
	return (error);

	error = dsl_dataset_hold_obj(dp, zc->zc_sendobj, FTAG, &ds);
	if (error != 0) {
	dsl_pool_rele(dp, FTAG);
	return (error);
	}

	dsl_dataset_name(ds, zc->zc_name);

	error = zfs_secpolicy_write_perms_ds(zc->zc_name, ds,
	ZFS_DELEG_PERM_SEND, cr);
	dsl_dataset_rele(ds, FTAG);
	dsl_pool_rele(dp, FTAG);

	return (error);
	}

	/* ARGSUSED */
	static int
	zfs_secpolicy_send_new(zfs_cmd_t zc, nvlist_t innvl, cred_t *cr)
	{
	return (zfs_secpolicy_write_perms(zc->zc_name,
	ZFS_DELEG_PERM_SEND, cr));
	}

	static int
	zfs_secpolicy_share(zfs_cmd_t zc, nvlist_t innvl, cred_t *cr)
	{
	return (SET_ERROR(ENOTSUP));
	}

	static int
	zfs_secpolicy_smb_acl(zfs_cmd_t zc, nvlist_t innvl, cred_t *cr)
	{
	return (SET_ERROR(ENOTSUP));
	}

	static int
	zfs_get_parent(const char datasetname, char parent, int parentsize)
	{
	char *cp;

	/*
	* Remove the @bla or /bla from the end of the name to get the parent.
	*/
	(void) strncpy(parent, datasetname, parentsize);
	cp = strrchr(parent, '@');
	if (cp != NULL) {
	cp[0] = '\0';
	} else {
	cp = strrchr(parent, '/');
	if (cp == NULL)
	return (SET_ERROR(ENOENT));
	cp[0] = '\0';
	}

	return (0);
	}

	int
	zfs_secpolicy_destroy_perms(const char name, cred_t cr)
	{
	int error;

	if ((error = zfs_secpolicy_write_perms(name,
	ZFS_DELEG_PERM_MOUNT, cr)) != 0)
	return (error);

	return (zfs_secpolicy_write_perms(name, ZFS_DELEG_PERM_DESTROY, cr));
	}

	/* ARGSUSED */
	static int
	zfs_secpolicy_destroy(zfs_cmd_t zc, nvlist_t innvl, cred_t *cr)
	{
	return (zfs_secpolicy_destroy_perms(zc->zc_name, cr));
	}

	/*
	* Destroying snapshots with delegated permissions requires
	* descendant mount and destroy permissions.
	*/
	/* ARGSUSED */
	static int
	zfs_secpolicy_destroy_snaps(zfs_cmd_t zc, nvlist_t innvl, cred_t *cr)
	{
	nvlist_t *snaps;
	nvpair_t pair, nextpair;
	int error = 0;

	snaps = fnvlist_lookup_nvlist(innvl, "snaps");

	for (pair = nvlist_next_nvpair(snaps, NULL); pair != NULL;
	pair = nextpair) {
	nextpair = nvlist_next_nvpair(snaps, pair);
	error = zfs_secpolicy_destroy_perms(nvpair_name(pair), cr);
	if (error == ENOENT) {
	/*
	* Ignore any snapshots that don't exist (we consider
	* them "already destroyed"). Remove the name from the
	* nvl here in case the snapshot is created between
	* now and when we try to destroy it (in which case
	* we don't want to destroy it since we haven't
	* checked for permission).
	*/
	fnvlist_remove_nvpair(snaps, pair);
	error = 0;
	}
	if (error != 0)
	break;
	}

	return (error);
	}

	int
	zfs_secpolicy_rename_perms(const char from, const char to, cred_t *cr)
	{
	char parentname[ZFS_MAX_DATASET_NAME_LEN];
	int error;

	if ((error = zfs_secpolicy_write_perms(from,
	ZFS_DELEG_PERM_RENAME, cr)) != 0)
	return (error);

	if ((error = zfs_secpolicy_write_perms(from,
	ZFS_DELEG_PERM_MOUNT, cr)) != 0)
	return (error);

	if ((error = zfs_get_parent(to, parentname,
	sizeof (parentname))) != 0)
	return (error);

	if ((error = zfs_secpolicy_write_perms(parentname,
	ZFS_DELEG_PERM_CREATE, cr)) != 0)
	return (error);

	if ((error = zfs_secpolicy_write_perms(parentname,
	ZFS_DELEG_PERM_MOUNT, cr)) != 0)
	return (error);

	return (error);
	}

	/* ARGSUSED */
	static int
	zfs_secpolicy_rename(zfs_cmd_t zc, nvlist_t innvl, cred_t *cr)
	{
	return (zfs_secpolicy_rename_perms(zc->zc_name, zc->zc_value, cr));
	}

	/* ARGSUSED */
	static int
	zfs_secpolicy_promote(zfs_cmd_t zc, nvlist_t innvl, cred_t *cr)
	{
	dsl_pool_t *dp;
	dsl_dataset_t *clone;
	int error;

	error = zfs_secpolicy_write_perms(zc->zc_name,
	ZFS_DELEG_PERM_PROMOTE, cr);
	if (error != 0)
	return (error);

	error = dsl_pool_hold(zc->zc_name, FTAG, &dp);
	if (error != 0)
	return (error);

	error = dsl_dataset_hold(dp, zc->zc_name, FTAG, &clone);

	if (error == 0) {
	char parentname[ZFS_MAX_DATASET_NAME_LEN];
	dsl_dataset_t *origin = NULL;
	dsl_dir_t *dd;
	dd = clone->ds_dir;

	error = dsl_dataset_hold_obj(dd->dd_pool,
	dsl_dir_phys(dd)->dd_origin_obj, FTAG, &origin);
	if (error != 0) {
	dsl_dataset_rele(clone, FTAG);
	dsl_pool_rele(dp, FTAG);
	return (error);
	}

	error = zfs_secpolicy_write_perms_ds(zc->zc_name, clone,
	ZFS_DELEG_PERM_MOUNT, cr);

	dsl_dataset_name(origin, parentname);
	if (error == 0) {
	error = zfs_secpolicy_write_perms_ds(parentname, origin,
	ZFS_DELEG_PERM_PROMOTE, cr);
	}
	dsl_dataset_rele(clone, FTAG);
	dsl_dataset_rele(origin, FTAG);
	}
	dsl_pool_rele(dp, FTAG);
	return (error);
	}

	/* ARGSUSED */
	static int
	zfs_secpolicy_recv(zfs_cmd_t zc, nvlist_t innvl, cred_t *cr)
	{
	int error;

	if ((error = zfs_secpolicy_write_perms(zc->zc_name,
	ZFS_DELEG_PERM_RECEIVE, cr)) != 0)
	return (error);

	if ((error = zfs_secpolicy_write_perms(zc->zc_name,
	ZFS_DELEG_PERM_MOUNT, cr)) != 0)
	return (error);

	return (zfs_secpolicy_write_perms(zc->zc_name,
	ZFS_DELEG_PERM_CREATE, cr));
	}

	/* ARGSUSED */
	static int
	zfs_secpolicy_recv_new(zfs_cmd_t zc, nvlist_t innvl, cred_t *cr)
	{
	return (zfs_secpolicy_recv(zc, innvl, cr));
	}

	int
	zfs_secpolicy_snapshot_perms(const char name, cred_t cr)
	{
	return (zfs_secpolicy_write_perms(name,
	ZFS_DELEG_PERM_SNAPSHOT, cr));
	}

	/*
	* Check for permission to create each snapshot in the nvlist.
	*/
	/* ARGSUSED */
	static int
	zfs_secpolicy_snapshot(zfs_cmd_t zc, nvlist_t innvl, cred_t *cr)
	{
	nvlist_t *snaps;
	int error = 0;
	nvpair_t *pair;

	snaps = fnvlist_lookup_nvlist(innvl, "snaps");

	for (pair = nvlist_next_nvpair(snaps, NULL); pair != NULL;
	pair = nvlist_next_nvpair(snaps, pair)) {
	char *name = nvpair_name(pair);
	char *atp = strchr(name, '@');

	if (atp == NULL) {
	error = SET_ERROR(EINVAL);
	break;
	}
	*atp = '\0';
	error = zfs_secpolicy_snapshot_perms(name, cr);
	*atp = '@';
	if (error != 0)
	break;
	}
	return (error);
	}

	/*
	* Check for permission to create each bookmark in the nvlist.
	*/
	/* ARGSUSED */
	static int
	zfs_secpolicy_bookmark(zfs_cmd_t zc, nvlist_t innvl, cred_t *cr)
	{
	int error = 0;

	for (nvpair_t *pair = nvlist_next_nvpair(innvl, NULL);
	pair != NULL; pair = nvlist_next_nvpair(innvl, pair)) {
	char *name = nvpair_name(pair);
	char *hashp = strchr(name, '#');

	if (hashp == NULL) {
	error = SET_ERROR(EINVAL);
	break;
	}
	*hashp = '\0';
	error = zfs_secpolicy_write_perms(name,
	ZFS_DELEG_PERM_BOOKMARK, cr);
	*hashp = '#';
	if (error != 0)
	break;
	}
	return (error);
	}

	/* ARGSUSED */
	static int
	zfs_secpolicy_destroy_bookmarks(zfs_cmd_t zc, nvlist_t innvl, cred_t *cr)
	{
	nvpair_t pair, nextpair;
	int error = 0;

	for (pair = nvlist_next_nvpair(innvl, NULL); pair != NULL;
	pair = nextpair) {
	char *name = nvpair_name(pair);
	char *hashp = strchr(name, '#');
	nextpair = nvlist_next_nvpair(innvl, pair);

	if (hashp == NULL) {
	error = SET_ERROR(EINVAL);
	break;
	}

	*hashp = '\0';
	error = zfs_secpolicy_write_perms(name,
	ZFS_DELEG_PERM_DESTROY, cr);
	*hashp = '#';
	if (error == ENOENT) {
	/*
	* Ignore any filesystems that don't exist (we consider
	* their bookmarks "already destroyed"). Remove
	* the name from the nvl here in case the filesystem
	* is created between now and when we try to destroy
	* the bookmark (in which case we don't want to
	* destroy it since we haven't checked for permission).
	*/
	fnvlist_remove_nvpair(innvl, pair);
	error = 0;
	}
	if (error != 0)
	break;
	}

	return (error);
	}

	/* ARGSUSED */
	static int
	zfs_secpolicy_log_history(zfs_cmd_t zc, nvlist_t innvl, cred_t *cr)
	{
	/*
	* Even root must have a proper TSD so that we know what pool
	* to log to.
	*/
	if (tsd_get(zfs_allow_log_key) == NULL)
	return (SET_ERROR(EPERM));
	return (0);
	}

	static int
	zfs_secpolicy_create_clone(zfs_cmd_t zc, nvlist_t innvl, cred_t *cr)
	{
	char parentname[ZFS_MAX_DATASET_NAME_LEN];
	int error;
	char *origin;

	if ((error = zfs_get_parent(zc->zc_name, parentname,
	sizeof (parentname))) != 0)
	return (error);

	if (nvlist_lookup_string(innvl, "origin", &origin) == 0 &&
	(error = zfs_secpolicy_write_perms(origin,
	ZFS_DELEG_PERM_CLONE, cr)) != 0)
	return (error);

	if ((error = zfs_secpolicy_write_perms(parentname,
	ZFS_DELEG_PERM_CREATE, cr)) != 0)
	return (error);

	return (zfs_secpolicy_write_perms(parentname,
	ZFS_DELEG_PERM_MOUNT, cr));
	}

	/*
	* Policy for pool operations - create/destroy pools, add vdevs, etc. Requires
	* SYS_CONFIG privilege, which is not available in a local zone.
	*/
	/* ARGSUSED */
	int
	zfs_secpolicy_config(zfs_cmd_t zc, nvlist_t innvl, cred_t *cr)
	{
	if (secpolicy_sys_config(cr, B_FALSE) != 0)
	return (SET_ERROR(EPERM));

	return (0);
	}

	/*
	* Policy for object to name lookups.
	*/
	/* ARGSUSED */
	static int
	zfs_secpolicy_diff(zfs_cmd_t zc, nvlist_t innvl, cred_t *cr)
	{
	int error;

	if ((error = secpolicy_sys_config(cr, B_FALSE)) == 0)
	return (0);

	error = zfs_secpolicy_write_perms(zc->zc_name, ZFS_DELEG_PERM_DIFF, cr);
	return (error);
	}

	/*
	* Policy for fault injection. Requires all privileges.
	*/
	/* ARGSUSED */
	static int
	zfs_secpolicy_inject(zfs_cmd_t zc, nvlist_t innvl, cred_t *cr)
	{
	return (secpolicy_zinject(cr));
	}

	/* ARGSUSED */
	static int
	zfs_secpolicy_inherit_prop(zfs_cmd_t zc, nvlist_t innvl, cred_t *cr)
	{
	zfs_prop_t prop = zfs_name_to_prop(zc->zc_value);

	if (prop == ZPROP_INVAL) {
	if (!zfs_prop_user(zc->zc_value))
	return (SET_ERROR(EINVAL));
	return (zfs_secpolicy_write_perms(zc->zc_name,
	ZFS_DELEG_PERM_USERPROP, cr));
	} else {
	return (zfs_secpolicy_setprop(zc->zc_name, prop,
	NULL, cr));
	}
	}

	static int
	zfs_secpolicy_userspace_one(zfs_cmd_t zc, nvlist_t innvl, cred_t *cr)
	{
	int err = zfs_secpolicy_read(zc, innvl, cr);
	if (err)
	return (err);

	if (zc->zc_objset_type >= ZFS_NUM_USERQUOTA_PROPS)
	return (SET_ERROR(EINVAL));

	if (zc->zc_value[0] == 0) {
	/*
	* They are asking about a posix uid/gid. If it's
	* themself, allow it.
	*/
	if (zc->zc_objset_type == ZFS_PROP_USERUSED \|\|
	zc->zc_objset_type == ZFS_PROP_USERQUOTA \|\|
	zc->zc_objset_type == ZFS_PROP_USEROBJUSED \|\|
	zc->zc_objset_type == ZFS_PROP_USEROBJQUOTA) {
	if (zc->zc_guid == crgetuid(cr))
	return (0);
	} else if (zc->zc_objset_type == ZFS_PROP_GROUPUSED \|\|
	zc->zc_objset_type == ZFS_PROP_GROUPQUOTA \|\|
	zc->zc_objset_type == ZFS_PROP_GROUPOBJUSED \|\|
	zc->zc_objset_type == ZFS_PROP_GROUPOBJQUOTA) {
	if (groupmember(zc->zc_guid, cr))
	return (0);
	}
	/* else is for project quota/used */
	}

	return (zfs_secpolicy_write_perms(zc->zc_name,
	userquota_perms[zc->zc_objset_type], cr));
	}

	static int
	zfs_secpolicy_userspace_many(zfs_cmd_t zc, nvlist_t innvl, cred_t *cr)
	{
	int err = zfs_secpolicy_read(zc, innvl, cr);
	if (err)
	return (err);

	if (zc->zc_objset_type >= ZFS_NUM_USERQUOTA_PROPS)
	return (SET_ERROR(EINVAL));

	return (zfs_secpolicy_write_perms(zc->zc_name,
	userquota_perms[zc->zc_objset_type], cr));
	}

	/* ARGSUSED */
	static int
	zfs_secpolicy_userspace_upgrade(zfs_cmd_t zc, nvlist_t innvl, cred_t *cr)
	{
	return (zfs_secpolicy_setprop(zc->zc_name, ZFS_PROP_VERSION,
	NULL, cr));
	}

	/* ARGSUSED */
	static int
	zfs_secpolicy_hold(zfs_cmd_t zc, nvlist_t innvl, cred_t *cr)
	{
	nvpair_t *pair;
	nvlist_t *holds;
	int error;

	holds = fnvlist_lookup_nvlist(innvl, "holds");

	for (pair = nvlist_next_nvpair(holds, NULL); pair != NULL;
	pair = nvlist_next_nvpair(holds, pair)) {
	char fsname[ZFS_MAX_DATASET_NAME_LEN];
	error = dmu_fsname(nvpair_name(pair), fsname);
	if (error != 0)
	return (error);
	error = zfs_secpolicy_write_perms(fsname,
	ZFS_DELEG_PERM_HOLD, cr);
	if (error != 0)
	return (error);
	}
	return (0);
	}

	/* ARGSUSED */
	static int
	zfs_secpolicy_release(zfs_cmd_t zc, nvlist_t innvl, cred_t *cr)
	{
	nvpair_t *pair;
	int error;

	for (pair = nvlist_next_nvpair(innvl, NULL); pair != NULL;
	pair = nvlist_next_nvpair(innvl, pair)) {
	char fsname[ZFS_MAX_DATASET_NAME_LEN];
	error = dmu_fsname(nvpair_name(pair), fsname);
	if (error != 0)
	return (error);
	error = zfs_secpolicy_write_perms(fsname,
	ZFS_DELEG_PERM_RELEASE, cr);
	if (error != 0)
	return (error);
	}
	return (0);
	}

	/*
	* Policy for allowing temporary snapshots to be taken or released
	*/
	static int
	zfs_secpolicy_tmp_snapshot(zfs_cmd_t zc, nvlist_t innvl, cred_t *cr)
	{
	/*
	* A temporary snapshot is the same as a snapshot,
	* hold, destroy and release all rolled into one.
	* Delegated diff alone is sufficient that we allow this.
	*/
	int error;

	if ((error = zfs_secpolicy_write_perms(zc->zc_name,
	ZFS_DELEG_PERM_DIFF, cr)) == 0)
	return (0);

	error = zfs_secpolicy_snapshot_perms(zc->zc_name, cr);

	if (innvl != NULL) {
	if (error == 0)
	error = zfs_secpolicy_hold(zc, innvl, cr);
	if (error == 0)
	error = zfs_secpolicy_release(zc, innvl, cr);
	if (error == 0)
	error = zfs_secpolicy_destroy(zc, innvl, cr);
	}
	return (error);
	}

	static int
	zfs_secpolicy_load_key(zfs_cmd_t zc, nvlist_t innvl, cred_t *cr)
	{
	return (zfs_secpolicy_write_perms(zc->zc_name,
	ZFS_DELEG_PERM_LOAD_KEY, cr));
	}

	static int
	zfs_secpolicy_change_key(zfs_cmd_t zc, nvlist_t innvl, cred_t *cr)
	{
	return (zfs_secpolicy_write_perms(zc->zc_name,
	ZFS_DELEG_PERM_CHANGE_KEY, cr));
	}

	/*
	* Returns the nvlist as specified by the user in the zfs_cmd_t.
	*/
	static int
	get_nvlist(uint64_t nvl, uint64_t size, int iflag, nvlist_t **nvp)
	{
	char *packed;
	int error;
	nvlist_t *list = NULL;

	/*
	* Read in and unpack the user-supplied nvlist.
	*/
	if (size == 0)
	return (SET_ERROR(EINVAL));

	packed = vmem_alloc(size, KM_SLEEP);

	if ((error = ddi_copyin((void *)(uintptr_t)nvl, packed, size,
	iflag)) != 0) {
	vmem_free(packed, size);
	return (SET_ERROR(EFAULT));
	}

	if ((error = nvlist_unpack(packed, size, &list, 0)) != 0) {
	vmem_free(packed, size);
	return (error);
	}

	vmem_free(packed, size);

	*nvp = list;
	return (0);
	}

	/*
	* Reduce the size of this nvlist until it can be serialized in 'max' bytes.
	* Entries will be removed from the end of the nvlist, and one int32 entry
	* named "N_MORE_ERRORS" will be added indicating how many entries were
	* removed.
	*/
	static int
	nvlist_smush(nvlist_t *errors, size_t max)
	{
	size_t size;

	size = fnvlist_size(errors);

	if (size > max) {
	nvpair_t *more_errors;
	int n = 0;

	if (max < 1024)
	return (SET_ERROR(ENOMEM));

	fnvlist_add_int32(errors, ZPROP_N_MORE_ERRORS, 0);
	more_errors = nvlist_prev_nvpair(errors, NULL);

	do {
	nvpair_t *pair = nvlist_prev_nvpair(errors,
	more_errors);
	fnvlist_remove_nvpair(errors, pair);
	n++;
	size = fnvlist_size(errors);
	} while (size > max);

	fnvlist_remove_nvpair(errors, more_errors);
	fnvlist_add_int32(errors, ZPROP_N_MORE_ERRORS, n);
	ASSERT3U(fnvlist_size(errors), <=, max);
	}

	return (0);
	}

	static int
	put_nvlist(zfs_cmd_t zc, nvlist_t nvl)
	{
	char *packed = NULL;
	int error = 0;
	size_t size;

	size = fnvlist_size(nvl);

	if (size > zc->zc_nvlist_dst_size) {
	error = SET_ERROR(ENOMEM);
	} else {
	packed = fnvlist_pack(nvl, &size);
	if (ddi_copyout(packed, (void *)(uintptr_t)zc->zc_nvlist_dst,
	size, zc->zc_iflags) != 0)
	error = SET_ERROR(EFAULT);
	fnvlist_pack_free(packed, size);
	}

	zc->zc_nvlist_dst_size = size;
	zc->zc_nvlist_dst_filled = B_TRUE;
	return (error);
	}

	int
	getzfsvfs_impl(objset_t os, zfsvfs_t *zfvp)
	{
	int error = 0;
	if (dmu_objset_type(os) != DMU_OST_ZFS) {
	return (SET_ERROR(EINVAL));
	}

	mutex_enter(&os->os_user_ptr_lock);
	*zfvp = dmu_objset_get_user(os);
	/* bump s_active only when non-zero to prevent umount race */
	error = zfs_vfs_ref(zfvp);
	mutex_exit(&os->os_user_ptr_lock);
	return (error);
	}

	int
	getzfsvfs(const char dsname, zfsvfs_t *zfvp)
	{
	objset_t *os;
	int error;

	error = dmu_objset_hold(dsname, FTAG, &os);
	if (error != 0)
	return (error);

	error = getzfsvfs_impl(os, zfvp);
	dmu_objset_rele(os, FTAG);
	return (error);
	}

	/*
	* Find a zfsvfs_t for a mounted filesystem, or create our own, in which
	* case its z_sb will be NULL, and it will be opened as the owner.
	* If 'writer' is set, the z_teardown_lock will be held for RW_WRITER,
	* which prevents all inode ops from running.
	*/
	static int
	zfsvfs_hold(const char name, void tag, zfsvfs_t **zfvp, boolean_t writer)
	{
	int error = 0;

	if (getzfsvfs(name, zfvp) != 0)
	error = zfsvfs_create(name, B_FALSE, zfvp);
	if (error == 0) {
	if (writer)
	ZFS_TEARDOWN_ENTER_WRITE(*zfvp, tag);
	else
	ZFS_TEARDOWN_ENTER_READ(*zfvp, tag);
	if ((*zfvp)->z_unmounted) {
	/*
	* XXX we could probably try again, since the unmounting
	* thread should be just about to disassociate the
	* objset from the zfsvfs.
	*/
	ZFS_TEARDOWN_EXIT(*zfvp, tag);
	return (SET_ERROR(EBUSY));
	}
	}
	return (error);
	}

	static void
	zfsvfs_rele(zfsvfs_t zfsvfs, void tag)
	{
	ZFS_TEARDOWN_EXIT(zfsvfs, tag);

	if (zfs_vfs_held(zfsvfs)) {
	zfs_vfs_rele(zfsvfs);
	} else {
	dmu_objset_disown(zfsvfs->z_os, B_TRUE, zfsvfs);
	zfsvfs_free(zfsvfs);
	}
	}

	static int
	zfs_ioc_pool_create(zfs_cmd_t *zc)
	{
	int error;
	nvlist_t config, props = NULL;
	nvlist_t *rootprops = NULL;
	nvlist_t *zplprops = NULL;
	dsl_crypto_params_t *dcp = NULL;
	const char *spa_name = zc->zc_name;
	boolean_t unload_wkey = B_TRUE;

	if ((error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size,
	zc->zc_iflags, &config)))
	return (error);

	if (zc->zc_nvlist_src_size != 0 && (error =
	get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
	zc->zc_iflags, &props))) {
	nvlist_free(config);
	return (error);
	}

	if (props) {
	nvlist_t *nvl = NULL;
	nvlist_t *hidden_args = NULL;
	uint64_t version = SPA_VERSION;
	char *tname;

	(void) nvlist_lookup_uint64(props,
	zpool_prop_to_name(ZPOOL_PROP_VERSION), &version);
	if (!SPA_VERSION_IS_SUPPORTED(version)) {
	error = SET_ERROR(EINVAL);
	goto pool_props_bad;
	}
	(void) nvlist_lookup_nvlist(props, ZPOOL_ROOTFS_PROPS, &nvl);
	if (nvl) {
	error = nvlist_dup(nvl, &rootprops, KM_SLEEP);
	if (error != 0)
	goto pool_props_bad;
	(void) nvlist_remove_all(props, ZPOOL_ROOTFS_PROPS);
	}

	(void) nvlist_lookup_nvlist(props, ZPOOL_HIDDEN_ARGS,
	&hidden_args);
	error = dsl_crypto_params_create_nvlist(DCP_CMD_NONE,
	rootprops, hidden_args, &dcp);
	if (error != 0)
	goto pool_props_bad;
	(void) nvlist_remove_all(props, ZPOOL_HIDDEN_ARGS);

	VERIFY(nvlist_alloc(&zplprops, NV_UNIQUE_NAME, KM_SLEEP) == 0);
	error = zfs_fill_zplprops_root(version, rootprops,
	zplprops, NULL);
	if (error != 0)
	goto pool_props_bad;

	if (nvlist_lookup_string(props,
	zpool_prop_to_name(ZPOOL_PROP_TNAME), &tname) == 0)
	spa_name = tname;
	}

	error = spa_create(zc->zc_name, config, props, zplprops, dcp);

	/*
	* Set the remaining root properties
	*/
	if (!error && (error = zfs_set_prop_nvlist(spa_name,
	ZPROP_SRC_LOCAL, rootprops, NULL)) != 0) {
	(void) spa_destroy(spa_name);
	unload_wkey = B_FALSE; /* spa_destroy() unloads wrapping keys */
	}

	pool_props_bad:
	nvlist_free(rootprops);
	nvlist_free(zplprops);
	nvlist_free(config);
	nvlist_free(props);
	dsl_crypto_params_free(dcp, unload_wkey && !!error);

	return (error);
	}

	static int
	zfs_ioc_pool_destroy(zfs_cmd_t *zc)
	{
	int error;
	zfs_log_history(zc);
	error = spa_destroy(zc->zc_name);

	return (error);
	}

	static int
	zfs_ioc_pool_import(zfs_cmd_t *zc)
	{
	nvlist_t config, props = NULL;
	uint64_t guid;
	int error;

	if ((error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size,
	zc->zc_iflags, &config)) != 0)
	return (error);

	if (zc->zc_nvlist_src_size != 0 && (error =
	get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
	zc->zc_iflags, &props))) {
	nvlist_free(config);
	return (error);
	}

	if (nvlist_lookup_uint64(config, ZPOOL_CONFIG_POOL_GUID, &guid) != 0 \|\|
	guid != zc->zc_guid)
	error = SET_ERROR(EINVAL);
	else
	error = spa_import(zc->zc_name, config, props, zc->zc_cookie);

	if (zc->zc_nvlist_dst != 0) {
	int err;

	if ((err = put_nvlist(zc, config)) != 0)
	error = err;
	}

	nvlist_free(config);
	nvlist_free(props);

	return (error);
	}

	static int
	zfs_ioc_pool_export(zfs_cmd_t *zc)
	{
	int error;
	boolean_t force = (boolean_t)zc->zc_cookie;
	boolean_t hardforce = (boolean_t)zc->zc_guid;

	zfs_log_history(zc);
	error = spa_export(zc->zc_name, NULL, force, hardforce);

	return (error);
	}

	static int
	zfs_ioc_pool_configs(zfs_cmd_t *zc)
	{
	nvlist_t *configs;
	int error;

	if ((configs = spa_all_configs(&zc->zc_cookie)) == NULL)
	return (SET_ERROR(EEXIST));

	error = put_nvlist(zc, configs);

	nvlist_free(configs);

	return (error);
	}

	/*
	* inputs:
	* zc_name name of the pool
	*
	* outputs:
	* zc_cookie real errno
	* zc_nvlist_dst config nvlist
	* zc_nvlist_dst_size size of config nvlist
	*/
	static int
	zfs_ioc_pool_stats(zfs_cmd_t *zc)
	{
	nvlist_t *config;
	int error;
	int ret = 0;

	error = spa_get_stats(zc->zc_name, &config, zc->zc_value,
	sizeof (zc->zc_value));

	if (config != NULL) {
	ret = put_nvlist(zc, config);
	nvlist_free(config);

	/*
	* The config may be present even if 'error' is non-zero.
	* In this case we return success, and preserve the real errno
	* in 'zc_cookie'.
	*/
	zc->zc_cookie = error;
	} else {
	ret = error;
	}

	return (ret);
	}

	/*
	* Try to import the given pool, returning pool stats as appropriate so that
	* user land knows which devices are available and overall pool health.
	*/
	static int
	zfs_ioc_pool_tryimport(zfs_cmd_t *zc)
	{
	nvlist_t tryconfig, config = NULL;
	int error;

	if ((error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size,
	zc->zc_iflags, &tryconfig)) != 0)
	return (error);

	config = spa_tryimport(tryconfig);

	nvlist_free(tryconfig);

	if (config == NULL)
	return (SET_ERROR(EINVAL));

	error = put_nvlist(zc, config);
	nvlist_free(config);

	return (error);
	}

	/*
	* inputs:
	* zc_name name of the pool
	* zc_cookie scan func (pool_scan_func_t)
	* zc_flags scrub pause/resume flag (pool_scrub_cmd_t)
	*/
	static int
	zfs_ioc_pool_scan(zfs_cmd_t *zc)
	{
	spa_t *spa;
	int error;

	if (zc->zc_flags >= POOL_SCRUB_FLAGS_END)
	return (SET_ERROR(EINVAL));

	if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
	return (error);

	if (zc->zc_flags == POOL_SCRUB_PAUSE)
	error = spa_scrub_pause_resume(spa, POOL_SCRUB_PAUSE);
	else if (zc->zc_cookie == POOL_SCAN_NONE)
	error = spa_scan_stop(spa);
	else
	error = spa_scan(spa, zc->zc_cookie);

	spa_close(spa, FTAG);

	return (error);
	}

	static int
	zfs_ioc_pool_freeze(zfs_cmd_t *zc)
	{
	spa_t *spa;
	int error;

	error = spa_open(zc->zc_name, &spa, FTAG);
	if (error == 0) {
	spa_freeze(spa);
	spa_close(spa, FTAG);
	}
	return (error);
	}

	static int
	zfs_ioc_pool_upgrade(zfs_cmd_t *zc)
	{
	spa_t *spa;
	int error;

	if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
	return (error);

	if (zc->zc_cookie < spa_version(spa) \|\|
	!SPA_VERSION_IS_SUPPORTED(zc->zc_cookie)) {
	spa_close(spa, FTAG);
	return (SET_ERROR(EINVAL));
	}

	spa_upgrade(spa, zc->zc_cookie);
	spa_close(spa, FTAG);

	return (error);
	}

	static int
	zfs_ioc_pool_get_history(zfs_cmd_t *zc)
	{
	spa_t *spa;
	char *hist_buf;
	uint64_t size;
	int error;

	if ((size = zc->zc_history_len) == 0)
	return (SET_ERROR(EINVAL));

	if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
	return (error);

	if (spa_version(spa) < SPA_VERSION_ZPOOL_HISTORY) {
	spa_close(spa, FTAG);
	return (SET_ERROR(ENOTSUP));
	}

	hist_buf = vmem_alloc(size, KM_SLEEP);
	if ((error = spa_history_get(spa, &zc->zc_history_offset,
	&zc->zc_history_len, hist_buf)) == 0) {
	error = ddi_copyout(hist_buf,
	(void *)(uintptr_t)zc->zc_history,
	zc->zc_history_len, zc->zc_iflags);
	}

	spa_close(spa, FTAG);
	vmem_free(hist_buf, size);
	return (error);
	}

	static int
	zfs_ioc_pool_reguid(zfs_cmd_t *zc)
	{
	spa_t *spa;
	int error;

	error = spa_open(zc->zc_name, &spa, FTAG);
	if (error == 0) {
	error = spa_change_guid(spa);
	spa_close(spa, FTAG);
	}
	return (error);
	}

	static int
	zfs_ioc_dsobj_to_dsname(zfs_cmd_t *zc)
	{
	return (dsl_dsobj_to_dsname(zc->zc_name, zc->zc_obj, zc->zc_value));
	}

	/*
	* inputs:
	* zc_name name of filesystem
	* zc_obj object to find
	*
	* outputs:
	* zc_value name of object
	*/
	static int
	zfs_ioc_obj_to_path(zfs_cmd_t *zc)
	{
	objset_t *os;
	int error;

	/* XXX reading from objset not owned */
	if ((error = dmu_objset_hold_flags(zc->zc_name, B_TRUE,
	FTAG, &os)) != 0)
	return (error);
	if (dmu_objset_type(os) != DMU_OST_ZFS) {
	dmu_objset_rele_flags(os, B_TRUE, FTAG);
	return (SET_ERROR(EINVAL));
	}
	error = zfs_obj_to_path(os, zc->zc_obj, zc->zc_value,
	sizeof (zc->zc_value));
	dmu_objset_rele_flags(os, B_TRUE, FTAG);

	return (error);
	}

	/*
	* inputs:
	* zc_name name of filesystem
	* zc_obj object to find
	*
	* outputs:
	* zc_stat stats on object
	* zc_value path to object
	*/
	static int
	zfs_ioc_obj_to_stats(zfs_cmd_t *zc)
	{
	objset_t *os;
	int error;

	/* XXX reading from objset not owned */
	if ((error = dmu_objset_hold_flags(zc->zc_name, B_TRUE,
	FTAG, &os)) != 0)
	return (error);
	if (dmu_objset_type(os) != DMU_OST_ZFS) {
	dmu_objset_rele_flags(os, B_TRUE, FTAG);
	return (SET_ERROR(EINVAL));
	}
	error = zfs_obj_to_stats(os, zc->zc_obj, &zc->zc_stat, zc->zc_value,
	sizeof (zc->zc_value));
	dmu_objset_rele_flags(os, B_TRUE, FTAG);

	return (error);
	}

	static int
	zfs_ioc_vdev_add(zfs_cmd_t *zc)
	{
	spa_t *spa;
	int error;
	nvlist_t *config;

	error = spa_open(zc->zc_name, &spa, FTAG);
	if (error != 0)
	return (error);

	error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size,
	zc->zc_iflags, &config);
	if (error == 0) {
	error = spa_vdev_add(spa, config);
	nvlist_free(config);
	}
	spa_close(spa, FTAG);
	return (error);
	}

	/*
	* inputs:
	* zc_name name of the pool
	* zc_guid guid of vdev to remove
	* zc_cookie cancel removal
	*/
	static int
	zfs_ioc_vdev_remove(zfs_cmd_t *zc)
	{
	spa_t *spa;
	int error;

	error = spa_open(zc->zc_name, &spa, FTAG);
	if (error != 0)
	return (error);
	if (zc->zc_cookie != 0) {
	error = spa_vdev_remove_cancel(spa);
	} else {
	error = spa_vdev_remove(spa, zc->zc_guid, B_FALSE);
	}
	spa_close(spa, FTAG);
	return (error);
	}

	static int
	zfs_ioc_vdev_set_state(zfs_cmd_t *zc)
	{
	spa_t *spa;
	int error;
	vdev_state_t newstate = VDEV_STATE_UNKNOWN;

	if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
	return (error);
	switch (zc->zc_cookie) {
	case VDEV_STATE_ONLINE:
	error = vdev_online(spa, zc->zc_guid, zc->zc_obj, &newstate);
	break;

	case VDEV_STATE_OFFLINE:
	error = vdev_offline(spa, zc->zc_guid, zc->zc_obj);
	break;

	case VDEV_STATE_FAULTED:
	if (zc->zc_obj != VDEV_AUX_ERR_EXCEEDED &&
	zc->zc_obj != VDEV_AUX_EXTERNAL &&
	zc->zc_obj != VDEV_AUX_EXTERNAL_PERSIST)
	zc->zc_obj = VDEV_AUX_ERR_EXCEEDED;

	error = vdev_fault(spa, zc->zc_guid, zc->zc_obj);
	break;

	case VDEV_STATE_DEGRADED:
	if (zc->zc_obj != VDEV_AUX_ERR_EXCEEDED &&
	zc->zc_obj != VDEV_AUX_EXTERNAL)
	zc->zc_obj = VDEV_AUX_ERR_EXCEEDED;

	error = vdev_degrade(spa, zc->zc_guid, zc->zc_obj);
	break;

	default:
	error = SET_ERROR(EINVAL);
	}
	zc->zc_cookie = newstate;
	spa_close(spa, FTAG);
	return (error);
	}

	static int
	zfs_ioc_vdev_attach(zfs_cmd_t *zc)
	{
	spa_t *spa;
	nvlist_t *config;
	int replacing = zc->zc_cookie;
	int rebuild = zc->zc_simple;
	int error;

	if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
	return (error);

	if ((error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size,
	zc->zc_iflags, &config)) == 0) {
	error = spa_vdev_attach(spa, zc->zc_guid, config, replacing,
	rebuild);
	nvlist_free(config);
	}

	spa_close(spa, FTAG);
	return (error);
	}

	static int
	zfs_ioc_vdev_detach(zfs_cmd_t *zc)
	{
	spa_t *spa;
	int error;

	if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
	return (error);

	error = spa_vdev_detach(spa, zc->zc_guid, 0, B_FALSE);

	spa_close(spa, FTAG);
	return (error);
	}

	static int
	zfs_ioc_vdev_split(zfs_cmd_t *zc)
	{
	spa_t *spa;
	nvlist_t config, props = NULL;
	int error;
	boolean_t exp = !!(zc->zc_cookie & ZPOOL_EXPORT_AFTER_SPLIT);

	if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
	return (error);

	if ((error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size,
	zc->zc_iflags, &config))) {
	spa_close(spa, FTAG);
	return (error);
	}

	if (zc->zc_nvlist_src_size != 0 && (error =
	get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
	zc->zc_iflags, &props))) {
	spa_close(spa, FTAG);
	nvlist_free(config);
	return (error);
	}

	error = spa_vdev_split_mirror(spa, zc->zc_string, config, props, exp);

	spa_close(spa, FTAG);

	nvlist_free(config);
	nvlist_free(props);

	return (error);
	}

	static int
	zfs_ioc_vdev_setpath(zfs_cmd_t *zc)
	{
	spa_t *spa;
	const char *path = zc->zc_value;
	uint64_t guid = zc->zc_guid;
	int error;

	error = spa_open(zc->zc_name, &spa, FTAG);
	if (error != 0)
	return (error);

	error = spa_vdev_setpath(spa, guid, path);
	spa_close(spa, FTAG);
	return (error);
	}

	static int
	zfs_ioc_vdev_setfru(zfs_cmd_t *zc)
	{
	spa_t *spa;
	const char *fru = zc->zc_value;
	uint64_t guid = zc->zc_guid;
	int error;

	error = spa_open(zc->zc_name, &spa, FTAG);
	if (error != 0)
	return (error);

	error = spa_vdev_setfru(spa, guid, fru);
	spa_close(spa, FTAG);
	return (error);
	}

	static int
	zfs_ioc_objset_stats_impl(zfs_cmd_t zc, objset_t os)
	{
	int error = 0;
	nvlist_t *nv;

	dmu_objset_fast_stat(os, &zc->zc_objset_stats);

	if (zc->zc_nvlist_dst != 0 &&
	(error = dsl_prop_get_all(os, &nv)) == 0) {
	dmu_objset_stats(os, nv);
	/*
	* NB: zvol_get_stats() will read the objset contents,
	* which we aren't supposed to do with a
	* DS_MODE_USER hold, because it could be
	* inconsistent. So this is a bit of a workaround...
	* XXX reading without owning
	*/
	if (!zc->zc_objset_stats.dds_inconsistent &&
	dmu_objset_type(os) == DMU_OST_ZVOL) {
	error = zvol_get_stats(os, nv);
	if (error == EIO) {
	nvlist_free(nv);
	return (error);
	}
	VERIFY0(error);
	}
	if (error == 0)
	error = put_nvlist(zc, nv);
	nvlist_free(nv);
	}

	return (error);
	}

	/*
	* inputs:
	* zc_name name of filesystem
	* zc_nvlist_dst_size size of buffer for property nvlist
	*
	* outputs:
	* zc_objset_stats stats
	* zc_nvlist_dst property nvlist
	* zc_nvlist_dst_size size of property nvlist
	*/
	static int
	zfs_ioc_objset_stats(zfs_cmd_t *zc)
	{
	objset_t *os;
	int error;

	error = dmu_objset_hold(zc->zc_name, FTAG, &os);
	if (error == 0) {
	error = zfs_ioc_objset_stats_impl(zc, os);
	dmu_objset_rele(os, FTAG);
	}

	return (error);
	}

	/*
	* inputs:
	* zc_name name of filesystem
	* zc_nvlist_dst_size size of buffer for property nvlist
	*
	* outputs:
	* zc_nvlist_dst received property nvlist
	* zc_nvlist_dst_size size of received property nvlist
	*
	* Gets received properties (distinct from local properties on or after
	* SPA_VERSION_RECVD_PROPS) for callers who want to differentiate received from
	* local property values.
	*/
	static int
	zfs_ioc_objset_recvd_props(zfs_cmd_t *zc)
	{
	int error = 0;
	nvlist_t *nv;

	/*
	* Without this check, we would return local property values if the
	* caller has not already received properties on or after
	* SPA_VERSION_RECVD_PROPS.
	*/
	if (!dsl_prop_get_hasrecvd(zc->zc_name))
	return (SET_ERROR(ENOTSUP));

	if (zc->zc_nvlist_dst != 0 &&
	(error = dsl_prop_get_received(zc->zc_name, &nv)) == 0) {
	error = put_nvlist(zc, nv);
	nvlist_free(nv);
	}

	return (error);
	}

	static int
	nvl_add_zplprop(objset_t os, nvlist_t props, zfs_prop_t prop)
	{
	uint64_t value;
	int error;

	/*
	* zfs_get_zplprop() will either find a value or give us
	* the default value (if there is one).
	*/
	if ((error = zfs_get_zplprop(os, prop, &value)) != 0)
	return (error);
	VERIFY(nvlist_add_uint64(props, zfs_prop_to_name(prop), value) == 0);
	return (0);
	}

	/*
	* inputs:
	* zc_name name of filesystem
	* zc_nvlist_dst_size size of buffer for zpl property nvlist
	*
	* outputs:
	* zc_nvlist_dst zpl property nvlist
	* zc_nvlist_dst_size size of zpl property nvlist
	*/
	static int
	zfs_ioc_objset_zplprops(zfs_cmd_t *zc)
	{
	objset_t *os;
	int err;

	/* XXX reading without owning */
	if ((err = dmu_objset_hold(zc->zc_name, FTAG, &os)))
	return (err);

	dmu_objset_fast_stat(os, &zc->zc_objset_stats);

	/*
	* NB: nvl_add_zplprop() will read the objset contents,
	* which we aren't supposed to do with a DS_MODE_USER
	* hold, because it could be inconsistent.
	*/
	if (zc->zc_nvlist_dst != 0 &&
	!zc->zc_objset_stats.dds_inconsistent &&
	dmu_objset_type(os) == DMU_OST_ZFS) {
	nvlist_t *nv;

	VERIFY(nvlist_alloc(&nv, NV_UNIQUE_NAME, KM_SLEEP) == 0);
	if ((err = nvl_add_zplprop(os, nv, ZFS_PROP_VERSION)) == 0 &&
	(err = nvl_add_zplprop(os, nv, ZFS_PROP_NORMALIZE)) == 0 &&
	(err = nvl_add_zplprop(os, nv, ZFS_PROP_UTF8ONLY)) == 0 &&
	(err = nvl_add_zplprop(os, nv, ZFS_PROP_CASE)) == 0)
	err = put_nvlist(zc, nv);
	nvlist_free(nv);
	} else {
	err = SET_ERROR(ENOENT);
	}
	dmu_objset_rele(os, FTAG);
	return (err);
	}

	/*
	* inputs:
	* zc_name name of filesystem
	* zc_cookie zap cursor
	* zc_nvlist_dst_size size of buffer for property nvlist
	*
	* outputs:
	* zc_name name of next filesystem
	* zc_cookie zap cursor
	* zc_objset_stats stats
	* zc_nvlist_dst property nvlist
	* zc_nvlist_dst_size size of property nvlist
	*/
	static int
	zfs_ioc_dataset_list_next(zfs_cmd_t *zc)
	{
	objset_t *os;
	int error;
	char *p;
	size_t orig_len = strlen(zc->zc_name);

	top:
	if ((error = dmu_objset_hold(zc->zc_name, FTAG, &os))) {
	if (error == ENOENT)
	error = SET_ERROR(ESRCH);
	return (error);
	}

	p = strrchr(zc->zc_name, '/');
	if (p == NULL \|\| p[1] != '\0')
	(void) strlcat(zc->zc_name, "/", sizeof (zc->zc_name));
	p = zc->zc_name + strlen(zc->zc_name);

	do {
	error = dmu_dir_list_next(os,
	sizeof (zc->zc_name) - (p - zc->zc_name), p,
	NULL, &zc->zc_cookie);
	if (error == ENOENT)
	error = SET_ERROR(ESRCH);
	} while (error == 0 && zfs_dataset_name_hidden(zc->zc_name));
	dmu_objset_rele(os, FTAG);

	/*
	* If it's an internal dataset (ie. with a '$' in its name),
	* don't try to get stats for it, otherwise we'll return ENOENT.
	*/
	if (error == 0 && strchr(zc->zc_name, '$') == NULL) {
	error = zfs_ioc_objset_stats(zc); /* fill in the stats */
	if (error == ENOENT) {
	/* We lost a race with destroy, get the next one. */
	zc->zc_name[orig_len] = '\0';
	goto top;
	}
	}
	return (error);
	}

	/*
	* inputs:
	* zc_name name of filesystem
	* zc_cookie zap cursor
	* zc_nvlist_src iteration range nvlist
	* zc_nvlist_src_size size of iteration range nvlist
	*
	* outputs:
	* zc_name name of next snapshot
	* zc_objset_stats stats
	* zc_nvlist_dst property nvlist
	* zc_nvlist_dst_size size of property nvlist
	*/
	static int
	zfs_ioc_snapshot_list_next(zfs_cmd_t *zc)
	{
	int error;
	objset_t os, ossnap;
	dsl_dataset_t *ds;
	uint64_t min_txg = 0, max_txg = 0;

	if (zc->zc_nvlist_src_size != 0) {
	nvlist_t *props = NULL;
	error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
	zc->zc_iflags, &props);
	if (error != 0)
	return (error);
	(void) nvlist_lookup_uint64(props, SNAP_ITER_MIN_TXG,
	&min_txg);
	(void) nvlist_lookup_uint64(props, SNAP_ITER_MAX_TXG,
	&max_txg);
	nvlist_free(props);
	}

	error = dmu_objset_hold(zc->zc_name, FTAG, &os);
	if (error != 0) {
	return (error == ENOENT ? SET_ERROR(ESRCH) : error);
	}

	/*
	* A dataset name of maximum length cannot have any snapshots,
	* so exit immediately.
	*/
	if (strlcat(zc->zc_name, "@", sizeof (zc->zc_name)) >=
	ZFS_MAX_DATASET_NAME_LEN) {
	dmu_objset_rele(os, FTAG);
	return (SET_ERROR(ESRCH));
	}

	while (error == 0) {
	if (issig(JUSTLOOKING) && issig(FORREAL)) {
	error = SET_ERROR(EINTR);
	break;
	}

	error = dmu_snapshot_list_next(os,
	sizeof (zc->zc_name) - strlen(zc->zc_name),
	zc->zc_name + strlen(zc->zc_name), &zc->zc_obj,
	&zc->zc_cookie, NULL);
	if (error == ENOENT) {
	error = SET_ERROR(ESRCH);
	break;
	} else if (error != 0) {
	break;
	}

	error = dsl_dataset_hold_obj(dmu_objset_pool(os), zc->zc_obj,
	FTAG, &ds);
	if (error != 0)
	break;

	if ((min_txg != 0 && dsl_get_creationtxg(ds) < min_txg) \|\|
	(max_txg != 0 && dsl_get_creationtxg(ds) > max_txg)) {
	dsl_dataset_rele(ds, FTAG);
	/* undo snapshot name append */
	*(strchr(zc->zc_name, '@') + 1) = '\0';
	/* skip snapshot */
	continue;
	}

	if (zc->zc_simple) {
	dsl_dataset_rele(ds, FTAG);
	break;
	}

	if ((error = dmu_objset_from_ds(ds, &ossnap)) != 0) {
	dsl_dataset_rele(ds, FTAG);
	break;
	}
	if ((error = zfs_ioc_objset_stats_impl(zc, ossnap)) != 0) {
	dsl_dataset_rele(ds, FTAG);
	break;
	}
	dsl_dataset_rele(ds, FTAG);
	break;
	}

	dmu_objset_rele(os, FTAG);
	/* if we failed, undo the @ that we tacked on to zc_name */
	if (error != 0)
	*strchr(zc->zc_name, '@') = '\0';
	return (error);
	}

	static int
	zfs_prop_set_userquota(const char dsname, nvpair_t pair)
	{
	const char *propname = nvpair_name(pair);
	uint64_t *valary;
	unsigned int vallen;
	const char dash, domain;
	zfs_userquota_prop_t type;
	uint64_t rid;
	uint64_t quota;
	zfsvfs_t *zfsvfs;
	int err;

	if (nvpair_type(pair) == DATA_TYPE_NVLIST) {
	nvlist_t *attrs;
	VERIFY(nvpair_value_nvlist(pair, &attrs) == 0);
	if (nvlist_lookup_nvpair(attrs, ZPROP_VALUE,
	&pair) != 0)
	return (SET_ERROR(EINVAL));
	}

	/*
	* A correctly constructed propname is encoded as
	* userquota@<rid>-<domain>.
	*/
	if ((dash = strchr(propname, '-')) == NULL \|\|
	nvpair_value_uint64_array(pair, &valary, &vallen) != 0 \|\|
	vallen != 3)
	return (SET_ERROR(EINVAL));

	domain = dash + 1;
	type = valary[0];
	rid = valary[1];
	quota = valary[2];

	err = zfsvfs_hold(dsname, FTAG, &zfsvfs, B_FALSE);
	if (err == 0) {
	err = zfs_set_userquota(zfsvfs, type, domain, rid, quota);
	zfsvfs_rele(zfsvfs, FTAG);
	}

	return (err);
	}

	/*
	* If the named property is one that has a special function to set its value,
	* return 0 on success and a positive error code on failure; otherwise if it is
	* not one of the special properties handled by this function, return -1.
	*
	* XXX: It would be better for callers of the property interface if we handled
	* these special cases in dsl_prop.c (in the dsl layer).
	*/
	static int
	zfs_prop_set_special(const char *dsname, zprop_source_t source,
	nvpair_t *pair)
	{
	const char *propname = nvpair_name(pair);
	zfs_prop_t prop = zfs_name_to_prop(propname);
	uint64_t intval = 0;
	const char *strval = NULL;
	int err = -1;

	if (prop == ZPROP_INVAL) {
	if (zfs_prop_userquota(propname))
	return (zfs_prop_set_userquota(dsname, pair));
	return (-1);
	}

	if (nvpair_type(pair) == DATA_TYPE_NVLIST) {
	nvlist_t *attrs;
	VERIFY(nvpair_value_nvlist(pair, &attrs) == 0);
	VERIFY(nvlist_lookup_nvpair(attrs, ZPROP_VALUE,
	&pair) == 0);
	}

	/* all special properties are numeric except for keylocation */
	if (zfs_prop_get_type(prop) == PROP_TYPE_STRING) {
	strval = fnvpair_value_string(pair);
	} else {
	intval = fnvpair_value_uint64(pair);
	}

	switch (prop) {
	case ZFS_PROP_QUOTA:
	err = dsl_dir_set_quota(dsname, source, intval);
	break;
	case ZFS_PROP_REFQUOTA:
	err = dsl_dataset_set_refquota(dsname, source, intval);
	break;
	case ZFS_PROP_FILESYSTEM_LIMIT:
	case ZFS_PROP_SNAPSHOT_LIMIT:
	if (intval == UINT64_MAX) {
	/* clearing the limit, just do it */
	err = 0;
	} else {
	err = dsl_dir_activate_fs_ss_limit(dsname);
	}
	/*
	* Set err to -1 to force the zfs_set_prop_nvlist code down the
	* default path to set the value in the nvlist.
	*/
	if (err == 0)
	err = -1;
	break;
	case ZFS_PROP_KEYLOCATION:
	err = dsl_crypto_can_set_keylocation(dsname, strval);

	/*
	* Set err to -1 to force the zfs_set_prop_nvlist code down the
	* default path to set the value in the nvlist.
	*/
	if (err == 0)
	err = -1;
	break;
	case ZFS_PROP_RESERVATION:
	err = dsl_dir_set_reservation(dsname, source, intval);
	break;
	case ZFS_PROP_REFRESERVATION:
	err = dsl_dataset_set_refreservation(dsname, source, intval);
	break;
	case ZFS_PROP_COMPRESSION:
	err = dsl_dataset_set_compression(dsname, source, intval);
	/*
	* Set err to -1 to force the zfs_set_prop_nvlist code down the
	* default path to set the value in the nvlist.
	*/
	if (err == 0)
	err = -1;
	break;
	case ZFS_PROP_VOLSIZE:
	err = zvol_set_volsize(dsname, intval);
	break;
	case ZFS_PROP_SNAPDEV:
	err = zvol_set_snapdev(dsname, source, intval);
	break;
	case ZFS_PROP_VOLMODE:
	err = zvol_set_volmode(dsname, source, intval);
	break;
	case ZFS_PROP_VERSION:
	{
	zfsvfs_t *zfsvfs;

	if ((err = zfsvfs_hold(dsname, FTAG, &zfsvfs, B_TRUE)) != 0)
	break;

	err = zfs_set_version(zfsvfs, intval);
	zfsvfs_rele(zfsvfs, FTAG);

	if (err == 0 && intval >= ZPL_VERSION_USERSPACE) {
	zfs_cmd_t *zc;

	zc = kmem_zalloc(sizeof (zfs_cmd_t), KM_SLEEP);
	(void) strlcpy(zc->zc_name, dsname,
	sizeof (zc->zc_name));
	(void) zfs_ioc_userspace_upgrade(zc);
	(void) zfs_ioc_id_quota_upgrade(zc);
	kmem_free(zc, sizeof (zfs_cmd_t));
	}
	break;
	}
	default:
	err = -1;
	}

	return (err);
	}

	/*
	* This function is best effort. If it fails to set any of the given properties,
	* it continues to set as many as it can and returns the last error
	* encountered. If the caller provides a non-NULL errlist, it will be filled in
	* with the list of names of all the properties that failed along with the
	* corresponding error numbers.
	*
	* If every property is set successfully, zero is returned and errlist is not
	* modified.
	*/
	int
	zfs_set_prop_nvlist(const char dsname, zprop_source_t source, nvlist_t nvl,
	nvlist_t *errlist)
	{
	nvpair_t *pair;
	nvpair_t *propval;
	int rv = 0;
	uint64_t intval;
	const char *strval;

	nvlist_t *genericnvl = fnvlist_alloc();
	nvlist_t *retrynvl = fnvlist_alloc();
	retry:
	pair = NULL;
	while ((pair = nvlist_next_nvpair(nvl, pair)) != NULL) {
	const char *propname = nvpair_name(pair);
	zfs_prop_t prop = zfs_name_to_prop(propname);
	int err = 0;

	/* decode the property value */
	propval = pair;
	if (nvpair_type(pair) == DATA_TYPE_NVLIST) {
	nvlist_t *attrs;
	attrs = fnvpair_value_nvlist(pair);
	if (nvlist_lookup_nvpair(attrs, ZPROP_VALUE,
	&propval) != 0)
	err = SET_ERROR(EINVAL);
	}

	/* Validate value type */
	if (err == 0 && source == ZPROP_SRC_INHERITED) {
	/* inherited properties are expected to be booleans */
	if (nvpair_type(propval) != DATA_TYPE_BOOLEAN)
	err = SET_ERROR(EINVAL);
	} else if (err == 0 && prop == ZPROP_INVAL) {
	if (zfs_prop_user(propname)) {
	if (nvpair_type(propval) != DATA_TYPE_STRING)
	err = SET_ERROR(EINVAL);
	} else if (zfs_prop_userquota(propname)) {
	if (nvpair_type(propval) !=
	DATA_TYPE_UINT64_ARRAY)
	err = SET_ERROR(EINVAL);
	} else {
	err = SET_ERROR(EINVAL);
	}
	} else if (err == 0) {
	if (nvpair_type(propval) == DATA_TYPE_STRING) {
	if (zfs_prop_get_type(prop) != PROP_TYPE_STRING)
	err = SET_ERROR(EINVAL);
	} else if (nvpair_type(propval) == DATA_TYPE_UINT64) {
	const char *unused;

	intval = fnvpair_value_uint64(propval);

	switch (zfs_prop_get_type(prop)) {
	case PROP_TYPE_NUMBER:
	break;
	case PROP_TYPE_STRING:
	err = SET_ERROR(EINVAL);
	break;
	case PROP_TYPE_INDEX:
	if (zfs_prop_index_to_string(prop,
	intval, &unused) != 0)
	err =
	SET_ERROR(ZFS_ERR_BADPROP);
	break;
	default:
	cmn_err(CE_PANIC,
	"unknown property type");
	}
	} else {
	err = SET_ERROR(EINVAL);
	}
	}

	/* Validate permissions */
	if (err == 0)
	err = zfs_check_settable(dsname, pair, CRED());

	if (err == 0) {
	if (source == ZPROP_SRC_INHERITED)
	err = -1; /* does not need special handling */
	else
	err = zfs_prop_set_special(dsname, source,
	pair);
	if (err == -1) {
	/*
	* For better performance we build up a list of
	* properties to set in a single transaction.
	*/
	err = nvlist_add_nvpair(genericnvl, pair);
	} else if (err != 0 && nvl != retrynvl) {
	/*
	* This may be a spurious error caused by
	* receiving quota and reservation out of order.
	* Try again in a second pass.
	*/
	err = nvlist_add_nvpair(retrynvl, pair);
	}
	}

	if (err != 0) {
	if (errlist != NULL)
	fnvlist_add_int32(errlist, propname, err);
	rv = err;
	}
	}

	if (nvl != retrynvl && !nvlist_empty(retrynvl)) {
	nvl = retrynvl;
	goto retry;
	}

	if (!nvlist_empty(genericnvl) &&
	dsl_props_set(dsname, source, genericnvl) != 0) {
	/*
	* If this fails, we still want to set as many properties as we
	* can, so try setting them individually.
	*/
	pair = NULL;
	while ((pair = nvlist_next_nvpair(genericnvl, pair)) != NULL) {
	const char *propname = nvpair_name(pair);
	int err = 0;

	propval = pair;
	if (nvpair_type(pair) == DATA_TYPE_NVLIST) {
	nvlist_t *attrs;
	attrs = fnvpair_value_nvlist(pair);
	propval = fnvlist_lookup_nvpair(attrs,
	ZPROP_VALUE);
	}

	if (nvpair_type(propval) == DATA_TYPE_STRING) {
	strval = fnvpair_value_string(propval);
	err = dsl_prop_set_string(dsname, propname,
	source, strval);
	} else if (nvpair_type(propval) == DATA_TYPE_BOOLEAN) {
	err = dsl_prop_inherit(dsname, propname,
	source);
	} else {
	intval = fnvpair_value_uint64(propval);
	err = dsl_prop_set_int(dsname, propname, source,
	intval);
	}

	if (err != 0) {
	if (errlist != NULL) {
	fnvlist_add_int32(errlist, propname,
	err);
	}
	rv = err;
	}
	}
	}
	nvlist_free(genericnvl);
	nvlist_free(retrynvl);

	return (rv);
	}

	/*
	* Check that all the properties are valid user properties.
	*/
	static int
	zfs_check_userprops(nvlist_t *nvl)
	{
	nvpair_t *pair = NULL;

	while ((pair = nvlist_next_nvpair(nvl, pair)) != NULL) {
	const char *propname = nvpair_name(pair);

	if (!zfs_prop_user(propname) \|\|
	nvpair_type(pair) != DATA_TYPE_STRING)
	return (SET_ERROR(EINVAL));

	if (strlen(propname) >= ZAP_MAXNAMELEN)
	return (SET_ERROR(ENAMETOOLONG));

	if (strlen(fnvpair_value_string(pair)) >= ZAP_MAXVALUELEN)
	return (SET_ERROR(E2BIG));
	}
	return (0);
	}

	static void
	props_skip(nvlist_t props, nvlist_t skipped, nvlist_t **newprops)
	{
	nvpair_t *pair;

	VERIFY(nvlist_alloc(newprops, NV_UNIQUE_NAME, KM_SLEEP) == 0);

	pair = NULL;
	while ((pair = nvlist_next_nvpair(props, pair)) != NULL) {
	if (nvlist_exists(skipped, nvpair_name(pair)))
	continue;

	VERIFY(nvlist_add_nvpair(*newprops, pair) == 0);
	}
	}

	static int
	clear_received_props(const char dsname, nvlist_t props,
	nvlist_t *skipped)
	{
	int err = 0;
	nvlist_t *cleared_props = NULL;
	props_skip(props, skipped, &cleared_props);
	if (!nvlist_empty(cleared_props)) {
	/*
	* Acts on local properties until the dataset has received
	* properties at least once on or after SPA_VERSION_RECVD_PROPS.
	*/
	zprop_source_t flags = (ZPROP_SRC_NONE \|
	(dsl_prop_get_hasrecvd(dsname) ? ZPROP_SRC_RECEIVED : 0));
	err = zfs_set_prop_nvlist(dsname, flags, cleared_props, NULL);
	}
	nvlist_free(cleared_props);
	return (err);
	}

	/*
	* inputs:
	* zc_name name of filesystem
	* zc_value name of property to set
	* zc_nvlist_src{_size} nvlist of properties to apply
	* zc_cookie received properties flag
	*
	* outputs:
	* zc_nvlist_dst{_size} error for each unapplied received property
	*/
	static int
	zfs_ioc_set_prop(zfs_cmd_t *zc)
	{
	nvlist_t *nvl;
	boolean_t received = zc->zc_cookie;
	zprop_source_t source = (received ? ZPROP_SRC_RECEIVED :
	ZPROP_SRC_LOCAL);
	nvlist_t *errors;
	int error;

	if ((error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
	zc->zc_iflags, &nvl)) != 0)
	return (error);

	if (received) {
	nvlist_t *origprops;

	if (dsl_prop_get_received(zc->zc_name, &origprops) == 0) {
	(void) clear_received_props(zc->zc_name,
	origprops, nvl);
	nvlist_free(origprops);
	}

	error = dsl_prop_set_hasrecvd(zc->zc_name);
	}

	errors = fnvlist_alloc();
	if (error == 0)
	error = zfs_set_prop_nvlist(zc->zc_name, source, nvl, errors);

	if (zc->zc_nvlist_dst != 0 && errors != NULL) {
	(void) put_nvlist(zc, errors);
	}

	nvlist_free(errors);
	nvlist_free(nvl);
	return (error);
	}

	/*
	* inputs:
	* zc_name name of filesystem
	* zc_value name of property to inherit
	* zc_cookie revert to received value if TRUE
	*
	* outputs: none
	*/
	static int
	zfs_ioc_inherit_prop(zfs_cmd_t *zc)
	{
	const char *propname = zc->zc_value;
	zfs_prop_t prop = zfs_name_to_prop(propname);
	boolean_t received = zc->zc_cookie;
	zprop_source_t source = (received
	? ZPROP_SRC_NONE /* revert to received value, if any */
	: ZPROP_SRC_INHERITED); /* explicitly inherit */
	nvlist_t *dummy;
	nvpair_t *pair;
	zprop_type_t type;
	int err;

	if (!received) {
	/*
	* Only check this in the non-received case. We want to allow
	* 'inherit -S' to revert non-inheritable properties like quota
	* and reservation to the received or default values even though
	* they are not considered inheritable.
	*/
	if (prop != ZPROP_INVAL && !zfs_prop_inheritable(prop))
	return (SET_ERROR(EINVAL));
	}

	if (prop == ZPROP_INVAL) {
	if (!zfs_prop_user(propname))
	return (SET_ERROR(EINVAL));

	type = PROP_TYPE_STRING;
	} else if (prop == ZFS_PROP_VOLSIZE \|\| prop == ZFS_PROP_VERSION) {
	return (SET_ERROR(EINVAL));
	} else {
	type = zfs_prop_get_type(prop);
	}

	/*
	* zfs_prop_set_special() expects properties in the form of an
	* nvpair with type info.
	*/
	dummy = fnvlist_alloc();

	switch (type) {
	case PROP_TYPE_STRING:
	VERIFY(0 == nvlist_add_string(dummy, propname, ""));
	break;
	case PROP_TYPE_NUMBER:
	case PROP_TYPE_INDEX:
	VERIFY(0 == nvlist_add_uint64(dummy, propname, 0));
	break;
	default:
	err = SET_ERROR(EINVAL);
	goto errout;
	}

	pair = nvlist_next_nvpair(dummy, NULL);
	if (pair == NULL) {
	err = SET_ERROR(EINVAL);
	} else {
	err = zfs_prop_set_special(zc->zc_name, source, pair);
	if (err == -1) /* property is not "special", needs handling */
	err = dsl_prop_inherit(zc->zc_name, zc->zc_value,
	source);
	}

	errout:
	nvlist_free(dummy);
	return (err);
	}

	static int
	zfs_ioc_pool_set_props(zfs_cmd_t *zc)
	{
	nvlist_t *props;
	spa_t *spa;
	int error;
	nvpair_t *pair;

	if ((error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
	zc->zc_iflags, &props)))
	return (error);

	/*
	* If the only property is the configfile, then just do a spa_lookup()
	* to handle the faulted case.
	*/
	pair = nvlist_next_nvpair(props, NULL);
	if (pair != NULL && strcmp(nvpair_name(pair),
	zpool_prop_to_name(ZPOOL_PROP_CACHEFILE)) == 0 &&
	nvlist_next_nvpair(props, pair) == NULL) {
	mutex_enter(&spa_namespace_lock);
	if ((spa = spa_lookup(zc->zc_name)) != NULL) {
	spa_configfile_set(spa, props, B_FALSE);
	spa_write_cachefile(spa, B_FALSE, B_TRUE);
	}
	mutex_exit(&spa_namespace_lock);
	if (spa != NULL) {
	nvlist_free(props);
	return (0);
	}
	}

	if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0) {
	nvlist_free(props);
	return (error);
	}

	error = spa_prop_set(spa, props);

	nvlist_free(props);
	spa_close(spa, FTAG);

	return (error);
	}

	static int
	zfs_ioc_pool_get_props(zfs_cmd_t *zc)
	{
	spa_t *spa;
	int error;
	nvlist_t *nvp = NULL;

	if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0) {
	/*
	* If the pool is faulted, there may be properties we can still
	* get (such as altroot and cachefile), so attempt to get them
	* anyway.
	*/
	mutex_enter(&spa_namespace_lock);
	if ((spa = spa_lookup(zc->zc_name)) != NULL)
	error = spa_prop_get(spa, &nvp);
	mutex_exit(&spa_namespace_lock);
	} else {
	error = spa_prop_get(spa, &nvp);
	spa_close(spa, FTAG);
	}

	if (error == 0 && zc->zc_nvlist_dst != 0)
	error = put_nvlist(zc, nvp);
	else
	error = SET_ERROR(EFAULT);

	nvlist_free(nvp);
	return (error);
	}

	/*
	* inputs:
	* zc_name name of filesystem
	* zc_nvlist_src{_size} nvlist of delegated permissions
	* zc_perm_action allow/unallow flag
	*
	* outputs: none
	*/
	static int
	zfs_ioc_set_fsacl(zfs_cmd_t *zc)
	{
	int error;
	nvlist_t *fsaclnv = NULL;

	if ((error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
	zc->zc_iflags, &fsaclnv)) != 0)
	return (error);

	/*
	* Verify nvlist is constructed correctly
	*/
	if ((error = zfs_deleg_verify_nvlist(fsaclnv)) != 0) {
	nvlist_free(fsaclnv);
	return (SET_ERROR(EINVAL));
	}

	/*
	* If we don't have PRIV_SYS_MOUNT, then validate
	* that user is allowed to hand out each permission in
	* the nvlist(s)
	*/

	error = secpolicy_zfs(CRED());
	if (error != 0) {
	if (zc->zc_perm_action == B_FALSE) {
	error = dsl_deleg_can_allow(zc->zc_name,
	fsaclnv, CRED());
	} else {
	error = dsl_deleg_can_unallow(zc->zc_name,
	fsaclnv, CRED());
	}
	}

	if (error == 0)
	error = dsl_deleg_set(zc->zc_name, fsaclnv, zc->zc_perm_action);

	nvlist_free(fsaclnv);
	return (error);
	}

	/*
	* inputs:
	* zc_name name of filesystem
	*
	* outputs:
	* zc_nvlist_src{_size} nvlist of delegated permissions
	*/
	static int
	zfs_ioc_get_fsacl(zfs_cmd_t *zc)
	{
	nvlist_t *nvp;
	int error;

	if ((error = dsl_deleg_get(zc->zc_name, &nvp)) == 0) {
	error = put_nvlist(zc, nvp);
	nvlist_free(nvp);
	}

	return (error);
	}

	/* ARGSUSED */
	static void
	zfs_create_cb(objset_t os, void arg, cred_t cr, dmu_tx_t tx)
	{
	zfs_creat_t *zct = arg;

	zfs_create_fs(os, cr, zct->zct_zplprops, tx);
	}

	#define ZFS_PROP_UNDEFINED ((uint64_t)-1)

	/*
	* inputs:
	* os parent objset pointer (NULL if root fs)
	* fuids_ok fuids allowed in this version of the spa?
	* sa_ok SAs allowed in this version of the spa?
	* createprops list of properties requested by creator
	*
	* outputs:
	* zplprops values for the zplprops we attach to the master node object
	* is_ci true if requested file system will be purely case-insensitive
	*
	* Determine the settings for utf8only, normalization and
	* casesensitivity. Specific values may have been requested by the
	* creator and/or we can inherit values from the parent dataset. If
	* the file system is of too early a vintage, a creator can not
	* request settings for these properties, even if the requested
	* setting is the default value. We don't actually want to create dsl
	* properties for these, so remove them from the source nvlist after
	* processing.
	*/
	static int
	zfs_fill_zplprops_impl(objset_t *os, uint64_t zplver,
	boolean_t fuids_ok, boolean_t sa_ok, nvlist_t *createprops,
	nvlist_t zplprops, boolean_t is_ci)
	{
	uint64_t sense = ZFS_PROP_UNDEFINED;
	uint64_t norm = ZFS_PROP_UNDEFINED;
	uint64_t u8 = ZFS_PROP_UNDEFINED;
	int error;

	ASSERT(zplprops != NULL);

	/* parent dataset must be a filesystem */
	if (os != NULL && os->os_phys->os_type != DMU_OST_ZFS)
	return (SET_ERROR(ZFS_ERR_WRONG_PARENT));

	/*
	* Pull out creator prop choices, if any.
	*/
	if (createprops) {
	(void) nvlist_lookup_uint64(createprops,
	zfs_prop_to_name(ZFS_PROP_VERSION), &zplver);
	(void) nvlist_lookup_uint64(createprops,
	zfs_prop_to_name(ZFS_PROP_NORMALIZE), &norm);
	(void) nvlist_remove_all(createprops,
	zfs_prop_to_name(ZFS_PROP_NORMALIZE));
	(void) nvlist_lookup_uint64(createprops,
	zfs_prop_to_name(ZFS_PROP_UTF8ONLY), &u8);
	(void) nvlist_remove_all(createprops,
	zfs_prop_to_name(ZFS_PROP_UTF8ONLY));
	(void) nvlist_lookup_uint64(createprops,
	zfs_prop_to_name(ZFS_PROP_CASE), &sense);
	(void) nvlist_remove_all(createprops,
	zfs_prop_to_name(ZFS_PROP_CASE));
	}

	/*
	* If the zpl version requested is whacky or the file system
	* or pool is version is too "young" to support normalization
	* and the creator tried to set a value for one of the props,
	* error out.
	*/
	if ((zplver < ZPL_VERSION_INITIAL \|\| zplver > ZPL_VERSION) \|\|
	(zplver >= ZPL_VERSION_FUID && !fuids_ok) \|\|
	(zplver >= ZPL_VERSION_SA && !sa_ok) \|\|
	(zplver < ZPL_VERSION_NORMALIZATION &&
	(norm != ZFS_PROP_UNDEFINED \|\| u8 != ZFS_PROP_UNDEFINED \|\|
	sense != ZFS_PROP_UNDEFINED)))
	return (SET_ERROR(ENOTSUP));

	/*
	* Put the version in the zplprops
	*/
	VERIFY(nvlist_add_uint64(zplprops,
	zfs_prop_to_name(ZFS_PROP_VERSION), zplver) == 0);

	if (norm == ZFS_PROP_UNDEFINED &&
	(error = zfs_get_zplprop(os, ZFS_PROP_NORMALIZE, &norm)) != 0)
	return (error);
	VERIFY(nvlist_add_uint64(zplprops,
	zfs_prop_to_name(ZFS_PROP_NORMALIZE), norm) == 0);

	/*
	* If we're normalizing, names must always be valid UTF-8 strings.
	*/
	if (norm)
	u8 = 1;
	if (u8 == ZFS_PROP_UNDEFINED &&
	(error = zfs_get_zplprop(os, ZFS_PROP_UTF8ONLY, &u8)) != 0)
	return (error);
	VERIFY(nvlist_add_uint64(zplprops,
	zfs_prop_to_name(ZFS_PROP_UTF8ONLY), u8) == 0);

	if (sense == ZFS_PROP_UNDEFINED &&
	(error = zfs_get_zplprop(os, ZFS_PROP_CASE, &sense)) != 0)
	return (error);
	VERIFY(nvlist_add_uint64(zplprops,
	zfs_prop_to_name(ZFS_PROP_CASE), sense) == 0);

	if (is_ci)
	*is_ci = (sense == ZFS_CASE_INSENSITIVE);

	return (0);
	}

	static int
	zfs_fill_zplprops(const char dataset, nvlist_t createprops,
	nvlist_t zplprops, boolean_t is_ci)
	{
	boolean_t fuids_ok, sa_ok;
	uint64_t zplver = ZPL_VERSION;
	objset_t *os = NULL;
	char parentname[ZFS_MAX_DATASET_NAME_LEN];
	spa_t *spa;
	uint64_t spa_vers;
	int error;

	zfs_get_parent(dataset, parentname, sizeof (parentname));

	if ((error = spa_open(dataset, &spa, FTAG)) != 0)
	return (error);

	spa_vers = spa_version(spa);
	spa_close(spa, FTAG);

	zplver = zfs_zpl_version_map(spa_vers);
	fuids_ok = (zplver >= ZPL_VERSION_FUID);
	sa_ok = (zplver >= ZPL_VERSION_SA);

	/*
	* Open parent object set so we can inherit zplprop values.
	*/
	if ((error = dmu_objset_hold(parentname, FTAG, &os)) != 0)
	return (error);

	error = zfs_fill_zplprops_impl(os, zplver, fuids_ok, sa_ok, createprops,
	zplprops, is_ci);
	dmu_objset_rele(os, FTAG);
	return (error);
	}

	static int
	zfs_fill_zplprops_root(uint64_t spa_vers, nvlist_t *createprops,
	nvlist_t zplprops, boolean_t is_ci)
	{
	boolean_t fuids_ok;
	boolean_t sa_ok;
	uint64_t zplver = ZPL_VERSION;
	int error;

	zplver = zfs_zpl_version_map(spa_vers);
	fuids_ok = (zplver >= ZPL_VERSION_FUID);
	sa_ok = (zplver >= ZPL_VERSION_SA);

	error = zfs_fill_zplprops_impl(NULL, zplver, fuids_ok, sa_ok,
	createprops, zplprops, is_ci);
	return (error);
	}

	/*
	* innvl: {
	* "type" -> dmu_objset_type_t (int32)
	* (optional) "props" -> { prop -> value }
	* (optional) "hidden_args" -> { "wkeydata" -> value }
	* raw uint8_t array of encryption wrapping key data (32 bytes)
	* }
	*
	* outnvl: propname -> error code (int32)
	*/

	static const zfs_ioc_key_t zfs_keys_create[] = {
	{"type", DATA_TYPE_INT32, 0},
	{"props", DATA_TYPE_NVLIST, ZK_OPTIONAL},
	{"hidden_args", DATA_TYPE_NVLIST, ZK_OPTIONAL},
	};

	static int
	zfs_ioc_create(const char fsname, nvlist_t innvl, nvlist_t *outnvl)
	{
	int error = 0;
	zfs_creat_t zct = { 0 };
	nvlist_t *nvprops = NULL;
	nvlist_t *hidden_args = NULL;
	void (cbfunc)(objset_t os, void arg, cred_t cr, dmu_tx_t *tx);
	dmu_objset_type_t type;
	boolean_t is_insensitive = B_FALSE;
	dsl_crypto_params_t *dcp = NULL;

	type = (dmu_objset_type_t)fnvlist_lookup_int32(innvl, "type");
	(void) nvlist_lookup_nvlist(innvl, "props", &nvprops);
	(void) nvlist_lookup_nvlist(innvl, ZPOOL_HIDDEN_ARGS, &hidden_args);

	switch (type) {
	case DMU_OST_ZFS:
	cbfunc = zfs_create_cb;
	break;

	case DMU_OST_ZVOL:
	cbfunc = zvol_create_cb;
	break;

	default:
	cbfunc = NULL;
	break;
	}
	if (strchr(fsname, '@') \|\|
	strchr(fsname, '%'))
	return (SET_ERROR(EINVAL));

	zct.zct_props = nvprops;

	if (cbfunc == NULL)
	return (SET_ERROR(EINVAL));

	if (type == DMU_OST_ZVOL) {
	uint64_t volsize, volblocksize;

	if (nvprops == NULL)
	return (SET_ERROR(EINVAL));
	if (nvlist_lookup_uint64(nvprops,
	zfs_prop_to_name(ZFS_PROP_VOLSIZE), &volsize) != 0)
	return (SET_ERROR(EINVAL));

	if ((error = nvlist_lookup_uint64(nvprops,
	zfs_prop_to_name(ZFS_PROP_VOLBLOCKSIZE),
	&volblocksize)) != 0 && error != ENOENT)
	return (SET_ERROR(EINVAL));

	if (error != 0)
	volblocksize = zfs_prop_default_numeric(
	ZFS_PROP_VOLBLOCKSIZE);

	if ((error = zvol_check_volblocksize(fsname,
	volblocksize)) != 0 \|\|
	(error = zvol_check_volsize(volsize,
	volblocksize)) != 0)
	return (error);
	} else if (type == DMU_OST_ZFS) {
	int error;

	/*
	* We have to have normalization and
	* case-folding flags correct when we do the
	* file system creation, so go figure them out
	* now.
	*/
	VERIFY(nvlist_alloc(&zct.zct_zplprops,
	NV_UNIQUE_NAME, KM_SLEEP) == 0);
	error = zfs_fill_zplprops(fsname, nvprops,
	zct.zct_zplprops, &is_insensitive);
	if (error != 0) {
	nvlist_free(zct.zct_zplprops);
	return (error);
	}
	}

	error = dsl_crypto_params_create_nvlist(DCP_CMD_NONE, nvprops,
	hidden_args, &dcp);
	if (error != 0) {
	nvlist_free(zct.zct_zplprops);
	return (error);
	}

	error = dmu_objset_create(fsname, type,
	is_insensitive ? DS_FLAG_CI_DATASET : 0, dcp, cbfunc, &zct);

	nvlist_free(zct.zct_zplprops);
	dsl_crypto_params_free(dcp, !!error);

	/*
	* It would be nice to do this atomically.
	*/
	if (error == 0) {
	error = zfs_set_prop_nvlist(fsname, ZPROP_SRC_LOCAL,
	nvprops, outnvl);
	if (error != 0) {
	spa_t *spa;
	int error2;

	/*
	* Volumes will return EBUSY and cannot be destroyed
	* until all asynchronous minor handling (e.g. from
	* setting the volmode property) has completed. Wait for
	* the spa_zvol_taskq to drain then retry.
	*/
	error2 = dsl_destroy_head(fsname);
	while ((error2 == EBUSY) && (type == DMU_OST_ZVOL)) {
	error2 = spa_open(fsname, &spa, FTAG);
	if (error2 == 0) {
	taskq_wait(spa->spa_zvol_taskq);
	spa_close(spa, FTAG);
	}
	error2 = dsl_destroy_head(fsname);
	}
	}
	}
	return (error);
	}

	/*
	* innvl: {
	* "origin" -> name of origin snapshot
	* (optional) "props" -> { prop -> value }
	* (optional) "hidden_args" -> { "wkeydata" -> value }
	* raw uint8_t array of encryption wrapping key data (32 bytes)
	* }
	*
	* outputs:
	* outnvl: propname -> error code (int32)
	*/
	static const zfs_ioc_key_t zfs_keys_clone[] = {
	{"origin", DATA_TYPE_STRING, 0},
	{"props", DATA_TYPE_NVLIST, ZK_OPTIONAL},
	{"hidden_args", DATA_TYPE_NVLIST, ZK_OPTIONAL},
	};

	static int
	zfs_ioc_clone(const char fsname, nvlist_t innvl, nvlist_t *outnvl)
	{
	int error = 0;
	nvlist_t *nvprops = NULL;
	const char *origin_name;

	origin_name = fnvlist_lookup_string(innvl, "origin");
	(void) nvlist_lookup_nvlist(innvl, "props", &nvprops);

	if (strchr(fsname, '@') \|\|
	strchr(fsname, '%'))
	return (SET_ERROR(EINVAL));

	if (dataset_namecheck(origin_name, NULL, NULL) != 0)
	return (SET_ERROR(EINVAL));

	error = dmu_objset_clone(fsname, origin_name);

	/*
	* It would be nice to do this atomically.
	*/
	if (error == 0) {
	error = zfs_set_prop_nvlist(fsname, ZPROP_SRC_LOCAL,
	nvprops, outnvl);
	if (error != 0)
	(void) dsl_destroy_head(fsname);
	}
	return (error);
	}

	static const zfs_ioc_key_t zfs_keys_remap[] = {
	/* no nvl keys */
	};

	/* ARGSUSED */
	static int
	zfs_ioc_remap(const char fsname, nvlist_t innvl, nvlist_t *outnvl)
	{
	/* This IOCTL is no longer supported. */
	return (0);
	}

	/*
	* innvl: {
	* "snaps" -> { snapshot1, snapshot2 }
	* (optional) "props" -> { prop -> value (string) }
	* }
	*
	* outnvl: snapshot -> error code (int32)
	*/
	static const zfs_ioc_key_t zfs_keys_snapshot[] = {
	{"snaps", DATA_TYPE_NVLIST, 0},
	{"props", DATA_TYPE_NVLIST, ZK_OPTIONAL},
	};

	static int
	zfs_ioc_snapshot(const char poolname, nvlist_t innvl, nvlist_t *outnvl)
	{
	nvlist_t *snaps;
	nvlist_t *props = NULL;
	int error, poollen;
	nvpair_t *pair;

	(void) nvlist_lookup_nvlist(innvl, "props", &props);
	if (!nvlist_empty(props) &&
	zfs_earlier_version(poolname, SPA_VERSION_SNAP_PROPS))
	return (SET_ERROR(ENOTSUP));
	if ((error = zfs_check_userprops(props)) != 0)
	return (error);

	snaps = fnvlist_lookup_nvlist(innvl, "snaps");
	poollen = strlen(poolname);
	for (pair = nvlist_next_nvpair(snaps, NULL); pair != NULL;
	pair = nvlist_next_nvpair(snaps, pair)) {
	const char *name = nvpair_name(pair);
	char *cp = strchr(name, '@');

	/*
	* The snap name must contain an @, and the part after it must
	* contain only valid characters.
	*/
	if (cp == NULL \|\|
	zfs_component_namecheck(cp + 1, NULL, NULL) != 0)
	return (SET_ERROR(EINVAL));

	/*
	* The snap must be in the specified pool.
	*/
	if (strncmp(name, poolname, poollen) != 0 \|\|
	(name[poollen] != '/' && name[poollen] != '@'))
	return (SET_ERROR(EXDEV));

	/*
	* Check for permission to set the properties on the fs.
	*/
	if (!nvlist_empty(props)) {
	*cp = '\0';
	error = zfs_secpolicy_write_perms(name,
	ZFS_DELEG_PERM_USERPROP, CRED());
	*cp = '@';
	if (error != 0)
	return (error);
	}

	/* This must be the only snap of this fs. */
	for (nvpair_t *pair2 = nvlist_next_nvpair(snaps, pair);
	pair2 != NULL; pair2 = nvlist_next_nvpair(snaps, pair2)) {
	if (strncmp(name, nvpair_name(pair2), cp - name + 1)
	== 0) {
	return (SET_ERROR(EXDEV));
	}
	}
	}

	error = dsl_dataset_snapshot(snaps, props, outnvl);

	return (error);
	}

	/*
	* innvl: "message" -> string
	*/
	static const zfs_ioc_key_t zfs_keys_log_history[] = {
	{"message", DATA_TYPE_STRING, 0},
	};

	/* ARGSUSED */
	static int
	zfs_ioc_log_history(const char unused, nvlist_t innvl, nvlist_t *outnvl)
	{
	const char *message;
	char *poolname;
	spa_t *spa;
	int error;

	/*
	* The poolname in the ioctl is not set, we get it from the TSD,
	* which was set at the end of the last successful ioctl that allows
	* logging. The secpolicy func already checked that it is set.
	* Only one log ioctl is allowed after each successful ioctl, so
	* we clear the TSD here.
	*/
	poolname = tsd_get(zfs_allow_log_key);
	if (poolname == NULL)
	return (SET_ERROR(EINVAL));
	(void) tsd_set(zfs_allow_log_key, NULL);
	error = spa_open(poolname, &spa, FTAG);
	kmem_strfree(poolname);
	if (error != 0)
	return (error);

	message = fnvlist_lookup_string(innvl, "message");

	if (spa_version(spa) < SPA_VERSION_ZPOOL_HISTORY) {
	spa_close(spa, FTAG);
	return (SET_ERROR(ENOTSUP));
	}

	error = spa_history_log(spa, message);
	spa_close(spa, FTAG);
	return (error);
	}

	/*
	* This ioctl is used to set the bootenv configuration on the current
	* pool. This configuration is stored in the second padding area of the label,
	* and it is used by the bootloader(s) to store the bootloader and/or system
	* specific data.
	* The data is stored as nvlist data stream, and is protected by
	* an embedded checksum.
	* The version can have two possible values:
	* VB_RAW: nvlist should have key GRUB_ENVMAP, value DATA_TYPE_STRING.
	* VB_NVLIST: nvlist with arbitrary <key, value> pairs.
	*/
	static const zfs_ioc_key_t zfs_keys_set_bootenv[] = {
	{"version", DATA_TYPE_UINT64, 0},
	{"<keys>", DATA_TYPE_ANY, ZK_OPTIONAL \| ZK_WILDCARDLIST},
	};

	static int
	zfs_ioc_set_bootenv(const char name, nvlist_t innvl, nvlist_t *outnvl)
	{
	int error;
	spa_t *spa;

	if ((error = spa_open(name, &spa, FTAG)) != 0)
	return (error);
	spa_vdev_state_enter(spa, SCL_ALL);
	error = vdev_label_write_bootenv(spa->spa_root_vdev, innvl);
	(void) spa_vdev_state_exit(spa, NULL, 0);
	spa_close(spa, FTAG);
	return (error);
	}

	static const zfs_ioc_key_t zfs_keys_get_bootenv[] = {
	/* no nvl keys */
	};

	static int
	zfs_ioc_get_bootenv(const char name, nvlist_t innvl, nvlist_t *outnvl)
	{
	spa_t *spa;
	int error;

	if ((error = spa_open(name, &spa, FTAG)) != 0)
	return (error);
	spa_vdev_state_enter(spa, SCL_ALL);
	error = vdev_label_read_bootenv(spa->spa_root_vdev, outnvl);
	(void) spa_vdev_state_exit(spa, NULL, 0);
	spa_close(spa, FTAG);
	return (error);
	}

	/*
	* The dp_config_rwlock must not be held when calling this, because the
	* unmount may need to write out data.
	*
	* This function is best-effort. Callers must deal gracefully if it
	* remains mounted (or is remounted after this call).
	*
	* Returns 0 if the argument is not a snapshot, or it is not currently a
	* filesystem, or we were able to unmount it. Returns error code otherwise.
	*/
	void
	zfs_unmount_snap(const char *snapname)
	{
	if (strchr(snapname, '@') == NULL)
	return;

	(void) zfsctl_snapshot_unmount(snapname, MNT_FORCE);
	}

	/* ARGSUSED */
	static int
	zfs_unmount_snap_cb(const char snapname, void arg)
	{
	zfs_unmount_snap(snapname);
	return (0);
	}

	/*
	* When a clone is destroyed, its origin may also need to be destroyed,
	* in which case it must be unmounted. This routine will do that unmount
	* if necessary.
	*/
	void
	zfs_destroy_unmount_origin(const char *fsname)
	{
	int error;
	objset_t *os;
	dsl_dataset_t *ds;

	error = dmu_objset_hold(fsname, FTAG, &os);
	if (error != 0)
	return;
	ds = dmu_objset_ds(os);
	if (dsl_dir_is_clone(ds->ds_dir) && DS_IS_DEFER_DESTROY(ds->ds_prev)) {
	char originname[ZFS_MAX_DATASET_NAME_LEN];
	dsl_dataset_name(ds->ds_prev, originname);
	dmu_objset_rele(os, FTAG);
	zfs_unmount_snap(originname);
	} else {
	dmu_objset_rele(os, FTAG);
	}
	}

	/*
	* innvl: {
	* "snaps" -> { snapshot1, snapshot2 }
	* (optional boolean) "defer"
	* }
	*
	* outnvl: snapshot -> error code (int32)
	*/
	static const zfs_ioc_key_t zfs_keys_destroy_snaps[] = {
	{"snaps", DATA_TYPE_NVLIST, 0},
	{"defer", DATA_TYPE_BOOLEAN, ZK_OPTIONAL},
	};

	/* ARGSUSED */
	static int
	zfs_ioc_destroy_snaps(const char poolname, nvlist_t innvl, nvlist_t *outnvl)
	{
	int poollen;
	nvlist_t *snaps;
	nvpair_t *pair;
	boolean_t defer;
	spa_t *spa;

	snaps = fnvlist_lookup_nvlist(innvl, "snaps");
	defer = nvlist_exists(innvl, "defer");

	poollen = strlen(poolname);
	for (pair = nvlist_next_nvpair(snaps, NULL); pair != NULL;
	pair = nvlist_next_nvpair(snaps, pair)) {
	const char *name = nvpair_name(pair);

	/*
	* The snap must be in the specified pool to prevent the
	* invalid removal of zvol minors below.
	*/
	if (strncmp(name, poolname, poollen) != 0 \|\|
	(name[poollen] != '/' && name[poollen] != '@'))
	return (SET_ERROR(EXDEV));

	zfs_unmount_snap(nvpair_name(pair));
	if (spa_open(name, &spa, FTAG) == 0) {
	zvol_remove_minors(spa, name, B_TRUE);
	spa_close(spa, FTAG);
	}
	}

	return (dsl_destroy_snapshots_nvl(snaps, defer, outnvl));
	}

	/*
	* Create bookmarks. The bookmark names are of the form <fs>#<bmark>.
	* All bookmarks and snapshots must be in the same pool.
	* dsl_bookmark_create_nvl_validate describes the nvlist schema in more detail.
	*
	* innvl: {
	* new_bookmark1 -> existing_snapshot,
	* new_bookmark2 -> existing_bookmark,
	* }
	*
	* outnvl: bookmark -> error code (int32)
	*
	*/
	static const zfs_ioc_key_t zfs_keys_bookmark[] = {
	{"<bookmark>...", DATA_TYPE_STRING, ZK_WILDCARDLIST},
	};

	/* ARGSUSED */
	static int
	zfs_ioc_bookmark(const char poolname, nvlist_t innvl, nvlist_t *outnvl)
	{
	return (dsl_bookmark_create(innvl, outnvl));
	}

	/*
	* innvl: {
	* property 1, property 2, ...
	* }
	*
	* outnvl: {
	* bookmark name 1 -> { property 1, property 2, ... },
	* bookmark name 2 -> { property 1, property 2, ... }
	* }
	*
	*/
	static const zfs_ioc_key_t zfs_keys_get_bookmarks[] = {
	{"<property>...", DATA_TYPE_BOOLEAN, ZK_WILDCARDLIST \| ZK_OPTIONAL},
	};

	static int
	zfs_ioc_get_bookmarks(const char fsname, nvlist_t innvl, nvlist_t *outnvl)
	{
	return (dsl_get_bookmarks(fsname, innvl, outnvl));
	}

	/*
	* innvl is not used.
	*
	* outnvl: {
	* property 1, property 2, ...
	* }
	*
	*/
	static const zfs_ioc_key_t zfs_keys_get_bookmark_props[] = {
	/* no nvl keys */
	};

	/* ARGSUSED */
	static int
	zfs_ioc_get_bookmark_props(const char bookmark, nvlist_t innvl,
	nvlist_t *outnvl)
	{
	char fsname[ZFS_MAX_DATASET_NAME_LEN];
	char *bmname;

	bmname = strchr(bookmark, '#');
	if (bmname == NULL)
	return (SET_ERROR(EINVAL));
	bmname++;

	(void) strlcpy(fsname, bookmark, sizeof (fsname));
	*(strchr(fsname, '#')) = '\0';

	return (dsl_get_bookmark_props(fsname, bmname, outnvl));
	}

	/*
	* innvl: {
	* bookmark name 1, bookmark name 2
	* }
	*
	* outnvl: bookmark -> error code (int32)
	*
	*/
	static const zfs_ioc_key_t zfs_keys_destroy_bookmarks[] = {
	{"<bookmark>...", DATA_TYPE_BOOLEAN, ZK_WILDCARDLIST},
	};

	static int
	zfs_ioc_destroy_bookmarks(const char poolname, nvlist_t innvl,
	nvlist_t *outnvl)
	{
	int error, poollen;

	poollen = strlen(poolname);
	for (nvpair_t *pair = nvlist_next_nvpair(innvl, NULL);
	pair != NULL; pair = nvlist_next_nvpair(innvl, pair)) {
	const char *name = nvpair_name(pair);
	const char *cp = strchr(name, '#');

	/*
	* The bookmark name must contain an #, and the part after it
	* must contain only valid characters.
	*/
	if (cp == NULL \|\|
	zfs_component_namecheck(cp + 1, NULL, NULL) != 0)
	return (SET_ERROR(EINVAL));

	/*
	* The bookmark must be in the specified pool.
	*/
	if (strncmp(name, poolname, poollen) != 0 \|\|
	(name[poollen] != '/' && name[poollen] != '#'))
	return (SET_ERROR(EXDEV));
	}

	error = dsl_bookmark_destroy(innvl, outnvl);
	return (error);
	}

	static const zfs_ioc_key_t zfs_keys_channel_program[] = {
	{"program", DATA_TYPE_STRING, 0},
	{"arg", DATA_TYPE_ANY, 0},
	{"sync", DATA_TYPE_BOOLEAN_VALUE, ZK_OPTIONAL},
	{"instrlimit", DATA_TYPE_UINT64, ZK_OPTIONAL},
	{"memlimit", DATA_TYPE_UINT64, ZK_OPTIONAL},
	};

	static int
	zfs_ioc_channel_program(const char poolname, nvlist_t innvl,
	nvlist_t *outnvl)
	{
	char *program;
	uint64_t instrlimit, memlimit;
	boolean_t sync_flag;
	nvpair_t *nvarg = NULL;

	program = fnvlist_lookup_string(innvl, ZCP_ARG_PROGRAM);
	if (0 != nvlist_lookup_boolean_value(innvl, ZCP_ARG_SYNC, &sync_flag)) {
	sync_flag = B_TRUE;
	}
	if (0 != nvlist_lookup_uint64(innvl, ZCP_ARG_INSTRLIMIT, &instrlimit)) {
	instrlimit = ZCP_DEFAULT_INSTRLIMIT;
	}
	if (0 != nvlist_lookup_uint64(innvl, ZCP_ARG_MEMLIMIT, &memlimit)) {
	memlimit = ZCP_DEFAULT_MEMLIMIT;
	}
	nvarg = fnvlist_lookup_nvpair(innvl, ZCP_ARG_ARGLIST);

	if (instrlimit == 0 \|\| instrlimit > zfs_lua_max_instrlimit)
	return (SET_ERROR(EINVAL));
	if (memlimit == 0 \|\| memlimit > zfs_lua_max_memlimit)
	return (SET_ERROR(EINVAL));

	return (zcp_eval(poolname, program, sync_flag, instrlimit, memlimit,
	nvarg, outnvl));
	}

	/*
	* innvl: unused
	* outnvl: empty
	*/
	static const zfs_ioc_key_t zfs_keys_pool_checkpoint[] = {
	/* no nvl keys */
	};

	/* ARGSUSED */
	static int
	zfs_ioc_pool_checkpoint(const char poolname, nvlist_t innvl, nvlist_t *outnvl)
	{
	return (spa_checkpoint(poolname));
	}

	/*
	* innvl: unused
	* outnvl: empty
	*/
	static const zfs_ioc_key_t zfs_keys_pool_discard_checkpoint[] = {
	/* no nvl keys */
	};

	/* ARGSUSED */
	static int
	zfs_ioc_pool_discard_checkpoint(const char poolname, nvlist_t innvl,
	nvlist_t *outnvl)
	{
	return (spa_checkpoint_discard(poolname));
	}

	/*
	* inputs:
	* zc_name name of dataset to destroy
	* zc_defer_destroy mark for deferred destroy
	*
	* outputs: none
	*/
	static int
	zfs_ioc_destroy(zfs_cmd_t *zc)
	{
	objset_t *os;
	dmu_objset_type_t ost;
	int err;

	err = dmu_objset_hold(zc->zc_name, FTAG, &os);
	if (err != 0)
	return (err);
	ost = dmu_objset_type(os);
	dmu_objset_rele(os, FTAG);

	if (ost == DMU_OST_ZFS)
	zfs_unmount_snap(zc->zc_name);

	if (strchr(zc->zc_name, '@')) {
	err = dsl_destroy_snapshot(zc->zc_name, zc->zc_defer_destroy);
	} else {
	err = dsl_destroy_head(zc->zc_name);
	if (err == EEXIST) {
	/*
	* It is possible that the given DS may have
	* hidden child (%recv) datasets - "leftovers"
	* resulting from the previously interrupted
	* 'zfs receive'.
	*
	* 6 extra bytes for /%recv
	*/
	char namebuf[ZFS_MAX_DATASET_NAME_LEN + 6];

	if (snprintf(namebuf, sizeof (namebuf), "%s/%s",
	zc->zc_name, recv_clone_name) >=
	sizeof (namebuf))
	return (SET_ERROR(EINVAL));

	/*
	* Try to remove the hidden child (%recv) and after
	* that try to remove the target dataset.
	* If the hidden child (%recv) does not exist
	* the original error (EEXIST) will be returned
	*/
	err = dsl_destroy_head(namebuf);
	if (err == 0)
	err = dsl_destroy_head(zc->zc_name);
	else if (err == ENOENT)
	err = SET_ERROR(EEXIST);
	}
	}

	return (err);
	}

	/*
	* innvl: {
	* "initialize_command" -> POOL_INITIALIZE_{CANCEL\|START\|SUSPEND} (uint64)
	* "initialize_vdevs": { -> guids to initialize (nvlist)
	* "vdev_path_1": vdev_guid_1, (uint64),
	* "vdev_path_2": vdev_guid_2, (uint64),
	* ...
	* },
	* }
	*
	* outnvl: {
	* "initialize_vdevs": { -> initialization errors (nvlist)
	* "vdev_path_1": errno, see function body for possible errnos (uint64)
	* "vdev_path_2": errno, ... (uint64)
	* ...
	* }
	* }
	*
	* EINVAL is returned for an unknown commands or if any of the provided vdev
	* guids have be specified with a type other than uint64.
	*/
	static const zfs_ioc_key_t zfs_keys_pool_initialize[] = {
	{ZPOOL_INITIALIZE_COMMAND, DATA_TYPE_UINT64, 0},
	{ZPOOL_INITIALIZE_VDEVS, DATA_TYPE_NVLIST, 0}
	};

	static int
	zfs_ioc_pool_initialize(const char poolname, nvlist_t innvl, nvlist_t *outnvl)
	{
	uint64_t cmd_type;
	if (nvlist_lookup_uint64(innvl, ZPOOL_INITIALIZE_COMMAND,
	&cmd_type) != 0) {
	return (SET_ERROR(EINVAL));
	}

	if (!(cmd_type == POOL_INITIALIZE_CANCEL \|\|
	cmd_type == POOL_INITIALIZE_START \|\|
	cmd_type == POOL_INITIALIZE_SUSPEND)) {
	return (SET_ERROR(EINVAL));
	}

	nvlist_t *vdev_guids;
	if (nvlist_lookup_nvlist(innvl, ZPOOL_INITIALIZE_VDEVS,
	&vdev_guids) != 0) {
	return (SET_ERROR(EINVAL));
	}

	for (nvpair_t *pair = nvlist_next_nvpair(vdev_guids, NULL);
	pair != NULL; pair = nvlist_next_nvpair(vdev_guids, pair)) {
	uint64_t vdev_guid;
	if (nvpair_value_uint64(pair, &vdev_guid) != 0) {
	return (SET_ERROR(EINVAL));
	}
	}

	spa_t *spa;
	int error = spa_open(poolname, &spa, FTAG);
	if (error != 0)
	return (error);

	nvlist_t *vdev_errlist = fnvlist_alloc();
	int total_errors = spa_vdev_initialize(spa, vdev_guids, cmd_type,
	vdev_errlist);

	if (fnvlist_size(vdev_errlist) > 0) {
	fnvlist_add_nvlist(outnvl, ZPOOL_INITIALIZE_VDEVS,
	vdev_errlist);
	}
	fnvlist_free(vdev_errlist);

	spa_close(spa, FTAG);
	return (total_errors > 0 ? SET_ERROR(EINVAL) : 0);
	}

	/*
	* innvl: {
	* "trim_command" -> POOL_TRIM_{CANCEL\|START\|SUSPEND} (uint64)
	* "trim_vdevs": { -> guids to TRIM (nvlist)
	* "vdev_path_1": vdev_guid_1, (uint64),
	* "vdev_path_2": vdev_guid_2, (uint64),
	* ...
	* },
	* "trim_rate" -> Target TRIM rate in bytes/sec.
	* "trim_secure" -> Set to request a secure TRIM.
	* }
	*
	* outnvl: {
	* "trim_vdevs": { -> TRIM errors (nvlist)
	* "vdev_path_1": errno, see function body for possible errnos (uint64)
	* "vdev_path_2": errno, ... (uint64)
	* ...
	* }
	* }
	*
	* EINVAL is returned for an unknown commands or if any of the provided vdev
	* guids have be specified with a type other than uint64.
	*/
	static const zfs_ioc_key_t zfs_keys_pool_trim[] = {
	{ZPOOL_TRIM_COMMAND, DATA_TYPE_UINT64, 0},
	{ZPOOL_TRIM_VDEVS, DATA_TYPE_NVLIST, 0},
	{ZPOOL_TRIM_RATE, DATA_TYPE_UINT64, ZK_OPTIONAL},
	{ZPOOL_TRIM_SECURE, DATA_TYPE_BOOLEAN_VALUE, ZK_OPTIONAL},
	};

	static int
	zfs_ioc_pool_trim(const char poolname, nvlist_t innvl, nvlist_t *outnvl)
	{
	uint64_t cmd_type;
	if (nvlist_lookup_uint64(innvl, ZPOOL_TRIM_COMMAND, &cmd_type) != 0)
	return (SET_ERROR(EINVAL));

	if (!(cmd_type == POOL_TRIM_CANCEL \|\|
	cmd_type == POOL_TRIM_START \|\|
	cmd_type == POOL_TRIM_SUSPEND)) {
	return (SET_ERROR(EINVAL));
	}

	nvlist_t *vdev_guids;
	if (nvlist_lookup_nvlist(innvl, ZPOOL_TRIM_VDEVS, &vdev_guids) != 0)
	return (SET_ERROR(EINVAL));

	for (nvpair_t *pair = nvlist_next_nvpair(vdev_guids, NULL);
	pair != NULL; pair = nvlist_next_nvpair(vdev_guids, pair)) {
	uint64_t vdev_guid;
	if (nvpair_value_uint64(pair, &vdev_guid) != 0) {
	return (SET_ERROR(EINVAL));
	}
	}

	/* Optional, defaults to maximum rate when not provided */
	uint64_t rate;
	if (nvlist_lookup_uint64(innvl, ZPOOL_TRIM_RATE, &rate) != 0)
	rate = 0;

	/* Optional, defaults to standard TRIM when not provided */
	boolean_t secure;
	if (nvlist_lookup_boolean_value(innvl, ZPOOL_TRIM_SECURE,
	&secure) != 0) {
	secure = B_FALSE;
	}

	spa_t *spa;
	int error = spa_open(poolname, &spa, FTAG);
	if (error != 0)
	return (error);

	nvlist_t *vdev_errlist = fnvlist_alloc();
	int total_errors = spa_vdev_trim(spa, vdev_guids, cmd_type,
	rate, !!zfs_trim_metaslab_skip, secure, vdev_errlist);

	if (fnvlist_size(vdev_errlist) > 0)
	fnvlist_add_nvlist(outnvl, ZPOOL_TRIM_VDEVS, vdev_errlist);

	fnvlist_free(vdev_errlist);

	spa_close(spa, FTAG);
	return (total_errors > 0 ? SET_ERROR(EINVAL) : 0);
	}

	/*
	* This ioctl waits for activity of a particular type to complete. If there is
	* no activity of that type in progress, it returns immediately, and the
	* returned value "waited" is false. If there is activity in progress, and no
	* tag is passed in, the ioctl blocks until all activity of that type is
	* complete, and then returns with "waited" set to true.
	*
	* If a tag is provided, it identifies a particular instance of an activity to
	* wait for. Currently, this is only valid for use with 'initialize', because
	* that is the only activity for which there can be multiple instances running
	* concurrently. In the case of 'initialize', the tag corresponds to the guid of
	* the vdev on which to wait.
	*
	* If a thread waiting in the ioctl receives a signal, the call will return
	* immediately, and the return value will be EINTR.
	*
	* innvl: {
	* "wait_activity" -> int32_t
	* (optional) "wait_tag" -> uint64_t
	* }
	*
	* outnvl: "waited" -> boolean_t
	*/
	static const zfs_ioc_key_t zfs_keys_pool_wait[] = {
	{ZPOOL_WAIT_ACTIVITY, DATA_TYPE_INT32, 0},
	{ZPOOL_WAIT_TAG, DATA_TYPE_UINT64, ZK_OPTIONAL},
	};

	static int
	zfs_ioc_wait(const char name, nvlist_t innvl, nvlist_t *outnvl)
	{
	int32_t activity;
	uint64_t tag;
	boolean_t waited;
	int error;

	if (nvlist_lookup_int32(innvl, ZPOOL_WAIT_ACTIVITY, &activity) != 0)
	return (EINVAL);

	if (nvlist_lookup_uint64(innvl, ZPOOL_WAIT_TAG, &tag) == 0)
	error = spa_wait_tag(name, activity, tag, &waited);
	else
	error = spa_wait(name, activity, &waited);

	if (error == 0)
	fnvlist_add_boolean_value(outnvl, ZPOOL_WAIT_WAITED, waited);

	return (error);
	}

	/*
	* This ioctl waits for activity of a particular type to complete. If there is
	* no activity of that type in progress, it returns immediately, and the
	* returned value "waited" is false. If there is activity in progress, and no
	* tag is passed in, the ioctl blocks until all activity of that type is
	* complete, and then returns with "waited" set to true.
	*
	* If a thread waiting in the ioctl receives a signal, the call will return
	* immediately, and the return value will be EINTR.
	*
	* innvl: {
	* "wait_activity" -> int32_t
	* }
	*
	* outnvl: "waited" -> boolean_t
	*/
	static const zfs_ioc_key_t zfs_keys_fs_wait[] = {
	{ZFS_WAIT_ACTIVITY, DATA_TYPE_INT32, 0},
	};

	static int
	zfs_ioc_wait_fs(const char name, nvlist_t innvl, nvlist_t *outnvl)
	{
	int32_t activity;
	boolean_t waited = B_FALSE;
	int error;
	dsl_pool_t *dp;
	dsl_dir_t *dd;
	dsl_dataset_t *ds;

	if (nvlist_lookup_int32(innvl, ZFS_WAIT_ACTIVITY, &activity) != 0)
	return (SET_ERROR(EINVAL));

	if (activity >= ZFS_WAIT_NUM_ACTIVITIES \|\| activity < 0)
	return (SET_ERROR(EINVAL));

	if ((error = dsl_pool_hold(name, FTAG, &dp)) != 0)
	return (error);

	if ((error = dsl_dataset_hold(dp, name, FTAG, &ds)) != 0) {
	dsl_pool_rele(dp, FTAG);
	return (error);
	}

	dd = ds->ds_dir;
	mutex_enter(&dd->dd_activity_lock);
	dd->dd_activity_waiters++;

	/*
	* We get a long-hold here so that the dsl_dataset_t and dsl_dir_t
	* aren't evicted while we're waiting. Normally this is prevented by
	* holding the pool, but we can't do that while we're waiting since
	* that would prevent TXGs from syncing out. Some of the functionality
	* of long-holds (e.g. preventing deletion) is unnecessary for this
	* case, since we would cancel the waiters before proceeding with a
	* deletion. An alternative mechanism for keeping the dataset around
	* could be developed but this is simpler.
	*/
	dsl_dataset_long_hold(ds, FTAG);
	dsl_pool_rele(dp, FTAG);

	error = dsl_dir_wait(dd, ds, activity, &waited);

	dsl_dataset_long_rele(ds, FTAG);
	dd->dd_activity_waiters--;
	if (dd->dd_activity_waiters == 0)
	cv_signal(&dd->dd_activity_cv);
	mutex_exit(&dd->dd_activity_lock);

	dsl_dataset_rele(ds, FTAG);

	if (error == 0)
	fnvlist_add_boolean_value(outnvl, ZFS_WAIT_WAITED, waited);

	return (error);
	}

	/*
	* fsname is name of dataset to rollback (to most recent snapshot)
	*
	* innvl may contain name of expected target snapshot
	*
	* outnvl: "target" -> name of most recent snapshot
	* }
	*/
	static const zfs_ioc_key_t zfs_keys_rollback[] = {
	{"target", DATA_TYPE_STRING, ZK_OPTIONAL},
	};

	/* ARGSUSED */
	static int
	zfs_ioc_rollback(const char fsname, nvlist_t innvl, nvlist_t *outnvl)
	{
	zfsvfs_t *zfsvfs;
	zvol_state_handle_t *zv;
	char *target = NULL;
	int error;

	(void) nvlist_lookup_string(innvl, "target", &target);
	if (target != NULL) {
	const char *cp = strchr(target, '@');

	/*
	* The snap name must contain an @, and the part after it must
	* contain only valid characters.
	*/
	if (cp == NULL \|\|
	zfs_component_namecheck(cp + 1, NULL, NULL) != 0)
	return (SET_ERROR(EINVAL));
	}

	if (getzfsvfs(fsname, &zfsvfs) == 0) {
	dsl_dataset_t *ds;

	ds = dmu_objset_ds(zfsvfs->z_os);
	error = zfs_suspend_fs(zfsvfs);
	if (error == 0) {
	int resume_err;

	error = dsl_dataset_rollback(fsname, target, zfsvfs,
	outnvl);
	resume_err = zfs_resume_fs(zfsvfs, ds);
	error = error ? error : resume_err;
	}
	zfs_vfs_rele(zfsvfs);
	} else if ((zv = zvol_suspend(fsname)) != NULL) {
	error = dsl_dataset_rollback(fsname, target, zvol_tag(zv),
	outnvl);
	zvol_resume(zv);
	} else {
	error = dsl_dataset_rollback(fsname, target, NULL, outnvl);
	}
	return (error);
	}

	static int
	recursive_unmount(const char fsname, void arg)
	{
	const char *snapname = arg;
	char *fullname;

	fullname = kmem_asprintf("%s@%s", fsname, snapname);
	zfs_unmount_snap(fullname);
	kmem_strfree(fullname);

	return (0);
	}

	/*
	*
	* snapname is the snapshot to redact.
	* innvl: {
	* "bookname" -> (string)
	* shortname of the redaction bookmark to generate
	* "snapnv" -> (nvlist, values ignored)
	* snapshots to redact snapname with respect to
	* }
	*
	* outnvl is unused
	*/

	/* ARGSUSED */
	static const zfs_ioc_key_t zfs_keys_redact[] = {
	{"bookname", DATA_TYPE_STRING, 0},
	{"snapnv", DATA_TYPE_NVLIST, 0},
	};
	static int
	zfs_ioc_redact(const char snapname, nvlist_t innvl, nvlist_t *outnvl)
	{
	nvlist_t *redactnvl = NULL;
	char *redactbook = NULL;

	if (nvlist_lookup_nvlist(innvl, "snapnv", &redactnvl) != 0)
	return (SET_ERROR(EINVAL));
	if (fnvlist_num_pairs(redactnvl) == 0)
	return (SET_ERROR(ENXIO));
	if (nvlist_lookup_string(innvl, "bookname", &redactbook) != 0)
	return (SET_ERROR(EINVAL));

	return (dmu_redact_snap(snapname, redactnvl, redactbook));
	}

	/*
	* inputs:
	* zc_name old name of dataset
	* zc_value new name of dataset
	* zc_cookie recursive flag (only valid for snapshots)
	*
	* outputs: none
	*/
	static int
	zfs_ioc_rename(zfs_cmd_t *zc)
	{
	objset_t *os;
	dmu_objset_type_t ost;
	boolean_t recursive = zc->zc_cookie & 1;
	boolean_t nounmount = !!(zc->zc_cookie & 2);
	char *at;
	int err;

	/* "zfs rename" from and to ...%recv datasets should both fail */
	zc->zc_name[sizeof (zc->zc_name) - 1] = '\0';
	zc->zc_value[sizeof (zc->zc_value) - 1] = '\0';
	if (dataset_namecheck(zc->zc_name, NULL, NULL) != 0 \|\|
	dataset_namecheck(zc->zc_value, NULL, NULL) != 0 \|\|
	strchr(zc->zc_name, '%') \|\| strchr(zc->zc_value, '%'))
	return (SET_ERROR(EINVAL));

	err = dmu_objset_hold(zc->zc_name, FTAG, &os);
	if (err != 0)
	return (err);
	ost = dmu_objset_type(os);
	dmu_objset_rele(os, FTAG);

	at = strchr(zc->zc_name, '@');
	if (at != NULL) {
	/* snaps must be in same fs */
	int error;

	if (strncmp(zc->zc_name, zc->zc_value, at - zc->zc_name + 1))
	return (SET_ERROR(EXDEV));
	*at = '\0';
	if (ost == DMU_OST_ZFS && !nounmount) {
	error = dmu_objset_find(zc->zc_name,
	recursive_unmount, at + 1,
	recursive ? DS_FIND_CHILDREN : 0);
	if (error != 0) {
	*at = '@';
	return (error);
	}
	}
	error = dsl_dataset_rename_snapshot(zc->zc_name,
	at + 1, strchr(zc->zc_value, '@') + 1, recursive);
	*at = '@';

	return (error);
	} else {
	return (dsl_dir_rename(zc->zc_name, zc->zc_value));
	}
	}

	static int
	zfs_check_settable(const char dsname, nvpair_t pair, cred_t *cr)
	{
	const char *propname = nvpair_name(pair);
	boolean_t issnap = (strchr(dsname, '@') != NULL);
	zfs_prop_t prop = zfs_name_to_prop(propname);
	uint64_t intval, compval;
	int err;

	if (prop == ZPROP_INVAL) {
	if (zfs_prop_user(propname)) {
	if ((err = zfs_secpolicy_write_perms(dsname,
	ZFS_DELEG_PERM_USERPROP, cr)))
	return (err);
	return (0);
	}

	if (!issnap && zfs_prop_userquota(propname)) {
	const char *perm = NULL;
	const char *uq_prefix =
	zfs_userquota_prop_prefixes[ZFS_PROP_USERQUOTA];
	const char *gq_prefix =
	zfs_userquota_prop_prefixes[ZFS_PROP_GROUPQUOTA];
	const char *uiq_prefix =
	zfs_userquota_prop_prefixes[ZFS_PROP_USEROBJQUOTA];
	const char *giq_prefix =
	zfs_userquota_prop_prefixes[ZFS_PROP_GROUPOBJQUOTA];
	const char *pq_prefix =
	zfs_userquota_prop_prefixes[ZFS_PROP_PROJECTQUOTA];
	const char *piq_prefix = zfs_userquota_prop_prefixes[\
	ZFS_PROP_PROJECTOBJQUOTA];

	if (strncmp(propname, uq_prefix,
	strlen(uq_prefix)) == 0) {
	perm = ZFS_DELEG_PERM_USERQUOTA;
	} else if (strncmp(propname, uiq_prefix,
	strlen(uiq_prefix)) == 0) {
	perm = ZFS_DELEG_PERM_USEROBJQUOTA;
	} else if (strncmp(propname, gq_prefix,
	strlen(gq_prefix)) == 0) {
	perm = ZFS_DELEG_PERM_GROUPQUOTA;
	} else if (strncmp(propname, giq_prefix,
	strlen(giq_prefix)) == 0) {
	perm = ZFS_DELEG_PERM_GROUPOBJQUOTA;
	} else if (strncmp(propname, pq_prefix,
	strlen(pq_prefix)) == 0) {
	perm = ZFS_DELEG_PERM_PROJECTQUOTA;
	} else if (strncmp(propname, piq_prefix,
	strlen(piq_prefix)) == 0) {
	perm = ZFS_DELEG_PERM_PROJECTOBJQUOTA;
	} else {
	/* {USER\|GROUP\|PROJECT}USED are read-only */
	return (SET_ERROR(EINVAL));
	}

	if ((err = zfs_secpolicy_write_perms(dsname, perm, cr)))
	return (err);
	return (0);
	}

	return (SET_ERROR(EINVAL));
	}

	if (issnap)
	return (SET_ERROR(EINVAL));

	if (nvpair_type(pair) == DATA_TYPE_NVLIST) {
	/*
	* dsl_prop_get_all_impl() returns properties in this
	* format.
	*/
	nvlist_t *attrs;
	VERIFY(nvpair_value_nvlist(pair, &attrs) == 0);
	VERIFY(nvlist_lookup_nvpair(attrs, ZPROP_VALUE,
	&pair) == 0);
	}

	/*
	* Check that this value is valid for this pool version
	*/
	switch (prop) {
	case ZFS_PROP_COMPRESSION:
	/*
	* If the user specified gzip compression, make sure
	* the SPA supports it. We ignore any errors here since
	* we'll catch them later.
	*/
	if (nvpair_value_uint64(pair, &intval) == 0) {
	compval = ZIO_COMPRESS_ALGO(intval);
	if (compval >= ZIO_COMPRESS_GZIP_1 &&
	compval <= ZIO_COMPRESS_GZIP_9 &&
	zfs_earlier_version(dsname,
	SPA_VERSION_GZIP_COMPRESSION)) {
	return (SET_ERROR(ENOTSUP));
	}

	if (compval == ZIO_COMPRESS_ZLE &&
	zfs_earlier_version(dsname,
	SPA_VERSION_ZLE_COMPRESSION))
	return (SET_ERROR(ENOTSUP));

	if (compval == ZIO_COMPRESS_LZ4) {
	spa_t *spa;

	if ((err = spa_open(dsname, &spa, FTAG)) != 0)
	return (err);

	if (!spa_feature_is_enabled(spa,
	SPA_FEATURE_LZ4_COMPRESS)) {
	spa_close(spa, FTAG);
	return (SET_ERROR(ENOTSUP));
	}
	spa_close(spa, FTAG);
	}

	if (compval == ZIO_COMPRESS_ZSTD) {
	spa_t *spa;

	if ((err = spa_open(dsname, &spa, FTAG)) != 0)
	return (err);

	if (!spa_feature_is_enabled(spa,
	SPA_FEATURE_ZSTD_COMPRESS)) {
	spa_close(spa, FTAG);
	return (SET_ERROR(ENOTSUP));
	}
	spa_close(spa, FTAG);
	}
	}
	break;

	case ZFS_PROP_COPIES:
	if (zfs_earlier_version(dsname, SPA_VERSION_DITTO_BLOCKS))
	return (SET_ERROR(ENOTSUP));
	break;

	case ZFS_PROP_VOLBLOCKSIZE:
	case ZFS_PROP_RECORDSIZE:
	/* Record sizes above 128k need the feature to be enabled */
	if (nvpair_value_uint64(pair, &intval) == 0 &&
	intval > SPA_OLD_MAXBLOCKSIZE) {
	spa_t *spa;

	/*
	* We don't allow setting the property above 1MB,
	* unless the tunable has been changed.
	*/
	if (intval > zfs_max_recordsize \|\|
	intval > SPA_MAXBLOCKSIZE)
	return (SET_ERROR(ERANGE));

	if ((err = spa_open(dsname, &spa, FTAG)) != 0)
	return (err);

	if (!spa_feature_is_enabled(spa,
	SPA_FEATURE_LARGE_BLOCKS)) {
	spa_close(spa, FTAG);
	return (SET_ERROR(ENOTSUP));
	}
	spa_close(spa, FTAG);
	}
	break;

	case ZFS_PROP_DNODESIZE:
	/* Dnode sizes above 512 need the feature to be enabled */
	if (nvpair_value_uint64(pair, &intval) == 0 &&
	intval != ZFS_DNSIZE_LEGACY) {
	spa_t *spa;

	if ((err = spa_open(dsname, &spa, FTAG)) != 0)
	return (err);

	if (!spa_feature_is_enabled(spa,
	SPA_FEATURE_LARGE_DNODE)) {
	spa_close(spa, FTAG);
	return (SET_ERROR(ENOTSUP));
	}
	spa_close(spa, FTAG);
	}
	break;

	case ZFS_PROP_SPECIAL_SMALL_BLOCKS:
	/*
	* This property could require the allocation classes
	* feature to be active for setting, however we allow
	* it so that tests of settable properties succeed.
	* The CLI will issue a warning in this case.
	*/
	break;

	case ZFS_PROP_SHARESMB:
	if (zpl_earlier_version(dsname, ZPL_VERSION_FUID))
	return (SET_ERROR(ENOTSUP));
	break;

	case ZFS_PROP_ACLINHERIT:
	if (nvpair_type(pair) == DATA_TYPE_UINT64 &&
	nvpair_value_uint64(pair, &intval) == 0) {
	if (intval == ZFS_ACL_PASSTHROUGH_X &&
	zfs_earlier_version(dsname,
	SPA_VERSION_PASSTHROUGH_X))
	return (SET_ERROR(ENOTSUP));
	}
	break;
	case ZFS_PROP_CHECKSUM:
	case ZFS_PROP_DEDUP:
	{
	spa_feature_t feature;
	spa_t *spa;
	int err;

	/* dedup feature version checks */
	if (prop == ZFS_PROP_DEDUP &&
	zfs_earlier_version(dsname, SPA_VERSION_DEDUP))
	return (SET_ERROR(ENOTSUP));

	if (nvpair_type(pair) == DATA_TYPE_UINT64 &&
	nvpair_value_uint64(pair, &intval) == 0) {
	/* check prop value is enabled in features */
	feature = zio_checksum_to_feature(
	intval & ZIO_CHECKSUM_MASK);
	if (feature == SPA_FEATURE_NONE)
	break;

	if ((err = spa_open(dsname, &spa, FTAG)) != 0)
	return (err);

	if (!spa_feature_is_enabled(spa, feature)) {
	spa_close(spa, FTAG);
	return (SET_ERROR(ENOTSUP));
	}
	spa_close(spa, FTAG);
	}
	break;
	}

	default:
	break;
	}

	return (zfs_secpolicy_setprop(dsname, prop, pair, CRED()));
	}

	/*
	* Removes properties from the given props list that fail permission checks
	* needed to clear them and to restore them in case of a receive error. For each
	* property, make sure we have both set and inherit permissions.
	*
	* Returns the first error encountered if any permission checks fail. If the
	* caller provides a non-NULL errlist, it also gives the complete list of names
	* of all the properties that failed a permission check along with the
	* corresponding error numbers. The caller is responsible for freeing the
	* returned errlist.
	*
	* If every property checks out successfully, zero is returned and the list
	* pointed at by errlist is NULL.
	*/
	static int
	zfs_check_clearable(const char dataset, nvlist_t props, nvlist_t **errlist)
	{
	zfs_cmd_t *zc;
	nvpair_t pair, next_pair;
	nvlist_t *errors;
	int err, rv = 0;

	if (props == NULL)
	return (0);

	VERIFY(nvlist_alloc(&errors, NV_UNIQUE_NAME, KM_SLEEP) == 0);

	zc = kmem_alloc(sizeof (zfs_cmd_t), KM_SLEEP);
	(void) strlcpy(zc->zc_name, dataset, sizeof (zc->zc_name));
	pair = nvlist_next_nvpair(props, NULL);
	while (pair != NULL) {
	next_pair = nvlist_next_nvpair(props, pair);

	(void) strlcpy(zc->zc_value, nvpair_name(pair),
	sizeof (zc->zc_value));
	if ((err = zfs_check_settable(dataset, pair, CRED())) != 0 \|\|
	(err = zfs_secpolicy_inherit_prop(zc, NULL, CRED())) != 0) {
	VERIFY(nvlist_remove_nvpair(props, pair) == 0);
	VERIFY(nvlist_add_int32(errors,
	zc->zc_value, err) == 0);
	}
	pair = next_pair;
	}
	kmem_free(zc, sizeof (zfs_cmd_t));

	if ((pair = nvlist_next_nvpair(errors, NULL)) == NULL) {
	nvlist_free(errors);
	errors = NULL;
	} else {
	VERIFY(nvpair_value_int32(pair, &rv) == 0);
	}

	if (errlist == NULL)
	nvlist_free(errors);
	else
	*errlist = errors;

	return (rv);
	}

	static boolean_t
	propval_equals(nvpair_t p1, nvpair_t p2)
	{
	if (nvpair_type(p1) == DATA_TYPE_NVLIST) {
	/* dsl_prop_get_all_impl() format */
	nvlist_t *attrs;
	VERIFY(nvpair_value_nvlist(p1, &attrs) == 0);
	VERIFY(nvlist_lookup_nvpair(attrs, ZPROP_VALUE,
	&p1) == 0);
	}

	if (nvpair_type(p2) == DATA_TYPE_NVLIST) {
	nvlist_t *attrs;
	VERIFY(nvpair_value_nvlist(p2, &attrs) == 0);
	VERIFY(nvlist_lookup_nvpair(attrs, ZPROP_VALUE,
	&p2) == 0);
	}

	if (nvpair_type(p1) != nvpair_type(p2))
	return (B_FALSE);

	if (nvpair_type(p1) == DATA_TYPE_STRING) {
	char valstr1, valstr2;

	VERIFY(nvpair_value_string(p1, (char **)&valstr1) == 0);
	VERIFY(nvpair_value_string(p2, (char **)&valstr2) == 0);
	return (strcmp(valstr1, valstr2) == 0);
	} else {
	uint64_t intval1, intval2;

	VERIFY(nvpair_value_uint64(p1, &intval1) == 0);
	VERIFY(nvpair_value_uint64(p2, &intval2) == 0);
	return (intval1 == intval2);
	}
	}

	/*
	* Remove properties from props if they are not going to change (as determined
	* by comparison with origprops). Remove them from origprops as well, since we
	* do not need to clear or restore properties that won't change.
	*/
	static void
	props_reduce(nvlist_t props, nvlist_t origprops)
	{
	nvpair_t pair, next_pair;

	if (origprops == NULL)
	return; /* all props need to be received */

	pair = nvlist_next_nvpair(props, NULL);
	while (pair != NULL) {
	const char *propname = nvpair_name(pair);
	nvpair_t *match;

	next_pair = nvlist_next_nvpair(props, pair);

	if ((nvlist_lookup_nvpair(origprops, propname,
	&match) != 0) \|\| !propval_equals(pair, match))
	goto next; /* need to set received value */

	/* don't clear the existing received value */
	(void) nvlist_remove_nvpair(origprops, match);
	/* don't bother receiving the property */
	(void) nvlist_remove_nvpair(props, pair);
	next:
	pair = next_pair;
	}
	}

	/*
	* Extract properties that cannot be set PRIOR to the receipt of a dataset.
	* For example, refquota cannot be set until after the receipt of a dataset,
	* because in replication streams, an older/earlier snapshot may exceed the
	* refquota. We want to receive the older/earlier snapshot, but setting
	* refquota pre-receipt will set the dsl's ACTUAL quota, which will prevent
	* the older/earlier snapshot from being received (with EDQUOT).
	*
	* The ZFS test "zfs_receive_011_pos" demonstrates such a scenario.
	*
	* libzfs will need to be judicious handling errors encountered by props
	* extracted by this function.
	*/
	static nvlist_t *
	extract_delay_props(nvlist_t *props)
	{
	nvlist_t *delayprops;
	nvpair_t nvp, tmp;
	static const zfs_prop_t delayable[] = {
	ZFS_PROP_REFQUOTA,
	ZFS_PROP_KEYLOCATION,
	0
	};
	int i;

	VERIFY(nvlist_alloc(&delayprops, NV_UNIQUE_NAME, KM_SLEEP) == 0);

	for (nvp = nvlist_next_nvpair(props, NULL); nvp != NULL;
	nvp = nvlist_next_nvpair(props, nvp)) {
	/*
	* strcmp() is safe because zfs_prop_to_name() always returns
	* a bounded string.
	*/
	for (i = 0; delayable[i] != 0; i++) {
	if (strcmp(zfs_prop_to_name(delayable[i]),
	nvpair_name(nvp)) == 0) {
	break;
	}
	}
	if (delayable[i] != 0) {
	tmp = nvlist_prev_nvpair(props, nvp);
	VERIFY(nvlist_add_nvpair(delayprops, nvp) == 0);
	VERIFY(nvlist_remove_nvpair(props, nvp) == 0);
	nvp = tmp;
	}
	}

	if (nvlist_empty(delayprops)) {
	nvlist_free(delayprops);
	delayprops = NULL;
	}
	return (delayprops);
	}

	static void
	zfs_allow_log_destroy(void *arg)
	{
	char *poolname = arg;

	if (poolname != NULL)
	kmem_strfree(poolname);
	}

	#ifdef ZFS_DEBUG
	static boolean_t zfs_ioc_recv_inject_err;
	#endif

	/*
	* nvlist 'errors' is always allocated. It will contain descriptions of
	* encountered errors, if any. It's the callers responsibility to free.
	*/
	static int
	zfs_ioc_recv_impl(char tofs, char tosnap, char origin, nvlist_t recvprops,
	nvlist_t localprops, nvlist_t hidden_args, boolean_t force,
	boolean_t resumable, int input_fd,
	dmu_replay_record_t begin_record, uint64_t read_bytes,
	uint64_t errflags, nvlist_t *errors)
	{
	dmu_recv_cookie_t drc;
	int error = 0;
	int props_error = 0;
	offset_t off, noff;
	nvlist_t *local_delayprops = NULL;
	nvlist_t *recv_delayprops = NULL;
	nvlist_t origprops = NULL; / existing properties */
	nvlist_t origrecvd = NULL; / existing received properties */
	boolean_t first_recvd_props = B_FALSE;
	boolean_t tofs_was_redacted;
	zfs_file_t *input_fp;

	*read_bytes = 0;
	*errflags = 0;
	*errors = fnvlist_alloc();
	off = 0;

	if ((error = zfs_file_get(input_fd, &input_fp)))
	return (error);

	noff = off = zfs_file_off(input_fp);
	error = dmu_recv_begin(tofs, tosnap, begin_record, force,
	resumable, localprops, hidden_args, origin, &drc, input_fp,
	&off);
	if (error != 0)
	goto out;
	tofs_was_redacted = dsl_get_redacted(drc.drc_ds);

	/*
	* Set properties before we receive the stream so that they are applied
	* to the new data. Note that we must call dmu_recv_stream() if
	* dmu_recv_begin() succeeds.
	*/
	if (recvprops != NULL && !drc.drc_newfs) {
	if (spa_version(dsl_dataset_get_spa(drc.drc_ds)) >=
	SPA_VERSION_RECVD_PROPS &&
	!dsl_prop_get_hasrecvd(tofs))
	first_recvd_props = B_TRUE;

	/*
	* If new received properties are supplied, they are to
	* completely replace the existing received properties,
	* so stash away the existing ones.
	*/
	if (dsl_prop_get_received(tofs, &origrecvd) == 0) {
	nvlist_t *errlist = NULL;
	/*
	* Don't bother writing a property if its value won't
	* change (and avoid the unnecessary security checks).
	*
	* The first receive after SPA_VERSION_RECVD_PROPS is a
	* special case where we blow away all local properties
	* regardless.
	*/
	if (!first_recvd_props)
	props_reduce(recvprops, origrecvd);
	if (zfs_check_clearable(tofs, origrecvd, &errlist) != 0)
	(void) nvlist_merge(*errors, errlist, 0);
	nvlist_free(errlist);

	if (clear_received_props(tofs, origrecvd,
	first_recvd_props ? NULL : recvprops) != 0)
	*errflags \|= ZPROP_ERR_NOCLEAR;
	} else {
	*errflags \|= ZPROP_ERR_NOCLEAR;
	}
	}

	/*
	* Stash away existing properties so we can restore them on error unless
	* we're doing the first receive after SPA_VERSION_RECVD_PROPS, in which
	* case "origrecvd" will take care of that.
	*/
	if (localprops != NULL && !drc.drc_newfs && !first_recvd_props) {
	objset_t *os;
	if (dmu_objset_hold(tofs, FTAG, &os) == 0) {
	if (dsl_prop_get_all(os, &origprops) != 0) {
	*errflags \|= ZPROP_ERR_NOCLEAR;
	}
	dmu_objset_rele(os, FTAG);
	} else {
	*errflags \|= ZPROP_ERR_NOCLEAR;
	}
	}

	if (recvprops != NULL) {
	props_error = dsl_prop_set_hasrecvd(tofs);

	if (props_error == 0) {
	recv_delayprops = extract_delay_props(recvprops);
	(void) zfs_set_prop_nvlist(tofs, ZPROP_SRC_RECEIVED,
	recvprops, *errors);
	}
	}

	if (localprops != NULL) {
	nvlist_t *oprops = fnvlist_alloc();
	nvlist_t *xprops = fnvlist_alloc();
	nvpair_t *nvp = NULL;

	while ((nvp = nvlist_next_nvpair(localprops, nvp)) != NULL) {
	if (nvpair_type(nvp) == DATA_TYPE_BOOLEAN) {
	/* -x property */
	const char *name = nvpair_name(nvp);
	zfs_prop_t prop = zfs_name_to_prop(name);
	if (prop != ZPROP_INVAL) {
	if (!zfs_prop_inheritable(prop))
	continue;
	} else if (!zfs_prop_user(name))
	continue;
	fnvlist_add_boolean(xprops, name);
	} else {
	/* -o property=value */
	fnvlist_add_nvpair(oprops, nvp);
	}
	}

	local_delayprops = extract_delay_props(oprops);
	(void) zfs_set_prop_nvlist(tofs, ZPROP_SRC_LOCAL,
	oprops, *errors);
	(void) zfs_set_prop_nvlist(tofs, ZPROP_SRC_INHERITED,
	xprops, *errors);

	nvlist_free(oprops);
	nvlist_free(xprops);
	}

	error = dmu_recv_stream(&drc, &off);

	if (error == 0) {
	zfsvfs_t *zfsvfs = NULL;
	zvol_state_handle_t *zv = NULL;

	if (getzfsvfs(tofs, &zfsvfs) == 0) {
	/* online recv */
	dsl_dataset_t *ds;
	int end_err;
	boolean_t stream_is_redacted = DMU_GET_FEATUREFLAGS(
	begin_record->drr_u.drr_begin.
	drr_versioninfo) & DMU_BACKUP_FEATURE_REDACTED;

	ds = dmu_objset_ds(zfsvfs->z_os);
	error = zfs_suspend_fs(zfsvfs);
	/*
	* If the suspend fails, then the recv_end will
	* likely also fail, and clean up after itself.
	*/
	end_err = dmu_recv_end(&drc, zfsvfs);
	/*
	* If the dataset was not redacted, but we received a
	* redacted stream onto it, we need to unmount the
	* dataset. Otherwise, resume the filesystem.
	*/
	if (error == 0 && !drc.drc_newfs &&
	stream_is_redacted && !tofs_was_redacted) {
	error = zfs_end_fs(zfsvfs, ds);
	} else if (error == 0) {
	error = zfs_resume_fs(zfsvfs, ds);
	}
	error = error ? error : end_err;
	zfs_vfs_rele(zfsvfs);
	} else if ((zv = zvol_suspend(tofs)) != NULL) {
	error = dmu_recv_end(&drc, zvol_tag(zv));
	zvol_resume(zv);
	} else {
	error = dmu_recv_end(&drc, NULL);
	}

	/* Set delayed properties now, after we're done receiving. */
	if (recv_delayprops != NULL && error == 0) {
	(void) zfs_set_prop_nvlist(tofs, ZPROP_SRC_RECEIVED,
	recv_delayprops, *errors);
	}
	if (local_delayprops != NULL && error == 0) {
	(void) zfs_set_prop_nvlist(tofs, ZPROP_SRC_LOCAL,
	local_delayprops, *errors);
	}
	}

	/*
	* Merge delayed props back in with initial props, in case
	* we're DEBUG and zfs_ioc_recv_inject_err is set (which means
	* we have to make sure clear_received_props() includes
	* the delayed properties).
	*
	* Since zfs_ioc_recv_inject_err is only in DEBUG kernels,
	* using ASSERT() will be just like a VERIFY.
	*/
	if (recv_delayprops != NULL) {
	ASSERT(nvlist_merge(recvprops, recv_delayprops, 0) == 0);
	nvlist_free(recv_delayprops);
	}
	if (local_delayprops != NULL) {
	ASSERT(nvlist_merge(localprops, local_delayprops, 0) == 0);
	nvlist_free(local_delayprops);
	}
	*read_bytes = off - noff;

	#ifdef ZFS_DEBUG
	if (zfs_ioc_recv_inject_err) {
	zfs_ioc_recv_inject_err = B_FALSE;
	error = 1;
	}
	#endif

	/*
	* On error, restore the original props.
	*/
	if (error != 0 && recvprops != NULL && !drc.drc_newfs) {
	if (clear_received_props(tofs, recvprops, NULL) != 0) {
	/*
	* We failed to clear the received properties.
	* Since we may have left a $recvd value on the
	* system, we can't clear the $hasrecvd flag.
	*/
	*errflags \|= ZPROP_ERR_NORESTORE;
	} else if (first_recvd_props) {
	dsl_prop_unset_hasrecvd(tofs);
	}

	if (origrecvd == NULL && !drc.drc_newfs) {
	/* We failed to stash the original properties. */
	*errflags \|= ZPROP_ERR_NORESTORE;
	}

	/*
	* dsl_props_set() will not convert RECEIVED to LOCAL on or
	* after SPA_VERSION_RECVD_PROPS, so we need to specify LOCAL
	* explicitly if we're restoring local properties cleared in the
	* first new-style receive.
	*/
	if (origrecvd != NULL &&
	zfs_set_prop_nvlist(tofs, (first_recvd_props ?
	ZPROP_SRC_LOCAL : ZPROP_SRC_RECEIVED),
	origrecvd, NULL) != 0) {
	/*
	* We stashed the original properties but failed to
	* restore them.
	*/
	*errflags \|= ZPROP_ERR_NORESTORE;
	}
	}
	if (error != 0 && localprops != NULL && !drc.drc_newfs &&
	!first_recvd_props) {
	nvlist_t *setprops;
	nvlist_t *inheritprops;
	nvpair_t *nvp;

	if (origprops == NULL) {
	/* We failed to stash the original properties. */
	*errflags \|= ZPROP_ERR_NORESTORE;
	goto out;
	}

	/* Restore original props */
	setprops = fnvlist_alloc();
	inheritprops = fnvlist_alloc();
	nvp = NULL;
	while ((nvp = nvlist_next_nvpair(localprops, nvp)) != NULL) {
	const char *name = nvpair_name(nvp);
	const char *source;
	nvlist_t *attrs;

	if (!nvlist_exists(origprops, name)) {
	/*
	* Property was not present or was explicitly
	* inherited before the receive, restore this.
	*/
	fnvlist_add_boolean(inheritprops, name);
	continue;
	}
	attrs = fnvlist_lookup_nvlist(origprops, name);
	source = fnvlist_lookup_string(attrs, ZPROP_SOURCE);

	/* Skip received properties */
	if (strcmp(source, ZPROP_SOURCE_VAL_RECVD) == 0)
	continue;

	if (strcmp(source, tofs) == 0) {
	/* Property was locally set */
	fnvlist_add_nvlist(setprops, name, attrs);
	} else {
	/* Property was implicitly inherited */
	fnvlist_add_boolean(inheritprops, name);
	}
	}

	if (zfs_set_prop_nvlist(tofs, ZPROP_SRC_LOCAL, setprops,
	NULL) != 0)
	*errflags \|= ZPROP_ERR_NORESTORE;
	if (zfs_set_prop_nvlist(tofs, ZPROP_SRC_INHERITED, inheritprops,
	NULL) != 0)
	*errflags \|= ZPROP_ERR_NORESTORE;

	nvlist_free(setprops);
	nvlist_free(inheritprops);
	}
	out:
	zfs_file_put(input_fd);
	nvlist_free(origrecvd);
	nvlist_free(origprops);

	if (error == 0)
	error = props_error;

	return (error);
	}

	/*
	* inputs:
	* zc_name name of containing filesystem (unused)
	* zc_nvlist_src{_size} nvlist of properties to apply
	* zc_nvlist_conf{_size} nvlist of properties to exclude
	* (DATA_TYPE_BOOLEAN) and override (everything else)
	* zc_value name of snapshot to create
	* zc_string name of clone origin (if DRR_FLAG_CLONE)
	* zc_cookie file descriptor to recv from
	* zc_begin_record the BEGIN record of the stream (not byteswapped)
	* zc_guid force flag
	*
	* outputs:
	* zc_cookie number of bytes read
	* zc_obj zprop_errflags_t
	* zc_nvlist_dst{_size} error for each unapplied received property
	*/
	static int
	zfs_ioc_recv(zfs_cmd_t *zc)
	{
	dmu_replay_record_t begin_record;
	nvlist_t *errors = NULL;
	nvlist_t *recvdprops = NULL;
	nvlist_t *localprops = NULL;
	char *origin = NULL;
	char *tosnap;
	char tofs[ZFS_MAX_DATASET_NAME_LEN];
	int error = 0;

	if (dataset_namecheck(zc->zc_value, NULL, NULL) != 0 \|\|
	strchr(zc->zc_value, '@') == NULL \|\|
	strchr(zc->zc_value, '%'))
	return (SET_ERROR(EINVAL));

	(void) strlcpy(tofs, zc->zc_value, sizeof (tofs));
	tosnap = strchr(tofs, '@');
	*tosnap++ = '\0';

	if (zc->zc_nvlist_src != 0 &&
	(error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
	zc->zc_iflags, &recvdprops)) != 0)
	return (error);

	if (zc->zc_nvlist_conf != 0 &&
	(error = get_nvlist(zc->zc_nvlist_conf, zc->zc_nvlist_conf_size,
	zc->zc_iflags, &localprops)) != 0)
	return (error);

	if (zc->zc_string[0])
	origin = zc->zc_string;

	begin_record.drr_type = DRR_BEGIN;
	begin_record.drr_payloadlen = 0;
	begin_record.drr_u.drr_begin = zc->zc_begin_record;

	error = zfs_ioc_recv_impl(tofs, tosnap, origin, recvdprops, localprops,
	NULL, zc->zc_guid, B_FALSE, zc->zc_cookie, &begin_record,
	&zc->zc_cookie, &zc->zc_obj, &errors);
	nvlist_free(recvdprops);
	nvlist_free(localprops);

	/*
	* Now that all props, initial and delayed, are set, report the prop
	* errors to the caller.
	*/
	if (zc->zc_nvlist_dst_size != 0 && errors != NULL &&
	(nvlist_smush(errors, zc->zc_nvlist_dst_size) != 0 \|\|
	put_nvlist(zc, errors) != 0)) {
	/*
	* Caller made zc->zc_nvlist_dst less than the minimum expected
	* size or supplied an invalid address.
	*/
	error = SET_ERROR(EINVAL);
	}

	nvlist_free(errors);

	return (error);
	}

	/*
	* innvl: {
	* "snapname" -> full name of the snapshot to create
	* (optional) "props" -> received properties to set (nvlist)
	* (optional) "localprops" -> override and exclude properties (nvlist)
	* (optional) "origin" -> name of clone origin (DRR_FLAG_CLONE)
	* "begin_record" -> non-byteswapped dmu_replay_record_t
	* "input_fd" -> file descriptor to read stream from (int32)
	* (optional) "force" -> force flag (value ignored)
	* (optional) "resumable" -> resumable flag (value ignored)
	* (optional) "cleanup_fd" -> unused
	* (optional) "action_handle" -> unused
	* (optional) "hidden_args" -> { "wkeydata" -> value }
	* }
	*
	* outnvl: {
	* "read_bytes" -> number of bytes read
	* "error_flags" -> zprop_errflags_t
	* "errors" -> error for each unapplied received property (nvlist)
	* }
	*/
	static const zfs_ioc_key_t zfs_keys_recv_new[] = {
	{"snapname", DATA_TYPE_STRING, 0},
	{"props", DATA_TYPE_NVLIST, ZK_OPTIONAL},
	{"localprops", DATA_TYPE_NVLIST, ZK_OPTIONAL},
	{"origin", DATA_TYPE_STRING, ZK_OPTIONAL},
	{"begin_record", DATA_TYPE_BYTE_ARRAY, 0},
	{"input_fd", DATA_TYPE_INT32, 0},
	{"force", DATA_TYPE_BOOLEAN, ZK_OPTIONAL},
	{"resumable", DATA_TYPE_BOOLEAN, ZK_OPTIONAL},
	{"cleanup_fd", DATA_TYPE_INT32, ZK_OPTIONAL},
	{"action_handle", DATA_TYPE_UINT64, ZK_OPTIONAL},
	{"hidden_args", DATA_TYPE_NVLIST, ZK_OPTIONAL},
	};

	static int
	zfs_ioc_recv_new(const char fsname, nvlist_t innvl, nvlist_t *outnvl)
	{
	dmu_replay_record_t *begin_record;
	uint_t begin_record_size;
	nvlist_t *errors = NULL;
	nvlist_t *recvprops = NULL;
	nvlist_t *localprops = NULL;
	nvlist_t *hidden_args = NULL;
	char *snapname;
	char *origin = NULL;
	char *tosnap;
	char tofs[ZFS_MAX_DATASET_NAME_LEN];
	boolean_t force;
	boolean_t resumable;
	uint64_t read_bytes = 0;
	uint64_t errflags = 0;
	int input_fd = -1;
	int error;

	snapname = fnvlist_lookup_string(innvl, "snapname");

	if (dataset_namecheck(snapname, NULL, NULL) != 0 \|\|
	strchr(snapname, '@') == NULL \|\|
	strchr(snapname, '%'))
	return (SET_ERROR(EINVAL));

	(void) strlcpy(tofs, snapname, sizeof (tofs));
	tosnap = strchr(tofs, '@');
	*tosnap++ = '\0';

	error = nvlist_lookup_string(innvl, "origin", &origin);
	if (error && error != ENOENT)
	return (error);

	error = nvlist_lookup_byte_array(innvl, "begin_record",
	(uchar_t **)&begin_record, &begin_record_size);
	if (error != 0 \|\| begin_record_size != sizeof (*begin_record))
	return (SET_ERROR(EINVAL));

	input_fd = fnvlist_lookup_int32(innvl, "input_fd");

	force = nvlist_exists(innvl, "force");
	resumable = nvlist_exists(innvl, "resumable");

	/* we still use "props" here for backwards compatibility */
	error = nvlist_lookup_nvlist(innvl, "props", &recvprops);
	if (error && error != ENOENT)
	return (error);

	error = nvlist_lookup_nvlist(innvl, "localprops", &localprops);
	if (error && error != ENOENT)
	return (error);

	error = nvlist_lookup_nvlist(innvl, ZPOOL_HIDDEN_ARGS, &hidden_args);
	if (error && error != ENOENT)
	return (error);

	error = zfs_ioc_recv_impl(tofs, tosnap, origin, recvprops, localprops,
	hidden_args, force, resumable, input_fd, begin_record,
	&read_bytes, &errflags, &errors);

	fnvlist_add_uint64(outnvl, "read_bytes", read_bytes);
	fnvlist_add_uint64(outnvl, "error_flags", errflags);
	fnvlist_add_nvlist(outnvl, "errors", errors);

	nvlist_free(errors);
	nvlist_free(recvprops);
	nvlist_free(localprops);

	return (error);
	}

	typedef struct dump_bytes_io {
	zfs_file_t *dbi_fp;
	caddr_t dbi_buf;
	int dbi_len;
	int dbi_err;
	} dump_bytes_io_t;

	static void
	dump_bytes_cb(void *arg)
	{
	dump_bytes_io_t dbi = (dump_bytes_io_t )arg;
	zfs_file_t *fp;
	caddr_t buf;

	fp = dbi->dbi_fp;
	buf = dbi->dbi_buf;

	dbi->dbi_err = zfs_file_write(fp, buf, dbi->dbi_len, NULL);
	}

	static int
	dump_bytes(objset_t os, void buf, int len, void *arg)
	{
	dump_bytes_io_t dbi;

	dbi.dbi_fp = arg;
	dbi.dbi_buf = buf;
	dbi.dbi_len = len;

	#if defined(HAVE_LARGE_STACKS)
	dump_bytes_cb(&dbi);
	#else
	/*
	* The vn_rdwr() call is performed in a taskq to ensure that there is
	* always enough stack space to write safely to the target filesystem.
	* The ZIO_TYPE_FREE threads are used because there can be a lot of
	* them and they are used in vdev_file.c for a similar purpose.
	*/
	spa_taskq_dispatch_sync(dmu_objset_spa(os), ZIO_TYPE_FREE,
	ZIO_TASKQ_ISSUE, dump_bytes_cb, &dbi, TQ_SLEEP);
	#endif /* HAVE_LARGE_STACKS */

	return (dbi.dbi_err);
	}

	/*
	* inputs:
	* zc_name name of snapshot to send
	* zc_cookie file descriptor to send stream to
	* zc_obj fromorigin flag (mutually exclusive with zc_fromobj)
	* zc_sendobj objsetid of snapshot to send
	* zc_fromobj objsetid of incremental fromsnap (may be zero)
	* zc_guid if set, estimate size of stream only. zc_cookie is ignored.
	* output size in zc_objset_type.
	* zc_flags lzc_send_flags
	*
	* outputs:
	* zc_objset_type estimated size, if zc_guid is set
	*
	* NOTE: This is no longer the preferred interface, any new functionality
	* should be added to zfs_ioc_send_new() instead.
	*/
	static int
	zfs_ioc_send(zfs_cmd_t *zc)
	{
	int error;
	offset_t off;
	boolean_t estimate = (zc->zc_guid != 0);
	boolean_t embedok = (zc->zc_flags & 0x1);
	boolean_t large_block_ok = (zc->zc_flags & 0x2);
	boolean_t compressok = (zc->zc_flags & 0x4);
	boolean_t rawok = (zc->zc_flags & 0x8);
	boolean_t savedok = (zc->zc_flags & 0x10);

	if (zc->zc_obj != 0) {
	dsl_pool_t *dp;
	dsl_dataset_t *tosnap;

	error = dsl_pool_hold(zc->zc_name, FTAG, &dp);
	if (error != 0)
	return (error);

	error = dsl_dataset_hold_obj(dp, zc->zc_sendobj, FTAG, &tosnap);
	if (error != 0) {
	dsl_pool_rele(dp, FTAG);
	return (error);
	}

	if (dsl_dir_is_clone(tosnap->ds_dir))
	zc->zc_fromobj =
	dsl_dir_phys(tosnap->ds_dir)->dd_origin_obj;
	dsl_dataset_rele(tosnap, FTAG);
	dsl_pool_rele(dp, FTAG);
	}

	if (estimate) {
	dsl_pool_t *dp;
	dsl_dataset_t *tosnap;
	dsl_dataset_t *fromsnap = NULL;

	error = dsl_pool_hold(zc->zc_name, FTAG, &dp);
	if (error != 0)
	return (error);

	error = dsl_dataset_hold_obj(dp, zc->zc_sendobj,
	FTAG, &tosnap);
	if (error != 0) {
	dsl_pool_rele(dp, FTAG);
	return (error);
	}

	if (zc->zc_fromobj != 0) {
	error = dsl_dataset_hold_obj(dp, zc->zc_fromobj,
	FTAG, &fromsnap);
	if (error != 0) {
	dsl_dataset_rele(tosnap, FTAG);
	dsl_pool_rele(dp, FTAG);
	return (error);
	}
	}

	error = dmu_send_estimate_fast(tosnap, fromsnap, NULL,
	compressok \|\| rawok, savedok, &zc->zc_objset_type);

	if (fromsnap != NULL)
	dsl_dataset_rele(fromsnap, FTAG);
	dsl_dataset_rele(tosnap, FTAG);
	dsl_pool_rele(dp, FTAG);
	} else {
	zfs_file_t *fp;
	dmu_send_outparams_t out = {0};

	if ((error = zfs_file_get(zc->zc_cookie, &fp)))
	return (error);

	off = zfs_file_off(fp);
	out.dso_outfunc = dump_bytes;
	out.dso_arg = fp;
	out.dso_dryrun = B_FALSE;
	error = dmu_send_obj(zc->zc_name, zc->zc_sendobj,
	zc->zc_fromobj, embedok, large_block_ok, compressok,
	rawok, savedok, zc->zc_cookie, &off, &out);

	zfs_file_put(zc->zc_cookie);
	}
	return (error);
	}

	/*
	* inputs:
	* zc_name name of snapshot on which to report progress
	* zc_cookie file descriptor of send stream
	*
	* outputs:
	* zc_cookie number of bytes written in send stream thus far
	* zc_objset_type logical size of data traversed by send thus far
	*/
	static int
	zfs_ioc_send_progress(zfs_cmd_t *zc)
	{
	dsl_pool_t *dp;
	dsl_dataset_t *ds;
	dmu_sendstatus_t *dsp = NULL;
	int error;

	error = dsl_pool_hold(zc->zc_name, FTAG, &dp);
	if (error != 0)
	return (error);

	error = dsl_dataset_hold(dp, zc->zc_name, FTAG, &ds);
	if (error != 0) {
	dsl_pool_rele(dp, FTAG);
	return (error);
	}

	mutex_enter(&ds->ds_sendstream_lock);

	/*
	* Iterate over all the send streams currently active on this dataset.
	* If there's one which matches the specified file descriptor _and_ the
	* stream was started by the current process, return the progress of
	* that stream.
	*/

	for (dsp = list_head(&ds->ds_sendstreams); dsp != NULL;
	dsp = list_next(&ds->ds_sendstreams, dsp)) {
	if (dsp->dss_outfd == zc->zc_cookie &&
	zfs_proc_is_caller(dsp->dss_proc))
	break;
	}

	if (dsp != NULL) {
	zc->zc_cookie = atomic_cas_64((volatile uint64_t *)dsp->dss_off,
	0, 0);
	/* This is the closest thing we have to atomic_read_64. */
	zc->zc_objset_type = atomic_cas_64(&dsp->dss_blocks, 0, 0);
	} else {
	error = SET_ERROR(ENOENT);
	}

	mutex_exit(&ds->ds_sendstream_lock);
	dsl_dataset_rele(ds, FTAG);
	dsl_pool_rele(dp, FTAG);
	return (error);
	}

	static int
	zfs_ioc_inject_fault(zfs_cmd_t *zc)
	{
	int id, error;

	error = zio_inject_fault(zc->zc_name, (int)zc->zc_guid, &id,
	&zc->zc_inject_record);

	if (error == 0)
	zc->zc_guid = (uint64_t)id;

	return (error);
	}

	static int
	zfs_ioc_clear_fault(zfs_cmd_t *zc)
	{
	return (zio_clear_fault((int)zc->zc_guid));
	}

	static int
	zfs_ioc_inject_list_next(zfs_cmd_t *zc)
	{
	int id = (int)zc->zc_guid;
	int error;

	error = zio_inject_list_next(&id, zc->zc_name, sizeof (zc->zc_name),
	&zc->zc_inject_record);

	zc->zc_guid = id;

	return (error);
	}

	static int
	zfs_ioc_error_log(zfs_cmd_t *zc)
	{
	spa_t *spa;
	int error;
	size_t count = (size_t)zc->zc_nvlist_dst_size;

	if ((error = spa_open(zc->zc_name, &spa, FTAG)) != 0)
	return (error);

	error = spa_get_errlog(spa, (void *)(uintptr_t)zc->zc_nvlist_dst,
	&count);
	if (error == 0)
	zc->zc_nvlist_dst_size = count;
	else
	zc->zc_nvlist_dst_size = spa_get_errlog_size(spa);

	spa_close(spa, FTAG);

	return (error);
	}

	static int
	zfs_ioc_clear(zfs_cmd_t *zc)
	{
	spa_t *spa;
	vdev_t *vd;
	int error;

	/*
	* On zpool clear we also fix up missing slogs
	*/
	mutex_enter(&spa_namespace_lock);
	spa = spa_lookup(zc->zc_name);
	if (spa == NULL) {
	mutex_exit(&spa_namespace_lock);
	return (SET_ERROR(EIO));
	}
	if (spa_get_log_state(spa) == SPA_LOG_MISSING) {
	/* we need to let spa_open/spa_load clear the chains */
	spa_set_log_state(spa, SPA_LOG_CLEAR);
	}
	spa->spa_last_open_failed = 0;
	mutex_exit(&spa_namespace_lock);

	if (zc->zc_cookie & ZPOOL_NO_REWIND) {
	error = spa_open(zc->zc_name, &spa, FTAG);
	} else {
	nvlist_t *policy;
	nvlist_t *config = NULL;

	if (zc->zc_nvlist_src == 0)
	return (SET_ERROR(EINVAL));

	if ((error = get_nvlist(zc->zc_nvlist_src,
	zc->zc_nvlist_src_size, zc->zc_iflags, &policy)) == 0) {
	error = spa_open_rewind(zc->zc_name, &spa, FTAG,
	policy, &config);
	if (config != NULL) {
	int err;

	if ((err = put_nvlist(zc, config)) != 0)
	error = err;
	nvlist_free(config);
	}
	nvlist_free(policy);
	}
	}

	if (error != 0)
	return (error);

	/*
	* If multihost is enabled, resuming I/O is unsafe as another
	* host may have imported the pool.
	*/
	if (spa_multihost(spa) && spa_suspended(spa))
	return (SET_ERROR(EINVAL));

	spa_vdev_state_enter(spa, SCL_NONE);

	if (zc->zc_guid == 0) {
	vd = NULL;
	} else {
	vd = spa_lookup_by_guid(spa, zc->zc_guid, B_TRUE);
	if (vd == NULL) {
	error = SET_ERROR(ENODEV);
	(void) spa_vdev_state_exit(spa, NULL, error);
	spa_close(spa, FTAG);
	return (error);
	}
	}

	vdev_clear(spa, vd);

	(void) spa_vdev_state_exit(spa, spa_suspended(spa) ?
	NULL : spa->spa_root_vdev, 0);

	/*
	* Resume any suspended I/Os.
	*/
	if (zio_resume(spa) != 0)
	error = SET_ERROR(EIO);

	spa_close(spa, FTAG);

	return (error);
	}

	/*
	* Reopen all the vdevs associated with the pool.
	*
	* innvl: {
	* "scrub_restart" -> when true and scrub is running, allow to restart
	* scrub as the side effect of the reopen (boolean).
	* }
	*
	* outnvl is unused
	*/
	static const zfs_ioc_key_t zfs_keys_pool_reopen[] = {
	{"scrub_restart", DATA_TYPE_BOOLEAN_VALUE, ZK_OPTIONAL},
	};

	/* ARGSUSED */
	static int
	zfs_ioc_pool_reopen(const char pool, nvlist_t innvl, nvlist_t *outnvl)
	{
	spa_t *spa;
	int error;
	boolean_t rc, scrub_restart = B_TRUE;

	if (innvl) {
	error = nvlist_lookup_boolean_value(innvl,
	"scrub_restart", &rc);
	if (error == 0)
	scrub_restart = rc;
	}

	error = spa_open(pool, &spa, FTAG);
	if (error != 0)
	return (error);

	spa_vdev_state_enter(spa, SCL_NONE);

	/*
	* If the scrub_restart flag is B_FALSE and a scrub is already
	* in progress then set spa_scrub_reopen flag to B_TRUE so that
	* we don't restart the scrub as a side effect of the reopen.
	* Otherwise, let vdev_open() decided if a resilver is required.
	*/

	spa->spa_scrub_reopen = (!scrub_restart &&
	dsl_scan_scrubbing(spa->spa_dsl_pool));
	vdev_reopen(spa->spa_root_vdev);
	spa->spa_scrub_reopen = B_FALSE;

	(void) spa_vdev_state_exit(spa, NULL, 0);
	spa_close(spa, FTAG);
	return (0);
	}

	/*
	* inputs:
	* zc_name name of filesystem
	*
	* outputs:
	* zc_string name of conflicting snapshot, if there is one
	*/
	static int
	zfs_ioc_promote(zfs_cmd_t *zc)
	{
	dsl_pool_t *dp;
	dsl_dataset_t ds, ods;
	char origin[ZFS_MAX_DATASET_NAME_LEN];
	char *cp;
	int error;

	zc->zc_name[sizeof (zc->zc_name) - 1] = '\0';
	if (dataset_namecheck(zc->zc_name, NULL, NULL) != 0 \|\|
	strchr(zc->zc_name, '%'))
	return (SET_ERROR(EINVAL));

	error = dsl_pool_hold(zc->zc_name, FTAG, &dp);
	if (error != 0)
	return (error);

	error = dsl_dataset_hold(dp, zc->zc_name, FTAG, &ds);
	if (error != 0) {
	dsl_pool_rele(dp, FTAG);
	return (error);
	}

	if (!dsl_dir_is_clone(ds->ds_dir)) {
	dsl_dataset_rele(ds, FTAG);
	dsl_pool_rele(dp, FTAG);
	return (SET_ERROR(EINVAL));
	}

	error = dsl_dataset_hold_obj(dp,
	dsl_dir_phys(ds->ds_dir)->dd_origin_obj, FTAG, &ods);
	if (error != 0) {
	dsl_dataset_rele(ds, FTAG);
	dsl_pool_rele(dp, FTAG);
	return (error);
	}

	dsl_dataset_name(ods, origin);
	dsl_dataset_rele(ods, FTAG);
	dsl_dataset_rele(ds, FTAG);
	dsl_pool_rele(dp, FTAG);

	/*
	* We don't need to unmount all the origin fs's snapshots, but
	* it's easier.
	*/
	cp = strchr(origin, '@');
	if (cp)
	*cp = '\0';
	(void) dmu_objset_find(origin,
	zfs_unmount_snap_cb, NULL, DS_FIND_SNAPSHOTS);
	return (dsl_dataset_promote(zc->zc_name, zc->zc_string));
	}

	/*
	* Retrieve a single {user\|group\|project}{used\|quota}@... property.
	*
	* inputs:
	* zc_name name of filesystem
	* zc_objset_type zfs_userquota_prop_t
	* zc_value domain name (eg. "S-1-234-567-89")
	* zc_guid RID/UID/GID
	*
	* outputs:
	* zc_cookie property value
	*/
	static int
	zfs_ioc_userspace_one(zfs_cmd_t *zc)
	{
	zfsvfs_t *zfsvfs;
	int error;

	if (zc->zc_objset_type >= ZFS_NUM_USERQUOTA_PROPS)
	return (SET_ERROR(EINVAL));

	error = zfsvfs_hold(zc->zc_name, FTAG, &zfsvfs, B_FALSE);
	if (error != 0)
	return (error);

	error = zfs_userspace_one(zfsvfs,
	zc->zc_objset_type, zc->zc_value, zc->zc_guid, &zc->zc_cookie);
	zfsvfs_rele(zfsvfs, FTAG);

	return (error);
	}

	/*
	* inputs:
	* zc_name name of filesystem
	* zc_cookie zap cursor
	* zc_objset_type zfs_userquota_prop_t
	* zc_nvlist_dst[_size] buffer to fill (not really an nvlist)
	*
	* outputs:
	* zc_nvlist_dst[_size] data buffer (array of zfs_useracct_t)
	* zc_cookie zap cursor
	*/
	static int
	zfs_ioc_userspace_many(zfs_cmd_t *zc)
	{
	zfsvfs_t *zfsvfs;
	int bufsize = zc->zc_nvlist_dst_size;

	if (bufsize <= 0)
	return (SET_ERROR(ENOMEM));

	int error = zfsvfs_hold(zc->zc_name, FTAG, &zfsvfs, B_FALSE);
	if (error != 0)
	return (error);

	void *buf = vmem_alloc(bufsize, KM_SLEEP);

	error = zfs_userspace_many(zfsvfs, zc->zc_objset_type, &zc->zc_cookie,
	buf, &zc->zc_nvlist_dst_size);

	if (error == 0) {
	error = xcopyout(buf,
	(void *)(uintptr_t)zc->zc_nvlist_dst,
	zc->zc_nvlist_dst_size);
	}
	vmem_free(buf, bufsize);
	zfsvfs_rele(zfsvfs, FTAG);

	return (error);
	}

	/*
	* inputs:
	* zc_name name of filesystem
	*
	* outputs:
	* none
	*/
	static int
	zfs_ioc_userspace_upgrade(zfs_cmd_t *zc)
	{
	int error = 0;
	zfsvfs_t *zfsvfs;

	if (getzfsvfs(zc->zc_name, &zfsvfs) == 0) {
	if (!dmu_objset_userused_enabled(zfsvfs->z_os)) {
	/*
	* If userused is not enabled, it may be because the
	* objset needs to be closed & reopened (to grow the
	* objset_phys_t). Suspend/resume the fs will do that.
	*/
	dsl_dataset_t ds, newds;

	ds = dmu_objset_ds(zfsvfs->z_os);
	error = zfs_suspend_fs(zfsvfs);
	if (error == 0) {
	dmu_objset_refresh_ownership(ds, &newds,
	B_TRUE, zfsvfs);
	error = zfs_resume_fs(zfsvfs, newds);
	}
	}
	if (error == 0) {
	mutex_enter(&zfsvfs->z_os->os_upgrade_lock);
	if (zfsvfs->z_os->os_upgrade_id == 0) {
	/* clear potential error code and retry */
	zfsvfs->z_os->os_upgrade_status = 0;
	mutex_exit(&zfsvfs->z_os->os_upgrade_lock);

	dsl_pool_config_enter(
	dmu_objset_pool(zfsvfs->z_os), FTAG);
	dmu_objset_userspace_upgrade(zfsvfs->z_os);
	dsl_pool_config_exit(
	dmu_objset_pool(zfsvfs->z_os), FTAG);
	} else {
	mutex_exit(&zfsvfs->z_os->os_upgrade_lock);
	}

	taskq_wait_id(zfsvfs->z_os->os_spa->spa_upgrade_taskq,
	zfsvfs->z_os->os_upgrade_id);
	error = zfsvfs->z_os->os_upgrade_status;
	}
	zfs_vfs_rele(zfsvfs);
	} else {
	objset_t *os;

	/* XXX kind of reading contents without owning */
	error = dmu_objset_hold_flags(zc->zc_name, B_TRUE, FTAG, &os);
	if (error != 0)
	return (error);

	mutex_enter(&os->os_upgrade_lock);
	if (os->os_upgrade_id == 0) {
	/* clear potential error code and retry */
	os->os_upgrade_status = 0;
	mutex_exit(&os->os_upgrade_lock);

	dmu_objset_userspace_upgrade(os);
	} else {
	mutex_exit(&os->os_upgrade_lock);
	}

	dsl_pool_rele(dmu_objset_pool(os), FTAG);

	taskq_wait_id(os->os_spa->spa_upgrade_taskq, os->os_upgrade_id);
	error = os->os_upgrade_status;

	dsl_dataset_rele_flags(dmu_objset_ds(os), DS_HOLD_FLAG_DECRYPT,
	FTAG);
	}
	return (error);
	}

	/*
	* inputs:
	* zc_name name of filesystem
	*
	* outputs:
	* none
	*/
	static int
	zfs_ioc_id_quota_upgrade(zfs_cmd_t *zc)
	{
	objset_t *os;
	int error;

	error = dmu_objset_hold_flags(zc->zc_name, B_TRUE, FTAG, &os);
	if (error != 0)
	return (error);

	if (dmu_objset_userobjspace_upgradable(os) \|\|
	dmu_objset_projectquota_upgradable(os)) {
	mutex_enter(&os->os_upgrade_lock);
	if (os->os_upgrade_id == 0) {
	/* clear potential error code and retry */
	os->os_upgrade_status = 0;
	mutex_exit(&os->os_upgrade_lock);

	dmu_objset_id_quota_upgrade(os);
	} else {
	mutex_exit(&os->os_upgrade_lock);
	}

	dsl_pool_rele(dmu_objset_pool(os), FTAG);

	taskq_wait_id(os->os_spa->spa_upgrade_taskq, os->os_upgrade_id);
	error = os->os_upgrade_status;
	} else {
	dsl_pool_rele(dmu_objset_pool(os), FTAG);
	}

	dsl_dataset_rele_flags(dmu_objset_ds(os), DS_HOLD_FLAG_DECRYPT, FTAG);

	return (error);
	}

	static int
	zfs_ioc_share(zfs_cmd_t *zc)
	{
	return (SET_ERROR(ENOSYS));
	}

	ace_t full_access[] = {
	{(uid_t)-1, ACE_ALL_PERMS, ACE_EVERYONE, 0}
	};

	/*
	* inputs:
	* zc_name name of containing filesystem
	* zc_obj object # beyond which we want next in-use object #
	*
	* outputs:
	* zc_obj next in-use object #
	*/
	static int
	zfs_ioc_next_obj(zfs_cmd_t *zc)
	{
	objset_t *os = NULL;
	int error;

	error = dmu_objset_hold(zc->zc_name, FTAG, &os);
	if (error != 0)
	return (error);

	error = dmu_object_next(os, &zc->zc_obj, B_FALSE, 0);

	dmu_objset_rele(os, FTAG);
	return (error);
	}

	/*
	* inputs:
	* zc_name name of filesystem
	* zc_value prefix name for snapshot
	* zc_cleanup_fd cleanup-on-exit file descriptor for calling process
	*
	* outputs:
	* zc_value short name of new snapshot
	*/
	static int
	zfs_ioc_tmp_snapshot(zfs_cmd_t *zc)
	{
	char *snap_name;
	char *hold_name;
	int error;
	minor_t minor;

	error = zfs_onexit_fd_hold(zc->zc_cleanup_fd, &minor);
	if (error != 0)
	return (error);

	snap_name = kmem_asprintf("%s-%016llx", zc->zc_value,
	(u_longlong_t)ddi_get_lbolt64());
	hold_name = kmem_asprintf("%%%s", zc->zc_value);

	error = dsl_dataset_snapshot_tmp(zc->zc_name, snap_name, minor,
	hold_name);
	if (error == 0)
	(void) strlcpy(zc->zc_value, snap_name,
	sizeof (zc->zc_value));
	kmem_strfree(snap_name);
	kmem_strfree(hold_name);
	zfs_onexit_fd_rele(zc->zc_cleanup_fd);
	return (error);
	}

	/*
	* inputs:
	* zc_name name of "to" snapshot
	* zc_value name of "from" snapshot
	* zc_cookie file descriptor to write diff data on
	*
	* outputs:
	* dmu_diff_record_t's to the file descriptor
	*/
	static int
	zfs_ioc_diff(zfs_cmd_t *zc)
	{
	zfs_file_t *fp;
	offset_t off;
	int error;

	if ((error = zfs_file_get(zc->zc_cookie, &fp)))
	return (error);

	off = zfs_file_off(fp);
	error = dmu_diff(zc->zc_name, zc->zc_value, fp, &off);

	zfs_file_put(zc->zc_cookie);

	return (error);
	}

	static int
	zfs_ioc_smb_acl(zfs_cmd_t *zc)
	{
	return (SET_ERROR(ENOTSUP));
	}

	/*
	* innvl: {
	* "holds" -> { snapname -> holdname (string), ... }
	* (optional) "cleanup_fd" -> fd (int32)
	* }
	*
	* outnvl: {
	* snapname -> error value (int32)
	* ...
	* }
	*/
	static const zfs_ioc_key_t zfs_keys_hold[] = {
	{"holds", DATA_TYPE_NVLIST, 0},
	{"cleanup_fd", DATA_TYPE_INT32, ZK_OPTIONAL},
	};

	/* ARGSUSED */
	static int
	zfs_ioc_hold(const char pool, nvlist_t args, nvlist_t *errlist)
	{
	nvpair_t *pair;
	nvlist_t *holds;
	int cleanup_fd = -1;
	int error;
	minor_t minor = 0;

	holds = fnvlist_lookup_nvlist(args, "holds");

	/* make sure the user didn't pass us any invalid (empty) tags */
	for (pair = nvlist_next_nvpair(holds, NULL); pair != NULL;
	pair = nvlist_next_nvpair(holds, pair)) {
	char *htag;

	error = nvpair_value_string(pair, &htag);
	if (error != 0)
	return (SET_ERROR(error));

	if (strlen(htag) == 0)
	return (SET_ERROR(EINVAL));
	}

	if (nvlist_lookup_int32(args, "cleanup_fd", &cleanup_fd) == 0) {
	error = zfs_onexit_fd_hold(cleanup_fd, &minor);
	if (error != 0)
	return (SET_ERROR(error));
	}

	error = dsl_dataset_user_hold(holds, minor, errlist);
	if (minor != 0)
	zfs_onexit_fd_rele(cleanup_fd);
	return (SET_ERROR(error));
	}

	/*
	* innvl is not used.
	*
	* outnvl: {
	* holdname -> time added (uint64 seconds since epoch)
	* ...
	* }
	*/
	static const zfs_ioc_key_t zfs_keys_get_holds[] = {
	/* no nvl keys */
	};

	/* ARGSUSED */
	static int
	zfs_ioc_get_holds(const char snapname, nvlist_t args, nvlist_t *outnvl)
	{
	return (dsl_dataset_get_holds(snapname, outnvl));
	}

	/*
	* innvl: {
	* snapname -> { holdname, ... }
	* ...
	* }
	*
	* outnvl: {
	* snapname -> error value (int32)
	* ...
	* }
	*/
	static const zfs_ioc_key_t zfs_keys_release[] = {
	{"<snapname>...", DATA_TYPE_NVLIST, ZK_WILDCARDLIST},
	};

	/* ARGSUSED */
	static int
	zfs_ioc_release(const char pool, nvlist_t holds, nvlist_t *errlist)
	{
	return (dsl_dataset_user_release(holds, errlist));
	}

	/*
	* inputs:
	* zc_guid flags (ZEVENT_NONBLOCK)
	* zc_cleanup_fd zevent file descriptor
	*
	* outputs:
	* zc_nvlist_dst next nvlist event
	* zc_cookie dropped events since last get
	*/
	static int
	zfs_ioc_events_next(zfs_cmd_t *zc)
	{
	zfs_zevent_t *ze;
	nvlist_t *event = NULL;
	minor_t minor;
	uint64_t dropped = 0;
	int error;

	error = zfs_zevent_fd_hold(zc->zc_cleanup_fd, &minor, &ze);
	if (error != 0)
	return (error);

	do {
	error = zfs_zevent_next(ze, &event,
	&zc->zc_nvlist_dst_size, &dropped);
	if (event != NULL) {
	zc->zc_cookie = dropped;
	error = put_nvlist(zc, event);
	nvlist_free(event);
	}

	if (zc->zc_guid & ZEVENT_NONBLOCK)
	break;

	if ((error == 0) \|\| (error != ENOENT))
	break;

	error = zfs_zevent_wait(ze);
	if (error != 0)
	break;
	} while (1);

	zfs_zevent_fd_rele(zc->zc_cleanup_fd);

	return (error);
	}

	/*
	* outputs:
	* zc_cookie cleared events count
	*/
	static int
	zfs_ioc_events_clear(zfs_cmd_t *zc)
	{
	int count;

	zfs_zevent_drain_all(&count);
	zc->zc_cookie = count;

	return (0);
	}

	/*
	* inputs:
	* zc_guid eid \| ZEVENT_SEEK_START \| ZEVENT_SEEK_END
	* zc_cleanup zevent file descriptor
	*/
	static int
	zfs_ioc_events_seek(zfs_cmd_t *zc)
	{
	zfs_zevent_t *ze;
	minor_t minor;
	int error;

	error = zfs_zevent_fd_hold(zc->zc_cleanup_fd, &minor, &ze);
	if (error != 0)
	return (error);

	error = zfs_zevent_seek(ze, zc->zc_guid);
	zfs_zevent_fd_rele(zc->zc_cleanup_fd);

	return (error);
	}

	/*
	* inputs:
	* zc_name name of later filesystem or snapshot
	* zc_value full name of old snapshot or bookmark
	*
	* outputs:
	* zc_cookie space in bytes
	* zc_objset_type compressed space in bytes
	* zc_perm_action uncompressed space in bytes
	*/
	static int
	zfs_ioc_space_written(zfs_cmd_t *zc)
	{
	int error;
	dsl_pool_t *dp;
	dsl_dataset_t *new;

	error = dsl_pool_hold(zc->zc_name, FTAG, &dp);
	if (error != 0)
	return (error);
	error = dsl_dataset_hold(dp, zc->zc_name, FTAG, &new);
	if (error != 0) {
	dsl_pool_rele(dp, FTAG);
	return (error);
	}
	if (strchr(zc->zc_value, '#') != NULL) {
	zfs_bookmark_phys_t bmp;
	error = dsl_bookmark_lookup(dp, zc->zc_value,
	new, &bmp);
	if (error == 0) {
	error = dsl_dataset_space_written_bookmark(&bmp, new,
	&zc->zc_cookie,
	&zc->zc_objset_type, &zc->zc_perm_action);
	}
	} else {
	dsl_dataset_t *old;
	error = dsl_dataset_hold(dp, zc->zc_value, FTAG, &old);

	if (error == 0) {
	error = dsl_dataset_space_written(old, new,
	&zc->zc_cookie,
	&zc->zc_objset_type, &zc->zc_perm_action);
	dsl_dataset_rele(old, FTAG);
	}
	}
	dsl_dataset_rele(new, FTAG);
	dsl_pool_rele(dp, FTAG);
	return (error);
	}

	/*
	* innvl: {
	* "firstsnap" -> snapshot name
	* }
	*
	* outnvl: {
	* "used" -> space in bytes
	* "compressed" -> compressed space in bytes
	* "uncompressed" -> uncompressed space in bytes
	* }
	*/
	static const zfs_ioc_key_t zfs_keys_space_snaps[] = {
	{"firstsnap", DATA_TYPE_STRING, 0},
	};

	static int
	zfs_ioc_space_snaps(const char lastsnap, nvlist_t innvl, nvlist_t *outnvl)
	{
	int error;
	dsl_pool_t *dp;
	dsl_dataset_t new, old;
	char *firstsnap;
	uint64_t used, comp, uncomp;

	firstsnap = fnvlist_lookup_string(innvl, "firstsnap");

	error = dsl_pool_hold(lastsnap, FTAG, &dp);
	if (error != 0)
	return (error);

	error = dsl_dataset_hold(dp, lastsnap, FTAG, &new);
	if (error == 0 && !new->ds_is_snapshot) {
	dsl_dataset_rele(new, FTAG);
	error = SET_ERROR(EINVAL);
	}
	if (error != 0) {
	dsl_pool_rele(dp, FTAG);
	return (error);
	}
	error = dsl_dataset_hold(dp, firstsnap, FTAG, &old);
	if (error == 0 && !old->ds_is_snapshot) {
	dsl_dataset_rele(old, FTAG);
	error = SET_ERROR(EINVAL);
	}
	if (error != 0) {
	dsl_dataset_rele(new, FTAG);
	dsl_pool_rele(dp, FTAG);
	return (error);
	}

	error = dsl_dataset_space_wouldfree(old, new, &used, &comp, &uncomp);
	dsl_dataset_rele(old, FTAG);
	dsl_dataset_rele(new, FTAG);
	dsl_pool_rele(dp, FTAG);
	fnvlist_add_uint64(outnvl, "used", used);
	fnvlist_add_uint64(outnvl, "compressed", comp);
	fnvlist_add_uint64(outnvl, "uncompressed", uncomp);
	return (error);
	}

	/*
	* innvl: {
	* "fd" -> file descriptor to write stream to (int32)
	* (optional) "fromsnap" -> full snap name to send an incremental from
	* (optional) "largeblockok" -> (value ignored)
	* indicates that blocks > 128KB are permitted
	* (optional) "embedok" -> (value ignored)
	* presence indicates DRR_WRITE_EMBEDDED records are permitted
	* (optional) "compressok" -> (value ignored)
	* presence indicates compressed DRR_WRITE records are permitted
	* (optional) "rawok" -> (value ignored)
	* presence indicates raw encrypted records should be used.
	* (optional) "savedok" -> (value ignored)
	* presence indicates we should send a partially received snapshot
	* (optional) "resume_object" and "resume_offset" -> (uint64)
	* if present, resume send stream from specified object and offset.
	* (optional) "redactbook" -> (string)
	* if present, use this bookmark's redaction list to generate a redacted
	* send stream
	* }
	*
	* outnvl is unused
	*/
	static const zfs_ioc_key_t zfs_keys_send_new[] = {
	{"fd", DATA_TYPE_INT32, 0},
	{"fromsnap", DATA_TYPE_STRING, ZK_OPTIONAL},
	{"largeblockok", DATA_TYPE_BOOLEAN, ZK_OPTIONAL},
	{"embedok", DATA_TYPE_BOOLEAN, ZK_OPTIONAL},
	{"compressok", DATA_TYPE_BOOLEAN, ZK_OPTIONAL},
	{"rawok", DATA_TYPE_BOOLEAN, ZK_OPTIONAL},
	{"savedok", DATA_TYPE_BOOLEAN, ZK_OPTIONAL},
	{"resume_object", DATA_TYPE_UINT64, ZK_OPTIONAL},
	{"resume_offset", DATA_TYPE_UINT64, ZK_OPTIONAL},
	{"redactbook", DATA_TYPE_STRING, ZK_OPTIONAL},
	};

	/* ARGSUSED */
	static int
	zfs_ioc_send_new(const char snapname, nvlist_t innvl, nvlist_t *outnvl)
	{
	int error;
	offset_t off;
	char *fromname = NULL;
	int fd;
	zfs_file_t *fp;
	boolean_t largeblockok;
	boolean_t embedok;
	boolean_t compressok;
	boolean_t rawok;
	boolean_t savedok;
	uint64_t resumeobj = 0;
	uint64_t resumeoff = 0;
	char *redactbook = NULL;

	fd = fnvlist_lookup_int32(innvl, "fd");

	(void) nvlist_lookup_string(innvl, "fromsnap", &fromname);

	largeblockok = nvlist_exists(innvl, "largeblockok");
	embedok = nvlist_exists(innvl, "embedok");
	compressok = nvlist_exists(innvl, "compressok");
	rawok = nvlist_exists(innvl, "rawok");
	savedok = nvlist_exists(innvl, "savedok");

	(void) nvlist_lookup_uint64(innvl, "resume_object", &resumeobj);
	(void) nvlist_lookup_uint64(innvl, "resume_offset", &resumeoff);

	(void) nvlist_lookup_string(innvl, "redactbook", &redactbook);

	if ((error = zfs_file_get(fd, &fp)))
	return (error);

	off = zfs_file_off(fp);

	dmu_send_outparams_t out = {0};
	out.dso_outfunc = dump_bytes;
	out.dso_arg = fp;
	out.dso_dryrun = B_FALSE;
	error = dmu_send(snapname, fromname, embedok, largeblockok,
	compressok, rawok, savedok, resumeobj, resumeoff,
	redactbook, fd, &off, &out);

	zfs_file_put(fd);
	return (error);
	}

	/* ARGSUSED */
	static int
	send_space_sum(objset_t os, void buf, int len, void *arg)
	{
	uint64_t *size = arg;
	*size += len;
	return (0);
	}

	/*
	* Determine approximately how large a zfs send stream will be -- the number
	* of bytes that will be written to the fd supplied to zfs_ioc_send_new().
	*
	* innvl: {
	* (optional) "from" -> full snap or bookmark name to send an incremental
	* from
	* (optional) "largeblockok" -> (value ignored)
	* indicates that blocks > 128KB are permitted
	* (optional) "embedok" -> (value ignored)
	* presence indicates DRR_WRITE_EMBEDDED records are permitted
	* (optional) "compressok" -> (value ignored)
	* presence indicates compressed DRR_WRITE records are permitted
	* (optional) "rawok" -> (value ignored)
	* presence indicates raw encrypted records should be used.
	* (optional) "resume_object" and "resume_offset" -> (uint64)
	* if present, resume send stream from specified object and offset.
	* (optional) "fd" -> file descriptor to use as a cookie for progress
	* tracking (int32)
	* }
	*
	* outnvl: {
	* "space" -> bytes of space (uint64)
	* }
	*/
	static const zfs_ioc_key_t zfs_keys_send_space[] = {
	{"from", DATA_TYPE_STRING, ZK_OPTIONAL},
	{"fromsnap", DATA_TYPE_STRING, ZK_OPTIONAL},
	{"largeblockok", DATA_TYPE_BOOLEAN, ZK_OPTIONAL},
	{"embedok", DATA_TYPE_BOOLEAN, ZK_OPTIONAL},
	{"compressok", DATA_TYPE_BOOLEAN, ZK_OPTIONAL},
	{"rawok", DATA_TYPE_BOOLEAN, ZK_OPTIONAL},
	{"fd", DATA_TYPE_INT32, ZK_OPTIONAL},
	{"redactbook", DATA_TYPE_STRING, ZK_OPTIONAL},
	{"resume_object", DATA_TYPE_UINT64, ZK_OPTIONAL},
	{"resume_offset", DATA_TYPE_UINT64, ZK_OPTIONAL},
	{"bytes", DATA_TYPE_UINT64, ZK_OPTIONAL},
	};

	static int
	zfs_ioc_send_space(const char snapname, nvlist_t innvl, nvlist_t *outnvl)
	{
	dsl_pool_t *dp;
	dsl_dataset_t *tosnap;
	dsl_dataset_t *fromsnap = NULL;
	int error;
	char *fromname = NULL;
	char *redactlist_book = NULL;
	boolean_t largeblockok;
	boolean_t embedok;
	boolean_t compressok;
	boolean_t rawok;
	boolean_t savedok;
	uint64_t space = 0;
	boolean_t full_estimate = B_FALSE;
	uint64_t resumeobj = 0;
	uint64_t resumeoff = 0;
	uint64_t resume_bytes = 0;
	int32_t fd = -1;
	zfs_bookmark_phys_t zbm = {0};

	error = dsl_pool_hold(snapname, FTAG, &dp);
	if (error != 0)
	return (error);

	error = dsl_dataset_hold(dp, snapname, FTAG, &tosnap);
	if (error != 0) {
	dsl_pool_rele(dp, FTAG);
	return (error);
	}
	(void) nvlist_lookup_int32(innvl, "fd", &fd);

	largeblockok = nvlist_exists(innvl, "largeblockok");
	embedok = nvlist_exists(innvl, "embedok");
	compressok = nvlist_exists(innvl, "compressok");
	rawok = nvlist_exists(innvl, "rawok");
	savedok = nvlist_exists(innvl, "savedok");
	boolean_t from = (nvlist_lookup_string(innvl, "from", &fromname) == 0);
	boolean_t altbook = (nvlist_lookup_string(innvl, "redactbook",
	&redactlist_book) == 0);

	(void) nvlist_lookup_uint64(innvl, "resume_object", &resumeobj);
	(void) nvlist_lookup_uint64(innvl, "resume_offset", &resumeoff);
	(void) nvlist_lookup_uint64(innvl, "bytes", &resume_bytes);

	if (altbook) {
	full_estimate = B_TRUE;
	} else if (from) {
	if (strchr(fromname, '#')) {
	error = dsl_bookmark_lookup(dp, fromname, tosnap, &zbm);

	/*
	* dsl_bookmark_lookup() will fail with EXDEV if
	* the from-bookmark and tosnap are at the same txg.
	* However, it's valid to do a send (and therefore,
	* a send estimate) from and to the same time point,
	* if the bookmark is redacted (the incremental send
	* can change what's redacted on the target). In
	* this case, dsl_bookmark_lookup() fills in zbm
	* but returns EXDEV. Ignore this error.
	*/
	if (error == EXDEV && zbm.zbm_redaction_obj != 0 &&
	zbm.zbm_guid ==
	dsl_dataset_phys(tosnap)->ds_guid)
	error = 0;

	if (error != 0) {
	dsl_dataset_rele(tosnap, FTAG);
	dsl_pool_rele(dp, FTAG);
	return (error);
	}
	if (zbm.zbm_redaction_obj != 0 \|\| !(zbm.zbm_flags &
	ZBM_FLAG_HAS_FBN)) {
	full_estimate = B_TRUE;
	}
	} else if (strchr(fromname, '@')) {
	error = dsl_dataset_hold(dp, fromname, FTAG, &fromsnap);
	if (error != 0) {
	dsl_dataset_rele(tosnap, FTAG);
	dsl_pool_rele(dp, FTAG);
	return (error);
	}

	if (!dsl_dataset_is_before(tosnap, fromsnap, 0)) {
	full_estimate = B_TRUE;
	dsl_dataset_rele(fromsnap, FTAG);
	}
	} else {
	/*
	* from is not properly formatted as a snapshot or
	* bookmark
	*/
	dsl_dataset_rele(tosnap, FTAG);
	dsl_pool_rele(dp, FTAG);
	return (SET_ERROR(EINVAL));
	}
	}

	if (full_estimate) {
	dmu_send_outparams_t out = {0};
	offset_t off = 0;
	out.dso_outfunc = send_space_sum;
	out.dso_arg = &space;
	out.dso_dryrun = B_TRUE;
	/*
	* We have to release these holds so dmu_send can take them. It
	* will do all the error checking we need.
	*/
	dsl_dataset_rele(tosnap, FTAG);
	dsl_pool_rele(dp, FTAG);
	error = dmu_send(snapname, fromname, embedok, largeblockok,
	compressok, rawok, savedok, resumeobj, resumeoff,
	redactlist_book, fd, &off, &out);
	} else {
	error = dmu_send_estimate_fast(tosnap, fromsnap,
	(from && strchr(fromname, '#') != NULL ? &zbm : NULL),
	compressok \|\| rawok, savedok, &space);
	space -= resume_bytes;
	if (fromsnap != NULL)
	dsl_dataset_rele(fromsnap, FTAG);
	dsl_dataset_rele(tosnap, FTAG);
	dsl_pool_rele(dp, FTAG);
	}

	fnvlist_add_uint64(outnvl, "space", space);

	return (error);
	}

	/*
	* Sync the currently open TXG to disk for the specified pool.
	* This is somewhat similar to 'zfs_sync()'.
	* For cases that do not result in error this ioctl will wait for
	* the currently open TXG to commit before returning back to the caller.
	*
	* innvl: {
	* "force" -> when true, force uberblock update even if there is no dirty data.
	* In addition this will cause the vdev configuration to be written
	* out including updating the zpool cache file. (boolean_t)
	* }
	*
	* onvl is unused
	*/
	static const zfs_ioc_key_t zfs_keys_pool_sync[] = {
	{"force", DATA_TYPE_BOOLEAN_VALUE, 0},
	};

	/* ARGSUSED */
	static int
	zfs_ioc_pool_sync(const char pool, nvlist_t innvl, nvlist_t *onvl)
	{
	int err;
	boolean_t rc, force = B_FALSE;
	spa_t *spa;

	if ((err = spa_open(pool, &spa, FTAG)) != 0)
	return (err);

	if (innvl) {
	err = nvlist_lookup_boolean_value(innvl, "force", &rc);
	if (err == 0)
	force = rc;
	}

	if (force) {
	spa_config_enter(spa, SCL_CONFIG, FTAG, RW_WRITER);
	vdev_config_dirty(spa->spa_root_vdev);
	spa_config_exit(spa, SCL_CONFIG, FTAG);
	}
	txg_wait_synced(spa_get_dsl(spa), 0);

	spa_close(spa, FTAG);

	return (0);
	}

	/*
	* Load a user's wrapping key into the kernel.
	* innvl: {
	* "hidden_args" -> { "wkeydata" -> value }
	* raw uint8_t array of encryption wrapping key data (32 bytes)
	* (optional) "noop" -> (value ignored)
	* presence indicated key should only be verified, not loaded
	* }
	*/
	static const zfs_ioc_key_t zfs_keys_load_key[] = {
	{"hidden_args", DATA_TYPE_NVLIST, 0},
	{"noop", DATA_TYPE_BOOLEAN, ZK_OPTIONAL},
	};

	/* ARGSUSED */
	static int
	zfs_ioc_load_key(const char dsname, nvlist_t innvl, nvlist_t *outnvl)
	{
	int ret;
	dsl_crypto_params_t *dcp = NULL;
	nvlist_t *hidden_args;
	boolean_t noop = nvlist_exists(innvl, "noop");

	if (strchr(dsname, '@') != NULL \|\| strchr(dsname, '%') != NULL) {
	ret = SET_ERROR(EINVAL);
	goto error;
	}

	hidden_args = fnvlist_lookup_nvlist(innvl, ZPOOL_HIDDEN_ARGS);

	ret = dsl_crypto_params_create_nvlist(DCP_CMD_NONE, NULL,
	hidden_args, &dcp);
	if (ret != 0)
	goto error;

	ret = spa_keystore_load_wkey(dsname, dcp, noop);
	if (ret != 0)
	goto error;

	dsl_crypto_params_free(dcp, noop);

	return (0);

	error:
	dsl_crypto_params_free(dcp, B_TRUE);
	return (ret);
	}

	/*
	* Unload a user's wrapping key from the kernel.
	* Both innvl and outnvl are unused.
	*/
	static const zfs_ioc_key_t zfs_keys_unload_key[] = {
	/* no nvl keys */
	};

	/* ARGSUSED */
	static int
	zfs_ioc_unload_key(const char dsname, nvlist_t innvl, nvlist_t *outnvl)
	{
	int ret = 0;

	if (strchr(dsname, '@') != NULL \|\| strchr(dsname, '%') != NULL) {
	ret = (SET_ERROR(EINVAL));
	goto out;
	}

	ret = spa_keystore_unload_wkey(dsname);
	if (ret != 0)
	goto out;

	out:
	return (ret);
	}

	/*
	* Changes a user's wrapping key used to decrypt a dataset. The keyformat,
	* keylocation, pbkdf2salt, and pbkdf2iters properties can also be specified
	* here to change how the key is derived in userspace.
	*
	* innvl: {
	* "hidden_args" (optional) -> { "wkeydata" -> value }
	* raw uint8_t array of new encryption wrapping key data (32 bytes)
	* "props" (optional) -> { prop -> value }
	* }
	*
	* outnvl is unused
	*/
	static const zfs_ioc_key_t zfs_keys_change_key[] = {
	{"crypt_cmd", DATA_TYPE_UINT64, ZK_OPTIONAL},
	{"hidden_args", DATA_TYPE_NVLIST, ZK_OPTIONAL},
	{"props", DATA_TYPE_NVLIST, ZK_OPTIONAL},
	};

	/* ARGSUSED */
	static int
	zfs_ioc_change_key(const char dsname, nvlist_t innvl, nvlist_t *outnvl)
	{
	int ret;
	uint64_t cmd = DCP_CMD_NONE;
	dsl_crypto_params_t *dcp = NULL;
	nvlist_t args = NULL, hidden_args = NULL;

	if (strchr(dsname, '@') != NULL \|\| strchr(dsname, '%') != NULL) {
	ret = (SET_ERROR(EINVAL));
	goto error;
	}

	(void) nvlist_lookup_uint64(innvl, "crypt_cmd", &cmd);
	(void) nvlist_lookup_nvlist(innvl, "props", &args);
	(void) nvlist_lookup_nvlist(innvl, ZPOOL_HIDDEN_ARGS, &hidden_args);

	ret = dsl_crypto_params_create_nvlist(cmd, args, hidden_args, &dcp);
	if (ret != 0)
	goto error;

	ret = spa_keystore_change_key(dsname, dcp);
	if (ret != 0)
	goto error;

	dsl_crypto_params_free(dcp, B_FALSE);

	return (0);

	error:
	dsl_crypto_params_free(dcp, B_TRUE);
	return (ret);
	}

	static zfs_ioc_vec_t zfs_ioc_vec[ZFS_IOC_LAST - ZFS_IOC_FIRST];

	static void
	zfs_ioctl_register_legacy(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func,
	zfs_secpolicy_func_t *secpolicy, zfs_ioc_namecheck_t namecheck,
	boolean_t log_history, zfs_ioc_poolcheck_t pool_check)
	{
	zfs_ioc_vec_t *vec = &zfs_ioc_vec[ioc - ZFS_IOC_FIRST];

	ASSERT3U(ioc, >=, ZFS_IOC_FIRST);
	ASSERT3U(ioc, <, ZFS_IOC_LAST);
	ASSERT3P(vec->zvec_legacy_func, ==, NULL);
	ASSERT3P(vec->zvec_func, ==, NULL);

	vec->zvec_legacy_func = func;
	vec->zvec_secpolicy = secpolicy;
	vec->zvec_namecheck = namecheck;
	vec->zvec_allow_log = log_history;
	vec->zvec_pool_check = pool_check;
	}

	/*
	* See the block comment at the beginning of this file for details on
	* each argument to this function.
	*/
	void
	zfs_ioctl_register(const char name, zfs_ioc_t ioc, zfs_ioc_func_t func,
	zfs_secpolicy_func_t *secpolicy, zfs_ioc_namecheck_t namecheck,
	zfs_ioc_poolcheck_t pool_check, boolean_t smush_outnvlist,
	boolean_t allow_log, const zfs_ioc_key_t *nvl_keys, size_t num_keys)
	{
	zfs_ioc_vec_t *vec = &zfs_ioc_vec[ioc - ZFS_IOC_FIRST];

	ASSERT3U(ioc, >=, ZFS_IOC_FIRST);
	ASSERT3U(ioc, <, ZFS_IOC_LAST);
	ASSERT3P(vec->zvec_legacy_func, ==, NULL);
	ASSERT3P(vec->zvec_func, ==, NULL);

	/* if we are logging, the name must be valid */
	ASSERT(!allow_log \|\| namecheck != NO_NAME);

	vec->zvec_name = name;
	vec->zvec_func = func;
	vec->zvec_secpolicy = secpolicy;
	vec->zvec_namecheck = namecheck;
	vec->zvec_pool_check = pool_check;
	vec->zvec_smush_outnvlist = smush_outnvlist;
	vec->zvec_allow_log = allow_log;
	vec->zvec_nvl_keys = nvl_keys;
	vec->zvec_nvl_key_count = num_keys;
	}

	static void
	zfs_ioctl_register_pool(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func,
	zfs_secpolicy_func_t *secpolicy, boolean_t log_history,
	zfs_ioc_poolcheck_t pool_check)
	{
	zfs_ioctl_register_legacy(ioc, func, secpolicy,
	POOL_NAME, log_history, pool_check);
	}

	void
	zfs_ioctl_register_dataset_nolog(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func,
	zfs_secpolicy_func_t *secpolicy, zfs_ioc_poolcheck_t pool_check)
	{
	zfs_ioctl_register_legacy(ioc, func, secpolicy,
	DATASET_NAME, B_FALSE, pool_check);
	}

	static void
	zfs_ioctl_register_pool_modify(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func)
	{
	zfs_ioctl_register_legacy(ioc, func, zfs_secpolicy_config,
	POOL_NAME, B_TRUE, POOL_CHECK_SUSPENDED \| POOL_CHECK_READONLY);
	}

	static void
	zfs_ioctl_register_pool_meta(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func,
	zfs_secpolicy_func_t *secpolicy)
	{
	zfs_ioctl_register_legacy(ioc, func, secpolicy,
	NO_NAME, B_FALSE, POOL_CHECK_NONE);
	}

	static void
	zfs_ioctl_register_dataset_read_secpolicy(zfs_ioc_t ioc,
	zfs_ioc_legacy_func_t func, zfs_secpolicy_func_t secpolicy)
	{
	zfs_ioctl_register_legacy(ioc, func, secpolicy,
	DATASET_NAME, B_FALSE, POOL_CHECK_SUSPENDED);
	}

	static void
	zfs_ioctl_register_dataset_read(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func)
	{
	zfs_ioctl_register_dataset_read_secpolicy(ioc, func,
	zfs_secpolicy_read);
	}

	static void
	zfs_ioctl_register_dataset_modify(zfs_ioc_t ioc, zfs_ioc_legacy_func_t *func,
	zfs_secpolicy_func_t *secpolicy)
	{
	zfs_ioctl_register_legacy(ioc, func, secpolicy,
	DATASET_NAME, B_TRUE, POOL_CHECK_SUSPENDED \| POOL_CHECK_READONLY);
	}

	static void
	zfs_ioctl_init(void)
	{
	zfs_ioctl_register("snapshot", ZFS_IOC_SNAPSHOT,
	zfs_ioc_snapshot, zfs_secpolicy_snapshot, POOL_NAME,
	POOL_CHECK_SUSPENDED \| POOL_CHECK_READONLY, B_TRUE, B_TRUE,
	zfs_keys_snapshot, ARRAY_SIZE(zfs_keys_snapshot));

	zfs_ioctl_register("log_history", ZFS_IOC_LOG_HISTORY,
	zfs_ioc_log_history, zfs_secpolicy_log_history, NO_NAME,
	POOL_CHECK_SUSPENDED \| POOL_CHECK_READONLY, B_FALSE, B_FALSE,
	zfs_keys_log_history, ARRAY_SIZE(zfs_keys_log_history));

	zfs_ioctl_register("space_snaps", ZFS_IOC_SPACE_SNAPS,
	zfs_ioc_space_snaps, zfs_secpolicy_read, DATASET_NAME,
	POOL_CHECK_SUSPENDED, B_FALSE, B_FALSE,
	zfs_keys_space_snaps, ARRAY_SIZE(zfs_keys_space_snaps));

	zfs_ioctl_register("send", ZFS_IOC_SEND_NEW,
	zfs_ioc_send_new, zfs_secpolicy_send_new, DATASET_NAME,
	POOL_CHECK_SUSPENDED, B_FALSE, B_FALSE,
	zfs_keys_send_new, ARRAY_SIZE(zfs_keys_send_new));

	zfs_ioctl_register("send_space", ZFS_IOC_SEND_SPACE,
	zfs_ioc_send_space, zfs_secpolicy_read, DATASET_NAME,
	POOL_CHECK_SUSPENDED, B_FALSE, B_FALSE,
	zfs_keys_send_space, ARRAY_SIZE(zfs_keys_send_space));

	zfs_ioctl_register("create", ZFS_IOC_CREATE,
	zfs_ioc_create, zfs_secpolicy_create_clone, DATASET_NAME,
	POOL_CHECK_SUSPENDED \| POOL_CHECK_READONLY, B_TRUE, B_TRUE,
	zfs_keys_create, ARRAY_SIZE(zfs_keys_create));

	zfs_ioctl_register("clone", ZFS_IOC_CLONE,
	zfs_ioc_clone, zfs_secpolicy_create_clone, DATASET_NAME,
	POOL_CHECK_SUSPENDED \| POOL_CHECK_READONLY, B_TRUE, B_TRUE,
	zfs_keys_clone, ARRAY_SIZE(zfs_keys_clone));

	zfs_ioctl_register("remap", ZFS_IOC_REMAP,
	zfs_ioc_remap, zfs_secpolicy_none, DATASET_NAME,
	POOL_CHECK_SUSPENDED \| POOL_CHECK_READONLY, B_FALSE, B_TRUE,
	zfs_keys_remap, ARRAY_SIZE(zfs_keys_remap));

	zfs_ioctl_register("destroy_snaps", ZFS_IOC_DESTROY_SNAPS,
	zfs_ioc_destroy_snaps, zfs_secpolicy_destroy_snaps, POOL_NAME,
	POOL_CHECK_SUSPENDED \| POOL_CHECK_READONLY, B_TRUE, B_TRUE,
	zfs_keys_destroy_snaps, ARRAY_SIZE(zfs_keys_destroy_snaps));

	zfs_ioctl_register("hold", ZFS_IOC_HOLD,
	zfs_ioc_hold, zfs_secpolicy_hold, POOL_NAME,
	POOL_CHECK_SUSPENDED \| POOL_CHECK_READONLY, B_TRUE, B_TRUE,
	zfs_keys_hold, ARRAY_SIZE(zfs_keys_hold));
	zfs_ioctl_register("release", ZFS_IOC_RELEASE,
	zfs_ioc_release, zfs_secpolicy_release, POOL_NAME,
	POOL_CHECK_SUSPENDED \| POOL_CHECK_READONLY, B_TRUE, B_TRUE,
	zfs_keys_release, ARRAY_SIZE(zfs_keys_release));

	zfs_ioctl_register("get_holds", ZFS_IOC_GET_HOLDS,
	zfs_ioc_get_holds, zfs_secpolicy_read, DATASET_NAME,
	POOL_CHECK_SUSPENDED, B_FALSE, B_FALSE,
	zfs_keys_get_holds, ARRAY_SIZE(zfs_keys_get_holds));

	zfs_ioctl_register("rollback", ZFS_IOC_ROLLBACK,
	zfs_ioc_rollback, zfs_secpolicy_rollback, DATASET_NAME,
	POOL_CHECK_SUSPENDED \| POOL_CHECK_READONLY, B_FALSE, B_TRUE,
	zfs_keys_rollback, ARRAY_SIZE(zfs_keys_rollback));

	zfs_ioctl_register("bookmark", ZFS_IOC_BOOKMARK,
	zfs_ioc_bookmark, zfs_secpolicy_bookmark, POOL_NAME,
	POOL_CHECK_SUSPENDED \| POOL_CHECK_READONLY, B_TRUE, B_TRUE,
	zfs_keys_bookmark, ARRAY_SIZE(zfs_keys_bookmark));

	zfs_ioctl_register("get_bookmarks", ZFS_IOC_GET_BOOKMARKS,
	zfs_ioc_get_bookmarks, zfs_secpolicy_read, DATASET_NAME,
	POOL_CHECK_SUSPENDED, B_FALSE, B_FALSE,
	zfs_keys_get_bookmarks, ARRAY_SIZE(zfs_keys_get_bookmarks));

	zfs_ioctl_register("get_bookmark_props", ZFS_IOC_GET_BOOKMARK_PROPS,
	zfs_ioc_get_bookmark_props, zfs_secpolicy_read, ENTITY_NAME,
	POOL_CHECK_SUSPENDED, B_FALSE, B_FALSE, zfs_keys_get_bookmark_props,
	ARRAY_SIZE(zfs_keys_get_bookmark_props));

	zfs_ioctl_register("destroy_bookmarks", ZFS_IOC_DESTROY_BOOKMARKS,
	zfs_ioc_destroy_bookmarks, zfs_secpolicy_destroy_bookmarks,
	POOL_NAME,
	POOL_CHECK_SUSPENDED \| POOL_CHECK_READONLY, B_TRUE, B_TRUE,
	zfs_keys_destroy_bookmarks,
	ARRAY_SIZE(zfs_keys_destroy_bookmarks));

	zfs_ioctl_register("receive", ZFS_IOC_RECV_NEW,
	zfs_ioc_recv_new, zfs_secpolicy_recv_new, DATASET_NAME,
	POOL_CHECK_SUSPENDED \| POOL_CHECK_READONLY, B_TRUE, B_TRUE,
	zfs_keys_recv_new, ARRAY_SIZE(zfs_keys_recv_new));
	zfs_ioctl_register("load-key", ZFS_IOC_LOAD_KEY,
	zfs_ioc_load_key, zfs_secpolicy_load_key,
	DATASET_NAME, POOL_CHECK_SUSPENDED, B_TRUE, B_TRUE,
	zfs_keys_load_key, ARRAY_SIZE(zfs_keys_load_key));
	zfs_ioctl_register("unload-key", ZFS_IOC_UNLOAD_KEY,
	zfs_ioc_unload_key, zfs_secpolicy_load_key,
	DATASET_NAME, POOL_CHECK_SUSPENDED, B_TRUE, B_TRUE,
	zfs_keys_unload_key, ARRAY_SIZE(zfs_keys_unload_key));
	zfs_ioctl_register("change-key", ZFS_IOC_CHANGE_KEY,
	zfs_ioc_change_key, zfs_secpolicy_change_key,
	DATASET_NAME, POOL_CHECK_SUSPENDED \| POOL_CHECK_READONLY,
	B_TRUE, B_TRUE, zfs_keys_change_key,
	ARRAY_SIZE(zfs_keys_change_key));

	zfs_ioctl_register("sync", ZFS_IOC_POOL_SYNC,
	zfs_ioc_pool_sync, zfs_secpolicy_none, POOL_NAME,
	POOL_CHECK_SUSPENDED \| POOL_CHECK_READONLY, B_FALSE, B_FALSE,
	zfs_keys_pool_sync, ARRAY_SIZE(zfs_keys_pool_sync));
	zfs_ioctl_register("reopen", ZFS_IOC_POOL_REOPEN, zfs_ioc_pool_reopen,
	zfs_secpolicy_config, POOL_NAME, POOL_CHECK_SUSPENDED, B_TRUE,
	B_TRUE, zfs_keys_pool_reopen, ARRAY_SIZE(zfs_keys_pool_reopen));

	zfs_ioctl_register("channel_program", ZFS_IOC_CHANNEL_PROGRAM,
	zfs_ioc_channel_program, zfs_secpolicy_config,
	POOL_NAME, POOL_CHECK_SUSPENDED \| POOL_CHECK_READONLY, B_TRUE,
	B_TRUE, zfs_keys_channel_program,
	ARRAY_SIZE(zfs_keys_channel_program));

	zfs_ioctl_register("redact", ZFS_IOC_REDACT,
	zfs_ioc_redact, zfs_secpolicy_config, DATASET_NAME,
	POOL_CHECK_SUSPENDED \| POOL_CHECK_READONLY, B_TRUE, B_TRUE,
	zfs_keys_redact, ARRAY_SIZE(zfs_keys_redact));

	zfs_ioctl_register("zpool_checkpoint", ZFS_IOC_POOL_CHECKPOINT,
	zfs_ioc_pool_checkpoint, zfs_secpolicy_config, POOL_NAME,
	POOL_CHECK_SUSPENDED \| POOL_CHECK_READONLY, B_TRUE, B_TRUE,
	zfs_keys_pool_checkpoint, ARRAY_SIZE(zfs_keys_pool_checkpoint));

	zfs_ioctl_register("zpool_discard_checkpoint",
	ZFS_IOC_POOL_DISCARD_CHECKPOINT, zfs_ioc_pool_discard_checkpoint,
	zfs_secpolicy_config, POOL_NAME,
	POOL_CHECK_SUSPENDED \| POOL_CHECK_READONLY, B_TRUE, B_TRUE,
	zfs_keys_pool_discard_checkpoint,
	ARRAY_SIZE(zfs_keys_pool_discard_checkpoint));

	zfs_ioctl_register("initialize", ZFS_IOC_POOL_INITIALIZE,
	zfs_ioc_pool_initialize, zfs_secpolicy_config, POOL_NAME,
	POOL_CHECK_SUSPENDED \| POOL_CHECK_READONLY, B_TRUE, B_TRUE,
	zfs_keys_pool_initialize, ARRAY_SIZE(zfs_keys_pool_initialize));

	zfs_ioctl_register("trim", ZFS_IOC_POOL_TRIM,
	zfs_ioc_pool_trim, zfs_secpolicy_config, POOL_NAME,
	POOL_CHECK_SUSPENDED \| POOL_CHECK_READONLY, B_TRUE, B_TRUE,
	zfs_keys_pool_trim, ARRAY_SIZE(zfs_keys_pool_trim));

	zfs_ioctl_register("wait", ZFS_IOC_WAIT,
	zfs_ioc_wait, zfs_secpolicy_none, POOL_NAME,
	POOL_CHECK_SUSPENDED \| POOL_CHECK_READONLY, B_FALSE, B_FALSE,
	zfs_keys_pool_wait, ARRAY_SIZE(zfs_keys_pool_wait));

	zfs_ioctl_register("wait_fs", ZFS_IOC_WAIT_FS,
	zfs_ioc_wait_fs, zfs_secpolicy_none, DATASET_NAME,
	POOL_CHECK_SUSPENDED \| POOL_CHECK_READONLY, B_FALSE, B_FALSE,
	zfs_keys_fs_wait, ARRAY_SIZE(zfs_keys_fs_wait));

	zfs_ioctl_register("set_bootenv", ZFS_IOC_SET_BOOTENV,
	zfs_ioc_set_bootenv, zfs_secpolicy_config, POOL_NAME,
	POOL_CHECK_SUSPENDED \| POOL_CHECK_READONLY, B_FALSE, B_TRUE,
	zfs_keys_set_bootenv, ARRAY_SIZE(zfs_keys_set_bootenv));

	zfs_ioctl_register("get_bootenv", ZFS_IOC_GET_BOOTENV,
	zfs_ioc_get_bootenv, zfs_secpolicy_none, POOL_NAME,
	POOL_CHECK_SUSPENDED, B_FALSE, B_TRUE,
	zfs_keys_get_bootenv, ARRAY_SIZE(zfs_keys_get_bootenv));

	/* IOCTLS that use the legacy function signature */

	zfs_ioctl_register_legacy(ZFS_IOC_POOL_FREEZE, zfs_ioc_pool_freeze,
	zfs_secpolicy_config, NO_NAME, B_FALSE, POOL_CHECK_READONLY);

	zfs_ioctl_register_pool(ZFS_IOC_POOL_CREATE, zfs_ioc_pool_create,
	zfs_secpolicy_config, B_TRUE, POOL_CHECK_NONE);
	zfs_ioctl_register_pool_modify(ZFS_IOC_POOL_SCAN,
	zfs_ioc_pool_scan);
	zfs_ioctl_register_pool_modify(ZFS_IOC_POOL_UPGRADE,
	zfs_ioc_pool_upgrade);
	zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_ADD,
	zfs_ioc_vdev_add);
	zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_REMOVE,
	zfs_ioc_vdev_remove);
	zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_SET_STATE,
	zfs_ioc_vdev_set_state);
	zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_ATTACH,
	zfs_ioc_vdev_attach);
	zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_DETACH,
	zfs_ioc_vdev_detach);
	zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_SETPATH,
	zfs_ioc_vdev_setpath);
	zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_SETFRU,
	zfs_ioc_vdev_setfru);
	zfs_ioctl_register_pool_modify(ZFS_IOC_POOL_SET_PROPS,
	zfs_ioc_pool_set_props);
	zfs_ioctl_register_pool_modify(ZFS_IOC_VDEV_SPLIT,
	zfs_ioc_vdev_split);
	zfs_ioctl_register_pool_modify(ZFS_IOC_POOL_REGUID,
	zfs_ioc_pool_reguid);

	zfs_ioctl_register_pool_meta(ZFS_IOC_POOL_CONFIGS,
	zfs_ioc_pool_configs, zfs_secpolicy_none);
	zfs_ioctl_register_pool_meta(ZFS_IOC_POOL_TRYIMPORT,
	zfs_ioc_pool_tryimport, zfs_secpolicy_config);
	zfs_ioctl_register_pool_meta(ZFS_IOC_INJECT_FAULT,
	zfs_ioc_inject_fault, zfs_secpolicy_inject);
	zfs_ioctl_register_pool_meta(ZFS_IOC_CLEAR_FAULT,
	zfs_ioc_clear_fault, zfs_secpolicy_inject);
	zfs_ioctl_register_pool_meta(ZFS_IOC_INJECT_LIST_NEXT,
	zfs_ioc_inject_list_next, zfs_secpolicy_inject);

	/*
	* pool destroy, and export don't log the history as part of
	* zfsdev_ioctl, but rather zfs_ioc_pool_export
	* does the logging of those commands.
	*/
	zfs_ioctl_register_pool(ZFS_IOC_POOL_DESTROY, zfs_ioc_pool_destroy,
	zfs_secpolicy_config, B_FALSE, POOL_CHECK_SUSPENDED);
	zfs_ioctl_register_pool(ZFS_IOC_POOL_EXPORT, zfs_ioc_pool_export,
	zfs_secpolicy_config, B_FALSE, POOL_CHECK_SUSPENDED);

	zfs_ioctl_register_pool(ZFS_IOC_POOL_STATS, zfs_ioc_pool_stats,
	zfs_secpolicy_read, B_FALSE, POOL_CHECK_NONE);
	zfs_ioctl_register_pool(ZFS_IOC_POOL_GET_PROPS, zfs_ioc_pool_get_props,
	zfs_secpolicy_read, B_FALSE, POOL_CHECK_NONE);

	zfs_ioctl_register_pool(ZFS_IOC_ERROR_LOG, zfs_ioc_error_log,
	zfs_secpolicy_inject, B_FALSE, POOL_CHECK_SUSPENDED);
	zfs_ioctl_register_pool(ZFS_IOC_DSOBJ_TO_DSNAME,
	zfs_ioc_dsobj_to_dsname,
	zfs_secpolicy_diff, B_FALSE, POOL_CHECK_SUSPENDED);
	zfs_ioctl_register_pool(ZFS_IOC_POOL_GET_HISTORY,
	zfs_ioc_pool_get_history,
	zfs_secpolicy_config, B_FALSE, POOL_CHECK_SUSPENDED);

	zfs_ioctl_register_pool(ZFS_IOC_POOL_IMPORT, zfs_ioc_pool_import,
	zfs_secpolicy_config, B_TRUE, POOL_CHECK_NONE);

	zfs_ioctl_register_pool(ZFS_IOC_CLEAR, zfs_ioc_clear,
	zfs_secpolicy_config, B_TRUE, POOL_CHECK_READONLY);

	zfs_ioctl_register_dataset_read(ZFS_IOC_SPACE_WRITTEN,
	zfs_ioc_space_written);
	zfs_ioctl_register_dataset_read(ZFS_IOC_OBJSET_RECVD_PROPS,
	zfs_ioc_objset_recvd_props);
	zfs_ioctl_register_dataset_read(ZFS_IOC_NEXT_OBJ,
	zfs_ioc_next_obj);
	zfs_ioctl_register_dataset_read(ZFS_IOC_GET_FSACL,
	zfs_ioc_get_fsacl);
	zfs_ioctl_register_dataset_read(ZFS_IOC_OBJSET_STATS,
	zfs_ioc_objset_stats);
	zfs_ioctl_register_dataset_read(ZFS_IOC_OBJSET_ZPLPROPS,
	zfs_ioc_objset_zplprops);
	zfs_ioctl_register_dataset_read(ZFS_IOC_DATASET_LIST_NEXT,
	zfs_ioc_dataset_list_next);
	zfs_ioctl_register_dataset_read(ZFS_IOC_SNAPSHOT_LIST_NEXT,
	zfs_ioc_snapshot_list_next);
	zfs_ioctl_register_dataset_read(ZFS_IOC_SEND_PROGRESS,
	zfs_ioc_send_progress);

	zfs_ioctl_register_dataset_read_secpolicy(ZFS_IOC_DIFF,
	zfs_ioc_diff, zfs_secpolicy_diff);
	zfs_ioctl_register_dataset_read_secpolicy(ZFS_IOC_OBJ_TO_STATS,
	zfs_ioc_obj_to_stats, zfs_secpolicy_diff);
	zfs_ioctl_register_dataset_read_secpolicy(ZFS_IOC_OBJ_TO_PATH,
	zfs_ioc_obj_to_path, zfs_secpolicy_diff);
	zfs_ioctl_register_dataset_read_secpolicy(ZFS_IOC_USERSPACE_ONE,
	zfs_ioc_userspace_one, zfs_secpolicy_userspace_one);
	zfs_ioctl_register_dataset_read_secpolicy(ZFS_IOC_USERSPACE_MANY,
	zfs_ioc_userspace_many, zfs_secpolicy_userspace_many);
	zfs_ioctl_register_dataset_read_secpolicy(ZFS_IOC_SEND,
	zfs_ioc_send, zfs_secpolicy_send);

	zfs_ioctl_register_dataset_modify(ZFS_IOC_SET_PROP, zfs_ioc_set_prop,
	zfs_secpolicy_none);
	zfs_ioctl_register_dataset_modify(ZFS_IOC_DESTROY, zfs_ioc_destroy,
	zfs_secpolicy_destroy);
	zfs_ioctl_register_dataset_modify(ZFS_IOC_RENAME, zfs_ioc_rename,
	zfs_secpolicy_rename);
	zfs_ioctl_register_dataset_modify(ZFS_IOC_RECV, zfs_ioc_recv,
	zfs_secpolicy_recv);
	zfs_ioctl_register_dataset_modify(ZFS_IOC_PROMOTE, zfs_ioc_promote,
	zfs_secpolicy_promote);
	zfs_ioctl_register_dataset_modify(ZFS_IOC_INHERIT_PROP,
	zfs_ioc_inherit_prop, zfs_secpolicy_inherit_prop);
	zfs_ioctl_register_dataset_modify(ZFS_IOC_SET_FSACL, zfs_ioc_set_fsacl,
	zfs_secpolicy_set_fsacl);

	zfs_ioctl_register_dataset_nolog(ZFS_IOC_SHARE, zfs_ioc_share,
	zfs_secpolicy_share, POOL_CHECK_NONE);
	zfs_ioctl_register_dataset_nolog(ZFS_IOC_SMB_ACL, zfs_ioc_smb_acl,
	zfs_secpolicy_smb_acl, POOL_CHECK_NONE);
	zfs_ioctl_register_dataset_nolog(ZFS_IOC_USERSPACE_UPGRADE,
	zfs_ioc_userspace_upgrade, zfs_secpolicy_userspace_upgrade,
	POOL_CHECK_SUSPENDED \| POOL_CHECK_READONLY);
	zfs_ioctl_register_dataset_nolog(ZFS_IOC_TMP_SNAPSHOT,
	zfs_ioc_tmp_snapshot, zfs_secpolicy_tmp_snapshot,
	POOL_CHECK_SUSPENDED \| POOL_CHECK_READONLY);

	zfs_ioctl_register_legacy(ZFS_IOC_EVENTS_NEXT, zfs_ioc_events_next,
	zfs_secpolicy_config, NO_NAME, B_FALSE, POOL_CHECK_NONE);
	zfs_ioctl_register_legacy(ZFS_IOC_EVENTS_CLEAR, zfs_ioc_events_clear,
	zfs_secpolicy_config, NO_NAME, B_FALSE, POOL_CHECK_NONE);
	zfs_ioctl_register_legacy(ZFS_IOC_EVENTS_SEEK, zfs_ioc_events_seek,
	zfs_secpolicy_config, NO_NAME, B_FALSE, POOL_CHECK_NONE);

	zfs_ioctl_init_os();
	}

	/*
	* Verify that for non-legacy ioctls the input nvlist
	* pairs match against the expected input.
	*
	* Possible errors are:
	* ZFS_ERR_IOC_ARG_UNAVAIL An unrecognized nvpair was encountered
	* ZFS_ERR_IOC_ARG_REQUIRED A required nvpair is missing
	* ZFS_ERR_IOC_ARG_BADTYPE Invalid type for nvpair
	*/
	static int
	zfs_check_input_nvpairs(nvlist_t innvl, const zfs_ioc_vec_t vec)
	{
	const zfs_ioc_key_t *nvl_keys = vec->zvec_nvl_keys;
	boolean_t required_keys_found = B_FALSE;

	/*
	* examine each input pair
	*/
	for (nvpair_t *pair = nvlist_next_nvpair(innvl, NULL);
	pair != NULL; pair = nvlist_next_nvpair(innvl, pair)) {
	char *name = nvpair_name(pair);
	data_type_t type = nvpair_type(pair);
	boolean_t identified = B_FALSE;

	/*
	* check pair against the documented names and type
	*/
	for (int k = 0; k < vec->zvec_nvl_key_count; k++) {
	/* if not a wild card name, check for an exact match */
	if ((nvl_keys[k].zkey_flags & ZK_WILDCARDLIST) == 0 &&
	strcmp(nvl_keys[k].zkey_name, name) != 0)
	continue;

	identified = B_TRUE;

	if (nvl_keys[k].zkey_type != DATA_TYPE_ANY &&
	nvl_keys[k].zkey_type != type) {
	return (SET_ERROR(ZFS_ERR_IOC_ARG_BADTYPE));
	}

	if (nvl_keys[k].zkey_flags & ZK_OPTIONAL)
	continue;

	required_keys_found = B_TRUE;
	break;
	}

	/* allow an 'optional' key, everything else is invalid */
	if (!identified &&
	(strcmp(name, "optional") != 0 \|\|
	type != DATA_TYPE_NVLIST)) {
	return (SET_ERROR(ZFS_ERR_IOC_ARG_UNAVAIL));
	}
	}

	/* verify that all required keys were found */
	for (int k = 0; k < vec->zvec_nvl_key_count; k++) {
	if (nvl_keys[k].zkey_flags & ZK_OPTIONAL)
	continue;

	if (nvl_keys[k].zkey_flags & ZK_WILDCARDLIST) {
	/* at least one non-optional key is expected here */
	if (!required_keys_found)
	return (SET_ERROR(ZFS_ERR_IOC_ARG_REQUIRED));
	continue;
	}

	if (!nvlist_exists(innvl, nvl_keys[k].zkey_name))
	return (SET_ERROR(ZFS_ERR_IOC_ARG_REQUIRED));
	}

	return (0);
	}

	static int
	pool_status_check(const char *name, zfs_ioc_namecheck_t type,
	zfs_ioc_poolcheck_t check)
	{
	spa_t *spa;
	int error;

	ASSERT(type == POOL_NAME \|\| type == DATASET_NAME \|\|
	type == ENTITY_NAME);

	if (check & POOL_CHECK_NONE)
	return (0);

	error = spa_open(name, &spa, FTAG);
	if (error == 0) {
	if ((check & POOL_CHECK_SUSPENDED) && spa_suspended(spa))
	error = SET_ERROR(EAGAIN);
	else if ((check & POOL_CHECK_READONLY) && !spa_writeable(spa))
	error = SET_ERROR(EROFS);
	spa_close(spa, FTAG);
	}
	return (error);
	}

	int
	zfsdev_getminor(int fd, minor_t *minorp)
	{
	zfsdev_state_t zs, fpd;
	zfs_file_t *fp;
	int rc;

	ASSERT(!MUTEX_HELD(&zfsdev_state_lock));

	if ((rc = zfs_file_get(fd, &fp)))
	return (rc);

	fpd = zfs_file_private(fp);
	if (fpd == NULL)
	return (SET_ERROR(EBADF));

	mutex_enter(&zfsdev_state_lock);

	for (zs = zfsdev_state_list; zs != NULL; zs = zs->zs_next) {

	if (zs->zs_minor == -1)
	continue;

	if (fpd == zs) {
	*minorp = fpd->zs_minor;
	mutex_exit(&zfsdev_state_lock);
	return (0);
	}
	}

	mutex_exit(&zfsdev_state_lock);

	return (SET_ERROR(EBADF));
	}

	static void *
	zfsdev_get_state_impl(minor_t minor, enum zfsdev_state_type which)
	{
	zfsdev_state_t *zs;

	for (zs = zfsdev_state_list; zs != NULL; zs = zs->zs_next) {
	if (zs->zs_minor == minor) {
	smp_rmb();
	switch (which) {
	case ZST_ONEXIT:
	return (zs->zs_onexit);
	case ZST_ZEVENT:
	return (zs->zs_zevent);
	case ZST_ALL:
	return (zs);
	}
	}
	}

	return (NULL);
	}

	void *
	zfsdev_get_state(minor_t minor, enum zfsdev_state_type which)
	{
	void *ptr;

	ptr = zfsdev_get_state_impl(minor, which);

	return (ptr);
	}

	/*
	* Find a free minor number. The zfsdev_state_list is expected to
	* be short since it is only a list of currently open file handles.
	*/
	minor_t
	zfsdev_minor_alloc(void)
	{
	static minor_t last_minor = 0;
	minor_t m;

	ASSERT(MUTEX_HELD(&zfsdev_state_lock));

	for (m = last_minor + 1; m != last_minor; m++) {
	if (m > ZFSDEV_MAX_MINOR)
	m = 1;
	if (zfsdev_get_state_impl(m, ZST_ALL) == NULL) {
	last_minor = m;
	return (m);
	}
	}

	return (0);
	}

	long
	zfsdev_ioctl_common(uint_t vecnum, zfs_cmd_t *zc, int flag)
	{
	int error, cmd;
	const zfs_ioc_vec_t *vec;
	char *saved_poolname = NULL;
	uint64_t max_nvlist_src_size;
	size_t saved_poolname_len = 0;
	nvlist_t *innvl = NULL;
	fstrans_cookie_t cookie;
	hrtime_t start_time = gethrtime();

	cmd = vecnum;
	error = 0;
	if (vecnum >= sizeof (zfs_ioc_vec) / sizeof (zfs_ioc_vec[0]))
	return (SET_ERROR(ZFS_ERR_IOC_CMD_UNAVAIL));

	vec = &zfs_ioc_vec[vecnum];

	/*
	* The registered ioctl list may be sparse, verify that either
	* a normal or legacy handler are registered.
	*/
	if (vec->zvec_func == NULL && vec->zvec_legacy_func == NULL)
	return (SET_ERROR(ZFS_ERR_IOC_CMD_UNAVAIL));

	zc->zc_iflags = flag & FKIOCTL;
	max_nvlist_src_size = zfs_max_nvlist_src_size_os();
	if (zc->zc_nvlist_src_size > max_nvlist_src_size) {
	/*
	* Make sure the user doesn't pass in an insane value for
	* zc_nvlist_src_size. We have to check, since we will end
	* up allocating that much memory inside of get_nvlist(). This
	* prevents a nefarious user from allocating tons of kernel
	* memory.
	*
	* Also, we return EINVAL instead of ENOMEM here. The reason
	* being that returning ENOMEM from an ioctl() has a special
	* connotation; that the user's size value is too small and
	* needs to be expanded to hold the nvlist. See
	* zcmd_expand_dst_nvlist() for details.
	*/
	error = SET_ERROR(EINVAL); /* User's size too big */

	} else if (zc->zc_nvlist_src_size != 0) {
	error = get_nvlist(zc->zc_nvlist_src, zc->zc_nvlist_src_size,
	zc->zc_iflags, &innvl);
	if (error != 0)
	goto out;
	}

	/*
	* Ensure that all pool/dataset names are valid before we pass down to
	* the lower layers.
	*/
	zc->zc_name[sizeof (zc->zc_name) - 1] = '\0';
	switch (vec->zvec_namecheck) {
	case POOL_NAME:
	if (pool_namecheck(zc->zc_name, NULL, NULL) != 0)
	error = SET_ERROR(EINVAL);
	else
	error = pool_status_check(zc->zc_name,
	vec->zvec_namecheck, vec->zvec_pool_check);
	break;

	case DATASET_NAME:
	if (dataset_namecheck(zc->zc_name, NULL, NULL) != 0)
	error = SET_ERROR(EINVAL);
	else
	error = pool_status_check(zc->zc_name,
	vec->zvec_namecheck, vec->zvec_pool_check);
	break;

	case ENTITY_NAME:
	if (entity_namecheck(zc->zc_name, NULL, NULL) != 0) {
	error = SET_ERROR(EINVAL);
	} else {
	error = pool_status_check(zc->zc_name,
	vec->zvec_namecheck, vec->zvec_pool_check);
	}
	break;

	case NO_NAME:
	break;
	}
	/*
	* Ensure that all input pairs are valid before we pass them down
	* to the lower layers.
	*
	* The vectored functions can use fnvlist_lookup_{type} for any
	* required pairs since zfs_check_input_nvpairs() confirmed that
	* they exist and are of the correct type.
	*/
	if (error == 0 && vec->zvec_func != NULL) {
	error = zfs_check_input_nvpairs(innvl, vec);
	if (error != 0)
	goto out;
	}

	if (error == 0) {
	cookie = spl_fstrans_mark();
	error = vec->zvec_secpolicy(zc, innvl, CRED());
	spl_fstrans_unmark(cookie);
	}

	if (error != 0)
	goto out;

	/* legacy ioctls can modify zc_name */
	/*
	* Can't use kmem_strdup() as we might truncate the string and
	* kmem_strfree() would then free with incorrect size.
	*/
	saved_poolname_len = strlen(zc->zc_name) + 1;
	saved_poolname = kmem_alloc(saved_poolname_len, KM_SLEEP);

	strlcpy(saved_poolname, zc->zc_name, saved_poolname_len);
	saved_poolname[strcspn(saved_poolname, "/@#")] = '\0';

	if (vec->zvec_func != NULL) {
	nvlist_t *outnvl;
	int puterror = 0;
	spa_t *spa;
	nvlist_t *lognv = NULL;

	ASSERT(vec->zvec_legacy_func == NULL);

	/*
	* Add the innvl to the lognv before calling the func,
	* in case the func changes the innvl.
	*/
	if (vec->zvec_allow_log) {
	lognv = fnvlist_alloc();
	fnvlist_add_string(lognv, ZPOOL_HIST_IOCTL,
	vec->zvec_name);
	if (!nvlist_empty(innvl)) {
	fnvlist_add_nvlist(lognv, ZPOOL_HIST_INPUT_NVL,
	innvl);
	}
	}

	outnvl = fnvlist_alloc();
	cookie = spl_fstrans_mark();
	error = vec->zvec_func(zc->zc_name, innvl, outnvl);
	spl_fstrans_unmark(cookie);

	/*
	* Some commands can partially execute, modify state, and still
	* return an error. In these cases, attempt to record what
	* was modified.
	*/
	if ((error == 0 \|\|
	(cmd == ZFS_IOC_CHANNEL_PROGRAM && error != EINVAL)) &&
	vec->zvec_allow_log &&
	spa_open(zc->zc_name, &spa, FTAG) == 0) {
	if (!nvlist_empty(outnvl)) {
	size_t out_size = fnvlist_size(outnvl);
	if (out_size > zfs_history_output_max) {
	fnvlist_add_int64(lognv,
	ZPOOL_HIST_OUTPUT_SIZE, out_size);
	} else {
	fnvlist_add_nvlist(lognv,
	ZPOOL_HIST_OUTPUT_NVL, outnvl);
	}
	}
	if (error != 0) {
	fnvlist_add_int64(lognv, ZPOOL_HIST_ERRNO,
	error);
	}
	fnvlist_add_int64(lognv, ZPOOL_HIST_ELAPSED_NS,
	gethrtime() - start_time);
	(void) spa_history_log_nvl(spa, lognv);
	spa_close(spa, FTAG);
	}
	fnvlist_free(lognv);

	if (!nvlist_empty(outnvl) \|\| zc->zc_nvlist_dst_size != 0) {
	int smusherror = 0;
	if (vec->zvec_smush_outnvlist) {
	smusherror = nvlist_smush(outnvl,
	zc->zc_nvlist_dst_size);
	}
	if (smusherror == 0)
	puterror = put_nvlist(zc, outnvl);
	}

	if (puterror != 0)
	error = puterror;

	nvlist_free(outnvl);
	} else {
	cookie = spl_fstrans_mark();
	error = vec->zvec_legacy_func(zc);
	spl_fstrans_unmark(cookie);
	}

	out:
	nvlist_free(innvl);
	if (error == 0 && vec->zvec_allow_log) {
	char *s = tsd_get(zfs_allow_log_key);
	if (s != NULL)
	kmem_strfree(s);
	(void) tsd_set(zfs_allow_log_key, kmem_strdup(saved_poolname));
	}
	if (saved_poolname != NULL)
	kmem_free(saved_poolname, saved_poolname_len);

	return (error);
	}

	int
	zfs_kmod_init(void)
	{
	int error;

	if ((error = zvol_init()) != 0)
	return (error);

	spa_init(SPA_MODE_READ \| SPA_MODE_WRITE);
	zfs_init();

	zfs_ioctl_init();

	mutex_init(&zfsdev_state_lock, NULL, MUTEX_DEFAULT, NULL);
	zfsdev_state_list = kmem_zalloc(sizeof (zfsdev_state_t), KM_SLEEP);
	zfsdev_state_list->zs_minor = -1;

	if ((error = zfsdev_attach()) != 0)
	goto out;

	tsd_create(&zfs_fsyncer_key, NULL);
	tsd_create(&rrw_tsd_key, rrw_tsd_destroy);
	tsd_create(&zfs_allow_log_key, zfs_allow_log_destroy);

	return (0);
	out:
	zfs_fini();
	spa_fini();
	zvol_fini();

	return (error);
	}

	void
	zfs_kmod_fini(void)
	{
	zfsdev_state_t zs, zsnext = NULL;

	zfsdev_detach();

	mutex_destroy(&zfsdev_state_lock);

	for (zs = zfsdev_state_list; zs != NULL; zs = zsnext) {
	zsnext = zs->zs_next;
	if (zs->zs_onexit)
	zfs_onexit_destroy(zs->zs_onexit);
	if (zs->zs_zevent)
	zfs_zevent_destroy(zs->zs_zevent);
	kmem_free(zs, sizeof (zfsdev_state_t));
	}

	zfs_ereport_taskq_fini(); /* run before zfs_fini() on Linux */
	zfs_fini();
	spa_fini();
	zvol_fini();

	tsd_destroy(&zfs_fsyncer_key);
	tsd_destroy(&rrw_tsd_key);
	tsd_destroy(&zfs_allow_log_key);
	}

	/* BEGIN CSTYLED */
	ZFS_MODULE_PARAM(zfs, zfs_, max_nvlist_src_size, ULONG, ZMOD_RW,
	"Maximum size in bytes allowed for src nvlist passed with ZFS ioctls");

	ZFS_MODULE_PARAM(zfs, zfs_, history_output_max, ULONG, ZMOD_RW,
	"Maximum size in bytes of ZFS ioctl output that will be logged");
	/* END CSTYLED */
	diff --git a/sys/contrib/openzfs/module/zfs/zio.c b/sys/contrib/openzfs/module/zfs/zio.c
	index 26e40716710e..87ccb6861850 100644
	--- a/sys/contrib/openzfs/module/zfs/zio.c
	+++ b/sys/contrib/openzfs/module/zfs/zio.c
	@@ -1,5040 +1,5036 @@
	/*
	* 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) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2011, 2020 by Delphix. All rights reserved.
	* Copyright (c) 2011 Nexenta Systems, Inc. All rights reserved.
	* Copyright (c) 2017, Intel Corporation.
	* Copyright (c) 2019, Klara Inc.
	* Copyright (c) 2019, Allan Jude
	+ * Copyright (c) 2021, Datto, Inc.
	*/

	#include <sys/sysmacros.h>
	#include <sys/zfs_context.h>
	#include <sys/fm/fs/zfs.h>
	#include <sys/spa.h>
	#include <sys/txg.h>
	#include <sys/spa_impl.h>
	#include <sys/vdev_impl.h>
	#include <sys/vdev_trim.h>
	#include <sys/zio_impl.h>
	#include <sys/zio_compress.h>
	#include <sys/zio_checksum.h>
	#include <sys/dmu_objset.h>
	#include <sys/arc.h>
	#include <sys/ddt.h>
	#include <sys/blkptr.h>
	#include <sys/zfeature.h>
	#include <sys/dsl_scan.h>
	#include <sys/metaslab_impl.h>
	#include <sys/time.h>
	#include <sys/trace_zfs.h>
	#include <sys/abd.h>
	#include <sys/dsl_crypt.h>
	#include <cityhash.h>

	/*
	* ==========================================================================
	* I/O type descriptions
	* ==========================================================================
	*/
	const char *zio_type_name[ZIO_TYPES] = {
	/*
	* Note: Linux kernel thread name length is limited
	* so these names will differ from upstream open zfs.
	*/
	"z_null", "z_rd", "z_wr", "z_fr", "z_cl", "z_ioctl", "z_trim"
	};

	int zio_dva_throttle_enabled = B_TRUE;
	int zio_deadman_log_all = B_FALSE;

	/*
	* ==========================================================================
	* I/O kmem caches
	* ==========================================================================
	*/
	kmem_cache_t *zio_cache;
	kmem_cache_t *zio_link_cache;
	kmem_cache_t *zio_buf_cache[SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT];
	kmem_cache_t *zio_data_buf_cache[SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT];
	#if defined(ZFS_DEBUG) && !defined(_KERNEL)
	uint64_t zio_buf_cache_allocs[SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT];
	uint64_t zio_buf_cache_frees[SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT];
	#endif

	/* Mark IOs as "slow" if they take longer than 30 seconds */
	int zio_slow_io_ms = (30 * MILLISEC);

	#define BP_SPANB(indblkshift, level) \
	(((uint64_t)1) << ((level) * ((indblkshift) - SPA_BLKPTRSHIFT)))
	#define COMPARE_META_LEVEL 0x80000000ul
	/*
	* The following actions directly effect the spa's sync-to-convergence logic.
	* The values below define the sync pass when we start performing the action.
	* Care should be taken when changing these values as they directly impact
	* spa_sync() performance. Tuning these values may introduce subtle performance
	* pathologies and should only be done in the context of performance analysis.
	* These tunables will eventually be removed and replaced with #defines once
	* enough analysis has been done to determine optimal values.
	*
	* The 'zfs_sync_pass_deferred_free' pass must be greater than 1 to ensure that
	* regular blocks are not deferred.
	*
	* Starting in sync pass 8 (zfs_sync_pass_dont_compress), we disable
	* compression (including of metadata). In practice, we don't have this
	* many sync passes, so this has no effect.
	*
	* The original intent was that disabling compression would help the sync
	* passes to converge. However, in practice disabling compression increases
	* the average number of sync passes, because when we turn compression off, a
	* lot of block's size will change and thus we have to re-allocate (not
	* overwrite) them. It also increases the number of 128KB allocations (e.g.
	* for indirect blocks and spacemaps) because these will not be compressed.
	* The 128K allocations are especially detrimental to performance on highly
	* fragmented systems, which may have very few free segments of this size,
	* and may need to load new metaslabs to satisfy 128K allocations.
	*/
	int zfs_sync_pass_deferred_free = 2; /* defer frees starting in this pass */
	int zfs_sync_pass_dont_compress = 8; /* don't compress starting in this pass */
	int zfs_sync_pass_rewrite = 2; /* rewrite new bps starting in this pass */

	/*
	* An allocating zio is one that either currently has the DVA allocate
	* stage set or will have it later in its lifetime.
	*/
	#define IO_IS_ALLOCATING(zio) ((zio)->io_orig_pipeline & ZIO_STAGE_DVA_ALLOCATE)

	/*
	* Enable smaller cores by excluding metadata
	* allocations as well.
	*/
	int zio_exclude_metadata = 0;
	int zio_requeue_io_start_cut_in_line = 1;

	#ifdef ZFS_DEBUG
	int zio_buf_debug_limit = 16384;
	#else
	int zio_buf_debug_limit = 0;
	#endif

	static inline void __zio_execute(zio_t *zio);

	static void zio_taskq_dispatch(zio_t *, zio_taskq_type_t, boolean_t);

	void
	zio_init(void)
	{
	size_t c;

	zio_cache = kmem_cache_create("zio_cache",
	sizeof (zio_t), 0, NULL, NULL, NULL, NULL, NULL, 0);
	zio_link_cache = kmem_cache_create("zio_link_cache",
	sizeof (zio_link_t), 0, NULL, NULL, NULL, NULL, NULL, 0);

	/*
	* For small buffers, we want a cache for each multiple of
	* SPA_MINBLOCKSIZE. For larger buffers, we want a cache
	* for each quarter-power of 2.
	*/
	for (c = 0; c < SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT; c++) {
	size_t size = (c + 1) << SPA_MINBLOCKSHIFT;
	size_t p2 = size;
	size_t align = 0;
	size_t data_cflags, cflags;

	data_cflags = KMC_NODEBUG;
	cflags = (zio_exclude_metadata \|\| size > zio_buf_debug_limit) ?
	KMC_NODEBUG : 0;

	#if defined(_ILP32) && defined(_KERNEL)
	/*
	* Cache size limited to 1M on 32-bit platforms until ARC
	* buffers no longer require virtual address space.
	*/
	if (size > zfs_max_recordsize)
	break;
	#endif

	while (!ISP2(p2))
	p2 &= p2 - 1;

	#ifndef _KERNEL
	/*
	* If we are using watchpoints, put each buffer on its own page,
	* to eliminate the performance overhead of trapping to the
	* kernel when modifying a non-watched buffer that shares the
	* page with a watched buffer.
	*/
	if (arc_watch && !IS_P2ALIGNED(size, PAGESIZE))
	continue;
	/*
	* Here's the problem - on 4K native devices in userland on
	* Linux using O_DIRECT, buffers must be 4K aligned or I/O
	* will fail with EINVAL, causing zdb (and others) to coredump.
	* Since userland probably doesn't need optimized buffer caches,
	* we just force 4K alignment on everything.
	*/
	align = 8 * SPA_MINBLOCKSIZE;
	#else
	if (size < PAGESIZE) {
	align = SPA_MINBLOCKSIZE;
	} else if (IS_P2ALIGNED(size, p2 >> 2)) {
	align = PAGESIZE;
	}
	#endif

	if (align != 0) {
	char name[36];
	if (cflags == data_cflags) {
	/*
	* Resulting kmem caches would be identical.
	* Save memory by creating only one.
	*/
	(void) snprintf(name, sizeof (name),
	"zio_buf_comb_%lu", (ulong_t)size);
	zio_buf_cache[c] = kmem_cache_create(name,
	size, align, NULL, NULL, NULL, NULL, NULL,
	cflags);
	zio_data_buf_cache[c] = zio_buf_cache[c];
	continue;
	}
	(void) snprintf(name, sizeof (name), "zio_buf_%lu",
	(ulong_t)size);
	zio_buf_cache[c] = kmem_cache_create(name, size,
	align, NULL, NULL, NULL, NULL, NULL, cflags);

	(void) snprintf(name, sizeof (name), "zio_data_buf_%lu",
	(ulong_t)size);
	zio_data_buf_cache[c] = kmem_cache_create(name, size,
	align, NULL, NULL, NULL, NULL, NULL, data_cflags);
	}
	}

	while (--c != 0) {
	ASSERT(zio_buf_cache[c] != NULL);
	if (zio_buf_cache[c - 1] == NULL)
	zio_buf_cache[c - 1] = zio_buf_cache[c];

	ASSERT(zio_data_buf_cache[c] != NULL);
	if (zio_data_buf_cache[c - 1] == NULL)
	zio_data_buf_cache[c - 1] = zio_data_buf_cache[c];
	}

	zio_inject_init();

	lz4_init();
	}

	void
	zio_fini(void)
	{
	- size_t i, j, n;
	- kmem_cache_t *cache;
	-
	- n = SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT;
	+ size_t n = SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT;

	#if defined(ZFS_DEBUG) && !defined(_KERNEL)
	- for (i = 0; i < n; i++) {
	+ for (size_t i = 0; i < n; i++) {
	if (zio_buf_cache_allocs[i] != zio_buf_cache_frees[i])
	(void) printf("zio_fini: [%d] %llu != %llu\n",
	(int)((i + 1) << SPA_MINBLOCKSHIFT),
	(long long unsigned)zio_buf_cache_allocs[i],
	(long long unsigned)zio_buf_cache_frees[i]);
	}
	#endif

	/*
	* The same kmem cache can show up multiple times in both zio_buf_cache
	* and zio_data_buf_cache. Do a wasteful but trivially correct scan to
	* sort it out.
	*/
	- for (i = 0; i < n; i++) {
	- cache = zio_buf_cache[i];
	+ for (size_t i = 0; i < n; i++) {
	+ kmem_cache_t *cache = zio_buf_cache[i];
	if (cache == NULL)
	continue;
	- for (j = i; j < n; j++) {
	+ for (size_t j = i; j < n; j++) {
	if (cache == zio_buf_cache[j])
	zio_buf_cache[j] = NULL;
	if (cache == zio_data_buf_cache[j])
	zio_data_buf_cache[j] = NULL;
	}
	kmem_cache_destroy(cache);
	}

	- for (i = 0; i < n; i++) {
	- cache = zio_data_buf_cache[i];
	+ for (size_t i = 0; i < n; i++) {
	+ kmem_cache_t *cache = zio_data_buf_cache[i];
	if (cache == NULL)
	continue;
	- for (j = i; j < n; j++) {
	+ for (size_t j = i; j < n; j++) {
	if (cache == zio_data_buf_cache[j])
	zio_data_buf_cache[j] = NULL;
	}
	kmem_cache_destroy(cache);
	}

	- for (i = 0; i < n; i++) {
	- if (zio_buf_cache[i] != NULL)
	- panic("zio_fini: zio_buf_cache[%zd] != NULL", i);
	- if (zio_data_buf_cache[i] != NULL)
	- panic("zio_fini: zio_data_buf_cache[%zd] != NULL", i);
	+ for (size_t i = 0; i < n; i++) {
	+ VERIFY3P(zio_buf_cache[i], ==, NULL);
	+ VERIFY3P(zio_data_buf_cache[i], ==, NULL);
	}

	kmem_cache_destroy(zio_link_cache);
	kmem_cache_destroy(zio_cache);

	zio_inject_fini();

	lz4_fini();
	}

	/*
	* ==========================================================================
	* Allocate and free I/O buffers
	* ==========================================================================
	*/

	/*
	* Use zio_buf_alloc to allocate ZFS metadata. This data will appear in a
	* crashdump if the kernel panics, so use it judiciously. Obviously, it's
	* useful to inspect ZFS metadata, but if possible, we should avoid keeping
	* excess / transient data in-core during a crashdump.
	*/
	void *
	zio_buf_alloc(size_t size)
	{
	size_t c = (size - 1) >> SPA_MINBLOCKSHIFT;

	VERIFY3U(c, <, SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT);
	#if defined(ZFS_DEBUG) && !defined(_KERNEL)
	atomic_add_64(&zio_buf_cache_allocs[c], 1);
	#endif

	return (kmem_cache_alloc(zio_buf_cache[c], KM_PUSHPAGE));
	}

	/*
	* Use zio_data_buf_alloc to allocate data. The data will not appear in a
	* crashdump if the kernel panics. This exists so that we will limit the amount
	* of ZFS data that shows up in a kernel crashdump. (Thus reducing the amount
	* of kernel heap dumped to disk when the kernel panics)
	*/
	void *
	zio_data_buf_alloc(size_t size)
	{
	size_t c = (size - 1) >> SPA_MINBLOCKSHIFT;

	VERIFY3U(c, <, SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT);

	return (kmem_cache_alloc(zio_data_buf_cache[c], KM_PUSHPAGE));
	}

	void
	zio_buf_free(void *buf, size_t size)
	{
	size_t c = (size - 1) >> SPA_MINBLOCKSHIFT;

	VERIFY3U(c, <, SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT);
	#if defined(ZFS_DEBUG) && !defined(_KERNEL)
	atomic_add_64(&zio_buf_cache_frees[c], 1);
	#endif

	kmem_cache_free(zio_buf_cache[c], buf);
	}

	void
	zio_data_buf_free(void *buf, size_t size)
	{
	size_t c = (size - 1) >> SPA_MINBLOCKSHIFT;

	VERIFY3U(c, <, SPA_MAXBLOCKSIZE >> SPA_MINBLOCKSHIFT);

	kmem_cache_free(zio_data_buf_cache[c], buf);
	}

	static void
	zio_abd_free(void *abd, size_t size)
	{
	abd_free((abd_t *)abd);
	}

	/*
	* ==========================================================================
	* Push and pop I/O transform buffers
	* ==========================================================================
	*/
	void
	zio_push_transform(zio_t zio, abd_t data, uint64_t size, uint64_t bufsize,
	zio_transform_func_t *transform)
	{
	zio_transform_t *zt = kmem_alloc(sizeof (zio_transform_t), KM_SLEEP);

	zt->zt_orig_abd = zio->io_abd;
	zt->zt_orig_size = zio->io_size;
	zt->zt_bufsize = bufsize;
	zt->zt_transform = transform;

	zt->zt_next = zio->io_transform_stack;
	zio->io_transform_stack = zt;

	zio->io_abd = data;
	zio->io_size = size;
	}

	void
	zio_pop_transforms(zio_t *zio)
	{
	zio_transform_t *zt;

	while ((zt = zio->io_transform_stack) != NULL) {
	if (zt->zt_transform != NULL)
	zt->zt_transform(zio,
	zt->zt_orig_abd, zt->zt_orig_size);

	if (zt->zt_bufsize != 0)
	abd_free(zio->io_abd);

	zio->io_abd = zt->zt_orig_abd;
	zio->io_size = zt->zt_orig_size;
	zio->io_transform_stack = zt->zt_next;

	kmem_free(zt, sizeof (zio_transform_t));
	}
	}

	/*
	* ==========================================================================
	* I/O transform callbacks for subblocks, decompression, and decryption
	* ==========================================================================
	*/
	static void
	zio_subblock(zio_t zio, abd_t data, uint64_t size)
	{
	ASSERT(zio->io_size > size);

	if (zio->io_type == ZIO_TYPE_READ)
	abd_copy(data, zio->io_abd, size);
	}

	static void
	zio_decompress(zio_t zio, abd_t data, uint64_t size)
	{
	if (zio->io_error == 0) {
	void *tmp = abd_borrow_buf(data, size);
	int ret = zio_decompress_data(BP_GET_COMPRESS(zio->io_bp),
	zio->io_abd, tmp, zio->io_size, size,
	&zio->io_prop.zp_complevel);
	abd_return_buf_copy(data, tmp, size);

	if (zio_injection_enabled && ret == 0)
	ret = zio_handle_fault_injection(zio, EINVAL);

	if (ret != 0)
	zio->io_error = SET_ERROR(EIO);
	}
	}

	static void
	zio_decrypt(zio_t zio, abd_t data, uint64_t size)
	{
	int ret;
	void *tmp;
	blkptr_t *bp = zio->io_bp;
	spa_t *spa = zio->io_spa;
	uint64_t dsobj = zio->io_bookmark.zb_objset;
	uint64_t lsize = BP_GET_LSIZE(bp);
	dmu_object_type_t ot = BP_GET_TYPE(bp);
	uint8_t salt[ZIO_DATA_SALT_LEN];
	uint8_t iv[ZIO_DATA_IV_LEN];
	uint8_t mac[ZIO_DATA_MAC_LEN];
	boolean_t no_crypt = B_FALSE;

	ASSERT(BP_USES_CRYPT(bp));
	ASSERT3U(size, !=, 0);

	if (zio->io_error != 0)
	return;

	/*
	* Verify the cksum of MACs stored in an indirect bp. It will always
	* be possible to verify this since it does not require an encryption
	* key.
	*/
	if (BP_HAS_INDIRECT_MAC_CKSUM(bp)) {
	zio_crypt_decode_mac_bp(bp, mac);

	if (BP_GET_COMPRESS(bp) != ZIO_COMPRESS_OFF) {
	/*
	* We haven't decompressed the data yet, but
	* zio_crypt_do_indirect_mac_checksum() requires
	* decompressed data to be able to parse out the MACs
	* from the indirect block. We decompress it now and
	* throw away the result after we are finished.
	*/
	tmp = zio_buf_alloc(lsize);
	ret = zio_decompress_data(BP_GET_COMPRESS(bp),
	zio->io_abd, tmp, zio->io_size, lsize,
	&zio->io_prop.zp_complevel);
	if (ret != 0) {
	ret = SET_ERROR(EIO);
	goto error;
	}
	ret = zio_crypt_do_indirect_mac_checksum(B_FALSE,
	tmp, lsize, BP_SHOULD_BYTESWAP(bp), mac);
	zio_buf_free(tmp, lsize);
	} else {
	ret = zio_crypt_do_indirect_mac_checksum_abd(B_FALSE,
	zio->io_abd, size, BP_SHOULD_BYTESWAP(bp), mac);
	}
	abd_copy(data, zio->io_abd, size);

	if (zio_injection_enabled && ot != DMU_OT_DNODE && ret == 0) {
	ret = zio_handle_decrypt_injection(spa,
	&zio->io_bookmark, ot, ECKSUM);
	}
	if (ret != 0)
	goto error;

	return;
	}

	/*
	* If this is an authenticated block, just check the MAC. It would be
	* nice to separate this out into its own flag, but for the moment
	* enum zio_flag is out of bits.
	*/
	if (BP_IS_AUTHENTICATED(bp)) {
	if (ot == DMU_OT_OBJSET) {
	ret = spa_do_crypt_objset_mac_abd(B_FALSE, spa,
	dsobj, zio->io_abd, size, BP_SHOULD_BYTESWAP(bp));
	} else {
	zio_crypt_decode_mac_bp(bp, mac);
	ret = spa_do_crypt_mac_abd(B_FALSE, spa, dsobj,
	zio->io_abd, size, mac);
	if (zio_injection_enabled && ret == 0) {
	ret = zio_handle_decrypt_injection(spa,
	&zio->io_bookmark, ot, ECKSUM);
	}
	}
	abd_copy(data, zio->io_abd, size);

	if (ret != 0)
	goto error;

	return;
	}

	zio_crypt_decode_params_bp(bp, salt, iv);

	if (ot == DMU_OT_INTENT_LOG) {
	tmp = abd_borrow_buf_copy(zio->io_abd, sizeof (zil_chain_t));
	zio_crypt_decode_mac_zil(tmp, mac);
	abd_return_buf(zio->io_abd, tmp, sizeof (zil_chain_t));
	} else {
	zio_crypt_decode_mac_bp(bp, mac);
	}

	ret = spa_do_crypt_abd(B_FALSE, spa, &zio->io_bookmark, BP_GET_TYPE(bp),
	BP_GET_DEDUP(bp), BP_SHOULD_BYTESWAP(bp), salt, iv, mac, size, data,
	zio->io_abd, &no_crypt);
	if (no_crypt)
	abd_copy(data, zio->io_abd, size);

	if (ret != 0)
	goto error;

	return;

	error:
	/* assert that the key was found unless this was speculative */
	ASSERT(ret != EACCES \|\| (zio->io_flags & ZIO_FLAG_SPECULATIVE));

	/*
	* If there was a decryption / authentication error return EIO as
	* the io_error. If this was not a speculative zio, create an ereport.
	*/
	if (ret == ECKSUM) {
	zio->io_error = SET_ERROR(EIO);
	if ((zio->io_flags & ZIO_FLAG_SPECULATIVE) == 0) {
	spa_log_error(spa, &zio->io_bookmark);
	(void) zfs_ereport_post(FM_EREPORT_ZFS_AUTHENTICATION,
	spa, NULL, &zio->io_bookmark, zio, 0);
	}
	} else {
	zio->io_error = ret;
	}
	}

	/*
	* ==========================================================================
	* I/O parent/child relationships and pipeline interlocks
	* ==========================================================================
	*/
	zio_t *
	zio_walk_parents(zio_t cio, zio_link_t *zl)
	{
	list_t *pl = &cio->io_parent_list;

	zl = (zl == NULL) ? list_head(pl) : list_next(pl, *zl);
	if (*zl == NULL)
	return (NULL);

	ASSERT((*zl)->zl_child == cio);
	return ((*zl)->zl_parent);
	}

	zio_t *
	zio_walk_children(zio_t pio, zio_link_t *zl)
	{
	list_t *cl = &pio->io_child_list;

	ASSERT(MUTEX_HELD(&pio->io_lock));

	zl = (zl == NULL) ? list_head(cl) : list_next(cl, *zl);
	if (*zl == NULL)
	return (NULL);

	ASSERT((*zl)->zl_parent == pio);
	return ((*zl)->zl_child);
	}

	zio_t *
	zio_unique_parent(zio_t *cio)
	{
	zio_link_t *zl = NULL;
	zio_t *pio = zio_walk_parents(cio, &zl);

	VERIFY3P(zio_walk_parents(cio, &zl), ==, NULL);
	return (pio);
	}

	void
	zio_add_child(zio_t pio, zio_t cio)
	{
	zio_link_t *zl = kmem_cache_alloc(zio_link_cache, KM_SLEEP);

	/*
	* Logical I/Os can have logical, gang, or vdev children.
	* Gang I/Os can have gang or vdev children.
	* Vdev I/Os can only have vdev children.
	* The following ASSERT captures all of these constraints.
	*/
	ASSERT3S(cio->io_child_type, <=, pio->io_child_type);

	zl->zl_parent = pio;
	zl->zl_child = cio;

	mutex_enter(&pio->io_lock);
	mutex_enter(&cio->io_lock);

	ASSERT(pio->io_state[ZIO_WAIT_DONE] == 0);

	for (int w = 0; w < ZIO_WAIT_TYPES; w++)
	pio->io_children[cio->io_child_type][w] += !cio->io_state[w];

	list_insert_head(&pio->io_child_list, zl);
	list_insert_head(&cio->io_parent_list, zl);

	pio->io_child_count++;
	cio->io_parent_count++;

	mutex_exit(&cio->io_lock);
	mutex_exit(&pio->io_lock);
	}

	static void
	zio_remove_child(zio_t pio, zio_t cio, zio_link_t *zl)
	{
	ASSERT(zl->zl_parent == pio);
	ASSERT(zl->zl_child == cio);

	mutex_enter(&pio->io_lock);
	mutex_enter(&cio->io_lock);

	list_remove(&pio->io_child_list, zl);
	list_remove(&cio->io_parent_list, zl);

	pio->io_child_count--;
	cio->io_parent_count--;

	mutex_exit(&cio->io_lock);
	mutex_exit(&pio->io_lock);
	kmem_cache_free(zio_link_cache, zl);
	}

	static boolean_t
	zio_wait_for_children(zio_t *zio, uint8_t childbits, enum zio_wait_type wait)
	{
	boolean_t waiting = B_FALSE;

	mutex_enter(&zio->io_lock);
	ASSERT(zio->io_stall == NULL);
	for (int c = 0; c < ZIO_CHILD_TYPES; c++) {
	if (!(ZIO_CHILD_BIT_IS_SET(childbits, c)))
	continue;

	uint64_t *countp = &zio->io_children[c][wait];
	if (*countp != 0) {
	zio->io_stage >>= 1;
	ASSERT3U(zio->io_stage, !=, ZIO_STAGE_OPEN);
	zio->io_stall = countp;
	waiting = B_TRUE;
	break;
	}
	}
	mutex_exit(&zio->io_lock);
	return (waiting);
	}

	__attribute__((always_inline))
	static inline void
	zio_notify_parent(zio_t pio, zio_t zio, enum zio_wait_type wait,
	zio_t **next_to_executep)
	{
	uint64_t *countp = &pio->io_children[zio->io_child_type][wait];
	int *errorp = &pio->io_child_error[zio->io_child_type];

	mutex_enter(&pio->io_lock);
	if (zio->io_error && !(zio->io_flags & ZIO_FLAG_DONT_PROPAGATE))
	errorp = zio_worst_error(errorp, zio->io_error);
	pio->io_reexecute \|= zio->io_reexecute;
	ASSERT3U(*countp, >, 0);

	(*countp)--;

	if (*countp == 0 && pio->io_stall == countp) {
	zio_taskq_type_t type =
	pio->io_stage < ZIO_STAGE_VDEV_IO_START ? ZIO_TASKQ_ISSUE :
	ZIO_TASKQ_INTERRUPT;
	pio->io_stall = NULL;
	mutex_exit(&pio->io_lock);

	/*
	* If we can tell the caller to execute this parent next, do
	* so. Otherwise dispatch the parent zio as its own task.
	*
	* Having the caller execute the parent when possible reduces
	* locking on the zio taskq's, reduces context switch
	* overhead, and has no recursion penalty. Note that one
	* read from disk typically causes at least 3 zio's: a
	* zio_null(), the logical zio_read(), and then a physical
	* zio. When the physical ZIO completes, we are able to call
	* zio_done() on all 3 of these zio's from one invocation of
	* zio_execute() by returning the parent back to
	* zio_execute(). Since the parent isn't executed until this
	* thread returns back to zio_execute(), the caller should do
	* so promptly.
	*
	* In other cases, dispatching the parent prevents
	* overflowing the stack when we have deeply nested
	* parent-child relationships, as we do with the "mega zio"
	* of writes for spa_sync(), and the chain of ZIL blocks.
	*/
	if (next_to_executep != NULL && *next_to_executep == NULL) {
	*next_to_executep = pio;
	} else {
	zio_taskq_dispatch(pio, type, B_FALSE);
	}
	} else {
	mutex_exit(&pio->io_lock);
	}
	}

	static void
	zio_inherit_child_errors(zio_t *zio, enum zio_child c)
	{
	if (zio->io_child_error[c] != 0 && zio->io_error == 0)
	zio->io_error = zio->io_child_error[c];
	}

	int
	zio_bookmark_compare(const void x1, const void x2)
	{
	const zio_t *z1 = x1;
	const zio_t *z2 = x2;

	if (z1->io_bookmark.zb_objset < z2->io_bookmark.zb_objset)
	return (-1);
	if (z1->io_bookmark.zb_objset > z2->io_bookmark.zb_objset)
	return (1);

	if (z1->io_bookmark.zb_object < z2->io_bookmark.zb_object)
	return (-1);
	if (z1->io_bookmark.zb_object > z2->io_bookmark.zb_object)
	return (1);

	if (z1->io_bookmark.zb_level < z2->io_bookmark.zb_level)
	return (-1);
	if (z1->io_bookmark.zb_level > z2->io_bookmark.zb_level)
	return (1);

	if (z1->io_bookmark.zb_blkid < z2->io_bookmark.zb_blkid)
	return (-1);
	if (z1->io_bookmark.zb_blkid > z2->io_bookmark.zb_blkid)
	return (1);

	if (z1 < z2)
	return (-1);
	if (z1 > z2)
	return (1);

	return (0);
	}

	/*
	* ==========================================================================
	* Create the various types of I/O (read, write, free, etc)
	* ==========================================================================
	*/
	static zio_t *
	zio_create(zio_t pio, spa_t spa, uint64_t txg, const blkptr_t *bp,
	abd_t data, uint64_t lsize, uint64_t psize, zio_done_func_t done,
	void *private, zio_type_t type, zio_priority_t priority,
	enum zio_flag flags, vdev_t *vd, uint64_t offset,
	const zbookmark_phys_t *zb, enum zio_stage stage,
	enum zio_stage pipeline)
	{
	zio_t *zio;

	IMPLY(type != ZIO_TYPE_TRIM, psize <= SPA_MAXBLOCKSIZE);
	ASSERT(P2PHASE(psize, SPA_MINBLOCKSIZE) == 0);
	ASSERT(P2PHASE(offset, SPA_MINBLOCKSIZE) == 0);

	ASSERT(!vd \|\| spa_config_held(spa, SCL_STATE_ALL, RW_READER));
	ASSERT(!bp \|\| !(flags & ZIO_FLAG_CONFIG_WRITER));
	ASSERT(vd \|\| stage == ZIO_STAGE_OPEN);

	IMPLY(lsize != psize, (flags & ZIO_FLAG_RAW_COMPRESS) != 0);

	zio = kmem_cache_alloc(zio_cache, KM_SLEEP);
	bzero(zio, sizeof (zio_t));

	mutex_init(&zio->io_lock, NULL, MUTEX_NOLOCKDEP, NULL);
	cv_init(&zio->io_cv, NULL, CV_DEFAULT, NULL);

	list_create(&zio->io_parent_list, sizeof (zio_link_t),
	offsetof(zio_link_t, zl_parent_node));
	list_create(&zio->io_child_list, sizeof (zio_link_t),
	offsetof(zio_link_t, zl_child_node));
	metaslab_trace_init(&zio->io_alloc_list);

	if (vd != NULL)
	zio->io_child_type = ZIO_CHILD_VDEV;
	else if (flags & ZIO_FLAG_GANG_CHILD)
	zio->io_child_type = ZIO_CHILD_GANG;
	else if (flags & ZIO_FLAG_DDT_CHILD)
	zio->io_child_type = ZIO_CHILD_DDT;
	else
	zio->io_child_type = ZIO_CHILD_LOGICAL;

	if (bp != NULL) {
	zio->io_bp = (blkptr_t *)bp;
	zio->io_bp_copy = *bp;
	zio->io_bp_orig = *bp;
	if (type != ZIO_TYPE_WRITE \|\|
	zio->io_child_type == ZIO_CHILD_DDT)
	zio->io_bp = &zio->io_bp_copy; /* so caller can free */
	if (zio->io_child_type == ZIO_CHILD_LOGICAL)
	zio->io_logical = zio;
	if (zio->io_child_type > ZIO_CHILD_GANG && BP_IS_GANG(bp))
	pipeline \|= ZIO_GANG_STAGES;
	}

	zio->io_spa = spa;
	zio->io_txg = txg;
	zio->io_done = done;
	zio->io_private = private;
	zio->io_type = type;
	zio->io_priority = priority;
	zio->io_vd = vd;
	zio->io_offset = offset;
	zio->io_orig_abd = zio->io_abd = data;
	zio->io_orig_size = zio->io_size = psize;
	zio->io_lsize = lsize;
	zio->io_orig_flags = zio->io_flags = flags;
	zio->io_orig_stage = zio->io_stage = stage;
	zio->io_orig_pipeline = zio->io_pipeline = pipeline;
	zio->io_pipeline_trace = ZIO_STAGE_OPEN;

	zio->io_state[ZIO_WAIT_READY] = (stage >= ZIO_STAGE_READY);
	zio->io_state[ZIO_WAIT_DONE] = (stage >= ZIO_STAGE_DONE);

	if (zb != NULL)
	zio->io_bookmark = *zb;

	if (pio != NULL) {
	if (zio->io_metaslab_class == NULL)
	zio->io_metaslab_class = pio->io_metaslab_class;
	if (zio->io_logical == NULL)
	zio->io_logical = pio->io_logical;
	if (zio->io_child_type == ZIO_CHILD_GANG)
	zio->io_gang_leader = pio->io_gang_leader;
	zio_add_child(pio, zio);
	}

	taskq_init_ent(&zio->io_tqent);

	return (zio);
	}

	static void
	zio_destroy(zio_t *zio)
	{
	metaslab_trace_fini(&zio->io_alloc_list);
	list_destroy(&zio->io_parent_list);
	list_destroy(&zio->io_child_list);
	mutex_destroy(&zio->io_lock);
	cv_destroy(&zio->io_cv);
	kmem_cache_free(zio_cache, zio);
	}

	zio_t *
	zio_null(zio_t pio, spa_t spa, vdev_t vd, zio_done_func_t done,
	void *private, enum zio_flag flags)
	{
	zio_t *zio;

	zio = zio_create(pio, spa, 0, NULL, NULL, 0, 0, done, private,
	ZIO_TYPE_NULL, ZIO_PRIORITY_NOW, flags, vd, 0, NULL,
	ZIO_STAGE_OPEN, ZIO_INTERLOCK_PIPELINE);

	return (zio);
	}

	zio_t *
	zio_root(spa_t spa, zio_done_func_t done, void *private, enum zio_flag flags)
	{
	return (zio_null(NULL, spa, NULL, done, private, flags));
	}

	static int
	zfs_blkptr_verify_log(spa_t spa, const blkptr_t bp,
	enum blk_verify_flag blk_verify, const char *fmt, ...)
	{
	va_list adx;
	char buf[256];

	va_start(adx, fmt);
	(void) vsnprintf(buf, sizeof (buf), fmt, adx);
	va_end(adx);

	switch (blk_verify) {
	case BLK_VERIFY_HALT:
	dprintf_bp(bp, "blkptr at %p dprintf_bp():", bp);
	zfs_panic_recover("%s: %s", spa_name(spa), buf);
	break;
	case BLK_VERIFY_LOG:
	zfs_dbgmsg("%s: %s", spa_name(spa), buf);
	break;
	case BLK_VERIFY_ONLY:
	break;
	}

	return (1);
	}

	/*
	* Verify the block pointer fields contain reasonable values. This means
	* it only contains known object types, checksum/compression identifiers,
	* block sizes within the maximum allowed limits, valid DVAs, etc.
	*
	* If everything checks out B_TRUE is returned. The zfs_blkptr_verify
	* argument controls the behavior when an invalid field is detected.
	*
	* Modes for zfs_blkptr_verify:
	* 1) BLK_VERIFY_ONLY (evaluate the block)
	* 2) BLK_VERIFY_LOG (evaluate the block and log problems)
	* 3) BLK_VERIFY_HALT (call zfs_panic_recover on error)
	*/
	boolean_t
	zfs_blkptr_verify(spa_t spa, const blkptr_t bp, boolean_t config_held,
	enum blk_verify_flag blk_verify)
	{
	int errors = 0;

	if (!DMU_OT_IS_VALID(BP_GET_TYPE(bp))) {
	errors += zfs_blkptr_verify_log(spa, bp, blk_verify,
	"blkptr at %p has invalid TYPE %llu",
	bp, (longlong_t)BP_GET_TYPE(bp));
	}
	if (BP_GET_CHECKSUM(bp) >= ZIO_CHECKSUM_FUNCTIONS \|\|
	BP_GET_CHECKSUM(bp) <= ZIO_CHECKSUM_ON) {
	errors += zfs_blkptr_verify_log(spa, bp, blk_verify,
	"blkptr at %p has invalid CHECKSUM %llu",
	bp, (longlong_t)BP_GET_CHECKSUM(bp));
	}
	if (BP_GET_COMPRESS(bp) >= ZIO_COMPRESS_FUNCTIONS \|\|
	BP_GET_COMPRESS(bp) <= ZIO_COMPRESS_ON) {
	errors += zfs_blkptr_verify_log(spa, bp, blk_verify,
	"blkptr at %p has invalid COMPRESS %llu",
	bp, (longlong_t)BP_GET_COMPRESS(bp));
	}
	if (BP_GET_LSIZE(bp) > SPA_MAXBLOCKSIZE) {
	errors += zfs_blkptr_verify_log(spa, bp, blk_verify,
	"blkptr at %p has invalid LSIZE %llu",
	bp, (longlong_t)BP_GET_LSIZE(bp));
	}
	if (BP_GET_PSIZE(bp) > SPA_MAXBLOCKSIZE) {
	errors += zfs_blkptr_verify_log(spa, bp, blk_verify,
	"blkptr at %p has invalid PSIZE %llu",
	bp, (longlong_t)BP_GET_PSIZE(bp));
	}

	if (BP_IS_EMBEDDED(bp)) {
	if (BPE_GET_ETYPE(bp) >= NUM_BP_EMBEDDED_TYPES) {
	errors += zfs_blkptr_verify_log(spa, bp, blk_verify,
	"blkptr at %p has invalid ETYPE %llu",
	bp, (longlong_t)BPE_GET_ETYPE(bp));
	}
	}

	/*
	* Do not verify individual DVAs if the config is not trusted. This
	* will be done once the zio is executed in vdev_mirror_map_alloc.
	*/
	if (!spa->spa_trust_config)
	return (B_TRUE);

	if (!config_held)
	spa_config_enter(spa, SCL_VDEV, bp, RW_READER);
	else
	ASSERT(spa_config_held(spa, SCL_VDEV, RW_WRITER));
	/*
	* Pool-specific checks.
	*
	* Note: it would be nice to verify that the blk_birth and
	* BP_PHYSICAL_BIRTH() are not too large. However, spa_freeze()
	* allows the birth time of log blocks (and dmu_sync()-ed blocks
	* that are in the log) to be arbitrarily large.
	*/
	for (int i = 0; i < BP_GET_NDVAS(bp); i++) {
	const dva_t *dva = &bp->blk_dva[i];
	uint64_t vdevid = DVA_GET_VDEV(dva);

	if (vdevid >= spa->spa_root_vdev->vdev_children) {
	errors += zfs_blkptr_verify_log(spa, bp, blk_verify,
	"blkptr at %p DVA %u has invalid VDEV %llu",
	bp, i, (longlong_t)vdevid);
	continue;
	}
	vdev_t *vd = spa->spa_root_vdev->vdev_child[vdevid];
	if (vd == NULL) {
	errors += zfs_blkptr_verify_log(spa, bp, blk_verify,
	"blkptr at %p DVA %u has invalid VDEV %llu",
	bp, i, (longlong_t)vdevid);
	continue;
	}
	if (vd->vdev_ops == &vdev_hole_ops) {
	errors += zfs_blkptr_verify_log(spa, bp, blk_verify,
	"blkptr at %p DVA %u has hole VDEV %llu",
	bp, i, (longlong_t)vdevid);
	continue;
	}
	if (vd->vdev_ops == &vdev_missing_ops) {
	/*
	* "missing" vdevs are valid during import, but we
	* don't have their detailed info (e.g. asize), so
	* we can't perform any more checks on them.
	*/
	continue;
	}
	uint64_t offset = DVA_GET_OFFSET(dva);
	uint64_t asize = DVA_GET_ASIZE(dva);
	if (DVA_GET_GANG(dva))
	asize = vdev_gang_header_asize(vd);
	if (offset + asize > vd->vdev_asize) {
	errors += zfs_blkptr_verify_log(spa, bp, blk_verify,
	"blkptr at %p DVA %u has invalid OFFSET %llu",
	bp, i, (longlong_t)offset);
	}
	}
	if (errors > 0)
	dprintf_bp(bp, "blkptr at %p dprintf_bp():", bp);
	if (!config_held)
	spa_config_exit(spa, SCL_VDEV, bp);

	return (errors == 0);
	}

	boolean_t
	zfs_dva_valid(spa_t spa, const dva_t dva, const blkptr_t *bp)
	{
	uint64_t vdevid = DVA_GET_VDEV(dva);

	if (vdevid >= spa->spa_root_vdev->vdev_children)
	return (B_FALSE);

	vdev_t *vd = spa->spa_root_vdev->vdev_child[vdevid];
	if (vd == NULL)
	return (B_FALSE);

	if (vd->vdev_ops == &vdev_hole_ops)
	return (B_FALSE);

	if (vd->vdev_ops == &vdev_missing_ops) {
	return (B_FALSE);
	}

	uint64_t offset = DVA_GET_OFFSET(dva);
	uint64_t asize = DVA_GET_ASIZE(dva);

	if (DVA_GET_GANG(dva))
	asize = vdev_gang_header_asize(vd);
	if (offset + asize > vd->vdev_asize)
	return (B_FALSE);

	return (B_TRUE);
	}

	zio_t *
	zio_read(zio_t pio, spa_t spa, const blkptr_t *bp,
	abd_t data, uint64_t size, zio_done_func_t done, void *private,
	zio_priority_t priority, enum zio_flag flags, const zbookmark_phys_t *zb)
	{
	zio_t *zio;

	(void) zfs_blkptr_verify(spa, bp, flags & ZIO_FLAG_CONFIG_WRITER,
	BLK_VERIFY_HALT);

	zio = zio_create(pio, spa, BP_PHYSICAL_BIRTH(bp), bp,
	data, size, size, done, private,
	ZIO_TYPE_READ, priority, flags, NULL, 0, zb,
	ZIO_STAGE_OPEN, (flags & ZIO_FLAG_DDT_CHILD) ?
	ZIO_DDT_CHILD_READ_PIPELINE : ZIO_READ_PIPELINE);

	return (zio);
	}

	zio_t *
	zio_write(zio_t pio, spa_t spa, uint64_t txg, blkptr_t *bp,
	abd_t data, uint64_t lsize, uint64_t psize, const zio_prop_t zp,
	zio_done_func_t ready, zio_done_func_t children_ready,
	zio_done_func_t physdone, zio_done_func_t done,
	void *private, zio_priority_t priority, enum zio_flag flags,
	const zbookmark_phys_t *zb)
	{
	zio_t *zio;

	ASSERT(zp->zp_checksum >= ZIO_CHECKSUM_OFF &&
	zp->zp_checksum < ZIO_CHECKSUM_FUNCTIONS &&
	zp->zp_compress >= ZIO_COMPRESS_OFF &&
	zp->zp_compress < ZIO_COMPRESS_FUNCTIONS &&
	DMU_OT_IS_VALID(zp->zp_type) &&
	zp->zp_level < 32 &&
	zp->zp_copies > 0 &&
	zp->zp_copies <= spa_max_replication(spa));

	zio = zio_create(pio, spa, txg, bp, data, lsize, psize, done, private,
	ZIO_TYPE_WRITE, priority, flags, NULL, 0, zb,
	ZIO_STAGE_OPEN, (flags & ZIO_FLAG_DDT_CHILD) ?
	ZIO_DDT_CHILD_WRITE_PIPELINE : ZIO_WRITE_PIPELINE);

	zio->io_ready = ready;
	zio->io_children_ready = children_ready;
	zio->io_physdone = physdone;
	zio->io_prop = *zp;

	/*
	* Data can be NULL if we are going to call zio_write_override() to
	* provide the already-allocated BP. But we may need the data to
	* verify a dedup hit (if requested). In this case, don't try to
	* dedup (just take the already-allocated BP verbatim). Encrypted
	* dedup blocks need data as well so we also disable dedup in this
	* case.
	*/
	if (data == NULL &&
	(zio->io_prop.zp_dedup_verify \|\| zio->io_prop.zp_encrypt)) {
	zio->io_prop.zp_dedup = zio->io_prop.zp_dedup_verify = B_FALSE;
	}

	return (zio);
	}

	zio_t *
	zio_rewrite(zio_t pio, spa_t spa, uint64_t txg, blkptr_t bp, abd_t data,
	uint64_t size, zio_done_func_t done, void private,
	zio_priority_t priority, enum zio_flag flags, zbookmark_phys_t *zb)
	{
	zio_t *zio;

	zio = zio_create(pio, spa, txg, bp, data, size, size, done, private,
	ZIO_TYPE_WRITE, priority, flags \| ZIO_FLAG_IO_REWRITE, NULL, 0, zb,
	ZIO_STAGE_OPEN, ZIO_REWRITE_PIPELINE);

	return (zio);
	}

	void
	zio_write_override(zio_t zio, blkptr_t bp, int copies, boolean_t nopwrite)
	{
	ASSERT(zio->io_type == ZIO_TYPE_WRITE);
	ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
	ASSERT(zio->io_stage == ZIO_STAGE_OPEN);
	ASSERT(zio->io_txg == spa_syncing_txg(zio->io_spa));

	/*
	* We must reset the io_prop to match the values that existed
	* when the bp was first written by dmu_sync() keeping in mind
	* that nopwrite and dedup are mutually exclusive.
	*/
	zio->io_prop.zp_dedup = nopwrite ? B_FALSE : zio->io_prop.zp_dedup;
	zio->io_prop.zp_nopwrite = nopwrite;
	zio->io_prop.zp_copies = copies;
	zio->io_bp_override = bp;
	}

	void
	zio_free(spa_t spa, uint64_t txg, const blkptr_t bp)
	{

	(void) zfs_blkptr_verify(spa, bp, B_FALSE, BLK_VERIFY_HALT);

	/*
	* The check for EMBEDDED is a performance optimization. We
	* process the free here (by ignoring it) rather than
	* putting it on the list and then processing it in zio_free_sync().
	*/
	if (BP_IS_EMBEDDED(bp))
	return;
	metaslab_check_free(spa, bp);

	/*
	* Frees that are for the currently-syncing txg, are not going to be
	* deferred, and which will not need to do a read (i.e. not GANG or
	* DEDUP), can be processed immediately. Otherwise, put them on the
	* in-memory list for later processing.
	*
	* Note that we only defer frees after zfs_sync_pass_deferred_free
	* when the log space map feature is disabled. [see relevant comment
	* in spa_sync_iterate_to_convergence()]
	*/
	if (BP_IS_GANG(bp) \|\|
	BP_GET_DEDUP(bp) \|\|
	txg != spa->spa_syncing_txg \|\|
	(spa_sync_pass(spa) >= zfs_sync_pass_deferred_free &&
	!spa_feature_is_active(spa, SPA_FEATURE_LOG_SPACEMAP))) {
	bplist_append(&spa->spa_free_bplist[txg & TXG_MASK], bp);
	} else {
	VERIFY3P(zio_free_sync(NULL, spa, txg, bp, 0), ==, NULL);
	}
	}

	/*
	* To improve performance, this function may return NULL if we were able
	* to do the free immediately. This avoids the cost of creating a zio
	* (and linking it to the parent, etc).
	*/
	zio_t *
	zio_free_sync(zio_t pio, spa_t spa, uint64_t txg, const blkptr_t *bp,
	enum zio_flag flags)
	{
	ASSERT(!BP_IS_HOLE(bp));
	ASSERT(spa_syncing_txg(spa) == txg);

	if (BP_IS_EMBEDDED(bp))
	return (NULL);

	metaslab_check_free(spa, bp);
	arc_freed(spa, bp);
	dsl_scan_freed(spa, bp);

	if (BP_IS_GANG(bp) \|\| BP_GET_DEDUP(bp)) {
	/*
	* GANG and DEDUP blocks can induce a read (for the gang block
	* header, or the DDT), so issue them asynchronously so that
	* this thread is not tied up.
	*/
	enum zio_stage stage =
	ZIO_FREE_PIPELINE \| ZIO_STAGE_ISSUE_ASYNC;

	return (zio_create(pio, spa, txg, bp, NULL, BP_GET_PSIZE(bp),
	BP_GET_PSIZE(bp), NULL, NULL,
	ZIO_TYPE_FREE, ZIO_PRIORITY_NOW,
	flags, NULL, 0, NULL, ZIO_STAGE_OPEN, stage));
	} else {
	metaslab_free(spa, bp, txg, B_FALSE);
	return (NULL);
	}
	}

	zio_t *
	zio_claim(zio_t pio, spa_t spa, uint64_t txg, const blkptr_t *bp,
	zio_done_func_t done, void private, enum zio_flag flags)
	{
	zio_t *zio;

	(void) zfs_blkptr_verify(spa, bp, flags & ZIO_FLAG_CONFIG_WRITER,
	BLK_VERIFY_HALT);

	if (BP_IS_EMBEDDED(bp))
	return (zio_null(pio, spa, NULL, NULL, NULL, 0));

	/*
	* A claim is an allocation of a specific block. Claims are needed
	* to support immediate writes in the intent log. The issue is that
	* immediate writes contain committed data, but in a txg that was
	* not committed. Upon opening the pool after an unclean shutdown,
	* the intent log claims all blocks that contain immediate write data
	* so that the SPA knows they're in use.
	*
	* All claims must be resolved in the first txg -- before the SPA
	* starts allocating blocks -- so that nothing is allocated twice.
	* If txg == 0 we just verify that the block is claimable.
	*/
	ASSERT3U(spa->spa_uberblock.ub_rootbp.blk_birth, <,
	spa_min_claim_txg(spa));
	ASSERT(txg == spa_min_claim_txg(spa) \|\| txg == 0);
	ASSERT(!BP_GET_DEDUP(bp) \|\| !spa_writeable(spa)); /* zdb(8) */

	zio = zio_create(pio, spa, txg, bp, NULL, BP_GET_PSIZE(bp),
	BP_GET_PSIZE(bp), done, private, ZIO_TYPE_CLAIM, ZIO_PRIORITY_NOW,
	flags, NULL, 0, NULL, ZIO_STAGE_OPEN, ZIO_CLAIM_PIPELINE);
	ASSERT0(zio->io_queued_timestamp);

	return (zio);
	}

	zio_t *
	zio_ioctl(zio_t pio, spa_t spa, vdev_t *vd, int cmd,
	zio_done_func_t done, void private, enum zio_flag flags)
	{
	zio_t *zio;
	int c;

	if (vd->vdev_children == 0) {
	zio = zio_create(pio, spa, 0, NULL, NULL, 0, 0, done, private,
	ZIO_TYPE_IOCTL, ZIO_PRIORITY_NOW, flags, vd, 0, NULL,
	ZIO_STAGE_OPEN, ZIO_IOCTL_PIPELINE);

	zio->io_cmd = cmd;
	} else {
	zio = zio_null(pio, spa, NULL, NULL, NULL, flags);

	for (c = 0; c < vd->vdev_children; c++)
	zio_nowait(zio_ioctl(zio, spa, vd->vdev_child[c], cmd,
	done, private, flags));
	}

	return (zio);
	}

	zio_t *
	zio_trim(zio_t pio, vdev_t vd, uint64_t offset, uint64_t size,
	zio_done_func_t done, void private, zio_priority_t priority,
	enum zio_flag flags, enum trim_flag trim_flags)
	{
	zio_t *zio;

	ASSERT0(vd->vdev_children);
	ASSERT0(P2PHASE(offset, 1ULL << vd->vdev_ashift));
	ASSERT0(P2PHASE(size, 1ULL << vd->vdev_ashift));
	ASSERT3U(size, !=, 0);

	zio = zio_create(pio, vd->vdev_spa, 0, NULL, NULL, size, size, done,
	private, ZIO_TYPE_TRIM, priority, flags \| ZIO_FLAG_PHYSICAL,
	vd, offset, NULL, ZIO_STAGE_OPEN, ZIO_TRIM_PIPELINE);
	zio->io_trim_flags = trim_flags;

	return (zio);
	}

	zio_t *
	zio_read_phys(zio_t pio, vdev_t vd, uint64_t offset, uint64_t size,
	abd_t data, int checksum, zio_done_func_t done, void *private,
	zio_priority_t priority, enum zio_flag flags, boolean_t labels)
	{
	zio_t *zio;

	ASSERT(vd->vdev_children == 0);
	ASSERT(!labels \|\| offset + size <= VDEV_LABEL_START_SIZE \|\|
	offset >= vd->vdev_psize - VDEV_LABEL_END_SIZE);
	ASSERT3U(offset + size, <=, vd->vdev_psize);

	zio = zio_create(pio, vd->vdev_spa, 0, NULL, data, size, size, done,
	private, ZIO_TYPE_READ, priority, flags \| ZIO_FLAG_PHYSICAL, vd,
	offset, NULL, ZIO_STAGE_OPEN, ZIO_READ_PHYS_PIPELINE);

	zio->io_prop.zp_checksum = checksum;

	return (zio);
	}

	zio_t *
	zio_write_phys(zio_t pio, vdev_t vd, uint64_t offset, uint64_t size,
	abd_t data, int checksum, zio_done_func_t done, void *private,
	zio_priority_t priority, enum zio_flag flags, boolean_t labels)
	{
	zio_t *zio;

	ASSERT(vd->vdev_children == 0);
	ASSERT(!labels \|\| offset + size <= VDEV_LABEL_START_SIZE \|\|
	offset >= vd->vdev_psize - VDEV_LABEL_END_SIZE);
	ASSERT3U(offset + size, <=, vd->vdev_psize);

	zio = zio_create(pio, vd->vdev_spa, 0, NULL, data, size, size, done,
	private, ZIO_TYPE_WRITE, priority, flags \| ZIO_FLAG_PHYSICAL, vd,
	offset, NULL, ZIO_STAGE_OPEN, ZIO_WRITE_PHYS_PIPELINE);

	zio->io_prop.zp_checksum = checksum;

	if (zio_checksum_table[checksum].ci_flags & ZCHECKSUM_FLAG_EMBEDDED) {
	/*
	* zec checksums are necessarily destructive -- they modify
	* the end of the write buffer to hold the verifier/checksum.
	* Therefore, we must make a local copy in case the data is
	* being written to multiple places in parallel.
	*/
	abd_t *wbuf = abd_alloc_sametype(data, size);
	abd_copy(wbuf, data, size);

	zio_push_transform(zio, wbuf, size, size, NULL);
	}

	return (zio);
	}

	/*
	* Create a child I/O to do some work for us.
	*/
	zio_t *
	zio_vdev_child_io(zio_t pio, blkptr_t bp, vdev_t *vd, uint64_t offset,
	abd_t *data, uint64_t size, int type, zio_priority_t priority,
	enum zio_flag flags, zio_done_func_t done, void private)
	{
	enum zio_stage pipeline = ZIO_VDEV_CHILD_PIPELINE;
	zio_t *zio;

	/*
	* vdev child I/Os do not propagate their error to the parent.
	* Therefore, for correct operation the caller must check for
	* and handle the error in the child i/o's done callback.
	* The only exceptions are i/os that we don't care about
	* (OPTIONAL or REPAIR).
	*/
	ASSERT((flags & ZIO_FLAG_OPTIONAL) \|\| (flags & ZIO_FLAG_IO_REPAIR) \|\|
	done != NULL);

	if (type == ZIO_TYPE_READ && bp != NULL) {
	/*
	* If we have the bp, then the child should perform the
	* checksum and the parent need not. This pushes error
	* detection as close to the leaves as possible and
	* eliminates redundant checksums in the interior nodes.
	*/
	pipeline \|= ZIO_STAGE_CHECKSUM_VERIFY;
	pio->io_pipeline &= ~ZIO_STAGE_CHECKSUM_VERIFY;
	}

	if (vd->vdev_ops->vdev_op_leaf) {
	ASSERT0(vd->vdev_children);
	offset += VDEV_LABEL_START_SIZE;
	}

	flags \|= ZIO_VDEV_CHILD_FLAGS(pio);

	/*
	* If we've decided to do a repair, the write is not speculative --
	* even if the original read was.
	*/
	if (flags & ZIO_FLAG_IO_REPAIR)
	flags &= ~ZIO_FLAG_SPECULATIVE;

	/*
	* If we're creating a child I/O that is not associated with a
	* top-level vdev, then the child zio is not an allocating I/O.
	* If this is a retried I/O then we ignore it since we will
	* have already processed the original allocating I/O.
	*/
	if (flags & ZIO_FLAG_IO_ALLOCATING &&
	(vd != vd->vdev_top \|\| (flags & ZIO_FLAG_IO_RETRY))) {
	ASSERT(pio->io_metaslab_class != NULL);
	ASSERT(pio->io_metaslab_class->mc_alloc_throttle_enabled);
	ASSERT(type == ZIO_TYPE_WRITE);
	ASSERT(priority == ZIO_PRIORITY_ASYNC_WRITE);
	ASSERT(!(flags & ZIO_FLAG_IO_REPAIR));
	ASSERT(!(pio->io_flags & ZIO_FLAG_IO_REWRITE) \|\|
	pio->io_child_type == ZIO_CHILD_GANG);

	flags &= ~ZIO_FLAG_IO_ALLOCATING;
	}


	zio = zio_create(pio, pio->io_spa, pio->io_txg, bp, data, size, size,
	done, private, type, priority, flags, vd, offset, &pio->io_bookmark,
	ZIO_STAGE_VDEV_IO_START >> 1, pipeline);
	ASSERT3U(zio->io_child_type, ==, ZIO_CHILD_VDEV);

	zio->io_physdone = pio->io_physdone;
	if (vd->vdev_ops->vdev_op_leaf && zio->io_logical != NULL)
	zio->io_logical->io_phys_children++;

	return (zio);
	}

	zio_t *
	zio_vdev_delegated_io(vdev_t vd, uint64_t offset, abd_t data, uint64_t size,
	zio_type_t type, zio_priority_t priority, enum zio_flag flags,
	zio_done_func_t done, void private)
	{
	zio_t *zio;

	ASSERT(vd->vdev_ops->vdev_op_leaf);

	zio = zio_create(NULL, vd->vdev_spa, 0, NULL,
	data, size, size, done, private, type, priority,
	flags \| ZIO_FLAG_CANFAIL \| ZIO_FLAG_DONT_RETRY \| ZIO_FLAG_DELEGATED,
	vd, offset, NULL,
	ZIO_STAGE_VDEV_IO_START >> 1, ZIO_VDEV_CHILD_PIPELINE);

	return (zio);
	}

	void
	zio_flush(zio_t zio, vdev_t vd)
	{
	zio_nowait(zio_ioctl(zio, zio->io_spa, vd, DKIOCFLUSHWRITECACHE,
	NULL, NULL,
	ZIO_FLAG_CANFAIL \| ZIO_FLAG_DONT_PROPAGATE \| ZIO_FLAG_DONT_RETRY));
	}

	void
	zio_shrink(zio_t *zio, uint64_t size)
	{
	ASSERT3P(zio->io_executor, ==, NULL);
	ASSERT3U(zio->io_orig_size, ==, zio->io_size);
	ASSERT3U(size, <=, zio->io_size);

	/*
	* We don't shrink for raidz because of problems with the
	* reconstruction when reading back less than the block size.
	* Note, BP_IS_RAIDZ() assumes no compression.
	*/
	ASSERT(BP_GET_COMPRESS(zio->io_bp) == ZIO_COMPRESS_OFF);
	if (!BP_IS_RAIDZ(zio->io_bp)) {
	/* we are not doing a raw write */
	ASSERT3U(zio->io_size, ==, zio->io_lsize);
	zio->io_orig_size = zio->io_size = zio->io_lsize = size;
	}
	}

	/*
	* ==========================================================================
	* Prepare to read and write logical blocks
	* ==========================================================================
	*/

	static zio_t *
	zio_read_bp_init(zio_t *zio)
	{
	blkptr_t *bp = zio->io_bp;
	uint64_t psize =
	BP_IS_EMBEDDED(bp) ? BPE_GET_PSIZE(bp) : BP_GET_PSIZE(bp);

	ASSERT3P(zio->io_bp, ==, &zio->io_bp_copy);

	if (BP_GET_COMPRESS(bp) != ZIO_COMPRESS_OFF &&
	zio->io_child_type == ZIO_CHILD_LOGICAL &&
	!(zio->io_flags & ZIO_FLAG_RAW_COMPRESS)) {
	zio_push_transform(zio, abd_alloc_sametype(zio->io_abd, psize),
	psize, psize, zio_decompress);
	}

	if (((BP_IS_PROTECTED(bp) && !(zio->io_flags & ZIO_FLAG_RAW_ENCRYPT)) \|\|
	BP_HAS_INDIRECT_MAC_CKSUM(bp)) &&
	zio->io_child_type == ZIO_CHILD_LOGICAL) {
	zio_push_transform(zio, abd_alloc_sametype(zio->io_abd, psize),
	psize, psize, zio_decrypt);
	}

	if (BP_IS_EMBEDDED(bp) && BPE_GET_ETYPE(bp) == BP_EMBEDDED_TYPE_DATA) {
	int psize = BPE_GET_PSIZE(bp);
	void *data = abd_borrow_buf(zio->io_abd, psize);

	zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
	decode_embedded_bp_compressed(bp, data);
	abd_return_buf_copy(zio->io_abd, data, psize);
	} else {
	ASSERT(!BP_IS_EMBEDDED(bp));
	ASSERT3P(zio->io_bp, ==, &zio->io_bp_copy);
	}

	if (!DMU_OT_IS_METADATA(BP_GET_TYPE(bp)) && BP_GET_LEVEL(bp) == 0)
	zio->io_flags \|= ZIO_FLAG_DONT_CACHE;

	if (BP_GET_TYPE(bp) == DMU_OT_DDT_ZAP)
	zio->io_flags \|= ZIO_FLAG_DONT_CACHE;

	if (BP_GET_DEDUP(bp) && zio->io_child_type == ZIO_CHILD_LOGICAL)
	zio->io_pipeline = ZIO_DDT_READ_PIPELINE;

	return (zio);
	}

	static zio_t *
	zio_write_bp_init(zio_t *zio)
	{
	if (!IO_IS_ALLOCATING(zio))
	return (zio);

	ASSERT(zio->io_child_type != ZIO_CHILD_DDT);

	if (zio->io_bp_override) {
	blkptr_t *bp = zio->io_bp;
	zio_prop_t *zp = &zio->io_prop;

	ASSERT(bp->blk_birth != zio->io_txg);
	ASSERT(BP_GET_DEDUP(zio->io_bp_override) == 0);

	bp = zio->io_bp_override;
	zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;

	if (BP_IS_EMBEDDED(bp))
	return (zio);

	/*
	* If we've been overridden and nopwrite is set then
	* set the flag accordingly to indicate that a nopwrite
	* has already occurred.
	*/
	if (!BP_IS_HOLE(bp) && zp->zp_nopwrite) {
	ASSERT(!zp->zp_dedup);
	ASSERT3U(BP_GET_CHECKSUM(bp), ==, zp->zp_checksum);
	zio->io_flags \|= ZIO_FLAG_NOPWRITE;
	return (zio);
	}

	ASSERT(!zp->zp_nopwrite);

	if (BP_IS_HOLE(bp) \|\| !zp->zp_dedup)
	return (zio);

	ASSERT((zio_checksum_table[zp->zp_checksum].ci_flags &
	ZCHECKSUM_FLAG_DEDUP) \|\| zp->zp_dedup_verify);

	if (BP_GET_CHECKSUM(bp) == zp->zp_checksum &&
	!zp->zp_encrypt) {
	BP_SET_DEDUP(bp, 1);
	zio->io_pipeline \|= ZIO_STAGE_DDT_WRITE;
	return (zio);
	}

	/*
	* We were unable to handle this as an override bp, treat
	* it as a regular write I/O.
	*/
	zio->io_bp_override = NULL;
	*bp = zio->io_bp_orig;
	zio->io_pipeline = zio->io_orig_pipeline;
	}

	return (zio);
	}

	static zio_t *
	zio_write_compress(zio_t *zio)
	{
	spa_t *spa = zio->io_spa;
	zio_prop_t *zp = &zio->io_prop;
	enum zio_compress compress = zp->zp_compress;
	blkptr_t *bp = zio->io_bp;
	uint64_t lsize = zio->io_lsize;
	uint64_t psize = zio->io_size;
	int pass = 1;

	/*
	* If our children haven't all reached the ready stage,
	* wait for them and then repeat this pipeline stage.
	*/
	if (zio_wait_for_children(zio, ZIO_CHILD_LOGICAL_BIT \|
	ZIO_CHILD_GANG_BIT, ZIO_WAIT_READY)) {
	return (NULL);
	}

	if (!IO_IS_ALLOCATING(zio))
	return (zio);

	if (zio->io_children_ready != NULL) {
	/*
	* Now that all our children are ready, run the callback
	* associated with this zio in case it wants to modify the
	* data to be written.
	*/
	ASSERT3U(zp->zp_level, >, 0);
	zio->io_children_ready(zio);
	}

	ASSERT(zio->io_child_type != ZIO_CHILD_DDT);
	ASSERT(zio->io_bp_override == NULL);

	if (!BP_IS_HOLE(bp) && bp->blk_birth == zio->io_txg) {
	/*
	* We're rewriting an existing block, which means we're
	* working on behalf of spa_sync(). For spa_sync() to
	* converge, it must eventually be the case that we don't
	* have to allocate new blocks. But compression changes
	* the blocksize, which forces a reallocate, and makes
	* convergence take longer. Therefore, after the first
	* few passes, stop compressing to ensure convergence.
	*/
	pass = spa_sync_pass(spa);

	ASSERT(zio->io_txg == spa_syncing_txg(spa));
	ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
	ASSERT(!BP_GET_DEDUP(bp));

	if (pass >= zfs_sync_pass_dont_compress)
	compress = ZIO_COMPRESS_OFF;

	/* Make sure someone doesn't change their mind on overwrites */
	ASSERT(BP_IS_EMBEDDED(bp) \|\| MIN(zp->zp_copies + BP_IS_GANG(bp),
	spa_max_replication(spa)) == BP_GET_NDVAS(bp));
	}

	/* If it's a compressed write that is not raw, compress the buffer. */
	if (compress != ZIO_COMPRESS_OFF &&
	!(zio->io_flags & ZIO_FLAG_RAW_COMPRESS)) {
	void *cbuf = zio_buf_alloc(lsize);
	psize = zio_compress_data(compress, zio->io_abd, cbuf, lsize,
	zp->zp_complevel);
	if (psize == 0 \|\| psize >= lsize) {
	compress = ZIO_COMPRESS_OFF;
	zio_buf_free(cbuf, lsize);
	} else if (!zp->zp_dedup && !zp->zp_encrypt &&
	psize <= BPE_PAYLOAD_SIZE &&
	zp->zp_level == 0 && !DMU_OT_HAS_FILL(zp->zp_type) &&
	spa_feature_is_enabled(spa, SPA_FEATURE_EMBEDDED_DATA)) {
	encode_embedded_bp_compressed(bp,
	cbuf, compress, lsize, psize);
	BPE_SET_ETYPE(bp, BP_EMBEDDED_TYPE_DATA);
	BP_SET_TYPE(bp, zio->io_prop.zp_type);
	BP_SET_LEVEL(bp, zio->io_prop.zp_level);
	zio_buf_free(cbuf, lsize);
	bp->blk_birth = zio->io_txg;
	zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
	ASSERT(spa_feature_is_active(spa,
	SPA_FEATURE_EMBEDDED_DATA));
	return (zio);
	} else {
	/*
	* Round compressed size up to the minimum allocation
	* size of the smallest-ashift device, and zero the
	* tail. This ensures that the compressed size of the
	* BP (and thus compressratio property) are correct,
	* in that we charge for the padding used to fill out
	* the last sector.
	*/
	ASSERT3U(spa->spa_min_alloc, >=, SPA_MINBLOCKSHIFT);
	size_t rounded = (size_t)roundup(psize,
	spa->spa_min_alloc);
	if (rounded >= lsize) {
	compress = ZIO_COMPRESS_OFF;
	zio_buf_free(cbuf, lsize);
	psize = lsize;
	} else {
	abd_t *cdata = abd_get_from_buf(cbuf, lsize);
	abd_take_ownership_of_buf(cdata, B_TRUE);
	abd_zero_off(cdata, psize, rounded - psize);
	psize = rounded;
	zio_push_transform(zio, cdata,
	psize, lsize, NULL);
	}
	}

	/*
	* We were unable to handle this as an override bp, treat
	* it as a regular write I/O.
	*/
	zio->io_bp_override = NULL;
	*bp = zio->io_bp_orig;
	zio->io_pipeline = zio->io_orig_pipeline;

	} else if ((zio->io_flags & ZIO_FLAG_RAW_ENCRYPT) != 0 &&
	zp->zp_type == DMU_OT_DNODE) {
	/*
	* The DMU actually relies on the zio layer's compression
	* to free metadnode blocks that have had all contained
	* dnodes freed. As a result, even when doing a raw
	* receive, we must check whether the block can be compressed
	* to a hole.
	*/
	psize = zio_compress_data(ZIO_COMPRESS_EMPTY,
	zio->io_abd, NULL, lsize, zp->zp_complevel);
	if (psize == 0 \|\| psize >= lsize)
	compress = ZIO_COMPRESS_OFF;
	} else {
	ASSERT3U(psize, !=, 0);
	}

	/*
	* The final pass of spa_sync() must be all rewrites, but the first
	* few passes offer a trade-off: allocating blocks defers convergence,
	* but newly allocated blocks are sequential, so they can be written
	* to disk faster. Therefore, we allow the first few passes of
	* spa_sync() to allocate new blocks, but force rewrites after that.
	* There should only be a handful of blocks after pass 1 in any case.
	*/
	if (!BP_IS_HOLE(bp) && bp->blk_birth == zio->io_txg &&
	BP_GET_PSIZE(bp) == psize &&
	pass >= zfs_sync_pass_rewrite) {
	VERIFY3U(psize, !=, 0);
	enum zio_stage gang_stages = zio->io_pipeline & ZIO_GANG_STAGES;

	zio->io_pipeline = ZIO_REWRITE_PIPELINE \| gang_stages;
	zio->io_flags \|= ZIO_FLAG_IO_REWRITE;
	} else {
	BP_ZERO(bp);
	zio->io_pipeline = ZIO_WRITE_PIPELINE;
	}

	if (psize == 0) {
	if (zio->io_bp_orig.blk_birth != 0 &&
	spa_feature_is_active(spa, SPA_FEATURE_HOLE_BIRTH)) {
	BP_SET_LSIZE(bp, lsize);
	BP_SET_TYPE(bp, zp->zp_type);
	BP_SET_LEVEL(bp, zp->zp_level);
	BP_SET_BIRTH(bp, zio->io_txg, 0);
	}
	zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
	} else {
	ASSERT(zp->zp_checksum != ZIO_CHECKSUM_GANG_HEADER);
	BP_SET_LSIZE(bp, lsize);
	BP_SET_TYPE(bp, zp->zp_type);
	BP_SET_LEVEL(bp, zp->zp_level);
	BP_SET_PSIZE(bp, psize);
	BP_SET_COMPRESS(bp, compress);
	BP_SET_CHECKSUM(bp, zp->zp_checksum);
	BP_SET_DEDUP(bp, zp->zp_dedup);
	BP_SET_BYTEORDER(bp, ZFS_HOST_BYTEORDER);
	if (zp->zp_dedup) {
	ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
	ASSERT(!(zio->io_flags & ZIO_FLAG_IO_REWRITE));
	ASSERT(!zp->zp_encrypt \|\|
	DMU_OT_IS_ENCRYPTED(zp->zp_type));
	zio->io_pipeline = ZIO_DDT_WRITE_PIPELINE;
	}
	if (zp->zp_nopwrite) {
	ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
	ASSERT(!(zio->io_flags & ZIO_FLAG_IO_REWRITE));
	zio->io_pipeline \|= ZIO_STAGE_NOP_WRITE;
	}
	}
	return (zio);
	}

	static zio_t *
	zio_free_bp_init(zio_t *zio)
	{
	blkptr_t *bp = zio->io_bp;

	if (zio->io_child_type == ZIO_CHILD_LOGICAL) {
	if (BP_GET_DEDUP(bp))
	zio->io_pipeline = ZIO_DDT_FREE_PIPELINE;
	}

	ASSERT3P(zio->io_bp, ==, &zio->io_bp_copy);

	return (zio);
	}

	/*
	* ==========================================================================
	* Execute the I/O pipeline
	* ==========================================================================
	*/

	static void
	zio_taskq_dispatch(zio_t *zio, zio_taskq_type_t q, boolean_t cutinline)
	{
	spa_t *spa = zio->io_spa;
	zio_type_t t = zio->io_type;
	int flags = (cutinline ? TQ_FRONT : 0);

	/*
	* If we're a config writer or a probe, the normal issue and
	* interrupt threads may all be blocked waiting for the config lock.
	* In this case, select the otherwise-unused taskq for ZIO_TYPE_NULL.
	*/
	if (zio->io_flags & (ZIO_FLAG_CONFIG_WRITER \| ZIO_FLAG_PROBE))
	t = ZIO_TYPE_NULL;

	/*
	* A similar issue exists for the L2ARC write thread until L2ARC 2.0.
	*/
	if (t == ZIO_TYPE_WRITE && zio->io_vd && zio->io_vd->vdev_aux)
	t = ZIO_TYPE_NULL;

	/*
	* If this is a high priority I/O, then use the high priority taskq if
	* available.
	*/
	if ((zio->io_priority == ZIO_PRIORITY_NOW \|\|
	zio->io_priority == ZIO_PRIORITY_SYNC_WRITE) &&
	spa->spa_zio_taskq[t][q + 1].stqs_count != 0)
	q++;

	ASSERT3U(q, <, ZIO_TASKQ_TYPES);

	/*
	* NB: We are assuming that the zio can only be dispatched
	* to a single taskq at a time. It would be a grievous error
	* to dispatch the zio to another taskq at the same time.
	*/
	ASSERT(taskq_empty_ent(&zio->io_tqent));
	spa_taskq_dispatch_ent(spa, t, q, (task_func_t *)zio_execute, zio,
	flags, &zio->io_tqent);
	}

	static boolean_t
	zio_taskq_member(zio_t *zio, zio_taskq_type_t q)
	{
	spa_t *spa = zio->io_spa;

	taskq_t *tq = taskq_of_curthread();

	for (zio_type_t t = 0; t < ZIO_TYPES; t++) {
	spa_taskqs_t *tqs = &spa->spa_zio_taskq[t][q];
	uint_t i;
	for (i = 0; i < tqs->stqs_count; i++) {
	if (tqs->stqs_taskq[i] == tq)
	return (B_TRUE);
	}
	}

	return (B_FALSE);
	}

	static zio_t *
	zio_issue_async(zio_t *zio)
	{
	zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, B_FALSE);

	return (NULL);
	}

	void
	zio_interrupt(zio_t *zio)
	{
	zio_taskq_dispatch(zio, ZIO_TASKQ_INTERRUPT, B_FALSE);
	}

	void
	zio_delay_interrupt(zio_t *zio)
	{
	/*
	* The timeout_generic() function isn't defined in userspace, so
	* rather than trying to implement the function, the zio delay
	* functionality has been disabled for userspace builds.
	*/

	#ifdef _KERNEL
	/*
	* If io_target_timestamp is zero, then no delay has been registered
	* for this IO, thus jump to the end of this function and "skip" the
	* delay; issuing it directly to the zio layer.
	*/
	if (zio->io_target_timestamp != 0) {
	hrtime_t now = gethrtime();

	if (now >= zio->io_target_timestamp) {
	/*
	* This IO has already taken longer than the target
	* delay to complete, so we don't want to delay it
	* any longer; we "miss" the delay and issue it
	* directly to the zio layer. This is likely due to
	* the target latency being set to a value less than
	* the underlying hardware can satisfy (e.g. delay
	* set to 1ms, but the disks take 10ms to complete an
	* IO request).
	*/

	DTRACE_PROBE2(zio__delay__miss, zio_t *, zio,
	hrtime_t, now);

	zio_interrupt(zio);
	} else {
	taskqid_t tid;
	hrtime_t diff = zio->io_target_timestamp - now;
	clock_t expire_at_tick = ddi_get_lbolt() +
	NSEC_TO_TICK(diff);

	DTRACE_PROBE3(zio__delay__hit, zio_t *, zio,
	hrtime_t, now, hrtime_t, diff);

	if (NSEC_TO_TICK(diff) == 0) {
	/* Our delay is less than a jiffy - just spin */
	zfs_sleep_until(zio->io_target_timestamp);
	zio_interrupt(zio);
	} else {
	/*
	* Use taskq_dispatch_delay() in the place of
	* OpenZFS's timeout_generic().
	*/
	tid = taskq_dispatch_delay(system_taskq,
	(task_func_t *)zio_interrupt,
	zio, TQ_NOSLEEP, expire_at_tick);
	if (tid == TASKQID_INVALID) {
	/*
	* Couldn't allocate a task. Just
	* finish the zio without a delay.
	*/
	zio_interrupt(zio);
	}
	}
	}
	return;
	}
	#endif
	DTRACE_PROBE1(zio__delay__skip, zio_t *, zio);
	zio_interrupt(zio);
	}

	static void
	zio_deadman_impl(zio_t *pio, int ziodepth)
	{
	zio_t cio, cio_next;
	zio_link_t *zl = NULL;
	vdev_t *vd = pio->io_vd;

	if (zio_deadman_log_all \|\| (vd != NULL && vd->vdev_ops->vdev_op_leaf)) {
	vdev_queue_t *vq = vd ? &vd->vdev_queue : NULL;
	zbookmark_phys_t *zb = &pio->io_bookmark;
	uint64_t delta = gethrtime() - pio->io_timestamp;
	uint64_t failmode = spa_get_deadman_failmode(pio->io_spa);

	zfs_dbgmsg("slow zio[%d]: zio=%px timestamp=%llu "
	"delta=%llu queued=%llu io=%llu "
	"path=%s last=%llu "
	"type=%d priority=%d flags=0x%x "
	"stage=0x%x pipeline=0x%x pipeline-trace=0x%x "
	"objset=%llu object=%llu level=%llu blkid=%llu "
	"offset=%llu size=%llu error=%d",
	ziodepth, pio, pio->io_timestamp,
	delta, pio->io_delta, pio->io_delay,
	vd ? vd->vdev_path : "NULL", vq ? vq->vq_io_complete_ts : 0,
	pio->io_type, pio->io_priority, pio->io_flags,
	pio->io_stage, pio->io_pipeline, pio->io_pipeline_trace,
	zb->zb_objset, zb->zb_object, zb->zb_level, zb->zb_blkid,
	pio->io_offset, pio->io_size, pio->io_error);
	(void) zfs_ereport_post(FM_EREPORT_ZFS_DEADMAN,
	pio->io_spa, vd, zb, pio, 0);

	if (failmode == ZIO_FAILURE_MODE_CONTINUE &&
	taskq_empty_ent(&pio->io_tqent)) {
	zio_interrupt(pio);
	}
	}

	mutex_enter(&pio->io_lock);
	for (cio = zio_walk_children(pio, &zl); cio != NULL; cio = cio_next) {
	cio_next = zio_walk_children(pio, &zl);
	zio_deadman_impl(cio, ziodepth + 1);
	}
	mutex_exit(&pio->io_lock);
	}

	/*
	* Log the critical information describing this zio and all of its children
	* using the zfs_dbgmsg() interface then post deadman event for the ZED.
	*/
	void
	zio_deadman(zio_t pio, char tag)
	{
	spa_t *spa = pio->io_spa;
	char *name = spa_name(spa);

	if (!zfs_deadman_enabled \|\| spa_suspended(spa))
	return;

	zio_deadman_impl(pio, 0);

	switch (spa_get_deadman_failmode(spa)) {
	case ZIO_FAILURE_MODE_WAIT:
	zfs_dbgmsg("%s waiting for hung I/O to pool '%s'", tag, name);
	break;

	case ZIO_FAILURE_MODE_CONTINUE:
	zfs_dbgmsg("%s restarting hung I/O for pool '%s'", tag, name);
	break;

	case ZIO_FAILURE_MODE_PANIC:
	fm_panic("%s determined I/O to pool '%s' is hung.", tag, name);
	break;
	}
	}

	/*
	* Execute the I/O pipeline until one of the following occurs:
	* (1) the I/O completes; (2) the pipeline stalls waiting for
	* dependent child I/Os; (3) the I/O issues, so we're waiting
	* for an I/O completion interrupt; (4) the I/O is delegated by
	* vdev-level caching or aggregation; (5) the I/O is deferred
	* due to vdev-level queueing; (6) the I/O is handed off to
	* another thread. In all cases, the pipeline stops whenever
	* there's no CPU work; it never burns a thread in cv_wait_io().
	*
	* There's no locking on io_stage because there's no legitimate way
	* for multiple threads to be attempting to process the same I/O.
	*/
	static zio_pipe_stage_t *zio_pipeline[];

	/*
	* zio_execute() is a wrapper around the static function
	* __zio_execute() so that we can force __zio_execute() to be
	* inlined. This reduces stack overhead which is important
	* because __zio_execute() is called recursively in several zio
	* code paths. zio_execute() itself cannot be inlined because
	* it is externally visible.
	*/
	void
	zio_execute(zio_t *zio)
	{
	fstrans_cookie_t cookie;

	cookie = spl_fstrans_mark();
	__zio_execute(zio);
	spl_fstrans_unmark(cookie);
	}

	/*
	* Used to determine if in the current context the stack is sized large
	* enough to allow zio_execute() to be called recursively. A minimum
	* stack size of 16K is required to avoid needing to re-dispatch the zio.
	*/
	static boolean_t
	zio_execute_stack_check(zio_t *zio)
	{
	#if !defined(HAVE_LARGE_STACKS)
	dsl_pool_t *dp = spa_get_dsl(zio->io_spa);

	/* Executing in txg_sync_thread() context. */
	if (dp && curthread == dp->dp_tx.tx_sync_thread)
	return (B_TRUE);

	/* Pool initialization outside of zio_taskq context. */
	if (dp && spa_is_initializing(dp->dp_spa) &&
	!zio_taskq_member(zio, ZIO_TASKQ_ISSUE) &&
	!zio_taskq_member(zio, ZIO_TASKQ_ISSUE_HIGH))
	return (B_TRUE);
	#endif /* HAVE_LARGE_STACKS */

	return (B_FALSE);
	}

	__attribute__((always_inline))
	static inline void
	__zio_execute(zio_t *zio)
	{
	ASSERT3U(zio->io_queued_timestamp, >, 0);

	while (zio->io_stage < ZIO_STAGE_DONE) {
	enum zio_stage pipeline = zio->io_pipeline;
	enum zio_stage stage = zio->io_stage;

	zio->io_executor = curthread;

	ASSERT(!MUTEX_HELD(&zio->io_lock));
	ASSERT(ISP2(stage));
	ASSERT(zio->io_stall == NULL);

	do {
	stage <<= 1;
	} while ((stage & pipeline) == 0);

	ASSERT(stage <= ZIO_STAGE_DONE);

	/*
	* If we are in interrupt context and this pipeline stage
	* will grab a config lock that is held across I/O,
	* or may wait for an I/O that needs an interrupt thread
	* to complete, issue async to avoid deadlock.
	*
	* For VDEV_IO_START, we cut in line so that the io will
	* be sent to disk promptly.
	*/
	if ((stage & ZIO_BLOCKING_STAGES) && zio->io_vd == NULL &&
	zio_taskq_member(zio, ZIO_TASKQ_INTERRUPT)) {
	boolean_t cut = (stage == ZIO_STAGE_VDEV_IO_START) ?
	zio_requeue_io_start_cut_in_line : B_FALSE;
	zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, cut);
	return;
	}

	/*
	* If the current context doesn't have large enough stacks
	* the zio must be issued asynchronously to prevent overflow.
	*/
	if (zio_execute_stack_check(zio)) {
	boolean_t cut = (stage == ZIO_STAGE_VDEV_IO_START) ?
	zio_requeue_io_start_cut_in_line : B_FALSE;
	zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, cut);
	return;
	}

	zio->io_stage = stage;
	zio->io_pipeline_trace \|= zio->io_stage;

	/*
	* The zio pipeline stage returns the next zio to execute
	* (typically the same as this one), or NULL if we should
	* stop.
	*/
	zio = zio_pipeline[highbit64(stage) - 1](zio);

	if (zio == NULL)
	return;
	}
	}


	/*
	* ==========================================================================
	* Initiate I/O, either sync or async
	* ==========================================================================
	*/
	int
	zio_wait(zio_t *zio)
	{
	/*
	* Some routines, like zio_free_sync(), may return a NULL zio
	* to avoid the performance overhead of creating and then destroying
	* an unneeded zio. For the callers' simplicity, we accept a NULL
	* zio and ignore it.
	*/
	if (zio == NULL)
	return (0);

	long timeout = MSEC_TO_TICK(zfs_deadman_ziotime_ms);
	int error;

	ASSERT3S(zio->io_stage, ==, ZIO_STAGE_OPEN);
	ASSERT3P(zio->io_executor, ==, NULL);

	zio->io_waiter = curthread;
	ASSERT0(zio->io_queued_timestamp);
	zio->io_queued_timestamp = gethrtime();

	__zio_execute(zio);

	mutex_enter(&zio->io_lock);
	while (zio->io_executor != NULL) {
	error = cv_timedwait_io(&zio->io_cv, &zio->io_lock,
	ddi_get_lbolt() + timeout);

	if (zfs_deadman_enabled && error == -1 &&
	gethrtime() - zio->io_queued_timestamp >
	spa_deadman_ziotime(zio->io_spa)) {
	mutex_exit(&zio->io_lock);
	timeout = MSEC_TO_TICK(zfs_deadman_checktime_ms);
	zio_deadman(zio, FTAG);
	mutex_enter(&zio->io_lock);
	}
	}
	mutex_exit(&zio->io_lock);

	error = zio->io_error;
	zio_destroy(zio);

	return (error);
	}

	void
	zio_nowait(zio_t *zio)
	{
	/*
	* See comment in zio_wait().
	*/
	if (zio == NULL)
	return;

	ASSERT3P(zio->io_executor, ==, NULL);

	if (zio->io_child_type == ZIO_CHILD_LOGICAL &&
	zio_unique_parent(zio) == NULL) {
	zio_t *pio;

	/*
	* This is a logical async I/O with no parent to wait for it.
	* We add it to the spa_async_root_zio "Godfather" I/O which
	* will ensure they complete prior to unloading the pool.
	*/
	spa_t *spa = zio->io_spa;
	pio = spa->spa_async_zio_root[CPU_SEQID_UNSTABLE];

	zio_add_child(pio, zio);
	}

	ASSERT0(zio->io_queued_timestamp);
	zio->io_queued_timestamp = gethrtime();
	__zio_execute(zio);
	}

	/*
	* ==========================================================================
	* Reexecute, cancel, or suspend/resume failed I/O
	* ==========================================================================
	*/

	static void
	zio_reexecute(zio_t *pio)
	{
	zio_t cio, cio_next;

	ASSERT(pio->io_child_type == ZIO_CHILD_LOGICAL);
	ASSERT(pio->io_orig_stage == ZIO_STAGE_OPEN);
	ASSERT(pio->io_gang_leader == NULL);
	ASSERT(pio->io_gang_tree == NULL);

	pio->io_flags = pio->io_orig_flags;
	pio->io_stage = pio->io_orig_stage;
	pio->io_pipeline = pio->io_orig_pipeline;
	pio->io_reexecute = 0;
	pio->io_flags \|= ZIO_FLAG_REEXECUTED;
	pio->io_pipeline_trace = 0;
	pio->io_error = 0;
	for (int w = 0; w < ZIO_WAIT_TYPES; w++)
	pio->io_state[w] = 0;
	for (int c = 0; c < ZIO_CHILD_TYPES; c++)
	pio->io_child_error[c] = 0;

	if (IO_IS_ALLOCATING(pio))
	BP_ZERO(pio->io_bp);

	/*
	* As we reexecute pio's children, new children could be created.
	* New children go to the head of pio's io_child_list, however,
	* so we will (correctly) not reexecute them. The key is that
	* the remainder of pio's io_child_list, from 'cio_next' onward,
	* cannot be affected by any side effects of reexecuting 'cio'.
	*/
	zio_link_t *zl = NULL;
	mutex_enter(&pio->io_lock);
	for (cio = zio_walk_children(pio, &zl); cio != NULL; cio = cio_next) {
	cio_next = zio_walk_children(pio, &zl);
	for (int w = 0; w < ZIO_WAIT_TYPES; w++)
	pio->io_children[cio->io_child_type][w]++;
	mutex_exit(&pio->io_lock);
	zio_reexecute(cio);
	mutex_enter(&pio->io_lock);
	}
	mutex_exit(&pio->io_lock);

	/*
	* Now that all children have been reexecuted, execute the parent.
	* We don't reexecute "The Godfather" I/O here as it's the
	* responsibility of the caller to wait on it.
	*/
	if (!(pio->io_flags & ZIO_FLAG_GODFATHER)) {
	pio->io_queued_timestamp = gethrtime();
	__zio_execute(pio);
	}
	}

	void
	zio_suspend(spa_t spa, zio_t zio, zio_suspend_reason_t reason)
	{
	if (spa_get_failmode(spa) == ZIO_FAILURE_MODE_PANIC)
	fm_panic("Pool '%s' has encountered an uncorrectable I/O "
	"failure and the failure mode property for this pool "
	"is set to panic.", spa_name(spa));

	cmn_err(CE_WARN, "Pool '%s' has encountered an uncorrectable I/O "
	"failure and has been suspended.\n", spa_name(spa));

	(void) zfs_ereport_post(FM_EREPORT_ZFS_IO_FAILURE, spa, NULL,
	NULL, NULL, 0);

	mutex_enter(&spa->spa_suspend_lock);

	if (spa->spa_suspend_zio_root == NULL)
	spa->spa_suspend_zio_root = zio_root(spa, NULL, NULL,
	ZIO_FLAG_CANFAIL \| ZIO_FLAG_SPECULATIVE \|
	ZIO_FLAG_GODFATHER);

	spa->spa_suspended = reason;

	if (zio != NULL) {
	ASSERT(!(zio->io_flags & ZIO_FLAG_GODFATHER));
	ASSERT(zio != spa->spa_suspend_zio_root);
	ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);
	ASSERT(zio_unique_parent(zio) == NULL);
	ASSERT(zio->io_stage == ZIO_STAGE_DONE);
	zio_add_child(spa->spa_suspend_zio_root, zio);
	}

	mutex_exit(&spa->spa_suspend_lock);
	}

	int
	zio_resume(spa_t *spa)
	{
	zio_t *pio;

	/*
	* Reexecute all previously suspended i/o.
	*/
	mutex_enter(&spa->spa_suspend_lock);
	spa->spa_suspended = ZIO_SUSPEND_NONE;
	cv_broadcast(&spa->spa_suspend_cv);
	pio = spa->spa_suspend_zio_root;
	spa->spa_suspend_zio_root = NULL;
	mutex_exit(&spa->spa_suspend_lock);

	if (pio == NULL)
	return (0);

	zio_reexecute(pio);
	return (zio_wait(pio));
	}

	void
	zio_resume_wait(spa_t *spa)
	{
	mutex_enter(&spa->spa_suspend_lock);
	while (spa_suspended(spa))
	cv_wait(&spa->spa_suspend_cv, &spa->spa_suspend_lock);
	mutex_exit(&spa->spa_suspend_lock);
	}

	/*
	* ==========================================================================
	* Gang blocks.
	*
	* A gang block is a collection of small blocks that looks to the DMU
	* like one large block. When zio_dva_allocate() cannot find a block
	* of the requested size, due to either severe fragmentation or the pool
	* being nearly full, it calls zio_write_gang_block() to construct the
	* block from smaller fragments.
	*
	* A gang block consists of a gang header (zio_gbh_phys_t) and up to
	* three (SPA_GBH_NBLKPTRS) gang members. The gang header is just like
	* an indirect block: it's an array of block pointers. It consumes
	* only one sector and hence is allocatable regardless of fragmentation.
	* The gang header's bps point to its gang members, which hold the data.
	*
	* Gang blocks are self-checksumming, using the bp's <vdev, offset, txg>
	* as the verifier to ensure uniqueness of the SHA256 checksum.
	* Critically, the gang block bp's blk_cksum is the checksum of the data,
	* not the gang header. This ensures that data block signatures (needed for
	* deduplication) are independent of how the block is physically stored.
	*
	* Gang blocks can be nested: a gang member may itself be a gang block.
	* Thus every gang block is a tree in which root and all interior nodes are
	* gang headers, and the leaves are normal blocks that contain user data.
	* The root of the gang tree is called the gang leader.
	*
	* To perform any operation (read, rewrite, free, claim) on a gang block,
	* zio_gang_assemble() first assembles the gang tree (minus data leaves)
	* in the io_gang_tree field of the original logical i/o by recursively
	* reading the gang leader and all gang headers below it. This yields
	* an in-core tree containing the contents of every gang header and the
	* bps for every constituent of the gang block.
	*
	* With the gang tree now assembled, zio_gang_issue() just walks the gang tree
	* and invokes a callback on each bp. To free a gang block, zio_gang_issue()
	* calls zio_free_gang() -- a trivial wrapper around zio_free() -- for each bp.
	* zio_claim_gang() provides a similarly trivial wrapper for zio_claim().
	* zio_read_gang() is a wrapper around zio_read() that omits reading gang
	* headers, since we already have those in io_gang_tree. zio_rewrite_gang()
	* performs a zio_rewrite() of the data or, for gang headers, a zio_rewrite()
	* of the gang header plus zio_checksum_compute() of the data to update the
	* gang header's blk_cksum as described above.
	*
	* The two-phase assemble/issue model solves the problem of partial failure --
	* what if you'd freed part of a gang block but then couldn't read the
	* gang header for another part? Assembling the entire gang tree first
	* ensures that all the necessary gang header I/O has succeeded before
	* starting the actual work of free, claim, or write. Once the gang tree
	* is assembled, free and claim are in-memory operations that cannot fail.
	*
	* In the event that a gang write fails, zio_dva_unallocate() walks the
	* gang tree to immediately free (i.e. insert back into the space map)
	* everything we've allocated. This ensures that we don't get ENOSPC
	* errors during repeated suspend/resume cycles due to a flaky device.
	*
	* Gang rewrites only happen during sync-to-convergence. If we can't assemble
	* the gang tree, we won't modify the block, so we can safely defer the free
	* (knowing that the block is still intact). If we can assemble the gang
	* tree, then even if some of the rewrites fail, zio_dva_unallocate() will free
	* each constituent bp and we can allocate a new block on the next sync pass.
	*
	* In all cases, the gang tree allows complete recovery from partial failure.
	* ==========================================================================
	*/

	static void
	zio_gang_issue_func_done(zio_t *zio)
	{
	abd_free(zio->io_abd);
	}

	static zio_t *
	zio_read_gang(zio_t pio, blkptr_t bp, zio_gang_node_t gn, abd_t data,
	uint64_t offset)
	{
	if (gn != NULL)
	return (pio);

	return (zio_read(pio, pio->io_spa, bp, abd_get_offset(data, offset),
	BP_GET_PSIZE(bp), zio_gang_issue_func_done,
	NULL, pio->io_priority, ZIO_GANG_CHILD_FLAGS(pio),
	&pio->io_bookmark));
	}

	static zio_t *
	zio_rewrite_gang(zio_t pio, blkptr_t bp, zio_gang_node_t gn, abd_t data,
	uint64_t offset)
	{
	zio_t *zio;

	if (gn != NULL) {
	abd_t *gbh_abd =
	abd_get_from_buf(gn->gn_gbh, SPA_GANGBLOCKSIZE);
	zio = zio_rewrite(pio, pio->io_spa, pio->io_txg, bp,
	gbh_abd, SPA_GANGBLOCKSIZE, zio_gang_issue_func_done, NULL,
	pio->io_priority, ZIO_GANG_CHILD_FLAGS(pio),
	&pio->io_bookmark);
	/*
	* As we rewrite each gang header, the pipeline will compute
	* a new gang block header checksum for it; but no one will
	* compute a new data checksum, so we do that here. The one
	* exception is the gang leader: the pipeline already computed
	* its data checksum because that stage precedes gang assembly.
	* (Presently, nothing actually uses interior data checksums;
	* this is just good hygiene.)
	*/
	if (gn != pio->io_gang_leader->io_gang_tree) {
	abd_t *buf = abd_get_offset(data, offset);

	zio_checksum_compute(zio, BP_GET_CHECKSUM(bp),
	buf, BP_GET_PSIZE(bp));

	abd_free(buf);
	}
	/*
	* If we are here to damage data for testing purposes,
	* leave the GBH alone so that we can detect the damage.
	*/
	if (pio->io_gang_leader->io_flags & ZIO_FLAG_INDUCE_DAMAGE)
	zio->io_pipeline &= ~ZIO_VDEV_IO_STAGES;
	} else {
	zio = zio_rewrite(pio, pio->io_spa, pio->io_txg, bp,
	abd_get_offset(data, offset), BP_GET_PSIZE(bp),
	zio_gang_issue_func_done, NULL, pio->io_priority,
	ZIO_GANG_CHILD_FLAGS(pio), &pio->io_bookmark);
	}

	return (zio);
	}

	/* ARGSUSED */
	static zio_t *
	zio_free_gang(zio_t pio, blkptr_t bp, zio_gang_node_t gn, abd_t data,
	uint64_t offset)
	{
	zio_t *zio = zio_free_sync(pio, pio->io_spa, pio->io_txg, bp,
	ZIO_GANG_CHILD_FLAGS(pio));
	if (zio == NULL) {
	zio = zio_null(pio, pio->io_spa,
	NULL, NULL, NULL, ZIO_GANG_CHILD_FLAGS(pio));
	}
	return (zio);
	}

	/* ARGSUSED */
	static zio_t *
	zio_claim_gang(zio_t pio, blkptr_t bp, zio_gang_node_t gn, abd_t data,
	uint64_t offset)
	{
	return (zio_claim(pio, pio->io_spa, pio->io_txg, bp,
	NULL, NULL, ZIO_GANG_CHILD_FLAGS(pio)));
	}

	static zio_gang_issue_func_t *zio_gang_issue_func[ZIO_TYPES] = {
	NULL,
	zio_read_gang,
	zio_rewrite_gang,
	zio_free_gang,
	zio_claim_gang,
	NULL
	};

	static void zio_gang_tree_assemble_done(zio_t *zio);

	static zio_gang_node_t *
	zio_gang_node_alloc(zio_gang_node_t **gnpp)
	{
	zio_gang_node_t *gn;

	ASSERT(*gnpp == NULL);

	gn = kmem_zalloc(sizeof (*gn), KM_SLEEP);
	gn->gn_gbh = zio_buf_alloc(SPA_GANGBLOCKSIZE);
	*gnpp = gn;

	return (gn);
	}

	static void
	zio_gang_node_free(zio_gang_node_t **gnpp)
	{
	zio_gang_node_t gn = gnpp;

	for (int g = 0; g < SPA_GBH_NBLKPTRS; g++)
	ASSERT(gn->gn_child[g] == NULL);

	zio_buf_free(gn->gn_gbh, SPA_GANGBLOCKSIZE);
	kmem_free(gn, sizeof (*gn));
	*gnpp = NULL;
	}

	static void
	zio_gang_tree_free(zio_gang_node_t **gnpp)
	{
	zio_gang_node_t gn = gnpp;

	if (gn == NULL)
	return;

	for (int g = 0; g < SPA_GBH_NBLKPTRS; g++)
	zio_gang_tree_free(&gn->gn_child[g]);

	zio_gang_node_free(gnpp);
	}

	static void
	zio_gang_tree_assemble(zio_t gio, blkptr_t bp, zio_gang_node_t **gnpp)
	{
	zio_gang_node_t *gn = zio_gang_node_alloc(gnpp);
	abd_t *gbh_abd = abd_get_from_buf(gn->gn_gbh, SPA_GANGBLOCKSIZE);

	ASSERT(gio->io_gang_leader == gio);
	ASSERT(BP_IS_GANG(bp));

	zio_nowait(zio_read(gio, gio->io_spa, bp, gbh_abd, SPA_GANGBLOCKSIZE,
	zio_gang_tree_assemble_done, gn, gio->io_priority,
	ZIO_GANG_CHILD_FLAGS(gio), &gio->io_bookmark));
	}

	static void
	zio_gang_tree_assemble_done(zio_t *zio)
	{
	zio_t *gio = zio->io_gang_leader;
	zio_gang_node_t *gn = zio->io_private;
	blkptr_t *bp = zio->io_bp;

	ASSERT(gio == zio_unique_parent(zio));
	ASSERT(zio->io_child_count == 0);

	if (zio->io_error)
	return;

	/* this ABD was created from a linear buf in zio_gang_tree_assemble */
	if (BP_SHOULD_BYTESWAP(bp))
	byteswap_uint64_array(abd_to_buf(zio->io_abd), zio->io_size);

	ASSERT3P(abd_to_buf(zio->io_abd), ==, gn->gn_gbh);
	ASSERT(zio->io_size == SPA_GANGBLOCKSIZE);
	ASSERT(gn->gn_gbh->zg_tail.zec_magic == ZEC_MAGIC);

	abd_free(zio->io_abd);

	for (int g = 0; g < SPA_GBH_NBLKPTRS; g++) {
	blkptr_t *gbp = &gn->gn_gbh->zg_blkptr[g];
	if (!BP_IS_GANG(gbp))
	continue;
	zio_gang_tree_assemble(gio, gbp, &gn->gn_child[g]);
	}
	}

	static void
	zio_gang_tree_issue(zio_t pio, zio_gang_node_t gn, blkptr_t bp, abd_t data,
	uint64_t offset)
	{
	zio_t *gio = pio->io_gang_leader;
	zio_t *zio;

	ASSERT(BP_IS_GANG(bp) == !!gn);
	ASSERT(BP_GET_CHECKSUM(bp) == BP_GET_CHECKSUM(gio->io_bp));
	ASSERT(BP_GET_LSIZE(bp) == BP_GET_PSIZE(bp) \|\| gn == gio->io_gang_tree);

	/*
	* If you're a gang header, your data is in gn->gn_gbh.
	* If you're a gang member, your data is in 'data' and gn == NULL.
	*/
	zio = zio_gang_issue_func[gio->io_type](pio, bp, gn, data, offset);

	if (gn != NULL) {
	ASSERT(gn->gn_gbh->zg_tail.zec_magic == ZEC_MAGIC);

	for (int g = 0; g < SPA_GBH_NBLKPTRS; g++) {
	blkptr_t *gbp = &gn->gn_gbh->zg_blkptr[g];
	if (BP_IS_HOLE(gbp))
	continue;
	zio_gang_tree_issue(zio, gn->gn_child[g], gbp, data,
	offset);
	offset += BP_GET_PSIZE(gbp);
	}
	}

	if (gn == gio->io_gang_tree)
	ASSERT3U(gio->io_size, ==, offset);

	if (zio != pio)
	zio_nowait(zio);
	}

	static zio_t *
	zio_gang_assemble(zio_t *zio)
	{
	blkptr_t *bp = zio->io_bp;

	ASSERT(BP_IS_GANG(bp) && zio->io_gang_leader == NULL);
	ASSERT(zio->io_child_type > ZIO_CHILD_GANG);

	zio->io_gang_leader = zio;

	zio_gang_tree_assemble(zio, bp, &zio->io_gang_tree);

	return (zio);
	}

	static zio_t *
	zio_gang_issue(zio_t *zio)
	{
	blkptr_t *bp = zio->io_bp;

	if (zio_wait_for_children(zio, ZIO_CHILD_GANG_BIT, ZIO_WAIT_DONE)) {
	return (NULL);
	}

	ASSERT(BP_IS_GANG(bp) && zio->io_gang_leader == zio);
	ASSERT(zio->io_child_type > ZIO_CHILD_GANG);

	if (zio->io_child_error[ZIO_CHILD_GANG] == 0)
	zio_gang_tree_issue(zio, zio->io_gang_tree, bp, zio->io_abd,
	0);
	else
	zio_gang_tree_free(&zio->io_gang_tree);

	zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;

	return (zio);
	}

	static void
	zio_write_gang_member_ready(zio_t *zio)
	{
	zio_t *pio = zio_unique_parent(zio);
	dva_t *cdva = zio->io_bp->blk_dva;
	dva_t *pdva = pio->io_bp->blk_dva;
	uint64_t asize;
	zio_t *gio __maybe_unused = zio->io_gang_leader;

	if (BP_IS_HOLE(zio->io_bp))
	return;

	ASSERT(BP_IS_HOLE(&zio->io_bp_orig));

	ASSERT(zio->io_child_type == ZIO_CHILD_GANG);
	ASSERT3U(zio->io_prop.zp_copies, ==, gio->io_prop.zp_copies);
	ASSERT3U(zio->io_prop.zp_copies, <=, BP_GET_NDVAS(zio->io_bp));
	ASSERT3U(pio->io_prop.zp_copies, <=, BP_GET_NDVAS(pio->io_bp));
	ASSERT3U(BP_GET_NDVAS(zio->io_bp), <=, BP_GET_NDVAS(pio->io_bp));

	mutex_enter(&pio->io_lock);
	for (int d = 0; d < BP_GET_NDVAS(zio->io_bp); d++) {
	ASSERT(DVA_GET_GANG(&pdva[d]));
	asize = DVA_GET_ASIZE(&pdva[d]);
	asize += DVA_GET_ASIZE(&cdva[d]);
	DVA_SET_ASIZE(&pdva[d], asize);
	}
	mutex_exit(&pio->io_lock);
	}

	static void
	zio_write_gang_done(zio_t *zio)
	{
	/*
	* The io_abd field will be NULL for a zio with no data. The io_flags
	* will initially have the ZIO_FLAG_NODATA bit flag set, but we can't
	* check for it here as it is cleared in zio_ready.
	*/
	if (zio->io_abd != NULL)
	abd_free(zio->io_abd);
	}

	static zio_t *
	zio_write_gang_block(zio_t pio, metaslab_class_t mc)
	{
	spa_t *spa = pio->io_spa;
	blkptr_t *bp = pio->io_bp;
	zio_t *gio = pio->io_gang_leader;
	zio_t *zio;
	zio_gang_node_t gn, *gnpp;
	zio_gbh_phys_t *gbh;
	abd_t *gbh_abd;
	uint64_t txg = pio->io_txg;
	uint64_t resid = pio->io_size;
	uint64_t lsize;
	int copies = gio->io_prop.zp_copies;
	int gbh_copies;
	zio_prop_t zp;
	int error;
	boolean_t has_data = !(pio->io_flags & ZIO_FLAG_NODATA);

	/*
	* encrypted blocks need DVA[2] free so encrypted gang headers can't
	* have a third copy.
	*/
	gbh_copies = MIN(copies + 1, spa_max_replication(spa));
	if (gio->io_prop.zp_encrypt && gbh_copies >= SPA_DVAS_PER_BP)
	gbh_copies = SPA_DVAS_PER_BP - 1;

	int flags = METASLAB_HINTBP_FAVOR \| METASLAB_GANG_HEADER;
	if (pio->io_flags & ZIO_FLAG_IO_ALLOCATING) {
	ASSERT(pio->io_priority == ZIO_PRIORITY_ASYNC_WRITE);
	ASSERT(has_data);

	flags \|= METASLAB_ASYNC_ALLOC;
	VERIFY(zfs_refcount_held(&mc->mc_allocator[pio->io_allocator].
	mca_alloc_slots, pio));

	/*
	* The logical zio has already placed a reservation for
	* 'copies' allocation slots but gang blocks may require
	* additional copies. These additional copies
	* (i.e. gbh_copies - copies) are guaranteed to succeed
	* since metaslab_class_throttle_reserve() always allows
	* additional reservations for gang blocks.
	*/
	VERIFY(metaslab_class_throttle_reserve(mc, gbh_copies - copies,
	pio->io_allocator, pio, flags));
	}

	error = metaslab_alloc(spa, mc, SPA_GANGBLOCKSIZE,
	bp, gbh_copies, txg, pio == gio ? NULL : gio->io_bp, flags,
	&pio->io_alloc_list, pio, pio->io_allocator);
	if (error) {
	if (pio->io_flags & ZIO_FLAG_IO_ALLOCATING) {
	ASSERT(pio->io_priority == ZIO_PRIORITY_ASYNC_WRITE);
	ASSERT(has_data);

	/*
	* If we failed to allocate the gang block header then
	* we remove any additional allocation reservations that
	* we placed here. The original reservation will
	* be removed when the logical I/O goes to the ready
	* stage.
	*/
	metaslab_class_throttle_unreserve(mc,
	gbh_copies - copies, pio->io_allocator, pio);
	}

	pio->io_error = error;
	return (pio);
	}

	if (pio == gio) {
	gnpp = &gio->io_gang_tree;
	} else {
	gnpp = pio->io_private;
	ASSERT(pio->io_ready == zio_write_gang_member_ready);
	}

	gn = zio_gang_node_alloc(gnpp);
	gbh = gn->gn_gbh;
	bzero(gbh, SPA_GANGBLOCKSIZE);
	gbh_abd = abd_get_from_buf(gbh, SPA_GANGBLOCKSIZE);

	/*
	* Create the gang header.
	*/
	zio = zio_rewrite(pio, spa, txg, bp, gbh_abd, SPA_GANGBLOCKSIZE,
	zio_write_gang_done, NULL, pio->io_priority,
	ZIO_GANG_CHILD_FLAGS(pio), &pio->io_bookmark);

	/*
	* Create and nowait the gang children.
	*/
	for (int g = 0; resid != 0; resid -= lsize, g++) {
	lsize = P2ROUNDUP(resid / (SPA_GBH_NBLKPTRS - g),
	SPA_MINBLOCKSIZE);
	ASSERT(lsize >= SPA_MINBLOCKSIZE && lsize <= resid);

	zp.zp_checksum = gio->io_prop.zp_checksum;
	zp.zp_compress = ZIO_COMPRESS_OFF;
	zp.zp_complevel = gio->io_prop.zp_complevel;
	zp.zp_type = DMU_OT_NONE;
	zp.zp_level = 0;
	zp.zp_copies = gio->io_prop.zp_copies;
	zp.zp_dedup = B_FALSE;
	zp.zp_dedup_verify = B_FALSE;
	zp.zp_nopwrite = B_FALSE;
	zp.zp_encrypt = gio->io_prop.zp_encrypt;
	zp.zp_byteorder = gio->io_prop.zp_byteorder;
	bzero(zp.zp_salt, ZIO_DATA_SALT_LEN);
	bzero(zp.zp_iv, ZIO_DATA_IV_LEN);
	bzero(zp.zp_mac, ZIO_DATA_MAC_LEN);

	zio_t *cio = zio_write(zio, spa, txg, &gbh->zg_blkptr[g],
	has_data ? abd_get_offset(pio->io_abd, pio->io_size -
	resid) : NULL, lsize, lsize, &zp,
	zio_write_gang_member_ready, NULL, NULL,
	zio_write_gang_done, &gn->gn_child[g], pio->io_priority,
	ZIO_GANG_CHILD_FLAGS(pio), &pio->io_bookmark);

	if (pio->io_flags & ZIO_FLAG_IO_ALLOCATING) {
	ASSERT(pio->io_priority == ZIO_PRIORITY_ASYNC_WRITE);
	ASSERT(has_data);

	/*
	* Gang children won't throttle but we should
	* account for their work, so reserve an allocation
	* slot for them here.
	*/
	VERIFY(metaslab_class_throttle_reserve(mc,
	zp.zp_copies, cio->io_allocator, cio, flags));
	}
	zio_nowait(cio);
	}

	/*
	* Set pio's pipeline to just wait for zio to finish.
	*/
	pio->io_pipeline = ZIO_INTERLOCK_PIPELINE;

	/*
	* We didn't allocate this bp, so make sure it doesn't get unmarked.
	*/
	pio->io_flags &= ~ZIO_FLAG_FASTWRITE;

	zio_nowait(zio);

	return (pio);
	}

	/*
	* The zio_nop_write stage in the pipeline determines if allocating a
	* new bp is necessary. The nopwrite feature can handle writes in
	* either syncing or open context (i.e. zil writes) and as a result is
	* mutually exclusive with dedup.
	*
	* By leveraging a cryptographically secure checksum, such as SHA256, we
	* can compare the checksums of the new data and the old to determine if
	* allocating a new block is required. Note that our requirements for
	* cryptographic strength are fairly weak: there can't be any accidental
	* hash collisions, but we don't need to be secure against intentional
	* (malicious) collisions. To trigger a nopwrite, you have to be able
	* to write the file to begin with, and triggering an incorrect (hash
	* collision) nopwrite is no worse than simply writing to the file.
	* That said, there are no known attacks against the checksum algorithms
	* used for nopwrite, assuming that the salt and the checksums
	* themselves remain secret.
	*/
	static zio_t *
	zio_nop_write(zio_t *zio)
	{
	blkptr_t *bp = zio->io_bp;
	blkptr_t *bp_orig = &zio->io_bp_orig;
	zio_prop_t *zp = &zio->io_prop;

	ASSERT(BP_GET_LEVEL(bp) == 0);
	ASSERT(!(zio->io_flags & ZIO_FLAG_IO_REWRITE));
	ASSERT(zp->zp_nopwrite);
	ASSERT(!zp->zp_dedup);
	ASSERT(zio->io_bp_override == NULL);
	ASSERT(IO_IS_ALLOCATING(zio));

	/*
	* Check to see if the original bp and the new bp have matching
	* characteristics (i.e. same checksum, compression algorithms, etc).
	* If they don't then just continue with the pipeline which will
	* allocate a new bp.
	*/
	if (BP_IS_HOLE(bp_orig) \|\|
	!(zio_checksum_table[BP_GET_CHECKSUM(bp)].ci_flags &
	ZCHECKSUM_FLAG_NOPWRITE) \|\|
	BP_IS_ENCRYPTED(bp) \|\| BP_IS_ENCRYPTED(bp_orig) \|\|
	BP_GET_CHECKSUM(bp) != BP_GET_CHECKSUM(bp_orig) \|\|
	BP_GET_COMPRESS(bp) != BP_GET_COMPRESS(bp_orig) \|\|
	BP_GET_DEDUP(bp) != BP_GET_DEDUP(bp_orig) \|\|
	zp->zp_copies != BP_GET_NDVAS(bp_orig))
	return (zio);

	/*
	* If the checksums match then reset the pipeline so that we
	* avoid allocating a new bp and issuing any I/O.
	*/
	if (ZIO_CHECKSUM_EQUAL(bp->blk_cksum, bp_orig->blk_cksum)) {
	ASSERT(zio_checksum_table[zp->zp_checksum].ci_flags &
	ZCHECKSUM_FLAG_NOPWRITE);
	ASSERT3U(BP_GET_PSIZE(bp), ==, BP_GET_PSIZE(bp_orig));
	ASSERT3U(BP_GET_LSIZE(bp), ==, BP_GET_LSIZE(bp_orig));
	ASSERT(zp->zp_compress != ZIO_COMPRESS_OFF);
	ASSERT(bcmp(&bp->blk_prop, &bp_orig->blk_prop,
	sizeof (uint64_t)) == 0);

	/*
	* If we're overwriting a block that is currently on an
	* indirect vdev, then ignore the nopwrite request and
	* allow a new block to be allocated on a concrete vdev.
	*/
	spa_config_enter(zio->io_spa, SCL_VDEV, FTAG, RW_READER);
	vdev_t *tvd = vdev_lookup_top(zio->io_spa,
	DVA_GET_VDEV(&bp->blk_dva[0]));
	if (tvd->vdev_ops == &vdev_indirect_ops) {
	spa_config_exit(zio->io_spa, SCL_VDEV, FTAG);
	return (zio);
	}
	spa_config_exit(zio->io_spa, SCL_VDEV, FTAG);

	bp = bp_orig;
	zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;
	zio->io_flags \|= ZIO_FLAG_NOPWRITE;
	}

	return (zio);
	}

	/*
	* ==========================================================================
	* Dedup
	* ==========================================================================
	*/
	static void
	zio_ddt_child_read_done(zio_t *zio)
	{
	blkptr_t *bp = zio->io_bp;
	ddt_entry_t *dde = zio->io_private;
	ddt_phys_t *ddp;
	zio_t *pio = zio_unique_parent(zio);

	mutex_enter(&pio->io_lock);
	ddp = ddt_phys_select(dde, bp);
	if (zio->io_error == 0)
	ddt_phys_clear(ddp); /* this ddp doesn't need repair */

	if (zio->io_error == 0 && dde->dde_repair_abd == NULL)
	dde->dde_repair_abd = zio->io_abd;
	else
	abd_free(zio->io_abd);
	mutex_exit(&pio->io_lock);
	}

	static zio_t *
	zio_ddt_read_start(zio_t *zio)
	{
	blkptr_t *bp = zio->io_bp;

	ASSERT(BP_GET_DEDUP(bp));
	ASSERT(BP_GET_PSIZE(bp) == zio->io_size);
	ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);

	if (zio->io_child_error[ZIO_CHILD_DDT]) {
	ddt_t *ddt = ddt_select(zio->io_spa, bp);
	ddt_entry_t *dde = ddt_repair_start(ddt, bp);
	ddt_phys_t *ddp = dde->dde_phys;
	ddt_phys_t *ddp_self = ddt_phys_select(dde, bp);
	blkptr_t blk;

	ASSERT(zio->io_vsd == NULL);
	zio->io_vsd = dde;

	if (ddp_self == NULL)
	return (zio);

	for (int p = 0; p < DDT_PHYS_TYPES; p++, ddp++) {
	if (ddp->ddp_phys_birth == 0 \|\| ddp == ddp_self)
	continue;
	ddt_bp_create(ddt->ddt_checksum, &dde->dde_key, ddp,
	&blk);
	zio_nowait(zio_read(zio, zio->io_spa, &blk,
	abd_alloc_for_io(zio->io_size, B_TRUE),
	zio->io_size, zio_ddt_child_read_done, dde,
	zio->io_priority, ZIO_DDT_CHILD_FLAGS(zio) \|
	ZIO_FLAG_DONT_PROPAGATE, &zio->io_bookmark));
	}
	return (zio);
	}

	zio_nowait(zio_read(zio, zio->io_spa, bp,
	zio->io_abd, zio->io_size, NULL, NULL, zio->io_priority,
	ZIO_DDT_CHILD_FLAGS(zio), &zio->io_bookmark));

	return (zio);
	}

	static zio_t *
	zio_ddt_read_done(zio_t *zio)
	{
	blkptr_t *bp = zio->io_bp;

	if (zio_wait_for_children(zio, ZIO_CHILD_DDT_BIT, ZIO_WAIT_DONE)) {
	return (NULL);
	}

	ASSERT(BP_GET_DEDUP(bp));
	ASSERT(BP_GET_PSIZE(bp) == zio->io_size);
	ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);

	if (zio->io_child_error[ZIO_CHILD_DDT]) {
	ddt_t *ddt = ddt_select(zio->io_spa, bp);
	ddt_entry_t *dde = zio->io_vsd;
	if (ddt == NULL) {
	ASSERT(spa_load_state(zio->io_spa) != SPA_LOAD_NONE);
	return (zio);
	}
	if (dde == NULL) {
	zio->io_stage = ZIO_STAGE_DDT_READ_START >> 1;
	zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, B_FALSE);
	return (NULL);
	}
	if (dde->dde_repair_abd != NULL) {
	abd_copy(zio->io_abd, dde->dde_repair_abd,
	zio->io_size);
	zio->io_child_error[ZIO_CHILD_DDT] = 0;
	}
	ddt_repair_done(ddt, dde);
	zio->io_vsd = NULL;
	}

	ASSERT(zio->io_vsd == NULL);

	return (zio);
	}

	static boolean_t
	zio_ddt_collision(zio_t zio, ddt_t ddt, ddt_entry_t *dde)
	{
	spa_t *spa = zio->io_spa;
	boolean_t do_raw = !!(zio->io_flags & ZIO_FLAG_RAW);

	ASSERT(!(zio->io_bp_override && do_raw));

	/*
	* Note: we compare the original data, not the transformed data,
	* because when zio->io_bp is an override bp, we will not have
	* pushed the I/O transforms. That's an important optimization
	* because otherwise we'd compress/encrypt all dmu_sync() data twice.
	* However, we should never get a raw, override zio so in these
	* cases we can compare the io_abd directly. This is useful because
	* it allows us to do dedup verification even if we don't have access
	* to the original data (for instance, if the encryption keys aren't
	* loaded).
	*/

	for (int p = DDT_PHYS_SINGLE; p <= DDT_PHYS_TRIPLE; p++) {
	zio_t *lio = dde->dde_lead_zio[p];

	if (lio != NULL && do_raw) {
	return (lio->io_size != zio->io_size \|\|
	abd_cmp(zio->io_abd, lio->io_abd) != 0);
	} else if (lio != NULL) {
	return (lio->io_orig_size != zio->io_orig_size \|\|
	abd_cmp(zio->io_orig_abd, lio->io_orig_abd) != 0);
	}
	}

	for (int p = DDT_PHYS_SINGLE; p <= DDT_PHYS_TRIPLE; p++) {
	ddt_phys_t *ddp = &dde->dde_phys[p];

	if (ddp->ddp_phys_birth != 0 && do_raw) {
	blkptr_t blk = *zio->io_bp;
	uint64_t psize;
	abd_t *tmpabd;
	int error;

	ddt_bp_fill(ddp, &blk, ddp->ddp_phys_birth);
	psize = BP_GET_PSIZE(&blk);

	if (psize != zio->io_size)
	return (B_TRUE);

	ddt_exit(ddt);

	tmpabd = abd_alloc_for_io(psize, B_TRUE);

	error = zio_wait(zio_read(NULL, spa, &blk, tmpabd,
	psize, NULL, NULL, ZIO_PRIORITY_SYNC_READ,
	ZIO_FLAG_CANFAIL \| ZIO_FLAG_SPECULATIVE \|
	ZIO_FLAG_RAW, &zio->io_bookmark));

	if (error == 0) {
	if (abd_cmp(tmpabd, zio->io_abd) != 0)
	error = SET_ERROR(ENOENT);
	}

	abd_free(tmpabd);
	ddt_enter(ddt);
	return (error != 0);
	} else if (ddp->ddp_phys_birth != 0) {
	arc_buf_t *abuf = NULL;
	arc_flags_t aflags = ARC_FLAG_WAIT;
	blkptr_t blk = *zio->io_bp;
	int error;

	ddt_bp_fill(ddp, &blk, ddp->ddp_phys_birth);

	if (BP_GET_LSIZE(&blk) != zio->io_orig_size)
	return (B_TRUE);

	ddt_exit(ddt);

	error = arc_read(NULL, spa, &blk,
	arc_getbuf_func, &abuf, ZIO_PRIORITY_SYNC_READ,
	ZIO_FLAG_CANFAIL \| ZIO_FLAG_SPECULATIVE,
	&aflags, &zio->io_bookmark);

	if (error == 0) {
	if (abd_cmp_buf(zio->io_orig_abd, abuf->b_data,
	zio->io_orig_size) != 0)
	error = SET_ERROR(ENOENT);
	arc_buf_destroy(abuf, &abuf);
	}

	ddt_enter(ddt);
	return (error != 0);
	}
	}

	return (B_FALSE);
	}

	static void
	zio_ddt_child_write_ready(zio_t *zio)
	{
	int p = zio->io_prop.zp_copies;
	ddt_t *ddt = ddt_select(zio->io_spa, zio->io_bp);
	ddt_entry_t *dde = zio->io_private;
	ddt_phys_t *ddp = &dde->dde_phys[p];
	zio_t *pio;

	if (zio->io_error)
	return;

	ddt_enter(ddt);

	ASSERT(dde->dde_lead_zio[p] == zio);

	ddt_phys_fill(ddp, zio->io_bp);

	zio_link_t *zl = NULL;
	while ((pio = zio_walk_parents(zio, &zl)) != NULL)
	ddt_bp_fill(ddp, pio->io_bp, zio->io_txg);

	ddt_exit(ddt);
	}

	static void
	zio_ddt_child_write_done(zio_t *zio)
	{
	int p = zio->io_prop.zp_copies;
	ddt_t *ddt = ddt_select(zio->io_spa, zio->io_bp);
	ddt_entry_t *dde = zio->io_private;
	ddt_phys_t *ddp = &dde->dde_phys[p];

	ddt_enter(ddt);

	ASSERT(ddp->ddp_refcnt == 0);
	ASSERT(dde->dde_lead_zio[p] == zio);
	dde->dde_lead_zio[p] = NULL;

	if (zio->io_error == 0) {
	zio_link_t *zl = NULL;
	while (zio_walk_parents(zio, &zl) != NULL)
	ddt_phys_addref(ddp);
	} else {
	ddt_phys_clear(ddp);
	}

	ddt_exit(ddt);
	}

	static zio_t *
	zio_ddt_write(zio_t *zio)
	{
	spa_t *spa = zio->io_spa;
	blkptr_t *bp = zio->io_bp;
	uint64_t txg = zio->io_txg;
	zio_prop_t *zp = &zio->io_prop;
	int p = zp->zp_copies;
	zio_t *cio = NULL;
	ddt_t *ddt = ddt_select(spa, bp);
	ddt_entry_t *dde;
	ddt_phys_t *ddp;

	ASSERT(BP_GET_DEDUP(bp));
	ASSERT(BP_GET_CHECKSUM(bp) == zp->zp_checksum);
	ASSERT(BP_IS_HOLE(bp) \|\| zio->io_bp_override);
	ASSERT(!(zio->io_bp_override && (zio->io_flags & ZIO_FLAG_RAW)));

	ddt_enter(ddt);
	dde = ddt_lookup(ddt, bp, B_TRUE);
	ddp = &dde->dde_phys[p];

	if (zp->zp_dedup_verify && zio_ddt_collision(zio, ddt, dde)) {
	/*
	* If we're using a weak checksum, upgrade to a strong checksum
	* and try again. If we're already using a strong checksum,
	* we can't resolve it, so just convert to an ordinary write.
	* (And automatically e-mail a paper to Nature?)
	*/
	if (!(zio_checksum_table[zp->zp_checksum].ci_flags &
	ZCHECKSUM_FLAG_DEDUP)) {
	zp->zp_checksum = spa_dedup_checksum(spa);
	zio_pop_transforms(zio);
	zio->io_stage = ZIO_STAGE_OPEN;
	BP_ZERO(bp);
	} else {
	zp->zp_dedup = B_FALSE;
	BP_SET_DEDUP(bp, B_FALSE);
	}
	ASSERT(!BP_GET_DEDUP(bp));
	zio->io_pipeline = ZIO_WRITE_PIPELINE;
	ddt_exit(ddt);
	return (zio);
	}

	if (ddp->ddp_phys_birth != 0 \|\| dde->dde_lead_zio[p] != NULL) {
	if (ddp->ddp_phys_birth != 0)
	ddt_bp_fill(ddp, bp, txg);
	if (dde->dde_lead_zio[p] != NULL)
	zio_add_child(zio, dde->dde_lead_zio[p]);
	else
	ddt_phys_addref(ddp);
	} else if (zio->io_bp_override) {
	ASSERT(bp->blk_birth == txg);
	ASSERT(BP_EQUAL(bp, zio->io_bp_override));
	ddt_phys_fill(ddp, bp);
	ddt_phys_addref(ddp);
	} else {
	cio = zio_write(zio, spa, txg, bp, zio->io_orig_abd,
	zio->io_orig_size, zio->io_orig_size, zp,
	zio_ddt_child_write_ready, NULL, NULL,
	zio_ddt_child_write_done, dde, zio->io_priority,
	ZIO_DDT_CHILD_FLAGS(zio), &zio->io_bookmark);

	zio_push_transform(cio, zio->io_abd, zio->io_size, 0, NULL);
	dde->dde_lead_zio[p] = cio;
	}

	ddt_exit(ddt);

	zio_nowait(cio);

	return (zio);
	}

	ddt_entry_t freedde; / for debugging */

	static zio_t *
	zio_ddt_free(zio_t *zio)
	{
	spa_t *spa = zio->io_spa;
	blkptr_t *bp = zio->io_bp;
	ddt_t *ddt = ddt_select(spa, bp);
	ddt_entry_t *dde;
	ddt_phys_t *ddp;

	ASSERT(BP_GET_DEDUP(bp));
	ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);

	ddt_enter(ddt);
	freedde = dde = ddt_lookup(ddt, bp, B_TRUE);
	if (dde) {
	ddp = ddt_phys_select(dde, bp);
	if (ddp)
	ddt_phys_decref(ddp);
	}
	ddt_exit(ddt);

	return (zio);
	}

	/*
	* ==========================================================================
	* Allocate and free blocks
	* ==========================================================================
	*/

	static zio_t *
	zio_io_to_allocate(spa_t *spa, int allocator)
	{
	zio_t *zio;

	ASSERT(MUTEX_HELD(&spa->spa_alloc_locks[allocator]));

	zio = avl_first(&spa->spa_alloc_trees[allocator]);
	if (zio == NULL)
	return (NULL);

	ASSERT(IO_IS_ALLOCATING(zio));

	/*
	* Try to place a reservation for this zio. If we're unable to
	* reserve then we throttle.
	*/
	ASSERT3U(zio->io_allocator, ==, allocator);
	if (!metaslab_class_throttle_reserve(zio->io_metaslab_class,
	zio->io_prop.zp_copies, zio->io_allocator, zio, 0)) {
	return (NULL);
	}

	avl_remove(&spa->spa_alloc_trees[allocator], zio);
	ASSERT3U(zio->io_stage, <, ZIO_STAGE_DVA_ALLOCATE);

	return (zio);
	}

	static zio_t *
	zio_dva_throttle(zio_t *zio)
	{
	spa_t *spa = zio->io_spa;
	zio_t *nio;
	metaslab_class_t *mc;

	/* locate an appropriate allocation class */
	mc = spa_preferred_class(spa, zio->io_size, zio->io_prop.zp_type,
	zio->io_prop.zp_level, zio->io_prop.zp_zpl_smallblk);

	if (zio->io_priority == ZIO_PRIORITY_SYNC_WRITE \|\|
	!mc->mc_alloc_throttle_enabled \|\|
	zio->io_child_type == ZIO_CHILD_GANG \|\|
	zio->io_flags & ZIO_FLAG_NODATA) {
	return (zio);
	}

	ASSERT(zio->io_child_type > ZIO_CHILD_GANG);

	ASSERT3U(zio->io_queued_timestamp, >, 0);
	ASSERT(zio->io_stage == ZIO_STAGE_DVA_THROTTLE);

	zbookmark_phys_t *bm = &zio->io_bookmark;
	/*
	* We want to try to use as many allocators as possible to help improve
	* performance, but we also want logically adjacent IOs to be physically
	* adjacent to improve sequential read performance. We chunk each object
	* into 2^20 block regions, and then hash based on the objset, object,
	* level, and region to accomplish both of these goals.
	*/
	zio->io_allocator = cityhash4(bm->zb_objset, bm->zb_object,
	bm->zb_level, bm->zb_blkid >> 20) % spa->spa_alloc_count;
	mutex_enter(&spa->spa_alloc_locks[zio->io_allocator]);
	ASSERT(zio->io_type == ZIO_TYPE_WRITE);
	zio->io_metaslab_class = mc;
	avl_add(&spa->spa_alloc_trees[zio->io_allocator], zio);
	nio = zio_io_to_allocate(spa, zio->io_allocator);
	mutex_exit(&spa->spa_alloc_locks[zio->io_allocator]);
	return (nio);
	}

	static void
	zio_allocate_dispatch(spa_t *spa, int allocator)
	{
	zio_t *zio;

	mutex_enter(&spa->spa_alloc_locks[allocator]);
	zio = zio_io_to_allocate(spa, allocator);
	mutex_exit(&spa->spa_alloc_locks[allocator]);
	if (zio == NULL)
	return;

	ASSERT3U(zio->io_stage, ==, ZIO_STAGE_DVA_THROTTLE);
	ASSERT0(zio->io_error);
	zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE, B_TRUE);
	}

	static zio_t *
	zio_dva_allocate(zio_t *zio)
	{
	spa_t *spa = zio->io_spa;
	metaslab_class_t *mc;
	blkptr_t *bp = zio->io_bp;
	int error;
	int flags = 0;

	if (zio->io_gang_leader == NULL) {
	ASSERT(zio->io_child_type > ZIO_CHILD_GANG);
	zio->io_gang_leader = zio;
	}

	ASSERT(BP_IS_HOLE(bp));
	ASSERT0(BP_GET_NDVAS(bp));
	ASSERT3U(zio->io_prop.zp_copies, >, 0);
	ASSERT3U(zio->io_prop.zp_copies, <=, spa_max_replication(spa));
	ASSERT3U(zio->io_size, ==, BP_GET_PSIZE(bp));

	flags \|= (zio->io_flags & ZIO_FLAG_FASTWRITE) ? METASLAB_FASTWRITE : 0;
	if (zio->io_flags & ZIO_FLAG_NODATA)
	flags \|= METASLAB_DONT_THROTTLE;
	if (zio->io_flags & ZIO_FLAG_GANG_CHILD)
	flags \|= METASLAB_GANG_CHILD;
	if (zio->io_priority == ZIO_PRIORITY_ASYNC_WRITE)
	flags \|= METASLAB_ASYNC_ALLOC;

	/*
	* if not already chosen, locate an appropriate allocation class
	*/
	mc = zio->io_metaslab_class;
	if (mc == NULL) {
	mc = spa_preferred_class(spa, zio->io_size,
	zio->io_prop.zp_type, zio->io_prop.zp_level,
	zio->io_prop.zp_zpl_smallblk);
	zio->io_metaslab_class = mc;
	}

	/*
	* Try allocating the block in the usual metaslab class.
	* If that's full, allocate it in the normal class.
	* If that's full, allocate as a gang block,
	* and if all are full, the allocation fails (which shouldn't happen).
	*
	* Note that we do not fall back on embedded slog (ZIL) space, to
	* preserve unfragmented slog space, which is critical for decent
	* sync write performance. If a log allocation fails, we will fall
	* back to spa_sync() which is abysmal for performance.
	*/
	error = metaslab_alloc(spa, mc, zio->io_size, bp,
	zio->io_prop.zp_copies, zio->io_txg, NULL, flags,
	&zio->io_alloc_list, zio, zio->io_allocator);

	/*
	* Fallback to normal class when an alloc class is full
	*/
	if (error == ENOSPC && mc != spa_normal_class(spa)) {
	/*
	* If throttling, transfer reservation over to normal class.
	* The io_allocator slot can remain the same even though we
	* are switching classes.
	*/
	if (mc->mc_alloc_throttle_enabled &&
	(zio->io_flags & ZIO_FLAG_IO_ALLOCATING)) {
	metaslab_class_throttle_unreserve(mc,
	zio->io_prop.zp_copies, zio->io_allocator, zio);
	zio->io_flags &= ~ZIO_FLAG_IO_ALLOCATING;

	VERIFY(metaslab_class_throttle_reserve(
	spa_normal_class(spa),
	zio->io_prop.zp_copies, zio->io_allocator, zio,
	flags \| METASLAB_MUST_RESERVE));
	}
	zio->io_metaslab_class = mc = spa_normal_class(spa);
	if (zfs_flags & ZFS_DEBUG_METASLAB_ALLOC) {
	zfs_dbgmsg("%s: metaslab allocation failure, "
	"trying normal class: zio %px, size %llu, error %d",
	spa_name(spa), zio, zio->io_size, error);
	}

	error = metaslab_alloc(spa, mc, zio->io_size, bp,
	zio->io_prop.zp_copies, zio->io_txg, NULL, flags,
	&zio->io_alloc_list, zio, zio->io_allocator);
	}

	if (error == ENOSPC && zio->io_size > SPA_MINBLOCKSIZE) {
	if (zfs_flags & ZFS_DEBUG_METASLAB_ALLOC) {
	zfs_dbgmsg("%s: metaslab allocation failure, "
	"trying ganging: zio %px, size %llu, error %d",
	spa_name(spa), zio, zio->io_size, error);
	}
	return (zio_write_gang_block(zio, mc));
	}
	if (error != 0) {
	if (error != ENOSPC \|\|
	(zfs_flags & ZFS_DEBUG_METASLAB_ALLOC)) {
	zfs_dbgmsg("%s: metaslab allocation failure: zio %px, "
	"size %llu, error %d",
	spa_name(spa), zio, zio->io_size, error);
	}
	zio->io_error = error;
	}

	return (zio);
	}

	static zio_t *
	zio_dva_free(zio_t *zio)
	{
	metaslab_free(zio->io_spa, zio->io_bp, zio->io_txg, B_FALSE);

	return (zio);
	}

	static zio_t *
	zio_dva_claim(zio_t *zio)
	{
	int error;

	error = metaslab_claim(zio->io_spa, zio->io_bp, zio->io_txg);
	if (error)
	zio->io_error = error;

	return (zio);
	}

	/*
	* Undo an allocation. This is used by zio_done() when an I/O fails
	* and we want to give back the block we just allocated.
	* This handles both normal blocks and gang blocks.
	*/
	static void
	zio_dva_unallocate(zio_t zio, zio_gang_node_t gn, blkptr_t *bp)
	{
	ASSERT(bp->blk_birth == zio->io_txg \|\| BP_IS_HOLE(bp));
	ASSERT(zio->io_bp_override == NULL);

	if (!BP_IS_HOLE(bp))
	metaslab_free(zio->io_spa, bp, bp->blk_birth, B_TRUE);

	if (gn != NULL) {
	for (int g = 0; g < SPA_GBH_NBLKPTRS; g++) {
	zio_dva_unallocate(zio, gn->gn_child[g],
	&gn->gn_gbh->zg_blkptr[g]);
	}
	}
	}

	/*
	* Try to allocate an intent log block. Return 0 on success, errno on failure.
	*/
	int
	zio_alloc_zil(spa_t spa, objset_t os, uint64_t txg, blkptr_t *new_bp,
	uint64_t size, boolean_t *slog)
	{
	int error = 1;
	zio_alloc_list_t io_alloc_list;

	ASSERT(txg > spa_syncing_txg(spa));

	metaslab_trace_init(&io_alloc_list);

	/*
	* Block pointer fields are useful to metaslabs for stats and debugging.
	* Fill in the obvious ones before calling into metaslab_alloc().
	*/
	BP_SET_TYPE(new_bp, DMU_OT_INTENT_LOG);
	BP_SET_PSIZE(new_bp, size);
	BP_SET_LEVEL(new_bp, 0);

	/*
	* When allocating a zil block, we don't have information about
	* the final destination of the block except the objset it's part
	* of, so we just hash the objset ID to pick the allocator to get
	* some parallelism.
	*/
	int flags = METASLAB_FASTWRITE \| METASLAB_ZIL;
	int allocator = cityhash4(0, 0, 0, os->os_dsl_dataset->ds_object) %
	spa->spa_alloc_count;
	error = metaslab_alloc(spa, spa_log_class(spa), size, new_bp, 1,
	txg, NULL, flags, &io_alloc_list, NULL, allocator);
	*slog = (error == 0);
	if (error != 0) {
	error = metaslab_alloc(spa, spa_embedded_log_class(spa), size,
	new_bp, 1, txg, NULL, flags,
	&io_alloc_list, NULL, allocator);
	}
	if (error != 0) {
	error = metaslab_alloc(spa, spa_normal_class(spa), size,
	new_bp, 1, txg, NULL, flags,
	&io_alloc_list, NULL, allocator);
	}
	metaslab_trace_fini(&io_alloc_list);

	if (error == 0) {
	BP_SET_LSIZE(new_bp, size);
	BP_SET_PSIZE(new_bp, size);
	BP_SET_COMPRESS(new_bp, ZIO_COMPRESS_OFF);
	BP_SET_CHECKSUM(new_bp,
	spa_version(spa) >= SPA_VERSION_SLIM_ZIL
	? ZIO_CHECKSUM_ZILOG2 : ZIO_CHECKSUM_ZILOG);
	BP_SET_TYPE(new_bp, DMU_OT_INTENT_LOG);
	BP_SET_LEVEL(new_bp, 0);
	BP_SET_DEDUP(new_bp, 0);
	BP_SET_BYTEORDER(new_bp, ZFS_HOST_BYTEORDER);

	/*
	* encrypted blocks will require an IV and salt. We generate
	* these now since we will not be rewriting the bp at
	* rewrite time.
	*/
	if (os->os_encrypted) {
	uint8_t iv[ZIO_DATA_IV_LEN];
	uint8_t salt[ZIO_DATA_SALT_LEN];

	BP_SET_CRYPT(new_bp, B_TRUE);
	VERIFY0(spa_crypt_get_salt(spa,
	dmu_objset_id(os), salt));
	VERIFY0(zio_crypt_generate_iv(iv));

	zio_crypt_encode_params_bp(new_bp, salt, iv);
	}
	} else {
	zfs_dbgmsg("%s: zil block allocation failure: "
	"size %llu, error %d", spa_name(spa), size, error);
	}

	return (error);
	}

	/*
	* ==========================================================================
	* Read and write to physical devices
	* ==========================================================================
	*/

	/*
	* Issue an I/O to the underlying vdev. Typically the issue pipeline
	* stops after this stage and will resume upon I/O completion.
	* However, there are instances where the vdev layer may need to
	* continue the pipeline when an I/O was not issued. Since the I/O
	* that was sent to the vdev layer might be different than the one
	* currently active in the pipeline (see vdev_queue_io()), we explicitly
	* force the underlying vdev layers to call either zio_execute() or
	* zio_interrupt() to ensure that the pipeline continues with the correct I/O.
	*/
	static zio_t *
	zio_vdev_io_start(zio_t *zio)
	{
	vdev_t *vd = zio->io_vd;
	uint64_t align;
	spa_t *spa = zio->io_spa;

	zio->io_delay = 0;

	ASSERT(zio->io_error == 0);
	ASSERT(zio->io_child_error[ZIO_CHILD_VDEV] == 0);

	if (vd == NULL) {
	if (!(zio->io_flags & ZIO_FLAG_CONFIG_WRITER))
	spa_config_enter(spa, SCL_ZIO, zio, RW_READER);

	/*
	* The mirror_ops handle multiple DVAs in a single BP.
	*/
	vdev_mirror_ops.vdev_op_io_start(zio);
	return (NULL);
	}

	ASSERT3P(zio->io_logical, !=, zio);
	if (zio->io_type == ZIO_TYPE_WRITE) {
	ASSERT(spa->spa_trust_config);

	/*
	* Note: the code can handle other kinds of writes,
	* but we don't expect them.
	*/
	if (zio->io_vd->vdev_removing) {
	ASSERT(zio->io_flags &
	(ZIO_FLAG_PHYSICAL \| ZIO_FLAG_SELF_HEAL \|
	ZIO_FLAG_RESILVER \| ZIO_FLAG_INDUCE_DAMAGE));
	}
	}

	align = 1ULL << vd->vdev_top->vdev_ashift;

	if (!(zio->io_flags & ZIO_FLAG_PHYSICAL) &&
	P2PHASE(zio->io_size, align) != 0) {
	/* Transform logical writes to be a full physical block size. */
	uint64_t asize = P2ROUNDUP(zio->io_size, align);
	abd_t *abuf = abd_alloc_sametype(zio->io_abd, asize);
	ASSERT(vd == vd->vdev_top);
	if (zio->io_type == ZIO_TYPE_WRITE) {
	abd_copy(abuf, zio->io_abd, zio->io_size);
	abd_zero_off(abuf, zio->io_size, asize - zio->io_size);
	}
	zio_push_transform(zio, abuf, asize, asize, zio_subblock);
	}

	/*
	* If this is not a physical io, make sure that it is properly aligned
	* before proceeding.
	*/
	if (!(zio->io_flags & ZIO_FLAG_PHYSICAL)) {
	ASSERT0(P2PHASE(zio->io_offset, align));
	ASSERT0(P2PHASE(zio->io_size, align));
	} else {
	/*
	* For physical writes, we allow 512b aligned writes and assume
	* the device will perform a read-modify-write as necessary.
	*/
	ASSERT0(P2PHASE(zio->io_offset, SPA_MINBLOCKSIZE));
	ASSERT0(P2PHASE(zio->io_size, SPA_MINBLOCKSIZE));
	}

	VERIFY(zio->io_type != ZIO_TYPE_WRITE \|\| spa_writeable(spa));

	/*
	* If this is a repair I/O, and there's no self-healing involved --
	* that is, we're just resilvering what we expect to resilver --
	* then don't do the I/O unless zio's txg is actually in vd's DTL.
	* This prevents spurious resilvering.
	*
	* There are a few ways that we can end up creating these spurious
	* resilver i/os:
	*
	* 1. A resilver i/o will be issued if any DVA in the BP has a
	* dirty DTL. The mirror code will issue resilver writes to
	* each DVA, including the one(s) that are not on vdevs with dirty
	* DTLs.
	*
	* 2. With nested replication, which happens when we have a
	* "replacing" or "spare" vdev that's a child of a mirror or raidz.
	* For example, given mirror(replacing(A+B), C), it's likely that
	* only A is out of date (it's the new device). In this case, we'll
	* read from C, then use the data to resilver A+B -- but we don't
	* actually want to resilver B, just A. The top-level mirror has no
	* way to know this, so instead we just discard unnecessary repairs
	* as we work our way down the vdev tree.
	*
	* 3. ZTEST also creates mirrors of mirrors, mirrors of raidz, etc.
	* The same logic applies to any form of nested replication: ditto
	* + mirror, RAID-Z + replacing, etc.
	*
	* However, indirect vdevs point off to other vdevs which may have
	* DTL's, so we never bypass them. The child i/os on concrete vdevs
	* will be properly bypassed instead.
	*
	* Leaf DTL_PARTIAL can be empty when a legitimate write comes from
	* a dRAID spare vdev. For example, when a dRAID spare is first
	* used, its spare blocks need to be written to but the leaf vdev's
	* of such blocks can have empty DTL_PARTIAL.
	*
	* There seemed no clean way to allow such writes while bypassing
	* spurious ones. At this point, just avoid all bypassing for dRAID
	* for correctness.
	*/
	if ((zio->io_flags & ZIO_FLAG_IO_REPAIR) &&
	!(zio->io_flags & ZIO_FLAG_SELF_HEAL) &&
	zio->io_txg != 0 && /* not a delegated i/o */
	vd->vdev_ops != &vdev_indirect_ops &&
	vd->vdev_top->vdev_ops != &vdev_draid_ops &&
	!vdev_dtl_contains(vd, DTL_PARTIAL, zio->io_txg, 1)) {
	ASSERT(zio->io_type == ZIO_TYPE_WRITE);
	zio_vdev_io_bypass(zio);
	return (zio);
	}

	/*
	* Select the next best leaf I/O to process. Distributed spares are
	* excluded since they dispatch the I/O directly to a leaf vdev after
	* applying the dRAID mapping.
	*/
	if (vd->vdev_ops->vdev_op_leaf &&
	vd->vdev_ops != &vdev_draid_spare_ops &&
	(zio->io_type == ZIO_TYPE_READ \|\|
	zio->io_type == ZIO_TYPE_WRITE \|\|
	zio->io_type == ZIO_TYPE_TRIM)) {

	if (zio->io_type == ZIO_TYPE_READ && vdev_cache_read(zio))
	return (zio);

	if ((zio = vdev_queue_io(zio)) == NULL)
	return (NULL);

	if (!vdev_accessible(vd, zio)) {
	zio->io_error = SET_ERROR(ENXIO);
	zio_interrupt(zio);
	return (NULL);
	}
	zio->io_delay = gethrtime();
	}

	vd->vdev_ops->vdev_op_io_start(zio);
	return (NULL);
	}

	static zio_t *
	zio_vdev_io_done(zio_t *zio)
	{
	vdev_t *vd = zio->io_vd;
	vdev_ops_t *ops = vd ? vd->vdev_ops : &vdev_mirror_ops;
	boolean_t unexpected_error = B_FALSE;

	if (zio_wait_for_children(zio, ZIO_CHILD_VDEV_BIT, ZIO_WAIT_DONE)) {
	return (NULL);
	}

	ASSERT(zio->io_type == ZIO_TYPE_READ \|\|
	zio->io_type == ZIO_TYPE_WRITE \|\| zio->io_type == ZIO_TYPE_TRIM);

	if (zio->io_delay)
	zio->io_delay = gethrtime() - zio->io_delay;

	if (vd != NULL && vd->vdev_ops->vdev_op_leaf &&
	vd->vdev_ops != &vdev_draid_spare_ops) {
	vdev_queue_io_done(zio);

	if (zio->io_type == ZIO_TYPE_WRITE)
	vdev_cache_write(zio);

	if (zio_injection_enabled && zio->io_error == 0)
	zio->io_error = zio_handle_device_injections(vd, zio,
	EIO, EILSEQ);

	if (zio_injection_enabled && zio->io_error == 0)
	zio->io_error = zio_handle_label_injection(zio, EIO);

	if (zio->io_error && zio->io_type != ZIO_TYPE_TRIM) {
	if (!vdev_accessible(vd, zio)) {
	zio->io_error = SET_ERROR(ENXIO);
	} else {
	unexpected_error = B_TRUE;
	}
	}
	}

	ops->vdev_op_io_done(zio);

	if (unexpected_error)
	VERIFY(vdev_probe(vd, zio) == NULL);

	return (zio);
	}

	/*
	* This function is used to change the priority of an existing zio that is
	* currently in-flight. This is used by the arc to upgrade priority in the
	* event that a demand read is made for a block that is currently queued
	* as a scrub or async read IO. Otherwise, the high priority read request
	* would end up having to wait for the lower priority IO.
	*/
	void
	zio_change_priority(zio_t *pio, zio_priority_t priority)
	{
	zio_t cio, cio_next;
	zio_link_t *zl = NULL;

	ASSERT3U(priority, <, ZIO_PRIORITY_NUM_QUEUEABLE);

	if (pio->io_vd != NULL && pio->io_vd->vdev_ops->vdev_op_leaf) {
	vdev_queue_change_io_priority(pio, priority);
	} else {
	pio->io_priority = priority;
	}

	mutex_enter(&pio->io_lock);
	for (cio = zio_walk_children(pio, &zl); cio != NULL; cio = cio_next) {
	cio_next = zio_walk_children(pio, &zl);
	zio_change_priority(cio, priority);
	}
	mutex_exit(&pio->io_lock);
	}

	/*
	* For non-raidz ZIOs, we can just copy aside the bad data read from the
	* disk, and use that to finish the checksum ereport later.
	*/
	static void
	zio_vsd_default_cksum_finish(zio_cksum_report_t *zcr,
	const abd_t *good_buf)
	{
	/* no processing needed */
	zfs_ereport_finish_checksum(zcr, good_buf, zcr->zcr_cbdata, B_FALSE);
	}

	/ARGSUSED/
	void
	zio_vsd_default_cksum_report(zio_t zio, zio_cksum_report_t zcr)
	{
	void *abd = abd_alloc_sametype(zio->io_abd, zio->io_size);

	abd_copy(abd, zio->io_abd, zio->io_size);

	zcr->zcr_cbinfo = zio->io_size;
	zcr->zcr_cbdata = abd;
	zcr->zcr_finish = zio_vsd_default_cksum_finish;
	zcr->zcr_free = zio_abd_free;
	}

	static zio_t *
	zio_vdev_io_assess(zio_t *zio)
	{
	vdev_t *vd = zio->io_vd;

	if (zio_wait_for_children(zio, ZIO_CHILD_VDEV_BIT, ZIO_WAIT_DONE)) {
	return (NULL);
	}

	if (vd == NULL && !(zio->io_flags & ZIO_FLAG_CONFIG_WRITER))
	spa_config_exit(zio->io_spa, SCL_ZIO, zio);

	if (zio->io_vsd != NULL) {
	zio->io_vsd_ops->vsd_free(zio);
	zio->io_vsd = NULL;
	}

	if (zio_injection_enabled && zio->io_error == 0)
	zio->io_error = zio_handle_fault_injection(zio, EIO);

	/*
	* If the I/O failed, determine whether we should attempt to retry it.
	*
	* On retry, we cut in line in the issue queue, since we don't want
	* compression/checksumming/etc. work to prevent our (cheap) IO reissue.
	*/
	if (zio->io_error && vd == NULL &&
	!(zio->io_flags & (ZIO_FLAG_DONT_RETRY \| ZIO_FLAG_IO_RETRY))) {
	ASSERT(!(zio->io_flags & ZIO_FLAG_DONT_QUEUE)); /* not a leaf */
	ASSERT(!(zio->io_flags & ZIO_FLAG_IO_BYPASS)); /* not a leaf */
	zio->io_error = 0;
	zio->io_flags \|= ZIO_FLAG_IO_RETRY \|
	ZIO_FLAG_DONT_CACHE \| ZIO_FLAG_DONT_AGGREGATE;
	zio->io_stage = ZIO_STAGE_VDEV_IO_START >> 1;
	zio_taskq_dispatch(zio, ZIO_TASKQ_ISSUE,
	zio_requeue_io_start_cut_in_line);
	return (NULL);
	}

	/*
	* If we got an error on a leaf device, convert it to ENXIO
	* if the device is not accessible at all.
	*/
	if (zio->io_error && vd != NULL && vd->vdev_ops->vdev_op_leaf &&
	!vdev_accessible(vd, zio))
	zio->io_error = SET_ERROR(ENXIO);

	/*
	* If we can't write to an interior vdev (mirror or RAID-Z),
	* set vdev_cant_write so that we stop trying to allocate from it.
	*/
	if (zio->io_error == ENXIO && zio->io_type == ZIO_TYPE_WRITE &&
	vd != NULL && !vd->vdev_ops->vdev_op_leaf) {
	vdev_dbgmsg(vd, "zio_vdev_io_assess(zio=%px) setting "
	"cant_write=TRUE due to write failure with ENXIO",
	zio);
	vd->vdev_cant_write = B_TRUE;
	}

	/*
	* If a cache flush returns ENOTSUP or ENOTTY, we know that no future
	* attempts will ever succeed. In this case we set a persistent
	* boolean flag so that we don't bother with it in the future.
	*/
	if ((zio->io_error == ENOTSUP \|\| zio->io_error == ENOTTY) &&
	zio->io_type == ZIO_TYPE_IOCTL &&
	zio->io_cmd == DKIOCFLUSHWRITECACHE && vd != NULL)
	vd->vdev_nowritecache = B_TRUE;

	if (zio->io_error)
	zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;

	if (vd != NULL && vd->vdev_ops->vdev_op_leaf &&
	zio->io_physdone != NULL) {
	ASSERT(!(zio->io_flags & ZIO_FLAG_DELEGATED));
	ASSERT(zio->io_child_type == ZIO_CHILD_VDEV);
	zio->io_physdone(zio->io_logical);
	}

	return (zio);
	}

	void
	zio_vdev_io_reissue(zio_t *zio)
	{
	ASSERT(zio->io_stage == ZIO_STAGE_VDEV_IO_START);
	ASSERT(zio->io_error == 0);

	zio->io_stage >>= 1;
	}

	void
	zio_vdev_io_redone(zio_t *zio)
	{
	ASSERT(zio->io_stage == ZIO_STAGE_VDEV_IO_DONE);

	zio->io_stage >>= 1;
	}

	void
	zio_vdev_io_bypass(zio_t *zio)
	{
	ASSERT(zio->io_stage == ZIO_STAGE_VDEV_IO_START);
	ASSERT(zio->io_error == 0);

	zio->io_flags \|= ZIO_FLAG_IO_BYPASS;
	zio->io_stage = ZIO_STAGE_VDEV_IO_ASSESS >> 1;
	}

	/*
	* ==========================================================================
	* Encrypt and store encryption parameters
	* ==========================================================================
	*/


	/*
	* This function is used for ZIO_STAGE_ENCRYPT. It is responsible for
	* managing the storage of encryption parameters and passing them to the
	* lower-level encryption functions.
	*/
	static zio_t *
	zio_encrypt(zio_t *zio)
	{
	zio_prop_t *zp = &zio->io_prop;
	spa_t *spa = zio->io_spa;
	blkptr_t *bp = zio->io_bp;
	uint64_t psize = BP_GET_PSIZE(bp);
	uint64_t dsobj = zio->io_bookmark.zb_objset;
	dmu_object_type_t ot = BP_GET_TYPE(bp);
	void *enc_buf = NULL;
	abd_t *eabd = NULL;
	uint8_t salt[ZIO_DATA_SALT_LEN];
	uint8_t iv[ZIO_DATA_IV_LEN];
	uint8_t mac[ZIO_DATA_MAC_LEN];
	boolean_t no_crypt = B_FALSE;

	/* the root zio already encrypted the data */
	if (zio->io_child_type == ZIO_CHILD_GANG)
	return (zio);

	/* only ZIL blocks are re-encrypted on rewrite */
	if (!IO_IS_ALLOCATING(zio) && ot != DMU_OT_INTENT_LOG)
	return (zio);

	if (!(zp->zp_encrypt \|\| BP_IS_ENCRYPTED(bp))) {
	BP_SET_CRYPT(bp, B_FALSE);
	return (zio);
	}

	/* if we are doing raw encryption set the provided encryption params */
	if (zio->io_flags & ZIO_FLAG_RAW_ENCRYPT) {
	ASSERT0(BP_GET_LEVEL(bp));
	BP_SET_CRYPT(bp, B_TRUE);
	BP_SET_BYTEORDER(bp, zp->zp_byteorder);
	if (ot != DMU_OT_OBJSET)
	zio_crypt_encode_mac_bp(bp, zp->zp_mac);

	/* dnode blocks must be written out in the provided byteorder */
	if (zp->zp_byteorder != ZFS_HOST_BYTEORDER &&
	ot == DMU_OT_DNODE) {
	void *bswap_buf = zio_buf_alloc(psize);
	abd_t *babd = abd_get_from_buf(bswap_buf, psize);

	ASSERT3U(BP_GET_COMPRESS(bp), ==, ZIO_COMPRESS_OFF);
	abd_copy_to_buf(bswap_buf, zio->io_abd, psize);
	dmu_ot_byteswap[DMU_OT_BYTESWAP(ot)].ob_func(bswap_buf,
	psize);

	abd_take_ownership_of_buf(babd, B_TRUE);
	zio_push_transform(zio, babd, psize, psize, NULL);
	}

	if (DMU_OT_IS_ENCRYPTED(ot))
	zio_crypt_encode_params_bp(bp, zp->zp_salt, zp->zp_iv);
	return (zio);
	}

	/* indirect blocks only maintain a cksum of the lower level MACs */
	if (BP_GET_LEVEL(bp) > 0) {
	BP_SET_CRYPT(bp, B_TRUE);
	VERIFY0(zio_crypt_do_indirect_mac_checksum_abd(B_TRUE,
	zio->io_orig_abd, BP_GET_LSIZE(bp), BP_SHOULD_BYTESWAP(bp),
	mac));
	zio_crypt_encode_mac_bp(bp, mac);
	return (zio);
	}

	/*
	* Objset blocks are a special case since they have 2 256-bit MACs
	* embedded within them.
	*/
	if (ot == DMU_OT_OBJSET) {
	ASSERT0(DMU_OT_IS_ENCRYPTED(ot));
	ASSERT3U(BP_GET_COMPRESS(bp), ==, ZIO_COMPRESS_OFF);
	BP_SET_CRYPT(bp, B_TRUE);
	VERIFY0(spa_do_crypt_objset_mac_abd(B_TRUE, spa, dsobj,
	zio->io_abd, psize, BP_SHOULD_BYTESWAP(bp)));
	return (zio);
	}

	/* unencrypted object types are only authenticated with a MAC */
	if (!DMU_OT_IS_ENCRYPTED(ot)) {
	BP_SET_CRYPT(bp, B_TRUE);
	VERIFY0(spa_do_crypt_mac_abd(B_TRUE, spa, dsobj,
	zio->io_abd, psize, mac));
	zio_crypt_encode_mac_bp(bp, mac);
	return (zio);
	}

	/*
	* Later passes of sync-to-convergence may decide to rewrite data
	* in place to avoid more disk reallocations. This presents a problem
	* for encryption because this constitutes rewriting the new data with
	* the same encryption key and IV. However, this only applies to blocks
	* in the MOS (particularly the spacemaps) and we do not encrypt the
	* MOS. We assert that the zio is allocating or an intent log write
	* to enforce this.
	*/
	ASSERT(IO_IS_ALLOCATING(zio) \|\| ot == DMU_OT_INTENT_LOG);
	ASSERT(BP_GET_LEVEL(bp) == 0 \|\| ot == DMU_OT_INTENT_LOG);
	ASSERT(spa_feature_is_active(spa, SPA_FEATURE_ENCRYPTION));
	ASSERT3U(psize, !=, 0);

	enc_buf = zio_buf_alloc(psize);
	eabd = abd_get_from_buf(enc_buf, psize);
	abd_take_ownership_of_buf(eabd, B_TRUE);

	/*
	* For an explanation of what encryption parameters are stored
	* where, see the block comment in zio_crypt.c.
	*/
	if (ot == DMU_OT_INTENT_LOG) {
	zio_crypt_decode_params_bp(bp, salt, iv);
	} else {
	BP_SET_CRYPT(bp, B_TRUE);
	}

	/* Perform the encryption. This should not fail */
	VERIFY0(spa_do_crypt_abd(B_TRUE, spa, &zio->io_bookmark,
	BP_GET_TYPE(bp), BP_GET_DEDUP(bp), BP_SHOULD_BYTESWAP(bp),
	salt, iv, mac, psize, zio->io_abd, eabd, &no_crypt));

	/* encode encryption metadata into the bp */
	if (ot == DMU_OT_INTENT_LOG) {
	/*
	* ZIL blocks store the MAC in the embedded checksum, so the
	* transform must always be applied.
	*/
	zio_crypt_encode_mac_zil(enc_buf, mac);
	zio_push_transform(zio, eabd, psize, psize, NULL);
	} else {
	BP_SET_CRYPT(bp, B_TRUE);
	zio_crypt_encode_params_bp(bp, salt, iv);
	zio_crypt_encode_mac_bp(bp, mac);

	if (no_crypt) {
	ASSERT3U(ot, ==, DMU_OT_DNODE);
	abd_free(eabd);
	} else {
	zio_push_transform(zio, eabd, psize, psize, NULL);
	}
	}

	return (zio);
	}

	/*
	* ==========================================================================
	* Generate and verify checksums
	* ==========================================================================
	*/
	static zio_t *
	zio_checksum_generate(zio_t *zio)
	{
	blkptr_t *bp = zio->io_bp;
	enum zio_checksum checksum;

	if (bp == NULL) {
	/*
	* This is zio_write_phys().
	* We're either generating a label checksum, or none at all.
	*/
	checksum = zio->io_prop.zp_checksum;

	if (checksum == ZIO_CHECKSUM_OFF)
	return (zio);

	ASSERT(checksum == ZIO_CHECKSUM_LABEL);
	} else {
	if (BP_IS_GANG(bp) && zio->io_child_type == ZIO_CHILD_GANG) {
	ASSERT(!IO_IS_ALLOCATING(zio));
	checksum = ZIO_CHECKSUM_GANG_HEADER;
	} else {
	checksum = BP_GET_CHECKSUM(bp);
	}
	}

	zio_checksum_compute(zio, checksum, zio->io_abd, zio->io_size);

	return (zio);
	}

	static zio_t *
	zio_checksum_verify(zio_t *zio)
	{
	zio_bad_cksum_t info;
	blkptr_t *bp = zio->io_bp;
	int error;

	ASSERT(zio->io_vd != NULL);

	if (bp == NULL) {
	/*
	* This is zio_read_phys().
	* We're either verifying a label checksum, or nothing at all.
	*/
	if (zio->io_prop.zp_checksum == ZIO_CHECKSUM_OFF)
	return (zio);

	ASSERT3U(zio->io_prop.zp_checksum, ==, ZIO_CHECKSUM_LABEL);
	}

	if ((error = zio_checksum_error(zio, &info)) != 0) {
	zio->io_error = error;
	if (error == ECKSUM &&
	!(zio->io_flags & ZIO_FLAG_SPECULATIVE)) {
	(void) zfs_ereport_start_checksum(zio->io_spa,
	zio->io_vd, &zio->io_bookmark, zio,
	zio->io_offset, zio->io_size, &info);
	mutex_enter(&zio->io_vd->vdev_stat_lock);
	zio->io_vd->vdev_stat.vs_checksum_errors++;
	mutex_exit(&zio->io_vd->vdev_stat_lock);
	}
	}

	return (zio);
	}

	/*
	* Called by RAID-Z to ensure we don't compute the checksum twice.
	*/
	void
	zio_checksum_verified(zio_t *zio)
	{
	zio->io_pipeline &= ~ZIO_STAGE_CHECKSUM_VERIFY;
	}

	/*
	* ==========================================================================
	* Error rank. Error are ranked in the order 0, ENXIO, ECKSUM, EIO, other.
	* An error of 0 indicates success. ENXIO indicates whole-device failure,
	* which may be transient (e.g. unplugged) or permanent. ECKSUM and EIO
	* indicate errors that are specific to one I/O, and most likely permanent.
	* Any other error is presumed to be worse because we weren't expecting it.
	* ==========================================================================
	*/
	int
	zio_worst_error(int e1, int e2)
	{
	static int zio_error_rank[] = { 0, ENXIO, ECKSUM, EIO };
	int r1, r2;

	for (r1 = 0; r1 < sizeof (zio_error_rank) / sizeof (int); r1++)
	if (e1 == zio_error_rank[r1])
	break;

	for (r2 = 0; r2 < sizeof (zio_error_rank) / sizeof (int); r2++)
	if (e2 == zio_error_rank[r2])
	break;

	return (r1 > r2 ? e1 : e2);
	}

	/*
	* ==========================================================================
	* I/O completion
	* ==========================================================================
	*/
	static zio_t *
	zio_ready(zio_t *zio)
	{
	blkptr_t *bp = zio->io_bp;
	zio_t pio, pio_next;
	zio_link_t *zl = NULL;

	if (zio_wait_for_children(zio, ZIO_CHILD_GANG_BIT \| ZIO_CHILD_DDT_BIT,
	ZIO_WAIT_READY)) {
	return (NULL);
	}

	if (zio->io_ready) {
	ASSERT(IO_IS_ALLOCATING(zio));
	ASSERT(bp->blk_birth == zio->io_txg \|\| BP_IS_HOLE(bp) \|\|
	(zio->io_flags & ZIO_FLAG_NOPWRITE));
	ASSERT(zio->io_children[ZIO_CHILD_GANG][ZIO_WAIT_READY] == 0);

	zio->io_ready(zio);
	}

	if (bp != NULL && bp != &zio->io_bp_copy)
	zio->io_bp_copy = *bp;

	if (zio->io_error != 0) {
	zio->io_pipeline = ZIO_INTERLOCK_PIPELINE;

	if (zio->io_flags & ZIO_FLAG_IO_ALLOCATING) {
	ASSERT(IO_IS_ALLOCATING(zio));
	ASSERT(zio->io_priority == ZIO_PRIORITY_ASYNC_WRITE);
	ASSERT(zio->io_metaslab_class != NULL);

	/*
	* We were unable to allocate anything, unreserve and
	* issue the next I/O to allocate.
	*/
	metaslab_class_throttle_unreserve(
	zio->io_metaslab_class, zio->io_prop.zp_copies,
	zio->io_allocator, zio);
	zio_allocate_dispatch(zio->io_spa, zio->io_allocator);
	}
	}

	mutex_enter(&zio->io_lock);
	zio->io_state[ZIO_WAIT_READY] = 1;
	pio = zio_walk_parents(zio, &zl);
	mutex_exit(&zio->io_lock);

	/*
	* As we notify zio's parents, new parents could be added.
	* New parents go to the head of zio's io_parent_list, however,
	* so we will (correctly) not notify them. The remainder of zio's
	* io_parent_list, from 'pio_next' onward, cannot change because
	* all parents must wait for us to be done before they can be done.
	*/
	for (; pio != NULL; pio = pio_next) {
	pio_next = zio_walk_parents(zio, &zl);
	zio_notify_parent(pio, zio, ZIO_WAIT_READY, NULL);
	}

	if (zio->io_flags & ZIO_FLAG_NODATA) {
	if (BP_IS_GANG(bp)) {
	zio->io_flags &= ~ZIO_FLAG_NODATA;
	} else {
	ASSERT((uintptr_t)zio->io_abd < SPA_MAXBLOCKSIZE);
	zio->io_pipeline &= ~ZIO_VDEV_IO_STAGES;
	}
	}

	if (zio_injection_enabled &&
	zio->io_spa->spa_syncing_txg == zio->io_txg)
	zio_handle_ignored_writes(zio);

	return (zio);
	}

	/*
	* Update the allocation throttle accounting.
	*/
	static void
	zio_dva_throttle_done(zio_t *zio)
	{
	zio_t *lio __maybe_unused = zio->io_logical;
	zio_t *pio = zio_unique_parent(zio);
	vdev_t *vd = zio->io_vd;
	int flags = METASLAB_ASYNC_ALLOC;

	ASSERT3P(zio->io_bp, !=, NULL);
	ASSERT3U(zio->io_type, ==, ZIO_TYPE_WRITE);
	ASSERT3U(zio->io_priority, ==, ZIO_PRIORITY_ASYNC_WRITE);
	ASSERT3U(zio->io_child_type, ==, ZIO_CHILD_VDEV);
	ASSERT(vd != NULL);
	ASSERT3P(vd, ==, vd->vdev_top);
	ASSERT(zio_injection_enabled \|\| !(zio->io_flags & ZIO_FLAG_IO_RETRY));
	ASSERT(!(zio->io_flags & ZIO_FLAG_IO_REPAIR));
	ASSERT(zio->io_flags & ZIO_FLAG_IO_ALLOCATING);
	ASSERT(!(lio->io_flags & ZIO_FLAG_IO_REWRITE));
	ASSERT(!(lio->io_orig_flags & ZIO_FLAG_NODATA));

	/*
	* Parents of gang children can have two flavors -- ones that
	* allocated the gang header (will have ZIO_FLAG_IO_REWRITE set)
	* and ones that allocated the constituent blocks. The allocation
	* throttle needs to know the allocating parent zio so we must find
	* it here.
	*/
	if (pio->io_child_type == ZIO_CHILD_GANG) {
	/*
	* If our parent is a rewrite gang child then our grandparent
	* would have been the one that performed the allocation.
	*/
	if (pio->io_flags & ZIO_FLAG_IO_REWRITE)
	pio = zio_unique_parent(pio);
	flags \|= METASLAB_GANG_CHILD;
	}

	ASSERT(IO_IS_ALLOCATING(pio));
	ASSERT3P(zio, !=, zio->io_logical);
	ASSERT(zio->io_logical != NULL);
	ASSERT(!(zio->io_flags & ZIO_FLAG_IO_REPAIR));
	ASSERT0(zio->io_flags & ZIO_FLAG_NOPWRITE);
	ASSERT(zio->io_metaslab_class != NULL);

	mutex_enter(&pio->io_lock);
	metaslab_group_alloc_decrement(zio->io_spa, vd->vdev_id, pio, flags,
	pio->io_allocator, B_TRUE);
	mutex_exit(&pio->io_lock);

	metaslab_class_throttle_unreserve(zio->io_metaslab_class, 1,
	pio->io_allocator, pio);

	/*
	* Call into the pipeline to see if there is more work that
	* needs to be done. If there is work to be done it will be
	* dispatched to another taskq thread.
	*/
	zio_allocate_dispatch(zio->io_spa, pio->io_allocator);
	}

	static zio_t *
	zio_done(zio_t *zio)
	{
	/*
	* Always attempt to keep stack usage minimal here since
	* we can be called recursively up to 19 levels deep.
	*/
	const uint64_t psize = zio->io_size;
	zio_t pio, pio_next;
	zio_link_t *zl = NULL;

	/*
	* If our children haven't all completed,
	* wait for them and then repeat this pipeline stage.
	*/
	if (zio_wait_for_children(zio, ZIO_CHILD_ALL_BITS, ZIO_WAIT_DONE)) {
	return (NULL);
	}

	/*
	* If the allocation throttle is enabled, then update the accounting.
	* We only track child I/Os that are part of an allocating async
	* write. We must do this since the allocation is performed
	* by the logical I/O but the actual write is done by child I/Os.
	*/
	if (zio->io_flags & ZIO_FLAG_IO_ALLOCATING &&
	zio->io_child_type == ZIO_CHILD_VDEV) {
	ASSERT(zio->io_metaslab_class != NULL);
	ASSERT(zio->io_metaslab_class->mc_alloc_throttle_enabled);
	zio_dva_throttle_done(zio);
	}

	/*
	* If the allocation throttle is enabled, verify that
	* we have decremented the refcounts for every I/O that was throttled.
	*/
	if (zio->io_flags & ZIO_FLAG_IO_ALLOCATING) {
	ASSERT(zio->io_type == ZIO_TYPE_WRITE);
	ASSERT(zio->io_priority == ZIO_PRIORITY_ASYNC_WRITE);
	ASSERT(zio->io_bp != NULL);

	metaslab_group_alloc_verify(zio->io_spa, zio->io_bp, zio,
	zio->io_allocator);
	VERIFY(zfs_refcount_not_held(&zio->io_metaslab_class->
	mc_allocator[zio->io_allocator].mca_alloc_slots, zio));
	}


	for (int c = 0; c < ZIO_CHILD_TYPES; c++)
	for (int w = 0; w < ZIO_WAIT_TYPES; w++)
	ASSERT(zio->io_children[c][w] == 0);

	if (zio->io_bp != NULL && !BP_IS_EMBEDDED(zio->io_bp)) {
	ASSERT(zio->io_bp->blk_pad[0] == 0);
	ASSERT(zio->io_bp->blk_pad[1] == 0);
	ASSERT(bcmp(zio->io_bp, &zio->io_bp_copy,
	sizeof (blkptr_t)) == 0 \|\|
	(zio->io_bp == zio_unique_parent(zio)->io_bp));
	if (zio->io_type == ZIO_TYPE_WRITE && !BP_IS_HOLE(zio->io_bp) &&
	zio->io_bp_override == NULL &&
	!(zio->io_flags & ZIO_FLAG_IO_REPAIR)) {
	ASSERT3U(zio->io_prop.zp_copies, <=,
	BP_GET_NDVAS(zio->io_bp));
	ASSERT(BP_COUNT_GANG(zio->io_bp) == 0 \|\|
	(BP_COUNT_GANG(zio->io_bp) ==
	BP_GET_NDVAS(zio->io_bp)));
	}
	if (zio->io_flags & ZIO_FLAG_NOPWRITE)
	VERIFY(BP_EQUAL(zio->io_bp, &zio->io_bp_orig));
	}

	/*
	* If there were child vdev/gang/ddt errors, they apply to us now.
	*/
	zio_inherit_child_errors(zio, ZIO_CHILD_VDEV);
	zio_inherit_child_errors(zio, ZIO_CHILD_GANG);
	zio_inherit_child_errors(zio, ZIO_CHILD_DDT);

	/*
	* If the I/O on the transformed data was successful, generate any
	* checksum reports now while we still have the transformed data.
	*/
	if (zio->io_error == 0) {
	while (zio->io_cksum_report != NULL) {
	zio_cksum_report_t *zcr = zio->io_cksum_report;
	uint64_t align = zcr->zcr_align;
	uint64_t asize = P2ROUNDUP(psize, align);
	abd_t *adata = zio->io_abd;

	- if (asize != psize) {
	+ if (adata != NULL && asize != psize) {
	adata = abd_alloc(asize, B_TRUE);
	abd_copy(adata, zio->io_abd, psize);
	abd_zero_off(adata, psize, asize - psize);
	}

	zio->io_cksum_report = zcr->zcr_next;
	zcr->zcr_next = NULL;
	zcr->zcr_finish(zcr, adata);
	zfs_ereport_free_checksum(zcr);

	- if (asize != psize)
	+ if (adata != NULL && asize != psize)
	abd_free(adata);
	}
	}

	zio_pop_transforms(zio); /* note: may set zio->io_error */

	vdev_stat_update(zio, psize);

	/*
	* If this I/O is attached to a particular vdev is slow, exceeding
	* 30 seconds to complete, post an error described the I/O delay.
	* We ignore these errors if the device is currently unavailable.
	*/
	if (zio->io_delay >= MSEC2NSEC(zio_slow_io_ms)) {
	if (zio->io_vd != NULL && !vdev_is_dead(zio->io_vd)) {
	/*
	* We want to only increment our slow IO counters if
	* the IO is valid (i.e. not if the drive is removed).
	*
	* zfs_ereport_post() will also do these checks, but
	* it can also ratelimit and have other failures, so we
	* need to increment the slow_io counters independent
	* of it.
	*/
	if (zfs_ereport_is_valid(FM_EREPORT_ZFS_DELAY,
	zio->io_spa, zio->io_vd, zio)) {
	mutex_enter(&zio->io_vd->vdev_stat_lock);
	zio->io_vd->vdev_stat.vs_slow_ios++;
	mutex_exit(&zio->io_vd->vdev_stat_lock);

	(void) zfs_ereport_post(FM_EREPORT_ZFS_DELAY,
	zio->io_spa, zio->io_vd, &zio->io_bookmark,
	zio, 0);
	}
	}
	}

	if (zio->io_error) {
	/*
	* If this I/O is attached to a particular vdev,
	* generate an error message describing the I/O failure
	* at the block level. We ignore these errors if the
	* device is currently unavailable.
	*/
	if (zio->io_error != ECKSUM && zio->io_vd != NULL &&
	!vdev_is_dead(zio->io_vd)) {
	int ret = zfs_ereport_post(FM_EREPORT_ZFS_IO,
	zio->io_spa, zio->io_vd, &zio->io_bookmark, zio, 0);
	if (ret != EALREADY) {
	mutex_enter(&zio->io_vd->vdev_stat_lock);
	if (zio->io_type == ZIO_TYPE_READ)
	zio->io_vd->vdev_stat.vs_read_errors++;
	else if (zio->io_type == ZIO_TYPE_WRITE)
	zio->io_vd->vdev_stat.vs_write_errors++;
	mutex_exit(&zio->io_vd->vdev_stat_lock);
	}
	}

	if ((zio->io_error == EIO \|\| !(zio->io_flags &
	(ZIO_FLAG_SPECULATIVE \| ZIO_FLAG_DONT_PROPAGATE))) &&
	zio == zio->io_logical) {
	/*
	* For logical I/O requests, tell the SPA to log the
	* error and generate a logical data ereport.
	*/
	spa_log_error(zio->io_spa, &zio->io_bookmark);
	(void) zfs_ereport_post(FM_EREPORT_ZFS_DATA,
	zio->io_spa, NULL, &zio->io_bookmark, zio, 0);
	}
	}

	if (zio->io_error && zio == zio->io_logical) {
	/*
	* Determine whether zio should be reexecuted. This will
	* propagate all the way to the root via zio_notify_parent().
	*/
	ASSERT(zio->io_vd == NULL && zio->io_bp != NULL);
	ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);

	if (IO_IS_ALLOCATING(zio) &&
	!(zio->io_flags & ZIO_FLAG_CANFAIL)) {
	if (zio->io_error != ENOSPC)
	zio->io_reexecute \|= ZIO_REEXECUTE_NOW;
	else
	zio->io_reexecute \|= ZIO_REEXECUTE_SUSPEND;
	}

	if ((zio->io_type == ZIO_TYPE_READ \|\|
	zio->io_type == ZIO_TYPE_FREE) &&
	!(zio->io_flags & ZIO_FLAG_SCAN_THREAD) &&
	zio->io_error == ENXIO &&
	spa_load_state(zio->io_spa) == SPA_LOAD_NONE &&
	spa_get_failmode(zio->io_spa) != ZIO_FAILURE_MODE_CONTINUE)
	zio->io_reexecute \|= ZIO_REEXECUTE_SUSPEND;

	if (!(zio->io_flags & ZIO_FLAG_CANFAIL) && !zio->io_reexecute)
	zio->io_reexecute \|= ZIO_REEXECUTE_SUSPEND;

	/*
	* Here is a possibly good place to attempt to do
	* either combinatorial reconstruction or error correction
	* based on checksums. It also might be a good place
	* to send out preliminary ereports before we suspend
	* processing.
	*/
	}

	/*
	* If there were logical child errors, they apply to us now.
	* We defer this until now to avoid conflating logical child
	* errors with errors that happened to the zio itself when
	* updating vdev stats and reporting FMA events above.
	*/
	zio_inherit_child_errors(zio, ZIO_CHILD_LOGICAL);

	if ((zio->io_error \|\| zio->io_reexecute) &&
	IO_IS_ALLOCATING(zio) && zio->io_gang_leader == zio &&
	!(zio->io_flags & (ZIO_FLAG_IO_REWRITE \| ZIO_FLAG_NOPWRITE)))
	zio_dva_unallocate(zio, zio->io_gang_tree, zio->io_bp);

	zio_gang_tree_free(&zio->io_gang_tree);

	/*
	* Godfather I/Os should never suspend.
	*/
	if ((zio->io_flags & ZIO_FLAG_GODFATHER) &&
	(zio->io_reexecute & ZIO_REEXECUTE_SUSPEND))
	zio->io_reexecute &= ~ZIO_REEXECUTE_SUSPEND;

	if (zio->io_reexecute) {
	/*
	* This is a logical I/O that wants to reexecute.
	*
	* Reexecute is top-down. When an i/o fails, if it's not
	* the root, it simply notifies its parent and sticks around.
	* The parent, seeing that it still has children in zio_done(),
	* does the same. This percolates all the way up to the root.
	* The root i/o will reexecute or suspend the entire tree.
	*
	* This approach ensures that zio_reexecute() honors
	* all the original i/o dependency relationships, e.g.
	* parents not executing until children are ready.
	*/
	ASSERT(zio->io_child_type == ZIO_CHILD_LOGICAL);

	zio->io_gang_leader = NULL;

	mutex_enter(&zio->io_lock);
	zio->io_state[ZIO_WAIT_DONE] = 1;
	mutex_exit(&zio->io_lock);

	/*
	* "The Godfather" I/O monitors its children but is
	* not a true parent to them. It will track them through
	* the pipeline but severs its ties whenever they get into
	* trouble (e.g. suspended). This allows "The Godfather"
	* I/O to return status without blocking.
	*/
	zl = NULL;
	for (pio = zio_walk_parents(zio, &zl); pio != NULL;
	pio = pio_next) {
	zio_link_t *remove_zl = zl;
	pio_next = zio_walk_parents(zio, &zl);

	if ((pio->io_flags & ZIO_FLAG_GODFATHER) &&
	(zio->io_reexecute & ZIO_REEXECUTE_SUSPEND)) {
	zio_remove_child(pio, zio, remove_zl);
	/*
	* This is a rare code path, so we don't
	* bother with "next_to_execute".
	*/
	zio_notify_parent(pio, zio, ZIO_WAIT_DONE,
	NULL);
	}
	}

	if ((pio = zio_unique_parent(zio)) != NULL) {
	/*
	* We're not a root i/o, so there's nothing to do
	* but notify our parent. Don't propagate errors
	* upward since we haven't permanently failed yet.
	*/
	ASSERT(!(zio->io_flags & ZIO_FLAG_GODFATHER));
	zio->io_flags \|= ZIO_FLAG_DONT_PROPAGATE;
	/*
	* This is a rare code path, so we don't bother with
	* "next_to_execute".
	*/
	zio_notify_parent(pio, zio, ZIO_WAIT_DONE, NULL);
	} else if (zio->io_reexecute & ZIO_REEXECUTE_SUSPEND) {
	/*
	* We'd fail again if we reexecuted now, so suspend
	* until conditions improve (e.g. device comes online).
	*/
	zio_suspend(zio->io_spa, zio, ZIO_SUSPEND_IOERR);
	} else {
	/*
	* Reexecution is potentially a huge amount of work.
	* Hand it off to the otherwise-unused claim taskq.
	*/
	ASSERT(taskq_empty_ent(&zio->io_tqent));
	spa_taskq_dispatch_ent(zio->io_spa,
	ZIO_TYPE_CLAIM, ZIO_TASKQ_ISSUE,
	(task_func_t *)zio_reexecute, zio, 0,
	&zio->io_tqent);
	}
	return (NULL);
	}

	ASSERT(zio->io_child_count == 0);
	ASSERT(zio->io_reexecute == 0);
	ASSERT(zio->io_error == 0 \|\| (zio->io_flags & ZIO_FLAG_CANFAIL));

	/*
	* Report any checksum errors, since the I/O is complete.
	*/
	while (zio->io_cksum_report != NULL) {
	zio_cksum_report_t *zcr = zio->io_cksum_report;
	zio->io_cksum_report = zcr->zcr_next;
	zcr->zcr_next = NULL;
	zcr->zcr_finish(zcr, NULL);
	zfs_ereport_free_checksum(zcr);
	}

	if (zio->io_flags & ZIO_FLAG_FASTWRITE && zio->io_bp &&
	!BP_IS_HOLE(zio->io_bp) && !BP_IS_EMBEDDED(zio->io_bp) &&
	!(zio->io_flags & ZIO_FLAG_NOPWRITE)) {
	metaslab_fastwrite_unmark(zio->io_spa, zio->io_bp);
	}

	/*
	* It is the responsibility of the done callback to ensure that this
	* particular zio is no longer discoverable for adoption, and as
	* such, cannot acquire any new parents.
	*/
	if (zio->io_done)
	zio->io_done(zio);

	mutex_enter(&zio->io_lock);
	zio->io_state[ZIO_WAIT_DONE] = 1;
	mutex_exit(&zio->io_lock);

	/*
	* We are done executing this zio. We may want to execute a parent
	* next. See the comment in zio_notify_parent().
	*/
	zio_t *next_to_execute = NULL;
	zl = NULL;
	for (pio = zio_walk_parents(zio, &zl); pio != NULL; pio = pio_next) {
	zio_link_t *remove_zl = zl;
	pio_next = zio_walk_parents(zio, &zl);
	zio_remove_child(pio, zio, remove_zl);
	zio_notify_parent(pio, zio, ZIO_WAIT_DONE, &next_to_execute);
	}

	if (zio->io_waiter != NULL) {
	mutex_enter(&zio->io_lock);
	zio->io_executor = NULL;
	cv_broadcast(&zio->io_cv);
	mutex_exit(&zio->io_lock);
	} else {
	zio_destroy(zio);
	}

	return (next_to_execute);
	}

	/*
	* ==========================================================================
	* I/O pipeline definition
	* ==========================================================================
	*/
	static zio_pipe_stage_t *zio_pipeline[] = {
	NULL,
	zio_read_bp_init,
	zio_write_bp_init,
	zio_free_bp_init,
	zio_issue_async,
	zio_write_compress,
	zio_encrypt,
	zio_checksum_generate,
	zio_nop_write,
	zio_ddt_read_start,
	zio_ddt_read_done,
	zio_ddt_write,
	zio_ddt_free,
	zio_gang_assemble,
	zio_gang_issue,
	zio_dva_throttle,
	zio_dva_allocate,
	zio_dva_free,
	zio_dva_claim,
	zio_ready,
	zio_vdev_io_start,
	zio_vdev_io_done,
	zio_vdev_io_assess,
	zio_checksum_verify,
	zio_done
	};




	/*
	* Compare two zbookmark_phys_t's to see which we would reach first in a
	* pre-order traversal of the object tree.
	*
	* This is simple in every case aside from the meta-dnode object. For all other
	* objects, we traverse them in order (object 1 before object 2, and so on).
	* However, all of these objects are traversed while traversing object 0, since
	* the data it points to is the list of objects. Thus, we need to convert to a
	* canonical representation so we can compare meta-dnode bookmarks to
	* non-meta-dnode bookmarks.
	*
	* We do this by calculating "equivalents" for each field of the zbookmark.
	* zbookmarks outside of the meta-dnode use their own object and level, and
	* calculate the level 0 equivalent (the first L0 blkid that is contained in the
	* blocks this bookmark refers to) by multiplying their blkid by their span
	* (the number of L0 blocks contained within one block at their level).
	* zbookmarks inside the meta-dnode calculate their object equivalent
	* (which is L0equiv * dnodes per data block), use 0 for their L0equiv, and use
	* level + 1<<31 (any value larger than a level could ever be) for their level.
	* This causes them to always compare before a bookmark in their object
	* equivalent, compare appropriately to bookmarks in other objects, and to
	* compare appropriately to other bookmarks in the meta-dnode.
	*/
	int
	zbookmark_compare(uint16_t dbss1, uint8_t ibs1, uint16_t dbss2, uint8_t ibs2,
	const zbookmark_phys_t zb1, const zbookmark_phys_t zb2)
	{
	/*
	* These variables represent the "equivalent" values for the zbookmark,
	* after converting zbookmarks inside the meta dnode to their
	* normal-object equivalents.
	*/
	uint64_t zb1obj, zb2obj;
	uint64_t zb1L0, zb2L0;
	uint64_t zb1level, zb2level;

	if (zb1->zb_object == zb2->zb_object &&
	zb1->zb_level == zb2->zb_level &&
	zb1->zb_blkid == zb2->zb_blkid)
	return (0);

	IMPLY(zb1->zb_level > 0, ibs1 >= SPA_MINBLOCKSHIFT);
	IMPLY(zb2->zb_level > 0, ibs2 >= SPA_MINBLOCKSHIFT);

	/*
	* BP_SPANB calculates the span in blocks.
	*/
	zb1L0 = (zb1->zb_blkid) * BP_SPANB(ibs1, zb1->zb_level);
	zb2L0 = (zb2->zb_blkid) * BP_SPANB(ibs2, zb2->zb_level);

	if (zb1->zb_object == DMU_META_DNODE_OBJECT) {
	zb1obj = zb1L0 * (dbss1 << (SPA_MINBLOCKSHIFT - DNODE_SHIFT));
	zb1L0 = 0;
	zb1level = zb1->zb_level + COMPARE_META_LEVEL;
	} else {
	zb1obj = zb1->zb_object;
	zb1level = zb1->zb_level;
	}

	if (zb2->zb_object == DMU_META_DNODE_OBJECT) {
	zb2obj = zb2L0 * (dbss2 << (SPA_MINBLOCKSHIFT - DNODE_SHIFT));
	zb2L0 = 0;
	zb2level = zb2->zb_level + COMPARE_META_LEVEL;
	} else {
	zb2obj = zb2->zb_object;
	zb2level = zb2->zb_level;
	}

	/* Now that we have a canonical representation, do the comparison. */
	if (zb1obj != zb2obj)
	return (zb1obj < zb2obj ? -1 : 1);
	else if (zb1L0 != zb2L0)
	return (zb1L0 < zb2L0 ? -1 : 1);
	else if (zb1level != zb2level)
	return (zb1level > zb2level ? -1 : 1);
	/*
	* This can (theoretically) happen if the bookmarks have the same object
	* and level, but different blkids, if the block sizes are not the same.
	* There is presently no way to change the indirect block sizes
	*/
	return (0);
	}

	/*
	* This function checks the following: given that last_block is the place that
	* our traversal stopped last time, does that guarantee that we've visited
	* every node under subtree_root? Therefore, we can't just use the raw output
	* of zbookmark_compare. We have to pass in a modified version of
	* subtree_root; by incrementing the block id, and then checking whether
	* last_block is before or equal to that, we can tell whether or not having
	* visited last_block implies that all of subtree_root's children have been
	* visited.
	*/
	boolean_t
	zbookmark_subtree_completed(const dnode_phys_t *dnp,
	const zbookmark_phys_t subtree_root, const zbookmark_phys_t last_block)
	{
	zbookmark_phys_t mod_zb = *subtree_root;
	mod_zb.zb_blkid++;
	ASSERT(last_block->zb_level == 0);

	/* The objset_phys_t isn't before anything. */
	if (dnp == NULL)
	return (B_FALSE);

	/*
	* We pass in 1ULL << (DNODE_BLOCK_SHIFT - SPA_MINBLOCKSHIFT) for the
	* data block size in sectors, because that variable is only used if
	* the bookmark refers to a block in the meta-dnode. Since we don't
	* know without examining it what object it refers to, and there's no
	* harm in passing in this value in other cases, we always pass it in.
	*
	* We pass in 0 for the indirect block size shift because zb2 must be
	* level 0. The indirect block size is only used to calculate the span
	* of the bookmark, but since the bookmark must be level 0, the span is
	* always 1, so the math works out.
	*
	* If you make changes to how the zbookmark_compare code works, be sure
	* to make sure that this code still works afterwards.
	*/
	return (zbookmark_compare(dnp->dn_datablkszsec, dnp->dn_indblkshift,
	1ULL << (DNODE_BLOCK_SHIFT - SPA_MINBLOCKSHIFT), 0, &mod_zb,
	last_block) <= 0);
	}

	EXPORT_SYMBOL(zio_type_name);
	EXPORT_SYMBOL(zio_buf_alloc);
	EXPORT_SYMBOL(zio_data_buf_alloc);
	EXPORT_SYMBOL(zio_buf_free);
	EXPORT_SYMBOL(zio_data_buf_free);

	/* BEGIN CSTYLED */
	ZFS_MODULE_PARAM(zfs_zio, zio_, slow_io_ms, INT, ZMOD_RW,
	"Max I/O completion time (milliseconds) before marking it as slow");

	ZFS_MODULE_PARAM(zfs_zio, zio_, requeue_io_start_cut_in_line, INT, ZMOD_RW,
	"Prioritize requeued I/O");

	ZFS_MODULE_PARAM(zfs, zfs_, sync_pass_deferred_free, INT, ZMOD_RW,
	"Defer frees starting in this pass");

	ZFS_MODULE_PARAM(zfs, zfs_, sync_pass_dont_compress, INT, ZMOD_RW,
	"Don't compress starting in this pass");

	ZFS_MODULE_PARAM(zfs, zfs_, sync_pass_rewrite, INT, ZMOD_RW,
	"Rewrite new bps starting in this pass");

	ZFS_MODULE_PARAM(zfs_zio, zio_, dva_throttle_enabled, INT, ZMOD_RW,
	"Throttle block allocations in the ZIO pipeline");

	ZFS_MODULE_PARAM(zfs_zio, zio_, deadman_log_all, INT, ZMOD_RW,
	"Log all slow ZIOs, not just those with vdevs");
	/* END CSTYLED */
	diff --git a/sys/contrib/openzfs/module/zstd/README.md b/sys/contrib/openzfs/module/zstd/README.md
	index f8e127736aac..eed229e2f78f 100644
	--- a/sys/contrib/openzfs/module/zstd/README.md
	+++ b/sys/contrib/openzfs/module/zstd/README.md
	@@ -1,65 +1,65 @@
	# ZSTD-On-ZFS Library Manual

	## Introduction

	This subtree contains the ZSTD library used in ZFS. It is heavily cut-down by
	dropping any unneeded files, and combined into a single file, but otherwise is
	intentionally unmodified. Please do not alter the file containing the zstd
	library, besides upgrading to a newer ZSTD release.

	Tree structure:

	* `zfs_zstd.c` is the actual `zzstd` kernel module.
	-* `lib/` contains the the unmodified, [_"amalgamated"_](https://github.com/facebook/zstd/blob/dev/contrib/single_file_libs/README.md)
	+* `lib/` contains the unmodified, [_"amalgamated"_](https://github.com/facebook/zstd/blob/dev/contrib/single_file_libs/README.md)
	version of the `Zstandard` library, generated from our template file
	* `zstd-in.c` is our template file for generating the library
	* `include/`: This directory contains supplemental includes for platform
	compatibility, which are not expected to be used by ZFS elsewhere in the
	future. Thus we keep them private to ZSTD.

	## Updating ZSTD

	To update ZSTD the following steps need to be taken:

	1. Grab the latest release of [ZSTD](https://github.com/facebook/zstd/releases).
	2. Update `module/zstd/zstd-in.c` if required. (see
	`zstd/contrib/single_file_libs/zstd-in.c` in the zstd repository)
	3. Generate the "single-file-library" and put it to `module/zstd/lib/`.
	4. Copy the following files to `module/zstd/lib/`:
	- `zstd/lib/zstd.h`
	- `zstd/lib/common/zstd_errors.h`

	This can be done using a few shell commands from inside the zfs repo:

	~~~sh
	cd PATH/TO/ZFS

	url="https://github.com/facebook/zstd"
	release="$(curl -s "${url}"/releases/latest \| grep -oP '(?<=v)[\d\.]+')"
	zstd="/tmp/zstd-${release}/"

	wget -O /tmp/zstd.tar.gz \
	"${url}/releases/download/v${release}/zstd-${release}.tar.gz"
	tar -C /tmp -xzf /tmp/zstd.tar.gz

	cp ${zstd}/lib/zstd.h module/zstd/lib/
	cp ${zstd}/lib/zstd_errors.h module/zstd/lib/
	${zstd}/contrib/single_file_libs/combine.sh \
	-r ${zstd}/lib -o module/zstd/lib/zstd.c module/zstd/zstd-in.c
	~~~

	Note: if the zstd library for zfs is updated to a newer version,
	the macro list in include/zstd_compat_wrapper.h usually needs to be updated.
	this can be done with some hand crafting of the output of the following
	script: nm zstd.o \| awk '{print "#define "$3 " zfs_" $3}' > macrotable


	## Altering ZSTD and breaking changes

	If ZSTD made changes that break compatibility or you need to make breaking
	changes to the way we handle ZSTD, it is required to maintain backwards
	compatibility.

	We already save the ZSTD version number within the block header to be used
	to add future compatibility checks and/or fixes. However, currently it is
	not actually used in such a way.
	diff --git a/sys/contrib/openzfs/module/zstd/include/zstd_compat_wrapper.h b/sys/contrib/openzfs/module/zstd/include/zstd_compat_wrapper.h
	index 5cca517b5508..71adc78040fb 100644
	--- a/sys/contrib/openzfs/module/zstd/include/zstd_compat_wrapper.h
	+++ b/sys/contrib/openzfs/module/zstd/include/zstd_compat_wrapper.h
	@@ -1,460 +1,460 @@
	/*
	* BSD 3-Clause New License (https://spdx.org/licenses/BSD-3-Clause.html)
	*
	* 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.
	*
	* 3. Neither the name of the copyright holder nor the names of its
	* contributors may be used to endorse or promote products derived from this
	* software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT HOLDER 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.
	*/

	/*
	* Copyright (c) 2020, Sebastian Gottschall
	*/

	/*
	* This wrapper fixes a problem, in case the ZFS filesystem driver, is compiled
	- * staticly into the kernel.
	+ * statically into the kernel.
	* This will cause a symbol collision with the older in-kernel zstd library.
	* The following macros will simply rename all local zstd symbols and references
	*
	* Note: if the zstd library for zfs is updated to a newer version, this macro
	* list usually needs to be updated.
	* this can be done with some hand crafting of the output of the following
	* script
	* nm zstd.o \| awk '{print "#define "$3 " zfs_" $3}' > macrotable
	*/

	#define BIT_initDStream zfs_BIT_initDStream
	#define BIT_mask zfs_BIT_mask
	#define BIT_reloadDStream zfs_BIT_reloadDStream
	#define ERR_getErrorString zfs_ERR_getErrorString
	#define FSE_NCountWriteBound zfs_FSE_NCountWriteBound
	#define FSE_buildCTable zfs_FSE_buildCTable
	#define FSE_buildCTable_raw zfs_FSE_buildCTable_raw
	#define FSE_buildCTable_rle zfs_FSE_buildCTable_rle
	#define FSE_buildCTable_wksp zfs_FSE_buildCTable_wksp
	#define FSE_buildDTable zfs_FSE_buildDTable
	#define FSE_buildDTable_raw zfs_FSE_buildDTable_raw
	#define FSE_buildDTable_rle zfs_FSE_buildDTable_rle
	#define FSE_compress zfs_FSE_compress
	#define FSE_compress2 zfs_FSE_compress2
	#define FSE_compressBound zfs_FSE_compressBound
	#define FSE_compress_usingCTable zfs_FSE_compress_usingCTable
	#define FSE_compress_usingCTable_generic zfs_FSE_compress_usingCTable_generic
	#define FSE_compress_wksp zfs_FSE_compress_wksp
	#define FSE_createCTable zfs_FSE_createCTable
	#define FSE_createDTable zfs_FSE_createDTable
	#define FSE_decompress zfs_FSE_decompress
	#define FSE_decompress_usingDTable zfs_FSE_decompress_usingDTable
	#define FSE_decompress_wksp zfs_FSE_decompress_wksp
	#define FSE_freeCTable zfs_FSE_freeCTable
	#define FSE_freeDTable zfs_FSE_freeDTable
	#define FSE_getErrorName zfs_FSE_getErrorName
	#define FSE_normalizeCount zfs_FSE_normalizeCount
	#define FSE_optimalTableLog zfs_FSE_optimalTableLog
	#define FSE_optimalTableLog_internal zfs_FSE_optimalTableLog_internal
	#define FSE_readNCount zfs_FSE_readNCount
	#define FSE_versionNumber zfs_FSE_versionNumber
	#define FSE_writeNCount zfs_FSE_writeNCount
	#define HIST_count zfs_HIST_count
	#define HIST_countFast zfs_HIST_countFast
	#define HIST_countFast_wksp zfs_HIST_countFast_wksp
	#define HIST_count_parallel_wksp zfs_HIST_count_parallel_wksp
	#define HIST_count_simple zfs_HIST_count_simple
	#define HIST_count_wksp zfs_HIST_count_wksp
	#define HUF_buildCTable zfs_HUF_buildCTable
	#define HUF_buildCTable_wksp zfs_HUF_buildCTable_wksp
	#define HUF_compress zfs_HUF_compress
	#define HUF_compress1X zfs_HUF_compress1X
	#define HUF_compress1X_repeat zfs_HUF_compress1X_repeat
	#define HUF_compress1X_usingCTable zfs_HUF_compress1X_usingCTable
	#define HUF_compress1X_wksp zfs_HUF_compress1X_wksp
	#define HUF_compress2 zfs_HUF_compress2
	#define HUF_compress4X_repeat zfs_HUF_compress4X_repeat
	#define HUF_compress4X_usingCTable zfs_HUF_compress4X_usingCTable
	#define HUF_compress4X_wksp zfs_HUF_compress4X_wksp
	#define HUF_compressBound zfs_HUF_compressBound
	#define HUF_compressWeights zfs_HUF_compressWeights
	#define HUF_decompress zfs_HUF_decompress
	#define HUF_decompress1X1 zfs_HUF_decompress1X1
	#define HUF_decompress1X1_DCtx zfs_HUF_decompress1X1_DCtx
	#define HUF_decompress1X1_DCtx_wksp zfs_HUF_decompress1X1_DCtx_wksp
	#define HUF_decompress1X1_DCtx_wksp_bmi2 zfs_HUF_decompress1X1_DCtx_wksp_bmi2
	#define HUF_decompress1X1_usingDTable zfs_HUF_decompress1X1_usingDTable
	#define HUF_decompress1X2 zfs_HUF_decompress1X2
	#define HUF_decompress1X2_DCtx zfs_HUF_decompress1X2_DCtx
	#define HUF_decompress1X2_DCtx_wksp zfs_HUF_decompress1X2_DCtx_wksp
	#define HUF_decompress1X2_usingDTable zfs_HUF_decompress1X2_usingDTable
	#define HUF_decompress1X_DCtx zfs_HUF_decompress1X_DCtx
	#define HUF_decompress1X_DCtx_wksp zfs_HUF_decompress1X_DCtx_wksp
	#define HUF_decompress1X_usingDTable zfs_HUF_decompress1X_usingDTable
	#define HUF_decompress1X_usingDTable_bmi2 zfs_HUF_decompress1X_usingDTable_bmi2
	#define HUF_decompress4X1 zfs_HUF_decompress4X1
	#define HUF_decompress4X1_DCtx zfs_HUF_decompress4X1_DCtx
	#define HUF_decompress4X1_DCtx_wksp zfs_HUF_decompress4X1_DCtx_wksp
	#define HUF_decompress4X1_usingDTable zfs_HUF_decompress4X1_usingDTable
	#define HUF_decompress4X2 zfs_HUF_decompress4X2
	#define HUF_decompress4X2_DCtx zfs_HUF_decompress4X2_DCtx
	#define HUF_decompress4X2_DCtx_wksp zfs_HUF_decompress4X2_DCtx_wksp
	#define HUF_decompress4X2_usingDTable zfs_HUF_decompress4X2_usingDTable
	#define HUF_decompress4X_DCtx zfs_HUF_decompress4X_DCtx
	#define HUF_decompress4X_hufOnly zfs_HUF_decompress4X_hufOnly
	#define HUF_decompress4X_hufOnly_wksp zfs_HUF_decompress4X_hufOnly_wksp
	#define HUF_decompress4X_hufOnly_wksp_bmi2 \
	zfs_HUF_decompress4X_hufOnly_wksp_bmi2
	#define HUF_decompress4X_usingDTable zfs_HUF_decompress4X_usingDTable
	#define HUF_decompress4X_usingDTable_bmi2 zfs_HUF_decompress4X_usingDTable_bmi2
	#define HUF_estimateCompressedSize zfs_HUF_estimateCompressedSize
	#define HUF_fillDTableX2Level2 zfs_HUF_fillDTableX2Level2
	#define HUF_getErrorName zfs_HUF_getErrorName
	#define HUF_getNbBits zfs_HUF_getNbBits
	#define HUF_optimalTableLog zfs_HUF_optimalTableLog
	#define HUF_readCTable zfs_HUF_readCTable
	#define HUF_readDTableX1 zfs_HUF_readDTableX1
	#define HUF_readDTableX1_wksp zfs_HUF_readDTableX1_wksp
	#define HUF_readDTableX2 zfs_HUF_readDTableX2
	#define HUF_readDTableX2_wksp zfs_HUF_readDTableX2_wksp
	#define HUF_readStats zfs_HUF_readStats
	#define HUF_selectDecoder zfs_HUF_selectDecoder
	#define HUF_setMaxHeight zfs_HUF_setMaxHeight
	#define HUF_validateCTable zfs_HUF_validateCTable
	#define HUF_writeCTable zfs_HUF_writeCTable
	#define LL_base zfs_LL_base
	#define LL_bits zfs_LL_bits
	#define LL_defaultDTable zfs_LL_defaultDTable
	#define LL_defaultNorm zfs_LL_defaultNorm
	#define ML_base zfs_ML_base
	#define ML_bits zfs_ML_bits
	#define ML_defaultDTable zfs_ML_defaultDTable
	#define ML_defaultNorm zfs_ML_defaultNorm
	#define OF_base zfs_OF_base
	#define OF_bits zfs_OF_bits
	#define OF_defaultDTable zfs_OF_defaultDTable
	#define OF_defaultNorm zfs_OF_defaultNorm
	#define POOL_add zfs_POOL_add
	#define POOL_create zfs_POOL_create
	#define POOL_create_advanced zfs_POOL_create_advanced
	#define POOL_free zfs_POOL_free
	#define POOL_resize zfs_POOL_resize
	#define POOL_sizeof zfs_POOL_sizeof
	#define POOL_tryAdd zfs_POOL_tryAdd
	#define ZSTD_CCtxParams_getParameter zfs_ZSTD_CCtxParams_getParameter
	#define ZSTD_CCtxParams_init zfs_ZSTD_CCtxParams_init
	#define ZSTD_CCtxParams_init_advanced zfs_ZSTD_CCtxParams_init_advanced
	#define ZSTD_CCtxParams_reset zfs_ZSTD_CCtxParams_reset
	#define ZSTD_CCtxParams_setParameter zfs_ZSTD_CCtxParams_setParameter
	#define ZSTD_CCtx_getParameter zfs_ZSTD_CCtx_getParameter
	#define ZSTD_CCtx_loadDictionary zfs_ZSTD_CCtx_loadDictionary
	#define ZSTD_CCtx_loadDictionary_advanced zfs_ZSTD_CCtx_loadDictionary_advanced
	#define ZSTD_CCtx_loadDictionary_byReference \
	zfs_ZSTD_CCtx_loadDictionary_byReference
	#define ZSTD_CCtx_refCDict zfs_ZSTD_CCtx_refCDict
	#define ZSTD_CCtx_refPrefix zfs_ZSTD_CCtx_refPrefix
	#define ZSTD_CCtx_refPrefix_advanced zfs_ZSTD_CCtx_refPrefix_advanced
	#define ZSTD_CCtx_reset zfs_ZSTD_CCtx_reset
	#define ZSTD_CCtx_setParameter zfs_ZSTD_CCtx_setParameter
	#define ZSTD_CCtx_setParametersUsingCCtxParams \
	zfs_ZSTD_CCtx_setParametersUsingCCtxParams
	#define ZSTD_CCtx_setPledgedSrcSize zfs_ZSTD_CCtx_setPledgedSrcSize
	#define ZSTD_CStreamInSize zfs_ZSTD_CStreamInSize
	#define ZSTD_CStreamOutSize zfs_ZSTD_CStreamOutSize
	#define ZSTD_DCtx_loadDictionary zfs_ZSTD_DCtx_loadDictionary
	#define ZSTD_DCtx_loadDictionary_advanced zfs_ZSTD_DCtx_loadDictionary_advanced
	#define ZSTD_DCtx_loadDictionary_byReference \
	zfs_ZSTD_DCtx_loadDictionary_byReference
	#define ZSTD_DCtx_refDDict zfs_ZSTD_DCtx_refDDict
	#define ZSTD_DCtx_refPrefix zfs_ZSTD_DCtx_refPrefix
	#define ZSTD_DCtx_refPrefix_advanced zfs_ZSTD_DCtx_refPrefix_advanced
	#define ZSTD_DCtx_reset zfs_ZSTD_DCtx_reset
	#define ZSTD_DCtx_setFormat zfs_ZSTD_DCtx_setFormat
	#define ZSTD_DCtx_setMaxWindowSize zfs_ZSTD_DCtx_setMaxWindowSize
	#define ZSTD_DCtx_setParameter zfs_ZSTD_DCtx_setParameter
	#define ZSTD_DDict_dictContent zfs_ZSTD_DDict_dictContent
	#define ZSTD_DDict_dictSize zfs_ZSTD_DDict_dictSize
	#define ZSTD_DStreamInSize zfs_ZSTD_DStreamInSize
	#define ZSTD_DStreamOutSize zfs_ZSTD_DStreamOutSize
	#define ZSTD_DUBT_findBestMatch zfs_ZSTD_DUBT_findBestMatch
	#define ZSTD_NCountCost zfs_ZSTD_NCountCost
	#define ZSTD_XXH64_digest zfs_ZSTD_XXH64_digest
	#define ZSTD_adjustCParams zfs_ZSTD_adjustCParams
	#define ZSTD_assignParamsToCCtxParams zfs_ZSTD_assignParamsToCCtxParams
	#define ZSTD_buildCTable zfs_ZSTD_buildCTable
	#define ZSTD_buildFSETable zfs_ZSTD_buildFSETable
	#define ZSTD_buildSeqStore zfs_ZSTD_buildSeqStore
	#define ZSTD_buildSeqTable zfs_ZSTD_buildSeqTable
	#define ZSTD_cParam_getBounds zfs_ZSTD_cParam_getBounds
	#define ZSTD_cParam_withinBounds zfs_ZSTD_cParam_withinBounds
	#define ZSTD_calloc zfs_ZSTD_calloc
	#define ZSTD_checkCParams zfs_ZSTD_checkCParams
	#define ZSTD_checkContinuity zfs_ZSTD_checkContinuity
	#define ZSTD_compress zfs_ZSTD_compress
	#define ZSTD_compress2 zfs_ZSTD_compress2
	#define ZSTD_compressBegin zfs_ZSTD_compressBegin
	#define ZSTD_compressBegin_advanced zfs_ZSTD_compressBegin_advanced
	#define ZSTD_compressBegin_advanced_internal \
	zfs_ZSTD_compressBegin_advanced_internal
	#define ZSTD_compressBegin_usingCDict zfs_ZSTD_compressBegin_usingCDict
	#define ZSTD_compressBegin_usingCDict_advanced \
	zfs_ZSTD_compressBegin_usingCDict_advanced
	#define ZSTD_compressBegin_usingDict zfs_ZSTD_compressBegin_usingDict
	#define ZSTD_compressBlock zfs_ZSTD_compressBlock
	#define ZSTD_compressBlock_btlazy2 zfs_ZSTD_compressBlock_btlazy2
	#define ZSTD_compressBlock_btlazy2_dictMatchState \
	zfs_ZSTD_compressBlock_btlazy2_dictMatchState
	#define ZSTD_compressBlock_btlazy2_extDict \
	zfs_ZSTD_compressBlock_btlazy2_extDict
	#define ZSTD_compressBlock_btopt zfs_ZSTD_compressBlock_btopt
	#define ZSTD_compressBlock_btopt_dictMatchState \
	zfs_ZSTD_compressBlock_btopt_dictMatchState
	#define ZSTD_compressBlock_btopt_extDict zfs_ZSTD_compressBlock_btopt_extDict
	#define ZSTD_compressBlock_btultra zfs_ZSTD_compressBlock_btultra
	#define ZSTD_compressBlock_btultra2 zfs_ZSTD_compressBlock_btultra2
	#define ZSTD_compressBlock_btultra_dictMatchState \
	zfs_ZSTD_compressBlock_btultra_dictMatchState
	#define ZSTD_compressBlock_btultra_extDict \
	zfs_ZSTD_compressBlock_btultra_extDict
	#define ZSTD_compressBlock_doubleFast zfs_ZSTD_compressBlock_doubleFast
	#define ZSTD_compressBlock_doubleFast_dictMatchState \
	zfs_ZSTD_compressBlock_doubleFast_dictMatchState
	#define ZSTD_compressBlock_doubleFast_extDict \
	zfs_ZSTD_compressBlock_doubleFast_extDict
	#define ZSTD_compressBlock_doubleFast_extDict_generic \
	zfs_ZSTD_compressBlock_doubleFast_extDict_generic
	#define ZSTD_compressBlock_fast zfs_ZSTD_compressBlock_fast
	#define ZSTD_compressBlock_fast_dictMatchState \
	zfs_ZSTD_compressBlock_fast_dictMatchState
	#define ZSTD_compressBlock_fast_extDict zfs_ZSTD_compressBlock_fast_extDict
	#define ZSTD_compressBlock_fast_extDict_generic \
	zfs_ZSTD_compressBlock_fast_extDict_generic
	#define ZSTD_compressBlock_greedy zfs_ZSTD_compressBlock_greedy
	#define ZSTD_compressBlock_greedy_dictMatchState \
	zfs_ZSTD_compressBlock_greedy_dictMatchState
	#define ZSTD_compressBlock_greedy_extDict zfs_ZSTD_compressBlock_greedy_extDict
	#define ZSTD_compressBlock_internal zfs_ZSTD_compressBlock_internal
	#define ZSTD_compressBlock_lazy zfs_ZSTD_compressBlock_lazy
	#define ZSTD_compressBlock_lazy2 zfs_ZSTD_compressBlock_lazy2
	#define ZSTD_compressBlock_lazy2_dictMatchState \
	zfs_ZSTD_compressBlock_lazy2_dictMatchState
	#define ZSTD_compressBlock_lazy2_extDict zfs_ZSTD_compressBlock_lazy2_extDict
	#define ZSTD_compressBlock_lazy_dictMatchState \
	zfs_ZSTD_compressBlock_lazy_dictMatchState
	#define ZSTD_compressBlock_lazy_extDict zfs_ZSTD_compressBlock_lazy_extDict
	#define ZSTD_compressBound zfs_ZSTD_compressBound
	#define ZSTD_compressCCtx zfs_ZSTD_compressCCtx
	#define ZSTD_compressContinue zfs_ZSTD_compressContinue
	#define ZSTD_compressContinue_internal zfs_ZSTD_compressContinue_internal
	#define ZSTD_compressEnd zfs_ZSTD_compressEnd
	#define ZSTD_compressLiterals zfs_ZSTD_compressLiterals
	#define ZSTD_compressRleLiteralsBlock zfs_ZSTD_compressRleLiteralsBlock
	#define ZSTD_compressStream zfs_ZSTD_compressStream
	#define ZSTD_compressStream2 zfs_ZSTD_compressStream2
	#define ZSTD_compressStream2_simpleArgs zfs_ZSTD_compressStream2_simpleArgs
	#define ZSTD_compressSuperBlock zfs_ZSTD_compressSuperBlock
	#define ZSTD_compress_advanced zfs_ZSTD_compress_advanced
	#define ZSTD_compress_advanced_internal zfs_ZSTD_compress_advanced_internal
	#define ZSTD_compress_internal zfs_ZSTD_compress_internal
	#define ZSTD_compress_usingCDict zfs_ZSTD_compress_usingCDict
	#define ZSTD_compress_usingCDict_advanced zfs_ZSTD_compress_usingCDict_advanced
	#define ZSTD_compress_usingDict zfs_ZSTD_compress_usingDict
	#define ZSTD_copyCCtx zfs_ZSTD_copyCCtx
	#define ZSTD_copyDCtx zfs_ZSTD_copyDCtx
	#define ZSTD_copyDDictParameters zfs_ZSTD_copyDDictParameters
	#define ZSTD_count zfs_ZSTD_count
	#define ZSTD_count_2segments zfs_ZSTD_count_2segments
	#define ZSTD_createCCtx zfs_ZSTD_createCCtx
	#define ZSTD_createCCtxParams zfs_ZSTD_createCCtxParams
	#define ZSTD_createCCtx_advanced zfs_ZSTD_createCCtx_advanced
	#define ZSTD_createCDict zfs_ZSTD_createCDict
	#define ZSTD_createCDict_advanced zfs_ZSTD_createCDict_advanced
	#define ZSTD_createCDict_byReference zfs_ZSTD_createCDict_byReference
	#define ZSTD_createCStream zfs_ZSTD_createCStream
	#define ZSTD_createCStream_advanced zfs_ZSTD_createCStream_advanced
	#define ZSTD_createDCtx zfs_ZSTD_createDCtx
	#define ZSTD_createDCtx_advanced zfs_ZSTD_createDCtx_advanced
	#define ZSTD_createDDict zfs_ZSTD_createDDict
	#define ZSTD_createDDict_advanced zfs_ZSTD_createDDict_advanced
	#define ZSTD_createDDict_byReference zfs_ZSTD_createDDict_byReference
	#define ZSTD_createDStream zfs_ZSTD_createDStream
	#define ZSTD_createDStream_advanced zfs_ZSTD_createDStream_advanced
	#define ZSTD_crossEntropyCost zfs_ZSTD_crossEntropyCost
	#define ZSTD_cycleLog zfs_ZSTD_cycleLog
	#define ZSTD_dParam_getBounds zfs_ZSTD_dParam_getBounds
	#define ZSTD_decodeLiteralsBlock zfs_ZSTD_decodeLiteralsBlock
	#define ZSTD_decodeSeqHeaders zfs_ZSTD_decodeSeqHeaders
	#define ZSTD_decodingBufferSize_min zfs_ZSTD_decodingBufferSize_min
	#define ZSTD_decompress zfs_ZSTD_decompress
	#define ZSTD_decompressBegin zfs_ZSTD_decompressBegin
	#define ZSTD_decompressBegin_usingDDict zfs_ZSTD_decompressBegin_usingDDict
	#define ZSTD_decompressBegin_usingDict zfs_ZSTD_decompressBegin_usingDict
	#define ZSTD_decompressBlock zfs_ZSTD_decompressBlock
	#define ZSTD_decompressBlock_internal zfs_ZSTD_decompressBlock_internal
	#define ZSTD_decompressBound zfs_ZSTD_decompressBound
	#define ZSTD_decompressContinue zfs_ZSTD_decompressContinue
	#define ZSTD_decompressContinueStream zfs_ZSTD_decompressContinueStream
	#define ZSTD_decompressDCtx zfs_ZSTD_decompressDCtx
	#define ZSTD_decompressMultiFrame zfs_ZSTD_decompressMultiFrame
	#define ZSTD_decompressStream zfs_ZSTD_decompressStream
	#define ZSTD_decompressStream_simpleArgs zfs_ZSTD_decompressStream_simpleArgs
	#define ZSTD_decompress_usingDDict zfs_ZSTD_decompress_usingDDict
	#define ZSTD_decompress_usingDict zfs_ZSTD_decompress_usingDict
	#define ZSTD_defaultCParameters zfs_ZSTD_defaultCParameters
	#define ZSTD_did_fieldSize zfs_ZSTD_did_fieldSize
	#define ZSTD_encodeSequences zfs_ZSTD_encodeSequences
	#define ZSTD_encodeSequences_default zfs_ZSTD_encodeSequences_default
	#define ZSTD_endStream zfs_ZSTD_endStream
	#define ZSTD_estimateCCtxSize zfs_ZSTD_estimateCCtxSize
	#define ZSTD_estimateCCtxSize_usingCCtxParams \
	zfs_ZSTD_estimateCCtxSize_usingCCtxParams
	#define ZSTD_estimateCCtxSize_usingCParams \
	zfs_ZSTD_estimateCCtxSize_usingCParams
	#define ZSTD_estimateCDictSize zfs_ZSTD_estimateCDictSize
	#define ZSTD_estimateCDictSize_advanced zfs_ZSTD_estimateCDictSize_advanced
	#define ZSTD_estimateCStreamSize zfs_ZSTD_estimateCStreamSize
	#define ZSTD_estimateCStreamSize_usingCCtxParams \
	zfs_ZSTD_estimateCStreamSize_usingCCtxParams
	#define ZSTD_estimateCStreamSize_usingCParams \
	zfs_ZSTD_estimateCStreamSize_usingCParams
	#define ZSTD_estimateDCtxSize zfs_ZSTD_estimateDCtxSize
	#define ZSTD_estimateDDictSize zfs_ZSTD_estimateDDictSize
	#define ZSTD_estimateDStreamSize zfs_ZSTD_estimateDStreamSize
	#define ZSTD_estimateDStreamSize_fromFrame \
	zfs_ZSTD_estimateDStreamSize_fromFrame
	#define ZSTD_fcs_fieldSize zfs_ZSTD_fcs_fieldSize
	#define ZSTD_fillDoubleHashTable zfs_ZSTD_fillDoubleHashTable
	#define ZSTD_fillHashTable zfs_ZSTD_fillHashTable
	#define ZSTD_findDecompressedSize zfs_ZSTD_findDecompressedSize
	#define ZSTD_findFrameCompressedSize zfs_ZSTD_findFrameCompressedSize
	#define ZSTD_findFrameSizeInfo zfs_ZSTD_findFrameSizeInfo
	#define ZSTD_flushStream zfs_ZSTD_flushStream
	#define ZSTD_frameHeaderSize zfs_ZSTD_frameHeaderSize
	#define ZSTD_free zfs_ZSTD_free
	#define ZSTD_freeCCtx zfs_ZSTD_freeCCtx
	#define ZSTD_freeCCtxParams zfs_ZSTD_freeCCtxParams
	#define ZSTD_freeCDict zfs_ZSTD_freeCDict
	#define ZSTD_freeCStream zfs_ZSTD_freeCStream
	#define ZSTD_freeDCtx zfs_ZSTD_freeDCtx
	#define ZSTD_freeDDict zfs_ZSTD_freeDDict
	#define ZSTD_freeDStream zfs_ZSTD_freeDStream
	#define ZSTD_fseBitCost zfs_ZSTD_fseBitCost
	#define ZSTD_getBlockSize zfs_ZSTD_getBlockSize
	#define ZSTD_getCParams zfs_ZSTD_getCParams
	#define ZSTD_getCParamsFromCCtxParams zfs_ZSTD_getCParamsFromCCtxParams
	#define ZSTD_getCParamsFromCDict zfs_ZSTD_getCParamsFromCDict
	#define ZSTD_getCParams_internal zfs_ZSTD_getCParams_internal
	#define ZSTD_getDDict zfs_ZSTD_getDDict
	#define ZSTD_getDecompressedSize zfs_ZSTD_getDecompressedSize
	#define ZSTD_getDictID_fromDDict zfs_ZSTD_getDictID_fromDDict
	#define ZSTD_getDictID_fromDict zfs_ZSTD_getDictID_fromDict
	#define ZSTD_getDictID_fromFrame zfs_ZSTD_getDictID_fromFrame
	#define ZSTD_getErrorCode zfs_ZSTD_getErrorCode
	#define ZSTD_getErrorName zfs_ZSTD_getErrorName
	#define ZSTD_getErrorString zfs_ZSTD_getErrorString
	#define ZSTD_getFrameContentSize zfs_ZSTD_getFrameContentSize
	#define ZSTD_getFrameHeader zfs_ZSTD_getFrameHeader
	#define ZSTD_getFrameHeader_advanced zfs_ZSTD_getFrameHeader_advanced
	#define ZSTD_getFrameProgression zfs_ZSTD_getFrameProgression
	#define ZSTD_getParams zfs_ZSTD_getParams
	#define ZSTD_getSeqStore zfs_ZSTD_getSeqStore
	#define ZSTD_getSequences zfs_ZSTD_getSequences
	#define ZSTD_getcBlockSize zfs_ZSTD_getcBlockSize
	#define ZSTD_hashPtr zfs_ZSTD_hashPtr
	#define ZSTD_initCDict_internal zfs_ZSTD_initCDict_internal
	#define ZSTD_initCStream zfs_ZSTD_initCStream
	#define ZSTD_initCStream_advanced zfs_ZSTD_initCStream_advanced
	#define ZSTD_initCStream_internal zfs_ZSTD_initCStream_internal
	#define ZSTD_initCStream_srcSize zfs_ZSTD_initCStream_srcSize
	#define ZSTD_initCStream_usingCDict zfs_ZSTD_initCStream_usingCDict
	#define ZSTD_initCStream_usingCDict_advanced \
	zfs_ZSTD_initCStream_usingCDict_advanced
	#define ZSTD_initCStream_usingDict zfs_ZSTD_initCStream_usingDict
	#define ZSTD_initDDict_internal zfs_ZSTD_initDDict_internal
	#define ZSTD_initDStream zfs_ZSTD_initDStream
	#define ZSTD_initDStream_usingDDict zfs_ZSTD_initDStream_usingDDict
	#define ZSTD_initDStream_usingDict zfs_ZSTD_initDStream_usingDict
	#define ZSTD_initFseState zfs_ZSTD_initFseState
	#define ZSTD_initStaticCCtx zfs_ZSTD_initStaticCCtx
	#define ZSTD_initStaticCDict zfs_ZSTD_initStaticCDict
	#define ZSTD_initStaticCStream zfs_ZSTD_initStaticCStream
	#define ZSTD_initStaticDCtx zfs_ZSTD_initStaticDCtx
	#define ZSTD_initStaticDDict zfs_ZSTD_initStaticDDict
	#define ZSTD_initStaticDStream zfs_ZSTD_initStaticDStream
	#define ZSTD_initStats_ultra zfs_ZSTD_initStats_ultra
	#define ZSTD_insertAndFindFirstIndex zfs_ZSTD_insertAndFindFirstIndex
	#define ZSTD_insertAndFindFirstIndexHash3 zfs_ZSTD_insertAndFindFirstIndexHash3
	#define ZSTD_insertAndFindFirstIndex_internal \
	zfs_ZSTD_insertAndFindFirstIndex_internal
	#define ZSTD_insertBlock zfs_ZSTD_insertBlock
	#define ZSTD_invalidateRepCodes zfs_ZSTD_invalidateRepCodes
	#define ZSTD_isFrame zfs_ZSTD_isFrame
	#define ZSTD_ldm_adjustParameters zfs_ZSTD_ldm_adjustParameters
	#define ZSTD_ldm_blockCompress zfs_ZSTD_ldm_blockCompress
	#define ZSTD_ldm_fillHashTable zfs_ZSTD_ldm_fillHashTable
	#define ZSTD_ldm_generateSequences zfs_ZSTD_ldm_generateSequences
	#define ZSTD_ldm_getMaxNbSeq zfs_ZSTD_ldm_getMaxNbSeq
	#define ZSTD_ldm_getTableSize zfs_ZSTD_ldm_getTableSize
	#define ZSTD_ldm_skipSequences zfs_ZSTD_ldm_skipSequences
	#define ZSTD_loadCEntropy zfs_ZSTD_loadCEntropy
	#define ZSTD_loadDEntropy zfs_ZSTD_loadDEntropy
	#define ZSTD_loadDictionaryContent zfs_ZSTD_loadDictionaryContent
	#define ZSTD_makeCCtxParamsFromCParams zfs_ZSTD_makeCCtxParamsFromCParams
	#define ZSTD_malloc zfs_ZSTD_malloc
	#define ZSTD_maxCLevel zfs_ZSTD_maxCLevel
	#define ZSTD_minCLevel zfs_ZSTD_minCLevel
	#define ZSTD_nextInputType zfs_ZSTD_nextInputType
	#define ZSTD_nextSrcSizeToDecompress zfs_ZSTD_nextSrcSizeToDecompress
	#define ZSTD_noCompressLiterals zfs_ZSTD_noCompressLiterals
	#define ZSTD_referenceExternalSequences zfs_ZSTD_referenceExternalSequences
	#define ZSTD_rescaleFreqs zfs_ZSTD_rescaleFreqs
	#define ZSTD_resetCCtx_internal zfs_ZSTD_resetCCtx_internal
	#define ZSTD_resetCCtx_usingCDict zfs_ZSTD_resetCCtx_usingCDict
	#define ZSTD_resetCStream zfs_ZSTD_resetCStream
	#define ZSTD_resetDStream zfs_ZSTD_resetDStream
	#define ZSTD_resetSeqStore zfs_ZSTD_resetSeqStore
	#define ZSTD_reset_compressedBlockState zfs_ZSTD_reset_compressedBlockState
	#define ZSTD_safecopy zfs_ZSTD_safecopy
	#define ZSTD_selectBlockCompressor zfs_ZSTD_selectBlockCompressor
	#define ZSTD_selectEncodingType zfs_ZSTD_selectEncodingType
	#define ZSTD_seqToCodes zfs_ZSTD_seqToCodes
	#define ZSTD_sizeof_CCtx zfs_ZSTD_sizeof_CCtx
	#define ZSTD_sizeof_CDict zfs_ZSTD_sizeof_CDict
	#define ZSTD_sizeof_CStream zfs_ZSTD_sizeof_CStream
	#define ZSTD_sizeof_DCtx zfs_ZSTD_sizeof_DCtx
	#define ZSTD_sizeof_DDict zfs_ZSTD_sizeof_DDict
	#define ZSTD_sizeof_DStream zfs_ZSTD_sizeof_DStream
	#define ZSTD_toFlushNow zfs_ZSTD_toFlushNow
	#define ZSTD_updateRep zfs_ZSTD_updateRep
	#define ZSTD_updateStats zfs_ZSTD_updateStats
	#define ZSTD_updateTree zfs_ZSTD_updateTree
	#define ZSTD_versionNumber zfs_ZSTD_versionNumber
	#define ZSTD_versionString zfs_ZSTD_versionString
	#define ZSTD_writeFrameHeader zfs_ZSTD_writeFrameHeader
	#define ZSTD_writeLastEmptyBlock zfs_ZSTD_writeLastEmptyBlock
	#define algoTime zfs_algoTime
	#define attachDictSizeCutoffs zfs_attachDictSizeCutoffs
	#define g_ctx zfs_g_ctx
	#define g_debuglevel zfs_g_debuglevel
	#define kInverseProbabilityLog256 zfs_kInverseProbabilityLog256
	#define repStartValue zfs_repStartValue
	#define FSE_isError zfs_FSE_isError
	#define HUF_isError zfs_HUF_isError
	diff --git a/sys/contrib/openzfs/module/zstd/zfs_zstd.c b/sys/contrib/openzfs/module/zstd/zfs_zstd.c
	index 69ebf252d1ba..78616c08ba72 100644
	--- a/sys/contrib/openzfs/module/zstd/zfs_zstd.c
	+++ b/sys/contrib/openzfs/module/zstd/zfs_zstd.c
	@@ -1,780 +1,780 @@
	/*
	* BSD 3-Clause New License (https://spdx.org/licenses/BSD-3-Clause.html)
	*
	* 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.
	*
	* 3. Neither the name of the copyright holder nor the names of its
	* contributors may be used to endorse or promote products derived from this
	* software without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT HOLDER 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.
	*/

	/*
	* Copyright (c) 2016-2018, Klara Inc.
	* Copyright (c) 2016-2018, Allan Jude
	* Copyright (c) 2018-2020, Sebastian Gottschall
	* Copyright (c) 2019-2020, Michael Niewöhner
	* Copyright (c) 2020, The FreeBSD Foundation [1]
	*
	* [1] Portions of this software were developed by Allan Jude
	* under sponsorship from the FreeBSD Foundation.
	*/

	#include <sys/param.h>
	#include <sys/sysmacros.h>
	#include <sys/zfs_context.h>
	#include <sys/zio_compress.h>
	#include <sys/spa.h>
	#include <sys/zstd/zstd.h>

	#define ZSTD_STATIC_LINKING_ONLY
	#include "lib/zstd.h"
	#include "lib/zstd_errors.h"

	kstat_t *zstd_ksp = NULL;

	typedef struct zstd_stats {
	kstat_named_t zstd_stat_alloc_fail;
	kstat_named_t zstd_stat_alloc_fallback;
	kstat_named_t zstd_stat_com_alloc_fail;
	kstat_named_t zstd_stat_dec_alloc_fail;
	kstat_named_t zstd_stat_com_inval;
	kstat_named_t zstd_stat_dec_inval;
	kstat_named_t zstd_stat_dec_header_inval;
	kstat_named_t zstd_stat_com_fail;
	kstat_named_t zstd_stat_dec_fail;
	kstat_named_t zstd_stat_buffers;
	kstat_named_t zstd_stat_size;
	} zstd_stats_t;

	static zstd_stats_t zstd_stats = {
	{ "alloc_fail", KSTAT_DATA_UINT64 },
	{ "alloc_fallback", KSTAT_DATA_UINT64 },
	{ "compress_alloc_fail", KSTAT_DATA_UINT64 },
	{ "decompress_alloc_fail", KSTAT_DATA_UINT64 },
	{ "compress_level_invalid", KSTAT_DATA_UINT64 },
	{ "decompress_level_invalid", KSTAT_DATA_UINT64 },
	{ "decompress_header_invalid", KSTAT_DATA_UINT64 },
	{ "compress_failed", KSTAT_DATA_UINT64 },
	{ "decompress_failed", KSTAT_DATA_UINT64 },
	{ "buffers", KSTAT_DATA_UINT64 },
	{ "size", KSTAT_DATA_UINT64 },
	};

	/* Enums describing the allocator type specified by kmem_type in zstd_kmem */
	enum zstd_kmem_type {
	ZSTD_KMEM_UNKNOWN = 0,
	/* Allocation type using kmem_vmalloc */
	ZSTD_KMEM_DEFAULT,
	/* Pool based allocation using mempool_alloc */
	ZSTD_KMEM_POOL,
	/* Reserved fallback memory for decompression only */
	ZSTD_KMEM_DCTX,
	ZSTD_KMEM_COUNT,
	};

	/* Structure for pooled memory objects */
	struct zstd_pool {
	void *mem;
	size_t size;
	kmutex_t barrier;
	hrtime_t timeout;
	};

	/* Global structure for handling memory allocations */
	struct zstd_kmem {
	enum zstd_kmem_type kmem_type;
	size_t kmem_size;
	struct zstd_pool *pool;
	};

	/* Fallback memory structure used for decompression only if memory runs out */
	struct zstd_fallback_mem {
	size_t mem_size;
	void *mem;
	kmutex_t barrier;
	};

	struct zstd_levelmap {
	int16_t zstd_level;
	enum zio_zstd_levels level;
	};

	/*
	* ZSTD memory handlers
	*
	* For decompression we use a different handler which also provides fallback
	* memory allocation in case memory runs out.
	*
	* The ZSTD handlers were split up for the most simplified implementation.
	*/
	static void zstd_alloc(void opaque, size_t size);
	static void zstd_dctx_alloc(void opaque, size_t size);
	static void zstd_free(void opaque, void ptr);

	/* Compression memory handler */
	static const ZSTD_customMem zstd_malloc = {
	zstd_alloc,
	zstd_free,
	NULL,
	};

	/* Decompression memory handler */
	static const ZSTD_customMem zstd_dctx_malloc = {
	zstd_dctx_alloc,
	zstd_free,
	NULL,
	};

	/* Level map for converting ZFS internal levels to ZSTD levels and vice versa */
	static struct zstd_levelmap zstd_levels[] = {
	{ZIO_ZSTD_LEVEL_1, ZIO_ZSTD_LEVEL_1},
	{ZIO_ZSTD_LEVEL_2, ZIO_ZSTD_LEVEL_2},
	{ZIO_ZSTD_LEVEL_3, ZIO_ZSTD_LEVEL_3},
	{ZIO_ZSTD_LEVEL_4, ZIO_ZSTD_LEVEL_4},
	{ZIO_ZSTD_LEVEL_5, ZIO_ZSTD_LEVEL_5},
	{ZIO_ZSTD_LEVEL_6, ZIO_ZSTD_LEVEL_6},
	{ZIO_ZSTD_LEVEL_7, ZIO_ZSTD_LEVEL_7},
	{ZIO_ZSTD_LEVEL_8, ZIO_ZSTD_LEVEL_8},
	{ZIO_ZSTD_LEVEL_9, ZIO_ZSTD_LEVEL_9},
	{ZIO_ZSTD_LEVEL_10, ZIO_ZSTD_LEVEL_10},
	{ZIO_ZSTD_LEVEL_11, ZIO_ZSTD_LEVEL_11},
	{ZIO_ZSTD_LEVEL_12, ZIO_ZSTD_LEVEL_12},
	{ZIO_ZSTD_LEVEL_13, ZIO_ZSTD_LEVEL_13},
	{ZIO_ZSTD_LEVEL_14, ZIO_ZSTD_LEVEL_14},
	{ZIO_ZSTD_LEVEL_15, ZIO_ZSTD_LEVEL_15},
	{ZIO_ZSTD_LEVEL_16, ZIO_ZSTD_LEVEL_16},
	{ZIO_ZSTD_LEVEL_17, ZIO_ZSTD_LEVEL_17},
	{ZIO_ZSTD_LEVEL_18, ZIO_ZSTD_LEVEL_18},
	{ZIO_ZSTD_LEVEL_19, ZIO_ZSTD_LEVEL_19},
	{-1, ZIO_ZSTD_LEVEL_FAST_1},
	{-2, ZIO_ZSTD_LEVEL_FAST_2},
	{-3, ZIO_ZSTD_LEVEL_FAST_3},
	{-4, ZIO_ZSTD_LEVEL_FAST_4},
	{-5, ZIO_ZSTD_LEVEL_FAST_5},
	{-6, ZIO_ZSTD_LEVEL_FAST_6},
	{-7, ZIO_ZSTD_LEVEL_FAST_7},
	{-8, ZIO_ZSTD_LEVEL_FAST_8},
	{-9, ZIO_ZSTD_LEVEL_FAST_9},
	{-10, ZIO_ZSTD_LEVEL_FAST_10},
	{-20, ZIO_ZSTD_LEVEL_FAST_20},
	{-30, ZIO_ZSTD_LEVEL_FAST_30},
	{-40, ZIO_ZSTD_LEVEL_FAST_40},
	{-50, ZIO_ZSTD_LEVEL_FAST_50},
	{-60, ZIO_ZSTD_LEVEL_FAST_60},
	{-70, ZIO_ZSTD_LEVEL_FAST_70},
	{-80, ZIO_ZSTD_LEVEL_FAST_80},
	{-90, ZIO_ZSTD_LEVEL_FAST_90},
	{-100, ZIO_ZSTD_LEVEL_FAST_100},
	{-500, ZIO_ZSTD_LEVEL_FAST_500},
	{-1000, ZIO_ZSTD_LEVEL_FAST_1000},
	};

	/*
	* This variable represents the maximum count of the pool based on the number
	* of CPUs plus some buffer. We default to cpu count * 4, see init_zstd.
	*/
	static int pool_count = 16;

	#define ZSTD_POOL_MAX pool_count
	#define ZSTD_POOL_TIMEOUT 60 * 2

	static struct zstd_fallback_mem zstd_dctx_fallback;
	static struct zstd_pool *zstd_mempool_cctx;
	static struct zstd_pool *zstd_mempool_dctx;


	static void
	zstd_mempool_reap(struct zstd_pool *zstd_mempool)
	{
	struct zstd_pool *pool;

	if (!zstd_mempool \|\| !ZSTDSTAT(zstd_stat_buffers)) {
	return;
	}

	/* free obsolete slots */
	for (int i = 0; i < ZSTD_POOL_MAX; i++) {
	pool = &zstd_mempool[i];
	if (pool->mem && mutex_tryenter(&pool->barrier)) {
	/* Free memory if unused object older than 2 minutes */
	if (pool->mem && gethrestime_sec() > pool->timeout) {
	vmem_free(pool->mem, pool->size);
	ZSTDSTAT_SUB(zstd_stat_buffers, 1);
	ZSTDSTAT_SUB(zstd_stat_size, pool->size);
	pool->mem = NULL;
	pool->size = 0;
	pool->timeout = 0;
	}
	mutex_exit(&pool->barrier);
	}
	}
	}

	/*
	* Try to get a cached allocated buffer from memory pool or allocate a new one
	* if necessary. If a object is older than 2 minutes and does not fit the
	* requested size, it will be released and a new cached entry will be allocated.
	* If other pooled objects are detected without being used for 2 minutes, they
	* will be released, too.
	*
	* The concept is that high frequency memory allocations of bigger objects are
	* expensive. So if a lot of work is going on, allocations will be kept for a
	* while and can be reused in that time frame.
	*
	* The scheduled release will be updated every time a object is reused.
	*/

	static void *
	zstd_mempool_alloc(struct zstd_pool *zstd_mempool, size_t size)
	{
	struct zstd_pool *pool;
	struct zstd_kmem *mem = NULL;

	if (!zstd_mempool) {
	return (NULL);
	}

	/* Seek for preallocated memory slot and free obsolete slots */
	for (int i = 0; i < ZSTD_POOL_MAX; i++) {
	pool = &zstd_mempool[i];
	/*
	- * This lock is simply a marker for a pool object beeing in use.
	+ * This lock is simply a marker for a pool object being in use.
	* If it's already hold, it will be skipped.
	*
	* We need to create it before checking it to avoid race
	* conditions caused by running in a threaded context.
	*
	* The lock is later released by zstd_mempool_free.
	*/
	if (mutex_tryenter(&pool->barrier)) {
	/*
	* Check if objects fits the size, if so we take it and
	* update the timestamp.
	*/
	if (pool->mem && size <= pool->size) {
	pool->timeout = gethrestime_sec() +
	ZSTD_POOL_TIMEOUT;
	mem = pool->mem;
	return (mem);
	}
	mutex_exit(&pool->barrier);
	}
	}

	/*
	* If no preallocated slot was found, try to fill in a new one.
	*
	* We run a similar algorithm twice here to avoid pool fragmentation.
	* The first one may generate holes in the list if objects get released.
	* We always make sure that these holes get filled instead of adding new
	* allocations constantly at the end.
	*/
	for (int i = 0; i < ZSTD_POOL_MAX; i++) {
	pool = &zstd_mempool[i];
	if (mutex_tryenter(&pool->barrier)) {
	/* Object is free, try to allocate new one */
	if (!pool->mem) {
	mem = vmem_alloc(size, KM_SLEEP);
	if (mem) {
	ZSTDSTAT_ADD(zstd_stat_buffers, 1);
	ZSTDSTAT_ADD(zstd_stat_size, size);
	pool->mem = mem;
	pool->size = size;
	/* Keep track for later release */
	mem->pool = pool;
	mem->kmem_type = ZSTD_KMEM_POOL;
	mem->kmem_size = size;
	}
	}

	if (size <= pool->size) {
	/* Update timestamp */
	pool->timeout = gethrestime_sec() +
	ZSTD_POOL_TIMEOUT;

	return (pool->mem);
	}

	mutex_exit(&pool->barrier);
	}
	}

	/*
	* If the pool is full or the allocation failed, try lazy allocation
	* instead.
	*/
	if (!mem) {
	mem = vmem_alloc(size, KM_NOSLEEP);
	if (mem) {
	mem->pool = NULL;
	mem->kmem_type = ZSTD_KMEM_DEFAULT;
	mem->kmem_size = size;
	}
	}

	return (mem);
	}

	/* Mark object as released by releasing the barrier mutex */
	static void
	zstd_mempool_free(struct zstd_kmem *z)
	{
	mutex_exit(&z->pool->barrier);
	}

	/* Convert ZFS internal enum to ZSTD level */
	static int
	zstd_enum_to_level(enum zio_zstd_levels level, int16_t *zstd_level)
	{
	if (level > 0 && level <= ZIO_ZSTD_LEVEL_19) {
	*zstd_level = zstd_levels[level - 1].zstd_level;
	return (0);
	}
	if (level >= ZIO_ZSTD_LEVEL_FAST_1 &&
	level <= ZIO_ZSTD_LEVEL_FAST_1000) {
	*zstd_level = zstd_levels[level - ZIO_ZSTD_LEVEL_FAST_1
	+ ZIO_ZSTD_LEVEL_19].zstd_level;
	return (0);
	}

	/* Invalid/unknown zfs compression enum - this should never happen. */
	return (1);
	}

	/* Compress block using zstd */
	size_t
	zfs_zstd_compress(void s_start, void d_start, size_t s_len, size_t d_len,
	int level)
	{
	size_t c_len;
	int16_t zstd_level;
	zfs_zstdhdr_t *hdr;
	ZSTD_CCtx *cctx;

	hdr = (zfs_zstdhdr_t *)d_start;

	/* Skip compression if the specified level is invalid */
	if (zstd_enum_to_level(level, &zstd_level)) {
	ZSTDSTAT_BUMP(zstd_stat_com_inval);
	return (s_len);
	}

	ASSERT3U(d_len, >=, sizeof (*hdr));
	ASSERT3U(d_len, <=, s_len);
	ASSERT3U(zstd_level, !=, 0);

	cctx = ZSTD_createCCtx_advanced(zstd_malloc);

	/*
	* Out of kernel memory, gently fall through - this will disable
	* compression in zio_compress_data
	*/
	if (!cctx) {
	ZSTDSTAT_BUMP(zstd_stat_com_alloc_fail);
	return (s_len);
	}

	/* Set the compression level */
	ZSTD_CCtx_setParameter(cctx, ZSTD_c_compressionLevel, zstd_level);

	/* Use the "magicless" zstd header which saves us 4 header bytes */
	ZSTD_CCtx_setParameter(cctx, ZSTD_c_format, ZSTD_f_zstd1_magicless);

	/*
	* Disable redundant checksum calculation and content size storage since
	* this is already done by ZFS itself.
	*/
	ZSTD_CCtx_setParameter(cctx, ZSTD_c_checksumFlag, 0);
	ZSTD_CCtx_setParameter(cctx, ZSTD_c_contentSizeFlag, 0);

	c_len = ZSTD_compress2(cctx,
	hdr->data,
	d_len - sizeof (*hdr),
	s_start, s_len);

	ZSTD_freeCCtx(cctx);

	/* Error in the compression routine, disable compression. */
	if (ZSTD_isError(c_len)) {
	/*
	* If we are aborting the compression because the saves are
	* too small, that is not a failure. Everything else is a
	* failure, so increment the compression failure counter.
	*/
	if (ZSTD_getErrorCode(c_len) != ZSTD_error_dstSize_tooSmall) {
	ZSTDSTAT_BUMP(zstd_stat_com_fail);
	}
	return (s_len);
	}

	/*
	* Encode the compressed buffer size at the start. We'll need this in
	* decompression to counter the effects of padding which might be added
	* to the compressed buffer and which, if unhandled, would confuse the
	* hell out of our decompression function.
	*/
	hdr->c_len = BE_32(c_len);

	/*
	* Check version for overflow.
	* The limit of 24 bits must not be exceeded. This allows a maximum
	* version 1677.72.15 which we don't expect to be ever reached.
	*/
	ASSERT3U(ZSTD_VERSION_NUMBER, <=, 0xFFFFFF);

	/*
	* Encode the compression level as well. We may need to know the
	* original compression level if compressed_arc is disabled, to match
	* the compression settings to write this block to the L2ARC.
	*
	* Encode the actual level, so if the enum changes in the future, we
	* will be compatible.
	*
	* The upper 24 bits store the ZSTD version to be able to provide
	* future compatibility, since new versions might enhance the
	* compression algorithm in a way, where the compressed data will
	* change.
	*
	* As soon as such incompatibility occurs, handling code needs to be
	* added, differentiating between the versions.
	*/
	hdr->version = ZSTD_VERSION_NUMBER;
	hdr->level = level;
	hdr->raw_version_level = BE_32(hdr->raw_version_level);

	return (c_len + sizeof (*hdr));
	}

	/* Decompress block using zstd and return its stored level */
	int
	zfs_zstd_decompress_level(void s_start, void d_start, size_t s_len,
	size_t d_len, uint8_t *level)
	{
	ZSTD_DCtx *dctx;
	size_t result;
	int16_t zstd_level;
	uint32_t c_len;
	const zfs_zstdhdr_t *hdr;
	zfs_zstdhdr_t hdr_copy;

	hdr = (const zfs_zstdhdr_t *)s_start;
	c_len = BE_32(hdr->c_len);

	/*
	* Make a copy instead of directly converting the header, since we must
	* not modify the original data that may be used again later.
	*/
	hdr_copy.raw_version_level = BE_32(hdr->raw_version_level);

	/*
	* NOTE: We ignore the ZSTD version for now. As soon as any
	- * incompatibility occurrs, it has to be handled accordingly.
	+ * incompatibility occurs, it has to be handled accordingly.
	* The version can be accessed via `hdr_copy.version`.
	*/

	/*
	* Convert and check the level
	* An invalid level is a strong indicator for data corruption! In such
	* case return an error so the upper layers can try to fix it.
	*/
	if (zstd_enum_to_level(hdr_copy.level, &zstd_level)) {
	ZSTDSTAT_BUMP(zstd_stat_dec_inval);
	return (1);
	}

	ASSERT3U(d_len, >=, s_len);
	ASSERT3U(hdr_copy.level, !=, ZIO_COMPLEVEL_INHERIT);

	/* Invalid compressed buffer size encoded at start */
	if (c_len + sizeof (*hdr) > s_len) {
	ZSTDSTAT_BUMP(zstd_stat_dec_header_inval);
	return (1);
	}

	dctx = ZSTD_createDCtx_advanced(zstd_dctx_malloc);
	if (!dctx) {
	ZSTDSTAT_BUMP(zstd_stat_dec_alloc_fail);
	return (1);
	}

	/* Set header type to "magicless" */
	ZSTD_DCtx_setParameter(dctx, ZSTD_d_format, ZSTD_f_zstd1_magicless);

	/* Decompress the data and release the context */
	result = ZSTD_decompressDCtx(dctx, d_start, d_len, hdr->data, c_len);
	ZSTD_freeDCtx(dctx);

	/*
	* Returns 0 on success (decompression function returned non-negative)
	* and non-zero on failure (decompression function returned negative.
	*/
	if (ZSTD_isError(result)) {
	ZSTDSTAT_BUMP(zstd_stat_dec_fail);
	return (1);
	}

	if (level) {
	*level = hdr_copy.level;
	}

	return (0);
	}

	/* Decompress datablock using zstd */
	int
	zfs_zstd_decompress(void s_start, void d_start, size_t s_len, size_t d_len,
	int level __maybe_unused)
	{

	return (zfs_zstd_decompress_level(s_start, d_start, s_len, d_len,
	NULL));
	}

	/* Allocator for zstd compression context using mempool_allocator */
	static void *
	zstd_alloc(void *opaque __maybe_unused, size_t size)
	{
	size_t nbytes = sizeof (struct zstd_kmem) + size;
	struct zstd_kmem *z = NULL;

	z = (struct zstd_kmem *)zstd_mempool_alloc(zstd_mempool_cctx, nbytes);

	if (!z) {
	ZSTDSTAT_BUMP(zstd_stat_alloc_fail);
	return (NULL);
	}

	return ((void*)z + (sizeof (struct zstd_kmem)));
	}

	/*
	* Allocator for zstd decompression context using mempool_allocator with
	* fallback to reserved memory if allocation fails
	*/
	static void *
	zstd_dctx_alloc(void *opaque __maybe_unused, size_t size)
	{
	size_t nbytes = sizeof (struct zstd_kmem) + size;
	struct zstd_kmem *z = NULL;
	enum zstd_kmem_type type = ZSTD_KMEM_DEFAULT;

	z = (struct zstd_kmem *)zstd_mempool_alloc(zstd_mempool_dctx, nbytes);
	if (!z) {
	/* Try harder, decompression shall not fail */
	z = vmem_alloc(nbytes, KM_SLEEP);
	if (z) {
	z->pool = NULL;
	}
	ZSTDSTAT_BUMP(zstd_stat_alloc_fail);
	} else {
	return ((void*)z + (sizeof (struct zstd_kmem)));
	}

	/* Fallback if everything fails */
	if (!z) {
	/*
	* Barrier since we only can handle it in a single thread. All
	* other following threads need to wait here until decompression
	* is completed. zstd_free will release this barrier later.
	*/
	mutex_enter(&zstd_dctx_fallback.barrier);

	z = zstd_dctx_fallback.mem;
	type = ZSTD_KMEM_DCTX;
	ZSTDSTAT_BUMP(zstd_stat_alloc_fallback);
	}

	/* Allocation should always be successful */
	if (!z) {
	return (NULL);
	}

	z->kmem_type = type;
	z->kmem_size = nbytes;

	return ((void*)z + (sizeof (struct zstd_kmem)));
	}

	/* Free allocated memory by its specific type */
	static void
	zstd_free(void opaque __maybe_unused, void ptr)
	{
	struct zstd_kmem *z = (ptr - sizeof (struct zstd_kmem));
	enum zstd_kmem_type type;

	ASSERT3U(z->kmem_type, <, ZSTD_KMEM_COUNT);
	ASSERT3U(z->kmem_type, >, ZSTD_KMEM_UNKNOWN);

	type = z->kmem_type;
	switch (type) {
	case ZSTD_KMEM_DEFAULT:
	vmem_free(z, z->kmem_size);
	break;
	case ZSTD_KMEM_POOL:
	zstd_mempool_free(z);
	break;
	case ZSTD_KMEM_DCTX:
	mutex_exit(&zstd_dctx_fallback.barrier);
	break;
	default:
	break;
	}
	}

	/* Allocate fallback memory to ensure safe decompression */
	static void __init
	create_fallback_mem(struct zstd_fallback_mem *mem, size_t size)
	{
	mem->mem_size = size;
	mem->mem = vmem_zalloc(mem->mem_size, KM_SLEEP);
	mutex_init(&mem->barrier, NULL, MUTEX_DEFAULT, NULL);
	}

	/* Initialize memory pool barrier mutexes */
	static void __init
	zstd_mempool_init(void)
	{
	zstd_mempool_cctx = (struct zstd_pool *)
	kmem_zalloc(ZSTD_POOL_MAX * sizeof (struct zstd_pool), KM_SLEEP);
	zstd_mempool_dctx = (struct zstd_pool *)
	kmem_zalloc(ZSTD_POOL_MAX * sizeof (struct zstd_pool), KM_SLEEP);

	for (int i = 0; i < ZSTD_POOL_MAX; i++) {
	mutex_init(&zstd_mempool_cctx[i].barrier, NULL,
	MUTEX_DEFAULT, NULL);
	mutex_init(&zstd_mempool_dctx[i].barrier, NULL,
	MUTEX_DEFAULT, NULL);
	}
	}

	/* Initialize zstd-related memory handling */
	static int __init
	zstd_meminit(void)
	{
	zstd_mempool_init();

	/*
	* Estimate the size of the fallback decompression context.
	* The expected size on x64 with current ZSTD should be about 160 KB.
	*/
	create_fallback_mem(&zstd_dctx_fallback,
	P2ROUNDUP(ZSTD_estimateDCtxSize() + sizeof (struct zstd_kmem),
	PAGESIZE));

	return (0);
	}

	/* Release object from pool and free memory */
	static void __exit
	release_pool(struct zstd_pool *pool)
	{
	mutex_destroy(&pool->barrier);
	vmem_free(pool->mem, pool->size);
	pool->mem = NULL;
	pool->size = 0;
	}

	/* Release memory pool objects */
	static void __exit
	zstd_mempool_deinit(void)
	{
	for (int i = 0; i < ZSTD_POOL_MAX; i++) {
	release_pool(&zstd_mempool_cctx[i]);
	release_pool(&zstd_mempool_dctx[i]);
	}

	kmem_free(zstd_mempool_dctx, ZSTD_POOL_MAX * sizeof (struct zstd_pool));
	kmem_free(zstd_mempool_cctx, ZSTD_POOL_MAX * sizeof (struct zstd_pool));
	zstd_mempool_dctx = NULL;
	zstd_mempool_cctx = NULL;
	}

	/* release unused memory from pool */

	void
	zfs_zstd_cache_reap_now(void)
	{

	/*
	* Short-circuit if there are no buffers to begin with.
	*/
	if (ZSTDSTAT(zstd_stat_buffers) == 0)
	return;

	/*
	* calling alloc with zero size seeks
	* and releases old unused objects
	*/
	zstd_mempool_reap(zstd_mempool_cctx);
	zstd_mempool_reap(zstd_mempool_dctx);
	}

	extern int __init
	zstd_init(void)
	{
	/* Set pool size by using maximum sane thread count * 4 */
	pool_count = (boot_ncpus * 4);
	zstd_meminit();

	/* Initialize kstat */
	zstd_ksp = kstat_create("zfs", 0, "zstd", "misc",
	KSTAT_TYPE_NAMED, sizeof (zstd_stats) / sizeof (kstat_named_t),
	KSTAT_FLAG_VIRTUAL);
	if (zstd_ksp != NULL) {
	zstd_ksp->ks_data = &zstd_stats;
	kstat_install(zstd_ksp);
	}

	return (0);
	}

	extern void __exit
	zstd_fini(void)
	{
	/* Deinitialize kstat */
	if (zstd_ksp != NULL) {
	kstat_delete(zstd_ksp);
	zstd_ksp = NULL;
	}

	/* Release fallback memory */
	vmem_free(zstd_dctx_fallback.mem, zstd_dctx_fallback.mem_size);
	mutex_destroy(&zstd_dctx_fallback.barrier);

	/* Deinit memory pool */
	zstd_mempool_deinit();
	}

	#if defined(_KERNEL)
	module_init(zstd_init);
	module_exit(zstd_fini);

	ZFS_MODULE_DESCRIPTION("ZSTD Compression for ZFS");
	ZFS_MODULE_LICENSE("Dual BSD/GPL");
	ZFS_MODULE_VERSION(ZSTD_VERSION_STRING);

	EXPORT_SYMBOL(zfs_zstd_compress);
	EXPORT_SYMBOL(zfs_zstd_decompress_level);
	EXPORT_SYMBOL(zfs_zstd_decompress);
	EXPORT_SYMBOL(zfs_zstd_cache_reap_now);
	#endif
	diff --git a/sys/contrib/openzfs/rpm/generic/zfs-dkms.spec.in b/sys/contrib/openzfs/rpm/generic/zfs-dkms.spec.in
	index 6cdc224fcd89..0a6935516c6e 100644
	--- a/sys/contrib/openzfs/rpm/generic/zfs-dkms.spec.in
	+++ b/sys/contrib/openzfs/rpm/generic/zfs-dkms.spec.in
	@@ -1,102 +1,102 @@
	%{?!packager: %define packager Brian Behlendorf <behlendorf1@llnl.gov>}

	%if ! 0%{?rhel}%{?fedora}%{?mageia}%{?suse_version}
	%define not_rpm 1
	%endif

	# Exclude input files from mangling
	%global __brp_mangle_shebangs_exclude_from ^/usr/src/.*$

	%define module @PACKAGE@
	%define mkconf scripts/dkms.mkconf

	Name: %{module}-dkms

	Version: @VERSION@
	Release: @RELEASE@%{?dist}
	Summary: Kernel module(s) (dkms)

	Group: System Environment/Kernel
	License: @ZFS_META_LICENSE@
	URL: https://github.com/openzfs/zfs
	Source0: %{module}-%{version}.tar.gz
	BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n)
	BuildArch: noarch

	Requires: dkms >= 2.2.0.3
	Requires: gcc, make, perl, diffutils
	%if 0%{?rhel}%{?fedora}%{?mageia}%{?suse_version}
	-Requires: kernel-devel
	+Requires: kernel-devel >= @ZFS_META_KVER_MIN@, kernel-devel <= @ZFS_META_KVER_MAX@.999
	Obsoletes: spl-dkms
	%endif
	Provides: %{module}-kmod = %{version}
	AutoReqProv: no

	%description
	This package contains the dkms ZFS kernel modules.

	%prep
	%setup -q -n %{module}-%{version}

	%build
	%{mkconf} -n %{module} -v %{version} -f dkms.conf

	%install
	if [ "$RPM_BUILD_ROOT" != "/" ]; then
	rm -rf $RPM_BUILD_ROOT
	fi
	mkdir -p $RPM_BUILD_ROOT/usr/src/
	cp -rf ${RPM_BUILD_DIR}/%{module}-%{version} $RPM_BUILD_ROOT/usr/src/

	%clean
	if [ "$RPM_BUILD_ROOT" != "/" ]; then
	rm -rf $RPM_BUILD_ROOT
	fi

	%files
	%defattr(-,root,root)
	/usr/src/%{module}-%{version}

	%post
	for POSTINST in /usr/lib/dkms/common.postinst; do
	if [ -f $POSTINST ]; then
	$POSTINST %{module} %{version}
	exit $?
	fi
	echo "WARNING: $POSTINST does not exist."
	done
	echo -e "ERROR: DKMS version is too old and %{module} was not"
	echo -e "built with legacy DKMS support."
	echo -e "You must either rebuild %{module} with legacy postinst"
	echo -e "support or upgrade DKMS to a more current version."
	exit 1

	%preun
	# Are we doing an upgrade?
	if [ "$1" = "1" -o "$1" = "upgrade" ] ; then
	# Yes we are. Are we upgrading to a new ZFS version?
	NEWEST_VER=$(dkms status zfs \| sed 's/,//g' \| sort -r -V \| awk '/installed/{print $2; exit}')
	if [ "$NEWEST_VER" != "%{version}" ] ; then
	# Yes, it's a new ZFS version. We'll uninstall the old module
	# later on in this script.
	true
	else
	# No, it's probably an upgrade of the same ZFS version
	# to a new distro (zfs-dkms-0.7.12.fc28->zfs-dkms-0.7.12.fc29).
	# Don't remove our modules, since the rebuild for the new
	# distro will automatically delete the old modules.
	exit 0
	fi
	fi

	# If we're here then we're doing an uninstall (not upgrade).
	CONFIG_H="/var/lib/dkms/%{module}/%{version}///%{module}_config.h"
	SPEC_META_ALIAS="@PACKAGE@-@VERSION@-@RELEASE@"
	DKMS_META_ALIAS=`cat $CONFIG_H 2>/dev/null \|
	awk -F'"' '/META_ALIAS\s+"/ { print $2; exit 0 }'`
	if [ "$SPEC_META_ALIAS" = "$DKMS_META_ALIAS" ]; then
	echo -e
	echo -e "Uninstall of %{module} module ($SPEC_META_ALIAS) beginning:"
	dkms remove -m %{module} -v %{version} --all %{!?not_rpm:--rpm_safe_upgrade}
	fi
	exit 0
	diff --git a/sys/contrib/openzfs/rpm/generic/zfs.spec.in b/sys/contrib/openzfs/rpm/generic/zfs.spec.in
	index f46a633db6b6..b1750942f53f 100644
	--- a/sys/contrib/openzfs/rpm/generic/zfs.spec.in
	+++ b/sys/contrib/openzfs/rpm/generic/zfs.spec.in
	@@ -1,533 +1,555 @@
	%global _sbindir /sbin
	%global _libdir /%{_lib}

	# Set the default udev directory based on distribution.
	%if %{undefined _udevdir}
	%if 0%{?fedora} >= 17 \|\| 0%{?rhel} >= 7 \|\| 0%{?centos} >= 7
	%global _udevdir %{_prefix}/lib/udev
	%else
	%global _udevdir /lib/udev
	%endif
	%endif

	# Set the default udevrule directory based on distribution.
	%if %{undefined _udevruledir}
	%if 0%{?fedora} >= 17 \|\| 0%{?rhel} >= 7 \|\| 0%{?centos} >= 7
	%global _udevruledir %{_prefix}/lib/udev/rules.d
	%else
	%global _udevruledir /lib/udev/rules.d
	%endif
	%endif

	# Set the default dracut directory based on distribution.
	%if %{undefined _dracutdir}
	%if 0%{?fedora} >= 17 \|\| 0%{?rhel} >= 7 \|\| 0%{?centos} >= 7
	%global _dracutdir %{_prefix}/lib/dracut
	%else
	%global _dracutdir %{_prefix}/share/dracut
	%endif
	%endif

	%if %{undefined _initconfdir}
	%global _initconfdir /etc/sysconfig
	%endif

	%if %{undefined _unitdir}
	%global _unitdir %{_prefix}/lib/systemd/system
	%endif

	%if %{undefined _presetdir}
	%global _presetdir %{_prefix}/lib/systemd/system-preset
	%endif

	%if %{undefined _modulesloaddir}
	%global _modulesloaddir %{_prefix}/lib/modules-load.d
	%endif

	%if %{undefined _systemdgeneratordir}
	%global _systemdgeneratordir %{_prefix}/lib/systemd/system-generators
	%endif

	%if %{undefined _pkgconfigdir}
	%global _pkgconfigdir %{_prefix}/%{_lib}/pkgconfig
	%endif

	%bcond_with debug
	%bcond_with debuginfo
	%bcond_with asan
	%bcond_with systemd
	%bcond_with pam

	# Generic enable switch for systemd
	%if %{with systemd}
	%define _systemd 1
	%endif

	# RHEL >= 7 comes with systemd
	%if 0%{?rhel} >= 7
	%define _systemd 1
	%endif

	# Fedora >= 15 comes with systemd, but only >= 18 has
	# the proper macros
	%if 0%{?fedora} >= 18
	%define _systemd 1
	%endif

	# opensuse >= 12.1 comes with systemd, but only >= 13.1
	# has the proper macros
	%if 0%{?suse_version} >= 1310
	%define _systemd 1
	%endif

	# When not specified default to distribution provided version. This
	# is normally Python 3, but for RHEL <= 7 only Python 2 is provided.
	%if %{undefined __use_python}
	%if 0%{?rhel} && 0%{?rhel} <= 7
	%define __python /usr/bin/python2
	%define __python_pkg_version 2
	%define __python_cffi_pkg python-cffi
	%define __python_setuptools_pkg python-setuptools
	%else
	%define __python /usr/bin/python3
	%define __python_pkg_version 3
	%define __python_cffi_pkg python3-cffi
	%define __python_setuptools_pkg python3-setuptools
	%endif
	%else
	%define __python %{__use_python}
	%define __python_pkg_version %{__use_python_pkg_version}
	%define __python_cffi_pkg python%{__python_pkg_version}-cffi
	%define __python_setuptools_pkg python%{__python_pkg_version}-setuptools
	%endif
	%define __python_sitelib %(%{__python} -Esc "from distutils.sysconfig import get_python_lib; print(get_python_lib())")

	# By default python-pyzfs is enabled, with the exception of
	# RHEL 6 which by default uses Python 2.6 which is too old.
	%if 0%{?rhel} == 6
	%bcond_with pyzfs
	%else
	%bcond_without pyzfs
	%endif

	Name: @PACKAGE@
	Version: @VERSION@
	Release: @RELEASE@%{?dist}
	Summary: Commands to control the kernel modules and libraries

	Group: System Environment/Kernel
	License: @ZFS_META_LICENSE@
	URL: https://github.com/openzfs/zfs
	Source0: %{name}-%{version}.tar.gz
	BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n)
	-Requires: libzpool4 = %{version}
	+Requires: libzpool5 = %{version}
	Requires: libnvpair3 = %{version}
	Requires: libuutil3 = %{version}
	-Requires: libzfs4 = %{version}
	+Requires: libzfs5 = %{version}
	Requires: %{name}-kmod = %{version}
	Provides: %{name}-kmod-common = %{version}
	Obsoletes: spl

	-# zfs-fuse provides the same commands and man pages that ZoL does. Renaming
	-# those on either side would conflict with all available documentation.
	+# zfs-fuse provides the same commands and man pages that OpenZFS does.
	+# Renaming those on either side would conflict with all available documentation.
	Conflicts: zfs-fuse

	%if 0%{?rhel}%{?fedora}%{?suse_version}
	BuildRequires: gcc, make
	BuildRequires: zlib-devel
	BuildRequires: libuuid-devel
	BuildRequires: libblkid-devel
	BuildRequires: libudev-devel
	BuildRequires: libattr-devel
	BuildRequires: openssl-devel
	%if 0%{?fedora} >= 28 \|\| 0%{?rhel} >= 8 \|\| 0%{?centos} >= 8
	BuildRequires: libtirpc-devel
	%endif
	Requires: openssl
	%if 0%{?_systemd}
	BuildRequires: systemd
	%endif
	%endif

	%if 0%{?_systemd}
	Requires(post): systemd
	Requires(preun): systemd
	Requires(postun): systemd
	%endif

	# The zpool iostat/status -c scripts call some utilities like lsblk and iostat
	Requires: util-linux
	Requires: sysstat

	%description
	This package contains the core ZFS command line utilities.

	-%package -n libzpool4
	+%package -n libzpool5
	Summary: Native ZFS pool library for Linux
	Group: System Environment/Kernel
	Obsoletes: libzpool2
	+Obsoletes: libzpool4

	-%description -n libzpool4
	+%description -n libzpool5
	This package contains the zpool library, which provides support
	for managing zpools

	-%post -n libzpool4 -p /sbin/ldconfig
	-%postun -n libzpool4 -p /sbin/ldconfig
	+%if %{defined ldconfig_scriptlets}
	+%ldconfig_scriptlets -n libzpool5
	+%else
	+%post -n libzpool5 -p /sbin/ldconfig
	+%postun -n libzpool5 -p /sbin/ldconfig
	+%endif

	%package -n libnvpair3
	Summary: Solaris name-value library for Linux
	Group: System Environment/Kernel
	Obsoletes: libnvpair1

	%description -n libnvpair3
	This package contains routines for packing and unpacking name-value
	pairs. This functionality is used to portably transport data across
	process boundaries, between kernel and user space, and can be used
	to write self describing data structures on disk.

	+%if %{defined ldconfig_scriptlets}
	+%ldconfig_scriptlets -n libnvpair3
	+%else
	%post -n libnvpair3 -p /sbin/ldconfig
	%postun -n libnvpair3 -p /sbin/ldconfig
	+%endif

	%package -n libuutil3
	Summary: Solaris userland utility library for Linux
	Group: System Environment/Kernel
	Obsoletes: libuutil1

	%description -n libuutil3
	This library provides a variety of compatibility functions for OpenZFS:
	* libspl: The Solaris Porting Layer userland library, which provides APIs
	that make it possible to run Solaris user code in a Linux environment
	with relatively minimal modification.
	* libavl: The Adelson-Velskii Landis balanced binary tree manipulation
	library.
	* libefi: The Extensible Firmware Interface library for GUID disk
	partitioning.
	* libshare: NFS, SMB, and iSCSI service integration for ZFS.

	+%if %{defined ldconfig_scriptlets}
	+%ldconfig_scriptlets -n libuutil3
	+%else
	%post -n libuutil3 -p /sbin/ldconfig
	%postun -n libuutil3 -p /sbin/ldconfig
	+%endif

	-%package -n libzfs4
	+# The library version is encoded in the package name. When updating the
	+# version information it is important to add an obsoletes line below for
	+# the previous version of the package.
	+%package -n libzfs5
	Summary: Native ZFS filesystem library for Linux
	Group: System Environment/Kernel
	Obsoletes: libzfs2
	+Obsoletes: libzfs4

	-%description -n libzfs4
	+%description -n libzfs5
	This package provides support for managing ZFS filesystems

	-%post -n libzfs4 -p /sbin/ldconfig
	-%postun -n libzfs4 -p /sbin/ldconfig
	+%if %{defined ldconfig_scriptlets}
	+%ldconfig_scriptlets -n libzfs5
	+%else
	+%post -n libzfs5 -p /sbin/ldconfig
	+%postun -n libzfs5 -p /sbin/ldconfig
	+%endif

	-%package -n libzfs4-devel
	+%package -n libzfs5-devel
	Summary: Development headers
	Group: System Environment/Kernel
	-Requires: libzfs4 = %{version}
	-Requires: libzpool4 = %{version}
	+Requires: libzfs5 = %{version}
	+Requires: libzpool5 = %{version}
	Requires: libnvpair3 = %{version}
	Requires: libuutil3 = %{version}
	-Provides: libzpool4-devel
	+Provides: libzpool5-devel
	Provides: libnvpair3-devel
	Provides: libuutil3-devel
	Obsoletes: zfs-devel
	Obsoletes: libzfs2-devel
	+Obsoletes: libzfs4-devel

	-%description -n libzfs4-devel
	+%description -n libzfs5-devel
	This package contains the header files needed for building additional
	applications against the ZFS libraries.

	%package test
	Summary: Test infrastructure
	Group: System Environment/Kernel
	Requires: %{name}%{?_isa} = %{version}-%{release}
	Requires: parted
	Requires: lsscsi
	Requires: mdadm
	Requires: bc
	Requires: ksh
	Requires: fio
	Requires: acl
	Requires: sudo
	Requires: sysstat
	Requires: libaio
	Requires: python%{__python_pkg_version}
	%if 0%{?rhel}%{?fedora}%{?suse_version}
	BuildRequires: libaio-devel
	%endif
	AutoReqProv: no

	%description test
	This package contains test infrastructure and support scripts for
	validating the file system.

	%package dracut
	Summary: Dracut module
	Group: System Environment/Kernel
	BuildArch: noarch
	Requires: %{name} >= %{version}
	Requires: dracut
	Requires: /usr/bin/awk
	Requires: grep

	%description dracut
	This package contains a dracut module used to construct an initramfs
	image which is ZFS aware.

	%if %{with pyzfs}
	%package -n python%{__python_pkg_version}-pyzfs
	Summary: Python %{python_version} wrapper for libzfs_core
	Group: Development/Languages/Python
	License: Apache-2.0
	BuildArch: noarch
	-Requires: libzfs4 = %{version}
	+Requires: libzfs5 = %{version}
	Requires: libnvpair3 = %{version}
	Requires: libffi
	Requires: python%{__python_pkg_version}
	Requires: %{__python_cffi_pkg}
	%if 0%{?rhel}%{?fedora}%{?suse_version}
	BuildRequires: python%{__python_pkg_version}-devel
	BuildRequires: %{__python_cffi_pkg}
	BuildRequires: %{__python_setuptools_pkg}
	BuildRequires: libffi-devel
	%endif

	%description -n python%{__python_pkg_version}-pyzfs
	This package provides a python wrapper for the libzfs_core C library.
	%endif

	%if 0%{?_initramfs}
	%package initramfs
	Summary: Initramfs module
	Group: System Environment/Kernel
	Requires: %{name}%{?_isa} = %{version}-%{release}
	Requires: %{name} = %{version}-%{release}
	Requires: initramfs-tools

	%description initramfs
	This package contains a initramfs module used to construct an initramfs
	image which is ZFS aware.
	%endif

	%prep
	%if %{with debug}
	%define debug --enable-debug
	%else
	%define debug --disable-debug
	%endif

	%if %{with debuginfo}
	%define debuginfo --enable-debuginfo
	%else
	%define debuginfo --disable-debuginfo
	%endif

	%if %{with asan}
	%define asan --enable-asan
	%else
	%define asan --disable-asan
	%endif

	%if 0%{?_systemd}
	%define systemd --enable-systemd --with-systemdunitdir=%{_unitdir} --with-systemdpresetdir=%{_presetdir} --with-systemdmodulesloaddir=%{_modulesloaddir} --with-systemdgeneratordir=%{_systemdgeneratordir} --disable-sysvinit
	%define systemd_svcs zfs-import-cache.service zfs-import-scan.service zfs-mount.service zfs-share.service zfs-zed.service zfs.target zfs-import.target zfs-volume-wait.service zfs-volumes.target
	%else
	%define systemd --enable-sysvinit --disable-systemd
	%endif

	%if %{with pyzfs}
	%define pyzfs --enable-pyzfs
	%else
	%define pyzfs --disable-pyzfs
	%endif

	%if %{with pam}
	%define pam --enable-pam
	%else
	%define pam --disable-pam
	%endif

	%setup -q

	%build
	%configure \
	--with-config=user \
	--with-udevdir=%{_udevdir} \
	--with-udevruledir=%{_udevruledir} \
	--with-dracutdir=%{_dracutdir} \
	--with-pamconfigsdir=%{_datadir}/pam-configs \
	--with-pammoduledir=%{_libdir}/security \
	--with-python=%{__python} \
	--with-pkgconfigdir=%{_pkgconfigdir} \
	--disable-static \
	%{debug} \
	%{debuginfo} \
	%{asan} \
	%{systemd} \
	%{pam} \
	%{pyzfs}
	make %{?_smp_mflags}

	%install
	%{__rm} -rf $RPM_BUILD_ROOT
	make install DESTDIR=%{?buildroot}
	find %{?buildroot}%{_libdir} -name '*.la' -exec rm -f {} \;
	%if 0%{!?__brp_mangle_shebangs:1}
	find %{?buildroot}%{_bindir} \
	$ -name arc_summary -or -name arcstat -or -name dbufstat $ \
	-exec %{__sed} -i 's\|^#!.*\|#!%{__python}\|' {} \;
	find %{?buildroot}%{_datadir} \
	$ -name test-runner.py -or -name zts-report.py $ \
	-exec %{__sed} -i 's\|^#!.*\|#!%{__python}\|' {} \;
	%endif

	%post
	%if 0%{?_systemd}
	%if 0%{?systemd_post:1}
	%systemd_post %{systemd_svcs}
	%else
	if [ "$1" = "1" -o "$1" = "install" ] ; then
	# Initial installation
	systemctl preset %{systemd_svcs} >/dev/null \|\| true
	fi
	%endif
	%else
	if [ -x /sbin/chkconfig ]; then
	/sbin/chkconfig --add zfs-import
	/sbin/chkconfig --add zfs-mount
	/sbin/chkconfig --add zfs-share
	/sbin/chkconfig --add zfs-zed
	fi
	%endif
	exit 0

	# On RHEL/CentOS 7 the static nodes aren't refreshed by default after
	# installing a package. This is the default behavior for Fedora.
	%posttrans
	%if 0%{?rhel} == 7 \|\| 0%{?centos} == 7
	systemctl restart kmod-static-nodes
	systemctl restart systemd-tmpfiles-setup-dev
	udevadm trigger
	%endif

	%preun
	%if 0%{?_systemd}
	%if 0%{?systemd_preun:1}
	%systemd_preun %{systemd_svcs}
	%else
	if [ "$1" = "0" -o "$1" = "remove" ] ; then
	# Package removal, not upgrade
	systemctl --no-reload disable %{systemd_svcs} >/dev/null \|\| true
	systemctl stop %{systemd_svcs} >/dev/null \|\| true
	fi
	%endif
	%else
	if [ "$1" = "0" -o "$1" = "remove" ] && [ -x /sbin/chkconfig ]; then
	/sbin/chkconfig --del zfs-import
	/sbin/chkconfig --del zfs-mount
	/sbin/chkconfig --del zfs-share
	/sbin/chkconfig --del zfs-zed
	fi
	%endif
	exit 0

	%postun
	%if 0%{?_systemd}
	%if 0%{?systemd_postun:1}
	%systemd_postun %{systemd_svcs}
	%else
	systemctl --system daemon-reload >/dev/null \|\| true
	%endif
	%endif

	%files
	# Core utilities
	%{_sbindir}/*
	%{_bindir}/raidz_test
	%{_sbindir}/zgenhostid
	%{_bindir}/zvol_wait
	# Optional Python 2/3 scripts
	%{_bindir}/arc_summary
	%{_bindir}/arcstat
	%{_bindir}/dbufstat
	# Man pages
	%{_mandir}/man1/*
	%{_mandir}/man5/*
	%{_mandir}/man8/*
	# Configuration files and scripts
	%{_libexecdir}/%{name}
	%{_udevdir}/vdev_id
	%{_udevdir}/zvol_id
	%{_udevdir}/rules.d/*
	%{_datadir}/%{name}/compatibility.d
	%if ! 0%{?_systemd} \|\| 0%{?_initramfs}
	# Files needed for sysvinit and initramfs-tools
	%{_sysconfdir}/%{name}/zfs-functions
	%config(noreplace) %{_initconfdir}/zfs
	%else
	%exclude %{_sysconfdir}/%{name}/zfs-functions
	%exclude %{_initconfdir}/zfs
	%endif
	%if 0%{?_systemd}
	%{_unitdir}/*
	%{_presetdir}/*
	%{_modulesloaddir}/*
	%{_systemdgeneratordir}/*
	%else
	%config(noreplace) %{_sysconfdir}/init.d/*
	%endif
	%config(noreplace) %{_sysconfdir}/%{name}/zed.d/*
	%config(noreplace) %{_sysconfdir}/%{name}/zpool.d/*
	%config(noreplace) %{_sysconfdir}/%{name}/vdev_id.conf.*.example
	%attr(440, root, root) %config(noreplace) %{_sysconfdir}/sudoers.d/*
	%if %{with pam}
	%{_libdir}/security/*
	%{_datadir}/pam-configs/*
	%endif

	-%files -n libzpool4
	+%files -n libzpool5
	%{_libdir}/libzpool.so.*

	%files -n libnvpair3
	%{_libdir}/libnvpair.so.*

	%files -n libuutil3
	%{_libdir}/libuutil.so.*

	-%files -n libzfs4
	+%files -n libzfs5
	%{_libdir}/libzfs.so.

	-%files -n libzfs4-devel
	+%files -n libzfs5-devel
	%{_pkgconfigdir}/libzfs.pc
	%{_pkgconfigdir}/libzfsbootenv.pc
	%{_pkgconfigdir}/libzfs_core.pc
	%{_libdir}/*.so
	%{_includedir}/*
	%doc AUTHORS COPYRIGHT LICENSE NOTICE README.md

	%files test
	%{_datadir}/%{name}/zfs-tests
	%{_datadir}/%{name}/test-runner
	%{_datadir}/%{name}/runfiles
	%{_datadir}/%{name}/*.sh

	%files dracut
	%doc contrib/dracut/README.dracut.markdown
	%{_dracutdir}/modules.d/*

	%if %{with pyzfs}
	%files -n python%{__python_pkg_version}-pyzfs
	%doc contrib/pyzfs/README
	%doc contrib/pyzfs/LICENSE
	%defattr(-,root,root,-)
	%{__python_sitelib}/libzfs_core/*
	%{__python_sitelib}/pyzfs*
	%endif

	%if 0%{?_initramfs}
	%files initramfs
	%doc contrib/initramfs/README.initramfs.markdown
	/usr/share/initramfs-tools/*
	%else
	# Since we're not building the initramfs package,
	# ignore those files.
	%exclude /usr/share/initramfs-tools
	%endif
	diff --git a/sys/contrib/openzfs/rpm/redhat/zfs-kmod.spec.in b/sys/contrib/openzfs/rpm/redhat/zfs-kmod.spec.in
	index 9bc756c5aae6..eb93aeeb2efe 100644
	--- a/sys/contrib/openzfs/rpm/redhat/zfs-kmod.spec.in
	+++ b/sys/contrib/openzfs/rpm/redhat/zfs-kmod.spec.in
	@@ -1,88 +1,89 @@
	%bcond_with debug
	%bcond_with debuginfo

	Name: @PACKAGE@-kmod
	Version: @VERSION@
	Release: @RELEASE@%{?dist}

	Summary: Kernel module(s)
	Group: System Environment/Kernel
	License: @ZFS_META_LICENSE@
	URL: https://github.com/openzfs/zfs
	BuildRequires: %kernel_module_package_buildreqs
	Source0: @PACKAGE@-%{version}.tar.gz
	BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n)

	# Additional dependency information for the kmod sub-package must be specified
	# by generating a preamble text file which kmodtool can append to the spec file.
	%(/bin/echo -e "\
	Requires: @PACKAGE@ = %{version}\n\
	-Conflicts: @PACKAGE@-dkms\n\n" > %{_sourcedir}/kmod-preamble\n\
	-Obsoletes: spl-kmod)
	+Conflicts: @PACKAGE@-dkms\n\
	+Obsoletes: kmod-spl\n\
	+Obsoletes: spl-kmod\n\n" > %{_sourcedir}/kmod-preamble)

	# LDFLAGS are not sanitized by arch/*/Makefile for these architectures.
	%ifarch ppc ppc64 ppc64le aarch64
	%global __global_ldflags %{nil}
	%endif

	%description
	This package contains the ZFS kernel modules.

	%define kmod_name @PACKAGE@

	%kernel_module_package -n %{kmod_name} -p %{_sourcedir}/kmod-preamble

	%define ksrc %{_usrsrc}/kernels/%{kverrel}
	%define kobj %{ksrc}

	%package -n kmod-%{kmod_name}-devel
	Summary: ZFS kernel module(s) devel common
	Group: System Environment/Kernel
	Provides: kmod-spl-devel = %{version}

	%description -n kmod-%{kmod_name}-devel
	This package provides the header files and objects to build kernel modules.

	%prep
	if ! [ -d "%{ksrc}" ]; then
	echo "Kernel build directory isn't set properly, cannot continue"
	exit 1
	fi

	%if %{with debug}
	%define debug --enable-debug
	%else
	%define debug --disable-debug
	%endif

	%if %{with debuginfo}
	%define debuginfo --enable-debuginfo
	%else
	%define debuginfo --disable-debuginfo
	%endif

	%setup -n %{kmod_name}-%{version}
	%build
	%configure \
	--with-config=kernel \
	--with-linux=%{ksrc} \
	--with-linux-obj=%{kobj} \
	%{debug} \
	%{debuginfo}
	make %{?_smp_mflags}

	%install
	make install \
	DESTDIR=${RPM_BUILD_ROOT} \
	INSTALL_MOD_DIR=extra/%{kmod_name}
	%{__rm} -f %{buildroot}/lib/modules/%{kverrel}/modules.*

	# find-debuginfo.sh only considers executables
	%{__chmod} u+x %{buildroot}/lib/modules/%{kverrel}/extra///*

	%clean
	rm -rf $RPM_BUILD_ROOT

	%files -n kmod-%{kmod_name}-devel
	%{_usrsrc}/%{kmod_name}-%{version}
	%{_usrsrc}/spl-%{version}
	diff --git a/sys/contrib/openzfs/scripts/kmodtool b/sys/contrib/openzfs/scripts/kmodtool
	index 240cde3106a7..35d54bad2ba5 100755
	--- a/sys/contrib/openzfs/scripts/kmodtool
	+++ b/sys/contrib/openzfs/scripts/kmodtool
	@@ -1,611 +1,623 @@
	#!/usr/bin/env bash

	# kmodtool - Helper script for building kernel module RPMs
	# Copyright (c) 2003-2012 Ville Skyttä <ville.skytta@iki.fi>,
	# Thorsten Leemhuis <fedora@leemhuis.info>
	# Nicolas Chauvet <kwizart@gmail.com>
	#
	# Permission is hereby granted, free of charge, to any person obtaining
	# a copy of this software and associated documentation files (the
	# "Software"), to deal in the Software without restriction, including
	# without limitation the rights to use, copy, modify, merge, publish,
	# distribute, sublicense, and/or sell copies of the Software, and to
	# permit persons to whom the Software is furnished to do so, subject to
	# the following conditions:
	#
	# The above copyright notice and this permission notice shall be
	# included in all copies or substantial portions of the Software.
	#
	# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
	# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
	# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
	# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

	shopt -s extglob

	myprog="kmodtool-${repo}"
	myver="0.12.1"

	kmodname=
	build_kernels="current"
	kernels_known_variants=
	kernel_versions=
	kernel_versions_to_build_for=
	prefix=
	filterfile=
	target=
	buildroot=

	error_out()
	{
	local errorlevel=${1}
	shift
	echo "Error: $@" >&2
	# the next line is not multi-line safe -- not needed yet
	echo "%global kmodtool_check echo \"kmodtool error: $@\"; exit ${errorlevel};"
	exit ${errorlevel}
	}

	print_rpmtemplate_header()
	{
	echo
	echo '%global kmodinstdir_prefix '${prefix}/lib/modules/
	echo '%global kmodinstdir_postfix '/extra/${kmodname}/
	echo '%global kernel_versions '${kernel_versions}
	echo
	}

	print_akmodtemplate ()
	{
	echo
	cat <<EOF

	%global akmod_install mkdir -p \$RPM_BUILD_ROOT/%{_usrsrc}/akmods/; \\\
	LANG=C rpmbuild --define "_sourcedir %{_sourcedir}" \\\
	--define "_srcrpmdir \$RPM_BUILD_ROOT/%{_usrsrc}/akmods/" \\\
	-bs --nodeps %{_specdir}/%{name}.spec ; \\\
	ln -s \$(ls \$RPM_BUILD_ROOT/%{_usrsrc}/akmods/) \$RPM_BUILD_ROOT/%{_usrsrc}/akmods/${kmodname}-kmod.latest

	%package -n akmod-${kmodname}
	Summary: Akmod package for ${kmodname} kernel module(s)
	Group: System Environment/Kernel
	Requires: kmodtool
	Requires: akmods
	%{?AkmodsBuildRequires:Requires: %{AkmodsBuildRequires}}
	# same requires and provides as a kmods package would have
	Requires: ${kmodname}-kmod-common >= %{?epoch:%{epoch}:}%{version}
	Provides: ${kmodname}-kmod = %{?epoch:%{epoch}:}%{version}-%{release}
	EOF

	if [[ ${obsolete_name} ]]; then
	echo "Provides: akmod-${obsolete_name} = ${obsolete_version}"
	echo "Obsoletes: akmod-${obsolete_name} < ${obsolete_version}"
	fi

	cat <<EOF

	%description -n akmod-${kmodname}
	This package provides the akmod package for the ${kmodname} kernel modules.

	%posttrans -n akmod-${kmodname}
	nohup ${prefix}/sbin/akmods --from-akmod-posttrans --akmod ${kmodname} &> /dev/null &

	%files -n akmod-${kmodname}
	%defattr(-,root,root,-)
	%{_usrsrc}/akmods/*

	EOF
	}

	print_akmodmeta ()
	{
	cat <<EOF
	%package -n kmod-${kmodname}
	Summary: Metapackage which tracks in ${kmodname} kernel module for newest kernel${dashvariant}
	Group: System Environment/Kernel

	Provides: ${kmodname}-kmod = %{?epoch:%{epoch}:}%{version}-%{release}
	Provides: kmod-${kmodname}-xen = %{?epoch:%{epoch}:}%{version}-%{release}
	Provides: kmod-${kmodname}-smp = %{?epoch:%{epoch}:}%{version}-%{release}
	Provides: kmod-${kmodname}-PAE = %{?epoch:%{epoch}:}%{version}-%{release}
	Requires: akmod-${kmodname} = %{?epoch:%{epoch}:}%{version}-%{release}
	EOF

	if [[ ${obsolete_name} ]]; then
	echo "Provides: kmod-${obsolete_name} = ${obsolete_version}"
	echo "Obsoletes: kmod-${obsolete_name} < ${obsolete_version}"
	fi
	cat <<EOF

	%description -n kmod-${kmodname}${dashvariant}
	This is a meta-package without payload which sole purpose is to require the
	${kmodname} kernel module(s) for the newest kernel${dashvariant},
	to make sure you get it together with a new kernel.

	%files -n kmod-${kmodname}${dashvariant}
	%defattr(644,root,root,755)
	EOF
	}

	print_rpmtemplate_per_kmodpkg ()
	{
	if [[ "${1}" == "--custom" ]]; then
	shift
	local customkernel=true
	elif [[ "${1}" == "--redhat" ]]; then
	# this is needed for akmods
	shift
	local redhatkernel=true
	fi

	local kernel_uname_r=${1}
	local kernel_variant="${2:+-${2}}"

	# Detect depmod install location
	local depmod_path=/sbin/depmod
	if [ ! -f ${depmod_path} ]; then
	depmod_path=/usr/sbin/depmod
	fi

	# first part
	cat <<EOF
	%package -n kmod-${kmodname}-${kernel_uname_r}
	Summary: ${kmodname} kernel module(s) for ${kernel_uname_r}
	Group: System Environment/Kernel
	Provides: kernel-modules-for-kernel = ${kernel_uname_r}
	Provides: kmod-${kmodname}-uname-r = ${kernel_uname_r}
	Provides: ${kmodname}-kmod = %{?epoch:%{epoch}:}%{version}-%{release}
	Requires: ${kmodname}-kmod-common >= %{?epoch:%{epoch}:}%{version}

	%if 0%{?rhel} == 6 \|\| 0%{?centos} == 6
	Requires(post): module-init-tools
	Requires(postun): module-init-tools
	%else
	Requires(post): kmod
	Requires(postun): kmod
	%endif
	EOF

	if [[ ${obsolete_name} ]]; then
	echo "Provides: kmod-${obsolete_name}-${kernel_uname_r} = ${obsolete_version}"
	echo "Obsoletes: kmod-${obsolete_name}-${kernel_uname_r} < ${obsolete_version}"
	fi

	# second part
	if [[ ! "${customkernel}" ]]; then
	cat <<EOF
	Requires: kernel-uname-r = ${kernel_uname_r}
	BuildRequires: kernel-devel-uname-r = ${kernel_uname_r}
	%{?KmodsRequires:Requires: %{KmodsRequires}-uname-r = ${kernel_uname_r}}
	%{?KmodsRequires:BuildRequires: %{KmodsRequires}-uname-r = ${kernel_uname_r}}
	%post -n kmod-${kmodname}-${kernel_uname_r}
	-${prefix}${depmod_path} -aeF /boot/System.map-${kernel_uname_r} ${kernel_uname_r} > /dev/null \|\| :
	+if [[ -f "/boot/System.map-${kernel_uname_r}" ]]; then
	+ ${prefix}${depmod_path} -aeF /boot/System.map-${kernel_uname_r} ${kernel_uname_r} > /dev/null \|\| :
	+elif [[ -f "/lib/modules/${kernel_uname_r}/System.map" ]]; then
	+ ${prefix}${depmod_path} -aeF /lib/modules/${kernel_uname_r}/System.map ${kernel_uname_r} > /dev/null \|\| :
	+else
	+ ${prefix}${depmod_path} -ae ${kernel_uname_r} &> /dev/null \|\| :
	+fi
	%postun -n kmod-${kmodname}-${kernel_uname_r}
	-${prefix}${depmod_path} -aF /boot/System.map-${kernel_uname_r} ${kernel_uname_r} &> /dev/null \|\| :
	+if [[ -f "/boot/System.map-${kernel_uname_r}" ]]; then
	+ ${prefix}${depmod_path} -aF /boot/System.map-${kernel_uname_r} ${kernel_uname_r} &> /dev/null \|\| :
	+elif [[ -f "/lib/modules/${kernel_uname_r}/System.map" ]]; then
	+ ${prefix}${depmod_path} -aF /lib/modules/${kernel_uname_r}/System.map ${kernel_uname_r} &> /dev/null \|\| :
	+else
	+ ${prefix}${depmod_path} -a ${kernel_uname_r} &> /dev/null \|\| :
	+fi

	EOF
	else
	cat <<EOF
	%post -n kmod-${kmodname}-${kernel_uname_r}
	[[ "\$(uname -r)" == "${kernel_uname_r}" ]] && ${prefix}${depmod_path} -a > /dev/null \|\| :
	%postun -n kmod-${kmodname}-${kernel_uname_r}
	[[ "\$(uname -r)" == "${kernel_uname_r}" ]] && ${prefix}${depmod_path} -a > /dev/null \|\| :

	EOF
	fi

	# third part
	cat <<EOF
	%description -n kmod-${kmodname}-${kernel_uname_r}
	This package provides the ${kmodname} kernel modules built for the Linux
	kernel ${kernel_uname_r} for the %{_target_cpu} family of processors.
	%files -n kmod-${kmodname}-${kernel_uname_r}
	%defattr(644,root,root,755)
	%dir $prefix/lib/modules/${kernel_uname_r}/extra
	${prefix}/lib/modules/${kernel_uname_r}/extra/${kmodname}/


	EOF
	}

	print_rpmtemplate_kmoddevelpkg ()
	{
	if [[ "${1}" == "--custom" ]]; then
	shift
	local customkernel=true
	elif [[ "${1}" == "--redhat" ]]; then
	shift
	local redhatkernel=true
	fi

	local kernel_uname_r=${1}

	cat <<EOF
	%package -n kmod-${kmodname}-devel
	Summary: ${kmodname} kernel module(s) devel common
	Group: System Environment/Kernel
	Provides: ${kmodname}-devel-kmod = %{?epoch:%{epoch}:}%{version}-%{release}
	EOF

	if [[ ! ${customkernel} ]] && [[ ! ${redhatkernel} ]]; then
	echo "Requires: kmod-${kmodname}-devel-${kernel_uname_r} >= %{?epoch:%{epoch}:}%{version}-%{release}"
	fi

	if [[ ${obsolete_name} ]]; then
	echo "Provides: kmod-${obsolete_name}-devel = ${obsolete_version}"
	echo "Obsoletes: kmod-${obsolete_name}-devel < ${obsolete_version}"
	fi

	cat <<EOF
	%description -n kmod-${kmodname}-devel
	This package provides the common header files to build kernel modules
	which depend on the ${kmodname} kernel module. It may optionally require
	the ${kmodname}-devel-<kernel> objects for the newest kernel.

	%files -n kmod-${kmodname}-devel
	%defattr(644,root,root,755)
	%{_usrsrc}/${kmodname}-%{version}
	EOF
	if [[ ${obsolete_name} ]]; then
	echo "%{_usrsrc}/${obsolete_name}-%{version}"
	fi

	for kernel in ${1}; do
	local kernel_uname_r=${kernel}
	echo "%exclude %{_usrsrc}/${kmodname}-%{version}/${kernel_uname_r}"
	if [[ ${obsolete_name} ]]; then
	echo "%exclude %{_usrsrc}/${obsolete_name}-%{version}/${kernel_uname_r}"
	fi
	done

	echo
	echo
	}

	print_rpmtemplate_per_kmoddevelpkg ()
	{
	if [[ "${1}" == "--custom" ]]; then
	shift
	local customkernel=true
	elif [[ "${1}" == "--redhat" ]]; then
	# this is needed for akmods
	shift
	local redhatkernel=true
	fi

	local kernel_uname_r=${1}
	local kernel_variant="${2:+-${2}}"

	# first part
	cat <<EOF
	%package -n kmod-${kmodname}-devel-${kernel_uname_r}
	Summary: ${kmodname} kernel module(s) devel for ${kernel_uname_r}
	Group: System Environment/Kernel
	Provides: kernel-objects-for-kernel = ${kernel_uname_r}
	Provides: ${kmodname}-devel-kmod = %{?epoch:%{epoch}:}%{version}-%{release}
	Provides: kmod-${kmodname}-devel-uname-r = ${kernel_uname_r}
	EOF

	if [[ ${obsolete_name} ]]; then
	echo "Provides: kmod-${obsolete_name}-devel-${kernel_uname_r} = ${obsolete_version}"
	echo "Obsoletes: kmod-${obsolete_name}-devel-${kernel_uname_r} < ${obsolete_version}"
	fi

	# second part
	if [[ ! "${customkernel}" ]]; then
	cat <<EOF
	Requires: kernel-devel-uname-r = ${kernel_uname_r}
	BuildRequires: kernel-devel-uname-r = ${kernel_uname_r}
	%{?KmodsDevelRequires:Requires: %{KmodsDevelRequires}-uname-r = ${kernel_uname_r}}
	%{?KmodsDevelRequires:BuildRequires: %{KmodsDevelRequires}-uname-r = ${kernel_uname_r}}
	EOF
	fi

	# third part
	cat <<EOF
	%description -n kmod-${kmodname}-devel-${kernel_uname_r}
	This package provides objects and symbols required to build kernel modules
	which depend on the ${kmodname} kernel modules built for the Linux
	kernel ${kernel_uname_r} for the %{_target_cpu} family of processors.
	%files -n kmod-${kmodname}-devel-${kernel_uname_r}
	%defattr(644,root,root,755)
	%{_usrsrc}/${kmodname}-%{version}/${kernel_uname_r}
	EOF
	if [[ ${obsolete_name} ]]; then
	echo "%{_usrsrc}/${obsolete_name}-%{version}/${kernel_uname_r}"
	fi
	}

	print_rpmtemplate_kmodmetapkg ()
	{
	local kernel_uname_r=${1}
	local kernel_variant="${2:+-${2}}"

	cat <<EOF
	%package -n kmod-${kmodname}${kernel_variant}
	Summary: Metapackage which tracks in ${kmodname} kernel module for newest kernel${kernel_variant}
	Group: System Environment/Kernel

	Provides: ${kmodname}-kmod = %{?epoch:%{epoch}:}%{version}-%{release}
	Requires: kmod-${kmodname}-${kernel_uname_r} >= %{?epoch:%{epoch}:}%{version}-%{release}
	%{?KmodsMetaRequires:Requires: %{?KmodsMetaRequires}}
	EOF

	if [[ ${obsolete_name} ]]; then
	echo "Provides: kmod-${obsolete_name}${kernel_variant} = ${obsolete_version}"
	echo "Obsoletes: kmod-${obsolete_name}${kernel_variant} < ${obsolete_version}"
	fi

	cat <<EOF

	%description -n kmod-${kmodname}${kernel_variant}
	This is a meta-package without payload which sole purpose is to require the
	${kmodname} kernel module(s) for the newest kernel${kernel_variant}.
	to make sure you get it together with a new kernel.

	%files -n kmod-${kmodname}${kernel_variant}
	%defattr(644,root,root,755)


	EOF
	}

	print_customrpmtemplate ()
	{
	for kernel in ${1}
	do
	if [[ -e "${buildroot}/usr/src/kernels/${kernel}" ]] ; then
	# this looks like a Fedora/RH kernel -- print a normal template (which includes the proper BR) and be happy :)
	kernel_versions="${kernel_versions}${kernel}___${buildroot}%{_usrsrc}/kernels/${kernel} "

	# parse kernel versions string and print template
	local kernel_verrelarch=${kernel%%${kernels_known_variants}}
	print_rpmtemplate_per_kmodpkg --redhat ${kernel} ${kernel##${kernel_verrelarch}}

	# create development package
	if [[ "${devel}" ]]; then
	# create devel package including common headers
	print_rpmtemplate_kmoddevelpkg --redhat ${kernel} ${kernel##${kernel_verrelarch}}

	# create devel package
	print_rpmtemplate_per_kmoddevelpkg --redhat ${kernel} ${kernel##${kernel_verrelarch}}
	fi
	elif [[ -e ${prefix}/lib/modules/"${kernel}"/build/Makefile ]] ; then
	# likely a user-build-kernel with available buildfiles
	# fixme: we should check if uname from Makefile is the same as ${kernel}

	kernel_versions="${kernel_versions}${kernel}___${prefix}/lib/modules/${kernel}/build/ "
	print_rpmtemplate_per_kmodpkg --custom "${kernel}"

	# create development package
	if [[ "${devel}" ]]; then
	# create devel package including common headers
	print_rpmtemplate_kmoddevelpkg --custom "${kernel}"

	# create devel package
	print_rpmtemplate_per_kmoddevelpkg --custom "${kernel}"
	fi
	else
	error_out 2 "Don't know how to handle ${kernel} -- ${prefix}/lib/modules/${kernel}/build/Makefile not found"
	fi
	done

	# well, it's no header anymore, but who cares ;-)
	print_rpmtemplate_header
	}


	print_rpmtemplate ()
	{
	# create kernel_versions var
	for kernel_version in ${kernel_versions_to_build_for}
	do
	kernel_versions="${kernel_versions}${kernel_version}___%{_usrsrc}/kernels/${kernel_version} "
	done

	# and print it and some other required stuff as macro
	print_rpmtemplate_header

	# now print the packages
	for kernel in ${kernel_versions_to_build_for} ; do

	local kernel_verrelarch=${kernel%%${kernels_known_variants}}

	# create metapackage
	print_rpmtemplate_kmodmetapkg ${kernel} ${kernel##${kernel_verrelarch}}

	# create package
	print_rpmtemplate_per_kmodpkg ${kernel} ${kernel##${kernel_verrelarch}}

	if [[ "${devel}" ]]; then
	# create devel package including common headers
	print_rpmtemplate_kmoddevelpkg ${kernel} ${kernel##${kernel_verrelarch}}

	# create devel package
	print_rpmtemplate_per_kmoddevelpkg ${kernel} ${kernel##${kernel_verrelarch}}
	fi
	done
	}

	myprog_help ()
	{
	echo "Usage: $(basename ${0}) [OPTIONS]"
	echo $'\n'"Creates a template to be used during kmod building"
	echo $'\n'"Available options:"
	echo " --filterfile <file> -- filter the results with grep --file <file>"
	echo " --for-kernels <list> -- created templates only for these kernels"
	echo " --kmodname <file> -- name of the kmod (required)"
	echo " --devel -- make kmod-devel package"
	echo " --noakmod -- no akmod package"
	echo " --repo <name> -- use buildsys-build-<name>-kerneldevpkgs"
	echo " --target <arch> -- target-arch (required)"
	echo " --buildroot <dir> -- Build root (place to look for build files)"
	}

	while [ "${1}" ] ; do
	case "${1}" in
	--filterfile)
	shift
	if [[ ! "${1}" ]] ; then
	error_out 2 "Please provide path to a filter-file together with --filterfile" >&2
	elif [[ ! -e "${1}" ]]; then
	error_out 2 "Filterfile ${1} not found" >&2
	fi
	filterfile="${1}"
	shift
	;;
	--kmodname)
	shift
	if [[ ! "${1}" ]] ; then
	error_out 2 "Please provide the name of the kmod together with --kmodname" >&2
	fi
	# strip pending -kmod
	kmodname="${1%%-kmod}"
	shift
	;;
	--devel)
	shift
	devel="true"
	;;
	--prefix)
	shift
	if [[ ! "${1}" ]] ; then
	error_out 2 "Please provide a prefix with --prefix" >&2
	fi
	prefix="${1}"
	shift
	;;
	--repo)
	shift
	if [[ ! "${1}" ]] ; then
	error_out 2 "Please provide the name of the repo together with --repo" >&2
	fi
	repo=${1}
	shift
	;;
	--for-kernels)
	shift
	if [[ ! "${1}" ]] ; then
	error_out 2 "Please provide the name of the kmod together with --kmodname" >&2
	fi
	for_kernels="${1}"
	shift
	;;
	--noakmod)
	shift
	noakmod="true"
	;;
	--obsolete-name)
	shift
	if [[ ! "${1}" ]] ; then
	error_out 2 "Please provide the name of the kmod to obsolete together with --obsolete-name" >&2
	fi
	obsolete_name="${1}"
	shift
	;;
	--obsolete-version)
	shift
	if [[ ! "${1}" ]] ; then
	error_out 2 "Please provide the version of the kmod to obsolete together with --obsolete-version" >&2
	fi
	obsolete_version="${1}"
	shift
	;;
	--target)
	shift
	target="${1}"
	shift
	;;
	--akmod)
	shift
	build_kernels="akmod"
	;;
	--newest)
	shift
	build_kernels="newest"
	;;
	--current)
	shift
	build_kernels="current"
	;;
	--buildroot)
	shift
	buildroot="${1}"
	shift
	;;
	--help)
	myprog_help
	exit 0
	;;
	--version)
	echo "${myprog} ${myver}"
	exit 0
	;;
	*)
	echo "Error: Unknown option '${1}'." >&2
	usage >&2
	exit 2
	;;
	esac
	done

	if [[ -e ./kmodtool-kernel-variants ]]; then
	kernels_known_variants="$(cat ./kmodtool-kernel-variants)"
	elif [[ -e /usr/share/kmodtool/kernel-variants ]] ; then
	kernels_known_variants="$(cat /usr/share/kmodtool/kernel-variants)"
	else
	kernels_known_variants="@(smp?(-debug)\|PAE?(-debug)\|debug\|kdump\|xen\|kirkwood\|highbank\|imx\|omap\|tegra)"
	fi

	# general sanity checks
	if [[ ! "${target}" ]]; then
	error_out 2 "please pass target arch with --target"
	elif [[ ! "${kmodname}" ]]; then
	error_out 2 "please pass kmodname with --kmodname"
	elif [[ ! "${kernels_known_variants}" ]] ; then
	error_out 2 "could not determine known variants"
	elif ( [[ "${obsolete_name}" ]] && [[ ! "${obsolete_version}" ]] ) \|\| ( [[ ! "${obsolete_name}" ]] && [[ "${obsolete_version}" ]] ) ; then
	error_out 2 "you need to provide both --obsolete-name and --obsolete-version"
	fi

	# go
	if [[ "${for_kernels}" ]]; then
	# this is easy:
	print_customrpmtemplate "${for_kernels}"
	elif [[ "${build_kernels}" == "akmod" ]]; then
	# do only a akmod package
	print_akmodtemplate
	print_akmodmeta
	else
	# seems we are on out own to decide for which kernels to build

	# we need more sanity checks in this case
	if [[ ! "${repo}" ]]; then
	error_out 2 "please provide repo name with --repo"
	elif ! $(which buildsys-build-${repo}-kerneldevpkgs &> /dev/null) ; then
	error_out 2 "buildsys-build-${repo}-kerneldevpkgs not found"
	fi

	# call buildsys-build-${repo}-kerneldevpkgs to get the list of kernels
	cmdoptions="--target ${target}"

	# filterfile to filter list of kernels?
	if [[ "${filterfile}" ]] ; then
	cmdoptions="${cmdoptions} --filterfile ${filterfile}"
	fi

	kernel_versions_to_build_for="$(buildsys-build-${repo}-kerneldevpkgs --${build_kernels} ${cmdoptions})"
	returncode=$?
	if (( ${returncode} != 0 )); then
	error_out 2 "buildsys-build-${repo}-kerneldevpkgs failed: $(buildsys-build-${repo}-kerneldevpkgs --${build_kernels} ${cmdoptions})"
	fi

	if [[ "${build_kernels}" == "current" ]] && [[ ! "${noakmod}" ]]; then
	print_akmodtemplate
	fi

	print_rpmtemplate
	fi
	diff --git a/sys/contrib/openzfs/scripts/zimport.sh b/sys/contrib/openzfs/scripts/zimport.sh
	index 56dfbadae47b..6c3b415ffcd1 100755
	--- a/sys/contrib/openzfs/scripts/zimport.sh
	+++ b/sys/contrib/openzfs/scripts/zimport.sh
	@@ -1,517 +1,517 @@
	#!/usr/bin/env bash
	#
	# Verify that an assortment of known good reference pools can be imported
	-# using different versions of the ZoL code.
	+# using different versions of OpenZFS code.
	#
	# By default references pools for the major ZFS implementation will be
	-# checked against the most recent ZoL tags and the master development branch.
	+# checked against the most recent OpenZFS tags and the master development branch.
	# Alternate tags or branches may be verified with the '-s <src-tag> option.
	# Passing the keyword "installed" will instruct the script to test whatever
	# version is installed.
	#
	# Preferentially a reference pool is used for all tests. However, if one
	# does not exist and the pool-tag matches one of the src-tags then a new
	# reference pool will be created using binaries from that source build.
	# This is particularly useful when you need to test your changes before
	# opening a pull request. The keyword 'all' can be used as short hand
	# refer to all available reference pools.
	#
	# New reference pools may be added by placing a bzip2 compressed tarball
	# of the pool in the scripts/zfs-images directory and then passing
	# the -p <pool-tag> option. To increase the test coverage reference pools
	# should be collected for all the major ZFS implementations. Having these
	# pools easily available is also helpful to the developers.
	#
	# Care should be taken to run these tests with a kernel supported by all
	# the listed tags. Otherwise build failure will cause false positives.
	#
	#
	# EXAMPLES:
	#
	# The following example will verify the zfs-0.6.2 tag, the master branch,
	# and the installed zfs version can correctly import the listed pools.
	# Note there is no reference pool available for master and installed but
	# because binaries are available one is automatically constructed. The
	# working directory is also preserved between runs (-k) preventing the
	# need to rebuild from source for multiple runs.
	#
	# zimport.sh -k -f /var/tmp/zimport \
	# -s "zfs-0.6.2 master installed" \
	# -p "zevo-1.1.1 zol-0.6.2 zol-0.6.2-173 master installed"
	#
	# ------------------------ OpenZFS Source Versions ----------------
	# zfs-0.6.2 master 0.6.2-175_g36eb554
	# -----------------------------------------------------------------
	# Clone ZFS Local Local Skip
	# Build ZFS Pass Pass Skip
	# -----------------------------------------------------------------
	# zevo-1.1.1 Pass Pass Pass
	# zol-0.6.2 Pass Pass Pass
	# zol-0.6.2-173 Fail Pass Pass
	# master Pass Pass Pass
	# installed Pass Pass Pass
	#

	BASE_DIR=$(dirname "$0")
	SCRIPT_COMMON=common.sh
	if [ -f "${BASE_DIR}/${SCRIPT_COMMON}" ]; then
	. "${BASE_DIR}/${SCRIPT_COMMON}"
	else
	echo "Missing helper script ${SCRIPT_COMMON}" && exit 1
	fi

	PROG=zimport.sh
	SRC_TAGS="zfs-0.6.5.11 master"
	POOL_TAGS="all master"
	POOL_CREATE_OPTIONS=
	TEST_DIR=$(mktemp -u -d -p /var/tmp zimport.XXXXXXXX)
	KEEP="no"
	VERBOSE="no"
	COLOR="yes"
	REPO="https://github.com/openzfs"
	IMAGES_DIR="$SCRIPTDIR/zfs-images/"
	IMAGES_TAR="https://github.com/openzfs/zfs-images/tarball/master"
	ERROR=0

	CONFIG_LOG="configure.log"
	CONFIG_OPTIONS=${CONFIG_OPTIONS:-""}
	MAKE_LOG="make.log"
	MAKE_OPTIONS=${MAKE_OPTIONS:-"-s -j$(nproc)"}

	COLOR_GREEN="\033[0;32m"
	COLOR_RED="\033[0;31m"
	COLOR_BROWN="\033[0;33m"
	COLOR_RESET="\033[0m"

	usage() {
	cat << EOF
	USAGE:
	zimport.sh [hvl] [-r repo] [-s src-tag] [-i pool-dir] [-p pool-tag]
	[-f path] [-o options]

	DESCRIPTION:
	ZPOOL import verification tests

	OPTIONS:
	-h Show this message
	-v Verbose
	-c No color
	-k Keep temporary directory
	-r <repo> Source repository ($REPO)
	- -s <src-tag>... Verify ZoL versions with the listed tags
	+ -s <src-tag>... Verify OpenZFS versions with the listed tags
	-i <pool-dir> Pool image directory
	-p <pool-tag>... Verify pools created with the listed tags
	-f <path> Temporary directory to use
	-o <options> Additional options to pass to 'zpool create'

	EOF
	}

	while getopts 'hvckr:s:i:p:f:o:?' OPTION; do
	case $OPTION in
	h)
	usage
	exit 1
	;;
	v)
	VERBOSE="yes"
	;;
	c)
	COLOR="no"
	;;
	k)
	KEEP="yes"
	;;
	r)
	REPO="$OPTARG"
	;;
	s)
	SRC_TAGS="$OPTARG"
	;;
	i)
	IMAGES_DIR="$OPTARG"
	;;
	p)
	POOL_TAGS="$OPTARG"
	;;
	f)
	TEST_DIR="$OPTARG"
	;;
	o)
	POOL_CREATE_OPTIONS="$OPTARG"
	;;
	?)
	usage
	exit 1
	;;
	esac
	done

	#
	# Verify the module start is not loaded
	#
	if lsmod \| grep zfs >/dev/null; then
	echo "ZFS modules must be unloaded"
	exit 1
	fi

	#
	# Create a random directory tree of files and sub-directories to
	# to act as a copy source for the various regression tests.
	#
	populate() {
	local ROOT=$1
	local MAX_DIR_SIZE=$2
	local MAX_FILE_SIZE=$3

	# shellcheck disable=SC2086
	mkdir -p $ROOT/{a,b,c,d,e,f,g}/{h,i}
	DIRS=$(find "$ROOT")

	for DIR in $DIRS; do
	COUNT=$((RANDOM % MAX_DIR_SIZE))

	# shellcheck disable=SC2034
	for i in $(seq $COUNT); do
	FILE=$(mktemp -p "$DIR")
	SIZE=$((RANDOM % MAX_FILE_SIZE))
	dd if=/dev/urandom of="$FILE" bs=1k \
	count="$SIZE" &>/dev/null
	done
	done

	return 0
	}

	SRC_DIR=$(mktemp -d -p /var/tmp/ zfs.src.XXXXXXXX)
	trap 'rm -Rf "$SRC_DIR"' INT TERM EXIT
	populate "$SRC_DIR" 10 100

	SRC_DIR="$TEST_DIR/src"
	SRC_DIR_ZFS="$SRC_DIR/zfs"

	if [ "$COLOR" = "no" ]; then
	COLOR_GREEN=""
	COLOR_BROWN=""
	COLOR_RED=""
	COLOR_RESET=""
	fi

	pass_nonewline() {
	echo -n -e "${COLOR_GREEN}Pass${COLOR_RESET}\t\t"
	}

	skip_nonewline() {
	echo -n -e "${COLOR_BROWN}Skip${COLOR_RESET}\t\t"
	}

	fail_nonewline() {
	echo -n -e "${COLOR_RED}Fail${COLOR_RESET}\t\t"
	}

	#
	# Log a failure message, cleanup, and return an error.
	#
	fail() {
	echo -e "$PROG: $1" >&2
	$ZFS_SH -u >/dev/null 2>&1
	exit 1
	}

	#
	# Set several helper variables which are derived from a source tag.
	#
	# ZFS_TAG - The passed zfs-x.y.z tag
	# ZFS_DIR - The zfs directory name
	# ZFS_URL - The zfs github URL to fetch the tarball
	#
	src_set_vars() {
	local TAG=$1

	ZFS_TAG="$TAG"
	ZFS_DIR="$SRC_DIR_ZFS/$ZFS_TAG"
	ZFS_URL="$REPO/zfs/tarball/$ZFS_TAG"

	if [ "$TAG" = "installed" ]; then
	ZPOOL_CMD=$(command -v zpool)
	ZFS_CMD=$(command -v zfs)
	ZFS_SH="/usr/share/zfs/zfs.sh"
	else
	ZPOOL_CMD="./cmd/zpool/zpool"
	ZFS_CMD="./cmd/zfs/zfs"
	ZFS_SH="./scripts/zfs.sh"
	fi
	}

	#
	# Set several helper variables which are derived from a pool name such
	# as zol-0.6.x, zevo-1.1.1, etc. These refer to example pools from various
	# ZFS implementations which are used to verify compatibility.
	#
	# POOL_TAG - The example pools name in scripts/zfs-images/.
	# POOL_BZIP - The full path to the example bzip2 compressed pool.
	# POOL_DIR - The top level test path for this pool.
	# POOL_DIR_PRISTINE - The directory containing a pristine version of the pool.
	# POOL_DIR_COPY - The directory containing a working copy of the pool.
	# POOL_DIR_SRC - Location of a source build if it exists for this pool.
	#
	pool_set_vars() {
	local TAG=$1

	POOL_TAG=$TAG
	POOL_BZIP=$IMAGES_DIR/$POOL_TAG.tar.bz2
	POOL_DIR=$TEST_DIR/pools/$POOL_TAG
	POOL_DIR_PRISTINE=$POOL_DIR/pristine
	POOL_DIR_COPY=$POOL_DIR/copy
	POOL_DIR_SRC="$SRC_DIR_ZFS/${POOL_TAG//zol/zfs}"
	}

	#
	# Construct a non-trivial pool given a specific version of the source. More
	# interesting pools provide better test coverage so this function should
	# extended as needed to create more realistic pools.
	#
	pool_create() {
	pool_set_vars "$1"
	src_set_vars "$1"

	if [ "$POOL_TAG" != "installed" ]; then
	cd "$POOL_DIR_SRC" \|\| fail "Failed 'cd $POOL_DIR_SRC'"
	fi

	$ZFS_SH zfs="spa_config_path=$POOL_DIR_PRISTINE" \|\| \
	fail "Failed to load kmods"

	# Create a file vdev RAIDZ pool.
	truncate -s 1G \
	"$POOL_DIR_PRISTINE/vdev1" "$POOL_DIR_PRISTINE/vdev2" \
	"$POOL_DIR_PRISTINE/vdev3" "$POOL_DIR_PRISTINE/vdev4" \|\| \
	fail "Failed 'truncate -s 1G ...'"
	# shellcheck disable=SC2086
	$ZPOOL_CMD create $POOL_CREATE_OPTIONS "$POOL_TAG" raidz \
	"$POOL_DIR_PRISTINE/vdev1" "$POOL_DIR_PRISTINE/vdev2" \
	"$POOL_DIR_PRISTINE/vdev3" "$POOL_DIR_PRISTINE/vdev4" \|\| \
	fail "Failed '$ZPOOL_CMD create $POOL_CREATE_OPTIONS $POOL_TAG ...'"

	# Create a pool/fs filesystem with some random contents.
	$ZFS_CMD create "$POOL_TAG/fs" \|\| \
	fail "Failed '$ZFS_CMD create $POOL_TAG/fs'"
	populate "/$POOL_TAG/fs/" 10 100

	# Snapshot that filesystem, clone it, remove the files/dirs,
	# replace them with new files/dirs.
	$ZFS_CMD snap "$POOL_TAG/fs@snap" \|\| \
	fail "Failed '$ZFS_CMD snap $POOL_TAG/fs@snap'"
	$ZFS_CMD clone "$POOL_TAG/fs@snap" "$POOL_TAG/clone" \|\| \
	fail "Failed '$ZFS_CMD clone $POOL_TAG/fs@snap $POOL_TAG/clone'"
	# shellcheck disable=SC2086
	rm -Rf /$POOL_TAG/clone/*
	populate "/$POOL_TAG/clone/" 10 100

	# Scrub the pool, delay slightly, then export it. It is now
	# somewhat interesting for testing purposes.
	$ZPOOL_CMD scrub "$POOL_TAG" \|\| \
	fail "Failed '$ZPOOL_CMD scrub $POOL_TAG'"
	sleep 10
	$ZPOOL_CMD export "$POOL_TAG" \|\| \
	fail "Failed '$ZPOOL_CMD export $POOL_TAG'"

	$ZFS_SH -u \|\| fail "Failed to unload kmods"
	}

	# If the zfs-images directory doesn't exist fetch a copy from Github then
	# cache it in the $TEST_DIR and update $IMAGES_DIR.
	if [ ! -d "$IMAGES_DIR" ]; then
	IMAGES_DIR="$TEST_DIR/zfs-images"
	mkdir -p "$IMAGES_DIR"
	curl -sL "$IMAGES_TAR" \| \
	tar -xz -C "$IMAGES_DIR" --strip-components=1 \|\| \
	fail "Failed to download pool images"
	fi

	# Given the available images in the zfs-images directory substitute the
	# list of available images for the reserved keyword 'all'.
	for TAG in $POOL_TAGS; do

	if [ "$TAG" = "all" ]; then
	# shellcheck disable=SC2010
	ALL_TAGS=$(ls "$IMAGES_DIR" \| grep "tar.bz2" \| \
	sed 's/.tar.bz2//' \| tr '\n' ' ')
	NEW_TAGS="$NEW_TAGS $ALL_TAGS"
	else
	NEW_TAGS="$NEW_TAGS $TAG"
	fi
	done
	POOL_TAGS="$NEW_TAGS"

	if [ "$VERBOSE" = "yes" ]; then
	echo "---------------------------- Options ----------------------------"
	echo "VERBOSE=$VERBOSE"
	echo "KEEP=$KEEP"
	echo "REPO=$REPO"
	echo "SRC_TAGS=$SRC_TAGS"
	echo "POOL_TAGS=$POOL_TAGS"
	echo "PATH=$TEST_DIR"
	echo "POOL_CREATE_OPTIONS=$POOL_CREATE_OPTIONS"
	echo
	fi

	if [ ! -d "$TEST_DIR" ]; then
	mkdir -p "$TEST_DIR"
	fi

	if [ ! -d "$SRC_DIR" ]; then
	mkdir -p "$SRC_DIR"
	fi

	# Print a header for all tags which are being tested.
	echo "------------------------ OpenZFS Source Versions ----------------"
	printf "%-16s" " "
	for TAG in $SRC_TAGS; do
	src_set_vars "$TAG"

	if [ "$TAG" = "installed" ]; then
	ZFS_VERSION=$(modinfo zfs \| awk '/version:/ { print $2; exit }')
	if [ -n "$ZFS_VERSION" ]; then
	printf "%-16s" "$ZFS_VERSION"
	else
	fail "ZFS is not installed"
	fi
	else
	printf "%-16s" "$TAG"
	fi
	done
	echo -e "\n-----------------------------------------------------------------"

	#
	# Attempt to generate the tarball from your local git repository, if that
	# fails then attempt to download the tarball from Github.
	#
	printf "%-16s" "Clone ZFS"
	for TAG in $SRC_TAGS; do
	src_set_vars "$TAG"

	if [ -d "$ZFS_DIR" ]; then
	skip_nonewline
	elif [ "$ZFS_TAG" = "installed" ]; then
	skip_nonewline
	else
	cd "$SRC_DIR" \|\| fail "Failed 'cd $SRC_DIR'"

	if [ ! -d "$SRC_DIR_ZFS" ]; then
	mkdir -p "$SRC_DIR_ZFS"
	fi

	git archive --format=tar --prefix="$ZFS_TAG/ $ZFS_TAG" \
	-o "$SRC_DIR_ZFS/$ZFS_TAG.tar" &>/dev/null \|\| \
	rm "$SRC_DIR_ZFS/$ZFS_TAG.tar"
	if [ -s "$SRC_DIR_ZFS/$ZFS_TAG.tar" ]; then
	tar -xf "$SRC_DIR_ZFS/$ZFS_TAG.tar" -C "$SRC_DIR_ZFS"
	rm "$SRC_DIR_ZFS/$ZFS_TAG.tar"
	echo -n -e "${COLOR_GREEN}Local${COLOR_RESET}\t\t"
	else
	mkdir -p "$ZFS_DIR" \|\| fail "Failed to create $ZFS_DIR"
	curl -sL "$ZFS_URL" \| tar -xz -C "$ZFS_DIR" \
	--strip-components=1 \|\| \
	fail "Failed to download $ZFS_URL"
	echo -n -e "${COLOR_GREEN}Remote${COLOR_RESET}\t\t"
	fi
	fi
	done
	printf "\n"

	# Build the listed tags
	printf "%-16s" "Build ZFS"
	for TAG in $SRC_TAGS; do
	src_set_vars "$TAG"

	if [ -f "$ZFS_DIR/module/zfs/zfs.ko" ]; then
	skip_nonewline
	elif [ "$ZFS_TAG" = "installed" ]; then
	skip_nonewline
	else
	cd "$ZFS_DIR" \|\| fail "Failed 'cd $ZFS_DIR'"
	make distclean &>/dev/null
	./autogen.sh >>"$CONFIG_LOG" 2>&1 \|\| \
	fail "Failed ZFS 'autogen.sh'"
	# shellcheck disable=SC2086
	./configure $CONFIG_OPTIONS >>"$CONFIG_LOG" 2>&1 \|\| \
	fail "Failed ZFS 'configure $CONFIG_OPTIONS'"
	# shellcheck disable=SC2086
	make $MAKE_OPTIONS >>"$MAKE_LOG" 2>&1 \|\| \
	fail "Failed ZFS 'make $MAKE_OPTIONS'"
	pass_nonewline
	fi
	done
	printf "\n"
	echo "-----------------------------------------------------------------"

	# Either create a new pool using 'zpool create', or alternately restore an
	# existing pool from another ZFS implementation for compatibility testing.
	for TAG in $POOL_TAGS; do
	pool_set_vars "$TAG"
	SKIP=0

	printf "%-16s" "$POOL_TAG"
	rm -Rf "$POOL_DIR"
	mkdir -p "$POOL_DIR_PRISTINE"

	# Use the existing compressed image if available.
	if [ -f "$POOL_BZIP" ]; then
	tar -xjf "$POOL_BZIP" -C "$POOL_DIR_PRISTINE" \
	--strip-components=1 \|\| \
	fail "Failed 'tar -xjf $POOL_BZIP"
	# Use the installed version to create the pool.
	elif [ "$TAG" = "installed" ]; then
	pool_create "$TAG"
	# A source build is available to create the pool.
	elif [ -d "$POOL_DIR_SRC" ]; then
	pool_create "$TAG"
	else
	SKIP=1
	fi

	# Verify 'zpool import' works for all listed source versions.
	for SRC_TAG in $SRC_TAGS; do

	if [ $SKIP -eq 1 ]; then
	skip_nonewline
	continue
	fi

	src_set_vars "$SRC_TAG"
	if [ "$SRC_TAG" != "installed" ]; then
	cd "$ZFS_DIR" \|\| fail "Failed 'cd $ZFS_DIR'"
	fi
	$ZFS_SH zfs="spa_config_path=$POOL_DIR_COPY"

	cp -a --sparse=always "$POOL_DIR_PRISTINE" \
	"$POOL_DIR_COPY" \|\| \
	fail "Failed to copy $POOL_DIR_PRISTINE to $POOL_DIR_COPY"
	POOL_NAME=$($ZPOOL_CMD import -d "$POOL_DIR_COPY" \| \
	awk '/pool:/ { print $2; exit 0 }')

	$ZPOOL_CMD import -N -d "$POOL_DIR_COPY" \
	"$POOL_NAME" &>/dev/null
	# shellcheck disable=SC2181
	if [ $? -ne 0 ]; then
	fail_nonewline
	ERROR=1
	else
	$ZPOOL_CMD export "$POOL_NAME" \|\| \
	fail "Failed to export pool"
	pass_nonewline
	fi

	rm -Rf "$POOL_DIR_COPY"

	$ZFS_SH -u \|\| fail "Failed to unload kmods"
	done
	printf "\n"
	done

	if [ "$KEEP" = "no" ]; then
	rm -Rf "$TEST_DIR"
	fi

	exit $ERROR
	diff --git a/sys/contrib/openzfs/tests/runfiles/common.run b/sys/contrib/openzfs/tests/runfiles/common.run
	index cc241455084b..703407a7d03d 100644
	--- a/sys/contrib/openzfs/tests/runfiles/common.run
	+++ b/sys/contrib/openzfs/tests/runfiles/common.run
	@@ -1,936 +1,942 @@
	#
	# This file and its contents are supplied under the terms of the
	# Common Development and Distribution License ("CDDL"), version 1.0.
	# You may only use this file in accordance with the terms of version
	# 1.0 of the CDDL.
	#
	# A full copy of the text of the CDDL should have accompanied this
	# source. A copy of the CDDL is also available via the Internet at
	# http://www.illumos.org/license/CDDL.
	#
	# This run file contains all of the common functional tests. When
	# adding a new test consider also adding it to the sanity.run file
	# if the new test runs to completion in only a few seconds.
	#
	# Approximate run time: 4-5 hours
	#

	[DEFAULT]
	pre = setup
	quiet = False
	pre_user = root
	user = root
	timeout = 600
	post_user = root
	post = cleanup
	failsafe_user = root
	failsafe = callbacks/zfs_failsafe
	outputdir = /var/tmp/test_results
	tags = ['functional']

	[tests/functional/acl/off]
	tests = ['posixmode']
	tags = ['functional', 'acl']

	[tests/functional/alloc_class]
	tests = ['alloc_class_001_pos', 'alloc_class_002_neg', 'alloc_class_003_pos',
	'alloc_class_004_pos', 'alloc_class_005_pos', 'alloc_class_006_pos',
	'alloc_class_007_pos', 'alloc_class_008_pos', 'alloc_class_009_pos',
	'alloc_class_010_pos', 'alloc_class_011_neg', 'alloc_class_012_pos',
	'alloc_class_013_pos']
	tags = ['functional', 'alloc_class']

	[tests/functional/arc]
	tests = ['dbufstats_001_pos', 'dbufstats_002_pos', 'dbufstats_003_pos',
	'arcstats_runtime_tuning']
	tags = ['functional', 'arc']

	[tests/functional/atime]
	tests = ['atime_001_pos', 'atime_002_neg', 'root_atime_off', 'root_atime_on']
	tags = ['functional', 'atime']

	[tests/functional/bootfs]
	tests = ['bootfs_001_pos', 'bootfs_002_neg', 'bootfs_003_pos',
	'bootfs_004_neg', 'bootfs_005_neg', 'bootfs_006_pos', 'bootfs_007_pos',
	'bootfs_008_pos']
	tags = ['functional', 'bootfs']

	[tests/functional/btree]
	tests = ['btree_positive', 'btree_negative']
	tags = ['functional', 'btree']
	pre =
	post =

	[tests/functional/cache]
	tests = ['cache_001_pos', 'cache_002_pos', 'cache_003_pos', 'cache_004_neg',
	'cache_005_neg', 'cache_006_pos', 'cache_007_neg', 'cache_008_neg',
	'cache_009_pos', 'cache_010_pos', 'cache_011_pos', 'cache_012_pos']
	tags = ['functional', 'cache']

	[tests/functional/cachefile]
	tests = ['cachefile_001_pos', 'cachefile_002_pos', 'cachefile_003_pos',
	'cachefile_004_pos']
	tags = ['functional', 'cachefile']

	[tests/functional/casenorm]
	tests = ['case_all_values', 'norm_all_values', 'mixed_create_failure',
	'sensitive_none_lookup', 'sensitive_none_delete',
	'sensitive_formd_lookup', 'sensitive_formd_delete',
	'insensitive_none_lookup', 'insensitive_none_delete',
	'insensitive_formd_lookup', 'insensitive_formd_delete',
	'mixed_none_lookup', 'mixed_none_lookup_ci', 'mixed_none_delete',
	'mixed_formd_lookup', 'mixed_formd_lookup_ci', 'mixed_formd_delete']
	tags = ['functional', 'casenorm']

	[tests/functional/channel_program/lua_core]
	tests = ['tst.args_to_lua', 'tst.divide_by_zero', 'tst.exists',
	'tst.integer_illegal', 'tst.integer_overflow', 'tst.language_functions_neg',
	'tst.language_functions_pos', 'tst.large_prog', 'tst.libraries',
	'tst.memory_limit', 'tst.nested_neg', 'tst.nested_pos', 'tst.nvlist_to_lua',
	'tst.recursive_neg', 'tst.recursive_pos', 'tst.return_large',
	'tst.return_nvlist_neg', 'tst.return_nvlist_pos',
	'tst.return_recursive_table', 'tst.stack_gsub', 'tst.timeout']
	tags = ['functional', 'channel_program', 'lua_core']

	[tests/functional/channel_program/synctask_core]
	tests = ['tst.destroy_fs', 'tst.destroy_snap', 'tst.get_count_and_limit',
	'tst.get_index_props', 'tst.get_mountpoint', 'tst.get_neg',
	'tst.get_number_props', 'tst.get_string_props', 'tst.get_type',
	'tst.get_userquota', 'tst.get_written', 'tst.inherit', 'tst.list_bookmarks',
	'tst.list_children', 'tst.list_clones', 'tst.list_holds',
	'tst.list_snapshots', 'tst.list_system_props',
	'tst.list_user_props', 'tst.parse_args_neg','tst.promote_conflict',
	'tst.promote_multiple', 'tst.promote_simple', 'tst.rollback_mult',
	'tst.rollback_one', 'tst.set_props', 'tst.snapshot_destroy', 'tst.snapshot_neg',
	'tst.snapshot_recursive', 'tst.snapshot_simple',
	'tst.bookmark.create', 'tst.bookmark.copy',
	'tst.terminate_by_signal'
	]
	tags = ['functional', 'channel_program', 'synctask_core']

	[tests/functional/checksum]
	tests = ['run_sha2_test', 'run_skein_test', 'filetest_001_pos',
	'filetest_002_pos']
	tags = ['functional', 'checksum']

	[tests/functional/clean_mirror]
	tests = [ 'clean_mirror_001_pos', 'clean_mirror_002_pos',
	'clean_mirror_003_pos', 'clean_mirror_004_pos']
	tags = ['functional', 'clean_mirror']

	[tests/functional/cli_root/zdb]
	tests = ['zdb_002_pos', 'zdb_003_pos', 'zdb_004_pos', 'zdb_005_pos',
	'zdb_006_pos', 'zdb_args_neg', 'zdb_args_pos',
	'zdb_block_size_histogram', 'zdb_checksum', 'zdb_decompress',
	'zdb_display_block', 'zdb_object_range_neg', 'zdb_object_range_pos',
	'zdb_objset_id', 'zdb_decompress_zstd', 'zdb_recover', 'zdb_recover_2']
	pre =
	post =
	tags = ['functional', 'cli_root', 'zdb']

	[tests/functional/cli_root/zfs]
	tests = ['zfs_001_neg', 'zfs_002_pos']
	tags = ['functional', 'cli_root', 'zfs']

	[tests/functional/cli_root/zfs_bookmark]
	tests = ['zfs_bookmark_cliargs']
	tags = ['functional', 'cli_root', 'zfs_bookmark']

	[tests/functional/cli_root/zfs_change-key]
	tests = ['zfs_change-key', 'zfs_change-key_child', 'zfs_change-key_format',
	'zfs_change-key_inherit', 'zfs_change-key_load', 'zfs_change-key_location',
	'zfs_change-key_pbkdf2iters', 'zfs_change-key_clones']
	tags = ['functional', 'cli_root', 'zfs_change-key']

	[tests/functional/cli_root/zfs_clone]
	tests = ['zfs_clone_001_neg', 'zfs_clone_002_pos', 'zfs_clone_003_pos',
	'zfs_clone_004_pos', 'zfs_clone_005_pos', 'zfs_clone_006_pos',
	'zfs_clone_007_pos', 'zfs_clone_008_neg', 'zfs_clone_009_neg',
	'zfs_clone_010_pos', 'zfs_clone_encrypted', 'zfs_clone_deeply_nested']
	tags = ['functional', 'cli_root', 'zfs_clone']

	[tests/functional/cli_root/zfs_copies]
	tests = ['zfs_copies_001_pos', 'zfs_copies_002_pos', 'zfs_copies_003_pos',
	'zfs_copies_004_neg', 'zfs_copies_005_neg', 'zfs_copies_006_pos']
	tags = ['functional', 'cli_root', 'zfs_copies']

	[tests/functional/cli_root/zfs_create]
	tests = ['zfs_create_001_pos', 'zfs_create_002_pos', 'zfs_create_003_pos',
	'zfs_create_004_pos', 'zfs_create_005_pos', 'zfs_create_006_pos',
	'zfs_create_007_pos', 'zfs_create_008_neg', 'zfs_create_009_neg',
	'zfs_create_010_neg', 'zfs_create_011_pos', 'zfs_create_012_pos',
	'zfs_create_013_pos', 'zfs_create_014_pos', 'zfs_create_encrypted',
	'zfs_create_crypt_combos', 'zfs_create_dryrun', 'zfs_create_nomount',
	'zfs_create_verbose']
	tags = ['functional', 'cli_root', 'zfs_create']

	[tests/functional/cli_root/zfs_destroy]
	tests = ['zfs_clone_livelist_condense_and_disable',
	'zfs_clone_livelist_condense_races', 'zfs_destroy_001_pos',
	'zfs_destroy_002_pos', 'zfs_destroy_003_pos',
	'zfs_destroy_004_pos', 'zfs_destroy_005_neg', 'zfs_destroy_006_neg',
	'zfs_destroy_007_neg', 'zfs_destroy_008_pos', 'zfs_destroy_009_pos',
	'zfs_destroy_010_pos', 'zfs_destroy_011_pos', 'zfs_destroy_012_pos',
	'zfs_destroy_013_neg', 'zfs_destroy_014_pos', 'zfs_destroy_015_pos',
	'zfs_destroy_016_pos', 'zfs_destroy_clone_livelist',
	'zfs_destroy_dev_removal', 'zfs_destroy_dev_removal_condense']
	tags = ['functional', 'cli_root', 'zfs_destroy']

	[tests/functional/cli_root/zfs_diff]
	tests = ['zfs_diff_changes', 'zfs_diff_cliargs', 'zfs_diff_timestamp',
	'zfs_diff_types', 'zfs_diff_encrypted']
	tags = ['functional', 'cli_root', 'zfs_diff']

	[tests/functional/cli_root/zfs_get]
	tests = ['zfs_get_001_pos', 'zfs_get_002_pos', 'zfs_get_003_pos',
	'zfs_get_004_pos', 'zfs_get_005_neg', 'zfs_get_006_neg', 'zfs_get_007_neg',
	'zfs_get_008_pos', 'zfs_get_009_pos', 'zfs_get_010_neg']
	tags = ['functional', 'cli_root', 'zfs_get']

	[tests/functional/cli_root/zfs_ids_to_path]
	tests = ['zfs_ids_to_path_001_pos']
	tags = ['functional', 'cli_root', 'zfs_ids_to_path']

	[tests/functional/cli_root/zfs_inherit]
	tests = ['zfs_inherit_001_neg', 'zfs_inherit_002_neg', 'zfs_inherit_003_pos',
	'zfs_inherit_mountpoint']
	tags = ['functional', 'cli_root', 'zfs_inherit']

	[tests/functional/cli_root/zfs_load-key]
	tests = ['zfs_load-key', 'zfs_load-key_all', 'zfs_load-key_file',
	'zfs_load-key_location', 'zfs_load-key_noop', 'zfs_load-key_recursive']
	tags = ['functional', 'cli_root', 'zfs_load-key']

	[tests/functional/cli_root/zfs_mount]
	tests = ['zfs_mount_001_pos', 'zfs_mount_002_pos', 'zfs_mount_003_pos',
	'zfs_mount_004_pos', 'zfs_mount_005_pos', 'zfs_mount_007_pos',
	'zfs_mount_009_neg', 'zfs_mount_010_neg', 'zfs_mount_011_neg',
	'zfs_mount_012_pos', 'zfs_mount_all_001_pos', 'zfs_mount_encrypted',
	'zfs_mount_remount', 'zfs_mount_all_fail', 'zfs_mount_all_mountpoints',
	'zfs_mount_test_race']
	tags = ['functional', 'cli_root', 'zfs_mount']

	[tests/functional/cli_root/zfs_program]
	tests = ['zfs_program_json']
	tags = ['functional', 'cli_root', 'zfs_program']

	[tests/functional/cli_root/zfs_promote]
	tests = ['zfs_promote_001_pos', 'zfs_promote_002_pos', 'zfs_promote_003_pos',
	'zfs_promote_004_pos', 'zfs_promote_005_pos', 'zfs_promote_006_neg',
	'zfs_promote_007_neg', 'zfs_promote_008_pos', 'zfs_promote_encryptionroot']
	tags = ['functional', 'cli_root', 'zfs_promote']

	[tests/functional/cli_root/zfs_property]
	tests = ['zfs_written_property_001_pos']
	tags = ['functional', 'cli_root', 'zfs_property']

	[tests/functional/cli_root/zfs_receive]
	tests = ['zfs_receive_001_pos', 'zfs_receive_002_pos', 'zfs_receive_003_pos',
	'zfs_receive_004_neg', 'zfs_receive_005_neg', 'zfs_receive_006_pos',
	'zfs_receive_007_neg', 'zfs_receive_008_pos', 'zfs_receive_009_neg',
	'zfs_receive_010_pos', 'zfs_receive_011_pos', 'zfs_receive_012_pos',
	'zfs_receive_013_pos', 'zfs_receive_014_pos', 'zfs_receive_015_pos',
	'zfs_receive_016_pos', 'receive-o-x_props_override',
	'zfs_receive_from_encrypted', 'zfs_receive_to_encrypted',
	'zfs_receive_raw', 'zfs_receive_raw_incremental', 'zfs_receive_-e',
	'zfs_receive_raw_-d', 'zfs_receive_from_zstd', 'zfs_receive_new_props']
	tags = ['functional', 'cli_root', 'zfs_receive']

	[tests/functional/cli_root/zfs_rename]
	tests = ['zfs_rename_001_pos', 'zfs_rename_002_pos', 'zfs_rename_003_pos',
	'zfs_rename_004_neg', 'zfs_rename_005_neg', 'zfs_rename_006_pos',
	'zfs_rename_007_pos', 'zfs_rename_008_pos', 'zfs_rename_009_neg',
	'zfs_rename_010_neg', 'zfs_rename_011_pos', 'zfs_rename_012_neg',
	'zfs_rename_013_pos', 'zfs_rename_014_neg', 'zfs_rename_encrypted_child',
	'zfs_rename_to_encrypted', 'zfs_rename_mountpoint', 'zfs_rename_nounmount']
	tags = ['functional', 'cli_root', 'zfs_rename']

	[tests/functional/cli_root/zfs_reservation]
	tests = ['zfs_reservation_001_pos', 'zfs_reservation_002_pos']
	tags = ['functional', 'cli_root', 'zfs_reservation']

	[tests/functional/cli_root/zfs_rollback]
	tests = ['zfs_rollback_001_pos', 'zfs_rollback_002_pos',
	'zfs_rollback_003_neg', 'zfs_rollback_004_neg']
	tags = ['functional', 'cli_root', 'zfs_rollback']

	[tests/functional/cli_root/zfs_send]
	tests = ['zfs_send_001_pos', 'zfs_send_002_pos', 'zfs_send_003_pos',
	'zfs_send_004_neg', 'zfs_send_005_pos', 'zfs_send_006_pos',
	'zfs_send_007_pos', 'zfs_send_encrypted', 'zfs_send_raw',
	- 'zfs_send_sparse', 'zfs_send-b']
	+ 'zfs_send_sparse', 'zfs_send-b', 'zfs_send_skip_missing']
	tags = ['functional', 'cli_root', 'zfs_send']

	[tests/functional/cli_root/zfs_set]
	tests = ['cache_001_pos', 'cache_002_neg', 'canmount_001_pos',
	'canmount_002_pos', 'canmount_003_pos', 'canmount_004_pos',
	'checksum_001_pos', 'compression_001_pos', 'mountpoint_001_pos',
	'mountpoint_002_pos', 'reservation_001_neg', 'user_property_002_pos',
	'share_mount_001_neg', 'snapdir_001_pos', 'onoffs_001_pos',
	'user_property_001_pos', 'user_property_003_neg', 'readonly_001_pos',
	'user_property_004_pos', 'version_001_neg', 'zfs_set_001_neg',
	'zfs_set_002_neg', 'zfs_set_003_neg', 'property_alias_001_pos',
	'mountpoint_003_pos', 'ro_props_001_pos', 'zfs_set_keylocation',
	'zfs_set_feature_activation']
	tags = ['functional', 'cli_root', 'zfs_set']

	[tests/functional/cli_root/zfs_share]
	tests = ['zfs_share_001_pos', 'zfs_share_002_pos', 'zfs_share_003_pos',
	'zfs_share_004_pos', 'zfs_share_006_pos', 'zfs_share_008_neg',
	'zfs_share_010_neg', 'zfs_share_011_pos', 'zfs_share_concurrent_shares']
	tags = ['functional', 'cli_root', 'zfs_share']

	[tests/functional/cli_root/zfs_snapshot]
	tests = ['zfs_snapshot_001_neg', 'zfs_snapshot_002_neg',
	'zfs_snapshot_003_neg', 'zfs_snapshot_004_neg', 'zfs_snapshot_005_neg',
	'zfs_snapshot_006_pos', 'zfs_snapshot_007_neg', 'zfs_snapshot_008_neg',
	'zfs_snapshot_009_pos']
	tags = ['functional', 'cli_root', 'zfs_snapshot']

	[tests/functional/cli_root/zfs_unload-key]
	tests = ['zfs_unload-key', 'zfs_unload-key_all', 'zfs_unload-key_recursive']
	tags = ['functional', 'cli_root', 'zfs_unload-key']

	[tests/functional/cli_root/zfs_unmount]
	tests = ['zfs_unmount_001_pos', 'zfs_unmount_002_pos', 'zfs_unmount_003_pos',
	'zfs_unmount_004_pos', 'zfs_unmount_005_pos', 'zfs_unmount_006_pos',
	'zfs_unmount_007_neg', 'zfs_unmount_008_neg', 'zfs_unmount_009_pos',
	'zfs_unmount_all_001_pos', 'zfs_unmount_nested', 'zfs_unmount_unload_keys']
	tags = ['functional', 'cli_root', 'zfs_unmount']

	[tests/functional/cli_root/zfs_unshare]
	tests = ['zfs_unshare_001_pos', 'zfs_unshare_002_pos', 'zfs_unshare_003_pos',
	'zfs_unshare_004_neg', 'zfs_unshare_005_neg', 'zfs_unshare_006_pos',
	'zfs_unshare_007_pos']
	tags = ['functional', 'cli_root', 'zfs_unshare']

	[tests/functional/cli_root/zfs_upgrade]
	tests = ['zfs_upgrade_001_pos', 'zfs_upgrade_002_pos', 'zfs_upgrade_003_pos',
	'zfs_upgrade_004_pos', 'zfs_upgrade_005_pos', 'zfs_upgrade_006_neg',
	'zfs_upgrade_007_neg']
	tags = ['functional', 'cli_root', 'zfs_upgrade']

	[tests/functional/cli_root/zfs_wait]
	tests = ['zfs_wait_deleteq']
	tags = ['functional', 'cli_root', 'zfs_wait']

	[tests/functional/cli_root/zpool]
	tests = ['zpool_001_neg', 'zpool_002_pos', 'zpool_003_pos', 'zpool_colors']
	tags = ['functional', 'cli_root', 'zpool']

	[tests/functional/cli_root/zpool_add]
	tests = ['zpool_add_001_pos', 'zpool_add_002_pos', 'zpool_add_003_pos',
	'zpool_add_004_pos', 'zpool_add_006_pos', 'zpool_add_007_neg',
	'zpool_add_008_neg', 'zpool_add_009_neg', 'zpool_add_010_pos',
	'add-o_ashift', 'add_prop_ashift', 'zpool_add_dryrun_output']
	tags = ['functional', 'cli_root', 'zpool_add']

	[tests/functional/cli_root/zpool_attach]
	tests = ['zpool_attach_001_neg', 'attach-o_ashift']
	tags = ['functional', 'cli_root', 'zpool_attach']

	[tests/functional/cli_root/zpool_clear]
	tests = ['zpool_clear_001_pos', 'zpool_clear_002_neg', 'zpool_clear_003_neg',
	'zpool_clear_readonly']
	tags = ['functional', 'cli_root', 'zpool_clear']

	[tests/functional/cli_root/zpool_create]
	tests = ['zpool_create_001_pos', 'zpool_create_002_pos',
	'zpool_create_003_pos', 'zpool_create_004_pos', 'zpool_create_005_pos',
	'zpool_create_006_pos', 'zpool_create_007_neg', 'zpool_create_008_pos',
	'zpool_create_009_neg', 'zpool_create_010_neg', 'zpool_create_011_neg',
	'zpool_create_012_neg', 'zpool_create_014_neg', 'zpool_create_015_neg',
	'zpool_create_017_neg', 'zpool_create_018_pos', 'zpool_create_019_pos',
	'zpool_create_020_pos', 'zpool_create_021_pos', 'zpool_create_022_pos',
	'zpool_create_023_neg', 'zpool_create_024_pos',
	'zpool_create_encrypted', 'zpool_create_crypt_combos',
	'zpool_create_draid_001_pos', 'zpool_create_draid_002_pos',
	'zpool_create_draid_003_pos', 'zpool_create_draid_004_pos',
	'zpool_create_features_001_pos', 'zpool_create_features_002_pos',
	'zpool_create_features_003_pos', 'zpool_create_features_004_neg',
	'zpool_create_features_005_pos', 'zpool_create_features_006_pos',
	'zpool_create_features_007_pos', 'zpool_create_features_008_pos',
	'create-o_ashift', 'zpool_create_tempname', 'zpool_create_dryrun_output']
	tags = ['functional', 'cli_root', 'zpool_create']

	[tests/functional/cli_root/zpool_destroy]
	tests = ['zpool_destroy_001_pos', 'zpool_destroy_002_pos',
	'zpool_destroy_003_neg']
	pre =
	post =
	tags = ['functional', 'cli_root', 'zpool_destroy']

	[tests/functional/cli_root/zpool_detach]
	tests = ['zpool_detach_001_neg']
	tags = ['functional', 'cli_root', 'zpool_detach']

	[tests/functional/cli_root/zpool_events]
	tests = ['zpool_events_clear', 'zpool_events_cliargs', 'zpool_events_follow',
	'zpool_events_poolname', 'zpool_events_errors', 'zpool_events_duplicates',
	'zpool_events_clear_retained']
	tags = ['functional', 'cli_root', 'zpool_events']

	[tests/functional/cli_root/zpool_export]
	tests = ['zpool_export_001_pos', 'zpool_export_002_pos',
	'zpool_export_003_neg', 'zpool_export_004_pos']
	tags = ['functional', 'cli_root', 'zpool_export']

	[tests/functional/cli_root/zpool_get]
	tests = ['zpool_get_001_pos', 'zpool_get_002_pos', 'zpool_get_003_pos',
	'zpool_get_004_neg', 'zpool_get_005_pos']
	tags = ['functional', 'cli_root', 'zpool_get']

	[tests/functional/cli_root/zpool_history]
	tests = ['zpool_history_001_neg', 'zpool_history_002_pos']
	tags = ['functional', 'cli_root', 'zpool_history']

	[tests/functional/cli_root/zpool_import]
	tests = ['zpool_import_001_pos', 'zpool_import_002_pos',
	'zpool_import_003_pos', 'zpool_import_004_pos', 'zpool_import_005_pos',
	'zpool_import_006_pos', 'zpool_import_007_pos', 'zpool_import_008_pos',
	'zpool_import_009_neg', 'zpool_import_010_pos', 'zpool_import_011_neg',
	'zpool_import_012_pos', 'zpool_import_013_neg', 'zpool_import_014_pos',
	'zpool_import_015_pos', 'zpool_import_016_pos', 'zpool_import_017_pos',
	'zpool_import_features_001_pos', 'zpool_import_features_002_neg',
	'zpool_import_features_003_pos', 'zpool_import_missing_001_pos',
	'zpool_import_missing_002_pos', 'zpool_import_missing_003_pos',
	'zpool_import_rename_001_pos', 'zpool_import_all_001_pos',
	'zpool_import_encrypted', 'zpool_import_encrypted_load',
	'zpool_import_errata3', 'zpool_import_errata4',
	'import_cachefile_device_added',
	'import_cachefile_device_removed',
	'import_cachefile_device_replaced',
	'import_cachefile_mirror_attached',
	'import_cachefile_mirror_detached',
	'import_cachefile_paths_changed',
	'import_cachefile_shared_device',
	'import_devices_missing',
	'import_paths_changed',
	'import_rewind_config_changed',
	'import_rewind_device_replaced']
	tags = ['functional', 'cli_root', 'zpool_import']
	timeout = 1200

	[tests/functional/cli_root/zpool_labelclear]
	tests = ['zpool_labelclear_active', 'zpool_labelclear_exported',
	'zpool_labelclear_removed', 'zpool_labelclear_valid']
	pre =
	post =
	tags = ['functional', 'cli_root', 'zpool_labelclear']

	[tests/functional/cli_root/zpool_initialize]
	tests = ['zpool_initialize_attach_detach_add_remove',
	'zpool_initialize_fault_export_import_online',
	'zpool_initialize_import_export',
	'zpool_initialize_offline_export_import_online',
	'zpool_initialize_online_offline',
	'zpool_initialize_split',
	'zpool_initialize_start_and_cancel_neg',
	'zpool_initialize_start_and_cancel_pos',
	'zpool_initialize_suspend_resume',
	'zpool_initialize_unsupported_vdevs',
	'zpool_initialize_verify_checksums',
	'zpool_initialize_verify_initialized']
	pre =
	tags = ['functional', 'cli_root', 'zpool_initialize']

	[tests/functional/cli_root/zpool_offline]
	tests = ['zpool_offline_001_pos', 'zpool_offline_002_neg',
	'zpool_offline_003_pos']
	tags = ['functional', 'cli_root', 'zpool_offline']

	[tests/functional/cli_root/zpool_online]
	tests = ['zpool_online_001_pos', 'zpool_online_002_neg']
	tags = ['functional', 'cli_root', 'zpool_online']

	[tests/functional/cli_root/zpool_remove]
	tests = ['zpool_remove_001_neg', 'zpool_remove_002_pos',
	'zpool_remove_003_pos']
	tags = ['functional', 'cli_root', 'zpool_remove']

	[tests/functional/cli_root/zpool_replace]
	tests = ['zpool_replace_001_neg', 'replace-o_ashift', 'replace_prop_ashift']
	tags = ['functional', 'cli_root', 'zpool_replace']

	[tests/functional/cli_root/zpool_resilver]
	tests = ['zpool_resilver_bad_args', 'zpool_resilver_restart']
	tags = ['functional', 'cli_root', 'zpool_resilver']

	[tests/functional/cli_root/zpool_scrub]
	tests = ['zpool_scrub_001_neg', 'zpool_scrub_002_pos', 'zpool_scrub_003_pos',
	'zpool_scrub_004_pos', 'zpool_scrub_005_pos',
	'zpool_scrub_encrypted_unloaded', 'zpool_scrub_print_repairing',
	'zpool_scrub_offline_device', 'zpool_scrub_multiple_copies']
	tags = ['functional', 'cli_root', 'zpool_scrub']

	[tests/functional/cli_root/zpool_set]
	tests = ['zpool_set_001_pos', 'zpool_set_002_neg', 'zpool_set_003_neg',
	'zpool_set_ashift', 'zpool_set_features']
	tags = ['functional', 'cli_root', 'zpool_set']

	[tests/functional/cli_root/zpool_split]
	tests = ['zpool_split_cliargs', 'zpool_split_devices',
	'zpool_split_encryption', 'zpool_split_props', 'zpool_split_vdevs',
	'zpool_split_resilver', 'zpool_split_indirect',
	'zpool_split_dryrun_output']
	tags = ['functional', 'cli_root', 'zpool_split']

	[tests/functional/cli_root/zpool_status]
	tests = ['zpool_status_001_pos', 'zpool_status_002_pos',
	'zpool_status_features_001_pos']
	tags = ['functional', 'cli_root', 'zpool_status']

	[tests/functional/cli_root/zpool_sync]
	tests = ['zpool_sync_001_pos', 'zpool_sync_002_neg']
	tags = ['functional', 'cli_root', 'zpool_sync']

	[tests/functional/cli_root/zpool_trim]
	tests = ['zpool_trim_attach_detach_add_remove',
	'zpool_trim_fault_export_import_online',
	'zpool_trim_import_export', 'zpool_trim_multiple', 'zpool_trim_neg',
	'zpool_trim_offline_export_import_online', 'zpool_trim_online_offline',
	'zpool_trim_partial', 'zpool_trim_rate', 'zpool_trim_rate_neg',
	'zpool_trim_secure', 'zpool_trim_split', 'zpool_trim_start_and_cancel_neg',
	'zpool_trim_start_and_cancel_pos', 'zpool_trim_suspend_resume',
	'zpool_trim_unsupported_vdevs', 'zpool_trim_verify_checksums',
	'zpool_trim_verify_trimmed']
	tags = ['functional', 'zpool_trim']

	[tests/functional/cli_root/zpool_upgrade]
	tests = ['zpool_upgrade_001_pos', 'zpool_upgrade_002_pos',
	'zpool_upgrade_003_pos', 'zpool_upgrade_004_pos',
	'zpool_upgrade_005_neg', 'zpool_upgrade_006_neg',
	'zpool_upgrade_007_pos', 'zpool_upgrade_008_pos',
	'zpool_upgrade_009_neg', 'zpool_upgrade_features_001_pos']
	tags = ['functional', 'cli_root', 'zpool_upgrade']

	[tests/functional/cli_root/zpool_wait]
	tests = ['zpool_wait_discard', 'zpool_wait_freeing',
	'zpool_wait_initialize_basic', 'zpool_wait_initialize_cancel',
	'zpool_wait_initialize_flag', 'zpool_wait_multiple',
	'zpool_wait_no_activity', 'zpool_wait_remove', 'zpool_wait_remove_cancel',
	'zpool_wait_trim_basic', 'zpool_wait_trim_cancel', 'zpool_wait_trim_flag',
	'zpool_wait_usage']
	tags = ['functional', 'cli_root', 'zpool_wait']

	[tests/functional/cli_root/zpool_wait/scan]
	tests = ['zpool_wait_replace_cancel', 'zpool_wait_rebuild',
	'zpool_wait_resilver', 'zpool_wait_scrub_cancel',
	'zpool_wait_replace', 'zpool_wait_scrub_basic', 'zpool_wait_scrub_flag']
	tags = ['functional', 'cli_root', 'zpool_wait']

	[tests/functional/cli_user/misc]
	tests = ['zdb_001_neg', 'zfs_001_neg', 'zfs_allow_001_neg',
	'zfs_clone_001_neg', 'zfs_create_001_neg', 'zfs_destroy_001_neg',
	'zfs_get_001_neg', 'zfs_inherit_001_neg', 'zfs_mount_001_neg',
	'zfs_promote_001_neg', 'zfs_receive_001_neg', 'zfs_rename_001_neg',
	'zfs_rollback_001_neg', 'zfs_send_001_neg', 'zfs_set_001_neg',
	'zfs_share_001_neg', 'zfs_snapshot_001_neg', 'zfs_unallow_001_neg',
	'zfs_unmount_001_neg', 'zfs_unshare_001_neg', 'zfs_upgrade_001_neg',
	'zpool_001_neg', 'zpool_add_001_neg', 'zpool_attach_001_neg',
	'zpool_clear_001_neg', 'zpool_create_001_neg', 'zpool_destroy_001_neg',
	'zpool_detach_001_neg', 'zpool_export_001_neg', 'zpool_get_001_neg',
	'zpool_history_001_neg', 'zpool_import_001_neg', 'zpool_import_002_neg',
	'zpool_offline_001_neg', 'zpool_online_001_neg', 'zpool_remove_001_neg',
	'zpool_replace_001_neg', 'zpool_scrub_001_neg', 'zpool_set_001_neg',
	'zpool_status_001_neg', 'zpool_upgrade_001_neg', 'arcstat_001_pos',
	'arc_summary_001_pos', 'arc_summary_002_neg', 'zpool_wait_privilege']
	user =
	tags = ['functional', 'cli_user', 'misc']

	[tests/functional/cli_user/zfs_list]
	tests = ['zfs_list_001_pos', 'zfs_list_002_pos', 'zfs_list_003_pos',
	'zfs_list_004_neg', 'zfs_list_007_pos', 'zfs_list_008_neg']
	user =
	tags = ['functional', 'cli_user', 'zfs_list']

	[tests/functional/cli_user/zpool_iostat]
	tests = ['zpool_iostat_001_neg', 'zpool_iostat_002_pos',
	'zpool_iostat_003_neg', 'zpool_iostat_004_pos',
	'zpool_iostat_005_pos', 'zpool_iostat_-c_disable',
	'zpool_iostat_-c_homedir', 'zpool_iostat_-c_searchpath']
	user =
	tags = ['functional', 'cli_user', 'zpool_iostat']

	[tests/functional/cli_user/zpool_list]
	tests = ['zpool_list_001_pos', 'zpool_list_002_neg']
	user =
	tags = ['functional', 'cli_user', 'zpool_list']

	[tests/functional/cli_user/zpool_status]
	tests = ['zpool_status_003_pos', 'zpool_status_-c_disable',
	'zpool_status_-c_homedir', 'zpool_status_-c_searchpath']
	user =
	tags = ['functional', 'cli_user', 'zpool_status']

	[tests/functional/compression]
	tests = ['compress_001_pos', 'compress_002_pos', 'compress_003_pos',
	'l2arc_compressed_arc', 'l2arc_compressed_arc_disabled',
	'l2arc_encrypted', 'l2arc_encrypted_no_compressed_arc']
	tags = ['functional', 'compression']

	[tests/functional/cp_files]
	tests = ['cp_files_001_pos']
	tags = ['functional', 'cp_files']

	[tests/functional/ctime]
	tests = ['ctime_001_pos' ]
	tags = ['functional', 'ctime']

	+[tests/functional/deadman]
	+tests = ['deadman_ratelimit', 'deadman_sync', 'deadman_zio']
	+pre =
	+post =
	+tags = ['functional', 'deadman']
	+
	[tests/functional/delegate]
	tests = ['zfs_allow_001_pos', 'zfs_allow_002_pos', 'zfs_allow_003_pos',
	'zfs_allow_004_pos', 'zfs_allow_005_pos', 'zfs_allow_006_pos',
	'zfs_allow_007_pos', 'zfs_allow_008_pos', 'zfs_allow_009_neg',
	'zfs_allow_010_pos', 'zfs_allow_011_neg', 'zfs_allow_012_neg',
	'zfs_unallow_001_pos', 'zfs_unallow_002_pos', 'zfs_unallow_003_pos',
	'zfs_unallow_004_pos', 'zfs_unallow_005_pos', 'zfs_unallow_006_pos',
	'zfs_unallow_007_neg', 'zfs_unallow_008_neg']
	tags = ['functional', 'delegate']

	[tests/functional/exec]
	tests = ['exec_001_pos', 'exec_002_neg']
	tags = ['functional', 'exec']

	[tests/functional/features/async_destroy]
	tests = ['async_destroy_001_pos']
	tags = ['functional', 'features', 'async_destroy']

	[tests/functional/features/large_dnode]
	tests = ['large_dnode_001_pos', 'large_dnode_003_pos', 'large_dnode_004_neg',
	'large_dnode_005_pos', 'large_dnode_007_neg', 'large_dnode_009_pos']
	tags = ['functional', 'features', 'large_dnode']

	[tests/functional/grow]
	pre =
	post =
	tests = ['grow_pool_001_pos', 'grow_replicas_001_pos']
	tags = ['functional', 'grow']

	[tests/functional/history]
	tests = ['history_001_pos', 'history_002_pos', 'history_003_pos',
	'history_004_pos', 'history_005_neg', 'history_006_neg',
	'history_007_pos', 'history_008_pos', 'history_009_pos',
	'history_010_pos']
	tags = ['functional', 'history']

	[tests/functional/hkdf]
	tests = ['run_hkdf_test']
	tags = ['functional', 'hkdf']

	[tests/functional/inheritance]
	tests = ['inherit_001_pos']
	pre =
	tags = ['functional', 'inheritance']

	[tests/functional/io]
	tests = ['sync', 'psync', 'posixaio', 'mmap']
	tags = ['functional', 'io']

	[tests/functional/inuse]
	tests = ['inuse_004_pos', 'inuse_005_pos', 'inuse_008_pos', 'inuse_009_pos']
	post =
	tags = ['functional', 'inuse']

	[tests/functional/large_files]
	tests = ['large_files_001_pos', 'large_files_002_pos']
	tags = ['functional', 'large_files']

	[tests/functional/largest_pool]
	tests = ['largest_pool_001_pos']
	pre =
	post =
	tags = ['functional', 'largest_pool']

	[tests/functional/limits]
	tests = ['filesystem_count', 'filesystem_limit', 'snapshot_count',
	'snapshot_limit']
	tags = ['functional', 'limits']

	[tests/functional/link_count]
	tests = ['link_count_001', 'link_count_root_inode']
	tags = ['functional', 'link_count']

	[tests/functional/migration]
	tests = ['migration_001_pos', 'migration_002_pos', 'migration_003_pos',
	'migration_004_pos', 'migration_005_pos', 'migration_006_pos',
	'migration_007_pos', 'migration_008_pos', 'migration_009_pos',
	'migration_010_pos', 'migration_011_pos', 'migration_012_pos']
	tags = ['functional', 'migration']

	[tests/functional/mmap]
	tests = ['mmap_write_001_pos', 'mmap_read_001_pos']
	tags = ['functional', 'mmap']

	[tests/functional/mount]
	tests = ['umount_001', 'umountall_001']
	tags = ['functional', 'mount']

	[tests/functional/mv_files]
	tests = ['mv_files_001_pos', 'mv_files_002_pos', 'random_creation']
	tags = ['functional', 'mv_files']

	[tests/functional/nestedfs]
	tests = ['nestedfs_001_pos']
	tags = ['functional', 'nestedfs']

	[tests/functional/no_space]
	tests = ['enospc_001_pos', 'enospc_002_pos', 'enospc_003_pos',
	'enospc_df']
	tags = ['functional', 'no_space']

	[tests/functional/nopwrite]
	tests = ['nopwrite_copies', 'nopwrite_mtime', 'nopwrite_negative',
	'nopwrite_promoted_clone', 'nopwrite_recsize', 'nopwrite_sync',
	'nopwrite_varying_compression', 'nopwrite_volume']
	tags = ['functional', 'nopwrite']

	[tests/functional/online_offline]
	tests = ['online_offline_001_pos', 'online_offline_002_neg',
	'online_offline_003_neg']
	tags = ['functional', 'online_offline']

	[tests/functional/pool_checkpoint]
	tests = ['checkpoint_after_rewind', 'checkpoint_big_rewind',
	'checkpoint_capacity', 'checkpoint_conf_change', 'checkpoint_discard',
	'checkpoint_discard_busy', 'checkpoint_discard_many',
	'checkpoint_indirect', 'checkpoint_invalid', 'checkpoint_lun_expsz',
	'checkpoint_open', 'checkpoint_removal', 'checkpoint_rewind',
	'checkpoint_ro_rewind', 'checkpoint_sm_scale', 'checkpoint_twice',
	'checkpoint_vdev_add', 'checkpoint_zdb', 'checkpoint_zhack_feat']
	tags = ['functional', 'pool_checkpoint']
	timeout = 1800

	[tests/functional/pool_names]
	tests = ['pool_names_001_pos', 'pool_names_002_neg']
	pre =
	post =
	tags = ['functional', 'pool_names']

	[tests/functional/poolversion]
	tests = ['poolversion_001_pos', 'poolversion_002_pos']
	tags = ['functional', 'poolversion']

	[tests/functional/pyzfs]
	tests = ['pyzfs_unittest']
	pre =
	post =
	tags = ['functional', 'pyzfs']

	[tests/functional/quota]
	tests = ['quota_001_pos', 'quota_002_pos', 'quota_003_pos',
	'quota_004_pos', 'quota_005_pos', 'quota_006_neg']
	tags = ['functional', 'quota']

	[tests/functional/redacted_send]
	tests = ['redacted_compressed', 'redacted_contents', 'redacted_deleted',
	'redacted_disabled_feature', 'redacted_embedded', 'redacted_holes',
	'redacted_incrementals', 'redacted_largeblocks', 'redacted_many_clones',
	'redacted_mixed_recsize', 'redacted_mounts', 'redacted_negative',
	'redacted_origin', 'redacted_panic', 'redacted_props', 'redacted_resume',
	'redacted_size', 'redacted_volume']
	tags = ['functional', 'redacted_send']

	[tests/functional/raidz]
	tests = ['raidz_001_neg', 'raidz_002_pos', 'raidz_003_pos', 'raidz_004_pos']
	tags = ['functional', 'raidz']

	[tests/functional/redundancy]
	-tests = ['redundancy_draid1', 'redundancy_draid2', 'redundancy_draid3',
	- 'redundancy_draid_spare1', 'redundancy_draid_spare2',
	- 'redundancy_draid_spare3', 'redundancy_mirror', 'redundancy_raidz',
	- 'redundancy_raidz1', 'redundancy_raidz2', 'redundancy_raidz3',
	- 'redundancy_stripe']
	+tests = ['redundancy_draid', 'redundancy_draid1', 'redundancy_draid2',
	+ 'redundancy_draid3', 'redundancy_draid_damaged', 'redundancy_draid_spare1',
	+ 'redundancy_draid_spare2', 'redundancy_draid_spare3', 'redundancy_mirror',
	+ 'redundancy_raidz', 'redundancy_raidz1', 'redundancy_raidz2',
	+ 'redundancy_raidz3', 'redundancy_stripe']
	tags = ['functional', 'redundancy']
	+timeout = 1200

	[tests/functional/refquota]
	tests = ['refquota_001_pos', 'refquota_002_pos', 'refquota_003_pos',
	'refquota_004_pos', 'refquota_005_pos', 'refquota_006_neg',
	'refquota_007_neg', 'refquota_008_neg']
	tags = ['functional', 'refquota']

	[tests/functional/refreserv]
	tests = ['refreserv_001_pos', 'refreserv_002_pos', 'refreserv_003_pos',
	'refreserv_004_pos', 'refreserv_005_pos', 'refreserv_multi_raidz',
	'refreserv_raidz']
	tags = ['functional', 'refreserv']

	[tests/functional/removal]
	pre =
	tests = ['removal_all_vdev', 'removal_cancel', 'removal_check_space',
	'removal_condense_export', 'removal_multiple_indirection',
	'removal_nopwrite', 'removal_remap_deadlists',
	'removal_resume_export', 'removal_sanity', 'removal_with_add',
	'removal_with_create_fs', 'removal_with_dedup',
	'removal_with_errors', 'removal_with_export',
	'removal_with_ganging', 'removal_with_faulted',
	'removal_with_remove', 'removal_with_scrub', 'removal_with_send',
	'removal_with_send_recv', 'removal_with_snapshot',
	'removal_with_write', 'removal_with_zdb', 'remove_expanded',
	'remove_mirror', 'remove_mirror_sanity', 'remove_raidz',
	'remove_indirect', 'remove_attach_mirror']
	tags = ['functional', 'removal']

	[tests/functional/rename_dirs]
	tests = ['rename_dirs_001_pos']
	tags = ['functional', 'rename_dirs']

	[tests/functional/replacement]
	tests = ['attach_import', 'attach_multiple', 'attach_rebuild',
	'attach_resilver', 'detach', 'rebuild_disabled_feature',
	'rebuild_multiple', 'rebuild_raidz', 'replace_import', 'replace_rebuild',
	'replace_resilver', 'resilver_restart_001', 'resilver_restart_002',
	'scrub_cancel']
	tags = ['functional', 'replacement']

	[tests/functional/reservation]
	tests = ['reservation_001_pos', 'reservation_002_pos', 'reservation_003_pos',
	'reservation_004_pos', 'reservation_005_pos', 'reservation_006_pos',
	'reservation_007_pos', 'reservation_008_pos', 'reservation_009_pos',
	'reservation_010_pos', 'reservation_011_pos', 'reservation_012_pos',
	'reservation_013_pos', 'reservation_014_pos', 'reservation_015_pos',
	'reservation_016_pos', 'reservation_017_pos', 'reservation_018_pos',
	'reservation_019_pos', 'reservation_020_pos', 'reservation_021_neg',
	'reservation_022_pos']
	tags = ['functional', 'reservation']

	[tests/functional/rootpool]
	tests = ['rootpool_002_neg', 'rootpool_003_neg', 'rootpool_007_pos']
	tags = ['functional', 'rootpool']

	[tests/functional/rsend]
	tests = ['recv_dedup', 'recv_dedup_encrypted_zvol', 'rsend_001_pos',
	'rsend_002_pos', 'rsend_003_pos', 'rsend_004_pos', 'rsend_005_pos',
	'rsend_006_pos', 'rsend_007_pos', 'rsend_008_pos', 'rsend_009_pos',
	'rsend_010_pos', 'rsend_011_pos', 'rsend_012_pos', 'rsend_013_pos',
	'rsend_014_pos', 'rsend_016_neg', 'rsend_019_pos', 'rsend_020_pos',
	'rsend_021_pos', 'rsend_022_pos', 'rsend_024_pos',
	'send-c_verify_ratio', 'send-c_verify_contents', 'send-c_props',
	'send-c_incremental', 'send-c_volume', 'send-c_zstreamdump',
	'send-c_lz4_disabled', 'send-c_recv_lz4_disabled',
	'send-c_mixed_compression', 'send-c_stream_size_estimate',
	'send-c_embedded_blocks', 'send-c_resume', 'send-cpL_varied_recsize',
	'send-c_recv_dedup', 'send-L_toggle', 'send_encrypted_hierarchy',
	'send_encrypted_props', 'send_encrypted_truncated_files',
	'send_freeobjects', 'send_realloc_files',
	'send_realloc_encrypted_files', 'send_spill_block', 'send_holds',
	'send_hole_birth', 'send_mixed_raw', 'send-wR_encrypted_zvol',
	'send_partial_dataset', 'send_invalid', 'send_doall']
	tags = ['functional', 'rsend']

	[tests/functional/scrub_mirror]
	tests = ['scrub_mirror_001_pos', 'scrub_mirror_002_pos',
	'scrub_mirror_003_pos', 'scrub_mirror_004_pos']
	tags = ['functional', 'scrub_mirror']

	[tests/functional/slog]
	tests = ['slog_001_pos', 'slog_002_pos', 'slog_003_pos', 'slog_004_pos',
	'slog_005_pos', 'slog_006_pos', 'slog_007_pos', 'slog_008_neg',
	'slog_009_neg', 'slog_010_neg', 'slog_011_neg', 'slog_012_neg',
	'slog_013_pos', 'slog_014_pos', 'slog_015_neg', 'slog_replay_fs_001',
	'slog_replay_fs_002', 'slog_replay_volume']
	tags = ['functional', 'slog']

	[tests/functional/snapshot]
	tests = ['clone_001_pos', 'rollback_001_pos', 'rollback_002_pos',
	'rollback_003_pos', 'snapshot_001_pos', 'snapshot_002_pos',
	'snapshot_003_pos', 'snapshot_004_pos', 'snapshot_005_pos',
	'snapshot_006_pos', 'snapshot_007_pos', 'snapshot_008_pos',
	'snapshot_009_pos', 'snapshot_010_pos', 'snapshot_011_pos',
	'snapshot_012_pos', 'snapshot_013_pos', 'snapshot_014_pos',
	'snapshot_017_pos']
	tags = ['functional', 'snapshot']

	[tests/functional/snapused]
	tests = ['snapused_001_pos', 'snapused_002_pos', 'snapused_003_pos',
	'snapused_004_pos', 'snapused_005_pos']
	tags = ['functional', 'snapused']

	[tests/functional/sparse]
	tests = ['sparse_001_pos']
	tags = ['functional', 'sparse']

	[tests/functional/suid]
	tests = ['suid_write_to_suid', 'suid_write_to_sgid', 'suid_write_to_suid_sgid',
	'suid_write_to_none']
	tags = ['functional', 'suid']

	[tests/functional/threadsappend]
	tests = ['threadsappend_001_pos']
	tags = ['functional', 'threadsappend']

	[tests/functional/trim]
	tests = ['autotrim_integrity', 'autotrim_config', 'autotrim_trim_integrity',
	'trim_integrity', 'trim_config', 'trim_l2arc']
	tags = ['functional', 'trim']

	[tests/functional/truncate]
	tests = ['truncate_001_pos', 'truncate_002_pos', 'truncate_timestamps']
	tags = ['functional', 'truncate']

	[tests/functional/upgrade]
	tests = ['upgrade_userobj_001_pos', 'upgrade_readonly_pool']
	tags = ['functional', 'upgrade']

	[tests/functional/userquota]
	tests = [
	'userquota_001_pos', 'userquota_002_pos', 'userquota_003_pos',
	'userquota_004_pos', 'userquota_005_neg', 'userquota_006_pos',
	'userquota_007_pos', 'userquota_008_pos', 'userquota_009_pos',
	'userquota_010_pos', 'userquota_011_pos', 'userquota_012_neg',
	- 'userspace_001_pos', 'userspace_002_pos', 'userspace_encrypted',
	- 'userspace_send_encrypted']
	+ 'userspace_001_pos', 'userspace_002_pos', 'userspace_encrypted']
	tags = ['functional', 'userquota']

	[tests/functional/vdev_zaps]
	tests = ['vdev_zaps_001_pos', 'vdev_zaps_002_pos', 'vdev_zaps_003_pos',
	'vdev_zaps_004_pos', 'vdev_zaps_005_pos', 'vdev_zaps_006_pos',
	'vdev_zaps_007_pos']
	tags = ['functional', 'vdev_zaps']

	[tests/functional/write_dirs]
	tests = ['write_dirs_001_pos', 'write_dirs_002_pos']
	tags = ['functional', 'write_dirs']

	[tests/functional/xattr]
	tests = ['xattr_001_pos', 'xattr_002_neg', 'xattr_003_neg', 'xattr_004_pos',
	'xattr_005_pos', 'xattr_006_pos', 'xattr_007_neg',
	'xattr_011_pos', 'xattr_012_pos', 'xattr_013_pos']
	tags = ['functional', 'xattr']

	[tests/functional/zvol/zvol_ENOSPC]
	tests = ['zvol_ENOSPC_001_pos']
	tags = ['functional', 'zvol', 'zvol_ENOSPC']

	[tests/functional/zvol/zvol_cli]
	tests = ['zvol_cli_001_pos', 'zvol_cli_002_pos', 'zvol_cli_003_neg']
	tags = ['functional', 'zvol', 'zvol_cli']

	[tests/functional/zvol/zvol_misc]
	tests = ['zvol_misc_002_pos', 'zvol_misc_hierarchy', 'zvol_misc_rename_inuse',
	'zvol_misc_snapdev', 'zvol_misc_volmode', 'zvol_misc_zil']
	tags = ['functional', 'zvol', 'zvol_misc']

	[tests/functional/zvol/zvol_swap]
	tests = ['zvol_swap_001_pos', 'zvol_swap_002_pos', 'zvol_swap_004_pos']
	tags = ['functional', 'zvol', 'zvol_swap']

	[tests/functional/libzfs]
	tests = ['many_fds', 'libzfs_input']
	tags = ['functional', 'libzfs']

	[tests/functional/log_spacemap]
	tests = ['log_spacemap_import_logs']
	pre =
	post =
	tags = ['functional', 'log_spacemap']

	[tests/functional/l2arc]
	tests = ['l2arc_arcstats_pos', 'l2arc_mfuonly_pos', 'l2arc_l2miss_pos',
	'persist_l2arc_001_pos', 'persist_l2arc_002_pos',
	'persist_l2arc_003_neg', 'persist_l2arc_004_pos', 'persist_l2arc_005_pos',
	'persist_l2arc_006_pos', 'persist_l2arc_007_pos', 'persist_l2arc_008_pos']
	tags = ['functional', 'l2arc']

	[tests/functional/zpool_influxdb]
	tests = ['zpool_influxdb']
	tags = ['functional', 'zpool_influxdb']
	diff --git a/sys/contrib/openzfs/tests/runfiles/linux.run b/sys/contrib/openzfs/tests/runfiles/linux.run
	index 9f6bd856aa02..c6d4f5f6d34e 100644
	--- a/sys/contrib/openzfs/tests/runfiles/linux.run
	+++ b/sys/contrib/openzfs/tests/runfiles/linux.run
	@@ -1,179 +1,173 @@
	#
	# This file and its contents are supplied under the terms of the
	# Common Development and Distribution License ("CDDL"), version 1.0.
	# You may only use this file in accordance with the terms of version
	# 1.0 of the CDDL.
	#
	# A full copy of the text of the CDDL should have accompanied this
	# source. A copy of the CDDL is also available via the Internet at
	# http://www.illumos.org/license/CDDL.
	#

	[DEFAULT]
	pre = setup
	quiet = False
	pre_user = root
	user = root
	timeout = 600
	post_user = root
	post = cleanup
	failsafe_user = root
	failsafe = callbacks/zfs_failsafe
	outputdir = /var/tmp/test_results
	tags = ['functional']

	[tests/functional/acl/posix:Linux]
	tests = ['posix_001_pos', 'posix_002_pos', 'posix_003_pos', 'posix_004_pos']
	tags = ['functional', 'acl', 'posix']

	[tests/functional/acl/posix-sa:Linux]
	tests = ['posix_001_pos', 'posix_002_pos', 'posix_003_pos', 'posix_004_pos']
	tags = ['functional', 'acl', 'posix-sa']

	[tests/functional/atime:Linux]
	tests = ['atime_003_pos', 'root_relatime_on']
	tags = ['functional', 'atime']

	[tests/functional/chattr:Linux]
	tests = ['chattr_001_pos', 'chattr_002_neg']
	tags = ['functional', 'chattr']

	[tests/functional/checksum:Linux]
	tests = ['run_edonr_test']
	tags = ['functional', 'checksum']

	[tests/functional/cli_root/zfs:Linux]
	tests = ['zfs_003_neg']
	tags = ['functional', 'cli_root', 'zfs']

	[tests/functional/cli_root/zfs_mount:Linux]
	tests = ['zfs_mount_006_pos', 'zfs_mount_008_pos', 'zfs_mount_013_pos',
	'zfs_mount_014_neg', 'zfs_multi_mount']
	tags = ['functional', 'cli_root', 'zfs_mount']

	[tests/functional/cli_root/zfs_share:Linux]
	tests = ['zfs_share_005_pos', 'zfs_share_007_neg', 'zfs_share_009_neg',
	'zfs_share_012_pos']
	tags = ['functional', 'cli_root', 'zfs_share']

	[tests/functional/cli_root/zfs_sysfs:Linux]
	tests = ['zfeature_set_unsupported', 'zfs_get_unsupported',
	'zfs_set_unsupported', 'zfs_sysfs_live', 'zpool_get_unsupported',
	'zpool_set_unsupported']
	tags = ['functional', 'cli_root', 'zfs_sysfs']

	[tests/functional/cli_root/zpool_add:Linux]
	tests = ['add_nested_replacing_spare']
	tags = ['functional', 'cli_root', 'zpool_add']

	[tests/functional/cli_root/zpool_expand:Linux]
	tests = ['zpool_expand_001_pos', 'zpool_expand_002_pos',
	'zpool_expand_003_neg', 'zpool_expand_004_pos', 'zpool_expand_005_pos']
	tags = ['functional', 'cli_root', 'zpool_expand']

	[tests/functional/cli_root/zpool_reopen:Linux]
	tests = ['zpool_reopen_001_pos', 'zpool_reopen_002_pos',
	'zpool_reopen_003_pos', 'zpool_reopen_004_pos', 'zpool_reopen_005_pos',
	'zpool_reopen_006_neg', 'zpool_reopen_007_pos']
	tags = ['functional', 'cli_root', 'zpool_reopen']

	[tests/functional/cli_root/zpool_split:Linux]
	tests = ['zpool_split_wholedisk']
	tags = ['functional', 'cli_root', 'zpool_split']

	[tests/functional/compression:Linux]
	tests = ['compress_004_pos']
	tags = ['functional', 'compression']

	-[tests/functional/deadman:Linux]
	-tests = ['deadman_sync', 'deadman_zio']
	-pre =
	-post =
	-tags = ['functional', 'deadman']
	-
	[tests/functional/devices:Linux]
	tests = ['devices_001_pos', 'devices_002_neg', 'devices_003_pos']
	tags = ['functional', 'devices']

	[tests/functional/events:Linux]
	-tests = ['events_001_pos', 'events_002_pos', 'zed_rc_filter']
	+tests = ['events_001_pos', 'events_002_pos', 'zed_rc_filter', 'zed_fd_spill']
	tags = ['functional', 'events']

	[tests/functional/fallocate:Linux]
	tests = ['fallocate_prealloc', 'fallocate_punch-hole']
	tags = ['functional', 'fallocate']

	[tests/functional/fault:Linux]
	tests = ['auto_offline_001_pos', 'auto_online_001_pos', 'auto_replace_001_pos',
	'auto_spare_001_pos', 'auto_spare_002_pos', 'auto_spare_multiple',
	'auto_spare_ashift', 'auto_spare_shared', 'decrypt_fault',
	'decompress_fault', 'scrub_after_resilver', 'zpool_status_-s']
	tags = ['functional', 'fault']

	[tests/functional/features/large_dnode:Linux]
	tests = ['large_dnode_002_pos', 'large_dnode_006_pos', 'large_dnode_008_pos']
	tags = ['functional', 'features', 'large_dnode']

	[tests/functional/io:Linux]
	tests = ['libaio', 'io_uring']
	tags = ['functional', 'io']

	[tests/functional/mmap:Linux]
	tests = ['mmap_libaio_001_pos']
	tags = ['functional', 'mmap']

	[tests/functional/mmp:Linux]
	tests = ['mmp_on_thread', 'mmp_on_uberblocks', 'mmp_on_off', 'mmp_interval',
	'mmp_active_import', 'mmp_inactive_import', 'mmp_exported_import',
	'mmp_write_uberblocks', 'mmp_reset_interval', 'multihost_history',
	'mmp_on_zdb', 'mmp_write_distribution', 'mmp_hostid']
	tags = ['functional', 'mmp']

	[tests/functional/mount:Linux]
	tests = ['umount_unlinked_drain']
	tags = ['functional', 'mount']

	[tests/functional/pam:Linux]
	tests = ['pam_basic', 'pam_nounmount']
	tags = ['functional', 'pam']

	[tests/functional/procfs:Linux]
	tests = ['procfs_list_basic', 'procfs_list_concurrent_readers',
	'procfs_list_stale_read', 'pool_state']
	tags = ['functional', 'procfs']

	[tests/functional/projectquota:Linux]
	tests = ['projectid_001_pos', 'projectid_002_pos', 'projectid_003_pos',
	'projectquota_001_pos', 'projectquota_002_pos', 'projectquota_003_pos',
	'projectquota_004_neg', 'projectquota_005_pos', 'projectquota_006_pos',
	'projectquota_007_pos', 'projectquota_008_pos', 'projectquota_009_pos',
	'projectspace_001_pos', 'projectspace_002_pos', 'projectspace_003_pos',
	'projectspace_004_pos',
	'projecttree_001_pos', 'projecttree_002_pos', 'projecttree_003_neg']
	tags = ['functional', 'projectquota']

	[tests/functional/rsend:Linux]
	tests = ['send_realloc_dnode_size', 'send_encrypted_files']
	tags = ['functional', 'rsend']

	[tests/functional/snapshot:Linux]
	tests = ['snapshot_015_pos', 'snapshot_016_pos']
	tags = ['functional', 'snapshot']

	[tests/functional/tmpfile:Linux]
	tests = ['tmpfile_001_pos', 'tmpfile_002_pos', 'tmpfile_003_pos',
	'tmpfile_stat_mode']
	tags = ['functional', 'tmpfile']

	[tests/functional/upgrade:Linux]
	tests = ['upgrade_projectquota_001_pos']
	tags = ['functional', 'upgrade']

	[tests/functional/user_namespace:Linux]
	tests = ['user_namespace_001']
	tags = ['functional', 'user_namespace']

	[tests/functional/userquota:Linux]
	tests = ['groupspace_001_pos', 'groupspace_002_pos', 'groupspace_003_pos',
	'userquota_013_pos', 'userspace_003_pos']
	tags = ['functional', 'userquota']
	diff --git a/sys/contrib/openzfs/tests/runfiles/sanity.run b/sys/contrib/openzfs/tests/runfiles/sanity.run
	index e32cf5f6228e..b1d2c73de959 100644
	--- a/sys/contrib/openzfs/tests/runfiles/sanity.run
	+++ b/sys/contrib/openzfs/tests/runfiles/sanity.run
	@@ -1,622 +1,622 @@
	#
	# This file and its contents are supplied under the terms of the
	# Common Development and Distribution License ("CDDL"), version 1.0.
	# You may only use this file in accordance with the terms of version
	# 1.0 of the CDDL.
	#
	# A full copy of the text of the CDDL should have accompanied this
	# source. A copy of the CDDL is also available via the Internet at
	# http://www.illumos.org/license/CDDL.
	#
	# This run file contains a subset of functional tests which exercise
	# as much functionality as possible while still executing relatively
	# quickly. The included tests should take no more than a few seconds
	# each to run at most. This provides a convenient way to sanity test a
	-# change before commiting to a full test run which takes several hours.
	+# change before committing to a full test run which takes several hours.
	#
	# Approximate run time: 15 minutes
	#

	[DEFAULT]
	pre = setup
	quiet = False
	pre_user = root
	user = root
	timeout = 180
	post_user = root
	post = cleanup
	failsafe_user = root
	failsafe = callbacks/zfs_failsafe
	outputdir = /var/tmp/test_results
	tags = ['functional']

	[tests/functional/acl/off]
	tests = ['posixmode']
	tags = ['functional', 'acl']

	[tests/functional/alloc_class]
	tests = ['alloc_class_003_pos', 'alloc_class_004_pos', 'alloc_class_005_pos',
	'alloc_class_006_pos', 'alloc_class_008_pos', 'alloc_class_010_pos',
	'alloc_class_011_neg']
	tags = ['functional', 'alloc_class']

	[tests/functional/arc]
	tests = ['dbufstats_001_pos', 'dbufstats_002_pos', 'arcstats_runtime_tuning']
	tags = ['functional', 'arc']

	[tests/functional/bootfs]
	tests = ['bootfs_004_neg', 'bootfs_007_pos']
	tags = ['functional', 'bootfs']

	[tests/functional/cache]
	tests = ['cache_004_neg', 'cache_005_neg', 'cache_007_neg', 'cache_010_pos']
	tags = ['functional', 'cache']

	[tests/functional/cachefile]
	tests = ['cachefile_001_pos', 'cachefile_002_pos', 'cachefile_003_pos',
	'cachefile_004_pos']
	tags = ['functional', 'cachefile']

	[tests/functional/casenorm]
	tests = ['case_all_values', 'norm_all_values', 'sensitive_none_lookup',
	'sensitive_none_delete', 'insensitive_none_lookup',
	'insensitive_none_delete', 'mixed_none_lookup', 'mixed_none_delete']
	tags = ['functional', 'casenorm']

	[tests/functional/channel_program/lua_core]
	tests = ['tst.args_to_lua', 'tst.divide_by_zero', 'tst.exists',
	'tst.integer_illegal', 'tst.integer_overflow', 'tst.language_functions_neg',
	'tst.language_functions_pos', 'tst.large_prog', 'tst.libraries',
	'tst.memory_limit', 'tst.nested_neg', 'tst.nested_pos', 'tst.nvlist_to_lua',
	'tst.recursive_neg', 'tst.recursive_pos', 'tst.return_large',
	'tst.return_nvlist_neg', 'tst.return_nvlist_pos',
	'tst.return_recursive_table', 'tst.stack_gsub', 'tst.timeout']
	tags = ['functional', 'channel_program', 'lua_core']

	[tests/functional/channel_program/synctask_core]
	tests = ['tst.destroy_fs', 'tst.destroy_snap', 'tst.get_count_and_limit',
	'tst.get_index_props', 'tst.get_mountpoint', 'tst.get_neg',
	'tst.get_number_props', 'tst.get_string_props', 'tst.get_type',
	'tst.get_userquota', 'tst.get_written', 'tst.inherit', 'tst.list_bookmarks',
	'tst.list_children', 'tst.list_clones', 'tst.list_holds',
	'tst.list_snapshots', 'tst.list_system_props',
	'tst.list_user_props', 'tst.parse_args_neg','tst.promote_conflict',
	'tst.promote_multiple', 'tst.promote_simple', 'tst.rollback_mult',
	'tst.rollback_one', 'tst.set_props', 'tst.snapshot_destroy',
	'tst.snapshot_neg', 'tst.snapshot_recursive', 'tst.snapshot_simple',
	'tst.bookmark.create', 'tst.bookmark.copy']
	tags = ['functional', 'channel_program', 'synctask_core']

	[tests/functional/cli_root/zdb]
	tests = ['zdb_003_pos', 'zdb_004_pos', 'zdb_005_pos']
	pre =
	post =
	tags = ['functional', 'cli_root', 'zdb']

	[tests/functional/cli_root/zfs]
	tests = ['zfs_001_neg', 'zfs_002_pos']
	tags = ['functional', 'cli_root', 'zfs']

	[tests/functional/cli_root/zfs_bookmark]
	tests = ['zfs_bookmark_cliargs']
	tags = ['functional', 'cli_root', 'zfs_bookmark']

	[tests/functional/cli_root/zfs_change-key]
	tests = ['zfs_change-key', 'zfs_change-key_child', 'zfs_change-key_format',
	'zfs_change-key_inherit', 'zfs_change-key_load', 'zfs_change-key_location',
	'zfs_change-key_pbkdf2iters', 'zfs_change-key_clones']
	tags = ['functional', 'cli_root', 'zfs_change-key']

	[tests/functional/cli_root/zfs_clone]
	tests = ['zfs_clone_001_neg', 'zfs_clone_002_pos', 'zfs_clone_003_pos',
	'zfs_clone_004_pos', 'zfs_clone_005_pos', 'zfs_clone_006_pos',
	'zfs_clone_007_pos', 'zfs_clone_008_neg', 'zfs_clone_009_neg',
	'zfs_clone_encrypted']
	tags = ['functional', 'cli_root', 'zfs_clone']

	[tests/functional/cli_root/zfs_create]
	tests = ['zfs_create_001_pos', 'zfs_create_002_pos', 'zfs_create_003_pos',
	'zfs_create_004_pos', 'zfs_create_005_pos', 'zfs_create_006_pos',
	'zfs_create_007_pos', 'zfs_create_011_pos', 'zfs_create_012_pos',
	'zfs_create_013_pos', 'zfs_create_014_pos', 'zfs_create_encrypted',
	'zfs_create_dryrun', 'zfs_create_verbose']
	tags = ['functional', 'cli_root', 'zfs_create']

	[tests/functional/cli_root/zfs_destroy]
	tests = ['zfs_destroy_002_pos', 'zfs_destroy_003_pos',
	'zfs_destroy_004_pos', 'zfs_destroy_006_neg', 'zfs_destroy_007_neg',
	'zfs_destroy_008_pos', 'zfs_destroy_009_pos', 'zfs_destroy_010_pos',
	'zfs_destroy_011_pos', 'zfs_destroy_012_pos', 'zfs_destroy_013_neg',
	'zfs_destroy_014_pos', 'zfs_destroy_dev_removal',
	'zfs_destroy_dev_removal_condense']
	tags = ['functional', 'cli_root', 'zfs_destroy']

	[tests/functional/cli_root/zfs_diff]
	tests = ['zfs_diff_cliargs', 'zfs_diff_encrypted']
	tags = ['functional', 'cli_root', 'zfs_diff']

	[tests/functional/cli_root/zfs_get]
	tests = ['zfs_get_003_pos', 'zfs_get_006_neg', 'zfs_get_007_neg',
	'zfs_get_010_neg']
	tags = ['functional', 'cli_root', 'zfs_get']

	[tests/functional/cli_root/zfs_inherit]
	tests = ['zfs_inherit_001_neg', 'zfs_inherit_003_pos', 'zfs_inherit_mountpoint']
	tags = ['functional', 'cli_root', 'zfs_inherit']

	[tests/functional/cli_root/zfs_load-key]
	tests = ['zfs_load-key', 'zfs_load-key_all', 'zfs_load-key_file',
	'zfs_load-key_location', 'zfs_load-key_noop', 'zfs_load-key_recursive']
	tags = ['functional', 'cli_root', 'zfs_load-key']

	[tests/functional/cli_root/zfs_mount]
	tests = ['zfs_mount_001_pos', 'zfs_mount_002_pos', 'zfs_mount_003_pos',
	'zfs_mount_004_pos', 'zfs_mount_005_pos', 'zfs_mount_007_pos',
	'zfs_mount_009_neg', 'zfs_mount_010_neg', 'zfs_mount_011_neg',
	'zfs_mount_012_pos', 'zfs_mount_encrypted', 'zfs_mount_remount',
	'zfs_mount_all_fail', 'zfs_mount_all_mountpoints', 'zfs_mount_test_race']
	tags = ['functional', 'cli_root', 'zfs_mount']

	[tests/functional/cli_root/zfs_program]
	tests = ['zfs_program_json']
	tags = ['functional', 'cli_root', 'zfs_program']

	[tests/functional/cli_root/zfs_promote]
	tests = ['zfs_promote_001_pos', 'zfs_promote_002_pos', 'zfs_promote_003_pos',
	'zfs_promote_004_pos', 'zfs_promote_005_pos', 'zfs_promote_006_neg',
	'zfs_promote_007_neg', 'zfs_promote_008_pos', 'zfs_promote_encryptionroot']
	tags = ['functional', 'cli_root', 'zfs_promote']

	[tests/functional/cli_root/zfs_receive]
	tests = ['zfs_receive_001_pos', 'zfs_receive_002_pos', 'zfs_receive_003_pos',
	'zfs_receive_004_neg', 'zfs_receive_005_neg', 'zfs_receive_006_pos',
	'zfs_receive_007_neg', 'zfs_receive_008_pos', 'zfs_receive_009_neg',
	'zfs_receive_010_pos', 'zfs_receive_011_pos', 'zfs_receive_012_pos',
	'zfs_receive_013_pos', 'zfs_receive_014_pos', 'zfs_receive_015_pos',
	'zfs_receive_016_pos', 'zfs_receive_from_encrypted',
	'zfs_receive_to_encrypted', 'zfs_receive_raw',
	'zfs_receive_raw_incremental', 'zfs_receive_-e',
	'zfs_receive_raw_-d', 'zfs_receive_from_zstd', 'zfs_receive_new_props']
	tags = ['functional', 'cli_root', 'zfs_receive']

	[tests/functional/cli_root/zfs_rename]
	tests = ['zfs_rename_003_pos', 'zfs_rename_004_neg',
	'zfs_rename_005_neg', 'zfs_rename_006_pos', 'zfs_rename_007_pos',
	'zfs_rename_008_pos', 'zfs_rename_009_neg', 'zfs_rename_010_neg',
	'zfs_rename_011_pos', 'zfs_rename_012_neg', 'zfs_rename_013_pos',
	'zfs_rename_encrypted_child', 'zfs_rename_to_encrypted',
	'zfs_rename_mountpoint', 'zfs_rename_nounmount']
	tags = ['functional', 'cli_root', 'zfs_rename']

	[tests/functional/cli_root/zfs_reservation]
	tests = ['zfs_reservation_001_pos', 'zfs_reservation_002_pos']
	tags = ['functional', 'cli_root', 'zfs_reservation']

	[tests/functional/cli_root/zfs_rollback]
	tests = ['zfs_rollback_003_neg', 'zfs_rollback_004_neg']
	tags = ['functional', 'cli_root', 'zfs_rollback']

	[tests/functional/cli_root/zfs_send]
	tests = ['zfs_send_001_pos', 'zfs_send_002_pos', 'zfs_send_003_pos',
	'zfs_send_004_neg', 'zfs_send_005_pos', 'zfs_send_encrypted',
	'zfs_send_raw']
	tags = ['functional', 'cli_root', 'zfs_send']

	[tests/functional/cli_root/zfs_set]
	tests = ['cache_001_pos', 'cache_002_neg', 'canmount_001_pos',
	'canmount_002_pos', 'canmount_003_pos', 'canmount_004_pos',
	'checksum_001_pos', 'compression_001_pos', 'mountpoint_001_pos',
	'mountpoint_002_pos', 'user_property_002_pos',
	'share_mount_001_neg', 'snapdir_001_pos', 'onoffs_001_pos',
	'user_property_001_pos', 'user_property_003_neg', 'readonly_001_pos',
	'user_property_004_pos', 'version_001_neg',
	'zfs_set_003_neg', 'property_alias_001_pos',
	'zfs_set_keylocation', 'zfs_set_feature_activation']
	tags = ['functional', 'cli_root', 'zfs_set']

	[tests/functional/cli_root/zfs_snapshot]
	tests = ['zfs_snapshot_001_neg', 'zfs_snapshot_002_neg',
	'zfs_snapshot_003_neg', 'zfs_snapshot_006_pos', 'zfs_snapshot_007_neg']
	tags = ['functional', 'cli_root', 'zfs_snapshot']

	[tests/functional/cli_root/zfs_unload-key]
	tests = ['zfs_unload-key', 'zfs_unload-key_all', 'zfs_unload-key_recursive']
	tags = ['functional', 'cli_root', 'zfs_unload-key']

	[tests/functional/cli_root/zfs_unmount]
	tests = ['zfs_unmount_001_pos', 'zfs_unmount_002_pos', 'zfs_unmount_003_pos',
	'zfs_unmount_004_pos', 'zfs_unmount_007_neg', 'zfs_unmount_008_neg',
	'zfs_unmount_009_pos', 'zfs_unmount_unload_keys']
	tags = ['functional', 'cli_root', 'zfs_unmount']

	[tests/functional/cli_root/zfs_upgrade]
	tests = ['zfs_upgrade_001_pos', 'zfs_upgrade_002_pos', 'zfs_upgrade_006_neg',
	'zfs_upgrade_007_neg']
	tags = ['functional', 'cli_root', 'zfs_upgrade']

	[tests/functional/cli_root/zfs_wait]
	tests = ['zfs_wait_deleteq']
	tags = ['functional', 'cli_root', 'zfs_wait']

	[tests/functional/cli_root/zpool]
	tests = ['zpool_001_neg', 'zpool_003_pos', 'zpool_colors']
	tags = ['functional', 'cli_root', 'zpool']

	[tests/functional/cli_root/zpool_add]
	tests = ['zpool_add_002_pos', 'zpool_add_003_pos',
	'zpool_add_004_pos', 'zpool_add_006_pos', 'zpool_add_007_neg',
	'zpool_add_008_neg', 'zpool_add_009_neg']
	tags = ['functional', 'cli_root', 'zpool_add']

	[tests/functional/cli_root/zpool_attach]
	tests = ['zpool_attach_001_neg']
	tags = ['functional', 'cli_root', 'zpool_attach']

	[tests/functional/cli_root/zpool_clear]
	tests = ['zpool_clear_002_neg']
	tags = ['functional', 'cli_root', 'zpool_clear']

	[tests/functional/cli_root/zpool_create]
	tests = ['zpool_create_001_pos', 'zpool_create_002_pos',
	'zpool_create_003_pos', 'zpool_create_004_pos', 'zpool_create_007_neg',
	'zpool_create_008_pos', 'zpool_create_010_neg', 'zpool_create_011_neg',
	'zpool_create_012_neg', 'zpool_create_014_neg', 'zpool_create_015_neg',
	'zpool_create_017_neg', 'zpool_create_018_pos', 'zpool_create_019_pos',
	'zpool_create_020_pos', 'zpool_create_021_pos', 'zpool_create_022_pos',
	'zpool_create_encrypted',
	'zpool_create_features_001_pos', 'zpool_create_features_002_pos',
	'zpool_create_features_003_pos', 'zpool_create_features_004_neg',
	'zpool_create_features_005_pos']
	tags = ['functional', 'cli_root', 'zpool_create']

	[tests/functional/cli_root/zpool_destroy]
	tests = ['zpool_destroy_001_pos', 'zpool_destroy_002_pos',
	'zpool_destroy_003_neg']
	pre =
	post =
	tags = ['functional', 'cli_root', 'zpool_destroy']

	[tests/functional/cli_root/zpool_detach]
	tests = ['zpool_detach_001_neg']
	tags = ['functional', 'cli_root', 'zpool_detach']

	[tests/functional/cli_root/zpool_events]
	tests = ['zpool_events_clear', 'zpool_events_follow', 'zpool_events_poolname']
	tags = ['functional', 'cli_root', 'zpool_events']

	[tests/functional/cli_root/zpool_export]
	tests = ['zpool_export_001_pos', 'zpool_export_002_pos', 'zpool_export_003_neg']
	tags = ['functional', 'cli_root', 'zpool_export']

	[tests/functional/cli_root/zpool_get]
	tests = ['zpool_get_001_pos', 'zpool_get_002_pos', 'zpool_get_003_pos',
	'zpool_get_004_neg', 'zpool_get_005_pos']
	tags = ['functional', 'cli_root', 'zpool_get']

	[tests/functional/cli_root/zpool_history]
	tests = ['zpool_history_001_neg', 'zpool_history_002_pos']
	tags = ['functional', 'cli_root', 'zpool_history']

	[tests/functional/cli_root/zpool_import]
	tests = ['zpool_import_003_pos', 'zpool_import_010_pos', 'zpool_import_011_neg',
	'zpool_import_014_pos', 'zpool_import_features_001_pos',
	'zpool_import_all_001_pos', 'zpool_import_encrypted']
	tags = ['functional', 'cli_root', 'zpool_import']

	[tests/functional/cli_root/zpool_labelclear]
	tests = ['zpool_labelclear_active', 'zpool_labelclear_exported',
	'zpool_labelclear_removed', 'zpool_labelclear_valid']
	pre =
	post =
	tags = ['functional', 'cli_root', 'zpool_labelclear']

	[tests/functional/cli_root/zpool_initialize]
	tests = ['zpool_initialize_online_offline']
	pre =
	tags = ['functional', 'cli_root', 'zpool_initialize']

	[tests/functional/cli_root/zpool_offline]
	tests = ['zpool_offline_001_pos', 'zpool_offline_002_neg']
	tags = ['functional', 'cli_root', 'zpool_offline']

	[tests/functional/cli_root/zpool_online]
	tests = ['zpool_online_001_pos', 'zpool_online_002_neg']
	tags = ['functional', 'cli_root', 'zpool_online']

	[tests/functional/cli_root/zpool_remove]
	tests = ['zpool_remove_001_neg', 'zpool_remove_002_pos',
	'zpool_remove_003_pos']
	tags = ['functional', 'cli_root', 'zpool_remove']

	[tests/functional/cli_root/zpool_replace]
	tests = ['zpool_replace_001_neg']
	tags = ['functional', 'cli_root', 'zpool_replace']

	[tests/functional/cli_root/zpool_resilver]
	tests = ['zpool_resilver_bad_args']
	tags = ['functional', 'cli_root', 'zpool_resilver']

	[tests/functional/cli_root/zpool_scrub]
	tests = ['zpool_scrub_001_neg', 'zpool_scrub_003_pos',
	'zpool_scrub_encrypted_unloaded', 'zpool_scrub_print_repairing',
	'zpool_scrub_offline_device', 'zpool_scrub_multiple_copies']
	tags = ['functional', 'cli_root', 'zpool_scrub']

	[tests/functional/cli_root/zpool_set]
	tests = ['zpool_set_001_pos', 'zpool_set_002_neg', 'zpool_set_003_neg',
	'zpool_set_ashift', 'zpool_set_features']
	tags = ['functional', 'cli_root', 'zpool_set']

	[tests/functional/cli_root/zpool_split]
	tests = ['zpool_split_cliargs', 'zpool_split_devices',
	'zpool_split_props', 'zpool_split_vdevs', 'zpool_split_indirect']
	tags = ['functional', 'cli_root', 'zpool_split']

	[tests/functional/cli_root/zpool_status]
	tests = ['zpool_status_001_pos', 'zpool_status_002_pos']
	tags = ['functional', 'cli_root', 'zpool_status']

	[tests/functional/cli_root/zpool_sync]
	tests = ['zpool_sync_002_neg']
	tags = ['functional', 'cli_root', 'zpool_sync']

	[tests/functional/cli_root/zpool_trim]
	tests = ['zpool_trim_attach_detach_add_remove', 'zpool_trim_neg',
	'zpool_trim_offline_export_import_online', 'zpool_trim_online_offline',
	'zpool_trim_rate_neg', 'zpool_trim_secure', 'zpool_trim_split',
	'zpool_trim_start_and_cancel_neg', 'zpool_trim_start_and_cancel_pos']
	tags = ['functional', 'zpool_trim']

	[tests/functional/cli_root/zpool_upgrade]
	tests = ['zpool_upgrade_001_pos', 'zpool_upgrade_003_pos',
	'zpool_upgrade_005_neg', 'zpool_upgrade_006_neg',
	'zpool_upgrade_009_neg']
	tags = ['functional', 'cli_root', 'zpool_upgrade']

	[tests/functional/cli_root/zpool_wait]
	tests = ['zpool_wait_no_activity', 'zpool_wait_usage']
	tags = ['functional', 'cli_root', 'zpool_wait']

	[tests/functional/cli_root/zpool_wait/scan]
	tests = ['zpool_wait_scrub_flag']
	tags = ['functional', 'cli_root', 'zpool_wait']

	[tests/functional/cli_user/misc]
	tests = ['zdb_001_neg', 'zfs_001_neg', 'zfs_allow_001_neg',
	'zfs_clone_001_neg', 'zfs_create_001_neg', 'zfs_destroy_001_neg',
	'zfs_get_001_neg', 'zfs_inherit_001_neg', 'zfs_mount_001_neg',
	'zfs_promote_001_neg', 'zfs_receive_001_neg', 'zfs_rename_001_neg',
	'zfs_rollback_001_neg', 'zfs_send_001_neg', 'zfs_set_001_neg',
	'zfs_snapshot_001_neg', 'zfs_unallow_001_neg',
	'zfs_unmount_001_neg', 'zfs_upgrade_001_neg',
	'zpool_001_neg', 'zpool_add_001_neg', 'zpool_attach_001_neg',
	'zpool_clear_001_neg', 'zpool_create_001_neg', 'zpool_destroy_001_neg',
	'zpool_detach_001_neg', 'zpool_export_001_neg', 'zpool_get_001_neg',
	'zpool_history_001_neg', 'zpool_offline_001_neg', 'zpool_online_001_neg',
	'zpool_remove_001_neg', 'zpool_scrub_001_neg', 'zpool_set_001_neg',
	'zpool_status_001_neg', 'zpool_upgrade_001_neg', 'arcstat_001_pos',
	'arc_summary_001_pos', 'arc_summary_002_neg', 'zpool_wait_privilege']
	user =
	tags = ['functional', 'cli_user', 'misc']

	[tests/functional/cli_user/zpool_iostat]
	tests = ['zpool_iostat_001_neg', 'zpool_iostat_002_pos',
	'zpool_iostat_003_neg', 'zpool_iostat_004_pos',
	'zpool_iostat_-c_disable',
	'zpool_iostat_-c_homedir', 'zpool_iostat_-c_searchpath']
	user =
	tags = ['functional', 'cli_user', 'zpool_iostat']

	[tests/functional/cli_user/zpool_list]
	tests = ['zpool_list_001_pos', 'zpool_list_002_neg']
	user =
	tags = ['functional', 'cli_user', 'zpool_list']

	[tests/functional/compression]
	tests = ['compress_003_pos']
	tags = ['functional', 'compression']

	[tests/functional/exec]
	tests = ['exec_001_pos', 'exec_002_neg']
	tags = ['functional', 'exec']

	[tests/functional/features/large_dnode]
	tests = ['large_dnode_003_pos', 'large_dnode_004_neg',
	'large_dnode_005_pos', 'large_dnode_007_neg']
	tags = ['functional', 'features', 'large_dnode']

	[tests/functional/grow]
	pre =
	post =
	tests = ['grow_pool_001_pos', 'grow_replicas_001_pos']
	tags = ['functional', 'grow']

	[tests/functional/history]
	tests = ['history_004_pos', 'history_005_neg', 'history_006_neg',
	'history_007_pos', 'history_008_pos', 'history_009_pos']
	tags = ['functional', 'history']

	[tests/functional/hkdf]
	tests = ['run_hkdf_test']
	tags = ['functional', 'hkdf']

	[tests/functional/inuse]
	tests = ['inuse_004_pos', 'inuse_005_pos']
	post =
	tags = ['functional', 'inuse']

	[tests/functional/large_files]
	tests = ['large_files_001_pos', 'large_files_002_pos']
	tags = ['functional', 'large_files']

	[tests/functional/libzfs]
	tests = ['many_fds', 'libzfs_input']
	tags = ['functional', 'libzfs']

	[tests/functional/limits]
	tests = ['filesystem_count', 'snapshot_count']
	tags = ['functional', 'limits']

	[tests/functional/link_count]
	tests = ['link_count_root_inode']
	tags = ['functional', 'link_count']

	[tests/functional/log_spacemap]
	tests = ['log_spacemap_import_logs']
	pre =
	post =
	tags = ['functional', 'log_spacemap']

	[tests/functional/migration]
	tests = ['migration_001_pos', 'migration_002_pos', 'migration_003_pos',
	'migration_004_pos', 'migration_005_pos', 'migration_006_pos',
	'migration_007_pos', 'migration_008_pos', 'migration_009_pos',
	'migration_010_pos', 'migration_011_pos', 'migration_012_pos']
	tags = ['functional', 'migration']

	[tests/functional/mmap]
	tests = ['mmap_read_001_pos']
	tags = ['functional', 'mmap']

	[tests/functional/nestedfs]
	tests = ['nestedfs_001_pos']
	tags = ['functional', 'nestedfs']

	[tests/functional/nopwrite]
	tests = ['nopwrite_sync', 'nopwrite_volume']
	tags = ['functional', 'nopwrite']

	[tests/functional/pool_checkpoint]
	tests = ['checkpoint_conf_change', 'checkpoint_discard_many',
	'checkpoint_removal', 'checkpoint_sm_scale', 'checkpoint_twice']
	tags = ['functional', 'pool_checkpoint']
	timeout = 1800

	[tests/functional/poolversion]
	tests = ['poolversion_001_pos', 'poolversion_002_pos']
	tags = ['functional', 'poolversion']

	[tests/functional/redacted_send]
	tests = ['redacted_compressed', 'redacted_contents', 'redacted_deleted',
	'redacted_disabled_feature', 'redacted_incrementals',
	'redacted_largeblocks', 'redacted_mixed_recsize', 'redacted_negative',
	'redacted_origin', 'redacted_props', 'redacted_resume', 'redacted_size']
	tags = ['functional', 'redacted_send']

	[tests/functional/raidz]
	tests = ['raidz_001_neg']
	tags = ['functional', 'raidz']

	[tests/functional/refquota]
	tests = ['refquota_001_pos', 'refquota_002_pos', 'refquota_003_pos',
	'refquota_004_pos', 'refquota_005_pos', 'refquota_006_neg',
	'refquota_007_neg']
	tags = ['functional', 'refquota']

	[tests/functional/refreserv]
	tests = ['refreserv_001_pos', 'refreserv_002_pos', 'refreserv_003_pos',
	'refreserv_005_pos', 'refreserv_multi_raidz']
	tags = ['functional', 'refreserv']

	[tests/functional/removal]
	pre =
	tests = ['removal_all_vdev', 'removal_sanity', 'removal_with_dedup',
	'removal_with_ganging', 'removal_with_faulted']
	tags = ['functional', 'removal']

	[tests/functional/replacement]
	tests = ['rebuild_raidz']
	tags = ['functional', 'replacement']

	[tests/functional/reservation]
	tests = ['reservation_001_pos', 'reservation_002_pos', 'reservation_003_pos',
	'reservation_004_pos', 'reservation_005_pos', 'reservation_006_pos',
	'reservation_007_pos', 'reservation_008_pos', 'reservation_009_pos',
	'reservation_010_pos', 'reservation_011_pos', 'reservation_012_pos',
	'reservation_014_pos', 'reservation_015_pos',
	'reservation_016_pos', 'reservation_017_pos', 'reservation_018_pos',
	'reservation_019_pos', 'reservation_020_pos', 'reservation_021_neg',
	'reservation_022_pos']
	tags = ['functional', 'reservation']

	[tests/functional/rsend]
	tests = ['recv_dedup', 'recv_dedup_encrypted_zvol', 'rsend_001_pos',
	'rsend_002_pos', 'rsend_003_pos', 'rsend_004_pos', 'rsend_005_pos',
	'rsend_006_pos', 'rsend_009_pos', 'rsend_010_pos', 'rsend_011_pos',
	'rsend_014_pos', 'rsend_016_neg', 'send-c_verify_contents',
	'send-c_volume', 'send-c_zstreamdump', 'send-c_recv_dedup',
	'send-L_toggle', 'send_encrypted_hierarchy', 'send_encrypted_props',
	'send_encrypted_truncated_files', 'send_freeobjects', 'send_holds',
	'send_mixed_raw', 'send-wR_encrypted_zvol', 'send_partial_dataset',
	'send_invalid']
	tags = ['functional', 'rsend']

	[tests/functional/scrub_mirror]
	tests = ['scrub_mirror_001_pos', 'scrub_mirror_002_pos']
	tags = ['functional', 'scrub_mirror']

	[tests/functional/slog]
	tests = ['slog_008_neg', 'slog_009_neg', 'slog_010_neg']
	tags = ['functional', 'slog']

	[tests/functional/snapshot]
	tests = ['clone_001_pos', 'rollback_001_pos', 'rollback_002_pos',
	'rollback_003_pos', 'snapshot_001_pos', 'snapshot_002_pos',
	'snapshot_003_pos', 'snapshot_004_pos', 'snapshot_005_pos',
	'snapshot_006_pos', 'snapshot_007_pos', 'snapshot_008_pos',
	'snapshot_009_pos', 'snapshot_010_pos', 'snapshot_011_pos',
	'snapshot_012_pos', 'snapshot_013_pos', 'snapshot_014_pos',
	'snapshot_017_pos']
	tags = ['functional', 'snapshot']

	[tests/functional/snapused]
	tests = ['snapused_002_pos', 'snapused_004_pos', 'snapused_005_pos']
	tags = ['functional', 'snapused']

	[tests/functional/sparse]
	tests = ['sparse_001_pos']
	tags = ['functional', 'sparse']

	[tests/functional/suid]
	tests = ['suid_write_to_suid', 'suid_write_to_sgid', 'suid_write_to_suid_sgid',
	'suid_write_to_none']
	tags = ['functional', 'suid']

	[tests/functional/threadsappend]
	tests = ['threadsappend_001_pos']
	tags = ['functional', 'threadsappend']

	[tests/functional/truncate]
	tests = ['truncate_001_pos', 'truncate_002_pos']
	tags = ['functional', 'truncate']

	[tests/functional/upgrade]
	tests = ['upgrade_userobj_001_pos', 'upgrade_readonly_pool']
	tags = ['functional', 'upgrade']

	[tests/functional/vdev_zaps]
	tests = ['vdev_zaps_001_pos', 'vdev_zaps_003_pos', 'vdev_zaps_004_pos',
	'vdev_zaps_005_pos', 'vdev_zaps_006_pos']
	tags = ['functional', 'vdev_zaps']

	[tests/functional/xattr]
	tests = ['xattr_001_pos', 'xattr_002_neg', 'xattr_003_neg', 'xattr_004_pos',
	'xattr_005_pos', 'xattr_006_pos', 'xattr_007_neg',
	'xattr_011_pos', 'xattr_013_pos']
	tags = ['functional', 'xattr']

	[tests/functional/zvol/zvol_ENOSPC]
	tests = ['zvol_ENOSPC_001_pos']
	tags = ['functional', 'zvol', 'zvol_ENOSPC']

	[tests/functional/zvol/zvol_cli]
	tests = ['zvol_cli_001_pos', 'zvol_cli_002_pos', 'zvol_cli_003_neg']
	tags = ['functional', 'zvol', 'zvol_cli']

	[tests/functional/zvol/zvol_swap]
	tests = ['zvol_swap_001_pos', 'zvol_swap_002_pos']
	tags = ['functional', 'zvol', 'zvol_swap']

	[tests/functional/zpool_influxdb]
	tests = ['zpool_influxdb']
	tags = ['functional', 'zpool_influxdb']
	diff --git a/sys/contrib/openzfs/tests/test-runner/bin/zts-report.py.in b/sys/contrib/openzfs/tests/test-runner/bin/zts-report.py.in
	index c5a1011c102d..a3e9f2a82e69 100755
	--- a/sys/contrib/openzfs/tests/test-runner/bin/zts-report.py.in
	+++ b/sys/contrib/openzfs/tests/test-runner/bin/zts-report.py.in
	@@ -1,424 +1,445 @@
	#!/usr/bin/env @PYTHON_SHEBANG@

	#
	# This file and its contents are supplied under the terms of the
	# Common Development and Distribution License ("CDDL"), version 1.0.
	# You may only use this file in accordance with the terms of version
	# 1.0 of the CDDL.
	#
	# A full copy of the text of the CDDL should have accompanied this
	# source. A copy of the CDDL is also available via the Internet at
	# http://www.illumos.org/license/CDDL.
	#

	#
	# Copyright (c) 2017 by Delphix. All rights reserved.
	# Copyright (c) 2018 by Lawrence Livermore National Security, LLC.
	#
	# This script must remain compatible with Python 2.6+ and Python 3.4+.
	#

	import os
	import re
	import sys

	#
	# This script parses the stdout of zfstest, which has this format:
	#
	# Test: /path/to/testa (run as root) [00:00] [PASS]
	# Test: /path/to/testb (run as jkennedy) [00:00] [PASS]
	# Test: /path/to/testc (run as root) [00:00] [FAIL]
	# [...many more results...]
	#
	# Results Summary
	# FAIL 22
	# SKIP 32
	# PASS 1156
	#
	# Running Time: 02:50:31
	# Percent passed: 95.5%
	# Log directory: /var/tmp/test_results/20180615T205926
	#

	#
	# Common generic reasons for a test or test group to be skipped.
	#
	# Some test cases are known to fail in ways which are not harmful or dangerous.
	# In these cases simply mark the test as a known failure until it can be
	# updated and the issue resolved. Note that it's preferable to open a unique
	# issue on the GitHub issue tracker for each test case failure.
	#
	known_reason = 'Known issue'

	#
	# Some tests require that a test user be able to execute the zfs utilities.
	# This may not be possible when testing in-tree due to the default permissions
	# on the user's home directory. When testing this can be resolved by granting
	# group read access.
	#
	# chmod 0750 $HOME
	#
	exec_reason = 'Test user execute permissions required for utilities'

	#
	# Some tests require a minimum python version of 3.5 and will be skipped when
	# the default system version is too old. There may also be tests which require
	# additional python modules be installed, for example python-cffi is required
	# by the pyzfs tests.
	#
	python_reason = 'Python v3.5 or newer required'
	python_deps_reason = 'Python modules missing: python-cffi'

	#
	# Some tests require the O_TMPFILE flag which was first introduced in the
	# 3.11 kernel.
	#
	tmpfile_reason = 'Kernel O_TMPFILE support required'

	#
	# Some tests require that the NFS client and server utilities be installed.
	#
	share_reason = 'NFS client and server utilities required'

	#
	# Some tests require that the lsattr utility support the project id feature.
	#
	project_id_reason = 'lsattr with set/show project ID required'

	#
	# Some tests require that the kernel support user namespaces.
	#
	user_ns_reason = 'Kernel user namespace support required'

	#
	# Some rewind tests can fail since nothing guarantees that old MOS blocks
	# are not overwritten. Snapshots protect datasets and data files but not
	# the MOS. Reasonable efforts are made in the test case to increase the
	# odds that some txgs will have their MOS data left untouched, but it is
	# never a sure thing.
	#
	rewind_reason = 'Arbitrary pool rewind is not guaranteed'

	#
	# Some tests may by structured in a way that relies on exact knowledge
	# of how much free space in available in a pool. These tests cannot be
	# made completely reliable because the internal details of how free space
	# is managed are not exposed to user space.
	#
	enospc_reason = 'Exact free space reporting is not guaranteed'

	#
	# Some tests require a minimum version of the fio benchmark utility.
	# Older distributions such as CentOS 6.x only provide fio-2.0.13.
	#
	fio_reason = 'Fio v2.3 or newer required'

	#
	# Some tests require that the DISKS provided support the discard operation.
	# Normally this is not an issue because loop back devices are used for DISKS
	# and they support discard (TRIM/UNMAP).
	#
	trim_reason = 'DISKS must support discard (TRIM/UNMAP)'

	#
	# Some tests are not applicable to a platform or need to be updated to operate
	# in the manor required by the platform. Any tests which are skipped for this
	# reason will be suppressed in the final analysis output.
	#
	na_reason = "Not applicable"

	#
	# Some test cases doesn't have all requirements to run on Github actions CI.
	#
	ci_reason = 'CI runner doesn\'t have all requirements'

	summary = {
	'total': float(0),
	'passed': float(0),
	'logfile': "Could not determine logfile location."
	}

	#
	# These tests are known to fail, thus we use this list to prevent these
	# failures from failing the job as a whole; only unexpected failures
	# bubble up to cause this script to exit with a non-zero exit status.
	#
	# Format: { 'test-name': ['expected result', 'issue-number \| reason'] }
	#
	# For each known failure it is recommended to link to a GitHub issue by
	# setting the reason to the issue number. Alternately, one of the generic
	# reasons listed above can be used.
	#
	known = {
	'casenorm/mixed_none_lookup_ci': ['FAIL', '7633'],
	'casenorm/mixed_formd_lookup_ci': ['FAIL', '7633'],
	'cli_root/zfs_unshare/zfs_unshare_002_pos': ['SKIP', na_reason],
	'cli_root/zfs_unshare/zfs_unshare_006_pos': ['SKIP', na_reason],
	'cli_user/misc/zfs_share_001_neg': ['SKIP', na_reason],
	'cli_user/misc/zfs_unshare_001_neg': ['SKIP', na_reason],
	'privilege/setup': ['SKIP', na_reason],
	'refreserv/refreserv_004_pos': ['FAIL', known_reason],
	'rootpool/setup': ['SKIP', na_reason],
	'rsend/rsend_008_pos': ['SKIP', '6066'],
	'vdev_zaps/vdev_zaps_007_pos': ['FAIL', known_reason],
	}

	if sys.platform.startswith('freebsd'):
	known.update({
	'cli_root/zpool_wait/zpool_wait_trim_basic': ['SKIP', trim_reason],
	'cli_root/zpool_wait/zpool_wait_trim_cancel': ['SKIP', trim_reason],
	'cli_root/zpool_wait/zpool_wait_trim_flag': ['SKIP', trim_reason],
	'link_count/link_count_001': ['SKIP', na_reason],
	})
	elif sys.platform.startswith('linux'):
	known.update({
	'casenorm/mixed_formd_lookup': ['FAIL', '7633'],
	'casenorm/mixed_formd_delete': ['FAIL', '7633'],
	'casenorm/sensitive_formd_lookup': ['FAIL', '7633'],
	'casenorm/sensitive_formd_delete': ['FAIL', '7633'],
	'removal/removal_with_zdb': ['SKIP', known_reason],
	})


	#
	# These tests may occasionally fail or be skipped. We want there failures
	# to be reported but only unexpected failures should bubble up to cause
	# this script to exit with a non-zero exit status.
	#
	# Format: { 'test-name': ['expected result', 'issue-number \| reason'] }
	#
	# For each known failure it is recommended to link to a GitHub issue by
	# setting the reason to the issue number. Alternately, one of the generic
	# reasons listed above can be used.
	#
	maybe = {
	'chattr/setup': ['SKIP', exec_reason],
	'cli_root/zdb/zdb_006_pos': ['FAIL', known_reason],
	+ 'cli_root/zfs_destroy/zfs_destroy_dev_removal_condense':
	+ ['FAIL', known_reason],
	'cli_root/zfs_get/zfs_get_004_pos': ['FAIL', known_reason],
	'cli_root/zfs_get/zfs_get_009_pos': ['SKIP', '5479'],
	+ 'cli_root/zfs_rollback/zfs_rollback_001_pos': ['FAIL', known_reason],
	+ 'cli_root/zfs_rollback/zfs_rollback_002_pos': ['FAIL', known_reason],
	'cli_root/zfs_share/setup': ['SKIP', share_reason],
	'cli_root/zfs_snapshot/zfs_snapshot_002_neg': ['FAIL', known_reason],
	'cli_root/zfs_unshare/setup': ['SKIP', share_reason],
	'cli_root/zpool_add/zpool_add_004_pos': ['FAIL', known_reason],
	'cli_root/zpool_destroy/zpool_destroy_001_pos': ['SKIP', '6145'],
	'cli_root/zpool_import/import_rewind_device_replaced':
	['FAIL', rewind_reason],
	'cli_root/zpool_import/import_rewind_config_changed':
	['FAIL', rewind_reason],
	'cli_root/zpool_import/zpool_import_missing_003_pos': ['SKIP', '6839'],
	+ 'cli_root/zpool_initialize/zpool_initialize_import_export':
	+ ['FAIL', '11948'],
	+ 'cli_root/zpool_labelclear/zpool_labelclear_removed':
	+ ['FAIL', known_reason],
	'cli_root/zpool_trim/setup': ['SKIP', trim_reason],
	'cli_root/zpool_upgrade/zpool_upgrade_004_pos': ['FAIL', '6141'],
	'delegate/setup': ['SKIP', exec_reason],
	'history/history_004_pos': ['FAIL', '7026'],
	'history/history_005_neg': ['FAIL', '6680'],
	'history/history_006_neg': ['FAIL', '5657'],
	'history/history_008_pos': ['FAIL', known_reason],
	'history/history_010_pos': ['SKIP', exec_reason],
	'io/mmap': ['SKIP', fio_reason],
	+ 'l2arc/persist_l2arc_005_pos': ['FAIL', known_reason],
	+ 'l2arc/persist_l2arc_007_pos': ['FAIL', '11887'],
	'largest_pool/largest_pool_001_pos': ['FAIL', known_reason],
	'mmp/mmp_on_uberblocks': ['FAIL', known_reason],
	'pyzfs/pyzfs_unittest': ['SKIP', python_deps_reason],
	'no_space/enospc_002_pos': ['FAIL', enospc_reason],
	+ 'pool_checkpoint/checkpoint_discard_busy': ['FAIL', '11946'],
	'projectquota/setup': ['SKIP', exec_reason],
	'redundancy/redundancy_004_neg': ['FAIL', '7290'],
	'redundancy/redundancy_draid_spare3': ['SKIP', known_reason],
	+ 'removal/removal_condense_export': ['FAIL', known_reason],
	'reservation/reservation_008_pos': ['FAIL', '7741'],
	'reservation/reservation_018_pos': ['FAIL', '5642'],
	'rsend/rsend_019_pos': ['FAIL', '6086'],
	'rsend/rsend_020_pos': ['FAIL', '6446'],
	'rsend/rsend_021_pos': ['FAIL', '6446'],
	'rsend/rsend_024_pos': ['FAIL', '5665'],
	'rsend/send-c_volume': ['FAIL', '6087'],
	'rsend/send_partial_dataset': ['FAIL', known_reason],
	'snapshot/clone_001_pos': ['FAIL', known_reason],
	'snapshot/snapshot_009_pos': ['FAIL', '7961'],
	'snapshot/snapshot_010_pos': ['FAIL', '7961'],
	'snapused/snapused_004_pos': ['FAIL', '5513'],
	'tmpfile/setup': ['SKIP', tmpfile_reason],
	'threadsappend/threadsappend_001_pos': ['FAIL', '6136'],
	'trim/setup': ['SKIP', trim_reason],
	'upgrade/upgrade_projectquota_001_pos': ['SKIP', project_id_reason],
	'user_namespace/setup': ['SKIP', user_ns_reason],
	'userquota/setup': ['SKIP', exec_reason],
	'vdev_zaps/vdev_zaps_004_pos': ['FAIL', '6935'],
	'zvol/zvol_ENOSPC/zvol_ENOSPC_001_pos': ['FAIL', '5848'],
	'pam/setup': ['SKIP', "pamtester might be not available"],
	}

	if sys.platform.startswith('freebsd'):
	maybe.update({
	'cli_root/zfs_copies/zfs_copies_002_pos': ['FAIL', known_reason],
	'cli_root/zfs_inherit/zfs_inherit_001_neg': ['FAIL', known_reason],
	'cli_root/zfs_share/zfs_share_011_pos': ['FAIL', known_reason],
	'cli_root/zfs_share/zfs_share_concurrent_shares':
	['FAIL', known_reason],
	'cli_root/zpool_import/zpool_import_012_pos': ['FAIL', known_reason],
	+ 'cli_root/zpool_import/zpool_import_features_001_pos':
	+ ['FAIL', '11854'],
	+ 'cli_root/zpool_import/zpool_import_features_002_neg':
	+ ['FAIL', '11854'],
	+ 'cli_root/zpool_import/zpool_import_features_003_pos':
	+ ['FAIL', '11854'],
	'delegate/zfs_allow_003_pos': ['FAIL', known_reason],
	- 'removal/removal_condense_export': ['FAIL', known_reason],
	- 'removal/removal_with_export': ['FAIL', known_reason],
	+ 'inheritance/inherit_001_pos': ['FAIL', '11829'],
	+ 'pool_checkpoint/checkpoint_zhack_feat': ['FAIL', '11854'],
	'resilver/resilver_restart_001': ['FAIL', known_reason],
	'zvol/zvol_misc/zvol_misc_volmode': ['FAIL', known_reason],
	})
	elif sys.platform.startswith('linux'):
	maybe.update({
	'alloc_class/alloc_class_009_pos': ['FAIL', known_reason],
	'alloc_class/alloc_class_010_pos': ['FAIL', known_reason],
	'alloc_class/alloc_class_011_neg': ['FAIL', known_reason],
	+ 'alloc_class/alloc_class_013_pos': ['FAIL', '11888'],
	'cli_root/zfs_rename/zfs_rename_002_pos': ['FAIL', known_reason],
	'cli_root/zpool_expand/zpool_expand_001_pos': ['FAIL', known_reason],
	'cli_root/zpool_expand/zpool_expand_005_pos': ['FAIL', known_reason],
	'cli_root/zpool_reopen/zpool_reopen_003_pos': ['FAIL', known_reason],
	+ 'fault/auto_spare_shared': ['FAIL', '11889'],
	'io/io_uring': ['SKIP', 'io_uring support required'],
	'limits/filesystem_limit': ['SKIP', known_reason],
	'limits/snapshot_limit': ['SKIP', known_reason],
	+ 'mmp/mmp_active_import': ['FAIL', known_reason],
	'mmp/mmp_exported_import': ['FAIL', known_reason],
	'mmp/mmp_inactive_import': ['FAIL', known_reason],
	'refreserv/refreserv_raidz': ['FAIL', known_reason],
	'rsend/rsend_007_pos': ['FAIL', known_reason],
	'rsend/rsend_010_pos': ['FAIL', known_reason],
	'rsend/rsend_011_pos': ['FAIL', known_reason],
	'snapshot/rollback_003_pos': ['FAIL', known_reason],
	})


	# Not all Github actions runners have scsi_debug module, so we may skip
	# some tests which use it.
	if os.environ.get('CI') == 'true':
	known.update({
	'cli_root/zpool_expand/zpool_expand_001_pos': ['SKIP', ci_reason],
	'cli_root/zpool_expand/zpool_expand_003_neg': ['SKIP', ci_reason],
	'cli_root/zpool_expand/zpool_expand_005_pos': ['SKIP', ci_reason],
	'cli_root/zpool_reopen/setup': ['SKIP', ci_reason],
	'cli_root/zpool_reopen/zpool_reopen_001_pos': ['SKIP', ci_reason],
	'cli_root/zpool_reopen/zpool_reopen_002_pos': ['SKIP', ci_reason],
	'cli_root/zpool_reopen/zpool_reopen_003_pos': ['SKIP', ci_reason],
	'cli_root/zpool_reopen/zpool_reopen_004_pos': ['SKIP', ci_reason],
	'cli_root/zpool_reopen/zpool_reopen_005_pos': ['SKIP', ci_reason],
	'cli_root/zpool_reopen/zpool_reopen_006_neg': ['SKIP', ci_reason],
	'cli_root/zpool_reopen/zpool_reopen_007_pos': ['SKIP', ci_reason],
	'cli_root/zpool_split/zpool_split_wholedisk': ['SKIP', ci_reason],
	'fault/auto_offline_001_pos': ['SKIP', ci_reason],
	'fault/auto_online_001_pos': ['SKIP', ci_reason],
	'fault/auto_replace_001_pos': ['SKIP', ci_reason],
	'fault/auto_spare_ashift': ['SKIP', ci_reason],
	'fault/auto_spare_shared': ['SKIP', ci_reason],
	'procfs/pool_state': ['SKIP', ci_reason],
	})

	maybe.update({
	'events/events_002_pos': ['FAIL', '11546'],
	})


	def usage(s):
	print(s)
	sys.exit(1)


	def process_results(pathname):
	try:
	f = open(pathname)
	except IOError as e:
	print('Error opening file: %s' % e)
	sys.exit(1)

	prefix = '/zfs-tests/tests/functional/'
	pattern = \
	r'^Test(?:\s+$\S+$)?:' + \
	r'\s\S%s(\S+)\s$run as (\S+)$\s\[(\S+)\]\s*\[(\S+)\]' \
	% prefix
	pattern_log = r'^\sLog directory:\s(\S*)'

	d = {}
	for line in f.readlines():
	m = re.match(pattern, line)
	if m and len(m.groups()) == 4:
	summary['total'] += 1
	if m.group(4) == "PASS":
	summary['passed'] += 1
	d[m.group(1)] = m.group(4)
	continue

	m = re.match(pattern_log, line)
	if m:
	summary['logfile'] = m.group(1)

	return d


	if __name__ == "__main__":
	if len(sys.argv) != 2:
	usage('usage: %s <pathname>' % sys.argv[0])
	results = process_results(sys.argv[1])

	if summary['total'] == 0:
	print("\n\nNo test results were found.")
	print("Log directory: %s" % summary['logfile'])
	sys.exit(0)

	expected = []
	unexpected = []

	for test in list(results.keys()):
	if results[test] == "PASS":
	continue

	setup = test.replace(os.path.basename(test), "setup")
	if results[test] == "SKIP" and test != setup:
	if setup in known and known[setup][0] == "SKIP":
	continue
	if setup in maybe and maybe[setup][0] == "SKIP":
	continue

	if ((test not in known or results[test] not in known[test][0]) and
	(test not in maybe or results[test] not in maybe[test][0])):
	unexpected.append(test)
	else:
	expected.append(test)

	print("\nTests with results other than PASS that are expected:")
	for test in sorted(expected):
	issue_url = 'https://github.com/openzfs/zfs/issues/'

	# Include the reason why the result is expected, given the following:
	# 1. Suppress test results which set the "Not applicable" reason.
	# 2. Numerical reasons are assumed to be GitHub issue numbers.
	# 3. When an entire test group is skipped only report the setup reason.
	if test in known:
	if known[test][1] == na_reason:
	continue
	elif known[test][1].isdigit():
	expect = issue_url + known[test][1]
	else:
	expect = known[test][1]
	elif test in maybe:
	if maybe[test][1].isdigit():
	expect = issue_url + maybe[test][1]
	else:
	expect = maybe[test][1]
	elif setup in known and known[setup][0] == "SKIP" and setup != test:
	continue
	elif setup in maybe and maybe[setup][0] == "SKIP" and setup != test:
	continue
	else:
	expect = "UNKNOWN REASON"
	print(" %s %s (%s)" % (results[test], test, expect))

	print("\nTests with result of PASS that are unexpected:")
	for test in sorted(known.keys()):
	# We probably should not be silently ignoring the case
	# where "test" is not in "results".
	if test not in results or results[test] != "PASS":
	continue
	print(" %s %s (expected %s)" % (results[test], test,
	known[test][0]))

	print("\nTests with results other than PASS that are unexpected:")
	for test in sorted(unexpected):
	expect = "PASS" if test not in known else known[test][0]
	print(" %s %s (expected %s)" % (results[test], test, expect))

	if len(unexpected) == 0:
	sys.exit(0)
	else:
	sys.exit(1)
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/cmd/draid/draid.c b/sys/contrib/openzfs/tests/zfs-tests/cmd/draid/draid.c
	index 861c6ba1a8c2..57261348b3cd 100644
	--- a/sys/contrib/openzfs/tests/zfs-tests/cmd/draid/draid.c
	+++ b/sys/contrib/openzfs/tests/zfs-tests/cmd/draid/draid.c
	@@ -1,1414 +1,1414 @@
	/*
	* 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) 2018 Intel Corporation.
	* Copyright (c) 2020 by Lawrence Livermore National Security, LLC.
	*/

	#include <stdio.h>
	#include <zlib.h>
	#include <zfs_fletcher.h>
	#include <sys/vdev_draid.h>
	#include <sys/nvpair.h>
	#include <sys/stat.h>

	/*
	* The number of rows to generate for new permutation maps.
	*/
	#define MAP_ROWS_DEFAULT 256

	/*
	* Key values for dRAID maps when stored as nvlists.
	*/
	#define MAP_SEED "seed"
	#define MAP_CHECKSUM "checksum"
	#define MAP_WORST_RATIO "worst_ratio"
	#define MAP_AVG_RATIO "avg_ratio"
	#define MAP_CHILDREN "children"
	#define MAP_NPERMS "nperms"
	#define MAP_PERMS "perms"

	static void
	draid_usage(void)
	{
	(void) fprintf(stderr,
	"usage: draid command args ...\n"
	"Available commands are:\n"
	"\n"
	"\tdraid generate [-cv] [-m min] [-n max] [-p passes] FILE\n"
	"\tdraid verify [-rv] FILE\n"
	"\tdraid dump [-v] [-m min] [-n max] FILE\n"
	"\tdraid table FILE\n"
	"\tdraid merge FILE SRC SRC...\n");
	exit(1);
	}

	static int
	read_map(const char filename, nvlist_t *allcfgs)
	{
	int block_size = 131072;
	int buf_size = 131072;
	int tmp_size, error;
	char *tmp_buf;

	struct stat64 stat;
	if (lstat64(filename, &stat) != 0)
	return (errno);

	if (stat.st_size == 0 \|\|
	!(S_ISREG(stat.st_mode) \|\| S_ISLNK(stat.st_mode))) {
	return (EINVAL);
	}

	gzFile fp = gzopen(filename, "rb");
	if (fp == Z_NULL)
	return (errno);

	char *buf = malloc(buf_size);
	if (buf == NULL) {
	(void) gzclose(fp);
	return (ENOMEM);
	}

	ssize_t rc, bytes = 0;
	while (!gzeof(fp)) {
	rc = gzread(fp, buf + bytes, block_size);
	if ((rc < 0) \|\| (rc == 0 && !gzeof(fp))) {
	free(buf);
	(void) gzclose(fp);
	(void) gzerror(fp, &error);
	return (error);
	} else {
	bytes += rc;

	if (bytes + block_size >= buf_size) {
	tmp_size = 2 * buf_size;
	tmp_buf = malloc(tmp_size);
	if (tmp_buf == NULL) {
	free(buf);
	(void) gzclose(fp);
	return (ENOMEM);
	}

	memcpy(tmp_buf, buf, bytes);
	free(buf);
	buf = tmp_buf;
	buf_size = tmp_size;
	}
	}
	}

	(void) gzclose(fp);

	error = nvlist_unpack(buf, bytes, allcfgs, 0);
	free(buf);

	return (error);
	}

	/*
	* Read a map from the specified filename. A file contains multiple maps
	* which are indexed by the number of children. The caller is responsible
	* for freeing the configuration returned.
	*/
	static int
	read_map_key(const char filename, char key, nvlist_t **cfg)
	{
	nvlist_t allcfgs, foundcfg = NULL;
	int error;

	error = read_map(filename, &allcfgs);
	if (error != 0)
	return (error);

	nvlist_lookup_nvlist(allcfgs, key, &foundcfg);
	if (foundcfg != NULL) {
	nvlist_dup(foundcfg, cfg, KM_SLEEP);
	error = 0;
	} else {
	error = ENOENT;
	}

	nvlist_free(allcfgs);

	return (error);
	}

	/*
	* Write all mappings to the map file.
	*/
	static int
	write_map(const char filename, nvlist_t allcfgs)
	{
	size_t buflen = 0;
	int error;

	error = nvlist_size(allcfgs, &buflen, NV_ENCODE_XDR);
	if (error)
	return (error);

	char *buf = malloc(buflen);
	if (buf == NULL)
	return (ENOMEM);

	error = nvlist_pack(allcfgs, &buf, &buflen, NV_ENCODE_XDR, KM_SLEEP);
	if (error) {
	free(buf);
	return (error);
	}

	/*
	* Atomically update the file using a temporary file and the
	* traditional unlink then rename steps. This code provides
	* no locking, it only guarantees the packed nvlist on disk
	* is updated atomically and is internally consistent.
	*/
	char *tmpname = calloc(MAXPATHLEN, 1);
	if (tmpname == NULL) {
	free(buf);
	return (ENOMEM);
	}

	snprintf(tmpname, MAXPATHLEN - 1, "%s.XXXXXX", filename);

	int fd = mkstemp(tmpname);
	if (fd < 0) {
	error = errno;
	free(buf);
	free(tmpname);
	return (error);
	}
	(void) close(fd);

	gzFile fp = gzopen(tmpname, "w9b");
	if (fp == Z_NULL) {
	error = errno;
	free(buf);
	free(tmpname);
	return (errno);
	}

	ssize_t rc, bytes = 0;
	while (bytes < buflen) {
	size_t size = MIN(buflen - bytes, 131072);
	rc = gzwrite(fp, buf + bytes, size);
	if (rc < 0) {
	free(buf);
	(void) gzerror(fp, &error);
	(void) gzclose(fp);
	(void) unlink(tmpname);
	free(tmpname);
	return (error);
	} else if (rc == 0) {
	break;
	} else {
	bytes += rc;
	}
	}

	free(buf);
	(void) gzclose(fp);

	if (bytes != buflen) {
	(void) unlink(tmpname);
	free(tmpname);
	return (EIO);
	}

	/*
	* Unlink the previous config file and replace it with the updated
	* version. If we're able to unlink the file then directory is
	* writable by us and the subsequent rename should never fail.
	*/
	error = unlink(filename);
	if (error != 0 && errno != ENOENT) {
	error = errno;
	(void) unlink(tmpname);
	free(tmpname);
	return (error);
	}

	error = rename(tmpname, filename);
	if (error != 0) {
	error = errno;
	(void) unlink(tmpname);
	free(tmpname);
	return (error);
	}

	free(tmpname);

	return (0);
	}

	/*
	* Add the dRAID map to the file and write it out.
	*/
	static int
	write_map_key(const char filename, char key, draid_map_t *map,
	double worst_ratio, double avg_ratio)
	{
	nvlist_t nv_cfg, allcfgs;
	int error;

	/*
	* Add the configuration to an existing or new file. The new
	* configuration will replace an existing configuration with the
	* same key if it has a lower ratio and is therefore better.
	*/
	error = read_map(filename, &allcfgs);
	if (error == ENOENT) {
	allcfgs = fnvlist_alloc();
	} else if (error != 0) {
	return (error);
	}

	error = nvlist_lookup_nvlist(allcfgs, key, &nv_cfg);
	if (error == 0) {
	uint64_t nv_cfg_worst_ratio = fnvlist_lookup_uint64(nv_cfg,
	MAP_WORST_RATIO);
	double nv_worst_ratio = (double)nv_cfg_worst_ratio / 1000.0;

	if (worst_ratio < nv_worst_ratio) {
	/* Replace old map with the more balanced new map. */
	fnvlist_remove(allcfgs, key);
	} else {
	/* The old map is preferable, keep it. */
	nvlist_free(allcfgs);
	return (EEXIST);
	}
	}

	nvlist_t *cfg = fnvlist_alloc();
	fnvlist_add_uint64(cfg, MAP_SEED, map->dm_seed);
	fnvlist_add_uint64(cfg, MAP_CHECKSUM, map->dm_checksum);
	fnvlist_add_uint64(cfg, MAP_CHILDREN, map->dm_children);
	fnvlist_add_uint64(cfg, MAP_NPERMS, map->dm_nperms);
	fnvlist_add_uint8_array(cfg, MAP_PERMS, map->dm_perms,
	map->dm_children * map->dm_nperms * sizeof (uint8_t));

	fnvlist_add_uint64(cfg, MAP_WORST_RATIO,
	(uint64_t)(worst_ratio * 1000.0));
	fnvlist_add_uint64(cfg, MAP_AVG_RATIO,
	(uint64_t)(avg_ratio * 1000.0));

	error = nvlist_add_nvlist(allcfgs, key, cfg);
	if (error == 0)
	error = write_map(filename, allcfgs);

	nvlist_free(cfg);
	nvlist_free(allcfgs);
	return (error);
	}

	static void
	dump_map(draid_map_t map, char key, double worst_ratio, double avg_ratio,
	int verbose)
	{
	if (verbose == 0) {
	return;
	} else if (verbose == 1) {
	printf(" \"%s\": seed: 0x%016llx worst_ratio: %2.03f "
	"avg_ratio: %2.03f\n", key, (u_longlong_t)map->dm_seed,
	worst_ratio, avg_ratio);
	return;
	} else {
	printf(" \"%s\":\n"
	" seed: 0x%016llx\n"
	" checksum: 0x%016llx\n"
	" worst_ratio: %2.03f\n"
	" avg_ratio: %2.03f\n"
	" children: %llu\n"
	" nperms: %llu\n",
	key, (u_longlong_t)map->dm_seed,
	(u_longlong_t)map->dm_checksum, worst_ratio, avg_ratio,
	(u_longlong_t)map->dm_children,
	(u_longlong_t)map->dm_nperms);

	if (verbose > 2) {
	printf(" perms = {\n");
	for (int i = 0; i < map->dm_nperms; i++) {
	printf(" { ");
	for (int j = 0; j < map->dm_children; j++) {
	printf("%3d%s ", map->dm_perms[
	i * map->dm_children + j],
	j < map->dm_children - 1 ?
	"," : "");
	}
	printf(" },\n");
	}
	printf(" }\n");
	} else if (verbose == 2) {
	printf(" draid_perms = <omitted>\n");
	}
	}
	}

	static void
	dump_map_nv(char key, nvlist_t cfg, int verbose)
	{
	draid_map_t map;
	uint_t c;

	uint64_t worst_ratio = fnvlist_lookup_uint64(cfg, MAP_WORST_RATIO);
	uint64_t avg_ratio = fnvlist_lookup_uint64(cfg, MAP_AVG_RATIO);

	map.dm_seed = fnvlist_lookup_uint64(cfg, MAP_SEED);
	map.dm_checksum = fnvlist_lookup_uint64(cfg, MAP_CHECKSUM);
	map.dm_children = fnvlist_lookup_uint64(cfg, MAP_CHILDREN);
	map.dm_nperms = fnvlist_lookup_uint64(cfg, MAP_NPERMS);
	nvlist_lookup_uint8_array(cfg, MAP_PERMS, &map.dm_perms, &c);

	dump_map(&map, key, (double)worst_ratio / 1000.0,
	avg_ratio / 1000.0, verbose);
	}

	/*
	* Print a summary of the mapping.
	*/
	static int
	dump_map_key(const char filename, char key, int verbose)
	{
	nvlist_t *cfg;
	int error;

	error = read_map_key(filename, key, &cfg);
	if (error != 0)
	return (error);

	dump_map_nv(key, cfg, verbose);

	return (0);
	}

	/*
	* Allocate a new permutation map for evaluation.
	*/
	static int
	alloc_new_map(uint64_t children, uint64_t nperms, uint64_t seed,
	draid_map_t **mapp)
	{
	draid_map_t *map;
	int error;

	map = malloc(sizeof (draid_map_t));
	if (map == NULL)
	return (ENOMEM);

	map->dm_children = children;
	map->dm_nperms = nperms;
	map->dm_seed = seed;
	map->dm_checksum = 0;

	error = vdev_draid_generate_perms(map, &map->dm_perms);
	if (error) {
	free(map);
	return (error);
	}

	*mapp = map;

	return (0);
	}

	/*
	* Allocate the fixed permutation map for N children.
	*/
	static int
	alloc_fixed_map(uint64_t children, draid_map_t **mapp)
	{
	const draid_map_t *fixed_map;
	draid_map_t *map;
	int error;

	error = vdev_draid_lookup_map(children, &fixed_map);
	if (error)
	return (error);

	map = malloc(sizeof (draid_map_t));
	if (map == NULL)
	return (ENOMEM);

	memcpy(map, fixed_map, sizeof (draid_map_t));
	VERIFY3U(map->dm_checksum, !=, 0);

	error = vdev_draid_generate_perms(map, &map->dm_perms);
	if (error) {
	free(map);
	return (error);
	}

	*mapp = map;

	return (0);
	}

	/*
	* Free a permutation map.
	*/
	static void
	free_map(draid_map_t *map)
	{
	free(map->dm_perms);
	free(map);
	}

	/*
	* Check if dev is in the provided list of faulted devices.
	*/
	static inline boolean_t
	is_faulted(int *faulted_devs, int nfaulted, int dev)
	{
	for (int i = 0; i < nfaulted; i++)
	if (faulted_devs[i] == dev)
	return (B_TRUE);

	return (B_FALSE);
	}

	/*
	* Evaluate how resilvering I/O will be distributed given a list of faulted
	* vdevs. As a simplification we assume one IO is sufficient to repair each
	* damaged device in a group.
	*/
	static double
	eval_resilver(draid_map_t *map, uint64_t groupwidth, uint64_t nspares,
	int faulted_devs, int nfaulted, int min_child_ios, int *max_child_ios)
	{
	uint64_t children = map->dm_children;
	uint64_t ngroups = 1;
	uint64_t ndisks = children - nspares;

	/*
	* Calculate the minimum number of groups required to fill a slice.
	*/
	while (ngroups * (groupwidth) % (children - nspares) != 0)
	ngroups++;

	int *ios = calloc(map->dm_children, sizeof (uint64_t));

	/* Resilver all rows */
	for (int i = 0; i < map->dm_nperms; i++) {
	uint8_t row = &map->dm_perms[i map->dm_children];

	/* Resilver all groups with faulted drives */
	for (int j = 0; j < ngroups; j++) {
	uint64_t spareidx = map->dm_children - nspares;
	boolean_t repair_needed = B_FALSE;

	/* See if any devices in this group are faulted */
	uint64_t groupstart = (j * groupwidth) % ndisks;

	for (int k = 0; k < groupwidth; k++) {
	uint64_t groupidx = (groupstart + k) % ndisks;

	repair_needed = is_faulted(faulted_devs,
	nfaulted, row[groupidx]);
	if (repair_needed)
	break;
	}

	if (repair_needed == B_FALSE)
	continue;

	/*
	* This group is degraded. Calculate the number of
	* reads the non-faulted drives require and the number
	* of writes to the distributed hot spare for this row.
	*/
	for (int k = 0; k < groupwidth; k++) {
	uint64_t groupidx = (groupstart + k) % ndisks;

	if (!is_faulted(faulted_devs, nfaulted,
	row[groupidx])) {
	ios[row[groupidx]]++;
	} else if (nspares > 0) {
	while (is_faulted(faulted_devs,
	nfaulted, row[spareidx])) {
	spareidx++;
	}

	ASSERT3U(spareidx, <, map->dm_children);
	ios[row[spareidx]]++;
	spareidx++;
	}
	}
	}
	}

	*min_child_ios = INT_MAX;
	*max_child_ios = 0;

	/*
	* Find the drives with fewest and most required I/O. These values
	* are used to calculate the imbalance ratio. To avoid returning an
	* infinite value for permutations which have children that perform
	* no IO a floor of 1 IO per child is set. This ensures a meaningful
	* ratio is returned for comparison and it is not an uncommon when
	* there are a large number of children.
	*/
	for (int i = 0; i < map->dm_children; i++) {

	if (is_faulted(faulted_devs, nfaulted, i)) {
	ASSERT0(ios[i]);
	continue;
	}

	if (ios[i] == 0)
	ios[i] = 1;

	if (ios[i] < *min_child_ios)
	*min_child_ios = ios[i];

	if (ios[i] > *max_child_ios)
	*max_child_ios = ios[i];
	}

	ASSERT3S(*min_child_ios, !=, INT_MAX);
	ASSERT3S(*max_child_ios, !=, 0);

	double ratio = (double)(max_child_ios) / (double)(min_child_ios);

	free(ios);

	return (ratio);
	}

	/*
	* Evaluate the quality of the permutation mapping by considering possible
	* device failures. Returns the imbalance ratio for the worst mapping which
	* is defined to be the largest number of child IOs over the fewest number
	* child IOs. A value of 1.0 indicates the mapping is perfectly balance and
	* all children perform an equal amount of work during reconstruction.
	*/
	static void
	eval_decluster(draid_map_t map, double worst_ratiop, double *avg_ratiop)
	{
	uint64_t children = map->dm_children;
	double worst_ratio = 1.0;
	double sum = 0;
	int worst_min_ios = 0, worst_max_ios = 0;
	int n = 0;

	/*
	* When there are only 2 children there can be no distributed
	* spare and no resilver to evaluate. Default to a ratio of 1.0
	* for this degenerate case.
	*/
	if (children == VDEV_DRAID_MIN_CHILDREN) {
	*worst_ratiop = 1.0;
	*avg_ratiop = 1.0;
	return;
	}

	/*
	* Score the mapping as if it had either 1 or 2 distributed spares.
	*/
	for (int nspares = 1; nspares <= 2; nspares++) {
	uint64_t faults = nspares;

	/*
	- * Score groupwidths up to 19. This value was choosen as the
	+ * Score groupwidths up to 19. This value was chosen as the
	* largest reasonable width (16d+3p). dRAID pools may be still
	* be created with wider stripes but they are not considered in
	* this analysis in order to optimize for the most common cases.
	*/
	for (uint64_t groupwidth = 2;
	groupwidth <= MIN(children - nspares, 19);
	groupwidth++) {
	int faulted_devs[2];
	int min_ios, max_ios;

	/*
	* Score possible devices faults. This is limited
	* to exactly one fault per distributed spare for
	* the purposes of this similation.
	*/
	for (int f1 = 0; f1 < children; f1++) {
	faulted_devs[0] = f1;
	double ratio;

	if (faults == 1) {
	ratio = eval_resilver(map, groupwidth,
	nspares, faulted_devs, faults,
	&min_ios, &max_ios);

	if (ratio > worst_ratio) {
	worst_ratio = ratio;
	worst_min_ios = min_ios;
	worst_max_ios = max_ios;
	}

	sum += ratio;
	n++;
	} else if (faults == 2) {
	for (int f2 = f1 + 1; f2 < children;
	f2++) {
	faulted_devs[1] = f2;

	ratio = eval_resilver(map,
	groupwidth, nspares,
	faulted_devs, faults,
	&min_ios, &max_ios);

	if (ratio > worst_ratio) {
	worst_ratio = ratio;
	worst_min_ios = min_ios;
	worst_max_ios = max_ios;
	}

	sum += ratio;
	n++;
	}
	}
	}
	}
	}

	*worst_ratiop = worst_ratio;
	*avg_ratiop = sum / n;

	/*
	* Log the min/max io values for particularly unbalanced maps.
	* Since the maps are generated entirely randomly these are possible
	* be exceedingly unlikely. We log it for possible investigation.
	*/
	if (worst_ratio > 100.0) {
	dump_map(map, "DEBUG", worst_ratio, *avg_ratiop, 2);
	printf("worst_min_ios=%d worst_max_ios=%d\n",
	worst_min_ios, worst_max_ios);
	}
	}

	static int
	eval_maps(uint64_t children, int passes, uint64_t *map_seed,
	draid_map_t *best_mapp, double best_ratiop, double *avg_ratiop)
	{
	draid_map_t *best_map = NULL;
	double best_worst_ratio = 1000.0;
	double best_avg_ratio = 1000.0;

	/*
	* Perform the requested number of passes evaluating randomly
	* generated permutation maps. Only the best version is kept.
	*/
	for (int i = 0; i < passes; i++) {
	double worst_ratio, avg_ratio;
	draid_map_t *map;
	int error;

	/*
	* Calculate the next seed and generate a new candidate map.
	*/
	error = alloc_new_map(children, MAP_ROWS_DEFAULT,
	vdev_draid_rand(map_seed), &map);
	if (error)
	return (error);

	/*
	* Consider maps with a lower worst_ratio to be of higher
	* quality. Some maps may have a lower avg_ratio but they
	* are discarded since they might include some particularly
	- * imbalanced permuations. The average is tracked to in
	+ * imbalanced permutations. The average is tracked to in
	* order to get a sense of the average permutation quality.
	*/
	eval_decluster(map, &worst_ratio, &avg_ratio);

	if (best_map == NULL \|\| worst_ratio < best_worst_ratio) {

	if (best_map != NULL)
	free_map(best_map);

	best_map = map;
	best_worst_ratio = worst_ratio;
	best_avg_ratio = avg_ratio;
	} else {
	free_map(map);
	}
	}

	/*
	* After determining the best map generate a checksum over the full
	* permutation array. This checksum is verified when opening a dRAID
	* pool to ensure the generated in memory permutations are correct.
	*/
	zio_cksum_t cksum;
	fletcher_4_native_varsize(best_map->dm_perms,
	sizeof (uint8_t) * best_map->dm_children * best_map->dm_nperms,
	&cksum);
	best_map->dm_checksum = cksum.zc_word[0];

	*best_mapp = best_map;
	*best_ratiop = best_worst_ratio;
	*avg_ratiop = best_avg_ratio;

	return (0);
	}

	static int
	draid_generate(int argc, char *argv[])
	{
	char filename[MAXPATHLEN];
	uint64_t map_seed;
	int c, fd, error, verbose = 0, passes = 1, continuous = 0;
	int min_children = VDEV_DRAID_MIN_CHILDREN;
	int max_children = VDEV_DRAID_MAX_CHILDREN;
	int restarts = 0;

	while ((c = getopt(argc, argv, ":cm:n:p:v")) != -1) {
	switch (c) {
	case 'c':
	continuous++;
	break;
	case 'm':
	min_children = (int)strtol(optarg, NULL, 0);
	if (min_children < VDEV_DRAID_MIN_CHILDREN) {
	(void) fprintf(stderr, "A minimum of 2 "
	"children are required.\n");
	return (1);
	}

	break;
	case 'n':
	max_children = (int)strtol(optarg, NULL, 0);
	if (max_children > VDEV_DRAID_MAX_CHILDREN) {
	(void) fprintf(stderr, "A maximum of %d "
	"children are allowed.\n",
	VDEV_DRAID_MAX_CHILDREN);
	return (1);
	}
	break;
	case 'p':
	passes = (int)strtol(optarg, NULL, 0);
	break;
	case 'v':
	/*
	* 0 - Only log when a better map is added to the file.
	* 1 - Log the current best map for each child count.
	* Minimal output on a single summary line.
	* 2 - Log the current best map for each child count.
	* More verbose includes most map fields.
	* 3 - Log the current best map for each child count.
	* Very verbose all fields including the full map.
	*/
	verbose++;
	break;
	case ':':
	(void) fprintf(stderr,
	"missing argument for '%c' option\n", optopt);
	draid_usage();
	break;
	case '?':
	(void) fprintf(stderr, "invalid option '%c'\n",
	optopt);
	draid_usage();
	break;
	}
	}

	if (argc > optind) {
	bzero(filename, MAXPATHLEN);
	strncpy(filename, argv[optind], MAXPATHLEN - 1);
	} else {
	(void) fprintf(stderr, "A FILE must be specified.\n");
	return (1);
	}

	restart:
	/*
	* Start with a fresh seed from /dev/urandom.
	*/
	fd = open("/dev/urandom", O_RDONLY);
	if (fd < 0) {
	printf("Unable to open /dev/urandom: %s\n:", strerror(errno));
	return (1);
	} else {
	ssize_t bytes = sizeof (map_seed);
	ssize_t bytes_read = 0;

	while (bytes_read < bytes) {
	ssize_t rc = read(fd, ((char *)&map_seed) + bytes_read,
	bytes - bytes_read);
	if (rc < 0) {
	printf("Unable to read /dev/urandom: %s\n:",
	strerror(errno));
	return (1);
	}
	bytes_read += rc;
	}

	(void) close(fd);
	}

	if (restarts == 0)
	printf("Writing generated mappings to '%s':\n", filename);

	/*
	* Generate maps for all requested child counts. The best map for
	* each child count is written out to the specified file. If the file
	* already contains a better mapping this map will not be added.
	*/
	for (uint64_t children = min_children;
	children <= max_children; children++) {
	char key[8] = { 0 };
	draid_map_t *map;
	double worst_ratio = 1000.0;
	double avg_ratio = 1000.0;

	error = eval_maps(children, passes, &map_seed, &map,
	&worst_ratio, &avg_ratio);
	if (error) {
	printf("Error eval_maps(): %s\n", strerror(error));
	return (1);
	}

	if (worst_ratio < 1.0 \|\| avg_ratio < 1.0) {
	printf("Error ratio < 1.0: worst_ratio = %2.03f "
	"avg_ratio = %2.03f\n", worst_ratio, avg_ratio);
	return (1);
	}

	snprintf(key, 7, "%llu", (u_longlong_t)children);
	error = write_map_key(filename, key, map, worst_ratio,
	avg_ratio);
	if (error == 0) {
	/* The new map was added to the file. */
	dump_map(map, key, worst_ratio, avg_ratio,
	MAX(verbose, 1));
	} else if (error == EEXIST) {
	/* The existing map was preferable and kept. */
	if (verbose > 0)
	dump_map_key(filename, key, verbose);
	} else {
	printf("Error write_map_key(): %s\n", strerror(error));
	return (1);
	}

	free_map(map);
	}

	/*
	* When the continuous option is set restart at the minimum number of
	* children instead of exiting. This option is useful as a mechanism
	* to continuous try and refine the discovered permutations.
	*/
	if (continuous) {
	restarts++;
	printf("Restarting by request (-c): %d\n", restarts);
	goto restart;
	}

	return (0);
	}

	/*
	* Verify each map in the file by generating its in-memory permutation array
	* and comfirming its checksum is correct.
	*/
	static int
	draid_verify(int argc, char *argv[])
	{
	char filename[MAXPATHLEN];
	int n = 0, c, error, verbose = 1;
	int check_ratios = 0;

	while ((c = getopt(argc, argv, ":rv")) != -1) {
	switch (c) {
	case 'r':
	check_ratios++;
	break;
	case 'v':
	verbose++;
	break;
	case ':':
	(void) fprintf(stderr,
	"missing argument for '%c' option\n", optopt);
	draid_usage();
	break;
	case '?':
	(void) fprintf(stderr, "invalid option '%c'\n",
	optopt);
	draid_usage();
	break;
	}
	}

	if (argc > optind) {
	char *abspath = malloc(MAXPATHLEN);
	if (abspath == NULL)
	return (ENOMEM);

	bzero(filename, MAXPATHLEN);
	if (realpath(argv[optind], abspath) != NULL)
	strncpy(filename, abspath, MAXPATHLEN - 1);
	else
	strncpy(filename, argv[optind], MAXPATHLEN - 1);

	free(abspath);
	} else {
	(void) fprintf(stderr, "A FILE must be specified.\n");
	return (1);
	}

	printf("Verifying permutation maps: '%s'\n", filename);

	/*
	* Lookup hardcoded permutation map for each valid number of children
	* and verify a generated map has the correct checksum. Then compare
	* the generated map values with the nvlist map values read from the
	* reference file to cross-check the permutation.
	*/
	for (uint64_t children = VDEV_DRAID_MIN_CHILDREN;
	children <= VDEV_DRAID_MAX_CHILDREN;
	children++) {
	draid_map_t *map;
	char key[8];

	bzero(key, 8);
	snprintf(key, 8, "%llu", (u_longlong_t)children);

	error = alloc_fixed_map(children, &map);
	if (error) {
	printf("Error alloc_fixed_map() failed: %s\n",
	error == ECKSUM ? "Invalid checksum" :
	strerror(error));
	return (1);
	}

	uint64_t nv_seed, nv_checksum, nv_children, nv_nperms;
	uint8_t *nv_perms;
	nvlist_t *cfg;
	uint_t c;

	error = read_map_key(filename, key, &cfg);
	if (error != 0) {
	printf("Error read_map_key() failed: %s\n",
	strerror(error));
	free_map(map);
	return (1);
	}

	nv_seed = fnvlist_lookup_uint64(cfg, MAP_SEED);
	nv_checksum = fnvlist_lookup_uint64(cfg, MAP_CHECKSUM);
	nv_children = fnvlist_lookup_uint64(cfg, MAP_CHILDREN);
	nv_nperms = fnvlist_lookup_uint64(cfg, MAP_NPERMS);
	nvlist_lookup_uint8_array(cfg, MAP_PERMS, &nv_perms, &c);

	/*
	* Compare draid_map_t and nvlist reference values.
	*/
	if (map->dm_seed != nv_seed) {
	printf("Error different seeds: 0x%016llx != "
	"0x%016llx\n", (u_longlong_t)map->dm_seed,
	(u_longlong_t)nv_seed);
	error = EINVAL;
	}

	if (map->dm_checksum != nv_checksum) {
	printf("Error different checksums: 0x%016llx "
	"!= 0x%016llx\n",
	(u_longlong_t)map->dm_checksum,
	(u_longlong_t)nv_checksum);
	error = EINVAL;
	}

	if (map->dm_children != nv_children) {
	printf("Error different children: %llu "
	"!= %llu\n", (u_longlong_t)map->dm_children,
	(u_longlong_t)nv_children);
	error = EINVAL;
	}

	if (map->dm_nperms != nv_nperms) {
	printf("Error different nperms: %llu "
	"!= %llu\n", (u_longlong_t)map->dm_nperms,
	(u_longlong_t)nv_nperms);
	error = EINVAL;
	}

	for (uint64_t i = 0; i < nv_children * nv_nperms; i++) {
	if (map->dm_perms[i] != nv_perms[i]) {
	printf("Error different perms[%llu]: "
	"%d != %d\n", (u_longlong_t)i,
	(int)map->dm_perms[i],
	(int)nv_perms[i]);
	error = EINVAL;
	break;
	}
	}

	/*
	* For good measure recalculate the worst and average
	* ratios and confirm they match the nvlist values.
	*/
	if (check_ratios) {
	uint64_t nv_worst_ratio, nv_avg_ratio;
	double worst_ratio, avg_ratio;

	eval_decluster(map, &worst_ratio, &avg_ratio);

	nv_worst_ratio = fnvlist_lookup_uint64(cfg,
	MAP_WORST_RATIO);
	nv_avg_ratio = fnvlist_lookup_uint64(cfg,
	MAP_AVG_RATIO);

	if (worst_ratio < 1.0 \|\| avg_ratio < 1.0) {
	printf("Error ratio out of range %2.03f, "
	"%2.03f\n", worst_ratio, avg_ratio);
	error = EINVAL;
	}

	if ((uint64_t)(worst_ratio * 1000.0) !=
	nv_worst_ratio) {
	printf("Error different worst_ratio %2.03f "
	"!= %2.03f\n", (double)nv_worst_ratio /
	1000.0, worst_ratio);
	error = EINVAL;
	}

	if ((uint64_t)(avg_ratio * 1000.0) != nv_avg_ratio) {
	printf("Error different average_ratio %2.03f "
	"!= %2.03f\n", (double)nv_avg_ratio /
	1000.0, avg_ratio);
	error = EINVAL;
	}
	}

	if (error) {
	free_map(map);
	nvlist_free(cfg);
	return (1);
	}

	if (verbose > 0) {
	printf("- %llu children: good\n",
	(u_longlong_t)children);
	}
	n++;

	free_map(map);
	nvlist_free(cfg);
	}

	if (n != (VDEV_DRAID_MAX_CHILDREN - 1)) {
	printf("Error permutation maps missing: %d / %d checked\n",
	n, VDEV_DRAID_MAX_CHILDREN - 1);
	return (1);
	}

	printf("Successfully verified %d / %d permutation maps\n",
	n, VDEV_DRAID_MAX_CHILDREN - 1);

	return (0);
	}

	/*
	* Dump the contents of the specified mapping(s) for inspection.
	*/
	static int
	draid_dump(int argc, char *argv[])
	{
	char filename[MAXPATHLEN];
	int c, error, verbose = 1;
	int min_children = VDEV_DRAID_MIN_CHILDREN;
	int max_children = VDEV_DRAID_MAX_CHILDREN;

	while ((c = getopt(argc, argv, ":vm:n:")) != -1) {
	switch (c) {
	case 'm':
	min_children = (int)strtol(optarg, NULL, 0);
	if (min_children < 2) {
	(void) fprintf(stderr, "A minimum of 2 "
	"children are required.\n");
	return (1);
	}

	break;
	case 'n':
	max_children = (int)strtol(optarg, NULL, 0);
	if (max_children > VDEV_DRAID_MAX_CHILDREN) {
	(void) fprintf(stderr, "A maximum of %d "
	"children are allowed.\n",
	VDEV_DRAID_MAX_CHILDREN);
	return (1);
	}
	break;
	case 'v':
	verbose++;
	break;
	case ':':
	(void) fprintf(stderr,
	"missing argument for '%c' option\n", optopt);
	draid_usage();
	break;
	case '?':
	(void) fprintf(stderr, "invalid option '%c'\n",
	optopt);
	draid_usage();
	break;
	}
	}

	if (argc > optind) {
	bzero(filename, MAXPATHLEN);
	strncpy(filename, argv[optind], MAXPATHLEN - 1);
	} else {
	(void) fprintf(stderr, "A FILE must be specified.\n");
	return (1);
	}

	/*
	* Dump maps for the requested child counts.
	*/
	for (uint64_t children = min_children;
	children <= max_children; children++) {
	char key[8] = { 0 };

	snprintf(key, 7, "%llu", (u_longlong_t)children);
	error = dump_map_key(filename, key, verbose);
	if (error) {
	printf("Error dump_map_key(): %s\n", strerror(error));
	return (1);
	}
	}

	return (0);
	}

	/*
	- * Print all of the mappings as a C formated draid_map_t array. This table
	- * is found in the module/zcommon/zfs_draid.c file and is the definative
	+ * Print all of the mappings as a C formatted draid_map_t array. This table
	+ * is found in the module/zcommon/zfs_draid.c file and is the definitive
	* source for all mapping used by dRAID. It cannot be updated without
	* changing the dRAID on disk format.
	*/
	static int
	draid_table(int argc, char *argv[])
	{
	char filename[MAXPATHLEN];
	int error;

	if (argc > optind) {
	bzero(filename, MAXPATHLEN);
	strncpy(filename, argv[optind], MAXPATHLEN - 1);
	} else {
	(void) fprintf(stderr, "A FILE must be specified.\n");
	return (1);
	}

	printf("static const draid_map_t "
	"draid_maps[VDEV_DRAID_MAX_MAPS] = {\n");

	for (uint64_t children = VDEV_DRAID_MIN_CHILDREN;
	children <= VDEV_DRAID_MAX_CHILDREN;
	children++) {
	uint64_t seed, checksum, nperms, avg_ratio;
	nvlist_t *cfg;
	char key[8];

	bzero(key, 8);
	snprintf(key, 8, "%llu", (u_longlong_t)children);

	error = read_map_key(filename, key, &cfg);
	if (error != 0) {
	printf("Error read_map_key() failed: %s\n",
	strerror(error));
	return (1);
	}

	seed = fnvlist_lookup_uint64(cfg, MAP_SEED);
	checksum = fnvlist_lookup_uint64(cfg, MAP_CHECKSUM);
	children = fnvlist_lookup_uint64(cfg, MAP_CHILDREN);
	nperms = fnvlist_lookup_uint64(cfg, MAP_NPERMS);
	avg_ratio = fnvlist_lookup_uint64(cfg, MAP_AVG_RATIO);

	printf("\t{ %3llu, %3llu, 0x%016llx, 0x%016llx },\t"
	"/* %2.03f */\n", (u_longlong_t)children,
	(u_longlong_t)nperms, (u_longlong_t)seed,
	(u_longlong_t)checksum, (double)avg_ratio / 1000.0);

	nvlist_free(cfg);
	}

	printf("};\n");

	return (0);
	}

	static int
	draid_merge_impl(nvlist_t allcfgs, const char srcfilename, int *mergedp)
	{
	nvlist_t *srccfgs;
	nvpair_t *elem = NULL;
	int error, merged = 0;

	error = read_map(srcfilename, &srccfgs);
	if (error != 0)
	return (error);

	while ((elem = nvlist_next_nvpair(srccfgs, elem)) != NULL) {
	uint64_t nv_worst_ratio;
	uint64_t allcfg_worst_ratio;
	nvlist_t cfg, allcfg;
	char *key;

	switch (nvpair_type(elem)) {
	case DATA_TYPE_NVLIST:

	(void) nvpair_value_nvlist(elem, &cfg);
	key = nvpair_name(elem);

	nv_worst_ratio = fnvlist_lookup_uint64(cfg,
	MAP_WORST_RATIO);

	error = nvlist_lookup_nvlist(allcfgs, key, &allcfg);
	if (error == 0) {
	allcfg_worst_ratio = fnvlist_lookup_uint64(
	allcfg, MAP_WORST_RATIO);

	if (nv_worst_ratio < allcfg_worst_ratio) {
	fnvlist_remove(allcfgs, key);
	error = nvlist_add_nvlist(allcfgs,
	key, cfg);
	merged++;
	}
	} else if (error == ENOENT) {
	error = nvlist_add_nvlist(allcfgs, key, cfg);
	merged++;
	} else {
	return (error);
	}

	break;
	default:
	continue;
	}
	}

	nvlist_free(srccfgs);

	*mergedp = merged;

	return (0);
	}

	/*
	* Merge the best map for each child count found in the listed files into
	* a new file. This allows 'draid generate' to be run in parallel and for
	* the results maps to be combined.
	*/
	static int
	draid_merge(int argc, char *argv[])
	{
	char filename[MAXPATHLEN];
	int c, error, total_merged = 0, verbose = 0;
	nvlist_t *allcfgs;

	while ((c = getopt(argc, argv, ":v")) != -1) {
	switch (c) {
	case 'v':
	verbose++;
	break;
	case ':':
	(void) fprintf(stderr,
	"missing argument for '%c' option\n", optopt);
	draid_usage();
	break;
	case '?':
	(void) fprintf(stderr, "invalid option '%c'\n",
	optopt);
	draid_usage();
	break;
	}
	}

	if (argc < 4) {
	(void) fprintf(stderr,
	"A FILE and multiple SRCs must be specified.\n");
	return (1);
	}

	bzero(filename, MAXPATHLEN);
	strncpy(filename, argv[optind], MAXPATHLEN - 1);
	optind++;

	error = read_map(filename, &allcfgs);
	if (error == ENOENT) {
	allcfgs = fnvlist_alloc();
	} else if (error != 0) {
	printf("Error read_map(): %s\n", strerror(error));
	return (error);
	}

	while (optind < argc) {
	char srcfilename[MAXPATHLEN];
	int merged = 0;

	bzero(srcfilename, MAXPATHLEN);
	strncpy(srcfilename, argv[optind], MAXPATHLEN - 1);

	error = draid_merge_impl(allcfgs, srcfilename, &merged);
	if (error) {
	printf("Error draid_merge_impl(): %s\n",
	strerror(error));
	nvlist_free(allcfgs);
	return (1);
	}

	total_merged += merged;
	printf("Merged %d key(s) from '%s' into '%s'\n", merged,
	srcfilename, filename);

	optind++;
	}

	if (total_merged > 0)
	write_map(filename, allcfgs);

	printf("Merged a total of %d key(s) into '%s'\n", total_merged,
	filename);

	nvlist_free(allcfgs);

	return (0);
	}

	int
	main(int argc, char *argv[])
	{
	if (argc < 2)
	draid_usage();

	char *subcommand = argv[1];

	if (strcmp(subcommand, "generate") == 0) {
	return (draid_generate(argc - 1, argv + 1));
	} else if (strcmp(subcommand, "verify") == 0) {
	return (draid_verify(argc - 1, argv + 1));
	} else if (strcmp(subcommand, "dump") == 0) {
	return (draid_dump(argc - 1, argv + 1));
	} else if (strcmp(subcommand, "table") == 0) {
	return (draid_table(argc - 1, argv + 1));
	} else if (strcmp(subcommand, "merge") == 0) {
	return (draid_merge(argc - 1, argv + 1));
	} else {
	draid_usage();
	}
	}
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/cmd/file_write/file_write.c b/sys/contrib/openzfs/tests/zfs-tests/cmd/file_write/file_write.c
	index 45d296db43c6..60893c34fbc9 100644
	--- a/sys/contrib/openzfs/tests/zfs-tests/cmd/file_write/file_write.c
	+++ b/sys/contrib/openzfs/tests/zfs-tests/cmd/file_write/file_write.c
	@@ -1,258 +1,258 @@
	/*
	* 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 2007 Sun Microsystems, Inc. All rights reserved.
	* Use is subject to license terms.
	*/

	#include "../file_common.h"
	#include <libgen.h>
	#include <string.h>
	#include <inttypes.h>
	#include <sys/types.h>
	#include <unistd.h>
	#include <stdlib.h>
	#include <time.h>
	#include <stdint.h>

	static unsigned char bigbuffer[BIGBUFFERSIZE];

	/*
	* Writes (or appends) a given value to a file repeatedly.
	* See header file for defaults.
	*/

	static void usage(char *);

	/*
	- * psudo-randomize the buffer
	+ * pseudo-randomize the buffer
	*/
	static void randomize_buffer(int block_size) {
	int i;
	char rnd = rand() & 0xff;
	for (i = 0; i < block_size; i++)
	bigbuffer[i] ^= rnd;
	}

	int
	main(int argc, char **argv)
	{
	int bigfd;
	int c;
	int oflag = 0;
	int err = 0;
	int k;
	long i;
	int64_t good_writes = 0;
	uchar_t nxtfillchar;
	char *prog = argv[0];
	/*
	* Default Parameters
	*/
	int write_count = BIGFILESIZE;
	uchar_t fillchar = DATA;
	int block_size = BLOCKSZ;
	char *filename = NULL;
	char *operation = NULL;
	offset_t noffset, offset = 0;
	int verbose = 0;
	int rsync = 0;
	int wsync = 0;

	/*
	* Process Arguments
	*/
	while ((c = getopt(argc, argv, "b:c:d:s:f:o:vwr")) != -1) {
	switch (c) {
	case 'b':
	block_size = atoi(optarg);
	break;
	case 'c':
	write_count = atoi(optarg);
	break;
	case 'd':
	if (optarg[0] == 'R')
	fillchar = 'R'; /* R = random data */
	else
	fillchar = atoi(optarg);
	break;
	case 's':
	offset = atoll(optarg);
	break;
	case 'f':
	filename = optarg;
	break;
	case 'o':
	operation = optarg;
	break;
	case 'v':
	verbose = 1;
	break;
	case 'w':
	wsync = 1;
	break;
	case 'r':
	rsync = 1;
	break;
	case '?':
	(void) printf("unknown arg %c\n", optopt);
	usage(prog);
	break;
	}
	}

	/*
	* Validate Parameters
	*/
	if (!filename) {
	(void) printf("Filename not specified (-f <file>)\n");
	err++;
	}

	if (!operation) {
	(void) printf("Operation not specified (-o <operation>).\n");
	err++;
	}

	if (block_size > BIGBUFFERSIZE) {
	(void) printf("block_size is too large max==%d.\n",
	BIGBUFFERSIZE);
	err++;
	}

	if (err) {
	usage(prog); /* no return */
	return (1);
	}

	/*
	* Prepare the buffer and determine the requested operation
	*/
	nxtfillchar = fillchar;
	k = 0;

	if (fillchar == 'R')
	srand(time(NULL));

	for (i = 0; i < block_size; i++) {
	bigbuffer[i] = nxtfillchar;

	if (fillchar == 0) {
	if ((k % DATA_RANGE) == 0) {
	k = 0;
	}
	nxtfillchar = k++;
	} else if (fillchar == 'R') {
	nxtfillchar = rand() & 0xff;
	}
	}

	/*
	* using the strncmp of operation will make the operation match the
	* first shortest match - as the operations are unique from the first
	* character this means that we match single character operations
	*/
	if ((strncmp(operation, "create", strlen(operation) + 1)) == 0 \|\|
	(strncmp(operation, "overwrite", strlen(operation) + 1)) == 0) {
	oflag = (O_RDWR\|O_CREAT);
	} else if ((strncmp(operation, "append", strlen(operation) + 1)) == 0) {
	oflag = (O_RDWR\|O_APPEND);
	} else {
	(void) printf("valid operations are <create\|append> not '%s'\n",
	operation);
	usage(prog);
	}

	if (rsync) {
	oflag = oflag \| O_RSYNC;
	}

	if (wsync) {
	oflag = oflag \| O_SYNC;
	}

	/*
	* Given an operation (create/overwrite/append), open the file
	* accordingly and perform a write of the appropriate type.
	*/
	if ((bigfd = open(filename, oflag, 0666)) == -1) {
	(void) printf("open %s: failed [%s]%d. Aborting!\n", filename,
	strerror(errno), errno);
	exit(errno);
	}
	noffset = lseek64(bigfd, offset, SEEK_SET);
	if (noffset != offset) {
	(void) printf("llseek %s (%lld/%lld) failed [%s]%d.Aborting!\n",
	filename, offset, noffset, strerror(errno), errno);
	exit(errno);
	}

	if (verbose) {
	(void) printf("%s: block_size = %d, write_count = %d, "
	"offset = %lld, ", filename, block_size,
	write_count, offset);
	if (fillchar == 'R') {
	(void) printf("data = [random]\n");
	} else {
	(void) printf("data = %s%d\n",
	(fillchar == 0) ? "0->" : "",
	(fillchar == 0) ? DATA_RANGE : fillchar);
	}
	}

	for (i = 0; i < write_count; i++) {
	ssize_t n;
	if (fillchar == 'R')
	randomize_buffer(block_size);

	if ((n = write(bigfd, &bigbuffer, block_size)) == -1) {
	(void) printf("write failed (%ld), good_writes = %"
	PRId64 ", " "error: %s[%d]\n",
	(long)n, good_writes,
	strerror(errno),
	errno);
	exit(errno);
	}
	good_writes++;
	}

	if (verbose) {
	(void) printf("Success: good_writes = %" PRId64 "(%"
	PRId64 ")\n", good_writes, (good_writes * block_size));
	}

	return (0);
	}

	static void
	usage(char *prog)
	{
	(void) printf("Usage: %s [-v] -o {create,overwrite,append} -f file_name"
	" [-b block_size]\n"
	"\t[-s offset] [-c write_count] [-d data]\n\n"
	"Where [data] equal to zero causes chars "
	"0->%d to be repeated throughout, or [data]\n"
	"equal to 'R' for psudorandom data.\n",
	prog, DATA_RANGE);

	exit(1);
	}
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/include/libtest.shlib b/sys/contrib/openzfs/tests/zfs-tests/include/libtest.shlib
	index bd77bae7d967..08c29c25fac7 100644
	--- a/sys/contrib/openzfs/tests/zfs-tests/include/libtest.shlib
	+++ b/sys/contrib/openzfs/tests/zfs-tests/include/libtest.shlib
	@@ -1,4256 +1,4250 @@
	#
	# 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) 2009, Sun Microsystems Inc. All rights reserved.
	# Copyright (c) 2012, 2020, Delphix. All rights reserved.
	# Copyright (c) 2017, Tim Chase. All rights reserved.
	# Copyright (c) 2017, Nexenta Systems Inc. All rights reserved.
	# Copyright (c) 2017, Lawrence Livermore National Security LLC.
	# Copyright (c) 2017, Datto Inc. All rights reserved.
	# Copyright (c) 2017, Open-E Inc. All rights reserved.
	# Use is subject to license terms.
	#

	. ${STF_TOOLS}/include/logapi.shlib
	. ${STF_SUITE}/include/math.shlib
	. ${STF_SUITE}/include/blkdev.shlib

	. ${STF_SUITE}/include/tunables.cfg

	#
	# Apply constrained path when available. This is required since the
	# PATH may have been modified by sudo's secure_path behavior.
	#
	if [ -n "$STF_PATH" ]; then
	export PATH="$STF_PATH"
	fi

	#
	# Generic dot version comparison function
	#
	# Returns success when version $1 is greater than or equal to $2.
	#
	function compare_version_gte
	{
	if [[ "$(printf "$1\n$2" \| sort -V \| tail -n1)" == "$1" ]]; then
	return 0
	else
	return 1
	fi
	}

	# Linux kernel version comparison function
	#
	# $1 Linux version ("4.10", "2.6.32") or blank for installed Linux version
	#
	# Used for comparison: if [ $(linux_version) -ge $(linux_version "2.6.32") ]
	#
	function linux_version
	{
	typeset ver="$1"

	[[ -z "$ver" ]] && ver=$(uname -r \| grep -Eo "^[0-9]+\.[0-9]+\.[0-9]+")

	typeset version=$(echo $ver \| cut -d '.' -f 1)
	typeset major=$(echo $ver \| cut -d '.' -f 2)
	typeset minor=$(echo $ver \| cut -d '.' -f 3)

	[[ -z "$version" ]] && version=0
	[[ -z "$major" ]] && major=0
	[[ -z "$minor" ]] && minor=0

	echo $((version * 10000 + major * 100 + minor))
	}

	# Determine if this is a Linux test system
	#
	# Return 0 if platform Linux, 1 if otherwise

	function is_linux
	{
	if [[ $(uname -o) == "GNU/Linux" ]]; then
	return 0
	else
	return 1
	fi
	}

	# Determine if this is an illumos test system
	#
	# Return 0 if platform illumos, 1 if otherwise
	function is_illumos
	{
	if [[ $(uname -o) == "illumos" ]]; then
	return 0
	else
	return 1
	fi
	}

	# Determine if this is a FreeBSD test system
	#
	# Return 0 if platform FreeBSD, 1 if otherwise

	function is_freebsd
	{
	if [[ $(uname -o) == "FreeBSD" ]]; then
	return 0
	else
	return 1
	fi
	}

	# Determine if this is a DilOS test system
	#
	# Return 0 if platform DilOS, 1 if otherwise

	function is_dilos
	{
	typeset ID=""
	[[ -f /etc/os-release ]] && . /etc/os-release
	if [[ $ID == "dilos" ]]; then
	return 0
	else
	return 1
	fi
	}

	# Determine if this is a 32-bit system
	#
	# Return 0 if platform is 32-bit, 1 if otherwise

	function is_32bit
	{
	if [[ $(getconf LONG_BIT) == "32" ]]; then
	return 0
	else
	return 1
	fi
	}

	# Determine if kmemleak is enabled
	#
	# Return 0 if kmemleak is enabled, 1 if otherwise

	function is_kmemleak
	{
	if is_linux && [[ -e /sys/kernel/debug/kmemleak ]]; then
	return 0
	else
	return 1
	fi
	}

	# Determine whether a dataset is mounted
	#
	# $1 dataset name
	# $2 filesystem type; optional - defaulted to zfs
	#
	# Return 0 if dataset is mounted; 1 if unmounted; 2 on error

	function ismounted
	{
	typeset fstype=$2
	[[ -z $fstype ]] && fstype=zfs
	typeset out dir name ret

	case $fstype in
	zfs)
	if [[ "$1" == "/"* ]] ; then
	for out in $(zfs mount \| awk '{print $2}'); do
	[[ $1 == $out ]] && return 0
	done
	else
	for out in $(zfs mount \| awk '{print $1}'); do
	[[ $1 == $out ]] && return 0
	done
	fi
	;;
	ufs\|nfs)
	if is_freebsd; then
	mount -pt $fstype \| while read dev dir _t _flags; do
	[[ "$1" == "$dev" \|\| "$1" == "$dir" ]] && return 0
	done
	else
	out=$(df -F $fstype $1 2>/dev/null)
	ret=$?
	(($ret != 0)) && return $ret

	dir=${out%%\(*}
	dir=${dir%% *}
	name=${out##*\(}
	name=${name%%\)*}
	name=${name%% *}

	[[ "$1" == "$dir" \|\| "$1" == "$name" ]] && return 0
	fi
	;;
	ext*)
	out=$(df -t $fstype $1 2>/dev/null)
	return $?
	;;
	zvol)
	if [[ -L "$ZVOL_DEVDIR/$1" ]]; then
	link=$(readlink -f $ZVOL_DEVDIR/$1)
	[[ -n "$link" ]] && \
	mount \| grep -q "^$link" && \
	return 0
	fi
	;;
	esac

	return 1
	}

	# Return 0 if a dataset is mounted; 1 otherwise
	#
	# $1 dataset name
	# $2 filesystem type; optional - defaulted to zfs

	function mounted
	{
	ismounted $1 $2
	(($? == 0)) && return 0
	return 1
	}

	# Return 0 if a dataset is unmounted; 1 otherwise
	#
	# $1 dataset name
	# $2 filesystem type; optional - defaulted to zfs

	function unmounted
	{
	ismounted $1 $2
	(($? == 1)) && return 0
	return 1
	}

	# split line on ","
	#
	# $1 - line to split

	function splitline
	{
	echo $1 \| sed "s/,/ /g"
	}

	function default_setup
	{
	default_setup_noexit "$@"

	log_pass
	}

	function default_setup_no_mountpoint
	{
	default_setup_noexit "$1" "$2" "$3" "yes"

	log_pass
	}

	#
	# Given a list of disks, setup storage pools and datasets.
	#
	function default_setup_noexit
	{
	typeset disklist=$1
	typeset container=$2
	typeset volume=$3
	typeset no_mountpoint=$4
	log_note begin default_setup_noexit

	if is_global_zone; then
	if poolexists $TESTPOOL ; then
	destroy_pool $TESTPOOL
	fi
	[[ -d /$TESTPOOL ]] && rm -rf /$TESTPOOL
	log_must zpool create -f $TESTPOOL $disklist
	else
	reexport_pool
	fi

	rm -rf $TESTDIR \|\| log_unresolved Could not remove $TESTDIR
	mkdir -p $TESTDIR \|\| log_unresolved Could not create $TESTDIR

	log_must zfs create $TESTPOOL/$TESTFS
	if [[ -z $no_mountpoint ]]; then
	log_must zfs set mountpoint=$TESTDIR $TESTPOOL/$TESTFS
	fi

	if [[ -n $container ]]; then
	rm -rf $TESTDIR1 \|\| \
	log_unresolved Could not remove $TESTDIR1
	mkdir -p $TESTDIR1 \|\| \
	log_unresolved Could not create $TESTDIR1

	log_must zfs create $TESTPOOL/$TESTCTR
	log_must zfs set canmount=off $TESTPOOL/$TESTCTR
	log_must zfs create $TESTPOOL/$TESTCTR/$TESTFS1
	if [[ -z $no_mountpoint ]]; then
	log_must zfs set mountpoint=$TESTDIR1 \
	$TESTPOOL/$TESTCTR/$TESTFS1
	fi
	fi

	if [[ -n $volume ]]; then
	if is_global_zone ; then
	log_must zfs create -V $VOLSIZE $TESTPOOL/$TESTVOL
	block_device_wait
	else
	log_must zfs create $TESTPOOL/$TESTVOL
	fi
	fi
	}

	#
	# Given a list of disks, setup a storage pool, file system and
	# a container.
	#
	function default_container_setup
	{
	typeset disklist=$1

	default_setup "$disklist" "true"
	}

	#
	# Given a list of disks, setup a storage pool,file system
	# and a volume.
	#
	function default_volume_setup
	{
	typeset disklist=$1

	default_setup "$disklist" "" "true"
	}

	#
	# Given a list of disks, setup a storage pool,file system,
	# a container and a volume.
	#
	function default_container_volume_setup
	{
	typeset disklist=$1

	default_setup "$disklist" "true" "true"
	}

	#
	# Create a snapshot on a filesystem or volume. Defaultly create a snapshot on
	# filesystem
	#
	# $1 Existing filesystem or volume name. Default, $TESTPOOL/$TESTFS
	# $2 snapshot name. Default, $TESTSNAP
	#
	function create_snapshot
	{
	typeset fs_vol=${1:-$TESTPOOL/$TESTFS}
	typeset snap=${2:-$TESTSNAP}

	[[ -z $fs_vol ]] && log_fail "Filesystem or volume's name is undefined."
	[[ -z $snap ]] && log_fail "Snapshot's name is undefined."

	if snapexists $fs_vol@$snap; then
	log_fail "$fs_vol@$snap already exists."
	fi
	datasetexists $fs_vol \|\| \
	log_fail "$fs_vol must exist."

	log_must zfs snapshot $fs_vol@$snap
	}

	#
	# Create a clone from a snapshot, default clone name is $TESTCLONE.
	#
	# $1 Existing snapshot, $TESTPOOL/$TESTFS@$TESTSNAP is default.
	# $2 Clone name, $TESTPOOL/$TESTCLONE is default.
	#
	function create_clone # snapshot clone
	{
	typeset snap=${1:-$TESTPOOL/$TESTFS@$TESTSNAP}
	typeset clone=${2:-$TESTPOOL/$TESTCLONE}

	[[ -z $snap ]] && \
	log_fail "Snapshot name is undefined."
	[[ -z $clone ]] && \
	log_fail "Clone name is undefined."

	log_must zfs clone $snap $clone
	}

	#
	# Create a bookmark of the given snapshot. Defaultly create a bookmark on
	# filesystem.
	#
	# $1 Existing filesystem or volume name. Default, $TESTFS
	# $2 Existing snapshot name. Default, $TESTSNAP
	# $3 bookmark name. Default, $TESTBKMARK
	#
	function create_bookmark
	{
	typeset fs_vol=${1:-$TESTFS}
	typeset snap=${2:-$TESTSNAP}
	typeset bkmark=${3:-$TESTBKMARK}

	[[ -z $fs_vol ]] && log_fail "Filesystem or volume's name is undefined."
	[[ -z $snap ]] && log_fail "Snapshot's name is undefined."
	[[ -z $bkmark ]] && log_fail "Bookmark's name is undefined."

	if bkmarkexists $fs_vol#$bkmark; then
	log_fail "$fs_vol#$bkmark already exists."
	fi
	datasetexists $fs_vol \|\| \
	log_fail "$fs_vol must exist."
	snapexists $fs_vol@$snap \|\| \
	log_fail "$fs_vol@$snap must exist."

	log_must zfs bookmark $fs_vol@$snap $fs_vol#$bkmark
	}

	#
	# Create a temporary clone result of an interrupted resumable 'zfs receive'
	# $1 Destination filesystem name. Must not exist, will be created as the result
	# of this function along with its %recv temporary clone
	# $2 Source filesystem name. Must not exist, will be created and destroyed
	#
	function create_recv_clone
	{
	typeset recvfs="$1"
	typeset sendfs="${2:-$TESTPOOL/create_recv_clone}"
	typeset snap="$sendfs@snap1"
	typeset incr="$sendfs@snap2"
	typeset mountpoint="$TESTDIR/create_recv_clone"
	typeset sendfile="$TESTDIR/create_recv_clone.zsnap"

	[[ -z $recvfs ]] && log_fail "Recv filesystem's name is undefined."

	datasetexists $recvfs && log_fail "Recv filesystem must not exist."
	datasetexists $sendfs && log_fail "Send filesystem must not exist."

	log_must zfs create -o mountpoint="$mountpoint" $sendfs
	log_must zfs snapshot $snap
	log_must eval "zfs send $snap \| zfs recv -u $recvfs"
	log_must mkfile 1m "$mountpoint/data"
	log_must zfs snapshot $incr
	log_must eval "zfs send -i $snap $incr \| dd bs=10K count=1 \
	iflag=fullblock > $sendfile"
	log_mustnot eval "zfs recv -su $recvfs < $sendfile"
	destroy_dataset "$sendfs" "-r"
	log_must rm -f "$sendfile"

	if [[ $(get_prop 'inconsistent' "$recvfs/%recv") -ne 1 ]]; then
	log_fail "Error creating temporary $recvfs/%recv clone"
	fi
	}

	function default_mirror_setup
	{
	default_mirror_setup_noexit $1 $2 $3

	log_pass
	}

	#
	# Given a pair of disks, set up a storage pool and dataset for the mirror
	# @parameters: $1 the primary side of the mirror
	# $2 the secondary side of the mirror
	# @uses: ZPOOL ZFS TESTPOOL TESTFS
	function default_mirror_setup_noexit
	{
	readonly func="default_mirror_setup_noexit"
	typeset primary=$1
	typeset secondary=$2

	[[ -z $primary ]] && \
	log_fail "$func: No parameters passed"
	[[ -z $secondary ]] && \
	log_fail "$func: No secondary partition passed"
	[[ -d /$TESTPOOL ]] && rm -rf /$TESTPOOL
	log_must zpool create -f $TESTPOOL mirror $@
	log_must zfs create $TESTPOOL/$TESTFS
	log_must zfs set mountpoint=$TESTDIR $TESTPOOL/$TESTFS
	}

	#
	# create a number of mirrors.
	# We create a number($1) of 2 way mirrors using the pairs of disks named
	# on the command line. These mirrors are not mounted
	# @parameters: $1 the number of mirrors to create
	# $... the devices to use to create the mirrors on
	# @uses: ZPOOL ZFS TESTPOOL
	function setup_mirrors
	{
	typeset -i nmirrors=$1

	shift
	while ((nmirrors > 0)); do
	log_must test -n "$1" -a -n "$2"
	[[ -d /$TESTPOOL$nmirrors ]] && rm -rf /$TESTPOOL$nmirrors
	log_must zpool create -f $TESTPOOL$nmirrors mirror $1 $2
	shift 2
	((nmirrors = nmirrors - 1))
	done
	}

	#
	# create a number of raidz pools.
	# We create a number($1) of 2 raidz pools using the pairs of disks named
	# on the command line. These pools are not mounted
	# @parameters: $1 the number of pools to create
	# $... the devices to use to create the pools on
	# @uses: ZPOOL ZFS TESTPOOL
	function setup_raidzs
	{
	typeset -i nraidzs=$1

	shift
	while ((nraidzs > 0)); do
	log_must test -n "$1" -a -n "$2"
	[[ -d /$TESTPOOL$nraidzs ]] && rm -rf /$TESTPOOL$nraidzs
	log_must zpool create -f $TESTPOOL$nraidzs raidz $1 $2
	shift 2
	((nraidzs = nraidzs - 1))
	done
	}

	#
	# Destroy the configured testpool mirrors.
	# the mirrors are of the form ${TESTPOOL}{number}
	# @uses: ZPOOL ZFS TESTPOOL
	function destroy_mirrors
	{
	default_cleanup_noexit

	log_pass
	}

	#
	# Given a minimum of two disks, set up a storage pool and dataset for the raid-z
	# $1 the list of disks
	#
	function default_raidz_setup
	{
	typeset disklist="$*"
	disks=(${disklist[*]})

	if [[ ${#disks[*]} -lt 2 ]]; then
	log_fail "A raid-z requires a minimum of two disks."
	fi

	[[ -d /$TESTPOOL ]] && rm -rf /$TESTPOOL
	log_must zpool create -f $TESTPOOL raidz $disklist
	log_must zfs create $TESTPOOL/$TESTFS
	log_must zfs set mountpoint=$TESTDIR $TESTPOOL/$TESTFS

	log_pass
	}

	#
	# Common function used to cleanup storage pools and datasets.
	#
	# Invoked at the start of the test suite to ensure the system
	# is in a known state, and also at the end of each set of
	# sub-tests to ensure errors from one set of tests doesn't
	# impact the execution of the next set.

	function default_cleanup
	{
	default_cleanup_noexit

	log_pass
	}

	#
	# Utility function used to list all available pool names.
	#
	# NOTE: $KEEP is a variable containing pool names, separated by a newline
	# character, that must be excluded from the returned list.
	#
	function get_all_pools
	{
	zpool list -H -o name \| grep -Fvx "$KEEP" \| grep -v "$NO_POOLS"
	}

	function default_cleanup_noexit
	{
	typeset pool=""
	#
	# Destroying the pool will also destroy any
	# filesystems it contains.
	#
	if is_global_zone; then
	zfs unmount -a > /dev/null 2>&1
	ALL_POOLS=$(get_all_pools)
	# Here, we loop through the pools we're allowed to
	# destroy, only destroying them if it's safe to do
	# so.
	while [ ! -z ${ALL_POOLS} ]
	do
	for pool in ${ALL_POOLS}
	do
	if safe_to_destroy_pool $pool ;
	then
	destroy_pool $pool
	fi
	done
	ALL_POOLS=$(get_all_pools)
	done

	zfs mount -a
	else
	typeset fs=""
	for fs in $(zfs list -H -o name \
	\| grep "^$ZONE_POOL/$ZONE_CTR[01234]/"); do
	destroy_dataset "$fs" "-Rf"
	done

	# Need cleanup here to avoid garbage dir left.
	for fs in $(zfs list -H -o name); do
	[[ $fs == /$ZONE_POOL ]] && continue
	[[ -d $fs ]] && log_must rm -rf $fs/*
	done

	#
	# Reset the $ZONE_POOL/$ZONE_CTR[01234] file systems property to
	# the default value
	#
	for fs in $(zfs list -H -o name); do
	if [[ $fs == $ZONE_POOL/$ZONE_CTR[01234] ]]; then
	log_must zfs set reservation=none $fs
	log_must zfs set recordsize=128K $fs
	log_must zfs set mountpoint=/$fs $fs
	typeset enc=""
	enc=$(get_prop encryption $fs)
	if [[ $? -ne 0 ]] \|\| [[ -z "$enc" ]] \|\| \
	[[ "$enc" == "off" ]]; then
	log_must zfs set checksum=on $fs
	fi
	log_must zfs set compression=off $fs
	log_must zfs set atime=on $fs
	log_must zfs set devices=off $fs
	log_must zfs set exec=on $fs
	log_must zfs set setuid=on $fs
	log_must zfs set readonly=off $fs
	log_must zfs set snapdir=hidden $fs
	log_must zfs set aclmode=groupmask $fs
	log_must zfs set aclinherit=secure $fs
	fi
	done
	fi

	[[ -d $TESTDIR ]] && \
	log_must rm -rf $TESTDIR

	disk1=${DISKS%% *}
	if is_mpath_device $disk1; then
	delete_partitions
	fi

	rm -f $TEST_BASE_DIR/{err,out}
	}


	#
	# Common function used to cleanup storage pools, file systems
	# and containers.
	#
	function default_container_cleanup
	{
	if ! is_global_zone; then
	reexport_pool
	fi

	ismounted $TESTPOOL/$TESTCTR/$TESTFS1
	[[ $? -eq 0 ]] && \
	log_must zfs unmount $TESTPOOL/$TESTCTR/$TESTFS1

	destroy_dataset "$TESTPOOL/$TESTCTR/$TESTFS1" "-R"
	destroy_dataset "$TESTPOOL/$TESTCTR" "-Rf"

	[[ -e $TESTDIR1 ]] && \
	log_must rm -rf $TESTDIR1 > /dev/null 2>&1

	default_cleanup
	}

	#
	# Common function used to cleanup snapshot of file system or volume. Default to
	# delete the file system's snapshot
	#
	# $1 snapshot name
	#
	function destroy_snapshot
	{
	typeset snap=${1:-$TESTPOOL/$TESTFS@$TESTSNAP}

	if ! snapexists $snap; then
	log_fail "'$snap' does not exist."
	fi

	#
	# For the sake of the value which come from 'get_prop' is not equal
	# to the really mountpoint when the snapshot is unmounted. So, firstly
	# check and make sure this snapshot's been mounted in current system.
	#
	typeset mtpt=""
	if ismounted $snap; then
	mtpt=$(get_prop mountpoint $snap)
	(($? != 0)) && \
	log_fail "get_prop mountpoint $snap failed."
	fi

	destroy_dataset "$snap"
	[[ $mtpt != "" && -d $mtpt ]] && \
	log_must rm -rf $mtpt
	}

	#
	# Common function used to cleanup clone.
	#
	# $1 clone name
	#
	function destroy_clone
	{
	typeset clone=${1:-$TESTPOOL/$TESTCLONE}

	if ! datasetexists $clone; then
	log_fail "'$clone' does not existed."
	fi

	# With the same reason in destroy_snapshot
	typeset mtpt=""
	if ismounted $clone; then
	mtpt=$(get_prop mountpoint $clone)
	(($? != 0)) && \
	log_fail "get_prop mountpoint $clone failed."
	fi

	destroy_dataset "$clone"
	[[ $mtpt != "" && -d $mtpt ]] && \
	log_must rm -rf $mtpt
	}

	#
	# Common function used to cleanup bookmark of file system or volume. Default
	# to delete the file system's bookmark.
	#
	# $1 bookmark name
	#
	function destroy_bookmark
	{
	typeset bkmark=${1:-$TESTPOOL/$TESTFS#$TESTBKMARK}

	if ! bkmarkexists $bkmark; then
	log_fail "'$bkmarkp' does not existed."
	fi

	destroy_dataset "$bkmark"
	}

	# Return 0 if a snapshot exists; $? otherwise
	#
	# $1 - snapshot name

	function snapexists
	{
	zfs list -H -t snapshot "$1" > /dev/null 2>&1
	return $?
	}

	#
	# Return 0 if a bookmark exists; $? otherwise
	#
	# $1 - bookmark name
	#
	function bkmarkexists
	{
	zfs list -H -t bookmark "$1" > /dev/null 2>&1
	return $?
	}

	#
	# Return 0 if a hold exists; $? otherwise
	#
	# $1 - hold tag
	# $2 - snapshot name
	#
	function holdexists
	{
	zfs holds "$2" \| awk '{ print $2 }' \| grep "$1" > /dev/null 2>&1
	return $?
	}

	#
	# Set a property to a certain value on a dataset.
	# Sets a property of the dataset to the value as passed in.
	# @param:
	# $1 dataset who's property is being set
	# $2 property to set
	# $3 value to set property to
	# @return:
	# 0 if the property could be set.
	# non-zero otherwise.
	# @use: ZFS
	#
	function dataset_setprop
	{
	typeset fn=dataset_setprop

	if (($# < 3)); then
	log_note "$fn: Insufficient parameters (need 3, had $#)"
	return 1
	fi
	typeset output=
	output=$(zfs set $2=$3 $1 2>&1)
	typeset rv=$?
	if ((rv != 0)); then
	log_note "Setting property on $1 failed."
	log_note "property $2=$3"
	log_note "Return Code: $rv"
	log_note "Output: $output"
	return $rv
	fi
	return 0
	}

	#
	# Assign suite defined dataset properties.
	# This function is used to apply the suite's defined default set of
	# properties to a dataset.
	# @parameters: $1 dataset to use
	# @uses: ZFS COMPRESSION_PROP CHECKSUM_PROP
	# @returns:
	# 0 if the dataset has been altered.
	# 1 if no pool name was passed in.
	# 2 if the dataset could not be found.
	# 3 if the dataset could not have it's properties set.
	#
	function dataset_set_defaultproperties
	{
	typeset dataset="$1"

	[[ -z $dataset ]] && return 1

	typeset confset=
	typeset -i found=0
	for confset in $(zfs list); do
	if [[ $dataset = $confset ]]; then
	found=1
	break
	fi
	done
	[[ $found -eq 0 ]] && return 2
	if [[ -n $COMPRESSION_PROP ]]; then
	dataset_setprop $dataset compression $COMPRESSION_PROP \|\| \
	return 3
	log_note "Compression set to '$COMPRESSION_PROP' on $dataset"
	fi
	if [[ -n $CHECKSUM_PROP ]]; then
	dataset_setprop $dataset checksum $CHECKSUM_PROP \|\| \
	return 3
	log_note "Checksum set to '$CHECKSUM_PROP' on $dataset"
	fi
	return 0
	}

	#
	# Check a numeric assertion
	# @parameter: $@ the assertion to check
	# @output: big loud notice if assertion failed
	# @use: log_fail
	#
	function assert
	{
	(($@)) \|\| log_fail "$@"
	}

	#
	# Function to format partition size of a disk
	# Given a disk cxtxdx reduces all partitions
	# to 0 size
	#
	function zero_partitions #<whole_disk_name>
	{
	typeset diskname=$1
	typeset i

	if is_freebsd; then
	gpart destroy -F $diskname
	elif is_linux; then
	DSK=$DEV_DSKDIR/$diskname
	DSK=$(echo $DSK \| sed -e "s\|//\|/\|g")
	log_must parted $DSK -s -- mklabel gpt
	blockdev --rereadpt $DSK 2>/dev/null
	block_device_wait
	else
	for i in 0 1 3 4 5 6 7
	do
	log_must set_partition $i "" 0mb $diskname
	done
	fi

	return 0
	}

	#
	# Given a slice, size and disk, this function
	# formats the slice to the specified size.
	# Size should be specified with units as per
	# the `format` command requirements eg. 100mb 3gb
	#
	# NOTE: This entire interface is problematic for the Linux parted utility
	# which requires the end of the partition to be specified. It would be
	# best to retire this interface and replace it with something more flexible.
	# At the moment a best effort is made.
	#
	# arguments: <slice_num> <slice_start> <size_plus_units> <whole_disk_name>
	function set_partition
	{
	typeset -i slicenum=$1
	typeset start=$2
	typeset size=$3
	typeset disk=${4#$DEV_DSKDIR/}
	disk=${disk#$DEV_RDSKDIR/}

	case "$(uname)" in
	Linux)
	if [[ -z $size \|\| -z $disk ]]; then
	log_fail "The size or disk name is unspecified."
	fi
	disk=$DEV_DSKDIR/$disk
	typeset size_mb=${size%%[mMgG]}

	size_mb=${size_mb%%[mMgG][bB]}
	if [[ ${size:1:1} == 'g' ]]; then
	((size_mb = size_mb * 1024))
	fi

	# Create GPT partition table when setting slice 0 or
	# when the device doesn't already contain a GPT label.
	parted $disk -s -- print 1 >/dev/null
	typeset ret_val=$?
	if [[ $slicenum -eq 0 \|\| $ret_val -ne 0 ]]; then
	parted $disk -s -- mklabel gpt
	if [[ $? -ne 0 ]]; then
	log_note "Failed to create GPT partition table on $disk"
	return 1
	fi
	fi

	# When no start is given align on the first cylinder.
	if [[ -z "$start" ]]; then
	start=1
	fi

	# Determine the cylinder size for the device and using
	# that calculate the end offset in cylinders.
	typeset -i cly_size_kb=0
	cly_size_kb=$(parted -m $disk -s -- \
	unit cyl print \| head -3 \| tail -1 \| \
	awk -F '[:k.]' '{print $4}')
	((end = (size_mb * 1024 / cly_size_kb) + start))

	parted $disk -s -- \
	mkpart part$slicenum ${start}cyl ${end}cyl
	typeset ret_val=$?
	if [[ $ret_val -ne 0 ]]; then
	log_note "Failed to create partition $slicenum on $disk"
	return 1
	fi

	blockdev --rereadpt $disk 2>/dev/null
	block_device_wait $disk
	;;
	FreeBSD)
	if [[ -z $size \|\| -z $disk ]]; then
	log_fail "The size or disk name is unspecified."
	fi
	disk=$DEV_DSKDIR/$disk

	if [[ $slicenum -eq 0 ]] \|\| ! gpart show $disk >/dev/null 2>&1; then
	gpart destroy -F $disk >/dev/null 2>&1
	gpart create -s GPT $disk
	if [[ $? -ne 0 ]]; then
	log_note "Failed to create GPT partition table on $disk"
	return 1
	fi
	fi

	typeset index=$((slicenum + 1))

	if [[ -n $start ]]; then
	start="-b $start"
	fi
	gpart add -t freebsd-zfs $start -s $size -i $index $disk
	if [[ $ret_val -ne 0 ]]; then
	log_note "Failed to create partition $slicenum on $disk"
	return 1
	fi

	block_device_wait $disk
	;;
	*)
	if [[ -z $slicenum \|\| -z $size \|\| -z $disk ]]; then
	log_fail "The slice, size or disk name is unspecified."
	fi

	typeset format_file=/var/tmp/format_in.$$

	echo "partition" >$format_file
	echo "$slicenum" >> $format_file
	echo "" >> $format_file
	echo "" >> $format_file
	echo "$start" >> $format_file
	echo "$size" >> $format_file
	echo "label" >> $format_file
	echo "" >> $format_file
	echo "q" >> $format_file
	echo "q" >> $format_file

	format -e -s -d $disk -f $format_file
	typeset ret_val=$?
	rm -f $format_file
	;;
	esac

	if [[ $ret_val -ne 0 ]]; then
	log_note "Unable to format $disk slice $slicenum to $size"
	return 1
	fi
	return 0
	}

	#
	# Delete all partitions on all disks - this is specifically for the use of multipath
	# devices which currently can only be used in the test suite as raw/un-partitioned
	# devices (ie a zpool cannot be created on a whole mpath device that has partitions)
	#
	function delete_partitions
	{
	typeset disk

	if [[ -z $DISKSARRAY ]]; then
	DISKSARRAY=$DISKS
	fi

	if is_linux; then
	typeset -i part
	for disk in $DISKSARRAY; do
	for (( part = 1; part < MAX_PARTITIONS; part++ )); do
	typeset partition=${disk}${SLICE_PREFIX}${part}
	parted $DEV_DSKDIR/$disk -s rm $part > /dev/null 2>&1
	if lsblk \| grep -qF ${partition}; then
	log_fail "Partition ${partition} not deleted"
	else
	log_note "Partition ${partition} deleted"
	fi
	done
	done
	elif is_freebsd; then
	for disk in $DISKSARRAY; do
	if gpart destroy -F $disk; then
	log_note "Partitions for ${disk} deleted"
	else
	log_fail "Partitions for ${disk} not deleted"
	fi
	done
	fi
	}

	#
	# Get the end cyl of the given slice
	#
	function get_endslice #<disk> <slice>
	{
	typeset disk=$1
	typeset slice=$2
	if [[ -z $disk \|\| -z $slice ]] ; then
	log_fail "The disk name or slice number is unspecified."
	fi

	case "$(uname)" in
	Linux)
	endcyl=$(parted -s $DEV_DSKDIR/$disk -- unit cyl print \| \
	grep "part${slice}" \| \
	awk '{print $3}' \| \
	sed 's,cyl,,')
	((endcyl = (endcyl + 1)))
	;;
	FreeBSD)
	disk=${disk#/dev/zvol/}
	disk=${disk%p*}
	slice=$((slice + 1))
	endcyl=$(gpart show $disk \| \
	awk -v slice=$slice '$3 == slice { print $1 + $2 }')
	;;
	*)
	disk=${disk#/dev/dsk/}
	disk=${disk#/dev/rdsk/}
	disk=${disk%s*}

	typeset -i ratio=0
	ratio=$(prtvtoc /dev/rdsk/${disk}s2 \| \
	grep "sectors\/cylinder" \| \
	awk '{print $2}')

	if ((ratio == 0)); then
	return
	fi

	typeset -i endcyl=$(prtvtoc -h /dev/rdsk/${disk}s2 \|
	nawk -v token="$slice" '{if ($1==token) print $6}')

	((endcyl = (endcyl + 1) / ratio))
	;;
	esac

	echo $endcyl
	}


	#
	# Given a size,disk and total slice number, this function formats the
	# disk slices from 0 to the total slice number with the same specified
	# size.
	#
	function partition_disk #<slice_size> <whole_disk_name> <total_slices>
	{
	typeset -i i=0
	typeset slice_size=$1
	typeset disk_name=$2
	typeset total_slices=$3
	typeset cyl

	zero_partitions $disk_name
	while ((i < $total_slices)); do
	if ! is_linux; then
	if ((i == 2)); then
	((i = i + 1))
	continue
	fi
	fi
	log_must set_partition $i "$cyl" $slice_size $disk_name
	cyl=$(get_endslice $disk_name $i)
	((i = i+1))
	done
	}

	#
	# This function continues to write to a filenum number of files into dirnum
	# number of directories until either file_write returns an error or the
	# maximum number of files per directory have been written.
	#
	# Usage:
	# fill_fs [destdir] [dirnum] [filenum] [bytes] [num_writes] [data]
	#
	# Return value: 0 on success
	# non 0 on error
	#
	# Where :
	# destdir: is the directory where everything is to be created under
	# dirnum: the maximum number of subdirectories to use, -1 no limit
	# filenum: the maximum number of files per subdirectory
	# bytes: number of bytes to write
	# num_writes: number of types to write out bytes
	# data: the data that will be written
	#
	# E.g.
	# fill_fs /testdir 20 25 1024 256 0
	#
	# Note: bytes * num_writes equals the size of the testfile
	#
	function fill_fs # destdir dirnum filenum bytes num_writes data
	{
	typeset destdir=${1:-$TESTDIR}
	typeset -i dirnum=${2:-50}
	typeset -i filenum=${3:-50}
	typeset -i bytes=${4:-8192}
	typeset -i num_writes=${5:-10240}
	typeset data=${6:-0}

	mkdir -p $destdir/{1..$dirnum}
	for f in $destdir/{1..$dirnum}/$TESTFILE{1..$filenum}; do
	file_write -o create -f $f -b $bytes -c $num_writes -d $data \
	\|\| return $?
	done
	return 0
	}

	#
	# Simple function to get the specified property. If unable to
	# get the property then exits.
	#
	# Note property is in 'parsable' format (-p)
	#
	function get_prop # property dataset
	{
	typeset prop_val
	typeset prop=$1
	typeset dataset=$2

	prop_val=$(zfs get -pH -o value $prop $dataset 2>/dev/null)
	if [[ $? -ne 0 ]]; then
	log_note "Unable to get $prop property for dataset " \
	"$dataset"
	return 1
	fi

	echo "$prop_val"
	return 0
	}

	#
	# Simple function to get the specified property of pool. If unable to
	# get the property then exits.
	#
	# Note property is in 'parsable' format (-p)
	#
	function get_pool_prop # property pool
	{
	typeset prop_val
	typeset prop=$1
	typeset pool=$2

	if poolexists $pool ; then
	prop_val=$(zpool get -pH $prop $pool 2>/dev/null \| tail -1 \| \
	awk '{print $3}')
	if [[ $? -ne 0 ]]; then
	log_note "Unable to get $prop property for pool " \
	"$pool"
	return 1
	fi
	else
	log_note "Pool $pool not exists."
	return 1
	fi

	echo "$prop_val"
	return 0
	}

	# Return 0 if a pool exists; $? otherwise
	#
	# $1 - pool name

	function poolexists
	{
	typeset pool=$1

	if [[ -z $pool ]]; then
	log_note "No pool name given."
	return 1
	fi

	zpool get name "$pool" > /dev/null 2>&1
	return $?
	}

	# Return 0 if all the specified datasets exist; $? otherwise
	#
	# $1-n dataset name
	function datasetexists
	{
	if (($# == 0)); then
	log_note "No dataset name given."
	return 1
	fi

	while (($# > 0)); do
	zfs get name $1 > /dev/null 2>&1 \|\| \
	return $?
	shift
	done

	return 0
	}

	# return 0 if none of the specified datasets exists, otherwise return 1.
	#
	# $1-n dataset name
	function datasetnonexists
	{
	if (($# == 0)); then
	log_note "No dataset name given."
	return 1
	fi

	while (($# > 0)); do
	zfs list -H -t filesystem,snapshot,volume $1 > /dev/null 2>&1 \
	&& return 1
	shift
	done

	return 0
	}

	function is_shared_freebsd
	{
	typeset fs=$1

	pgrep -q mountd && showmount -E \| grep -qx $fs
	}

	function is_shared_illumos
	{
	typeset fs=$1
	typeset mtpt

	for mtpt in `share \| awk '{print $2}'` ; do
	if [[ $mtpt == $fs ]] ; then
	return 0
	fi
	done

	typeset stat=$(svcs -H -o STA nfs/server:default)
	if [[ $stat != "ON" ]]; then
	log_note "Current nfs/server status: $stat"
	fi

	return 1
	}

	function is_shared_linux
	{
	typeset fs=$1
	typeset mtpt

	for mtpt in `share \| awk '{print $1}'` ; do
	if [[ $mtpt == $fs ]] ; then
	return 0
	fi
	done
	return 1
	}

	#
	# Given a mountpoint, or a dataset name, determine if it is shared via NFS.
	#
	# Returns 0 if shared, 1 otherwise.
	#
	function is_shared
	{
	typeset fs=$1
	typeset mtpt

	if [[ $fs != "/"* ]] ; then
	if datasetnonexists "$fs" ; then
	return 1
	else
	mtpt=$(get_prop mountpoint "$fs")
	case $mtpt in
	none\|legacy\|-) return 1
	;;
	*) fs=$mtpt
	;;
	esac
	fi
	fi

	case $(uname) in
	FreeBSD) is_shared_freebsd "$fs" ;;
	Linux) is_shared_linux "$fs" ;;
	*) is_shared_illumos "$fs" ;;
	esac
	}

	function is_exported_illumos
	{
	typeset fs=$1
	typeset mtpt

	for mtpt in `awk '{print $1}' /etc/dfs/sharetab` ; do
	if [[ $mtpt == $fs ]] ; then
	return 0
	fi
	done

	return 1
	}

	function is_exported_freebsd
	{
	typeset fs=$1
	typeset mtpt

	for mtpt in `awk '{print $1}' /etc/zfs/exports` ; do
	if [[ $mtpt == $fs ]] ; then
	return 0
	fi
	done

	return 1
	}

	function is_exported_linux
	{
	typeset fs=$1
	typeset mtpt

	for mtpt in `awk '{print $1}' /etc/exports.d/zfs.exports` ; do
	if [[ $mtpt == $fs ]] ; then
	return 0
	fi
	done

	return 1
	}

	#
	# Given a mountpoint, or a dataset name, determine if it is exported via
	# the os-specific NFS exports file.
	#
	# Returns 0 if exported, 1 otherwise.
	#
	function is_exported
	{
	typeset fs=$1
	typeset mtpt

	if [[ $fs != "/"* ]] ; then
	if datasetnonexists "$fs" ; then
	return 1
	else
	mtpt=$(get_prop mountpoint "$fs")
	case $mtpt in
	none\|legacy\|-) return 1
	;;
	*) fs=$mtpt
	;;
	esac
	fi
	fi

	case $(uname) in
	FreeBSD) is_exported_freebsd "$fs" ;;
	Linux) is_exported_linux "$fs" ;;
	*) is_exported_illumos "$fs" ;;
	esac
	}

	#
	# Given a dataset name determine if it is shared via SMB.
	#
	# Returns 0 if shared, 1 otherwise.
	#
	function is_shared_smb
	{
	typeset fs=$1
	typeset mtpt

	if datasetnonexists "$fs" ; then
	return 1
	else
	fs=$(echo $fs \| sed 's@/@_@g')
	fi

	if is_linux; then
	for mtpt in `net usershare list \| awk '{print $1}'` ; do
	if [[ $mtpt == $fs ]] ; then
	return 0
	fi
	done
	return 1
	else
	log_note "Currently unsupported by the test framework"
	return 1
	fi
	}

	#
	# Given a mountpoint, determine if it is not shared via NFS.
	#
	# Returns 0 if not shared, 1 otherwise.
	#
	function not_shared
	{
	typeset fs=$1

	is_shared $fs
	if (($? == 0)); then
	return 1
	fi

	return 0
	}

	#
	# Given a dataset determine if it is not shared via SMB.
	#
	# Returns 0 if not shared, 1 otherwise.
	#
	function not_shared_smb
	{
	typeset fs=$1

	is_shared_smb $fs
	if (($? == 0)); then
	return 1
	fi

	return 0
	}

	#
	# Helper function to unshare a mountpoint.
	#
	function unshare_fs #fs
	{
	typeset fs=$1

	is_shared $fs \|\| is_shared_smb $fs
	if (($? == 0)); then
	zfs unshare $fs \|\| log_fail "zfs unshare $fs failed"
	fi

	return 0
	}

	#
	# Helper function to share a NFS mountpoint.
	#
	function share_nfs #fs
	{
	typeset fs=$1

	if is_linux; then
	is_shared $fs
	if (($? != 0)); then
	log_must share "*:$fs"
	fi
	else
	is_shared $fs
	if (($? != 0)); then
	log_must share -F nfs $fs
	fi
	fi

	return 0
	}

	#
	# Helper function to unshare a NFS mountpoint.
	#
	function unshare_nfs #fs
	{
	typeset fs=$1

	if is_linux; then
	is_shared $fs
	if (($? == 0)); then
	log_must unshare -u "*:$fs"
	fi
	else
	is_shared $fs
	if (($? == 0)); then
	log_must unshare -F nfs $fs
	fi
	fi

	return 0
	}

	#
	# Helper function to show NFS shares.
	#
	function showshares_nfs
	{
	if is_linux; then
	share -v
	else
	share -F nfs
	fi

	return 0
	}

	#
	# Helper function to show SMB shares.
	#
	function showshares_smb
	{
	if is_linux; then
	net usershare list
	else
	share -F smb
	fi

	return 0
	}

	function check_nfs
	{
	if is_linux; then
	share -s
	elif is_freebsd; then
	showmount -e
	else
	log_unsupported "Unknown platform"
	fi

	if [[ $? -ne 0 ]]; then
	log_unsupported "The NFS utilities are not installed"
	fi
	}

	#
	# Check NFS server status and trigger it online.
	#
	function setup_nfs_server
	{
	# Cannot share directory in non-global zone.
	#
	if ! is_global_zone; then
	log_note "Cannot trigger NFS server by sharing in LZ."
	return
	fi

	if is_linux; then
	#
	# Re-synchronize /var/lib/nfs/etab with /etc/exports and
	# /etc/exports.d./* to provide a clean test environment.
	#
	log_must share -r

	log_note "NFS server must be started prior to running ZTS."
	return
	elif is_freebsd; then
	kill -s HUP $(cat /var/run/mountd.pid)

	log_note "NFS server must be started prior to running ZTS."
	return
	fi

	typeset nfs_fmri="svc:/network/nfs/server:default"
	if [[ $(svcs -Ho STA $nfs_fmri) != "ON" ]]; then
	#
	# Only really sharing operation can enable NFS server
	# to online permanently.
	#
	typeset dummy=/tmp/dummy

	if [[ -d $dummy ]]; then
	log_must rm -rf $dummy
	fi

	log_must mkdir $dummy
	log_must share $dummy

	#
	# Waiting for fmri's status to be the final status.
	# Otherwise, in transition, an asterisk (*) is appended for
	# instances, unshare will reverse status to 'DIS' again.
	#
	# Waiting for 1's at least.
	#
	log_must sleep 1
	timeout=10
	while [[ timeout -ne 0 && $(svcs -Ho STA $nfs_fmri) == '' ]]
	do
	log_must sleep 1

	((timeout -= 1))
	done

	log_must unshare $dummy
	log_must rm -rf $dummy
	fi

	log_note "Current NFS status: '$(svcs -Ho STA,FMRI $nfs_fmri)'"
	}

	#
	# To verify whether calling process is in global zone
	#
	# Return 0 if in global zone, 1 in non-global zone
	#
	function is_global_zone
	{
	if is_linux \|\| is_freebsd; then
	return 0
	else
	typeset cur_zone=$(zonename 2>/dev/null)
	if [[ $cur_zone != "global" ]]; then
	return 1
	fi
	return 0
	fi
	}

	#
	# Verify whether test is permitted to run from
	# global zone, local zone, or both
	#
	# $1 zone limit, could be "global", "local", or "both"(no limit)
	#
	# Return 0 if permitted, otherwise exit with log_unsupported
	#
	function verify_runnable # zone limit
	{
	typeset limit=$1

	[[ -z $limit ]] && return 0

	if is_global_zone ; then
	case $limit in
	global\|both)
	;;
	local) log_unsupported "Test is unable to run from "\
	"global zone."
	;;
	*) log_note "Warning: unknown limit $limit - " \
	"use both."
	;;
	esac
	else
	case $limit in
	local\|both)
	;;
	global) log_unsupported "Test is unable to run from "\
	"local zone."
	;;
	*) log_note "Warning: unknown limit $limit - " \
	"use both."
	;;
	esac

	reexport_pool
	fi

	return 0
	}

	# Return 0 if create successfully or the pool exists; $? otherwise
	# Note: In local zones, this function should return 0 silently.
	#
	# $1 - pool name
	# $2-n - [keyword] devs_list

	function create_pool #pool devs_list
	{
	typeset pool=${1%%/*}

	shift

	if [[ -z $pool ]]; then
	log_note "Missing pool name."
	return 1
	fi

	if poolexists $pool ; then
	destroy_pool $pool
	fi

	if is_global_zone ; then
	[[ -d /$pool ]] && rm -rf /$pool
	log_must zpool create -f $pool $@
	fi

	return 0
	}

	# Return 0 if destroy successfully or the pool exists; $? otherwise
	# Note: In local zones, this function should return 0 silently.
	#
	# $1 - pool name
	# Destroy pool with the given parameters.

	function destroy_pool #pool
	{
	typeset pool=${1%%/*}
	typeset mtpt

	if [[ -z $pool ]]; then
	log_note "No pool name given."
	return 1
	fi

	if is_global_zone ; then
	if poolexists "$pool" ; then
	mtpt=$(get_prop mountpoint "$pool")

	# At times, syseventd/udev activity can cause attempts
	# to destroy a pool to fail with EBUSY. We retry a few
	# times allowing failures before requiring the destroy
	# to succeed.
	log_must_busy zpool destroy -f $pool

	[[ -d $mtpt ]] && \
	log_must rm -rf $mtpt
	else
	log_note "Pool does not exist. ($pool)"
	return 1
	fi
	fi

	return 0
	}

	# Return 0 if created successfully; $? otherwise
	#
	# $1 - dataset name
	# $2-n - dataset options

	function create_dataset #dataset dataset_options
	{
	typeset dataset=$1

	shift

	if [[ -z $dataset ]]; then
	log_note "Missing dataset name."
	return 1
	fi

	if datasetexists $dataset ; then
	destroy_dataset $dataset
	fi

	log_must zfs create $@ $dataset

	return 0
	}

	# Return 0 if destroy successfully or the dataset exists; $? otherwise
	# Note: In local zones, this function should return 0 silently.
	#
	# $1 - dataset name
	# $2 - custom arguments for zfs destroy
	# Destroy dataset with the given parameters.

	function destroy_dataset #dataset #args
	{
	typeset dataset=$1
	typeset mtpt
	typeset args=${2:-""}

	if [[ -z $dataset ]]; then
	log_note "No dataset name given."
	return 1
	fi

	if is_global_zone ; then
	if datasetexists "$dataset" ; then
	mtpt=$(get_prop mountpoint "$dataset")
	log_must_busy zfs destroy $args $dataset

	[[ -d $mtpt ]] && \
	log_must rm -rf $mtpt
	else
	log_note "Dataset does not exist. ($dataset)"
	return 1
	fi
	fi

	return 0
	}

	#
	# Firstly, create a pool with 5 datasets. Then, create a single zone and
	# export the 5 datasets to it. In addition, we also add a ZFS filesystem
	# and a zvol device to the zone.
	#
	# $1 zone name
	# $2 zone root directory prefix
	# $3 zone ip
	#
	function zfs_zones_setup #zone_name zone_root zone_ip
	{
	typeset zone_name=${1:-$(hostname)-z}
	typeset zone_root=${2:-"/zone_root"}
	typeset zone_ip=${3:-"10.1.1.10"}
	typeset prefix_ctr=$ZONE_CTR
	typeset pool_name=$ZONE_POOL
	typeset -i cntctr=5
	typeset -i i=0

	# Create pool and 5 container within it
	#
	[[ -d /$pool_name ]] && rm -rf /$pool_name
	log_must zpool create -f $pool_name $DISKS
	while ((i < cntctr)); do
	log_must zfs create $pool_name/$prefix_ctr$i
	((i += 1))
	done

	# create a zvol
	log_must zfs create -V 1g $pool_name/zone_zvol
	block_device_wait

	#
	# If current system support slog, add slog device for pool
	#
	if verify_slog_support ; then
	typeset sdevs="$TEST_BASE_DIR/sdev1 $TEST_BASE_DIR/sdev2"
	log_must mkfile $MINVDEVSIZE $sdevs
	log_must zpool add $pool_name log mirror $sdevs
	fi

	# this isn't supported just yet.
	# Create a filesystem. In order to add this to
	# the zone, it must have it's mountpoint set to 'legacy'
	# log_must zfs create $pool_name/zfs_filesystem
	# log_must zfs set mountpoint=legacy $pool_name/zfs_filesystem

	[[ -d $zone_root ]] && \
	log_must rm -rf $zone_root/$zone_name
	[[ ! -d $zone_root ]] && \
	log_must mkdir -p -m 0700 $zone_root/$zone_name

	# Create zone configure file and configure the zone
	#
	typeset zone_conf=/tmp/zone_conf.$$
	echo "create" > $zone_conf
	echo "set zonepath=$zone_root/$zone_name" >> $zone_conf
	echo "set autoboot=true" >> $zone_conf
	i=0
	while ((i < cntctr)); do
	echo "add dataset" >> $zone_conf
	echo "set name=$pool_name/$prefix_ctr$i" >> \
	$zone_conf
	echo "end" >> $zone_conf
	((i += 1))
	done

	# add our zvol to the zone
	echo "add device" >> $zone_conf
	echo "set match=/dev/zvol/dsk/$pool_name/zone_zvol" >> $zone_conf
	echo "end" >> $zone_conf

	# add a corresponding zvol rdsk to the zone
	echo "add device" >> $zone_conf
	echo "set match=$ZVOL_RDEVDIR/$pool_name/zone_zvol" >> $zone_conf
	echo "end" >> $zone_conf

	# once it's supported, we'll add our filesystem to the zone
	# echo "add fs" >> $zone_conf
	# echo "set type=zfs" >> $zone_conf
	# echo "set special=$pool_name/zfs_filesystem" >> $zone_conf
	# echo "set dir=/export/zfs_filesystem" >> $zone_conf
	# echo "end" >> $zone_conf

	echo "verify" >> $zone_conf
	echo "commit" >> $zone_conf
	log_must zonecfg -z $zone_name -f $zone_conf
	log_must rm -f $zone_conf

	# Install the zone
	zoneadm -z $zone_name install
	if (($? == 0)); then
	log_note "SUCCESS: zoneadm -z $zone_name install"
	else
	log_fail "FAIL: zoneadm -z $zone_name install"
	fi

	# Install sysidcfg file
	#
	typeset sysidcfg=$zone_root/$zone_name/root/etc/sysidcfg
	echo "system_locale=C" > $sysidcfg
	echo "terminal=dtterm" >> $sysidcfg
	echo "network_interface=primary {" >> $sysidcfg
	echo "hostname=$zone_name" >> $sysidcfg
	echo "}" >> $sysidcfg
	echo "name_service=NONE" >> $sysidcfg
	echo "root_password=mo791xfZ/SFiw" >> $sysidcfg
	echo "security_policy=NONE" >> $sysidcfg
	echo "timezone=US/Eastern" >> $sysidcfg

	# Boot this zone
	log_must zoneadm -z $zone_name boot
	}

	#
	# Reexport TESTPOOL & TESTPOOL(1-4)
	#
	function reexport_pool
	{
	typeset -i cntctr=5
	typeset -i i=0

	while ((i < cntctr)); do
	if ((i == 0)); then
	TESTPOOL=$ZONE_POOL/$ZONE_CTR$i
	if ! ismounted $TESTPOOL; then
	log_must zfs mount $TESTPOOL
	fi
	else
	eval TESTPOOL$i=$ZONE_POOL/$ZONE_CTR$i
	if eval ! ismounted \$TESTPOOL$i; then
	log_must eval zfs mount \$TESTPOOL$i
	fi
	fi
	((i += 1))
	done
	}

	#
	# Verify a given disk or pool state
	#
	# Return 0 is pool/disk matches expected state, 1 otherwise
	#
	function check_state # pool disk state{online,offline,degraded}
	{
	typeset pool=$1
	typeset disk=${2#$DEV_DSKDIR/}
	typeset state=$3

	[[ -z $pool ]] \|\| [[ -z $state ]] \
	&& log_fail "Arguments invalid or missing"

	if [[ -z $disk ]]; then
	#check pool state only
	zpool get -H -o value health $pool \
	\| grep -i "$state" > /dev/null 2>&1
	else
	zpool status -v $pool \| grep "$disk" \
	\| grep -i "$state" > /dev/null 2>&1
	fi

	return $?
	}

	#
	# Get the mountpoint of snapshot
	# For the snapshot use <mp_filesystem>/.zfs/snapshot/<snap>
	# as its mountpoint
	#
	function snapshot_mountpoint
	{
	typeset dataset=${1:-$TESTPOOL/$TESTFS@$TESTSNAP}

	if [[ $dataset != @ ]]; then
	log_fail "Error name of snapshot '$dataset'."
	fi

	typeset fs=${dataset%@*}
	typeset snap=${dataset#*@}

	if [[ -z $fs \|\| -z $snap ]]; then
	log_fail "Error name of snapshot '$dataset'."
	fi

	echo $(get_prop mountpoint $fs)/.zfs/snapshot/$snap
	}

	#
	# Given a device and 'ashift' value verify it's correctly set on every label
	#
	function verify_ashift # device ashift
	{
	typeset device="$1"
	typeset ashift="$2"

	zdb -e -lll $device \| awk -v ashift=$ashift '/ashift: / {
	if (ashift != $2)
	exit 1;
	else
	count++;
	} END {
	if (count != 4)
	exit 1;
	else
	exit 0;
	}'

	return $?
	}

	#
	# Given a pool and file system, this function will verify the file system
	# using the zdb internal tool. Note that the pool is exported and imported
	# to ensure it has consistent state.
	#
	function verify_filesys # pool filesystem dir
	{
	typeset pool="$1"
	typeset filesys="$2"
	typeset zdbout="/tmp/zdbout.$$"

	shift
	shift
	typeset dirs=$@
	typeset search_path=""

	log_note "Calling zdb to verify filesystem '$filesys'"
	zfs unmount -a > /dev/null 2>&1
	log_must zpool export $pool

	if [[ -n $dirs ]] ; then
	for dir in $dirs ; do
	search_path="$search_path -d $dir"
	done
	fi

	log_must zpool import $search_path $pool

	zdb -cudi $filesys > $zdbout 2>&1
	if [[ $? != 0 ]]; then
	log_note "Output: zdb -cudi $filesys"
	cat $zdbout
	log_fail "zdb detected errors with: '$filesys'"
	fi

	log_must zfs mount -a
	log_must rm -rf $zdbout
	}

	#
	# Given a pool issue a scrub and verify that no checksum errors are reported.
	#
	function verify_pool
	{
	typeset pool=${1:-$TESTPOOL}

	log_must zpool scrub $pool
	log_must wait_scrubbed $pool

	typeset -i cksum=$(zpool status $pool \| awk '
	!NF { isvdev = 0 }
	isvdev { errors += $NF }
	/CKSUM$/ { isvdev = 1 }
	END { print errors }
	')
	if [[ $cksum != 0 ]]; then
	log_must zpool status -v
	log_fail "Unexpected CKSUM errors found on $pool ($cksum)"
	fi
	}

	#
	# Given a pool, and this function list all disks in the pool
	#
	function get_disklist # pool
	{
	typeset disklist=""

	disklist=$(zpool iostat -v $1 \| nawk '(NR >4) {print $1}' \| \
	grep -v "\-\-\-\-\-" \| \
	egrep -v -e "^(mirror\|raidz[1-3]\|spare\|log\|cache\|special\|dedup)$")

	echo $disklist
	}

	#
	# Given a pool, and this function list all disks in the pool with their full
	# path (like "/dev/sda" instead of "sda").
	#
	function get_disklist_fullpath # pool
	{
	args="-P $1"
	get_disklist $args
	}



	# /**
	# This function kills a given list of processes after a time period. We use
	# this in the stress tests instead of STF_TIMEOUT so that we can have processes
	# run for a fixed amount of time, yet still pass. Tests that hit STF_TIMEOUT
	# would be listed as FAIL, which we don't want : we're happy with stress tests
	# running for a certain amount of time, then finishing.
	#
	# @param $1 the time in seconds after which we should terminate these processes
	# @param $2..$n the processes we wish to terminate.
	# */
	function stress_timeout
	{
	typeset -i TIMEOUT=$1
	shift
	typeset cpids="$@"

	log_note "Waiting for child processes($cpids). " \
	"It could last dozens of minutes, please be patient ..."
	log_must sleep $TIMEOUT

	log_note "Killing child processes after ${TIMEOUT} stress timeout."
	typeset pid
	for pid in $cpids; do
	ps -p $pid > /dev/null 2>&1
	if (($? == 0)); then
	log_must kill -USR1 $pid
	fi
	done
	}

	#
	# Verify a given hotspare disk is inuse or avail
	#
	# Return 0 is pool/disk matches expected state, 1 otherwise
	#
	function check_hotspare_state # pool disk state{inuse,avail}
	{
	typeset pool=$1
	typeset disk=${2#$DEV_DSKDIR/}
	typeset state=$3

	cur_state=$(get_device_state $pool $disk "spares")

	if [[ $state != ${cur_state} ]]; then
	return 1
	fi
	return 0
	}

	#
	# Wait until a hotspare transitions to a given state or times out.
	#
	# Return 0 when pool/disk matches expected state, 1 on timeout.
	#
	function wait_hotspare_state # pool disk state timeout
	{
	typeset pool=$1
	typeset disk=${2#*$DEV_DSKDIR/}
	typeset state=$3
	typeset timeout=${4:-60}
	typeset -i i=0

	while [[ $i -lt $timeout ]]; do
	if check_hotspare_state $pool $disk $state; then
	return 0
	fi

	i=$((i+1))
	sleep 1
	done

	return 1
	}

	#
	# Verify a given slog disk is inuse or avail
	#
	# Return 0 is pool/disk matches expected state, 1 otherwise
	#
	function check_slog_state # pool disk state{online,offline,unavail}
	{
	typeset pool=$1
	typeset disk=${2#$DEV_DSKDIR/}
	typeset state=$3

	cur_state=$(get_device_state $pool $disk "logs")

	if [[ $state != ${cur_state} ]]; then
	return 1
	fi
	return 0
	}

	#
	# Verify a given vdev disk is inuse or avail
	#
	# Return 0 is pool/disk matches expected state, 1 otherwise
	#
	function check_vdev_state # pool disk state{online,offline,unavail}
	{
	typeset pool=$1
	typeset disk=${2#*$DEV_DSKDIR/}
	typeset state=$3

	cur_state=$(get_device_state $pool $disk)

	if [[ $state != ${cur_state} ]]; then
	return 1
	fi
	return 0
	}

	#
	# Wait until a vdev transitions to a given state or times out.
	#
	# Return 0 when pool/disk matches expected state, 1 on timeout.
	#
	function wait_vdev_state # pool disk state timeout
	{
	typeset pool=$1
	typeset disk=${2#*$DEV_DSKDIR/}
	typeset state=$3
	typeset timeout=${4:-60}
	typeset -i i=0

	while [[ $i -lt $timeout ]]; do
	if check_vdev_state $pool $disk $state; then
	return 0
	fi

	i=$((i+1))
	sleep 1
	done

	return 1
	}

	#
	# Check the output of 'zpool status -v <pool>',
	# and to see if the content of <token> contain the <keyword> specified.
	#
	# Return 0 is contain, 1 otherwise
	#
	function check_pool_status # pool token keyword <verbose>
	{
	typeset pool=$1
	typeset token=$2
	typeset keyword=$3
	typeset verbose=${4:-false}

	scan=$(zpool status -v "$pool" 2>/dev/null \| nawk -v token="$token:" '
	($1==token) {print $0}')
	if [[ $verbose == true ]]; then
	log_note $scan
	fi
	echo $scan \| egrep -i "$keyword" > /dev/null 2>&1

	return $?
	}

	#
	# The following functions are instance of check_pool_status()
	# is_pool_resilvering - to check if the pool resilver is in progress
	# is_pool_resilvered - to check if the pool resilver is completed
	# is_pool_scrubbing - to check if the pool scrub is in progress
	# is_pool_scrubbed - to check if the pool scrub is completed
	# is_pool_scrub_stopped - to check if the pool scrub is stopped
	# is_pool_scrub_paused - to check if the pool scrub has paused
	# is_pool_removing - to check if the pool removing is a vdev
	# is_pool_removed - to check if the pool remove is completed
	# is_pool_discarding - to check if the pool checkpoint is being discarded
	#
	function is_pool_resilvering #pool <verbose>
	{
	check_pool_status "$1" "scan" \
	"resilver[ ()0-9A-Za-z:_-]* in progress since" $2
	return $?
	}

	function is_pool_resilvered #pool <verbose>
	{
	check_pool_status "$1" "scan" "resilvered " $2
	return $?
	}

	function is_pool_scrubbing #pool <verbose>
	{
	check_pool_status "$1" "scan" "scrub in progress since " $2
	return $?
	}

	function is_pool_scrubbed #pool <verbose>
	{
	check_pool_status "$1" "scan" "scrub repaired" $2
	return $?
	}

	function is_pool_scrub_stopped #pool <verbose>
	{
	check_pool_status "$1" "scan" "scrub canceled" $2
	return $?
	}

	function is_pool_scrub_paused #pool <verbose>
	{
	check_pool_status "$1" "scan" "scrub paused since " $2
	return $?
	}

	function is_pool_removing #pool
	{
	check_pool_status "$1" "remove" "in progress since "
	return $?
	}

	function is_pool_removed #pool
	{
	check_pool_status "$1" "remove" "completed on"
	return $?
	}

	function is_pool_discarding #pool
	{
	check_pool_status "$1" "checkpoint" "discarding"
	return $?
	}

	function wait_for_degraded
	{
	typeset pool=$1
	typeset timeout=${2:-30}
	typeset t0=$SECONDS

	while :; do
	[[ $(get_pool_prop health $pool) == "DEGRADED" ]] && break
	log_note "$pool is not yet degraded."
	sleep 1
	if ((SECONDS - t0 > $timeout)); then
	log_note "$pool not degraded after $timeout seconds."
	return 1
	fi
	done

	return 0
	}

	#
	# Use create_pool()/destroy_pool() to clean up the information in
	# in the given disk to avoid slice overlapping.
	#
	function cleanup_devices #vdevs
	{
	typeset pool="foopool$$"

	for vdev in $@; do
	zero_partitions $vdev
	done

	poolexists $pool && destroy_pool $pool
	create_pool $pool $@
	destroy_pool $pool

	return 0
	}

	#/**
	# A function to find and locate free disks on a system or from given
	# disks as the parameter. It works by locating disks that are in use
	# as swap devices and dump devices, and also disks listed in /etc/vfstab
	#
	# $@ given disks to find which are free, default is all disks in
	# the test system
	#
	# @return a string containing the list of available disks
	#*/
	function find_disks
	{
	# Trust provided list, no attempt is made to locate unused devices.
	if is_linux \|\| is_freebsd; then
	echo "$@"
	return
	fi


	sfi=/tmp/swaplist.$$
	dmpi=/tmp/dumpdev.$$
	max_finddisksnum=${MAX_FINDDISKSNUM:-6}

	swap -l > $sfi
	dumpadm > $dmpi 2>/dev/null

	# write an awk script that can process the output of format
	# to produce a list of disks we know about. Note that we have
	# to escape "$2" so that the shell doesn't interpret it while
	# we're creating the awk script.
	# -------------------
	cat > /tmp/find_disks.awk <<EOF
	#!/bin/nawk -f
	BEGIN { FS="."; }

	/^Specify disk/{
	searchdisks=0;
	}

	{
	if (searchdisks && \$2 !~ "^$"){
	split(\$2,arr," ");
	print arr[1];
	}
	}

	/^AVAILABLE DISK SELECTIONS:/{
	searchdisks=1;
	}
	EOF
	#---------------------

	chmod 755 /tmp/find_disks.awk
	disks=${@:-$(echo "" \| format -e 2>/dev/null \| /tmp/find_disks.awk)}
	rm /tmp/find_disks.awk

	unused=""
	for disk in $disks; do
	# Check for mounted
	grep "${disk}[sp]" /etc/mnttab >/dev/null
	(($? == 0)) && continue
	# Check for swap
	grep "${disk}[sp]" $sfi >/dev/null
	(($? == 0)) && continue
	# check for dump device
	grep "${disk}[sp]" $dmpi >/dev/null
	(($? == 0)) && continue
	# check to see if this disk hasn't been explicitly excluded
	# by a user-set environment variable
	echo "${ZFS_HOST_DEVICES_IGNORE}" \| grep "${disk}" > /dev/null
	(($? == 0)) && continue
	unused_candidates="$unused_candidates $disk"
	done
	rm $sfi
	rm $dmpi

	# now just check to see if those disks do actually exist
	# by looking for a device pointing to the first slice in
	# each case. limit the number to max_finddisksnum
	count=0
	for disk in $unused_candidates; do
	if is_disk_device $DEV_DSKDIR/${disk}s0 && \
	[ $count -lt $max_finddisksnum ]; then
	unused="$unused $disk"
	# do not impose limit if $@ is provided
	[[ -z $@ ]] && ((count = count + 1))
	fi
	done

	# finally, return our disk list
	echo $unused
	}

	function add_user_freebsd #<group_name> <user_name> <basedir>
	{
	typeset group=$1
	typeset user=$2
	typeset basedir=$3

	# Check to see if the user exists.
	if id $user > /dev/null 2>&1; then
	return 0
	fi

	# Assign 1000 as the base uid
	typeset -i uid=1000
	while true; do
	typeset -i ret
	pw useradd -u $uid -g $group -d $basedir/$user -m -n $user
	ret=$?
	case $ret in
	0) break ;;
	# The uid is not unique
	65) ((uid += 1)) ;;
	*) return 1 ;;
	esac
	if [[ $uid == 65000 ]]; then
	log_fail "No user id available under 65000 for $user"
	fi
	done

	# Silence MOTD
	touch $basedir/$user/.hushlogin

	return 0
	}

	#
	# Delete the specified user.
	#
	# $1 login name
	#
	function del_user_freebsd #<logname>
	{
	typeset user=$1

	if id $user > /dev/null 2>&1; then
	log_must pw userdel $user
	fi

	return 0
	}

	#
	# Select valid gid and create specified group.
	#
	# $1 group name
	#
	function add_group_freebsd #<group_name>
	{
	typeset group=$1

	# See if the group already exists.
	if pw groupshow $group >/dev/null 2>&1; then
	return 0
	fi

	# Assign 1000 as the base gid
	typeset -i gid=1000
	while true; do
	pw groupadd -g $gid -n $group > /dev/null 2>&1
	typeset -i ret=$?
	case $ret in
	0) return 0 ;;
	# The gid is not unique
	65) ((gid += 1)) ;;
	*) return 1 ;;
	esac
	if [[ $gid == 65000 ]]; then
	log_fail "No user id available under 65000 for $group"
	fi
	done
	}

	#
	# Delete the specified group.
	#
	# $1 group name
	#
	function del_group_freebsd #<group_name>
	{
	typeset group=$1

	pw groupdel -n $group > /dev/null 2>&1
	typeset -i ret=$?
	case $ret in
	# Group does not exist, or was deleted successfully.
	0\|6\|65) return 0 ;;
	# Name already exists as a group name
	9) log_must pw groupdel $group ;;
	*) return 1 ;;
	esac

	return 0
	}

	function add_user_illumos #<group_name> <user_name> <basedir>
	{
	typeset group=$1
	typeset user=$2
	typeset basedir=$3

	log_must useradd -g $group -d $basedir/$user -m $user

	return 0
	}

	function del_user_illumos #<user_name>
	{
	typeset user=$1

	if id $user > /dev/null 2>&1; then
	log_must_retry "currently used" 6 userdel $user
	fi

	return 0
	}

	function add_group_illumos #<group_name>
	{
	typeset group=$1

	typeset -i gid=100
	while true; do
	groupadd -g $gid $group > /dev/null 2>&1
	typeset -i ret=$?
	case $ret in
	0) return 0 ;;
	# The gid is not unique
	4) ((gid += 1)) ;;
	*) return 1 ;;
	esac
	done
	}

	function del_group_illumos #<group_name>
	{
	typeset group=$1

	groupmod -n $grp $grp > /dev/null 2>&1
	typeset -i ret=$?
	case $ret in
	# Group does not exist.
	6) return 0 ;;
	# Name already exists as a group name
	9) log_must groupdel $grp ;;
	*) return 1 ;;
	esac
	}

	function add_user_linux #<group_name> <user_name> <basedir>
	{
	typeset group=$1
	typeset user=$2
	typeset basedir=$3

	log_must useradd -g $group -d $basedir/$user -m $user

	# Add new users to the same group and the command line utils.
	# This allows them to be run out of the original users home
	# directory as long as it permissioned to be group readable.
	cmd_group=$(stat --format="%G" $(which zfs))
	log_must usermod -a -G $cmd_group $user

	return 0
	}

	function del_user_linux #<user_name>
	{
	typeset user=$1

	if id $user > /dev/null 2>&1; then
	log_must_retry "currently used" 6 userdel $user
	fi

	return 0
	}

	function add_group_linux #<group_name>
	{
	typeset group=$1

	# Assign 100 as the base gid, a larger value is selected for
	# Linux because for many distributions 1000 and under are reserved.
	while true; do
	groupadd $group > /dev/null 2>&1
	typeset -i ret=$?
	case $ret in
	0) return 0 ;;
	*) return 1 ;;
	esac
	done
	}

	function del_group_linux #<group_name>
	{
	typeset group=$1

	getent group $group > /dev/null 2>&1
	typeset -i ret=$?
	case $ret in
	# Group does not exist.
	2) return 0 ;;
	# Name already exists as a group name
	0) log_must groupdel $group ;;
	*) return 1 ;;
	esac

	return 0
	}

	#
	# Add specified user to specified group
	#
	# $1 group name
	# $2 user name
	# $3 base of the homedir (optional)
	#
	function add_user #<group_name> <user_name> <basedir>
	{
	typeset group=$1
	typeset user=$2
	typeset basedir=${3:-"/var/tmp"}

	if ((${#group} == 0 \|\| ${#user} == 0)); then
	log_fail "group name or user name are not defined."
	fi

	case $(uname) in
	FreeBSD)
	add_user_freebsd "$group" "$user" "$basedir"
	;;
	Linux)
	add_user_linux "$group" "$user" "$basedir"
	;;
	*)
	add_user_illumos "$group" "$user" "$basedir"
	;;
	esac

	return 0
	}

	#
	# Delete the specified user.
	#
	# $1 login name
	# $2 base of the homedir (optional)
	#
	function del_user #<logname> <basedir>
	{
	typeset user=$1
	typeset basedir=${2:-"/var/tmp"}

	if ((${#user} == 0)); then
	log_fail "login name is necessary."
	fi

	case $(uname) in
	FreeBSD)
	del_user_freebsd "$user"
	;;
	Linux)
	del_user_linux "$user"
	;;
	*)
	del_user_illumos "$user"
	;;
	esac

	[[ -d $basedir/$user ]] && rm -fr $basedir/$user

	return 0
	}

	#
	# Select valid gid and create specified group.
	#
	# $1 group name
	#
	function add_group #<group_name>
	{
	typeset group=$1

	if ((${#group} == 0)); then
	log_fail "group name is necessary."
	fi

	case $(uname) in
	FreeBSD)
	add_group_freebsd "$group"
	;;
	Linux)
	add_group_linux "$group"
	;;
	*)
	add_group_illumos "$group"
	;;
	esac

	return 0
	}

	#
	# Delete the specified group.
	#
	# $1 group name
	#
	function del_group #<group_name>
	{
	typeset group=$1

	if ((${#group} == 0)); then
	log_fail "group name is necessary."
	fi

	case $(uname) in
	FreeBSD)
	del_group_freebsd "$group"
	;;
	Linux)
	del_group_linux "$group"
	;;
	*)
	del_group_illumos "$group"
	;;
	esac

	return 0
	}

	#
	# This function will return true if it's safe to destroy the pool passed
	# as argument 1. It checks for pools based on zvols and files, and also
	# files contained in a pool that may have a different mountpoint.
	#
	function safe_to_destroy_pool { # $1 the pool name

	typeset pool=""
	typeset DONT_DESTROY=""

	# We check that by deleting the $1 pool, we're not
	# going to pull the rug out from other pools. Do this
	# by looking at all other pools, ensuring that they
	# aren't built from files or zvols contained in this pool.

	for pool in $(zpool list -H -o name)
	do
	ALTMOUNTPOOL=""

	# this is a list of the top-level directories in each of the
	# files that make up the path to the files the pool is based on
	FILEPOOL=$(zpool status -v $pool \| grep /$1/ \| \
	awk '{print $1}')

	# this is a list of the zvols that make up the pool
	ZVOLPOOL=$(zpool status -v $pool \| grep "$ZVOL_DEVDIR/$1$" \
	\| awk '{print $1}')

	# also want to determine if it's a file-based pool using an
	# alternate mountpoint...
	POOL_FILE_DIRS=$(zpool status -v $pool \| \
	grep / \| awk '{print $1}' \| \
	awk -F/ '{print $2}' \| grep -v "dev")

	for pooldir in $POOL_FILE_DIRS
	do
	OUTPUT=$(zfs list -H -r -o mountpoint $1 \| \
	grep "${pooldir}$" \| awk '{print $1}')

	ALTMOUNTPOOL="${ALTMOUNTPOOL}${OUTPUT}"
	done


	if [ ! -z "$ZVOLPOOL" ]
	then
	DONT_DESTROY="true"
	log_note "Pool $pool is built from $ZVOLPOOL on $1"
	fi

	if [ ! -z "$FILEPOOL" ]
	then
	DONT_DESTROY="true"
	log_note "Pool $pool is built from $FILEPOOL on $1"
	fi

	if [ ! -z "$ALTMOUNTPOOL" ]
	then
	DONT_DESTROY="true"
	log_note "Pool $pool is built from $ALTMOUNTPOOL on $1"
	fi
	done

	if [ -z "${DONT_DESTROY}" ]
	then
	return 0
	else
	log_note "Warning: it is not safe to destroy $1!"
	return 1
	fi
	}

	#
	# Verify zfs operation with -p option work as expected
	# $1 operation, value could be create, clone or rename
	# $2 dataset type, value could be fs or vol
	# $3 dataset name
	# $4 new dataset name
	#
	function verify_opt_p_ops
	{
	typeset ops=$1
	typeset datatype=$2
	typeset dataset=$3
	typeset newdataset=$4

	if [[ $datatype != "fs" && $datatype != "vol" ]]; then
	log_fail "$datatype is not supported."
	fi

	# check parameters accordingly
	case $ops in
	create)
	newdataset=$dataset
	dataset=""
	if [[ $datatype == "vol" ]]; then
	ops="create -V $VOLSIZE"
	fi
	;;
	clone)
	if [[ -z $newdataset ]]; then
	log_fail "newdataset should not be empty" \
	"when ops is $ops."
	fi
	log_must datasetexists $dataset
	log_must snapexists $dataset
	;;
	rename)
	if [[ -z $newdataset ]]; then
	log_fail "newdataset should not be empty" \
	"when ops is $ops."
	fi
	log_must datasetexists $dataset
	;;
	*)
	log_fail "$ops is not supported."
	;;
	esac

	# make sure the upper level filesystem does not exist
	destroy_dataset "${newdataset%/*}" "-rRf"

	# without -p option, operation will fail
	log_mustnot zfs $ops $dataset $newdataset
	log_mustnot datasetexists $newdataset ${newdataset%/*}

	# with -p option, operation should succeed
	log_must zfs $ops -p $dataset $newdataset
	block_device_wait

	if ! datasetexists $newdataset ; then
	log_fail "-p option does not work for $ops"
	fi

	# when $ops is create or clone, redo the operation still return zero
	if [[ $ops != "rename" ]]; then
	log_must zfs $ops -p $dataset $newdataset
	fi

	return 0
	}

	#
	# Get configuration of pool
	# $1 pool name
	# $2 config name
	#
	function get_config
	{
	typeset pool=$1
	typeset config=$2
	typeset alt_root

	if ! poolexists "$pool" ; then
	return 1
	fi
	alt_root=$(zpool list -H $pool \| awk '{print $NF}')
	if [[ $alt_root == "-" ]]; then
	value=$(zdb -C $pool \| grep "$config:" \| awk -F: \
	'{print $2}')
	else
	value=$(zdb -e $pool \| grep "$config:" \| awk -F: \
	'{print $2}')
	fi
	if [[ -n $value ]] ; then
	value=${value#'}
	value=${value%'}
	fi
	echo $value

	return 0
	}

	#
	# Privated function. Random select one of items from arguments.
	#
	# $1 count
	# $2-n string
	#
	function _random_get
	{
	typeset cnt=$1
	shift

	typeset str="$@"
	typeset -i ind
	((ind = RANDOM % cnt + 1))

	typeset ret=$(echo "$str" \| cut -f $ind -d ' ')
	echo $ret
	}

	#
	# Random select one of item from arguments which include NONE string
	#
	function random_get_with_non
	{
	typeset -i cnt=$#
	((cnt =+ 1))

	_random_get "$cnt" "$@"
	}

	#
	# Random select one of item from arguments which doesn't include NONE string
	#
	function random_get
	{
	_random_get "$#" "$@"
	}

	#
	# Detect if the current system support slog
	#
	function verify_slog_support
	{
	typeset dir=$TEST_BASE_DIR/disk.$$
	typeset pool=foo.$$
	typeset vdev=$dir/a
	typeset sdev=$dir/b

	mkdir -p $dir
	mkfile $MINVDEVSIZE $vdev $sdev

	typeset -i ret=0
	if ! zpool create -n $pool $vdev log $sdev > /dev/null 2>&1; then
	ret=1
	fi
	rm -r $dir

	return $ret
	}

	#
	# The function will generate a dataset name with specific length
	# $1, the length of the name
	# $2, the base string to construct the name
	#
	function gen_dataset_name
	{
	typeset -i len=$1
	typeset basestr="$2"
	typeset -i baselen=${#basestr}
	typeset -i iter=0
	typeset l_name=""

	if ((len % baselen == 0)); then
	((iter = len / baselen))
	else
	((iter = len / baselen + 1))
	fi
	while ((iter > 0)); do
	l_name="${l_name}$basestr"

	((iter -= 1))
	done

	echo $l_name
	}

	#
	# Get cksum tuple of dataset
	# $1 dataset name
	#
	# sample zdb output:
	# Dataset data/test [ZPL], ID 355, cr_txg 2413856, 31.0K, 7 objects, rootbp
	# DVA[0]=<0:803046400:200> DVA[1]=<0:81199000:200> [L0 DMU objset] fletcher4
	# lzjb LE contiguous unique double size=800L/200P birth=2413856L/2413856P
	# fill=7 cksum=11ce125712:643a9c18ee2:125e25238fca0:254a3f74b59744
	function datasetcksum
	{
	typeset cksum
	sync
	cksum=$(zdb -vvv $1 \| grep "^Dataset $1 \[" \| grep "cksum" \
	\| awk -F= '{print $7}')
	echo $cksum
	}

	#
	# Get cksum of file
	# #1 file path
	#
	function checksum
	{
	typeset cksum
	cksum=$(cksum $1 \| awk '{print $1}')
	echo $cksum
	}

	#
	# Get the given disk/slice state from the specific field of the pool
	#
	function get_device_state #pool disk field("", "spares","logs")
	{
	typeset pool=$1
	typeset disk=${2#$DEV_DSKDIR/}
	typeset field=${3:-$pool}

	state=$(zpool status -v "$pool" 2>/dev/null \| \
	nawk -v device=$disk -v pool=$pool -v field=$field \
	'BEGIN {startconfig=0; startfield=0; }
	/config:/ {startconfig=1}
	(startconfig==1) && ($1==field) {startfield=1; next;}
	(startfield==1) && ($1==device) {print $2; exit;}
	(startfield==1) &&
	($1==field \|\| $1 ~ "^spares$" \|\| $1 ~ "^logs$") {startfield=0}')
	echo $state
	}


	#
	# print the given directory filesystem type
	#
	# $1 directory name
	#
	function get_fstype
	{
	typeset dir=$1

	if [[ -z $dir ]]; then
	log_fail "Usage: get_fstype <directory>"
	fi

	#
	# $ df -n /
	# / : ufs
	#
	df -n $dir \| awk '{print $3}'
	}

	#
	# Given a disk, label it to VTOC regardless what label was on the disk
	# $1 disk
	#
	function labelvtoc
	{
	typeset disk=$1
	if [[ -z $disk ]]; then
	log_fail "The disk name is unspecified."
	fi
	typeset label_file=/var/tmp/labelvtoc.$$
	typeset arch=$(uname -p)

	if is_linux \|\| is_freebsd; then
	log_note "Currently unsupported by the test framework"
	return 1
	fi

	if [[ $arch == "i386" ]]; then
	echo "label" > $label_file
	echo "0" >> $label_file
	echo "" >> $label_file
	echo "q" >> $label_file
	echo "q" >> $label_file

	fdisk -B $disk >/dev/null 2>&1
	# wait a while for fdisk finishes
	sleep 60
	elif [[ $arch == "sparc" ]]; then
	echo "label" > $label_file
	echo "0" >> $label_file
	echo "" >> $label_file
	echo "" >> $label_file
	echo "" >> $label_file
	echo "q" >> $label_file
	else
	log_fail "unknown arch type"
	fi

	format -e -s -d $disk -f $label_file
	typeset -i ret_val=$?
	rm -f $label_file
	#
	# wait the format to finish
	#
	sleep 60
	if ((ret_val != 0)); then
	log_fail "unable to label $disk as VTOC."
	fi

	return 0
	}

	#
	# check if the system was installed as zfsroot or not
	# return: 0 if zfsroot, non-zero if not
	#
	function is_zfsroot
	{
	df -n / \| grep zfs > /dev/null 2>&1
	return $?
	}

	#
	# get the root filesystem name if it's zfsroot system.
	#
	# return: root filesystem name
	function get_rootfs
	{
	typeset rootfs=""

	if is_freebsd; then
	rootfs=$(mount -p \| awk '$2 == "/" && $3 == "zfs" {print $1}')
	elif ! is_linux; then
	rootfs=$(awk '{if ($2 == "/" && $3 == "zfs") print $1}' \
	/etc/mnttab)
	fi
	if [[ -z "$rootfs" ]]; then
	log_fail "Can not get rootfs"
	fi
	zfs list $rootfs > /dev/null 2>&1
	if (($? == 0)); then
	echo $rootfs
	else
	log_fail "This is not a zfsroot system."
	fi
	}

	#
	# get the rootfs's pool name
	# return:
	# rootpool name
	#
	function get_rootpool
	{
	typeset rootfs=""
	typeset rootpool=""

	if is_freebsd; then
	rootfs=$(mount -p \| awk '$2 == "/" && $3 == "zfs" {print $1}')
	elif ! is_linux; then
	rootfs=$(awk '{if ($2 == "/" && $3 =="zfs") print $1}' \
	/etc/mnttab)
	fi
	if [[ -z "$rootfs" ]]; then
	log_fail "Can not get rootpool"
	fi
	zfs list $rootfs > /dev/null 2>&1
	if (($? == 0)); then
	echo ${rootfs%%/*}
	else
	log_fail "This is not a zfsroot system."
	fi
	}

	#
	# Get the word numbers from a string separated by white space
	#
	function get_word_count
	{
	echo $1 \| wc -w
	}

	#
	# To verify if the require numbers of disks is given
	#
	function verify_disk_count
	{
	typeset -i min=${2:-1}

	typeset -i count=$(get_word_count "$1")

	if ((count < min)); then
	log_untested "A minimum of $min disks is required to run." \
	" You specified $count disk(s)"
	fi
	}

	function ds_is_volume
	{
	typeset type=$(get_prop type $1)
	[[ $type = "volume" ]] && return 0
	return 1
	}

	function ds_is_filesystem
	{
	typeset type=$(get_prop type $1)
	[[ $type = "filesystem" ]] && return 0
	return 1
	}

	function ds_is_snapshot
	{
	typeset type=$(get_prop type $1)
	[[ $type = "snapshot" ]] && return 0
	return 1
	}

	#
	# Check if Trusted Extensions are installed and enabled
	#
	function is_te_enabled
	{
	svcs -H -o state labeld 2>/dev/null \| grep "enabled"
	if (($? != 0)); then
	return 1
	else
	return 0
	fi
	}

	# Utility function to determine if a system has multiple cpus.
	function is_mp
	{
	if is_linux; then
	(($(nproc) > 1))
	elif is_freebsd; then
	sysctl -n kern.smp.cpus
	else
	(($(psrinfo \| wc -l) > 1))
	fi

	return $?
	}

	function get_cpu_freq
	{
	if is_linux; then
	lscpu \| awk '/CPU MHz/ { print $3 }'
	elif is_freebsd; then
	sysctl -n hw.clockrate
	else
	psrinfo -v 0 \| awk '/processor operates at/ {print $6}'
	fi
	}

	# Run the given command as the user provided.
	function user_run
	{
	typeset user=$1
	shift

	log_note "user: $user"
	log_note "cmd: $*"

	typeset out=$TEST_BASE_DIR/out
	typeset err=$TEST_BASE_DIR/err

	sudo -Eu $user env PATH="$PATH" ksh <<<"$*" >$out 2>$err
	typeset res=$?
	log_note "out: $(<$out)"
	log_note "err: $(<$err)"
	return $res
	}

	#
	# Check if the pool contains the specified vdevs
	#
	# $1 pool
	# $2..n <vdev> ...
	#
	# Return 0 if the vdevs are contained in the pool, 1 if any of the specified
	# vdevs is not in the pool, and 2 if pool name is missing.
	#
	function vdevs_in_pool
	{
	typeset pool=$1
	typeset vdev

	if [[ -z $pool ]]; then
	log_note "Missing pool name."
	return 2
	fi

	shift

	# We could use 'zpool list' to only get the vdevs of the pool but we
	# can't reference a mirror/raidz vdev using its ID (i.e mirror-0),
	# therefore we use the 'zpool status' output.
	typeset tmpfile=$(mktemp)
	zpool status -v "$pool" \| grep -A 1000 "config:" >$tmpfile
	for vdev in $@; do
	grep -w ${vdev##*/} $tmpfile >/dev/null 2>&1
	[[ $? -ne 0 ]] && return 1
	done

	rm -f $tmpfile

	return 0;
	}

	function get_max
	{
	typeset -l i max=$1
	shift

	for i in "$@"; do
	max=$((max > i ? max : i))
	done

	echo $max
	}

	function get_min
	{
	typeset -l i min=$1
	shift

	for i in "$@"; do
	min=$((min < i ? min : i))
	done

	echo $min
	}

	# Write data that can be compressed into a directory
	function write_compressible
	{
	typeset dir=$1
	typeset megs=$2
	typeset nfiles=${3:-1}
	typeset bs=${4:-1024k}
	typeset fname=${5:-file}

	[[ -d $dir ]] \|\| log_fail "No directory: $dir"

	# Under Linux fio is not currently used since its behavior can
	# differ significantly across versions. This includes missing
	# command line options and cases where the --buffer_compress_*
	# options fail to behave as expected.
	if is_linux; then
	typeset file_bytes=$(to_bytes $megs)
	typeset bs_bytes=4096
	typeset blocks=$(($file_bytes / $bs_bytes))

	for (( i = 0; i < $nfiles; i++ )); do
	truncate -s $file_bytes $dir/$fname.$i

	# Write every third block to get 66% compression.
	for (( j = 0; j < $blocks; j += 3 )); do
	dd if=/dev/urandom of=$dir/$fname.$i \
	seek=$j bs=$bs_bytes count=1 \
	conv=notrunc >/dev/null 2>&1
	done
	done
	else
	log_must eval "fio \
	--name=job \
	--fallocate=0 \
	--minimal \
	--randrepeat=0 \
	--buffer_compress_percentage=66 \
	--buffer_compress_chunk=4096 \
	--directory=$dir \
	--numjobs=$nfiles \
	--nrfiles=$nfiles \
	--rw=write \
	--bs=$bs \
	--filesize=$megs \
	--filename_format='$fname.\$jobnum' >/dev/null"
	fi
	}

	function get_objnum
	{
	typeset pathname=$1
	typeset objnum

	[[ -e $pathname ]] \|\| log_fail "No such file or directory: $pathname"
	if is_freebsd; then
	objnum=$(stat -f "%i" $pathname)
	else
	objnum=$(stat -c %i $pathname)
	fi
	echo $objnum
	}

	#
	# Sync data to the pool
	#
	# $1 pool name
	# $2 boolean to force uberblock (and config including zpool cache file) update
	#
	function sync_pool #pool <force>
	{
	typeset pool=${1:-$TESTPOOL}
	typeset force=${2:-false}

	if [[ $force == true ]]; then
	log_must zpool sync -f $pool
	else
	log_must zpool sync $pool
	fi

	return 0
	}

	#
	# Wait for zpool 'freeing' property drops to zero.
	#
	# $1 pool name
	#
	function wait_freeing #pool
	{
	typeset pool=${1:-$TESTPOOL}
	while true; do
	[[ "0" == "$(zpool list -Ho freeing $pool)" ]] && break
	log_must sleep 1
	done
	}

	#
	# Wait for every device replace operation to complete
	#
	# $1 pool name
	#
	function wait_replacing #pool
	{
	typeset pool=${1:-$TESTPOOL}
	while true; do
	[[ "" == "$(zpool status $pool \|
	awk '/replacing-[0-9]+/ {print $1}')" ]] && break
	log_must sleep 1
	done
	}

	#
	# Wait for a pool to be scrubbed
	#
	# $1 pool name
	-# $2 number of seconds to wait (optional)
	-#
	-# Returns true when pool has been scrubbed, or false if there's a timeout or if
	-# no scrub was done.
	#
	function wait_scrubbed
	{
	typeset pool=${1:-$TESTPOOL}
	- while true ; do
	- is_pool_scrubbed $pool && break
	+ while ! is_pool_scrubbed $pool ; do
	sleep 1
	done
	}

	# Backup the zed.rc in our test directory so that we can edit it for our test.
	#
	# Returns: Backup file name. You will need to pass this to zed_rc_restore().
	function zed_rc_backup
	{
	zedrc_backup="$(mktemp)"
	cp $ZEDLET_DIR/zed.rc $zedrc_backup
	echo $zedrc_backup
	}

	function zed_rc_restore
	{
	mv $1 $ZEDLET_DIR/zed.rc
	}

	#
	# Setup custom environment for the ZED.
	#
	# $@ Optional list of zedlets to run under zed.
	function zed_setup
	{
	if ! is_linux; then
	log_unsupported "No zed on $(uname)"
	fi

	if [[ ! -d $ZEDLET_DIR ]]; then
	log_must mkdir $ZEDLET_DIR
	fi

	if [[ ! -e $VDEVID_CONF ]]; then
	log_must touch $VDEVID_CONF
	fi

	if [[ -e $VDEVID_CONF_ETC ]]; then
	log_fail "Must not have $VDEVID_CONF_ETC file present on system"
	fi
	EXTRA_ZEDLETS=$@

	# Create a symlink for /etc/zfs/vdev_id.conf file.
	log_must ln -s $VDEVID_CONF $VDEVID_CONF_ETC

	# Setup minimal ZED configuration. Individual test cases should
	# add additional ZEDLETs as needed for their specific test.
	log_must cp ${ZEDLET_ETC_DIR}/zed.rc $ZEDLET_DIR
	log_must cp ${ZEDLET_ETC_DIR}/zed-functions.sh $ZEDLET_DIR

	# Scripts must only be user writable.
	if [[ -n "$EXTRA_ZEDLETS" ]] ; then
	saved_umask=$(umask)
	log_must umask 0022
	for i in $EXTRA_ZEDLETS ; do
	log_must cp ${ZEDLET_LIBEXEC_DIR}/$i $ZEDLET_DIR
	done
	log_must umask $saved_umask
	fi

	# Customize the zed.rc file to enable the full debug log.
	log_must sed -i '/\#ZED_DEBUG_LOG=.*/d' $ZEDLET_DIR/zed.rc
	echo "ZED_DEBUG_LOG=$ZED_DEBUG_LOG" >>$ZEDLET_DIR/zed.rc

	}

	#
	# Cleanup custom ZED environment.
	#
	# $@ Optional list of zedlets to remove from our test zed.d directory.
	function zed_cleanup
	{
	if ! is_linux; then
	return
	fi
	EXTRA_ZEDLETS=$@

	log_must rm -f ${ZEDLET_DIR}/zed.rc
	log_must rm -f ${ZEDLET_DIR}/zed-functions.sh
	log_must rm -f ${ZEDLET_DIR}/all-syslog.sh
	log_must rm -f ${ZEDLET_DIR}/all-debug.sh
	log_must rm -f ${ZEDLET_DIR}/state

	if [[ -n "$EXTRA_ZEDLETS" ]] ; then
	for i in $EXTRA_ZEDLETS ; do
	log_must rm -f ${ZEDLET_DIR}/$i
	done
	fi
	log_must rm -f $ZED_LOG
	log_must rm -f $ZED_DEBUG_LOG
	log_must rm -f $VDEVID_CONF_ETC
	log_must rm -f $VDEVID_CONF
	rmdir $ZEDLET_DIR
	}

	#
	# Check if ZED is currently running, if not start ZED.
	#
	function zed_start
	{
	if ! is_linux; then
	return
	fi

	# ZEDLET_DIR=/var/tmp/zed
	if [[ ! -d $ZEDLET_DIR ]]; then
	log_must mkdir $ZEDLET_DIR
	fi

	# Verify the ZED is not already running.
	pgrep -x zed > /dev/null
	if (($? == 0)); then
	log_note "ZED already running"
	else
	log_note "Starting ZED"
	# run ZED in the background and redirect foreground logging
	# output to $ZED_LOG.
	log_must truncate -s 0 $ZED_DEBUG_LOG
	- log_must eval "zed -vF -d $ZEDLET_DIR -p $ZEDLET_DIR/zed.pid -P $PATH" \
	- "-s $ZEDLET_DIR/state 2>$ZED_LOG &"
	+ log_must eval "zed -vF -d $ZEDLET_DIR -P $PATH" \
	+ "-s $ZEDLET_DIR/state -j 1 2>$ZED_LOG &"
	fi

	return 0
	}

	#
	# Kill ZED process
	#
	function zed_stop
	{
	if ! is_linux; then
	return
	fi

	log_note "Stopping ZED"
	- if [[ -f ${ZEDLET_DIR}/zed.pid ]]; then
	- zedpid=$(<${ZEDLET_DIR}/zed.pid)
	- kill $zedpid
	- while ps -p $zedpid > /dev/null; do
	- sleep 1
	- done
	- rm -f ${ZEDLET_DIR}/zed.pid
	- fi
	+ while true; do
	+ zedpids="$(pgrep -x zed)"
	+ [ "$?" -ne 0 ] && break
	+
	+ log_must kill $zedpids
	+ sleep 1
	+ done
	return 0
	}

	#
	# Drain all zevents
	#
	function zed_events_drain
	{
	while [ $(zpool events -H \| wc -l) -ne 0 ]; do
	sleep 1
	zpool events -c >/dev/null
	done
	}

	# Set a variable in zed.rc to something, un-commenting it in the process.
	#
	# $1 variable
	# $2 value
	function zed_rc_set
	{
	var="$1"
	val="$2"
	# Remove the line
	cmd="'/$var/d'"
	eval sed -i $cmd $ZEDLET_DIR/zed.rc

	# Add it at the end
	echo "$var=$val" >> $ZEDLET_DIR/zed.rc
	}


	#
	# Check is provided device is being active used as a swap device.
	#
	function is_swap_inuse
	{
	typeset device=$1

	if [[ -z $device ]] ; then
	log_note "No device specified."
	return 1
	fi

	if is_linux; then
	swapon -s \| grep -w $(readlink -f $device) > /dev/null 2>&1
	elif is_freebsd; then
	swapctl -l \| grep -w $device
	else
	swap -l \| grep -w $device > /dev/null 2>&1
	fi

	return $?
	}

	#
	# Setup a swap device using the provided device.
	#
	function swap_setup
	{
	typeset swapdev=$1

	if is_linux; then
	log_must eval "mkswap $swapdev > /dev/null 2>&1"
	log_must swapon $swapdev
	elif is_freebsd; then
	log_must swapctl -a $swapdev
	else
	log_must swap -a $swapdev
	fi

	return 0
	}

	#
	# Cleanup a swap device on the provided device.
	#
	function swap_cleanup
	{
	typeset swapdev=$1

	if is_swap_inuse $swapdev; then
	if is_linux; then
	log_must swapoff $swapdev
	elif is_freebsd; then
	log_must swapoff $swapdev
	else
	log_must swap -d $swapdev
	fi
	fi

	return 0
	}

	#
	# Set a global system tunable (64-bit value)
	#
	# $1 tunable name (use a NAME defined in tunables.cfg)
	# $2 tunable values
	#
	function set_tunable64
	{
	set_tunable_impl "$1" "$2" Z
	}

	#
	# Set a global system tunable (32-bit value)
	#
	# $1 tunable name (use a NAME defined in tunables.cfg)
	# $2 tunable values
	#
	function set_tunable32
	{
	set_tunable_impl "$1" "$2" W
	}

	function set_tunable_impl
	{
	typeset name="$1"
	typeset value="$2"
	typeset mdb_cmd="$3"
	typeset module="${4:-zfs}"

	eval "typeset tunable=\$$name"
	case "$tunable" in
	UNSUPPORTED)
	log_unsupported "Tunable '$name' is unsupported on $(uname)"
	;;
	"")
	log_fail "Tunable '$name' must be added to tunables.cfg"
	;;
	*)
	;;
	esac

	[[ -z "$value" ]] && return 1
	[[ -z "$mdb_cmd" ]] && return 1

	case "$(uname)" in
	Linux)
	typeset zfs_tunables="/sys/module/$module/parameters"
	[[ -w "$zfs_tunables/$tunable" ]] \|\| return 1
	cat >"$zfs_tunables/$tunable" <<<"$value"
	return $?
	;;
	FreeBSD)
	sysctl vfs.zfs.$tunable=$value
	return "$?"
	;;
	SunOS)
	[[ "$module" -eq "zfs" ]] \|\| return 1
	echo "${tunable}/${mdb_cmd}0t${value}" \| mdb -kw
	return $?
	;;
	esac
	}

	#
	# Get a global system tunable
	#
	# $1 tunable name (use a NAME defined in tunables.cfg)
	#
	function get_tunable
	{
	get_tunable_impl "$1"
	}

	function get_tunable_impl
	{
	typeset name="$1"
	typeset module="${2:-zfs}"

	eval "typeset tunable=\$$name"
	case "$tunable" in
	UNSUPPORTED)
	log_unsupported "Tunable '$name' is unsupported on $(uname)"
	;;
	"")
	log_fail "Tunable '$name' must be added to tunables.cfg"
	;;
	*)
	;;
	esac

	case "$(uname)" in
	Linux)
	typeset zfs_tunables="/sys/module/$module/parameters"
	[[ -f "$zfs_tunables/$tunable" ]] \|\| return 1
	cat $zfs_tunables/$tunable
	return $?
	;;
	FreeBSD)
	sysctl -n vfs.zfs.$tunable
	;;
	SunOS)
	[[ "$module" -eq "zfs" ]] \|\| return 1
	;;
	esac

	return 1
	}

	#
	# Prints the current time in seconds since UNIX Epoch.
	#
	function current_epoch
	{
	printf '%(%s)T'
	}

	#
	# Get decimal value of global uint32_t variable using mdb.
	#
	function mdb_get_uint32
	{
	typeset variable=$1
	typeset value

	value=$(mdb -k -e "$variable/X \| ::eval .=U")
	if [[ $? -ne 0 ]]; then
	log_fail "Failed to get value of '$variable' from mdb."
	return 1
	fi

	echo $value
	return 0
	}

	#
	# Set global uint32_t variable to a decimal value using mdb.
	#
	function mdb_set_uint32
	{
	typeset variable=$1
	typeset value=$2

	mdb -kw -e "$variable/W 0t$value" > /dev/null
	if [[ $? -ne 0 ]]; then
	echo "Failed to set '$variable' to '$value' in mdb."
	return 1
	fi

	return 0
	}

	#
	# Set global scalar integer variable to a hex value using mdb.
	# Note: Target should have CTF data loaded.
	#
	function mdb_ctf_set_int
	{
	typeset variable=$1
	typeset value=$2

	mdb -kw -e "$variable/z $value" > /dev/null
	if [[ $? -ne 0 ]]; then
	echo "Failed to set '$variable' to '$value' in mdb."
	return 1
	fi

	return 0
	}

	#
	# Compute MD5 digest for given file or stdin if no file given.
	# Note: file path must not contain spaces
	#
	function md5digest
	{
	typeset file=$1

	case $(uname) in
	FreeBSD)
	md5 -q $file
	;;
	*)
	md5sum -b $file \| awk '{ print $1 }'
	;;
	esac
	}

	#
	# Compute SHA256 digest for given file or stdin if no file given.
	# Note: file path must not contain spaces
	#
	function sha256digest
	{
	typeset file=$1

	case $(uname) in
	FreeBSD)
	sha256 -q $file
	;;
	*)
	sha256sum -b $file \| awk '{ print $1 }'
	;;
	esac
	}

	function new_fs #<args>
	{
	case $(uname) in
	FreeBSD)
	newfs "$@"
	;;
	*)
	echo y \| newfs -v "$@"
	;;
	esac
	}

	function stat_size #<path>
	{
	typeset path=$1

	case $(uname) in
	FreeBSD)
	stat -f %z "$path"
	;;
	*)
	stat -c %s "$path"
	;;
	esac
	}

	# Run a command as if it was being run in a TTY.
	#
	# Usage:
	#
	# faketty command
	#
	function faketty
	{
	if is_freebsd; then
	script -q /dev/null env "$@"
	else
	script --return --quiet -c "$*" /dev/null
	fi
	}

	#
	# Produce a random permutation of the integers in a given range (inclusive).
	#
	function range_shuffle # begin end
	{
	typeset -i begin=$1
	typeset -i end=$2

	seq ${begin} ${end} \| sort -R
	}

	#
	# Cross-platform xattr helpers
	#

	function get_xattr # name path
	{
	typeset name=$1
	typeset path=$2

	case $(uname) in
	FreeBSD)
	getextattr -qq user "${name}" "${path}"
	;;
	*)
	attr -qg "${name}" "${path}"
	;;
	esac
	}

	function set_xattr # name value path
	{
	typeset name=$1
	typeset value=$2
	typeset path=$3

	case $(uname) in
	FreeBSD)
	setextattr user "${name}" "${value}" "${path}"
	;;
	*)
	attr -qs "${name}" -V "${value}" "${path}"
	;;
	esac
	}

	function set_xattr_stdin # name value
	{
	typeset name=$1
	typeset path=$2

	case $(uname) in
	FreeBSD)
	setextattr -i user "${name}" "${path}"
	;;
	*)
	attr -qs "${name}" "${path}"
	;;
	esac
	}

	function rm_xattr # name path
	{
	typeset name=$1
	typeset path=$2

	case $(uname) in
	FreeBSD)
	rmextattr -q user "${name}" "${path}"
	;;
	*)
	attr -qr "${name}" "${path}"
	;;
	esac
	}

	function ls_xattr # path
	{
	typeset path=$1

	case $(uname) in
	FreeBSD)
	lsextattr -qq user "${path}"
	;;
	*)
	attr -ql "${path}"
	;;
	esac
	}

	function kstat # stat flags?
	{
	typeset stat=$1
	typeset flags=${2-"-n"}

	case $(uname) in
	FreeBSD)
	sysctl $flags kstat.zfs.misc.$stat
	;;
	Linux)
	typeset zfs_kstat="/proc/spl/kstat/zfs/$stat"
	[[ -f "$zfs_kstat" ]] \|\| return 1
	cat $zfs_kstat
	;;
	*)
	false
	;;
	esac
	}

	function get_arcstat # stat
	{
	typeset stat=$1

	case $(uname) in
	FreeBSD)
	kstat arcstats.$stat
	;;
	Linux)
	kstat arcstats \| awk "/$stat/ { print \$3 }"
	;;
	*)
	false
	;;
	esac
	}

	#
	# Wait for the specified arcstat to reach non-zero quiescence.
	# If echo is 1 echo the value after reaching quiescence, otherwise
	# if echo is 0 print the arcstat we are waiting on.
	#
	function arcstat_quiescence # stat echo
	{
	typeset stat=$1
	typeset echo=$2
	typeset do_once=true

	if [[ $echo -eq 0 ]]; then
	echo "Waiting for arcstat $1 quiescence."
	fi

	while $do_once \|\| [ $stat1 -ne $stat2 ] \|\| [ $stat2 -eq 0 ]; do
	typeset stat1=$(get_arcstat $stat)
	sleep 2
	typeset stat2=$(get_arcstat $stat)
	do_once=false
	done

	if [[ $echo -eq 1 ]]; then
	echo $stat2
	fi
	}

	function arcstat_quiescence_noecho # stat
	{
	typeset stat=$1
	arcstat_quiescence $stat 0
	}

	function arcstat_quiescence_echo # stat
	{
	typeset stat=$1
	arcstat_quiescence $stat 1
	}

	#
	# Given an array of pids, wait until all processes
	# have completed and check their return status.
	#
	function wait_for_children #children
	{
	rv=0
	children=("$@")
	for child in "${children[@]}"
	do
	child_exit=0
	wait ${child} \|\| child_exit=$?
	if [ $child_exit -ne 0 ]; then
	echo "child ${child} failed with ${child_exit}"
	rv=1
	fi
	done
	return $rv
	}
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/include/tunables.cfg b/sys/contrib/openzfs/tests/zfs-tests/include/tunables.cfg
	index 1cef60b0d634..a1b75a48292f 100644
	--- a/sys/contrib/openzfs/tests/zfs-tests/include/tunables.cfg
	+++ b/sys/contrib/openzfs/tests/zfs-tests/include/tunables.cfg
	@@ -1,94 +1,95 @@
	# This file exports variables for each tunable used in the test suite.
	#
	# Different platforms use different names for most tunables. To avoid littering
	# the tests with conditional logic for deciding how to set each tunable, the
	# logic is instead consolidated to this one file.
	#
	# Any use of tunables in tests must use a name defined here. New entries
	# should be added to the table as needed. Please keep the table sorted
	# alphabetically for ease of maintenance.
	#
	# Platform-specific tunables should still use a NAME from this table for
	# consistency. Enter UNSUPPORTED in the column for platforms on which the
	# tunable is not implemented.

	UNAME=$(uname)

	# NAME FreeBSD tunable Linux tunable
	cat <<%%%% \|
	ADMIN_SNAPSHOT UNSUPPORTED zfs_admin_snapshot
	ALLOW_REDACTED_DATASET_MOUNT allow_redacted_dataset_mount zfs_allow_redacted_dataset_mount
	ARC_MAX arc.max zfs_arc_max
	ARC_MIN arc.min zfs_arc_min
	ASYNC_BLOCK_MAX_BLOCKS async_block_max_blocks zfs_async_block_max_blocks
	CHECKSUM_EVENTS_PER_SECOND checksum_events_per_second zfs_checksum_events_per_second
	COMMIT_TIMEOUT_PCT commit_timeout_pct zfs_commit_timeout_pct
	COMPRESSED_ARC_ENABLED compressed_arc_enabled zfs_compressed_arc_enabled
	CONDENSE_INDIRECT_COMMIT_ENTRY_DELAY_MS condense.indirect_commit_entry_delay_ms zfs_condense_indirect_commit_entry_delay_ms
	+CONDENSE_INDIRECT_OBSOLETE_PCT condense.indirect_obsolete_pct zfs_condense_indirect_obsolete_pct
	CONDENSE_MIN_MAPPING_BYTES condense.min_mapping_bytes zfs_condense_min_mapping_bytes
	DBUF_CACHE_MAX_BYTES dbuf_cache.max_bytes dbuf_cache_max_bytes
	DEADMAN_CHECKTIME_MS deadman.checktime_ms zfs_deadman_checktime_ms
	DEADMAN_FAILMODE deadman.failmode zfs_deadman_failmode
	DEADMAN_SYNCTIME_MS deadman.synctime_ms zfs_deadman_synctime_ms
	DEADMAN_ZIOTIME_MS deadman.ziotime_ms zfs_deadman_ziotime_ms
	DISABLE_IVSET_GUID_CHECK disable_ivset_guid_check zfs_disable_ivset_guid_check
	INITIALIZE_CHUNK_SIZE initialize_chunk_size zfs_initialize_chunk_size
	INITIALIZE_VALUE initialize_value zfs_initialize_value
	KEEP_LOG_SPACEMAPS_AT_EXPORT keep_log_spacemaps_at_export zfs_keep_log_spacemaps_at_export
	LUA_MAX_MEMLIMIT lua.max_memlimit zfs_lua_max_memlimit
	L2ARC_MFUONLY l2arc.mfuonly l2arc_mfuonly
	L2ARC_NOPREFETCH l2arc.noprefetch l2arc_noprefetch
	L2ARC_REBUILD_BLOCKS_MIN_L2SIZE l2arc.rebuild_blocks_min_l2size l2arc_rebuild_blocks_min_l2size
	L2ARC_REBUILD_ENABLED l2arc.rebuild_enabled l2arc_rebuild_enabled
	L2ARC_TRIM_AHEAD l2arc.trim_ahead l2arc_trim_ahead
	L2ARC_WRITE_BOOST l2arc.write_boost l2arc_write_boost
	L2ARC_WRITE_MAX l2arc.write_max l2arc_write_max
	LIVELIST_CONDENSE_NEW_ALLOC livelist.condense.new_alloc zfs_livelist_condense_new_alloc
	LIVELIST_CONDENSE_SYNC_CANCEL livelist.condense.sync_cancel zfs_livelist_condense_sync_cancel
	LIVELIST_CONDENSE_SYNC_PAUSE livelist.condense.sync_pause zfs_livelist_condense_sync_pause
	LIVELIST_CONDENSE_ZTHR_CANCEL livelist.condense.zthr_cancel zfs_livelist_condense_zthr_cancel
	LIVELIST_CONDENSE_ZTHR_PAUSE livelist.condense.zthr_pause zfs_livelist_condense_zthr_pause
	LIVELIST_MAX_ENTRIES livelist.max_entries zfs_livelist_max_entries
	LIVELIST_MIN_PERCENT_SHARED livelist.min_percent_shared zfs_livelist_min_percent_shared
	MAX_DATASET_NESTING max_dataset_nesting zfs_max_dataset_nesting
	MAX_MISSING_TVDS max_missing_tvds zfs_max_missing_tvds
	METASLAB_DEBUG_LOAD metaslab.debug_load metaslab_debug_load
	METASLAB_FORCE_GANGING metaslab.force_ganging metaslab_force_ganging
	MULTIHOST_FAIL_INTERVALS multihost.fail_intervals zfs_multihost_fail_intervals
	MULTIHOST_HISTORY multihost.history zfs_multihost_history
	MULTIHOST_IMPORT_INTERVALS multihost.import_intervals zfs_multihost_import_intervals
	MULTIHOST_INTERVAL multihost.interval zfs_multihost_interval
	OVERRIDE_ESTIMATE_RECORDSIZE send.override_estimate_recordsize zfs_override_estimate_recordsize
	PREFETCH_DISABLE prefetch.disable zfs_prefetch_disable
	REBUILD_SCRUB_ENABLED rebuild_scrub_enabled zfs_rebuild_scrub_enabled
	REMOVAL_SUSPEND_PROGRESS removal_suspend_progress zfs_removal_suspend_progress
	REMOVE_MAX_SEGMENT remove_max_segment zfs_remove_max_segment
	RESILVER_MIN_TIME_MS resilver_min_time_ms zfs_resilver_min_time_ms
	SCAN_LEGACY scan_legacy zfs_scan_legacy
	SCAN_SUSPEND_PROGRESS scan_suspend_progress zfs_scan_suspend_progress
	SCAN_VDEV_LIMIT scan_vdev_limit zfs_scan_vdev_limit
	SEND_HOLES_WITHOUT_BIRTH_TIME send_holes_without_birth_time send_holes_without_birth_time
	SLOW_IO_EVENTS_PER_SECOND slow_io_events_per_second zfs_slow_io_events_per_second
	SPA_ASIZE_INFLATION spa.asize_inflation spa_asize_inflation
	SPA_DISCARD_MEMORY_LIMIT spa.discard_memory_limit zfs_spa_discard_memory_limit
	SPA_LOAD_VERIFY_DATA spa.load_verify_data spa_load_verify_data
	SPA_LOAD_VERIFY_METADATA spa.load_verify_metadata spa_load_verify_metadata
	TRIM_EXTENT_BYTES_MIN trim.extent_bytes_min zfs_trim_extent_bytes_min
	TRIM_METASLAB_SKIP trim.metaslab_skip zfs_trim_metaslab_skip
	TRIM_TXG_BATCH trim.txg_batch zfs_trim_txg_batch
	TXG_HISTORY txg.history zfs_txg_history
	TXG_TIMEOUT txg.timeout zfs_txg_timeout
	UNLINK_SUSPEND_PROGRESS UNSUPPORTED zfs_unlink_suspend_progress
	VDEV_FILE_PHYSICAL_ASHIFT vdev.file.physical_ashift vdev_file_physical_ashift
	VDEV_MIN_MS_COUNT vdev.min_ms_count zfs_vdev_min_ms_count
	VDEV_VALIDATE_SKIP vdev.validate_skip vdev_validate_skip
	VOL_INHIBIT_DEV UNSUPPORTED zvol_inhibit_dev
	VOL_MODE vol.mode zvol_volmode
	VOL_RECURSIVE vol.recursive UNSUPPORTED
	ZEVENT_LEN_MAX zevent.len_max zfs_zevent_len_max
	ZEVENT_RETAIN_MAX zevent.retain_max zfs_zevent_retain_max
	ZIO_SLOW_IO_MS zio.slow_io_ms zio_slow_io_ms
	%%%%
	while read name FreeBSD Linux; do
	eval "export ${name}=\$${UNAME}"
	done
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/atime/root_atime_off.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/atime/root_atime_off.ksh
	index 2fbf06b13773..7eb2ed937287 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/atime/root_atime_off.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/atime/root_atime_off.ksh
	@@ -1,74 +1,74 @@
	#!/bin/ksh -p
	#
	# 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 2007 Sun Microsystems, Inc. All rights reserved.
	# Use is subject to license terms.
	#

	#
	# Copyright (c) 2016 by Delphix. All rights reserved.
	# Copyright (c) 2019 by Tomohiro Kusumi. All rights reserved.
	#

	. $STF_SUITE/tests/functional/atime/atime_common.kshlib

	#
	# DESCRIPTION:
	# When atime=off, verify the access time for files is not updated when read.
	# It is available to pool, fs snapshot and clone.
	#
	# STRATEGY:
	# 1. Create pool, fs.
	# 2. Create '$TESTFILE' for fs.
	# 3. Create snapshot and clone.
	# 4. Setting atime=off on dataset and read '$TESTFILE'.
	# 5. Verify the access time is not updated.
	#

	verify_runnable "both"

	log_assert "Setting atime=off, the access time for files will not be updated \
	when read."
	log_onexit cleanup

	#
	# Create $TESTFILE, snapshot and clone.
	-# Same as 002 except that atime applies to root dataset (ZoL#8675).
	+# Same as 002 except that atime applies to root dataset (OpenZFS#8675).
	#
	setup_snap_clone
	reset_atime

	for dst in $TESTPOOL/$TESTFS $TESTPOOL/$TESTCLONE $TESTPOOL/$TESTFS@$TESTSNAP
	do
	typeset mtpt=$(get_prop mountpoint $dst)

	if [[ $dst == $TESTPOOL/$TESTFS@$TESTSNAP ]]; then
	mtpt=$(snapshot_mountpoint $dst)
	else
	log_must zfs set atime=off $(dirname $dst)
	fi

	log_mustnot check_atime_updated $mtpt/$TESTFILE
	done

	log_pass "Verify the property atime=off passed."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/atime/root_atime_on.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/atime/root_atime_on.ksh
	index 3976523b0b13..44d471a2128f 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/atime/root_atime_on.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/atime/root_atime_on.ksh
	@@ -1,78 +1,78 @@
	#!/bin/ksh -p
	#
	# 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 2007 Sun Microsystems, Inc. All rights reserved.
	# Use is subject to license terms.
	#

	#
	# Copyright (c) 2016 by Delphix. All rights reserved.
	# Copyright (c) 2019 by Tomohiro Kusumi. All rights reserved.
	#

	. $STF_SUITE/tests/functional/atime/atime_common.kshlib

	#
	# DESCRIPTION:
	# When atime=on, verify the access time for files is updated when read. It
	# is available to fs and clone. To snapshot, it is unavailable.
	#
	# STRATEGY:
	# 1. Create pool and fs.
	# 2. Create '$TESTFILE' for fs.
	# 3. Create snapshot and clone.
	# 4. Setting atime=on on datasets except snapshot, and read '$TESTFILE'.
	# 5. Expect the access time is updated on datasets except snapshot.
	#

	verify_runnable "both"

	log_assert "Setting atime=on, the access time for files is updated when read."
	log_onexit cleanup

	#
	# Create $TESTFILE, snapshot and clone.
	-# Same as 001 except that atime/relatime applies to root dataset (ZoL#8675).
	+# Same as 001 except that atime/relatime applies to root dataset (OpenZFS#8675).
	#
	setup_snap_clone
	reset_atime

	for dst in $TESTPOOL/$TESTFS $TESTPOOL/$TESTCLONE $TESTPOOL/$TESTFS@$TESTSNAP
	do
	typeset mtpt=$(get_prop mountpoint $dst)

	if [[ $dst == $TESTPOOL/$TESTFS@$TESTSNAP ]]; then
	mtpt=$(snapshot_mountpoint $dst)
	log_mustnot check_atime_updated $mtpt/$TESTFILE
	else
	if is_linux; then
	log_must zfs set relatime=off $(dirname $dst)
	fi

	log_must zfs set atime=on $(dirname $dst)
	log_must check_atime_updated $mtpt/$TESTFILE
	log_must check_atime_updated $mtpt/$TESTFILE
	fi
	done

	log_pass "Verify the property atime=on passed."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/atime/root_relatime_on.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/atime/root_relatime_on.ksh
	index c919e9f29883..120129425afa 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/atime/root_relatime_on.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/atime/root_relatime_on.ksh
	@@ -1,76 +1,76 @@
	#!/bin/ksh -p
	#
	# 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 2007 Sun Microsystems, Inc. All rights reserved.
	# Use is subject to license terms.
	#

	#
	# Copyright (c) 2019 by Tomohiro Kusumi. All rights reserved.
	#

	. $STF_SUITE/tests/functional/atime/atime_common.kshlib

	#
	# DESCRIPTION:
	# When relatime=on, verify the access time for files is updated when first
	# read but not on second.
	# It is available to fs and clone. To snapshot, it is unavailable.
	#
	# STRATEGY:
	# 1. Create pool and fs.
	# 2. Create '$TESTFILE' for fs.
	# 3. Create snapshot and clone.
	# 4. Setting atime=on and relatime=on on datasets.
	# 5. Expect the access time is updated for first read but not on second.
	#

	verify_runnable "both"

	log_assert "Setting relatime=on, the access time for files is updated when \
	when read the first time, but not second time."
	log_onexit cleanup

	#
	# Create $TESTFILE, snapshot and clone.
	-# Same as 003 except that atime/relatime applies to root dataset (ZoL#8675).
	+# Same as 003 except that atime/relatime applies to root dataset (OpenZFS#8675).
	#
	setup_snap_clone
	reset_atime

	for dst in $TESTPOOL/$TESTFS $TESTPOOL/$TESTCLONE $TESTPOOL/$TESTFS@$TESTSNAP
	do
	typeset mtpt=$(get_prop mountpoint $dst)

	if [[ $dst == $TESTPOOL/$TESTFS@$TESTSNAP ]]; then
	mtpt=$(snapshot_mountpoint $dst)
	log_mustnot check_atime_updated $mtpt/$TESTFILE
	else
	log_must zfs set atime=on $(dirname $dst)
	log_must zfs set relatime=on $(dirname $dst)
	log_must check_atime_updated $mtpt/$TESTFILE
	log_mustnot check_atime_updated $mtpt/$TESTFILE
	fi
	done

	log_pass "Verify the property relatime=on passed."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_destroy/zfs_destroy_015_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_destroy/zfs_destroy_015_pos.ksh
	index f399ad270634..fb29e4acda14 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_destroy/zfs_destroy_015_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_destroy/zfs_destroy_015_pos.ksh
	@@ -1,161 +1,161 @@
	#!/bin/ksh
	#
	# This file and its contents are supplied under the terms of the
	# Common Development and Distribution License ("CDDL"), version 1.0.
	# You may only use this file in accordance with the terms of version
	# 1.0 of the CDDL.
	#
	# A full copy of the text of the CDDL should have accompanied this
	# source. A copy of the CDDL is also available via the Internet at
	# http://www.illumos.org/license/CDDL.
	#

	#
	# Copyright (c) 2012, 2016 by Delphix. All rights reserved.
	#

	# DESCRIPTION
	# zfs destroy <dataset@snap1,snap2..> can destroy a list of multiple
	# snapshots from the same datasets
	#
	# STRATEGY
	-# 1. Create multiple snapshots for the same datset
	+# 1. Create multiple snapshots for the same dataset
	# 2. Run zfs destroy for these snapshots for a mix of valid and
	# invalid snapshot names
	# 3. Run zfs destroy for snapshots from different datasets and
	# pools

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_destroy/zfs_destroy.cfg

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS1 && zfs destroy -R $TESTPOOL/$TESTFS1
	datasetexists $TESTPOOL/$TESTFS2 && zfs destroy -R $TESTPOOL/$TESTFS2
	poolexists $TESTPOOL2 && zpool destroy $TESTPOOL2
	rm -rf $VIRTUAL_DISK
	}

	log_assert "zfs destroy for multiple snapshot is handled correctly"
	log_onexit cleanup

	zfs create $TESTPOOL/$TESTFS1
	typeset -i i=1
	snaplist=""
	log_note "zfs destroy on valid snapshot names"
	for i in 1 2 3 4 5; do
	log_must zfs snapshot $TESTPOOL/$TESTFS1@snap$i
	snaplist=$snaplist,snap$i
	done
	snaplist=${snaplist#,}
	log_must zfs destroy $TESTPOOL/$TESTFS1@$snaplist
	for i in 1 2 3 4 5; do
	log_mustnot snapexists $TESTPOOL/$TESFS1@snap$i
	done

	log_note "zfs destroy with all bogus snapshot names"
	log_mustnot zfs destroy $TESTPOOL/$TESTFS1@snap12,snap21,sna@pple1@,s""nappy2

	log_note "zfs destroy with some bogus snapshot names"
	for i in 1 2 3; do
	log_must zfs snapshot $TESTPOOL/$TESTFS1@snap$i
	done
	log_must zfs destroy $TESTPOOL/$TESTFS1@snap1,snap2,snapple1,snappy2,snap3
	for i in 1 2 3; do
	log_mustnot snapexists $TESTPOOL/$TESTFS1@snap$i
	done

	log_note "zfs destroy with some snapshot names having special characters"
	for i in 1 2 3; do
	log_must zfs snapshot $TESTPOOL/$TESTFS1@snap$i
	done
	log_must zfs destroy $TESTPOOL/$TESTFS1@snap1,@,snap2,,,,snap3,
	for i in 1 2 3; do
	log_mustnot snapexists $TESTPOOL/$TESTFS1@snap$i
	done
	log_note "zfs destroy for too many snapshots"
	snaplist=""
	for i in {1..100}; do
	log_must zfs snapshot $TESTPOOL/$TESTFS1@snap$i
	snaplist=$snaplist,snap$i
	done
	snaplist=${snaplist#,}
	log_must zfs destroy $TESTPOOL/$TESTFS1@$snaplist
	for i in {1..100}; do
	log_mustnot snapexists $TESTPOOL/$TESTFS1@snap$i
	done
	log_note "zfs destroy multiple snapshots with hold"
	snaplist=""
	for i in 1 2 3 4 5; do
	log_must zfs snapshot $TESTPOOL/$TESTFS1@snap$i
	log_must zfs hold keep $TESTPOOL/$TESTFS1@snap$i
	snaplist=$snaplist,snap$i
	done
	snaplist=${snaplist#,}
	log_mustnot zfs destroy $TESTPOOL/$TESTFS1@$snaplist
	for i in 1 2 3 4 5; do
	log_must zfs release keep $TESTPOOL/$TESTFS1@snap$i
	done
	log_must zfs destroy $TESTPOOL/$TESTFS1@$snaplist

	log_note "zfs destroy for multiple snapshots having clones"
	for i in 1 2 3 4 5; do
	log_must zfs snapshot $TESTPOOL/$TESTFS1@snap$i
	done
	snaplist=""
	for i in 1 2 3 4 5; do
	log_must zfs clone $TESTPOOL/$TESTFS1@snap$i $TESTPOOL/$TESTFS1/clone$i
	snaplist=$snaplist,snap$i
	done
	snaplist=${snaplist#,}
	log_mustnot zfs destroy $TESTPOOL/$TESTFS1@$snaplist
	for i in 1 2 3 4 5; do
	log_must snapexists $TESTPOOL/$TESTFS1@snap$i
	log_must zfs destroy $TESTPOOL/$TESTFS1/clone$i
	done

	log_note "zfs destroy for snapshots for different datasets"
	log_must zfs create $TESTPOOL/$TESTFS2
	log_must zfs snapshot $TESTPOOL/$TESTFS2@fs2snap
	log_must zfs create $TESTPOOL/$TESTFS1/$TESTFS2
	log_must zfs snapshot $TESTPOOL/$TESTFS1/$TESTFS2@fs12snap

	long_arg=$TESTPOOL/$TESTFS1@snap1,$TESTPOOL/$TESTFS2@fs2snap,
	long_arg=$long_arg$TESTPOOL/$TESTFS1/$TESTFS2@fs12snap
	log_must zfs destroy $long_arg
	log_mustnot snapexists $TESTPOOL/$TESTFS1@snap1
	log_must snapexists $TESTPOOL/$TESTFS2@fs2snap
	log_must snapexists $TESTPOOL/$TESTFS1/$TESTFS2@fs12snap

	log_must zfs destroy $TESTPOOL/$TESTFS1@fs2snap,fs12snap,snap2
	log_must snapexists $TESTPOOL/$TESTFS2@fs2snap
	log_must snapexists $TESTPOOL/$TESTFS1/$TESTFS2@fs12snap
	log_mustnot snapexists $TESTPOOL/$TESTFS1@snap2

	log_must zfs destroy $TESTPOOL/$TESTFS2@fs2snap,fs12snap,snap3
	log_mustnot snapexists $TESTPOOL/$TESTFS2@fs2snap
	log_must snapexists $TESTPOOL/$TESTFS1/$TESTFS2@fs12snap
	log_must snapexists $TESTPOOL/$TESTFS1@snap3

	log_note "zfs destroy for snapshots from different pools"
	VIRTUAL_DISK=$TEST_BASE_DIR/disk
	log_must mkfile $MINVDEVSIZE $VIRTUAL_DISK
	log_must zpool create $TESTPOOL2 $VIRTUAL_DISK
	log_must poolexists $TESTPOOL2

	log_must zfs create $TESTPOOL2/$TESTFS1
	log_must zfs snapshot $TESTPOOL2/$TESTFS1@snap
	long_arg=$TESTPOOL2/$TESTFS1@snap,$TESTPOOL/$TESTFS1@snap3,
	long_arg=$long_arg$TESTPOOL/$TESTFS1@snap5
	log_must zfs destroy $long_arg
	log_mustnot snapexists $TESTPOOL2/$TESTFS1@snap
	log_must snapexists $TESTPOOL/$TESTFS1@snap3
	log_must snapexists $TESTPOOL/$TESTFS1@snap5

	log_must zfs snapshot $TESTPOOL2/$TESTFS1@snap
	log_must zfs destroy $TESTPOOL2/$TESTFS1@snap5,snap3,snap
	log_mustnot snapexists $TESTPOOL2/$TESTFS1@snap
	log_must snapexists $TESTPOOL/$TESTFS1@snap3
	log_must snapexists $TESTPOOL/$TESTFS1@snap5

	log_pass "zfs destroy for multiple snapshots passes"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_get/zfs_get_001_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_get/zfs_get_001_pos.ksh
	index eeae5390f088..3547fb76c69e 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_get/zfs_get_001_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_get/zfs_get_001_pos.ksh
	@@ -1,163 +1,173 @@
	#!/bin/ksh -p
	#
	# 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 2009 Sun Microsystems, Inc. All rights reserved.
	# Use is subject to license terms.
	#

	#
	# Copyright (c) 2016 by Delphix. All rights reserved.
	+# Copyright (c) 2021 Matt Fiddaman
	#

	. $STF_SUITE/tests/functional/cli_root/zfs_get/zfs_get_common.kshlib
	. $STF_SUITE/tests/functional/cli_root/zfs_get/zfs_get_list_d.kshlib

	#
	# DESCRIPTION:
	# Setting the valid option and properties, 'zfs get' should return the
	# correct property value.
	#
	# STRATEGY:
	# 1. Create pool, filesystem, volume, snapshot, and bookmark.
	# 2. Setting valid parameter, 'zfs get' should succeed.
	# 3. Compare the output property name with the original input property.
	#

	verify_runnable "both"

	typeset options=("" "-p" "-r" "-H")

	typeset -i i=${#options[*]}
	typeset -i j=0
	while ((j<${#depth_options[*]}));
	do
	options[$i]=-"${depth_options[$j]}"
	((j+=1))
	((i+=1))
	done

	typeset zfs_props=("type" used available creation volsize referenced \
	compressratio mounted origin recordsize quota reservation mountpoint \
	sharenfs checksum compression atime devices exec readonly setuid \
	snapdir aclinherit canmount primarycache secondarycache version \
	usedbychildren usedbydataset usedbyrefreservation usedbysnapshots)
	if is_freebsd; then
	typeset zfs_props_os=(jailed aclmode)
	else
	typeset zfs_props_os=(zoned acltype)
	fi
	typeset userquota_props=(userquota@root groupquota@root userused@root \
	groupused@root)
	typeset all_props=("${zfs_props[@]}" \
	"${zfs_props_os[@]}" \
	"${userquota_props[@]}")
	typeset dataset=($TESTPOOL/$TESTCTR $TESTPOOL/$TESTFS $TESTPOOL/$TESTVOL \
	- $TESTPOOL/$TESTFS@$TESTSNAP $TESTPOOL/$TESTVOL@$TESTSNAP)
	+ $TESTPOOL/$TESTFS@$TESTSNAP $TESTPOOL/$TESTVOL@$TESTSNAP
	+ $TESTPOOL/$TESTFS@$TESTSNAP1 $TESTPOOL/$TESTCLONE)

	typeset bookmark_props=(creation)
	typeset bookmark=($TESTPOOL/$TESTFS#$TESTBKMARK $TESTPOOL/$TESTVOL#$TESTBKMARK)

	#
	# According to dataset and option, checking if 'zfs get' return correct
	# property information.
	#
	# $1 dataset
	# $2 properties which are expected to output into $TESTDIR/$TESTFILE0
	# $3 option
	#
	function check_return_value
	{
	typeset dst=$1
	typeset props=$2
	typeset opt=$3
	typeset -i found=0
	typeset p

	for p in $props; do
	found=0

	while read line; do
	typeset item
	item=$(echo $line \| awk '{print $2}' 2>&1)

	if [[ $item == $p ]]; then
	((found += 1))
	+ cols=$(echo $line \| awk '{print NF}')
	break
	fi
	done < $TESTDIR/$TESTFILE0

	if ((found == 0)); then
	log_fail "'zfs get $opt $props $dst' return " \
	"error message.'$p' haven't been found."
	+ elif [[ "$opt" == "-p" ]] && ((cols != 4)); then
	+ log_fail "'zfs get $opt $props $dst' returned " \
	+ "$cols columns instead of 4."
	fi
	done

	log_note "SUCCESS: 'zfs get $opt $prop $dst'."
	}

	log_assert "Setting the valid options and properties 'zfs get' should return " \
	"the correct property value."
	log_onexit cleanup

	# Create filesystem and volume's snapshot
	create_snapshot $TESTPOOL/$TESTFS $TESTSNAP
	create_snapshot $TESTPOOL/$TESTVOL $TESTSNAP

	+# Create second snapshot and clone it
	+create_snapshot $TESTPOOL/$TESTFS $TESTSNAP1
	+create_clone $TESTPOOL/$TESTFS@$TESTSNAP1 $TESTPOOL/$TESTCLONE
	+
	# Create filesystem and volume's bookmark
	create_bookmark $TESTPOOL/$TESTFS $TESTSNAP $TESTBKMARK
	create_bookmark $TESTPOOL/$TESTVOL $TESTSNAP $TESTBKMARK

	typeset -i i=0
	while ((i < ${#dataset[@]})); do
	for opt in "${options[@]}"; do
	for prop in ${all_props[@]}; do
	eval "zfs get $opt $prop ${dataset[i]} > \
	$TESTDIR/$TESTFILE0"
	ret=$?
	if [[ $ret != 0 ]]; then
	log_fail "zfs get returned: $ret"
	fi
	check_return_value ${dataset[i]} "$prop" "$opt"
	done
	done
	((i += 1))
	done

	i=0
	while ((i < ${#bookmark[@]})); do
	for opt in "${options[@]}"; do
	for prop in ${bookmark_props[@]}; do
	eval "zfs get $opt $prop ${bookmark[i]} > \
	$TESTDIR/$TESTFILE0"
	ret=$?
	if [[ $ret != 0 ]]; then
	log_fail "zfs get returned: $ret"
	fi
	check_return_value ${bookmark[i]} "$prop" "$opt"
	done
	done
	((i += 1))
	done

	log_pass "Setting the valid options to dataset, it should succeed and return " \
	"valid value. 'zfs get' pass."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_get/zfs_get_common.kshlib b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_get/zfs_get_common.kshlib
	index d8cb9af028e5..9b4eecf37127 100644
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_get/zfs_get_common.kshlib
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_get/zfs_get_common.kshlib
	@@ -1,106 +1,112 @@
	#
	# 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 2007 Sun Microsystems, Inc. All rights reserved.
	# Use is subject to license terms.
	#

	#
	# Copyright (c) 2016 by Delphix. All rights reserved.
	+# Copyright (c) 2021 Matt Fiddaman
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# According to $elements, $prefix and $separator, the function random produce
	# the number of $counter combination.
	#
	# $1 elements which is used to get the combination.
	# $2 prefix is appended to the combination
	# $3 separator between the combination, such as ' ' or ','
	# $4 counter is the number of combination which you want to get.
	#
	function gen_option_str # $elements $prefix $separator $counter
	{
	typeset elements=""
	typeset prefix=${2}
	typeset separator=${3}
	typeset -i counter=${4:-0}
	typeset -i i=0
	typeset comb_str=""

	for e in $1; do
	elements[i]="$e"
	(( i += 1 ))
	done
	(( ${#elements[@]} == 0 )) && log_fail "The elements can't be empty."

	typeset -i item=0
	typeset -i j=0
	typeset -i numb_item=0

	# Loop and get the specified number combination strings.
	i=0
	while (( i < counter )); do
	j=0
	numb_item=0
	comb_str=""

	# Get random number items for each combinations.
	(( numb_item = ($RANDOM % ${#elements[@]}) + 1 ))

	while (( j < numb_item )); do
	# Random select elements from the array
	(( item = $RANDOM % ${#elements[@]} ))

	if (( ${#comb_str} == 0 )); then
	comb_str=${elements[item]}
	else
	comb_str=$comb_str$separator${elements[item]}
	fi
	(( j += 1 ))
	done

	echo "$prefix$comb_str"

	(( i += 1 ))
	done
	}

	#
	-# Cleanup the volume snapshot, filesystem snapshot, volume bookmark, and
	-# filesystem bookmark that were created for this test case.
	+# Cleanup the volume snapshot, filesystem snapshots, clone, volume bookmark,
	+# and filesystem bookmark that were created for this test case.
	#
	function cleanup
	{
	datasetexists $TESTPOOL/$TESTVOL@$TESTSNAP && \
	destroy_snapshot $TESTPOOL/$TESTVOL@$TESTSNAP
	datasetexists $TESTPOOL/$TESTFS@$TESTSNAP && \
	destroy_snapshot $TESTPOOL/$TESTFS@$TESTSNAP

	+ datasetexists $TESTPOOL/$TESTCLONE && \
	+ destroy_clone $TESTPOOL/$TESTCLONE
	+ datasetexists $TESTPOOL/$TESTFS@$TESTSNAP1 && \
	+ destroy_snapshot $TESTPOOL/$TESTFS@$TESTSNAP1
	+
	bkmarkexists $TESTPOOL/$TESTVOL#$TESTBKMARK && \
	destroy_bookmark $TESTPOOL/$TESTVOL#$TESTBKMARK
	bkmarkexists $TESTPOOL/$TESTFS#$TESTBKMARK && \
	destroy_bookmark $TESTPOOL/$TESTFS#$TESTBKMARK

	[[ -e $TESTFILE0 ]] && log_must rm $TESTFILE0
	}
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_mount/zfs_mount_test_race.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_mount/zfs_mount_test_race.ksh
	index 135b31354f07..3a5793d0707d 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_mount/zfs_mount_test_race.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_mount/zfs_mount_test_race.ksh
	@@ -1,116 +1,117 @@
	#!/bin/ksh

	#
	# This file and its contents are supplied under the terms of the
	# Common Development and Distribution License ("CDDL"), version 1.0.
	# You may only use this file in accordance with the terms of version
	# 1.0 of the CDDL.
	#
	# A full copy of the text of the CDDL should have accompanied this
	# source. A copy of the CDDL is also available via the Internet at
	# http://www.illumos.org/license/CDDL.
	#

	#
	# Copyright (c) 2019 by Tomohiro Kusumi. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_mount/zfs_mount.cfg

	#
	# DESCRIPTION:
	# Verify parallel mount ordering is consistent.
	#
	# There was a bug in initial thread dispatching algorithm which put threads
	# under race condition which resulted in undefined mount order. The purpose
	# of this test is to verify `zfs unmount -a` succeeds (not `zfs mount -a`
	# succeeds, it always does) after `zfs mount -a`, which could fail if threads
	# race. See github.com/openzfs/zfs/issues/{8450,8833,8878} for details.
	#
	# STRATEGY:
	# 1. Create pools and filesystems.
	# 2. Set same mount point for >1 datasets.
	# 3. Unmount all datasets.
	# 4. Mount all datasets.
	# 5. Unmount all datasets (verify this succeeds).
	#

	verify_runnable "both"

	TMPDIR=${TMPDIR:-$TEST_BASE_DIR}
	MNTPT=$TMPDIR/zfs_mount_test_race_mntpt
	DISK1="$TMPDIR/zfs_mount_test_race_disk1"
	DISK2="$TMPDIR/zfs_mount_test_race_disk2"

	TESTPOOL1=zfs_mount_test_race_tp1
	TESTPOOL2=zfs_mount_test_race_tp2

	export __ZFS_POOL_RESTRICT="$TESTPOOL1 $TESTPOOL2"
	log_must zfs $unmountall
	unset __ZFS_POOL_RESTRICT

	function cleanup
	{
	zpool destroy $TESTPOOL1
	zpool destroy $TESTPOOL2
	rm -rf $MNTPT
	rm -rf /$TESTPOOL1
	rm -rf /$TESTPOOL2
	rm -f $DISK1
	rm -f $DISK2
	export __ZFS_POOL_RESTRICT="$TESTPOOL1 $TESTPOOL2"
	log_must zfs $mountall
	unset __ZFS_POOL_RESTRICT
	}
	log_onexit cleanup

	log_note "Verify parallel mount ordering is consistent"

	log_must truncate -s $MINVDEVSIZE $DISK1
	log_must truncate -s $MINVDEVSIZE $DISK2

	log_must zpool create -f $TESTPOOL1 $DISK1
	log_must zpool create -f $TESTPOOL2 $DISK2

	log_must zfs create $TESTPOOL1/$TESTFS1
	log_must zfs create $TESTPOOL2/$TESTFS2

	log_must zfs set mountpoint=none $TESTPOOL1
	log_must zfs set mountpoint=$MNTPT $TESTPOOL1/$TESTFS1

	# Note that unmount can fail (due to race condition on `zfs mount -a`) with or
	# without `canmount=off`. The race has nothing to do with canmount property,
	# but turn it off for convenience of mount layout used in this test case.
	log_must zfs set canmount=off $TESTPOOL2
	log_must zfs set mountpoint=$MNTPT $TESTPOOL2

	# At this point, layout of datasets in two pools will look like below.
	# Previously, on next `zfs mount -a`, pthreads assigned to TESTFS1 and TESTFS2
	-# could race, and TESTFS2 usually (actually always) won in ZoL. Note that the
	-# problem is how two or more threads could initially be assigned to the same
	-# top level directory, not this specific layout. This layout is just an example
	-# that can reproduce race, and is also the layout reported in #8833.
	+# could race, and TESTFS2 usually (actually always) won in OpenZFS.
	+# Note that the problem is how two or more threads could initially be assigned
	+# to the same top level directory, not this specific layout.
	+# This layout is just an example that can reproduce race,
	+# and is also the layout reported in #8833.
	#
	# NAME MOUNTED MOUNTPOINT
	# ----------------------------------------------
	# /$TESTPOOL1 no none
	# /$TESTPOOL1/$TESTFS1 yes $MNTPT
	# /$TESTPOOL2 no $MNTPT
	# /$TESTPOOL2/$TESTFS2 yes $MNTPT/$TESTFS2

	# Apparently two datasets must be mounted.
	log_must ismounted $TESTPOOL1/$TESTFS1
	log_must ismounted $TESTPOOL2/$TESTFS2
	# This unmount always succeeds, because potential race hasn't happened yet.
	log_must zfs unmount -a
	# This mount always succeeds, whether threads are under race condition or not.
	log_must zfs mount -a

	# Verify datasets are mounted (TESTFS2 fails if the race broke mount order).
	log_must ismounted $TESTPOOL1/$TESTFS1
	log_must ismounted $TESTPOOL2/$TESTFS2
	# Verify unmount succeeds (fails if the race broke mount order).
	log_must zfs unmount -a

	log_pass "Verify parallel mount ordering is consistent passed"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/receive-o-x_props_override.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/receive-o-x_props_override.ksh
	index 6f897a96f3e8..2d3c15c62fc9 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/receive-o-x_props_override.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_receive/receive-o-x_props_override.ksh
	@@ -1,320 +1,325 @@
	#!/bin/ksh -p
	#
	# CDDL HEADER START
	#
	# This file and its contents are supplied under the terms of the
	# Common Development and Distribution License ("CDDL"), version 1.0.
	# You may only use this file in accordance with the terms of version
	# 1.0 of the CDDL.
	#
	# A full copy of the text of the CDDL should have accompanied this
	# source. A copy of the CDDL is also available via the Internet at
	# http://www.illumos.org/license/CDDL.
	#
	# CDDL HEADER END
	#

	#
	# Copyright 2017, loli10K <ezomori.nozomu@gmail.com>. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/cli_root/zfs_set/zfs_set_common.kshlib

	#
	# DESCRIPTION:
	# Verify ZFS property override (-o) and exclude (-x) options work when
	# receiving a send stream
	#
	# STRATEGY:
	# 1. Create a filesystem with children.
	# 2. Snapshot the filesystems.
	# 3. Create various send streams (full, incremental, replication) and verify
	# we can both override and exclude native and user properties.
	#

	verify_runnable "both"

	function cleanup
	{
	log_must rm -f $streamfile_full
	log_must rm -f $streamfile_incr
	log_must rm -f $streamfile_repl
	log_must rm -f $streamfile_trun
	destroy_dataset "$orig" "-rf"
	destroy_dataset "$dest" "-rf"
	}

	log_assert "ZFS receive property override and exclude options work as expected."
	log_onexit cleanup

	orig=$TESTPOOL/$TESTFS1
	origsub=$orig/sub
	dest=$TESTPOOL/$TESTFS2
	destsub=$dest/sub
	typeset userprop=$(valid_user_property 8)
	typeset userval=$(user_property_value 8)
	typeset streamfile_full=$TESTDIR/streamfile_full.$$
	typeset streamfile_incr=$TESTDIR/streamfile_incr.$$
	typeset streamfile_repl=$TESTDIR/streamfile_repl.$$
	typeset streamfile_trun=$TESTDIR/streamfile_trun.$$

	#
	# 3.1 Verify we can't specify the same property in multiple -o or -x options
	# or an invalid value was specified.
	#
	# Create a full send stream
	log_must zfs create $orig
	log_must zfs snapshot $orig@snap1
	log_must eval "zfs send $orig@snap1 > $streamfile_full"
	# Verify we reject invalid options
	log_mustnot eval "zfs recv $dest -o atime < $streamfile_full"
	log_mustnot eval "zfs recv $dest -x atime=off < $streamfile_full"
	log_mustnot eval "zfs recv $dest -o atime=off -x atime < $streamfile_full"
	log_mustnot eval "zfs recv $dest -o atime=off -o atime=on < $streamfile_full"
	log_mustnot eval "zfs recv $dest -x atime -x atime < $streamfile_full"
	log_mustnot eval "zfs recv $dest -o version=1 < $streamfile_full"
	log_mustnot eval "zfs recv $dest -x version < $streamfile_full"
	log_mustnot eval "zfs recv $dest -x normalization < $streamfile_full"
	# Verify we also reject invalid ZVOL options
	log_must zfs create -V 32K -s $orig/zvol
	log_must eval "zfs send $orig@snap1 > $streamfile_full"
	log_mustnot eval "zfs recv $dest -x volsize < $streamfile_full"
	log_mustnot eval "zfs recv $dest -o volsize=32K < $streamfile_full"
	# Cleanup
	block_device_wait
	log_must_busy zfs destroy -r -f $orig

	#
	# 3.2 Verify -o property=value works on streams without properties.
	#
	# Create a full send stream
	log_must zfs create $orig
	log_must zfs snapshot $orig@snap1
	log_must eval "zfs send $orig@snap1 > $streamfile_full"
	# Receive the full stream, override some properties
	log_must eval "zfs recv -o compression=on -o '$userprop:dest'='$userval' "\
	"$dest < $streamfile_full"
	log_must eval "check_prop_source $dest compression on local"
	log_must eval "check_prop_source $dest '$userprop:dest' '$userval' local"
	# Cleanup
	log_must zfs destroy -r -f $orig
	log_must zfs destroy -r -f $dest

	#
	# 3.3 Verify -o property=value and -x work on both native and user properties
	# for an incremental replication send stream.
	#
	# Create a dataset tree and receive it
	log_must zfs create $orig
	log_must zfs create $origsub
	log_must zfs snapshot -r $orig@snap1
	log_must eval "zfs send -R $orig@snap1 > $streamfile_repl"
	log_must eval "zfs recv $dest < $streamfile_repl"
	# Fill the datasets with properties and create an incremental replication stream
	log_must zfs snapshot -r $orig@snap2
	log_must zfs snapshot -r $orig@snap3
	log_must eval "zfs set copies=2 $orig"
	log_must eval "zfs set '$userprop:orig'='$userval' $orig"
	log_must eval "zfs set '$userprop:orig'='$userval' $origsub"
	log_must eval "zfs set '$userprop:snap'='$userval' $orig@snap1"
	log_must eval "zfs set '$userprop:snap'='$userval' $origsub@snap3"
	log_must eval "zfs send -R -I $orig@snap1 $orig@snap3 > $streamfile_incr"
	# Sets various combination of override and exclude options
	log_must eval "zfs recv -F -o atime=off -o '$userprop:dest2'='$userval' "\
	"-o quota=123456789 -o checksum=sha512 -x compression "\
	"-x '$userprop:orig' -x '$userprop:snap3' $dest < $streamfile_incr"
	# Verify we can correctly override and exclude properties
	log_must eval "check_prop_source $dest copies 2 received"
	log_must eval "check_prop_source $dest atime off local"
	log_must eval "check_prop_source $dest '$userprop:dest2' '$userval' local"
	log_must eval "check_prop_source $dest quota 123456789 local"
	log_must eval "check_prop_source $dest checksum sha512 local"
	log_must eval "check_prop_inherit $destsub copies $dest"
	log_must eval "check_prop_inherit $destsub atime $dest"
	log_must eval "check_prop_inherit $destsub checksum $dest"
	log_must eval "check_prop_inherit $destsub '$userprop:dest2' $dest"
	log_must eval "check_prop_source $destsub quota 0 default"
	log_must eval "check_prop_source $destsub compression off default"
	log_must eval "check_prop_missing $dest '$userprop:orig'"
	log_must eval "check_prop_missing $destsub '$userprop:orig'"
	log_must eval "check_prop_source " \
	"$dest@snap1 '$userprop:snap' '$userval' received"
	log_must eval "check_prop_source " \
	"$destsub@snap3 '$userprop:snap' '$userval' received"
	log_must eval "check_prop_missing $dest@snap3 '$userprop:snap3'"
	log_must eval "check_prop_missing $destsub@snap3 '$userprop:snap3'"
	# Cleanup
	log_must zfs destroy -r -f $orig
	log_must zfs destroy -r -f $dest

	#
	# 3.4 Verify '-x property' does not remove existing local properties and a
	# modified sent property is received and updated to the new value but can
	# still be excluded.
	#
	# Create a dataset tree
	log_must zfs create $orig
	log_must zfs create $origsub
	log_must zfs snapshot -r $orig@snap1
	log_must eval "zfs set copies=2 $orig"
	log_must eval "zfs set '$userprop:orig'='oldval' $orig"
	log_must eval "zfs set '$userprop:orig'='oldsubval' $origsub"
	log_must eval "zfs send -R $orig@snap1 > $streamfile_repl"
	log_must eval "zfs receive $dest < $streamfile_repl"
	log_must eval "check_prop_source $dest copies 2 received"
	log_must eval "check_prop_inherit $destsub copies $dest"
	log_must eval "check_prop_source $dest '$userprop:orig' 'oldval' received"
	log_must eval "check_prop_source $destsub '$userprop:orig' 'oldsubval' received"
	# Set new custom properties on both source and destination
	log_must eval "zfs set copies=3 $orig"
	log_must eval "zfs set '$userprop:orig'='newval' $orig"
	log_must eval "zfs set '$userprop:orig'='newsubval' $origsub"
	log_must eval "zfs set compression=gzip $dest"
	log_must eval "zfs set '$userprop:dest'='localval' $dest"
	# Receive the new stream, verify we preserve locally set properties
	log_must zfs snapshot -r $orig@snap2
	log_must zfs snapshot -r $orig@snap3
	log_must eval "zfs send -R -I $orig@snap1 $orig@snap3 > $streamfile_incr"
	log_must eval "zfs recv -F -x copies -x compression -x '$userprop:orig' " \
	"-x '$userprop:dest' $dest < $streamfile_incr"
	log_must eval "check_prop_source $dest '$userprop:dest' 'localval' local"
	log_must eval "check_prop_received $dest '$userprop:orig' 'newval'"
	log_must eval "check_prop_received $destsub '$userprop:orig' 'newsubval'"
	log_must eval "check_prop_missing $dest '$userprop:orig'"
	log_must eval "check_prop_missing $destsub '$userprop:orig'"
	log_must eval "check_prop_source $dest copies 1 default"
	log_must eval "check_prop_received $dest copies 3"
	log_must eval "check_prop_source $destsub copies 1 default"
	log_must eval "check_prop_received $destsub copies '-'"
	log_must eval "check_prop_source $dest compression gzip local"
	log_must eval "check_prop_inherit $destsub compression $dest"
	# Cleanup
	log_must zfs destroy -r -f $orig
	log_must zfs destroy -r -f $dest

	#
	# 3.5 Verify we can exclude non-inheritable properties from a send stream
	#
	# Create a dataset tree and replication stream
	log_must zfs create $orig
	log_must zfs create $origsub
	log_must zfs snapshot -r $orig@snap1
	log_must eval "zfs set quota=123456789 $orig"
	log_must eval "zfs send -R $orig@snap1 > $streamfile_repl"
	# Receive the stream excluding non-inheritable properties
	log_must eval "zfs recv -F -x quota $dest < $streamfile_repl"
	log_must eval "check_prop_source $dest quota 0 default"
	log_must eval "check_prop_source $destsub quota 0 default"
	# Set some non-inheritable properties on the destination, verify we keep them
	log_must eval "zfs set quota=123456789 $dest"
	log_must eval "zfs set canmount=off $destsub"
	log_must zfs snapshot -r $orig@snap2
	log_must zfs snapshot -r $orig@snap3
	log_must eval "zfs send -R -I $orig@snap1 $orig@snap3 > $streamfile_incr"
	log_must eval "zfs recv -F -x quota -x canmount $dest < $streamfile_incr"
	log_must eval "check_prop_source $dest quota 123456789 local"
	log_must eval "check_prop_source $destsub quota 0 default"
	log_must eval "check_prop_source $destsub canmount off local"
	# Cleanup
	log_must zfs destroy -r -f $orig
	log_must zfs destroy -r -f $dest

	#
	# 3.6 Verify we correctly restore existing properties on a failed receive
	#
	# Receive a "clean" dataset tree
	log_must zfs create $orig
	log_must zfs create $origsub
	log_must zfs snapshot -r $orig@snap1
	log_must eval "zfs send -R $orig@snap1 > $streamfile_repl"
	log_must eval "zfs receive $dest < $streamfile_repl"
	# Set custom properties on the destination
	log_must eval "zfs set atime=off $dest"
	log_must eval "zfs set quota=123456789 $dest"
	log_must eval "zfs set '$userprop:orig'='$userval' $dest"
	log_must eval "zfs set '$userprop:origsub'='$userval' $destsub"
	# Create a truncated incremental replication stream
	mntpnt=$(get_prop mountpoint $orig)
	log_must eval "dd if=/dev/urandom of=$mntpnt/file bs=1024k count=10"
	log_must zfs snapshot -r $orig@snap2
	log_must zfs snapshot -r $orig@snap3
	log_must eval "zfs send -R -I $orig@snap1 $orig@snap3 > $streamfile_incr"
	log_must eval "dd if=$streamfile_incr of=$streamfile_trun bs=1024k count=9"
	# Receive the truncated stream, verify original properties are kept
	log_mustnot eval "zfs recv -F -o copies=3 -o quota=987654321 "\
	"-o '$userprop:new'='badval' $dest < $streamfile_trun"
	log_must eval "check_prop_source $dest copies 1 default"
	log_must eval "check_prop_source $destsub copies 1 default"
	log_must eval "check_prop_source $dest atime off local"
	log_must eval "check_prop_inherit $destsub atime $dest"
	log_must eval "check_prop_source $dest quota 123456789 local"
	log_must eval "check_prop_source $destsub quota 0 default"
	log_must eval "check_prop_source $dest '$userprop:orig' '$userval' local"
	log_must eval "check_prop_inherit $destsub '$userprop:orig' $dest"
	log_must eval "check_prop_source $destsub '$userprop:origsub' '$userval' local"
	log_must eval "check_prop_missing $dest '$userprop:new'"
	# Cleanup
	log_must zfs destroy -r -f $orig
	log_must zfs destroy -r -f $dest

	#
	-# 3.7 Verify we can't receive a send stream overriding or excluding properties
	-# invalid for the dataset type unless the stream it's recursive, in which
	-# case only the appropriate properties are set on the destination.
	-#
	+# 3.7 Verify we can receive a send stream excluding but not overriding
	+# properties invalid for the dataset type, in which case only the
	+# appropriate properties are set on the destination.
	log_must zfs create -V 128K -s $orig
	log_must zfs snapshot $orig@snap1
	log_must eval "zfs send $orig@snap1 > $streamfile_full"
	-log_mustnot eval "zfs receive -x atime $dest < $streamfile_full"
	log_mustnot eval "zfs receive -o atime=off $dest < $streamfile_full"
	+log_mustnot eval "zfs receive -o atime=off -x canmount $dest < $streamfile_full"
	+log_must eval "zfs receive -x atime -x canmount $dest < $streamfile_full"
	+log_must eval "check_prop_source $dest type volume -"
	+log_must eval "check_prop_source $dest atime - -"
	+log_must eval "check_prop_source $dest canmount - -"
	log_must_busy zfs destroy -r -f $orig
	+log_must_busy zfs destroy -r -f $dest
	+# Recursive sends also accept (and ignore) such overrides
	log_must zfs create $orig
	log_must zfs create -V 128K -s $origsub
	log_must zfs snapshot -r $orig@snap1
	log_must eval "zfs send -R $orig@snap1 > $streamfile_repl"
	log_must eval "zfs receive -o atime=off $dest < $streamfile_repl"
	log_must eval "check_prop_source $dest type filesystem -"
	log_must eval "check_prop_source $dest atime off local"
	log_must eval "check_prop_source $destsub type volume -"
	log_must eval "check_prop_source $destsub atime - -"
	# Cleanup
	block_device_wait
	log_must_busy zfs destroy -r -f $orig
	log_must_busy zfs destroy -r -f $dest

	#
	# 3.8 Verify 'zfs recv -x\|-o' works correctly when used in conjunction with -d
	# and -e options.
	#
	log_must zfs create -p $orig/1/2/3/4
	log_must eval "zfs set copies=2 $orig"
	log_must eval "zfs set atime=on $orig"
	log_must eval "zfs set '$userprop:orig'='oldval' $orig"
	log_must zfs snapshot -r $orig@snap1
	log_must eval "zfs send -R $orig/1/2@snap1 > $streamfile_repl"
	# Verify 'zfs recv -e'
	log_must zfs create $dest
	log_must eval "zfs receive -e -o copies=3 -x atime "\
	"-o '$userprop:orig'='newval' $dest < $streamfile_repl"
	log_must datasetexists $dest/2/3/4
	log_must eval "check_prop_source $dest/2 copies 3 local"
	log_must eval "check_prop_inherit $dest/2/3/4 copies $dest/2"
	log_must eval "check_prop_source $dest/2/3/4 atime on default"
	log_must eval "check_prop_source $dest/2 '$userprop:orig' 'newval' local"
	log_must eval "check_prop_inherit $dest/2/3/4 '$userprop:orig' $dest/2"
	log_must zfs destroy -r -f $dest
	# Verify 'zfs recv -d'
	log_must zfs create $dest
	typeset fs="$(echo $orig \| awk -F'/' '{print $NF}')"
	log_must eval "zfs receive -d -o copies=3 -x atime "\
	"-o '$userprop:orig'='newval' $dest < $streamfile_repl"
	log_must datasetexists $dest/$fs/1/2/3/4
	log_must eval "check_prop_source $dest/$fs/1/2 copies 3 local"
	log_must eval "check_prop_inherit $dest/$fs/1/2/3/4 copies $dest/$fs/1/2"
	log_must eval "check_prop_source $dest/$fs/1/2/3/4 atime on default"
	log_must eval "check_prop_source $dest/$fs/1/2 '$userprop:orig' 'newval' local"
	log_must eval "check_prop_inherit $dest/$fs/1/2/3/4 '$userprop:orig' $dest/$fs/1/2"
	# We don't need to cleanup here

	log_pass "ZFS receive property override and exclude options passed."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/Makefile.am b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/Makefile.am
	index 9a492f32311d..25c7065670f2 100644
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/Makefile.am
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/Makefile.am
	@@ -1,19 +1,20 @@
	pkgdatadir = $(datadir)/@PACKAGE@/zfs-tests/tests/functional/cli_root/zfs_send
	dist_pkgdata_SCRIPTS = \
	setup.ksh \
	cleanup.ksh \
	zfs_send_001_pos.ksh \
	zfs_send_002_pos.ksh \
	zfs_send_003_pos.ksh \
	zfs_send_004_neg.ksh \
	zfs_send_005_pos.ksh \
	zfs_send_006_pos.ksh \
	zfs_send_007_pos.ksh \
	zfs_send_encrypted.ksh \
	zfs_send_encrypted_unloaded.ksh \
	zfs_send_raw.ksh \
	zfs_send_sparse.ksh \
	- zfs_send-b.ksh
	+ zfs_send-b.ksh \
	+ zfs_send_skip_missing.ksh

	dist_pkgdata_DATA = \
	zfs_send.cfg
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_skip_missing.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_skip_missing.ksh
	new file mode 100755
	index 000000000000..b367cef9c4a4
	--- /dev/null
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zfs_send/zfs_send_skip_missing.ksh
	@@ -0,0 +1,77 @@
	+#!/bin/ksh -p
	+#
	+# 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) 2016, loli10K. All rights reserved.
	+# Copyright (c) 2021, Pablo Correa Gómez. All rights reserved.
	+#
	+
	+. $STF_SUITE/tests/functional/cli_root/cli_common.kshlib
	+. $STF_SUITE/tests/functional/cli_root/zfs_send/zfs_send.cfg
	+
	+#
	+# DESCRIPTION:
	+# Verify 'zfs send' will avoid sending replication send
	+# streams when we're missing snapshots in the dataset
	+# hierarchy, unless -s\|--skip-missing provided
	+#
	+# STRATEGY:
	+# 1. Create a parent and child fs and then only snapshot the parent
	+# 2. Verify sending with replication will fail
	+# 3. Verify sending with skip-missing will print a warning but succeed
	+#
	+
	+verify_runnable "both"
	+
	+function cleanup
	+{
	+ snapexists $SNAP && log_must zfs destroy -f $SNAP
	+
	+ datasetexists $PARENT && log_must zfs destroy -rf $PARENT
	+
	+ [[ -e $WARNF ]] && log_must rm -f $WARNF
	+ rm -f $TEST_BASE_DIR/devnull
	+}
	+
	+log_assert "Verify 'zfs send -Rs' works as expected."
	+log_onexit cleanup
	+
	+PARENT=$TESTPOOL/parent
	+CHILD=$PARENT/child
	+SNAP=$PARENT@snap
	+WARNF=$TEST_BASE_DIR/warn.2
	+
	+log_note "Verify 'zfs send -R' fails to generate replication stream"\
	+ " for datasets created before"
	+
	+log_must zfs create $PARENT
	+log_must zfs create $CHILD
	+log_must zfs snapshot $SNAP
	+log_mustnot eval "zfs send -R $SNAP >$TEST_BASE_DIR/devnull"
	+
	+log_note "Verify 'zfs send -Rs' warns about missing snapshots, "\
	+ "but still succeeds"
	+
	+log_must eval "zfs send -Rs $SNAP 2> $WARNF >$TEST_BASE_DIR/devnull"
	+log_must eval "[[ -s $WARNF ]]"
	+
	+log_pass "Verify 'zfs send -Rs' works as expected."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_add/zpool_add_dryrun_output.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_add/zpool_add_dryrun_output.ksh
	index dbf81262ee1a..73dec9240326 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_add/zpool_add_dryrun_output.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_root/zpool_add/zpool_add_dryrun_output.ksh
	@@ -1,175 +1,175 @@
	#!/bin/ksh -p
	#
	# 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 2020 Attila Fülöp <attila@fueloep.org>
	#

	. $STF_SUITE/include/libtest.shlib

	typeset STR_DRYRUN="would update '$TESTPOOL' to the following configuration:"
	typeset VDEV_PREFIX="$TEST_BASE_DIR/filedev"

	#
	# DESCRIPTION:
	# 'zpool add -n <pool> <vdev> ...' can display the correct configuration
	#
	# STRATEGY:
	# 1. Create different storage pools, use -n to add devices to the pool and
	# verify the output is as expected.
	-# 2. Create a pool whith a hole vdev and verify it's not listed with add -n.
	+# 2. Create a pool with a hole vdev and verify it's not listed with add -n.
	#

	typeset -a dev=(
	"${VDEV_PREFIX}00" "${VDEV_PREFIX}01" "${VDEV_PREFIX}02"
	"${VDEV_PREFIX}03" "${VDEV_PREFIX}04" "${VDEV_PREFIX}05"
	"${VDEV_PREFIX}06" "${VDEV_PREFIX}07" "${VDEV_PREFIX}08"
	"${VDEV_PREFIX}09" "${VDEV_PREFIX}10" "${VDEV_PREFIX}11"
	)

	typeset -a tests=(
	(
	tree="'${dev[0]}' log '${dev[1]}' special '${dev[2]}' dedup '${dev[3]}'"
	add="spare '${dev[4]}' cache '${dev[5]}'"
	want="$STR_DRYRUN

	$TESTPOOL
	${dev[0]}
	dedup
	${dev[3]}
	special
	${dev[2]}
	logs
	${dev[1]}
	cache
	${dev[5]}
	spares
	${dev[4]}"
	)
	(
	tree="'${dev[0]}' log '${dev[1]}' special '${dev[2]}' dedup '${dev[3]}' \
	spare '${dev[4]}' cache '${dev[5]}'"

	add="'${dev[6]}' log '${dev[7]}' special '${dev[8]}' dedup '${dev[9]}' \
	spare '${dev[10]}' cache '${dev[11]}'"

	want="$STR_DRYRUN

	$TESTPOOL
	${dev[0]}
	${dev[6]}
	dedup
	${dev[3]}
	${dev[9]}
	special
	${dev[2]}
	${dev[8]}
	logs
	${dev[1]}
	${dev[7]}
	cache
	${dev[5]}
	${dev[11]}
	spares
	${dev[4]}
	${dev[10]}"
	)
	(
	tree="mirror '${dev[0]}' '${dev[1]}' \
	log mirror '${dev[2]}' '${dev[3]}' \
	dedup mirror '${dev[6]}' '${dev[7]}' \
	spare '${dev[8]}'"

	add="special mirror '${dev[4]}' '${dev[5]}' \
	spare '${dev[9]}' cache '${dev[10]}' '${dev[11]}'"

	want="$STR_DRYRUN

	$TESTPOOL
	mirror-0
	${dev[0]}
	${dev[1]}
	dedup
	mirror
	${dev[6]}
	${dev[7]}
	special
	mirror
	${dev[4]}
	${dev[5]}
	logs
	mirror
	${dev[2]}
	${dev[3]}
	cache
	${dev[10]}
	${dev[11]}
	spares
	${dev[8]}
	${dev[9]}"
	)
	)

	verify_runnable "global"

	function cleanup
	{
	destroy_pool "$TESTPOOL"
	rm -f "$VDEV_PREFIX"*
	}

	log_assert "'zpool add -n <pool> <vdev> ...' can display the configuration"

	log_onexit cleanup

	# Create needed file vdevs.
	for (( i=0; i < ${#dev[@]}; i+=1 )); do
	log_must truncate -s $SPA_MINDEVSIZE "${dev[$i]}"
	done

	# Foreach test create pool, add -n devices and check output.
	for (( i=0; i < ${#tests[@]}; i+=1 )); do
	typeset tree="${tests[$i].tree}"
	typeset add="${tests[$i].add}"
	typeset want="${tests[$i].want}"

	log_must eval zpool create "$TESTPOOL" $tree
	log_must poolexists "$TESTPOOL"
	typeset out="$(log_must eval "zpool add -n '$TESTPOOL' $add" \| \
	sed /^SUCCESS/d)"

	if [[ "$out" != "$want" ]]; then
	log_fail "Got:\n" "$out" "\nbut expected:\n" "$want"
	fi
	log_must destroy_pool "$TESTPOOL"
	done

	-# Make sure hole vdevs are skiped in output.
	+# Make sure hole vdevs are skipped in output.
	log_must eval "zpool create '$TESTPOOL' '${dev[0]}' log '${dev[1]}' \
	cache '${dev[2]}'"

	# Create a hole vdev.
	log_must eval "zpool remove '$TESTPOOL' '${dev[1]}'"
	log_mustnot eval "zpool add -n '$TESTPOOL' '${dev[1]}' \| \
	grep -qE '[[:space:]]+hole'"

	log_pass "'zpool add -n <pool> <vdev> ...' displays config correctly."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_user/misc/arc_summary_001_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_user/misc/arc_summary_001_pos.ksh
	index a445fbb48cf3..befbea986e1b 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_user/misc/arc_summary_001_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_user/misc/arc_summary_001_pos.ksh
	@@ -1,60 +1,63 @@
	#! /bin/ksh -p
	#
	# 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) 2015 by Lawrence Livermore National Security, LLC.
	# All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib

	log_assert "arc_summary generates output and doesn't return an error code"

	# Depending on which version of arc_summary is installed some command
	# line options may not be available. The python3 version includes
	# several additional flags.
	python3 -V 2>&1 > /dev/null
	if (( $? )); then
	# Some systems have Python 3 installed, but only older versions
	# that don't have the subprocess.run() functionality. We catch
	# these with a separate test. Remove this when all systems have
	# reached 3.5 or greater
	VERSIONPYTEST=$(python3 -V)
	if [[ ${VERSIONPYTEST:9:1} -lt 5 ]]; then
	set -A args "" "-a" "-d" "-p 1"
	else
	set -A args "" "-a" "-d" "-p 1" "-g" "-s arc" "-r"
	fi
	else
	set -A args "" "-a" "-d" "-p 1"
	fi

	+# Without this, the below checks aren't going to work the way we hope...
	+set -o pipefail
	+
	typeset -i i=0
	while [[ $i -lt ${#args[*]} ]]; do
	log_must eval "arc_summary ${args[i]} > /dev/null"
	((i = i + 1))
	done

	log_must eval "arc_summary \| head > /dev/null"
	log_must eval "arc_summary \| head -1 > /dev/null"

	log_pass "arc_summary generates output and doesn't return an error code"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_user/zfs_list/zfs_list_002_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_user/zfs_list/zfs_list_002_pos.ksh
	index 382b2cb7f0b1..4951097aca51 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_user/zfs_list/zfs_list_002_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_user/zfs_list/zfs_list_002_pos.ksh
	@@ -1,176 +1,176 @@
	#!/bin/ksh -p
	#
	# 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 2008 Sun Microsystems, Inc. All rights reserved.
	# Use is subject to license terms.
	#

	#
	# Copyright (c) 2013, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/tests/functional/cli_user/zfs_list/zfs_list.kshlib

	#
	# DESCRIPTION:
	# The sort functionality in 'zfs list' works as expected.
	#
	# STRATEGY:
	# 1. Using several zfs datasets with names, creation dates, checksum options
	# 2. Sort the datasets by name, checksum options, creation date.
	# 3. Verify that the datasets are sorted correctly.
	#

	verify_runnable "both"

	# datasets ordered by name
	fs_name="Apple Banana Carrot Orange apple banana carrot"
	vol_name="Apple-vol Banana-vol Carrot-vol Orange-vol apple-vol"
	vol_name="$vol_name banana-vol carrot-vol"
	if is_global_zone ; then
	snap_name="Apple-vol@snap Apple@snap Banana-vol@snap Banana@snap"
	snap_name="$snap_name Carrot-vol@snap Carrot@snap Orange-vol@snap Orange@snap"
	snap_name="$snap_name apple-vol@snap apple@snap banana-vol@snap banana@snap"
	snap_name="$snap_name carrot-vol@snap carrot@snap"
	else
	snap_name="Apple@snap Banana@snap"
	snap_name="$snap_name Carrot@snap Orange@snap"
	snap_name="$snap_name apple@snap banana@snap"
	snap_name="$snap_name carrot@snap"
	fi

	fs_creation=$fs_name
	vol_creation=$vol_name
	if is_global_zone ; then
	snap_creation="Apple@snap Apple-vol@snap Banana@snap Banana-vol@snap"
	snap_creation="$snap_creation Carrot@snap Carrot-vol@snap Orange@snap Orange-vol@snap"
	snap_creation="$snap_creation apple@snap apple-vol@snap banana@snap banana-vol@snap"
	snap_creation="$snap_creation carrot@snap carrot-vol@snap"
	else
	snap_creation="Apple@snap Banana@snap"
	snap_creation="$snap_creation Carrot@snap Orange@snap"
	snap_creation="$snap_creation apple@snap banana@snap"
	snap_creation="$snap_creation carrot@snap"
	fi

	#
	-# datsets ordered by checksum options (note, Orange, Carrot & Banana have the
	+# datasets ordered by checksum options (note, Orange, Carrot & Banana have the
	# same checksum options, so ZFS should revert to sorting them alphabetically by
	# name)
	#
	fs_cksum="carrot apple banana Apple Banana Carrot Orange"
	vol_cksum="carrot-vol apple-vol banana-vol Apple-vol Banana-vol"
	vol_cksum="$vol_cksum Carrot-vol Orange-vol"
	snap_cksum=$snap_creation

	fs_rev_cksum="carrot apple banana Apple Orange Carrot Banana"
	vol_rev_cksum="carrot-vol apple-vol banana-vol Apple-vol Orange-vol"
	vol_rev_cksum="$vol_rev_cksum Carrot-vol Banana-vol"

	log_assert "The sort functionality in 'zfs list' works as expected."

	#
	# we must be in the C locale here, as running in other locales
	# will make zfs use that locale's sort order.
	#
	LC_ALL=C; export LC_ALL

	# sort by creation
	verify_sort \
	"zfs list -H -r -o name -s creation -t filesystem $TESTPOOL/$TESTFS" \
	"$fs_creation" "creation date"
	if is_global_zone ; then
	verify_sort \
	"zfs list -H -r -o name -s creation -t volume $TESTPOOL/$TESTFS" \
	"$vol_creation" "creation date"
	fi
	verify_sort \
	"zfs list -H -r -o name -s creation -t snapshot $TESTPOOL/$TESTFS" \
	"$snap_creation" "creation date"

	# sort by checksum
	verify_sort \
	"zfs list -H -r -o name -s checksum -t filesystem $TESTPOOL/$TESTFS" \
	"$fs_cksum" "checksum"
	if is_global_zone ; then
	verify_sort \
	"zfs list -H -r -o name -s checksum -t volume $TESTPOOL/$TESTFS" \
	"$vol_cksum" "checksum"
	fi
	verify_sort \
	"zfs list -H -r -o name -s checksum -t snapshot $TESTPOOL/$TESTFS" \
	"$snap_cksum" "checksum"
	verify_sort \
	"zfs list -H -r -o name -S checksum -t snapshot $TESTPOOL/$TESTFS" \
	"$snap_cksum" "checksum"

	# sort by name
	verify_sort \
	"zfs list -H -r -o name -s name -t filesystem $TESTPOOL/$TESTFS" \
	"$fs_name" "name"
	if is_global_zone ; then
	verify_sort \
	"zfs list -H -r -o name -s name -t volume $TESTPOOL/$TESTFS" \
	"$vol_name" "name"
	fi
	verify_sort \
	"zfs list -H -r -o name -s name -t snapshot $TESTPOOL/$TESTFS" \
	"$snap_name" "name"

	# reverse sort by creation
	verify_reverse_sort \
	"zfs list -H -r -o name -S creation -t filesystem $TESTPOOL/$TESTFS" \
	"$fs_creation" "creation date"
	if is_global_zone ; then
	verify_reverse_sort \
	"zfs list -H -r -o name -S creation -t volume $TESTPOOL/$TESTFS" \
	"$vol_creation" "creation date"
	fi
	verify_reverse_sort \
	"zfs list -H -r -o name -S creation -t snapshot $TESTPOOL/$TESTFS" \
	"$snap_creation" "creation date"

	# reverse sort by checksum
	verify_reverse_sort \
	"zfs list -H -r -o name -S checksum -t filesystem $TESTPOOL/$TESTFS" \
	"$fs_rev_cksum" "checksum"
	if is_global_zone ; then
	verify_reverse_sort \
	"zfs list -H -r -o name -S checksum -t volume $TESTPOOL/$TESTFS" \
	"$vol_rev_cksum" "checksum"
	fi

	# reverse sort by name
	verify_reverse_sort \
	"zfs list -H -r -o name -S name -t filesystem $TESTPOOL/$TESTFS"\
	"$fs_name" "name"
	if is_global_zone ; then
	verify_reverse_sort \
	"zfs list -H -r -o name -S name -t volume $TESTPOOL/$TESTFS"\
	"$vol_name" "name"
	fi
	verify_reverse_sort \
	"zfs list -H -r -o name -S name -t snapshot $TESTPOOL/$TESTFS"\
	"$snap_name" "name"

	log_pass "The sort functionality in 'zfs list' works as expected."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_user/zpool_iostat/zpool_iostat_-c_homedir.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_user/zpool_iostat/zpool_iostat_-c_homedir.ksh
	index 5cb50fde6fba..22450d89dfd2 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_user/zpool_iostat/zpool_iostat_-c_homedir.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_user/zpool_iostat/zpool_iostat_-c_homedir.ksh
	@@ -1,76 +1,76 @@
	#!/bin/ksh -p
	#
	# 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) 2017 by Lawrence Livermore National Security, LLC.
	#

	# DESCRIPTION:
	# Verify zpool iostat command mode (-c) works with scripts in user's
	# home directory.
	#
	# STRATEGY:
	# 1. Change HOME to /var/tmp
	-# 2. Make a simple script that echos a key value pair
	+# 2. Make a simple script that echoes a key value pair
	# in /var/tmp/.zpool.d
	# 3. Make sure it can be run with -c
	# 4. Remove the script we created

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/include/zpool_script.shlib

	verify_runnable "both"

	# In tree testing sets this variable, we need to unset it
	# to restore zpool's search path.
	unset ZPOOL_SCRIPTS_PATH

	# change HOME
	export HOME="$TEST_BASE_DIR"
	typeset USER_SCRIPT_FULL="$HOME/.zpool.d/userscript"

	function cleanup
	{
	log_must rm -rf "$HOME/.zpool.d"
	}

	log_assert "zpool iostat -c can run scripts from ~/.zpool.d"

	if [ -e "$USER_SCRIPT_FULL" ]; then
	log_fail "$USER_SCRIPT_FULL already exists."
	fi

	log_onexit cleanup

	# create simple script
	log_must mkdir -p "$HOME/.zpool.d"
	cat > "$USER_SCRIPT_FULL" << EOF
	#!/bin/sh
	echo "USRCOL=USRVAL"
	EOF
	log_must chmod +x "$USER_SCRIPT_FULL"

	# test that we can run the script
	typeset USER_SCRIPT=$(basename "$USER_SCRIPT_FULL")
	test_zpool_script "$USER_SCRIPT" "$TESTPOOL" "zpool iostat -P -c"

	log_pass "zpool iostat -c can run scripts from ~/.zpool.d passed"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_user/zpool_iostat/zpool_iostat_-c_searchpath.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_user/zpool_iostat/zpool_iostat_-c_searchpath.ksh
	index 1197ea2d1176..11f51350af56 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_user/zpool_iostat/zpool_iostat_-c_searchpath.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_user/zpool_iostat/zpool_iostat_-c_searchpath.ksh
	@@ -1,88 +1,88 @@
	#!/bin/ksh -p
	#
	# 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) 2017 by Lawrence Livermore National Security, LLC.
	#

	# DESCRIPTION:
	# Verify zpool iostat command mode (-c) works with ZPOOL_SCRIPTS_PATH
	# defined.
	#
	# STRATEGY:
	# 1. Set ZPOOL_SCRIPTS_PATH to contain a couple of non-default dirs
	-# 2. Make a simple script that echos a key value pair in each dir
	+# 2. Make a simple script that echoes a key value pair in each dir
	# 3. Make sure scripts can be run with -c
	# 4. Remove the scripts we created

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/include/zpool_script.shlib

	verify_runnable "both"

	typeset SCRIPT_1="$TEST_BASE_DIR/scripts1/test1"
	typeset SCRIPT_2="$TEST_BASE_DIR/scripts2/test2"

	function cleanup
	{
	log_must rm -rf $(dirname "$SCRIPT_1")
	log_must rm -rf $(dirname "$SCRIPT_2")
	}

	log_assert "zpool iostat -c can run scripts from custom search path"

	if [ -e "$SCRIPT_1" ]; then
	log_fail "$SCRIPT_1 already exists."
	fi

	if [ -e "$SCRIPT_2" ]; then
	log_fail "$SCRIPT_2 already exists."
	fi

	log_onexit cleanup

	# change zpool iostat search path
	export ZPOOL_SCRIPTS_PATH="$(dirname $SCRIPT_1):$(dirname $SCRIPT_2)"

	# create simple script in each dir
	log_must mkdir -p $(dirname "$SCRIPT_1")
	cat > "$SCRIPT_1" << EOF
	#!/bin/sh
	echo "USRCOL1=USRVAL1"
	EOF
	log_must chmod +x "$SCRIPT_1"

	log_must mkdir -p $(dirname "$SCRIPT_2")
	cat > "$SCRIPT_2" << EOF
	#!/bin/sh
	echo "USRCOL2=USRVAL2"
	EOF
	log_must chmod +x "$SCRIPT_2"

	# test that we can run the scripts
	typeset CMD_1=$(basename "$SCRIPT_1")
	typeset CMD_2=$(basename "$SCRIPT_2")
	test_zpool_script "$CMD_1" "$TESTPOOL" "zpool iostat -P -c"
	test_zpool_script "$CMD_2" "$TESTPOOL" "zpool iostat -P -c"
	test_zpool_script "$CMD_2,$CMD_1" "$TESTPOOL" "zpool iostat -P -c"

	log_pass "zpool iostat -c can run scripts from custom search path passed"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_user/zpool_status/zpool_status_-c_homedir.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_user/zpool_status/zpool_status_-c_homedir.ksh
	index 4cc3deb6dadf..5363043a8307 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_user/zpool_status/zpool_status_-c_homedir.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_user/zpool_status/zpool_status_-c_homedir.ksh
	@@ -1,76 +1,76 @@
	#!/bin/ksh -p
	#
	# 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) 2017 by Lawrence Livermore National Security, LLC.
	#

	# DESCRIPTION:
	# Verify zpool status command mode (-c) works with scripts in user's
	# home directory.
	#
	# STRATEGY:
	# 1. Change HOME to /var/tmp
	-# 2. Make a simple script that echos a key value pair
	+# 2. Make a simple script that echoes a key value pair
	# in /var/tmp/.zpool.d
	# 3. Make sure it can be run with -c
	# 4. Remove the script we created

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/include/zpool_script.shlib

	verify_runnable "both"

	# In tree testing sets this variable, we need to unset it
	# to restore zpool's search path.
	unset ZPOOL_SCRIPTS_PATH

	# change HOME
	export HOME="$TEST_BASE_DIR"
	typeset USER_SCRIPT_FULL="$HOME/.zpool.d/userscript"

	function cleanup
	{
	log_must rm -rf "$HOME/.zpool.d"
	}

	log_assert "zpool status -c can run scripts from ~/.zpool.d"

	if [ -e "$USER_SCRIPT_FULL" ]; then
	log_fail "$USER_SCRIPT_FULL already exists."
	fi

	log_onexit cleanup

	# create simple script
	log_must mkdir -p "$HOME/.zpool.d"
	cat > "$USER_SCRIPT_FULL" << EOF
	#!/bin/sh
	echo "USRCOL=USRVAL"
	EOF
	log_must chmod +x "$USER_SCRIPT_FULL"

	# test that we can run the script
	typeset USER_SCRIPT=$(basename "$USER_SCRIPT_FULL")
	test_zpool_script "$USER_SCRIPT" "$TESTPOOL" "zpool status -P -c"

	log_pass "zpool status -c can run scripts from ~/.zpool.d passed"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_user/zpool_status/zpool_status_-c_searchpath.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_user/zpool_status/zpool_status_-c_searchpath.ksh
	index a075b9a0c181..3f64fdf1a708 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_user/zpool_status/zpool_status_-c_searchpath.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/cli_user/zpool_status/zpool_status_-c_searchpath.ksh
	@@ -1,88 +1,88 @@
	#!/bin/ksh -p
	#
	# 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) 2017 by Lawrence Livermore National Security, LLC.
	#

	# DESCRIPTION:
	# Verify zpool status command mode (-c) works with ZPOOL_SCRIPTS_PATH
	# defined.
	#
	# STRATEGY:
	# 1. Set ZPOOL_SCRIPTS_PATH to contain a couple of non-default dirs
	-# 2. Make a simple script that echos a key value pair in each dir
	+# 2. Make a simple script that echoes a key value pair in each dir
	# 3. Make sure scripts can be run with -c
	# 4. Remove the scripts we created

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/include/zpool_script.shlib

	verify_runnable "both"

	typeset SCRIPT_1="$TEST_BASE_DIR/scripts1/test1"
	typeset SCRIPT_2="$TEST_BASE_DIR/scripts2/test2"

	function cleanup
	{
	log_must rm -rf $(dirname "$SCRIPT_1")
	log_must rm -rf $(dirname "$SCRIPT_2")
	}

	log_assert "zpool status -c can run scripts from custom search path"

	if [ -e "$SCRIPT_1" ]; then
	log_fail "$SCRIPT_1 already exists."
	fi

	if [ -e "$SCRIPT_2" ]; then
	log_fail "$SCRIPT_2 already exists."
	fi

	log_onexit cleanup

	# change zpool status search path
	export ZPOOL_SCRIPTS_PATH="$(dirname $SCRIPT_1):$(dirname $SCRIPT_2)"

	# create simple script in each dir
	log_must mkdir -p $(dirname "$SCRIPT_1")
	cat > "$SCRIPT_1" << EOF
	#!/bin/sh
	echo "USRCOL1=USRVAL1"
	EOF
	log_must chmod +x "$SCRIPT_1"

	log_must mkdir -p $(dirname "$SCRIPT_2")
	cat > "$SCRIPT_2" << EOF
	#!/bin/sh
	echo "USRCOL2=USRVAL2"
	EOF
	log_must chmod +x "$SCRIPT_2"

	# test that we can run the scripts
	typeset CMD_1=$(basename "$SCRIPT_1")
	typeset CMD_2=$(basename "$SCRIPT_2")
	test_zpool_script "$CMD_1" "$TESTPOOL" "zpool status -P -c"
	test_zpool_script "$CMD_2" "$TESTPOOL" "zpool status -P -c"
	test_zpool_script "$CMD_2,$CMD_1" "$TESTPOOL" "zpool status -P -c"

	log_pass "zpool status -c can run scripts from custom search path passed"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/deadman/Makefile.am b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/deadman/Makefile.am
	index 7b70ca09df56..097f23e88404 100644
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/deadman/Makefile.am
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/deadman/Makefile.am
	@@ -1,7 +1,8 @@
	pkgdatadir = $(datadir)/@PACKAGE@/zfs-tests/tests/functional/deadman
	dist_pkgdata_SCRIPTS = \
	+ deadman_ratelimit.ksh \
	deadman_sync.ksh \
	deadman_zio.ksh

	dist_pkgdata_DATA = \
	deadman.cfg
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/deadman/deadman_ratelimit.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/deadman/deadman_ratelimit.ksh
	new file mode 100755
	index 000000000000..469117a56cc0
	--- /dev/null
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/deadman/deadman_ratelimit.ksh
	@@ -0,0 +1,78 @@
	+#!/bin/ksh -p
	+#
	+# 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
	+#
	+
	+#
	+# Portions Copyright 2021 iXsystems, Inc.
	+#
	+
	+# DESCRIPTION:
	+# Verify spa deadman events are rate limited
	+#
	+# STRATEGY:
	+# 1. Reduce the zfs_slow_io_events_per_second to 1.
	+# 2. Reduce the zfs_deadman_ziotime_ms to 1ms.
	+# 3. Write data to a pool and read it back.
	+# 4. Verify deadman events have been produced at a reasonable rate.
	+#
	+
	+. $STF_SUITE/include/libtest.shlib
	+. $STF_SUITE/tests/functional/deadman/deadman.cfg
	+
	+verify_runnable "both"
	+
	+function cleanup
	+{
	+ zinject -c all
	+ default_cleanup_noexit
	+
	+ set_tunable64 SLOW_IO_EVENTS_PER_SECOND $OLD_SLOW_IO_EVENTS
	+ set_tunable64 DEADMAN_ZIOTIME_MS $ZIOTIME_DEFAULT
	+}
	+
	+log_assert "Verify spa deadman events are rate limited"
	+log_onexit cleanup
	+
	+OLD_SLOW_IO_EVENTS=$(get_tunable SLOW_IO_EVENTS_PER_SECOND)
	+log_must set_tunable64 SLOW_IO_EVENTS_PER_SECOND 1
	+log_must set_tunable64 DEADMAN_ZIOTIME_MS 1
	+
	+# Create a new pool in order to use the updated deadman settings.
	+default_setup_noexit $DISK1
	+log_must zpool events -c
	+
	+mntpnt=$(get_prop mountpoint $TESTPOOL/$TESTFS)
	+log_must file_write -b 1048576 -c 8 -o create -d 0 -f $mntpnt/file
	+log_must zpool export $TESTPOOL
	+log_must zpool import $TESTPOOL
	+log_must zinject -d $DISK1 -D 5:1 $TESTPOOL
	+log_must dd if=$mntpnt/file of=$TEST_BASE_DIR/devnull oflag=sync
	+
	+events=$(zpool events $TESTPOOL \| grep -c ereport.fs.zfs.deadman)
	+log_note "events=$events"
	+if [ "$events" -lt 1 ]; then
	+ log_fail "Expect >= 1 deadman events, $events found"
	+fi
	+if [ "$events" -gt 10 ]; then
	+ log_fail "Expect <= 10 deadman events, $events found"
	+fi
	+
	+log_pass "Verify spa deadman events are rate limited"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/deadman/deadman_sync.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/deadman/deadman_sync.ksh
	index 5d803af85bed..b0b03f5d523e 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/deadman/deadman_sync.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/deadman/deadman_sync.ksh
	@@ -1,86 +1,90 @@
	#!/bin/ksh -p
	#
	# 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) 2017 by Lawrence Livermore National Security, LLC.
	# Use is subject to license terms.
	#

	# DESCRIPTION:
	# Verify spa deadman detects a hung txg
	#
	# STRATEGY:
	# 1. Reduce the zfs_deadman_synctime_ms to 5s.
	# 2. Reduce the zfs_deadman_checktime_ms to 1s.
	# 3. Inject a 10s zio delay to force long IOs.
	# 4. Write enough data to force a long txg sync time due to the delay.
	# 5. Verify a "deadman" event is posted.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/deadman/deadman.cfg

	verify_runnable "both"

	function cleanup
	{
	log_must zinject -c all
	default_cleanup_noexit

	log_must set_tunable64 DEADMAN_SYNCTIME_MS $SYNCTIME_DEFAULT
	log_must set_tunable64 DEADMAN_CHECKTIME_MS $CHECKTIME_DEFAULT
	log_must set_tunable64 DEADMAN_FAILMODE $FAILMODE_DEFAULT
	}

	log_assert "Verify spa deadman detects a hung txg"
	log_onexit cleanup

	log_must set_tunable64 DEADMAN_SYNCTIME_MS 5000
	log_must set_tunable64 DEADMAN_CHECKTIME_MS 1000
	log_must set_tunable64 DEADMAN_FAILMODE "wait"

	# Create a new pool in order to use the updated deadman settings.
	default_setup_noexit $DISK1
	log_must zpool events -c

	# Force each IO to take 10s by allow them to run concurrently.
	log_must zinject -d $DISK1 -D10000:10 $TESTPOOL

	mntpnt=$(get_prop mountpoint $TESTPOOL/$TESTFS)
	log_must file_write -b 1048576 -c 8 -o create -d 0 -f $mntpnt/file
	sleep 10

	log_must zinject -c all
	log_must zpool sync

	# Log txg sync times for reference and the zpool event summary.
	-log_must cat /proc/spl/kstat/zfs/$TESTPOOL/txgs
	+if is_freebsd; then
	+ log_must sysctl -n kstat.zfs.$TESTPOOL.txgs
	+else
	+ log_must cat /proc/spl/kstat/zfs/$TESTPOOL/txgs
	+fi
	log_must zpool events

	# Verify at least 5 deadman events were logged. The first after 5 seconds,
	# and another each second thereafter until the delay is clearer.
	events=$(zpool events \| grep -c ereport.fs.zfs.deadman)
	if [ "$events" -lt 5 ]; then
	log_fail "Expect >=5 deadman events, $events found"
	fi

	log_pass "Verify spa deadman detected a hung txg and $events deadman events"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/events/.gitignore b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/events/.gitignore
	new file mode 100644
	index 000000000000..ed5af03a1095
	--- /dev/null
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/events/.gitignore
	@@ -0,0 +1 @@
	+/zed_fd_spill-zedlet
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/events/Makefile.am b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/events/Makefile.am
	index e1fe490812b3..92ce5dbc3825 100644
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/events/Makefile.am
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/events/Makefile.am
	@@ -1,11 +1,18 @@
	+include $(top_srcdir)/config/Rules.am
	+
	pkgdatadir = $(datadir)/@PACKAGE@/zfs-tests/tests/functional/events
	dist_pkgdata_SCRIPTS = \
	setup.ksh \
	cleanup.ksh \
	events_001_pos.ksh \
	events_002_pos.ksh \
	- zed_rc_filter.ksh
	+ zed_rc_filter.ksh \
	+ zed_fd_spill.ksh

	dist_pkgdata_DATA = \
	events.cfg \
	events_common.kshlib
	+
	+pkgexecdir = $(pkgdatadir)
	+pkgexec_PROGRAMS = zed_fd_spill-zedlet
	+zed_fd_spill_zedlet_SOURCES = zed_fd_spill-zedlet.c
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/events/cleanup.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/events/cleanup.ksh
	index 4905342b713b..699bc2823343 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/events/cleanup.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/events/cleanup.ksh
	@@ -1,31 +1,31 @@
	#!/bin/ksh -p
	#
	# 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) 2017 by Lawrence Livermore National Security, LLC.
	#

	. $STF_SUITE/include/libtest.shlib

	-zed_cleanup all-debug.sh all-syslog.sh
	+zed_cleanup all-debug.sh all-syslog.sh all-dumpfds

	default_cleanup
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/events/events_002_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/events/events_002_pos.ksh
	index 586eaa9e1fd8..af2be33dbc73 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/events/events_002_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/events/events_002_pos.ksh
	@@ -1,102 +1,102 @@
	#!/bin/ksh -p
	#
	# 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) 2017 by Lawrence Livermore National Security, LLC.
	# Use is subject to license terms.
	#

	# DESCRIPTION:
	# Verify ZED handles missed events from a pool when starting.
	#
	# STRATEGY:
	# 1. Clear the events and create a pool to generate some events.
	# 2. Start the ZED and verify it handles missed events.
	# 3. Stop the ZED
	# 4. Generate additional events.
	# 5. Start the ZED and verify it only handles the new missed events.

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/events/events_common.kshlib

	verify_runnable "both"

	function cleanup
	{
	if poolexists $MPOOL; then
	destroy_pool $MPOOL
	fi

	for file in $VDEV1 $VDEV2; do
	[[ -f $file ]] && rm -f $file
	done

	- log_must rm -f $TMP_EVENTS_ZED $TMP_EVENTS_ZED
	+ log_must rm -f $TMP_EVENTS_ZED
	log_must zed_stop
	}

	-log_assert "Verify ZED handles missed events on when starting"
	+log_assert "Verify ZED handles missed events when starting"
	log_onexit cleanup

	log_must truncate -s $MINVDEVSIZE $VDEV1 $VDEV2

	# 1. Create a pool and generate some events.
	log_must truncate -s 0 $ZED_DEBUG_LOG
	log_must zpool events -c
	log_must zpool create $MPOOL mirror $VDEV1 $VDEV2

	# 2. Start the ZED and verify it handles missed events.
	log_must zed_start
	log_must file_wait_event $ZED_DEBUG_LOG 'sysevent\.fs\.zfs\.config_sync' 150
	log_must cp $ZED_DEBUG_LOG $TMP_EVENTS_ZED

	awk -v event="sysevent.fs.zfs.pool_create" \
	'BEGIN{FS="\n"; RS=""} $0 ~ event { print $0 }' \
	$TMP_EVENTS_ZED >$TMP_EVENT_ZED
	log_must grep -q "^ZEVENT_POOL=$MPOOL" $TMP_EVENT_ZED

	# 3. Stop the ZED
	zed_stop
	log_must truncate -s 0 $ZED_DEBUG_LOG

	# 4. Generate additional events.
	log_must zpool offline $MPOOL $VDEV1
	log_must zpool online $MPOOL $VDEV1
	log_must zpool wait -t resilver $MPOOL

	log_must zpool scrub $MPOOL

	# Wait for the scrub to wrap, or is_healthy will be wrong.
	while ! is_pool_scrubbed $MPOOL; do
	sleep 1
	done

	# 5. Start the ZED and verify it only handled the new missed events.
	log_must zed_start
	log_must file_wait_event $ZED_DEBUG_LOG 'sysevent\.fs\.zfs\.resilver_finish' 150
	log_must cp $ZED_DEBUG_LOG $TMP_EVENTS_ZED

	log_mustnot file_wait_event $ZED_DEBUG_LOG 'sysevent\.fs\.zfs\.pool_create' 30
	log_must grep -q "sysevent.fs.zfs.vdev_online" $TMP_EVENTS_ZED
	log_must grep -q "sysevent.fs.zfs.resilver_start" $TMP_EVENTS_ZED

	log_pass "Verify ZED handles missed events on when starting"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/events/zed_fd_spill-zedlet.c b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/events/zed_fd_spill-zedlet.c
	new file mode 100644
	index 000000000000..c072f906d23e
	--- /dev/null
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/events/zed_fd_spill-zedlet.c
	@@ -0,0 +1,36 @@
	+/*
	+ * Permission to use, copy, modify, and/or distribute this software for
	+ * any purpose with or without fee is hereby granted.
	+ *
	+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
	+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
	+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
	+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
	+ * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
	+ * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	+ */
	+
	+#include <sys/types.h>
	+#include <sys/wait.h>
	+#include <fcntl.h>
	+#include <unistd.h>
	+#include <stdlib.h>
	+#include <string.h>
	+#include <stdio.h>
	+
	+int main(void) {
	+ if (fork()) {
	+ int err;
	+ wait(&err);
	+ return (err);
	+ }
	+
	+ char buf[64];
	+ sprintf(buf, "/tmp/zts-zed_fd_spill-logdir/%d", getppid());
	+ dup2(creat(buf, 0644), STDOUT_FILENO);
	+
	+ snprintf(buf, sizeof (buf), "/proc/%d/fd", getppid());
	+ execlp("ls", "ls", buf, NULL);
	+ _exit(127);
	+}
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/events/zed_fd_spill.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/events/zed_fd_spill.ksh
	new file mode 100755
	index 000000000000..8736a7fdf7e6
	--- /dev/null
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/events/zed_fd_spill.ksh
	@@ -0,0 +1,77 @@
	+#!/bin/ksh -p
	+#
	+# 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
	+#
	+
	+# DESCRIPTION:
	+# Verify ZEDLETs only inherit the fds specified in the manpage
	+#
	+# STRATEGY:
	+# 1. Inject a ZEDLET that dumps the fds it gets to a file.
	+# 2. Generate some events.
	+# 3. Read back the generated files and assert that there is no fd past 3,
	+# and there are exactly 4 fds.
	+
	+. $STF_SUITE/include/libtest.shlib
	+. $STF_SUITE/tests/functional/events/events_common.kshlib
	+
	+verify_runnable "both"
	+
	+function cleanup
	+{
	+ log_must rm -rf "$logdir"
	+ log_must rm "/tmp/zts-zed_fd_spill-logdir"
	+ log_must zed_stop
	+}
	+
	+log_assert "Verify ZEDLETs inherit only the fds specified"
	+log_onexit cleanup
	+
	+logdir="$(mktemp -d)"
	+log_must ln -s "$logdir" /tmp/zts-zed_fd_spill-logdir
	+
	+self="$(readlink -f "$0")"
	+log_must ln -s "${self%/*}/zed_fd_spill-zedlet" "${ZEDLET_DIR}/all-dumpfds"
	+
	+log_must zpool events -c
	+log_must zed_stop
	+log_must zed_start
	+
	+log_must truncate -s 0 $ZED_DEBUG_LOG
	+log_must zpool scrub $TESTPOOL
	+log_must zfs set compression=off $TESTPOOL/$TESTFS
	+log_must wait_scrubbed $TESTPOOL
	+log_must file_wait $ZED_DEBUG_LOG 3
	+
	+if [ -n "$(find "$logdir" -maxdepth 0 -empty)" ]; then
	+ log_fail "Our ZEDLET didn't run!"
	+fi
	+log_must awk '
	+ !/^[0123]$/ {
	+ print FILENAME ": " $0
	+ err=1
	+ }
	+ END {
	+ exit err
	+ }
	+' "$logdir"/*
	+wc -l "$logdir"/* \| log_must awk '$1 != "4" && $2 != "total" {print; exit 1}'
	+
	+log_pass "ZED doesn't leak fds to ZEDLETs"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/events/zed_rc_filter.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/events/zed_rc_filter.ksh
	index 44652ee4cf12..0bef0ef1f96b 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/events/zed_rc_filter.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/events/zed_rc_filter.ksh
	@@ -1,104 +1,105 @@
	#!/bin/ksh -p
	#
	# 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) 2018 by Lawrence Livermore National Security, LLC.
	# Use is subject to license terms.
	#

	# DESCRIPTION:
	# Verify zed.rc ZED_SYSLOG_SUBCLASS_INCLUDE/EXCLUDE event filtering works.
	#
	# STRATEGY:
	# 1. Execute zpool sub-commands on a pool.
	# 2. Test different combinations of ZED_SYSLOG_SUBCLASS_INCLUDE filtering.
	# 3. Execute zpool sub-commands on a pool.
	# 4. Test different combinations of ZED_SYSLOG_SUBCLASS_EXCLUDE filtering.

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/events/events_common.kshlib

	verify_runnable "both"

	function cleanup
	{
	log_must zed_stop
	zed_rc_restore $zedrc_backup
	}

	log_assert "Verify zpool sub-commands generate expected events"
	log_onexit cleanup

	log_must zpool events -c
	+log_must zed_stop
	log_must zed_start

	# Backup our zed.rc
	zedrc_backup=$(zed_rc_backup)

	log_note "Include a single event type"
	zed_rc_set ZED_SYSLOG_SUBCLASS_INCLUDE history_event
	run_and_verify -p "$TESTPOOL" -e "sysevent.fs.zfs.history_event" \
	"zfs set compression=off $TESTPOOL/$TESTFS"

	log_note "Include a single event type with wildcards"
	zed_rc_set ZED_SYSLOG_SUBCLASS_INCLUDE 'history_event'
	run_and_verify -p "$TESTPOOL" -e "sysevent.fs.zfs.history_event" \
	"zfs set compression=off $TESTPOOL/$TESTFS"

	log_note "Test a filter of a non-match and a match"
	zed_rc_set ZED_SYSLOG_SUBCLASS_INCLUDE 'foobar\|history_event'
	run_and_verify -p "$TESTPOOL" -e "sysevent.fs.zfs.history_event" \
	"zfs set compression=off $TESTPOOL/$TESTFS"

	log_note "Include multiple events"
	zed_rc_set ZED_SYSLOG_SUBCLASS_INCLUDE 'scrub_start\|scrub_finish'
	run_and_verify -p "$TESTPOOL" -e "sysevent.fs.zfs.scrub_start" \
	-e "sysevent.fs.zfs.scrub_finish" \
	"zpool scrub $TESTPOOL && wait_scrubbed $TESTPOOL"

	# We can't use run_and_verify() for exclusions, so run the rest of the tests
	# manually.
	log_note "Test one exclusion"
	zed_rc_set ZED_SYSLOG_SUBCLASS_EXCLUDE 'history_event'
	truncate -s 0 $ZED_DEBUG_LOG
	log_must zfs set compression=off $TESTPOOL/$TESTFS
	log_must file_wait $ZED_DEBUG_LOG 3
	log_mustnot grep -q history_event $ZED_DEBUG_LOG

	log_note "Test one exclusion with wildcards"
	zed_rc_set ZED_SYSLOG_SUBCLASS_EXCLUDE 'history_event'
	truncate -s 0 $ZED_DEBUG_LOG
	log_must zfs set compression=off $TESTPOOL/$TESTFS
	log_must file_wait $ZED_DEBUG_LOG 3
	log_mustnot grep -q history_event $ZED_DEBUG_LOG

	log_note "Test one inclusion and one exclusion"
	zed_rc_set ZED_SYSLOG_SUBCLASS_INCLUDE 'scrub_start'
	zed_rc_set ZED_SYSLOG_SUBCLASS_EXCLUDE 'scrub_finish'
	truncate -s 0 $ZED_DEBUG_LOG
	zpool scrub $TESTPOOL
	wait_scrubbed $TESTPOOL
	log_must file_wait $ZED_DEBUG_LOG 3
	log_must grep -q scrub_start $ZED_DEBUG_LOG
	log_mustnot grep -q scrub_finish $ZED_DEBUG_LOG

	log_pass "zed.rc event filtering works correctly."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/fault/auto_offline_001_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/fault/auto_offline_001_pos.ksh
	index 0abe1e2ce599..86916bf906fe 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/fault/auto_offline_001_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/fault/auto_offline_001_pos.ksh
	@@ -1,191 +1,191 @@
	#!/bin/ksh -p
	#
	# CDDL HEADER START
	#
	# This file and its contents are supplied under the terms of the
	# Common Development and Distribution License ("CDDL"), version 1.0.
	# You may only use this file in accordance with the terms of version
	# 1.0 of the CDDL.
	#
	# A full copy of the text of the CDDL should have accompanied this
	# source. A copy of the CDDL is also available via the Internet at
	# http://www.illumos.org/license/CDDL.
	#
	# CDDL HEADER END
	#

	#
	# Copyright 2018, loli10K <ezomori.nozomu@gmail.com>. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/events/events_common.kshlib
	. $STF_SUITE/tests/functional/fault/fault.cfg

	#
	# DESCRIPTION:
	# Testing Fault Management Agent ZED Logic - Physically removed device is
	# made unavail and onlined when reattached
	#
	# STRATEGY:
	# 1. Create a pool
	# 2. Simulate physical removal of one device
	-# 3. Verify the device is unvailable
	+# 3. Verify the device is unavailable
	# 4. Reattach the device
	# 5. Verify the device is onlined
	# 6. Repeat the same tests with a spare device:
	# zed will use the spare to handle the removed data device
	# 7. Repeat the same tests again with a faulted spare device:
	# the removed data device should be unavailable
	#
	# NOTE: the use of 'block_device_wait' throughout the test helps avoid race
	# conditions caused by mixing creation/removal events from partitioning the
	# disk (zpool create) and events from physically removing it (remove_disk).
	#
	# NOTE: the test relies on 'zpool sync' to prompt the kmods to transition a
	# vdev to the unavailable state. The ZED does receive a removal notification
	# but only relies on it to activate a hot spare. Additional work is planned
	# to extend an existing ioctl interface to allow the ZED to transition the
	# vdev in to a removed state.
	#
	verify_runnable "both"

	if is_linux; then
	# Add one 512b scsi_debug device (4Kn would generate IO errors)
	# NOTE: must be larger than other "file" vdevs and minimum SPA devsize:
	# add 32m of fudge
	load_scsi_debug $(($MINVDEVSIZE/1024/1024+32)) 1 1 1 '512b'
	else
	log_unsupported "scsi debug module unsupported"
	fi

	function cleanup
	{
	destroy_pool $TESTPOOL
	rm -f $filedev1
	rm -f $filedev2
	rm -f $filedev3
	rm -f $sparedev
	unload_scsi_debug
	}

	log_assert "ZED detects physically removed devices"

	log_onexit cleanup

	filedev1="$TEST_BASE_DIR/file-vdev-1"
	filedev2="$TEST_BASE_DIR/file-vdev-2"
	filedev3="$TEST_BASE_DIR/file-vdev-3"
	sparedev="$TEST_BASE_DIR/file-vdev-spare"
	removedev=$(get_debug_device)

	typeset poolconfs=(
	"mirror $filedev1 $removedev"
	"raidz3 $filedev1 $filedev2 $filedev3 $removedev"
	"mirror $filedev1 $filedev2 special mirror $filedev3 $removedev"
	)

	log_must truncate -s $MINVDEVSIZE $filedev1
	log_must truncate -s $MINVDEVSIZE $filedev2
	log_must truncate -s $MINVDEVSIZE $filedev3
	log_must truncate -s $MINVDEVSIZE $sparedev

	for conf in "${poolconfs[@]}"
	do
	# 1. Create a pool
	log_must zpool create -f $TESTPOOL $conf
	block_device_wait ${DEV_DSKDIR}/${removedev}

	mntpnt=$(get_prop mountpoint /$TESTPOOL) \|\|
	log_fail "get_prop mountpoint /$TESTPOOL"

	# 2. Simulate physical removal of one device
	remove_disk $removedev
	log_must mkfile 1m $mntpnt/file
	log_must zpool sync $TESTPOOL

	- # 3. Verify the device is unvailable.
	+ # 3. Verify the device is unavailable.
	log_must wait_vdev_state $TESTPOOL $removedev "UNAVAIL"

	# 4. Reattach the device
	insert_disk $removedev

	# 5. Verify the device is onlined
	log_must wait_vdev_state $TESTPOOL $removedev "ONLINE"

	# cleanup
	destroy_pool $TESTPOOL
	log_must parted "${DEV_DSKDIR}/${removedev}" -s -- mklabel msdos
	block_device_wait ${DEV_DSKDIR}/${removedev}
	done

	# 6. Repeat the same tests with a spare device: zed will use the spare to handle
	# the removed data device
	for conf in "${poolconfs[@]}"
	do
	# 1. Create a pool with a spare
	log_must zpool create -f $TESTPOOL $conf
	block_device_wait ${DEV_DSKDIR}/${removedev}
	log_must zpool add $TESTPOOL spare $sparedev

	mntpnt=$(get_prop mountpoint /$TESTPOOL) \|\|
	log_fail "get_prop mountpoint /$TESTPOOL"

	# 2. Simulate physical removal of one device
	remove_disk $removedev
	log_must mkfile 1m $mntpnt/file
	log_must zpool sync $TESTPOOL

	# 3. Verify the device is handled by the spare.
	log_must wait_hotspare_state $TESTPOOL $sparedev "INUSE"
	log_must wait_vdev_state $TESTPOOL $removedev "UNAVAIL"

	# 4. Reattach the device
	insert_disk $removedev

	# 5. Verify the device is onlined
	log_must wait_vdev_state $TESTPOOL $removedev "ONLINE"

	# cleanup
	destroy_pool $TESTPOOL
	log_must parted "${DEV_DSKDIR}/${removedev}" -s -- mklabel msdos
	block_device_wait ${DEV_DSKDIR}/${removedev}
	done

	# 7. Repeat the same tests again with a faulted spare device: zed should offline
	# the removed data device if no spare is available
	for conf in "${poolconfs[@]}"
	do
	# 1. Create a pool with a spare
	log_must zpool create -f $TESTPOOL $conf
	block_device_wait ${DEV_DSKDIR}/${removedev}
	log_must zpool add $TESTPOOL spare $sparedev

	mntpnt=$(get_prop mountpoint /$TESTPOOL) \|\|
	log_fail "get_prop mountpoint /$TESTPOOL"

	# 2. Fault the spare device making it unavailable
	log_must zpool offline -f $TESTPOOL $sparedev
	log_must wait_hotspare_state $TESTPOOL $sparedev "FAULTED"

	# 3. Simulate physical removal of one device
	remove_disk $removedev
	log_must mkfile 1m $mntpnt/file
	log_must zpool sync $TESTPOOL

	# 4. Verify the device is unavailable
	log_must wait_vdev_state $TESTPOOL $removedev "UNAVAIL"

	# 5. Reattach the device
	insert_disk $removedev

	# 6. Verify the device is onlined
	log_must wait_vdev_state $TESTPOOL $removedev "ONLINE"

	# cleanup
	destroy_pool $TESTPOOL
	log_must parted "${DEV_DSKDIR}/${removedev}" -s -- mklabel msdos
	block_device_wait ${DEV_DSKDIR}/${removedev}
	done

	log_pass "ZED detects physically removed devices"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/pool_checkpoint/checkpoint_big_rewind.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/pool_checkpoint/checkpoint_big_rewind.ksh
	index f915d2ad418c..7e523ef90873 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/pool_checkpoint/checkpoint_big_rewind.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/pool_checkpoint/checkpoint_big_rewind.ksh
	@@ -1,57 +1,58 @@
	#!/bin/ksh -p

	#
	# This file and its contents are supplied under the terms of the
	# Common Development and Distribution License ("CDDL"), version 1.0.
	# You may only use this file in accordance with the terms of version
	# 1.0 of the CDDL.
	#
	# A full copy of the text of the CDDL should have accompanied this
	# source. A copy of the CDDL is also available via the Internet at
	# http://www.illumos.org/license/CDDL.
	#

	#
	# Copyright (c) 2017, 2018 by Delphix. All rights reserved.
	#

	. $STF_SUITE/tests/functional/pool_checkpoint/pool_checkpoint.kshlib

	#
	# DESCRIPTION:
	# Rewind to checkpoint on a stressed pool. We basically try to
	# fragment the pool before and after taking a checkpoint and
	# see if zdb finds any checksum or other errors that imply that
	# blocks from the checkpoint have been reused.
	#
	# STRATEGY:
	# 1. Import pool that's slightly fragmented
	# 2. Take checkpoint
	# 3. Apply a destructive action and do more random writes
	# 4. Run zdb on both current and checkpointed data and make
	# sure that zdb returns with no errors
	# 5. Rewind to checkpoint
	# 6. Run zdb again
	#

	verify_runnable "global"

	setup_nested_pool_state
	log_onexit cleanup_nested_pools

	log_must zpool checkpoint $NESTEDPOOL

	#
	# Destroy one dataset, modify an existing one and create a
	# a new one. Do more random writes in an attempt to raise
	# more fragmentation. Then verify both current and checkpointed
	# states.
	#
	fragment_after_checkpoint_and_verify

	log_must zpool export $NESTEDPOOL
	log_must zpool import -d $FILEDISKDIR --rewind-to-checkpoint $NESTEDPOOL

	-log_must zdb $NESTEDPOOL
	+log_must zpool export $NESTEDPOOL
	+log_must zdb -e -p $FILEDISKDIR $NESTEDPOOL

	log_pass "Rewind to checkpoint on a stressed pool."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/pool_checkpoint/checkpoint_capacity.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/pool_checkpoint/checkpoint_capacity.ksh
	index 15afc4adf4bc..b6d34307b3f2 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/pool_checkpoint/checkpoint_capacity.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/pool_checkpoint/checkpoint_capacity.ksh
	@@ -1,92 +1,93 @@
	#!/bin/ksh -p

	#
	# This file and its contents are supplied under the terms of the
	# Common Development and Distribution License ("CDDL"), version 1.0.
	# You may only use this file in accordance with the terms of version
	# 1.0 of the CDDL.
	#
	# A full copy of the text of the CDDL should have accompanied this
	# source. A copy of the CDDL is also available via the Internet at
	# http://www.illumos.org/license/CDDL.
	#

	#
	# Copyright (c) 2017 by Delphix. All rights reserved.
	#

	. $STF_SUITE/tests/functional/pool_checkpoint/pool_checkpoint.kshlib

	#
	# DESCRIPTION:
	# Ensure that we don't reuse checkpointed blocks when the
	# pool hits ENOSPC errors because of the slop space limit.
	# This test also ensures that the DSL layer correctly takes
	# into account the space used by the checkpoint when deciding
	# whether to allow operations based on the reserved slop
	# space.
	#
	# STRATEGY:
	# 1. Create pool with one disk of 1G size
	# 2. Create a file with random data of 700M in size.
	# leaving ~200M left in pool capacity.
	# 3. Checkpoint the pool
	# 4. Remove the file. All of its blocks should stay around
	# in ZFS as they are part of the checkpoint.
	# 5. Create a new empty file and attempt to write ~300M
	# of data to it. This should fail, as the reserved
	# SLOP space for the pool should be ~128M, and we should
	# be hitting that limit getting ENOSPC.
	# 6. Use zdb to traverse and checksum all the checkpointed
	# data to ensure its integrity.
	# 7. Export the pool and rewind to ensure that everything
	# is actually there as expected.
	#

	function test_cleanup
	{
	poolexists $NESTEDPOOL && destroy_pool $NESTEDPOOL
	set_tunable32 SPA_ASIZE_INFLATION 24
	cleanup_test_pool
	}

	verify_runnable "global"

	setup_test_pool
	log_onexit test_cleanup
	log_must set_tunable32 SPA_ASIZE_INFLATION 4

	log_must zfs create $DISKFS

	log_must mkfile $FILEDISKSIZE $FILEDISK1
	log_must zpool create $NESTEDPOOL $FILEDISK1

	log_must zfs create -o compression=lz4 -o recordsize=8k $NESTEDFS0
	log_must dd if=/dev/urandom of=$NESTEDFS0FILE bs=1M count=700
	FILE0INTRO=$(head -c 100 $NESTEDFS0FILE)

	log_must zpool checkpoint $NESTEDPOOL
	log_must rm $NESTEDFS0FILE

	#
	# only for debugging purposes
	#
	log_must zpool list $NESTEDPOOL

	log_mustnot dd if=/dev/urandom of=$NESTEDFS0FILE bs=1M count=300

	#
	# only for debugging purposes
	#
	log_must zpool list $NESTEDPOOL

	-log_must zdb -kc $NESTEDPOOL
	-
	log_must zpool export $NESTEDPOOL
	+log_must zdb -e -p $FILEDISKDIR -kc $NESTEDPOOL
	+
	log_must zpool import -d $FILEDISKDIR --rewind-to-checkpoint $NESTEDPOOL

	log_must [ "$(head -c 100 $NESTEDFS0FILE)" = "$FILE0INTRO" ]

	-log_must zdb $NESTEDPOOL
	+log_must zpool export $NESTEDPOOL
	+log_must zdb -e -p $FILEDISKDIR $NESTEDPOOL

	log_pass "Do not reuse checkpointed space at low capacity."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/pool_checkpoint/checkpoint_discard_busy.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/pool_checkpoint/checkpoint_discard_busy.ksh
	index ae099ff270f1..f970935f5bd0 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/pool_checkpoint/checkpoint_discard_busy.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/pool_checkpoint/checkpoint_discard_busy.ksh
	@@ -1,110 +1,111 @@
	#!/bin/ksh -p

	#
	# This file and its contents are supplied under the terms of the
	# Common Development and Distribution License ("CDDL"), version 1.0.
	# You may only use this file in accordance with the terms of version
	# 1.0 of the CDDL.
	#
	# A full copy of the text of the CDDL should have accompanied this
	# source. A copy of the CDDL is also available via the Internet at
	# http://www.illumos.org/license/CDDL.
	#

	#
	# Copyright (c) 2017, 2018 by Delphix. All rights reserved.
	#

	. $STF_SUITE/tests/functional/pool_checkpoint/pool_checkpoint.kshlib

	#
	# DESCRIPTION:
	# Discard checkpoint on a stressed pool. Ensure that we can
	# export and import the pool while discarding but not run any
	# operations that have to do with the checkpoint or change the
	# pool's config.
	#
	# STRATEGY:
	# 1. Import pools that's slightly fragmented
	# 2. Take checkpoint
	# 3. Do more random writes to "free" checkpointed blocks
	# 4. Start discarding checkpoint
	# 5. Export pool while discarding checkpoint
	# 6. Attempt to rewind (should fail)
	# 7. Import pool and ensure that discard is still running
	# 8. Attempt to run checkpoint commands, or commands that
	# change the pool's config (should fail)
	#

	verify_runnable "global"

	function test_cleanup
	{
	# reset memory limit to 16M
	set_tunable64 SPA_DISCARD_MEMORY_LIMIT 1000000
	cleanup_nested_pools
	}

	setup_nested_pool_state
	log_onexit test_cleanup

	#
	# Force discard to happen slower so it spans over
	# multiple txgs.
	#
	# Set memory limit to 128 bytes. Assuming that we
	# use 64-bit words for encoding space map entries,
	# ZFS will discard 8 non-debug entries per txg
	# (so at most 16 space map entries in debug-builds
	# due to debug entries).
	#
	# That should give us more than enough txgs to be
	# discarding the checkpoint for a long time as with
	# the current setup the checkpoint space maps should
	# have tens of thousands of entries.
	#
	# Note: If two-words entries are used in the space
	# map, we should have even more time to
	# verify this.
	#
	set_tunable64 SPA_DISCARD_MEMORY_LIMIT 128

	log_must zpool checkpoint $NESTEDPOOL

	fragment_after_checkpoint_and_verify

	log_must zpool checkpoint -d $NESTEDPOOL

	log_must zpool export $NESTEDPOOL

	#
	# Verify on-disk state while pool is exported
	#
	log_must zdb -e -p $FILEDISKDIR $NESTEDPOOL

	#
	# Attempt to rewind on a pool that is discarding
	# a checkpoint.
	#
	log_mustnot zpool import -d $FILEDISKDIR --rewind-to-checkpoint $NESTEDPOOL

	log_must zpool import -d $FILEDISKDIR $NESTEDPOOL

	#
	# Discarding should continue after import, so
	# all the following operations should fail.
	#
	log_mustnot zpool checkpoint $NESTEDPOOL
	log_mustnot zpool checkpoint -d $NESTEDPOOL
	log_mustnot zpool remove $NESTEDPOOL $FILEDISK1
	log_mustnot zpool reguid $NESTEDPOOL

	# reset memory limit to 16M
	set_tunable64 SPA_DISCARD_MEMORY_LIMIT 16777216

	nested_wait_discard_finish

	-log_must zdb $NESTEDPOOL
	+log_must zpool export $NESTEDPOOL
	+log_must zdb -e -p $FILEDISKDIR $NESTEDPOOL

	log_pass "Can export/import but not rewind/checkpoint/discard or " \
	"change pool's config while discarding."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/pool_checkpoint/pool_checkpoint.kshlib b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/pool_checkpoint/pool_checkpoint.kshlib
	index ea6c03e9d59d..bb8bab6cdf46 100644
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/pool_checkpoint/pool_checkpoint.kshlib
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/pool_checkpoint/pool_checkpoint.kshlib
	@@ -1,413 +1,418 @@
	#
	# This file and its contents are supplied under the terms of the
	# Common Development and Distribution License ("CDDL"), version 1.0.
	# You may only use this file in accordance with the terms of version
	# 1.0 of the CDDL.
	#
	# A full copy of the text of the CDDL should have accompanied this
	# source. A copy of the CDDL is also available via the Internet at
	# http://www.illumos.org/license/CDDL.
	#

	#
	# Copyright (c) 2017, 2018 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/removal/removal.kshlib

	#
	# In general all the tests related to the pool checkpoint can
	# be divided into two categories. TESTS that verify features
	# provided by the checkpoint (e.g. checkpoint_rewind) and tests
	# that stress-test the checkpoint (e.g. checkpoint_big_rewind).
	#
	# For the first group we don't really care about the size of
	# the pool or the individual file sizes within the filesystems.
	# This is why these tests run directly on pools that use a
	# "real disk vdev" (meaning not a file based one). These tests
	# use the $TESTPOOL pool that is created on top of $TESTDISK.
	# This pool is referred to as the "test pool" and thus all
	# the tests of this group use the testpool-related functions of
	# this file (not the nested_pools ones).
	#
	# For the second group we generally try to bring the pool to its
	# limits by increasing fragmentation, filling all allocatable
	# space, attempting to use vdevs that the checkpoint spacemap
	# cannot represent, etc. For these tests we need to control
	# almost all parameters of the pool and the vdevs that back it
	# so we create them based on file-based vdevs that we carefully
	# create within the $TESTPOOL pool. So most of these tests, in
	# order to create this nested pool sctructure, generally start
	# like this:
	# 1] We create the test pool ($TESTPOOL).
	# 2] We create a filesystem and we populate it with files of
	# some predetermined size.
	# 3] We use those files as vdevs for the pool that the test
	# will use ($NESTEDPOOL).
	# 4] Go on and let the test run and operate on $NESTEDPOOL.
	#

	#
	# These disks are used to back $TESTPOOL
	#
	TESTDISK="$(echo $DISKS \| cut -d' ' -f1)"
	EXTRATESTDISK="$(echo $DISKS \| cut -d' ' -f2)"

	FS0=$TESTPOOL/$TESTFS
	FS1=$TESTPOOL/$TESTFS1
	FS2=$TESTPOOL/$TESTFS2

	FS0FILE=/$FS0/$TESTFILE0
	FS1FILE=/$FS1/$TESTFILE1
	FS2FILE=/$FS2/$TESTFILE2

	#
	# The following are created within $TESTPOOL and
	# will be used to back $NESTEDPOOL
	#
	DISKFS=$TESTPOOL/disks
	FILEDISKDIR=/$DISKFS
	FILEDISK1=/$DISKFS/dsk1
	FILEDISK2=/$DISKFS/dsk2
	FILEDISKS="$FILEDISK1 $FILEDISK2"

	#
	# $NESTEDPOOL related variables
	#
	NESTEDPOOL=nestedpool
	NESTEDFS0=$NESTEDPOOL/$TESTFS
	NESTEDFS1=$NESTEDPOOL/$TESTFS1
	NESTEDFS2=$NESTEDPOOL/$TESTFS2
	NESTEDFS0FILE=/$NESTEDFS0/$TESTFILE0
	NESTEDFS1FILE=/$NESTEDFS1/$TESTFILE1
	NESTEDFS2FILE=/$NESTEDFS2/$TESTFILE2

	#
	# In the tests that stress-test the pool (second category
	# mentioned above), there exist some that need to bring
	# fragmentation at high percentages in a relatively short
	# period of time. In order to do that we set the following
	# parameters:
	#
	# * We use two disks of 1G each, to create a pool of size 2G.
	# The point is that 2G is not small nor large, and we also
	# want to have 2 disks to introduce indirect vdevs on our
	# setup.
	# * We enable compression and set the record size of all
	# filesystems to 8K. The point of compression is to
	# ensure that we are not filling up the whole pool (that's
	# what checkpoint_capacity is for), and the specific
	# record size is set to match the block size of randwritecomp
	# which is used to increase fragmentation by writing on
	# files.
	# * We always have 2 big files present of 512M each, which
	# should account for 40%~50% capacity by the end of each
	# test with fragmentation around 50~60%.
	# * At each file we attempt to do enough random writes to
	# touch every offset twice on average.
	#
	# Note that the amount of random writes per files are based
	# on the following calculation:
	#
	# ((512M / 8K) * 3) * 2 = ~400000
	#
	# Given that the file is 512M and one write is 8K, we would
	# need (512M / 8K) writes to go through the whole file.
	# Assuming though that each write has a compression ratio of
	# 3, then we want 3 times that to cover the same amount of
	# space. Finally, we multiply that by 2 since our goal is to
	# touch each offset twice on average.
	#
	# Examples of those tests are checkpoint_big_rewind and
	# checkpoint_discard_busy.
	#
	FILEDISKSIZE=1g
	DISKSIZE=1g
	BIGFILESIZE=512M
	RANDOMWRITES=400000


	#
	# Assumes create_test_pool has been called beforehand.
	#
	function setup_nested_pool
	{
	log_must zfs create $DISKFS

	log_must truncate -s $DISKSIZE $FILEDISK1
	log_must truncate -s $DISKSIZE $FILEDISK2

	log_must zpool create -O sync=disabled $NESTEDPOOL $FILEDISKS
	}

	function setup_test_pool
	{
	log_must zpool create -O sync=disabled $TESTPOOL "$TESTDISK"
	}

	function setup_nested_pools
	{
	setup_test_pool
	setup_nested_pool
	}

	function cleanup_nested_pool
	{
	- log_must zpool destroy $NESTEDPOOL
	+ if poolexists $NESTEDPOOL; then
	+ log_must zpool destroy $NESTEDPOOL
	+ fi
	+
	log_must rm -f $FILEDISKS
	}

	function cleanup_test_pool
	{
	- log_must zpool destroy $TESTPOOL
	+ if poolexists $TESTPOOL; then
	+ log_must zpool destroy $TESTPOOL
	+ fi

	#
	# We always clear the labels of all disks
	# between tests so imports from zpool or
	# or zdb do not get confused with leftover
	# data from old pools.
	#
	for disk in $DISKS; do
	zpool labelclear -f $disk
	done
	}

	function cleanup_nested_pools
	{
	cleanup_nested_pool
	cleanup_test_pool
	}

	#
	# Remove and re-add each vdev to ensure that data is
	# moved between disks and indirect mappings are created
	#
	function introduce_indirection
	{
	for disk in ${FILEDISKS[@]}; do
	log_must zpool remove $NESTEDPOOL $disk
	log_must wait_for_removal $NESTEDPOOL
	log_mustnot vdevs_in_pool $NESTEDPOOL $disk
	log_must zpool add $NESTEDPOOL $disk
	done
	}

	FILECONTENTS0="Can't wait to be checkpointed!"
	FILECONTENTS1="Can't wait to be checkpointed too!"
	NEWFILECONTENTS0="I survived after the checkpoint!"
	NEWFILECONTENTS2="I was born after the checkpoint!"

	function populate_test_pool
	{
	log_must zfs create -o compression=lz4 -o recordsize=8k $FS0
	log_must zfs create -o compression=lz4 -o recordsize=8k $FS1

	echo $FILECONTENTS0 > $FS0FILE
	echo $FILECONTENTS1 > $FS1FILE
	}

	function populate_nested_pool
	{
	log_must zfs create -o compression=lz4 -o recordsize=8k $NESTEDFS0
	log_must zfs create -o compression=lz4 -o recordsize=8k $NESTEDFS1

	echo $FILECONTENTS0 > $NESTEDFS0FILE
	echo $FILECONTENTS1 > $NESTEDFS1FILE
	}

	function test_verify_pre_checkpoint_state
	{
	log_must zfs list $FS0
	log_must zfs list $FS1
	log_must [ "$(<$FS0FILE)" = "$FILECONTENTS0" ]
	log_must [ "$(<$FS1FILE)" = "$FILECONTENTS1" ]

	#
	# If we've opened the checkpointed state of the
	# pool as read-only without rewinding on-disk we
	# can't really use zdb on it.
	#
	if [[ "$1" != "ro-check" ]] ; then
	log_must zdb $TESTPOOL
	fi

	#
	# Ensure post-checkpoint state is not present
	#
	log_mustnot zfs list $FS2
	log_mustnot [ "$(<$FS0FILE)" = "$NEWFILECONTENTS0" ]
	}

	function nested_verify_pre_checkpoint_state
	{
	log_must zfs list $NESTEDFS0
	log_must zfs list $NESTEDFS1
	log_must [ "$(<$NESTEDFS0FILE)" = "$FILECONTENTS0" ]
	log_must [ "$(<$NESTEDFS1FILE)" = "$FILECONTENTS1" ]

	#
	# If we've opened the checkpointed state of the
	# pool as read-only without rewinding on-disk we
	# can't really use zdb on it.
	#
	if [[ "$1" != "ro-check" ]] ; then
	log_must zdb $NESTEDPOOL
	fi

	#
	# Ensure post-checkpoint state is not present
	#
	log_mustnot zfs list $NESTEDFS2
	log_mustnot [ "$(<$NESTEDFS0FILE)" = "$NEWFILECONTENTS0" ]
	}

	function test_change_state_after_checkpoint
	{
	log_must zfs destroy $FS1
	log_must zfs create -o compression=lz4 -o recordsize=8k $FS2

	echo $NEWFILECONTENTS0 > $FS0FILE
	echo $NEWFILECONTENTS2 > $FS2FILE
	}

	function nested_change_state_after_checkpoint
	{
	log_must zfs destroy $NESTEDFS1
	log_must zfs create -o compression=lz4 -o recordsize=8k $NESTEDFS2

	echo $NEWFILECONTENTS0 > $NESTEDFS0FILE
	echo $NEWFILECONTENTS2 > $NESTEDFS2FILE
	}

	function test_verify_post_checkpoint_state
	{
	log_must zfs list $FS0
	log_must zfs list $FS2
	log_must [ "$(<$FS0FILE)" = "$NEWFILECONTENTS0" ]
	log_must [ "$(<$FS2FILE)" = "$NEWFILECONTENTS2" ]

	log_must zdb $TESTPOOL

	#
	# Ensure pre-checkpointed state that was removed post-checkpoint
	# is not present
	#
	log_mustnot zfs list $FS1
	log_mustnot [ "$(<$FS0FILE)" = "$FILECONTENTS0" ]
	}

	function fragment_before_checkpoint
	{
	populate_nested_pool
	log_must mkfile -n $BIGFILESIZE $NESTEDFS0FILE
	log_must mkfile -n $BIGFILESIZE $NESTEDFS1FILE
	log_must randwritecomp $NESTEDFS0FILE $RANDOMWRITES
	log_must randwritecomp $NESTEDFS1FILE $RANDOMWRITES

	#
	# Display fragmentation on test log
	#
	log_must zpool list -v
	}

	function fragment_after_checkpoint_and_verify
	{
	log_must zfs destroy $NESTEDFS1
	log_must zfs create -o compression=lz4 -o recordsize=8k $NESTEDFS2
	log_must mkfile -n $BIGFILESIZE $NESTEDFS2FILE
	log_must randwritecomp $NESTEDFS0FILE $RANDOMWRITES
	log_must randwritecomp $NESTEDFS2FILE $RANDOMWRITES

	#
	# Display fragmentation on test log
	#
	log_must zpool list -v

	#
	# Typically we would just run zdb at this point and things
	# would be fine. Unfortunately, if there is still any
	# background I/O in the pool the zdb command can fail with
	# checksum errors temporarily.
	#
	# Export the pool when running zdb so the pool is idle and
	# the verification results are consistent.
	#
	log_must zpool export $NESTEDPOOL
	log_must zdb -e -p $FILEDISKDIR $NESTEDPOOL
	log_must zdb -e -p $FILEDISKDIR -kc $NESTEDPOOL
	log_must zpool import -d $FILEDISKDIR $NESTEDPOOL
	}

	function wait_discard_finish
	{
	typeset pool="$1"

	typeset status
	status=$(zpool status $pool \| grep "checkpoint:")
	while [ "" != "$status" ]; do
	sleep 5
	status=$(zpool status $pool \| grep "checkpoint:")
	done
	}

	function test_wait_discard_finish
	{
	wait_discard_finish $TESTPOOL
	}

	function nested_wait_discard_finish
	{
	wait_discard_finish $NESTEDPOOL
	}

	#
	# Creating the setup for the second group of tests mentioned in
	# block comment of this file can take some time as we are doing
	# random writes to raise capacity and fragmentation before taking
	# the checkpoint. Thus we create this setup once and save the
	# disks of the nested pool in a temporary directory where we can
	# reuse it for each test that requires that setup.
	#
	SAVEDPOOLDIR="$TEST_BASE_DIR/ckpoint_saved_pool"

	function test_group_premake_nested_pools
	{
	setup_nested_pools

	#
	# Populate and fragment the pool.
	#
	fragment_before_checkpoint

	#
	# Export and save the pool for other tests.
	#
	log_must zpool export $NESTEDPOOL
	log_must mkdir $SAVEDPOOLDIR
	log_must cp $FILEDISKS $SAVEDPOOLDIR

	#
	# Reimport pool to be destroyed by
	# cleanup_nested_pools function
	#
	log_must zpool import -d $FILEDISKDIR $NESTEDPOOL
	}

	function test_group_destroy_saved_pool
	{
	log_must rm -rf $SAVEDPOOLDIR
	}

	#
	# Recreate nested pool setup from saved pool.
	#
	function setup_nested_pool_state
	{
	setup_test_pool

	log_must zfs create $DISKFS
	log_must cp $SAVEDPOOLDIR/* $FILEDISKDIR

	log_must zpool import -d $FILEDISKDIR $NESTEDPOOL
	}
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/pool_names/pool_names_002_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/pool_names/pool_names_002_neg.ksh
	index 0c96e1999ef4..0b40f7cd27f7 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/pool_names/pool_names_002_neg.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/pool_names/pool_names_002_neg.ksh
	@@ -1,129 +1,129 @@
	#!/bin/ksh -p
	#
	# 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 2008 Sun Microsystems, Inc. All rights reserved.
	# Use is subject to license terms.
	#

	#
	# Copyright (c) 2013, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib

	#
	# DESCRIPTION:
	#
	# Ensure that a set of invalid names cannot be used to create pools.
	#
	# STRATEGY:
	# 1) For each invalid character in the character set, try to create
	# and destroy the pool. Verify it fails.
	# 2) Given a list of invalid pool names, ensure the pools are not
	# created.
	#

	verify_runnable "global"

	log_assert "Ensure that a set of invalid names cannot be used to create pools."

	# Global variable use to cleanup failures.
	POOLNAME=""

	function cleanup
	{
	if poolexists $POOLNAME; then
	log_must zpool destroy $POOLNAME
	fi

	if [[ -d $TESTDIR ]]; then
	log_must rm -rf $TESTDIR
	fi
	}

	log_onexit cleanup

	for pool in $(get_all_pools); do
	if [[ "$pool" != "$TESTPOOL" ]]; then
	log_must zpool destroy $pool
	fi
	done

	DISK=${DISKS%% *}
	if [[ ! -e $TESTDIR ]]; then
	log_must mkdir $TESTDIR
	fi

	log_note "Ensure invalid characters fail"
	for POOLNAME in "!" "\"" "#" "$" "%" "&" "'" "(" ")" \
	"\*" "+" "," "-" "\." "/" "\\" \
	0 1 2 3 4 5 6 7 8 9 \
	":" ";" "<" "=" ">" "\?" "@" \
	"[" "]" "^" "_" "\`" "{" "\|" "}" "~"
	do
	log_mustnot zpool create -m $TESTDIR $POOLNAME $DISK
	if poolexists $POOLNAME; then
	log_fail "Unexpectedly created pool: '$POOLNAME'"
	fi

	log_mustnot zpool destroy $POOLNAME
	done

	log_note "Check that invalid octal values fail"
	for oct in "\000" "\001" "\002" "\003" "\004" "\005" "\006" "\007" \
	"\010" "\011" "\012" "\013" "\014" "\015" "\017" \
	"\020" "\021" "\022" "\023" "\024" "\025" "\026" "\027" \
	"\030" "\031" "\032" "\033" "\034" "\035" "\036" "\037" \
	"\040" "\177"
	do
	POOLNAME=`eval "echo x \| tr 'x' '$oct'"`
	log_mustnot zpool create -m $TESTDIR $POOLNAME $DISK
	if poolexists $POOLNAME; then
	log_fail "Unexpectedly created pool: '$POOLNAME'"
	fi

	log_mustnot zpool destroy $POOLNAME
	done

	log_note "Verify invalid pool names fail"
	-set -A POOLNAME "c0t0d0s0" "c0t0d0" "c0t0d19" "c0t50000E0108D279d0" \
	+set -A POOLNAME \
	"mirror" "raidz" ",," ",,,,,,,,,,,,,,,,,,,,,,,,," \
	"2222222222222222222" "mirror_pool" "raidz_pool" \
	"mirror-pool" "raidz-pool" "spare" "spare_pool" \
	"spare-pool" "raidz1-" "raidz2:" ":aaa" "-bbb" "_ccc" ".ddd"
	if verify_slog_support ; then
	POOLNAME[${#POOLNAME[@]}]='log'
	fi
	typeset -i i=0
	while ((i < ${#POOLNAME[@]})); do
	log_mustnot zpool create -m $TESTDIR ${POOLNAME[$i]} $DISK
	if poolexists ${POOLNAME[$i]}; then
	log_fail "Unexpectedly created pool: '${POOLNAME[$i]}'"
	fi

	log_mustnot zpool destroy ${POOLNAME[$i]}

	((i += 1))
	done

	log_pass "Invalid names and characters were caught correctly"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/Makefile.am b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/Makefile.am
	index 7b85d6a1bf5f..42c11c4aa957 100644
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/Makefile.am
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/Makefile.am
	@@ -1,20 +1,22 @@
	pkgdatadir = $(datadir)/@PACKAGE@/zfs-tests/tests/functional/redundancy
	dist_pkgdata_SCRIPTS = \
	setup.ksh \
	cleanup.ksh \
	+ redundancy_draid.ksh \
	redundancy_draid1.ksh \
	redundancy_draid2.ksh \
	redundancy_draid3.ksh \
	+ redundancy_draid_damaged.ksh \
	redundancy_draid_spare1.ksh \
	redundancy_draid_spare2.ksh \
	redundancy_draid_spare3.ksh \
	redundancy_mirror.ksh \
	redundancy_raidz.ksh \
	redundancy_raidz1.ksh \
	redundancy_raidz2.ksh \
	redundancy_raidz3.ksh \
	redundancy_stripe.ksh

	dist_pkgdata_DATA = \
	redundancy.cfg \
	redundancy.kshlib
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/redundancy.kshlib b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/redundancy.kshlib
	index 26ded8720d10..baee8269b1e1 100644
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/redundancy.kshlib
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/redundancy.kshlib
	@@ -1,374 +1,380 @@
	#
	# 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 2009 Sun Microsystems, Inc. All rights reserved.
	# Use is subject to license terms.
	#

	#
	# Copyright (c) 2013, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/redundancy/redundancy.cfg

	function cleanup
	{
	if poolexists $TESTPOOL; then
	destroy_pool $TESTPOOL
	fi
	typeset dir
	for dir in $TESTDIR $BASEDIR; do
	if [[ -d $dir ]]; then
	log_must rm -rf $dir
	fi
	done
	}

	#
	# Get random number between min and max number.
	#
	# $1 Minimal value
	# $2 Maximal value
	#
	function random
	{
	typeset -i min=$1
	typeset -i max=$2
	typeset -i value

	while true; do
	((value = RANDOM % (max + 1)))
	if ((value >= min)); then
	break
	fi
	done

	echo $value
	}

	#
	# Get the number of checksum errors for the pool.
	#
	# $1 Pool
	#
	function cksum_pool
	{
	typeset -i cksum=$(zpool status $1 \| awk '
	!NF { isvdev = 0 }
	isvdev { errors += $NF }
	/CKSUM$/ { isvdev = 1 }
	END { print errors }
	')

	echo $cksum
	}

	#
	# Record the directories construction and checksum all the files which reside
	# within the specified pool
	#
	# $1 The specified pool
	# $2 The file which save the record.
	#
	function record_data
	{
	typeset pool=$1
	typeset recordfile=$2

	[[ -z $pool ]] && log_fail "No specified pool."
	[[ -f $recordfile ]] && log_must rm -f $recordfile

	sync_pool $pool
	typeset mntpnt
	mntpnt=$(get_prop mountpoint $pool)
	log_must eval "du -a $mntpnt > $recordfile 2>&1"
	#
	# When the data was damaged, checksum is failing and return 1
	# So, will not use log_must
	#
	find $mntpnt -type f -exec cksum {} + >> $recordfile 2>&1
	}

	#
	# Create test pool and fill with files and directories.
	#
	# $1 pool name
	# $2 pool type
	# $3 virtual devices number
	#
	function setup_test_env
	{
	typeset pool=$1
	typeset keyword=$2
	typeset -i vdev_cnt=$3
	typeset vdevs

	typeset -i i=0
	while (( i < vdev_cnt )); do
	vdevs="$vdevs $BASEDIR/vdev$i"
	((i += 1))
	done

	if [[ ! -d $BASEDIR ]]; then
	log_must mkdir $BASEDIR
	fi

	if poolexists $pool ; then
	destroy_pool $pool
	fi

	log_must truncate -s $MINVDEVSIZE $vdevs

	log_must zpool create -f -m $TESTDIR $pool $keyword $vdevs

	log_note "Filling up the filesystem ..."
	typeset -i ret=0
	typeset -i i=0
	typeset file=$TESTDIR/file
	typeset -i limit
	- (( limit = $(get_prop available $pool) / 4 ))
	+ (( limit = $(get_prop available $pool) / 2 ))

	while true ; do
	[[ $(get_prop available $pool) -lt $limit ]] && break
	file_write -o create -f $file.$i -b $BLOCKSZ -c $NUM_WRITES
	ret=$?
	(( $ret != 0 )) && break
	(( i = i + 1 ))
	done

	record_data $TESTPOOL $PRE_RECORD_FILE
	}

	function refill_test_env
	{
	log_note "Re-filling the filesystem ..."
	+ typeset pool=$1
	typeset -i ret=0
	typeset -i i=0
	typeset mntpnt
	mntpnt=$(get_prop mountpoint $pool)
	typeset file=$mntpnt/file
	while [[ -e $file.$i ]]; do
	log_must rm -f $file.$i
	file_write -o create -f $file.$i -b $BLOCKSZ -c $NUM_WRITES
	ret=$?
	(( $ret != 0 )) && break
	(( i = i + 1 ))
	done

	record_data $TESTPOOL $PRE_RECORD_FILE
	}

	#
	# Check pool status is healthy
	#
	# $1 pool
	#
	function is_healthy
	{
	typeset pool=$1

	typeset healthy_output="pool '$pool' is healthy"
	typeset real_output=$(zpool status -x $pool)

	if [[ "$real_output" == "$healthy_output" ]]; then
	return 0
	else
	typeset -i ret
	zpool status -x $pool \| grep "state:" \| \
	grep "FAULTED" >/dev/null 2>&1
	ret=$?
	(( $ret == 0 )) && return 1
	typeset l_scan
	typeset errnum
	l_scan=$(zpool status -x $pool \| grep "scan:")
	l_scan=${l_scan##*"with"}
	errnum=$(echo $l_scan \| awk '{print $1}')

	return $errnum
	fi
	}

	#
	# Check pool data is valid
	#
	# $1 pool
	#
	function is_data_valid
	{
	typeset pool=$1

	+ log_must zpool scrub -w $pool
	+
	record_data $pool $PST_RECORD_FILE
	if ! diff $PRE_RECORD_FILE $PST_RECORD_FILE > /dev/null 2>&1; then
	+ log_must cat $PRE_RECORD_FILE
	+ log_must cat $PST_RECORD_FILE
	+ diff -u $PRE_RECORD_FILE $PST_RECORD_FILE
	return 1
	fi

	return 0
	}

	#
	# Get the specified count devices name
	#
	# $1 pool name
	# $2 devices count
	#
	function get_vdevs #pool cnt
	{
	typeset pool=$1
	typeset -i cnt=$2

	typeset all_devs=$(zpool iostat -v $pool \| awk '{print $1}'\| \
	- egrep -v "^pool$\|^capacity$\|^mirror$\|^raidz1$\|^raidz2$\|---" \| \
	+ egrep -v "^pool$\|^capacity$\|^mirror$\|^raidz1$\|^raidz2$\|^raidz3$\|^draid1.\|^draid2.\|^draid3.*\|---" \| \
	egrep -v "/old$\|^$pool$")
	typeset -i i=0
	typeset vdevs
	while ((i < cnt)); do
	typeset dev=$(echo $all_devs \| awk '{print $1}')
	eval all_devs=\${all_devs##*$dev}

	vdevs="$dev $vdevs"
	((i += 1))
	done

	echo "$vdevs"
	}

	#
	# Create and replace the same name virtual device files
	#
	# $1 pool name
	# $2-n virtual device files
	#
	function replace_missing_devs
	{
	typeset pool=$1
	shift

	typeset vdev
	for vdev in $@; do
	- log_must gnudd if=/dev/zero of=$vdev \
	- bs=1024k count=$(($MINDEVSIZE / (1024 * 1024))) \
	- oflag=fdatasync
	+ log_must dd if=/dev/zero of=$vdev \
	+ bs=1024k count=$((MINVDEVSIZE / (1024 * 1024))) \
	+ conv=fdatasync
	log_must zpool replace -wf $pool $vdev $vdev
	done
	}

	#
	# Damage the pool's virtual device files.
	#
	# $1 pool name
	# $2 Failing devices count
	# $3 damage vdevs method, if not null, we keep
	# the label for the vdevs
	#
	function damage_devs
	{
	typeset pool=$1
	typeset -i cnt=$2
	typeset label="$3"
	typeset vdevs
	- typeset -i bs_count=$((64 * 1024))
	+ typeset -i bs_count=$(((MINVDEVSIZE / 1024) - 4096))

	vdevs=$(get_vdevs $pool $cnt)
	typeset dev
	if [[ -n $label ]]; then
	for dev in $vdevs; do
	- dd if=/dev/zero of=$dev seek=512 bs=1024 \
	+ log_must dd if=/dev/zero of=$dev seek=512 bs=1024 \
	count=$bs_count conv=notrunc >/dev/null 2>&1
	done
	else
	for dev in $vdevs; do
	- dd if=/dev/zero of=$dev bs=1024 count=$bs_count \
	- conv=notrunc >/dev/null 2>&1
	+ log_must dd if=/dev/zero of=$dev bs=1024 \
	+ count=$bs_count conv=notrunc >/dev/null 2>&1
	done
	fi

	sync_pool $pool
	}

	#
	# Clear errors in the pool caused by data corruptions
	#
	# $1 pool name
	#
	function clear_errors
	{
	typeset pool=$1

	log_must zpool clear $pool

	if ! is_healthy $pool ; then
	log_note "$pool should be healthy."
	return 1
	fi
	if ! is_data_valid $pool ; then
	log_note "Data should be valid in $pool."
	return 1
	fi

	return 0
	}

	#
	# Remove the specified pool's virtual device files
	#
	# $1 Pool name
	# $2 Missing devices count
	#
	function remove_devs
	{
	typeset pool=$1
	typeset -i cnt=$2
	typeset vdevs

	vdevs=$(get_vdevs $pool $cnt)
	log_must rm -f $vdevs

	sync_pool $pool
	}

	#
	# Recover the bad or missing device files in the pool
	#
	# $1 Pool name
	# $2 Missing devices count
	#
	function recover_bad_missing_devs
	{
	typeset pool=$1
	typeset -i cnt=$2
	typeset vdevs

	vdevs=$(get_vdevs $pool $cnt)
	replace_missing_devs $pool $vdevs

	if ! is_healthy $pool ; then
	log_note "$pool should be healthy."
	return 1
	fi
	if ! is_data_valid $pool ; then
	log_note "Data should be valid in $pool."
	return 1
	fi

	return 0
	}
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/redundancy_raidz.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/redundancy_draid.ksh
	similarity index 73%
	copy from sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/redundancy_raidz.ksh
	copy to sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/redundancy_draid.ksh
	index 8d32e0603ae8..8015e682c892 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/redundancy_raidz.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/redundancy_draid.ksh
	@@ -1,198 +1,248 @@
	#!/bin/ksh -p
	#
	# 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) 2020 by vStack. All rights reserved.
	# Copyright (c) 2021 by Delphix. All rights reserved.
	+# Copyright (c) 2021 by Lawrence Livermore National Security, LLC.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/redundancy/redundancy.kshlib

	#
	# DESCRIPTION:
	-# RAIDZ should provide redundancy
	+# dRAID should provide redundancy
	#
	# STRATEGY:
	-# 1. Create block device files for the test raidz pool
	+# 1. Create block device files for the test draid pool
	# 2. For each parity value [1..3]
	-# - create raidz pool
	+# - create draid pool
	# - fill it with some directories/files
	+# - verify self-healing by overwriting devices
	# - verify resilver by replacing devices
	# - verify scrub by zeroing devices
	-# - destroy the raidz pool
	+# - destroy the draid pool

	typeset -r devs=6
	typeset -r dev_size_mb=512

	typeset -a disks

	prefetch_disable=$(get_tunable PREFETCH_DISABLE)

	function cleanup
	{
	poolexists "$TESTPOOL" && destroy_pool "$TESTPOOL"

	for i in {0..$devs}; do
	rm -f "$TEST_BASE_DIR/dev-$i"
	done

	set_tunable32 PREFETCH_DISABLE $prefetch_disable
	}

	+function test_selfheal # <pool> <parity> <dir>
	+{
	+ typeset pool=$1
	+ typeset nparity=$2
	+ typeset dir=$3
	+
	+ log_must zpool export $pool
	+
	+ for (( i=0; i<$nparity; i=i+1 )); do
	+ log_must dd conv=notrunc if=/dev/zero of=$dir/dev-$i \
	+ bs=1M seek=4 count=$(($dev_size_mb-4))
	+ done
	+
	+ log_must zpool import -o cachefile=none -d $dir $pool
	+
	+ typeset mntpnt=$(get_prop mountpoint $pool/fs)
	+ log_must find $mntpnt -type f -exec cksum {} + >> /dev/null 2>&1
	+ log_must check_pool_status $pool "errors" "No known data errors"
	+
	+ #
	+ # Scrub the pool because the find command will only self-heal blocks
	+ # from the files which were read. Before overwriting additional
	+ # devices we need to repair all of the blocks in the pool.
	+ #
	+ log_must zpool scrub -w $pool
	+ log_must check_pool_status $pool "errors" "No known data errors"
	+
	+ log_must zpool clear $pool
	+
	+ log_must zpool export $pool
	+
	+ for (( i=$nparity; i<$nparity*2; i=i+1 )); do
	+ log_must dd conv=notrunc if=/dev/zero of=$dir/dev-$i \
	+ bs=1M seek=4 count=$(($dev_size_mb-4))
	+ done
	+
	+ log_must zpool import -o cachefile=none -d $dir $pool
	+
	+ typeset mntpnt=$(get_prop mountpoint $pool/fs)
	+ log_must find $mntpnt -type f -exec cksum {} + >> /dev/null 2>&1
	+ log_must check_pool_status $pool "errors" "No known data errors"
	+
	+ log_must zpool scrub -w $pool
	+ log_must check_pool_status $pool "errors" "No known data errors"
	+
	+ log_must zpool clear $pool
	+}
	+
	function test_resilver # <pool> <parity> <dir>
	{
	typeset pool=$1
	typeset nparity=$2
	typeset dir=$3

	for (( i=0; i<$nparity; i=i+1 )); do
	log_must zpool offline $pool $dir/dev-$i
	done

	log_must zpool export $pool

	for (( i=0; i<$nparity; i=i+1 )); do
	log_must zpool labelclear -f $dir/dev-$i
	done

	log_must zpool import -o cachefile=none -d $dir $pool

	for (( i=0; i<$nparity; i=i+1 )); do
	log_must zpool replace -fw $pool $dir/dev-$i
	done

	log_must check_pool_status $pool "errors" "No known data errors"
	resilver_cksum=$(cksum_pool $pool)
	if [[ $resilver_cksum != 0 ]]; then
	log_must zpool status -v $pool
	log_fail "resilver cksum errors: $resilver_cksum"
	fi

	log_must zpool clear $pool

	for (( i=$nparity; i<$nparity*2; i=i+1 )); do
	log_must zpool offline $pool $dir/dev-$i
	done

	log_must zpool export $pool

	for (( i=$nparity; i<$nparity*2; i=i+1 )); do
	log_must zpool labelclear -f $dir/dev-$i
	done

	log_must zpool import -o cachefile=none -d $dir $pool

	for (( i=$nparity; i<$nparity*2; i=i+1 )); do
	log_must zpool replace -fw $pool $dir/dev-$i
	done

	log_must check_pool_status $pool "errors" "No known data errors"
	resilver_cksum=$(cksum_pool $pool)
	if [[ $resilver_cksum != 0 ]]; then
	log_must zpool status -v $pool
	log_fail "resilver cksum errors: $resilver_cksum"
	fi

	log_must zpool clear $pool
	}

	function test_scrub # <pool> <parity> <dir>
	{
	typeset pool=$1
	typeset nparity=$2
	typeset dir=$3
	- typeset combrec=$4

	log_must zpool export $pool

	for (( i=0; i<$nparity; i=i+1 )); do
	dd conv=notrunc if=/dev/zero of=$dir/dev-$i \
	bs=1M seek=4 count=$(($dev_size_mb-4))
	done

	log_must zpool import -o cachefile=none -d $dir $pool

	log_must zpool scrub -w $pool
	log_must check_pool_status $pool "errors" "No known data errors"

	log_must zpool clear $pool

	log_must zpool export $pool

	for (( i=$nparity; i<$nparity*2; i=i+1 )); do
	dd conv=notrunc if=/dev/zero of=$dir/dev-$i \
	bs=1M seek=4 count=$(($dev_size_mb-4))
	done

	log_must zpool import -o cachefile=none -d $dir $pool

	log_must zpool scrub -w $pool
	log_must check_pool_status $pool "errors" "No known data errors"

	log_must zpool clear $pool
	}

	log_onexit cleanup

	log_must set_tunable32 PREFETCH_DISABLE 1

	# Disk files which will be used by pool
	for i in {0..$(($devs - 1))}; do
	device=$TEST_BASE_DIR/dev-$i
	log_must truncate -s ${dev_size_mb}M $device
	disks[${#disks[*]}+1]=$device
	done

	# Disk file which will be attached
	log_must truncate -s 512M $TEST_BASE_DIR/dev-$devs

	for nparity in 1 2 3; do
	- raid=raidz$nparity
	+ raid=draid$nparity
	dir=$TEST_BASE_DIR

	log_must zpool create -f -o cachefile=none $TESTPOOL $raid ${disks[@]}
	log_must zfs set primarycache=metadata $TESTPOOL

	log_must zfs create $TESTPOOL/fs
	log_must fill_fs /$TESTPOOL/fs 1 512 100 1024 R

	log_must zfs create -o compress=on $TESTPOOL/fs2
	log_must fill_fs /$TESTPOOL/fs2 1 512 100 1024 R

	log_must zfs create -o compress=on -o recordsize=8k $TESTPOOL/fs3
	log_must fill_fs /$TESTPOOL/fs3 1 512 100 1024 R

	typeset pool_size=$(get_pool_prop size $TESTPOOL)

	log_must zpool export $TESTPOOL
	log_must zpool import -o cachefile=none -d $dir $TESTPOOL

	log_must check_pool_status $TESTPOOL "errors" "No known data errors"

	+ test_selfheal $TESTPOOL $nparity $dir
	test_resilver $TESTPOOL $nparity $dir
	test_scrub $TESTPOOL $nparity $dir

	log_must zpool destroy "$TESTPOOL"
	done

	-log_pass "raidz redundancy test succeeded."
	+log_pass "draid redundancy test succeeded."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/redundancy_draid3.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/redundancy_draid3.ksh
	index bddd150d0c98..d4c823ed9b37 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/redundancy_draid3.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/redundancy_draid3.ksh
	@@ -1,85 +1,85 @@
	#!/bin/ksh -p
	#
	# 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 2007 Sun Microsystems, Inc. All rights reserved.
	# Use is subject to license terms.
	#

	#
	# Copyright (c) 2013 by Delphix. All rights reserved.
	# Copyright (c) 2020 by Lawrence Livermore National Security, LLC.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/redundancy/redundancy.kshlib

	#
	# DESCRIPTION:
	# A draid3 pool can withstand 3 devices are failing or missing.
	#
	# STRATEGY:
	# 1. Create N(>5,<6) virtual disk files.
	# 2. Create draid3 pool based on the virtual disk files.
	# 3. Fill the filesystem with directories and files.
	# 4. Record all the files and directories checksum information.
	-# 5. Damaged at most two of the virtual disk files.
	+# 5. Damaged at most three of the virtual disk files.
	# 6. Verify the data is correct to prove draid3 can withstand 3 devices
	# are failing.
	#

	verify_runnable "global"

	log_assert "Verify draid3 pool can withstand three devices failing."
	log_onexit cleanup

	typeset -i cnt=$(random_int_between 5 6)
	setup_test_env $TESTPOOL draid3 $cnt

	#
	# Inject data corruption errors for draid3 pool
	#
	for i in 1 2 3; do
	damage_devs $TESTPOOL $i "label"
	log_must is_data_valid $TESTPOOL
	log_must clear_errors $TESTPOOL
	done

	#
	# Inject bad devices errors for draid3 pool
	#
	for i in 1 2 3; do
	damage_devs $TESTPOOL $i
	log_must is_data_valid $TESTPOOL
	log_must recover_bad_missing_devs $TESTPOOL $i
	done

	#
	# Inject missing device errors for draid3 pool
	#
	for i in 1 2 3; do
	remove_devs $TESTPOOL $i
	log_must is_data_valid $TESTPOOL
	log_must recover_bad_missing_devs $TESTPOOL $i
	done

	log_pass "draid3 pool can withstand three devices failing passed."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/redundancy_raidz.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/redundancy_draid_damaged.ksh
	similarity index 53%
	copy from sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/redundancy_raidz.ksh
	copy to sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/redundancy_draid_damaged.ksh
	index 8d32e0603ae8..6796cc78a1bd 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/redundancy_raidz.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/redundancy_draid_damaged.ksh
	@@ -1,198 +1,153 @@
	#!/bin/ksh -p
	#
	# 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) 2020 by vStack. All rights reserved.
	-# Copyright (c) 2021 by Delphix. All rights reserved.
	+# Copyright (c) 2021 by Lawrence Livermore National Security, LLC.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/redundancy/redundancy.kshlib

	#
	# DESCRIPTION:
	-# RAIDZ should provide redundancy
	+# When sequentially resilvering a dRAID pool with multiple vdevs
	+# that contain silent damage a sequential resilver should never
	+# introduce additional unrecoverable damage.
	#
	# STRATEGY:
	-# 1. Create block device files for the test raidz pool
	+# 1. Create block device files for the test draid pool
	# 2. For each parity value [1..3]
	-# - create raidz pool
	+# - create draid pool
	# - fill it with some directories/files
	-# - verify resilver by replacing devices
	-# - verify scrub by zeroing devices
	-# - destroy the raidz pool
	+# - overwrite the maximum number of repairable devices
	+# - sequentially resilver each overwritten device one at a time;
	+# the device will not be correctly repaired because the silent
	+# damage on the other vdevs will cause the parity calculations
	+# to generate incorrect data for the resilvering vdev.
	+# - verify that only the resilvering devices had invalid data
	+# written and that a scrub is still able to repair the pool
	+# - destroy the draid pool
	+#

	-typeset -r devs=6
	+typeset -r devs=7
	typeset -r dev_size_mb=512

	typeset -a disks

	prefetch_disable=$(get_tunable PREFETCH_DISABLE)
	+rebuild_scrub_enabled=$(get_tunable REBUILD_SCRUB_ENABLED)

	function cleanup
	{
	poolexists "$TESTPOOL" && destroy_pool "$TESTPOOL"

	for i in {0..$devs}; do
	rm -f "$TEST_BASE_DIR/dev-$i"
	done

	set_tunable32 PREFETCH_DISABLE $prefetch_disable
	+ set_tunable32 REBUILD_SCRUB_ENABLED $rebuild_scrub_enabled
	}

	-function test_resilver # <pool> <parity> <dir>
	+function test_sequential_resilver # <pool> <parity> <dir>
	{
	typeset pool=$1
	typeset nparity=$2
	typeset dir=$3

	- for (( i=0; i<$nparity; i=i+1 )); do
	- log_must zpool offline $pool $dir/dev-$i
	- done
	-
	log_must zpool export $pool

	for (( i=0; i<$nparity; i=i+1 )); do
	- log_must zpool labelclear -f $dir/dev-$i
	+ log_must dd conv=notrunc if=/dev/zero of=$dir/dev-$i \
	+ bs=1M seek=4 count=$(($dev_size_mb-4))
	done

	log_must zpool import -o cachefile=none -d $dir $pool

	for (( i=0; i<$nparity; i=i+1 )); do
	- log_must zpool replace -fw $pool $dir/dev-$i
	+ spare=draid${nparity}-0-$i
	+ log_must zpool replace -fsw $pool $dir/dev-$i $spare
	done

	- log_must check_pool_status $pool "errors" "No known data errors"
	- resilver_cksum=$(cksum_pool $pool)
	- if [[ $resilver_cksum != 0 ]]; then
	- log_must zpool status -v $pool
	- log_fail "resilver cksum errors: $resilver_cksum"
	- fi
	-
	- log_must zpool clear $pool
	-
	- for (( i=$nparity; i<$nparity*2; i=i+1 )); do
	- log_must zpool offline $pool $dir/dev-$i
	- done
	-
	- log_must zpool export $pool
	-
	- for (( i=$nparity; i<$nparity*2; i=i+1 )); do
	- log_must zpool labelclear -f $dir/dev-$i
	- done
	-
	- log_must zpool import -o cachefile=none -d $dir $pool
	-
	- for (( i=$nparity; i<$nparity*2; i=i+1 )); do
	- log_must zpool replace -fw $pool $dir/dev-$i
	- done
	-
	- log_must check_pool_status $pool "errors" "No known data errors"
	- resilver_cksum=$(cksum_pool $pool)
	- if [[ $resilver_cksum != 0 ]]; then
	- log_must zpool status -v $pool
	- log_fail "resilver cksum errors: $resilver_cksum"
	- fi
	-
	- log_must zpool clear $pool
	-}
	-
	-function test_scrub # <pool> <parity> <dir>
	-{
	- typeset pool=$1
	- typeset nparity=$2
	- typeset dir=$3
	- typeset combrec=$4
	-
	- log_must zpool export $pool
	-
	- for (( i=0; i<$nparity; i=i+1 )); do
	- dd conv=notrunc if=/dev/zero of=$dir/dev-$i \
	- bs=1M seek=4 count=$(($dev_size_mb-4))
	- done
	-
	- log_must zpool import -o cachefile=none -d $dir $pool
	-
	log_must zpool scrub -w $pool
	- log_must check_pool_status $pool "errors" "No known data errors"
	-
	- log_must zpool clear $pool
	-
	- log_must zpool export $pool
	-
	- for (( i=$nparity; i<$nparity*2; i=i+1 )); do
	- dd conv=notrunc if=/dev/zero of=$dir/dev-$i \
	- bs=1M seek=4 count=$(($dev_size_mb-4))
	- done

	- log_must zpool import -o cachefile=none -d $dir $pool
	+ # When only a single child was overwritten the sequential resilver
	+ # can fully repair the damange from parity and the scrub will have
	+ # nothing to repair. When multiple children are silently damaged
	+ # the sequential resilver will calculate the wrong data since only
	+ # the parity information is used and it cannot be verified with
	+ # the checksum. However, since only the resilvering devices are
	+ # written to with the bad data a subsequent scrub will be able to
	+ # fully repair the pool.
	+ #
	+ if [[ $nparity == 1 ]]; then
	+ log_must check_pool_status $pool "scan" "repaired 0B"
	+ else
	+ log_mustnot check_pool_status $pool "scan" "repaired 0B"
	+ fi

	- log_must zpool scrub -w $pool
	log_must check_pool_status $pool "errors" "No known data errors"
	-
	- log_must zpool clear $pool
	+ log_must check_pool_status $pool "scan" "with 0 errors"
	}

	log_onexit cleanup

	log_must set_tunable32 PREFETCH_DISABLE 1
	+log_must set_tunable32 REBUILD_SCRUB_ENABLED 0

	# Disk files which will be used by pool
	for i in {0..$(($devs - 1))}; do
	device=$TEST_BASE_DIR/dev-$i
	log_must truncate -s ${dev_size_mb}M $device
	disks[${#disks[*]}+1]=$device
	done

	# Disk file which will be attached
	log_must truncate -s 512M $TEST_BASE_DIR/dev-$devs

	for nparity in 1 2 3; do
	- raid=raidz$nparity
	+ raid=draid${nparity}:${nparity}s
	dir=$TEST_BASE_DIR

	log_must zpool create -f -o cachefile=none $TESTPOOL $raid ${disks[@]}
	log_must zfs set primarycache=metadata $TESTPOOL

	log_must zfs create $TESTPOOL/fs
	log_must fill_fs /$TESTPOOL/fs 1 512 100 1024 R

	log_must zfs create -o compress=on $TESTPOOL/fs2
	log_must fill_fs /$TESTPOOL/fs2 1 512 100 1024 R

	log_must zfs create -o compress=on -o recordsize=8k $TESTPOOL/fs3
	log_must fill_fs /$TESTPOOL/fs3 1 512 100 1024 R

	- typeset pool_size=$(get_pool_prop size $TESTPOOL)
	-
	log_must zpool export $TESTPOOL
	log_must zpool import -o cachefile=none -d $dir $TESTPOOL

	log_must check_pool_status $TESTPOOL "errors" "No known data errors"

	- test_resilver $TESTPOOL $nparity $dir
	- test_scrub $TESTPOOL $nparity $dir
	+ test_sequential_resilver $TESTPOOL $nparity $dir

	log_must zpool destroy "$TESTPOOL"
	done

	-log_pass "raidz redundancy test succeeded."
	+log_pass "draid damaged device(s) test succeeded."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/redundancy_draid_spare1.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/redundancy_draid_spare1.ksh
	index 3b7951596dbb..8acee1567957 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/redundancy_draid_spare1.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/redundancy_draid_spare1.ksh
	@@ -1,107 +1,98 @@
	#!/bin/ksh -p

	#
	# CDDL HEADER START
	#
	# This file and its contents are supplied under the terms of the
	# Common Development and Distribution License ("CDDL"), version 1.0.
	# You may only use this file in accordance with the terms of version
	# 1.0 of the CDDL.
	#
	# A full copy of the text of the CDDL should have accompanied this
	# source. A copy of the CDDL is also available via the Internet at
	# http://www.illumos.org/license/CDDL.
	#
	# CDDL HEADER END
	#

	#
	# Copyright (c) 2019, Datto Inc. All rights reserved.
	# Copyright (c) 2020 by Lawrence Livermore National Security, LLC.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/redundancy/redundancy.kshlib

	#
	# DESCRIPTION:
	# Verify resilver to dRAID distributed spares.
	#
	# STRATEGY:
	# 1. For resilvers:
	# a. Create a semi-random dRAID pool configuration which can:
	# - sustain N failures (1-3), and
	# - has N distributed spares to replace all faulted vdevs
	# b. Fill the pool with data
	# c. Systematically fault a vdev, then replace it with a spare
	# d. Scrub the pool to verify no data was lost
	# e. Verify the contents of files in the pool
	#

	log_assert "Verify resilver to dRAID distributed spares"

	-log_onexit cleanup
	+function cleanup_tunable
	+{
	+ log_must set_tunable32 REBUILD_SCRUB_ENABLED 1
	+ cleanup
	+}
	+
	+log_onexit cleanup_tunable
	+
	+log_must set_tunable32 REBUILD_SCRUB_ENABLED 0

	for replace_mode in "healing" "sequential"; do

	if [[ "$replace_mode" = "sequential" ]]; then
	flags="-s"
	else
	flags=""
	fi

	parity=$(random_int_between 1 3)
	spares=$(random_int_between $parity 3)
	data=$(random_int_between 1 8)

	(( min_children = (data + parity + spares) ))
	children=$(random_int_between $min_children 16)

	draid="draid${parity}:${data}d:${children}c:${spares}s"

	setup_test_env $TESTPOOL $draid $children

	i=0
	while [[ $i -lt $spares ]]; do
	fault_vdev="$BASEDIR/vdev$i"
	spare_vdev="draid${parity}-0-${i}"

	log_must zpool offline -f $TESTPOOL $fault_vdev
	log_must check_vdev_state $TESTPOOL $fault_vdev "FAULTED"
	log_must zpool replace -w $flags $TESTPOOL \
	$fault_vdev $spare_vdev
	log_must check_vdev_state spare-$i "DEGRADED"
	log_must check_vdev_state $spare_vdev "ONLINE"
	log_must check_hotspare_state $TESTPOOL $spare_vdev "INUSE"
	log_must zpool detach $TESTPOOL $fault_vdev
	-
	- resilver_cksum=$(cksum_pool $TESTPOOL)
	- if [[ $resilver_cksum != 0 ]]; then
	- log_must zpool status -v $TESTPOOL
	- log_fail "$replace_mode resilver "
	- "cksum errors: $resilver_cksum"
	- fi
	-
	- if [[ "$replace_mode" = "healing" ]]; then
	- log_must zpool scrub $TESTPOOL
	- fi
	-
	- log_must wait_scrubbed $TESTPOOL
	+ log_must verify_pool $TESTPOOL
	log_must check_pool_status $TESTPOOL "scan" "repaired 0B"
	log_must check_pool_status $TESTPOOL "scan" "with 0 errors"

	- scrub_cksum=$(cksum_pool $TESTPOOL)
	- if [[ $scrub_cksum != 0 ]]; then
	- log_must zpool status -v $TESTPOOL
	- log_fail "scrub cksum errors: $scrub_cksum"
	- fi
	-
	(( i += 1 ))
	done

	log_must is_data_valid $TESTPOOL
	+ log_must check_pool_status $TESTPOOL "errors" "No known data errors"

	cleanup
	done

	log_pass "Verify resilver to dRAID distributed spares"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/redundancy_draid_spare3.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/redundancy_draid_spare3.ksh
	index 587a1be0a66a..28e8e3c6d707 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/redundancy_draid_spare3.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/redundancy_draid_spare3.ksh
	@@ -1,197 +1,193 @@
	#!/bin/ksh -p

	#
	# CDDL HEADER START
	#
	# This file and its contents are supplied under the terms of the
	# Common Development and Distribution License ("CDDL"), version 1.0.
	# You may only use this file in accordance with the terms of version
	# 1.0 of the CDDL.
	#
	# A full copy of the text of the CDDL should have accompanied this
	# source. A copy of the CDDL is also available via the Internet at
	# http://www.illumos.org/license/CDDL.
	#
	# CDDL HEADER END
	#

	#
	# Copyright (c) 2020 by Lawrence Livermore National Security, LLC.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/redundancy/redundancy.kshlib

	#
	# DESCRIPTION:
	# Verify dRAID resilver to traditional and distributed spares for
	# a variety of pool configurations and pool states.
	#
	# STRATEGY:
	# 1. For resilvers:
	# a. Create a semi-random dRAID pool configuration which can
	# sustain 1 failure and has 5 distributed spares.
	# b. Fill the pool with data
	# c. Systematically fault and replace vdevs in the pools with
	# spares to test resilving in common pool states.
	# d. Scrub the pool to verify no data was lost
	# e. Verify the contents of files in the pool
	#

	log_assert "Verify dRAID resilver"

	function cleanup_tunable
	{
	log_must set_tunable32 REBUILD_SCRUB_ENABLED 1
	cleanup
	}

	log_onexit cleanup_tunable

	if is_kmemleak; then
	log_unsupported "Test case runs slowly when kmemleak is enabled"
	fi

	#
	# Disable scrubbing after a sequential resilver to verify the resilver
	# alone is able to reconstruct the data without the help of a scrub.
	#
	log_must set_tunable32 REBUILD_SCRUB_ENABLED 0

	for replace_mode in "healing" "sequential"; do

	if [[ "$replace_mode" = "sequential" ]]; then
	flags="-s"
	else
	flags=""
	fi

	parity=1
	spares=5
	data=$(random_int_between 1 4)
	children=10
	draid="draid${parity}:${data}d:${children}c:${spares}s"

	setup_test_env $TESTPOOL $draid $children

	#
	# Perform a variety of replacements to normal and distributed spares
	# for a variety of different vdev configurations to exercise different
	# resilver code paths. The final configuration is expected to be:
	#
	# NAME STATE READ WRITE CKSUM
	# testpool DEGRADED 0 0 0
	# draid1:1d:10c:5s-0 DEGRADED 0 0 0
	# /var/tmp/basedir.28683/new_vdev0 ONLINE 0 0 0
	# /var/tmp/basedir.28683/new_vdev1 ONLINE 0 0 0
	# spare-2 DEGRADED 0 0 0
	# /var/tmp/basedir.28683/vdev2 FAULTED 0 0 0
	# draid1-0-3 ONLINE 0 0 0
	# spare-3 DEGRADED 0 0 0
	# /var/tmp/basedir.28683/vdev3 FAULTED 0 0 0
	# draid1-0-4 ONLINE 0 0 0
	# /var/tmp/basedir.28683/vdev4 ONLINE 0 0 0
	# /var/tmp/basedir.28683/vdev5 ONLINE 0 0 0
	# /var/tmp/basedir.28683/vdev6 ONLINE 0 0 0
	# draid1-0-0 ONLINE 0 0 0
	# spare-8 DEGRADED 0 0 0
	# /var/tmp/basedir.28683/vdev8 FAULTED 0 0 0
	# draid1-0-1 ONLINE 0 0 0
	# spare-9 ONLINE 0 0 0
	# /var/tmp/basedir.28683/vdev9 ONLINE 0 0 0
	# draid1-0-2 ONLINE 0 0 0
	# spares
	# draid1-0-0 INUSE currently in use
	# draid1-0-1 INUSE currently in use
	# draid1-0-2 INUSE currently in use
	# draid1-0-3 INUSE currently in use
	# draid1-0-4 INUSE currently in use
	#

	# Distributed spare which replaces original online device
	log_must check_vdev_state $TESTPOOL $BASEDIR/vdev7 "ONLINE"
	log_must zpool replace -w $flags $TESTPOOL $BASEDIR/vdev7 draid1-0-0
	log_must zpool detach $TESTPOOL $BASEDIR/vdev7
	log_must check_vdev_state $TESTPOOL draid1-0-0 "ONLINE"
	log_must check_hotspare_state $TESTPOOL draid1-0-0 "INUSE"
	+ log_must verify_pool $TESTPOOL
	+ log_must check_pool_status $TESTPOOL "scan" "repaired 0B"
	+ log_must check_pool_status $TESTPOOL "scan" "with 0 errors"

	# Distributed spare in mirror with original device faulted
	log_must zpool offline -f $TESTPOOL $BASEDIR/vdev8
	log_must check_vdev_state $TESTPOOL $BASEDIR/vdev8 "FAULTED"
	log_must zpool replace -w $flags $TESTPOOL $BASEDIR/vdev8 draid1-0-1
	log_must check_vdev_state $TESTPOOL spare-8 "DEGRADED"
	log_must check_vdev_state $TESTPOOL draid1-0-1 "ONLINE"
	log_must check_hotspare_state $TESTPOOL draid1-0-1 "INUSE"
	+ log_must verify_pool $TESTPOOL
	+ log_must check_pool_status $TESTPOOL "scan" "repaired 0B"
	+ log_must check_pool_status $TESTPOOL "scan" "with 0 errors"

	# Distributed spare in mirror with original device still online
	log_must check_vdev_state $TESTPOOL $BASEDIR/vdev9 "ONLINE"
	log_must zpool replace -w $flags $TESTPOOL $BASEDIR/vdev9 draid1-0-2
	log_must check_vdev_state $TESTPOOL spare-9 "ONLINE"
	log_must check_vdev_state $TESTPOOL draid1-0-2 "ONLINE"
	log_must check_hotspare_state $TESTPOOL draid1-0-2 "INUSE"
	+ log_must verify_pool $TESTPOOL
	+ log_must check_pool_status $TESTPOOL "scan" "repaired 0B"
	+ log_must check_pool_status $TESTPOOL "scan" "with 0 errors"

	# Normal faulted device replacement
	new_vdev0="$BASEDIR/new_vdev0"
	log_must truncate -s $MINVDEVSIZE $new_vdev0
	log_must zpool offline -f $TESTPOOL $BASEDIR/vdev0
	log_must check_vdev_state $TESTPOOL $BASEDIR/vdev0 "FAULTED"
	log_must zpool replace -w $flags $TESTPOOL $BASEDIR/vdev0 $new_vdev0
	log_must check_vdev_state $TESTPOOL $new_vdev0 "ONLINE"
	+ log_must verify_pool $TESTPOOL
	+ log_must check_pool_status $TESTPOOL "scan" "repaired 0B"
	+ log_must check_pool_status $TESTPOOL "scan" "with 0 errors"

	# Distributed spare faulted device replacement
	log_must zpool offline -f $TESTPOOL $BASEDIR/vdev2
	log_must check_vdev_state $TESTPOOL $BASEDIR/vdev2 "FAULTED"
	log_must zpool replace -w $flags $TESTPOOL $BASEDIR/vdev2 draid1-0-3
	log_must check_vdev_state $TESTPOOL spare-2 "DEGRADED"
	log_must check_vdev_state $TESTPOOL draid1-0-3 "ONLINE"
	log_must check_hotspare_state $TESTPOOL draid1-0-3 "INUSE"
	+ log_must verify_pool $TESTPOOL
	+ log_must check_pool_status $TESTPOOL "scan" "repaired 0B"
	+ log_must check_pool_status $TESTPOOL "scan" "with 0 errors"

	# Normal online device replacement
	new_vdev1="$BASEDIR/new_vdev1"
	log_must truncate -s $MINVDEVSIZE $new_vdev1
	log_must check_vdev_state $TESTPOOL $BASEDIR/vdev1 "ONLINE"
	log_must zpool replace -w $flags $TESTPOOL $BASEDIR/vdev1 $new_vdev1
	log_must check_vdev_state $TESTPOOL $new_vdev1 "ONLINE"
	+ log_must verify_pool $TESTPOOL
	+ log_must check_pool_status $TESTPOOL "scan" "repaired 0B"
	+ log_must check_pool_status $TESTPOOL "scan" "with 0 errors"

	# Distributed spare online device replacement (then fault)
	log_must zpool replace -w $flags $TESTPOOL $BASEDIR/vdev3 draid1-0-4
	log_must check_vdev_state $TESTPOOL spare-3 "ONLINE"
	log_must check_vdev_state $TESTPOOL draid1-0-4 "ONLINE"
	log_must check_hotspare_state $TESTPOOL draid1-0-4 "INUSE"
	log_must zpool offline -f $TESTPOOL $BASEDIR/vdev3
	log_must check_vdev_state $TESTPOOL $BASEDIR/vdev3 "FAULTED"
	log_must check_vdev_state $TESTPOOL spare-3 "DEGRADED"
	-
	- resilver_cksum=$(cksum_pool $TESTPOOL)
	- if [[ $resilver_cksum != 0 ]]; then
	- log_must zpool status -v $TESTPOOL
	- log_fail "$replace_mode resilver cksum errors: $resilver_cksum"
	- fi
	-
	- if [[ "$replace_mode" = "healing" ]]; then
	- log_must zpool scrub -w $TESTPOOL
	- else
	- if [[ $(get_tunable REBUILD_SCRUB_ENABLED) -eq 0 ]]; then
	- log_must zpool scrub -w $TESTPOOL
	- else
	- log_must wait_scrubbed $TESTPOOL
	- fi
	- fi
	-
	- log_must is_pool_scrubbed $TESTPOOL
	-
	- scrub_cksum=$(cksum_pool $TESTPOOL)
	- if [[ $scrub_cksum != 0 ]]; then
	- log_must zpool status -v $TESTPOOL
	- log_fail "scrub cksum errors: $scrub_cksum"
	- fi
	-
	+ log_must verify_pool $TESTPOOL
	log_must check_pool_status $TESTPOOL "scan" "repaired 0B"
	log_must check_pool_status $TESTPOOL "scan" "with 0 errors"

	+ # Verify the original data is valid
	log_must is_data_valid $TESTPOOL
	+ log_must check_pool_status $TESTPOOL "errors" "No known data errors"

	cleanup
	done

	log_pass "Verify resilver to dRAID distributed spares"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/redundancy_raidz.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/redundancy_raidz.ksh
	index 8d32e0603ae8..d73688391624 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/redundancy_raidz.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/redundancy_raidz.ksh
	@@ -1,198 +1,248 @@
	#!/bin/ksh -p
	#
	# 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) 2020 by vStack. All rights reserved.
	# Copyright (c) 2021 by Delphix. All rights reserved.
	+# Copyright (c) 2021 by Lawrence Livermore National Security, LLC.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/redundancy/redundancy.kshlib

	#
	# DESCRIPTION:
	# RAIDZ should provide redundancy
	#
	# STRATEGY:
	# 1. Create block device files for the test raidz pool
	# 2. For each parity value [1..3]
	# - create raidz pool
	# - fill it with some directories/files
	+# - verify self-healing by overwriting devices
	# - verify resilver by replacing devices
	# - verify scrub by zeroing devices
	# - destroy the raidz pool

	typeset -r devs=6
	typeset -r dev_size_mb=512

	typeset -a disks

	prefetch_disable=$(get_tunable PREFETCH_DISABLE)

	function cleanup
	{
	poolexists "$TESTPOOL" && destroy_pool "$TESTPOOL"

	for i in {0..$devs}; do
	rm -f "$TEST_BASE_DIR/dev-$i"
	done

	set_tunable32 PREFETCH_DISABLE $prefetch_disable
	}

	+function test_selfheal # <pool> <parity> <dir>
	+{
	+ typeset pool=$1
	+ typeset nparity=$2
	+ typeset dir=$3
	+
	+ log_must zpool export $pool
	+
	+ for (( i=0; i<$nparity; i=i+1 )); do
	+ log_must dd conv=notrunc if=/dev/zero of=$dir/dev-$i \
	+ bs=1M seek=4 count=$(($dev_size_mb-4))
	+ done
	+
	+ log_must zpool import -o cachefile=none -d $dir $pool
	+
	+ typeset mntpnt=$(get_prop mountpoint $pool/fs)
	+ log_must find $mntpnt -type f -exec cksum {} + >> /dev/null 2>&1
	+ log_must check_pool_status $pool "errors" "No known data errors"
	+
	+ #
	+ # Scrub the pool because the find command will only self-heal blocks
	+ # from the files which were read. Before overwriting additional
	+ # devices we need to repair all of the blocks in the pool.
	+ #
	+ log_must zpool scrub -w $pool
	+ log_must check_pool_status $pool "errors" "No known data errors"
	+
	+ log_must zpool clear $pool
	+
	+ log_must zpool export $pool
	+
	+ for (( i=$nparity; i<$nparity*2; i=i+1 )); do
	+ log_must dd conv=notrunc if=/dev/zero of=$dir/dev-$i \
	+ bs=1M seek=4 count=$(($dev_size_mb-4))
	+ done
	+
	+ log_must zpool import -o cachefile=none -d $dir $pool
	+
	+ typeset mntpnt=$(get_prop mountpoint $pool/fs)
	+ log_must find $mntpnt -type f -exec cksum {} + >> /dev/null 2>&1
	+ log_must check_pool_status $pool "errors" "No known data errors"
	+
	+ log_must zpool scrub -w $pool
	+ log_must check_pool_status $pool "errors" "No known data errors"
	+
	+ log_must zpool clear $pool
	+}
	+
	function test_resilver # <pool> <parity> <dir>
	{
	typeset pool=$1
	typeset nparity=$2
	typeset dir=$3

	for (( i=0; i<$nparity; i=i+1 )); do
	log_must zpool offline $pool $dir/dev-$i
	done

	log_must zpool export $pool

	for (( i=0; i<$nparity; i=i+1 )); do
	log_must zpool labelclear -f $dir/dev-$i
	done

	log_must zpool import -o cachefile=none -d $dir $pool

	for (( i=0; i<$nparity; i=i+1 )); do
	log_must zpool replace -fw $pool $dir/dev-$i
	done

	log_must check_pool_status $pool "errors" "No known data errors"
	resilver_cksum=$(cksum_pool $pool)
	if [[ $resilver_cksum != 0 ]]; then
	log_must zpool status -v $pool
	log_fail "resilver cksum errors: $resilver_cksum"
	fi

	log_must zpool clear $pool

	for (( i=$nparity; i<$nparity*2; i=i+1 )); do
	log_must zpool offline $pool $dir/dev-$i
	done

	log_must zpool export $pool

	for (( i=$nparity; i<$nparity*2; i=i+1 )); do
	log_must zpool labelclear -f $dir/dev-$i
	done

	log_must zpool import -o cachefile=none -d $dir $pool

	for (( i=$nparity; i<$nparity*2; i=i+1 )); do
	log_must zpool replace -fw $pool $dir/dev-$i
	done

	log_must check_pool_status $pool "errors" "No known data errors"
	resilver_cksum=$(cksum_pool $pool)
	if [[ $resilver_cksum != 0 ]]; then
	log_must zpool status -v $pool
	log_fail "resilver cksum errors: $resilver_cksum"
	fi

	log_must zpool clear $pool
	}

	function test_scrub # <pool> <parity> <dir>
	{
	typeset pool=$1
	typeset nparity=$2
	typeset dir=$3
	- typeset combrec=$4

	log_must zpool export $pool

	for (( i=0; i<$nparity; i=i+1 )); do
	dd conv=notrunc if=/dev/zero of=$dir/dev-$i \
	bs=1M seek=4 count=$(($dev_size_mb-4))
	done

	log_must zpool import -o cachefile=none -d $dir $pool

	log_must zpool scrub -w $pool
	log_must check_pool_status $pool "errors" "No known data errors"

	log_must zpool clear $pool

	log_must zpool export $pool

	for (( i=$nparity; i<$nparity*2; i=i+1 )); do
	dd conv=notrunc if=/dev/zero of=$dir/dev-$i \
	bs=1M seek=4 count=$(($dev_size_mb-4))
	done

	log_must zpool import -o cachefile=none -d $dir $pool

	log_must zpool scrub -w $pool
	log_must check_pool_status $pool "errors" "No known data errors"

	log_must zpool clear $pool
	}

	log_onexit cleanup

	log_must set_tunable32 PREFETCH_DISABLE 1

	# Disk files which will be used by pool
	for i in {0..$(($devs - 1))}; do
	device=$TEST_BASE_DIR/dev-$i
	log_must truncate -s ${dev_size_mb}M $device
	disks[${#disks[*]}+1]=$device
	done

	# Disk file which will be attached
	log_must truncate -s 512M $TEST_BASE_DIR/dev-$devs

	for nparity in 1 2 3; do
	raid=raidz$nparity
	dir=$TEST_BASE_DIR

	log_must zpool create -f -o cachefile=none $TESTPOOL $raid ${disks[@]}
	log_must zfs set primarycache=metadata $TESTPOOL

	log_must zfs create $TESTPOOL/fs
	log_must fill_fs /$TESTPOOL/fs 1 512 100 1024 R

	log_must zfs create -o compress=on $TESTPOOL/fs2
	log_must fill_fs /$TESTPOOL/fs2 1 512 100 1024 R

	log_must zfs create -o compress=on -o recordsize=8k $TESTPOOL/fs3
	log_must fill_fs /$TESTPOOL/fs3 1 512 100 1024 R

	typeset pool_size=$(get_pool_prop size $TESTPOOL)

	log_must zpool export $TESTPOOL
	log_must zpool import -o cachefile=none -d $dir $TESTPOOL

	log_must check_pool_status $TESTPOOL "errors" "No known data errors"

	+ test_selfheal $TESTPOOL $nparity $dir
	test_resilver $TESTPOOL $nparity $dir
	test_scrub $TESTPOOL $nparity $dir

	log_must zpool destroy "$TESTPOOL"
	done

	log_pass "raidz redundancy test succeeded."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/redundancy_stripe.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/redundancy_stripe.ksh
	index 7ee51051ea1a..b2c4a85febef 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/redundancy_stripe.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/redundancy/redundancy_stripe.ksh
	@@ -1,62 +1,64 @@
	#!/bin/ksh -p
	#
	# 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 2007 Sun Microsystems, Inc. All rights reserved.
	# Use is subject to license terms.
	#

	#
	# Copyright (c) 2013, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/redundancy/redundancy.kshlib

	#
	# DESCRIPTION:
	# Striped pool have no data redundancy. Any device errors will
	# cause data corruption.
	#
	# STRATEGY:
	# 1. Create N virtual disk file.
	# 2. Create stripe pool based on the virtual disk files.
	# 3. Fill the filesystem with directories and files.
	# 4. Record all the files and directories checksum information.
	# 5. Damage one of the virtual disk file.
	# 6. Verify the data is error.
	#

	verify_runnable "global"

	log_assert "Verify striped pool have no data redundancy."
	log_onexit cleanup

	typeset -i cnt=$(random_int_between 2 5)
	setup_test_env $TESTPOOL "" $cnt

	damage_devs $TESTPOOL 1 "keep_label"
	log_must zpool scrub -w $TESTPOOL

	-log_mustnot is_healthy $TESTPOOL
	+if is_healthy $TESTPOOL ; then
	+ log_fail "$pool should not be healthy."
	+fi

	log_pass "Striped pool has no data redundancy as expected."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/removal/removal_condense_export.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/removal/removal_condense_export.ksh
	index 7648900acf10..8de17ff2e8a1 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/removal/removal_condense_export.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/removal/removal_condense_export.ksh
	@@ -1,93 +1,95 @@
	#! /bin/ksh -p
	#
	# CDDL HEADER START
	#
	# This file and its contents are supplied under the terms of the
	# Common Development and Distribution License ("CDDL"), version 1.0.
	# You may only use this file in accordance with the terms of version
	# 1.0 of the CDDL.
	#
	# A full copy of the text of the CDDL should have accompanied this
	# source. A copy of the CDDL is also available via the Internet at
	# http://www.illumos.org/license/CDDL.
	#
	# CDDL HEADER END
	#

	#
	# Copyright (c) 2015, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/removal/removal.kshlib

	function reset
	{
	log_must set_tunable64 CONDENSE_INDIRECT_COMMIT_ENTRY_DELAY_MS 0
	+ log_must set_tunable64 CONDENSE_INDIRECT_OBSOLETE_PCT 25
	log_must set_tunable64 CONDENSE_MIN_MAPPING_BYTES 131072
	default_cleanup_noexit
	}

	default_setup_noexit "$DISKS" "true"
	log_onexit reset
	log_must set_tunable64 CONDENSE_INDIRECT_COMMIT_ENTRY_DELAY_MS 5000
	+log_must set_tunable64 CONDENSE_INDIRECT_OBSOLETE_PCT 5
	log_must set_tunable64 CONDENSE_MIN_MAPPING_BYTES 1

	log_must zfs set recordsize=512 $TESTPOOL/$TESTFS

	#
	# Create a large file so that we know some of the blocks will be on the
	# removed device, and hence eligible for remapping.
	#
	log_must dd if=/dev/urandom of=$TESTDIR/file bs=1024k count=10

	#
	# Create a file in the other filesystem, which will not be remapped.
	#
	log_must dd if=/dev/urandom of=$TESTDIR1/file bs=1024k count=10

	#
	# Randomly rewrite some of blocks in the file so that there will be holes and
	# we will not be able to remap the entire file in a few huge chunks.
	#
	for i in {1..4096}; do
	#
	# We have to sync periodically so that all the writes don't end up in
	# the same txg. If they were all in the same txg, only the last write
	# would go through and we would not have as many allocations to
	# fragment the file.
	#
	((i % 100 > 0 )) \|\| sync_pool $TESTPOOL \|\| log_fail "Could not sync."
	random_write $TESTDIR/file 512 \|\| \
	log_fail "Could not random write."
	done

	REMOVEDISKPATH=/dev
	case $REMOVEDISK in
	/*)
	REMOVEDISKPATH=$(dirname $REMOVEDISK)
	;;
	esac

	log_must zpool remove $TESTPOOL $REMOVEDISK
	log_must wait_for_removal $TESTPOOL
	log_mustnot vdevs_in_pool $TESTPOOL $REMOVEDISK

	#
	# Touch one block under each L1 indirect block, so that the other data blocks
	# will be remapped to their concrete locations. These parameters assume
	# recordsize=512, indirect block size of 128K (1024 block pointers per
	# indirect block), and file size of less than 20*1024 blocks (10MB).
	#
	log_must stride_dd -i /dev/urandom -o $TESTDIR/file -b 512 -c 20 -s 1024

	sync_pool $TESTPOOL
	sleep 4
	sync_pool $TESTPOOL
	log_must zpool export $TESTPOOL
	zdb -e -p $REMOVEDISKPATH $TESTPOOL \| grep 'Condensing indirect vdev' \|\| \
	log_fail "Did not export during a condense."
	log_must zdb -e -p $REMOVEDISKPATH -cudi $TESTPOOL
	log_must zpool import $TESTPOOL

	log_pass "Pool can be exported in the middle of a condense."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/removal/removal_with_export.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/removal/removal_with_export.ksh
	index 0ec358aadba9..f76f76d34f5b 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/removal/removal_with_export.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/removal/removal_with_export.ksh
	@@ -1,47 +1,47 @@
	#! /bin/ksh -p
	#
	# CDDL HEADER START
	#
	# This file and its contents are supplied under the terms of the
	# Common Development and Distribution License ("CDDL"), version 1.0.
	# You may only use this file in accordance with the terms of version
	# 1.0 of the CDDL.
	#
	# A full copy of the text of the CDDL should have accompanied this
	# source. A copy of the CDDL is also available via the Internet at
	# http://www.illumos.org/license/CDDL.
	#
	# CDDL HEADER END
	#

	#
	# Copyright (c) 2014, 2017 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/removal/removal.kshlib

	default_setup_noexit "$DISKS"
	log_onexit default_cleanup_noexit

	function callback
	{
	- is_linux && test_removal_with_operation_kill
	+ test_removal_with_operation_kill
	log_must zpool export $TESTPOOL

	#
	# We are concurrently starting dd processes that will
	# create files in $TESTDIR. These could cause the import
	# to fail because it can't mount on the filesystem on a
	# non-empty directory. Therefore, remove the directory
	# so that the dd process will fail.
	#
	log_must rm -rf $TESTDIR

	log_must zpool import $TESTPOOL
	return 0
	}

	test_removal_with_operation callback

	log_pass "Can export and import pool during removal"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/replacement/attach_multiple.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/replacement/attach_multiple.ksh
	index b3192b2bfbda..5c3835349173 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/replacement/attach_multiple.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/replacement/attach_multiple.ksh
	@@ -1,111 +1,111 @@
	#!/bin/ksh

	#
	# This file and its contents are supplied under the terms of the
	# Common Development and Distribution License ("CDDL"), version 1.0.
	# You may only use this file in accordance with the terms of version
	# 1.0 of the CDDL.
	#
	# A full copy of the text of the CDDL should have accompanied this
	# source. A copy of the CDDL is also available via the Internet at
	# http://www.illumos.org/license/CDDL.
	#

	#
	# Copyright (c) 2019, Datto Inc. All rights reserved.
	# Copyright (c) 2020 by Lawrence Livermore National Security, LLC.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/replacement/replacement.cfg

	#
	# Description:
	# Verify that attach/detach work while resilvering and attaching
	# multiple vdevs.
	#
	# Strategy:
	# 1. Create a single vdev pool
	# 2. While healing or sequential resilvering:
	# a. Attach a vdev to convert the pool to a mirror.
	# b. Attach a vdev to convert the pool to a 3-way mirror.
	# c. Verify the original vdev cannot be removed (no redundant copies)
	# d. Detach a vdev. Healing and sequential resilver remain running.
	# e. Detach a vdev. Healing resilver remains running, sequential
	# resilver is canceled.
	# f. Wait for resilver to complete.
	#

	function cleanup
	{
	log_must set_tunable32 SCAN_SUSPEND_PROGRESS \
	$ORIG_SCAN_SUSPEND_PROGRESS
	destroy_pool $TESTPOOL1
	rm -f ${VDEV_FILES[@]}
	}

	-log_assert "Verify attach/detech with multiple vdevs"
	+log_assert "Verify attach/detach with multiple vdevs"

	ORIG_SCAN_SUSPEND_PROGRESS=$(get_tunable SCAN_SUSPEND_PROGRESS)

	log_onexit cleanup

	log_must truncate -s $VDEV_FILE_SIZE ${VDEV_FILES[@]}

	# Verify resilver resumes on import.
	log_must zpool create -f $TESTPOOL1 ${VDEV_FILES[0]}

	for replace_mode in "healing" "sequential"; do
	#
	# Resilvers abort the dsl_scan and reconfigure it for resilvering.
	# Rebuilds cancel the dsl_scan and start the vdev_rebuild thread.
	#
	if [[ "$replace_mode" = "healing" ]]; then
	flags=""
	else
	flags="-s"
	fi

	log_mustnot is_pool_resilvering $TESTPOOL1
	log_must set_tunable32 SCAN_SUSPEND_PROGRESS 1

	# Attach first vdev (stripe -> mirror)
	log_must zpool attach $flags $TESTPOOL1 \
	${VDEV_FILES[0]} ${VDEV_FILES[1]}
	log_must is_pool_resilvering $TESTPOOL1

	# Attach second vdev (2-way -> 3-way mirror)
	log_must zpool attach $flags $TESTPOOL1 \
	${VDEV_FILES[1]} ${VDEV_FILES[2]}
	log_must is_pool_resilvering $TESTPOOL1

	- # Original vdev cannot be detached until there is sufficent redundancy.
	+ # Original vdev cannot be detached until there is sufficient redundancy.
	log_mustnot zpool detach $TESTPOOL1 ${VDEV_FILES[0]}

	# Detach first vdev (resilver keeps running)
	log_must zpool detach $TESTPOOL1 ${VDEV_FILES[1]}
	log_must is_pool_resilvering $TESTPOOL1

	#
	# Detach second vdev. There's a difference in behavior between
	# healing and sequential resilvers. A healing resilver will not be
	# cancelled even though there's nothing on the original vdev which
	# needs to be rebuilt. A sequential resilver on the otherhand is
	# canceled when returning to a non-redundant striped layout. At
	# some point the healing resilver behavior should be updated to match
	# the sequential resilver behavior.
	#
	log_must zpool detach $TESTPOOL1 ${VDEV_FILES[2]}

	if [[ "$replace_mode" = "healing" ]]; then
	log_must is_pool_resilvering $TESTPOOL1
	else
	log_mustnot is_pool_resilvering $TESTPOOL1
	fi

	log_must set_tunable32 SCAN_SUSPEND_PROGRESS \
	$ORIG_SCAN_SUSPEND_PROGRESS
	log_must zpool wait $TESTPOOL1
	done

	-log_pass "Verify attach/detech with multiple vdevs"
	+log_pass "Verify attach/detach with multiple vdevs"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/replacement/replace_import.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/replacement/replace_import.ksh
	index 35d51d93938b..37d3c6645c3f 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/replacement/replace_import.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/replacement/replace_import.ksh
	@@ -1,67 +1,67 @@
	#!/bin/ksh

	#
	# This file and its contents are supplied under the terms of the
	# Common Development and Distribution License ("CDDL"), version 1.0.
	# You may only use this file in accordance with the terms of version
	# 1.0 of the CDDL.
	#
	# A full copy of the text of the CDDL should have accompanied this
	# source. A copy of the CDDL is also available via the Internet at
	# http://www.illumos.org/license/CDDL.
	#

	#
	# Copyright (c) 2019, Datto Inc. All rights reserved.
	# Copyright (c) 2020 by Lawrence Livermore National Security, LLC.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/replacement/replacement.cfg

	#
	# Description:
	# Verify that on import an in progress replace operation is resumed.
	#
	# Strategy:
	# 1. For both healing and sequential resilvering replace:
	# a. Create a pool
	-# b. Repalce a vdev with 'zpool replace' to resilver (-s) it.
	+# b. Replace a vdev with 'zpool replace' to resilver (-s) it.
	# c. Export the pool
	# d. Import the pool
	# e. Verify the 'zpool replace' resumed resilvering.
	# f. Destroy the pool
	#

	function cleanup
	{
	log_must set_tunable32 SCAN_SUSPEND_PROGRESS \
	$ORIG_SCAN_SUSPEND_PROGRESS
	destroy_pool $TESTPOOL1
	rm -f ${VDEV_FILES[@]} $SPARE_VDEV_FILE
	}

	log_assert "Verify replace is resumed on import"

	ORIG_SCAN_SUSPEND_PROGRESS=$(get_tunable SCAN_SUSPEND_PROGRESS)

	log_onexit cleanup

	log_must truncate -s $VDEV_FILE_SIZE ${VDEV_FILES[@]} $SPARE_VDEV_FILE

	# Verify healing and sequential resilver resume on import.
	for arg in "" "-s"; do
	log_must zpool create -f $TESTPOOL1 ${VDEV_FILES[@]}
	log_must set_tunable32 SCAN_SUSPEND_PROGRESS 1
	log_must zpool replace -s $TESTPOOL1 ${VDEV_FILES[0]} $SPARE_VDEV_FILE
	log_must is_pool_resilvering $TESTPOOL1
	log_must zpool export $TESTPOOL1
	log_must zpool import -d $TEST_BASE_DIR $TESTPOOL1
	log_must is_pool_resilvering $TESTPOOL1
	log_must set_tunable32 SCAN_SUSPEND_PROGRESS $ORIG_SCAN_SUSPEND_PROGRESS
	log_must zpool wait -t resilver $TESTPOOL1
	log_must is_pool_resilvered $TESTPOOL1
	destroy_pool $TESTPOOL1
	done

	log_pass "Verify replace is resumed on import"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/replacement/resilver_restart_001.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/replacement/resilver_restart_001.ksh
	index 7896b2dbe1d0..7e96ab518773 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/replacement/resilver_restart_001.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/replacement/resilver_restart_001.ksh
	@@ -1,187 +1,187 @@
	#!/bin/ksh -p

	#
	# CDDL HEADER START
	#
	# This file and its contents are supplied under the terms of the
	# Common Development and Distribution License ("CDDL"), version 1.0.
	# You may only use this file in accordance with the terms of version
	# 1.0 of the CDDL.
	#
	# A full copy of the text of the CDDL should have accompanied this
	# source. A copy of the CDDL is also available via the Internet at
	# http://www.illumos.org/license/CDDL.
	#
	# CDDL HEADER END
	#

	#
	# Copyright (c) 2019, Datto Inc. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/replacement/replacement.cfg

	#
	# DESCRIPTION:
	# Testing resilver restart logic both with and without the deferred resilver
	# feature enabled, verifying that resilver is not restarted when it is
	# unnecessary.
	#
	# STRATEGY:
	# 1. Create a pool
	# 2. Create four filesystems with the primary cache disable to force reads
	# 3. Write four files simultaneously, one to each filesystem
	# 4. Do with and without deferred resilvers enabled
	# a. Replace a vdev with a spare & suspend resilver immediately
	# b. Verify resilver starts properly
	# c. Offline / online another vdev to introduce a new DTL range
	-# d. Verify resilver restart restart or defer
	+# d. Verify resilver restart or defer
	# e. Inject read errors on vdev that was offlined / onlned
	# f. Verify that resilver did not restart
	# g. Unsuspend resilver and wait for it to finish
	# h. Verify that there are two resilvers and nothing is deferred
	#

	function cleanup
	{
	log_must set_tunable32 RESILVER_MIN_TIME_MS $ORIG_RESILVER_MIN_TIME
	log_must set_tunable32 SCAN_SUSPEND_PROGRESS \
	$ORIG_SCAN_SUSPEND_PROGRESS
	log_must set_tunable32 ZEVENT_LEN_MAX $ORIG_ZFS_ZEVENT_LEN_MAX
	log_must zinject -c all
	destroy_pool $TESTPOOL1
	rm -f ${VDEV_FILES[@]} $SPARE_VDEV_FILE
	}

	# count resilver events in zpool and number of deferred rsilvers on vdevs
	function verify_restarts # <msg> <cnt> <defer>
	{
	msg=$1
	cnt=$2
	defer=$3

	# check the number of resilver start in events log
	RESILVERS=$(zpool events \| grep -c sysevent.fs.zfs.resilver_start)
	log_note "expected $cnt resilver start(s)$msg, found $RESILVERS"
	[[ "$RESILVERS" -ne "$cnt" ]] &&
	log_fail "expected $cnt resilver start(s)$msg, found $RESILVERS"

	[[ -z "$defer" ]] && return

	# use zdb to find which vdevs have the resilver defer flag
	VDEV_DEFERS=$(zdb -C $TESTPOOL1 \| awk '
	/children/ { gsub(/[^0-9]/, ""); child = $0 }
	/com\.datto:resilver_defer$/ { print child }
	')

	if [[ "$defer" == "-" ]]
	then
	[[ -n $VDEV_DEFERS ]] &&
	log_fail "didn't expect any vdevs to have resilver deferred"
	return
	fi

	[[ $VDEV_DEFERS -eq $defer ]] \|\|
	log_fail "resilver deferred set on unexpected vdev: $VDEV_DEFERS"
	}

	log_assert "Check for unnecessary resilver restarts"

	ORIG_RESILVER_MIN_TIME=$(get_tunable RESILVER_MIN_TIME_MS)
	ORIG_SCAN_SUSPEND_PROGRESS=$(get_tunable SCAN_SUSPEND_PROGRESS)
	ORIG_ZFS_ZEVENT_LEN_MAX=$(get_tunable ZEVENT_LEN_MAX)

	set -A RESTARTS -- '1' '2' '2' '2'
	set -A VDEVS -- '' '' '' ''
	set -A DEFER_RESTARTS -- '1' '1' '1' '2'
	set -A DEFER_VDEVS -- '-' '2' '2' '-'

	VDEV_REPLACE="${VDEV_FILES[1]} $SPARE_VDEV_FILE"

	log_onexit cleanup

	# ensure that enough events will be saved
	log_must set_tunable32 ZEVENT_LEN_MAX 512

	log_must truncate -s $VDEV_FILE_SIZE ${VDEV_FILES[@]} $SPARE_VDEV_FILE

	log_must zpool create -f -o feature@resilver_defer=disabled $TESTPOOL1 \
	raidz ${VDEV_FILES[@]}

	# create 4 filesystems
	for fs in fs{0..3}
	do
	log_must zfs create -o primarycache=none -o recordsize=1k $TESTPOOL1/$fs
	done

	# simultaneously write 16M to each of them
	set -A DATAPATHS /$TESTPOOL1/fs{0..3}/dat.0
	log_note "Writing data files"
	for path in ${DATAPATHS[@]}
	do
	dd if=/dev/urandom of=$path bs=1M count=16 > /dev/null 2>&1 &
	done
	wait

	# test without and with deferred resilve feature enabled
	for test in "without" "with"
	do
	log_note "Testing $test deferred resilvers"

	if [[ $test == "with" ]]
	then
	log_must zpool set feature@resilver_defer=enabled $TESTPOOL1
	RESTARTS=( "${DEFER_RESTARTS[@]}" )
	VDEVS=( "${DEFER_VDEVS[@]}" )
	VDEV_REPLACE="$SPARE_VDEV_FILE ${VDEV_FILES[1]}"
	fi

	# clear the events
	log_must zpool events -c

	# limit scanning time
	log_must set_tunable32 RESILVER_MIN_TIME_MS 50

	# initiate a resilver and suspend the scan as soon as possible
	log_must zpool replace $TESTPOOL1 $VDEV_REPLACE
	log_must set_tunable32 SCAN_SUSPEND_PROGRESS 1

	# there should only be 1 resilver start
	verify_restarts '' "${RESTARTS[0]}" "${VDEVS[0]}"

	# offline then online a vdev to introduce a new DTL range after current
	# scan, which should restart (or defer) the resilver
	log_must zpool offline $TESTPOOL1 ${VDEV_FILES[2]}
	log_must zpool sync $TESTPOOL1
	log_must zpool online $TESTPOOL1 ${VDEV_FILES[2]}
	log_must zpool sync $TESTPOOL1

	# there should now be 2 resilver starts w/o defer, 1 with defer
	verify_restarts ' after offline/online' "${RESTARTS[1]}" "${VDEVS[1]}"

	# inject read io errors on vdev and verify resilver does not restart
	log_must zinject -a -d ${VDEV_FILES[2]} -e io -T read -f 0.25 $TESTPOOL1
	log_must cat ${DATAPATHS[1]} > /dev/null
	log_must zinject -c all

	# there should still be 2 resilver starts w/o defer, 1 with defer
	verify_restarts ' after zinject' "${RESTARTS[2]}" "${VDEVS[2]}"

	# unsuspend resilver
	log_must set_tunable32 SCAN_SUSPEND_PROGRESS 0
	log_must set_tunable32 RESILVER_MIN_TIME_MS 3000

	# wait for resilver to finish
	log_must zpool wait -t resilver $TESTPOOL1
	log_must is_pool_resilvered $TESTPOOL1

	# wait for a few txg's to see if a resilver happens
	log_must zpool sync $TESTPOOL1
	log_must zpool sync $TESTPOOL1

	# there should now be 2 resilver starts
	verify_restarts ' after resilver' "${RESTARTS[3]}" "${VDEVS[3]}"
	done

	log_pass "Resilver did not restart unnecessarily"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_006_pos.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_006_pos.ksh
	index ec1986c4547c..da0d36a35d3c 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_006_pos.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/reservation/reservation_006_pos.ksh
	@@ -1,81 +1,81 @@
	#!/bin/ksh -p
	#
	# 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 2009 Sun Microsystems, Inc. All rights reserved.
	# Use is subject to license terms.
	#

	#
	# Copyright (c) 2013, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/reservation/reservation.shlib

	#
	# DESCRIPTION:
	#
	# Reservations (if successfully set) guarantee a minimum amount of space
	# for a dataset. Unlike quotas however there should be no restrictions
	# on accessing space outside of the limits of the reservation (if the
	# space is available in the pool). Verify that in a filesystem with a
	-# reservation set that its possible to create files both within the
	+# reservation set that it's possible to create files both within the
	# reserved space and also outside.
	#
	# STRATEGY:
	# 1) Create a filesystem
	# 2) Get the space used and available in the pool
	# 3) Set a reservation on the filesystem
	# 4) Verify can write a file that is bigger than the reserved space
	#
	# i.e. we start writing within the reserved region and then continue
	# for 20MB outside it.
	#

	verify_runnable "both"

	function cleanup
	{
	[[ -e $TESTDIR/$TESTFILE1 ]] && log_must rm -rf $TESTDIR/$TESTFILE1
	log_must zfs set reservation=none $TESTPOOL/$TESTFS
	}

	log_onexit cleanup

	log_assert "Verify can create files both inside and outside reserved areas"

	space_used=`get_prop used $TESTPOOL`

	log_must zfs set reservation=$RESV_SIZE $TESTPOOL/$TESTFS

	#
	# Calculate how many writes of BLOCK_SIZE it would take to fill
	# up RESV_SIZE + 20971520 (20 MB).
	#
	fill_size=`expr $RESV_SIZE + 20971520`
	write_count=`expr $fill_size / $BLOCK_SIZE`

	log_must file_write -o create -f $TESTDIR/$TESTFILE1 -b $BLOCK_SIZE \
	-c $write_count -d 0

	log_pass "Able to create files inside and outside reserved area"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/send_encrypted_files.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/send_encrypted_files.ksh
	index f89cb3b31bee..1fd21cbf7eff 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/send_encrypted_files.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/rsend/send_encrypted_files.ksh
	@@ -1,120 +1,120 @@
	#!/bin/ksh -p
	#
	# CDDL HEADER START
	#
	# This file and its contents are supplied under the terms of the
	# Common Development and Distribution License ("CDDL"), version 1.0.
	# You may only use this file in accordance with the terms of version
	# 1.0 of the CDDL.
	#
	# A full copy of the text of the CDDL should have accompanied this
	# source. A copy of the CDDL is also available via the Internet at
	# http://www.illumos.org/license/CDDL.
	#
	# CDDL HEADER END
	#

	#
	# Copyright (c) 2018 by Datto Inc. All rights reserved.
	#

	. $STF_SUITE/tests/functional/rsend/rsend.kshlib

	#
	# DESCRIPTION:
	# Verify that a raw zfs send and receive can deal with several different
	# types of file layouts.
	#
	# STRATEGY:
	# 1. Create a new encrypted filesystem
	# 2. Add an empty file to the filesystem
	# 3. Add a small 512 byte file to the filesystem
	# 4. Add a larger 32M file to the filesystem
	# 5. Add a large sparse file to the filesystem
	# 6. Add 1000 empty files to the filesystem
	# 7. Add a file with a large xattr value
	# 8. Use xattrtest to create files with random xattrs (with and without xattrs=on)
	# 9. Take a snapshot of the filesystem
	# 10. Remove the 1000 empty files to the filesystem
	# 11. Take another snapshot of the filesystem
	# 12. Send and receive both snapshots
	# 13. Mount the filesystem and check the contents
	#

	verify_runnable "both"

	function cleanup
	{
	datasetexists $TESTPOOL/$TESTFS2 && \
	log_must zfs destroy -r $TESTPOOL/$TESTFS2
	datasetexists $TESTPOOL/recv && \
	log_must zfs destroy -r $TESTPOOL/recv
	[[ -f $keyfile ]] && log_must rm $keyfile
	[[ -f $sendfile ]] && log_must rm $sendfile
	}
	log_onexit cleanup

	log_assert "Verify 'zfs send -w' works with many different file layouts"

	typeset keyfile=/$TESTPOOL/pkey
	typeset sendfile=/$TESTPOOL/sendfile
	typeset sendfile2=/$TESTPOOL/sendfile2

	# Create an encrypted dataset
	log_must eval "echo 'password' > $keyfile"
	log_must zfs create -o encryption=on -o keyformat=passphrase \
	-o keylocation=file://$keyfile $TESTPOOL/$TESTFS2

	# Create files with varied layouts on disk
	log_must touch /$TESTPOOL/$TESTFS2/empty
	log_must mkfile 512 /$TESTPOOL/$TESTFS2/small
	log_must mkfile 32M /$TESTPOOL/$TESTFS2/full
	log_must dd if=/dev/urandom of=/$TESTPOOL/$TESTFS2/sparse \
	bs=512 count=1 seek=1048576 >/dev/null 2>&1

	log_must mkdir -p /$TESTPOOL/$TESTFS2/dir
	for i in {1..1000}; do
	log_must mkfile 512 /$TESTPOOL/$TESTFS2/dir/file-$i
	done

	log_must mkdir -p /$TESTPOOL/$TESTFS2/xattrondir
	log_must zfs set xattr=on $TESTPOOL/$TESTFS2
	log_must xattrtest -f 10 -x 3 -s 32768 -r -k -p /$TESTPOOL/$TESTFS2/xattrondir
	log_must mkdir -p /$TESTPOOL/$TESTFS2/xattrsadir
	log_must zfs set xattr=sa $TESTPOOL/$TESTFS2
	log_must xattrtest -f 10 -x 3 -s 32768 -r -k -p /$TESTPOOL/$TESTFS2/xattrsadir

	-# ZoL issue #7432
	+# OpenZFS issue #7432
	log_must zfs set compression=on xattr=sa $TESTPOOL/$TESTFS2
	log_must touch /$TESTPOOL/$TESTFS2/attrs
	log_must eval "python -c 'print \"a\" * 4096' \| \
	set_xattr_stdin bigval /$TESTPOOL/$TESTFS2/attrs"
	log_must zfs set compression=off xattr=on $TESTPOOL/$TESTFS2

	log_must zfs snapshot $TESTPOOL/$TESTFS2@snap1

	# Remove the empty files created in the first snapshot
	for i in {1..1000}; do
	log_must rm /$TESTPOOL/$TESTFS2/dir/file-$i
	done
	sync

	log_must zfs snapshot $TESTPOOL/$TESTFS2@snap2
	expected_cksum=$(recursive_cksum /$TESTPOOL/$TESTFS2)

	log_must eval "zfs send -wp $TESTPOOL/$TESTFS2@snap1 > $sendfile"
	log_must eval "zfs send -wp -i @snap1 $TESTPOOL/$TESTFS2@snap2 > $sendfile2"

	log_must eval "zfs recv -F $TESTPOOL/recv < $sendfile"
	log_must eval "zfs recv -F $TESTPOOL/recv < $sendfile2"
	log_must zfs load-key $TESTPOOL/recv

	log_must zfs mount -a
	actual_cksum=$(recursive_cksum /$TESTPOOL/recv)
	[[ "$expected_cksum" != "$actual_cksum" ]] && \
	log_fail "Recursive checksums differ ($expected_cksum != $actual_cksum)"

	log_must xattrtest -f 10 -o3 -y -p /$TESTPOOL/recv/xattrondir
	log_must xattrtest -f 10 -o3 -y -p /$TESTPOOL/recv/xattrsadir

	log_pass "Verified 'zfs send -w' works with many different file layouts"
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/Makefile.am b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/Makefile.am
	index 2c94d3e1521c..9100e4adadca 100644
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/Makefile.am
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/Makefile.am
	@@ -1,29 +1,28 @@
	pkgdatadir = $(datadir)/@PACKAGE@/zfs-tests/tests/functional/userquota
	dist_pkgdata_SCRIPTS = \
	setup.ksh \
	cleanup.ksh \
	groupspace_001_pos.ksh \
	groupspace_002_pos.ksh \
	groupspace_003_pos.ksh \
	userquota_001_pos.ksh \
	userquota_002_pos.ksh \
	userquota_003_pos.ksh \
	userquota_004_pos.ksh \
	userquota_005_neg.ksh \
	userquota_006_pos.ksh \
	userquota_007_pos.ksh \
	userquota_008_pos.ksh \
	userquota_009_pos.ksh \
	userquota_010_pos.ksh \
	userquota_011_pos.ksh \
	userquota_012_neg.ksh \
	userquota_013_pos.ksh \
	userspace_001_pos.ksh \
	userspace_002_pos.ksh \
	userspace_003_pos.ksh \
	- userspace_encrypted.ksh \
	- userspace_send_encrypted.ksh
	+ userspace_encrypted.ksh

	dist_pkgdata_DATA = \
	userquota.cfg \
	userquota_common.kshlib
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/userspace_send_encrypted.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/userspace_send_encrypted.ksh
	deleted file mode 100755
	index fbd2cc99b55b..000000000000
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/userquota/userspace_send_encrypted.ksh
	+++ /dev/null
	@@ -1,108 +0,0 @@
	-#!/bin/ksh -p
	-#
	-# This file and its contents are supplied under the terms of the
	-# Common Development and Distribution License ("CDDL"), version 1.0.
	-# You may only use this file in accordance with the terms of version
	-# 1.0 of the CDDL.
	-#
	-# A full copy of the text of the CDDL should have accompanied this
	-# source. A copy of the CDDL is also available via the Internet at
	-# http://www.illumos.org/license/CDDL.
	-#
	-
	-#
	-# Copyright 2020, George Amanakis <gamanakis@gmail.com>. All rights reserved.
	-#
	-
	-. $STF_SUITE/include/libtest.shlib
	-. $STF_SUITE/tests/functional/userquota/userquota_common.kshlib
	-
	-#
	-# DESCRIPTION:
	-# Sending raw encrypted datasets back to the source dataset succeeds.
	-#
	-#
	-# STRATEGY:
	-# 1. Create encrypted source dataset, set userquota and write a file
	-# 2. Create base and an additional snapshot (s1)
	-# 3. Unmount the source dataset
	-# 4. Raw send the base snapshot to a new target dataset
	-# 5. Raw send incrementally the s1 snapshot to the new target dataset
	-# 6. Mount both source and target datasets
	-# 7. Verify encrypted datasets support 'zfs userspace' and 'zfs groupspace'
	-# and the accounting is done correctly
	-#
	-
	-function cleanup
	-{
	- destroy_pool $POOLNAME
	- rm -f $FILEDEV
	-}
	-
	-function log_must_unsupported
	-{
	- log_must_retry "unsupported" 3 "$@"
	- (( $? != 0 )) && log_fail
	-}
	-
	-log_onexit cleanup
	-
	-FILEDEV="$TEST_BASE_DIR/userspace_encrypted"
	-POOLNAME="testpool$$"
	-ENC_SOURCE="$POOLNAME/source"
	-ENC_TARGET="$POOLNAME/target"
	-
	-log_assert "Sending raw encrypted datasets back to the source dataset succeeds."
	-
	-# Setup
	-truncate -s 200m $FILEDEV
	-log_must zpool create -o feature@encryption=enabled $POOLNAME \
	- $FILEDEV
	-
	-# Create encrypted source dataset
	-log_must eval "echo 'password' \| zfs create -o encryption=on" \
	- "-o keyformat=passphrase -o keylocation=prompt " \
	- "$ENC_SOURCE"
	-
	-# Set user quota and write file
	-log_must zfs set userquota@$QUSER1=50m $ENC_SOURCE
	-mkmount_writable $ENC_SOURCE
	-mntpnt=$(get_prop mountpoint $ENC_SOURCE)
	-log_must user_run $QUSER1 mkfile 20m /$mntpnt/file
	-sync
	-
	-# Snapshot, raw send to new dataset
	-log_must zfs snap $ENC_SOURCE@base
	-log_must zfs snap $ENC_SOURCE@s1
	-log_must zfs umount $ENC_SOURCE
	-log_must eval "zfs send -w $ENC_SOURCE@base \| zfs recv " \
	- "$ENC_TARGET"
	-
	-log_must eval "zfs send -w -i @base $ENC_SOURCE@s1 \| zfs recv " \
	- "$ENC_TARGET"
	-
	-log_must zfs destroy $ENC_SOURCE@s1
	-log_must eval "zfs send -w -i @base $ENC_TARGET@s1 \| zfs recv " \
	- "$ENC_SOURCE"
	-
	-# Mount encrypted datasets and verify they support 'zfs userspace' and
	-# 'zfs groupspace' and the accounting is done correctly
	-log_must zfs mount $ENC_SOURCE
	-log_must eval "echo password \| zfs load-key $ENC_TARGET"
	-log_must zfs mount $ENC_TARGET
	-sync
	-
	-src_uspace=$(( $(zfs userspace -Hp $ENC_SOURCE \| grep $QUSER1 \| \
	- awk '{print $4}')/1024/1024))
	-tgt_uspace=$(( $(zfs userspace -Hp $ENC_TARGET \| grep $QUSER1 \| \
	- awk '{print $4}')/1024/1024))
	-log_must test "$src_uspace" -eq "$tgt_uspace"
	-
	-src_uquota=$(zfs userspace -Hp $ENC_SOURCE \| grep $QUSER1 \| awk '{print $5}')
	-tgt_uquota=$(zfs userspace -Hp $ENC_TARGET \| grep $QUSER1 \| awk '{print $5}')
	-log_must test "$src_uquota" -eq "$tgt_uquota"
	-
	-# Cleanup
	-cleanup
	-
	-log_pass "Sending raw encrypted datasets back to the source dataset succeeds."
	diff --git a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/xattr/xattr_002_neg.ksh b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/xattr/xattr_002_neg.ksh
	index e379d1586ea9..4393774cb1ad 100755
	--- a/sys/contrib/openzfs/tests/zfs-tests/tests/functional/xattr/xattr_002_neg.ksh
	+++ b/sys/contrib/openzfs/tests/zfs-tests/tests/functional/xattr/xattr_002_neg.ksh
	@@ -1,62 +1,62 @@
	#!/bin/ksh -p
	#
	# 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 2007 Sun Microsystems, Inc. All rights reserved.
	# Use is subject to license terms.
	#

	#
	# Copyright (c) 2013, 2016 by Delphix. All rights reserved.
	#

	. $STF_SUITE/include/libtest.shlib
	. $STF_SUITE/tests/functional/xattr/xattr_common.kshlib

	#
	# DESCRIPTION:
	#
	# Trying to read a non-existent xattr should fail.
	#
	# STRATEGY:
	# 1. Create a file
	# 2. Try to read a non-existent xattr, check that an error is returned.
	#

	function cleanup {

	log_must rm $TESTDIR/myfile.$$

	}

	set -A args "on" "sa"

	log_assert "A read of a non-existent xattr fails"
	log_onexit cleanup

	for arg in ${args[*]}; do
	log_must zfs set xattr=$arg $TESTPOOL

	# create a file
	log_must touch $TESTDIR/myfile.$$
	log_mustnot eval "cat $TESTDIR/myfile.$$ not-here.txt > /dev/null 2>&1"
	-
	- log_pass "A read of a non-existent xattr fails"
	done
	+
	+log_pass "A read of a non-existent xattr fails"
	diff --git a/sys/modules/zfs/zfs_config.h b/sys/modules/zfs/zfs_config.h
	index ebc9bbe9059b..7e910ef6ec43 100644
	--- a/sys/modules/zfs/zfs_config.h
	+++ b/sys/modules/zfs/zfs_config.h
	@@ -1,774 +1,774 @@
	/*
	* $FreeBSD$
	*/

	/* zfs_config.h. Generated from zfs_config.h.in by configure. */
	/* zfs_config.h.in. Generated from configure.ac by autoheader. */

	/* Define to 1 if translation of program messages to the user's native
	language is requested. */
	/* #undef ENABLE_NLS */

	/* bio_end_io_t wants 1 arg */
	/* #undef HAVE_1ARG_BIO_END_IO_T */

	/* lookup_bdev() wants 1 arg */
	/* #undef HAVE_1ARG_LOOKUP_BDEV */

	/* submit_bio() wants 1 arg */
	/* #undef HAVE_1ARG_SUBMIT_BIO */

	/* bdi_setup_and_register() wants 2 args */
	/* #undef HAVE_2ARGS_BDI_SETUP_AND_REGISTER */

	/* vfs_getattr wants 2 args */
	/* #undef HAVE_2ARGS_VFS_GETATTR */

	/* zlib_deflate_workspacesize() wants 2 args */
	/* #undef HAVE_2ARGS_ZLIB_DEFLATE_WORKSPACESIZE */

	/* bdi_setup_and_register() wants 3 args */
	/* #undef HAVE_3ARGS_BDI_SETUP_AND_REGISTER */

	/* vfs_getattr wants 3 args */
	/* #undef HAVE_3ARGS_VFS_GETATTR */

	/* vfs_getattr wants 4 args */
	/* #undef HAVE_4ARGS_VFS_GETATTR */

	/* kernel has access_ok with 'type' parameter */
	/* #undef HAVE_ACCESS_OK_TYPE */

	/* posix_acl has refcount_t */
	/* #undef HAVE_ACL_REFCOUNT */

	/* Define if host toolchain supports AES */
	#define HAVE_AES 1

	#ifdef __amd64__
	#ifndef RESCUE
	/* Define if host toolchain supports AVX */
	#define HAVE_AVX 1
	#endif

	/* Define if host toolchain supports AVX2 */
	#define HAVE_AVX2 1

	/* Define if host toolchain supports AVX512BW */
	#define HAVE_AVX512BW 1

	/* Define if host toolchain supports AVX512CD */
	#define HAVE_AVX512CD 1

	/* Define if host toolchain supports AVX512DQ */
	#define HAVE_AVX512DQ 1

	/* Define if host toolchain supports AVX512ER */
	#define HAVE_AVX512ER 1

	/* Define if host toolchain supports AVX512F */
	#define HAVE_AVX512F 1

	/* Define if host toolchain supports AVX512IFMA */
	#define HAVE_AVX512IFMA 1

	/* Define if host toolchain supports AVX512PF */
	#define HAVE_AVX512PF 1

	/* Define if host toolchain supports AVX512VBMI */
	#define HAVE_AVX512VBMI 1

	/* Define if host toolchain supports AVX512VL */
	#define HAVE_AVX512VL 1
	#endif

	/* bdev_check_media_change() exists */
	/* #undef HAVE_BDEV_CHECK_MEDIA_CHANGE */

	/* bdev_whole() is available */
	/* #undef HAVE_BDEV_WHOLE */

	/* bio->bi_opf is defined */
	/* #undef HAVE_BIO_BI_OPF */

	/* bio->bi_status exists */
	/* #undef HAVE_BIO_BI_STATUS */

	/* bio has bi_iter */
	/* #undef HAVE_BIO_BVEC_ITER */

	/* bio__io_acct() available /
	/* #undef HAVE_BIO_IO_ACCT */

	/* bio_set_dev() is available */
	/* #undef HAVE_BIO_SET_DEV */

	/* bio_set_dev() GPL-only */
	/* #undef HAVE_BIO_SET_DEV_GPL_ONLY */

	/* bio_set_op_attrs is available */
	/* #undef HAVE_BIO_SET_OP_ATTRS */

	/* blkdev_reread_part() exists */
	/* #undef HAVE_BLKDEV_REREAD_PART */

	/* blkg_tryget() is available */
	/* #undef HAVE_BLKG_TRYGET */

	/* blkg_tryget() GPL-only */
	/* #undef HAVE_BLKG_TRYGET_GPL_ONLY */

	/* blk_alloc_queue() expects request function */
	/* #undef HAVE_BLK_ALLOC_QUEUE_REQUEST_FN */

	/* blk_alloc_queue_rh() expects request function */
	/* #undef HAVE_BLK_ALLOC_QUEUE_REQUEST_FN_RH */

	/* blk queue backing_dev_info is dynamic */
	/* #undef HAVE_BLK_QUEUE_BDI_DYNAMIC */

	/* blk_queue_flag_clear() exists */
	/* #undef HAVE_BLK_QUEUE_FLAG_CLEAR */

	/* blk_queue_flag_set() exists */
	/* #undef HAVE_BLK_QUEUE_FLAG_SET */

	/* blk_queue_flush() is available */
	/* #undef HAVE_BLK_QUEUE_FLUSH */

	/* blk_queue_flush() is GPL-only */
	/* #undef HAVE_BLK_QUEUE_FLUSH_GPL_ONLY */

	/* blk_queue_secdiscard() is available */
	/* #undef HAVE_BLK_QUEUE_SECDISCARD */

	/* blk_queue_secure_erase() is available */
	/* #undef HAVE_BLK_QUEUE_SECURE_ERASE */

	/* blk_queue_write_cache() exists */
	/* #undef HAVE_BLK_QUEUE_WRITE_CACHE */

	/* blk_queue_write_cache() is GPL-only */
	/* #undef HAVE_BLK_QUEUE_WRITE_CACHE_GPL_ONLY */

	/* Define to 1 if you have the Mac OS X function CFLocaleCopyCurrent in the
	CoreFoundation framework. */
	/* #undef HAVE_CFLOCALECOPYCURRENT */

	/* Define to 1 if you have the Mac OS X function
	CFLocaleCopyPreferredLanguages in the CoreFoundation framework. */
	/* #undef HAVE_CFLOCALECOPYPREFERREDLANGUAGES */

	/* Define to 1 if you have the Mac OS X function CFPreferencesCopyAppValue in
	the CoreFoundation framework. */
	/* #undef HAVE_CFPREFERENCESCOPYAPPVALUE */

	/* check_disk_change() exists */
	/* #undef HAVE_CHECK_DISK_CHANGE */

	/* clear_inode() is available */
	/* #undef HAVE_CLEAR_INODE */

	/* dentry uses const struct dentry_operations */
	/* #undef HAVE_CONST_DENTRY_OPERATIONS */

	/* copy_from_iter() is available */
	/* #undef HAVE_COPY_FROM_ITER */

	/* copy_to_iter() is available */
	/* #undef HAVE_COPY_TO_ITER */

	/* yes */
	/* #undef HAVE_CPU_HOTPLUG */

	/* current_time() exists */
	/* #undef HAVE_CURRENT_TIME */

	/* Define if the GNU dcgettext() function is already present or preinstalled.
	*/
	/* #undef HAVE_DCGETTEXT */

	/* DECLARE_EVENT_CLASS() is available */
	/* #undef HAVE_DECLARE_EVENT_CLASS */

	/* lookup_bdev() wants dev_t arg */
	/* #undef HAVE_DEVT_LOOKUP_BDEV */

	/* sops->dirty_inode() wants flags */
	/* #undef HAVE_DIRTY_INODE_WITH_FLAGS */

	/* Define to 1 if you have the <dlfcn.h> header file. */
	#define HAVE_DLFCN_H 1

	/* d_make_root() is available */
	/* #undef HAVE_D_MAKE_ROOT */

	/* d_prune_aliases() is available */
	/* #undef HAVE_D_PRUNE_ALIASES */

	/* dops->d_revalidate() operation takes nameidata */
	/* #undef HAVE_D_REVALIDATE_NAMEIDATA */

	/* eops->encode_fh() wants child and parent inodes */
	/* #undef HAVE_ENCODE_FH_WITH_INODE */

	/* sops->evict_inode() exists */
	/* #undef HAVE_EVICT_INODE */

	/* fops->aio_fsync() exists */
	/* #undef HAVE_FILE_AIO_FSYNC */

	/* file_dentry() is available */
	/* #undef HAVE_FILE_DENTRY */

	/* file_inode() is available */
	/* #undef HAVE_FILE_INODE */

	/* iops->follow_link() cookie */
	/* #undef HAVE_FOLLOW_LINK_COOKIE */

	/* iops->follow_link() nameidata */
	/* #undef HAVE_FOLLOW_LINK_NAMEIDATA */

	/* fops->fsync() with range */
	/* #undef HAVE_FSYNC_RANGE */

	/* fops->fsync() without dentry */
	/* #undef HAVE_FSYNC_WITHOUT_DENTRY */

	/* generic__io_acct() 3 arg available /
	/* #undef HAVE_GENERIC_IO_ACCT_3ARG */

	/* generic__io_acct() 4 arg available /
	/* #undef HAVE_GENERIC_IO_ACCT_4ARG */

	/* generic_readlink is global */
	/* #undef HAVE_GENERIC_READLINK */

	/* generic_setxattr() exists */
	/* #undef HAVE_GENERIC_SETXATTR */

	/* generic_write_checks() takes kiocb */
	/* #undef HAVE_GENERIC_WRITE_CHECKS_KIOCB */

	/* Define if the GNU gettext() function is already present or preinstalled. */
	/* #undef HAVE_GETTEXT */

	/* iops->get_link() cookie */
	/* #undef HAVE_GET_LINK_COOKIE */

	/* iops->get_link() delayed */
	/* #undef HAVE_GET_LINK_DELAYED */

	/* group_info->gid exists */
	/* #undef HAVE_GROUP_INFO_GID */

	/* has_capability() is available */
	/* #undef HAVE_HAS_CAPABILITY */

	/* Define if you have the iconv() function and it works. */
	#define HAVE_ICONV 1

	/* yes */
	/* #undef HAVE_INODE_LOCK_SHARED */

	/* inode_set_flags() exists */
	/* #undef HAVE_INODE_SET_FLAGS */

	/* inode_set_iversion() exists */
	/* #undef HAVE_INODE_SET_IVERSION */

	/* inode->i_time's are timespec64 /
	/* #undef HAVE_INODE_TIMESPEC64_TIMES */

	/* timestamp_truncate() exists */
	/* #undef HAVE_INODE_TIMESTAMP_TRUNCATE */

	/* Define to 1 if you have the <inttypes.h> header file. */
	#define HAVE_INTTYPES_H 1

	/* in_compat_syscall() is available */
	/* #undef HAVE_IN_COMPAT_SYSCALL */

	/* iov_iter_advance() is available */
	/* #undef HAVE_IOV_ITER_ADVANCE */

	/* iov_iter_count() is available */
	/* #undef HAVE_IOV_ITER_COUNT */

	/* iov_iter_fault_in_readable() is available */
	/* #undef HAVE_IOV_ITER_FAULT_IN_READABLE */

	/* iov_iter_init() is available */
	/* #undef HAVE_IOV_ITER_INIT */

	/* iov_iter_init() is available */
	/* #undef HAVE_IOV_ITER_INIT_LEGACY */

	/* iov_iter_revert() is available */
	/* #undef HAVE_IOV_ITER_REVERT */

	/* iov_iter types are available */
	/* #undef HAVE_IOV_ITER_TYPES */

	/* yes */
	/* #undef HAVE_IO_SCHEDULE_TIMEOUT */

	/* Define to 1 if you have the `issetugid' function. */
	#define HAVE_ISSETUGID 1

	/* kernel has kernel_fpu_* functions */
	/* #undef HAVE_KERNEL_FPU */

	/* kernel has asm/fpu/api.h */
	/* #undef HAVE_KERNEL_FPU_API_HEADER */

	/* kernel fpu internal */
	/* #undef HAVE_KERNEL_FPU_INTERNAL */

	/* uncached_acl_sentinel() exists */
	/* #undef HAVE_KERNEL_GET_ACL_HANDLE_CACHE */

	/* kernel does stack verification */
	/* #undef HAVE_KERNEL_OBJTOOL */

	/* kernel has linux/objtool.h */
	/* #undef HAVE_KERNEL_OBJTOOL_HEADER */

	/* kernel_read() take loff_t pointer */
	/* #undef HAVE_KERNEL_READ_PPOS */

	/* timer_list.function gets a timer_list */
	/* #undef HAVE_KERNEL_TIMER_FUNCTION_TIMER_LIST */

	/* struct timer_list has a flags member */
	/* #undef HAVE_KERNEL_TIMER_LIST_FLAGS */

	/* timer_setup() is available */
	/* #undef HAVE_KERNEL_TIMER_SETUP */

	/* kernel_write() take loff_t pointer */
	/* #undef HAVE_KERNEL_WRITE_PPOS */

	/* kmem_cache_create_usercopy() exists */
	/* #undef HAVE_KMEM_CACHE_CREATE_USERCOPY */

	/* kstrtoul() exists */
	/* #undef HAVE_KSTRTOUL */

	/* ktime_get_coarse_real_ts64() exists */
	/* #undef HAVE_KTIME_GET_COARSE_REAL_TS64 */

	/* ktime_get_raw_ts64() exists */
	/* #undef HAVE_KTIME_GET_RAW_TS64 */

	/* kvmalloc exists */
	/* #undef HAVE_KVMALLOC */

	/* kernel has large stacks */
	/* #undef HAVE_LARGE_STACKS */

	/* Define if you have [aio] */
	/* #undef HAVE_LIBAIO */

	/* Define if you have [blkid] */
	/* #undef HAVE_LIBBLKID */

	/* Define if you have [crypto] */
	#define HAVE_LIBCRYPTO 1

	/* Define if you have [tirpc] */
	/* #undef HAVE_LIBTIRPC */

	/* Define if you have [udev] */
	/* #undef HAVE_LIBUDEV */

	/* Define if you have [uuid] */
	/* #undef HAVE_LIBUUID */

	/* lseek_execute() is available */
	/* #undef HAVE_LSEEK_EXECUTE */

	/* makedev() is declared in sys/mkdev.h */
	/* #undef HAVE_MAKEDEV_IN_MKDEV */

	/* makedev() is declared in sys/sysmacros.h */
	/* #undef HAVE_MAKEDEV_IN_SYSMACROS */

	/* Noting that make_request_fn() returns blk_qc_t */
	/* #undef HAVE_MAKE_REQUEST_FN_RET_QC */

	/* Noting that make_request_fn() returns void */
	/* #undef HAVE_MAKE_REQUEST_FN_RET_VOID */

	/* Define to 1 if you have the <memory.h> header file. */
	#define HAVE_MEMORY_H 1

	/* iops->create()/mkdir()/mknod() take umode_t */
	/* #undef HAVE_MKDIR_UMODE_T */

	/* Define to 1 if you have the `mlockall' function. */
	#define HAVE_MLOCKALL 1

	/* lookup_bdev() wants mode arg */
	/* #undef HAVE_MODE_LOOKUP_BDEV */

	/* Define if host toolchain supports MOVBE */
	#define HAVE_MOVBE 1

	/* new_sync_read()/new_sync_write() are available */
	/* #undef HAVE_NEW_SYNC_READ */

	/* iops->getattr() takes a path */
	/* #undef HAVE_PATH_IOPS_GETATTR */

	/* Define if host toolchain supports PCLMULQDQ */
	#define HAVE_PCLMULQDQ 1

	/* percpu_counter_init() wants gfp_t */
	/* #undef HAVE_PERCPU_COUNTER_INIT_WITH_GFP */

	/* posix_acl_chmod() exists */
	/* #undef HAVE_POSIX_ACL_CHMOD */

	/* posix_acl_from_xattr() needs user_ns */
	/* #undef HAVE_POSIX_ACL_FROM_XATTR_USERNS */

	/* posix_acl_release() is available */
	/* #undef HAVE_POSIX_ACL_RELEASE */

	/* posix_acl_release() is GPL-only */
	/* #undef HAVE_POSIX_ACL_RELEASE_GPL_ONLY */

	/* posix_acl_valid() wants user namespace */
	/* #undef HAVE_POSIX_ACL_VALID_WITH_NS */

	/* proc_ops structure exists */
	/* #undef HAVE_PROC_OPS_STRUCT */

	/* iops->put_link() cookie */
	/* #undef HAVE_PUT_LINK_COOKIE */

	/* iops->put_link() delayed */
	/* #undef HAVE_PUT_LINK_DELAYED */

	/* iops->put_link() nameidata */
	/* #undef HAVE_PUT_LINK_NAMEIDATA */

	/* If available, contains the Python version number currently in use. */
	#define HAVE_PYTHON "3.7"

	/* qat is enabled and existed */
	/* #undef HAVE_QAT */

	/* iops->rename() wants flags */
	/* #undef HAVE_RENAME_WANTS_FLAGS */

	/* REQ_DISCARD is defined */
	/* #undef HAVE_REQ_DISCARD */

	/* REQ_FLUSH is defined */
	/* #undef HAVE_REQ_FLUSH */

	/* REQ_OP_DISCARD is defined */
	/* #undef HAVE_REQ_OP_DISCARD */

	/* REQ_OP_FLUSH is defined */
	/* #undef HAVE_REQ_OP_FLUSH */

	/* REQ_OP_SECURE_ERASE is defined */
	/* #undef HAVE_REQ_OP_SECURE_ERASE */

	/* REQ_PREFLUSH is defined */
	/* #undef HAVE_REQ_PREFLUSH */

	/* revalidate_disk() is available */
	/* #undef HAVE_REVALIDATE_DISK */

	/* revalidate_disk_size() is available */
	/* #undef HAVE_REVALIDATE_DISK_SIZE */

	/* struct rw_semaphore has member activity */
	/* #undef HAVE_RWSEM_ACTIVITY */

	/* struct rw_semaphore has atomic_long_t member count */
	/* #undef HAVE_RWSEM_ATOMIC_LONG_COUNT */

	/* linux/sched/signal.h exists */
	/* #undef HAVE_SCHED_SIGNAL_HEADER */

	/* Define to 1 if you have the <security/pam_modules.h> header file. */
	#define HAVE_SECURITY_PAM_MODULES_H 1

	/* setattr_prepare() is available */
	/* #undef HAVE_SETATTR_PREPARE */

	/* iops->set_acl() exists */
	/* #undef HAVE_SET_ACL */

	/* set_cached_acl() is usable */
	/* #undef HAVE_SET_CACHED_ACL_USABLE */

	/* struct shrink_control exists */
	/* #undef HAVE_SHRINK_CONTROL_STRUCT */

	/* new shrinker callback wants 2 args */
	/* #undef HAVE_SINGLE_SHRINKER_CALLBACK */

	/* ->count_objects exists */
	/* #undef HAVE_SPLIT_SHRINKER_CALLBACK */

	#if defined(__amd64__) \|\| defined(__i386__)
	/* Define if host toolchain supports SSE */
	#define HAVE_SSE 1

	/* Define if host toolchain supports SSE2 */
	#define HAVE_SSE2 1

	/* Define if host toolchain supports SSE3 */
	#define HAVE_SSE3 1

	/* Define if host toolchain supports SSE4.1 */
	#define HAVE_SSE4_1 1

	/* Define if host toolchain supports SSE4.2 */
	#define HAVE_SSE4_2 1

	/* Define if host toolchain supports SSSE3 */
	#define HAVE_SSSE3 1
	#endif

	/* STACK_FRAME_NON_STANDARD is defined */
	/* #undef HAVE_STACK_FRAME_NON_STANDARD */

	/* Define to 1 if you have the <stdint.h> header file. */
	#define HAVE_STDINT_H 1

	/* Define to 1 if you have the <stdlib.h> header file. */
	#define HAVE_STDLIB_H 1

	/* Define to 1 if you have the <strings.h> header file. */
	#define HAVE_STRINGS_H 1

	/* Define to 1 if you have the <string.h> header file. */
	#define HAVE_STRING_H 1

	/* Define to 1 if you have the `strlcat' function. */
	#define HAVE_STRLCAT 1

	/* Define to 1 if you have the `strlcpy' function. */
	#define HAVE_STRLCPY 1

	/* submit_bio is member of struct block_device_operations */
	/* #undef HAVE_SUBMIT_BIO_IN_BLOCK_DEVICE_OPERATIONS */

	/* super_setup_bdi_name() exits */
	/* #undef HAVE_SUPER_SETUP_BDI_NAME */

	/* super_block->s_user_ns exists */
	/* #undef HAVE_SUPER_USER_NS */

	/* Define to 1 if you have the <sys/stat.h> header file. */
	#define HAVE_SYS_STAT_H 1

	/* Define to 1 if you have the <sys/types.h> header file. */
	#define HAVE_SYS_TYPES_H 1

	/* i_op->tmpfile() exists */
	/* #undef HAVE_TMPFILE */

	/* totalhigh_pages() exists */
	/* #undef HAVE_TOTALHIGH_PAGES */

	/* kernel has totalram_pages() */
	/* #undef HAVE_TOTALRAM_PAGES_FUNC */

	/* Define to 1 if you have the `udev_device_get_is_initialized' function. */
	/* #undef HAVE_UDEV_DEVICE_GET_IS_INITIALIZED */

	/* kernel has __kernel_fpu_* functions */
	/* #undef HAVE_UNDERSCORE_KERNEL_FPU */

	/* Define to 1 if you have the <unistd.h> header file. */
	#define HAVE_UNISTD_H 1

	/* iops->getattr() takes a vfsmount */
	/* #undef HAVE_VFSMOUNT_IOPS_GETATTR */

	/* aops->direct_IO() uses iovec */
	/* #undef HAVE_VFS_DIRECT_IO_IOVEC */

	/* aops->direct_IO() uses iov_iter without rw */
	/* #undef HAVE_VFS_DIRECT_IO_ITER */

	/* aops->direct_IO() uses iov_iter with offset */
	/* #undef HAVE_VFS_DIRECT_IO_ITER_OFFSET */

	/* aops->direct_IO() uses iov_iter with rw and offset */
	/* #undef HAVE_VFS_DIRECT_IO_ITER_RW_OFFSET */

	/* All required iov_iter interfaces are available */
	/* #undef HAVE_VFS_IOV_ITER */

	/* fops->iterate() is available */
	/* #undef HAVE_VFS_ITERATE */

	/* fops->iterate_shared() is available */
	/* #undef HAVE_VFS_ITERATE_SHARED */

	/* fops->readdir() is available */
	/* #undef HAVE_VFS_READDIR */

	/* fops->read/write_iter() are available */
	/* #undef HAVE_VFS_RW_ITERATE */

	/* __vmalloc page flags exists */
	/* #undef HAVE_VMALLOC_PAGE_KERNEL */

	/* yes */
	/* #undef HAVE_WAIT_ON_BIT_ACTION */

	/* wait_queue_entry_t exists */
	/* #undef HAVE_WAIT_QUEUE_ENTRY_T */

	/* wq_head->head and wq_entry->entry exist */
	/* #undef HAVE_WAIT_QUEUE_HEAD_ENTRY */

	/* xattr_handler->get() wants dentry */
	/* #undef HAVE_XATTR_GET_DENTRY */

	/* xattr_handler->get() wants both dentry and inode */
	/* #undef HAVE_XATTR_GET_DENTRY_INODE */

	/* xattr_handler->get() wants xattr_handler */
	/* #undef HAVE_XATTR_GET_HANDLER */

	/* xattr_handler has name */
	/* #undef HAVE_XATTR_HANDLER_NAME */

	/* xattr_handler->list() wants dentry */
	/* #undef HAVE_XATTR_LIST_DENTRY */

	/* xattr_handler->list() wants xattr_handler */
	/* #undef HAVE_XATTR_LIST_HANDLER */

	/* xattr_handler->list() wants simple */
	/* #undef HAVE_XATTR_LIST_SIMPLE */

	/* xattr_handler->set() wants dentry */
	/* #undef HAVE_XATTR_SET_DENTRY */

	/* xattr_handler->set() wants both dentry and inode */
	/* #undef HAVE_XATTR_SET_DENTRY_INODE */

	/* xattr_handler->set() wants xattr_handler */
	/* #undef HAVE_XATTR_SET_HANDLER */

	/* Define if you have [z] */
	#define HAVE_ZLIB 1

	/* __posix_acl_chmod() exists */
	/* #undef HAVE___POSIX_ACL_CHMOD */

	/* kernel exports FPU functions */
	/* #undef KERNEL_EXPORTS_X86_FPU */

	/* Define to the sub-directory where libtool stores uninstalled libraries. */
	#define LT_OBJDIR ".libs/"

	/* make_request_fn() return type */
	/* #undef MAKE_REQUEST_FN_RET */

	/* hardened module_param_call */
	/* #undef MODULE_PARAM_CALL_CONST */

	/* struct shrink_control has nid */
	/* #undef SHRINK_CONTROL_HAS_NID */

	/* Defined for legacy compatibility. */
	#define SPL_META_ALIAS ZFS_META_ALIAS

	/* Defined for legacy compatibility. */
	#define SPL_META_RELEASE ZFS_META_RELEASE

	/* Defined for legacy compatibility. */
	#define SPL_META_VERSION ZFS_META_VERSION

	/* True if ZFS is to be compiled for a FreeBSD system */
	#define SYSTEM_FREEBSD 1

	/* True if ZFS is to be compiled for a Linux system */
	/* #undef SYSTEM_LINUX */

	/* zfs debugging enabled */
	/* #undef ZFS_DEBUG */

	/* /dev/zfs minor */
	/* #undef ZFS_DEVICE_MINOR */

	/* enum node_stat_item contains NR_FILE_PAGES */
	/* #undef ZFS_ENUM_NODE_STAT_ITEM_NR_FILE_PAGES */

	/* enum node_stat_item contains NR_INACTIVE_ANON */
	/* #undef ZFS_ENUM_NODE_STAT_ITEM_NR_INACTIVE_ANON */

	/* enum node_stat_item contains NR_INACTIVE_FILE */
	/* #undef ZFS_ENUM_NODE_STAT_ITEM_NR_INACTIVE_FILE */

	/* enum zone_stat_item contains NR_FILE_PAGES */
	/* #undef ZFS_ENUM_ZONE_STAT_ITEM_NR_FILE_PAGES */

	/* enum zone_stat_item contains NR_INACTIVE_ANON */
	/* #undef ZFS_ENUM_ZONE_STAT_ITEM_NR_INACTIVE_ANON */

	/* enum zone_stat_item contains NR_INACTIVE_FILE */
	/* #undef ZFS_ENUM_ZONE_STAT_ITEM_NR_INACTIVE_FILE */

	/* global_node_page_state() exists */
	/* #undef ZFS_GLOBAL_NODE_PAGE_STATE */

	/* global_zone_page_state() exists */
	/* #undef ZFS_GLOBAL_ZONE_PAGE_STATE */

	/* Define to 1 if GPL-only symbols can be used */
	/* #undef ZFS_IS_GPL_COMPATIBLE */

	/* Define the project alias string. */
	-#define ZFS_META_ALIAS "zfs-2.1.0-FreeBSD_g3522f57b6"
	+#define ZFS_META_ALIAS "zfs-2.1.0-FreeBSD_g7d9f3ef0e"

	/* Define the project author. */
	#define ZFS_META_AUTHOR "OpenZFS"

	/* Define the project release date. */
	/* #undef ZFS_META_DATA */

	/* Define the maximum compatible kernel version. */
	-#define ZFS_META_KVER_MAX "5.11"
	+#define ZFS_META_KVER_MAX "5.12"

	/* Define the minimum compatible kernel version. */
	#define ZFS_META_KVER_MIN "3.10"

	/* Define the project license. */
	#define ZFS_META_LICENSE "CDDL"

	/* Define the libtool library 'age' version information. */
	/* #undef ZFS_META_LT_AGE */

	/* Define the libtool library 'current' version information. */
	/* #undef ZFS_META_LT_CURRENT */

	/* Define the libtool library 'revision' version information. */
	/* #undef ZFS_META_LT_REVISION */

	/* Define the project name. */
	#define ZFS_META_NAME "zfs"

	/* Define the project release. */
	-#define ZFS_META_RELEASE "FreeBSD_g3522f57b6"
	+#define ZFS_META_RELEASE "FreeBSD_g7d9f3ef0e"

	/* Define the project version. */
	#define ZFS_META_VERSION "2.1.0"

	/* count is located in percpu_ref.data */
	/* #undef ZFS_PERCPU_REF_COUNT_IN_DATA */

File Metadata

Mime Type: application/octet-stream
Expires: Sun, May 5, 4:40 AM (1 d, 23 h)
Storage Engine: chunks
Storage Format: Chunks
Storage Handle: CWABLi.5XXpw
Default Alt Text: (7 MB)

Offset	End	Complete
0	4194304	Yes
4194304	7842913	Yes

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions